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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
994 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char* func0(int N) {
char str[6];
sprintf(str, "%d", N);
int sum = 0;
for (int i = 0; str[i] != '\0'; i++)
sum += str[i] - '0';
char* bi = malloc(33);
int index = 0;
if (sum == 0) {
bi[index++] = '0';
} else {
while (sum > 0) {
bi[index++] = (sum % 2) + '0';
sum /= 2;
}
}
bi[index] = '\0';
for (int i = 0; i < index / 2; i++) {
char temp = bi[i];
bi[i] = bi[index - i - 1];
bi[index - i - 1] = temp;
}
return bi;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0(1000);
assert(strcmp(result, "1") == 0);
free(result);
result = func0(150);
assert(strcmp(result, "110") == 0);
free(result);
result = func0(147);
assert(strcmp(result, "1100") == 0);
free(result);
result = func0(333);
assert(strcmp(result, "1001") == 0);
free(result);
result = func0(963);
assert(strcmp(result, "10010") == 0);
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %edi,%r8d
lea 0xc95(%rip),%rcx
mov $0x6,%edx
mov $0x1,%esi
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbx
mov %rbx,%rdi
callq 10d0 <__sprintf_chk@plt>
movsbl 0x2(%rsp),%eax
test %al,%al
je 1450 <func0+0xf0>
mov %rbx,%rdx
xor %ebx,%ebx
nopl 0x0(%rax)
add $0x1,%rdx
lea -0x30(%rbx,%rax,1),%ebx
movsbl (%rdx),%eax
test %al,%al
jne 13b0 <func0+0x50>
mov $0x21,%edi
callq 10c0 <malloc@plt>
test %ebx,%ebx
je 145a <func0+0xfa>
mov $0x1,%edx
jle 1466 <func0+0x106>
nopl 0x0(%rax)
mov %ebx,%ecx
mov %edx,%esi
and $0x1,%ecx
add $0x30,%ecx
mov %cl,-0x1(%rax,%rdx,1)
add $0x1,%rdx
sar %ebx
jne 13e0 <func0+0x80>
movslq %esi,%rdi
sar %esi
movb $0x0,(%rax,%rdi,1)
je 1433 <func0+0xd3>
lea -0x2(%rax,%rdi,1),%r8
sub $0x1,%esi
lea -0x1(%rax,%rdi,1),%rdx
mov %rax,%rcx
sub %rsi,%r8
nopl 0x0(%rax)
movzbl (%rcx),%esi
movzbl (%rdx),%edi
sub $0x1,%rdx
add $0x1,%rcx
mov %dil,-0x1(%rcx)
mov %sil,0x1(%rdx)
cmp %rdx,%r8
jne 1418 <func0+0xb8>
mov 0x8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 146b <func0+0x10b>
add $0x10,%rsp
pop %rbx
retq
nopl 0x0(%rax)
mov $0x21,%edi
callq 10c0 <malloc@plt>
movb $0x30,(%rax)
lea 0x1(%rax),%rdx
movb $0x0,(%rdx)
jmp 1433 <func0+0xd3>
mov %rax,%rdx
jmp 1461 <func0+0x101>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push rbx
mov r8d, edi
lea rcx, unk_2004
mov edx, 6
mov esi, 2
sub rsp, 10h
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
lea rbx, [rsp+18h+var_16]
mov rdi, rbx
call ___sprintf_chk
movsx eax, [rsp+18h+var_16]
test al, al
jz loc_1438
mov rdx, rbx
xor ebx, ebx
nop dword ptr [rax+00h]
loc_13B0:
add rdx, 1
lea ebx, [rbx+rax-30h]
movsx eax, byte ptr [rdx]
test al, al
jnz short loc_13B0
mov edi, 21h ; '!'; size
call _malloc
test ebx, ebx
jz short loc_1442
mov edx, 1
jle loc_1460
nop dword ptr [rax+rax+00000000h]
loc_13E0:
mov ecx, ebx
mov r8, rdx
and ecx, 1
add ecx, 30h ; '0'
mov [rax+rdx-1], cl
add rdx, 1
sar ebx, 1
jnz short loc_13E0
movsxd rcx, r8d
sar r8d, 1
mov byte ptr [rax+rcx], 0
jz short loc_144A
movsxd r8, r8d
mov rdx, rax
lea rcx, [rax+rcx-1]
add r8, rax
nop dword ptr [rax+00000000h]
loc_1418:
movzx edi, byte ptr [rcx]
movzx esi, byte ptr [rdx]
add rdx, 1
sub rcx, 1
mov [rdx-1], dil
mov [rcx+1], sil
cmp rdx, r8
jnz short loc_1418
jmp short loc_144A
loc_1438:
mov edi, 21h ; '!'; size
call _malloc
loc_1442:
mov edx, 30h ; '0'
mov [rax], dx
loc_144A:
mov rdx, [rsp+18h+var_10]
sub rdx, fs:28h
jnz short loc_1465
add rsp, 10h
pop rbx
retn
loc_1460:
mov byte ptr [rax], 0
jmp short loc_144A
loc_1465:
call ___stack_chk_fail
|
_WORD * func0(unsigned int a1)
{
int v1; // eax
_BYTE *v2; // rdx
int v3; // ebx
_WORD *result; // rax
long long v5; // rdx
int v6; // r8d
long long v7; // rcx
int v8; // r8d
char *v9; // rdx
char *v10; // rcx
char *v11; // r8
char v12; // di
char v13; // si
_BYTE v14[6]; // [rsp+2h] [rbp-16h] BYREF
unsigned long long v15; // [rsp+8h] [rbp-10h]
v15 = __readfsqword(0x28u);
__sprintf_chk(v14, 2LL, 6LL, &unk_2004, a1);
v1 = v14[0];
if ( !v14[0] )
{
result = malloc(0x21uLL);
LABEL_12:
*result = 48;
return result;
}
v2 = v14;
v3 = 0;
do
{
++v2;
v3 = v3 + v1 - 48;
v1 = (char)*v2;
}
while ( *v2 );
result = malloc(0x21uLL);
if ( !v3 )
goto LABEL_12;
v5 = 1LL;
if ( v3 <= 0 )
{
*(_BYTE *)result = 0;
}
else
{
do
{
v6 = v5;
*((_BYTE *)result + v5++ - 1) = (v3 & 1) + 48;
v3 >>= 1;
}
while ( v3 );
v7 = v6;
v8 = v6 >> 1;
*((_BYTE *)result + v7) = 0;
if ( v8 )
{
v9 = (char *)result;
v10 = (char *)result + v7 - 1;
v11 = (char *)result + v8;
do
{
v12 = *v10;
v13 = *v9++;
--v10;
*(v9 - 1) = v12;
v10[1] = v13;
}
while ( v9 != v11 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV R8D,EDI
LEA RCX,[0x102004]
MOV EDX,0x6
MOV ESI,0x2
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x2]
MOV RDI,RBX
CALL 0x001010f0
MOVSX EAX,byte ptr [RSP + 0x2]
TEST AL,AL
JZ 0x00101438
MOV RDX,RBX
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_001013b0:
ADD RDX,0x1
LEA EBX,[RBX + RAX*0x1 + -0x30]
MOVSX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x001013b0
MOV EDI,0x21
CALL 0x001010e0
TEST EBX,EBX
JZ 0x00101442
MOV EDX,0x1
JLE 0x00101460
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV ECX,EBX
MOV R8,RDX
AND ECX,0x1
ADD ECX,0x30
MOV byte ptr [RAX + RDX*0x1 + -0x1],CL
ADD RDX,0x1
SAR EBX,0x1
JNZ 0x001013e0
MOVSXD RCX,R8D
SAR R8D,0x1
MOV byte ptr [RAX + RCX*0x1],0x0
JZ 0x0010144a
MOVSXD R8,R8D
MOV RDX,RAX
LEA RCX,[RAX + RCX*0x1 + -0x1]
ADD R8,RAX
NOP dword ptr [RAX]
LAB_00101418:
MOVZX EDI,byte ptr [RCX]
MOVZX ESI,byte ptr [RDX]
ADD RDX,0x1
SUB RCX,0x1
MOV byte ptr [RDX + -0x1],DIL
MOV byte ptr [RCX + 0x1],SIL
CMP RDX,R8
JNZ 0x00101418
JMP 0x0010144a
LAB_00101438:
MOV EDI,0x21
CALL 0x001010e0
LAB_00101442:
MOV EDX,0x30
MOV word ptr [RAX],DX
LAB_0010144a:
MOV RDX,qword ptr [RSP + 0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101465
ADD RSP,0x10
POP RBX
RET
LAB_00101460:
MOV byte ptr [RAX],0x0
JMP 0x0010144a
LAB_00101465:
CALL 0x001010b0
|
void func0(int4 param_1)
{
int uVar1;
long lVar2;
int2 *puVar3;
int *puVar4;
char *pcVar5;
long lVar6;
int2 *puVar7;
int2 *puVar8;
int iVar9;
long in_FS_OFFSET;
char local_16;
char local_15 [5];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = &local_16;
__sprintf_chk(pcVar5,2,6,&DAT_00102004,param_1);
if (local_16 == '\0') {
puVar3 = (int2 *)malloc(0x21);
}
else {
iVar9 = 0;
do {
pcVar5 = pcVar5 + 1;
iVar9 = iVar9 + -0x30 + (int)local_16;
local_16 = *pcVar5;
} while (local_16 != '\0');
puVar3 = (int2 *)malloc(0x21);
if (iVar9 != 0) {
lVar2 = 1;
if (iVar9 < 1) {
*(int *)puVar3 = 0;
}
else {
do {
lVar6 = lVar2;
*(byte *)((long)puVar3 + lVar6 + -1) = ((byte)iVar9 & 1) + 0x30;
iVar9 = iVar9 >> 1;
lVar2 = lVar6 + 1;
} while (iVar9 != 0);
iVar9 = (int)lVar6;
*(int *)((long)puVar3 + (long)iVar9) = 0;
if (iVar9 >> 1 != 0) {
puVar4 = (int *)((long)puVar3 + (long)iVar9 + -1);
puVar7 = puVar3;
do {
uVar1 = *(int *)puVar7;
puVar8 = (int2 *)((long)puVar7 + 1);
*(int *)puVar7 = *puVar4;
*puVar4 = uVar1;
puVar4 = puVar4 + -1;
puVar7 = puVar8;
} while (puVar8 != (int2 *)((long)(iVar9 >> 1) + (long)puVar3));
}
}
goto LAB_0010144a;
}
}
*puVar3 = 0x30;
LAB_0010144a:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
995 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char* func0(int N) {
char str[6];
sprintf(str, "%d", N);
int sum = 0;
for (int i = 0; str[i] != '\0'; i++)
sum += str[i] - '0';
char* bi = malloc(33);
int index = 0;
if (sum == 0) {
bi[index++] = '0';
} else {
while (sum > 0) {
bi[index++] = (sum % 2) + '0';
sum /= 2;
}
}
bi[index] = '\0';
for (int i = 0; i < index / 2; i++) {
char temp = bi[i];
bi[i] = bi[index - i - 1];
bi[index - i - 1] = temp;
}
return bi;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0(1000);
assert(strcmp(result, "1") == 0);
free(result);
result = func0(150);
assert(strcmp(result, "110") == 0);
free(result);
result = func0(147);
assert(strcmp(result, "1100") == 0);
free(result);
result = func0(333);
assert(strcmp(result, "1001") == 0);
free(result);
result = func0(963);
assert(strcmp(result, "10010") == 0);
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %edi,%r8d
lea 0xc95(%rip),%rcx
mov $0x6,%edx
mov $0x1,%esi
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rdi
callq 10d0 <__sprintf_chk@plt>
movsbl 0x2(%rsp),%ebx
test %bl,%bl
je 1470 <func0+0x110>
movsbl 0x3(%rsp),%eax
sub $0x30,%ebx
test %al,%al
je 13db <func0+0x7b>
lea -0x30(%rbx,%rax,1),%ebx
movsbl 0x4(%rsp),%eax
test %al,%al
je 13db <func0+0x7b>
lea -0x30(%rbx,%rax,1),%ebx
movsbl 0x5(%rsp),%eax
test %al,%al
je 13db <func0+0x7b>
lea -0x30(%rbx,%rax,1),%ebx
movsbl 0x6(%rsp),%eax
test %al,%al
je 13db <func0+0x7b>
lea -0x30(%rbx,%rax,1),%ebx
mov $0x21,%edi
callq 10c0 <malloc@plt>
test %ebx,%ebx
je 147a <func0+0x11a>
mov $0x1,%edx
jle 1486 <func0+0x126>
nopl 0x0(%rax,%rax,1)
mov %ebx,%ecx
mov %edx,%esi
and $0x1,%ecx
add $0x30,%ecx
mov %cl,-0x1(%rax,%rdx,1)
add $0x1,%rdx
sar %ebx
jne 1400 <func0+0xa0>
movslq %esi,%rdi
sar %esi
movb $0x0,(%rax,%rdi,1)
je 1453 <func0+0xf3>
lea -0x2(%rax,%rdi,1),%r8
sub $0x1,%esi
lea -0x1(%rax,%rdi,1),%rdx
mov %rax,%rcx
sub %rsi,%r8
nopl 0x0(%rax)
movzbl (%rcx),%esi
movzbl (%rdx),%edi
sub $0x1,%rdx
add $0x1,%rcx
mov %dil,-0x1(%rcx)
mov %sil,0x1(%rdx)
cmp %r8,%rdx
jne 1438 <func0+0xd8>
mov 0x8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 148b <func0+0x12b>
add $0x10,%rsp
pop %rbx
retq
nopl 0x0(%rax)
mov $0x21,%edi
callq 10c0 <malloc@plt>
movb $0x30,(%rax)
lea 0x1(%rax),%rdx
movb $0x0,(%rdx)
jmp 1453 <func0+0xf3>
mov %rax,%rdx
jmp 1481 <func0+0x121>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push rbx
mov r8d, edi
lea rcx, unk_2004
mov edx, 6
mov esi, 2
sub rsp, 10h
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
lea rdi, [rsp+18h+var_16]
call ___sprintf_chk
movsx ebx, [rsp+18h+var_16]
test bl, bl
jz loc_1450
movsx eax, [rsp+18h+var_15]
sub ebx, 30h ; '0'
test al, al
jz short loc_13DB
lea ebx, [rbx+rax-30h]
movsx eax, [rsp+18h+var_14]
test al, al
jz short loc_13DB
lea ebx, [rbx+rax-30h]
movsx eax, [rsp+18h+var_13]
test al, al
jz short loc_13DB
lea ebx, [rbx+rax-30h]
movsx eax, [rsp+18h+var_12]
test al, al
jz short loc_13DB
lea ebx, [rbx+rax-30h]
loc_13DB:
mov edi, 21h ; '!'; size
call _malloc
test ebx, ebx
jz short loc_145A
mov edx, 1
jle loc_1478
nop dword ptr [rax+00h]
loc_13F8:
mov ecx, ebx
mov r8, rdx
and ecx, 1
add ecx, 30h ; '0'
mov [rax+rdx-1], cl
add rdx, 1
sar ebx, 1
jnz short loc_13F8
movsxd rcx, r8d
sar r8d, 1
mov byte ptr [rax+rcx], 0
jz short loc_1462
movsxd r8, r8d
mov rdx, rax
lea rcx, [rax+rcx-1]
add r8, rax
nop dword ptr [rax+00000000h]
loc_1430:
movzx edi, byte ptr [rcx]
movzx esi, byte ptr [rdx]
add rdx, 1
sub rcx, 1
mov [rdx-1], dil
mov [rcx+1], sil
cmp r8, rdx
jnz short loc_1430
jmp short loc_1462
loc_1450:
mov edi, 21h ; '!'; size
call _malloc
loc_145A:
mov edx, 30h ; '0'
mov [rax], dx
loc_1462:
mov rdx, [rsp+18h+var_10]
sub rdx, fs:28h
jnz short loc_147D
add rsp, 10h
pop rbx
retn
loc_1478:
mov byte ptr [rax], 0
jmp short loc_1462
loc_147D:
call ___stack_chk_fail
|
_WORD * func0(unsigned int a1)
{
int v1; // ebx
_WORD *result; // rax
long long v3; // rdx
int v4; // r8d
long long v5; // rcx
int v6; // r8d
char *v7; // rdx
char *v8; // rcx
char *v9; // r8
char v10; // di
char v11; // si
char v12; // [rsp+2h] [rbp-16h] BYREF
char v13; // [rsp+3h] [rbp-15h]
char v14; // [rsp+4h] [rbp-14h]
char v15; // [rsp+5h] [rbp-13h]
char v16; // [rsp+6h] [rbp-12h]
unsigned long long v17; // [rsp+8h] [rbp-10h]
v17 = __readfsqword(0x28u);
__sprintf_chk(&v12, 2LL, 6LL, &unk_2004, a1);
if ( !v12 )
{
result = malloc(0x21uLL);
LABEL_15:
*result = 48;
return result;
}
v1 = v12 - 48;
if ( v13 )
{
v1 = v1 + v13 - 48;
if ( v14 )
{
v1 = v1 + v14 - 48;
if ( v15 )
{
v1 = v1 + v15 - 48;
if ( v16 )
v1 = v1 + v16 - 48;
}
}
}
result = malloc(0x21uLL);
if ( !v1 )
goto LABEL_15;
v3 = 1LL;
if ( v1 <= 0 )
{
*(_BYTE *)result = 0;
}
else
{
do
{
v4 = v3;
*((_BYTE *)result + v3++ - 1) = (v1 & 1) + 48;
v1 >>= 1;
}
while ( v1 );
v5 = v4;
v6 = v4 >> 1;
*((_BYTE *)result + v5) = 0;
if ( v6 )
{
v7 = (char *)result;
v8 = (char *)result + v5 - 1;
v9 = (char *)result + v6;
do
{
v10 = *v8;
v11 = *v7++;
--v8;
*(v7 - 1) = v10;
v8[1] = v11;
}
while ( v9 != v7 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV R8D,EDI
LEA RCX,[0x102004]
MOV EDX,0x6
MOV ESI,0x2
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x2]
CALL 0x001010f0
MOVSX EBX,byte ptr [RSP + 0x2]
TEST BL,BL
JZ 0x00101450
MOVSX EAX,byte ptr [RSP + 0x3]
SUB EBX,0x30
TEST AL,AL
JZ 0x001013db
LEA EBX,[RBX + RAX*0x1 + -0x30]
MOVSX EAX,byte ptr [RSP + 0x4]
TEST AL,AL
JZ 0x001013db
LEA EBX,[RBX + RAX*0x1 + -0x30]
MOVSX EAX,byte ptr [RSP + 0x5]
TEST AL,AL
JZ 0x001013db
LEA EBX,[RBX + RAX*0x1 + -0x30]
MOVSX EAX,byte ptr [RSP + 0x6]
TEST AL,AL
JZ 0x001013db
LEA EBX,[RBX + RAX*0x1 + -0x30]
LAB_001013db:
MOV EDI,0x21
CALL 0x001010e0
TEST EBX,EBX
JZ 0x0010145a
MOV EDX,0x1
JLE 0x00101478
NOP dword ptr [RAX]
LAB_001013f8:
MOV ECX,EBX
MOV R8,RDX
AND ECX,0x1
ADD ECX,0x30
MOV byte ptr [RAX + RDX*0x1 + -0x1],CL
ADD RDX,0x1
SAR EBX,0x1
JNZ 0x001013f8
MOVSXD RCX,R8D
SAR R8D,0x1
MOV byte ptr [RAX + RCX*0x1],0x0
JZ 0x00101462
MOVSXD R8,R8D
MOV RDX,RAX
LEA RCX,[RAX + RCX*0x1 + -0x1]
ADD R8,RAX
NOP dword ptr [RAX]
LAB_00101430:
MOVZX EDI,byte ptr [RCX]
MOVZX ESI,byte ptr [RDX]
ADD RDX,0x1
SUB RCX,0x1
MOV byte ptr [RDX + -0x1],DIL
MOV byte ptr [RCX + 0x1],SIL
CMP R8,RDX
JNZ 0x00101430
JMP 0x00101462
LAB_00101450:
MOV EDI,0x21
CALL 0x001010e0
LAB_0010145a:
MOV EDX,0x30
MOV word ptr [RAX],DX
LAB_00101462:
MOV RDX,qword ptr [RSP + 0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010147d
ADD RSP,0x10
POP RBX
RET
LAB_00101478:
MOV byte ptr [RAX],0x0
JMP 0x00101462
LAB_0010147d:
CALL 0x001010b0
|
void func0(int4 param_1)
{
int uVar1;
long lVar2;
int2 *puVar3;
int *puVar4;
long lVar5;
int2 *puVar6;
int2 *puVar7;
int iVar8;
long in_FS_OFFSET;
char local_16;
char local_15;
char local_14;
char local_13;
char local_12;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(&local_16,2,6,&DAT_00102004,param_1);
if (local_16 == '\0') {
puVar3 = (int2 *)malloc(0x21);
}
else {
iVar8 = local_16 + -0x30;
if (local_15 != '\0') {
iVar8 = local_16 + -0x60 + (int)local_15;
if (local_14 != '\0') {
iVar8 = iVar8 + -0x30 + (int)local_14;
if (local_13 != '\0') {
iVar8 = iVar8 + -0x30 + (int)local_13;
if (local_12 != '\0') {
iVar8 = iVar8 + -0x30 + (int)local_12;
}
}
}
}
puVar3 = (int2 *)malloc(0x21);
if (iVar8 != 0) {
lVar2 = 1;
if (iVar8 < 1) {
*(int *)puVar3 = 0;
}
else {
do {
lVar5 = lVar2;
*(byte *)((long)puVar3 + lVar5 + -1) = ((byte)iVar8 & 1) + 0x30;
iVar8 = iVar8 >> 1;
lVar2 = lVar5 + 1;
} while (iVar8 != 0);
iVar8 = (int)lVar5;
*(int *)((long)puVar3 + (long)iVar8) = 0;
if (iVar8 >> 1 != 0) {
puVar4 = (int *)((long)puVar3 + (long)iVar8 + -1);
puVar6 = puVar3;
do {
uVar1 = *(int *)puVar6;
puVar7 = (int2 *)((long)puVar6 + 1);
*(int *)puVar6 = *puVar4;
*puVar4 = uVar1;
puVar4 = puVar4 + -1;
puVar6 = puVar7;
} while ((int2 *)((long)(iVar8 >> 1) + (long)puVar3) != puVar7);
}
}
goto LAB_00101462;
}
}
*puVar3 = 0x30;
LAB_00101462:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
996 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
}
|
#include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / sizeof(array3[0])) == 0);
int array4[] = {4, 4, 6, 8};
assert(func0(array4, sizeof(array4) / sizeof(array4[0])) == 12);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ce <func0+0x65>
mov -0x4(%rbp),%eax
add %eax,%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11ca <func0+0x61>
mov -0x4(%rbp),%eax
add %eax,%eax
cltq
add $0x1,%rax
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
add %eax,%eax
add $0x1,%eax
cmp %eax,-0x1c(%rbp)
jg 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11CE
loc_1188:
mov eax, [rbp+var_4]
add eax, eax
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11CA
mov eax, [rbp+var_4]
add eax, eax
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_11CA:
add [rbp+var_4], 1
loc_11CE:
mov eax, [rbp+var_4]
add eax, eax
add eax, 1
cmp [rbp+var_1C], eax
jg short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; a2 > 2 * i + 1; ++i )
{
if ( (*(_DWORD *)(4 * (2 * i + 1LL) + a1) & 1) == 0 )
v3 += *(_DWORD *)(4 * (2 * i + 1LL) + a1);
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ce
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011ca
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CDQE
ADD RAX,0x1
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_001011ca:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ce:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
ADD EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JG 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c * 2 + 1 < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + ((long)(local_c * 2) + 1) * 4) & 1) == 0) {
local_10 = local_10 + *(int *)(param_1 + ((long)(local_c * 2) + 1) * 4);
}
}
return local_10;
}
|
997 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
}
|
#include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / sizeof(array3[0])) == 0);
int array4[] = {4, 4, 6, 8};
assert(func0(array4, sizeof(array4) / sizeof(array4[0])) == 12);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 119e <func0+0x35>
lea 0x4(%rdi),%rax
sub $0x2,%esi
shr %esi
mov %esi,%esi
lea 0xc(%rdi,%rsi,8),%rdi
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test $0x1,%cl
cmove %esi,%edx
add $0x8,%rax
cmp %rdi,%rax
jne 1187 <func0+0x1e>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 119b <func0+0x32>
|
func0:
endbr64
cmp esi, 1
jle short loc_119E
lea rax, [rdi+4]
sub esi, 2
shr esi, 1
mov esi, esi
lea rdi, [rdi+rsi*8+0Ch]
mov edx, 0
loc_1187:
mov ecx, [rax]
lea esi, [rdx+rcx]
test cl, 1
cmovz edx, esi
add rax, 8
cmp rax, rdi
jnz short loc_1187
loc_119B:
mov eax, edx
retn
loc_119E:
mov edx, 0
jmp short loc_119B
|
long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rdi
unsigned int v4; // edx
if ( a2 <= 1 )
{
return 0;
}
else
{
v2 = (_DWORD *)(a1 + 4);
v3 = a1 + 8LL * ((unsigned int)(a2 - 2) >> 1) + 12;
v4 = 0;
do
{
if ( (*v2 & 1) == 0 )
v4 += *v2;
v2 += 2;
}
while ( v2 != (_DWORD *)v3 );
}
return v4;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010119e
LEA RAX,[RDI + 0x4]
SUB ESI,0x2
SHR ESI,0x1
MOV ESI,ESI
LEA RDI,[RDI + RSI*0x8 + 0xc]
MOV EDX,0x0
LAB_00101187:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST CL,0x1
CMOVZ EDX,ESI
ADD RAX,0x8
CMP RAX,RDI
JNZ 0x00101187
LAB_0010119b:
MOV EAX,EDX
RET
LAB_0010119e:
MOV EDX,0x0
JMP 0x0010119b
|
int func0(long param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (param_2 < 2) {
iVar2 = 0;
}
else {
puVar1 = (uint *)(param_1 + 4);
iVar2 = 0;
do {
if ((*puVar1 & 1) == 0) {
iVar2 = iVar2 + *puVar1;
}
puVar1 = puVar1 + 2;
} while (puVar1 != (uint *)(param_1 + 0xc + (ulong)(param_2 - 2U >> 1) * 8));
}
return iVar2;
}
|
998 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
}
|
#include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / sizeof(array3[0])) == 0);
int array4[] = {4, 4, 6, 8};
assert(func0(array4, sizeof(array4) / sizeof(array4[0])) == 12);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1180 <func0+0x40>
sub $0x2,%esi
lea 0x4(%rdi),%rax
xor %r8d,%r8d
shr %esi
lea 0xc(%rdi,%rsi,8),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rax),%edx
lea (%r8,%rdx,1),%ecx
and $0x1,%edx
cmove %ecx,%r8d
add $0x8,%rax
cmp %rsi,%rax
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
cmp esi, 1
jle short loc_1300
sub esi, 2
lea rax, [rdi+4]
xor edx, edx
shr esi, 1
lea rdi, [rdi+rsi*8+0Ch]
nop dword ptr [rax+00000000h]
loc_12E0:
mov ecx, [rax]
lea esi, [rdx+rcx]
and ecx, 1
cmovz edx, esi
add rax, 8
cmp rdi, rax
jnz short loc_12E0
mov eax, edx
retn
loc_1300:
xor edx, edx
mov eax, edx
retn
|
long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
long long v4; // rdi
if ( a2 <= 1 )
return 0LL;
v2 = (_DWORD *)(a1 + 4);
v3 = 0;
v4 = a1 + 8LL * ((unsigned int)(a2 - 2) >> 1) + 12;
do
{
if ( (*v2 & 1) == 0 )
v3 += *v2;
v2 += 2;
}
while ( (_DWORD *)v4 != v2 );
return v3;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101300
SUB ESI,0x2
LEA RAX,[RDI + 0x4]
XOR EDX,EDX
SHR ESI,0x1
LEA RDI,[RDI + RSI*0x8 + 0xc]
NOP dword ptr [RAX]
LAB_001012e0:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
AND ECX,0x1
CMOVZ EDX,ESI
ADD RAX,0x8
CMP RDI,RAX
JNZ 0x001012e0
MOV EAX,EDX
RET
LAB_00101300:
XOR EDX,EDX
MOV EAX,EDX
RET
|
int func0(long param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (1 < param_2) {
puVar1 = (uint *)(param_1 + 4);
iVar2 = 0;
do {
if ((*puVar1 & 1) == 0) {
iVar2 = iVar2 + *puVar1;
}
puVar1 = puVar1 + 2;
} while ((uint *)(param_1 + 0xc + (ulong)(param_2 - 2U >> 1) * 8) != puVar1);
return iVar2;
}
return 0;
}
|
999 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
}
|
#include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / sizeof(array3[0])) == 0);
int array4[] = {4, 4, 6, 8};
assert(func0(array4, sizeof(array4) / sizeof(array4[0])) == 12);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1240 <func0+0x100>
lea -0x2(%rsi),%edx
cmp $0x7,%edx
jbe 1243 <func0+0x103>
shr $0x3,%edx
pxor %xmm2,%xmm2
movdqa 0xea8(%rip),%xmm4
mov %rdi,%rax
mov %edx,%ecx
movdqa %xmm2,%xmm3
shl $0x5,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu 0x4(%rax),%xmm1
movdqu 0x14(%rax),%xmm5
add $0x20,%rax
shufps $0x88,%xmm5,%xmm1
movdqa %xmm1,%xmm0
pand %xmm4,%xmm0
pcmpeqd %xmm3,%xmm0
pand %xmm1,%xmm0
paddd %xmm0,%xmm2
cmp %rcx,%rax
jne 1180 <func0+0x40>
movdqa %xmm2,%xmm0
lea 0x0(,%rdx,4),%ecx
shl $0x3,%edx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm2
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%eax
movslq %edx,%rdx
mov 0x4(%rdi,%rdx,4),%edx
lea (%rax,%rdx,1),%r8d
and $0x1,%edx
lea 0x2(%rcx,%rcx,1),%edx
lea 0x1(%rdx),%ecx
cmove %r8d,%eax
cmp %ecx,%esi
jle 1242 <func0+0x102>
movslq %edx,%rcx
mov 0x4(%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
and $0x1,%ecx
lea 0x2(%rdx),%ecx
cmove %r8d,%eax
lea 0x3(%rdx),%r8d
cmp %r8d,%esi
jle 1242 <func0+0x102>
movslq %ecx,%rcx
mov 0x4(%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
and $0x1,%ecx
lea 0x4(%rdx),%ecx
cmove %r8d,%eax
add $0x5,%edx
cmp %edx,%esi
jle 1242 <func0+0x102>
movslq %ecx,%rcx
mov 0x4(%rdi,%rcx,4),%edx
lea (%rax,%rdx,1),%ecx
and $0x1,%edx
cmove %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
xor %ecx,%ecx
xor %eax,%eax
xor %edx,%edx
jmp 11d3 <func0+0x93>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
mov rcx, rdi
cmp esi, 1
jle loc_1238
lea edi, [rsi-2]
cmp edi, 7
jbe loc_123B
shr edi, 3
pxor xmm2, xmm2
movdqa xmm4, cs:xmmword_2010
mov rax, rcx
mov edx, edi
movdqa xmm3, xmm2
shl rdx, 5
add rdx, rcx
nop dword ptr [rax+rax+00h]
loc_1180:
movdqu xmm1, xmmword ptr [rax+4]
movdqu xmm5, xmmword ptr [rax+14h]
add rax, 20h ; ' '
shufps xmm1, xmm5, 88h
movdqa xmm0, xmm1
pand xmm0, xmm4
pcmpeqd xmm0, xmm3
pand xmm0, xmm1
paddd xmm2, xmm0
cmp rax, rdx
jnz short loc_1180
movdqa xmm0, xmm2
lea r8d, ds:0[rdi*4]
lea edx, ds:1[rdi*8]
psrldq xmm0, 8
paddd xmm2, xmm0
movdqa xmm0, xmm2
psrldq xmm0, 4
paddd xmm2, xmm0
movd eax, xmm2
loc_11D8:
movsxd rdx, edx
mov edx, [rcx+rdx*4]
lea edi, [rax+rdx]
and edx, 1
lea edx, [r8+r8+2]
cmovz eax, edi
lea edi, [rdx+1]
cmp esi, edi
jle short locret_123A
movsxd rdi, edi
mov edi, [rcx+rdi*4]
lea r8d, [rax+rdi]
and edi, 1
lea edi, [rdx+3]
cmovz eax, r8d
cmp edi, esi
jge short locret_123A
movsxd rdi, edi
mov edi, [rcx+rdi*4]
lea r8d, [rax+rdi]
and edi, 1
cmovz eax, r8d
add edx, 5
cmp esi, edx
jle short locret_123A
movsxd rdx, edx
mov edx, [rcx+rdx*4]
lea ecx, [rax+rdx]
and edx, 1
cmovz eax, ecx
retn
loc_1238:
xor eax, eax
locret_123A:
retn
loc_123B:
xor r8d, r8d
xor eax, eax
mov edx, 1
jmp short loc_11D8
|
long long func0(long long a1, int a2)
{
unsigned int v3; // edi
__m128i v4; // xmm2
__m128i si128; // xmm4
long long v6; // rax
__m128 v7; // xmm1
__m128 v8; // xmm5
__m128i v9; // xmm1
int v10; // r8d
int v11; // edx
__m128i v12; // xmm2
long long result; // rax
int v14; // edx
unsigned int v15; // edi
bool v16; // zf
int v17; // edx
int v18; // edi
unsigned int v19; // r8d
int v20; // edi
int v21; // edi
int v22; // edx
int v23; // edx
if ( a2 <= 1 )
return 0LL;
if ( (unsigned int)(a2 - 2) <= 7 )
{
v10 = 0;
result = 0LL;
v11 = 1;
}
else
{
v3 = (unsigned int)(a2 - 2) >> 3;
v4 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v6 = a1;
do
{
v7 = (__m128)_mm_loadu_si128((const __m128i *)(v6 + 4));
v8 = (__m128)_mm_loadu_si128((const __m128i *)(v6 + 20));
v6 += 32LL;
v9 = (__m128i)_mm_shuffle_ps(v7, v8, 136);
v4 = _mm_add_epi32(v4, _mm_and_si128(_mm_cmpeq_epi32(_mm_and_si128(v9, si128), (__m128i)0LL), v9));
}
while ( v6 != a1 + 32LL * v3 );
v10 = 4 * v3;
v11 = 8 * v3 + 1;
v12 = _mm_add_epi32(v4, _mm_srli_si128(v4, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v12, _mm_srli_si128(v12, 4)));
}
v14 = *(_DWORD *)(a1 + 4LL * v11);
v15 = result + v14;
v16 = (v14 & 1) == 0;
v17 = 2 * v10 + 2;
if ( v16 )
result = v15;
if ( a2 > 2 * v10 + 3 )
{
v18 = *(_DWORD *)(a1 + 4LL * (2 * v10 + 3));
v19 = result + v18;
v16 = (v18 & 1) == 0;
v20 = v17 + 3;
if ( v16 )
result = v19;
if ( v20 < a2 )
{
v21 = *(_DWORD *)(a1 + 4LL * v20);
if ( (v21 & 1) == 0 )
result = (unsigned int)(result + v21);
v22 = v17 + 5;
if ( a2 > v22 )
{
v23 = *(_DWORD *)(a1 + 4LL * v22);
if ( (v23 & 1) == 0 )
return (unsigned int)(result + v23);
}
}
}
return result;
}
|
func0:
ENDBR64
MOV RCX,RDI
CMP ESI,0x1
JLE 0x00101238
LEA EDI,[RSI + -0x2]
CMP EDI,0x7
JBE 0x0010123b
SHR EDI,0x3
PXOR XMM2,XMM2
MOVDQA XMM4,xmmword ptr [0x00102010]
MOV RAX,RCX
MOV EDX,EDI
MOVDQA XMM3,XMM2
SHL RDX,0x5
ADD RDX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM1,xmmword ptr [RAX + 0x4]
MOVDQU XMM5,xmmword ptr [RAX + 0x14]
ADD RAX,0x20
SHUFPS XMM1,XMM5,0x88
MOVDQA XMM0,XMM1
PAND XMM0,XMM4
PCMPEQD XMM0,XMM3
PAND XMM0,XMM1
PADDD XMM2,XMM0
CMP RAX,RDX
JNZ 0x00101180
MOVDQA XMM0,XMM2
LEA R8D,[RDI*0x4]
LEA EDX,[0x1 + RDI*0x8]
PSRLDQ XMM0,0x8
PADDD XMM2,XMM0
MOVDQA XMM0,XMM2
PSRLDQ XMM0,0x4
PADDD XMM2,XMM0
MOVD EAX,XMM2
LAB_001011d8:
MOVSXD RDX,EDX
MOV EDX,dword ptr [RCX + RDX*0x4]
LEA EDI,[RAX + RDX*0x1]
AND EDX,0x1
LEA EDX,[R8 + R8*0x1 + 0x2]
CMOVZ EAX,EDI
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JLE 0x0010123a
MOVSXD RDI,EDI
MOV EDI,dword ptr [RCX + RDI*0x4]
LEA R8D,[RAX + RDI*0x1]
AND EDI,0x1
LEA EDI,[RDX + 0x3]
CMOVZ EAX,R8D
CMP EDI,ESI
JGE 0x0010123a
MOVSXD RDI,EDI
MOV EDI,dword ptr [RCX + RDI*0x4]
LEA R8D,[RAX + RDI*0x1]
AND EDI,0x1
CMOVZ EAX,R8D
ADD EDX,0x5
CMP ESI,EDX
JLE 0x0010123a
MOVSXD RDX,EDX
MOV EDX,dword ptr [RCX + RDX*0x4]
LEA ECX,[RAX + RDX*0x1]
AND EDX,0x1
CMOVZ EAX,ECX
RET
LAB_00101238:
XOR EAX,EAX
LAB_0010123a:
RET
LAB_0010123b:
XOR R8D,R8D
XOR EAX,EAX
MOV EDX,0x1
JMP 0x001011d8
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(long param_1,int param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
long lVar5;
int iVar6;
uint uVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (param_2 < 2) {
iVar9 = 0;
}
else {
if (param_2 - 2U < 8) {
iVar8 = 0;
iVar9 = 0;
iVar6 = 1;
}
else {
uVar7 = param_2 - 2U >> 3;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
lVar5 = param_1;
do {
puVar1 = (uint *)(lVar5 + 4);
puVar3 = (uint *)(lVar5 + 0xc);
puVar2 = (uint *)(lVar5 + 0x14);
puVar4 = (uint *)(lVar5 + 0x1c);
lVar5 = lVar5 + 0x20;
iVar9 = iVar9 + (-(uint)((*puVar1 & _DAT_00102010) == 0) & *puVar1);
iVar10 = iVar10 + (-(uint)((*puVar3 & _UNK_00102014) == 0) & *puVar3);
iVar11 = iVar11 + (-(uint)((*puVar2 & _UNK_00102018) == 0) & *puVar2);
iVar12 = iVar12 + (-(uint)((*puVar4 & _UNK_0010201c) == 0) & *puVar4);
} while (lVar5 != (ulong)uVar7 * 0x20 + param_1);
iVar8 = uVar7 * 4;
iVar6 = uVar7 * 8 + 1;
iVar9 = iVar9 + iVar11 + iVar10 + iVar12;
}
uVar7 = *(uint *)(param_1 + (long)iVar6 * 4);
iVar8 = iVar8 * 2;
if ((uVar7 & 1) == 0) {
iVar9 = iVar9 + uVar7;
}
if (iVar8 + 3 < param_2) {
uVar7 = *(uint *)(param_1 + (long)(iVar8 + 3) * 4);
if ((uVar7 & 1) == 0) {
iVar9 = iVar9 + uVar7;
}
if (iVar8 + 5 < param_2) {
uVar7 = *(uint *)(param_1 + (long)(iVar8 + 5) * 4);
if ((uVar7 & 1) == 0) {
iVar9 = iVar9 + uVar7;
}
if (iVar8 + 7 < param_2) {
uVar7 = *(uint *)(param_1 + (long)(iVar8 + 7) * 4);
if ((uVar7 & 1) == 0) {
iVar9 = iVar9 + uVar7;
}
return iVar9;
}
}
}
}
return iVar9;
}
|
1,000 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = j + 1; k < current_index; k++) {
if (current[j] > current[k]) {
char temp = current[j];
current[j] = current[k];
current[k] = temp;
}
}
}
if (out_index > 0) out[out_index++] = ' ';
for (int j = 0; j < current_index; j++) {
out[out_index++] = current[j];
}
current_index = 0;
} else {
current[current_index++] = s[i];
}
}
out[out_index] = '\0';
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
free(result);
result = func0("abcd");
assert(strcmp(result, "abcd") == 0);
free(result);
result = func0("Hello World!!!");
assert(strcmp(result, "Hello !!!Wdlor") == 0);
free(result);
result = func0("");
assert(strcmp(result, "") == 0);
free(result);
result = func0("Hi. My name is Mister Robot. How are you?");
assert(strcmp(result, ".Hi My aemn is Meirst .Rboot How aer ?ouy") == 0);
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
add $0x2,%eax
cltq
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x48(%rbp)
movl $0x0,-0x64(%rbp)
movl $0x0,-0x60(%rbp)
movl $0x0,-0x5c(%rbp)
jmpq 1362 <func0+0x179>
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 1271 <func0+0x88>
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 133e <func0+0x155>
movl $0x0,-0x58(%rbp)
jmp 12da <func0+0xf1>
mov -0x58(%rbp),%eax
add $0x1,%eax
mov %eax,-0x54(%rbp)
jmp 12ce <func0+0xe5>
mov -0x58(%rbp),%eax
cltq
movzbl -0x40(%rbp,%rax,1),%edx
mov -0x54(%rbp),%eax
cltq
movzbl -0x40(%rbp,%rax,1),%eax
cmp %al,%dl
jle 12ca <func0+0xe1>
mov -0x58(%rbp),%eax
cltq
movzbl -0x40(%rbp,%rax,1),%eax
mov %al,-0x65(%rbp)
mov -0x54(%rbp),%eax
cltq
movzbl -0x40(%rbp,%rax,1),%edx
mov -0x58(%rbp),%eax
cltq
mov %dl,-0x40(%rbp,%rax,1)
mov -0x54(%rbp),%eax
cltq
movzbl -0x65(%rbp),%edx
mov %dl,-0x40(%rbp,%rax,1)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x60(%rbp),%eax
jl 1285 <func0+0x9c>
addl $0x1,-0x58(%rbp)
mov -0x60(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x58(%rbp)
jl 127a <func0+0x91>
cmpl $0x0,-0x64(%rbp)
jle 1301 <func0+0x118>
mov -0x64(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x64(%rbp)
movslq %eax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movb $0x20,(%rax)
movl $0x0,-0x50(%rbp)
jmp 132d <func0+0x144>
mov -0x64(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x64(%rbp)
movslq %eax,%rdx
mov -0x48(%rbp),%rax
add %rax,%rdx
mov -0x50(%rbp),%eax
cltq
movzbl -0x40(%rbp,%rax,1),%eax
mov %al,(%rdx)
addl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x60(%rbp),%eax
jl 130a <func0+0x121>
movl $0x0,-0x60(%rbp)
jmp 135e <func0+0x175>
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x60(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x60(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x40(%rbp,%rax,1)
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jle 1245 <func0+0x5c>
mov -0x64(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x48(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1396 <func0+0x1ad>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4C], eax
mov eax, [rbp+var_4C]
add eax, 2
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+var_48], rax
mov [rbp+var_64], 0
mov [rbp+var_60], 0
mov [rbp+var_5C], 0
jmp loc_1362
loc_1245:
mov eax, [rbp+var_5C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_1271
mov eax, [rbp+var_5C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_133E
loc_1271:
mov [rbp+var_58], 0
jmp short loc_12DA
loc_127A:
mov eax, [rbp+var_58]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_12CE
loc_1285:
mov eax, [rbp+var_58]
cdqe
movzx edx, [rbp+rax+var_40]
mov eax, [rbp+var_54]
cdqe
movzx eax, [rbp+rax+var_40]
cmp dl, al
jle short loc_12CA
mov eax, [rbp+var_58]
cdqe
movzx eax, [rbp+rax+var_40]
mov [rbp+var_65], al
mov eax, [rbp+var_54]
cdqe
movzx edx, [rbp+rax+var_40]
mov eax, [rbp+var_58]
cdqe
mov [rbp+rax+var_40], dl
mov eax, [rbp+var_54]
cdqe
movzx edx, [rbp+var_65]
mov [rbp+rax+var_40], dl
loc_12CA:
add [rbp+var_54], 1
loc_12CE:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_60]
jl short loc_1285
add [rbp+var_58], 1
loc_12DA:
mov eax, [rbp+var_60]
sub eax, 1
cmp [rbp+var_58], eax
jl short loc_127A
cmp [rbp+var_64], 0
jle short loc_1301
mov eax, [rbp+var_64]
lea edx, [rax+1]
mov [rbp+var_64], edx
movsxd rdx, eax
mov rax, [rbp+var_48]
add rax, rdx
mov byte ptr [rax], 20h ; ' '
loc_1301:
mov [rbp+var_50], 0
jmp short loc_132D
loc_130A:
mov eax, [rbp+var_64]
lea edx, [rax+1]
mov [rbp+var_64], edx
movsxd rdx, eax
mov rax, [rbp+var_48]
add rdx, rax
mov eax, [rbp+var_50]
cdqe
movzx eax, [rbp+rax+var_40]
mov [rdx], al
add [rbp+var_50], 1
loc_132D:
mov eax, [rbp+var_50]
cmp eax, [rbp+var_60]
jl short loc_130A
mov [rbp+var_60], 0
jmp short loc_135E
loc_133E:
mov eax, [rbp+var_5C]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_60]
lea edx, [rax+1]
mov [rbp+var_60], edx
movzx edx, byte ptr [rcx]
cdqe
mov [rbp+rax+var_40], dl
loc_135E:
add [rbp+var_5C], 1
loc_1362:
mov eax, [rbp+var_5C]
cmp eax, [rbp+var_4C]
jle loc_1245
mov eax, [rbp+var_64]
movsxd rdx, eax
mov rax, [rbp+var_48]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_48]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1396
call ___stack_chk_fail
locret_1396:
leave
retn
|
_BYTE * func0(const char *a1)
{
int v1; // eax
int v2; // eax
int v3; // eax
char v5; // [rsp+1Bh] [rbp-65h]
int v6; // [rsp+1Ch] [rbp-64h]
int v7; // [rsp+20h] [rbp-60h]
int i; // [rsp+24h] [rbp-5Ch]
int j; // [rsp+28h] [rbp-58h]
int k; // [rsp+2Ch] [rbp-54h]
int m; // [rsp+30h] [rbp-50h]
int v12; // [rsp+34h] [rbp-4Ch]
_BYTE *v13; // [rsp+38h] [rbp-48h]
_BYTE v14[56]; // [rsp+40h] [rbp-40h]
unsigned long long v15; // [rsp+78h] [rbp-8h]
v15 = __readfsqword(0x28u);
v12 = strlen(a1);
v13 = malloc(v12 + 2);
v6 = 0;
v7 = 0;
for ( i = 0; i <= v12; ++i )
{
if ( a1[i] != 32 && a1[i] )
{
v3 = v7++;
v14[v3] = a1[i];
}
else
{
for ( j = 0; j < v7 - 1; ++j )
{
for ( k = j + 1; k < v7; ++k )
{
if ( v14[j] > v14[k] )
{
v5 = v14[j];
v14[j] = v14[k];
v14[k] = v5;
}
}
}
if ( v6 > 0 )
{
v1 = v6++;
v13[v1] = 32;
}
for ( m = 0; m < v7; ++m )
{
v2 = v6++;
v13[v2] = v14[m];
}
v7 = 0;
}
}
v13[v6] = 0;
return v13;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x4c],EAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x2
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x48],RAX
MOV dword ptr [RBP + -0x64],0x0
MOV dword ptr [RBP + -0x60],0x0
MOV dword ptr [RBP + -0x5c],0x0
JMP 0x00101362
LAB_00101245:
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x00101271
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010133e
LAB_00101271:
MOV dword ptr [RBP + -0x58],0x0
JMP 0x001012da
LAB_0010127a:
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x001012ce
LAB_00101285:
MOV EAX,dword ptr [RBP + -0x58]
CDQE
MOVZX EDX,byte ptr [RBP + RAX*0x1 + -0x40]
MOV EAX,dword ptr [RBP + -0x54]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x40]
CMP DL,AL
JLE 0x001012ca
MOV EAX,dword ptr [RBP + -0x58]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x40]
MOV byte ptr [RBP + -0x65],AL
MOV EAX,dword ptr [RBP + -0x54]
CDQE
MOVZX EDX,byte ptr [RBP + RAX*0x1 + -0x40]
MOV EAX,dword ptr [RBP + -0x58]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x40],DL
MOV EAX,dword ptr [RBP + -0x54]
CDQE
MOVZX EDX,byte ptr [RBP + -0x65]
MOV byte ptr [RBP + RAX*0x1 + -0x40],DL
LAB_001012ca:
ADD dword ptr [RBP + -0x54],0x1
LAB_001012ce:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x60]
JL 0x00101285
ADD dword ptr [RBP + -0x58],0x1
LAB_001012da:
MOV EAX,dword ptr [RBP + -0x60]
SUB EAX,0x1
CMP dword ptr [RBP + -0x58],EAX
JL 0x0010127a
CMP dword ptr [RBP + -0x64],0x0
JLE 0x00101301
MOV EAX,dword ptr [RBP + -0x64]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x64],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV byte ptr [RAX],0x20
LAB_00101301:
MOV dword ptr [RBP + -0x50],0x0
JMP 0x0010132d
LAB_0010130a:
MOV EAX,dword ptr [RBP + -0x64]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x64],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x50]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x40]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x50],0x1
LAB_0010132d:
MOV EAX,dword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x60]
JL 0x0010130a
MOV dword ptr [RBP + -0x60],0x0
JMP 0x0010135e
LAB_0010133e:
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x78]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x60]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x60],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x40],DL
LAB_0010135e:
ADD dword ptr [RBP + -0x5c],0x1
LAB_00101362:
MOV EAX,dword ptr [RBP + -0x5c]
CMP EAX,dword ptr [RBP + -0x4c]
JLE 0x00101245
MOV EAX,dword ptr [RBP + -0x64]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101396
CALL 0x001010c0
LAB_00101396:
LEAVE
RET
|
void * func0(char *param_1)
{
char cVar1;
size_t sVar2;
void *pvVar3;
long in_FS_OFFSET;
int local_6c;
int local_68;
int local_64;
int local_60;
int local_5c;
int local_58;
char acStack_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
pvVar3 = malloc((long)((int)sVar2 + 2));
local_6c = 0;
local_68 = 0;
for (local_64 = 0; local_64 <= (int)sVar2; local_64 = local_64 + 1) {
if ((param_1[local_64] == ' ') || (param_1[local_64] == '\0')) {
for (local_60 = 0; local_5c = local_60, local_60 < local_68 + -1; local_60 = local_60 + 1) {
while (local_5c = local_5c + 1, local_5c < local_68) {
if (acStack_48[local_5c] < acStack_48[local_60]) {
cVar1 = acStack_48[local_60];
acStack_48[local_60] = acStack_48[local_5c];
acStack_48[local_5c] = cVar1;
}
}
}
if (0 < local_6c) {
*(int *)((long)pvVar3 + (long)local_6c) = 0x20;
local_6c = local_6c + 1;
}
for (local_58 = 0; local_58 < local_68; local_58 = local_58 + 1) {
*(char *)((long)local_6c + (long)pvVar3) = acStack_48[local_58];
local_6c = local_6c + 1;
}
local_68 = 0;
}
else {
acStack_48[local_68] = param_1[local_64];
local_68 = local_68 + 1;
}
}
*(int *)((long)pvVar3 + (long)local_6c) = 0;
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,001 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = j + 1; k < current_index; k++) {
if (current[j] > current[k]) {
char temp = current[j];
current[j] = current[k];
current[k] = temp;
}
}
}
if (out_index > 0) out[out_index++] = ' ';
for (int j = 0; j < current_index; j++) {
out[out_index++] = current[j];
}
current_index = 0;
} else {
current[current_index++] = s[i];
}
}
out[out_index] = '\0';
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
free(result);
result = func0("abcd");
assert(strcmp(result, "abcd") == 0);
free(result);
result = func0("Hello World!!!");
assert(strcmp(result, "Hello !!!Wdlor") == 0);
free(result);
result = func0("");
assert(strcmp(result, "") == 0);
free(result);
result = func0("Hi. My name is Mister Robot. How are you?");
assert(strcmp(result, ".Hi My aemn is Meirst .Rboot How aer ?ouy") == 0);
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
lea 0x1(%rcx),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r11
test %ebp,%ebp
js 12d4 <func0+0x12b>
mov %rbx,%r10
mov %ebp,%ebp
lea 0x1(%rbx,%rbp,1),%rbp
mov $0x0,%r9d
mov $0x0,%ebx
mov $0x0,%r12d
mov %rsp,%r13
jmpq 12b7 <func0+0x10e>
cmp $0x1,%r9d
jle 126c <func0+0xc3>
mov %rsp,%rsi
lea -0x1(%r9),%r15d
mov %r15d,%r14d
mov $0x0,%r8d
jmp 1253 <func0+0xaa>
add $0x1,%rax
cmp %rdi,%rax
je 124a <func0+0xa1>
movzbl (%rsi),%edx
movzbl 0x1(%rax),%ecx
cmp %cl,%dl
jle 122f <func0+0x86>
mov %cl,(%rsi)
mov %dl,0x1(%rax)
jmp 122f <func0+0x86>
add $0x1,%rsi
cmp %r14d,%r8d
je 126c <func0+0xc3>
add $0x1,%r8d
cmp %r9d,%r8d
jge 124a <func0+0xa1>
mov %r15d,%eax
sub %r8d,%eax
lea 0x1(%rsi,%rax,1),%rdi
mov %rsi,%rax
jmp 1238 <func0+0x8f>
test %ebx,%ebx
jle 127b <func0+0xd2>
movslq %ebx,%rax
movb $0x20,(%r11,%rax,1)
lea 0x1(%rbx),%ebx
test %r9d,%r9d
jle 12cf <func0+0x126>
movslq %ebx,%rdx
mov %r9d,%edi
lea -0x1(%r9),%eax
lea 0x1(%rdx,%rax,1),%rsi
mov %rdx,%rax
mov %r13,%rcx
sub %rdx,%rcx
movzbl (%rcx,%rax,1),%edx
mov %dl,(%r11,%rax,1)
add $0x1,%rax
cmp %rax,%rsi
jne 1298 <func0+0xef>
add %edi,%ebx
mov %r12d,%r9d
add $0x1,%r10
cmp %rbp,%r10
je 12d9 <func0+0x130>
movzbl (%r10),%eax
test $0xdf,%al
je 1217 <func0+0x6e>
movslq %r9d,%rdx
mov %al,(%rsp,%rdx,1)
lea 0x1(%r9),%r9d
jmp 12ae <func0+0x105>
mov %r12d,%r9d
jmp 12ae <func0+0x105>
mov $0x0,%ebx
movslq %ebx,%rbx
movb $0x0,(%r11,%rbx,1)
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1303 <func0+0x15a>
mov %r11,%rax
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1090 <__stack_chk_fail@plt>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 40h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
call _strlen
mov rbx, rax
lea edi, [rax+2]
movsxd rdi, edi; size
call _malloc
mov r11, rax
test ebx, ebx
js loc_12AD
mov r10, rbp
mov ebx, ebx
lea rbp, [rbp+rbx+1]
mov r9d, 0
mov ebx, 0
mov r13, rsp
mov r12d, 0
jmp loc_1320
loc_124D:
cmp r9d, 1
jle short loc_129F
mov rsi, rsp
lea r14d, [r9-1]
mov r8d, 0
jmp short loc_1286
loc_1262:
add rax, 1
cmp rax, rdi
jz short loc_127D
loc_126B:
movzx edx, byte ptr [rsi]
movzx ecx, byte ptr [rax+1]
cmp dl, cl
jle short loc_1262
mov [rsi], cl
mov [rax+1], dl
jmp short loc_1262
loc_127D:
add rsi, 1
cmp r8d, r14d
jz short loc_12DA
loc_1286:
add r8d, 1
cmp r8d, r9d
jge short loc_127D
mov eax, r14d
sub eax, r8d
lea rdi, [rsi+rax+1]
mov rax, rsi
jmp short loc_126B
loc_129F:
test ebx, ebx
jg short loc_12DE
jmp short loc_12E9
loc_12A5:
mov r9d, 0
jmp short loc_1317
loc_12AD:
mov ebx, 0
loc_12B2:
movsxd rbx, ebx
mov byte ptr [r11+rbx], 0
mov rax, [rsp+68h+var_30]
sub rax, fs:28h
jnz short loc_1338
mov rax, r11
add rsp, 40h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12DA:
test ebx, ebx
jle short loc_12EE
loc_12DE:
movsxd rax, ebx
mov byte ptr [r11+rax], 20h ; ' '
lea ebx, [rbx+1]
loc_12E9:
test r9d, r9d
jle short loc_12A5
loc_12EE:
movsxd rdx, ebx
movsxd rcx, r9d
add rcx, rdx
mov rax, rdx
mov rsi, r13
sub rsi, rdx
loc_1300:
movzx edx, byte ptr [rsi+rax]
mov [r11+rax], dl
add rax, 1
cmp rax, rcx
jnz short loc_1300
add ebx, r9d
mov r9d, r12d
loc_1317:
add r10, 1
cmp r10, rbp
jz short loc_12B2
loc_1320:
movzx eax, byte ptr [r10]
test al, 0DFh
jz loc_124D
movsxd rdx, r9d
mov [rsp+rdx+68h+var_68], al
lea r9d, [r9+1]
jmp short loc_1317
loc_1338:
call ___stack_chk_fail
|
_BYTE * func0(const char *a1)
{
int v1; // ebx
_BYTE *v2; // r11
const char *v3; // r10
long long v4; // rbp
int v5; // r9d
int v6; // ebx
char *v7; // rsi
int v8; // r14d
int v9; // r8d
char *v10; // rax
char v11; // dl
char v12; // cl
long long v14; // rax
_BYTE v15[56]; // [rsp+0h] [rbp-68h] BYREF
unsigned long long v16; // [rsp+38h] [rbp-30h]
v16 = __readfsqword(0x28u);
v1 = strlen(a1);
v2 = malloc(v1 + 2);
if ( v1 >= 0 )
{
v3 = a1;
v4 = (long long)&a1[v1 + 1];
v5 = 0;
v6 = 0;
while ( 1 )
{
if ( (*v3 & 0xDF) != 0 )
{
v15[v5++] = *v3;
goto LABEL_22;
}
if ( v5 <= 1 )
{
if ( v6 <= 0 )
goto LABEL_18;
}
else
{
v7 = v15;
v8 = v5 - 1;
v9 = 0;
do
{
if ( ++v9 < v5 )
{
v10 = v7;
do
{
v11 = *v7;
v12 = v10[1];
if ( *v7 > v12 )
{
*v7 = v12;
v10[1] = v11;
}
++v10;
}
while ( v10 != &v7[v8 - v9 + 1] );
}
++v7;
}
while ( v9 != v8 );
if ( v6 <= 0 )
{
LABEL_19:
v14 = v6;
do
{
v2[v14] = v15[v14 - v6];
++v14;
}
while ( v14 != v6 + (long long)v5 );
v6 += v5;
v5 = 0;
goto LABEL_22;
}
}
v2[v6++] = 32;
LABEL_18:
if ( v5 > 0 )
goto LABEL_19;
v5 = 0;
LABEL_22:
if ( ++v3 == (const char *)v4 )
goto LABEL_15;
}
}
v6 = 0;
LABEL_15:
v2[v6] = 0;
return v2;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV RBX,RAX
LEA EDI,[RAX + 0x2]
MOVSXD RDI,EDI
CALL 0x001010f0
MOV R11,RAX
TEST EBX,EBX
JS 0x001012ad
MOV R10,RBP
MOV EBX,EBX
LEA RBP,[RBP + RBX*0x1 + 0x1]
MOV R9D,0x0
MOV EBX,0x0
MOV R13,RSP
MOV R12D,0x0
JMP 0x00101320
LAB_0010124d:
CMP R9D,0x1
JLE 0x0010129f
MOV RSI,RSP
LEA R14D,[R9 + -0x1]
MOV R8D,0x0
JMP 0x00101286
LAB_00101262:
ADD RAX,0x1
CMP RAX,RDI
JZ 0x0010127d
LAB_0010126b:
MOVZX EDX,byte ptr [RSI]
MOVZX ECX,byte ptr [RAX + 0x1]
CMP DL,CL
JLE 0x00101262
MOV byte ptr [RSI],CL
MOV byte ptr [RAX + 0x1],DL
JMP 0x00101262
LAB_0010127d:
ADD RSI,0x1
CMP R8D,R14D
JZ 0x001012da
LAB_00101286:
ADD R8D,0x1
CMP R8D,R9D
JGE 0x0010127d
MOV EAX,R14D
SUB EAX,R8D
LEA RDI,[RSI + RAX*0x1 + 0x1]
MOV RAX,RSI
JMP 0x0010126b
LAB_0010129f:
TEST EBX,EBX
JG 0x001012de
JMP 0x001012e9
LAB_001012a5:
MOV R9D,0x0
JMP 0x00101317
LAB_001012ad:
MOV EBX,0x0
LAB_001012b2:
MOVSXD RBX,EBX
MOV byte ptr [R11 + RBX*0x1],0x0
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101338
MOV RAX,R11
ADD RSP,0x40
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012da:
TEST EBX,EBX
JLE 0x001012ee
LAB_001012de:
MOVSXD RAX,EBX
MOV byte ptr [R11 + RAX*0x1],0x20
LEA EBX,[RBX + 0x1]
LAB_001012e9:
TEST R9D,R9D
JLE 0x001012a5
LAB_001012ee:
MOVSXD RDX,EBX
MOVSXD RCX,R9D
ADD RCX,RDX
MOV RAX,RDX
MOV RSI,R13
SUB RSI,RDX
LAB_00101300:
MOVZX EDX,byte ptr [RSI + RAX*0x1]
MOV byte ptr [R11 + RAX*0x1],DL
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101300
ADD EBX,R9D
MOV R9D,R12D
LAB_00101317:
ADD R10,0x1
CMP R10,RBP
JZ 0x001012b2
LAB_00101320:
MOVZX EAX,byte ptr [R10]
TEST AL,0xdf
JZ 0x0010124d
MOVSXD RDX,R9D
MOV byte ptr [RSP + RDX*0x1],AL
LEA R9D,[R9 + 0x1]
JMP 0x00101317
LAB_00101338:
CALL 0x001010c0
|
void * func0(byte *param_1)
{
byte *pbVar1;
char cVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
long lVar6;
long lVar7;
int iVar8;
byte *pbVar9;
int iVar10;
int iVar11;
long in_FS_OFFSET;
byte local_68 [56];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen((char *)param_1);
pvVar4 = malloc((long)((int)sVar3 + 2));
if ((int)sVar3 < 0) {
iVar8 = 0;
}
else {
pbVar1 = param_1 + (sVar3 & 0xffffffff) + 1;
iVar11 = 0;
iVar8 = 0;
do {
if ((*param_1 & 0xdf) == 0) {
if (iVar11 < 2) {
if (0 < iVar8) goto LAB_001012de;
LAB_001012e9:
if (iVar11 < 1) {
iVar11 = 0;
goto LAB_00101317;
}
}
else {
iVar10 = 0;
pbVar9 = local_68;
do {
iVar10 = iVar10 + 1;
if (iVar10 < iVar11) {
pcVar5 = (char *)pbVar9;
do {
cVar2 = *pbVar9;
if (pcVar5[1] < cVar2) {
*pbVar9 = pcVar5[1];
pcVar5[1] = cVar2;
}
pcVar5 = pcVar5 + 1;
} while (pcVar5 != (char *)pbVar9 + (ulong)(uint)((iVar11 + -1) - iVar10) + 1);
}
pbVar9 = (byte *)((char *)pbVar9 + 1);
} while (iVar10 != iVar11 + -1);
if (0 < iVar8) {
LAB_001012de:
*(int *)((long)pvVar4 + (long)iVar8) = 0x20;
iVar8 = iVar8 + 1;
goto LAB_001012e9;
}
}
lVar7 = (long)iVar8;
lVar6 = lVar7;
do {
*(byte *)((long)pvVar4 + lVar6) = local_68[lVar6 - lVar7];
lVar6 = lVar6 + 1;
} while (lVar6 != iVar11 + lVar7);
iVar8 = iVar8 + iVar11;
iVar11 = 0;
}
else {
local_68[iVar11] = *param_1;
iVar11 = iVar11 + 1;
}
LAB_00101317:
param_1 = param_1 + 1;
} while (param_1 != pbVar1);
}
*(int *)((long)pvVar4 + (long)iVar8) = 0;
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pvVar4;
}
|
1,002 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = j + 1; k < current_index; k++) {
if (current[j] > current[k]) {
char temp = current[j];
current[j] = current[k];
current[k] = temp;
}
}
}
if (out_index > 0) out[out_index++] = ' ';
for (int j = 0; j < current_index; j++) {
out[out_index++] = current[j];
}
current_index = 0;
} else {
current[current_index++] = s[i];
}
}
out[out_index] = '\0';
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
free(result);
result = func0("abcd");
assert(strcmp(result, "abcd") == 0);
free(result);
result = func0("Hello World!!!");
assert(strcmp(result, "Hello !!!Wdlor") == 0);
free(result);
result = func0("");
assert(strcmp(result, "") == 0);
free(result);
result = func0("Hi. My name is Mister Robot. How are you?");
assert(strcmp(result, ".Hi My aemn is Meirst .Rboot How aer ?ouy") == 0);
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10a0 <strlen@plt>
lea 0x2(%rax),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r10
test %ebx,%ebx
js 153a <func0+0x12a>
mov %ebx,%ebx
mov %rbp,%r9
xor %r8d,%r8d
xor %r11d,%r11d
lea 0x1(%rbp,%rbx,1),%rbx
mov %rsp,%rbp
jmp 1487 <func0+0x77>
nopw %cs:0x0(%rax,%rax,1)
movslq %r8d,%rdx
add $0x1,%r8d
mov %al,(%rsp,%rdx,1)
add $0x1,%r9
cmp %rbx,%r9
je 1534 <func0+0x124>
movzbl (%r9),%eax
test $0xdf,%al
jne 1470 <func0+0x60>
mov %rbp,%rsi
lea -0x1(%r8),%r14d
xor %r12d,%r12d
cmp $0x1,%r8d
jle 14e1 <func0+0xd1>
add $0x1,%r12d
lea 0x1(%rsi),%r13
cmp %r8d,%r12d
jge 14d9 <func0+0xc9>
mov %r14d,%edi
mov %rsi,%rax
sub %r12d,%edi
add %r13,%rdi
nopl 0x0(%rax)
movzbl (%rsi),%edx
movzbl 0x1(%rax),%ecx
cmp %cl,%dl
jle 14d0 <func0+0xc0>
mov %cl,(%rsi)
mov %dl,0x1(%rax)
add $0x1,%rax
cmp %rdi,%rax
jne 14c0 <func0+0xb0>
mov %r13,%rsi
cmp %r14d,%r12d
jne 14a0 <func0+0x90>
test %r11d,%r11d
je 14f2 <func0+0xe2>
movslq %r11d,%rax
add $0x1,%r11d
movb $0x20,(%r10,%rax,1)
test %r8d,%r8d
je 147a <func0+0x6a>
movslq %r11d,%rax
lea -0x1(%r8),%edx
mov %rbp,%rcx
lea 0x1(%rax,%rdx,1),%rsi
sub %rax,%rcx
nopl 0x0(%rax)
movzbl (%rcx,%rax,1),%edx
mov %dl,(%r10,%rax,1)
add $0x1,%rax
cmp %rax,%rsi
jne 1510 <func0+0x100>
add $0x1,%r9
add %r8d,%r11d
xor %r8d,%r8d
cmp %rbx,%r9
jne 1487 <func0+0x77>
movslq %r11d,%rax
add %r10,%rax
movb $0x0,(%rax)
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 155d <func0+0x14d>
add $0x40,%rsp
mov %r10,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
call _strlen
lea edi, [rax+2]
mov rbx, rax
movsxd rdi, edi; size
call _malloc
mov r14, rax
test ebx, ebx
js loc_153A
mov ebx, ebx
xor r12d, r12d
mov r15, rsp
lea r13, [rbp+rbx+1]
xor ebx, ebx
jmp short loc_149E
loc_1488:
movsxd rdx, ebx
add ebx, 1
mov [rsp+rdx+78h+var_78], al
loc_1491:
add rbp, 1
cmp rbp, r13
jz loc_1534
loc_149E:
movzx eax, byte ptr [rbp+0]
test al, 0DFh
jnz short loc_1488
cmp ebx, 1
jle loc_1572
mov r10, r15
mov rsi, r15
lea r11d, [rbx-1]
xor r8d, r8d
nop dword ptr [rax+00h]
loc_14C0:
add r8d, 1
cmp r8d, ebx
jge loc_1560
mov edi, r11d
lea r9, [rsi+1]
mov rax, rsi
sub edi, r8d
add rdi, r9
nop dword ptr [rax]
loc_14E0:
movzx edx, byte ptr [rsi]
movzx ecx, byte ptr [rax+1]
cmp dl, cl
jle short loc_14F0
mov [rsi], cl
mov [rax+1], dl
loc_14F0:
add rax, 1
cmp rdi, rax
jnz short loc_14E0
mov rsi, r9
cmp r8d, r11d
jnz short loc_14C0
loc_1501:
test r12d, r12d
jle short loc_1512
movsxd rax, r12d
add r12d, 1
mov byte ptr [r14+rax], 20h ; ' '
loc_1512:
movsxd rdi, r12d
mov edx, ebx; n
mov rsi, r10; src
add rbp, 1
add rdi, r14; dest
add r12d, ebx
xor ebx, ebx
call _memcpy
cmp rbp, r13
jnz loc_149E
loc_1534:
movsxd rax, r12d
add rax, r14
loc_153A:
mov byte ptr [rax], 0
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1597
add rsp, 48h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1560:
lea r9, [rsi+1]
mov rsi, r9
cmp r8d, r11d
jnz loc_14C0
jmp short loc_1501
loc_1572:
test r12d, r12d
jle short loc_1583
movsxd rax, r12d
add r12d, 1
mov byte ptr [r14+rax], 20h ; ' '
loc_1583:
cmp ebx, 1
jz short loc_158F
xor ebx, ebx
jmp loc_1491
loc_158F:
mov r10, rsp
jmp loc_1512
loc_1597:
call ___stack_chk_fail
|
_BYTE * func0(const char *a1)
{
const char *v1; // rbp
int v2; // ebx
_BYTE *v3; // rax
_BYTE *v4; // r14
int v5; // r12d
long long v6; // r13
int v7; // ebx
long long v8; // rdx
char *v9; // rsi
int v10; // r11d
int v11; // r8d
char *v12; // rax
char v13; // dl
char v14; // cl
long long v15; // rax
size_t v16; // rdx
_BYTE *v17; // rdi
long long v19; // rax
_BYTE v20[56]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v21; // [rsp+38h] [rbp-40h]
v1 = a1;
v21 = __readfsqword(0x28u);
v2 = strlen(a1);
v3 = malloc(v2 + 2);
v4 = v3;
if ( v2 >= 0 )
{
v5 = 0;
v6 = (long long)&a1[v2 + 1];
v7 = 0;
while ( 1 )
{
while ( (*v1 & 0xDF) != 0 )
{
v8 = v7++;
v20[v8] = *v1;
LABEL_4:
if ( ++v1 == (const char *)v6 )
goto LABEL_17;
}
if ( v7 > 1 )
{
v9 = v20;
v10 = v7 - 1;
v11 = 0;
do
{
while ( ++v11 >= v7 )
{
++v9;
if ( v11 == v10 )
goto LABEL_14;
}
v12 = v9;
do
{
v13 = *v9;
v14 = v12[1];
if ( *v9 > v14 )
{
*v9 = v14;
v12[1] = v13;
}
++v12;
}
while ( &v9[v10 - v11 + 1] != v12 );
++v9;
}
while ( v11 != v10 );
LABEL_14:
if ( v5 > 0 )
{
v15 = v5++;
v4[v15] = 32;
}
goto LABEL_16;
}
if ( v5 > 0 )
{
v19 = v5++;
v4[v19] = 32;
}
if ( v7 != 1 )
{
v7 = 0;
goto LABEL_4;
}
LABEL_16:
v16 = (unsigned int)v7;
++v1;
v17 = &v4[v5];
v5 += v7;
v7 = 0;
memcpy(v17, v20, v16);
if ( v1 == (const char *)v6 )
{
LABEL_17:
v3 = &v4[v5];
break;
}
}
}
*v3 = 0;
return v4;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x001010c0
LEA EDI,[RAX + 0x2]
MOV RBX,RAX
MOVSXD RDI,EDI
CALL 0x00101110
MOV R14,RAX
TEST EBX,EBX
JS 0x0010153a
MOV EBX,EBX
XOR R12D,R12D
MOV R15,RSP
LEA R13,[RBP + RBX*0x1 + 0x1]
XOR EBX,EBX
JMP 0x0010149e
LAB_00101488:
MOVSXD RDX,EBX
ADD EBX,0x1
MOV byte ptr [RSP + RDX*0x1],AL
LAB_00101491:
ADD RBP,0x1
CMP RBP,R13
JZ 0x00101534
LAB_0010149e:
MOVZX EAX,byte ptr [RBP]
TEST AL,0xdf
JNZ 0x00101488
CMP EBX,0x1
JLE 0x00101572
MOV R10,R15
MOV RSI,R15
LEA R11D,[RBX + -0x1]
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001014c0:
ADD R8D,0x1
CMP R8D,EBX
JGE 0x00101560
MOV EDI,R11D
LEA R9,[RSI + 0x1]
MOV RAX,RSI
SUB EDI,R8D
ADD RDI,R9
NOP dword ptr [RAX]
LAB_001014e0:
MOVZX EDX,byte ptr [RSI]
MOVZX ECX,byte ptr [RAX + 0x1]
CMP DL,CL
JLE 0x001014f0
MOV byte ptr [RSI],CL
MOV byte ptr [RAX + 0x1],DL
LAB_001014f0:
ADD RAX,0x1
CMP RDI,RAX
JNZ 0x001014e0
MOV RSI,R9
CMP R8D,R11D
JNZ 0x001014c0
LAB_00101501:
TEST R12D,R12D
JLE 0x00101512
MOVSXD RAX,R12D
ADD R12D,0x1
MOV byte ptr [R14 + RAX*0x1],0x20
LAB_00101512:
MOVSXD RDI,R12D
MOV EDX,EBX
MOV RSI,R10
ADD RBP,0x1
ADD RDI,R14
ADD R12D,EBX
XOR EBX,EBX
CALL 0x00101100
CMP RBP,R13
JNZ 0x0010149e
LAB_00101534:
MOVSXD RAX,R12D
ADD RAX,R14
LAB_0010153a:
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101597
ADD RSP,0x48
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101560:
LEA R9,[RSI + 0x1]
MOV RSI,R9
CMP R8D,R11D
JNZ 0x001014c0
JMP 0x00101501
LAB_00101572:
TEST R12D,R12D
JLE 0x00101583
MOVSXD RAX,R12D
ADD R12D,0x1
MOV byte ptr [R14 + RAX*0x1],0x20
LAB_00101583:
CMP EBX,0x1
JZ 0x0010158f
XOR EBX,EBX
JMP 0x00101491
LAB_0010158f:
MOV R10,RSP
JMP 0x00101512
LAB_00101597:
CALL 0x001010d0
|
int * func0(byte *param_1)
{
int iVar1;
byte *pbVar2;
char cVar3;
size_t sVar4;
int *puVar5;
char *pcVar6;
long lVar7;
int *puVar8;
ulong __n;
uint uVar9;
byte *pbVar10;
int iVar11;
int iVar12;
long in_FS_OFFSET;
byte local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar4 = strlen((char *)param_1);
puVar5 = (int *)malloc((long)((int)sVar4 + 2));
puVar8 = puVar5;
if (-1 < (int)sVar4) {
iVar12 = 0;
pbVar2 = param_1 + (sVar4 & 0xffffffff) + 1;
uVar9 = 0;
do {
while ((*param_1 & 0xdf) != 0) {
lVar7 = (long)(int)uVar9;
uVar9 = uVar9 + 1;
local_78[lVar7] = *param_1;
LAB_00101491:
param_1 = param_1 + 1;
if (param_1 == pbVar2) goto LAB_00101534;
}
if ((int)uVar9 < 2) {
if (0 < iVar12) {
lVar7 = (long)iVar12;
iVar12 = iVar12 + 1;
puVar5[lVar7] = 0x20;
}
if (uVar9 != 1) {
uVar9 = 0;
goto LAB_00101491;
}
}
else {
iVar1 = uVar9 - 1;
iVar11 = 0;
pbVar10 = local_78;
do {
while (iVar11 = iVar11 + 1, iVar11 < (int)uVar9) {
pcVar6 = (char *)pbVar10;
do {
cVar3 = *pbVar10;
if (pcVar6[1] < cVar3) {
*pbVar10 = pcVar6[1];
pcVar6[1] = cVar3;
}
pcVar6 = pcVar6 + 1;
} while ((char *)pbVar10 + 1 + (uint)(iVar1 - iVar11) != pcVar6);
pbVar10 = (byte *)((char *)pbVar10 + 1);
if (iVar11 == iVar1) goto LAB_00101501;
}
pbVar10 = (byte *)((char *)pbVar10 + 1);
} while (iVar11 != iVar1);
LAB_00101501:
if (0 < iVar12) {
lVar7 = (long)iVar12;
iVar12 = iVar12 + 1;
puVar5[lVar7] = 0x20;
}
}
lVar7 = (long)iVar12;
__n = (ulong)uVar9;
param_1 = param_1 + 1;
iVar12 = iVar12 + uVar9;
uVar9 = 0;
memcpy(puVar5 + lVar7,local_78,__n);
} while (param_1 != pbVar2);
LAB_00101534:
puVar8 = puVar5 + iVar12;
}
*puVar8 = 0;
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar5;
}
|
1,003 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = j + 1; k < current_index; k++) {
if (current[j] > current[k]) {
char temp = current[j];
current[j] = current[k];
current[k] = temp;
}
}
}
if (out_index > 0) out[out_index++] = ' ';
for (int j = 0; j < current_index; j++) {
out[out_index++] = current[j];
}
current_index = 0;
} else {
current[current_index++] = s[i];
}
}
out[out_index] = '\0';
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
free(result);
result = func0("abcd");
assert(strcmp(result, "abcd") == 0);
free(result);
result = func0("Hello World!!!");
assert(strcmp(result, "Hello !!!Wdlor") == 0);
free(result);
result = func0("");
assert(strcmp(result, "") == 0);
free(result);
result = func0("Hi. My name is Mister Robot. How are you?");
assert(strcmp(result, ".Hi My aemn is Meirst .Rboot How aer ?ouy") == 0);
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10b0 <strlen@plt>
lea 0x2(%rax),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r14
test %ebx,%ebx
js 153b <func0+0x10b>
mov %ebx,%ebx
xor %r12d,%r12d
mov %rsp,%r15
lea 0x1(%rbp,%rbx,1),%r13
xor %ebx,%ebx
jmp 149e <func0+0x6e>
nopl 0x0(%rax)
movslq %ebx,%rdx
add $0x1,%ebx
mov %al,(%rsp,%rdx,1)
add $0x1,%rbp
cmp %r13,%rbp
je 1535 <func0+0x105>
movzbl 0x0(%rbp),%eax
test $0xdf,%al
jne 1488 <func0+0x58>
mov %r15,%rsi
lea -0x1(%rbx),%r10d
xor %r8d,%r8d
cmp $0x1,%ebx
jle 14f9 <func0+0xc9>
nopl (%rax)
add $0x1,%r8d
cmp %ebx,%r8d
jge 1560 <func0+0x130>
mov %r10d,%edi
lea 0x1(%rsi),%r9
mov %rsi,%rax
sub %r8d,%edi
add %r9,%rdi
nopl (%rax)
movzbl (%rsi),%edx
movzbl 0x1(%rax),%ecx
cmp %cl,%dl
jle 14e8 <func0+0xb8>
mov %cl,(%rsi)
mov %dl,0x1(%rax)
add $0x1,%rax
cmp %rax,%rdi
jne 14d8 <func0+0xa8>
mov %r9,%rsi
cmp %r8d,%r10d
jne 14b8 <func0+0x88>
test %r12d,%r12d
je 150a <func0+0xda>
movslq %r12d,%rax
add $0x1,%r12d
movb $0x20,(%r14,%rax,1)
test %ebx,%ebx
je 1491 <func0+0x61>
movslq %r12d,%rdi
lea -0x1(%rbx),%edx
mov %r15,%rsi
add $0x1,%rbp
add %r14,%rdi
add $0x1,%rdx
add %ebx,%r12d
xor %ebx,%ebx
callq 10e0 <memcpy@plt>
cmp %r13,%rbp
jne 149e <func0+0x6e>
movslq %r12d,%rax
add %r14,%rax
movb $0x0,(%rax)
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1572 <func0+0x142>
add $0x48,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
lea 0x1(%rsi),%r9
mov %r9,%rsi
cmp %r8d,%r10d
jne 14b8 <func0+0x88>
jmp 14f9 <func0+0xc9>
callq 10c0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
call _strlen
lea edi, [rax+2]
mov rbx, rax
movsxd rdi, edi; size
call _malloc
mov r14, rax
test ebx, ebx
js loc_153A
mov ebx, ebx
xor r12d, r12d
mov r15, rsp
lea r13, [rbp+rbx+1]
xor ebx, ebx
jmp short loc_149E
loc_1488:
movsxd rdx, ebx
add ebx, 1
mov [rsp+rdx+78h+var_78], al
loc_1491:
add rbp, 1
cmp rbp, r13
jz loc_1534
loc_149E:
movzx eax, byte ptr [rbp+0]
test al, 0DFh
jnz short loc_1488
cmp ebx, 1
jle loc_1572
mov r10, r15
mov rsi, r15
lea r11d, [rbx-1]
xor r8d, r8d
nop dword ptr [rax+00h]
loc_14C0:
add r8d, 1
cmp r8d, ebx
jge loc_1560
mov edi, r11d
lea r9, [rsi+1]
mov rax, rsi
sub edi, r8d
add rdi, r9
nop dword ptr [rax]
loc_14E0:
movzx edx, byte ptr [rsi]
movzx ecx, byte ptr [rax+1]
cmp dl, cl
jle short loc_14F0
mov [rsi], cl
mov [rax+1], dl
loc_14F0:
add rax, 1
cmp rdi, rax
jnz short loc_14E0
mov rsi, r9
cmp r11d, r8d
jnz short loc_14C0
loc_1501:
test r12d, r12d
jle short loc_1512
movsxd rax, r12d
add r12d, 1
mov byte ptr [r14+rax], 20h ; ' '
loc_1512:
movsxd rdi, r12d
mov edx, ebx; n
mov rsi, r10; src
add rbp, 1
add rdi, r14; dest
add r12d, ebx
xor ebx, ebx
call _memcpy
cmp rbp, r13
jnz loc_149E
loc_1534:
movsxd rax, r12d
add rax, r14
loc_153A:
mov byte ptr [rax], 0
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1597
add rsp, 48h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1560:
lea r9, [rsi+1]
mov rsi, r9
cmp r11d, r8d
jnz loc_14C0
jmp short loc_1501
loc_1572:
test r12d, r12d
jle short loc_1583
movsxd rax, r12d
add r12d, 1
mov byte ptr [r14+rax], 20h ; ' '
loc_1583:
cmp ebx, 1
jz short loc_158F
xor ebx, ebx
jmp loc_1491
loc_158F:
mov r10, rsp
jmp loc_1512
loc_1597:
call ___stack_chk_fail
|
_BYTE * func0(const char *a1)
{
const char *v1; // rbp
int v2; // ebx
_BYTE *v3; // rax
_BYTE *v4; // r14
int v5; // r12d
long long v6; // r13
int v7; // ebx
long long v8; // rdx
char *v9; // rsi
int v10; // r11d
int v11; // r8d
char *v12; // rax
char v13; // dl
char v14; // cl
long long v15; // rax
size_t v16; // rdx
_BYTE *v17; // rdi
long long v19; // rax
_BYTE v20[56]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v21; // [rsp+38h] [rbp-40h]
v1 = a1;
v21 = __readfsqword(0x28u);
v2 = strlen(a1);
v3 = malloc(v2 + 2);
v4 = v3;
if ( v2 >= 0 )
{
v5 = 0;
v6 = (long long)&a1[v2 + 1];
v7 = 0;
while ( 1 )
{
while ( (*v1 & 0xDF) != 0 )
{
v8 = v7++;
v20[v8] = *v1;
LABEL_4:
if ( ++v1 == (const char *)v6 )
goto LABEL_17;
}
if ( v7 > 1 )
{
v9 = v20;
v10 = v7 - 1;
v11 = 0;
do
{
while ( ++v11 >= v7 )
{
++v9;
if ( v10 == v11 )
goto LABEL_14;
}
v12 = v9;
do
{
v13 = *v9;
v14 = v12[1];
if ( *v9 > v14 )
{
*v9 = v14;
v12[1] = v13;
}
++v12;
}
while ( &v9[v10 - v11 + 1] != v12 );
++v9;
}
while ( v10 != v11 );
LABEL_14:
if ( v5 > 0 )
{
v15 = v5++;
v4[v15] = 32;
}
goto LABEL_16;
}
if ( v5 > 0 )
{
v19 = v5++;
v4[v19] = 32;
}
if ( v7 != 1 )
{
v7 = 0;
goto LABEL_4;
}
LABEL_16:
v16 = (unsigned int)v7;
++v1;
v17 = &v4[v5];
v5 += v7;
v7 = 0;
memcpy(v17, v20, v16);
if ( v1 == (const char *)v6 )
{
LABEL_17:
v3 = &v4[v5];
break;
}
}
}
*v3 = 0;
return v4;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x001010c0
LEA EDI,[RAX + 0x2]
MOV RBX,RAX
MOVSXD RDI,EDI
CALL 0x00101110
MOV R14,RAX
TEST EBX,EBX
JS 0x0010153a
MOV EBX,EBX
XOR R12D,R12D
MOV R15,RSP
LEA R13,[RBP + RBX*0x1 + 0x1]
XOR EBX,EBX
JMP 0x0010149e
LAB_00101488:
MOVSXD RDX,EBX
ADD EBX,0x1
MOV byte ptr [RSP + RDX*0x1],AL
LAB_00101491:
ADD RBP,0x1
CMP RBP,R13
JZ 0x00101534
LAB_0010149e:
MOVZX EAX,byte ptr [RBP]
TEST AL,0xdf
JNZ 0x00101488
CMP EBX,0x1
JLE 0x00101572
MOV R10,R15
MOV RSI,R15
LEA R11D,[RBX + -0x1]
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001014c0:
ADD R8D,0x1
CMP R8D,EBX
JGE 0x00101560
MOV EDI,R11D
LEA R9,[RSI + 0x1]
MOV RAX,RSI
SUB EDI,R8D
ADD RDI,R9
NOP dword ptr [RAX]
LAB_001014e0:
MOVZX EDX,byte ptr [RSI]
MOVZX ECX,byte ptr [RAX + 0x1]
CMP DL,CL
JLE 0x001014f0
MOV byte ptr [RSI],CL
MOV byte ptr [RAX + 0x1],DL
LAB_001014f0:
ADD RAX,0x1
CMP RDI,RAX
JNZ 0x001014e0
MOV RSI,R9
CMP R11D,R8D
JNZ 0x001014c0
LAB_00101501:
TEST R12D,R12D
JLE 0x00101512
MOVSXD RAX,R12D
ADD R12D,0x1
MOV byte ptr [R14 + RAX*0x1],0x20
LAB_00101512:
MOVSXD RDI,R12D
MOV EDX,EBX
MOV RSI,R10
ADD RBP,0x1
ADD RDI,R14
ADD R12D,EBX
XOR EBX,EBX
CALL 0x00101100
CMP RBP,R13
JNZ 0x0010149e
LAB_00101534:
MOVSXD RAX,R12D
ADD RAX,R14
LAB_0010153a:
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101597
ADD RSP,0x48
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101560:
LEA R9,[RSI + 0x1]
MOV RSI,R9
CMP R11D,R8D
JNZ 0x001014c0
JMP 0x00101501
LAB_00101572:
TEST R12D,R12D
JLE 0x00101583
MOVSXD RAX,R12D
ADD R12D,0x1
MOV byte ptr [R14 + RAX*0x1],0x20
LAB_00101583:
CMP EBX,0x1
JZ 0x0010158f
XOR EBX,EBX
JMP 0x00101491
LAB_0010158f:
MOV R10,RSP
JMP 0x00101512
LAB_00101597:
CALL 0x001010d0
|
int * func0(byte *param_1)
{
int iVar1;
byte *pbVar2;
char cVar3;
size_t sVar4;
int *puVar5;
char *pcVar6;
long lVar7;
int *puVar8;
ulong __n;
uint uVar9;
byte *pbVar10;
int iVar11;
int iVar12;
long in_FS_OFFSET;
byte local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar4 = strlen((char *)param_1);
puVar5 = (int *)malloc((long)((int)sVar4 + 2));
puVar8 = puVar5;
if (-1 < (int)sVar4) {
iVar12 = 0;
pbVar2 = param_1 + (sVar4 & 0xffffffff) + 1;
uVar9 = 0;
do {
while ((*param_1 & 0xdf) != 0) {
lVar7 = (long)(int)uVar9;
uVar9 = uVar9 + 1;
local_78[lVar7] = *param_1;
LAB_00101491:
param_1 = param_1 + 1;
if (param_1 == pbVar2) goto LAB_00101534;
}
if ((int)uVar9 < 2) {
if (0 < iVar12) {
lVar7 = (long)iVar12;
iVar12 = iVar12 + 1;
puVar5[lVar7] = 0x20;
}
if (uVar9 != 1) {
uVar9 = 0;
goto LAB_00101491;
}
}
else {
iVar1 = uVar9 - 1;
iVar11 = 0;
pbVar10 = local_78;
do {
while (iVar11 = iVar11 + 1, iVar11 < (int)uVar9) {
pcVar6 = (char *)pbVar10;
do {
cVar3 = *pbVar10;
if (pcVar6[1] < cVar3) {
*pbVar10 = pcVar6[1];
pcVar6[1] = cVar3;
}
pcVar6 = pcVar6 + 1;
} while ((char *)pbVar10 + 1 + (uint)(iVar1 - iVar11) != pcVar6);
pbVar10 = (byte *)((char *)pbVar10 + 1);
if (iVar1 == iVar11) goto LAB_00101501;
}
pbVar10 = (byte *)((char *)pbVar10 + 1);
} while (iVar1 != iVar11);
LAB_00101501:
if (0 < iVar12) {
lVar7 = (long)iVar12;
iVar12 = iVar12 + 1;
puVar5[lVar7] = 0x20;
}
}
lVar7 = (long)iVar12;
__n = (ulong)uVar9;
param_1 = param_1 + 1;
iVar12 = iVar12 + uVar9;
uVar9 = 0;
memcpy(puVar5 + lVar7,local_78,__n);
} while (param_1 != pbVar2);
LAB_00101534:
puVar8 = puVar5 + iVar12;
}
*puVar8 = 0;
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar5;
}
|
1,004 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)malloc(2 * sizeof(int));
out[count][0] = i;
out[count][1] = j;
count++;
}
}
}
*return_size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
for (int i = 0; i < size; ++i) {
free(result[i]);
}
free(result);
}
int main() {
int rows, returnSize;
int **result;
// Test case 1
rows = 3;
int cols1[] = {6, 6, 6};
int *lst1[] = {(const int[]){1,2,3,4,5,6}, (const int[]){1,2,3,4,1,6}, (const int[]){1,2,3,4,5,1}};
int *expected1[] = {(const int[]){0, 0}, (const int[]){1, 4}, (const int[]){1, 0}, (const int[]){2, 5}, (const int[]){2, 0}};
result = func0(lst1, rows, cols1, 1, &returnSize);
assert(issame(result, returnSize, expected1, 5));
free_result(result, returnSize);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x40(%rbp)
mov %r8,-0x50(%rbp)
mov $0x320,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 12a9 <func0+0x100>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
sub $0x1,%eax
mov %eax,-0x1c(%rbp)
jmpq 129b <func0+0xf2>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x40(%rbp)
jne 1297 <func0+0xee>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%edx
mov %edx,(%rax)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
lea 0x4(%rax),%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x24(%rbp)
subl $0x1,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jns 120a <func0+0x61>
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 11e9 <func0+0x40>
mov -0x50(%rbp),%rax
mov -0x24(%rbp),%edx
mov %edx,(%rax)
mov -0x18(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_40], ecx
mov [rbp+var_50], r8
mov edi, 320h; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp loc_12A9
loc_11E9:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
sub eax, 1
mov [rbp+var_1C], eax
jmp loc_129B
loc_120A:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_1C]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_40], eax
jnz short loc_1297
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rbx, [rdx+rax]
mov edi, 8; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_20]
mov [rax], edx
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
lea rdx, [rax+4]
mov eax, [rbp+var_1C]
mov [rdx], eax
add [rbp+var_24], 1
loc_1297:
sub [rbp+var_1C], 1
loc_129B:
cmp [rbp+var_1C], 0
jns loc_120A
add [rbp+var_20], 1
loc_12A9:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_3C]
jl loc_11E9
mov rax, [rbp+var_50]
mov edx, [rbp+var_24]
mov [rax], edx
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn
|
_QWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v9; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int j; // [rsp+34h] [rbp-1Ch]
_QWORD *v12; // [rsp+38h] [rbp-18h]
v12 = malloc(0x320uLL);
v9 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = *(_DWORD *)(4LL * i + a3) - 1; j >= 0; --j )
{
if ( a4 == *(_DWORD *)(4LL * j + *(_QWORD *)(8LL * i + a1)) )
{
v12[v9] = malloc(8uLL);
*(_DWORD *)v12[v9] = i;
*(_DWORD *)(v12[v9++] + 4LL) = j;
}
}
}
*a5 = v9;
return v12;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x40],ECX
MOV qword ptr [RBP + -0x50],R8
MOV EDI,0x320
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001012a9
LAB_001011e9:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
SUB EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0010129b
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x40],EAX
JNZ 0x00101297
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RBX,[RDX + RAX*0x1]
MOV EDI,0x8
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
LEA RDX,[RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_00101297:
SUB dword ptr [RBP + -0x1c],0x1
LAB_0010129b:
CMP dword ptr [RBP + -0x1c],0x0
JNS 0x0010120a
ADD dword ptr [RBP + -0x20],0x1
LAB_001012a9:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001011e9
MOV RAX,qword ptr [RBP + -0x50]
MOV EDX,dword ptr [RBP + -0x24]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
void *pvVar1;
void *pvVar2;
int4 local_2c;
int4 local_28;
int4 local_24;
pvVar1 = malloc(800);
local_2c = 0;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
local_24 = *(int *)(param_3 + (long)local_28 * 4);
while (local_24 = local_24 + -1, -1 < local_24) {
if (param_4 == *(int *)(*(long *)(param_1 + (long)local_28 * 8) + (long)local_24 * 4)) {
pvVar2 = malloc(8);
*(void **)((long)local_2c * 8 + (long)pvVar1) = pvVar2;
**(int **)((long)pvVar1 + (long)local_2c * 8) = local_28;
*(int *)(*(long *)((long)pvVar1 + (long)local_2c * 8) + 4) = local_24;
local_2c = local_2c + 1;
}
}
}
*param_5 = local_2c;
return pvVar1;
}
|
1,005 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)malloc(2 * sizeof(int));
out[count][0] = i;
out[count][1] = j;
count++;
}
}
}
*return_size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
for (int i = 0; i < size; ++i) {
free(result[i]);
}
free(result);
}
int main() {
int rows, returnSize;
int **result;
// Test case 1
rows = 3;
int cols1[] = {6, 6, 6};
int *lst1[] = {(const int[]){1,2,3,4,5,6}, (const int[]){1,2,3,4,1,6}, (const int[]){1,2,3,4,5,1}};
int *expected1[] = {(const int[]){0, 0}, (const int[]){1, 4}, (const int[]){1, 0}, (const int[]){2, 5}, (const int[]){2, 0}};
result = func0(lst1, rows, cols1, 1, &returnSize);
assert(issame(result, returnSize, expected1, 5));
free_result(result, returnSize);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %rdx,0x18(%rsp)
mov %ecx,%r13d
mov %r8,0x28(%rsp)
mov $0x320,%edi
callq 10b0 <malloc@plt>
mov %rax,0x10(%rsp)
test %ebx,%ebx
jle 1269 <func0+0xc0>
lea -0x1(%rbx),%eax
mov %rax,0x20(%rsp)
mov $0x0,%r15d
mov $0x0,%r14d
jmp 1247 <func0+0x9e>
mov $0x8,%edi
callq 10b0 <malloc@plt>
movslq %r14d,%rdx
mov 0x10(%rsp),%rcx
mov %rax,(%rcx,%rdx,8)
mov 0x8(%rsp),%esi
mov %esi,(%rax)
mov %ebx,0x4(%rax)
add $0x1,%r14d
sub $0x1,%ebx
sub $0x4,%rbp
cmp $0xffffffff,%ebx
je 1235 <func0+0x8c>
mov (%r12),%rax
cmp %r13d,(%rax,%rbp,1)
jne 121d <func0+0x74>
jmp 11fa <func0+0x51>
lea 0x1(%r15),%rax
add $0x8,%r12
cmp 0x20(%rsp),%r15
je 126f <func0+0xc6>
mov %rax,%r15
mov %r15d,0x8(%rsp)
mov 0x18(%rsp),%rax
mov (%rax,%r15,4),%eax
mov %eax,0xc(%rsp)
mov %eax,%ebx
sub $0x1,%ebx
js 1235 <func0+0x8c>
movslq %ebx,%rbp
shl $0x2,%rbp
jmp 1229 <func0+0x80>
mov $0x0,%r14d
mov 0x28(%rsp),%rax
mov %r14d,(%rax)
mov 0x10(%rsp),%rax
add $0x38,%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, 38h
mov r12, rdi
mov ebx, esi
mov [rsp+68h+var_50], rdx
mov r13d, ecx
mov [rsp+68h+var_40], r8
mov edi, 320h; size
call _malloc
mov [rsp+68h+var_58], rax
test ebx, ebx
jle loc_1269
movsxd rax, ebx
mov [rsp+68h+var_48], rax
mov r15d, 0
mov r14d, 0
jmp short loc_1247
loc_11FA:
mov edi, 8; size
call _malloc
movsxd rdx, r14d
mov rcx, [rsp+68h+var_58]
mov [rcx+rdx*8], rax
mov esi, [rsp+68h+var_60]
mov [rax], esi
mov [rax+4], ebx
add r14d, 1
loc_121D:
sub ebx, 1
sub rbp, 4
cmp ebx, 0FFFFFFFFh
jz short loc_1235
loc_1229:
mov rax, [r12]
cmp [rax+rbp], r13d
jnz short loc_121D
jmp short loc_11FA
loc_1235:
add r15, 1
add r12, 8
mov rax, [rsp+68h+var_48]
cmp r15, rax
jz short loc_126F
loc_1247:
mov [rsp+68h+var_60], r15d
mov rax, [rsp+68h+var_50]
mov eax, [rax+r15*4]
mov [rsp+68h+var_5C], eax
mov ebx, eax
sub ebx, 1
js short loc_1235
movsxd rbp, ebx
shl rbp, 2
jmp short loc_1229
loc_1269:
mov r14d, 0
loc_126F:
mov rax, [rsp+68h+var_40]
mov [rax], r14d
mov rax, [rsp+68h+var_58]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
_QWORD * func0(_QWORD *a1, int a2, long long a3, int a4, _DWORD *a5)
{
long long v7; // r15
int v8; // r14d
_DWORD *v9; // rax
int v10; // ebx
long long v11; // rbp
_QWORD *v13; // [rsp+10h] [rbp-58h]
v13 = malloc(0x320uLL);
if ( a2 <= 0 )
{
v8 = 0;
}
else
{
v7 = 0LL;
v8 = 0;
do
{
v10 = *(_DWORD *)(a3 + 4 * v7) - 1;
if ( v10 >= 0 )
{
v11 = 4LL * v10;
do
{
if ( *(_DWORD *)(*a1 + v11) == a4 )
{
v9 = malloc(8uLL);
v13[v8] = v9;
*v9 = v7;
v9[1] = v10;
++v8;
}
--v10;
v11 -= 4LL;
}
while ( v10 != -1 );
}
++v7;
++a1;
}
while ( v7 != a2 );
}
*a5 = v8;
return v13;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R12,RDI
MOV EBX,ESI
MOV qword ptr [RSP + 0x18],RDX
MOV R13D,ECX
MOV qword ptr [RSP + 0x28],R8
MOV EDI,0x320
CALL 0x001010b0
MOV qword ptr [RSP + 0x10],RAX
TEST EBX,EBX
JLE 0x00101269
MOVSXD RAX,EBX
MOV qword ptr [RSP + 0x20],RAX
MOV R15D,0x0
MOV R14D,0x0
JMP 0x00101247
LAB_001011fa:
MOV EDI,0x8
CALL 0x001010b0
MOVSXD RDX,R14D
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV ESI,dword ptr [RSP + 0x8]
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],EBX
ADD R14D,0x1
LAB_0010121d:
SUB EBX,0x1
SUB RBP,0x4
CMP EBX,-0x1
JZ 0x00101235
LAB_00101229:
MOV RAX,qword ptr [R12]
CMP dword ptr [RAX + RBP*0x1],R13D
JNZ 0x0010121d
JMP 0x001011fa
LAB_00101235:
ADD R15,0x1
ADD R12,0x8
MOV RAX,qword ptr [RSP + 0x20]
CMP R15,RAX
JZ 0x0010126f
LAB_00101247:
MOV dword ptr [RSP + 0x8],R15D
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX + R15*0x4]
MOV dword ptr [RSP + 0xc],EAX
MOV EBX,EAX
SUB EBX,0x1
JS 0x00101235
MOVSXD RBP,EBX
SHL RBP,0x2
JMP 0x00101229
LAB_00101269:
MOV R14D,0x0
LAB_0010126f:
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX],R14D
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void * func0(long *param_1,int param_2,long param_3,int param_4,int *param_5)
{
void *pvVar1;
int4 *puVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
pvVar1 = malloc(800);
if (param_2 < 1) {
iVar5 = 0;
}
else {
lVar6 = 0;
iVar5 = 0;
do {
iVar3 = *(int *)(param_3 + lVar6 * 4) + -1;
if (-1 < iVar3) {
lVar4 = (long)iVar3 << 2;
do {
if (*(int *)(*param_1 + lVar4) == param_4) {
puVar2 = (int4 *)malloc(8);
*(int4 **)((long)pvVar1 + (long)iVar5 * 8) = puVar2;
*puVar2 = (int)lVar6;
puVar2[1] = iVar3;
iVar5 = iVar5 + 1;
}
iVar3 = iVar3 + -1;
lVar4 = lVar4 + -4;
} while (iVar3 != -1);
}
lVar6 = lVar6 + 1;
param_1 = param_1 + 1;
} while (lVar6 != param_2);
}
*param_5 = iVar5;
return pvVar1;
}
|
1,006 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)malloc(2 * sizeof(int));
out[count][0] = i;
out[count][1] = j;
count++;
}
}
}
*return_size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
for (int i = 0; i < size; ++i) {
free(result[i]);
}
free(result);
}
int main() {
int rows, returnSize;
int **result;
// Test case 1
rows = 3;
int cols1[] = {6, 6, 6};
int *lst1[] = {(const int[]){1,2,3,4,5,6}, (const int[]){1,2,3,4,1,6}, (const int[]){1,2,3,4,5,1}};
int *expected1[] = {(const int[]){0, 0}, (const int[]){1, 4}, (const int[]){1, 0}, (const int[]){2, 5}, (const int[]){2, 0}};
result = func0(lst1, rows, cols1, 1, &returnSize);
assert(issame(result, returnSize, expected1, 5));
free_result(result, returnSize);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %ecx,%r13d
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x38,%rsp
mov %rdi,0x20(%rsp)
mov $0x320,%edi
mov %rdx,0x10(%rsp)
mov %r8,0x28(%rsp)
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 1498 <func0+0xc8>
lea -0x1(%rbx),%eax
xor %r14d,%r14d
xor %r15d,%r15d
mov %rax,0x18(%rsp)
nopl 0x0(%rax,%rax,1)
mov 0x10(%rsp),%rax
mov %r14d,%ebx
mov (%rax,%r14,4),%eax
mov %eax,%edx
mov %eax,0x4(%rsp)
sub $0x1,%edx
js 1488 <func0+0xb8>
mov 0x20(%rsp),%rax
movslq %edx,%r12
mov (%rax,%r14,8),%rbp
jmp 1451 <func0+0x81>
nopl (%rax)
sub $0x1,%r12
test %r12d,%r12d
js 1488 <func0+0xb8>
cmp %r13d,0x0(%rbp,%r12,4)
jne 1448 <func0+0x78>
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov 0x8(%rsp),%rcx
movslq %r15d,%rdi
add $0x1,%r15d
mov %r12d,0x4(%rax)
sub $0x1,%r12
mov %rax,(%rcx,%rdi,8)
mov %ebx,(%rax)
test %r12d,%r12d
jns 1451 <func0+0x81>
nopl 0x0(%rax)
lea 0x1(%r14),%rax
cmp %r14,0x18(%rsp)
je 149b <func0+0xcb>
mov %rax,%r14
jmp 1420 <func0+0x50>
xor %r15d,%r15d
mov 0x28(%rsp),%rax
mov %r15d,(%rax)
mov 0x8(%rsp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, ecx
push rbp
push rbx
mov ebx, esi
sub rsp, 38h
mov [rsp+68h+var_48], rdi
mov edi, 320h; size
mov [rsp+68h+var_58], rdx
mov [rsp+68h+var_40], r8
call _malloc
mov [rsp+68h+var_60], rax
test ebx, ebx
jle loc_145A
movsxd rax, ebx
xor r14d, r14d
xor r15d, r15d
mov [rsp+68h+var_50], rax
nop dword ptr [rax+rax+00h]
loc_13D0:
mov rax, [rsp+68h+var_58]
mov ebx, r14d
mov eax, [rax+r14*4]
mov edx, eax
mov [rsp+68h+var_64], eax
sub edx, 1
js short loc_1430
mov rax, [rsp+68h+var_48]
movsxd rbp, edx
mov r13, [rax+r14*8]
jmp short loc_1400
loc_13F8:
sub rbp, 1
test ebp, ebp
js short loc_1430
loc_1400:
cmp [r13+rbp*4+0], r12d
jnz short loc_13F8
mov edi, 8; size
call _malloc
mov rcx, [rsp+68h+var_60]
movsxd rdi, r15d
add r15d, 1
mov [rax+4], ebp
sub rbp, 1
mov [rcx+rdi*8], rax
mov [rax], ebx
test ebp, ebp
jns short loc_1400
xchg ax, ax
loc_1430:
mov rax, [rsp+68h+var_50]
add r14, 1
cmp r14, rax
jnz short loc_13D0
loc_143E:
mov rax, [rsp+68h+var_40]
mov [rax], r15d
mov rax, [rsp+68h+var_60]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_145A:
xor r15d, r15d
jmp short loc_143E
|
_QWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
long long v6; // r14
int v7; // r15d
int v8; // edx
long long v9; // rbp
long long v10; // r13
_DWORD *v11; // rax
long long v12; // rdi
_QWORD *v14; // [rsp+8h] [rbp-60h]
v14 = malloc(0x320uLL);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v6 = 0LL;
v7 = 0;
do
{
v8 = *(_DWORD *)(a3 + 4 * v6) - 1;
if ( v8 >= 0 )
{
v9 = v8;
v10 = *(_QWORD *)(a1 + 8 * v6);
do
{
while ( *(_DWORD *)(v10 + 4 * v9) != a4 )
{
if ( (int)--v9 < 0 )
goto LABEL_8;
}
v11 = malloc(8uLL);
v12 = v7++;
v11[1] = v9--;
v14[v12] = v11;
*v11 = v6;
}
while ( (int)v9 >= 0 );
}
LABEL_8:
++v6;
}
while ( v6 != a2 );
}
*a5 = v7;
return v14;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ECX
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV EDI,0x320
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x28],R8
CALL 0x001010b0
MOV qword ptr [RSP + 0x8],RAX
TEST EBX,EBX
JLE 0x0010145a
MOVSXD RAX,EBX
XOR R14D,R14D
XOR R15D,R15D
MOV qword ptr [RSP + 0x18],RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
MOV RAX,qword ptr [RSP + 0x10]
MOV EBX,R14D
MOV EAX,dword ptr [RAX + R14*0x4]
MOV EDX,EAX
MOV dword ptr [RSP + 0x4],EAX
SUB EDX,0x1
JS 0x00101430
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RBP,EDX
MOV R13,qword ptr [RAX + R14*0x8]
JMP 0x00101400
LAB_001013f8:
SUB RBP,0x1
TEST EBP,EBP
JS 0x00101430
LAB_00101400:
CMP dword ptr [R13 + RBP*0x4],R12D
JNZ 0x001013f8
MOV EDI,0x8
CALL 0x001010b0
MOV RCX,qword ptr [RSP + 0x8]
MOVSXD RDI,R15D
ADD R15D,0x1
MOV dword ptr [RAX + 0x4],EBP
SUB RBP,0x1
MOV qword ptr [RCX + RDI*0x8],RAX
MOV dword ptr [RAX],EBX
TEST EBP,EBP
JNS 0x00101400
NOP
LAB_00101430:
MOV RAX,qword ptr [RSP + 0x18]
ADD R14,0x1
CMP R14,RAX
JNZ 0x001013d0
LAB_0010143e:
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX],R15D
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010145a:
XOR R15D,R15D
JMP 0x0010143e
|
void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
void *pvVar2;
int4 *puVar3;
int iVar4;
long lVar5;
long lVar6;
long lVar7;
int iVar8;
pvVar2 = malloc(800);
if (param_2 < 1) {
iVar8 = 0;
}
else {
lVar7 = 0;
iVar8 = 0;
do {
iVar4 = *(int *)(param_3 + lVar7 * 4) + -1;
if (-1 < iVar4) {
lVar5 = (long)iVar4;
lVar1 = *(long *)(param_1 + lVar7 * 8);
do {
while (*(int *)(lVar1 + lVar5 * 4) == param_4) {
puVar3 = (int4 *)malloc(8);
lVar6 = (long)iVar8;
iVar8 = iVar8 + 1;
puVar3[1] = (int)lVar5;
lVar5 = lVar5 + -1;
*(int4 **)((long)pvVar2 + lVar6 * 8) = puVar3;
*puVar3 = (int)lVar7;
if ((int)lVar5 < 0) goto LAB_00101430;
}
lVar5 = lVar5 + -1;
} while (-1 < (int)lVar5);
}
LAB_00101430:
lVar7 = lVar7 + 1;
} while (lVar7 != param_2);
}
*param_5 = iVar8;
return pvVar2;
}
|
1,007 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)malloc(2 * sizeof(int));
out[count][0] = i;
out[count][1] = j;
count++;
}
}
}
*return_size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
for (int i = 0; i < size; ++i) {
free(result[i]);
}
free(result);
}
int main() {
int rows, returnSize;
int **result;
// Test case 1
rows = 3;
int cols1[] = {6, 6, 6};
int *lst1[] = {(const int[]){1,2,3,4,5,6}, (const int[]){1,2,3,4,1,6}, (const int[]){1,2,3,4,5,1}};
int *expected1[] = {(const int[]){0, 0}, (const int[]){1, 4}, (const int[]){1, 0}, (const int[]){2, 5}, (const int[]){2, 0}};
result = func0(lst1, rows, cols1, 1, &returnSize);
assert(issame(result, returnSize, expected1, 5));
free_result(result, returnSize);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %ecx,%r13d
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x38,%rsp
mov %rdi,0x20(%rsp)
mov $0x320,%edi
mov %rdx,0x10(%rsp)
mov %r8,0x28(%rsp)
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 14a8 <func0+0xc8>
lea -0x1(%rbx),%eax
xor %r14d,%r14d
xor %r15d,%r15d
mov %rax,0x18(%rsp)
nopl 0x0(%rax,%rax,1)
mov 0x10(%rsp),%rax
mov %r14d,%ebx
mov (%rax,%r14,4),%eax
mov %eax,%edx
mov %eax,0x4(%rsp)
sub $0x1,%edx
js 1498 <func0+0xb8>
mov 0x20(%rsp),%rax
movslq %edx,%r12
mov (%rax,%r14,8),%rbp
jmp 1461 <func0+0x81>
nopl (%rax)
sub $0x1,%r12
test %r12d,%r12d
js 1498 <func0+0xb8>
cmp %r13d,0x0(%rbp,%r12,4)
jne 1458 <func0+0x78>
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov 0x8(%rsp),%rcx
movslq %r15d,%rdi
add $0x1,%r15d
mov %r12d,0x4(%rax)
sub $0x1,%r12
mov %rax,(%rcx,%rdi,8)
mov %ebx,(%rax)
test %r12d,%r12d
jns 1461 <func0+0x81>
nopl 0x0(%rax)
lea 0x1(%r14),%rax
cmp %r14,0x18(%rsp)
je 14ab <func0+0xcb>
mov %rax,%r14
jmp 1430 <func0+0x50>
xor %r15d,%r15d
mov 0x28(%rsp),%rax
mov %r15d,(%rax)
mov 0x8(%rsp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
mov r14d, ecx
push r13
push r12
mov r12d, esi
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_48], rdi
mov edi, 320h; size
mov [rsp+68h+var_58], rdx
mov [rsp+68h+var_40], r8
call _malloc
mov [rsp+68h+var_60], rax
test r12d, r12d
jle loc_13E7
movsxd rax, r12d
xor r15d, r15d
xor r12d, r12d
mov [rsp+68h+var_50], rax
nop dword ptr [rax]
loc_1360:
mov rax, [rsp+68h+var_58]
mov ebx, r12d
mov eax, [rax+r12*4]
mov edx, eax
mov [rsp+68h+var_64], eax
sub edx, 1
js short loc_13C0
mov rax, [rsp+68h+var_48]
movsxd rbp, edx
mov r13, [rax+r12*8]
jmp short loc_1390
loc_1388:
sub rbp, 1
test ebp, ebp
js short loc_13C0
loc_1390:
cmp [r13+rbp*4+0], r14d
jnz short loc_1388
mov edi, 8; size
call _malloc
mov rcx, [rsp+68h+var_60]
movsxd rdi, r15d
add r15d, 1
mov [rax+4], ebp
sub rbp, 1
mov [rcx+rdi*8], rax
mov [rax], ebx
test ebp, ebp
jns short loc_1390
xchg ax, ax
loc_13C0:
add r12, 1
cmp [rsp+68h+var_50], r12
jnz short loc_1360
loc_13CB:
mov rax, [rsp+68h+var_40]
mov [rax], r15d
mov rax, [rsp+68h+var_60]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13E7:
xor r15d, r15d
jmp short loc_13CB
|
_QWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v6; // r15d
long long i; // r12
int v8; // edx
long long v9; // rbp
long long v10; // r13
_DWORD *v11; // rax
long long v12; // rdi
_QWORD *v14; // [rsp+8h] [rbp-60h]
v14 = malloc(0x320uLL);
if ( a2 <= 0 )
{
v6 = 0;
}
else
{
v6 = 0;
for ( i = 0LL; i != a2; ++i )
{
v8 = *(_DWORD *)(a3 + 4 * i) - 1;
if ( v8 >= 0 )
{
v9 = v8;
v10 = *(_QWORD *)(a1 + 8 * i);
do
{
while ( *(_DWORD *)(v10 + 4 * v9) != a4 )
{
if ( (int)--v9 < 0 )
goto LABEL_8;
}
v11 = malloc(8uLL);
v12 = v6++;
v11[1] = v9--;
v14[v12] = v11;
*v11 = i;
}
while ( (int)v9 >= 0 );
}
LABEL_8:
;
}
}
*a5 = v6;
return v14;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ECX
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV EDI,0x320
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x28],R8
CALL 0x001010b0
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x001013e7
MOVSXD RAX,R12D
XOR R15D,R15D
XOR R12D,R12D
MOV qword ptr [RSP + 0x18],RAX
NOP dword ptr [RAX]
LAB_00101360:
MOV RAX,qword ptr [RSP + 0x10]
MOV EBX,R12D
MOV EAX,dword ptr [RAX + R12*0x4]
MOV EDX,EAX
MOV dword ptr [RSP + 0x4],EAX
SUB EDX,0x1
JS 0x001013c0
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RBP,EDX
MOV R13,qword ptr [RAX + R12*0x8]
JMP 0x00101390
LAB_00101388:
SUB RBP,0x1
TEST EBP,EBP
JS 0x001013c0
LAB_00101390:
CMP dword ptr [R13 + RBP*0x4],R14D
JNZ 0x00101388
MOV EDI,0x8
CALL 0x001010b0
MOV RCX,qword ptr [RSP + 0x8]
MOVSXD RDI,R15D
ADD R15D,0x1
MOV dword ptr [RAX + 0x4],EBP
SUB RBP,0x1
MOV qword ptr [RCX + RDI*0x8],RAX
MOV dword ptr [RAX],EBX
TEST EBP,EBP
JNS 0x00101390
NOP
LAB_001013c0:
ADD R12,0x1
CMP qword ptr [RSP + 0x18],R12
JNZ 0x00101360
LAB_001013cb:
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX],R15D
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013e7:
XOR R15D,R15D
JMP 0x001013cb
|
void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
void *pvVar2;
int4 *puVar3;
int iVar4;
long lVar5;
long lVar6;
long lVar7;
int iVar8;
pvVar2 = malloc(800);
if (param_2 < 1) {
iVar8 = 0;
}
else {
iVar8 = 0;
lVar7 = 0;
do {
iVar4 = *(int *)(param_3 + lVar7 * 4) + -1;
if (-1 < iVar4) {
lVar5 = (long)iVar4;
lVar1 = *(long *)(param_1 + lVar7 * 8);
do {
while (*(int *)(lVar1 + lVar5 * 4) == param_4) {
puVar3 = (int4 *)malloc(8);
lVar6 = (long)iVar8;
iVar8 = iVar8 + 1;
puVar3[1] = (int)lVar5;
lVar5 = lVar5 + -1;
*(int4 **)((long)pvVar2 + lVar6 * 8) = puVar3;
*puVar3 = (int)lVar7;
if ((int)lVar5 < 0) goto LAB_001013c0;
}
lVar5 = lVar5 + -1;
} while (-1 < (int)lVar5);
}
LAB_001013c0:
lVar7 = lVar7 + 1;
} while (param_2 != lVar7);
}
*param_5 = iVar8;
return pvVar2;
}
|
1,008 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_array)[i] = array[i];
}
int shouldSortAscending = (array[0] + array[size - 1]) % 2 == 1;
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (shouldSortAscending) {
if ((*out_array)[i] > (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
} else {
if ((*out_array)[i] < (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &result, &result_size);
assert(issame(result, result_size, (const int[]){}, 0));
free(result);
func0((const int[]){5}, 1, &result, &result_size);
assert(issame(result, result_size, (const int[]){5}, 1));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 1, 2, 3, 4, 5}, 6));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5, 6}, 7, &result, &result_size);
assert(issame(result, result_size, (const int[]){6, 5, 4, 3, 2, 1, 0}, 7));
free(result);
func0((const int[]){2, 1}, 2, &result, &result_size);
assert(issame(result, result_size, (const int[]){1, 2}, 2));
free(result);
func0((const int[]){15, 42, 87, 32, 11, 0}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 11, 15, 32, 42, 87}, 6));
free(result);
func0((const int[]){21, 14, 23, 11}, 4, &result, &result_size);
assert(issame(result, result_size, (const int[]){23, 21, 14, 11}, 4));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %rcx,-0x40(%rbp)
mov -0x40(%rbp),%rax
mov -0x2c(%rbp),%edx
mov %edx,(%rax)
cmpl $0x0,-0x2c(%rbp)
jne 1203 <func0+0x3a>
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
jmpq 141f <func0+0x256>
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10c0 <malloc@plt>
mov %rax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,(%rax)
mov -0x38(%rbp),%rax
mov (%rax),%rax
test %rax,%rax
jne 1234 <func0+0x6b>
mov $0x1,%edi
callq 10d0 <exit@plt>
movl $0x0,-0x18(%rbp)
jmp 126e <func0+0xa5>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 123d <func0+0x74>
mov -0x28(%rbp),%rax
mov (%rax),%edx
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
shr $0x1f,%eax
add %eax,%edx
and $0x1,%edx
sub %eax,%edx
mov %edx,%eax
cmp $0x1,%eax
sete %al
movzbl %al,%eax
mov %eax,-0xc(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 1410 <func0+0x247>
mov -0x14(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
jmpq 1400 <func0+0x237>
cmpl $0x0,-0xc(%rbp)
je 136d <func0+0x1a4>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x10(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 13fc <func0+0x233>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea (%rax,%rdx,1),%rcx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
jmpq 13fc <func0+0x233>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x10(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 13fc <func0+0x233>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea (%rax,%rdx,1),%rcx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov -0x8(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 12cb <func0+0x102>
addl $0x1,-0x14(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jl 12bd <func0+0xf4>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov rax, [rbp+var_40]
mov edx, [rbp+var_2C]
mov [rax], edx
cmp [rbp+var_2C], 0
jnz short loc_1203
mov rax, [rbp+var_38]
mov qword ptr [rax], 0
jmp locret_141F
loc_1203:
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_38]
mov [rax], rdx
mov rax, [rbp+var_38]
mov rax, [rax]
test rax, rax
jnz short loc_1234
mov edi, 1; status
call _exit
loc_1234:
mov [rbp+var_18], 0
jmp short loc_126E
loc_123D:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_18]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_18], 1
loc_126E:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_123D
mov rax, [rbp+var_28]
mov edx, [rax]
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
add edx, eax
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
setz al
movzx eax, al
mov [rbp+var_C], eax
mov [rbp+var_14], 0
jmp loc_1410
loc_12BD:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_10], eax
jmp loc_1400
loc_12CB:
cmp [rbp+var_C], 0
jz loc_136D
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_10]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle loc_13FC
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
lea rcx, [rax+rdx]
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
jmp loc_13FC
loc_136D:
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_10]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_13FC
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
lea rcx, [rax+rdx]
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rbp+var_8]
mov [rdx], eax
loc_13FC:
add [rbp+var_10], 1
loc_1400:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl loc_12CB
add [rbp+var_14], 1
loc_1410:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_14], eax
jl loc_12BD
locret_141F:
leave
retn
|
void ** func0(_DWORD *a1, int a2, void **a3, int *a4)
{
void **result; // rax
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
int k; // [rsp+30h] [rbp-10h]
_BOOL4 v9; // [rsp+34h] [rbp-Ch]
int v10; // [rsp+38h] [rbp-8h]
int v11; // [rsp+3Ch] [rbp-4h]
*a4 = a2;
if ( a2 )
{
*a3 = malloc(4LL * a2);
if ( !*a3 )
exit(1);
for ( i = 0; i < a2; ++i )
*((_DWORD *)*a3 + i) = a1[i];
v9 = (a1[a2 - 1] + *a1) % 2 == 1;
for ( j = 0; ; ++j )
{
result = (void **)(unsigned int)(a2 - 1);
if ( j >= (int)result )
break;
for ( k = j + 1; k < a2; ++k )
{
if ( v9 )
{
if ( *((_DWORD *)*a3 + j) > *((_DWORD *)*a3 + k) )
{
v11 = *((_DWORD *)*a3 + j);
*((_DWORD *)*a3 + j) = *((_DWORD *)*a3 + k);
*((_DWORD *)*a3 + k) = v11;
}
}
else if ( *((_DWORD *)*a3 + j) < *((_DWORD *)*a3 + k) )
{
v10 = *((_DWORD *)*a3 + j);
*((_DWORD *)*a3 + j) = *((_DWORD *)*a3 + k);
*((_DWORD *)*a3 + k) = v10;
}
}
}
}
else
{
result = a3;
*a3 = 0LL;
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],EDX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00101203
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],0x0
JMP 0x0010141f
LAB_00101203:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JNZ 0x00101234
MOV EDI,0x1
CALL 0x001010d0
LAB_00101234:
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010126e
LAB_0010123d:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x18],0x1
LAB_0010126e:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010123d
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EDX,EAX
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
SETZ AL
MOVZX EAX,AL
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101410
LAB_001012bd:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00101400
LAB_001012cb:
CMP dword ptr [RBP + -0xc],0x0
JZ 0x0010136d
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x10]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001013fc
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
LEA RCX,[RAX + RDX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
JMP 0x001013fc
LAB_0010136d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x10]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001013fc
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
LEA RCX,[RAX + RDX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
LAB_001013fc:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101400:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001012cb
ADD dword ptr [RBP + -0x14],0x1
LAB_00101410:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x001012bd
LAB_0010141f:
LEAVE
RET
|
void func0(int *param_1,int param_2,long *param_3,int *param_4)
{
int iVar1;
int iVar2;
int4 uVar3;
void *pvVar4;
int local_20;
int local_1c;
int local_18;
*param_4 = param_2;
if (param_2 == 0) {
*param_3 = 0;
}
else {
pvVar4 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar4;
if (*param_3 == 0) {
/* WARNING: Subroutine does not return */
exit(1);
}
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
*(int *)((long)local_20 * 4 + *param_3) = param_1[local_20];
}
iVar1 = *param_1;
iVar2 = param_1[(long)param_2 + -1];
for (local_1c = 0; local_18 = local_1c, local_1c < param_2 + -1; local_1c = local_1c + 1) {
while (local_18 = local_18 + 1, local_18 < param_2) {
if ((iVar1 + iVar2) % 2 == 1) {
if (*(int *)(*param_3 + (long)local_18 * 4) < *(int *)(*param_3 + (long)local_1c * 4)) {
uVar3 = *(int4 *)(*param_3 + (long)local_1c * 4);
*(int4 *)((long)local_1c * 4 + *param_3) =
*(int4 *)(*param_3 + (long)local_18 * 4);
*(int4 *)((long)local_18 * 4 + *param_3) = uVar3;
}
}
else if (*(int *)(*param_3 + (long)local_1c * 4) < *(int *)(*param_3 + (long)local_18 * 4))
{
uVar3 = *(int4 *)(*param_3 + (long)local_1c * 4);
*(int4 *)((long)local_1c * 4 + *param_3) =
*(int4 *)(*param_3 + (long)local_18 * 4);
*(int4 *)((long)local_18 * 4 + *param_3) = uVar3;
}
}
}
}
return;
}
|
1,009 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_array)[i] = array[i];
}
int shouldSortAscending = (array[0] + array[size - 1]) % 2 == 1;
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (shouldSortAscending) {
if ((*out_array)[i] > (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
} else {
if ((*out_array)[i] < (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &result, &result_size);
assert(issame(result, result_size, (const int[]){}, 0));
free(result);
func0((const int[]){5}, 1, &result, &result_size);
assert(issame(result, result_size, (const int[]){5}, 1));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 1, 2, 3, 4, 5}, 6));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5, 6}, 7, &result, &result_size);
assert(issame(result, result_size, (const int[]){6, 5, 4, 3, 2, 1, 0}, 7));
free(result);
func0((const int[]){2, 1}, 2, &result, &result_size);
assert(issame(result, result_size, (const int[]){1, 2}, 2));
free(result);
func0((const int[]){15, 42, 87, 32, 11, 0}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 11, 15, 32, 42, 87}, 6));
free(result);
func0((const int[]){21, 14, 23, 11}, 4, &result, &result_size);
assert(issame(result, result_size, (const int[]){23, 21, 14, 11}, 4));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdx,%rbx
mov %esi,(%rcx)
test %esi,%esi
jne 11f2 <func0+0x29>
movq $0x0,(%rdx)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %rdi,%r12
mov %esi,%ebp
movslq %esi,%r13
shl $0x2,%r13
mov %r13,%rdi
callq 10c0 <malloc@plt>
mov %rax,(%rbx)
test %rax,%rax
je 126d <func0+0xa4>
test %ebp,%ebp
jle 1235 <func0+0x6c>
lea -0x1(%rbp),%eax
lea 0x4(,%rax,4),%rsi
mov $0x0,%eax
mov (%r12,%rax,1),%ecx
mov (%rbx),%rdx
mov %ecx,(%rdx,%rax,1)
add $0x4,%rax
cmp %rsi,%rax
jne 1222 <func0+0x59>
mov (%r12),%eax
add -0x4(%r12,%r13,1),%eax
mov %eax,%edx
shr $0x1f,%edx
lea (%rax,%rdx,1),%r9d
and $0x1,%r9d
sub %edx,%r9d
cmp $0x1,%ebp
jle 11e7 <func0+0x1e>
lea -0x1(%rbp),%r13d
mov %r13d,%r12d
mov $0x0,%edi
mov $0x0,%r11d
mov $0x0,%r10d
jmp 12c9 <func0+0x100>
mov $0x1,%edi
callq 10d0 <exit@plt>
mov (%rbx),%rdx
lea (%rdx,%rdi,1),%rsi
mov (%rsi),%ecx
mov (%rdx,%rax,1),%edx
cmp %edx,%ecx
jle 128f <func0+0xc6>
mov %edx,(%rsi)
mov (%rbx),%rdx
mov %ecx,(%rdx,%rax,1)
add $0x4,%rax
cmp %r8,%rax
je 12b8 <func0+0xef>
cmp $0x1,%r9d
je 1277 <func0+0xae>
mov (%rbx),%rdx
lea (%rdx,%rdi,1),%rsi
mov (%rsi),%ecx
mov (%rdx,%rax,1),%edx
cmp %edx,%ecx
jge 128f <func0+0xc6>
mov %edx,(%rsi)
mov (%rbx),%rdx
mov %ecx,(%rdx,%rax,1)
jmp 128f <func0+0xc6>
add $0x1,%r11
add $0x4,%rdi
cmp %r12d,%r10d
je 11e7 <func0+0x1e>
add $0x1,%r10d
cmp %r10d,%ebp
jle 12b8 <func0+0xef>
lea 0x4(%rdi),%rax
mov %r13d,%edx
sub %r10d,%edx
lea 0x2(%r11,%rdx,1),%r8
shl $0x2,%r8
jmp 1298 <func0+0xcf>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdx
mov [rcx], esi
test esi, esi
jnz short loc_11F2
mov qword ptr [rdx], 0
loc_11E7:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11F2:
mov r12, rdi
mov ebp, esi
movsxd r13, esi
shl r13, 2
mov rdi, r13; size
call _malloc
mov [rbx], rax
test rax, rax
jz short loc_125F
mov eax, 0
test ebp, ebp
jle short loc_11E7
loc_1217:
mov ecx, [r12+rax]
mov rdx, [rbx]
mov [rdx+rax], ecx
add rax, 4
cmp r13, rax
jnz short loc_1217
mov eax, [r12]
add eax, [r12+r13-4]
mov edx, eax
shr edx, 1Fh
lea r9d, [rax+rdx]
and r9d, 1
sub r9d, edx
cmp ebp, 1
jle short loc_11E7
lea r12d, [rbp-1]
mov edi, 0
mov r11d, 0
mov r10d, 0
jmp short loc_12BB
loc_125F:
mov edi, 1; status
call _exit
loc_1269:
mov rdx, [rbx]
lea rsi, [rdx+rdi]
mov ecx, [rsi]
mov edx, [rdx+rax]
cmp ecx, edx
jle short loc_1281
mov [rsi], edx
mov rdx, [rbx]
mov [rdx+rax], ecx
loc_1281:
add rax, 4
cmp rax, r8
jz short loc_12AA
loc_128A:
cmp r9d, 1
jz short loc_1269
mov rdx, [rbx]
lea rsi, [rdx+rdi]
mov ecx, [rsi]
mov edx, [rdx+rax]
cmp ecx, edx
jge short loc_1281
mov [rsi], edx
mov rdx, [rbx]
mov [rdx+rax], ecx
jmp short loc_1281
loc_12AA:
add r11, 1
add rdi, 4
cmp r10d, r12d
jz loc_11E7
loc_12BB:
add r10d, 1
cmp ebp, r10d
jle short loc_12AA
lea rax, [rdi+4]
mov edx, r12d
sub edx, r10d
lea r8, [r11+rdx+2]
shl r8, 2
jmp short loc_128A
|
void func0(_DWORD *a1, int a2, _QWORD *a3, int *a4)
{
size_t v6; // r13
void *v7; // rax
unsigned long long v8; // rax
int v9; // r9d
int v10; // r12d
long long v11; // rdi
long long v12; // r11
int v13; // r10d
int *v14; // rsi
int v15; // ecx
int v16; // edx
long long v17; // rax
int *v18; // rsi
int v19; // ecx
int v20; // edx
*a4 = a2;
if ( a2 )
{
v6 = 4LL * a2;
v7 = malloc(v6);
*a3 = v7;
if ( !v7 )
exit(1);
v8 = 0LL;
if ( a2 > 0 )
{
do
{
*(_DWORD *)(*a3 + v8) = a1[v8 / 4];
v8 += 4LL;
}
while ( v6 != v8 );
v9 = (a1[v6 / 4 - 1] + *a1) % 2;
if ( a2 > 1 )
{
v10 = a2 - 1;
v11 = 0LL;
v12 = 0LL;
v13 = 0;
do
{
if ( a2 > ++v13 )
{
v17 = v11 + 4;
do
{
if ( v9 == 1 )
{
v14 = (int *)(*a3 + v11);
v15 = *v14;
v16 = *(_DWORD *)(*a3 + v17);
if ( *v14 > v16 )
{
*v14 = v16;
*(_DWORD *)(*a3 + v17) = v15;
}
}
else
{
v18 = (int *)(*a3 + v11);
v19 = *v18;
v20 = *(_DWORD *)(*a3 + v17);
if ( *v18 < v20 )
{
*v18 = v20;
*(_DWORD *)(*a3 + v17) = v19;
}
}
v17 += 4LL;
}
while ( v17 != 4 * (v12 + (unsigned int)(v10 - v13) + 2) );
}
++v12;
v11 += 4LL;
}
while ( v13 != v10 );
}
}
}
else
{
*a3 = 0LL;
}
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDX
MOV dword ptr [RCX],ESI
TEST ESI,ESI
JNZ 0x001011f2
MOV qword ptr [RDX],0x0
LAB_001011e7:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011f2:
MOV R12,RDI
MOV EBP,ESI
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010c0
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JZ 0x0010125f
MOV EAX,0x0
TEST EBP,EBP
JLE 0x001011e7
LAB_00101217:
MOV ECX,dword ptr [R12 + RAX*0x1]
MOV RDX,qword ptr [RBX]
MOV dword ptr [RDX + RAX*0x1],ECX
ADD RAX,0x4
CMP R13,RAX
JNZ 0x00101217
MOV EAX,dword ptr [R12]
ADD EAX,dword ptr [R12 + R13*0x1 + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
LEA R9D,[RAX + RDX*0x1]
AND R9D,0x1
SUB R9D,EDX
CMP EBP,0x1
JLE 0x001011e7
LEA R12D,[RBP + -0x1]
MOV EDI,0x0
MOV R11D,0x0
MOV R10D,0x0
JMP 0x001012bb
LAB_0010125f:
MOV EDI,0x1
CALL 0x001010d0
LAB_00101269:
MOV RDX,qword ptr [RBX]
LEA RSI,[RDX + RDI*0x1]
MOV ECX,dword ptr [RSI]
MOV EDX,dword ptr [RDX + RAX*0x1]
CMP ECX,EDX
JLE 0x00101281
MOV dword ptr [RSI],EDX
MOV RDX,qword ptr [RBX]
MOV dword ptr [RDX + RAX*0x1],ECX
LAB_00101281:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001012aa
LAB_0010128a:
CMP R9D,0x1
JZ 0x00101269
MOV RDX,qword ptr [RBX]
LEA RSI,[RDX + RDI*0x1]
MOV ECX,dword ptr [RSI]
MOV EDX,dword ptr [RDX + RAX*0x1]
CMP ECX,EDX
JGE 0x00101281
MOV dword ptr [RSI],EDX
MOV RDX,qword ptr [RBX]
MOV dword ptr [RDX + RAX*0x1],ECX
JMP 0x00101281
LAB_001012aa:
ADD R11,0x1
ADD RDI,0x4
CMP R10D,R12D
JZ 0x001011e7
LAB_001012bb:
ADD R10D,0x1
CMP EBP,R10D
JLE 0x001012aa
LEA RAX,[RDI + 0x4]
MOV EDX,R12D
SUB EDX,R10D
LEA R8,[R11 + RDX*0x1 + 0x2]
SHL R8,0x2
JMP 0x0010128a
|
void func0(int *param_1,int param_2,long *param_3,int *param_4)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
void *pvVar6;
size_t sVar7;
long lVar8;
long lVar9;
int iVar10;
long lVar11;
size_t __size;
*param_4 = param_2;
if (param_2 == 0) {
*param_3 = 0;
}
else {
__size = (long)param_2 * 4;
pvVar6 = malloc(__size);
*param_3 = (long)pvVar6;
if (pvVar6 == (void *)0x0) {
/* WARNING: Subroutine does not return */
exit(1);
}
sVar7 = 0;
if (0 < param_2) {
do {
*(int4 *)(*param_3 + sVar7) = *(int4 *)((long)param_1 + sVar7);
sVar7 = sVar7 + 4;
} while (__size != sVar7);
iVar2 = *param_1;
iVar3 = param_1[(long)param_2 + -1];
if (1 < param_2) {
lVar9 = 0;
lVar11 = 0;
iVar10 = 0;
do {
iVar10 = iVar10 + 1;
if (iVar10 < param_2) {
lVar8 = lVar9 + 4;
do {
if ((iVar2 + iVar3) % 2 == 1) {
piVar1 = (int *)(*param_3 + lVar9);
iVar4 = *piVar1;
iVar5 = *(int *)(*param_3 + lVar8);
if (iVar5 < iVar4) {
*piVar1 = iVar5;
*(int *)(*param_3 + lVar8) = iVar4;
}
}
else {
piVar1 = (int *)(*param_3 + lVar9);
iVar4 = *piVar1;
iVar5 = *(int *)(*param_3 + lVar8);
if (iVar4 < iVar5) {
*piVar1 = iVar5;
*(int *)(*param_3 + lVar8) = iVar4;
}
}
lVar8 = lVar8 + 4;
} while (lVar8 != (lVar11 + 2 + (ulong)(uint)((param_2 + -1) - iVar10)) * 4);
}
lVar11 = lVar11 + 1;
lVar9 = lVar9 + 4;
} while (iVar10 != param_2 + -1);
}
}
}
return;
}
|
1,010 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_array)[i] = array[i];
}
int shouldSortAscending = (array[0] + array[size - 1]) % 2 == 1;
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (shouldSortAscending) {
if ((*out_array)[i] > (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
} else {
if ((*out_array)[i] < (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &result, &result_size);
assert(issame(result, result_size, (const int[]){}, 0));
free(result);
func0((const int[]){5}, 1, &result, &result_size);
assert(issame(result, result_size, (const int[]){5}, 1));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 1, 2, 3, 4, 5}, 6));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5, 6}, 7, &result, &result_size);
assert(issame(result, result_size, (const int[]){6, 5, 4, 3, 2, 1, 0}, 7));
free(result);
func0((const int[]){2, 1}, 2, &result, &result_size);
assert(issame(result, result_size, (const int[]){1, 2}, 2));
free(result);
func0((const int[]){15, 42, 87, 32, 11, 0}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 11, 15, 32, 42, 87}, 6));
free(result);
func0((const int[]){21, 14, 23, 11}, 4, &result, &result_size);
assert(issame(result, result_size, (const int[]){23, 21, 14, 11}, 4));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %esi,(%rcx)
test %esi,%esi
jne 1718 <func0+0x18>
movq $0x0,(%rdx)
retq
nopw 0x0(%rax,%rax,1)
jmpq 15d0 <func0.part.0>
nopl (%rax)
|
func0_part_0:
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, r13
shl r13, 2
mov rdi, r13; size
call _malloc
mov [rbp+0], rax
test rax, rax
jz loc_165D
test ebx, ebx
jle loc_1627
mov ebp, ebx
mov rsi, r14; src
lea r12d, [rbx-1]
mov rdi, rax; dest
lea rdx, ds:0[rbp*4]; n
call _memcpy
mov r11, rax
mov eax, [r14]
add eax, [r14+r13-4]
mov edx, eax
shr edx, 1Fh
lea r10d, [rax+rdx]
and r10d, 1
sub r10d, edx
cmp ebx, 1
jz short loc_1627
lea rsi, [r11+4]
mov r9d, 1
add r11, 8
nop dword ptr [rax+00h]
loc_15D0:
cmp ebx, r9d
jle short loc_161A
mov eax, r12d
mov edx, [rsi-4]
mov ecx, [rsi]
mov rdi, rsi
sub eax, r9d
lea rax, [r9+rax-1]
lea r8, [r11+rax*4]
mov rax, rsi
cmp r10d, 1
jnz short loc_1608
jmp short loc_1638
loc_1600:
mov edx, [rsi-4]
mov ecx, [rax]
mov rdi, rax
loc_1608:
cmp edx, ecx
jge short loc_1611
mov [rsi-4], ecx
mov [rdi], edx
loc_1611:
add rax, 4
cmp r8, rax
jnz short loc_1600
loc_161A:
add r9, 1
add rsi, 4
cmp r9, rbp
jnz short loc_15D0
loc_1627:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1630:
mov edx, [rsi-4]
mov ecx, [rax]
mov rdi, rax
loc_1638:
cmp edx, ecx
jle short loc_1641
mov [rsi-4], ecx
mov [rdi], edx
loc_1641:
add rax, 4
cmp r8, rax
jnz short loc_1630
add r9, 1
add rsi, 4
cmp r9, rbp
jnz loc_15D0
jmp short loc_1627
loc_165D:
mov edi, 1; status
call _exit
|
int * func0_part_0(char *src, int a2, int **a3)
{
size_t v5; // r13
int *result; // rax
int v7; // r12d
char *v8; // r11
int v9; // r10d
int *v10; // rsi
long long v11; // r9
char *v12; // r11
int v13; // edx
int v14; // ecx
int *v15; // rdi
char *v16; // r8
v5 = 4LL * a2;
result = (int *)malloc(v5);
*a3 = result;
if ( !result )
exit(1);
if ( a2 > 0 )
{
v7 = a2 - 1;
v8 = (char *)memcpy(result, src, 4LL * (unsigned int)a2);
result = (int *)(unsigned int)(*(_DWORD *)&src[v5 - 4] + *(_DWORD *)src);
v9 = (*(_DWORD *)&src[v5 - 4] + *(_DWORD *)src) % 2;
if ( a2 != 1 )
{
v10 = (int *)(v8 + 4);
v11 = 1LL;
v12 = v8 + 8;
do
{
while ( a2 <= (int)v11 )
{
LABEL_12:
++v11;
++v10;
if ( v11 == a2 )
return result;
}
v13 = *(v10 - 1);
v14 = *v10;
v15 = v10;
v16 = &v12[4 * v11 - 4 + 4 * (unsigned int)(v7 - v11)];
result = v10;
if ( v9 != 1 )
{
while ( 1 )
{
if ( v13 < v14 )
{
*(v10 - 1) = v14;
*v15 = v13;
}
if ( v16 == (char *)++result )
break;
v13 = *(v10 - 1);
v14 = *result;
v15 = result;
}
goto LABEL_12;
}
while ( 1 )
{
if ( v13 > v14 )
{
*(v10 - 1) = v14;
*v15 = v13;
}
if ( v16 == (char *)++result )
break;
v13 = *(v10 - 1);
v14 = *result;
v15 = result;
}
++v11;
++v10;
}
while ( v11 != a2 );
}
}
return result;
}
|
func0.part.0:
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,R13
SHL R13,0x2
MOV RDI,R13
CALL 0x001010e0
MOV qword ptr [RBP],RAX
TEST RAX,RAX
JZ 0x0010165d
TEST EBX,EBX
JLE 0x00101627
MOV EBP,EBX
MOV RSI,R14
LEA R12D,[RBX + -0x1]
MOV RDI,RAX
LEA RDX,[RBP*0x4]
CALL 0x001010d0
MOV R11,RAX
MOV EAX,dword ptr [R14]
ADD EAX,dword ptr [R14 + R13*0x1 + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
LEA R10D,[RAX + RDX*0x1]
AND R10D,0x1
SUB R10D,EDX
CMP EBX,0x1
JZ 0x00101627
LEA RSI,[R11 + 0x4]
MOV R9D,0x1
ADD R11,0x8
NOP dword ptr [RAX]
LAB_001015d0:
CMP EBX,R9D
JLE 0x0010161a
MOV EAX,R12D
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RSI]
MOV RDI,RSI
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA R8,[R11 + RAX*0x4]
MOV RAX,RSI
CMP R10D,0x1
JNZ 0x00101608
JMP 0x00101638
LAB_00101600:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
MOV RDI,RAX
LAB_00101608:
CMP EDX,ECX
JGE 0x00101611
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RDI],EDX
LAB_00101611:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101600
LAB_0010161a:
ADD R9,0x1
ADD RSI,0x4
CMP R9,RBP
JNZ 0x001015d0
LAB_00101627:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101630:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
MOV RDI,RAX
LAB_00101638:
CMP EDX,ECX
JLE 0x00101641
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RDI],EDX
LAB_00101641:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101630
ADD R9,0x1
ADD RSI,0x4
CMP R9,RBP
JNZ 0x001015d0
JMP 0x00101627
LAB_0010165d:
MOV EDI,0x1
CALL 0x001010f0
|
void func0_part_0(int *param_1,uint param_2,int8 *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
void *pvVar4;
int *piVar5;
int iVar6;
int iVar7;
ulong uVar8;
int *piVar9;
ulong uVar10;
pvVar4 = malloc((long)(int)param_2 * 4);
*param_3 = pvVar4;
if (pvVar4 == (void *)0x0) {
/* WARNING: Subroutine does not return */
exit(1);
}
if (0 < (int)param_2) {
uVar8 = (ulong)param_2;
pvVar4 = memcpy(pvVar4,param_1,uVar8 * 4);
iVar2 = *param_1;
iVar3 = param_1[(long)(int)param_2 + -1];
if (param_2 != 1) {
piVar9 = (int *)((long)pvVar4 + 4);
uVar10 = 1;
do {
while ((int)param_2 <= (int)uVar10) {
LAB_0010161a:
uVar10 = uVar10 + 1;
piVar9 = piVar9 + 1;
if (uVar10 == uVar8) {
return;
}
}
iVar7 = piVar9[-1];
iVar6 = *piVar9;
piVar1 = (int *)((long)pvVar4 +
((uVar10 - 1) + (ulong)((param_2 - 1) - (int)uVar10)) * 4 + 8);
piVar5 = piVar9;
if ((iVar2 + iVar3) % 2 != 1) {
while( true ) {
if (iVar7 < iVar6) {
piVar9[-1] = iVar6;
*piVar5 = iVar7;
}
piVar5 = piVar5 + 1;
if (piVar1 == piVar5) break;
iVar7 = piVar9[-1];
iVar6 = *piVar5;
}
goto LAB_0010161a;
}
while( true ) {
if (iVar6 < iVar7) {
piVar9[-1] = iVar6;
*piVar5 = iVar7;
}
piVar5 = piVar5 + 1;
if (piVar1 == piVar5) break;
iVar7 = piVar9[-1];
iVar6 = *piVar5;
}
uVar10 = uVar10 + 1;
piVar9 = piVar9 + 1;
if (uVar10 == uVar8) {
return;
}
} while( true );
}
}
return;
}
|
1,011 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_array)[i] = array[i];
}
int shouldSortAscending = (array[0] + array[size - 1]) % 2 == 1;
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (shouldSortAscending) {
if ((*out_array)[i] > (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
} else {
if ((*out_array)[i] < (*out_array)[j]) {
int temp = (*out_array)[i];
(*out_array)[i] = (*out_array)[j];
(*out_array)[j] = temp;
}
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &result, &result_size);
assert(issame(result, result_size, (const int[]){}, 0));
free(result);
func0((const int[]){5}, 1, &result, &result_size);
assert(issame(result, result_size, (const int[]){5}, 1));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 1, 2, 3, 4, 5}, 6));
free(result);
func0((const int[]){2, 4, 3, 0, 1, 5, 6}, 7, &result, &result_size);
assert(issame(result, result_size, (const int[]){6, 5, 4, 3, 2, 1, 0}, 7));
free(result);
func0((const int[]){2, 1}, 2, &result, &result_size);
assert(issame(result, result_size, (const int[]){1, 2}, 2));
free(result);
func0((const int[]){15, 42, 87, 32, 11, 0}, 6, &result, &result_size);
assert(issame(result, result_size, (const int[]){0, 11, 15, 32, 42, 87}, 6));
free(result);
func0((const int[]){21, 14, 23, 11}, 4, &result, &result_size);
assert(issame(result, result_size, (const int[]){23, 21, 14, 11}, 4));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov %esi,(%rcx)
test %esi,%esi
jne 16b8 <func0+0x18>
movq $0x0,(%rdx)
retq
nopw 0x0(%rax,%rax,1)
jmpq 1570 <func0.part.0>
nopl (%rax)
|
func0_part_0:
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, r13
shl r13, 2
mov rdi, r13; size
call _malloc
mov [rbp+0], rax
test rax, rax
jz loc_1676
test ebx, ebx
jle loc_1614
mov ebp, ebx
mov rsi, r14; src
lea r12d, [rbx-1]
mov rdi, rax; dest
lea rdx, ds:0[rbp*4]; n
call _memcpy
mov rcx, rax
mov eax, [r14]
add eax, [r14+r13-4]
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
cmp ebx, 1
jz short loc_1614
lea rsi, [rcx+4]
mov r8d, 1
lea r9, [rcx+8]
cmp eax, 1
jz short loc_1630
nop dword ptr [rax]
loc_15D0:
cmp ebx, r8d
jle short loc_1607
mov eax, r12d
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [r9+rax*4]
mov rax, rsi
nop word ptr [rax+rax+00000000h]
loc_15F0:
mov edx, [rsi-4]
mov ecx, [rax]
cmp ecx, edx
jle short loc_15FE
mov [rsi-4], ecx
mov [rax], edx
loc_15FE:
add rax, 4
cmp rax, rdi
jnz short loc_15F0
loc_1607:
add r8, 1
add rsi, 4
cmp r8, rbp
jnz short loc_15D0
loc_1614:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_161D:
add r8, 1
add rsi, 4
cmp r8, rbp
jz short loc_1614
nop word ptr [rax+rax+00h]
loc_1630:
cmp ebx, r8d
jle short loc_161D
mov eax, r12d
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [r9+rax*4]
mov rax, rsi
nop word ptr [rax+rax+00000000h]
loc_1650:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_165E
mov [rsi-4], ecx
mov [rax], edx
loc_165E:
add rax, 4
cmp rax, rdi
jnz short loc_1650
add r8, 1
add rsi, 4
cmp r8, rbp
jnz short loc_1630
jmp short loc_1614
loc_1676:
mov edi, 1; status
call _exit
|
long long func0_part_0(_DWORD *src, int a2, _QWORD *a3)
{
long long result; // rax
int v6; // r12d
char *v7; // rcx
long long v8; // rsi
long long v9; // r8
char *v10; // r9
int v11; // edx
int v12; // edx
result = (long long)malloc(4LL * a2);
*a3 = result;
if ( !result )
exit(1);
if ( a2 > 0 )
{
v6 = a2 - 1;
v7 = (char *)memcpy((void *)result, src, 4LL * (unsigned int)a2);
result = (unsigned int)((src[a2 - 1] + *src) % 2);
if ( a2 != 1 )
{
v8 = (long long)(v7 + 4);
v9 = 1LL;
v10 = v7 + 8;
if ( (_DWORD)result == 1 )
{
do
{
while ( a2 <= (int)v9 )
{
++v9;
v8 += 4LL;
if ( v9 == a2 )
return result;
}
result = v8;
do
{
v12 = *(_DWORD *)(v8 - 4);
if ( v12 > *(_DWORD *)result )
{
*(_DWORD *)(v8 - 4) = *(_DWORD *)result;
*(_DWORD *)result = v12;
}
result += 4LL;
}
while ( (char *)result != &v10[4 * v9 - 4 + 4 * (unsigned int)(v6 - v9)] );
++v9;
v8 += 4LL;
}
while ( v9 != a2 );
}
else
{
do
{
if ( a2 > (int)v9 )
{
result = v8;
do
{
v11 = *(_DWORD *)(v8 - 4);
if ( *(_DWORD *)result > v11 )
{
*(_DWORD *)(v8 - 4) = *(_DWORD *)result;
*(_DWORD *)result = v11;
}
result += 4LL;
}
while ( (char *)result != &v10[4 * v9 - 4 + 4 * (unsigned int)(v6 - v9)] );
}
++v9;
v8 += 4LL;
}
while ( v9 != a2 );
}
}
}
return result;
}
|
func0.part.0:
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,R13
SHL R13,0x2
MOV RDI,R13
CALL 0x001010e0
MOV qword ptr [RBP],RAX
TEST RAX,RAX
JZ 0x00101676
TEST EBX,EBX
JLE 0x00101614
MOV EBP,EBX
MOV RSI,R14
LEA R12D,[RBX + -0x1]
MOV RDI,RAX
LEA RDX,[RBP*0x4]
CALL 0x001010d0
MOV RCX,RAX
MOV EAX,dword ptr [R14]
ADD EAX,dword ptr [R14 + R13*0x1 + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
CMP EBX,0x1
JZ 0x00101614
LEA RSI,[RCX + 0x4]
MOV R8D,0x1
LEA R9,[RCX + 0x8]
CMP EAX,0x1
JZ 0x00101630
NOP dword ptr [RAX]
LAB_001015d0:
CMP EBX,R8D
JLE 0x00101607
MOV EAX,R12D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[R9 + RAX*0x4]
MOV RAX,RSI
NOP word ptr [RAX + RAX*0x1]
LAB_001015f0:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP ECX,EDX
JLE 0x001015fe
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_001015fe:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x001015f0
LAB_00101607:
ADD R8,0x1
ADD RSI,0x4
CMP R8,RBP
JNZ 0x001015d0
LAB_00101614:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010161d:
ADD R8,0x1
ADD RSI,0x4
CMP R8,RBP
JZ 0x00101614
NOP word ptr [RAX + RAX*0x1]
LAB_00101630:
CMP EBX,R8D
JLE 0x0010161d
MOV EAX,R12D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[R9 + RAX*0x4]
MOV RAX,RSI
NOP word ptr [RAX + RAX*0x1]
LAB_00101650:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x0010165e
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_0010165e:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101650
ADD R8,0x1
ADD RSI,0x4
CMP R8,RBP
JNZ 0x00101630
JMP 0x00101614
LAB_00101676:
MOV EDI,0x1
CALL 0x001010f0
|
void func0_part_0(int *param_1,uint param_2,int8 *param_3)
{
int iVar1;
void *pvVar2;
int *piVar3;
ulong uVar4;
int *piVar5;
ulong uVar6;
pvVar2 = malloc((long)(int)param_2 * 4);
*param_3 = pvVar2;
if (pvVar2 == (void *)0x0) {
/* WARNING: Subroutine does not return */
exit(1);
}
if (0 < (int)param_2) {
uVar4 = (ulong)param_2;
pvVar2 = memcpy(pvVar2,param_1,uVar4 * 4);
if (param_2 != 1) {
piVar5 = (int *)((long)pvVar2 + 4);
uVar6 = 1;
if ((*param_1 + param_1[(long)(int)param_2 + -1]) % 2 == 1) {
do {
while ((int)uVar6 < (int)param_2) {
piVar3 = piVar5;
do {
iVar1 = piVar5[-1];
if (*piVar3 < iVar1) {
piVar5[-1] = *piVar3;
*piVar3 = iVar1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != (int *)((long)pvVar2 +
((uVar6 - 1) + (ulong)((param_2 - 1) - (int)uVar6)) * 4 + 8));
uVar6 = uVar6 + 1;
piVar5 = piVar5 + 1;
if (uVar6 == uVar4) {
return;
}
}
uVar6 = uVar6 + 1;
piVar5 = piVar5 + 1;
} while (uVar6 != uVar4);
}
else {
do {
if ((int)uVar6 < (int)param_2) {
piVar3 = piVar5;
do {
iVar1 = piVar5[-1];
if (iVar1 < *piVar3) {
piVar5[-1] = *piVar3;
*piVar3 = iVar1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != (int *)((long)pvVar2 +
((uVar6 - 1) + (ulong)((param_2 - 1) - (int)uVar6)) * 4 + 8));
}
uVar6 = uVar6 + 1;
piVar5 = piVar5 + 1;
} while (uVar6 != uVar4);
}
}
}
return;
}
|
1,012 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
func0("gf", encrypted);
assert(strcmp(encrypted, "kj") == 0);
func0("et", encrypted);
assert(strcmp(encrypted, "ix") == 0);
func0("faewfawefaewg", encrypted);
assert(strcmp(encrypted, "jeiajeaijeiak") == 0);
func0("hellomyfriend", encrypted);
assert(strcmp(encrypted, "lippsqcjvmirh") == 0);
func0("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh", encrypted);
assert(strcmp(encrypted, "hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl") == 0);
func0("a", encrypted);
assert(strcmp(encrypted, "e") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x6e>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
lea -0x5d(%rax),%edx
movslq %edx,%rax
imul $0x4ec4ec4f,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x3,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
imul $0x1a,%eax,%eax
sub %eax,%edx
mov %edx,%eax
add $0x61,%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov -0x4(%rbp),%edx
mov %dl,(%rax)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11a2 <func0+0x19>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_8], 0
jmp short loc_11F3
loc_11A2:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
lea edx, [rax-5Dh]
movsxd rax, edx
imul rax, 4EC4EC4Fh
shr rax, 20h
sar eax, 3
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
imul ecx, eax, 1Ah
mov eax, edx
sub eax, ecx
add eax, 61h ; 'a'
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rbp+var_4]
mov [rax], dl
add [rbp+var_8], 1
loc_11F3:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_11A2
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
nop
pop rbp
retn
|
_BYTE * func0(long long a1, long long a2)
{
_BYTE *result; // rax
int i; // [rsp+18h] [rbp-8h]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
*(_BYTE *)(i + a2) = (*(char *)(i + a1) - 93) % 26 + 97;
result = (_BYTE *)(i + a2);
*result = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f3
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
LEA EDX,[RAX + -0x5d]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x4ec4ec4f
SHR RAX,0x20
SAR EAX,0x3
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
IMUL ECX,EAX,0x1a
MOV EAX,EDX
SUB EAX,ECX
ADD EAX,0x61
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x4]
MOV byte ptr [RAX],DL
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f3:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011a2
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
POP RBP
RET
|
void func0(long param_1,long param_2)
{
int iVar1;
int4 local_10;
for (local_10 = 0; *(char *)(param_1 + local_10) != '\0'; local_10 = local_10 + 1) {
iVar1 = *(char *)(param_1 + local_10) + -0x5d;
*(char *)(param_2 + local_10) = (char)iVar1 + (char)(iVar1 / 0x1a) * -0x1a + 'a';
}
*(int *)(param_2 + local_10) = 0;
return;
}
|
1,013 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
func0("gf", encrypted);
assert(strcmp(encrypted, "kj") == 0);
func0("et", encrypted);
assert(strcmp(encrypted, "ix") == 0);
func0("faewfawefaewg", encrypted);
assert(strcmp(encrypted, "jeiajeaijeiak") == 0);
func0("hellomyfriend", encrypted);
assert(strcmp(encrypted, "lippsqcjvmirh") == 0);
func0("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh", encrypted);
assert(strcmp(encrypted, "hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl") == 0);
func0("a", encrypted);
assert(strcmp(encrypted, "e") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 11b3 <func0+0x4a>
mov $0x0,%ecx
movsbl %al,%eax
sub $0x5d,%eax
movslq %eax,%rdx
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x23,%rdx
mov %eax,%r8d
sar $0x1f,%r8d
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%eax
add $0x61,%eax
mov %al,(%rsi,%rcx,1)
add $0x1,%rcx
movzbl (%rdi,%rcx,1),%eax
test %al,%al
jne 1179 <func0+0x10>
movb $0x0,(%rsi,%rcx,1)
retq
mov $0x0,%ecx
jmp 11ae <func0+0x45>
|
func0:
endbr64
mov r8, rdi
movzx eax, byte ptr [rdi]
test al, al
jz short loc_11D4
mov ecx, 0
loc_119C:
movsx eax, al
sub eax, 5Dh ; ']'
movsxd rdx, eax
imul rdx, 4EC4EC4Fh
sar rdx, 23h
mov edi, eax
sar edi, 1Fh
sub edx, edi
imul edx, 1Ah
sub eax, edx
add eax, 61h ; 'a'
mov [rsi+rcx], al
add rcx, 1
movzx eax, byte ptr [r8+rcx]
test al, al
jnz short loc_119C
loc_11CF:
mov byte ptr [rsi+rcx], 0
retn
loc_11D4:
mov ecx, 0
jmp short loc_11CF
|
long long func0(unsigned __int8 *a1, long long a2)
{
long long result; // rax
long long v3; // rcx
result = *a1;
if ( (_BYTE)result )
{
v3 = 0LL;
do
{
*(_BYTE *)(a2 + v3++) = ((char)result - 93) % 26 + 97;
result = a1[v3];
}
while ( (_BYTE)result );
}
else
{
v3 = 0LL;
}
*(_BYTE *)(a2 + v3) = 0;
return result;
}
|
func0:
ENDBR64
MOV R8,RDI
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001011d4
MOV ECX,0x0
LAB_0010119c:
MOVSX EAX,AL
SUB EAX,0x5d
MOVSXD RDX,EAX
IMUL RDX,RDX,0x4ec4ec4f
SAR RDX,0x23
MOV EDI,EAX
SAR EDI,0x1f
SUB EDX,EDI
IMUL EDX,EDX,0x1a
SUB EAX,EDX
ADD EAX,0x61
MOV byte ptr [RSI + RCX*0x1],AL
ADD RCX,0x1
MOVZX EAX,byte ptr [R8 + RCX*0x1]
TEST AL,AL
JNZ 0x0010119c
LAB_001011cf:
MOV byte ptr [RSI + RCX*0x1],0x0
RET
LAB_001011d4:
MOV ECX,0x0
JMP 0x001011cf
|
void func0(char *param_1,long param_2)
{
char cVar1;
long lVar2;
cVar1 = *param_1;
if (cVar1 == '\0') {
lVar2 = 0;
}
else {
lVar2 = 0;
do {
*(char *)(param_2 + lVar2) =
(char)(cVar1 + -0x5d) + (char)((cVar1 + -0x5d) / 0x1a) * -0x1a + 'a';
lVar2 = lVar2 + 1;
cVar1 = param_1[lVar2];
} while (cVar1 != '\0');
}
*(int *)(param_2 + lVar2) = 0;
return;
}
|
1,014 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
func0("gf", encrypted);
assert(strcmp(encrypted, "kj") == 0);
func0("et", encrypted);
assert(strcmp(encrypted, "ix") == 0);
func0("faewfawefaewg", encrypted);
assert(strcmp(encrypted, "jeiajeaijeiak") == 0);
func0("hellomyfriend", encrypted);
assert(strcmp(encrypted, "lippsqcjvmirh") == 0);
func0("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh", encrypted);
assert(strcmp(encrypted, "hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl") == 0);
func0("a", encrypted);
assert(strcmp(encrypted, "e") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 1575 <func0+0x45>
xor %ecx,%ecx
nopl (%rax)
sub $0x5d,%eax
movslq %eax,%rdx
mov %eax,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%eax
add $0x61,%eax
mov %al,(%rsi,%rcx,1)
add $0x1,%rcx
movsbl (%rdi,%rcx,1),%eax
test %al,%al
jne 1540 <func0+0x10>
add %rcx,%rsi
movb $0x0,(%rsi)
retq
nopl 0x0(%rax)
|
func0:
endbr64
movsx eax, byte ptr [rdi]
mov r8, rdi
test al, al
jz short loc_1423
xor ecx, ecx
loc_13F0:
sub eax, 5Dh ; ']'
movsxd rdx, eax
mov edi, eax
imul rdx, 4EC4EC4Fh
sar edi, 1Fh
sar rdx, 23h
sub edx, edi
imul edx, 1Ah
sub eax, edx
add eax, 61h ; 'a'
mov [rsi+rcx], al
add rcx, 1
movsx eax, byte ptr [r8+rcx]
test al, al
jnz short loc_13F0
add rsi, rcx
loc_1423:
mov byte ptr [rsi], 0
retn
|
long long func0(_BYTE *a1, _BYTE *a2)
{
long long result; // rax
long long v3; // rcx
result = (unsigned int)(char)*a1;
if ( *a1 )
{
v3 = 0LL;
do
{
a2[v3++] = ((int)result - 93) % 26 + 97;
result = (unsigned int)(char)a1[v3];
}
while ( a1[v3] );
a2 += v3;
}
*a2 = 0;
return result;
}
|
func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
MOV R8,RDI
TEST AL,AL
JZ 0x00101423
XOR ECX,ECX
LAB_001013f0:
SUB EAX,0x5d
MOVSXD RDX,EAX
MOV EDI,EAX
IMUL RDX,RDX,0x4ec4ec4f
SAR EDI,0x1f
SAR RDX,0x23
SUB EDX,EDI
IMUL EDX,EDX,0x1a
SUB EAX,EDX
ADD EAX,0x61
MOV byte ptr [RSI + RCX*0x1],AL
ADD RCX,0x1
MOVSX EAX,byte ptr [R8 + RCX*0x1]
TEST AL,AL
JNZ 0x001013f0
ADD RSI,RCX
LAB_00101423:
MOV byte ptr [RSI],0x0
RET
|
void func0(char *param_1,int *param_2)
{
char cVar1;
long lVar2;
cVar1 = *param_1;
if (cVar1 != '\0') {
lVar2 = 0;
do {
param_2[lVar2] = (char)(cVar1 + -0x5d) + (char)((cVar1 + -0x5d) / 0x1a) * -0x1a + 'a';
lVar2 = lVar2 + 1;
cVar1 = param_1[lVar2];
} while (cVar1 != '\0');
param_2 = param_2 + lVar2;
}
*param_2 = 0;
return;
}
|
1,015 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
func0("gf", encrypted);
assert(strcmp(encrypted, "kj") == 0);
func0("et", encrypted);
assert(strcmp(encrypted, "ix") == 0);
func0("faewfawefaewg", encrypted);
assert(strcmp(encrypted, "jeiajeaijeiak") == 0);
func0("hellomyfriend", encrypted);
assert(strcmp(encrypted, "lippsqcjvmirh") == 0);
func0("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh", encrypted);
assert(strcmp(encrypted, "hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl") == 0);
func0("a", encrypted);
assert(strcmp(encrypted, "e") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 1575 <func0+0x45>
xor %ecx,%ecx
nopl (%rax)
sub $0x5d,%eax
movslq %eax,%rdx
mov %eax,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%eax
add $0x61,%eax
mov %al,(%rsi,%rcx,1)
add $0x1,%rcx
movsbl (%rdi,%rcx,1),%eax
test %al,%al
jne 1540 <func0+0x10>
add %rcx,%rsi
movb $0x0,(%rsi)
retq
nopl 0x0(%rax)
|
func0:
endbr64
movsx eax, byte ptr [rdi]
mov r8, rdi
test al, al
jz short loc_1573
xor ecx, ecx
loc_1540:
sub eax, 5Dh ; ']'
movsxd rdx, eax
mov edi, eax
imul rdx, 4EC4EC4Fh
sar edi, 1Fh
sar rdx, 23h
sub edx, edi
imul edx, 1Ah
sub eax, edx
add eax, 61h ; 'a'
mov [rsi+rcx], al
add rcx, 1
movsx eax, byte ptr [r8+rcx]
test al, al
jnz short loc_1540
add rsi, rcx
loc_1573:
mov byte ptr [rsi], 0
retn
|
long long func0(_BYTE *a1, _BYTE *a2)
{
long long result; // rax
long long v3; // rcx
result = (unsigned int)(char)*a1;
if ( *a1 )
{
v3 = 0LL;
do
{
a2[v3++] = ((int)result - 93) % 26 + 97;
result = (unsigned int)(char)a1[v3];
}
while ( a1[v3] );
a2 += v3;
}
*a2 = 0;
return result;
}
|
func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
MOV R8,RDI
TEST AL,AL
JZ 0x00101573
XOR ECX,ECX
LAB_00101540:
SUB EAX,0x5d
MOVSXD RDX,EAX
MOV EDI,EAX
IMUL RDX,RDX,0x4ec4ec4f
SAR EDI,0x1f
SAR RDX,0x23
SUB EDX,EDI
IMUL EDX,EDX,0x1a
SUB EAX,EDX
ADD EAX,0x61
MOV byte ptr [RSI + RCX*0x1],AL
ADD RCX,0x1
MOVSX EAX,byte ptr [R8 + RCX*0x1]
TEST AL,AL
JNZ 0x00101540
ADD RSI,RCX
LAB_00101573:
MOV byte ptr [RSI],0x0
RET
|
void func0(char *param_1,int *param_2)
{
char cVar1;
long lVar2;
cVar1 = *param_1;
if (cVar1 != '\0') {
lVar2 = 0;
do {
param_2[lVar2] = (char)(cVar1 + -0x5d) + (char)((cVar1 + -0x5d) / 0x1a) * -0x1a + 'a';
lVar2 = lVar2 + 1;
cVar1 = param_1[lVar2];
} while (cVar1 != '\0');
param_2 = param_2 + lVar2;
}
*param_2 = 0;
return;
}
|
1,016 |
func0
|
#include <stdio.h>
#include <limits.h>
|
int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
}
}
if (second == INT_MAX) return -1;
return second;
}
|
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
assert(func0(test5, 5) == 1);
int test6[] = {-35, 34, 12, -45};
assert(func0(test6, 4) == -35);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x1,-0x1c(%rbp)
jg 1188 <func0+0x1f>
mov $0xffffffff,%eax
jmpq 1250 <func0+0xe7>
movl $0x7fffffff,-0xc(%rbp)
movl $0x7fffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1231 <func0+0xc8>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jle 11de <func0+0x75>
mov -0xc(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
jmp 122d <func0+0xc4>
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 122d <func0+0xc4>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
je 122d <func0+0xc4>
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 11a2 <func0+0x39>
cmpl $0x7fffffff,-0x8(%rbp)
jne 124d <func0+0xe4>
mov $0xffffffff,%eax
jmp 1250 <func0+0xe7>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 1
jg short loc_1188
mov eax, 0FFFFFFFFh
jmp loc_1250
loc_1188:
mov [rbp+var_C], 7FFFFFFFh
mov [rbp+var_8], 7FFFFFFFh
mov [rbp+var_4], 0
jmp loc_1231
loc_11A2:
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
jle short loc_11DE
mov eax, [rbp+var_C]
mov [rbp+var_8], eax
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
jmp short loc_122D
loc_11DE:
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_122D
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
jz short loc_122D
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_122D:
add [rbp+var_4], 1
loc_1231:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_11A2
cmp [rbp+var_8], 7FFFFFFFh
jnz short loc_124D
mov eax, 0FFFFFFFFh
jmp short loc_1250
loc_124D:
mov eax, [rbp+var_8]
loc_1250:
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v3 = 0x7FFFFFFF;
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( v3 <= *(_DWORD *)(4LL * i + a1) )
{
if ( v4 > *(_DWORD *)(4LL * i + a1) && v3 != *(_DWORD *)(4LL * i + a1) )
v4 = *(_DWORD *)(4LL * i + a1);
}
else
{
v4 = v3;
v3 = *(_DWORD *)(4LL * i + a1);
}
}
if ( v4 == 0x7FFFFFFF )
return 0xFFFFFFFFLL;
else
return (unsigned int)v4;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x1
JG 0x00101188
MOV EAX,0xffffffff
JMP 0x00101250
LAB_00101188:
MOV dword ptr [RBP + -0xc],0x7fffffff
MOV dword ptr [RBP + -0x8],0x7fffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101231
LAB_001011a2:
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
JLE 0x001011de
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x8],EAX
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
JMP 0x0010122d
LAB_001011de:
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 0x0010122d
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
JZ 0x0010122d
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_0010122d:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101231:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a2
CMP dword ptr [RBP + -0x8],0x7fffffff
JNZ 0x0010124d
MOV EAX,0xffffffff
JMP 0x00101250
LAB_0010124d:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101250:
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
if (param_2 < 2) {
local_10 = -1;
}
else {
local_14 = 0x7fffffff;
local_10 = 0x7fffffff;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < local_14) {
local_10 = local_14;
local_14 = *(int *)(param_1 + (long)local_c * 4);
}
else if ((*(int *)(param_1 + (long)local_c * 4) < local_10) &&
(local_14 != *(int *)(param_1 + (long)local_c * 4))) {
local_10 = *(int *)(param_1 + (long)local_c * 4);
}
}
if (local_10 == 0x7fffffff) {
local_10 = -1;
}
}
return local_10;
}
|
1,017 |
func0
|
#include <stdio.h>
#include <limits.h>
|
int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
}
}
if (second == INT_MAX) return -1;
return second;
}
|
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
assert(func0(test5, 5) == 1);
int test6[] = {-35, 34, 12, -45};
assert(func0(test6, 4) == -35);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 11b7 <func0+0x4e>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x7fffffff,%esi
mov $0x7fffffff,%ecx
jmp 1196 <func0+0x2d>
mov %ecx,%esi
mov %edx,%ecx
add $0x4,%rax
cmp %rdi,%rax
je 11a5 <func0+0x3c>
mov (%rax),%edx
cmp %ecx,%edx
jl 1189 <func0+0x20>
je 118d <func0+0x24>
cmp %esi,%edx
cmovl %edx,%esi
jmp 118d <func0+0x24>
cmp $0x7fffffff,%esi
je 11b0 <func0+0x47>
mov %esi,%eax
retq
mov $0xffffffff,%esi
jmp 11ad <func0+0x44>
mov $0xffffffff,%esi
jmp 11ad <func0+0x44>
|
func0:
endbr64
cmp esi, 1
jle short loc_11B3
mov rcx, rdi
movsxd rsi, esi
lea rdi, [rdi+rsi*4]
mov eax, 7FFFFFFFh
mov esi, 7FFFFFFFh
jmp short loc_1195
loc_1188:
mov eax, esi
mov esi, edx
loc_118C:
add rcx, 4
cmp rcx, rdi
jz short loc_11AB
loc_1195:
mov edx, [rcx]
cmp edx, esi
jl short loc_1188
mov r8d, eax
cmp edx, eax
cmovle eax, edx
cmp edx, esi
cmovz eax, r8d
jmp short loc_118C
loc_11AB:
cmp eax, 7FFFFFFFh
jz short loc_11B9
retn
loc_11B3:
mov eax, 0FFFFFFFFh
retn
loc_11B9:
mov eax, 0FFFFFFFFh
retn
|
long long func0(int *a1, int a2)
{
int *v2; // rcx
int *v3; // rdi
long long result; // rax
int v5; // esi
int v6; // edx
unsigned int v7; // r8d
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v2 = a1;
v3 = &a1[a2];
result = 0x7FFFFFFFLL;
v5 = 0x7FFFFFFF;
do
{
v6 = *v2;
if ( *v2 < v5 )
{
result = (unsigned int)v5;
v5 = *v2;
}
else
{
v7 = result;
if ( v6 <= (int)result )
result = (unsigned int)v6;
if ( v6 == v5 )
result = v7;
}
++v2;
}
while ( v2 != v3 );
if ( (_DWORD)result == 0x7FFFFFFF )
return 0xFFFFFFFFLL;
return result;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011b3
MOV RCX,RDI
MOVSXD RSI,ESI
LEA RDI,[RDI + RSI*0x4]
MOV EAX,0x7fffffff
MOV ESI,0x7fffffff
JMP 0x00101195
LAB_00101188:
MOV EAX,ESI
MOV ESI,EDX
LAB_0010118c:
ADD RCX,0x4
CMP RCX,RDI
JZ 0x001011ab
LAB_00101195:
MOV EDX,dword ptr [RCX]
CMP EDX,ESI
JL 0x00101188
MOV R8D,EAX
CMP EDX,EAX
CMOVLE EAX,EDX
CMP EDX,ESI
CMOVZ EAX,R8D
JMP 0x0010118c
LAB_001011ab:
CMP EAX,0x7fffffff
JZ 0x001011b9
RET
LAB_001011b3:
MOV EAX,0xffffffff
RET
LAB_001011b9:
MOV EAX,0xffffffff
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 2) {
return -1;
}
piVar1 = param_1 + param_2;
iVar6 = 0x7fffffff;
iVar4 = 0x7fffffff;
do {
iVar2 = *param_1;
iVar5 = iVar2;
iVar3 = iVar6;
if (iVar6 <= iVar2) {
iVar3 = iVar4;
if (iVar2 <= iVar4) {
iVar3 = iVar2;
}
iVar5 = iVar6;
if (iVar2 == iVar6) {
iVar3 = iVar4;
}
}
param_1 = param_1 + 1;
iVar6 = iVar5;
iVar4 = iVar3;
} while (param_1 != piVar1);
if (iVar3 == 0x7fffffff) {
return -1;
}
return iVar3;
}
|
1,018 |
func0
|
#include <stdio.h>
#include <limits.h>
|
int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
}
}
if (second == INT_MAX) return -1;
return second;
}
|
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
assert(func0(test5, 5) == 1);
int test6[] = {-35, 34, 12, -45};
assert(func0(test6, 4) == -35);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 13cb <func0+0xb>
jmp 1350 <func0.part.0>
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0_part_0:
test esi, esi
jle short loc_1360
movsxd rsi, esi
mov ecx, 7FFFFFFFh
mov edx, 7FFFFFFFh
lea rsi, [rdi+rsi*4]
jmp short loc_1340
loc_1330:
jz short loc_1337
cmp ecx, eax
cmovg ecx, eax
loc_1337:
add rdi, 4
cmp rsi, rdi
jz short loc_1353
loc_1340:
mov eax, [rdi]
cmp edx, eax
jle short loc_1330
add rdi, 4
mov ecx, edx
mov edx, eax
cmp rsi, rdi
jnz short loc_1340
loc_1353:
cmp ecx, 7FFFFFFFh
jz short loc_1360
mov eax, ecx
retn
loc_1360:
mov ecx, 0FFFFFFFFh
mov eax, ecx
retn
|
long long func0_part_0(int *a1, int a2)
{
int v2; // ecx
int v3; // edx
int *v4; // rsi
int v5; // eax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0x7FFFFFFF;
v3 = 0x7FFFFFFF;
v4 = &a1[a2];
do
{
while ( 1 )
{
v5 = *a1;
if ( v3 <= *a1 )
break;
++a1;
v2 = v3;
v3 = v5;
if ( v4 == a1 )
goto LABEL_9;
}
if ( v3 != v5 && v2 > v5 )
v2 = *a1;
++a1;
}
while ( v4 != a1 );
LABEL_9:
if ( v2 == 0x7FFFFFFF )
return 0xFFFFFFFFLL;
else
return (unsigned int)v2;
}
|
func0.part.0:
TEST ESI,ESI
JLE 0x00101360
MOVSXD RSI,ESI
MOV ECX,0x7fffffff
MOV EDX,0x7fffffff
LEA RSI,[RDI + RSI*0x4]
JMP 0x00101340
LAB_00101330:
JZ 0x00101337
CMP ECX,EAX
CMOVG ECX,EAX
LAB_00101337:
ADD RDI,0x4
CMP RSI,RDI
JZ 0x00101353
LAB_00101340:
MOV EAX,dword ptr [RDI]
CMP EDX,EAX
JLE 0x00101330
ADD RDI,0x4
MOV ECX,EDX
MOV EDX,EAX
CMP RSI,RDI
JNZ 0x00101340
LAB_00101353:
CMP ECX,0x7fffffff
JZ 0x00101360
MOV EAX,ECX
RET
LAB_00101360:
MOV ECX,0xffffffff
MOV EAX,ECX
RET
|
int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0x7fffffff;
iVar4 = 0x7fffffff;
do {
while( true ) {
iVar2 = *param_1;
if (iVar4 <= iVar2) break;
param_1 = param_1 + 1;
iVar3 = iVar4;
iVar4 = iVar2;
if (piVar1 == param_1) goto LAB_00101353;
}
if ((iVar4 != iVar2) && (iVar2 < iVar3)) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
LAB_00101353:
if (iVar3 != 0x7fffffff) {
return iVar3;
}
}
return -1;
}
|
1,019 |
func0
|
#include <stdio.h>
#include <limits.h>
|
int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
}
}
if (second == INT_MAX) return -1;
return second;
}
|
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
assert(func0(test5, 5) == 1);
int test6[] = {-35, 34, 12, -45};
assert(func0(test6, 4) == -35);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 13d5 <func0+0x55>
lea -0x1(%rsi),%eax
mov $0x7fffffff,%r8d
mov $0x7fffffff,%edx
lea 0x4(%rdi,%rax,4),%rcx
jmp 13b4 <func0+0x34>
xchg %ax,%ax
cmp %r8d,%eax
jge 13ab <func0+0x2b>
cmp %edx,%eax
cmovne %eax,%r8d
add $0x4,%rdi
cmp %rdi,%rcx
je 13c8 <func0+0x48>
mov (%rdi),%eax
cmp %edx,%eax
jge 13a0 <func0+0x20>
add $0x4,%rdi
mov %edx,%r8d
mov %eax,%edx
cmp %rdi,%rcx
jne 13b4 <func0+0x34>
cmp $0x7fffffff,%r8d
je 13d5 <func0+0x55>
mov %r8d,%eax
retq
mov $0xffffffff,%r8d
jmp 13d1 <func0+0x51>
nopl (%rax)
|
func0_part_0:
test esi, esi
jle short loc_1360
movsxd rsi, esi
mov ecx, 7FFFFFFFh
mov edx, 7FFFFFFFh
lea rsi, [rdi+rsi*4]
jmp short loc_1340
loc_1330:
jz short loc_1337
cmp ecx, eax
cmovg ecx, eax
loc_1337:
add rdi, 4
cmp rsi, rdi
jz short loc_1353
loc_1340:
mov eax, [rdi]
cmp edx, eax
jle short loc_1330
add rdi, 4
mov ecx, edx
mov edx, eax
cmp rsi, rdi
jnz short loc_1340
loc_1353:
cmp ecx, 7FFFFFFFh
jz short loc_1360
mov eax, ecx
retn
loc_1360:
mov ecx, 0FFFFFFFFh
mov eax, ecx
retn
|
long long func0_part_0(int *a1, int a2)
{
int v2; // ecx
int v3; // edx
int *v4; // rsi
int v5; // eax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0x7FFFFFFF;
v3 = 0x7FFFFFFF;
v4 = &a1[a2];
do
{
while ( 1 )
{
v5 = *a1;
if ( v3 <= *a1 )
break;
++a1;
v2 = v3;
v3 = v5;
if ( v4 == a1 )
goto LABEL_9;
}
if ( v3 != v5 && v2 > v5 )
v2 = *a1;
++a1;
}
while ( v4 != a1 );
LABEL_9:
if ( v2 == 0x7FFFFFFF )
return 0xFFFFFFFFLL;
else
return (unsigned int)v2;
}
|
func0.part.0:
TEST ESI,ESI
JLE 0x00101360
MOVSXD RSI,ESI
MOV ECX,0x7fffffff
MOV EDX,0x7fffffff
LEA RSI,[RDI + RSI*0x4]
JMP 0x00101340
LAB_00101330:
JZ 0x00101337
CMP ECX,EAX
CMOVG ECX,EAX
LAB_00101337:
ADD RDI,0x4
CMP RSI,RDI
JZ 0x00101353
LAB_00101340:
MOV EAX,dword ptr [RDI]
CMP EDX,EAX
JLE 0x00101330
ADD RDI,0x4
MOV ECX,EDX
MOV EDX,EAX
CMP RSI,RDI
JNZ 0x00101340
LAB_00101353:
CMP ECX,0x7fffffff
JZ 0x00101360
MOV EAX,ECX
RET
LAB_00101360:
MOV ECX,0xffffffff
MOV EAX,ECX
RET
|
int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0x7fffffff;
iVar4 = 0x7fffffff;
do {
while( true ) {
iVar2 = *param_1;
if (iVar4 <= iVar2) break;
param_1 = param_1 + 1;
iVar3 = iVar4;
iVar4 = iVar2;
if (piVar1 == param_1) goto LAB_00101353;
}
if ((iVar4 != iVar2) && (iVar2 < iVar3)) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
LAB_00101353:
if (iVar3 != 0x7fffffff) {
return iVar3;
}
}
return -1;
}
|
1,020 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
isi = 0;
}
if (!isspace(S[i])) {
isstart = 0;
}
if (S[i] == '.' || S[i] == '?' || S[i] == '!') {
isstart = 1;
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x1,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 12b6 <func0+0x14d>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
je 11dc <func0+0x73>
cmpl $0x0,-0xc(%rbp)
je 11dc <func0+0x73>
movl $0x0,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x49,%al
jne 11ff <func0+0x96>
cmpl $0x0,-0x10(%rbp)
je 11ff <func0+0x96>
movl $0x1,-0xc(%rbp)
jmp 1237 <func0+0xce>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
jne 1237 <func0+0xce>
movl $0x0,-0xc(%rbp)
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
jne 126f <func0+0x106>
movl $0x0,-0x10(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2e,%al
je 12ab <func0+0x142>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x3f,%al
je 12ab <func0+0x142>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x21,%al
jne 12b2 <func0+0x149>
movl $0x1,-0x10(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 119a <func0+0x31>
mov -0x8(%rbp),%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_10], 1
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_12B6
loc_119A:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 2000h
test eax, eax
jz short loc_11DC
cmp [rbp+var_C], 0
jz short loc_11DC
mov [rbp+var_C], 0
add [rbp+var_8], 1
loc_11DC:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 49h ; 'I'
jnz short loc_11FF
cmp [rbp+var_10], 0
jz short loc_11FF
mov [rbp+var_C], 1
jmp short loc_1237
loc_11FF:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 2000h
test eax, eax
jnz short loc_1237
mov [rbp+var_C], 0
loc_1237:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 2000h
test eax, eax
jnz short loc_126F
mov [rbp+var_10], 0
loc_126F:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Eh ; '.'
jz short loc_12AB
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 3Fh ; '?'
jz short loc_12AB
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 21h ; '!'
jnz short loc_12B2
loc_12AB:
mov [rbp+var_10], 1
loc_12B2:
add [rbp+var_4], 1
loc_12B6:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_119A
mov eax, [rbp+var_8]
leave
retn
|
long long func0(long long a1)
{
int v2; // [rsp+10h] [rbp-10h]
int v3; // [rsp+14h] [rbp-Ch]
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v2 = 1;
v3 = 0;
v4 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x2000) != 0 && v3 )
{
v3 = 0;
++v4;
}
if ( *(_BYTE *)(i + a1) == 73 && v2 )
{
v3 = 1;
}
else if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x2000) == 0 )
{
v3 = 0;
}
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x2000) == 0 )
v2 = 0;
if ( *(_BYTE *)(i + a1) == 46 || *(_BYTE *)(i + a1) == 63 || *(_BYTE *)(i + a1) == 33 )
v2 = 1;
}
return v4;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012b6
LAB_0010119a:
CALL 0x00101070
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x2000
TEST EAX,EAX
JZ 0x001011dc
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011dc
MOV dword ptr [RBP + -0xc],0x0
ADD dword ptr [RBP + -0x8],0x1
LAB_001011dc:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x49
JNZ 0x001011ff
CMP dword ptr [RBP + -0x10],0x0
JZ 0x001011ff
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101237
LAB_001011ff:
CALL 0x00101070
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x2000
TEST EAX,EAX
JNZ 0x00101237
MOV dword ptr [RBP + -0xc],0x0
LAB_00101237:
CALL 0x00101070
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x2000
TEST EAX,EAX
JNZ 0x0010126f
MOV dword ptr [RBP + -0x10],0x0
LAB_0010126f:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2e
JZ 0x001012ab
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x3f
JZ 0x001012ab
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x21
JNZ 0x001012b2
LAB_001012ab:
MOV dword ptr [RBP + -0x10],0x1
LAB_001012b2:
ADD dword ptr [RBP + -0x4],0x1
LAB_001012b6:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010119a
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET
|
int func0(long param_1)
{
bool bVar1;
bool bVar2;
ushort **ppuVar3;
int local_10;
int local_c;
bVar2 = true;
bVar1 = false;
local_10 = 0;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
ppuVar3 = __ctype_b_loc();
if ((((*ppuVar3)[*(char *)(param_1 + local_c)] & 0x2000) != 0) && (bVar1)) {
bVar1 = false;
local_10 = local_10 + 1;
}
if ((*(char *)(param_1 + local_c) == 'I') && (bVar2)) {
bVar1 = true;
}
else {
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[*(char *)(param_1 + local_c)] & 0x2000) == 0) {
bVar1 = false;
}
}
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[*(char *)(param_1 + local_c)] & 0x2000) == 0) {
bVar2 = false;
}
if (((*(char *)(param_1 + local_c) == '.') || (*(char *)(param_1 + local_c) == '?')) ||
(*(char *)(param_1 + local_c) == '!')) {
bVar2 = true;
}
}
return local_10;
}
|
1,021 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
isi = 0;
}
if (!isspace(S[i])) {
isstart = 0;
}
if (S[i] == '.' || S[i] == '?' || S[i] == '!') {
isstart = 1;
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
mov $0x0,%ebp
test %bl,%bl
je 1226 <func0+0xbd>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%r9
movsbq %bl,%rax
movzwl (%r9,%rax,2),%eax
and $0x2000,%ax
lea 0x1(%rbp),%rdi
mov $0x1,%edx
mov $0x0,%ebp
mov $0x0,%esi
mov $0x0,%r8d
movabs $0x8000400200000000,%r11
mov $0x1,%r10d
jmp 11ca <func0+0x61>
add $0x1,%rdi
test %edx,%edx
je 11d3 <func0+0x6a>
cmp $0x49,%bl
je 1218 <func0+0xaf>
test %ax,%ax
cmove %r8d,%esi
cmove %r8d,%edx
cmp $0x3f,%bl
ja 11f1 <func0+0x88>
mov %r11,%rax
mov %ebx,%ecx
shr %cl,%rax
test $0x1,%al
cmovne %r10d,%edx
movzbl (%rdi),%ebx
test %bl,%bl
je 1226 <func0+0xbd>
movsbq %bl,%rax
movzwl (%r9,%rax,2),%eax
and $0x2000,%ax
test %esi,%esi
je 11c6 <func0+0x5d>
test %ax,%ax
je 11c6 <func0+0x5d>
add $0x1,%ebp
mov $0x0,%esi
jmp 11c6 <func0+0x5d>
mov $0x1,%esi
test %ax,%ax
cmove %r8d,%edx
jmp 11f1 <func0+0x88>
mov %ebp,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1219
mov rbp, rdi
call ___ctype_b_loc
mov r8, [rax]
lea rdi, [rbp+1]
mov r11d, 0
mov ecx, 0
mov edx, 1
mov esi, 0
mov r10, 8000400200000000h
mov r9d, 1
jmp short loc_11ED
loc_11B4:
add r11d, 1
test edx, edx
jz short loc_11C6
mov ecx, 1
cmp bl, 49h ; 'I'
jz short loc_11E1
loc_11C6:
mov ecx, 0
loc_11CB:
test ax, ax
cmovz ecx, esi
cmovz edx, esi
cmp bl, 3Fh ; '?'
ja short loc_11E1
bt r10, rbx
cmovb edx, r9d
loc_11E1:
add rdi, 1
movzx ebx, byte ptr [rdi-1]
test bl, bl
jz short loc_121F
loc_11ED:
movsx rax, bl
movzx eax, word ptr [r8+rax*2]
and ax, 2000h
test ecx, ecx
jz short loc_1203
test ax, ax
jnz short loc_11B4
loc_1203:
test edx, edx
jz short loc_11CB
cmp bl, 49h ; 'I'
jnz short loc_11CB
mov ecx, 1
test ax, ax
cmovz edx, esi
jmp short loc_11E1
loc_1219:
mov r11d, 0
loc_121F:
mov eax, r11d
add rsp, 8
pop rbx
pop rbp
retn
|
long long func0(unsigned __int8 *a1)
{
unsigned long long v1; // rbx
const unsigned __int16 *v2; // r8
unsigned __int8 *v3; // rdi
unsigned int v4; // r11d
int v5; // ecx
int v6; // edx
unsigned long long v7; // r10
__int16 v8; // ax
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = *__ctype_b_loc();
v3 = a1 + 1;
v4 = 0;
v5 = 0;
v6 = 1;
v7 = 0x8000400200000000LL;
while ( 1 )
{
v8 = v2[(char)v1] & 0x2000;
if ( v5 && v8 )
{
++v4;
if ( !v6 || (v5 = 1, (_BYTE)v1 != 73) )
{
v5 = 0;
LABEL_6:
if ( !v8 )
{
v5 = 0;
v6 = 0;
}
if ( (unsigned __int8)v1 <= 0x3Fu && _bittest64((const long long *)&v7, v1) )
v6 = 1;
}
}
else
{
if ( !v6 || (_BYTE)v1 != 73 )
goto LABEL_6;
v5 = 1;
if ( !v8 )
v6 = 0;
}
v1 = *v3++;
if ( !(_BYTE)v1 )
return v4;
}
}
return 0;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101219
MOV RBP,RDI
CALL 0x00101070
MOV R8,qword ptr [RAX]
LEA RDI,[RBP + 0x1]
MOV R11D,0x0
MOV ECX,0x0
MOV EDX,0x1
MOV ESI,0x0
MOV R10,-0x7fffbffe00000000
MOV R9D,0x1
JMP 0x001011ed
LAB_001011b4:
ADD R11D,0x1
TEST EDX,EDX
JZ 0x001011c6
MOV ECX,0x1
CMP BL,0x49
JZ 0x001011e1
LAB_001011c6:
MOV ECX,0x0
LAB_001011cb:
TEST AX,AX
CMOVZ ECX,ESI
CMOVZ EDX,ESI
CMP BL,0x3f
JA 0x001011e1
BT R10,RBX
CMOVC EDX,R9D
LAB_001011e1:
ADD RDI,0x1
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JZ 0x0010121f
LAB_001011ed:
MOVSX RAX,BL
MOVZX EAX,word ptr [R8 + RAX*0x2]
AND AX,0x2000
TEST ECX,ECX
JZ 0x00101203
TEST AX,AX
JNZ 0x001011b4
LAB_00101203:
TEST EDX,EDX
JZ 0x001011cb
CMP BL,0x49
JNZ 0x001011cb
MOV ECX,0x1
TEST AX,AX
CMOVZ EDX,ESI
JMP 0x001011e1
LAB_00101219:
MOV R11D,0x0
LAB_0010121f:
MOV EAX,R11D
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int func0(byte *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
ushort uVar4;
ushort **ppuVar5;
byte *pbVar6;
int iVar7;
bVar1 = *param_1;
if (bVar1 == 0) {
iVar7 = 0;
}
else {
ppuVar5 = __ctype_b_loc();
iVar7 = 0;
bVar3 = false;
bVar2 = true;
pbVar6 = param_1 + 1;
do {
uVar4 = (*ppuVar5)[(char)bVar1] & 0x2000;
if ((bVar3) && (uVar4 != 0)) {
iVar7 = iVar7 + 1;
if ((!bVar2) || (bVar3 = true, bVar1 != 0x49)) {
bVar3 = false;
LAB_001011cb:
if (uVar4 == 0) {
bVar3 = false;
bVar2 = false;
}
if ((bVar1 < 0x40) && ((0x8000400200000000U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) {
bVar2 = true;
}
}
}
else {
if ((!bVar2) || (bVar1 != 0x49)) goto LAB_001011cb;
bVar3 = true;
if (uVar4 == 0) {
bVar2 = false;
}
}
bVar1 = *pbVar6;
pbVar6 = pbVar6 + 1;
} while (bVar1 != 0);
}
return iVar7;
}
|
1,022 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
isi = 0;
}
if (!isspace(S[i])) {
isstart = 0;
}
if (S[i] == '.' || S[i] == '?' || S[i] == '!') {
isstart = 1;
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1360 <func0+0xb0>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %r8d,%r8d
xor %esi,%esi
mov (%rax),%r9
mov $0x1,%edx
mov $0x1,%r11d
movabs $0x8000400200000000,%r10
jmp 131b <func0+0x6b>
cmp $0x1,%esi
sbb $0xffffffff,%r8d
test %al,%al
jne 1350 <func0+0xa0>
xor %esi,%esi
cmp $0x3f,%bl
ja 1310 <func0+0x60>
mov %r10,%rax
mov %ebx,%ecx
shr %cl,%rax
test $0x1,%al
cmovne %r11d,%edx
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
je 1345 <func0+0x95>
cmp $0x49,%bl
movsbq %bl,%rcx
sete %al
and %edx,%eax
testb $0x20,0x1(%r9,%rcx,2)
jne 12f0 <func0+0x40>
xor %edx,%edx
test %al,%al
je 12fb <func0+0x4b>
mov $0x1,%esi
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
jne 131b <func0+0x6b>
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
mov $0x1,%edx
mov $0x1,%esi
jmp 133a <func0+0x8a>
nopl 0x0(%rax)
add $0x8,%rsp
xor %r8d,%r8d
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopl (%rax)
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1370
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r11d, r11d
xor esi, esi
mov r8, [rax]
mov ecx, 1
mov r10, 8000400200000000h
mov r9d, 1
jmp short loc_1310
loc_12F0:
test dl, dl
jnz short loc_1333
xor ecx, ecx
loc_12F6:
xor esi, esi
cmp bl, 3Fh ; '?'
ja short loc_1305
bt r10, rbx
cmovb ecx, r9d
loc_1305:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jz short loc_134B
loc_1310:
movsx rax, bl
cmp bl, 49h ; 'I'
movzx eax, word ptr [r8+rax*2]
setz dl
and edx, ecx
and ax, 2000h
jz short loc_12F0
test esi, esi
jz short loc_1358
add r11d, 1
test dl, dl
jz short loc_12F6
loc_1333:
xor ecx, ecx
test ax, ax
mov esi, 1
setnz cl
loc_1340:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jnz short loc_1310
loc_134B:
add rsp, 8
mov eax, r11d
pop rbx
pop rbp
retn
loc_1358:
test dl, dl
jz short loc_12F6
xor ecx, ecx
test ax, ax
mov esi, 1
setnz cl
jmp short loc_1340
loc_1370:
add rsp, 8
xor r11d, r11d
mov eax, r11d
pop rbx
pop rbp
retn
|
long long func0(unsigned __int8 *a1)
{
unsigned long long v1; // rbx
const unsigned __int16 **v2; // rax
unsigned __int8 *v3; // rdi
unsigned int v4; // r11d
int v5; // esi
const unsigned __int16 *v6; // r8
bool v7; // cl
unsigned long long v8; // r10
bool v9; // dl
__int16 v10; // ax
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = __ctype_b_loc();
v3 = a1 + 1;
v4 = 0;
v5 = 0;
v6 = *v2;
v7 = 1;
v8 = 0x8000400200000000LL;
while ( 1 )
{
while ( 1 )
{
v9 = v7 && (_BYTE)v1 == 73;
v10 = v6[(char)v1] & 0x2000;
if ( !v10 )
break;
if ( v5 )
{
++v4;
if ( v9 )
goto LABEL_12;
}
else if ( v9 )
{
v5 = 1;
v7 = v10 != 0;
goto LABEL_13;
}
LABEL_5:
v5 = 0;
if ( (unsigned __int8)v1 <= 0x3Fu )
{
if ( _bittest64((const long long *)&v8, v1) )
v7 = 1;
}
v1 = *v3++;
if ( !(_BYTE)v1 )
return v4;
}
if ( !v9 )
{
v7 = 0;
goto LABEL_5;
}
LABEL_12:
v5 = 1;
v7 = v10 != 0;
LABEL_13:
v1 = *v3++;
if ( !(_BYTE)v1 )
return v4;
}
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101370
MOV RBP,RDI
CALL 0x00101070
LEA RDI,[RBP + 0x1]
XOR R11D,R11D
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV ECX,0x1
MOV R10,-0x7fffbffe00000000
MOV R9D,0x1
JMP 0x00101310
LAB_001012f0:
TEST DL,DL
JNZ 0x00101333
XOR ECX,ECX
LAB_001012f6:
XOR ESI,ESI
CMP BL,0x3f
JA 0x00101305
BT R10,RBX
CMOVC ECX,R9D
LAB_00101305:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JZ 0x0010134b
LAB_00101310:
MOVSX RAX,BL
CMP BL,0x49
MOVZX EAX,word ptr [R8 + RAX*0x2]
SETZ DL
AND EDX,ECX
AND AX,0x2000
JZ 0x001012f0
TEST ESI,ESI
JZ 0x00101358
ADD R11D,0x1
TEST DL,DL
JZ 0x001012f6
LAB_00101333:
XOR ECX,ECX
TEST AX,AX
MOV ESI,0x1
SETNZ CL
LAB_00101340:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JNZ 0x00101310
LAB_0010134b:
ADD RSP,0x8
MOV EAX,R11D
POP RBX
POP RBP
RET
LAB_00101358:
TEST DL,DL
JZ 0x001012f6
XOR ECX,ECX
TEST AX,AX
MOV ESI,0x1
SETNZ CL
JMP 0x00101340
LAB_00101370:
ADD RSP,0x8
XOR R11D,R11D
MOV EAX,R11D
POP RBX
POP RBP
RET
|
int func0(byte *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
ushort **ppuVar5;
int iVar6;
bVar1 = *param_1;
if (bVar1 == 0) {
return 0;
}
ppuVar5 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar6 = 0;
bVar3 = false;
bVar2 = true;
do {
bVar4 = (bool)(bVar1 == 0x49 & bVar2);
if (((*ppuVar5)[(char)bVar1] & 0x2000) == 0) {
if (bVar4) goto LAB_00101340;
bVar2 = false;
LAB_001012f6:
bVar3 = false;
if ((bVar1 < 0x40) && ((0x8000400200000000U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) {
bVar2 = true;
}
bVar1 = *param_1;
}
else {
if (!bVar3) {
if (bVar4) goto LAB_00101340;
goto LAB_001012f6;
}
iVar6 = iVar6 + 1;
if (!bVar4) goto LAB_001012f6;
LAB_00101340:
bVar2 = ((*ppuVar5)[(char)bVar1] & 0x2000) != 0;
bVar3 = true;
bVar1 = *param_1;
}
param_1 = param_1 + 1;
if (bVar1 == 0) {
return iVar6;
}
} while( true );
}
|
1,023 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
isi = 0;
}
if (!isspace(S[i])) {
isstart = 0;
}
if (S[i] == '.' || S[i] == '?' || S[i] == '!') {
isstart = 1;
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1360 <func0+0xb0>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %r8d,%r8d
xor %esi,%esi
mov (%rax),%r9
mov $0x1,%edx
movabs $0x8000400200000000,%r11
mov $0x1,%r10d
jmp 131b <func0+0x6b>
cmp $0x1,%esi
sbb $0xffffffff,%r8d
test %al,%al
jne 1350 <func0+0xa0>
xor %esi,%esi
cmp $0x3f,%bl
ja 1310 <func0+0x60>
mov %r11,%rax
mov %ebx,%ecx
shr %cl,%rax
test $0x1,%al
cmovne %r10d,%edx
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
je 1345 <func0+0x95>
cmp $0x49,%bl
movsbq %bl,%rcx
sete %al
and %edx,%eax
testb $0x20,0x1(%r9,%rcx,2)
jne 12f0 <func0+0x40>
xor %edx,%edx
test %al,%al
je 12fb <func0+0x4b>
mov $0x1,%esi
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
jne 131b <func0+0x6b>
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
mov $0x1,%edx
mov $0x1,%esi
jmp 133a <func0+0x8a>
nopl 0x0(%rax)
add $0x8,%rsp
xor %r8d,%r8d
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopl (%rax)
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1370
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r11d, r11d
xor esi, esi
mov r8, [rax]
mov ecx, 1
mov r10, 8000400200000000h
mov r9d, 1
jmp short loc_1310
loc_12F0:
test dl, dl
jnz short loc_1333
xor ecx, ecx
loc_12F6:
xor esi, esi
cmp bl, 3Fh ; '?'
ja short loc_1305
bt r10, rbx
cmovb ecx, r9d
loc_1305:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jz short loc_134B
loc_1310:
movsx rax, bl
cmp bl, 49h ; 'I'
movzx eax, word ptr [r8+rax*2]
setz dl
and edx, ecx
and ax, 2000h
jz short loc_12F0
test esi, esi
jz short loc_1358
add r11d, 1
test dl, dl
jz short loc_12F6
loc_1333:
xor ecx, ecx
test ax, ax
mov esi, 1
setnz cl
loc_1340:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jnz short loc_1310
loc_134B:
add rsp, 8
mov eax, r11d
pop rbx
pop rbp
retn
loc_1358:
test dl, dl
jz short loc_12F6
xor ecx, ecx
test ax, ax
mov esi, 1
setnz cl
jmp short loc_1340
loc_1370:
add rsp, 8
xor r11d, r11d
mov eax, r11d
pop rbx
pop rbp
retn
|
long long func0(unsigned __int8 *a1)
{
unsigned long long v1; // rbx
const unsigned __int16 **v2; // rax
unsigned __int8 *v3; // rdi
unsigned int v4; // r11d
int v5; // esi
const unsigned __int16 *v6; // r8
bool v7; // cl
unsigned long long v8; // r10
bool v9; // dl
__int16 v10; // ax
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = __ctype_b_loc();
v3 = a1 + 1;
v4 = 0;
v5 = 0;
v6 = *v2;
v7 = 1;
v8 = 0x8000400200000000LL;
while ( 1 )
{
while ( 1 )
{
v9 = v7 && (_BYTE)v1 == 73;
v10 = v6[(char)v1] & 0x2000;
if ( !v10 )
break;
if ( v5 )
{
++v4;
if ( v9 )
goto LABEL_12;
}
else if ( v9 )
{
v5 = 1;
v7 = v10 != 0;
goto LABEL_13;
}
LABEL_5:
v5 = 0;
if ( (unsigned __int8)v1 <= 0x3Fu )
{
if ( _bittest64((const long long *)&v8, v1) )
v7 = 1;
}
v1 = *v3++;
if ( !(_BYTE)v1 )
return v4;
}
if ( !v9 )
{
v7 = 0;
goto LABEL_5;
}
LABEL_12:
v5 = 1;
v7 = v10 != 0;
LABEL_13:
v1 = *v3++;
if ( !(_BYTE)v1 )
return v4;
}
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101370
MOV RBP,RDI
CALL 0x00101070
LEA RDI,[RBP + 0x1]
XOR R11D,R11D
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV ECX,0x1
MOV R10,-0x7fffbffe00000000
MOV R9D,0x1
JMP 0x00101310
LAB_001012f0:
TEST DL,DL
JNZ 0x00101333
XOR ECX,ECX
LAB_001012f6:
XOR ESI,ESI
CMP BL,0x3f
JA 0x00101305
BT R10,RBX
CMOVC ECX,R9D
LAB_00101305:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JZ 0x0010134b
LAB_00101310:
MOVSX RAX,BL
CMP BL,0x49
MOVZX EAX,word ptr [R8 + RAX*0x2]
SETZ DL
AND EDX,ECX
AND AX,0x2000
JZ 0x001012f0
TEST ESI,ESI
JZ 0x00101358
ADD R11D,0x1
TEST DL,DL
JZ 0x001012f6
LAB_00101333:
XOR ECX,ECX
TEST AX,AX
MOV ESI,0x1
SETNZ CL
LAB_00101340:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JNZ 0x00101310
LAB_0010134b:
ADD RSP,0x8
MOV EAX,R11D
POP RBX
POP RBP
RET
LAB_00101358:
TEST DL,DL
JZ 0x001012f6
XOR ECX,ECX
TEST AX,AX
MOV ESI,0x1
SETNZ CL
JMP 0x00101340
LAB_00101370:
ADD RSP,0x8
XOR R11D,R11D
MOV EAX,R11D
POP RBX
POP RBP
RET
|
int func0(byte *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
ushort **ppuVar5;
int iVar6;
bVar1 = *param_1;
if (bVar1 == 0) {
return 0;
}
ppuVar5 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar6 = 0;
bVar3 = false;
bVar2 = true;
do {
bVar4 = (bool)(bVar1 == 0x49 & bVar2);
if (((*ppuVar5)[(char)bVar1] & 0x2000) == 0) {
if (bVar4) goto LAB_00101340;
bVar2 = false;
LAB_001012f6:
bVar3 = false;
if ((bVar1 < 0x40) && ((0x8000400200000000U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) {
bVar2 = true;
}
bVar1 = *param_1;
}
else {
if (!bVar3) {
if (bVar4) goto LAB_00101340;
goto LAB_001012f6;
}
iVar6 = iVar6 + 1;
if (!bVar4) goto LAB_001012f6;
LAB_00101340:
bVar2 = ((*ppuVar5)[(char)bVar1] & 0x2000) != 0;
bVar3 = true;
bVar1 = *param_1;
}
param_1 = param_1 + 1;
if (bVar1 == 0) {
return iVar6;
}
} while( true );
}
|
1,024 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
assert(func0(3, 4, 7) == 1);
assert(func0(3.01, 4, 7) == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
mov -0x4(%rbp),%eax
movd %eax,%xmm0
callq 1060 <roundf@plt>
ucomiss -0x4(%rbp),%xmm0
jp 119c <func0+0x33>
ucomiss -0x4(%rbp),%xmm0
je 11a6 <func0+0x3d>
mov $0x0,%eax
jmpq 1232 <func0+0xc9>
mov -0x8(%rbp),%eax
movd %eax,%xmm0
callq 1060 <roundf@plt>
ucomiss -0x8(%rbp),%xmm0
jp 11be <func0+0x55>
ucomiss -0x8(%rbp),%xmm0
je 11c5 <func0+0x5c>
mov $0x0,%eax
jmp 1232 <func0+0xc9>
mov -0xc(%rbp),%eax
movd %eax,%xmm0
callq 1060 <roundf@plt>
ucomiss -0xc(%rbp),%xmm0
jp 11dd <func0+0x74>
ucomiss -0xc(%rbp),%xmm0
je 11e4 <func0+0x7b>
mov $0x0,%eax
jmp 1232 <func0+0xc9>
movss -0x4(%rbp),%xmm0
addss -0x8(%rbp),%xmm0
ucomiss -0xc(%rbp),%xmm0
jp 11fa <func0+0x91>
ucomiss -0xc(%rbp),%xmm0
je 1226 <func0+0xbd>
movss -0x4(%rbp),%xmm0
addss -0xc(%rbp),%xmm0
ucomiss -0x8(%rbp),%xmm0
jp 1210 <func0+0xa7>
ucomiss -0x8(%rbp),%xmm0
je 1226 <func0+0xbd>
movss -0x8(%rbp),%xmm0
addss -0xc(%rbp),%xmm0
ucomiss -0x4(%rbp),%xmm0
jp 122d <func0+0xc4>
ucomiss -0x4(%rbp),%xmm0
jne 122d <func0+0xc4>
mov $0x1,%eax
jmp 1232 <func0+0xc9>
mov $0x0,%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
movss [rbp+x], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
mov eax, [rbp+x]
movd xmm0, eax; x
call _roundf
movd eax, xmm0
movd xmm3, eax
ucomiss xmm3, [rbp+x]
jp short loc_11A8
movd xmm4, eax
ucomiss xmm4, [rbp+x]
jz short loc_11B2
loc_11A8:
mov eax, 0
jmp locret_1256
loc_11B2:
mov eax, [rbp+var_8]
movd xmm0, eax; x
call _roundf
movd eax, xmm0
movd xmm5, eax
ucomiss xmm5, [rbp+var_8]
jp short loc_11D6
movd xmm6, eax
ucomiss xmm6, [rbp+var_8]
jz short loc_11DD
loc_11D6:
mov eax, 0
jmp short locret_1256
loc_11DD:
mov eax, [rbp+var_C]
movd xmm0, eax; x
call _roundf
movd eax, xmm0
movd xmm7, eax
ucomiss xmm7, [rbp+var_C]
jp short loc_1201
movd xmm1, eax
ucomiss xmm1, [rbp+var_C]
jz short loc_1208
loc_1201:
mov eax, 0
jmp short locret_1256
loc_1208:
movss xmm0, [rbp+x]
addss xmm0, [rbp+var_8]
ucomiss xmm0, [rbp+var_C]
jp short loc_121E
ucomiss xmm0, [rbp+var_C]
jz short loc_124A
loc_121E:
movss xmm0, [rbp+x]
addss xmm0, [rbp+var_C]
ucomiss xmm0, [rbp+var_8]
jp short loc_1234
ucomiss xmm0, [rbp+var_8]
jz short loc_124A
loc_1234:
movss xmm0, [rbp+var_8]
addss xmm0, [rbp+var_C]
ucomiss xmm0, [rbp+x]
jp short loc_1251
ucomiss xmm0, [rbp+x]
jnz short loc_1251
loc_124A:
mov eax, 1
jmp short locret_1256
loc_1251:
mov eax, 0
locret_1256:
leave
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
__m128i v3; // xmm0
__m128i v5; // xmm0
__m128i v6; // xmm0
v3 = _mm_cvtsi32_si128(LODWORD(a1));
*(float *)v3.m128i_i32 = roundf(*(float *)v3.m128i_i32);
if ( COERCE_FLOAT(_mm_cvtsi128_si32(v3)) != a1 )
return 0LL;
v5 = _mm_cvtsi32_si128(LODWORD(a2));
*(float *)v5.m128i_i32 = roundf(*(float *)v5.m128i_i32);
if ( COERCE_FLOAT(_mm_cvtsi128_si32(v5)) != a2 )
return 0LL;
v6 = _mm_cvtsi32_si128(LODWORD(a3));
*(float *)v6.m128i_i32 = roundf(*(float *)v6.m128i_i32);
if ( COERCE_FLOAT(_mm_cvtsi128_si32(v6)) != a3 )
return 0LL;
return (float)(a1 + a2) == a3 || (float)(a1 + a3) == a2 || (float)(a2 + a3) == a1;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOV EAX,dword ptr [RBP + -0x4]
MOVD XMM0,EAX
CALL 0x00101060
MOVD EAX,XMM0
MOVD XMM3,EAX
UCOMISS XMM3,dword ptr [RBP + -0x4]
JP 0x001011a8
MOVD XMM4,EAX
UCOMISS XMM4,dword ptr [RBP + -0x4]
JZ 0x001011b2
LAB_001011a8:
MOV EAX,0x0
JMP 0x00101256
LAB_001011b2:
MOV EAX,dword ptr [RBP + -0x8]
MOVD XMM0,EAX
CALL 0x00101060
MOVD EAX,XMM0
MOVD XMM5,EAX
UCOMISS XMM5,dword ptr [RBP + -0x8]
JP 0x001011d6
MOVD XMM6,EAX
UCOMISS XMM6,dword ptr [RBP + -0x8]
JZ 0x001011dd
LAB_001011d6:
MOV EAX,0x0
JMP 0x00101256
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0xc]
MOVD XMM0,EAX
CALL 0x00101060
MOVD EAX,XMM0
MOVD XMM7,EAX
UCOMISS XMM7,dword ptr [RBP + -0xc]
JP 0x00101201
MOVD XMM1,EAX
UCOMISS XMM1,dword ptr [RBP + -0xc]
JZ 0x00101208
LAB_00101201:
MOV EAX,0x0
JMP 0x00101256
LAB_00101208:
MOVSS XMM0,dword ptr [RBP + -0x4]
ADDSS XMM0,dword ptr [RBP + -0x8]
UCOMISS XMM0,dword ptr [RBP + -0xc]
JP 0x0010121e
UCOMISS XMM0,dword ptr [RBP + -0xc]
JZ 0x0010124a
LAB_0010121e:
MOVSS XMM0,dword ptr [RBP + -0x4]
ADDSS XMM0,dword ptr [RBP + -0xc]
UCOMISS XMM0,dword ptr [RBP + -0x8]
JP 0x00101234
UCOMISS XMM0,dword ptr [RBP + -0x8]
JZ 0x0010124a
LAB_00101234:
MOVSS XMM0,dword ptr [RBP + -0x8]
ADDSS XMM0,dword ptr [RBP + -0xc]
UCOMISS XMM0,dword ptr [RBP + -0x4]
JP 0x00101251
UCOMISS XMM0,dword ptr [RBP + -0x4]
JNZ 0x00101251
LAB_0010124a:
MOV EAX,0x1
JMP 0x00101256
LAB_00101251:
MOV EAX,0x0
LAB_00101256:
LEAVE
RET
|
int8 func0(float param_1,float param_2,float param_3)
{
int8 uVar1;
float fVar2;
fVar2 = roundf(param_1);
if (fVar2 == param_1) {
fVar2 = roundf(param_2);
if (fVar2 == param_2) {
fVar2 = roundf(param_3);
if (fVar2 == param_3) {
if (((param_1 + param_2 == param_3) || (param_1 + param_3 == param_2)) ||
(param_2 + param_3 == param_1)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
}
else {
uVar1 = 0;
}
}
else {
uVar1 = 0;
}
}
else {
uVar1 = 0;
}
return uVar1;
}
|
1,025 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
assert(func0(3, 4, 7) == 1);
assert(func0(3.01, 4, 7) == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
movss 0x8(%rsp),%xmm3
ucomiss %xmm3,%xmm0
jp 1228 <func0+0xbf>
jne 1228 <func0+0xbf>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0x4(%rsp),%xmm4
ucomiss %xmm4,%xmm0
jp 1232 <func0+0xc9>
jne 1232 <func0+0xc9>
movss 0xc(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0xc(%rsp),%xmm5
ucomiss %xmm5,%xmm0
jp 1239 <func0+0xd0>
jne 1239 <func0+0xd0>
movss 0x8(%rsp),%xmm0
addss 0x4(%rsp),%xmm0
ucomiss %xmm5,%xmm0
jnp 1216 <func0+0xad>
movss 0x8(%rsp),%xmm0
addss 0xc(%rsp),%xmm0
ucomiss 0x4(%rsp),%xmm0
jnp 121f <func0+0xb6>
movss 0x4(%rsp),%xmm0
addss 0xc(%rsp),%xmm0
movss 0x8(%rsp),%xmm6
ucomiss %xmm6,%xmm0
setnp %al
movzbl %al,%eax
mov $0x0,%edx
cmovne %edx,%eax
jmp 122d <func0+0xc4>
jne 11de <func0+0x75>
mov $0x1,%eax
jmp 122d <func0+0xc4>
jne 11f1 <func0+0x88>
mov $0x1,%eax
jmp 122d <func0+0xc4>
mov $0x0,%eax
add $0x18,%rsp
retq
mov $0x0,%eax
jmp 122d <func0+0xc4>
mov $0x0,%eax
jmp 122d <func0+0xc4>
|
func0:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_14], xmm0
call _roundf
movss xmm3, [rsp+18h+var_14]
ucomiss xmm0, xmm3
jp loc_1224
jnz loc_1224
movss xmm0, [rsp+18h+x]; x
call _roundf
movss xmm4, [rsp+18h+x]
ucomiss xmm0, xmm4
jp short loc_122E
jnz short loc_122E
movss xmm0, [rsp+18h+var_C]; x
call _roundf
movss xmm5, [rsp+18h+var_C]
ucomiss xmm0, xmm5
jp short loc_1235
jnz short loc_1235
movss xmm0, [rsp+18h+var_14]
addss xmm0, [rsp+18h+x]
ucomiss xmm0, xmm5
jp short loc_11E5
mov eax, 1
jz short loc_1229
loc_11E5:
movss xmm0, [rsp+18h+var_14]
addss xmm0, [rsp+18h+var_C]
movss xmm6, [rsp+18h+x]
ucomiss xmm0, xmm6
jp short loc_1203
mov eax, 1
jz short loc_1229
loc_1203:
movss xmm0, [rsp+18h+x]
addss xmm0, [rsp+18h+var_C]
ucomiss xmm0, [rsp+18h+var_14]
setnp al
movzx eax, al
mov edx, 0
cmovnz eax, edx
jmp short loc_1229
loc_1224:
mov eax, 0
loc_1229:
add rsp, 18h
retn
loc_122E:
mov eax, 0
jmp short loc_1229
loc_1235:
mov eax, 0
jmp short loc_1229
|
_BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
if ( roundf(a1) != a1 )
return 0LL;
if ( roundf(a2) != a2 )
return 0LL;
if ( roundf(a3) != a3 )
return 0LL;
result = 1LL;
if ( (float)(a1 + a2) != a3 )
{
result = 1LL;
if ( (float)(a1 + a3) != a2 )
return (float)(a2 + a3) == a1;
}
return result;
}
|
func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x8],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x4],XMM0
CALL 0x00101060
MOVSS XMM3,dword ptr [RSP + 0x4]
UCOMISS XMM0,XMM3
JP 0x00101224
JNZ 0x00101224
MOVSS XMM0,dword ptr [RSP + 0x8]
CALL 0x00101060
MOVSS XMM4,dword ptr [RSP + 0x8]
UCOMISS XMM0,XMM4
JP 0x0010122e
JNZ 0x0010122e
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00101060
MOVSS XMM5,dword ptr [RSP + 0xc]
UCOMISS XMM0,XMM5
JP 0x00101235
JNZ 0x00101235
MOVSS XMM0,dword ptr [RSP + 0x4]
ADDSS XMM0,dword ptr [RSP + 0x8]
UCOMISS XMM0,XMM5
JP 0x001011e5
MOV EAX,0x1
JZ 0x00101229
LAB_001011e5:
MOVSS XMM0,dword ptr [RSP + 0x4]
ADDSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM6,dword ptr [RSP + 0x8]
UCOMISS XMM0,XMM6
JP 0x00101203
MOV EAX,0x1
JZ 0x00101229
LAB_00101203:
MOVSS XMM0,dword ptr [RSP + 0x8]
ADDSS XMM0,dword ptr [RSP + 0xc]
UCOMISS XMM0,dword ptr [RSP + 0x4]
SETNP AL
MOVZX EAX,AL
MOV EDX,0x0
CMOVNZ EAX,EDX
JMP 0x00101229
LAB_00101224:
MOV EAX,0x0
LAB_00101229:
ADD RSP,0x18
RET
LAB_0010122e:
MOV EAX,0x0
JMP 0x00101229
LAB_00101235:
MOV EAX,0x0
JMP 0x00101229
|
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (fVar2 == param_1) {
fVar2 = roundf(param_2);
if (fVar2 == param_2) {
fVar2 = roundf(param_3);
if (fVar2 == param_3) {
bVar1 = true;
if ((param_1 + param_2 != param_3) && (bVar1 = true, param_1 + param_3 != param_2)) {
bVar1 = param_2 + param_3 == param_1;
}
}
else {
bVar1 = false;
}
}
else {
bVar1 = false;
}
}
else {
bVar1 = false;
}
return bVar1;
}
|
1,026 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
assert(func0(3, 4, 7) == 1);
assert(func0(3.01, 4, 7) == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
ucomiss 0x8(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
ucomiss 0x4(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0xc(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0xc(%rsp),%xmm5
ucomiss %xmm5,%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0x8(%rsp),%xmm0
addss 0x4(%rsp),%xmm0
ucomiss %xmm0,%xmm5
jnp 14d0 <func0+0xc0>
movss 0x8(%rsp),%xmm0
addss 0xc(%rsp),%xmm0
movss 0x4(%rsp),%xmm7
ucomiss %xmm0,%xmm7
jnp 14e0 <func0+0xd0>
movss 0x4(%rsp),%xmm0
addss 0xc(%rsp),%xmm0
xor %eax,%eax
mov $0x0,%edx
movss 0x8(%rsp),%xmm6
ucomiss %xmm6,%xmm0
setnp %al
cmovne %edx,%eax
add $0x18,%rsp
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
add $0x18,%rsp
retq
nopw 0x0(%rax,%rax,1)
jne 147d <func0+0x6d>
mov $0x1,%eax
add $0x18,%rsp
retq
nopl 0x0(%rax)
je 14d2 <func0+0xc2>
jmp 1494 <func0+0x84>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_10], xmm0
call _roundf
ucomiss xmm0, [rsp+18h+var_10]
jp loc_14C8
jnz loc_14C8
movss xmm0, [rsp+18h+x]; x
call _roundf
ucomiss xmm0, [rsp+18h+x]
jp short loc_14C8
jnz short loc_14C8
movss xmm0, [rsp+18h+var_C]; x
call _roundf
movss xmm5, [rsp+18h+var_C]
ucomiss xmm0, xmm5
jp short loc_14C8
jnz short loc_14C8
movss xmm0, [rsp+18h+var_10]
addss xmm0, [rsp+18h+x]
ucomiss xmm5, xmm0
jp short loc_1484
mov eax, 1
jz short loc_14CA
loc_1484:
movss xmm0, [rsp+18h+var_10]
addss xmm0, [rsp+18h+var_C]
movss xmm7, [rsp+18h+x]
ucomiss xmm7, xmm0
jp short loc_14A2
mov eax, 1
jz short loc_14CA
loc_14A2:
movss xmm0, [rsp+18h+x]
xor eax, eax
mov edx, 0
addss xmm0, [rsp+18h+var_C]
ucomiss xmm0, [rsp+18h+var_10]
setnp al
cmovnz eax, edx
add rsp, 18h
retn
loc_14C8:
xor eax, eax
loc_14CA:
add rsp, 18h
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
if ( roundf(a1) != a1 || roundf(a2) != a2 || roundf(a3) != a3 )
return 0LL;
result = 1LL;
if ( a3 != (float)(a1 + a2) )
{
result = 1LL;
if ( a2 != (float)(a1 + a3) )
return (float)(a2 + a3) == a1;
}
return result;
}
|
func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x8]
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x4]
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00101060
MOVSS XMM5,dword ptr [RSP + 0xc]
UCOMISS XMM0,XMM5
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0x8]
ADDSS XMM0,dword ptr [RSP + 0x4]
UCOMISS XMM5,XMM0
JP 0x00101484
MOV EAX,0x1
JZ 0x001014ca
LAB_00101484:
MOVSS XMM0,dword ptr [RSP + 0x8]
ADDSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM7,dword ptr [RSP + 0x4]
UCOMISS XMM7,XMM0
JP 0x001014a2
MOV EAX,0x1
JZ 0x001014ca
LAB_001014a2:
MOVSS XMM0,dword ptr [RSP + 0x4]
XOR EAX,EAX
MOV EDX,0x0
ADDSS XMM0,dword ptr [RSP + 0xc]
UCOMISS XMM0,dword ptr [RSP + 0x8]
SETNP AL
CMOVNZ EAX,EDX
ADD RSP,0x18
RET
LAB_001014c8:
XOR EAX,EAX
LAB_001014ca:
ADD RSP,0x18
RET
|
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (((fVar2 == param_1) && (fVar2 = roundf(param_2), fVar2 == param_2)) &&
(fVar2 = roundf(param_3), fVar2 == param_3)) {
bVar1 = true;
if ((param_3 != param_1 + param_2) && (bVar1 = true, param_2 != param_1 + param_3)) {
return param_2 + param_3 == param_1;
}
}
else {
bVar1 = false;
}
return bVar1;
}
|
1,027 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
assert(func0(3, 4, 7) == 1);
assert(func0(3.01, 4, 7) == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
ucomiss 0x8(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
ucomiss 0x4(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0xc(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0xc(%rsp),%xmm5
ucomiss %xmm5,%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0x8(%rsp),%xmm0
addss 0x4(%rsp),%xmm0
ucomiss %xmm0,%xmm5
jnp 14d0 <func0+0xc0>
movss 0x8(%rsp),%xmm0
addss 0xc(%rsp),%xmm0
movss 0x4(%rsp),%xmm7
ucomiss %xmm0,%xmm7
jnp 14e0 <func0+0xd0>
movss 0x4(%rsp),%xmm0
addss 0xc(%rsp),%xmm0
xor %eax,%eax
mov $0x0,%edx
movss 0x8(%rsp),%xmm6
ucomiss %xmm6,%xmm0
setnp %al
cmovne %edx,%eax
add $0x18,%rsp
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
add $0x18,%rsp
retq
nopw 0x0(%rax,%rax,1)
jne 147d <func0+0x6d>
mov $0x1,%eax
add $0x18,%rsp
retq
nopl 0x0(%rax)
je 14d2 <func0+0xc2>
jmp 1494 <func0+0x84>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_10], xmm0
call _roundf
ucomiss xmm0, [rsp+18h+var_10]
jp loc_14C8
jnz loc_14C8
movss xmm0, [rsp+18h+x]; x
call _roundf
ucomiss xmm0, [rsp+18h+x]
jp short loc_14C8
jnz short loc_14C8
movss xmm0, [rsp+18h+var_C]; x
call _roundf
movss xmm5, [rsp+18h+var_C]
ucomiss xmm0, xmm5
jp short loc_14C8
jnz short loc_14C8
movss xmm0, [rsp+18h+var_10]
addss xmm0, [rsp+18h+x]
ucomiss xmm5, xmm0
jp short loc_1484
mov eax, 1
jz short loc_14CA
loc_1484:
movss xmm0, [rsp+18h+var_10]
addss xmm0, [rsp+18h+var_C]
movss xmm7, [rsp+18h+x]
ucomiss xmm7, xmm0
jp short loc_14A2
mov eax, 1
jz short loc_14CA
loc_14A2:
movss xmm0, [rsp+18h+x]
xor eax, eax
mov edx, 0
addss xmm0, [rsp+18h+var_C]
ucomiss xmm0, [rsp+18h+var_10]
setnp al
cmovnz eax, edx
add rsp, 18h
retn
loc_14C8:
xor eax, eax
loc_14CA:
add rsp, 18h
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
if ( roundf(a1) != a1 || roundf(a2) != a2 || roundf(a3) != a3 )
return 0LL;
result = 1LL;
if ( a3 != (float)(a1 + a2) )
{
result = 1LL;
if ( a2 != (float)(a1 + a3) )
return (float)(a2 + a3) == a1;
}
return result;
}
|
func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x8]
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x4]
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00101060
MOVSS XMM5,dword ptr [RSP + 0xc]
UCOMISS XMM0,XMM5
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0x8]
ADDSS XMM0,dword ptr [RSP + 0x4]
UCOMISS XMM5,XMM0
JP 0x00101484
MOV EAX,0x1
JZ 0x001014ca
LAB_00101484:
MOVSS XMM0,dword ptr [RSP + 0x8]
ADDSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM7,dword ptr [RSP + 0x4]
UCOMISS XMM7,XMM0
JP 0x001014a2
MOV EAX,0x1
JZ 0x001014ca
LAB_001014a2:
MOVSS XMM0,dword ptr [RSP + 0x4]
XOR EAX,EAX
MOV EDX,0x0
ADDSS XMM0,dword ptr [RSP + 0xc]
UCOMISS XMM0,dword ptr [RSP + 0x8]
SETNP AL
CMOVNZ EAX,EDX
ADD RSP,0x18
RET
LAB_001014c8:
XOR EAX,EAX
LAB_001014ca:
ADD RSP,0x18
RET
|
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (((fVar2 == param_1) && (fVar2 = roundf(param_2), fVar2 == param_2)) &&
(fVar2 = roundf(param_3), fVar2 == param_3)) {
bVar1 = true;
if ((param_3 != param_1 + param_2) && (bVar1 = true, param_2 != param_1 + param_3)) {
return param_2 + param_3 == param_1;
}
}
else {
bVar1 = false;
}
return bVar1;
}
|
1,028 |
func0
|
#include <stdio.h>
#include <ctype.h>
#include <string.h>
|
void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for (j = 0; vowels[j] != '\0'; ++j) {
if (w == vowels[j]) {
if (j < 10) {
w = w + 2;
}
break;
}
}
out[i] = w;
}
out[i] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", output);
assert(strcmp(output, "tHKS KS C MGSSCGG") == 0);
func0("I DoNt KnOw WhAt tO WrItE", output);
assert(strcmp(output, "k dQnT kNqW wHcT Tq wRkTg") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
lea 0xe04(%rip),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 12eb <func0+0x102>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x11(%rbp)
callq 10f0 <__ctype_b_loc@plt>
mov (%rax),%rax
movsbq -0x11(%rbp),%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 1259 <func0+0x70>
movsbl -0x11(%rbp),%eax
mov %eax,%edi
callq 10a0 <toupper@plt>
mov %al,-0x11(%rbp)
jmp 1289 <func0+0xa0>
callq 10f0 <__ctype_b_loc@plt>
mov (%rax),%rax
movsbq -0x11(%rbp),%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 1289 <func0+0xa0>
movsbl -0x11(%rbp),%eax
mov %eax,%edi
callq 10e0 <tolower@plt>
mov %al,-0x11(%rbp)
movl $0x0,-0xc(%rbp)
jmp 12bd <func0+0xd4>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x11(%rbp)
jne 12b9 <func0+0xd0>
cmpl $0x9,-0xc(%rbp)
jg 12d3 <func0+0xea>
movzbl -0x11(%rbp),%eax
add $0x2,%eax
mov %al,-0x11(%rbp)
jmp 12d3 <func0+0xea>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1292 <func0+0xa9>
jmp 12d4 <func0+0xeb>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
movzbl -0x11(%rbp),%eax
mov %al,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1214 <func0+0x2b>
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
lea rax, aAeiouaeiou; "aeiouAEIOU"
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp loc_12EB
loc_1214:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_11], al
call ___ctype_b_loc
mov rax, [rax]
movsx rdx, [rbp+var_11]
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jz short loc_1259
movsx eax, [rbp+var_11]
mov edi, eax; c
call _toupper
mov [rbp+var_11], al
jmp short loc_1289
loc_1259:
call ___ctype_b_loc
mov rax, [rax]
movsx rdx, [rbp+var_11]
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_1289
movsx eax, [rbp+var_11]
mov edi, eax; c
call _tolower
mov [rbp+var_11], al
loc_1289:
mov [rbp+var_C], 0
jmp short loc_12BD
loc_1292:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_11], al
jnz short loc_12B9
cmp [rbp+var_C], 9
jg short loc_12D3
movzx eax, [rbp+var_11]
add eax, 2
mov [rbp+var_11], al
jmp short loc_12D3
loc_12B9:
add [rbp+var_C], 1
loc_12BD:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1292
jmp short loc_12D4
loc_12D3:
nop
loc_12D4:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rdx, rax
movzx eax, [rbp+var_11]
mov [rdx], al
add [rbp+var_10], 1
loc_12EB:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_1214
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)
{
_BYTE *result; // rax
char v3; // [rsp+1Fh] [rbp-11h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
v3 = *(_BYTE *)(i + a1);
if ( ((*__ctype_b_loc())[v3] & 0x200) != 0 )
{
v3 = toupper(v3);
}
else if ( ((*__ctype_b_loc())[v3] & 0x100) != 0 )
{
v3 = tolower(v3);
}
for ( j = 0; aAeiouaeiou[j]; ++j )
{
if ( v3 == aAeiouaeiou[j] )
{
if ( j <= 9 )
v3 += 2;
break;
}
}
*(_BYTE *)(a2 + i) = v3;
}
result = (_BYTE *)(i + 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
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012eb
LAB_00101214:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
CALL 0x001010f0
MOV RAX,qword ptr [RAX]
MOVSX RDX,byte ptr [RBP + -0x11]
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x00101259
MOVSX EAX,byte ptr [RBP + -0x11]
MOV EDI,EAX
CALL 0x001010a0
MOV byte ptr [RBP + -0x11],AL
JMP 0x00101289
LAB_00101259:
CALL 0x001010f0
MOV RAX,qword ptr [RAX]
MOVSX RDX,byte ptr [RBP + -0x11]
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x00101289
MOVSX EAX,byte ptr [RBP + -0x11]
MOV EDI,EAX
CALL 0x001010e0
MOV byte ptr [RBP + -0x11],AL
LAB_00101289:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012bd
LAB_00101292:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x11],AL
JNZ 0x001012b9
CMP dword ptr [RBP + -0xc],0x9
JG 0x001012d3
MOVZX EAX,byte ptr [RBP + -0x11]
ADD EAX,0x2
MOV byte ptr [RBP + -0x11],AL
JMP 0x001012d3
LAB_001012b9:
ADD dword ptr [RBP + -0xc],0x1
LAB_001012bd:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101292
JMP 0x001012d4
LAB_001012d3:
NOP
LAB_001012d4:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOVZX EAX,byte ptr [RBP + -0x11]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x10],0x1
LAB_001012eb:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101214
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)
{
int iVar1;
ushort **ppuVar2;
char local_19;
int local_18;
int local_14;
local_18 = 0;
do {
if (*(char *)(param_1 + local_18) == '\0') {
*(int *)(param_2 + local_18) = 0;
return;
}
local_19 = *(char *)(param_1 + local_18);
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[local_19] & 0x200) == 0) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[local_19] & 0x100) != 0) {
iVar1 = tolower((int)local_19);
local_19 = (char)iVar1;
}
}
else {
iVar1 = toupper((int)local_19);
local_19 = (char)iVar1;
}
for (local_14 = 0; "aeiouAEIOU"[local_14] != '\0'; local_14 = local_14 + 1) {
if (local_19 == "aeiouAEIOU"[local_14]) {
if (local_14 < 10) {
local_19 = local_19 + '\x02';
}
break;
}
}
*(char *)(local_18 + param_2) = local_19;
local_18 = local_18 + 1;
} while( true );
}
|
1,029 |
func0
|
#include <stdio.h>
#include <ctype.h>
#include <string.h>
|
void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for (j = 0; vowels[j] != '\0'; ++j) {
if (w == vowels[j]) {
if (j < 10) {
w = w + 2;
}
break;
}
}
out[i] = w;
}
out[i] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", output);
assert(strcmp(output, "tHKS KS C MGSSCGG") == 0);
func0("I DoNt KnOw WhAt tO WrItE", output);
assert(strcmp(output, "k dQnT kNqW wHcT Tq wRkTg") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
movzbl (%rdi),%ebx
test %bl,%bl
je 1275 <func0+0xac>
mov %rdi,%r14
callq 10d0 <__ctype_b_loc@plt>
mov %rax,%r15
mov $0x0,%r12d
lea 0xe01(%rip),%rbp
jmp 1238 <func0+0x6f>
test $0x1,%ah
je 1256 <func0+0x8d>
callq 10c0 <__ctype_tolower_loc@plt>
mov (%rax),%rax
movzbl (%rax,%r13,4),%ebx
jmp 1256 <func0+0x8d>
lea 0x2(%rbx),%eax
cmp $0xa,%ecx
cmovl %eax,%ebx
mov 0x8(%rsp),%rax
mov %bl,(%rax,%r12,1)
add $0x1,%r12
movzbl (%r14,%r12,1),%ebx
test %bl,%bl
je 127b <func0+0xb2>
movsbq %bl,%r13
mov (%r15),%rax
movzwl (%rax,%r13,2),%eax
test $0x2,%ah
je 1205 <func0+0x3c>
callq 1090 <__ctype_toupper_loc@plt>
mov (%rax),%rax
movzbl (%rax,%r13,4),%ebx
mov $0x0,%eax
mov $0x61,%edx
mov %eax,%ecx
cmp %dl,%bl
je 1219 <func0+0x50>
add $0x1,%rax
movzbl 0x0(%rbp,%rax,1),%edx
test %dl,%dl
jne 1260 <func0+0x97>
jmp 1222 <func0+0x59>
mov $0x0,%r12d
mov 0x8(%rsp),%rax
movb $0x0,(%rax,%r12,1)
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 [rsp+48h+var_40], rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1293
mov r14, rdi
call ___ctype_b_loc
mov r15, rax
mov r12d, 0
lea rbp, aAeiouaeiou; "aeiouAEIOU"
jmp short loc_1258
loc_1225:
test ah, 1
jz short loc_1276
call ___ctype_tolower_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+r13*4]
jmp short loc_1276
loc_1239:
lea edx, [rbx+2]
cmp eax, 0Ah
cmovl ebx, edx
loc_1242:
mov rax, [rsp+48h+var_40]
mov [rax+r12], bl
add r12, 1
movzx ebx, byte ptr [r14+r12]
test bl, bl
jz short loc_1299
loc_1258:
movsx r13, bl
mov rax, [r15]
movzx eax, word ptr [rax+r13*2]
test ah, 2
jz short loc_1225
call ___ctype_toupper_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+r13*4]
loc_1276:
mov eax, 0
mov edx, 61h ; 'a'
loc_1280:
cmp bl, dl
jz short loc_1239
add rax, 1
movzx edx, byte ptr [rbp+rax+0]
test dl, dl
jnz short loc_1280
jmp short loc_1242
loc_1293:
mov r12d, 0
loc_1299:
mov rax, [rsp+48h+var_40]
mov byte ptr [rax+r12], 0
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
long long func0(char *a1, long long a2)
{
char v2; // bl
const unsigned __int16 **v3; // r15
long long v4; // r12
unsigned __int16 v5; // ax
long long v6; // rax
char v7; // dl
long long result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = __ctype_b_loc();
v4 = 0LL;
do
{
v5 = (*v3)[v2];
if ( (v5 & 0x200) != 0 )
{
v2 = (*__ctype_toupper_loc())[v2];
}
else if ( (v5 & 0x100) != 0 )
{
v2 = (*__ctype_tolower_loc())[v2];
}
v6 = 0LL;
v7 = 97;
while ( v2 != v7 )
{
v7 = aAeiouaeiou[++v6];
if ( !v7 )
goto LABEL_7;
}
if ( (int)v6 < 10 )
v2 += 2;
LABEL_7:
*(_BYTE *)(a2 + v4++) = v2;
v2 = a1[v4];
}
while ( v2 );
}
else
{
v4 = 0LL;
}
result = a2;
*(_BYTE *)(a2 + v4) = 0;
return result;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101293
MOV R14,RDI
CALL 0x001010f0
MOV R15,RAX
MOV R12D,0x0
LEA RBP,[0x102004]
JMP 0x00101258
LAB_00101225:
TEST AH,0x1
JZ 0x00101276
CALL 0x001010e0
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + R13*0x4]
JMP 0x00101276
LAB_00101239:
LEA EDX,[RBX + 0x2]
CMP EAX,0xa
CMOVL EBX,EDX
LAB_00101242:
MOV RAX,qword ptr [RSP + 0x8]
MOV byte ptr [RAX + R12*0x1],BL
ADD R12,0x1
MOVZX EBX,byte ptr [R14 + R12*0x1]
TEST BL,BL
JZ 0x00101299
LAB_00101258:
MOVSX R13,BL
MOV RAX,qword ptr [R15]
MOVZX EAX,word ptr [RAX + R13*0x2]
TEST AH,0x2
JZ 0x00101225
CALL 0x001010a0
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + R13*0x4]
LAB_00101276:
MOV EAX,0x0
MOV EDX,0x61
LAB_00101280:
CMP BL,DL
JZ 0x00101239
ADD RAX,0x1
MOVZX EDX,byte ptr [RBP + RAX*0x1]
TEST DL,DL
JNZ 0x00101280
JMP 0x00101242
LAB_00101293:
MOV R12D,0x0
LAB_00101299:
MOV RAX,qword ptr [RSP + 0x8]
MOV byte ptr [RAX + R12*0x1],0x0
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void func0(char *param_1,long param_2)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
char cVar4;
char cVar5;
long lVar6;
cVar5 = *param_1;
if (cVar5 == '\0') {
lVar6 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
lVar6 = 0;
do {
if (((*ppuVar1)[cVar5] & 0x200) == 0) {
if (((*ppuVar1)[cVar5] & 0x100) != 0) {
pp_Var2 = __ctype_tolower_loc();
cVar5 = *(char *)(*pp_Var2 + cVar5);
}
}
else {
pp_Var2 = __ctype_toupper_loc();
cVar5 = *(char *)(*pp_Var2 + cVar5);
}
cVar4 = 'a';
lVar3 = 0;
do {
if (cVar5 == cVar4) {
if ((int)lVar3 < 10) {
cVar5 = cVar5 + '\x02';
}
break;
}
cVar4 = "aeiouAEIOU"[lVar3 + 1];
lVar3 = lVar3 + 1;
} while (cVar4 != '\0');
*(char *)(param_2 + lVar6) = cVar5;
lVar6 = lVar6 + 1;
cVar5 = param_1[lVar6];
} while (cVar5 != '\0');
}
*(int *)(param_2 + lVar6) = 0;
return;
}
|
1,030 |
func0
|
#include <stdio.h>
#include <ctype.h>
#include <string.h>
|
void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for (j = 0; vowels[j] != '\0'; ++j) {
if (w == vowels[j]) {
if (j < 10) {
w = w + 2;
}
break;
}
}
out[i] = w;
}
out[i] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", output);
assert(strcmp(output, "tHKS KS C MGSSCGG") == 0);
func0("I DoNt KnOw WhAt tO WrItE", output);
assert(strcmp(output, "k dQnT kNqW wHcT Tq wRkTg") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
movzbl (%rdi),%ebx
mov %rdi,0x8(%rsp)
test %bl,%bl
je 1417 <func0+0x97>
callq 10d0 <__ctype_b_loc@plt>
xor %r14d,%r14d
lea 0xc54(%rip),%r13
mov %rax,%r12
nopl 0x0(%rax,%rax,1)
mov (%r12),%rax
movsbq %bl,%r15
movzwl (%rax,%r15,2),%eax
test $0x2,%ah
je 1430 <func0+0xb0>
callq 1090 <__ctype_toupper_loc@plt>
mov (%rax),%rax
movzbl (%rax,%r15,4),%ebx
xor %eax,%eax
mov $0x61,%edx
jmp 13ee <func0+0x6e>
add $0x1,%rax
movzbl 0x0(%r13,%rax,1),%edx
test %dl,%dl
je 13fd <func0+0x7d>
mov %eax,%ecx
cmp %dl,%bl
jne 13e0 <func0+0x60>
lea 0x2(%rbx),%eax
cmp $0xa,%ecx
cmovl %eax,%ebx
mov 0x8(%rsp),%rax
mov %bl,0x0(%rbp,%r14,1)
add $0x1,%r14
movzbl (%rax,%r14,1),%ebx
test %bl,%bl
jne 13b8 <func0+0x38>
add %r14,%rbp
movb $0x0,0x0(%rbp)
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
test $0x1,%ah
je 13d7 <func0+0x57>
callq 10c0 <__ctype_tolower_loc@plt>
mov (%rax),%rax
movzbl (%rax,%r15,4),%ebx
jmp 13d7 <func0+0x57>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov [rsp+48h+var_40], rdi
test bl, bl
jz short loc_1423
call ___ctype_b_loc
xor r14d, r14d
lea rbp, aAeiouaeiou; "aeiouAEIOU"
mov r13, rax
nop dword ptr [rax+rax+00h]
loc_13C8:
mov rax, [r13+0]
movsx r15, bl
movzx eax, word ptr [rax+r15*2]
test ah, 2
jz short loc_1440
call ___ctype_toupper_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+r15*4]
loc_13E7:
xor eax, eax
mov edx, 61h ; 'a'
jmp short loc_13FD
loc_13F0:
add rax, 1
movzx edx, byte ptr [rbp+rax+0]
test dl, dl
jz short loc_140A
loc_13FD:
cmp bl, dl
jnz short loc_13F0
lea edx, [rbx+2]
cmp eax, 0Ah
cmovl ebx, edx
loc_140A:
mov rax, [rsp+48h+var_40]
mov [r12+r14], bl
add r14, 1
movzx ebx, byte ptr [rax+r14]
test bl, bl
jnz short loc_13C8
add r12, r14
loc_1423:
mov byte ptr [r12], 0
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
test ah, 1
jz short loc_13E7
call ___ctype_tolower_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+r15*4]
jmp short loc_13E7
|
void func0(char *a1, _BYTE *a2)
{
_BYTE *v2; // r12
char v3; // bl
long long v4; // r14
const unsigned __int16 **v5; // r13
unsigned __int16 v6; // ax
long long v7; // rax
char v8; // dl
v2 = a2;
v3 = *a1;
if ( *a1 )
{
v4 = 0LL;
v5 = __ctype_b_loc();
do
{
v6 = (*v5)[v3];
if ( (v6 & 0x200) != 0 )
{
v3 = (*__ctype_toupper_loc())[v3];
}
else if ( (v6 & 0x100) != 0 )
{
v3 = (*__ctype_tolower_loc())[v3];
}
v7 = 0LL;
v8 = 97;
while ( v3 != v8 )
{
v8 = aAeiouaeiou[++v7];
if ( !v8 )
goto LABEL_10;
}
if ( (int)v7 < 10 )
v3 += 2;
LABEL_10:
a2[v4++] = v3;
v3 = a1[v4];
}
while ( v3 );
v2 = &a2[v4];
}
*v2 = 0;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV qword ptr [RSP + 0x8],RDI
TEST BL,BL
JZ 0x00101423
CALL 0x001010d0
XOR R14D,R14D
LEA RBP,[0x102004]
MOV R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOV RAX,qword ptr [R13]
MOVSX R15,BL
MOVZX EAX,word ptr [RAX + R15*0x2]
TEST AH,0x2
JZ 0x00101440
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + R15*0x4]
LAB_001013e7:
XOR EAX,EAX
MOV EDX,0x61
JMP 0x001013fd
LAB_001013f0:
ADD RAX,0x1
MOVZX EDX,byte ptr [RBP + RAX*0x1]
TEST DL,DL
JZ 0x0010140a
LAB_001013fd:
CMP BL,DL
JNZ 0x001013f0
LEA EDX,[RBX + 0x2]
CMP EAX,0xa
CMOVL EBX,EDX
LAB_0010140a:
MOV RAX,qword ptr [RSP + 0x8]
MOV byte ptr [R12 + R14*0x1],BL
ADD R14,0x1
MOVZX EBX,byte ptr [RAX + R14*0x1]
TEST BL,BL
JNZ 0x001013c8
ADD R12,R14
LAB_00101423:
MOV byte ptr [R12],0x0
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
TEST AH,0x1
JZ 0x001013e7
CALL 0x001010c0
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + R15*0x4]
JMP 0x001013e7
|
void func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
char cVar4;
char cVar5;
long lVar6;
cVar5 = *param_1;
if (cVar5 != '\0') {
ppuVar1 = __ctype_b_loc();
lVar6 = 0;
do {
if (((*ppuVar1)[cVar5] & 0x200) == 0) {
if (((*ppuVar1)[cVar5] & 0x100) != 0) {
pp_Var2 = __ctype_tolower_loc();
cVar5 = *(char *)(*pp_Var2 + cVar5);
}
}
else {
pp_Var2 = __ctype_toupper_loc();
cVar5 = *(char *)(*pp_Var2 + cVar5);
}
cVar4 = 'a';
lVar3 = 0;
do {
if (cVar5 == cVar4) {
if ((int)lVar3 < 10) {
cVar5 = cVar5 + '\x02';
}
break;
}
cVar4 = "aeiouAEIOU"[lVar3 + 1];
lVar3 = lVar3 + 1;
} while (cVar4 != '\0');
param_2[lVar6] = cVar5;
lVar6 = lVar6 + 1;
cVar5 = param_1[lVar6];
} while (cVar5 != '\0');
param_2 = param_2 + lVar6;
}
*param_2 = 0;
return;
}
|
1,031 |
func0
|
#include <stdio.h>
#include <ctype.h>
#include <string.h>
|
void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for (j = 0; vowels[j] != '\0'; ++j) {
if (w == vowels[j]) {
if (j < 10) {
w = w + 2;
}
break;
}
}
out[i] = w;
}
out[i] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", output);
assert(strcmp(output, "tHKS KS C MGSSCGG") == 0);
func0("I DoNt KnOw WhAt tO WrItE", output);
assert(strcmp(output, "k dQnT kNqW wHcT Tq wRkTg") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
movzbl (%rdi),%ebx
mov %rdi,0x8(%rsp)
test %bl,%bl
je 1417 <func0+0x97>
callq 10d0 <__ctype_b_loc@plt>
xor %r14d,%r14d
lea 0xc54(%rip),%r13
mov %rax,%r12
nopl 0x0(%rax,%rax,1)
mov (%r12),%rax
movsbq %bl,%r15
movzwl (%rax,%r15,2),%eax
test $0x2,%ah
je 1430 <func0+0xb0>
callq 1090 <__ctype_toupper_loc@plt>
mov (%rax),%rax
movzbl (%rax,%r15,4),%ebx
xor %eax,%eax
mov $0x61,%edx
jmp 13ee <func0+0x6e>
add $0x1,%rax
movzbl 0x0(%r13,%rax,1),%edx
test %dl,%dl
je 13fd <func0+0x7d>
mov %eax,%ecx
cmp %dl,%bl
jne 13e0 <func0+0x60>
lea 0x2(%rbx),%eax
cmp $0xa,%ecx
cmovl %eax,%ebx
mov 0x8(%rsp),%rax
mov %bl,0x0(%rbp,%r14,1)
add $0x1,%r14
movzbl (%rax,%r14,1),%ebx
test %bl,%bl
jne 13b8 <func0+0x38>
add %r14,%rbp
movb $0x0,0x0(%rbp)
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
test $0x1,%ah
je 13d7 <func0+0x57>
callq 10c0 <__ctype_tolower_loc@plt>
mov (%rax),%rax
movzbl (%rax,%r15,4),%ebx
jmp 13d7 <func0+0x57>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov [rsp+48h+var_40], rdi
test bl, bl
jz short loc_1423
call ___ctype_b_loc
xor r14d, r14d
lea rbp, aAeiouaeiou; "aeiouAEIOU"
mov r13, rax
nop dword ptr [rax+rax+00h]
loc_13C8:
mov rax, [r13+0]
movsx r15, bl
movzx eax, word ptr [rax+r15*2]
test ah, 2
jz short loc_1440
call ___ctype_toupper_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+r15*4]
loc_13E7:
xor eax, eax
mov edx, 61h ; 'a'
jmp short loc_13FD
loc_13F0:
add rax, 1
movzx edx, byte ptr [rbp+rax+0]
test dl, dl
jz short loc_140A
loc_13FD:
cmp bl, dl
jnz short loc_13F0
lea edx, [rbx+2]
cmp eax, 0Ah
cmovl ebx, edx
loc_140A:
mov rax, [rsp+48h+var_40]
mov [r12+r14], bl
add r14, 1
movzx ebx, byte ptr [rax+r14]
test bl, bl
jnz short loc_13C8
add r12, r14
loc_1423:
mov byte ptr [r12], 0
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
test ah, 1
jz short loc_13E7
call ___ctype_tolower_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+r15*4]
jmp short loc_13E7
|
void func0(char *a1, _BYTE *a2)
{
_BYTE *v2; // r12
char v3; // bl
long long v4; // r14
const unsigned __int16 **v5; // r13
unsigned __int16 v6; // ax
long long v7; // rax
char v8; // dl
v2 = a2;
v3 = *a1;
if ( *a1 )
{
v4 = 0LL;
v5 = __ctype_b_loc();
do
{
v6 = (*v5)[v3];
if ( (v6 & 0x200) != 0 )
{
v3 = (*__ctype_toupper_loc())[v3];
}
else if ( (v6 & 0x100) != 0 )
{
v3 = (*__ctype_tolower_loc())[v3];
}
v7 = 0LL;
v8 = 97;
while ( v3 != v8 )
{
v8 = aAeiouaeiou[++v7];
if ( !v8 )
goto LABEL_10;
}
if ( (int)v7 < 10 )
v3 += 2;
LABEL_10:
a2[v4++] = v3;
v3 = a1[v4];
}
while ( v3 );
v2 = &a2[v4];
}
*v2 = 0;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV qword ptr [RSP + 0x8],RDI
TEST BL,BL
JZ 0x00101423
CALL 0x001010d0
XOR R14D,R14D
LEA RBP,[0x102004]
MOV R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOV RAX,qword ptr [R13]
MOVSX R15,BL
MOVZX EAX,word ptr [RAX + R15*0x2]
TEST AH,0x2
JZ 0x00101440
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + R15*0x4]
LAB_001013e7:
XOR EAX,EAX
MOV EDX,0x61
JMP 0x001013fd
LAB_001013f0:
ADD RAX,0x1
MOVZX EDX,byte ptr [RBP + RAX*0x1]
TEST DL,DL
JZ 0x0010140a
LAB_001013fd:
CMP BL,DL
JNZ 0x001013f0
LEA EDX,[RBX + 0x2]
CMP EAX,0xa
CMOVL EBX,EDX
LAB_0010140a:
MOV RAX,qword ptr [RSP + 0x8]
MOV byte ptr [R12 + R14*0x1],BL
ADD R14,0x1
MOVZX EBX,byte ptr [RAX + R14*0x1]
TEST BL,BL
JNZ 0x001013c8
ADD R12,R14
LAB_00101423:
MOV byte ptr [R12],0x0
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
TEST AH,0x1
JZ 0x001013e7
CALL 0x001010c0
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + R15*0x4]
JMP 0x001013e7
|
void func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
char cVar4;
char cVar5;
long lVar6;
cVar5 = *param_1;
if (cVar5 != '\0') {
ppuVar1 = __ctype_b_loc();
lVar6 = 0;
do {
if (((*ppuVar1)[cVar5] & 0x200) == 0) {
if (((*ppuVar1)[cVar5] & 0x100) != 0) {
pp_Var2 = __ctype_tolower_loc();
cVar5 = *(char *)(*pp_Var2 + cVar5);
}
}
else {
pp_Var2 = __ctype_toupper_loc();
cVar5 = *(char *)(*pp_Var2 + cVar5);
}
cVar4 = 'a';
lVar3 = 0;
do {
if (cVar5 == cVar4) {
if ((int)lVar3 < 10) {
cVar5 = cVar5 + '\x02';
}
break;
}
cVar4 = "aeiouAEIOU"[lVar3 + 1];
lVar3 = lVar3 + 1;
} while (cVar4 != '\0');
param_2[lVar6] = cVar5;
lVar6 = lVar6 + 1;
cVar5 = param_1[lVar6];
} while (cVar5 != '\0');
param_2 = param_2 + lVar6;
}
*param_2 = 0;
return;
}
|
1,032 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
break;
}
}
if (prime) {
largest = num > largest ? num : largest;
}
}
}
while (largest > 0) {
sum += largest % 10;
largest /= 10;
}
return sum;
}
|
#include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3};
assert(func0(lst3, sizeof(lst3)/sizeof(lst3[0])) == 13);
int lst4[] = {0,724,32,71,99,32,6,0,5,91,83,0,5,6};
assert(func0(lst4, sizeof(lst4)/sizeof(lst4[0])) == 11);
int lst5[] = {0,81,12,3,1,21};
assert(func0(lst5, sizeof(lst5)/sizeof(lst5[0])) == 3);
int lst6[] = {0,8,1,2,1,7};
assert(func0(lst6, sizeof(lst6)/sizeof(lst6[0])) == 7);
int lst7[] = {8191};
assert(func0(lst7, sizeof(lst7)/sizeof(lst7[0])) == 19);
int lst8[] = {8191, 123456, 127, 7};
assert(func0(lst8, sizeof(lst8)/sizeof(lst8[0])) == 19);
int lst9[] = {127, 97, 8192};
assert(func0(lst9, sizeof(lst9)/sizeof(lst9[0])) == 10);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11fa <func0+0x91>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jle 11f6 <func0+0x8d>
movl $0x1,-0xc(%rbp)
movl $0x2,-0x8(%rbp)
jmp 11d8 <func0+0x6f>
mov -0x4(%rbp),%eax
cltd
idivl -0x8(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11d4 <func0+0x6b>
movl $0x0,-0xc(%rbp)
jmp 11e3 <func0+0x7a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x4(%rbp)
jge 11be <func0+0x55>
cmpl $0x0,-0xc(%rbp)
je 11f6 <func0+0x8d>
mov -0x4(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovge -0x18(%rbp),%eax
mov %eax,-0x18(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 118f <func0+0x26>
jmp 124f <func0+0xe6>
mov -0x18(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
add %edx,-0x14(%rbp)
mov -0x18(%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,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
jg 1204 <func0+0x9b>
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_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_11FB
loc_118F:
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_4], eax
cmp [rbp+var_4], 1
jle short loc_11F7
mov [rbp+var_C], 1
mov [rbp+var_8], 2
jmp short loc_11D8
loc_11BE:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_8]
mov eax, edx
test eax, eax
jnz short loc_11D4
mov [rbp+var_C], 0
jmp short loc_11E3
loc_11D4:
add [rbp+var_8], 1
loc_11D8:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_4], eax
jge short loc_11BE
loc_11E3:
cmp [rbp+var_C], 0
jz short loc_11F7
mov edx, [rbp+var_18]
mov eax, [rbp+var_4]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_18], eax
loc_11F7:
add [rbp+var_10], 1
loc_11FB:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl short loc_118F
jmp short loc_1250
loc_1205:
mov ecx, [rbp+var_18]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
add [rbp+var_14], edx
mov eax, [rbp+var_18]
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_18], eax
loc_1250:
cmp [rbp+var_18], 0
jg short loc_1205
mov eax, [rbp+var_14]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int v2; // eax
int v4; // [rsp+14h] [rbp-18h]
unsigned int v5; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int v7; // [rsp+20h] [rbp-Ch]
int j; // [rsp+24h] [rbp-8h]
int v9; // [rsp+28h] [rbp-4h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2; ++i )
{
v9 = *(_DWORD *)(4LL * i + a1);
if ( v9 > 1 )
{
v7 = 1;
for ( j = 2; v9 >= j * j; ++j )
{
if ( !(v9 % j) )
{
v7 = 0;
break;
}
}
if ( v7 )
{
v2 = *(_DWORD *)(4LL * i + a1);
if ( v4 >= v9 )
v2 = v4;
v4 = v2;
}
}
}
while ( v4 > 0 )
{
v5 += v4 % 10;
v4 /= 10;
}
return v5;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011fb
LAB_0010118f:
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 + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x1
JLE 0x001011f7
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x2
JMP 0x001011d8
LAB_001011be:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x8]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011d4
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011e3
LAB_001011d4:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x4],EAX
JGE 0x001011be
LAB_001011e3:
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011f7
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x4]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x18],EAX
LAB_001011f7:
ADD dword ptr [RBP + -0x10],0x1
LAB_001011fb:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010118f
JMP 0x00101250
LAB_00101205:
MOV ECX,dword ptr [RBP + -0x18]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
ADD dword ptr [RBP + -0x14],EDX
MOV EAX,dword ptr [RBP + -0x18]
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 + -0x18],EAX
LAB_00101250:
CMP dword ptr [RBP + -0x18],0x0
JG 0x00101205
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int iVar1;
bool bVar2;
int iVar3;
int local_20;
int local_1c;
int local_18;
int local_10;
local_20 = 0;
local_1c = 0;
local_18 = 0;
do {
if (param_2 <= local_18) {
for (; 0 < local_20; local_20 = local_20 / 10) {
local_1c = local_1c + local_20 % 10;
}
return local_1c;
}
iVar1 = *(int *)(param_1 + (long)local_18 * 4);
iVar3 = local_20;
if (1 < iVar1) {
bVar2 = true;
for (local_10 = 2; local_10 * local_10 <= iVar1; local_10 = local_10 + 1) {
if (iVar1 % local_10 == 0) {
bVar2 = false;
break;
}
}
if ((bVar2) && (iVar3 = iVar1, iVar1 <= local_20)) {
iVar3 = local_20;
}
}
local_20 = iVar3;
local_18 = local_18 + 1;
} while( true );
}
|
1,033 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
break;
}
}
if (prime) {
largest = num > largest ? num : largest;
}
}
}
while (largest > 0) {
sum += largest % 10;
largest /= 10;
}
return sum;
}
|
#include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3};
assert(func0(lst3, sizeof(lst3)/sizeof(lst3[0])) == 13);
int lst4[] = {0,724,32,71,99,32,6,0,5,91,83,0,5,6};
assert(func0(lst4, sizeof(lst4)/sizeof(lst4[0])) == 11);
int lst5[] = {0,81,12,3,1,21};
assert(func0(lst5, sizeof(lst5)/sizeof(lst5[0])) == 3);
int lst6[] = {0,8,1,2,1,7};
assert(func0(lst6, sizeof(lst6)/sizeof(lst6[0])) == 7);
int lst7[] = {8191};
assert(func0(lst7, sizeof(lst7)/sizeof(lst7[0])) == 19);
int lst8[] = {8191, 123456, 127, 7};
assert(func0(lst8, sizeof(lst8)/sizeof(lst8[0])) == 19);
int lst9[] = {127, 97, 8192};
assert(func0(lst9, sizeof(lst9)/sizeof(lst9[0])) == 10);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11b8 <func0+0x4f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%edi
jmp 11d4 <func0+0x6b>
test %edi,%edi
jle 11bf <func0+0x56>
mov $0x0,%ecx
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%edx
add %edx,%edx
mov %edi,%esi
sub %edx,%esi
add %esi,%ecx
mov %edi,%edx
mov %eax,%edi
cmp $0x9,%edx
jg 118c <func0+0x23>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 11b5 <func0+0x4c>
mov $0x0,%ecx
jmp 11b5 <func0+0x4c>
cmp %esi,%edi
cmovl %esi,%edi
add $0x4,%r8
cmp %r9,%r8
je 1183 <func0+0x1a>
mov (%r8),%esi
cmp $0x1,%esi
jle 11cb <func0+0x62>
cmp $0x3,%esi
jle 11c6 <func0+0x5d>
test $0x1,%sil
je 11cb <func0+0x62>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jg 11c6 <func0+0x5d>
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 11ec <func0+0x83>
jmp 11cb <func0+0x62>
|
func0:
endbr64
test esi, esi
jle loc_11F8
mov r8, rdi
movsxd rsi, esi
lea r9, [rdi+rsi*4]
mov edi, 0
jmp short loc_1194
loc_1186:
cmp edi, esi
cmovl edi, esi
loc_118B:
add r8, 4
cmp r9, r8
jz short loc_11C3
loc_1194:
mov esi, [r8]
cmp esi, 1
jle short loc_118B
cmp esi, 3
jle short loc_1186
test sil, 1
jz short loc_118B
mov ecx, 2
loc_11AC:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jg short loc_1186
mov eax, esi
cdq
idiv ecx
test edx, edx
jnz short loc_11AC
jmp short loc_118B
loc_11C3:
test edi, edi
jle short loc_11FF
mov ecx, 0
loc_11CC:
movsxd rax, edi
imul rax, 66666667h
sar rax, 22h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea edx, [rax+rax*4]
add edx, edx
mov esi, edi
sub esi, edx
add ecx, esi
mov edx, edi
mov edi, eax
cmp edx, 9
jg short loc_11CC
loc_11F5:
mov eax, ecx
retn
loc_11F8:
mov ecx, 0
jmp short loc_11F5
loc_11FF:
mov ecx, 0
jmp short loc_11F5
|
long long func0(int *a1, int a2)
{
int *v2; // r8
int *v3; // r9
int v4; // edi
int v5; // esi
int v6; // ecx
unsigned int v7; // ecx
int v8; // edx
if ( a2 <= 0 )
return 0;
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
v5 = *v2;
if ( *v2 <= 1 )
goto LABEL_5;
if ( v5 > 3 )
{
if ( (v5 & 1) == 0 )
goto LABEL_5;
v6 = 2;
while ( 1 )
{
++v6;
if ( v6 * v6 > v5 )
break;
if ( !(v5 % v6) )
goto LABEL_5;
}
}
if ( v4 < v5 )
v4 = *v2;
LABEL_5:
++v2;
}
while ( v3 != v2 );
if ( v4 <= 0 )
{
return 0;
}
else
{
v7 = 0;
do
{
v7 += v4 % 10;
v8 = v4;
v4 /= 10;
}
while ( v8 > 9 );
}
return v7;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011f8
MOV R8,RDI
MOVSXD RSI,ESI
LEA R9,[RDI + RSI*0x4]
MOV EDI,0x0
JMP 0x00101194
LAB_00101186:
CMP EDI,ESI
CMOVL EDI,ESI
LAB_0010118b:
ADD R8,0x4
CMP R9,R8
JZ 0x001011c3
LAB_00101194:
MOV ESI,dword ptr [R8]
CMP ESI,0x1
JLE 0x0010118b
CMP ESI,0x3
JLE 0x00101186
TEST SIL,0x1
JZ 0x0010118b
MOV ECX,0x2
LAB_001011ac:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JG 0x00101186
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001011ac
JMP 0x0010118b
LAB_001011c3:
TEST EDI,EDI
JLE 0x001011ff
MOV ECX,0x0
LAB_001011cc:
MOVSXD RAX,EDI
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
MOV ESI,EDI
SUB ESI,EDX
ADD ECX,ESI
MOV EDX,EDI
MOV EDI,EAX
CMP EDX,0x9
JG 0x001011cc
LAB_001011f5:
MOV EAX,ECX
RET
LAB_001011f8:
MOV ECX,0x0
JMP 0x001011f5
LAB_001011ff:
MOV ECX,0x0
JMP 0x001011f5
|
int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
int iVar4;
uint uVar5;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar1 = param_1 + param_2;
uVar5 = 0;
do {
uVar2 = *param_1;
if (1 < (int)uVar2) {
if ((int)uVar2 < 4) {
LAB_00101186:
if ((int)uVar5 < (int)uVar2) {
uVar5 = uVar2;
}
}
else if ((uVar2 & 1) != 0) {
iVar4 = 2;
do {
iVar4 = iVar4 + 1;
if ((int)uVar2 < iVar4 * iVar4) goto LAB_00101186;
} while ((int)uVar2 % iVar4 != 0);
}
}
param_1 = param_1 + 1;
} while (puVar1 != param_1);
if ((int)uVar5 < 1) {
iVar4 = 0;
}
else {
iVar4 = 0;
do {
iVar4 = iVar4 + (int)uVar5 % 10;
bVar3 = 9 < (int)uVar5;
uVar5 = (int)uVar5 / 10;
} while (bVar3);
}
}
return iVar4;
}
|
1,034 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
break;
}
}
if (prime) {
largest = num > largest ? num : largest;
}
}
}
while (largest > 0) {
sum += largest % 10;
largest /= 10;
}
return sum;
}
|
#include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3};
assert(func0(lst3, sizeof(lst3)/sizeof(lst3[0])) == 13);
int lst4[] = {0,724,32,71,99,32,6,0,5,91,83,0,5,6};
assert(func0(lst4, sizeof(lst4)/sizeof(lst4[0])) == 11);
int lst5[] = {0,81,12,3,1,21};
assert(func0(lst5, sizeof(lst5)/sizeof(lst5[0])) == 3);
int lst6[] = {0,8,1,2,1,7};
assert(func0(lst6, sizeof(lst6)/sizeof(lst6[0])) == 7);
int lst7[] = {8191};
assert(func0(lst7, sizeof(lst7)/sizeof(lst7[0])) == 19);
int lst8[] = {8191, 123456, 127, 7};
assert(func0(lst8, sizeof(lst8)/sizeof(lst8[0])) == 19);
int lst9[] = {127, 97, 8192};
assert(func0(lst9, sizeof(lst9)/sizeof(lst9[0])) == 10);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1711 <func0+0xa1>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%r9
jmp 1699 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rdi
cmp %r9,%rdi
je 16e0 <func0+0x70>
mov (%rdi),%esi
cmp $0x1,%esi
jle 1690 <func0+0x20>
cmp $0x3,%esi
jle 16cd <func0+0x5d>
test $0x1,%sil
je 1690 <func0+0x20>
mov $0x2,%ecx
jmp 16c1 <func0+0x51>
nopw 0x0(%rax,%rax,1)
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1690 <func0+0x20>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jle 16b8 <func0+0x48>
cmp %esi,%r8d
cmovl %esi,%r8d
add $0x4,%rdi
cmp %r9,%rdi
jne 1699 <func0+0x29>
nopl (%rax)
xor %r9d,%r9d
test %r8d,%r8d
je 170d <func0+0x9d>
mov $0xcccccccd,%ecx
nopl (%rax)
mov %r8d,%eax
imul %rcx,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%edx
add %edx,%edx
sub %edx,%r8d
add %r8d,%r9d
mov %eax,%r8d
test %eax,%eax
jne 16f0 <func0+0x80>
mov %r9d,%eax
retq
xor %r9d,%r9d
mov %r9d,%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle loc_15D5
movsxd rsi, esi
xor r8d, r8d
lea r9, [rdi+rsi*4]
jmp short loc_1559
loc_1550:
add rdi, 4
cmp r9, rdi
jz short loc_15A0
loc_1559:
mov esi, [rdi]
cmp esi, 1
jle short loc_1550
cmp esi, 3
jle short loc_158D
test sil, 1
jz short loc_1550
mov ecx, 2
jmp short loc_1581
loc_1578:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1550
loc_1581:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_1578
loc_158D:
cmp r8d, esi
cmovl r8d, esi
add rdi, 4
cmp r9, rdi
jnz short loc_1559
nop dword ptr [rax]
loc_15A0:
xor ecx, ecx
test r8d, r8d
jle short loc_15D2
mov edi, 0CCCCCCCDh
nop dword ptr [rax+00h]
loc_15B0:
mov eax, r8d
mov esi, r8d
imul rax, rdi
shr rax, 23h
lea edx, [rax+rax*4]
add edx, edx
sub esi, edx
mov edx, r8d
mov r8d, eax
add ecx, esi
cmp edx, 9
jg short loc_15B0
loc_15D2:
mov eax, ecx
retn
loc_15D5:
xor ecx, ecx
mov eax, ecx
retn
|
long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // r9
int v4; // esi
int v5; // ecx
unsigned int v6; // ecx
unsigned int v7; // esi
int v8; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
v4 = *a1;
if ( *a1 > 1 )
{
if ( v4 <= 3 )
goto LABEL_10;
if ( (v4 & 1) != 0 )
break;
}
LABEL_3:
if ( v3 == ++a1 )
goto LABEL_13;
}
v5 = 2;
while ( 1 )
{
++v5;
if ( v5 * v5 > v4 )
break;
if ( !(v4 % v5) )
goto LABEL_3;
}
LABEL_10:
if ( v2 < v4 )
v2 = *a1;
++a1;
}
while ( v3 != a1 );
LABEL_13:
v6 = 0;
if ( v2 > 0 )
{
do
{
v7 = v2 % 0xAu;
v8 = v2;
v2 /= 0xAu;
v6 += v7;
}
while ( v8 > 9 );
}
return v6;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001015d5
MOVSXD RSI,ESI
XOR R8D,R8D
LEA R9,[RDI + RSI*0x4]
JMP 0x00101559
LAB_00101550:
ADD RDI,0x4
CMP R9,RDI
JZ 0x001015a0
LAB_00101559:
MOV ESI,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101550
CMP ESI,0x3
JLE 0x0010158d
TEST SIL,0x1
JZ 0x00101550
MOV ECX,0x2
JMP 0x00101581
LAB_00101578:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101550
LAB_00101581:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x00101578
LAB_0010158d:
CMP R8D,ESI
CMOVL R8D,ESI
ADD RDI,0x4
CMP R9,RDI
JNZ 0x00101559
NOP dword ptr [RAX]
LAB_001015a0:
XOR ECX,ECX
TEST R8D,R8D
JLE 0x001015d2
MOV EDI,0xcccccccd
NOP dword ptr [RAX]
LAB_001015b0:
MOV EAX,R8D
MOV ESI,R8D
IMUL RAX,RDI
SHR RAX,0x23
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
SUB ESI,EDX
MOV EDX,R8D
MOV R8D,EAX
ADD ECX,ESI
CMP EDX,0x9
JG 0x001015b0
LAB_001015d2:
MOV EAX,ECX
RET
LAB_001015d5:
XOR ECX,ECX
MOV EAX,ECX
RET
|
int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
int iVar4;
uint uVar5;
if (param_2 < 1) {
return 0;
}
uVar5 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (1 < (int)uVar2) {
if ((int)uVar2 < 4) {
LAB_0010158d:
if ((int)uVar5 < (int)uVar2) {
uVar5 = uVar2;
}
}
else if ((uVar2 & 1) != 0) {
iVar4 = 2;
do {
iVar4 = iVar4 + 1;
if ((int)uVar2 < iVar4 * iVar4) goto LAB_0010158d;
} while ((int)uVar2 % iVar4 != 0);
}
}
param_1 = param_1 + 1;
if (puVar1 == param_1) {
iVar4 = 0;
if (0 < (int)uVar5) {
do {
iVar4 = iVar4 + uVar5 % 10;
bVar3 = 9 < (int)uVar5;
uVar5 = uVar5 / 10;
} while (bVar3);
}
return iVar4;
}
} while( true );
}
|
1,035 |
func0
|
#include <stdio.h>
|
int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
break;
}
}
if (prime) {
largest = num > largest ? num : largest;
}
}
}
while (largest > 0) {
sum += largest % 10;
largest /= 10;
}
return sum;
}
|
#include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3};
assert(func0(lst3, sizeof(lst3)/sizeof(lst3[0])) == 13);
int lst4[] = {0,724,32,71,99,32,6,0,5,91,83,0,5,6};
assert(func0(lst4, sizeof(lst4)/sizeof(lst4[0])) == 11);
int lst5[] = {0,81,12,3,1,21};
assert(func0(lst5, sizeof(lst5)/sizeof(lst5[0])) == 3);
int lst6[] = {0,8,1,2,1,7};
assert(func0(lst6, sizeof(lst6)/sizeof(lst6[0])) == 7);
int lst7[] = {8191};
assert(func0(lst7, sizeof(lst7)/sizeof(lst7[0])) == 19);
int lst8[] = {8191, 123456, 127, 7};
assert(func0(lst8, sizeof(lst8)/sizeof(lst8[0])) == 19);
int lst9[] = {127, 97, 8192};
assert(func0(lst9, sizeof(lst9)/sizeof(lst9[0])) == 10);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 15e1 <func0+0xa1>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%r9
jmp 1569 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rdi
cmp %r9,%rdi
je 15b0 <func0+0x70>
mov (%rdi),%esi
cmp $0x1,%esi
jle 1560 <func0+0x20>
cmp $0x3,%esi
jle 159d <func0+0x5d>
test $0x1,%sil
je 1560 <func0+0x20>
mov $0x2,%ecx
jmp 1591 <func0+0x51>
nopw 0x0(%rax,%rax,1)
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1560 <func0+0x20>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jle 1588 <func0+0x48>
cmp %esi,%r8d
cmovl %esi,%r8d
add $0x4,%rdi
cmp %r9,%rdi
jne 1569 <func0+0x29>
nopl (%rax)
xor %r9d,%r9d
test %r8d,%r8d
je 15dd <func0+0x9d>
mov $0xcccccccd,%ecx
nopl (%rax)
mov %r8d,%eax
imul %rcx,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%edx
add %edx,%edx
sub %edx,%r8d
add %r8d,%r9d
mov %eax,%r8d
test %eax,%eax
jne 15c0 <func0+0x80>
mov %r9d,%eax
retq
xor %r9d,%r9d
mov %r9d,%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle loc_15D5
movsxd rsi, esi
xor r8d, r8d
lea r9, [rdi+rsi*4]
jmp short loc_1559
loc_1550:
add rdi, 4
cmp r9, rdi
jz short loc_15A0
loc_1559:
mov esi, [rdi]
cmp esi, 1
jle short loc_1550
cmp esi, 3
jle short loc_158D
test sil, 1
jz short loc_1550
mov ecx, 2
jmp short loc_1581
loc_1578:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1550
loc_1581:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_1578
loc_158D:
cmp r8d, esi
cmovl r8d, esi
add rdi, 4
cmp r9, rdi
jnz short loc_1559
nop dword ptr [rax]
loc_15A0:
xor ecx, ecx
test r8d, r8d
jle short loc_15D2
mov edi, 0CCCCCCCDh
nop dword ptr [rax+00h]
loc_15B0:
mov eax, r8d
mov esi, r8d
imul rax, rdi
shr rax, 23h
lea edx, [rax+rax*4]
add edx, edx
sub esi, edx
mov edx, r8d
mov r8d, eax
add ecx, esi
cmp edx, 9
jg short loc_15B0
loc_15D2:
mov eax, ecx
retn
loc_15D5:
xor ecx, ecx
mov eax, ecx
retn
|
long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // r9
int v4; // esi
int v5; // ecx
unsigned int v6; // ecx
unsigned int v7; // esi
int v8; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
v4 = *a1;
if ( *a1 > 1 )
{
if ( v4 <= 3 )
goto LABEL_10;
if ( (v4 & 1) != 0 )
break;
}
LABEL_3:
if ( v3 == ++a1 )
goto LABEL_13;
}
v5 = 2;
while ( 1 )
{
++v5;
if ( v5 * v5 > v4 )
break;
if ( !(v4 % v5) )
goto LABEL_3;
}
LABEL_10:
if ( v2 < v4 )
v2 = *a1;
++a1;
}
while ( v3 != a1 );
LABEL_13:
v6 = 0;
if ( v2 > 0 )
{
do
{
v7 = v2 % 0xAu;
v8 = v2;
v2 /= 0xAu;
v6 += v7;
}
while ( v8 > 9 );
}
return v6;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001015d5
MOVSXD RSI,ESI
XOR R8D,R8D
LEA R9,[RDI + RSI*0x4]
JMP 0x00101559
LAB_00101550:
ADD RDI,0x4
CMP R9,RDI
JZ 0x001015a0
LAB_00101559:
MOV ESI,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101550
CMP ESI,0x3
JLE 0x0010158d
TEST SIL,0x1
JZ 0x00101550
MOV ECX,0x2
JMP 0x00101581
LAB_00101578:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101550
LAB_00101581:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x00101578
LAB_0010158d:
CMP R8D,ESI
CMOVL R8D,ESI
ADD RDI,0x4
CMP R9,RDI
JNZ 0x00101559
NOP dword ptr [RAX]
LAB_001015a0:
XOR ECX,ECX
TEST R8D,R8D
JLE 0x001015d2
MOV EDI,0xcccccccd
NOP dword ptr [RAX]
LAB_001015b0:
MOV EAX,R8D
MOV ESI,R8D
IMUL RAX,RDI
SHR RAX,0x23
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
SUB ESI,EDX
MOV EDX,R8D
MOV R8D,EAX
ADD ECX,ESI
CMP EDX,0x9
JG 0x001015b0
LAB_001015d2:
MOV EAX,ECX
RET
LAB_001015d5:
XOR ECX,ECX
MOV EAX,ECX
RET
|
int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
int iVar4;
uint uVar5;
if (param_2 < 1) {
return 0;
}
uVar5 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (1 < (int)uVar2) {
if ((int)uVar2 < 4) {
LAB_0010158d:
if ((int)uVar5 < (int)uVar2) {
uVar5 = uVar2;
}
}
else if ((uVar2 & 1) != 0) {
iVar4 = 2;
do {
iVar4 = iVar4 + 1;
if ((int)uVar2 < iVar4 * iVar4) goto LAB_0010158d;
} while ((int)uVar2 % iVar4 != 0);
}
}
param_1 = param_1 + 1;
if (puVar1 == param_1) {
iVar4 = 0;
if (0 < (int)uVar5) {
do {
iVar4 = iVar4 + uVar5 % 10;
bVar3 = 9 < (int)uVar5;
uVar5 = uVar5 / 10;
} while (bVar3);
}
return iVar4;
}
} while( true );
}
|
1,036 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j])) has_upper = 1;
if (islower((unsigned char)key[j])) has_lower = 1;
if (has_upper + has_lower == 2) return 0;
}
}
return 1;
}
|
#include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
assert(func0(test3, 3) == 0);
char* test4[][2] = {{"Name","John"}, {"Age","36"}, {"City","Houston"}};
assert(func0(test4, 3) == 0);
char* test5[][2] = {{"STATE","NC"}, {"ZIP","12345"}};
assert(func0(test5, 2) == 1);
char* test6[][2] = {{"fruit","Orange"}, {"taste","Sweet"}};
assert(func0(test6, 2) == 1);
assert(func0(NULL, 0) == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
cmpl $0x0,-0x2c(%rbp)
jne 11ac <func0+0x23>
mov $0x0,%eax
jmpq 12d9 <func0+0x150>
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 12c8 <func0+0x13f>
mov -0x10(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 12ac <func0+0x123>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x400,%eax
test %eax,%eax
jne 1226 <func0+0x9d>
mov $0x0,%eax
jmpq 12d9 <func0+0x150>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 125d <func0+0xd4>
movl $0x1,-0x14(%rbp)
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 1294 <func0+0x10b>
movl $0x1,-0x18(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
cmp $0x2,%eax
jne 12a8 <func0+0x11f>
mov $0x0,%eax
jmp 12d9 <func0+0x150>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11ec <func0+0x63>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11c6 <func0+0x3d>
mov $0x1,%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
cmp [rbp+var_2C], 0
jnz short loc_11AC
mov eax, 0
jmp locret_12D9
loc_11AC:
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp loc_12C8
loc_11C6:
mov eax, [rbp+var_10]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp loc_12AC
loc_11EC:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rcx, edx
mov rdx, [rbp+var_8]
add rdx, rcx
movzx edx, byte ptr [rdx]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 400h
test eax, eax
jnz short loc_1226
mov eax, 0
jmp locret_12D9
loc_1226:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rcx, edx
mov rdx, [rbp+var_8]
add rdx, rcx
movzx edx, byte ptr [rdx]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_125D
mov [rbp+var_14], 1
loc_125D:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rcx, edx
mov rdx, [rbp+var_8]
add rdx, rcx
movzx edx, byte ptr [rdx]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jz short loc_1294
mov [rbp+var_18], 1
loc_1294:
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add eax, edx
cmp eax, 2
jnz short loc_12A8
mov eax, 0
jmp short locret_12D9
loc_12A8:
add [rbp+var_C], 1
loc_12AC:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11EC
add [rbp+var_10], 1
loc_12C8:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl loc_11C6
mov eax, 1
locret_12D9:
leave
retn
|
long long func0(long long a1, int a2)
{
int v3; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
long long v7; // [rsp+28h] [rbp-8h]
if ( !a2 )
return 0LL;
v3 = 0;
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v7 = *(_QWORD *)(16LL * i + a1);
for ( j = 0; *(_BYTE *)(j + v7); ++j )
{
if ( ((*__ctype_b_loc())[*(unsigned __int8 *)(j + v7)] & 0x400) == 0 )
return 0LL;
if ( ((*__ctype_b_loc())[*(unsigned __int8 *)(j + v7)] & 0x100) != 0 )
v4 = 1;
if ( ((*__ctype_b_loc())[*(unsigned __int8 *)(j + v7)] & 0x200) != 0 )
v3 = 1;
if ( v4 + v3 == 2 )
return 0LL;
}
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x001011ac
MOV EAX,0x0
JMP 0x001012d9
LAB_001011ac:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012c8
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012ac
LAB_001011ec:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x400
TEST EAX,EAX
JNZ 0x00101226
MOV EAX,0x0
JMP 0x001012d9
LAB_00101226:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x0010125d
MOV dword ptr [RBP + -0x14],0x1
LAB_0010125d:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x00101294
MOV dword ptr [RBP + -0x18],0x1
LAB_00101294:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
CMP EAX,0x2
JNZ 0x001012a8
MOV EAX,0x0
JMP 0x001012d9
LAB_001012a8:
ADD dword ptr [RBP + -0xc],0x1
LAB_001012ac:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011ec
ADD dword ptr [RBP + -0x10],0x1
LAB_001012c8:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011c6
MOV EAX,0x1
LAB_001012d9:
LEAVE
RET
|
int8 func0(long param_1,int param_2)
{
long lVar1;
int8 uVar2;
ushort **ppuVar3;
int local_20;
int local_1c;
int local_18;
int local_14;
if (param_2 == 0) {
uVar2 = 0;
}
else {
local_20 = 0;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
lVar1 = *(long *)(param_1 + (long)local_18 * 0x10);
for (local_14 = 0; *(char *)(lVar1 + local_14) != '\0'; local_14 = local_14 + 1) {
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[*(byte *)(lVar1 + local_14)] & 0x400) == 0) {
return 0;
}
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[*(byte *)(lVar1 + local_14)] & 0x100) != 0) {
local_1c = 1;
}
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[*(byte *)(lVar1 + local_14)] & 0x200) != 0) {
local_20 = 1;
}
if (local_20 + local_1c == 2) {
return 0;
}
}
}
uVar2 = 1;
}
return uVar2;
}
|
1,037 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j])) has_upper = 1;
if (islower((unsigned char)key[j])) has_lower = 1;
if (has_upper + has_lower == 2) return 0;
}
}
return 1;
}
|
#include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
assert(func0(test3, 3) == 0);
char* test4[][2] = {{"Name","John"}, {"Age","36"}, {"City","Houston"}};
assert(func0(test4, 3) == 0);
char* test5[][2] = {{"STATE","NC"}, {"ZIP","12345"}};
assert(func0(test5, 2) == 1);
char* test6[][2] = {{"fruit","Orange"}, {"taste","Sweet"}};
assert(func0(test6, 2) == 1);
assert(func0(NULL, 0) == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %esi,%eax
test %esi,%esi
je 1264 <func0+0xdb>
jle 1205 <func0+0x7c>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,(%rsp)
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%rax
mov %rax,0x8(%rsp)
mov $0x0,%r13d
mov $0x0,%r12d
mov $0x1,%r14d
mov %r14d,%r15d
mov (%rsp),%rax
mov (%rax),%rbp
movzbl 0x0(%rbp),%ebx
test %bl,%bl
je 11ee <func0+0x65>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rdx
add $0x1,%rbp
jmp 124a <func0+0xc1>
addq $0x10,(%rsp)
mov (%rsp),%rax
cmp 0x8(%rsp),%rax
jne 11d1 <func0+0x48>
mov $0x1,%eax
jmp 1210 <func0+0x87>
mov $0x1,%eax
retq
mov $0x0,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%eax
jmp 1210 <func0+0x87>
mov $0x0,%eax
jmp 1210 <func0+0x87>
test $0x2,%ah
jne 1226 <func0+0x9d>
mov %r15d,%r13d
lea (%r12,%r13,1),%eax
cmp $0x2,%eax
je 121f <func0+0x96>
add $0x1,%rbp
movzbl -0x1(%rbp),%ebx
test %bl,%bl
je 11ee <func0+0x65>
movzbl %bl,%ebx
movzwl (%rdx,%rbx,2),%eax
test $0x4,%ah
je 120b <func0+0x82>
test $0x1,%ah
jne 122d <func0+0xa4>
test $0x2,%ah
cmovne %r14d,%r12d
jmp 1235 <func0+0xac>
retq
|
func0:
endbr64
mov eax, esi
test esi, esi
jz locret_1259
jle short loc_11FA
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r15, rdi
movsxd rsi, esi
shl rsi, 4
lea rax, [rdi+rsi]
mov [rsp+48h+var_40], rax
mov r13d, 0
mov r12d, 0
mov r14d, 1
loc_11CC:
mov rbp, [r15]
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_11E5
call ___ctype_b_loc
mov rdx, [rax]
add rbp, 1
jmp short loc_123F
loc_11E5:
add r15, 10h
mov rax, [rsp+48h+var_40]
cmp r15, rax
jnz short loc_11CC
mov eax, 1
jmp short loc_1205
loc_11FA:
mov eax, 1
retn
loc_1200:
mov eax, 0
loc_1205:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1214:
mov eax, 0
jmp short loc_1205
loc_121B:
mov eax, 0
jmp short loc_1205
loc_1222:
test ah, 2
jnz short loc_121B
mov r13d, r14d
loc_122A:
lea eax, [r12+r13]
cmp eax, 2
jz short loc_1214
add rbp, 1
movzx ebx, byte ptr [rbp-1]
test bl, bl
jz short loc_11E5
loc_123F:
movzx ebx, bl
movzx eax, word ptr [rdx+rbx*2]
test ah, 4
jz short loc_1200
test ah, 1
jnz short loc_1222
test ah, 2
cmovnz r12d, r14d
jmp short loc_122A
locret_1259:
retn
|
long long func0(unsigned __int8 **a1, int a2)
{
long long result; // rax
unsigned __int8 **v3; // r15
int v4; // r13d
int v5; // r12d
unsigned __int8 *v6; // rbp
unsigned __int8 v7; // bl
const unsigned __int16 *v8; // rdx
unsigned __int8 *v9; // rbp
unsigned __int16 v10; // ax
result = (unsigned int)a2;
if ( a2 )
{
if ( a2 <= 0 )
return 1LL;
v3 = a1;
v4 = 0;
v5 = 0;
while ( 1 )
{
v6 = *v3;
v7 = **v3;
if ( v7 )
break;
LABEL_6:
v3 += 2;
if ( v3 == &a1[2 * a2] )
return 1LL;
}
v8 = *__ctype_b_loc();
v9 = v6 + 1;
while ( 1 )
{
v10 = v8[v7];
if ( (v10 & 0x400) == 0 )
return 0LL;
if ( (v10 & 0x100) != 0 )
{
if ( (v10 & 0x200) != 0 )
return 0LL;
v4 = 1;
}
else if ( (v10 & 0x200) != 0 )
{
v5 = 1;
}
if ( v5 + v4 == 2 )
return 0LL;
v7 = *v9++;
if ( !v7 )
goto LABEL_6;
}
}
return result;
}
|
func0:
ENDBR64
MOV EAX,ESI
TEST ESI,ESI
JZ 0x00101259
JLE 0x001011fa
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOVSXD RSI,ESI
SHL RSI,0x4
LEA RAX,[RDI + RSI*0x1]
MOV qword ptr [RSP + 0x8],RAX
MOV R13D,0x0
MOV R12D,0x0
MOV R14D,0x1
LAB_001011cc:
MOV RBP,qword ptr [R15]
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x001011e5
CALL 0x00101090
MOV RDX,qword ptr [RAX]
ADD RBP,0x1
JMP 0x0010123f
LAB_001011e5:
ADD R15,0x10
MOV RAX,qword ptr [RSP + 0x8]
CMP R15,RAX
JNZ 0x001011cc
MOV EAX,0x1
JMP 0x00101205
LAB_001011fa:
MOV EAX,0x1
RET
LAB_00101200:
MOV EAX,0x0
LAB_00101205:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101214:
MOV EAX,0x0
JMP 0x00101205
LAB_0010121b:
MOV EAX,0x0
JMP 0x00101205
LAB_00101222:
TEST AH,0x2
JNZ 0x0010121b
MOV R13D,R14D
LAB_0010122a:
LEA EAX,[R12 + R13*0x1]
CMP EAX,0x2
JZ 0x00101214
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP + -0x1]
TEST BL,BL
JZ 0x001011e5
LAB_0010123f:
MOVZX EBX,BL
MOVZX EAX,word ptr [RDX + RBX*0x2]
TEST AH,0x4
JZ 0x00101200
TEST AH,0x1
JNZ 0x00101222
TEST AH,0x2
CMOVNZ R12D,R14D
JMP 0x0010122a
LAB_00101259:
RET
|
int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
ushort uVar2;
ushort **ppuVar3;
byte bVar4;
byte *pbVar5;
int iVar6;
int iVar7;
if (param_2 == 0) {
return param_2;
}
if (param_2 < 1) {
return 1;
}
puVar1 = param_1 + (long)param_2 * 2;
iVar7 = 0;
iVar6 = 0;
do {
pbVar5 = (byte *)*param_1;
bVar4 = *pbVar5;
if (bVar4 != 0) {
ppuVar3 = __ctype_b_loc();
do {
pbVar5 = pbVar5 + 1;
uVar2 = (*ppuVar3)[bVar4];
if ((uVar2 & 0x400) == 0) {
return 0;
}
if ((uVar2 & 0x100) == 0) {
if ((uVar2 & 0x200) != 0) {
iVar6 = 1;
}
}
else {
if ((uVar2 & 0x200) != 0) {
return 0;
}
iVar7 = 1;
}
if (iVar6 + iVar7 == 2) {
return 0;
}
bVar4 = *pbVar5;
} while (bVar4 != 0);
}
param_1 = param_1 + 2;
if (param_1 == puVar1) {
return 1;
}
} while( true );
}
|
1,038 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j])) has_upper = 1;
if (islower((unsigned char)key[j])) has_lower = 1;
if (has_upper + has_lower == 2) return 0;
}
}
return 1;
}
|
#include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
assert(func0(test3, 3) == 0);
char* test4[][2] = {{"Name","John"}, {"Age","36"}, {"City","Houston"}};
assert(func0(test4, 3) == 0);
char* test5[][2] = {{"STATE","NC"}, {"ZIP","12345"}};
assert(func0(test5, 2) == 1);
char* test6[][2] = {{"fruit","Orange"}, {"taste","Sweet"}};
assert(func0(test6, 2) == 1);
assert(func0(NULL, 0) == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
je 1550 <func0+0x10>
jmpq 1480 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0_part_0:
test esi, esi
jle loc_15CA
push r15
movsxd rsi, esi
mov r15, rdi
push r14
shl rsi, 4
xor r14d, r14d
push r13
lea rax, [rdi+rsi]
xor r13d, r13d
push r12
mov r12d, 1
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rax
loc_1545:
mov rbp, [r15]
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_15B8
call ___ctype_b_loc
lea rdx, [rbp+1]
mov rsi, [rax]
jmp short loc_1580
loc_1560:
test cx, cx
jnz short loc_15A0
mov r14d, 1
loc_156B:
lea eax, [r13+r14+0]
cmp eax, 2
jz short loc_15A0
movzx ebx, byte ptr [rdx]
add rdx, 1
test bl, bl
jz short loc_15B8
loc_1580:
movzx eax, word ptr [rsi+rbx*2]
test ah, 4
jz short loc_15A0
mov ecx, eax
and cx, 200h
test ah, 1
jnz short loc_1560
test cx, cx
cmovnz r13d, r12d
jmp short loc_156B
loc_15A0:
xor eax, eax
loc_15A2:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B8:
add r15, 10h
cmp [rsp+48h+var_40], r15
jnz short loc_1545
mov eax, 1
jmp short loc_15A2
loc_15CA:
mov eax, 1
retn
|
long long func0_part_0(unsigned __int8 **a1, int a2)
{
unsigned __int8 **v2; // r15
int v3; // r14d
int v4; // r13d
unsigned __int8 *v5; // rbp
long long v6; // rbx
const unsigned __int16 **v7; // rax
unsigned __int8 *v8; // rdx
const unsigned __int16 *v9; // rsi
unsigned __int16 v10; // ax
__int16 v11; // cx
unsigned __int8 **v13; // [rsp+0h] [rbp-40h]
if ( a2 <= 0 )
return 1LL;
v2 = a1;
v3 = 0;
v4 = 0;
v13 = &a1[2 * a2];
while ( 1 )
{
v5 = *v2;
v6 = **v2;
if ( (_BYTE)v6 )
break;
LABEL_16:
v2 += 2;
if ( v13 == v2 )
return 1LL;
}
v7 = __ctype_b_loc();
v8 = v5 + 1;
v9 = *v7;
while ( 1 )
{
v10 = v9[v6];
if ( (v10 & 0x400) == 0 )
return 0LL;
v11 = v10 & 0x200;
if ( (v10 & 0x100) != 0 )
{
if ( v11 )
return 0LL;
v3 = 1;
}
else if ( v11 )
{
v4 = 1;
}
if ( v4 + v3 == 2 )
return 0LL;
v6 = *v8++;
if ( !(_BYTE)v6 )
goto LABEL_16;
}
}
|
func0.part.0:
TEST ESI,ESI
JLE 0x001015ca
PUSH R15
MOVSXD RSI,ESI
MOV R15,RDI
PUSH R14
SHL RSI,0x4
XOR R14D,R14D
PUSH R13
LEA RAX,[RDI + RSI*0x1]
XOR R13D,R13D
PUSH R12
MOV R12D,0x1
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
LAB_00101545:
MOV RBP,qword ptr [R15]
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x001015b8
CALL 0x00101090
LEA RDX,[RBP + 0x1]
MOV RSI,qword ptr [RAX]
JMP 0x00101580
LAB_00101560:
TEST CX,CX
JNZ 0x001015a0
MOV R14D,0x1
LAB_0010156b:
LEA EAX,[R13 + R14*0x1]
CMP EAX,0x2
JZ 0x001015a0
MOVZX EBX,byte ptr [RDX]
ADD RDX,0x1
TEST BL,BL
JZ 0x001015b8
LAB_00101580:
MOVZX EAX,word ptr [RSI + RBX*0x2]
TEST AH,0x4
JZ 0x001015a0
MOV ECX,EAX
AND CX,0x200
TEST AH,0x1
JNZ 0x00101560
TEST CX,CX
CMOVNZ R13D,R12D
JMP 0x0010156b
LAB_001015a0:
XOR EAX,EAX
LAB_001015a2:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b8:
ADD R15,0x10
CMP qword ptr [RSP + 0x8],R15
JNZ 0x00101545
MOV EAX,0x1
JMP 0x001015a2
LAB_001015ca:
MOV EAX,0x1
RET
|
int8 func0_part_0(int8 *param_1,int param_2)
{
int8 *puVar1;
byte bVar2;
ushort uVar3;
ushort **ppuVar4;
byte *pbVar5;
int iVar6;
int iVar7;
if (param_2 < 1) {
return 1;
}
iVar7 = 0;
puVar1 = param_1 + (long)param_2 * 2;
iVar6 = 0;
do {
pbVar5 = (byte *)*param_1;
bVar2 = *pbVar5;
if (bVar2 != 0) {
ppuVar4 = __ctype_b_loc();
do {
pbVar5 = pbVar5 + 1;
uVar3 = (*ppuVar4)[bVar2];
if ((uVar3 & 0x400) == 0) {
return 0;
}
if ((uVar3 & 0x100) == 0) {
if ((uVar3 & 0x200) != 0) {
iVar6 = 1;
}
}
else {
if ((uVar3 & 0x200) != 0) {
return 0;
}
iVar7 = 1;
}
if (iVar6 + iVar7 == 2) {
return 0;
}
bVar2 = *pbVar5;
} while (bVar2 != 0);
}
param_1 = param_1 + 2;
if (puVar1 == param_1) {
return 1;
}
} while( true );
}
|
1,039 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j])) has_upper = 1;
if (islower((unsigned char)key[j])) has_lower = 1;
if (has_upper + has_lower == 2) return 0;
}
}
return 1;
}
|
#include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
assert(func0(test3, 3) == 0);
char* test4[][2] = {{"Name","John"}, {"Age","36"}, {"City","Houston"}};
assert(func0(test4, 3) == 0);
char* test5[][2] = {{"STATE","NC"}, {"ZIP","12345"}};
assert(func0(test5, 2) == 1);
char* test6[][2] = {{"fruit","Orange"}, {"taste","Sweet"}};
assert(func0(test6, 2) == 1);
assert(func0(NULL, 0) == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
xor %eax,%eax
test %esi,%esi
je 1670 <func0+0xd0>
jle 1671 <func0+0xd1>
push %r15
lea -0x1(%rsi),%eax
mov %rdi,%r15
push %r14
shl $0x4,%rax
xor %r14d,%r14d
push %r13
lea 0x10(%rdi,%rax,1),%rax
xor %r13d,%r13d
push %r12
mov $0x1,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
mov %rax,0x8(%rsp)
mov (%r15),%rbp
movzbl 0x0(%rbp),%ebx
test %bl,%bl
je 1658 <func0+0xb8>
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdx
mov (%rax),%rsi
jmp 161c <func0+0x7c>
nopl 0x0(%rax,%rax,1)
test %cx,%cx
cmovne %r12d,%r13d
lea 0x0(%r13,%r14,1),%eax
cmp $0x2,%eax
je 1640 <func0+0xa0>
movzbl (%rdx),%ebx
add $0x1,%rdx
test %bl,%bl
je 1658 <func0+0xb8>
movzwl (%rsi,%rbx,2),%eax
test $0x4,%ah
je 1640 <func0+0xa0>
mov %eax,%ecx
and $0x200,%cx
test $0x1,%ah
je 1600 <func0+0x60>
test %cx,%cx
jne 1640 <func0+0xa0>
mov $0x1,%r14d
jmp 1607 <func0+0x67>
xchg %ax,%ax
xor %eax,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
add $0x10,%r15
cmp %r15,0x8(%rsp)
jne 15e2 <func0+0x42>
mov $0x1,%eax
jmp 1642 <func0+0xa2>
xchg %ax,%ax
retq
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0_part_0:
test esi, esi
jle loc_15CA
push r15
movsxd rsi, esi
mov r15, rdi
push r14
shl rsi, 4
xor r14d, r14d
push r13
lea rax, [rdi+rsi]
xor r13d, r13d
push r12
mov r12d, 1
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rax
loc_1545:
mov rbp, [r15]
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_15B8
call ___ctype_b_loc
lea rdx, [rbp+1]
mov rsi, [rax]
jmp short loc_1580
loc_1560:
test cx, cx
jnz short loc_15A0
mov r14d, 1
loc_156B:
lea eax, [r13+r14+0]
cmp eax, 2
jz short loc_15A0
movzx ebx, byte ptr [rdx]
add rdx, 1
test bl, bl
jz short loc_15B8
loc_1580:
movzx eax, word ptr [rsi+rbx*2]
test ah, 4
jz short loc_15A0
mov ecx, eax
and cx, 200h
test ah, 1
jnz short loc_1560
test cx, cx
cmovnz r13d, r12d
jmp short loc_156B
loc_15A0:
xor eax, eax
loc_15A2:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B8:
add r15, 10h
cmp [rsp+48h+var_40], r15
jnz short loc_1545
mov eax, 1
jmp short loc_15A2
loc_15CA:
mov eax, 1
retn
|
long long func0_part_0(unsigned __int8 **a1, int a2)
{
unsigned __int8 **v2; // r15
int v3; // r14d
int v4; // r13d
unsigned __int8 *v5; // rbp
long long v6; // rbx
const unsigned __int16 **v7; // rax
unsigned __int8 *v8; // rdx
const unsigned __int16 *v9; // rsi
unsigned __int16 v10; // ax
__int16 v11; // cx
unsigned __int8 **v13; // [rsp+0h] [rbp-40h]
if ( a2 <= 0 )
return 1LL;
v2 = a1;
v3 = 0;
v4 = 0;
v13 = &a1[2 * a2];
while ( 1 )
{
v5 = *v2;
v6 = **v2;
if ( (_BYTE)v6 )
break;
LABEL_16:
v2 += 2;
if ( v13 == v2 )
return 1LL;
}
v7 = __ctype_b_loc();
v8 = v5 + 1;
v9 = *v7;
while ( 1 )
{
v10 = v9[v6];
if ( (v10 & 0x400) == 0 )
return 0LL;
v11 = v10 & 0x200;
if ( (v10 & 0x100) != 0 )
{
if ( v11 )
return 0LL;
v3 = 1;
}
else if ( v11 )
{
v4 = 1;
}
if ( v4 + v3 == 2 )
return 0LL;
v6 = *v8++;
if ( !(_BYTE)v6 )
goto LABEL_16;
}
}
|
func0.part.0:
TEST ESI,ESI
JLE 0x001015ca
PUSH R15
MOVSXD RSI,ESI
MOV R15,RDI
PUSH R14
SHL RSI,0x4
XOR R14D,R14D
PUSH R13
LEA RAX,[RDI + RSI*0x1]
XOR R13D,R13D
PUSH R12
MOV R12D,0x1
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
LAB_00101545:
MOV RBP,qword ptr [R15]
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x001015b8
CALL 0x00101090
LEA RDX,[RBP + 0x1]
MOV RSI,qword ptr [RAX]
JMP 0x00101580
LAB_00101560:
TEST CX,CX
JNZ 0x001015a0
MOV R14D,0x1
LAB_0010156b:
LEA EAX,[R13 + R14*0x1]
CMP EAX,0x2
JZ 0x001015a0
MOVZX EBX,byte ptr [RDX]
ADD RDX,0x1
TEST BL,BL
JZ 0x001015b8
LAB_00101580:
MOVZX EAX,word ptr [RSI + RBX*0x2]
TEST AH,0x4
JZ 0x001015a0
MOV ECX,EAX
AND CX,0x200
TEST AH,0x1
JNZ 0x00101560
TEST CX,CX
CMOVNZ R13D,R12D
JMP 0x0010156b
LAB_001015a0:
XOR EAX,EAX
LAB_001015a2:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b8:
ADD R15,0x10
CMP qword ptr [RSP + 0x8],R15
JNZ 0x00101545
MOV EAX,0x1
JMP 0x001015a2
LAB_001015ca:
MOV EAX,0x1
RET
|
int8 func0_part_0(int8 *param_1,int param_2)
{
int8 *puVar1;
byte bVar2;
ushort uVar3;
ushort **ppuVar4;
byte *pbVar5;
int iVar6;
int iVar7;
if (param_2 < 1) {
return 1;
}
iVar7 = 0;
puVar1 = param_1 + (long)param_2 * 2;
iVar6 = 0;
do {
pbVar5 = (byte *)*param_1;
bVar2 = *pbVar5;
if (bVar2 != 0) {
ppuVar4 = __ctype_b_loc();
do {
pbVar5 = pbVar5 + 1;
uVar3 = (*ppuVar4)[bVar2];
if ((uVar3 & 0x400) == 0) {
return 0;
}
if ((uVar3 & 0x100) == 0) {
if ((uVar3 & 0x200) != 0) {
iVar6 = 1;
}
}
else {
if ((uVar3 & 0x200) != 0) {
return 0;
}
iVar7 = 1;
}
if (iVar6 + iVar7 == 2) {
return 0;
}
bVar2 = *pbVar5;
} while (bVar2 != 0);
}
param_1 = param_1 + 2;
if (puVar1 == param_1) {
return 1;
}
} while( true );
}
|
1,040 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
break;
}
}
if (isp) {
out[*count] = i;
(*count)++;
}
}
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int *result = func0(5, &count);
assert(issame(result, count, (const int[]){2, 3}, 2));
free(result);
result = func0(6, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(7, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(10, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7}, 4));
free(result);
result = func0(0, &count);
assert(count == 0);
free(result);
result = func0(22, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19}, 8));
free(result);
result = func0(1, &count);
assert(count == 0);
free(result);
result = func0(18, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17}, 7));
free(result);
result = func0(47, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43}, 14));
free(result);
result = func0(101, &count);
assert(issame(result, count, expected, 25));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
movl $0x2,-0x18(%rbp)
jmpq 1278 <func0+0xcf>
movl $0x1,-0x10(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1235 <func0+0x8c>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x18(%rbp)
jl 1242 <func0+0x99>
mov -0x18(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1231 <func0+0x88>
movl $0x0,-0x10(%rbp)
jmp 1243 <func0+0x9a>
addl $0x1,-0x14(%rbp)
mov -0x30(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x14(%rbp)
jl 11f7 <func0+0x4e>
jmp 1243 <func0+0x9a>
cmpl $0x0,-0x10(%rbp)
je 1274 <func0+0xcb>
mov -0x30(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x18(%rbp),%eax
mov %eax,(%rdx)
mov -0x30(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11e7 <func0+0x3e>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov [rbp+var_18], 2
jmp loc_1278
loc_11E7:
mov [rbp+var_10], 1
mov [rbp+var_14], 0
jmp short loc_1235
loc_11F7:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
imul eax, eax
cmp [rbp+var_18], eax
jl short loc_1242
mov eax, [rbp+var_18]
cdq
idiv [rbp+var_C]
mov eax, edx
test eax, eax
jnz short loc_1231
mov [rbp+var_10], 0
jmp short loc_1243
loc_1231:
add [rbp+var_14], 1
loc_1235:
mov rax, [rbp+var_30]
mov eax, [rax]
cmp [rbp+var_14], eax
jl short loc_11F7
jmp short loc_1243
loc_1242:
nop
loc_1243:
cmp [rbp+var_10], 0
jz short loc_1274
mov rax, [rbp+var_30]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_18]
mov [rdx], eax
mov rax, [rbp+var_30]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_30]
mov [rax], edx
loc_1274:
add [rbp+var_18], 1
loc_1278:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_24]
jl loc_11E7
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(int a1, _DWORD *a2)
{
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v5; // [rsp+20h] [rbp-10h]
int v6; // [rsp+24h] [rbp-Ch]
_DWORD *v7; // [rsp+28h] [rbp-8h]
v7 = malloc(4LL * a1);
*a2 = 0;
for ( i = 2; i < a1; ++i )
{
v5 = 1;
for ( j = 0; j < *a2; ++j )
{
v6 = v7[j];
if ( i < v6 * v6 )
break;
if ( !(i % v6) )
{
v5 = 0;
break;
}
}
if ( v5 )
v7[(*a2)++] = i;
}
return v7;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x18],0x2
JMP 0x00101278
LAB_001011e7:
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101235
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x18],EAX
JL 0x00101242
MOV EAX,dword ptr [RBP + -0x18]
CDQ
IDIV dword ptr [RBP + -0xc]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101231
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101243
LAB_00101231:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101235:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x14],EAX
JL 0x001011f7
JMP 0x00101243
LAB_00101242:
NOP
LAB_00101243:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x00101274
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
LAB_00101274:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101278:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011e7
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(int param_1,int *param_2)
{
int iVar1;
bool bVar2;
void *pvVar3;
int local_20;
int local_1c;
pvVar3 = malloc((long)param_1 << 2);
*param_2 = 0;
local_20 = 2;
do {
if (param_1 <= local_20) {
return pvVar3;
}
bVar2 = true;
local_1c = 0;
while( true ) {
if ((*param_2 <= local_1c) ||
(iVar1 = *(int *)((long)pvVar3 + (long)local_1c * 4), local_20 < iVar1 * iVar1))
goto LAB_00101243;
if (local_20 % iVar1 == 0) break;
local_1c = local_1c + 1;
}
bVar2 = false;
LAB_00101243:
if (bVar2) {
*(int *)((long)*param_2 * 4 + (long)pvVar3) = local_20;
*param_2 = *param_2 + 1;
}
local_20 = local_20 + 1;
} while( true );
}
|
1,041 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
break;
}
}
if (isp) {
out[*count] = i;
(*count)++;
}
}
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int *result = func0(5, &count);
assert(issame(result, count, (const int[]){2, 3}, 2));
free(result);
result = func0(6, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(7, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(10, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7}, 4));
free(result);
result = func0(0, &count);
assert(count == 0);
free(result);
result = func0(22, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19}, 8));
free(result);
result = func0(1, &count);
assert(count == 0);
free(result);
result = func0(18, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17}, 7));
free(result);
result = func0(47, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43}, 14));
free(result);
result = func0(101, &count);
assert(issame(result, count, expected, 25));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebp
mov %rsi,%rbx
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r10
movl $0x0,(%rbx)
mov $0x2,%edi
cmp $0x2,%ebp
jg 11f6 <func0+0x4d>
mov %r10,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
movslq %r9d,%rax
mov %edi,(%r10,%rax,4)
add $0x1,%r9d
mov %r9d,(%rbx)
add $0x1,%edi
cmp %edi,%ebp
je 11d7 <func0+0x2e>
mov (%rbx),%r9d
test %r9d,%r9d
jle 11e1 <func0+0x38>
mov %r10,%rsi
lea -0x1(%r9),%eax
lea 0x4(%r10,%rax,4),%r8
mov (%rsi),%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 11e1 <func0+0x38>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 11ef <func0+0x46>
add $0x4,%rsi
cmp %r8,%rsi
jne 120a <func0+0x61>
jmp 11e1 <func0+0x38>
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebp, edi
mov rbx, rsi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov r10, rax
mov dword ptr [rbx], 0
mov edi, 2
cmp ebp, 2
jg short loc_11F6
loc_11D7:
mov rax, r10
add rsp, 8
pop rbx
pop rbp
retn
loc_11E1:
movsxd rax, r9d
mov [r10+rax*4], edi
add r9d, 1
mov [rbx], r9d
loc_11EF:
add edi, 1
cmp ebp, edi
jz short loc_11D7
loc_11F6:
mov r9d, [rbx]
test r9d, r9d
jle short loc_11E1
mov rsi, r10
movsxd rax, r9d
lea r8, [r10+rax*4]
loc_1208:
mov ecx, [rsi]
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_11E1
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_11EF
add rsi, 4
cmp r8, rsi
jnz short loc_1208
jmp short loc_11E1
|
int * func0(int a1, int *a2)
{
int *v4; // r10
int v5; // edi
int v7; // r9d
int *v8; // rsi
int v9; // ecx
v4 = (int *)malloc(4LL * a1);
*a2 = 0;
v5 = 2;
if ( a1 > 2 )
{
do
{
v7 = *a2;
if ( *a2 > 0 )
{
v8 = v4;
do
{
v9 = *v8;
if ( v9 * v9 > v5 )
break;
if ( !(v5 % v9) )
goto LABEL_4;
++v8;
}
while ( &v4[v7] != v8 );
}
v4[v7] = v5;
*a2 = v7 + 1;
LABEL_4:
++v5;
}
while ( a1 != v5 );
}
return v4;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDI
MOV RBX,RSI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R10,RAX
MOV dword ptr [RBX],0x0
MOV EDI,0x2
CMP EBP,0x2
JG 0x001011f6
LAB_001011d7:
MOV RAX,R10
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011e1:
MOVSXD RAX,R9D
MOV dword ptr [R10 + RAX*0x4],EDI
ADD R9D,0x1
MOV dword ptr [RBX],R9D
LAB_001011ef:
ADD EDI,0x1
CMP EBP,EDI
JZ 0x001011d7
LAB_001011f6:
MOV R9D,dword ptr [RBX]
TEST R9D,R9D
JLE 0x001011e1
MOV RSI,R10
MOVSXD RAX,R9D
LEA R8,[R10 + RAX*0x4]
LAB_00101208:
MOV ECX,dword ptr [RSI]
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x001011e1
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001011ef
ADD RSI,0x4
CMP R8,RSI
JNZ 0x00101208
JMP 0x001011e1
|
int * func0(int param_1,int *param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int iVar5;
piVar3 = (int *)malloc((long)param_1 << 2);
*param_2 = 0;
iVar5 = 2;
if (2 < param_1) {
do {
iVar1 = *param_2;
if (0 < iVar1) {
piVar4 = piVar3;
do {
iVar2 = *piVar4;
if (iVar5 < iVar2 * iVar2) break;
if (iVar5 % iVar2 == 0) goto LAB_001011ef;
piVar4 = piVar4 + 1;
} while (piVar3 + iVar1 != piVar4);
}
piVar3[iVar1] = iVar5;
*param_2 = iVar1 + 1;
LAB_001011ef:
iVar5 = iVar5 + 1;
} while (param_1 != iVar5);
}
return piVar3;
}
|
1,042 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
break;
}
}
if (isp) {
out[*count] = i;
(*count)++;
}
}
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int *result = func0(5, &count);
assert(issame(result, count, (const int[]){2, 3}, 2));
free(result);
result = func0(6, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(7, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(10, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7}, 4));
free(result);
result = func0(0, &count);
assert(count == 0);
free(result);
result = func0(22, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19}, 8));
free(result);
result = func0(1, &count);
assert(count == 0);
free(result);
result = func0(18, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17}, 7));
free(result);
result = func0(47, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43}, 14));
free(result);
result = func0(101, &count);
assert(issame(result, count, expected, 25));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
movslq %edi,%rdi
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
xor %r10d,%r10d
mov $0x2,%r8d
mov %rax,%r11
lea 0x4(%rax),%rsi
cmp $0x2,%ebx
jle 1798 <func0+0x98>
nopl 0x0(%rax,%rax,1)
test %r10d,%r10d
jle 1777 <func0+0x77>
lea -0x1(%r10),%eax
mov %r11,%rdi
lea (%rsi,%rax,4),%r9
jmp 176b <func0+0x6b>
nopw 0x0(%rax,%rax,1)
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 1786 <func0+0x86>
add $0x4,%rdi
cmp %r9,%rdi
je 1777 <func0+0x77>
mov (%rdi),%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %r8d,%eax
jle 1758 <func0+0x58>
movslq %r10d,%rax
add $0x1,%r10d
mov %r8d,(%r11,%rax,4)
mov %r10d,0x0(%rbp)
add $0x1,%r8d
cmp %r8d,%ebx
je 1798 <func0+0x98>
mov 0x0(%rbp),%r10d
jmp 1740 <func0+0x40>
nopl (%rax)
add $0x8,%rsp
mov %r11,%rax
pop %rbx
pop %rbp
retq
data16 nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
push rbp
movsxd rdi, edi
mov rbp, rsi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
xor r9d, r9d
mov edi, 2
mov r10, rax
cmp ebx, 2
jle short loc_1700
nop dword ptr [rax+rax+00h]
loc_16A8:
movsxd r11, r9d
test r9d, r9d
jle short loc_16DD
movsxd r11, r9d
mov rsi, r10
lea r8, [r10+r11*4]
jmp short loc_16D2
loc_16C0:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_16E9
add rsi, 4
cmp rsi, r8
jz short loc_16DD
loc_16D2:
mov ecx, [rsi]
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_16C0
loc_16DD:
add r9d, 1
mov [r10+r11*4], edi
mov [rbp+0], r9d
loc_16E9:
add edi, 1
cmp ebx, edi
jz short loc_1700
mov r9d, [rbp+0]
jmp short loc_16A8
loc_1700:
add rsp, 8
mov rax, r10
pop rbx
pop rbp
retn
|
int * func0(int a1, int *a2)
{
int *result; // rax
int v5; // r9d
int v6; // edi
long long v7; // r11
int *v8; // rsi
int v9; // ecx
result = (int *)malloc(4LL * a1);
*a2 = 0;
v5 = 0;
v6 = 2;
if ( a1 > 2 )
{
while ( 1 )
{
v7 = v5;
if ( v5 > 0 )
{
v7 = v5;
v8 = result;
do
{
v9 = *v8;
if ( v9 * v9 > v6 )
break;
if ( !(v6 % v9) )
goto LABEL_8;
++v8;
}
while ( v8 != &result[v5] );
}
result[v7] = v6;
*a2 = v5 + 1;
LABEL_8:
if ( a1 == ++v6 )
break;
v5 = *a2;
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOVSXD RDI,EDI
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
XOR R9D,R9D
MOV EDI,0x2
MOV R10,RAX
CMP EBX,0x2
JLE 0x00101700
NOP dword ptr [RAX + RAX*0x1]
LAB_001016a8:
MOVSXD R11,R9D
TEST R9D,R9D
JLE 0x001016dd
MOVSXD R11,R9D
MOV RSI,R10
LEA R8,[R10 + R11*0x4]
JMP 0x001016d2
LAB_001016c0:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001016e9
ADD RSI,0x4
CMP RSI,R8
JZ 0x001016dd
LAB_001016d2:
MOV ECX,dword ptr [RSI]
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x001016c0
LAB_001016dd:
ADD R9D,0x1
MOV dword ptr [R10 + R11*0x4],EDI
MOV dword ptr [RBP],R9D
LAB_001016e9:
ADD EDI,0x1
CMP EBX,EDI
JZ 0x00101700
MOV R9D,dword ptr [RBP]
JMP 0x001016a8
LAB_00101700:
ADD RSP,0x8
MOV RAX,R10
POP RBX
POP RBP
RET
|
int * func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
piVar2 = (int *)malloc((long)param_1 << 2);
*param_2 = 0;
iVar5 = 0;
iVar4 = 2;
if (param_1 < 3) {
return piVar2;
}
do {
if (0 < iVar5) {
piVar3 = piVar2;
do {
iVar1 = *piVar3;
if (iVar4 < iVar1 * iVar1) break;
if (iVar4 % iVar1 == 0) goto LAB_001016e9;
piVar3 = piVar3 + 1;
} while (piVar3 != piVar2 + iVar5);
}
piVar2[iVar5] = iVar4;
*param_2 = iVar5 + 1;
LAB_001016e9:
iVar4 = iVar4 + 1;
if (param_1 == iVar4) {
return piVar2;
}
iVar5 = *param_2;
} while( true );
}
|
1,043 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
break;
}
}
if (isp) {
out[*count] = i;
(*count)++;
}
}
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int *result = func0(5, &count);
assert(issame(result, count, (const int[]){2, 3}, 2));
free(result);
result = func0(6, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(7, &count);
assert(issame(result, count, (const int[]){2, 3, 5}, 3));
free(result);
result = func0(10, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7}, 4));
free(result);
result = func0(0, &count);
assert(count == 0);
free(result);
result = func0(22, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19}, 8));
free(result);
result = func0(1, &count);
assert(count == 0);
free(result);
result = func0(18, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17}, 7));
free(result);
result = func0(47, &count);
assert(issame(result, count, (const int[]){2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43}, 14));
free(result);
result = func0(101, &count);
assert(issame(result, count, expected, 25));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
movslq %edi,%rdi
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
xor %r10d,%r10d
mov $0x2,%r8d
mov %rax,%r11
lea 0x4(%rax),%rsi
cmp $0x2,%ebx
jle 16ff <func0+0x8f>
nopl 0x0(%rax,%rax,1)
test %r10d,%r10d
je 16e7 <func0+0x77>
lea -0x1(%r10),%eax
mov %r11,%rdi
lea (%rsi,%rax,4),%r9
jmp 16db <func0+0x6b>
nopw 0x0(%rax,%rax,1)
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 16f6 <func0+0x86>
add $0x4,%rdi
cmp %r9,%rdi
je 16e7 <func0+0x77>
mov (%rdi),%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %r8d,%eax
jle 16c8 <func0+0x58>
movslq %r10d,%rax
add $0x1,%r10d
mov %r8d,(%r11,%rax,4)
mov %r10d,0x0(%rbp)
add $0x1,%r8d
cmp %r8d,%ebx
jne 16b0 <func0+0x40>
add $0x8,%rsp
mov %r11,%rax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
|
func0:
endbr64
push rbp
movsxd rdi, edi
mov rbp, rsi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
xor r9d, r9d
mov edi, 2
mov r10, rax
cmp ebx, 2
jle short loc_16F0
nop dword ptr [rax+rax+00h]
loc_16A8:
movsxd r11, r9d
lea r8, [r10+r11*4]
test r9d, r9d
jle short loc_16DD
loc_16B4:
mov rsi, r10
jmp short loc_16D2
loc_16C0:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1700
add rsi, 4
cmp r8, rsi
jz short loc_16DD
loc_16D2:
mov ecx, [rsi]
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_16C0
loc_16DD:
mov [r10+r11*4], edi
add r9d, 1
add edi, 1
mov [rbp+0], r9d
cmp ebx, edi
jnz short loc_16A8
loc_16F0:
add rsp, 8
mov rax, r10
pop rbx
pop rbp
retn
loc_1700:
add edi, 1
cmp edi, ebx
jnz short loc_16B4
add rsp, 8
mov rax, r10
pop rbx
pop rbp
retn
|
int * func0(int a1, int *a2)
{
int *result; // rax
int v5; // r9d
int v6; // edi
int *i; // rsi
int v8; // ecx
result = (int *)malloc(4LL * a1);
*a2 = 0;
v5 = 0;
v6 = 2;
if ( a1 > 2 )
{
do
{
if ( v5 > 0 )
{
LABEL_3:
for ( i = result; &result[v5] != i; ++i )
{
v8 = *i;
if ( v8 * v8 > v6 )
break;
if ( !(v6 % v8) )
{
if ( ++v6 != a1 )
goto LABEL_3;
return result;
}
}
}
result[v5++] = v6++;
*a2 = v5;
}
while ( a1 != v6 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOVSXD RDI,EDI
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
XOR R9D,R9D
MOV EDI,0x2
MOV R10,RAX
CMP EBX,0x2
JLE 0x001016f0
NOP dword ptr [RAX + RAX*0x1]
LAB_001016a8:
MOVSXD R11,R9D
LEA R8,[R10 + R11*0x4]
TEST R9D,R9D
JLE 0x001016dd
LAB_001016b4:
MOV RSI,R10
JMP 0x001016d2
LAB_001016c0:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101700
ADD RSI,0x4
CMP R8,RSI
JZ 0x001016dd
LAB_001016d2:
MOV ECX,dword ptr [RSI]
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x001016c0
LAB_001016dd:
MOV dword ptr [R10 + R11*0x4],EDI
ADD R9D,0x1
ADD EDI,0x1
MOV dword ptr [RBP],R9D
CMP EBX,EDI
JNZ 0x001016a8
LAB_001016f0:
ADD RSP,0x8
MOV RAX,R10
POP RBX
POP RBP
RET
LAB_00101700:
ADD EDI,0x1
CMP EDI,EBX
JNZ 0x001016b4
ADD RSP,0x8
MOV RAX,R10
POP RBX
POP RBP
RET
|
int * func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
piVar2 = (int *)malloc((long)param_1 << 2);
*param_2 = 0;
iVar5 = 0;
iVar4 = 2;
if (2 < param_1) {
do {
piVar3 = piVar2;
if (0 < iVar5) {
do {
while( true ) {
iVar1 = *piVar3;
if (iVar4 < iVar1 * iVar1) goto LAB_001016dd;
if (iVar4 % iVar1 != 0) break;
iVar4 = iVar4 + 1;
piVar3 = piVar2;
if (iVar4 == param_1) {
return piVar2;
}
}
piVar3 = piVar3 + 1;
} while (piVar2 + iVar5 != piVar3);
}
LAB_001016dd:
piVar2[iVar5] = iVar4;
iVar5 = iVar5 + 1;
iVar4 = iVar4 + 1;
*param_2 = iVar5;
} while (param_1 != iVar4);
}
return piVar2;
}
|
1,044 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
}
|
#include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
sar $0x1f,%eax
mov %eax,%edx
xor -0x4(%rbp),%edx
sub %eax,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
mov %ecx,%esi
sub %eax,%esi
mov %esi,%eax
shl $0x2,%eax
add %esi,%eax
add %eax,%eax
mov %edx,%esi
sub %eax,%esi
mov -0x8(%rbp),%eax
sar $0x1f,%eax
mov %eax,%edx
xor -0x8(%rbp),%edx
sub %eax,%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
mov %edx,%ecx
sub %eax,%ecx
mov %esi,%eax
imul %ecx,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
mov edx, eax
neg edx
cmovs edx, eax
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
mov ecx, edx
sub ecx, eax
mov eax, [rbp+var_8]
mov edx, eax
neg edx
cmovns eax, edx
mov esi, eax
movsxd rax, esi
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, esi
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub esi, eax
mov edx, esi
mov eax, ecx
imul eax, edx
pop rbp
retn
|
long long func0(int a1, int a2)
{
int v2; // edx
int v3; // eax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = a2;
if ( a2 <= 0 )
v3 = -a2;
return (unsigned int)(v3 % 10 * (v2 % 10));
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
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
MOV ECX,EDX
SUB ECX,EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV ESI,EAX
MOVSXD RAX,ESI
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ESI
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ESI,EAX
MOV EDX,ESI
MOV EAX,ECX
IMUL EAX,EDX
POP RBP
RET
|
int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = -param_1;
if (0 < param_1) {
iVar1 = param_1;
}
if (param_2 < 1) {
param_2 = -param_2;
}
return (iVar1 % 10) * (param_2 % 10);
}
|
1,045 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
}
|
#include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %edi,%eax
cltd
xor %edx,%eax
sub %edx,%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%ecx
sar $0x1f,%ecx
sub %ecx,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
mov %esi,%edx
sar $0x1f,%edx
xor %edx,%esi
sub %edx,%esi
movslq %esi,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %esi,%ecx
sar $0x1f,%ecx
sub %ecx,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%esi
imul %esi,%eax
retq
|
func0:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
mov ecx, eax
sar ecx, 1Fh
sub edx, ecx
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov ecx, esi
neg ecx
cmovs ecx, esi
movsxd rdx, ecx
imul rdx, 66666667h
sar rdx, 22h
mov esi, ecx
sar esi, 1Fh
sub edx, esi
lea edx, [rdx+rdx*4]
add edx, edx
sub ecx, edx
imul eax, ecx
retn
|
long long func0(int a1, int a2)
{
int v2; // eax
int v3; // eax
int v4; // ecx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 10;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return (unsigned int)(v4 % 10 * v3);
}
|
func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ECX,EAX
SAR ECX,0x1f
SUB EDX,ECX
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV ECX,ESI
NEG ECX
CMOVS ECX,ESI
MOVSXD RDX,ECX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ESI,ECX
SAR ESI,0x1f
SUB EDX,ESI
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB ECX,EDX
IMUL EAX,ECX
RET
|
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
iVar1 = -param_1;
if (0 < param_1) {
iVar1 = param_1;
}
iVar2 = -param_2;
if (0 < param_2) {
iVar2 = param_2;
}
return (iVar1 % 10) * (iVar2 % 10);
}
|
1,046 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
}
|
#include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %edi,%edx
mov %esi,%eax
mov $0xcccccccd,%esi
sar $0x1f,%edx
xor %edx,%edi
sub %edx,%edi
cltd
xor %edx,%eax
mov %edi,%ecx
sub %edx,%eax
imul %rsi,%rcx
mov %eax,%edx
imul %rsi,%rdx
shr $0x23,%rcx
lea (%rcx,%rcx,4),%ecx
shr $0x23,%rdx
add %ecx,%ecx
lea (%rdx,%rdx,4),%edx
sub %ecx,%edi
add %edx,%edx
sub %edx,%eax
imul %edi,%eax
retq
|
func0:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
mov edi, 0CCCCCCCDh
mov edx, eax
imul rdx, rdi
shr rdx, 23h
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov edx, esi
neg edx
cmovs edx, esi
mov ecx, edx
imul rcx, rdi
shr rcx, 23h
lea ecx, [rcx+rcx*4]
add ecx, ecx
sub edx, ecx
imul eax, edx
retn
|
long long func0(int a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // edx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 0xA;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return v4 % 0xA * v3;
}
|
func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOV EDI,0xcccccccd
MOV EDX,EAX
IMUL RDX,RDI
SHR RDX,0x23
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV EDX,ESI
NEG EDX
CMOVS EDX,ESI
MOV ECX,EDX
IMUL RCX,RDI
SHR RCX,0x23
LEA ECX,[RCX + RCX*0x4]
ADD ECX,ECX
SUB EDX,ECX
IMUL EAX,EDX
RET
|
int func0(uint param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = -param_1;
if (0 < (int)param_1) {
uVar1 = param_1;
}
uVar2 = (ulong)-param_2;
if (0 < (int)param_2) {
uVar2 = (ulong)param_2;
}
return (uVar1 % 10) * ((int)uVar2 + (int)(uVar2 / 10) * -10);
}
|
1,047 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
}
|
#include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov %edi,%edx
mov %esi,%eax
mov $0xcccccccd,%esi
sar $0x1f,%edx
xor %edx,%edi
sub %edx,%edi
cltd
xor %edx,%eax
mov %edi,%ecx
sub %edx,%eax
imul %rsi,%rcx
mov %eax,%edx
imul %rsi,%rdx
shr $0x23,%rcx
lea (%rcx,%rcx,4),%ecx
shr $0x23,%rdx
add %ecx,%ecx
lea (%rdx,%rdx,4),%edx
sub %ecx,%edi
add %edx,%edx
sub %edx,%eax
imul %edi,%eax
retq
|
func0:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
mov edi, 0CCCCCCCDh
mov edx, eax
imul rdx, rdi
shr rdx, 23h
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov edx, esi
neg edx
cmovs edx, esi
mov ecx, edx
imul rcx, rdi
shr rcx, 23h
lea ecx, [rcx+rcx*4]
add ecx, ecx
sub edx, ecx
imul eax, edx
retn
|
long long func0(int a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // edx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 0xA;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return v4 % 0xA * v3;
}
|
func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOV EDI,0xcccccccd
MOV EDX,EAX
IMUL RDX,RDI
SHR RDX,0x23
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV EDX,ESI
NEG EDX
CMOVS EDX,ESI
MOV ECX,EDX
IMUL RCX,RDI
SHR RCX,0x23
LEA ECX,[RCX + RCX*0x4]
ADD ECX,ECX
SUB EDX,ECX
IMUL EAX,EDX
RET
|
int func0(uint param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = -param_1;
if (0 < (int)param_1) {
uVar1 = param_1;
}
uVar2 = (ulong)-param_2;
if (0 < (int)param_2) {
uVar2 = (ulong)param_2;
}
return (uVar1 % 10) * ((int)uVar2 + (int)(uVar2 / 10) * -10);
}
|
1,048 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
lea 0xe67(%rip),%rax
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 11e5 <func0+0x5c>
mov -0x1c(%rbp),%eax
add %eax,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 11e1 <func0+0x58>
addl $0x1,-0x20(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
je 1212 <func0+0x89>
mov -0x1c(%rbp),%eax
add %eax,%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
cmp %rax,%rbx
jb 11b5 <func0+0x2c>
mov -0x20(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
lea rax, aAeiou; "AEIOU"
mov [rbp+s], rax
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp short loc_11E5
loc_11B5:
mov eax, [rbp+var_1C]
add eax, eax
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+s]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jz short loc_11E1
add [rbp+var_20], 1
loc_11E1:
add [rbp+var_1C], 1
loc_11E5:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jz short loc_1212
mov eax, [rbp+var_1C]
add eax, eax
movsxd rbx, eax
mov rax, [rbp+var_28]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_11B5
loc_1212:
mov eax, [rbp+var_20]
mov rbx, [rbp+var_8]
leave
retn
|
long long func0(const char *a1)
{
unsigned int v2; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
v2 = 0;
for ( i = 0; a1[i] && 2 * i < strlen(a1); ++i )
{
if ( strchr("AEIOU", a1[2 * i]) )
++v2;
}
return v2;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001011e5
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EAX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101080
TEST RAX,RAX
JZ 0x001011e1
ADD dword ptr [RBP + -0x20],0x1
LAB_001011e1:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001011e5:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x00101212
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EAX
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
CMP RBX,RAX
JC 0x001011b5
LAB_00101212:
MOV EAX,dword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
int local_28;
int local_24;
local_28 = 0;
local_24 = 0;
while( true ) {
if (param_1[local_24] == '\0') {
return local_28;
}
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)(local_24 * 2)) break;
pcVar1 = strchr("AEIOU",(int)param_1[local_24 * 2]);
if (pcVar1 != (char *)0x0) {
local_28 = local_28 + 1;
}
local_24 = local_24 + 1;
}
return local_28;
}
|
1,049 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmpb $0x0,(%rdi)
je 11d7 <func0+0x6e>
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
shr %rcx
mov %rcx,%r13
mov $0x0,%ebx
mov $0x0,%r12d
lea 0xe5e(%rip),%r14
cmp %r13,%rbx
je 11cb <func0+0x62>
movsbl 0x0(%rbp,%rbx,2),%esi
mov %r14,%rdi
callq 1060 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%r12d
add $0x1,%rbx
cmpb $0x0,0x0(%rbp,%rbx,1)
jne 11a6 <func0+0x3d>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x0,%r12d
jmp 11cb <func0+0x62>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
cmp byte ptr [rdi], 0
jz short loc_11EC
mov rbp, rdi
call _strlen
lea r13, [rax+1]
shr r13, 1
mov ebx, 0
mov r12d, 0
lea r14, s; "AEIOU"
loc_11BB:
cmp rbx, r13
jz short loc_11E0
movsx esi, byte ptr [rbp+rbx*2+0]; c
mov rdi, r14; s
call _strchr
cmp rax, 1
sbb r12d, 0FFFFFFFFh
add rbx, 1
cmp byte ptr [rbp+rbx+0], 0
jnz short loc_11BB
loc_11E0:
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_11EC:
mov r12d, 0
jmp short loc_11E0
|
long long func0(const char *a1)
{
size_t v1; // r13
long long v2; // rbx
unsigned int v3; // r12d
if ( *a1 )
{
v1 = (strlen(a1) + 1) >> 1;
v2 = 0LL;
v3 = 0;
do
{
if ( v2 == v1 )
break;
v3 -= (strchr("AEIOU", a1[2 * v2++]) == 0LL) - 1;
}
while ( a1[v2] );
}
else
{
return 0;
}
return v3;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
CMP byte ptr [RDI],0x0
JZ 0x001011ec
MOV RBP,RDI
CALL 0x00101070
LEA R13,[RAX + 0x1]
SHR R13,0x1
MOV EBX,0x0
MOV R12D,0x0
LEA R14,[0x102004]
LAB_001011bb:
CMP RBX,R13
JZ 0x001011e0
MOVSX ESI,byte ptr [RBP + RBX*0x2]
MOV RDI,R14
CALL 0x00101080
CMP RAX,0x1
SBB R12D,-0x1
ADD RBX,0x1
CMP byte ptr [RBP + RBX*0x1],0x0
JNZ 0x001011bb
LAB_001011e0:
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001011ec:
MOV R12D,0x0
JMP 0x001011e0
|
int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
int iVar4;
if (*param_1 == '\0') {
iVar4 = 0;
}
else {
sVar1 = strlen(param_1);
uVar3 = 0;
iVar4 = 0;
do {
if (uVar3 == sVar1 + 1 >> 1) {
return iVar4;
}
pcVar2 = strchr("AEIOU",(int)param_1[uVar3 * 2]);
iVar4 = (iVar4 + 1) - (uint)(pcVar2 == (char *)0x0);
uVar3 = uVar3 + 1;
} while (param_1[uVar3] != '\0');
}
return iVar4;
}
|
1,050 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmpb $0x0,(%rdi)
je 1361 <func0+0x61>
mov %rdi,%r14
xor %ebx,%ebx
lea 0xce7(%rip),%r13
xor %r12d,%r12d
callq 1070 <strlen@plt>
lea 0x1(%rax),%rbp
shr %rbp
jmp 1350 <func0+0x50>
xchg %ax,%ax
movsbl (%r14,%rbx,2),%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%r12d
add $0x1,%rbx
cmpb $0x0,(%r14,%rbx,1)
je 1355 <func0+0x55>
cmp %rbp,%rbx
jne 1330 <func0+0x30>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r12d,%r12d
jmp 1355 <func0+0x55>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
cmp byte ptr [rdi], 0
jz short loc_1361
mov rbp, rdi
xor ebx, ebx
lea r14, s; "AEIOU"
xor r12d, r12d
call _strlen
lea r13, [rax+1]
shr r13, 1
jmp short loc_1350
loc_1330:
movsx esi, byte ptr [rbp+rbx*2+0]; c
mov rdi, r14; s
call _strchr
cmp rax, 1
sbb r12d, 0FFFFFFFFh
add rbx, 1
cmp byte ptr [rbp+rbx+0], 0
jz short loc_1355
loc_1350:
cmp rbx, r13
jnz short loc_1330
loc_1355:
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1361:
xor r12d, r12d
jmp short loc_1355
|
long long func0(const char *a1)
{
long long v1; // rbx
unsigned int v2; // r12d
size_t v3; // r13
if ( *a1 )
{
v1 = 0LL;
v2 = 0;
v3 = (strlen(a1) + 1) >> 1;
do
{
if ( v1 == v3 )
break;
v2 -= (strchr("AEIOU", a1[2 * v1++]) == 0LL) - 1;
}
while ( a1[v1] );
}
else
{
return 0;
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
CMP byte ptr [RDI],0x0
JZ 0x00101361
MOV RBP,RDI
XOR EBX,EBX
LEA R14,[0x102004]
XOR R12D,R12D
CALL 0x00101070
LEA R13,[RAX + 0x1]
SHR R13,0x1
JMP 0x00101350
LAB_00101330:
MOVSX ESI,byte ptr [RBP + RBX*0x2]
MOV RDI,R14
CALL 0x00101080
CMP RAX,0x1
SBB R12D,-0x1
ADD RBX,0x1
CMP byte ptr [RBP + RBX*0x1],0x0
JZ 0x00101355
LAB_00101350:
CMP RBX,R13
JNZ 0x00101330
LAB_00101355:
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101361:
XOR R12D,R12D
JMP 0x00101355
|
int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
int iVar4;
if (*param_1 == '\0') {
iVar4 = 0;
}
else {
uVar3 = 0;
iVar4 = 0;
sVar1 = strlen(param_1);
do {
if (uVar3 == sVar1 + 1 >> 1) {
return iVar4;
}
pcVar2 = strchr("AEIOU",(int)param_1[uVar3 * 2]);
iVar4 = (iVar4 + 1) - (uint)(pcVar2 == (char *)0x0);
uVar3 = uVar3 + 1;
} while (param_1[uVar3] != '\0');
}
return iVar4;
}
|
1,051 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmpb $0x0,(%rdi)
je 1361 <func0+0x61>
mov %rdi,%r14
xor %ebx,%ebx
lea 0xce7(%rip),%r13
xor %r12d,%r12d
callq 1070 <strlen@plt>
lea 0x1(%rax),%rbp
shr %rbp
jmp 1350 <func0+0x50>
xchg %ax,%ax
movsbl (%r14,%rbx,2),%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%r12d
add $0x1,%rbx
cmpb $0x0,(%r14,%rbx,1)
je 1355 <func0+0x55>
cmp %rbx,%rbp
jne 1330 <func0+0x30>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r12d,%r12d
jmp 1355 <func0+0x55>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
cmp byte ptr [rdi], 0
jz short loc_1361
mov rbp, rdi
xor ebx, ebx
lea r14, s; "AEIOU"
xor r12d, r12d
call _strlen
lea r13, [rax+1]
shr r13, 1
jmp short loc_1350
loc_1330:
movsx esi, byte ptr [rbp+rbx*2+0]; c
mov rdi, r14; s
call _strchr
cmp rax, 1
sbb r12d, 0FFFFFFFFh
add rbx, 1
cmp byte ptr [rbp+rbx+0], 0
jz short loc_1355
loc_1350:
cmp r13, rbx
jnz short loc_1330
loc_1355:
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1361:
xor r12d, r12d
jmp short loc_1355
|
long long func0(const char *a1)
{
long long v1; // rbx
unsigned int v2; // r12d
size_t v3; // r13
if ( *a1 )
{
v1 = 0LL;
v2 = 0;
v3 = (strlen(a1) + 1) >> 1;
do
{
if ( v3 == v1 )
break;
v2 -= (strchr("AEIOU", a1[2 * v1++]) == 0LL) - 1;
}
while ( a1[v1] );
}
else
{
return 0;
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
CMP byte ptr [RDI],0x0
JZ 0x00101361
MOV RBP,RDI
XOR EBX,EBX
LEA R14,[0x102004]
XOR R12D,R12D
CALL 0x00101070
LEA R13,[RAX + 0x1]
SHR R13,0x1
JMP 0x00101350
LAB_00101330:
MOVSX ESI,byte ptr [RBP + RBX*0x2]
MOV RDI,R14
CALL 0x00101080
CMP RAX,0x1
SBB R12D,-0x1
ADD RBX,0x1
CMP byte ptr [RBP + RBX*0x1],0x0
JZ 0x00101355
LAB_00101350:
CMP R13,RBX
JNZ 0x00101330
LAB_00101355:
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101361:
XOR R12D,R12D
JMP 0x00101355
|
int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
int iVar4;
if (*param_1 == '\0') {
iVar4 = 0;
}
else {
uVar3 = 0;
iVar4 = 0;
sVar1 = strlen(param_1);
do {
if (sVar1 + 1 >> 1 == uVar3) {
return iVar4;
}
pcVar2 = strchr("AEIOU",(int)param_1[uVar3 * 2]);
iVar4 = (iVar4 + 1) - (uint)(pcVar2 == (char *)0x0);
uVar3 = uVar3 + 1;
} while (param_1[uVar3] != '\0');
}
return iVar4;
}
|
1,052 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
}
|
#include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <atof@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
pxor %xmm0,%xmm0
comisd -0x8(%rbp),%xmm0
jbe 11f5 <func0+0x4c>
movsd -0x8(%rbp),%xmm0
movsd 0xee2(%rip),%xmm1
subsd %xmm1,%xmm0
callq 10b0 <ceil@plt>
cvttsd2si %xmm0,%eax
jmp 120f <func0+0x66>
movsd -0x8(%rbp),%xmm1
movsd 0xec6(%rip),%xmm0
addsd %xmm1,%xmm0
callq 10a0 <floor@plt>
cvttsd2si %xmm0,%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+nptr], rdi
mov rax, [rbp+nptr]
mov rdi, rax; nptr
call _atof
movq rax, xmm0
mov [rbp+var_8], rax
pxor xmm0, xmm0
comisd xmm0, [rbp+var_8]
jbe short loc_11FF
movsd xmm0, [rbp+var_8]
movsd xmm1, cs:qword_20A8
subsd xmm0, xmm1
movq rax, xmm0
movq xmm0, rax; x
call _ceil
cvttsd2si eax, xmm0
jmp short locret_1223
loc_11FF:
movsd xmm1, [rbp+var_8]
movsd xmm0, cs:qword_20A8
addsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _floor
cvttsd2si eax, xmm0
locret_1223:
leave
retn
|
long long func0(const char *a1)
{
double v2; // [rsp+18h] [rbp-8h]
v2 = atof(a1);
if ( v2 >= 0.0 )
return (unsigned int)(int)floor(v2 + 0.5);
else
return (unsigned int)(int)ceil(v2 - 0.5);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
PXOR XMM0,XMM0
COMISD XMM0,qword ptr [RBP + -0x8]
JBE 0x001011ff
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [0x001020a8]
SUBSD XMM0,XMM1
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x001010b0
CVTTSD2SI EAX,XMM0
JMP 0x00101223
LAB_001011ff:
MOVSD XMM1,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x001020a8]
ADDSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x001010a0
CVTTSD2SI EAX,XMM0
LAB_00101223:
LEAVE
RET
|
int func0(char *param_1)
{
double dVar1;
dVar1 = atof(param_1);
if (0.0 <= dVar1) {
dVar1 = floor(dVar1 + DAT_001020a8);
}
else {
dVar1 = ceil(dVar1 - DAT_001020a8);
}
return (int)dVar1;
}
|
1,053 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
}
|
#include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
sub $0x8,%rsp
mov $0x0,%esi
callq 1060 <strtod@plt>
pxor %xmm1,%xmm1
comisd %xmm0,%xmm1
ja 11eb <func0+0x82>
addsd 0xf33(%rip),%xmm0
movapd %xmm0,%xmm1
movsd 0xf47(%rip),%xmm3
movapd %xmm0,%xmm2
andpd %xmm3,%xmm2
movsd 0xf1f(%rip),%xmm4
ucomisd %xmm2,%xmm4
jbe 11e2 <func0+0x79>
cvttsd2si %xmm0,%rax
pxor %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
movapd %xmm2,%xmm1
cmpnlesd %xmm0,%xmm1
movsd 0xf02(%rip),%xmm4
andpd %xmm4,%xmm1
subsd %xmm1,%xmm2
andnpd %xmm0,%xmm3
movapd %xmm3,%xmm1
orpd %xmm2,%xmm1
cvttsd2si %xmm1,%eax
add $0x8,%rsp
retq
subsd 0xecd(%rip),%xmm0
movapd %xmm0,%xmm1
movsd 0xee1(%rip),%xmm3
movapd %xmm0,%xmm2
andpd %xmm3,%xmm2
movsd 0xeb9(%rip),%xmm4
ucomisd %xmm2,%xmm4
jbe 1244 <func0+0xdb>
cvttsd2si %xmm0,%rax
pxor %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
cmpnlesd %xmm2,%xmm1
movsd 0xea0(%rip),%xmm4
andpd %xmm4,%xmm1
addsd %xmm1,%xmm2
andnpd %xmm0,%xmm3
movapd %xmm3,%xmm1
orpd %xmm2,%xmm1
cvttsd2si %xmm1,%eax
jmp 11e6 <func0+0x7d>
|
func0:
endbr64
sub rsp, 8
mov esi, 0; endptr
call _strtod
pxor xmm1, xmm1
comisd xmm1, xmm0
ja short loc_11EB
addsd xmm0, cs:qword_20A0
movapd xmm3, xmm0
movsd xmm2, cs:qword_20B8
movapd xmm1, xmm0
andpd xmm1, xmm2
movsd xmm4, cs:qword_20A8
ucomisd xmm4, xmm1
jbe short loc_11E2
cvttsd2si rax, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
movsd xmm4, cs:qword_20B0
andpd xmm3, xmm4
subsd xmm1, xmm3
andnpd xmm2, xmm0
movapd xmm3, xmm1
orpd xmm3, xmm2
loc_11E2:
cvttsd2si eax, xmm3
loc_11E6:
add rsp, 8
retn
loc_11EB:
subsd xmm0, cs:qword_20A0
movapd xmm3, xmm0
movsd xmm2, cs:qword_20B8
movapd xmm1, xmm0
andpd xmm1, xmm2
movsd xmm4, cs:qword_20A8
ucomisd xmm4, xmm1
jbe short loc_1240
cvttsd2si rax, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, rax
cmpnlesd xmm3, xmm1
movsd xmm4, cs:qword_20B0
andpd xmm3, xmm4
addsd xmm3, xmm1
andnpd xmm2, xmm0
orpd xmm3, xmm2
loc_1240:
cvttsd2si eax, xmm3
jmp short loc_11E6
|
long long func0(const char *a1, __m128d a2)
{
double v2; // xmm0_8
__m128d v3; // xmm0
double v4; // xmm3_8
__m128d v5; // xmm1
unsigned long long v7; // xmm3_8
__m128d v8; // xmm1
v2 = strtod(a1, 0LL);
if ( v2 < 0.0 )
{
a2.m128d_f64[0] = v2 - 0.5;
v7 = *(unsigned long long *)&a2.m128d_f64[0];
if ( fabs(a2.m128d_f64[0]) < 4.503599627370496e15 )
{
v8.m128d_f64[0] = (double)(int)a2.m128d_f64[0];
v7 = COERCE_UNSIGNED_INT64(COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(a2, v8) & 0x3FF0000000000000LL) + v8.m128d_f64[0]) | *(_QWORD *)&a2.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)(int)*(double *)&v7;
}
else
{
v3.m128d_f64[0] = v2 + 0.5;
v4 = v3.m128d_f64[0];
if ( fabs(v3.m128d_f64[0]) < 4.503599627370496e15 )
{
v5 = 0LL;
v5.m128d_f64[0] = (double)(int)v3.m128d_f64[0];
*(_QWORD *)&v4 = COERCE_UNSIGNED_INT64(v5.m128d_f64[0] - COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v5, v3) & 0x3FF0000000000000LL)) | *(_QWORD *)&v3.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)(int)v4;
}
}
|
func0:
ENDBR64
SUB RSP,0x8
MOV ESI,0x0
CALL 0x00101060
PXOR XMM1,XMM1
COMISD XMM1,XMM0
JA 0x001011eb
ADDSD XMM0,qword ptr [0x001020a0]
MOVAPD XMM3,XMM0
MOVSD XMM2,qword ptr [0x001020b8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVSD XMM4,qword ptr [0x001020a8]
UCOMISD XMM4,XMM1
JBE 0x001011e2
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001020b0]
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ANDNPD XMM2,XMM0
MOVAPD XMM3,XMM1
ORPD XMM3,XMM2
LAB_001011e2:
CVTTSD2SI EAX,XMM3
LAB_001011e6:
ADD RSP,0x8
RET
LAB_001011eb:
SUBSD XMM0,qword ptr [0x001020a0]
MOVAPD XMM3,XMM0
MOVSD XMM2,qword ptr [0x001020b8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVSD XMM4,qword ptr [0x001020a8]
UCOMISD XMM4,XMM1
JBE 0x00101240
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,RAX
CMPNLESD XMM3,XMM1
MOVSD XMM4,qword ptr [0x001020b0]
ANDPD XMM3,XMM4
ADDSD XMM3,XMM1
ANDNPD XMM2,XMM0
ORPD XMM3,XMM2
LAB_00101240:
CVTTSD2SI EAX,XMM3
JMP 0x001011e6
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
double dVar1;
dVar1 = strtod(param_1,(char **)0x0);
if (dVar1 < 0.0) {
dVar1 = dVar1 - _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
dVar1 = (double)((ulong)((double)(-(ulong)((double)(long)dVar1 < dVar1) & DAT_001020b0) +
(double)(long)dVar1) | ~DAT_001020b8 & (ulong)dVar1);
}
}
else {
dVar1 = dVar1 + _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
dVar1 = (double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_001020b0)) |
~DAT_001020b8 & (ulong)dVar1);
}
}
return (int)dVar1;
}
|
1,054 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
}
|
#include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
sub $0x8,%rsp
xor %esi,%esi
callq 1060 <strtod@plt>
pxor %xmm1,%xmm1
comisd %xmm0,%xmm1
ja 1310 <func0+0x90>
addsd 0xe1f(%rip),%xmm0
movsd 0xe37(%rip),%xmm2
movsd 0xe17(%rip),%xmm3
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
ja 12d0 <func0+0x50>
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movsd 0xdef(%rip),%xmm4
andnpd %xmm0,%xmm2
add $0x8,%rsp
cvtsi2sd %rax,%xmm1
movapd %xmm1,%xmm3
cmpnlesd %xmm0,%xmm3
movapd %xmm2,%xmm0
andpd %xmm4,%xmm3
subsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopl 0x0(%rax)
subsd 0xda8(%rip),%xmm0
movsd 0xdc0(%rip),%xmm2
movsd 0xda0(%rip),%xmm3
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
jbe 12bf <func0+0x3f>
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movapd %xmm0,%xmm3
movsd 0xd85(%rip),%xmm4
andnpd %xmm0,%xmm2
add $0x8,%rsp
movapd %xmm2,%xmm0
cvtsi2sd %rax,%xmm1
cmpnlesd %xmm1,%xmm3
andpd %xmm4,%xmm3
addsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
sub rsp, 8
xor esi, esi; endptr
call _strtod
pxor xmm1, xmm1
comisd xmm1, xmm0
ja short loc_1310
addsd xmm0, cs:qword_20A0
movsd xmm2, cs:qword_20B8
movsd xmm3, cs:qword_20A8
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
ja short loc_12D0
loc_12BF:
cvttsd2si eax, xmm0
add rsp, 8
retn
loc_12D0:
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movsd xmm4, cs:qword_20B0
andnpd xmm2, xmm0
add rsp, 8
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
andpd xmm3, xmm4
subsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
cvttsd2si eax, xmm0
retn
loc_1310:
subsd xmm0, cs:qword_20A0
movsd xmm2, cs:qword_20B8
movsd xmm3, cs:qword_20A8
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
jbe short loc_12BF
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movapd xmm3, xmm0
movsd xmm4, cs:qword_20B0
andnpd xmm2, xmm0
add rsp, 8
cvtsi2sd xmm1, rax
cmpnlesd xmm3, xmm1
andpd xmm3, xmm4
addsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
cvttsd2si eax, xmm0
retn
|
long long func0(const char *a1, __m128d a2)
{
double v2; // xmm0_8
__m128d v4; // xmm1
__m128d v5; // xmm1
v2 = strtod(a1, 0LL);
if ( v2 < 0.0 )
{
a2.m128d_f64[0] = v2 - 0.5;
if ( fabs(a2.m128d_f64[0]) >= 4.503599627370496e15 )
return (unsigned int)(int)a2.m128d_f64[0];
v5.m128d_f64[0] = (double)(int)a2.m128d_f64[0];
return (unsigned int)(int)COERCE_DOUBLE(COERCE_UNSIGNED_INT64(
v5.m128d_f64[0]
+ COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(a2, v5) & 0x3FF0000000000000LL)) | *(_QWORD *)&a2.m128d_f64[0] & 0x8000000000000000LL);
}
else
{
a2.m128d_f64[0] = v2 + 0.5;
if ( fabs(a2.m128d_f64[0]) >= 4.503599627370496e15 )
return (unsigned int)(int)a2.m128d_f64[0];
v4 = 0LL;
v4.m128d_f64[0] = (double)(int)a2.m128d_f64[0];
return (unsigned int)(int)COERCE_DOUBLE(COERCE_UNSIGNED_INT64(
v4.m128d_f64[0]
- COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v4, a2) & 0x3FF0000000000000LL)) | *(_QWORD *)&a2.m128d_f64[0] & 0x8000000000000000LL);
}
}
|
func0:
ENDBR64
SUB RSP,0x8
XOR ESI,ESI
CALL 0x00101060
PXOR XMM1,XMM1
COMISD XMM1,XMM0
JA 0x00101310
ADDSD XMM0,qword ptr [0x001020a0]
MOVSD XMM2,qword ptr [0x001020b8]
MOVSD XMM3,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JA 0x001012d0
LAB_001012bf:
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET
LAB_001012d0:
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVSD XMM4,qword ptr [0x001020b0]
ANDNPD XMM2,XMM0
ADD RSP,0x8
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
CVTTSD2SI EAX,XMM0
RET
LAB_00101310:
SUBSD XMM0,qword ptr [0x001020a0]
MOVSD XMM2,qword ptr [0x001020b8]
MOVSD XMM3,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JBE 0x001012bf
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVAPD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001020b0]
ANDNPD XMM2,XMM0
ADD RSP,0x8
CVTSI2SD XMM1,RAX
CMPNLESD XMM3,XMM1
ANDPD XMM3,XMM4
ADDSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
CVTTSD2SI EAX,XMM0
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
double dVar1;
dVar1 = strtod(param_1,(char **)0x0);
if (dVar1 < 0.0) {
dVar1 = dVar1 - _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
return (int)(double)((ulong)((double)(long)dVar1 +
(double)(-(ulong)((double)(long)dVar1 < dVar1) & DAT_001020b0)) |
~DAT_001020b8 & (ulong)dVar1);
}
}
else {
dVar1 = dVar1 + _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
return (int)(double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_001020b0)) |
~DAT_001020b8 & (ulong)dVar1);
}
}
return (int)dVar1;
}
|
1,055 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
}
|
#include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
sub $0x8,%rsp
xor %esi,%esi
callq 1060 <strtod@plt>
pxor %xmm1,%xmm1
comisd %xmm0,%xmm1
ja 1310 <func0+0x90>
addsd 0xe1f(%rip),%xmm0
movsd 0xe37(%rip),%xmm2
movsd 0xe17(%rip),%xmm3
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
ja 12d0 <func0+0x50>
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movsd 0xdef(%rip),%xmm4
andnpd %xmm0,%xmm2
add $0x8,%rsp
cvtsi2sd %rax,%xmm1
movapd %xmm1,%xmm3
cmpnlesd %xmm0,%xmm3
movapd %xmm2,%xmm0
andpd %xmm4,%xmm3
subsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopl 0x0(%rax)
subsd 0xda8(%rip),%xmm0
movsd 0xdc0(%rip),%xmm2
movsd 0xda0(%rip),%xmm3
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
jbe 12bf <func0+0x3f>
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movapd %xmm0,%xmm3
movsd 0xd85(%rip),%xmm4
andnpd %xmm0,%xmm2
add $0x8,%rsp
movapd %xmm2,%xmm0
cvtsi2sd %rax,%xmm1
cmpnlesd %xmm1,%xmm3
andpd %xmm4,%xmm3
addsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
sub rsp, 8
xor esi, esi; endptr
call _strtod
pxor xmm1, xmm1
comisd xmm1, xmm0
ja short loc_1310
addsd xmm0, cs:qword_20A0
movsd xmm2, cs:qword_20B8
movsd xmm3, cs:qword_20A8
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
ja short loc_12D0
loc_12BF:
cvttsd2si eax, xmm0
add rsp, 8
retn
loc_12D0:
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movsd xmm4, cs:qword_20B0
andnpd xmm2, xmm0
add rsp, 8
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
andpd xmm3, xmm4
subsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
cvttsd2si eax, xmm0
retn
loc_1310:
subsd xmm0, cs:qword_20A0
movsd xmm2, cs:qword_20B8
movsd xmm3, cs:qword_20A8
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
jbe short loc_12BF
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movapd xmm3, xmm0
movsd xmm4, cs:qword_20B0
andnpd xmm2, xmm0
add rsp, 8
cvtsi2sd xmm1, rax
cmpnlesd xmm3, xmm1
andpd xmm3, xmm4
addsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
cvttsd2si eax, xmm0
retn
|
long long func0(const char *a1, __m128d a2)
{
double v2; // xmm0_8
__m128d v4; // xmm1
__m128d v5; // xmm1
v2 = strtod(a1, 0LL);
if ( v2 < 0.0 )
{
a2.m128d_f64[0] = v2 - 0.5;
if ( fabs(a2.m128d_f64[0]) >= 4.503599627370496e15 )
return (unsigned int)(int)a2.m128d_f64[0];
v5.m128d_f64[0] = (double)(int)a2.m128d_f64[0];
return (unsigned int)(int)COERCE_DOUBLE(COERCE_UNSIGNED_INT64(
v5.m128d_f64[0]
+ COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(a2, v5) & 0x3FF0000000000000LL)) | *(_QWORD *)&a2.m128d_f64[0] & 0x8000000000000000LL);
}
else
{
a2.m128d_f64[0] = v2 + 0.5;
if ( fabs(a2.m128d_f64[0]) >= 4.503599627370496e15 )
return (unsigned int)(int)a2.m128d_f64[0];
v4 = 0LL;
v4.m128d_f64[0] = (double)(int)a2.m128d_f64[0];
return (unsigned int)(int)COERCE_DOUBLE(COERCE_UNSIGNED_INT64(
v4.m128d_f64[0]
- COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v4, a2) & 0x3FF0000000000000LL)) | *(_QWORD *)&a2.m128d_f64[0] & 0x8000000000000000LL);
}
}
|
func0:
ENDBR64
SUB RSP,0x8
XOR ESI,ESI
CALL 0x00101060
PXOR XMM1,XMM1
COMISD XMM1,XMM0
JA 0x00101310
ADDSD XMM0,qword ptr [0x001020a0]
MOVSD XMM2,qword ptr [0x001020b8]
MOVSD XMM3,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JA 0x001012d0
LAB_001012bf:
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET
LAB_001012d0:
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVSD XMM4,qword ptr [0x001020b0]
ANDNPD XMM2,XMM0
ADD RSP,0x8
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
CVTTSD2SI EAX,XMM0
RET
LAB_00101310:
SUBSD XMM0,qword ptr [0x001020a0]
MOVSD XMM2,qword ptr [0x001020b8]
MOVSD XMM3,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JBE 0x001012bf
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVAPD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001020b0]
ANDNPD XMM2,XMM0
ADD RSP,0x8
CVTSI2SD XMM1,RAX
CMPNLESD XMM3,XMM1
ANDPD XMM3,XMM4
ADDSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
CVTTSD2SI EAX,XMM0
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
double dVar1;
dVar1 = strtod(param_1,(char **)0x0);
if (dVar1 < 0.0) {
dVar1 = dVar1 - _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
return (int)(double)((ulong)((double)(long)dVar1 +
(double)(-(ulong)((double)(long)dVar1 < dVar1) & DAT_001020b0)) |
~DAT_001020b8 & (ulong)dVar1);
}
}
else {
dVar1 = dVar1 + _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
return (int)(double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_001020b0)) |
~DAT_001020b8 & (ulong)dVar1);
}
}
return (int)dVar1;
}
|
1,056 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) assert(result[i] == test1[i]);
free(result);
result = func0(4);
for (int i = 0; i < 4; i++) assert(result[i] == test2[i]);
free(result);
result = func0(5);
for (int i = 0; i < 5; i++) assert(result[i] == test3[i]);
free(result);
result = func0(6);
for (int i = 0; i < 6; i++) assert(result[i] == test4[i]);
free(result);
result = func0(8);
for (int i = 0; i < 8; i++) assert(result[i] == test5[i]);
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov -0x14(%rbp),%edx
mov %edx,(%rax)
movl $0x1,-0xc(%rbp)
jmp 1212 <func0+0x69>
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
add $0x2,%edx
mov %edx,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 11df <func0+0x36>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov edx, [rbp+var_14]
mov [rax], edx
mov [rbp+var_C], 1
jmp short loc_1212
loc_11DF:
mov eax, [rbp+var_C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rcx
add edx, 2
mov [rax], edx
add [rbp+var_C], 1
loc_1212:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jl short loc_11DF
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(int a1)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v3; // [rsp+18h] [rbp-8h]
v3 = malloc(4LL * a1);
*v3 = a1;
for ( i = 1; i < a1; ++i )
v3[i] = v3[i - 1] + 2;
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101212
LAB_001011df:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
ADD EDX,0x2
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0xc],0x1
LAB_00101212:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x001011df
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int * func0(int param_1)
{
int *piVar1;
int local_14;
piVar1 = (int *)malloc((long)param_1 << 2);
*piVar1 = param_1;
for (local_14 = 1; local_14 < param_1; local_14 = local_14 + 1) {
piVar1[local_14] = piVar1[(long)local_14 + -1] + 2;
}
return piVar1;
}
|
1,057 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) assert(result[i] == test1[i]);
free(result);
result = func0(4);
for (int i = 0; i < 4; i++) assert(result[i] == test2[i]);
free(result);
result = func0(5);
for (int i = 0; i < 5; i++) assert(result[i] == test3[i]);
free(result);
result = func0(6);
for (int i = 0; i < 6; i++) assert(result[i] == test4[i]);
free(result);
result = func0(8);
for (int i = 0; i < 8; i++) assert(result[i] == test5[i]);
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %ebx,(%rax)
cmp $0x1,%ebx
jle 11df <func0+0x36>
mov %rax,%rdx
lea -0x2(%rbx),%ecx
lea 0x4(%rax,%rcx,4),%rsi
mov (%rdx),%ebx
lea 0x2(%rbx),%ecx
mov %ecx,0x4(%rdx)
add $0x4,%rdx
cmp %rsi,%rdx
jne 11ce <func0+0x25>
pop %rbx
retq
|
func0:
endbr64
push rbx
mov ebx, edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov [rax], ebx
cmp ebx, 1
jle short loc_11DE
mov rdx, rax
lea ecx, [rbx-1]
lea rsi, [rax+rcx*4]
loc_11CD:
mov ebx, [rdx]
lea ecx, [rbx+2]
mov [rdx+4], ecx
add rdx, 4
cmp rdx, rsi
jnz short loc_11CD
loc_11DE:
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
_DWORD *v2; // rdx
result = malloc(4LL * a1);
*result = a1;
if ( a1 > 1 )
{
v2 = result;
do
{
v2[1] = *v2 + 2;
++v2;
}
while ( v2 != &result[a1 - 1] );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],EBX
CMP EBX,0x1
JLE 0x001011de
MOV RDX,RAX
LEA ECX,[RBX + -0x1]
LEA RSI,[RAX + RCX*0x4]
LAB_001011cd:
MOV EBX,dword ptr [RDX]
LEA ECX,[RBX + 0x2]
MOV dword ptr [RDX + 0x4],ECX
ADD RDX,0x4
CMP RDX,RSI
JNZ 0x001011cd
LAB_001011de:
POP RBX
RET
|
void func0(int param_1)
{
int *piVar1;
int *piVar2;
piVar2 = (int *)malloc((long)param_1 << 2);
*piVar2 = param_1;
if (1 < param_1) {
piVar1 = piVar2 + (param_1 - 1);
do {
piVar2[1] = *piVar2 + 2;
piVar2 = piVar2 + 1;
} while (piVar2 != piVar1);
}
return;
}
|
1,058 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) assert(result[i] == test1[i]);
free(result);
result = func0(4);
for (int i = 0; i < 4; i++) assert(result[i] == test2[i]);
free(result);
result = func0(5);
for (int i = 0; i < 5; i++) assert(result[i] == test3[i]);
free(result);
result = func0(6);
for (int i = 0; i < 6; i++) assert(result[i] == test4[i]);
free(result);
result = func0(8);
for (int i = 0; i < 8; i++) assert(result[i] == test5[i]);
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %ebx,(%rax)
cmp $0x1,%ebx
jle 145e <func0+0x3e>
lea -0x2(%rbx),%ecx
lea 0x4(%rax),%rdx
lea 0x4(%rax,%rcx,4),%rcx
jmp 1454 <func0+0x34>
nopl 0x0(%rax)
add $0x4,%rdx
add $0x2,%ebx
mov %ebx,(%rdx)
cmp %rcx,%rdx
jne 1450 <func0+0x30>
pop %rbx
retq
|
func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov [rax], ebx
cmp ebx, 1
jle short loc_140F
lea ecx, [rbx-2]
lea rdx, [rax+4]
lea rcx, [rax+rcx*4+8]
nop word ptr [rax+rax+00000000h]
loc_1400:
add ebx, 2
add rdx, 4
mov [rdx-4], ebx
cmp rdx, rcx
jnz short loc_1400
loc_140F:
pop rbx
retn
|
_DWORD * func0(int a1)
{
int v1; // ebx
_DWORD *result; // rax
_DWORD *v3; // rdx
v1 = a1;
result = malloc(4LL * a1);
*result = a1;
if ( a1 > 1 )
{
v3 = result + 1;
do
{
v1 += 2;
*v3++ = v1;
}
while ( v3 != &result[a1 - 2 + 2] );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],EBX
CMP EBX,0x1
JLE 0x0010140f
LEA ECX,[RBX + -0x2]
LEA RDX,[RAX + 0x4]
LEA RCX,[RAX + RCX*0x4 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101400:
ADD EBX,0x2
ADD RDX,0x4
MOV dword ptr [RDX + -0x4],EBX
CMP RDX,RCX
JNZ 0x00101400
LAB_0010140f:
POP RBX
RET
|
void func0(int param_1)
{
int *piVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
uVar5 = (ulong)param_1;
piVar1 = (int *)malloc(uVar5 << 2);
*piVar1 = param_1;
if (1 < param_1) {
puVar2 = (uint *)(piVar1 + 1);
do {
uVar4 = (int)uVar5 + 2;
uVar5 = (ulong)uVar4;
puVar3 = puVar2 + 1;
*puVar2 = uVar4;
puVar2 = puVar3;
} while (puVar3 != (uint *)(piVar1 + (ulong)(param_1 - 2) + 2));
}
return;
}
|
1,059 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) assert(result[i] == test1[i]);
free(result);
result = func0(4);
for (int i = 0; i < 4; i++) assert(result[i] == test2[i]);
free(result);
result = func0(5);
for (int i = 0; i < 5; i++) assert(result[i] == test3[i]);
free(result);
result = func0(6);
for (int i = 0; i < 6; i++) assert(result[i] == test4[i]);
free(result);
result = func0(8);
for (int i = 0; i < 8; i++) assert(result[i] == test5[i]);
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %ebx,(%rax)
cmp $0x1,%ebx
jle 1455 <func0+0x35>
lea 0x2(%rbx),%edx
lea 0x4(%rax),%rcx
lea (%rbx,%rbx,2),%esi
nopl (%rax)
mov %edx,(%rcx)
add $0x2,%edx
add $0x4,%rcx
cmp %esi,%edx
jne 1448 <func0+0x28>
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov [rax], ebx
cmp ebx, 1
jle short loc_13AF
lea ecx, [rbx-2]
lea rdx, [rax+4]
lea rcx, [rax+rcx*4+8]
nop word ptr [rax+rax+00000000h]
loc_13A0:
add ebx, 2
add rdx, 4
mov [rdx-4], ebx
cmp rdx, rcx
jnz short loc_13A0
loc_13AF:
pop rbx
retn
|
_DWORD * func0(int a1)
{
int v1; // ebx
_DWORD *result; // rax
_DWORD *v3; // rdx
v1 = a1;
result = malloc(4LL * a1);
*result = a1;
if ( a1 > 1 )
{
v3 = result + 1;
do
{
v1 += 2;
*v3++ = v1;
}
while ( v3 != &result[a1 - 2 + 2] );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x00101090
MOV dword ptr [RAX],EBX
CMP EBX,0x1
JLE 0x001013af
LEA ECX,[RBX + -0x2]
LEA RDX,[RAX + 0x4]
LEA RCX,[RAX + RCX*0x4 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001013a0:
ADD EBX,0x2
ADD RDX,0x4
MOV dword ptr [RDX + -0x4],EBX
CMP RDX,RCX
JNZ 0x001013a0
LAB_001013af:
POP RBX
RET
|
void func0(int param_1)
{
int *piVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
uVar5 = (ulong)param_1;
piVar1 = (int *)malloc(uVar5 << 2);
*piVar1 = param_1;
if (1 < param_1) {
puVar2 = (uint *)(piVar1 + 1);
do {
uVar4 = (int)uVar5 + 2;
uVar5 = (ulong)uVar4;
puVar3 = puVar2 + 1;
*puVar2 = uVar4;
puVar2 = puVar3;
} while (puVar3 != (uint *)(piVar1 + (ulong)(param_1 - 2) + 2));
}
return;
}
|
1,060 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
current_length = 0;
if (word_count >= capacity) {
capacity *= 2;
out = realloc(out, capacity * sizeof(char*));
}
}
} else {
current[current_length++] = s[i];
}
}
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
}
free(current);
*count = word_count;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char** words, int count) {
for (int i = 0; i < count; i++)
free(words[i]);
free(words);
}
int main() {
int count;
char** result;
char* expected1[] = {"Hi", "my", "name", "is", "John"};
result = func0("Hi, my name is John", &count);
assert(issame(result, count, expected1, 5));
free_words(result, count);
char* expected2[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One, two, three, four, five, six", &count);
assert(issame(result, count, expected2, 6));
free_words(result, count);
char* expected3[] = {"Hi", "my", "name"};
result = func0("Hi, my name", &count);
assert(issame(result, count, expected3, 3));
free_words(result, count);
char* expected4[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One,, two, three, four, five, six,", &count);
assert(issame(result, count, expected4, 6));
free_words(result, count);
char* expected5[] = {};
result = func0("", &count);
assert(issame(result, count, expected5, 0));
free_words(result, count);
char* expected6[] = {"ahmed", "gamal"};
result = func0("ahmed , gamal", &count);
assert(issame(result, count, expected6, 2));
free_words(result, count);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
movl $0xa,-0x30(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
add $0x1,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x2c(%rbp)
movl $0x0,-0x28(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 135d <func0+0x134>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 12b8 <func0+0x8f>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2c,%al
jne 1330 <func0+0x107>
cmpl $0x0,-0x28(%rbp)
jle 1358 <func0+0x12f>
mov -0x28(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x2c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x2c(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1130 <strdup@plt>
mov %rax,(%rbx)
movl $0x0,-0x28(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1358 <func0+0x12f>
shll -0x30(%rbp)
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1120 <realloc@plt>
mov %rax,-0x20(%rbp)
jmp 1358 <func0+0x12f>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x28(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x28(%rbp)
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
jmp 1359 <func0+0x130>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1290 <func0+0x67>
cmpl $0x0,-0x28(%rbp)
jle 13b5 <func0+0x18c>
mov -0x28(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x2c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x2c(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1130 <strdup@plt>
mov %rax,(%rbx)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10c0 <free@plt>
mov -0x40(%rbp),%rax
mov -0x2c(%rbp),%edx
mov %edx,(%rax)
mov -0x20(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov [rbp+var_30], 0Ah
mov eax, [rbp+var_30]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_2C], 0
mov [rbp+var_28], 0
mov [rbp+var_24], 0
jmp loc_135D
loc_1290:
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_12B8
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jnz short loc_1330
loc_12B8:
cmp [rbp+var_28], 0
jle loc_1358
mov eax, [rbp+var_28]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 0
mov eax, [rbp+var_2C]
lea edx, [rax+1]
mov [rbp+var_2C], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
lea rbx, [rdx+rax]
mov rax, [rbp+var_18]
mov rdi, rax; s
call _strdup
mov [rbx], rax
mov [rbp+var_28], 0
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_30]
jl short loc_1358
shl [rbp+var_30], 1
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
jmp short loc_1358
loc_1330:
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_28]
lea edx, [rax+1]
mov [rbp+var_28], edx
movsxd rdx, eax
mov rax, [rbp+var_18]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
jmp short loc_1359
loc_1358:
nop
loc_1359:
add [rbp+var_24], 1
loc_135D:
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_1290
cmp [rbp+var_28], 0
jle short loc_13B5
mov eax, [rbp+var_28]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 0
mov eax, [rbp+var_2C]
lea edx, [rax+1]
mov [rbp+var_2C], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
lea rbx, [rdx+rax]
mov rax, [rbp+var_18]
mov rdi, rax; s
call _strdup
mov [rbx], rax
loc_13B5:
mov rax, [rbp+var_18]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_40]
mov edx, [rbp+var_2C]
mov [rax], edx
mov rax, [rbp+ptr]
mov rbx, [rbp+var_8]
leave
retn
|
_QWORD * func0(const char *a1, int *a2)
{
size_t v2; // rax
int v3; // eax
int v4; // eax
int v5; // eax
int v7; // [rsp+10h] [rbp-30h]
int v8; // [rsp+14h] [rbp-2Ch]
int v9; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
_QWORD *ptr; // [rsp+20h] [rbp-20h]
char *v12; // [rsp+28h] [rbp-18h]
v7 = 10;
ptr = malloc(0x50uLL);
v2 = strlen(a1);
v12 = (char *)malloc(v2 + 1);
v8 = 0;
v9 = 0;
for ( i = 0; a1[i]; ++i )
{
if ( a1[i] == 32 || a1[i] == 44 )
{
if ( v9 > 0 )
{
v12[v9] = 0;
v3 = v8++;
ptr[v3] = strdup(v12);
v9 = 0;
if ( v8 >= v7 )
{
v7 *= 2;
ptr = realloc(ptr, 8LL * v7);
}
}
}
else
{
v4 = v9++;
v12[v4] = a1[i];
}
}
if ( v9 > 0 )
{
v12[v9] = 0;
v5 = v8++;
ptr[v5] = strdup(v12);
}
free(v12);
*a2 = v8;
return ptr;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x30],0xa
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010d0
ADD RAX,0x1
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x2c],0x0
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010135d
LAB_00101290:
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x001012b8
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JNZ 0x00101330
LAB_001012b8:
CMP dword ptr [RBP + -0x28],0x0
JLE 0x00101358
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x2c],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x28],0x0
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101358
SHL dword ptr [RBP + -0x30],0x1
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00101358
LAB_00101330:
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x28]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x28],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
JMP 0x00101359
LAB_00101358:
NOP
LAB_00101359:
ADD dword ptr [RBP + -0x24],0x1
LAB_0010135d:
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101290
CMP dword ptr [RBP + -0x28],0x0
JLE 0x001013b5
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x2c],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBX],RAX
LAB_001013b5:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010c0
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *__s;
char *pcVar3;
int local_38;
int local_34;
int local_30;
int local_2c;
void *local_28;
local_38 = 10;
local_28 = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
local_34 = 0;
local_30 = 0;
for (local_2c = 0; param_1[local_2c] != '\0'; local_2c = local_2c + 1) {
if ((param_1[local_2c] == ' ') || (param_1[local_2c] == ',')) {
if (0 < local_30) {
__s[local_30] = '\0';
iVar1 = local_34 + 1;
pcVar3 = strdup(__s);
*(char **)((long)local_34 * 8 + (long)local_28) = pcVar3;
local_30 = 0;
local_34 = iVar1;
if (local_38 <= iVar1) {
local_38 = local_38 << 1;
local_28 = realloc(local_28,(long)local_38 * 8);
}
}
}
else {
__s[local_30] = param_1[local_2c];
local_30 = local_30 + 1;
}
}
if (0 < local_30) {
__s[local_30] = '\0';
pcVar3 = strdup(__s);
*(char **)((long)local_34 * 8 + (long)local_28) = pcVar3;
local_34 = local_34 + 1;
}
free(__s);
*param_2 = local_34;
return local_28;
}
|
1,061 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
current_length = 0;
if (word_count >= capacity) {
capacity *= 2;
out = realloc(out, capacity * sizeof(char*));
}
}
} else {
current[current_length++] = s[i];
}
}
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
}
free(current);
*count = word_count;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char** words, int count) {
for (int i = 0; i < count; i++)
free(words[i]);
free(words);
}
int main() {
int count;
char** result;
char* expected1[] = {"Hi", "my", "name", "is", "John"};
result = func0("Hi, my name is John", &count);
assert(issame(result, count, expected1, 5));
free_words(result, count);
char* expected2[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One, two, three, four, five, six", &count);
assert(issame(result, count, expected2, 6));
free_words(result, count);
char* expected3[] = {"Hi", "my", "name"};
result = func0("Hi, my name", &count);
assert(issame(result, count, expected3, 3));
free_words(result, count);
char* expected4[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One,, two, three, four, five, six,", &count);
assert(issame(result, count, expected4, 6));
free_words(result, count);
char* expected5[] = {};
result = func0("", &count);
assert(issame(result, count, expected5, 0));
free_words(result, count);
char* expected6[] = {"ahmed", "gamal"};
result = func0("ahmed , gamal", &count);
assert(issame(result, count, expected6, 2));
free_words(result, count);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %rsi,0x8(%rsp)
mov $0x50,%edi
callq 10f0 <malloc@plt>
mov %rax,%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
callq 10f0 <malloc@plt>
mov %rax,%r12
movzbl (%rbx),%eax
test %al,%al
je 131b <func0+0x112>
add $0x1,%rbx
mov $0x0,%edx
mov $0x0,%ebp
mov $0xa,%r15d
jmp 1286 <func0+0x7d>
movslq %edx,%rcx
mov %al,(%r12,%rcx,1)
lea 0x1(%rdx),%edx
add $0x1,%rbx
movzbl -0x1(%rbx),%eax
test %al,%al
je 12d7 <func0+0xce>
cmp $0x20,%al
je 128e <func0+0x85>
cmp $0x2c,%al
jne 1270 <func0+0x67>
test %edx,%edx
jle 127a <func0+0x71>
movslq %edx,%rdx
movb $0x0,(%r12,%rdx,1)
lea 0x1(%rbp),%r14d
mov %r12,%rdi
callq 1110 <strdup@plt>
movslq %ebp,%rbp
mov %rax,0x0(%r13,%rbp,8)
mov %r14d,%ebp
mov $0x0,%edx
cmp %r15d,%r14d
jl 127a <func0+0x71>
add %r15d,%r15d
movslq %r15d,%rsi
shl $0x3,%rsi
mov %r13,%rdi
callq 1100 <realloc@plt>
mov %rax,%r13
mov $0x0,%edx
jmp 127a <func0+0x71>
test %edx,%edx
jg 12fc <func0+0xf3>
mov %r12,%rdi
callq 10b0 <free@plt>
mov 0x8(%rsp),%rax
mov %ebp,(%rax)
mov %r13,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq %edx,%rdx
movb $0x0,(%r12,%rdx,1)
lea 0x1(%rbp),%ebx
mov %r12,%rdi
callq 1110 <strdup@plt>
movslq %ebp,%rbp
mov %rax,0x0(%r13,%rbp,8)
mov %ebx,%ebp
jmp 12db <func0+0xd2>
mov $0x0,%ebp
jmp 12db <func0+0xd2>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov [rsp+48h+var_40], rsi
mov edi, 50h ; 'P'; size
call _malloc
mov r13, rax
mov rdi, rbx; s
call _strlen
lea rdi, [rax+1]; size
call _malloc
mov r12, rax
movzx eax, byte ptr [rbx]
test al, al
jz loc_1330
add rbx, 1
mov edx, 0
mov ebp, 0
mov r15d, 0Ah
jmp short loc_129B
loc_1285:
movsxd rcx, edx
mov [r12+rcx], al
lea edx, [rdx+1]
loc_128F:
add rbx, 1
movzx eax, byte ptr [rbx-1]
test al, al
jz short loc_12EC
loc_129B:
cmp al, 20h ; ' '
jz short loc_12A3
cmp al, 2Ch ; ','
jnz short loc_1285
loc_12A3:
test edx, edx
jle short loc_128F
movsxd rdx, edx
mov byte ptr [r12+rdx], 0
lea r14d, [rbp+1]
mov rdi, r12; s
call _strdup
movsxd rbp, ebp
mov [r13+rbp*8+0], rax
mov ebp, r14d
mov edx, 0
cmp r14d, r15d
jl short loc_128F
add r15d, r15d
movsxd rsi, r15d
shl rsi, 3; size
mov rdi, r13; ptr
call _realloc
mov r13, rax
mov edx, 0
jmp short loc_128F
loc_12EC:
test edx, edx
jg short loc_1311
loc_12F0:
mov rdi, r12; ptr
call _free
mov rax, [rsp+48h+var_40]
mov [rax], ebp
mov rax, r13
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1311:
movsxd rdx, edx
mov byte ptr [r12+rdx], 0
lea ebx, [rbp+1]
mov rdi, r12; s
call _strdup
movsxd rbp, ebp
mov [r13+rbp*8+0], rax
mov ebp, ebx
jmp short loc_12F0
loc_1330:
mov ebp, 0
jmp short loc_12F0
|
_QWORD * func0(char *s, int *a2)
{
_QWORD *v2; // r13
size_t v3; // rax
char *v4; // r12
char v5; // al
char *v6; // rbx
int v7; // edx
int v8; // ebp
int v9; // r15d
v2 = malloc(0x50uLL);
v3 = strlen(s);
v4 = (char *)malloc(v3 + 1);
v5 = *s;
if ( *s )
{
v6 = s + 1;
v7 = 0;
v8 = 0;
v9 = 10;
do
{
if ( v5 == 32 || v5 == 44 )
{
if ( v7 > 0 )
{
v4[v7] = 0;
v2[v8++] = strdup(v4);
v7 = 0;
if ( v8 >= v9 )
{
v9 *= 2;
v2 = realloc(v2, 8LL * v9);
v7 = 0;
}
}
}
else
{
v4[v7++] = v5;
}
v5 = *v6++;
}
while ( v5 );
if ( v7 > 0 )
{
v4[v7] = 0;
v2[v8++] = strdup(v4);
}
}
else
{
v8 = 0;
}
free(v4);
*a2 = v8;
return v2;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV EDI,0x50
CALL 0x00101110
MOV R13,RAX
MOV RDI,RBX
CALL 0x001010d0
LEA RDI,[RAX + 0x1]
CALL 0x00101110
MOV R12,RAX
MOVZX EAX,byte ptr [RBX]
TEST AL,AL
JZ 0x00101330
ADD RBX,0x1
MOV EDX,0x0
MOV EBP,0x0
MOV R15D,0xa
JMP 0x0010129b
LAB_00101285:
MOVSXD RCX,EDX
MOV byte ptr [R12 + RCX*0x1],AL
LEA EDX,[RDX + 0x1]
LAB_0010128f:
ADD RBX,0x1
MOVZX EAX,byte ptr [RBX + -0x1]
TEST AL,AL
JZ 0x001012ec
LAB_0010129b:
CMP AL,0x20
JZ 0x001012a3
CMP AL,0x2c
JNZ 0x00101285
LAB_001012a3:
TEST EDX,EDX
JLE 0x0010128f
MOVSXD RDX,EDX
MOV byte ptr [R12 + RDX*0x1],0x0
LEA R14D,[RBP + 0x1]
MOV RDI,R12
CALL 0x00101130
MOVSXD RBP,EBP
MOV qword ptr [R13 + RBP*0x8],RAX
MOV EBP,R14D
MOV EDX,0x0
CMP R14D,R15D
JL 0x0010128f
ADD R15D,R15D
MOVSXD RSI,R15D
SHL RSI,0x3
MOV RDI,R13
CALL 0x00101120
MOV R13,RAX
MOV EDX,0x0
JMP 0x0010128f
LAB_001012ec:
TEST EDX,EDX
JG 0x00101311
LAB_001012f0:
MOV RDI,R12
CALL 0x001010c0
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],EBP
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101311:
MOVSXD RDX,EDX
MOV byte ptr [R12 + RDX*0x1],0x0
LEA EBX,[RBP + 0x1]
MOV RDI,R12
CALL 0x00101130
MOVSXD RBP,EBP
MOV qword ptr [R13 + RBP*0x8],RAX
MOV EBP,EBX
JMP 0x001012f0
LAB_00101330:
MOV EBP,0x0
JMP 0x001012f0
|
void * func0(char *param_1,int *param_2)
{
char cVar1;
void *__ptr;
size_t sVar2;
char *__s;
char *pcVar3;
char *pcVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
__ptr = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar7 = 0;
}
else {
iVar5 = 0;
iVar6 = 0;
iVar7 = 10;
pcVar4 = param_1 + 1;
do {
if ((cVar1 == ' ') || (cVar1 == ',')) {
if (0 < iVar5) {
__s[iVar5] = '\0';
iVar8 = iVar6 + 1;
pcVar3 = strdup(__s);
*(char **)((long)__ptr + (long)iVar6 * 8) = pcVar3;
iVar5 = 0;
iVar6 = iVar8;
if (iVar7 <= iVar8) {
iVar7 = iVar7 * 2;
__ptr = realloc(__ptr,(long)iVar7 << 3);
iVar5 = 0;
}
}
}
else {
__s[iVar5] = cVar1;
iVar5 = iVar5 + 1;
}
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
iVar7 = iVar6;
if (0 < iVar5) {
__s[iVar5] = '\0';
iVar7 = iVar6 + 1;
pcVar4 = strdup(__s);
*(char **)((long)__ptr + (long)iVar6 * 8) = pcVar4;
}
}
free(__s);
*param_2 = iVar7;
return __ptr;
}
|
1,062 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
current_length = 0;
if (word_count >= capacity) {
capacity *= 2;
out = realloc(out, capacity * sizeof(char*));
}
}
} else {
current[current_length++] = s[i];
}
}
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
}
free(current);
*count = word_count;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char** words, int count) {
for (int i = 0; i < count; i++)
free(words[i]);
free(words);
}
int main() {
int count;
char** result;
char* expected1[] = {"Hi", "my", "name", "is", "John"};
result = func0("Hi, my name is John", &count);
assert(issame(result, count, expected1, 5));
free_words(result, count);
char* expected2[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One, two, three, four, five, six", &count);
assert(issame(result, count, expected2, 6));
free_words(result, count);
char* expected3[] = {"Hi", "my", "name"};
result = func0("Hi, my name", &count);
assert(issame(result, count, expected3, 3));
free_words(result, count);
char* expected4[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One,, two, three, four, five, six,", &count);
assert(issame(result, count, expected4, 6));
free_words(result, count);
char* expected5[] = {};
result = func0("", &count);
assert(issame(result, count, expected5, 0));
free_words(result, count);
char* expected6[] = {"ahmed", "gamal"};
result = func0("ahmed , gamal", &count);
assert(issame(result, count, expected6, 2));
free_words(result, count);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov $0x50,%edi
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1110 <malloc@plt>
mov %rbx,%rdi
mov %rax,%r12
callq 10d0 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1110 <malloc@plt>
mov %rax,%r14
movzbl (%rbx),%eax
test %al,%al
je 1770 <func0+0x110>
add $0x1,%rbx
xor %ebp,%ebp
xor %r15d,%r15d
mov $0xa,%r13d
jmp 16d5 <func0+0x75>
nopw 0x0(%rax,%rax,1)
movslq %ebp,%rdx
add $0x1,%ebp
mov %al,(%r14,%rdx,1)
movzbl (%rbx),%eax
add $0x1,%rbx
test %al,%al
je 1728 <func0+0xc8>
cmp $0x20,%al
je 16dd <func0+0x7d>
cmp $0x2c,%al
jne 16c0 <func0+0x60>
test %ebp,%ebp
je 16ca <func0+0x6a>
movslq %ebp,%rbp
mov %r14,%rdi
movb $0x0,(%r14,%rbp,1)
lea 0x1(%r15),%ebp
callq 1130 <strdup@plt>
mov %rax,(%r12,%r15,8)
movslq %ebp,%r15
xor %ebp,%ebp
cmp %r13d,%r15d
jl 16ca <func0+0x6a>
add %r13d,%r13d
mov %r12,%rdi
add $0x1,%rbx
movslq %r13d,%rsi
shl $0x3,%rsi
callq 1120 <realloc@plt>
mov %rax,%r12
movzbl -0x1(%rbx),%eax
test %al,%al
jne 16d5 <func0+0x75>
nopl 0x0(%rax)
test %ebp,%ebp
jne 1750 <func0+0xf0>
mov %r14,%rdi
callq 10c0 <free@plt>
mov 0x8(%rsp),%rax
mov %r15d,(%rax)
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
movslq %ebp,%rbp
mov %r14,%rdi
lea 0x1(%r15),%ebx
movb $0x0,(%r14,%rbp,1)
callq 1130 <strdup@plt>
mov %rax,(%r12,%r15,8)
mov %ebx,%r15d
jmp 172c <func0+0xcc>
nopl (%rax)
xor %r15d,%r15d
jmp 172c <func0+0xcc>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
mov rdi, r14; s
mov rbp, rax
call _strlen
lea rdi, [rax+1]; size
call _malloc
mov r12, rax
movzx eax, byte ptr [r14]
test al, al
jz loc_17A0
add r14, 1
xor ebx, ebx
xor r15d, r15d
mov r13d, 0Ah
jmp short loc_16F6
loc_16E0:
movsxd rcx, ebx
add ebx, 1
mov [r12+rcx], al
loc_16EA:
movzx eax, byte ptr [r14]
add r14, 1
test al, al
jz short loc_1750
loc_16F6:
cmp al, 20h ; ' '
jz short loc_16FE
cmp al, 2Ch ; ','
jnz short loc_16E0
loc_16FE:
test ebx, ebx
jle short loc_16EA
movsxd rbx, ebx
mov rdi, r12; s
mov byte ptr [r12+rbx], 0
lea ebx, [r15+1]
call _strdup
mov [rbp+r15*8+0], rax
movsxd r15, ebx
xor ebx, ebx
cmp r15d, r13d
jl short loc_16EA
add r13d, r13d
mov rdi, rbp; ptr
add r14, 1
movsxd rsi, r13d
shl rsi, 3; size
call _realloc
mov rbp, rax
movzx eax, byte ptr [r14-1]
test al, al
jnz short loc_16F6
nop word ptr [rax+rax+00000000h]
loc_1750:
test ebx, ebx
jg short loc_1780
loc_1754:
mov rdi, r12; ptr
call _free
mov rax, [rsp+48h+var_40]
mov [rax], r15d
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1780:
movsxd rbx, ebx
mov rdi, r12; s
mov byte ptr [r12+rbx], 0
lea ebx, [r15+1]
call _strdup
mov [rbp+r15*8+0], rax
mov r15d, ebx
jmp short loc_1754
loc_17A0:
xor r15d, r15d
jmp short loc_1754
|
_QWORD * func0(char *s, _DWORD *a2)
{
_QWORD *v2; // rbp
size_t v3; // rax
char *v4; // r12
char v5; // al
char *v6; // r14
int v7; // ebx
long long v8; // r15
int v9; // r13d
long long v10; // rcx
v2 = malloc(0x50uLL);
v3 = strlen(s);
v4 = (char *)malloc(v3 + 1);
v5 = *s;
if ( !*s )
{
LODWORD(v8) = 0;
goto LABEL_12;
}
v6 = s + 1;
v7 = 0;
v8 = 0LL;
v9 = 10;
do
{
while ( v5 != 32 && v5 != 44 )
{
v10 = v7++;
v4[v10] = v5;
LABEL_4:
v5 = *v6++;
if ( !v5 )
goto LABEL_10;
}
if ( v7 <= 0 )
goto LABEL_4;
v4[v7] = 0;
v2[v8] = strdup(v4);
v8 = (int)v8 + 1;
v7 = 0;
if ( (int)v8 < v9 )
goto LABEL_4;
v9 *= 2;
++v6;
v2 = realloc(v2, 8LL * v9);
v5 = *(v6 - 1);
}
while ( v5 );
LABEL_10:
if ( v7 > 0 )
{
v4[v7] = 0;
v2[v8] = strdup(v4);
LODWORD(v8) = v8 + 1;
}
LABEL_12:
free(v4);
*a2 = v8;
return v2;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101110
MOV RDI,R14
MOV RBP,RAX
CALL 0x001010d0
LEA RDI,[RAX + 0x1]
CALL 0x00101110
MOV R12,RAX
MOVZX EAX,byte ptr [R14]
TEST AL,AL
JZ 0x001017a0
ADD R14,0x1
XOR EBX,EBX
XOR R15D,R15D
MOV R13D,0xa
JMP 0x001016f6
LAB_001016e0:
MOVSXD RCX,EBX
ADD EBX,0x1
MOV byte ptr [R12 + RCX*0x1],AL
LAB_001016ea:
MOVZX EAX,byte ptr [R14]
ADD R14,0x1
TEST AL,AL
JZ 0x00101750
LAB_001016f6:
CMP AL,0x20
JZ 0x001016fe
CMP AL,0x2c
JNZ 0x001016e0
LAB_001016fe:
TEST EBX,EBX
JLE 0x001016ea
MOVSXD RBX,EBX
MOV RDI,R12
MOV byte ptr [R12 + RBX*0x1],0x0
LEA EBX,[R15 + 0x1]
CALL 0x00101130
MOV qword ptr [RBP + R15*0x8],RAX
MOVSXD R15,EBX
XOR EBX,EBX
CMP R15D,R13D
JL 0x001016ea
ADD R13D,R13D
MOV RDI,RBP
ADD R14,0x1
MOVSXD RSI,R13D
SHL RSI,0x3
CALL 0x00101120
MOV RBP,RAX
MOVZX EAX,byte ptr [R14 + -0x1]
TEST AL,AL
JNZ 0x001016f6
NOP word ptr [RAX + RAX*0x1]
LAB_00101750:
TEST EBX,EBX
JG 0x00101780
LAB_00101754:
MOV RDI,R12
CALL 0x001010c0
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R15D
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101780:
MOVSXD RBX,EBX
MOV RDI,R12
MOV byte ptr [R12 + RBX*0x1],0x0
LEA EBX,[R15 + 0x1]
CALL 0x00101130
MOV qword ptr [RBP + R15*0x8],RAX
MOV R15D,EBX
JMP 0x00101754
LAB_001017a0:
XOR R15D,R15D
JMP 0x00101754
|
void * func0(char *param_1,int4 *param_2)
{
char cVar1;
void *__ptr;
size_t sVar2;
char *__s;
char *pcVar3;
char *pcVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
ulong uVar9;
__ptr = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
cVar1 = *param_1;
if (cVar1 == '\0') {
uVar9 = 0;
}
else {
iVar7 = 0;
uVar9 = 0;
iVar8 = 10;
pcVar4 = param_1 + 1;
do {
while ((cVar1 != ' ' && (cVar1 != ','))) {
lVar5 = (long)iVar7;
iVar7 = iVar7 + 1;
__s[lVar5] = cVar1;
LAB_001016ea:
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
if (cVar1 == '\0') goto LAB_00101750;
}
if (iVar7 < 1) goto LAB_001016ea;
__s[iVar7] = '\0';
iVar6 = (int)uVar9 + 1;
pcVar3 = strdup(__s);
*(char **)((long)__ptr + uVar9 * 8) = pcVar3;
uVar9 = (ulong)iVar6;
iVar7 = 0;
if (iVar6 < iVar8) goto LAB_001016ea;
iVar8 = iVar8 * 2;
__ptr = realloc(__ptr,(long)iVar8 << 3);
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
LAB_00101750:
if (0 < iVar7) {
__s[iVar7] = '\0';
pcVar4 = strdup(__s);
*(char **)((long)__ptr + uVar9 * 8) = pcVar4;
uVar9 = (ulong)((int)uVar9 + 1);
}
}
free(__s);
*param_2 = (int)uVar9;
return __ptr;
}
|
1,063 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
current_length = 0;
if (word_count >= capacity) {
capacity *= 2;
out = realloc(out, capacity * sizeof(char*));
}
}
} else {
current[current_length++] = s[i];
}
}
if (current_length > 0) {
current[current_length] = '\0';
out[word_count++] = strdup(current);
}
free(current);
*count = word_count;
return out;
}
|
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char** words, int count) {
for (int i = 0; i < count; i++)
free(words[i]);
free(words);
}
int main() {
int count;
char** result;
char* expected1[] = {"Hi", "my", "name", "is", "John"};
result = func0("Hi, my name is John", &count);
assert(issame(result, count, expected1, 5));
free_words(result, count);
char* expected2[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One, two, three, four, five, six", &count);
assert(issame(result, count, expected2, 6));
free_words(result, count);
char* expected3[] = {"Hi", "my", "name"};
result = func0("Hi, my name", &count);
assert(issame(result, count, expected3, 3));
free_words(result, count);
char* expected4[] = {"One", "two", "three", "four", "five", "six"};
result = func0("One,, two, three, four, five, six,", &count);
assert(issame(result, count, expected4, 6));
free_words(result, count);
char* expected5[] = {};
result = func0("", &count);
assert(issame(result, count, expected5, 0));
free_words(result, count);
char* expected6[] = {"ahmed", "gamal"};
result = func0("ahmed , gamal", &count);
assert(issame(result, count, expected6, 2));
free_words(result, count);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov $0x50,%edi
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1110 <malloc@plt>
mov %rbx,%rdi
mov %rax,%r12
callq 10d0 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1110 <malloc@plt>
mov %rax,%r14
movzbl (%rbx),%eax
test %al,%al
je 17a0 <func0+0x110>
add $0x1,%rbx
xor %ebp,%ebp
xor %r15d,%r15d
mov $0xa,%r13d
jmp 1705 <func0+0x75>
nopw 0x0(%rax,%rax,1)
movslq %ebp,%rdx
add $0x1,%ebp
mov %al,(%r14,%rdx,1)
movzbl (%rbx),%eax
add $0x1,%rbx
test %al,%al
je 1758 <func0+0xc8>
cmp $0x20,%al
je 170d <func0+0x7d>
cmp $0x2c,%al
jne 16f0 <func0+0x60>
test %ebp,%ebp
je 16fa <func0+0x6a>
movslq %ebp,%rbp
mov %r14,%rdi
movb $0x0,(%r14,%rbp,1)
lea 0x1(%r15),%ebp
callq 1130 <strdup@plt>
mov %rax,(%r12,%r15,8)
movslq %ebp,%r15
xor %ebp,%ebp
cmp %r13d,%r15d
jl 16fa <func0+0x6a>
add %r13d,%r13d
mov %r12,%rdi
add $0x1,%rbx
movslq %r13d,%rsi
shl $0x3,%rsi
callq 1120 <realloc@plt>
mov %rax,%r12
movzbl -0x1(%rbx),%eax
test %al,%al
jne 1705 <func0+0x75>
nopl 0x0(%rax)
test %ebp,%ebp
jne 1780 <func0+0xf0>
mov %r14,%rdi
callq 10c0 <free@plt>
mov 0x8(%rsp),%rax
mov %r15d,(%rax)
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
movslq %ebp,%rbp
mov %r14,%rdi
lea 0x1(%r15),%ebx
movb $0x0,(%r14,%rbp,1)
callq 1130 <strdup@plt>
mov %rax,(%r12,%r15,8)
mov %ebx,%r15d
jmp 175c <func0+0xcc>
nopl (%rax)
xor %r15d,%r15d
jmp 175c <func0+0xcc>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
mov rdi, r14; s
mov rbp, rax
call _strlen
lea rdi, [rax+1]; size
call _malloc
mov r12, rax
movzx eax, byte ptr [r14]
test al, al
jz loc_17A0
add r14, 1
xor ebx, ebx
xor r15d, r15d
mov r13d, 0Ah
jmp short loc_16F6
loc_16E0:
movsxd rcx, ebx
add ebx, 1
mov [r12+rcx], al
loc_16EA:
movzx eax, byte ptr [r14]
add r14, 1
test al, al
jz short loc_1750
loc_16F6:
cmp al, 20h ; ' '
jz short loc_16FE
cmp al, 2Ch ; ','
jnz short loc_16E0
loc_16FE:
test ebx, ebx
jle short loc_16EA
movsxd rbx, ebx
mov rdi, r12; s
mov byte ptr [r12+rbx], 0
lea ebx, [r15+1]
call _strdup
mov [rbp+r15*8+0], rax
movsxd r15, ebx
xor ebx, ebx
cmp r15d, r13d
jl short loc_16EA
add r13d, r13d
mov rdi, rbp; ptr
add r14, 1
movsxd rsi, r13d
shl rsi, 3; size
call _realloc
mov rbp, rax
movzx eax, byte ptr [r14-1]
test al, al
jnz short loc_16F6
nop word ptr [rax+rax+00000000h]
loc_1750:
test ebx, ebx
jg short loc_1780
loc_1754:
mov rdi, r12; ptr
call _free
mov rax, [rsp+48h+var_40]
mov [rax], r15d
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1780:
movsxd rbx, ebx
mov rdi, r12; s
mov byte ptr [r12+rbx], 0
lea ebx, [r15+1]
call _strdup
mov [rbp+r15*8+0], rax
mov r15d, ebx
jmp short loc_1754
loc_17A0:
xor r15d, r15d
jmp short loc_1754
|
_QWORD * func0(char *s, _DWORD *a2)
{
_QWORD *v2; // rbp
size_t v3; // rax
char *v4; // r12
char v5; // al
char *v6; // r14
int v7; // ebx
long long v8; // r15
int v9; // r13d
long long v10; // rcx
v2 = malloc(0x50uLL);
v3 = strlen(s);
v4 = (char *)malloc(v3 + 1);
v5 = *s;
if ( !*s )
{
LODWORD(v8) = 0;
goto LABEL_12;
}
v6 = s + 1;
v7 = 0;
v8 = 0LL;
v9 = 10;
do
{
while ( v5 != 32 && v5 != 44 )
{
v10 = v7++;
v4[v10] = v5;
LABEL_4:
v5 = *v6++;
if ( !v5 )
goto LABEL_10;
}
if ( v7 <= 0 )
goto LABEL_4;
v4[v7] = 0;
v2[v8] = strdup(v4);
v8 = (int)v8 + 1;
v7 = 0;
if ( (int)v8 < v9 )
goto LABEL_4;
v9 *= 2;
++v6;
v2 = realloc(v2, 8LL * v9);
v5 = *(v6 - 1);
}
while ( v5 );
LABEL_10:
if ( v7 > 0 )
{
v4[v7] = 0;
v2[v8] = strdup(v4);
LODWORD(v8) = v8 + 1;
}
LABEL_12:
free(v4);
*a2 = v8;
return v2;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101110
MOV RDI,R14
MOV RBP,RAX
CALL 0x001010d0
LEA RDI,[RAX + 0x1]
CALL 0x00101110
MOV R12,RAX
MOVZX EAX,byte ptr [R14]
TEST AL,AL
JZ 0x001017a0
ADD R14,0x1
XOR EBX,EBX
XOR R15D,R15D
MOV R13D,0xa
JMP 0x001016f6
LAB_001016e0:
MOVSXD RCX,EBX
ADD EBX,0x1
MOV byte ptr [R12 + RCX*0x1],AL
LAB_001016ea:
MOVZX EAX,byte ptr [R14]
ADD R14,0x1
TEST AL,AL
JZ 0x00101750
LAB_001016f6:
CMP AL,0x20
JZ 0x001016fe
CMP AL,0x2c
JNZ 0x001016e0
LAB_001016fe:
TEST EBX,EBX
JLE 0x001016ea
MOVSXD RBX,EBX
MOV RDI,R12
MOV byte ptr [R12 + RBX*0x1],0x0
LEA EBX,[R15 + 0x1]
CALL 0x00101130
MOV qword ptr [RBP + R15*0x8],RAX
MOVSXD R15,EBX
XOR EBX,EBX
CMP R15D,R13D
JL 0x001016ea
ADD R13D,R13D
MOV RDI,RBP
ADD R14,0x1
MOVSXD RSI,R13D
SHL RSI,0x3
CALL 0x00101120
MOV RBP,RAX
MOVZX EAX,byte ptr [R14 + -0x1]
TEST AL,AL
JNZ 0x001016f6
NOP word ptr [RAX + RAX*0x1]
LAB_00101750:
TEST EBX,EBX
JG 0x00101780
LAB_00101754:
MOV RDI,R12
CALL 0x001010c0
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R15D
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101780:
MOVSXD RBX,EBX
MOV RDI,R12
MOV byte ptr [R12 + RBX*0x1],0x0
LEA EBX,[R15 + 0x1]
CALL 0x00101130
MOV qword ptr [RBP + R15*0x8],RAX
MOV R15D,EBX
JMP 0x00101754
LAB_001017a0:
XOR R15D,R15D
JMP 0x00101754
|
void * func0(char *param_1,int4 *param_2)
{
char cVar1;
void *__ptr;
size_t sVar2;
char *__s;
char *pcVar3;
char *pcVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
ulong uVar9;
__ptr = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
cVar1 = *param_1;
if (cVar1 == '\0') {
uVar9 = 0;
}
else {
iVar7 = 0;
uVar9 = 0;
iVar8 = 10;
pcVar4 = param_1 + 1;
do {
while ((cVar1 != ' ' && (cVar1 != ','))) {
lVar5 = (long)iVar7;
iVar7 = iVar7 + 1;
__s[lVar5] = cVar1;
LAB_001016ea:
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
if (cVar1 == '\0') goto LAB_00101750;
}
if (iVar7 < 1) goto LAB_001016ea;
__s[iVar7] = '\0';
iVar6 = (int)uVar9 + 1;
pcVar3 = strdup(__s);
*(char **)((long)__ptr + uVar9 * 8) = pcVar3;
uVar9 = (ulong)iVar6;
iVar7 = 0;
if (iVar6 < iVar8) goto LAB_001016ea;
iVar8 = iVar8 * 2;
__ptr = realloc(__ptr,(long)iVar8 << 3);
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
LAB_00101750:
if (0 < iVar7) {
__s[iVar7] = '\0';
pcVar4 = strdup(__s);
*(char **)((long)__ptr + uVar9 * 8) = pcVar4;
uVar9 = (ulong)((int)uVar9 + 1);
}
}
free(__s);
*param_2 = (int)uVar9;
return __ptr;
}
|
1,064 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jge 1166 <func0+0x1d>
mov $0xffffffff,%eax
jmp 11a6 <func0+0x5d>
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jne 1188 <func0+0x3f>
mov -0x8(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1188 <func0+0x3f>
mov $0xffffffff,%eax
jmp 11a6 <func0+0x5d>
mov -0x8(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 11a3 <func0+0x5a>
mov -0x8(%rbp),%eax
sub $0x1,%eax
jmp 11a6 <func0+0x5d>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jge short loc_1166
mov eax, 0FFFFFFFFh
jmp short loc_11B2
loc_1166:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jnz short loc_118E
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_118E
mov eax, 0FFFFFFFFh
jmp short loc_11B2
loc_118E:
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_11AF
mov eax, [rbp+var_8]
sub eax, 1
jmp short loc_11B2
loc_11AF:
mov eax, [rbp+var_8]
loc_11B2:
pop rbp
retn
|
long long func0(int a1, signed int a2)
{
if ( a2 < a1 )
return 0xFFFFFFFFLL;
if ( a2 == a1 && a2 % 2 == 1 )
return 0xFFFFFFFFLL;
if ( a2 % 2 == 1 )
return (unsigned int)(a2 - 1);
return (unsigned int)a2;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JGE 0x00101166
MOV EAX,0xffffffff
JMP 0x001011b2
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x0010118e
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 0x0010118e
MOV EAX,0xffffffff
JMP 0x001011b2
LAB_0010118e:
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 0x001011af
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x1
JMP 0x001011b2
LAB_001011af:
MOV EAX,dword ptr [RBP + -0x8]
LAB_001011b2:
POP RBP
RET
|
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
param_2 = -1;
}
else if ((param_2 == param_1) && (param_2 % 2 == 1)) {
param_2 = -1;
}
else if (param_2 % 2 == 1) {
param_2 = param_2 + -1;
}
return param_2;
}
|
1,065 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1167 <func0+0x3e>
je 114e <func0+0x25>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
mov $0xffffffff,%edx
cmove %edx,%eax
retq
mov $0xffffffff,%eax
retq
|
func0:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1167
jz short loc_114E
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_114E:
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp edx, 1
mov edx, 0FFFFFFFFh
cmovz eax, edx
retn
loc_1167:
mov eax, 0FFFFFFFFh
retn
|
long long func0(int a1, signed int a2)
{
long long result; // rax
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
if ( a2 != a1 )
return a2 - (unsigned int)(a2 % 2 == 1);
if ( a2 % 2 == 1 )
return 0xFFFFFFFFLL;
return result;
}
|
func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101167
JZ 0x0010114e
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_0010114e:
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101167:
MOV EAX,0xffffffff
RET
|
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
}
|
1,066 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1180 <func0+0x40>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp %edi,%esi
je 1170 <func0+0x30>
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
cmp $0x1,%edx
mov $0xffffffff,%edx
cmove %edx,%eax
retq
nopl 0x0(%rax)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1180
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp esi, edi
jz short loc_1170
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_1170:
cmp edx, 1
mov edx, 0FFFFFFFFh
cmovz eax, edx
retn
loc_1180:
mov eax, 0FFFFFFFFh
retn
|
long long func0(int a1, signed int a2)
{
long long result; // rax
int v3; // edx
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
v3 = a2 % 2;
if ( a2 != a1 )
return a2 - (unsigned int)(v3 == 1);
if ( v3 == 1 )
return 0xFFFFFFFFLL;
return result;
}
|
func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101180
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP ESI,EDI
JZ 0x00101170
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_00101170:
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0xffffffff
RET
|
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
}
|
1,067 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1180 <func0+0x40>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp %edi,%esi
je 1170 <func0+0x30>
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
cmp $0x1,%edx
mov $0xffffffff,%edx
cmove %edx,%eax
retq
nopl 0x0(%rax)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1180
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp esi, edi
jz short loc_1170
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_1170:
cmp edx, 1
mov edx, 0FFFFFFFFh
cmovz eax, edx
retn
loc_1180:
mov eax, 0FFFFFFFFh
retn
|
long long func0(int a1, signed int a2)
{
long long result; // rax
int v3; // edx
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
v3 = a2 % 2;
if ( a2 != a1 )
return a2 - (unsigned int)(v3 == 1);
if ( v3 == 1 )
return 0xFFFFFFFFLL;
return result;
}
|
func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101180
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP ESI,EDI
JZ 0x00101170
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_00101170:
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0xffffffff
RET
|
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
}
|
1,068 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
assert(strcmp(func0(185, 546), "101101101") == 0);
assert(strcmp(func0(362, 496), "110101101") == 0);
assert(strcmp(func0(350, 902), "1001110010") == 0);
assert(strcmp(func0(197, 233), "11010111") == 0);
assert(strcmp(func0(7, 5), "-1") == 0);
assert(strcmp(func0(5, 1), "-1") == 0);
assert(strcmp(func0(5, 5), "101") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 11af <func0+0x26>
lea 0xe5e(%rip),%rax
jmpq 1242 <func0+0xb9>
mov -0x18(%rbp),%edx
mov -0x14(%rbp),%eax
add %edx,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x10(%rbp)
mov $0x21,%edi
callq 1090 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movb $0x0,(%rax)
movl $0x20,-0xc(%rbp)
mov -0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0xc(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x10(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
lea 0x30(%rax),%ecx
mov -0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0xc(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
mov -0x10(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x10(%rbp)
cmpl $0x0,-0x10(%rbp)
jg 11f5 <func0+0x6c>
mov -0xc(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jle short loc_11AF
lea rax, a1; "-1"
jmp locret_1248
loc_11AF:
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
add eax, edx
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_10], eax
mov edi, 21h ; '!'; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov [rbp+var_C], 20h ; ' '
mov eax, [rbp+var_C]
lea edx, [rax-1]
mov [rbp+var_C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 0
loc_11F5:
mov edx, [rbp+var_10]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
lea ecx, [rax+30h]
mov eax, [rbp+var_C]
lea edx, [rax-1]
mov [rbp+var_C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov edx, ecx
mov [rax], dl
mov eax, [rbp+var_10]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_10], eax
cmp [rbp+var_10], 0
jg short loc_11F5
mov eax, [rbp+var_C]
cdqe
lea rdx, [rax+1]
mov rax, [rbp+var_8]
add rax, rdx
locret_1248:
leave
retn
|
const char * func0(int a1, int a2)
{
int v3; // eax
int v4; // [rsp+10h] [rbp-10h]
int v5; // [rsp+14h] [rbp-Ch]
_BYTE *v6; // [rsp+18h] [rbp-8h]
if ( a1 > a2 )
return "-1";
v4 = (a2 + a1) / 2;
v6 = malloc(0x21uLL);
*v6 = 0;
v5 = 31;
v6[32] = 0;
do
{
v3 = v5--;
v6[v3] = v4 % 2 + 48;
v4 /= 2;
}
while ( v4 > 0 );
return &v6[v5 + 1];
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x001011af
LEA RAX,[0x102008]
JMP 0x00101248
LAB_001011af:
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
MOV EDI,0x21
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0xc],0x20
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0xc],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
LAB_001011f5:
MOV EDX,dword ptr [RBP + -0x10]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
LEA ECX,[RAX + 0x30]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0xc],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
MOV EAX,dword ptr [RBP + -0x10]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
CMP dword ptr [RBP + -0x10],0x0
JG 0x001011f5
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LAB_00101248:
LEAVE
RET
|
int * func0(int param_1,int param_2)
{
int iVar1;
char cVar2;
int *puVar3;
int local_18;
int local_14;
if (param_2 < param_1) {
puVar3 = &DAT_00102008;
}
else {
local_18 = (param_1 + param_2) / 2;
puVar3 = (int *)malloc(0x21);
*puVar3 = 0;
puVar3[0x20] = 0;
local_14 = 0x1f;
do {
cVar2 = (char)(local_18 >> 0x1f);
iVar1 = local_14 + -1;
puVar3[local_14] = ((char)local_18 - cVar2 & 1U) + cVar2 + '0';
local_18 = local_18 / 2;
local_14 = iVar1;
} while (0 < local_18);
puVar3 = puVar3 + (long)iVar1 + 1;
}
return puVar3;
}
|
1,069 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
assert(strcmp(func0(185, 546), "101101101") == 0);
assert(strcmp(func0(362, 496), "110101101") == 0);
assert(strcmp(func0(350, 902), "1001110010") == 0);
assert(strcmp(func0(197, 233), "11010111") == 0);
assert(strcmp(func0(7, 5), "-1") == 0);
assert(strcmp(func0(5, 1), "-1") == 0);
assert(strcmp(func0(5, 5), "101") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
lea 0xe90(%rip),%rax
cmp %esi,%edi
jle 1179 <func0+0x10>
retq
push %rbx
add %esi,%edi
mov %edi,%ebx
shr $0x1f,%ebx
add %edi,%ebx
sar %ebx
mov $0x21,%edi
callq 1070 <malloc@plt>
movb $0x0,(%rax)
movb $0x0,0x20(%rax)
mov $0x1e,%ecx
mov %ecx,%edi
mov %ebx,%esi
shr $0x1f,%esi
lea (%rbx,%rsi,1),%edx
and $0x1,%edx
sub %esi,%edx
add $0x30,%edx
mov %dl,0x1(%rax,%rcx,1)
mov %ebx,%esi
mov %ebx,%edx
shr $0x1f,%edx
add %edx,%ebx
sar %ebx
sub $0x1,%rcx
cmp $0x1,%esi
jg 119b <func0+0x32>
movslq %edi,%rdi
lea 0x1(%rax,%rdi,1),%rax
pop %rbx
retq
|
func0:
endbr64
lea r8, a1; "-1"
cmp edi, esi
jle short loc_119C
mov rax, r8
retn
loc_119C:
push rbx
add edi, esi
mov ebx, edi
shr ebx, 1Fh
add ebx, edi
sar ebx, 1
mov edi, 21h ; '!'; size
call _malloc
mov byte ptr [rax], 0
mov byte ptr [rax+20h], 0
add rax, 1Fh
loc_11BD:
mov r8, rax
mov ecx, ebx
shr ecx, 1Fh
lea edx, [rbx+rcx]
and edx, 1
sub edx, ecx
add edx, 30h ; '0'
mov [rax], dl
mov ecx, ebx
mov edx, ebx
shr edx, 1Fh
add edx, ebx
mov ebx, edx
sar ebx, 1
sub rax, 1
cmp ecx, 1
jg short loc_11BD
mov rax, r8
pop rbx
retn
|
const char * func0(int a1, int a2)
{
int v3; // ebx
_BYTE *v4; // rax
_BYTE *v5; // rax
_BYTE *v6; // r8
int v7; // ecx
if ( a1 > a2 )
return "-1";
v3 = (a2 + a1) / 2;
v4 = malloc(0x21uLL);
*v4 = 0;
v4[32] = 0;
v5 = v4 + 31;
do
{
v6 = v5;
*v5 = v3 % 2 + 48;
v7 = v3;
v3 /= 2;
--v5;
}
while ( v7 > 1 );
return v6;
}
|
func0:
ENDBR64
LEA R8,[0x102004]
CMP EDI,ESI
JLE 0x0010119c
MOV RAX,R8
RET
LAB_0010119c:
PUSH RBX
ADD EDI,ESI
MOV EBX,EDI
SHR EBX,0x1f
ADD EBX,EDI
SAR EBX,0x1
MOV EDI,0x21
CALL 0x00101090
MOV byte ptr [RAX],0x0
MOV byte ptr [RAX + 0x20],0x0
ADD RAX,0x1f
LAB_001011bd:
MOV R8,RAX
MOV ECX,EBX
SHR ECX,0x1f
LEA EDX,[RBX + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
ADD EDX,0x30
MOV byte ptr [RAX],DL
MOV ECX,EBX
MOV EDX,EBX
SHR EDX,0x1f
ADD EDX,EBX
MOV EBX,EDX
SAR EBX,0x1
SUB RAX,0x1
CMP ECX,0x1
JG 0x001011bd
MOV RAX,R8
POP RBX
RET
|
char * func0(int param_1,int param_2)
{
char cVar1;
char *pcVar2;
int *puVar3;
char *pcVar4;
int iVar5;
int iVar6;
if (param_2 < param_1) {
return "-1";
}
iVar5 = (param_1 + param_2) - (param_1 + param_2 >> 0x1f);
puVar3 = (int *)malloc(0x21);
*puVar3 = 0;
puVar3[0x20] = 0;
pcVar2 = puVar3 + 0x1f;
do {
pcVar4 = pcVar2;
iVar6 = iVar5 >> 1;
cVar1 = (char)(iVar5 >> 0x1f);
*pcVar4 = ((char)iVar6 - cVar1 & 1U) + cVar1 + '0';
iVar5 = iVar6 - (iVar5 >> 0x1f);
pcVar2 = pcVar4 + -1;
} while (1 < iVar6);
return pcVar4;
}
|
1,070 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
assert(strcmp(func0(185, 546), "101101101") == 0);
assert(strcmp(func0(362, 496), "110101101") == 0);
assert(strcmp(func0(350, 902), "1001110010") == 0);
assert(strcmp(func0(197, 233), "11010111") == 0);
assert(strcmp(func0(7, 5), "-1") == 0);
assert(strcmp(func0(5, 1), "-1") == 0);
assert(strcmp(func0(5, 5), "101") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp %esi,%edi
jle 14e0 <func0+0x10>
lea 0xb25(%rip),%rax
retq
jmp 1470 <func0.part.0>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0_part_0:
add edi, esi
push rbx
mov ebx, edi
shr ebx, 1Fh
add ebx, edi
mov edi, 21h ; '!'; size
call _malloc
sar ebx, 1
mov byte ptr [rax], 0
add rax, 1Fh
mov byte ptr [rax+1], 0
nop dword ptr [rax+00000000h]
loc_1478:
mov ecx, ebx
mov rsi, rax
sub rax, 1
shr ecx, 1Fh
lea edx, [rbx+rcx]
and edx, 1
sub edx, ecx
add edx, 30h ; '0'
mov [rax+1], dl
mov edx, ebx
mov ebx, ecx
add ebx, edx
sar ebx, 1
cmp edx, 1
jg short loc_1478
mov rax, rsi
pop rbx
retn
|
_BYTE * func0_part_0(int a1, int a2)
{
_BYTE *v2; // rax
int v3; // ebx
_BYTE *v4; // rax
_BYTE *v5; // rsi
int v6; // edx
v2 = malloc(0x21uLL);
v3 = (a2 + a1) / 2;
*v2 = 0;
v4 = v2 + 31;
v4[1] = 0;
do
{
v5 = v4--;
v4[1] = v3 % 2 + 48;
v6 = v3;
v3 /= 2;
}
while ( v6 > 1 );
return v5;
}
|
func0.part.0:
ADD EDI,ESI
PUSH RBX
MOV EBX,EDI
SHR EBX,0x1f
ADD EBX,EDI
MOV EDI,0x21
CALL 0x00101090
SAR EBX,0x1
MOV byte ptr [RAX],0x0
ADD RAX,0x1f
MOV byte ptr [RAX + 0x1],0x0
NOP dword ptr [RAX]
LAB_00101478:
MOV ECX,EBX
MOV RSI,RAX
SUB RAX,0x1
SHR ECX,0x1f
LEA EDX,[RBX + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
ADD EDX,0x30
MOV byte ptr [RAX + 0x1],DL
MOV EDX,EBX
MOV EBX,ECX
ADD EBX,EDX
SAR EBX,0x1
CMP EDX,0x1
JG 0x00101478
MOV RAX,RSI
POP RBX
RET
|
char * func0_part_0(int param_1,int param_2)
{
char *pcVar1;
int *puVar2;
char *pcVar3;
int iVar4;
int iVar5;
iVar4 = (param_1 + param_2) - (param_1 + param_2 >> 0x1f);
puVar2 = (int *)malloc(0x21);
*puVar2 = 0;
puVar2[0x20] = 0;
pcVar1 = puVar2 + 0x1f;
do {
pcVar3 = pcVar1;
iVar5 = iVar4 >> 1;
*pcVar3 = ((char)iVar5 + (char)-(iVar4 >> 0x1f) & 1U) + (char)(iVar4 >> 0x1f) + '0';
iVar4 = -(iVar4 >> 0x1f) + iVar5;
pcVar1 = pcVar3 + -1;
} while (1 < iVar5);
return pcVar3;
}
|
1,071 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
assert(strcmp(func0(185, 546), "101101101") == 0);
assert(strcmp(func0(362, 496), "110101101") == 0);
assert(strcmp(func0(350, 902), "1001110010") == 0);
assert(strcmp(func0(197, 233), "11010111") == 0);
assert(strcmp(func0(7, 5), "-1") == 0);
assert(strcmp(func0(5, 1), "-1") == 0);
assert(strcmp(func0(5, 5), "101") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp %esi,%edi
jle 14e0 <func0+0x10>
lea 0xb25(%rip),%rax
retq
add %esi,%edi
push %rbx
mov %edi,%ebx
shr $0x1f,%ebx
add %edi,%ebx
mov $0x21,%edi
callq 1070 <malloc@plt>
sar %ebx
mov $0x1e,%ecx
movb $0x0,(%rax)
movb $0x0,0x20(%rax)
nopw 0x0(%rax,%rax,1)
mov %ebx,%esi
movslq %ecx,%rdi
shr $0x1f,%esi
lea (%rbx,%rsi,1),%edx
and $0x1,%edx
sub %esi,%edx
add $0x30,%edx
mov %dl,0x1(%rax,%rcx,1)
mov %ebx,%edx
mov %esi,%ebx
sub $0x1,%rcx
add %edx,%ebx
sar %ebx
cmp $0x1,%edx
jg 1508 <func0+0x38>
lea 0x1(%rax,%rdi,1),%rax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
|
func0_part_0:
add edi, esi
push rbx
mov ebx, edi
shr ebx, 1Fh
add ebx, edi
mov edi, 21h ; '!'; size
call _malloc
sar ebx, 1
mov byte ptr [rax], 0
add rax, 1Fh
mov byte ptr [rax+1], 0
nop dword ptr [rax+00000000h]
loc_1478:
mov ecx, ebx
mov rsi, rax
sub rax, 1
shr ecx, 1Fh
lea edx, [rbx+rcx]
and edx, 1
sub edx, ecx
add edx, 30h ; '0'
mov [rax+1], dl
mov edx, ebx
mov ebx, ecx
add ebx, edx
sar ebx, 1
cmp edx, 1
jg short loc_1478
mov rax, rsi
pop rbx
retn
|
_BYTE * func0_part_0(int a1, int a2)
{
_BYTE *v2; // rax
int v3; // ebx
_BYTE *v4; // rax
_BYTE *v5; // rsi
int v6; // edx
v2 = malloc(0x21uLL);
v3 = (a2 + a1) / 2;
*v2 = 0;
v4 = v2 + 31;
v4[1] = 0;
do
{
v5 = v4--;
v4[1] = v3 % 2 + 48;
v6 = v3;
v3 /= 2;
}
while ( v6 > 1 );
return v5;
}
|
func0.part.0:
ADD EDI,ESI
PUSH RBX
MOV EBX,EDI
SHR EBX,0x1f
ADD EBX,EDI
MOV EDI,0x21
CALL 0x00101090
SAR EBX,0x1
MOV byte ptr [RAX],0x0
ADD RAX,0x1f
MOV byte ptr [RAX + 0x1],0x0
NOP dword ptr [RAX]
LAB_00101478:
MOV ECX,EBX
MOV RSI,RAX
SUB RAX,0x1
SHR ECX,0x1f
LEA EDX,[RBX + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
ADD EDX,0x30
MOV byte ptr [RAX + 0x1],DL
MOV EDX,EBX
MOV EBX,ECX
ADD EBX,EDX
SAR EBX,0x1
CMP EDX,0x1
JG 0x00101478
MOV RAX,RSI
POP RBX
RET
|
char * func0_part_0(int param_1,int param_2)
{
char *pcVar1;
int *puVar2;
char *pcVar3;
int iVar4;
int iVar5;
iVar4 = (param_1 + param_2) - (param_1 + param_2 >> 0x1f);
puVar2 = (int *)malloc(0x21);
*puVar2 = 0;
puVar2[0x20] = 0;
pcVar1 = puVar2 + 0x1f;
do {
pcVar3 = pcVar1;
iVar5 = iVar4 >> 1;
*pcVar3 = ((char)iVar5 + (char)-(iVar4 >> 0x1f) & 1U) + (char)(iVar4 >> 0x1f) + '0';
iVar4 = -(iVar4 >> 0x1f) + iVar5;
pcVar1 = pcVar3 + -1;
} while (1 < iVar5);
return pcVar3;
}
|
1,072 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
|
void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if (num % 2 == 0) has_even_digit = true;
num = num / 10;
}
if (!has_even_digit) {
(*out)[*out_size] = x[i];
(*out_size)++;
}
}
for (int i = 0; i < *out_size - 1; i++) {
for (int j = 0; j < *out_size - i - 1; j++) {
if ((*out)[j] > (*out)[j + 1]) {
int temp = (*out)[j];
(*out)[j] = (*out)[j + 1];
(*out)[j + 1] = temp;
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int test1[] = {15, 33, 1422, 1};
int expected1[] = {1, 15, 33};
int *out1;
int out1_size;
func0(test1, 4, &out1, &out1_size);
assert(issame(out1, out1_size, expected1, 3));
free(out1);
int test2[] = {152, 323, 1422, 10};
int *out2;
int out2_size;
func0(test2, 4, &out2, &out2_size);
assert(issame(out2, out2_size, NULL, 0));
free(out2);
int test3[] = {12345, 2033, 111, 151};
int expected3[] = {111, 151};
int *out3;
int out3_size;
func0(test3, 4, &out3, &out3_size);
assert(issame(out3, out3_size, expected3, 2));
free(out3);
int test4[] = {135, 103, 31};
int expected4[] = {31, 135};
int *out4;
int out4_size;
func0(test4, 3, &out4, &out4_size);
assert(issame(out4, out4_size, expected4, 2));
free(out4);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %rcx,-0x40(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,(%rax)
mov -0x40(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x14(%rbp)
jmpq 12a8 <func0+0xff>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
movb $0x0,-0x15(%rbp)
cmpl $0x0,-0x10(%rbp)
jne 124a <func0+0xa1>
movb $0x1,-0x15(%rbp)
jmp 124a <func0+0xa1>
mov -0x10(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 122c <func0+0x83>
movb $0x1,-0x15(%rbp)
mov -0x10(%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,-0x10(%rbp)
cmpl $0x0,-0x10(%rbp)
jle 125b <func0+0xb2>
movzbl -0x15(%rbp),%eax
xor $0x1,%eax
test %al,%al
jne 121e <func0+0x75>
movzbl -0x15(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 12a4 <func0+0xfb>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x38(%rbp),%rax
mov (%rax),%rdx
mov -0x40(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x40(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x40(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11f5 <func0+0x4c>
movl $0x0,-0xc(%rbp)
jmpq 1384 <func0+0x1db>
movl $0x0,-0x8(%rbp)
jmpq 136b <func0+0x1c2>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x8(%rbp),%ecx
movslq %ecx,%rcx
add $0x1,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1367 <func0+0x1be>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
shl $0x2,%rdx
lea (%rax,%rdx,1),%rcx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x40(%rbp),%rax
mov (%rax),%eax
sub -0xc(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x8(%rbp)
jl 12cc <func0+0x123>
addl $0x1,-0xc(%rbp)
mov -0x40(%rbp),%rax
mov (%rax),%eax
sub $0x1,%eax
cmp %eax,-0xc(%rbp)
jl 12c0 <func0+0x117>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_38]
mov [rax], rdx
mov rax, [rbp+var_40]
mov dword ptr [rax], 0
mov [rbp+var_14], 0
jmp loc_12A8
loc_11F5:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_15], 0
cmp [rbp+var_10], 0
jnz short loc_124A
mov [rbp+var_15], 1
jmp short loc_124A
loc_121E:
mov eax, [rbp+var_10]
and eax, 1
test eax, eax
jnz short loc_122C
mov [rbp+var_15], 1
loc_122C:
mov eax, [rbp+var_10]
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_10], eax
loc_124A:
cmp [rbp+var_10], 0
jle short loc_125B
movzx eax, [rbp+var_15]
xor eax, 1
test al, al
jnz short loc_121E
loc_125B:
movzx eax, [rbp+var_15]
xor eax, 1
test al, al
jz short loc_12A4
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov rax, [rbp+var_38]
mov rdx, [rax]
mov rax, [rbp+var_40]
mov eax, [rax]
cdqe
shl rax, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov rax, [rbp+var_40]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_40]
mov [rax], edx
loc_12A4:
add [rbp+var_14], 1
loc_12A8:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl loc_11F5
mov [rbp+var_C], 0
jmp loc_1384
loc_12C0:
mov [rbp+var_8], 0
jmp loc_136B
loc_12CC:
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_8]
movsxd rcx, ecx
add rcx, 1
shl rcx, 2
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1367
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
add rdx, 1
shl rdx, 2
lea rcx, [rax+rdx]
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
add rdx, 1
shl rdx, 2
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_1367:
add [rbp+var_8], 1
loc_136B:
mov rax, [rbp+var_40]
mov eax, [rax]
sub eax, [rbp+var_C]
sub eax, 1
cmp [rbp+var_8], eax
jl loc_12CC
add [rbp+var_C], 1
loc_1384:
mov rax, [rbp+var_40]
mov eax, [rax]
sub eax, 1
cmp [rbp+var_C], eax
jl loc_12C0
nop
nop
leave
retn
|
long long func0(long long a1, int a2, void **a3, _DWORD *a4)
{
long long result; // rax
bool v7; // [rsp+2Bh] [rbp-15h]
int i; // [rsp+2Ch] [rbp-14h]
int v9; // [rsp+30h] [rbp-10h]
int j; // [rsp+34h] [rbp-Ch]
int k; // [rsp+38h] [rbp-8h]
int v12; // [rsp+3Ch] [rbp-4h]
*a3 = malloc(4LL * a2);
*a4 = 0;
for ( i = 0; i < a2; ++i )
{
v9 = *(_DWORD *)(4LL * i + a1);
v7 = v9 == 0;
while ( v9 > 0 && !v7 )
{
if ( (v9 & 1) == 0 )
v7 = 1;
v9 /= 10;
}
if ( !v7 )
*((_DWORD *)*a3 + (int)(*a4)++) = *(_DWORD *)(4LL * i + a1);
}
for ( j = 0; ; ++j )
{
result = (unsigned int)(*a4 - 1);
if ( j >= (int)result )
break;
for ( k = 0; k < *a4 - j - 1; ++k )
{
if ( *((_DWORD *)*a3 + k) > *((_DWORD *)*a3 + k + 1) )
{
v12 = *((_DWORD *)*a3 + k);
*((_DWORD *)*a3 + k) = *((_DWORD *)*a3 + k + 1);
*((_DWORD *)*a3 + k + 1) = v12;
}
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012a8
LAB_001011f5:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV byte ptr [RBP + -0x15],0x0
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0010124a
MOV byte ptr [RBP + -0x15],0x1
JMP 0x0010124a
LAB_0010121e:
MOV EAX,dword ptr [RBP + -0x10]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x0010122c
MOV byte ptr [RBP + -0x15],0x1
LAB_0010122c:
MOV EAX,dword ptr [RBP + -0x10]
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 + -0x10],EAX
LAB_0010124a:
CMP dword ptr [RBP + -0x10],0x0
JLE 0x0010125b
MOVZX EAX,byte ptr [RBP + -0x15]
XOR EAX,0x1
TEST AL,AL
JNZ 0x0010121e
LAB_0010125b:
MOVZX EAX,byte ptr [RBP + -0x15]
XOR EAX,0x1
TEST AL,AL
JZ 0x001012a4
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],EDX
LAB_001012a4:
ADD dword ptr [RBP + -0x14],0x1
LAB_001012a8:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011f5
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101384
LAB_001012c0:
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010136b
LAB_001012cc:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RCX,ECX
ADD RCX,0x1
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101367
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
ADD RDX,0x1
SHL RDX,0x2
LEA RCX,[RAX + RDX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
ADD RDX,0x1
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_00101367:
ADD dword ptr [RBP + -0x8],0x1
LAB_0010136b:
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
SUB EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
CMP dword ptr [RBP + -0x8],EAX
JL 0x001012cc
ADD dword ptr [RBP + -0xc],0x1
LAB_00101384:
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
SUB EAX,0x1
CMP dword ptr [RBP + -0xc],EAX
JL 0x001012c0
NOP
NOP
LEAVE
RET
|
void func0(long param_1,int param_2,long *param_3,int *param_4)
{
int4 uVar1;
bool bVar2;
void *pvVar3;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
pvVar3 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar3;
*param_4 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = *(uint *)(param_1 + (long)local_1c * 4);
bVar2 = false;
if (local_18 == 0) {
bVar2 = true;
}
while ((0 < (int)local_18 && (!bVar2))) {
if ((local_18 & 1) == 0) {
bVar2 = true;
}
local_18 = (int)local_18 / 10;
}
if (!bVar2) {
*(int4 *)(*param_3 + (long)*param_4 * 4) = *(int4 *)((long)local_1c * 4 + param_1)
;
*param_4 = *param_4 + 1;
}
}
for (local_14 = 0; local_14 < *param_4 + -1; local_14 = local_14 + 1) {
for (local_10 = 0; local_10 < (*param_4 - local_14) + -1; local_10 = local_10 + 1) {
if (*(int *)(*param_3 + ((long)local_10 + 1) * 4) < *(int *)(*param_3 + (long)local_10 * 4)) {
uVar1 = *(int4 *)(*param_3 + (long)local_10 * 4);
*(int4 *)((long)local_10 * 4 + *param_3) =
*(int4 *)(*param_3 + ((long)local_10 + 1) * 4);
*(int4 *)(((long)local_10 + 1) * 4 + *param_3) = uVar1;
}
}
}
return;
}
|
1,073 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
|
void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if (num % 2 == 0) has_even_digit = true;
num = num / 10;
}
if (!has_even_digit) {
(*out)[*out_size] = x[i];
(*out_size)++;
}
}
for (int i = 0; i < *out_size - 1; i++) {
for (int j = 0; j < *out_size - i - 1; j++) {
if ((*out)[j] > (*out)[j + 1]) {
int temp = (*out)[j];
(*out)[j] = (*out)[j + 1];
(*out)[j + 1] = temp;
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int test1[] = {15, 33, 1422, 1};
int expected1[] = {1, 15, 33};
int *out1;
int out1_size;
func0(test1, 4, &out1, &out1_size);
assert(issame(out1, out1_size, expected1, 3));
free(out1);
int test2[] = {152, 323, 1422, 10};
int *out2;
int out2_size;
func0(test2, 4, &out2, &out2_size);
assert(issame(out2, out2_size, NULL, 0));
free(out2);
int test3[] = {12345, 2033, 111, 151};
int expected3[] = {111, 151};
int *out3;
int out3_size;
func0(test3, 4, &out3, &out3_size);
assert(issame(out3, out3_size, expected3, 2));
free(out3);
int test4[] = {135, 103, 31};
int expected4[] = {31, 135};
int *out4;
int out4_size;
func0(test4, 3, &out4, &out4_size);
assert(issame(out4, out4_size, expected4, 2));
free(out4);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %rdx,%rbx
mov %rcx,%rbp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 1298 <func0+0xef>
mov %r13,%rsi
lea -0x1(%r12),%eax
lea 0x4(%r13,%rax,4),%r8
jmp 121b <func0+0x72>
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
cmp $0x9,%edx
jle 1227 <func0+0x7e>
mov %eax,%edx
test $0x1,%dl
jne 11f1 <func0+0x48>
add $0x4,%rsi
cmp %rsi,%r8
je 1237 <func0+0x8e>
mov (%rsi),%edi
test %edi,%edi
jle 1225 <func0+0x7c>
mov %edi,%edx
jmp 120d <func0+0x64>
je 1212 <func0+0x69>
movslq 0x0(%rbp),%rdx
mov (%rbx),%rax
mov %edi,(%rax,%rdx,4)
addl $0x1,0x0(%rbp)
jmp 1212 <func0+0x69>
cmpl $0x1,0x0(%rbp)
jle 1298 <func0+0xef>
mov $0x0,%r8d
jmp 1281 <func0+0xd8>
add $0x1,%ecx
mov %r8d,%edx
not %edx
add 0x0(%rbp),%edx
cmp %ecx,%edx
jle 1272 <func0+0xc9>
mov (%rbx),%rdx
lea (%rdx,%rax,1),%rdi
mov (%rdi),%esi
add $0x4,%rax
mov (%rdx,%rax,1),%edx
cmp %edx,%esi
jle 1245 <func0+0x9c>
mov %edx,(%rdi)
mov (%rbx),%rdx
mov %esi,(%rdx,%rax,1)
jmp 1245 <func0+0x9c>
add $0x1,%r8d
mov 0x0(%rbp),%eax
sub $0x1,%eax
cmp %r8d,%eax
jle 1298 <func0+0xef>
mov 0x0(%rbp),%edx
sub %r8d,%edx
mov $0x0,%eax
mov $0x0,%ecx
cmp $0x1,%edx
jg 1254 <func0+0xab>
jmp 1272 <func0+0xc9>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13d, esi
mov rbx, rdx
mov rbp, rcx
movsxd r14, esi
shl r14, 2
mov rdi, r14; size
call _malloc
mov [rbx], rax
mov dword ptr [rbp+0], 0
test r13d, r13d
jle loc_1293
mov rsi, r12
lea r8, [r12+r14]
jmp short loc_1216
loc_11EC:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
cmp edx, 9
jle short loc_1222
mov edx, eax
loc_1208:
test dl, 1
jnz short loc_11EC
loc_120D:
add rsi, 4
cmp rsi, r8
jz short loc_1232
loc_1216:
mov edi, [rsi]
test edi, edi
jle short loc_1220
mov edx, edi
jmp short loc_1208
loc_1220:
jz short loc_120D
loc_1222:
movsxd rdx, dword ptr [rbp+0]
mov rax, [rbx]
mov [rax+rdx*4], edi
add dword ptr [rbp+0], 1
jmp short loc_120D
loc_1232:
cmp dword ptr [rbp+0], 1
jle short loc_1293
mov r8d, 0
jmp short loc_127C
loc_1240:
add ecx, 1
mov edx, r8d
not edx
add edx, [rbp+0]
cmp edx, ecx
jle short loc_126D
loc_124F:
mov rdx, [rbx]
lea rdi, [rdx+rax]
mov esi, [rdi]
add rax, 4
mov edx, [rdx+rax]
cmp esi, edx
jle short loc_1240
mov [rdi], edx
mov rdx, [rbx]
mov [rdx+rax], esi
jmp short loc_1240
loc_126D:
add r8d, 1
mov eax, [rbp+0]
sub eax, 1
cmp eax, r8d
jle short loc_1293
loc_127C:
mov edx, [rbp+0]
sub edx, r8d
mov eax, 0
mov ecx, 0
cmp edx, 1
jg short loc_124F
jmp short loc_126D
loc_1293:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
|
unsigned long long func0(int *a1, int a2, void **a3, int *a4)
{
size_t v7; // r14
unsigned long long result; // rax
int *v9; // rsi
int i; // edx
int v11; // edi
int v12; // r8d
int v13; // ecx
int *v14; // rdi
int v15; // esi
long long v16; // rax
int v17; // edx
v7 = a2;
result = (unsigned long long)malloc(v7 * 4);
*a3 = (void *)result;
*a4 = 0;
if ( a2 > 0 )
{
v9 = a1;
do
{
v11 = *v9;
if ( *v9 <= 0 )
{
if ( v11 )
{
LABEL_10:
result = (unsigned long long)*a3;
*((_DWORD *)*a3 + (*a4)++) = v11;
}
}
else
{
for ( i = *v9; (i & 1) != 0; i /= 10 )
{
result = (unsigned int)(i / 10);
if ( i <= 9 )
goto LABEL_10;
}
}
++v9;
}
while ( v9 != &a1[v7] );
if ( *a4 > 1 )
{
v12 = 0;
do
{
v16 = 0LL;
v13 = 0;
if ( *a4 - v12 > 1 )
{
do
{
v14 = (int *)((char *)*a3 + v16);
v15 = *v14;
v16 += 4LL;
v17 = *(_DWORD *)((char *)*a3 + v16);
if ( *v14 > v17 )
{
*v14 = v17;
*(_DWORD *)((char *)*a3 + v16) = v15;
}
++v13;
}
while ( *a4 + ~v12 > v13 );
}
++v12;
result = (unsigned int)(*a4 - 1);
}
while ( (int)result > v12 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13D,ESI
MOV RBX,RDX
MOV RBP,RCX
MOVSXD R14,ESI
SHL R14,0x2
MOV RDI,R14
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101293
MOV RSI,R12
LEA R8,[R12 + R14*0x1]
JMP 0x00101216
LAB_001011ec:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
CMP EDX,0x9
JLE 0x00101222
MOV EDX,EAX
LAB_00101208:
TEST DL,0x1
JNZ 0x001011ec
LAB_0010120d:
ADD RSI,0x4
CMP RSI,R8
JZ 0x00101232
LAB_00101216:
MOV EDI,dword ptr [RSI]
TEST EDI,EDI
JLE 0x00101220
MOV EDX,EDI
JMP 0x00101208
LAB_00101220:
JZ 0x0010120d
LAB_00101222:
MOVSXD RDX,dword ptr [RBP]
MOV RAX,qword ptr [RBX]
MOV dword ptr [RAX + RDX*0x4],EDI
ADD dword ptr [RBP],0x1
JMP 0x0010120d
LAB_00101232:
CMP dword ptr [RBP],0x1
JLE 0x00101293
MOV R8D,0x0
JMP 0x0010127c
LAB_00101240:
ADD ECX,0x1
MOV EDX,R8D
NOT EDX
ADD EDX,dword ptr [RBP]
CMP EDX,ECX
JLE 0x0010126d
LAB_0010124f:
MOV RDX,qword ptr [RBX]
LEA RDI,[RDX + RAX*0x1]
MOV ESI,dword ptr [RDI]
ADD RAX,0x4
MOV EDX,dword ptr [RDX + RAX*0x1]
CMP ESI,EDX
JLE 0x00101240
MOV dword ptr [RDI],EDX
MOV RDX,qword ptr [RBX]
MOV dword ptr [RDX + RAX*0x1],ESI
JMP 0x00101240
LAB_0010126d:
ADD R8D,0x1
MOV EAX,dword ptr [RBP]
SUB EAX,0x1
CMP EAX,R8D
JLE 0x00101293
LAB_0010127c:
MOV EDX,dword ptr [RBP]
SUB EDX,R8D
MOV EAX,0x0
MOV ECX,0x0
CMP EDX,0x1
JG 0x0010124f
JMP 0x0010126d
LAB_00101293:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
|
void func0(uint *param_1,int param_2,long *param_3,int *param_4)
{
uint *puVar1;
int *piVar2;
int iVar3;
int iVar4;
bool bVar5;
void *pvVar6;
long lVar7;
int iVar8;
uint uVar9;
uint uVar10;
pvVar6 = malloc((long)param_2 * 4);
*param_3 = (long)pvVar6;
*param_4 = 0;
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
uVar10 = *param_1;
uVar9 = uVar10;
if ((int)uVar10 < 1) {
if (uVar10 != 0) goto LAB_00101222;
}
else {
do {
if ((uVar9 & 1) == 0) goto LAB_0010120d;
bVar5 = 9 < (int)uVar9;
uVar9 = (int)uVar9 / 10;
} while (bVar5);
LAB_00101222:
*(uint *)(*param_3 + (long)*param_4 * 4) = uVar10;
*param_4 = *param_4 + 1;
}
LAB_0010120d:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
if (1 < *param_4) {
uVar10 = 0;
do {
lVar7 = 0;
iVar8 = 0;
if (1 < (int)(*param_4 - uVar10)) {
do {
piVar2 = (int *)(*param_3 + lVar7);
iVar3 = *piVar2;
lVar7 = lVar7 + 4;
iVar4 = *(int *)(*param_3 + lVar7);
if (iVar4 < iVar3) {
*piVar2 = iVar4;
*(int *)(*param_3 + lVar7) = iVar3;
}
iVar8 = iVar8 + 1;
} while (iVar8 < (int)(~uVar10 + *param_4));
}
uVar10 = uVar10 + 1;
} while ((int)uVar10 < *param_4 + -1);
}
}
return;
}
|
1,074 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
|
void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if (num % 2 == 0) has_even_digit = true;
num = num / 10;
}
if (!has_even_digit) {
(*out)[*out_size] = x[i];
(*out_size)++;
}
}
for (int i = 0; i < *out_size - 1; i++) {
for (int j = 0; j < *out_size - i - 1; j++) {
if ((*out)[j] > (*out)[j + 1]) {
int temp = (*out)[j];
(*out)[j] = (*out)[j + 1];
(*out)[j + 1] = temp;
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int test1[] = {15, 33, 1422, 1};
int expected1[] = {1, 15, 33};
int *out1;
int out1_size;
func0(test1, 4, &out1, &out1_size);
assert(issame(out1, out1_size, expected1, 3));
free(out1);
int test2[] = {152, 323, 1422, 10};
int *out2;
int out2_size;
func0(test2, 4, &out2, &out2_size);
assert(issame(out2, out2_size, NULL, 0));
free(out2);
int test3[] = {12345, 2033, 111, 151};
int expected3[] = {111, 151};
int *out3;
int out3_size;
func0(test3, 4, &out3, &out3_size);
assert(issame(out3, out3_size, expected3, 2));
free(out3);
int test4[] = {135, 103, 31};
int expected4[] = {31, 135};
int *out4;
int out4_size;
func0(test4, 3, &out4, &out4_size);
assert(issame(out4, out4_size, expected4, 2));
free(out4);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 153f <func0+0xcf>
lea -0x1(%r12),%edx
mov %rbx,%r10
xor %r8d,%r8d
mov $0xcccccccd,%r9d
lea 0x4(%rbx,%rdx,4),%rcx
mov (%r10),%r11d
test %r11d,%r11d
je 14f6 <func0+0x86>
jle 1555 <func0+0xe5>
mov %r11d,%edx
nopl 0x0(%rax)
mov %edx,%esi
mov %edx,%edx
mov %rdx,%rdi
imul %r9,%rdx
not %esi
and $0x1,%esi
shr $0x23,%rdx
cmp $0x9,%edi
jle 1550 <func0+0xe0>
test %sil,%sil
je 14d8 <func0+0x68>
add $0x4,%r10
cmp %rcx,%r10
jne 14c0 <func0+0x50>
lea -0x1(%r8),%ecx
test %ecx,%ecx
jle 153f <func0+0xcf>
lea 0x4(%rax),%r9
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rax,%rdx
mov %rcx,%r8
lea (%r9,%rcx,4),%rdi
nopl (%rax)
mov (%rdx),%ecx
mov 0x4(%rdx),%esi
cmp %esi,%ecx
jle 152e <func0+0xbe>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
add $0x4,%rdx
cmp %rdx,%rdi
jne 1520 <func0+0xb0>
mov %r8d,%ecx
test %r8d,%r8d
jne 1510 <func0+0xa0>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
test %sil,%sil
jne 14f6 <func0+0x86>
movslq %r8d,%rdx
add $0x4,%r10
add $0x1,%r8d
mov %r11d,(%rax,%rdx,4)
mov %r8d,0x0(%rbp)
cmp %rcx,%r10
jne 14c0 <func0+0x50>
jmp 14ff <func0+0x8f>
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r14
movsxd r11, esi
mov r14, rdx
push r13
mov r13, r11
push r12
lea r12, ds:0[r11*4]
push rbp
mov rbp, rcx
push rbx
mov rbx, rdi
mov rdi, r12; size
call _malloc
mov [r14], rax
mov dword ptr [rbp+0], 0
test r13d, r13d
jle loc_1507
mov r8, rax
mov r9, rbx
lea r11, [rbx+r12]
xor edi, edi
mov esi, 0CCCCCCCDh
nop
loc_1480:
mov r10d, [r9]
test r10d, r10d
jle loc_1530
mov eax, r10d
nop
loc_1490:
mov edx, eax
mov eax, eax
mov rcx, rax
imul rax, rsi
not edx
and edx, 1
shr rax, 23h
cmp ecx, 9
jle short loc_1510
test dl, dl
jz short loc_1490
loc_14AD:
add r9, 4
cmp r9, r11
jnz short loc_1480
loc_14B6:
cmp edi, 1
jle short loc_1507
lea r9, [r8+4]
nop
loc_14C0:
cmp edi, 1
jle loc_1548
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r9+rdx*4]
nop dword ptr [rax+rax+00h]
loc_14D8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd edx, xmm0
movd ecx, xmm1
cmp ecx, edx
jge short loc_14F6
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_14F6:
add rax, 4
cmp rsi, rax
jnz short loc_14D8
sub edi, 1
cmp edi, 1
jnz short loc_14C0
loc_1507:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1510:
test dl, dl
jnz short loc_14AD
loc_1514:
movsxd rax, edi
add r9, 4
add edi, 1
mov [r8+rax*4], r10d
mov [rbp+0], edi
cmp r9, r11
jnz loc_1480
jmp short loc_14B6
loc_1530:
jnz short loc_1514
add r9, 4
cmp r9, r11
jnz loc_1480
jmp loc_14B6
loc_1548:
sub edi, 1
jmp loc_14C0
|
unsigned long long func0(int *a1, int a2, unsigned long long *a3, int *a4)
{
unsigned long long result; // rax
unsigned long long v7; // r8
int *v8; // r9
int *v9; // r11
int v10; // edi
int v11; // r10d
int v12; // ecx
bool v13; // dl
__m128i v14; // xmm0
result = (unsigned long long)malloc(4LL * a2);
*a3 = result;
*a4 = 0;
if ( a2 > 0 )
{
v7 = result;
v8 = a1;
v9 = &a1[a2];
v10 = 0;
while ( 2 )
{
while ( 1 )
{
v11 = *v8;
if ( *v8 > 0 )
break;
if ( v11 )
{
LABEL_17:
result = v10;
++v8;
++v10;
*(_DWORD *)(v7 + 4 * result) = v11;
*a4 = v10;
if ( v8 == v9 )
goto LABEL_8;
}
else if ( ++v8 == v9 )
{
goto LABEL_8;
}
}
LODWORD(result) = *v8;
while ( 1 )
{
v12 = result;
v13 = (result & 1) == 0;
result = (unsigned int)result / 0xAuLL;
if ( v12 <= 9 )
break;
if ( v13 )
goto LABEL_7;
}
if ( !v13 )
goto LABEL_17;
LABEL_7:
if ( ++v8 != v9 )
continue;
break;
}
LABEL_8:
if ( v10 > 1 )
{
do
{
while ( v10 <= 1 )
--v10;
result = v7;
do
{
v14 = _mm_loadl_epi64((const __m128i *)result);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v14, 229)) < _mm_cvtsi128_si32(v14) )
*(_QWORD *)result = _mm_shuffle_epi32(v14, 225).m128i_u64[0];
result += 4LL;
}
while ( v7 + 4 + 4LL * (unsigned int)(v10 - 2) != result );
--v10;
}
while ( v10 != 1 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH R14
MOVSXD R11,ESI
MOV R14,RDX
PUSH R13
MOV R13,R11
PUSH R12
LEA R12,[R11*0x4]
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
CALL 0x001010b0
MOV qword ptr [R14],RAX
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101507
MOV R8,RAX
MOV R9,RBX
LEA R11,[RBX + R12*0x1]
XOR EDI,EDI
MOV ESI,0xcccccccd
NOP
LAB_00101480:
MOV R10D,dword ptr [R9]
TEST R10D,R10D
JLE 0x00101530
MOV EAX,R10D
NOP
LAB_00101490:
MOV EDX,EAX
MOV EAX,EAX
MOV RCX,RAX
IMUL RAX,RSI
NOT EDX
AND EDX,0x1
SHR RAX,0x23
CMP ECX,0x9
JLE 0x00101510
TEST DL,DL
JZ 0x00101490
LAB_001014ad:
ADD R9,0x4
CMP R9,R11
JNZ 0x00101480
LAB_001014b6:
CMP EDI,0x1
JLE 0x00101507
LEA R9,[R8 + 0x4]
NOP
LAB_001014c0:
CMP EDI,0x1
JLE 0x00101548
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R9 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014d8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM1
CMP ECX,EDX
JGE 0x001014f6
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001014f6:
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x001014d8
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001014c0
LAB_00101507:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101510:
TEST DL,DL
JNZ 0x001014ad
LAB_00101514:
MOVSXD RAX,EDI
ADD R9,0x4
ADD EDI,0x1
MOV dword ptr [R8 + RAX*0x4],R10D
MOV dword ptr [RBP],EDI
CMP R9,R11
JNZ 0x00101480
JMP 0x001014b6
LAB_00101530:
JNZ 0x00101514
ADD R9,0x4
CMP R9,R11
JNZ 0x00101480
JMP 0x001014b6
LAB_00101548:
SUB EDI,0x1
JMP 0x001014c0
|
void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
uint uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
long lVar7;
byte bVar8;
int iVar9;
int iVar10;
puVar4 = (int8 *)malloc((long)param_2 * 4);
*param_3 = puVar4;
*param_4 = 0;
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar9 = 0;
do {
while( true ) {
uVar2 = *param_1;
if ((int)uVar2 < 1) break;
uVar5 = (ulong)uVar2;
do {
iVar3 = (int)uVar5;
bVar8 = ~(byte)uVar5 & 1;
uVar5 = uVar5 / 10;
if (iVar3 < 10) {
if (bVar8 == 0) goto LAB_00101514;
break;
}
} while (bVar8 == 0);
joined_r0x00101528:
param_1 = param_1 + 1;
if (param_1 == puVar1) goto LAB_001014b6;
}
if (uVar2 != 0) {
LAB_00101514:
lVar7 = (long)iVar9;
iVar9 = iVar9 + 1;
*(uint *)((long)puVar4 + lVar7 * 4) = uVar2;
*param_4 = iVar9;
goto joined_r0x00101528;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
LAB_001014b6:
if (1 < iVar9) {
do {
for (; iVar9 < 2; iVar9 = iVar9 + -1) {
}
puVar6 = puVar4;
do {
iVar3 = (int)*puVar6;
iVar10 = (int)((ulong)*puVar6 >> 0x20);
if (iVar10 < iVar3) {
*puVar6 = CONCAT44(iVar3,iVar10);
}
puVar6 = (int8 *)((long)puVar6 + 4);
} while ((int8 *)((long)puVar4 + (ulong)(iVar9 - 2) * 4 + 4) != puVar6);
iVar9 = iVar9 + -1;
} while (iVar9 != 1);
}
}
return;
}
|
1,075 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
|
void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if (num % 2 == 0) has_even_digit = true;
num = num / 10;
}
if (!has_even_digit) {
(*out)[*out_size] = x[i];
(*out_size)++;
}
}
for (int i = 0; i < *out_size - 1; i++) {
for (int j = 0; j < *out_size - i - 1; j++) {
if ((*out)[j] > (*out)[j + 1]) {
int temp = (*out)[j];
(*out)[j] = (*out)[j + 1];
(*out)[j + 1] = temp;
}
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int test1[] = {15, 33, 1422, 1};
int expected1[] = {1, 15, 33};
int *out1;
int out1_size;
func0(test1, 4, &out1, &out1_size);
assert(issame(out1, out1_size, expected1, 3));
free(out1);
int test2[] = {152, 323, 1422, 10};
int *out2;
int out2_size;
func0(test2, 4, &out2, &out2_size);
assert(issame(out2, out2_size, NULL, 0));
free(out2);
int test3[] = {12345, 2033, 111, 151};
int expected3[] = {111, 151};
int *out3;
int out3_size;
func0(test3, 4, &out3, &out3_size);
assert(issame(out3, out3_size, expected3, 2));
free(out3);
int test4[] = {135, 103, 31};
int expected4[] = {31, 135};
int *out4;
int out4_size;
func0(test4, 3, &out4, &out4_size);
assert(issame(out4, out4_size, expected4, 2));
free(out4);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 150f <func0+0xcf>
lea -0x1(%r12),%edx
mov %rbx,%r10
xor %r8d,%r8d
mov $0xcccccccd,%r9d
lea 0x4(%rbx,%rdx,4),%rcx
mov (%r10),%r11d
test %r11d,%r11d
je 14c6 <func0+0x86>
jle 1525 <func0+0xe5>
mov %r11d,%edx
nopl 0x0(%rax)
mov %edx,%esi
mov %edx,%edx
mov %rdx,%rdi
imul %r9,%rdx
not %esi
and $0x1,%esi
shr $0x23,%rdx
cmp $0x9,%edi
jle 1520 <func0+0xe0>
test %sil,%sil
je 14a8 <func0+0x68>
add $0x4,%r10
cmp %r10,%rcx
jne 1490 <func0+0x50>
lea -0x1(%r8),%ecx
test %ecx,%ecx
jle 150f <func0+0xcf>
lea 0x4(%rax),%r9
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rax,%rdx
mov %rcx,%r8
lea (%r9,%rcx,4),%rdi
nopl (%rax)
mov (%rdx),%ecx
mov 0x4(%rdx),%esi
cmp %esi,%ecx
jle 14fe <func0+0xbe>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
add $0x4,%rdx
cmp %rdx,%rdi
jne 14f0 <func0+0xb0>
mov %r8d,%ecx
test %r8d,%r8d
jne 14e0 <func0+0xa0>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
test %sil,%sil
jne 14c6 <func0+0x86>
movslq %r8d,%rdx
add $0x4,%r10
add $0x1,%r8d
mov %r11d,(%rax,%rdx,4)
mov %r8d,0x0(%rbp)
cmp %r10,%rcx
jne 1490 <func0+0x50>
jmp 14cf <func0+0x8f>
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r14
movsxd r11, esi
mov r14, rdx
push r13
mov r13, r11
push r12
lea r12, ds:0[r11*4]
push rbp
mov rbp, rcx
push rbx
mov rbx, rdi
mov rdi, r12; size
call _malloc
mov [r14], rax
mov dword ptr [rbp+0], 0
test r13d, r13d
jle loc_1507
mov r8, rax
mov r9, rbx
lea r11, [rbx+r12]
xor edi, edi
mov esi, 0CCCCCCCDh
nop
loc_1480:
mov r10d, [r9]
test r10d, r10d
jle loc_1530
mov eax, r10d
nop
loc_1490:
mov edx, eax
mov eax, eax
mov rcx, rax
imul rax, rsi
not edx
and edx, 1
shr rax, 23h
cmp ecx, 9
jle short loc_1510
test dl, dl
jz short loc_1490
loc_14AD:
add r9, 4
cmp r11, r9
jnz short loc_1480
loc_14B6:
cmp edi, 1
jle short loc_1507
lea r9, [r8+4]
nop
loc_14C0:
cmp edi, 1
jle loc_1548
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r9+rdx*4]
nop dword ptr [rax+rax+00h]
loc_14D8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd edx, xmm0
movd ecx, xmm1
cmp ecx, edx
jge short loc_14F6
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_14F6:
add rax, 4
cmp rsi, rax
jnz short loc_14D8
sub edi, 1
cmp edi, 1
jnz short loc_14C0
loc_1507:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1510:
test dl, dl
jnz short loc_14AD
loc_1514:
movsxd rax, edi
add r9, 4
add edi, 1
mov [r8+rax*4], r10d
mov [rbp+0], edi
cmp r11, r9
jnz loc_1480
jmp short loc_14B6
loc_1530:
jnz short loc_1514
add r9, 4
cmp r11, r9
jnz loc_1480
jmp loc_14B6
loc_1548:
sub edi, 1
jmp loc_14C0
|
unsigned long long func0(int *a1, int a2, unsigned long long *a3, int *a4)
{
unsigned long long result; // rax
unsigned long long v7; // r8
int *v8; // r9
int *v9; // r11
int v10; // edi
int v11; // r10d
int v12; // ecx
bool v13; // dl
__m128i v14; // xmm0
result = (unsigned long long)malloc(4LL * a2);
*a3 = result;
*a4 = 0;
if ( a2 > 0 )
{
v7 = result;
v8 = a1;
v9 = &a1[a2];
v10 = 0;
while ( 2 )
{
while ( 1 )
{
v11 = *v8;
if ( *v8 > 0 )
break;
if ( v11 )
{
LABEL_17:
result = v10;
++v8;
++v10;
*(_DWORD *)(v7 + 4 * result) = v11;
*a4 = v10;
if ( v9 == v8 )
goto LABEL_8;
}
else if ( v9 == ++v8 )
{
goto LABEL_8;
}
}
LODWORD(result) = *v8;
while ( 1 )
{
v12 = result;
v13 = (result & 1) == 0;
result = (unsigned int)result / 0xAuLL;
if ( v12 <= 9 )
break;
if ( v13 )
goto LABEL_7;
}
if ( !v13 )
goto LABEL_17;
LABEL_7:
if ( v9 != ++v8 )
continue;
break;
}
LABEL_8:
if ( v10 > 1 )
{
do
{
while ( v10 <= 1 )
--v10;
result = v7;
do
{
v14 = _mm_loadl_epi64((const __m128i *)result);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v14, 229)) < _mm_cvtsi128_si32(v14) )
*(_QWORD *)result = _mm_shuffle_epi32(v14, 225).m128i_u64[0];
result += 4LL;
}
while ( v7 + 4 + 4LL * (unsigned int)(v10 - 2) != result );
--v10;
}
while ( v10 != 1 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH R14
MOVSXD R11,ESI
MOV R14,RDX
PUSH R13
MOV R13,R11
PUSH R12
LEA R12,[R11*0x4]
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
CALL 0x001010b0
MOV qword ptr [R14],RAX
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101507
MOV R8,RAX
MOV R9,RBX
LEA R11,[RBX + R12*0x1]
XOR EDI,EDI
MOV ESI,0xcccccccd
NOP
LAB_00101480:
MOV R10D,dword ptr [R9]
TEST R10D,R10D
JLE 0x00101530
MOV EAX,R10D
NOP
LAB_00101490:
MOV EDX,EAX
MOV EAX,EAX
MOV RCX,RAX
IMUL RAX,RSI
NOT EDX
AND EDX,0x1
SHR RAX,0x23
CMP ECX,0x9
JLE 0x00101510
TEST DL,DL
JZ 0x00101490
LAB_001014ad:
ADD R9,0x4
CMP R11,R9
JNZ 0x00101480
LAB_001014b6:
CMP EDI,0x1
JLE 0x00101507
LEA R9,[R8 + 0x4]
NOP
LAB_001014c0:
CMP EDI,0x1
JLE 0x00101548
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R9 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014d8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM1
CMP ECX,EDX
JGE 0x001014f6
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001014f6:
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x001014d8
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001014c0
LAB_00101507:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101510:
TEST DL,DL
JNZ 0x001014ad
LAB_00101514:
MOVSXD RAX,EDI
ADD R9,0x4
ADD EDI,0x1
MOV dword ptr [R8 + RAX*0x4],R10D
MOV dword ptr [RBP],EDI
CMP R11,R9
JNZ 0x00101480
JMP 0x001014b6
LAB_00101530:
JNZ 0x00101514
ADD R9,0x4
CMP R11,R9
JNZ 0x00101480
JMP 0x001014b6
LAB_00101548:
SUB EDI,0x1
JMP 0x001014c0
|
void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
uint uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
long lVar7;
byte bVar8;
int iVar9;
int iVar10;
puVar4 = (int8 *)malloc((long)param_2 * 4);
*param_3 = puVar4;
*param_4 = 0;
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar9 = 0;
do {
while( true ) {
uVar2 = *param_1;
if ((int)uVar2 < 1) break;
uVar5 = (ulong)uVar2;
do {
iVar3 = (int)uVar5;
bVar8 = ~(byte)uVar5 & 1;
uVar5 = uVar5 / 10;
if (iVar3 < 10) {
if (bVar8 == 0) goto LAB_00101514;
break;
}
} while (bVar8 == 0);
joined_r0x00101528:
param_1 = param_1 + 1;
if (puVar1 == param_1) goto LAB_001014b6;
}
if (uVar2 != 0) {
LAB_00101514:
lVar7 = (long)iVar9;
iVar9 = iVar9 + 1;
*(uint *)((long)puVar4 + lVar7 * 4) = uVar2;
*param_4 = iVar9;
goto joined_r0x00101528;
}
param_1 = param_1 + 1;
} while (puVar1 != param_1);
LAB_001014b6:
if (1 < iVar9) {
do {
for (; iVar9 < 2; iVar9 = iVar9 + -1) {
}
puVar6 = puVar4;
do {
iVar3 = (int)*puVar6;
iVar10 = (int)((ulong)*puVar6 >> 0x20);
if (iVar10 < iVar3) {
*puVar6 = CONCAT44(iVar3,iVar10);
}
puVar6 = (int8 *)((long)puVar6 + 4);
} while ((int8 *)((long)puVar4 + (ulong)(iVar9 - 2) * 4 + 4) != puVar6);
iVar9 = iVar9 + -1;
} while (iVar9 != 1);
}
}
return;
}
|
1,076 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
*out_size = 0;
for (i = size - 1; i >= 0; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out_size)++;
}
}
*out = malloc(*out_size * sizeof(char *));
for (i = size - 1, j = 0; i >= 0 && j < *out_size; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out)[j++] = names[arr[i]];
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char **a, int a_size, char **b, 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() {
char **out;
int out_size;
int test1[] = {2, 1, 1, 4, 5, 8, 2, 3};
char *expected1[] = {"Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"};
func0(test1, 8, &out, &out_size);
assert(issame(out, out_size, expected1, 8));
free(out);
int test2[] = {};
func0(test2, 0, &out, &out_size);
assert(issame(out, out_size, NULL, 0));
free(out);
int test3[] = {1, -1, 55};
char *expected3[] = {"One"};
func0(test3, 3, &out, &out_size);
assert(issame(out, out_size, expected3, 1));
free(out);
int test4[] = {1, -1, 3, 2};
char *expected4[] = {"Three", "Two", "One"};
func0(test4, 4, &out, &out_size);
assert(issame(out, out_size, expected4, 3));
free(out);
int test5[] = {9, 4, 8};
char *expected5[] = {"Nine", "Eight", "Four"};
func0(test5, 3, &out, &out_size);
assert(issame(out, out_size, expected5, 3));
free(out);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %rdx,-0x88(%rbp)
mov %rcx,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe05(%rip),%rax
mov %rax,-0x60(%rbp)
lea 0xdfb(%rip),%rax
mov %rax,-0x58(%rbp)
lea 0xdf4(%rip),%rax
mov %rax,-0x50(%rbp)
lea 0xded(%rip),%rax
mov %rax,-0x48(%rbp)
lea 0xde8(%rip),%rax
mov %rax,-0x40(%rbp)
lea 0xde2(%rip),%rax
mov %rax,-0x38(%rbp)
lea 0xddc(%rip),%rax
mov %rax,-0x30(%rbp)
lea 0xdd5(%rip),%rax
mov %rax,-0x28(%rbp)
lea 0xdd0(%rip),%rax
mov %rax,-0x20(%rbp)
lea 0xdcb(%rip),%rax
mov %rax,-0x18(%rbp)
movl $0x0,-0x6c(%rbp)
jmpq 1337 <func0+0x16e>
movl $0x0,-0x68(%rbp)
jmpq 1321 <func0+0x158>
mov -0x68(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x68(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 131d <func0+0x154>
mov -0x68(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x64(%rbp)
mov -0x68(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov -0x68(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x78(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x68(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rax,%rdx
mov -0x64(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x68(%rbp)
mov -0x7c(%rbp),%eax
sub -0x6c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x68(%rbp)
jl 1282 <func0+0xb9>
addl $0x1,-0x6c(%rbp)
mov -0x7c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x6c(%rbp)
jl 1276 <func0+0xad>
mov -0x90(%rbp),%rax
movl $0x0,(%rax)
mov -0x7c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x6c(%rbp)
jmp 13ac <func0+0x1e3>
mov -0x6c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 13a8 <func0+0x1df>
mov -0x6c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0x9,%eax
jg 13a8 <func0+0x1df>
mov -0x90(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x90(%rbp),%rax
mov %edx,(%rax)
subl $0x1,-0x6c(%rbp)
cmpl $0x0,-0x6c(%rbp)
jns 135e <func0+0x195>
mov -0x90(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rdx
mov -0x88(%rbp),%rax
mov %rdx,(%rax)
mov -0x7c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x6c(%rbp)
movl $0x0,-0x68(%rbp)
jmp 145f <func0+0x296>
mov -0x6c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 145b <func0+0x292>
mov -0x6c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0x9,%eax
jg 145b <func0+0x292>
mov -0x6c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x88(%rbp),%rax
mov (%rax),%rsi
mov -0x68(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x68(%rbp)
cltq
shl $0x3,%rax
lea (%rsi,%rax,1),%rdx
movslq %ecx,%rax
mov -0x60(%rbp,%rax,8),%rax
mov %rax,(%rdx)
subl $0x1,-0x6c(%rbp)
cmpl $0x0,-0x6c(%rbp)
js 1477 <func0+0x2ae>
mov -0x90(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x68(%rbp)
jl 13e8 <func0+0x21f>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 148c <func0+0x2c3>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov [rbp+var_88], rdx
mov [rbp+var_90], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, unk_2008
mov [rbp+var_60], rax
lea rax, unk_2009
mov [rbp+var_58], rax
lea rax, unk_200D
mov [rbp+var_50], rax
lea rax, aThree; "Three"
mov [rbp+var_48], rax
lea rax, aFour; "Four"
mov [rbp+var_40], rax
lea rax, aFive; "Five"
mov [rbp+var_38], rax
lea rax, aSix; "Six"
mov [rbp+var_30], rax
lea rax, aSeven; "Seven"
mov [rbp+var_28], rax
lea rax, aEight; "Eight"
mov [rbp+var_20], rax
lea rax, aNine; "Nine"
mov [rbp+var_18], rax
mov [rbp+var_6C], 0
jmp loc_1337
loc_1276:
mov [rbp+var_68], 0
jmp loc_1321
loc_1282:
mov eax, [rbp+var_68]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_68]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_131D
mov eax, [rbp+var_68]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov eax, [rax]
mov [rbp+var_64], eax
mov eax, [rbp+var_68]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov edx, [rbp+var_68]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_78]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_68]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rdx, rax
mov eax, [rbp+var_64]
mov [rdx], eax
loc_131D:
add [rbp+var_68], 1
loc_1321:
mov eax, [rbp+var_7C]
sub eax, [rbp+var_6C]
sub eax, 1
cmp [rbp+var_68], eax
jl loc_1282
add [rbp+var_6C], 1
loc_1337:
mov eax, [rbp+var_7C]
sub eax, 1
cmp [rbp+var_6C], eax
jl loc_1276
mov rax, [rbp+var_90]
mov dword ptr [rax], 0
mov eax, [rbp+var_7C]
sub eax, 1
mov [rbp+var_6C], eax
jmp short loc_13AC
loc_135E:
mov eax, [rbp+var_6C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_13A8
mov eax, [rbp+var_6C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov eax, [rax]
cmp eax, 9
jg short loc_13A8
mov rax, [rbp+var_90]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_90]
mov [rax], edx
loc_13A8:
sub [rbp+var_6C], 1
loc_13AC:
cmp [rbp+var_6C], 0
jns short loc_135E
mov rax, [rbp+var_90]
mov eax, [rax]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_88]
mov [rax], rdx
mov eax, [rbp+var_7C]
sub eax, 1
mov [rbp+var_6C], eax
mov [rbp+var_68], 0
jmp short loc_145F
loc_13E8:
mov eax, [rbp+var_6C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_145B
mov eax, [rbp+var_6C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov eax, [rax]
cmp eax, 9
jg short loc_145B
mov eax, [rbp+var_6C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_88]
mov rsi, [rax]
mov eax, [rbp+var_68]
lea edx, [rax+1]
mov [rbp+var_68], edx
cdqe
shl rax, 3
lea rdx, [rsi+rax]
movsxd rax, ecx
mov rax, [rbp+rax*8+var_60]
mov [rdx], rax
loc_145B:
sub [rbp+var_6C], 1
loc_145F:
cmp [rbp+var_6C], 0
js short loc_1477
mov rax, [rbp+var_90]
mov eax, [rax]
cmp [rbp+var_68], eax
jl loc_13E8
loc_1477:
nop
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_148C
call ___stack_chk_fail
locret_148C:
leave
retn
|
unsigned long long func0(long long a1, int a2, void **a3, int *a4)
{
int v4; // eax
int i; // [rsp+24h] [rbp-6Ch]
int k; // [rsp+24h] [rbp-6Ch]
int v10; // [rsp+24h] [rbp-6Ch]
int j; // [rsp+28h] [rbp-68h]
int v12; // [rsp+28h] [rbp-68h]
int v13; // [rsp+2Ch] [rbp-64h]
_QWORD v14[11]; // [rsp+30h] [rbp-60h]
unsigned long long v15; // [rsp+88h] [rbp-8h]
v15 = __readfsqword(0x28u);
v14[0] = &unk_2008;
v14[1] = &unk_2009;
v14[2] = &unk_200D;
v14[3] = "Three";
v14[4] = "Four";
v14[5] = "Five";
v14[6] = "Six";
v14[7] = "Seven";
v14[8] = "Eight";
v14[9] = "Nine";
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) > *(_DWORD *)(4 * (j + 1LL) + a1) )
{
v13 = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(4LL * j + a1) = *(_DWORD *)(4 * (j + 1LL) + a1);
*(_DWORD *)(a1 + 4 * (j + 1LL)) = v13;
}
}
}
*a4 = 0;
for ( k = a2 - 1; k >= 0; --k )
{
if ( *(int *)(4LL * k + a1) > 0 && *(int *)(4LL * k + a1) <= 9 )
++*a4;
}
*a3 = malloc(8LL * *a4);
v10 = a2 - 1;
v12 = 0;
while ( v10 >= 0 && v12 < *a4 )
{
if ( *(int *)(4LL * v10 + a1) > 0 && *(int *)(4LL * v10 + a1) <= 9 )
{
v4 = v12++;
*((_QWORD *)*a3 + v4) = v14[*(int *)(4LL * v10 + a1)];
}
--v10;
}
return v15 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV qword ptr [RBP + -0x88],RDX
MOV qword ptr [RBP + -0x90],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x102009]
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x102011]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[0x102017]
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,[0x102025]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x10202b]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x102031]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x6c],0x0
JMP 0x00101337
LAB_00101276:
MOV dword ptr [RBP + -0x68],0x0
JMP 0x00101321
LAB_00101282:
MOV EAX,dword ptr [RBP + -0x68]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x68]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010131d
MOV EAX,dword ptr [RBP + -0x68]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
MOV EAX,dword ptr [RBP + -0x68]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x68]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x78]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x68]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RDX],EAX
LAB_0010131d:
ADD dword ptr [RBP + -0x68],0x1
LAB_00101321:
MOV EAX,dword ptr [RBP + -0x7c]
SUB EAX,dword ptr [RBP + -0x6c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x68],EAX
JL 0x00101282
ADD dword ptr [RBP + -0x6c],0x1
LAB_00101337:
MOV EAX,dword ptr [RBP + -0x7c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x6c],EAX
JL 0x00101276
MOV RAX,qword ptr [RBP + -0x90]
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x7c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x001013ac
LAB_0010135e:
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x001013a8
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0x9
JG 0x001013a8
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x90]
MOV dword ptr [RAX],EDX
LAB_001013a8:
SUB dword ptr [RBP + -0x6c],0x1
LAB_001013ac:
CMP dword ptr [RBP + -0x6c],0x0
JNS 0x0010135e
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RDX
MOV EAX,dword ptr [RBP + -0x7c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x6c],EAX
MOV dword ptr [RBP + -0x68],0x0
JMP 0x0010145f
LAB_001013e8:
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x0010145b
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0x9
JG 0x0010145b
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x88]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x68]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x68],EDX
CDQE
SHL RAX,0x3
LEA RDX,[RSI + RAX*0x1]
MOVSXD RAX,ECX
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x60]
MOV qword ptr [RDX],RAX
LAB_0010145b:
SUB dword ptr [RBP + -0x6c],0x1
LAB_0010145f:
CMP dword ptr [RBP + -0x6c],0x0
JS 0x00101477
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x68],EAX
JL 0x001013e8
LAB_00101477:
NOP
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010148c
CALL 0x001010a0
LAB_0010148c:
LEAVE
RET
|
void func0(long param_1,int param_2,long *param_3,int *param_4)
{
int4 uVar1;
void *pvVar2;
long in_FS_OFFSET;
int local_74;
int local_70;
char *local_68 [4];
int *local_48;
int *local_40;
int *local_38;
char *local_30;
char *local_28;
int *local_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_68[0] = "";
local_68[1] = "One";
local_68[2] = "Two";
local_68[3] = "Three";
local_48 = &DAT_00102017;
local_40 = &DAT_0010201c;
local_38 = &DAT_00102021;
local_30 = "Seven";
local_28 = "Eight";
local_20 = &DAT_00102031;
for (local_74 = 0; local_74 < param_2 + -1; local_74 = local_74 + 1) {
for (local_70 = 0; local_70 < (param_2 - local_74) + -1; local_70 = local_70 + 1) {
if (*(int *)(param_1 + ((long)local_70 + 1) * 4) < *(int *)(param_1 + (long)local_70 * 4)) {
uVar1 = *(int4 *)(param_1 + (long)local_70 * 4);
*(int4 *)(param_1 + (long)local_70 * 4) =
*(int4 *)(param_1 + ((long)local_70 + 1) * 4);
*(int4 *)(((long)local_70 + 1) * 4 + param_1) = uVar1;
}
}
}
*param_4 = 0;
for (local_74 = param_2 + -1; -1 < local_74; local_74 = local_74 + -1) {
if ((0 < *(int *)(param_1 + (long)local_74 * 4)) &&
(*(int *)(param_1 + (long)local_74 * 4) < 10)) {
*param_4 = *param_4 + 1;
}
}
pvVar2 = malloc((long)*param_4 << 3);
*param_3 = (long)pvVar2;
local_74 = param_2 + -1;
local_70 = 0;
while ((-1 < local_74 && (local_70 < *param_4))) {
if ((0 < *(int *)(param_1 + (long)local_74 * 4)) &&
(*(int *)(param_1 + (long)local_74 * 4) < 10)) {
*(char **)(*param_3 + (long)local_70 * 8) = local_68[*(int *)(param_1 + (long)local_74 * 4)];
local_70 = local_70 + 1;
}
local_74 = local_74 + -1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,077 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
*out_size = 0;
for (i = size - 1; i >= 0; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out_size)++;
}
}
*out = malloc(*out_size * sizeof(char *));
for (i = size - 1, j = 0; i >= 0 && j < *out_size; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out)[j++] = names[arr[i]];
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char **a, int a_size, char **b, 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() {
char **out;
int out_size;
int test1[] = {2, 1, 1, 4, 5, 8, 2, 3};
char *expected1[] = {"Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"};
func0(test1, 8, &out, &out_size);
assert(issame(out, out_size, expected1, 8));
free(out);
int test2[] = {};
func0(test2, 0, &out, &out_size);
assert(issame(out, out_size, NULL, 0));
free(out);
int test3[] = {1, -1, 55};
char *expected3[] = {"One"};
func0(test3, 3, &out, &out_size);
assert(issame(out, out_size, expected3, 1));
free(out);
int test4[] = {1, -1, 3, 2};
char *expected4[] = {"Three", "Two", "One"};
func0(test4, 4, &out, &out_size);
assert(issame(out, out_size, expected4, 3));
free(out);
int test5[] = {9, 4, 8};
char *expected5[] = {"Nine", "Eight", "Four"};
func0(test5, 3, &out, &out_size);
assert(issame(out, out_size, expected5, 3));
free(out);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%rbx
mov %rdx,%r12
mov %rcx,%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xe1a(%rip),%rax
mov %rax,(%rsp)
lea 0xe02(%rip),%rax
mov %rax,0x8(%rsp)
lea 0xdfa(%rip),%rax
mov %rax,0x10(%rsp)
lea 0xdf2(%rip),%rax
mov %rax,0x18(%rsp)
lea 0xdec(%rip),%rax
mov %rax,0x20(%rsp)
lea 0xde5(%rip),%rax
mov %rax,0x28(%rsp)
lea 0xdde(%rip),%rax
mov %rax,0x30(%rsp)
lea 0xdd6(%rip),%rax
mov %rax,0x38(%rsp)
lea 0xdd0(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xdca(%rip),%rax
mov %rax,0x48(%rsp)
lea -0x1(%rsi),%r13d
test %r13d,%r13d
jle 12ab <func0+0xe2>
mov %r13d,%edi
lea 0x4(%rbx),%r8
jmp 129b <func0+0xd2>
add $0x4,%rax
cmp %rsi,%rax
je 1292 <func0+0xc9>
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 1279 <func0+0xb0>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
jmp 1279 <func0+0xb0>
sub $0x1,%edi
je 1341 <func0+0x178>
test %edi,%edi
jle 1292 <func0+0xc9>
mov %rbx,%rax
lea -0x1(%rdi),%edx
lea (%r8,%rdx,4),%rsi
jmp 1282 <func0+0xb9>
movl $0x0,(%rcx)
je 1348 <func0+0x17f>
mov $0x0,%edi
callq 10d0 <malloc@plt>
mov %rax,(%r12)
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1350 <func0+0x187>
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
sub $0x1,%rax
test %eax,%eax
js 1329 <func0+0x160>
mov (%rbx,%rax,4),%edi
lea -0x1(%rdi),%edx
cmp $0x8,%edx
ja 12e0 <func0+0x117>
addl $0x1,0x0(%rbp)
jmp 12e0 <func0+0x117>
sub $0x1,%r13
test %r13d,%r13d
js 12c5 <func0+0xfc>
cmp %edx,0x0(%rbp)
jle 12c5 <func0+0xfc>
mov (%rbx,%r13,4),%eax
lea -0x1(%rax),%ecx
cmp $0x8,%ecx
ja 12f9 <func0+0x130>
movslq %edx,%rsi
mov (%r12),%rcx
cltq
mov (%rsp,%rax,8),%rax
mov %rax,(%rcx,%rsi,8)
lea 0x1(%rdx),%edx
jmp 12f9 <func0+0x130>
movslq 0x0(%rbp),%rdi
shl $0x3,%rdi
callq 10d0 <malloc@plt>
mov %rax,(%r12)
mov $0x0,%edx
jmp 1302 <func0+0x139>
movl $0x0,0x0(%rbp)
movslq %r13d,%r13
mov %r13,%rax
jmp 12e8 <func0+0x11f>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rbx, rdi
mov r12, rdx
mov rbp, rcx
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rax, aThree+5; ""
mov [rsp+88h+var_88], rax
lea rax, unk_2004
mov [rsp+88h+var_80], rax
lea rax, unk_2008
mov [rsp+88h+var_78], rax
lea rax, aThree; "Three"
mov [rsp+88h+var_70], rax
lea rax, aFour; "Four"
mov [rsp+88h+var_68], rax
lea rax, aFive; "Five"
mov [rsp+88h+var_60], rax
lea rax, aSix; "Six"
mov [rsp+88h+var_58], rax
lea rax, aSeven; "Seven"
mov [rsp+88h+var_50], rax
lea rax, aEight; "Eight"
mov [rsp+88h+var_48], rax
lea rax, aNine; "Nine"
mov [rsp+88h+var_40], rax
lea r13d, [rsi-1]
test r13d, r13d
jle short loc_12B0
lea r8, [rdi+4]
jmp short loc_129B
loc_1276:
add rax, 4
cmp rax, rdi
jz short loc_128F
loc_127F:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_1276
mov [rax], ecx
mov [rax+4], edx
jmp short loc_1276
loc_128F:
sub esi, 1
cmp esi, 1
jz loc_134A
loc_129B:
cmp esi, 1
jle loc_1359
mov rax, rbx
lea edx, [rsi-2]
lea rdi, [r8+rdx*4]
jmp short loc_127F
loc_12B0:
mov dword ptr [rcx], 0
jns loc_1351
mov edi, 0; size
call _malloc
mov [r12], rax
loc_12CA:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz loc_1361
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12E9:
sub rax, 1
test eax, eax
js short loc_1302
loc_12F1:
mov esi, [rbx+rax*4]
lea edx, [rsi-1]
cmp edx, 8
ja short loc_12E9
add dword ptr [rbp+0], 1
jmp short loc_12E9
loc_1302:
movsxd rdi, dword ptr [rbp+0]
shl rdi, 3; size
call _malloc
mov [r12], rax
mov edx, 0
jmp short loc_1323
loc_131A:
sub r13, 1
test r13d, r13d
js short loc_12CA
loc_1323:
cmp [rbp+0], edx
jle short loc_12CA
mov eax, [rbx+r13*4]
lea ecx, [rax-1]
cmp ecx, 8
ja short loc_131A
movsxd rsi, edx
mov rcx, [r12]
cdqe
mov rax, [rsp+rax*8+88h+var_88]
mov [rcx+rsi*8], rax
lea edx, [rdx+1]
jmp short loc_131A
loc_134A:
mov dword ptr [rbp+0], 0
loc_1351:
movsxd r13, r13d
mov rax, r13
jmp short loc_12F1
loc_1359:
sub esi, 1
jmp loc_129B
loc_1361:
call ___stack_chk_fail
|
unsigned long long func0(int *a1, int a2, void **a3, int *a4)
{
long long v6; // r13
int *v7; // rax
int v8; // edx
int v9; // ecx
long long v11; // rax
int v12; // edx
int v13; // eax
_QWORD v14[11]; // [rsp+0h] [rbp-88h]
unsigned long long v15; // [rsp+58h] [rbp-30h]
v15 = __readfsqword(0x28u);
v14[0] = "";
v14[1] = &unk_2004;
v14[2] = &unk_2008;
v14[3] = "Three";
v14[4] = "Four";
v14[5] = "Five";
v14[6] = "Six";
v14[7] = "Seven";
v14[8] = "Eight";
v14[9] = "Nine";
LODWORD(v6) = a2 - 1;
if ( a2 - 1 <= 0 )
{
*a4 = 0;
if ( (int)v6 < 0 )
{
*a3 = malloc(0LL);
return v15 - __readfsqword(0x28u);
}
}
else
{
do
{
while ( a2 <= 1 )
--a2;
v7 = a1;
do
{
v8 = *v7;
v9 = v7[1];
if ( *v7 > v9 )
{
*v7 = v9;
v7[1] = v8;
}
++v7;
}
while ( v7 != &a1[a2 - 2 + 1] );
--a2;
}
while ( a2 != 1 );
*a4 = 0;
}
v6 = (int)v6;
v11 = (int)v6;
do
{
if ( (unsigned int)(a1[v11] - 1) <= 8 )
++*a4;
--v11;
}
while ( (int)v11 >= 0 );
*a3 = malloc(8LL * *a4);
v12 = 0;
do
{
if ( *a4 <= v12 )
break;
v13 = a1[v6];
if ( (unsigned int)(v13 - 1) <= 8 )
*((_QWORD *)*a3 + v12++) = v14[v13];
--v6;
}
while ( (int)v6 >= 0 );
return v15 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV R12,RDX
MOV RBP,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[0x102011]
MOV qword ptr [RSP],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[0x102008]
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,[0x102017]
MOV qword ptr [RSP + 0x28],RAX
LEA RAX,[0x10201c]
MOV qword ptr [RSP + 0x30],RAX
LEA RAX,[0x102020]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[0x102026]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x10202c]
MOV qword ptr [RSP + 0x48],RAX
LEA R13D,[RSI + -0x1]
TEST R13D,R13D
JLE 0x001012b0
LEA R8,[RDI + 0x4]
JMP 0x0010129b
LAB_00101276:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x0010128f
LAB_0010127f:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x00101276
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
JMP 0x00101276
LAB_0010128f:
SUB ESI,0x1
CMP ESI,0x1
JZ 0x0010134a
LAB_0010129b:
CMP ESI,0x1
JLE 0x00101359
MOV RAX,RBX
LEA EDX,[RSI + -0x2]
LEA RDI,[R8 + RDX*0x4]
JMP 0x0010127f
LAB_001012b0:
MOV dword ptr [RCX],0x0
JNS 0x00101351
MOV EDI,0x0
CALL 0x001010d0
MOV qword ptr [R12],RAX
LAB_001012ca:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101361
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012e9:
SUB RAX,0x1
TEST EAX,EAX
JS 0x00101302
LAB_001012f1:
MOV ESI,dword ptr [RBX + RAX*0x4]
LEA EDX,[RSI + -0x1]
CMP EDX,0x8
JA 0x001012e9
ADD dword ptr [RBP],0x1
JMP 0x001012e9
LAB_00101302:
MOVSXD RDI,dword ptr [RBP]
SHL RDI,0x3
CALL 0x001010d0
MOV qword ptr [R12],RAX
MOV EDX,0x0
JMP 0x00101323
LAB_0010131a:
SUB R13,0x1
TEST R13D,R13D
JS 0x001012ca
LAB_00101323:
CMP dword ptr [RBP],EDX
JLE 0x001012ca
MOV EAX,dword ptr [RBX + R13*0x4]
LEA ECX,[RAX + -0x1]
CMP ECX,0x8
JA 0x0010131a
MOVSXD RSI,EDX
MOV RCX,qword ptr [R12]
CDQE
MOV RAX,qword ptr [RSP + RAX*0x8]
MOV qword ptr [RCX + RSI*0x8],RAX
LEA EDX,[RDX + 0x1]
JMP 0x0010131a
LAB_0010134a:
MOV dword ptr [RBP],0x0
LAB_00101351:
MOVSXD R13,R13D
MOV RAX,R13
JMP 0x001012f1
LAB_00101359:
SUB ESI,0x1
JMP 0x0010129b
LAB_00101361:
CALL 0x001010a0
|
void func0(int *param_1,int param_2,long *param_3,int *param_4)
{
int iVar1;
int *piVar2;
long lVar3;
void *pvVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
char *local_88 [11];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "";
local_88[1] = "One";
local_88[2] = "Two";
local_88[3] = "Three";
local_88[4] = "Four";
local_88[5] = "Five";
local_88[6] = "Six";
local_88[7] = "Seven";
local_88[8] = "Eight";
local_88[9] = "Nine";
iVar5 = param_2 + -1;
if (iVar5 < 1) {
*param_4 = 0;
if (iVar5 < 0) {
pvVar4 = malloc(0);
*param_3 = (long)pvVar4;
goto LAB_001012ca;
}
}
else {
do {
for (; param_2 < 2; param_2 = param_2 + -1) {
}
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 1);
param_2 = param_2 + -1;
} while (param_2 != 1);
*param_4 = 0;
}
lVar6 = (long)iVar5;
lVar3 = lVar6;
do {
if (param_1[lVar3] - 1U < 9) {
*param_4 = *param_4 + 1;
}
lVar3 = lVar3 + -1;
} while (-1 < (int)lVar3);
pvVar4 = malloc((long)*param_4 << 3);
*param_3 = (long)pvVar4;
iVar5 = 0;
do {
if (*param_4 <= iVar5) break;
if (param_1[lVar6] - 1U < 9) {
*(char **)(*param_3 + (long)iVar5 * 8) = local_88[param_1[lVar6]];
iVar5 = iVar5 + 1;
}
lVar6 = lVar6 + -1;
} while (-1 < (int)lVar6);
LAB_001012ca:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,078 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
*out_size = 0;
for (i = size - 1; i >= 0; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out_size)++;
}
}
*out = malloc(*out_size * sizeof(char *));
for (i = size - 1, j = 0; i >= 0 && j < *out_size; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out)[j++] = names[arr[i]];
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char **a, int a_size, char **b, 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() {
char **out;
int out_size;
int test1[] = {2, 1, 1, 4, 5, 8, 2, 3};
char *expected1[] = {"Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"};
func0(test1, 8, &out, &out_size);
assert(issame(out, out_size, expected1, 8));
free(out);
int test2[] = {};
func0(test2, 0, &out, &out_size);
assert(issame(out, out_size, NULL, 0));
free(out);
int test3[] = {1, -1, 55};
char *expected3[] = {"One"};
func0(test3, 3, &out, &out_size);
assert(issame(out, out_size, expected3, 1));
free(out);
int test4[] = {1, -1, 3, 2};
char *expected4[] = {"Three", "Two", "One"};
func0(test4, 4, &out, &out_size);
assert(issame(out, out_size, expected4, 3));
free(out);
int test5[] = {9, 4, 8};
char *expected5[] = {"Nine", "Eight", "Four"};
func0(test5, 3, &out, &out_size);
assert(issame(out, out_size, expected5, 3));
free(out);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
mov %rcx,%r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
push %rbx
lea -0x1(%rsi),%ebx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x9f0(%rip),%rax
mov %rax,(%rsp)
lea 0x9d8(%rip),%rax
mov %rax,0x8(%rsp)
lea 0x9d0(%rip),%rax
mov %rax,0x10(%rsp)
lea 0x9c8(%rip),%rax
mov %rax,0x18(%rsp)
lea 0x9c2(%rip),%rax
mov %rax,0x20(%rsp)
lea 0x9bb(%rip),%rax
mov %rax,0x28(%rsp)
lea 0x9b4(%rip),%rax
mov %rax,0x30(%rsp)
lea 0x9ac(%rip),%rax
mov %rax,0x38(%rsp)
lea 0x9a6(%rip),%rax
mov %rax,0x40(%rsp)
lea 0x9a0(%rip),%rax
mov %rax,0x48(%rsp)
test %ebx,%ebx
jle 1762 <func0+0x172>
mov %ebx,%esi
lea 0x4(%rdi),%rcx
lea -0x1(%rsi),%edx
mov %rbp,%rax
mov %rdx,%r9
lea (%rcx,%rdx,4),%r8
nopl (%rax)
mov (%rax),%esi
mov 0x4(%rax),%edi
cmp %edi,%esi
jle 16be <func0+0xce>
mov %edi,(%rax)
mov %esi,0x4(%rax)
add $0x4,%rax
cmp %rax,%r8
jne 16b0 <func0+0xc0>
mov %r9d,%esi
test %r9d,%r9d
jne 16a0 <func0+0xb0>
movl $0x0,0x0(%r13)
movslq %ebx,%rbx
xor %ecx,%ecx
mov %rbx,%rax
mov 0x0(%rbp,%rax,4),%edx
sub $0x1,%edx
cmp $0x8,%edx
ja 16f3 <func0+0x103>
add $0x1,%ecx
mov %ecx,0x0(%r13)
sub $0x1,%rax
test %eax,%eax
jns 16e0 <func0+0xf0>
movslq %ecx,%rcx
lea 0x0(,%rcx,8),%rdi
callq 10d0 <malloc@plt>
mov 0x0(%r13),%edi
xor %ecx,%ecx
mov %rax,(%r12)
jmp 1743 <func0+0x153>
nopw 0x0(%rax,%rax,1)
movslq 0x0(%rbp,%rbx,4),%rdx
lea -0x1(%rdx),%esi
cmp $0x8,%esi
ja 173b <func0+0x14b>
mov (%rsp,%rdx,8),%rdx
movslq %ecx,%rsi
add $0x1,%ecx
mov %rdx,(%rax,%rsi,8)
sub $0x1,%rbx
test %ebx,%ebx
js 1747 <func0+0x157>
cmp %ecx,%edi
jg 1720 <func0+0x130>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 177b <func0+0x18b>
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
movl $0x0,(%rcx)
je 16d7 <func0+0xe7>
xor %edi,%edi
callq 10d0 <malloc@plt>
mov %rax,(%r12)
jmp 1747 <func0+0x157>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r13
mov r13, rcx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
lea rbx, aThree+5; ""
movq xmm0, rbx
lea rbx, unk_2008
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
lea rax, unk_2004
movq xmm2, rax
lea rax, aThree; "Three"
punpcklqdq xmm0, xmm2
movq xmm3, rax
lea rax, aFive; "Five"
movaps [rsp+88h+var_88], xmm0
movq xmm0, rbx
lea rbx, aFour; "Four"
movq xmm4, rax
punpcklqdq xmm0, xmm3
lea rax, aSeven; "Seven"
movaps [rsp+88h+var_78], xmm0
movq xmm0, rbx
movq xmm5, rax
lea rbx, aSix; "Six"
punpcklqdq xmm0, xmm4
lea rax, aNine; "Nine"
movaps [rsp+88h+var_68], xmm0
movq xmm0, rbx
movq xmm6, rax
lea rbx, aEight; "Eight"
punpcklqdq xmm0, xmm5
movaps [rsp+88h+var_58], xmm0
movq xmm0, rbx
lea ebx, [rsi-1]
punpcklqdq xmm0, xmm6
movaps [rsp+88h+var_48], xmm0
test ebx, ebx
jle loc_1780
mov edi, esi
lea r8, [rbp+4]
nop word ptr [rax+rax+00h]
loc_1690:
cmp edi, 1
jle loc_1778
lea edx, [rdi-2]
mov rax, rbp
lea rsi, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_16A8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_16C6
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_16C6:
add rax, 4
cmp rax, rsi
jnz short loc_16A8
sub edi, 1
cmp edi, 1
jnz short loc_1690
mov dword ptr [r13+0], 0
loc_16DF:
movsxd rbx, ebx
xor ecx, ecx
mov rax, rbx
nop word ptr [rax+rax+00000000h]
loc_16F0:
mov edi, [rbp+rax*4+0]
lea edx, [rdi-1]
cmp edx, 8
ja short loc_1703
add ecx, 1
mov [r13+0], ecx
loc_1703:
sub rax, 1
test eax, eax
jns short loc_16F0
movsxd rcx, ecx
lea rdi, ds:0[rcx*8]; size
call _malloc
mov edi, [r13+0]
xor ecx, ecx
mov [r12], rax
jmp short loc_1753
loc_1730:
movsxd rdx, dword ptr [rbp+rbx*4+0]
lea esi, [rdx-1]
cmp esi, 8
ja short loc_174B
mov rdx, qword ptr [rsp+rdx*8+88h+var_88]
movsxd rsi, ecx
add ecx, 1
mov [rax+rsi*8], rdx
loc_174B:
sub rbx, 1
test ebx, ebx
js short loc_1757
loc_1753:
cmp edi, ecx
jg short loc_1730
loc_1757:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_1799
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1778:
sub edi, 1
jmp loc_1690
loc_1780:
mov dword ptr [rcx], 0
jz loc_16DF
xor edi, edi; size
call _malloc
mov [r12], rax
jmp short loc_1757
loc_1799:
call ___stack_chk_fail
|
unsigned long long func0(__m128i *a1, int a2, void **a3, int *a4)
{
long long v7; // rbx
int v8; // edi
__m128i *v9; // rax
__m128i v10; // xmm0
int v11; // ecx
long long v12; // rax
_QWORD *v13; // rax
int v14; // edi
int v15; // ecx
long long v16; // rdx
long long v17; // rsi
_OWORD v19[5]; // [rsp+0h] [rbp-88h]
unsigned long long v20; // [rsp+58h] [rbp-30h]
v20 = __readfsqword(0x28u);
v19[0] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"", (__m128i)(unsigned long long)&unk_2004);
v19[1] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2008, (__m128i)(unsigned long long)"Three");
v19[2] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Four", (__m128i)(unsigned long long)"Five");
v19[3] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Six", (__m128i)(unsigned long long)"Seven");
LODWORD(v7) = a2 - 1;
v19[4] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Eight", (__m128i)(unsigned long long)"Nine");
if ( a2 - 1 <= 0 )
{
*a4 = 0;
if ( a2 != 1 )
{
*a3 = malloc(0LL);
return v20 - __readfsqword(0x28u);
}
}
else
{
v8 = a2;
do
{
while ( v8 <= 1 )
--v8;
v9 = a1;
do
{
v10 = _mm_loadl_epi64(v9);
if ( _mm_cvtsi128_si32(v10) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v10, 229)) )
v9->m128i_i64[0] = _mm_shuffle_epi32(v10, 225).m128i_u64[0];
v9 = (__m128i *)((char *)v9 + 4);
}
while ( v9 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(v8 - 2) + 4) );
--v8;
}
while ( v8 != 1 );
*a4 = 0;
}
v7 = (int)v7;
v11 = 0;
v12 = (int)v7;
do
{
if ( (unsigned int)(a1->m128i_i32[v12] - 1) <= 8 )
*a4 = ++v11;
--v12;
}
while ( (int)v12 >= 0 );
v13 = malloc(8LL * v11);
v14 = *a4;
v15 = 0;
*a3 = v13;
do
{
if ( v14 <= v15 )
break;
v16 = a1->m128i_i32[v7];
if ( (unsigned int)(v16 - 1) <= 8 )
{
v17 = v15++;
v13[v17] = *((_QWORD *)v19 + v16);
}
--v7;
}
while ( (int)v7 >= 0 );
return v20 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x102011]
MOVQ XMM0,RBX
LEA RBX,[0x102008]
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x102004]
MOVQ XMM2,RAX
LEA RAX,[0x10200c]
PUNPCKLQDQ XMM0,XMM2
MOVQ XMM3,RAX
LEA RAX,[0x102017]
MOVAPS xmmword ptr [RSP],XMM0
MOVQ XMM0,RBX
LEA RBX,[0x102012]
MOVQ XMM4,RAX
PUNPCKLQDQ XMM0,XMM3
LEA RAX,[0x102020]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,RBX
MOVQ XMM5,RAX
LEA RBX,[0x10201c]
PUNPCKLQDQ XMM0,XMM4
LEA RAX,[0x10202c]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVQ XMM0,RBX
MOVQ XMM6,RAX
LEA RBX,[0x102026]
PUNPCKLQDQ XMM0,XMM5
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVQ XMM0,RBX
LEA EBX,[RSI + -0x1]
PUNPCKLQDQ XMM0,XMM6
MOVAPS xmmword ptr [RSP + 0x40],XMM0
TEST EBX,EBX
JLE 0x00101780
MOV EDI,ESI
LEA R8,[RBP + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101690:
CMP EDI,0x1
JLE 0x00101778
LEA EDX,[RDI + -0x2]
MOV RAX,RBP
LEA RSI,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016a8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x001016c6
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001016c6:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001016a8
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x00101690
MOV dword ptr [R13],0x0
LAB_001016df:
MOVSXD RBX,EBX
XOR ECX,ECX
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_001016f0:
MOV EDI,dword ptr [RBP + RAX*0x4]
LEA EDX,[RDI + -0x1]
CMP EDX,0x8
JA 0x00101703
ADD ECX,0x1
MOV dword ptr [R13],ECX
LAB_00101703:
SUB RAX,0x1
TEST EAX,EAX
JNS 0x001016f0
MOVSXD RCX,ECX
LEA RDI,[RCX*0x8]
CALL 0x001010d0
MOV EDI,dword ptr [R13]
XOR ECX,ECX
MOV qword ptr [R12],RAX
JMP 0x00101753
LAB_00101730:
MOVSXD RDX,dword ptr [RBP + RBX*0x4]
LEA ESI,[RDX + -0x1]
CMP ESI,0x8
JA 0x0010174b
MOV RDX,qword ptr [RSP + RDX*0x8]
MOVSXD RSI,ECX
ADD ECX,0x1
MOV qword ptr [RAX + RSI*0x8],RDX
LAB_0010174b:
SUB RBX,0x1
TEST EBX,EBX
JS 0x00101757
LAB_00101753:
CMP EDI,ECX
JG 0x00101730
LAB_00101757:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101799
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101778:
SUB EDI,0x1
JMP 0x00101690
LAB_00101780:
MOV dword ptr [RCX],0x0
JZ 0x001016df
XOR EDI,EDI
CALL 0x001010d0
MOV qword ptr [R12],RAX
JMP 0x00101757
LAB_00101799:
CALL 0x001010a0
|
void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
long lVar2;
void *pvVar3;
int iVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int iVar7;
char *local_88 [4];
int *local_68;
int *puStack_60;
int *local_58;
char *pcStack_50;
char *local_48;
int *puStack_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "";
local_88[1] = "One";
local_88[2] = "Two";
local_88[3] = "Three";
local_68 = &DAT_00102012;
puStack_60 = &DAT_00102017;
local_58 = &DAT_0010201c;
pcStack_50 = "Seven";
iVar5 = param_2 + -1;
local_48 = "Eight";
puStack_40 = &DAT_0010202c;
if (iVar5 < 1) {
*param_4 = 0;
if (iVar5 != 0) {
pvVar3 = malloc(0);
*param_3 = pvVar3;
goto LAB_00101757;
}
}
else {
do {
for (; param_2 < 2; param_2 = param_2 + -1) {
}
puVar1 = param_1;
do {
iVar4 = (int)*puVar1;
iVar7 = (int)((ulong)*puVar1 >> 0x20);
if (iVar7 < iVar4) {
*puVar1 = CONCAT44(iVar4,iVar7);
}
puVar1 = (int8 *)((long)puVar1 + 4);
} while (puVar1 != (int8 *)((long)param_1 + (ulong)(param_2 - 2) * 4 + 4));
param_2 = param_2 + -1;
} while (param_2 != 1);
*param_4 = 0;
}
lVar6 = (long)iVar5;
iVar5 = 0;
lVar2 = lVar6;
do {
if (*(int *)((long)param_1 + lVar2 * 4) - 1U < 9) {
iVar5 = iVar5 + 1;
*param_4 = iVar5;
}
lVar2 = lVar2 + -1;
} while (-1 < (int)lVar2);
pvVar3 = malloc((long)iVar5 * 8);
iVar5 = *param_4;
iVar4 = 0;
*param_3 = pvVar3;
do {
if (iVar5 <= iVar4) break;
iVar7 = *(int *)((long)param_1 + lVar6 * 4);
if (iVar7 - 1U < 9) {
lVar2 = (long)iVar4;
iVar4 = iVar4 + 1;
*(char **)((long)pvVar3 + lVar2 * 8) = local_88[iVar7];
}
lVar6 = lVar6 + -1;
} while (-1 < (int)lVar6);
LAB_00101757:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,079 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
*out_size = 0;
for (i = size - 1; i >= 0; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out_size)++;
}
}
*out = malloc(*out_size * sizeof(char *));
for (i = size - 1, j = 0; i >= 0 && j < *out_size; i--) {
if (arr[i] >= 1 && arr[i] <= 9) {
(*out)[j++] = names[arr[i]];
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char **a, int a_size, char **b, 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() {
char **out;
int out_size;
int test1[] = {2, 1, 1, 4, 5, 8, 2, 3};
char *expected1[] = {"Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"};
func0(test1, 8, &out, &out_size);
assert(issame(out, out_size, expected1, 8));
free(out);
int test2[] = {};
func0(test2, 0, &out, &out_size);
assert(issame(out, out_size, NULL, 0));
free(out);
int test3[] = {1, -1, 55};
char *expected3[] = {"One"};
func0(test3, 3, &out, &out_size);
assert(issame(out, out_size, expected3, 1));
free(out);
int test4[] = {1, -1, 3, 2};
char *expected4[] = {"Three", "Two", "One"};
func0(test4, 4, &out, &out_size);
assert(issame(out, out_size, expected4, 3));
free(out);
int test5[] = {9, 4, 8};
char *expected5[] = {"Nine", "Eight", "Four"};
func0(test5, 3, &out, &out_size);
assert(issame(out, out_size, expected5, 3));
free(out);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
mov %rcx,%r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
push %rbx
lea 0xa47(%rip),%rbx
movq %rbx,%xmm0
lea 0xa32(%rip),%rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xa13(%rip),%rax
movq %rax,%xmm1
lea 0xa0f(%rip),%rax
punpcklqdq %xmm1,%xmm0
movq %rax,%xmm2
lea 0xa0a(%rip),%rax
movaps %xmm0,(%rsp)
movq %rbx,%xmm0
lea 0x9f5(%rip),%rbx
movq %rax,%xmm3
punpcklqdq %xmm2,%xmm0
lea 0x9f3(%rip),%rax
movaps %xmm0,0x10(%rsp)
movq %rbx,%xmm0
movq %rax,%xmm4
lea 0x9d9(%rip),%rbx
punpcklqdq %xmm3,%xmm0
lea 0x9de(%rip),%rax
movaps %xmm0,0x20(%rsp)
movq %rbx,%xmm0
movq %rax,%xmm5
lea 0x9c2(%rip),%rbx
punpcklqdq %xmm4,%xmm0
movaps %xmm0,0x30(%rsp)
movq %rbx,%xmm0
lea -0x1(%rsi),%ebx
punpcklqdq %xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
test %ebx,%ebx
jle 1752 <func0+0x1a2>
mov %ebx,%esi
lea 0x4(%rdi),%rcx
nopl 0x0(%rax)
lea -0x1(%rsi),%edx
mov %rbp,%rax
mov %rdx,%r9
lea (%rcx,%rdx,4),%r8
nopl (%rax)
mov (%rax),%esi
mov 0x4(%rax),%edi
cmp %edi,%esi
jle 16ae <func0+0xfe>
mov %edi,(%rax)
mov %esi,0x4(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 16a0 <func0+0xf0>
mov %r9d,%esi
test %r9d,%r9d
jne 1690 <func0+0xe0>
movl $0x0,0x0(%r13)
movslq %ebx,%rbx
xor %ecx,%ecx
mov %rbx,%rax
mov 0x0(%rbp,%rax,4),%edx
sub $0x1,%edx
cmp $0x8,%edx
ja 16e3 <func0+0x133>
add $0x1,%ecx
mov %ecx,0x0(%r13)
sub $0x1,%rax
test %eax,%eax
jns 16d0 <func0+0x120>
movslq %ecx,%rcx
lea 0x0(,%rcx,8),%rdi
callq 10d0 <malloc@plt>
mov 0x0(%r13),%edi
xor %ecx,%ecx
mov %rax,(%r12)
jmp 1733 <func0+0x183>
nopw 0x0(%rax,%rax,1)
movslq 0x0(%rbp,%rbx,4),%rdx
lea -0x1(%rdx),%esi
cmp $0x8,%esi
ja 172b <func0+0x17b>
mov (%rsp,%rdx,8),%rdx
movslq %ecx,%rsi
add $0x1,%ecx
mov %rdx,(%rax,%rsi,8)
sub $0x1,%rbx
test %ebx,%ebx
js 1737 <func0+0x187>
cmp %ecx,%edi
jg 1710 <func0+0x160>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 176b <func0+0x1bb>
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
movl $0x0,(%rcx)
je 16c7 <func0+0x117>
xor %edi,%edi
callq 10d0 <malloc@plt>
mov %rax,(%r12)
jmp 1737 <func0+0x187>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r13
mov r13, rcx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
lea rbx, aThree+5; ""
movq xmm0, rbx
lea rbx, unk_2008
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
lea rax, unk_2004
movq xmm2, rax
lea rax, aThree; "Three"
punpcklqdq xmm0, xmm2
movq xmm3, rax
lea rax, aFive; "Five"
movaps [rsp+88h+var_88], xmm0
movq xmm0, rbx
lea rbx, aFour; "Four"
movq xmm4, rax
punpcklqdq xmm0, xmm3
lea rax, aSeven; "Seven"
movaps [rsp+88h+var_78], xmm0
movq xmm0, rbx
movq xmm5, rax
lea rbx, aSix; "Six"
punpcklqdq xmm0, xmm4
lea rax, aNine; "Nine"
movaps [rsp+88h+var_68], xmm0
movq xmm0, rbx
movq xmm6, rax
lea rbx, aEight; "Eight"
punpcklqdq xmm0, xmm5
movaps [rsp+88h+var_58], xmm0
movq xmm0, rbx
lea ebx, [rsi-1]
punpcklqdq xmm0, xmm6
movaps [rsp+88h+var_48], xmm0
test ebx, ebx
jle loc_1780
mov edi, esi
lea r8, [rbp+4]
nop word ptr [rax+rax+00h]
loc_1690:
cmp edi, 1
jle loc_1778
lea edx, [rdi-2]
mov rax, rbp
lea rsi, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_16A8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_16C6
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_16C6:
add rax, 4
cmp rax, rsi
jnz short loc_16A8
sub edi, 1
cmp edi, 1
jnz short loc_1690
mov dword ptr [r13+0], 0
loc_16DF:
movsxd rbx, ebx
xor ecx, ecx
mov rax, rbx
nop word ptr [rax+rax+00000000h]
loc_16F0:
mov edi, [rbp+rax*4+0]
lea edx, [rdi-1]
cmp edx, 8
ja short loc_1703
add ecx, 1
mov [r13+0], ecx
loc_1703:
sub rax, 1
test eax, eax
jns short loc_16F0
movsxd rcx, ecx
lea rdi, ds:0[rcx*8]; size
call _malloc
mov edi, [r13+0]
xor ecx, ecx
mov [r12], rax
jmp short loc_1753
loc_1730:
movsxd rdx, dword ptr [rbp+rbx*4+0]
lea esi, [rdx-1]
cmp esi, 8
ja short loc_174B
mov rdx, qword ptr [rsp+rdx*8+88h+var_88]
movsxd rsi, ecx
add ecx, 1
mov [rax+rsi*8], rdx
loc_174B:
sub rbx, 1
test ebx, ebx
js short loc_1757
loc_1753:
cmp edi, ecx
jg short loc_1730
loc_1757:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_1799
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1778:
sub edi, 1
jmp loc_1690
loc_1780:
mov dword ptr [rcx], 0
jz loc_16DF
xor edi, edi; size
call _malloc
mov [r12], rax
jmp short loc_1757
loc_1799:
call ___stack_chk_fail
|
unsigned long long func0(__m128i *a1, int a2, void **a3, int *a4)
{
long long v7; // rbx
int v8; // edi
__m128i *v9; // rax
__m128i v10; // xmm0
int v11; // ecx
long long v12; // rax
_QWORD *v13; // rax
int v14; // edi
int v15; // ecx
long long v16; // rdx
long long v17; // rsi
_OWORD v19[5]; // [rsp+0h] [rbp-88h]
unsigned long long v20; // [rsp+58h] [rbp-30h]
v20 = __readfsqword(0x28u);
v19[0] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"", (__m128i)(unsigned long long)&unk_2004);
v19[1] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2008, (__m128i)(unsigned long long)"Three");
v19[2] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Four", (__m128i)(unsigned long long)"Five");
v19[3] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Six", (__m128i)(unsigned long long)"Seven");
LODWORD(v7) = a2 - 1;
v19[4] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Eight", (__m128i)(unsigned long long)"Nine");
if ( a2 - 1 <= 0 )
{
*a4 = 0;
if ( a2 != 1 )
{
*a3 = malloc(0LL);
return v20 - __readfsqword(0x28u);
}
}
else
{
v8 = a2;
do
{
while ( v8 <= 1 )
--v8;
v9 = a1;
do
{
v10 = _mm_loadl_epi64(v9);
if ( _mm_cvtsi128_si32(v10) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v10, 229)) )
v9->m128i_i64[0] = _mm_shuffle_epi32(v10, 225).m128i_u64[0];
v9 = (__m128i *)((char *)v9 + 4);
}
while ( v9 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(v8 - 2) + 4) );
--v8;
}
while ( v8 != 1 );
*a4 = 0;
}
v7 = (int)v7;
v11 = 0;
v12 = (int)v7;
do
{
if ( (unsigned int)(a1->m128i_i32[v12] - 1) <= 8 )
*a4 = ++v11;
--v12;
}
while ( (int)v12 >= 0 );
v13 = malloc(8LL * v11);
v14 = *a4;
v15 = 0;
*a3 = v13;
do
{
if ( v14 <= v15 )
break;
v16 = a1->m128i_i32[v7];
if ( (unsigned int)(v16 - 1) <= 8 )
{
v17 = v15++;
v13[v17] = *((_QWORD *)v19 + v16);
}
--v7;
}
while ( (int)v7 >= 0 );
return v20 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x102011]
MOVQ XMM0,RBX
LEA RBX,[0x102008]
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x102004]
MOVQ XMM2,RAX
LEA RAX,[0x10200c]
PUNPCKLQDQ XMM0,XMM2
MOVQ XMM3,RAX
LEA RAX,[0x102017]
MOVAPS xmmword ptr [RSP],XMM0
MOVQ XMM0,RBX
LEA RBX,[0x102012]
MOVQ XMM4,RAX
PUNPCKLQDQ XMM0,XMM3
LEA RAX,[0x102020]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,RBX
MOVQ XMM5,RAX
LEA RBX,[0x10201c]
PUNPCKLQDQ XMM0,XMM4
LEA RAX,[0x10202c]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVQ XMM0,RBX
MOVQ XMM6,RAX
LEA RBX,[0x102026]
PUNPCKLQDQ XMM0,XMM5
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVQ XMM0,RBX
LEA EBX,[RSI + -0x1]
PUNPCKLQDQ XMM0,XMM6
MOVAPS xmmword ptr [RSP + 0x40],XMM0
TEST EBX,EBX
JLE 0x00101780
MOV EDI,ESI
LEA R8,[RBP + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101690:
CMP EDI,0x1
JLE 0x00101778
LEA EDX,[RDI + -0x2]
MOV RAX,RBP
LEA RSI,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016a8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x001016c6
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001016c6:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001016a8
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x00101690
MOV dword ptr [R13],0x0
LAB_001016df:
MOVSXD RBX,EBX
XOR ECX,ECX
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_001016f0:
MOV EDI,dword ptr [RBP + RAX*0x4]
LEA EDX,[RDI + -0x1]
CMP EDX,0x8
JA 0x00101703
ADD ECX,0x1
MOV dword ptr [R13],ECX
LAB_00101703:
SUB RAX,0x1
TEST EAX,EAX
JNS 0x001016f0
MOVSXD RCX,ECX
LEA RDI,[RCX*0x8]
CALL 0x001010d0
MOV EDI,dword ptr [R13]
XOR ECX,ECX
MOV qword ptr [R12],RAX
JMP 0x00101753
LAB_00101730:
MOVSXD RDX,dword ptr [RBP + RBX*0x4]
LEA ESI,[RDX + -0x1]
CMP ESI,0x8
JA 0x0010174b
MOV RDX,qword ptr [RSP + RDX*0x8]
MOVSXD RSI,ECX
ADD ECX,0x1
MOV qword ptr [RAX + RSI*0x8],RDX
LAB_0010174b:
SUB RBX,0x1
TEST EBX,EBX
JS 0x00101757
LAB_00101753:
CMP EDI,ECX
JG 0x00101730
LAB_00101757:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101799
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101778:
SUB EDI,0x1
JMP 0x00101690
LAB_00101780:
MOV dword ptr [RCX],0x0
JZ 0x001016df
XOR EDI,EDI
CALL 0x001010d0
MOV qword ptr [R12],RAX
JMP 0x00101757
LAB_00101799:
CALL 0x001010a0
|
void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
long lVar2;
void *pvVar3;
int iVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int iVar7;
char *local_88 [4];
int *local_68;
int *puStack_60;
int *local_58;
char *pcStack_50;
char *local_48;
int *puStack_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "";
local_88[1] = "One";
local_88[2] = "Two";
local_88[3] = "Three";
local_68 = &DAT_00102012;
puStack_60 = &DAT_00102017;
local_58 = &DAT_0010201c;
pcStack_50 = "Seven";
iVar5 = param_2 + -1;
local_48 = "Eight";
puStack_40 = &DAT_0010202c;
if (iVar5 < 1) {
*param_4 = 0;
if (iVar5 != 0) {
pvVar3 = malloc(0);
*param_3 = pvVar3;
goto LAB_00101757;
}
}
else {
do {
for (; param_2 < 2; param_2 = param_2 + -1) {
}
puVar1 = param_1;
do {
iVar4 = (int)*puVar1;
iVar7 = (int)((ulong)*puVar1 >> 0x20);
if (iVar7 < iVar4) {
*puVar1 = CONCAT44(iVar4,iVar7);
}
puVar1 = (int8 *)((long)puVar1 + 4);
} while (puVar1 != (int8 *)((long)param_1 + (ulong)(param_2 - 2) * 4 + 4));
param_2 = param_2 + -1;
} while (param_2 != 1);
*param_4 = 0;
}
lVar6 = (long)iVar5;
iVar5 = 0;
lVar2 = lVar6;
do {
if (*(int *)((long)param_1 + lVar2 * 4) - 1U < 9) {
iVar5 = iVar5 + 1;
*param_4 = iVar5;
}
lVar2 = lVar2 + -1;
} while (-1 < (int)lVar2);
pvVar3 = malloc((long)iVar5 * 8);
iVar5 = *param_4;
iVar4 = 0;
*param_3 = pvVar3;
do {
if (iVar5 <= iVar4) break;
iVar7 = *(int *)((long)param_1 + lVar6 * 4);
if (iVar7 - 1U < 9) {
lVar2 = (long)iVar4;
iVar4 = iVar4 + 1;
*(char **)((long)pvVar3 + lVar2 * 8) = local_88[iVar7];
}
lVar6 = lVar6 + -1;
} while (-1 < (int)lVar6);
LAB_00101757:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,080 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
int expected1[] = {1, 2, 6, 24, 15};
result = func0(5);
assert(issame(result, 5, expected1, 5));
free(result);
int expected2[] = {1, 2, 6, 24, 15, 720, 28};
result = func0(7);
assert(issame(result, 7, expected2, 7));
free(result);
int expected3[] = {1};
result = func0(1);
assert(issame(result, 1, expected3, 1));
free(result);
int expected4[] = {1, 2, 6};
result = func0(3);
assert(issame(result, 3, expected4, 3));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x1,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 1236 <func0+0x8d>
mov -0xc(%rbp),%eax
add %eax,-0x14(%rbp)
mov -0x10(%rbp),%eax
imul -0xc(%rbp),%eax
mov %eax,-0x10(%rbp)
mov -0xc(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1219 <func0+0x70>
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
mov %eax,(%rdx)
jmp 1232 <func0+0x89>
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 11e4 <func0+0x3b>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov [rbp+var_10], 1
mov [rbp+var_C], 1
jmp short loc_1236
loc_11E4:
mov eax, [rbp+var_C]
add [rbp+var_14], eax
mov eax, [rbp+var_10]
imul eax, [rbp+var_C]
mov [rbp+var_10], eax
mov eax, [rbp+var_C]
and eax, 1
test eax, eax
jnz short loc_1219
mov eax, [rbp+var_C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_10]
mov [rdx], eax
jmp short loc_1232
loc_1219:
mov eax, [rbp+var_C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_14]
mov [rdx], eax
loc_1232:
add [rbp+var_C], 1
loc_1236:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
jle short loc_11E4
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(int a1)
{
int v2; // [rsp+1Ch] [rbp-14h]
int v3; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v5; // [rsp+28h] [rbp-8h]
v5 = malloc(4LL * a1);
v2 = 0;
v3 = 1;
for ( i = 1; i <= a1; ++i )
{
v2 += i;
v3 *= i;
if ( (i & 1) != 0 )
v5[i - 1] = v2;
else
v5[i - 1] = v3;
}
return v5;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101236
LAB_001011e4:
MOV EAX,dword ptr [RBP + -0xc]
ADD dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101219
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RDX],EAX
JMP 0x00101232
LAB_00101219:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RDX],EAX
LAB_00101232:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101236:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x001011e4
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(int param_1)
{
void *pvVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_1 << 2);
local_1c = 0;
local_18 = 1;
for (local_14 = 1; (int)local_14 <= param_1; local_14 = local_14 + 1) {
local_1c = local_1c + local_14;
local_18 = local_18 * local_14;
if ((local_14 & 1) == 0) {
*(int *)((long)(int)local_14 * 4 + -4 + (long)pvVar1) = local_18;
}
else {
*(int *)((long)(int)local_14 * 4 + -4 + (long)pvVar1) = local_1c;
}
}
return pvVar1;
}
|
1,081 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
int expected1[] = {1, 2, 6, 24, 15};
result = func0(5);
assert(issame(result, 5, expected1, 5));
free(result);
int expected2[] = {1, 2, 6, 24, 15, 720, 28};
result = func0(7);
assert(issame(result, 7, expected2, 7));
free(result);
int expected3[] = {1};
result = func0(1);
assert(issame(result, 1, expected3, 1));
free(result);
int expected4[] = {1, 2, 6};
result = func0(3);
assert(issame(result, 3, expected4, 3));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 11f1 <func0+0x48>
lea -0x1(%rbx),%r8d
add $0x2,%r8
mov $0x1,%edx
mov $0x1,%esi
mov $0x0,%ecx
add %edx,%ecx
imul %edx,%esi
test $0x1,%dl
mov %esi,%edi
cmovne %ecx,%edi
mov %edi,-0x4(%rax,%rdx,4)
add $0x1,%rdx
cmp %r8,%rdx
jne 11d7 <func0+0x2e>
pop %rbx
retq
|
func0:
endbr64
push rbx
mov ebx, edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
test ebx, ebx
jle short loc_11ED
lea r8d, [rbx+1]
mov edx, 1
mov esi, 1
mov ecx, 0
loc_11D3:
add ecx, edx
imul esi, edx
test dl, 1
mov edi, esi
cmovnz edi, ecx
mov [rax+rdx*4-4], edi
add rdx, 1
cmp rdx, r8
jnz short loc_11D3
loc_11ED:
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v3; // rdx
int v4; // esi
int v5; // ecx
int v6; // edi
result = malloc(4LL * a1);
if ( a1 > 0 )
{
v3 = 1LL;
v4 = 1;
v5 = 0;
do
{
v5 += v3;
v4 *= (_DWORD)v3;
v6 = v4;
if ( (v3 & 1) != 0 )
v6 = v5;
result[v3++ - 1] = v6;
}
while ( v3 != a1 + 1 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011ed
LEA R8D,[RBX + 0x1]
MOV EDX,0x1
MOV ESI,0x1
MOV ECX,0x0
LAB_001011d3:
ADD ECX,EDX
IMUL ESI,EDX
TEST DL,0x1
MOV EDI,ESI
CMOVNZ EDI,ECX
MOV dword ptr [RAX + RDX*0x4 + -0x4],EDI
ADD RDX,0x1
CMP RDX,R8
JNZ 0x001011d3
LAB_001011ed:
POP RBX
RET
|
void func0(int param_1)
{
void *pvVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
pvVar1 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
iVar4 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (int)uVar3;
iVar4 = iVar4 * (int)uVar3;
iVar5 = iVar4;
if ((uVar3 & 1) != 0) {
iVar5 = iVar2;
}
*(int *)((long)pvVar1 + uVar3 * 4 + -4) = iVar5;
uVar3 = uVar3 + 1;
} while (uVar3 != param_1 + 1);
}
return;
}
|
1,082 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
int expected1[] = {1, 2, 6, 24, 15};
result = func0(5);
assert(issame(result, 5, expected1, 5));
free(result);
int expected2[] = {1, 2, 6, 24, 15, 720, 28};
result = func0(7);
assert(issame(result, 7, expected2, 7));
free(result);
int expected3[] = {1};
result = func0(1);
assert(issame(result, 1, expected3, 1));
free(result);
int expected4[] = {1, 2, 6};
result = func0(3);
assert(issame(result, 3, expected4, 3));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 13ea <func0+0x4a>
lea -0x1(%rbx),%r8d
mov $0x1,%edx
mov $0x1,%esi
xor %ecx,%ecx
add $0x2,%r8
nopl 0x0(%rax)
imul %edx,%esi
add %edx,%ecx
test $0x1,%dl
mov %esi,%edi
cmovne %ecx,%edi
mov %edi,-0x4(%rax,%rdx,4)
add $0x1,%rdx
cmp %r8,%rdx
jne 13d0 <func0+0x30>
pop %rbx
retq
nopl 0x0(%rax)
|
func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
test ebx, ebx
jle short loc_13EA
lea r8d, [rbx+1]
mov edx, 1
mov esi, 1
xor ecx, ecx
nop dword ptr [rax+rax+00000000h]
loc_13D0:
imul esi, edx
add ecx, edx
test dl, 1
mov edi, ecx
cmovz edi, esi
mov [rax+rdx*4-4], edi
add rdx, 1
cmp r8, rdx
jnz short loc_13D0
loc_13EA:
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v3; // rdx
int v4; // esi
int v5; // ecx
int v6; // edi
result = malloc(4LL * a1);
if ( a1 > 0 )
{
v3 = 1LL;
v4 = 1;
v5 = 0;
do
{
v4 *= (_DWORD)v3;
v5 += v3;
v6 = v5;
if ( (v3 & 1) == 0 )
v6 = v4;
result[v3++ - 1] = v6;
}
while ( a1 + 1 != v3 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001013ea
LEA R8D,[RBX + 0x1]
MOV EDX,0x1
MOV ESI,0x1
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
IMUL ESI,EDX
ADD ECX,EDX
TEST DL,0x1
MOV EDI,ECX
CMOVZ EDI,ESI
MOV dword ptr [RAX + RDX*0x4 + -0x4],EDI
ADD RDX,0x1
CMP R8,RDX
JNZ 0x001013d0
LAB_001013ea:
POP RBX
RET
|
void func0(int param_1)
{
void *pvVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
pvVar1 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
iVar4 = 1;
iVar2 = 0;
do {
iVar4 = iVar4 * (int)uVar3;
iVar2 = iVar2 + (int)uVar3;
iVar5 = iVar2;
if ((uVar3 & 1) == 0) {
iVar5 = iVar4;
}
*(int *)((long)pvVar1 + uVar3 * 4 + -4) = iVar5;
uVar3 = uVar3 + 1;
} while (param_1 + 1 != uVar3);
}
return;
}
|
1,083 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
int expected1[] = {1, 2, 6, 24, 15};
result = func0(5);
assert(issame(result, 5, expected1, 5));
free(result);
int expected2[] = {1, 2, 6, 24, 15, 720, 28};
result = func0(7);
assert(issame(result, 7, expected2, 7));
free(result);
int expected3[] = {1};
result = func0(1);
assert(issame(result, 1, expected3, 1));
free(result);
int expected4[] = {1, 2, 6};
result = func0(3);
assert(issame(result, 3, expected4, 3));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 13ea <func0+0x4a>
lea -0x1(%rbx),%r8d
mov $0x1,%edx
mov $0x1,%esi
xor %ecx,%ecx
add $0x2,%r8
nopl 0x0(%rax)
imul %edx,%esi
add %edx,%ecx
test $0x1,%dl
mov %esi,%edi
cmovne %ecx,%edi
mov %edi,-0x4(%rax,%rdx,4)
add $0x1,%rdx
cmp %r8,%rdx
jne 13d0 <func0+0x30>
pop %rbx
retq
nopl 0x0(%rax)
|
func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
test ebx, ebx
jle short loc_13E7
lea edi, [rbx+1]
mov edx, 1
mov esi, 1
xor ecx, ecx
nop word ptr [rax+rax+00000000h]
loc_13D0:
imul esi, edx
add ecx, edx
test dl, 1
jz short loc_13F0
mov [rax+rdx*4-4], ecx
add rdx, 1
cmp rdx, rdi
jnz short loc_13D0
loc_13E7:
pop rbx
retn
loc_13F0:
mov [rax+rdx*4-4], esi
add rdx, 1
cmp rdi, rdx
jnz short loc_13D0
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v2; // rdi
long long v3; // rdx
int v4; // esi
int v5; // ecx
result = malloc(4LL * a1);
if ( a1 > 0 )
{
v2 = (unsigned int)(a1 + 1);
v3 = 1LL;
v4 = 1;
v5 = 0;
do
{
while ( 1 )
{
v4 *= (_DWORD)v3;
v5 += v3;
if ( (v3 & 1) == 0 )
break;
result[v3++ - 1] = v5;
if ( v3 == v2 )
return result;
}
result[v3++ - 1] = v4;
}
while ( v2 != v3 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001013e7
LEA EDI,[RBX + 0x1]
MOV EDX,0x1
MOV ESI,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001013d0:
IMUL ESI,EDX
ADD ECX,EDX
TEST DL,0x1
JZ 0x001013f0
MOV dword ptr [RAX + RDX*0x4 + -0x4],ECX
ADD RDX,0x1
CMP RDX,RDI
JNZ 0x001013d0
LAB_001013e7:
POP RBX
RET
LAB_001013f0:
MOV dword ptr [RAX + RDX*0x4 + -0x4],ESI
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x001013d0
POP RBX
RET
|
void func0(int param_1)
{
void *pvVar1;
int iVar2;
ulong uVar3;
int iVar4;
pvVar1 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
iVar4 = 1;
iVar2 = 0;
do {
while( true ) {
iVar4 = iVar4 * (int)uVar3;
iVar2 = iVar2 + (int)uVar3;
if ((uVar3 & 1) != 0) break;
*(int *)((long)pvVar1 + uVar3 * 4 + -4) = iVar4;
uVar3 = uVar3 + 1;
if (param_1 + 1 == uVar3) {
return;
}
}
*(int *)((long)pvVar1 + uVar3 * 4 + -4) = iVar2;
uVar3 = uVar3 + 1;
} while (uVar3 != param_1 + 1);
}
return;
}
|
1,084 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
}
if (original == reversed) {
if (original % 2 == 0) counts[0]++;
else counts[1]++;
}
}
return counts;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2));
free(result);
result = func0(12);
int expected2[] = {4, 6};
assert(issame(result, expected2, 2));
free(result);
result = func0(3);
int expected3[] = {1, 2};
assert(issame(result, expected3, 2));
free(result);
result = func0(63);
int expected4[] = {6, 8};
assert(issame(result, expected4, 2));
free(result);
result = func0(25);
int expected5[] = {5, 6};
assert(issame(result, expected5, 2));
free(result);
result = func0(19);
int expected6[] = {4, 6};
assert(issame(result, expected6, 2));
free(result);
result = func0(9);
int expected7[] = {4, 5};
assert(issame(result, expected7, 2));
free(result);
result = func0(1);
int expected8[] = {0, 1};
assert(issame(result, expected8, 2));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movl $0x0,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
movl $0x0,(%rax)
movl $0x1,-0x18(%rbp)
jmpq 1297 <func0+0xee>
movl $0x0,-0x14(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x10(%rbp)
jmp 125b <func0+0xb2>
mov -0x14(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,%esi
mov -0x10(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
lea (%rsi,%rdx,1),%eax
mov %eax,-0x14(%rbp)
mov -0x10(%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,-0x10(%rbp)
cmpl $0x0,-0x10(%rbp)
jne 11ff <func0+0x56>
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jne 1293 <func0+0xea>
mov -0xc(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1284 <func0+0xdb>
mov -0x8(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
jmp 1293 <func0+0xea>
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 11ea <func0+0x41>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov edi, 8; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov dword ptr [rax], 0
mov rax, [rbp+var_8]
add rax, 4
mov dword ptr [rax], 0
mov [rbp+var_18], 1
jmp loc_1297
loc_11EA:
mov [rbp+var_14], 0
mov eax, [rbp+var_18]
mov [rbp+var_C], eax
mov eax, [rbp+var_18]
mov [rbp+var_10], eax
jmp short loc_125B
loc_11FF:
mov edx, [rbp+var_14]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov esi, eax
mov ecx, [rbp+var_10]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
lea eax, [rsi+rdx]
mov [rbp+var_14], eax
mov eax, [rbp+var_10]
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_10], eax
loc_125B:
cmp [rbp+var_10], 0
jnz short loc_11FF
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jnz short loc_1293
mov eax, [rbp+var_C]
and eax, 1
test eax, eax
jnz short loc_1284
mov rax, [rbp+var_8]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_8]
mov [rax], edx
jmp short loc_1293
loc_1284:
mov rax, [rbp+var_8]
add rax, 4
mov edx, [rax]
add edx, 1
mov [rax], edx
loc_1293:
add [rbp+var_18], 1
loc_1297:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_24]
jle loc_11EA
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(int a1)
{
int i; // [rsp+18h] [rbp-18h]
int v3; // [rsp+1Ch] [rbp-14h]
int j; // [rsp+20h] [rbp-10h]
_DWORD *v5; // [rsp+28h] [rbp-8h]
v5 = malloc(8uLL);
*v5 = 0;
v5[1] = 0;
for ( i = 1; i <= a1; ++i )
{
v3 = 0;
for ( j = i; j; j /= 10 )
v3 = 10 * v3 + j % 10;
if ( i == v3 )
{
if ( (i & 1) != 0 )
++v5[1];
else
++*v5;
}
}
return v5;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV EDI,0x8
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x18],0x1
JMP 0x00101297
LAB_001011ea:
MOV dword ptr [RBP + -0x14],0x0
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0010125b
LAB_001011ff:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV ESI,EAX
MOV ECX,dword ptr [RBP + -0x10]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
LEA EAX,[RSI + RDX*0x1]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x10]
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 + -0x10],EAX
LAB_0010125b:
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x001011ff
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x00101293
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101284
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],EDX
JMP 0x00101293
LAB_00101284:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
MOV EDX,dword ptr [RAX]
ADD EDX,0x1
MOV dword ptr [RAX],EDX
LAB_00101293:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101297:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x001011ea
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int * func0(int param_1)
{
int *piVar1;
uint local_20;
uint local_1c;
uint local_18;
piVar1 = (int *)malloc(8);
*piVar1 = 0;
piVar1[1] = 0;
for (local_20 = 1; (int)local_20 <= param_1; local_20 = local_20 + 1) {
local_1c = 0;
for (local_18 = local_20; local_18 != 0; local_18 = (int)local_18 / 10) {
local_1c = local_1c * 10 + (int)local_18 % 10;
}
if (local_20 == local_1c) {
if ((local_20 & 1) == 0) {
*piVar1 = *piVar1 + 1;
}
else {
piVar1[1] = piVar1[1] + 1;
}
}
}
return piVar1;
}
|
1,085 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
}
if (original == reversed) {
if (original % 2 == 0) counts[0]++;
else counts[1]++;
}
}
return counts;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2));
free(result);
result = func0(12);
int expected2[] = {4, 6};
assert(issame(result, expected2, 2));
free(result);
result = func0(3);
int expected3[] = {1, 2};
assert(issame(result, expected3, 2));
free(result);
result = func0(63);
int expected4[] = {6, 8};
assert(issame(result, expected4, 2));
free(result);
result = func0(25);
int expected5[] = {5, 6};
assert(issame(result, expected5, 2));
free(result);
result = func0(19);
int expected6[] = {4, 6};
assert(issame(result, expected6, 2));
free(result);
result = func0(9);
int expected7[] = {4, 5};
assert(issame(result, expected7, 2));
free(result);
result = func0(1);
int expected8[] = {0, 1};
assert(issame(result, expected8, 2));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
mov $0x8,%edi
callq 10b0 <malloc@plt>
movl $0x0,(%rax)
movl $0x0,0x4(%rax)
test %ebx,%ebx
jle 122d <func0+0x84>
lea 0x1(%rbx),%r9d
mov $0x1,%r8d
mov $0x0,%r10d
jmp 11e9 <func0+0x40>
addl $0x1,(%rax)
add $0x1,%r8d
cmp %r8d,%r9d
je 122d <func0+0x84>
mov %r8d,%ecx
mov %r10d,%esi
test %r8d,%r8d
je 11dd <func0+0x34>
lea (%rsi,%rsi,4),%edi
movslq %ecx,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %ecx,%esi
sar $0x1f,%esi
sub %esi,%edx
lea (%rdx,%rdx,4),%esi
add %esi,%esi
sub %esi,%ecx
lea (%rcx,%rdi,2),%esi
mov %edx,%ecx
test %edx,%edx
jne 11f4 <func0+0x4b>
cmp %r8d,%esi
jne 11e0 <func0+0x37>
test $0x1,%r8b
je 11dd <func0+0x34>
addl $0x1,0x4(%rax)
jmp 11e0 <func0+0x37>
pop %rbx
retq
|
func0:
endbr64
push rbx
mov ebx, edi
mov edi, 8; size
call _malloc
mov r9, rax
mov dword ptr [rax], 0
mov dword ptr [rax+4], 0
test ebx, ebx
jle short loc_122D
lea r8d, [rbx+1]
mov edi, 1
mov r10d, 0
jmp short loc_11EB
loc_11DF:
add dword ptr [r9], 1
loc_11E3:
add edi, 1
cmp r8d, edi
jz short loc_122D
loc_11EB:
mov edx, edi
mov ecx, r10d
test edi, edi
jz short loc_11DF
loc_11F4:
lea esi, [rcx+rcx*4]
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
lea ecx, [rdx+rsi*2]
mov edx, eax
test eax, eax
jnz short loc_11F4
cmp ecx, edi
jnz short loc_11E3
test dil, 1
jz short loc_11DF
add dword ptr [r9+4], 1
jmp short loc_11E3
loc_122D:
mov rax, r9
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *v1; // r9
int v2; // r8d
int i; // edi
int v4; // edx
int v5; // ecx
v1 = malloc(8uLL);
*v1 = 0;
v1[1] = 0;
if ( a1 > 0 )
{
v2 = a1 + 1;
for ( i = 1; v2 != i; ++i )
{
v4 = i;
v5 = 0;
if ( !i )
goto LABEL_3;
do
{
v5 = v4 % 10 + 10 * v5;
v4 /= 10;
}
while ( v4 );
if ( v5 != i )
continue;
if ( (i & 1) != 0 )
++v1[1];
else
LABEL_3:
++*v1;
}
}
return v1;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOV EDI,0x8
CALL 0x001010b0
MOV R9,RAX
MOV dword ptr [RAX],0x0
MOV dword ptr [RAX + 0x4],0x0
TEST EBX,EBX
JLE 0x0010122d
LEA R8D,[RBX + 0x1]
MOV EDI,0x1
MOV R10D,0x0
JMP 0x001011eb
LAB_001011df:
ADD dword ptr [R9],0x1
LAB_001011e3:
ADD EDI,0x1
CMP R8D,EDI
JZ 0x0010122d
LAB_001011eb:
MOV EDX,EDI
MOV ECX,R10D
TEST EDI,EDI
JZ 0x001011df
LAB_001011f4:
LEA ESI,[RCX + RCX*0x4]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
LEA ECX,[RDX + RSI*0x2]
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x001011f4
CMP ECX,EDI
JNZ 0x001011e3
TEST DIL,0x1
JZ 0x001011df
ADD dword ptr [R9 + 0x4],0x1
JMP 0x001011e3
LAB_0010122d:
MOV RAX,R9
POP RBX
RET
|
int * func0(int param_1)
{
uint uVar1;
uint uVar2;
int *piVar3;
uint uVar4;
uint uVar5;
piVar3 = (int *)malloc(8);
*piVar3 = 0;
piVar3[1] = 0;
if (0 < param_1) {
uVar5 = 1;
do {
uVar4 = 0;
uVar2 = uVar5;
if (uVar5 == 0) {
LAB_001011df:
*piVar3 = *piVar3 + 1;
}
else {
do {
uVar1 = (int)uVar2 / 10;
uVar4 = (int)uVar2 % 10 + uVar4 * 10;
uVar2 = uVar1;
} while (uVar1 != 0);
if (uVar4 == uVar5) {
if ((uVar5 & 1) == 0) goto LAB_001011df;
piVar3[1] = piVar3[1] + 1;
}
}
uVar5 = uVar5 + 1;
} while (param_1 + 1U != uVar5);
}
return piVar3;
}
|
1,086 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
}
if (original == reversed) {
if (original % 2 == 0) counts[0]++;
else counts[1]++;
}
}
return counts;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2));
free(result);
result = func0(12);
int expected2[] = {4, 6};
assert(issame(result, expected2, 2));
free(result);
result = func0(3);
int expected3[] = {1, 2};
assert(issame(result, expected3, 2));
free(result);
result = func0(63);
int expected4[] = {6, 8};
assert(issame(result, expected4, 2));
free(result);
result = func0(25);
int expected5[] = {5, 6};
assert(issame(result, expected5, 2));
free(result);
result = func0(19);
int expected6[] = {4, 6};
assert(issame(result, expected6, 2));
free(result);
result = func0(9);
int expected7[] = {4, 5};
assert(issame(result, expected7, 2));
free(result);
result = func0(1);
int expected8[] = {0, 1};
assert(issame(result, expected8, 2));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
mov $0x8,%edi
callq 1090 <malloc@plt>
movq $0x0,(%rax)
test %ebx,%ebx
jle 1413 <func0+0x63>
lea 0x1(%rbx),%r10d
mov $0x1,%r9d
mov $0xcccccccd,%r8d
nopl 0x0(%rax)
mov %r9d,%ecx
xor %esi,%esi
nopl (%rax)
mov %ecx,%edx
lea (%rsi,%rsi,4),%edi
imul %r8,%rdx
shr $0x23,%rdx
lea (%rdx,%rdx,4),%esi
add %esi,%esi
sub %esi,%ecx
lea (%rcx,%rdi,2),%esi
mov %edx,%ecx
test %edx,%edx
jne 13e8 <func0+0x38>
cmp %esi,%r9d
je 1418 <func0+0x68>
add $0x1,%r9d
cmp %r9d,%r10d
jne 13e0 <func0+0x30>
pop %rbx
retq
nopl (%rax)
test $0x1,%r9b
jne 1428 <func0+0x78>
addl $0x1,(%rax)
jmp 140a <func0+0x5a>
nopl 0x0(%rax,%rax,1)
addl $0x1,0x4(%rax)
jmp 140a <func0+0x5a>
xchg %ax,%ax
|
func0:
endbr64
push rbx
mov ebx, edi
mov edi, 8; size
call _malloc
mov qword ptr [rax], 0
test ebx, ebx
jle short loc_141E
lea r9d, [rbx+1]
mov r8d, 1
nop word ptr [rax+rax+00000000h]
loc_13E0:
mov ecx, r8d
xor esi, esi
nop dword ptr [rax]
loc_13E8:
movsxd rdx, ecx
lea edi, [rsi+rsi*4]
mov esi, ecx
imul rdx, 66666667h
sar esi, 1Fh
sar rdx, 22h
sub edx, esi
lea esi, [rdx+rdx*4]
add esi, esi
sub ecx, esi
lea esi, [rcx+rdi*2]
mov ecx, edx
test edx, edx
jnz short loc_13E8
cmp esi, r8d
jz short loc_1420
loc_1415:
add r8d, 1
cmp r8d, r9d
jnz short loc_13E0
loc_141E:
pop rbx
retn
loc_1420:
test r8b, 1
jnz short loc_1430
add dword ptr [rax], 1
jmp short loc_1415
loc_1430:
add dword ptr [rax+4], 1
jmp short loc_1415
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
int v2; // r8d
int v3; // ecx
int v4; // esi
result = malloc(8uLL);
*(_QWORD *)result = 0LL;
if ( a1 > 0 )
{
v2 = 1;
do
{
v3 = v2;
v4 = 0;
do
{
v4 = v3 % 10 + 10 * v4;
v3 /= 10;
}
while ( v3 );
if ( v4 == v2 )
{
if ( (v2 & 1) != 0 )
++result[1];
else
++*result;
}
++v2;
}
while ( v2 != a1 + 1 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOV EDI,0x8
CALL 0x00101090
MOV qword ptr [RAX],0x0
TEST EBX,EBX
JLE 0x0010141e
LEA R9D,[RBX + 0x1]
MOV R8D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013e0:
MOV ECX,R8D
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_001013e8:
MOVSXD RDX,ECX
LEA EDI,[RSI + RSI*0x4]
MOV ESI,ECX
IMUL RDX,RDX,0x66666667
SAR ESI,0x1f
SAR RDX,0x22
SUB EDX,ESI
LEA ESI,[RDX + RDX*0x4]
ADD ESI,ESI
SUB ECX,ESI
LEA ESI,[RCX + RDI*0x2]
MOV ECX,EDX
TEST EDX,EDX
JNZ 0x001013e8
CMP ESI,R8D
JZ 0x00101420
LAB_00101415:
ADD R8D,0x1
CMP R8D,R9D
JNZ 0x001013e0
LAB_0010141e:
POP RBX
RET
LAB_00101420:
TEST R8B,0x1
JNZ 0x00101430
ADD dword ptr [RAX],0x1
JMP 0x00101415
LAB_00101430:
ADD dword ptr [RAX + 0x4],0x1
JMP 0x00101415
|
void func0(int param_1)
{
uint uVar1;
int *piVar2;
uint uVar3;
uint uVar4;
uint uVar5;
piVar2 = (int *)malloc(8);
piVar2[0] = 0;
piVar2[1] = 0;
if (0 < param_1) {
uVar5 = 1;
do {
uVar4 = 0;
uVar3 = uVar5;
do {
uVar1 = (int)uVar3 / 10;
uVar4 = (int)uVar3 % 10 + uVar4 * 10;
uVar3 = uVar1;
} while (uVar1 != 0);
if (uVar4 == uVar5) {
if ((uVar5 & 1) == 0) {
*piVar2 = *piVar2 + 1;
}
else {
piVar2[1] = piVar2[1] + 1;
}
}
uVar5 = uVar5 + 1;
} while (uVar5 != param_1 + 1U);
}
return;
}
|
1,087 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
}
if (original == reversed) {
if (original % 2 == 0) counts[0]++;
else counts[1]++;
}
}
return counts;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2));
free(result);
result = func0(12);
int expected2[] = {4, 6};
assert(issame(result, expected2, 2));
free(result);
result = func0(3);
int expected3[] = {1, 2};
assert(issame(result, expected3, 2));
free(result);
result = func0(63);
int expected4[] = {6, 8};
assert(issame(result, expected4, 2));
free(result);
result = func0(25);
int expected5[] = {5, 6};
assert(issame(result, expected5, 2));
free(result);
result = func0(19);
int expected6[] = {4, 6};
assert(issame(result, expected6, 2));
free(result);
result = func0(9);
int expected7[] = {4, 5};
assert(issame(result, expected7, 2));
free(result);
result = func0(1);
int expected8[] = {0, 1};
assert(issame(result, expected8, 2));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
mov $0x8,%edi
callq 1090 <malloc@plt>
movq $0x0,(%rax)
test %ebx,%ebx
jle 1413 <func0+0x63>
lea 0x1(%rbx),%r10d
mov $0x1,%r9d
mov $0xcccccccd,%r8d
nopl 0x0(%rax)
mov %r9d,%ecx
xor %esi,%esi
nopl (%rax)
mov %ecx,%edx
lea (%rsi,%rsi,4),%edi
imul %r8,%rdx
shr $0x23,%rdx
lea (%rdx,%rdx,4),%esi
add %esi,%esi
sub %esi,%ecx
lea (%rcx,%rdi,2),%esi
mov %edx,%ecx
test %edx,%edx
jne 13e8 <func0+0x38>
cmp %esi,%r9d
je 1418 <func0+0x68>
add $0x1,%r9d
cmp %r10d,%r9d
jne 13e0 <func0+0x30>
pop %rbx
retq
nopl (%rax)
test $0x1,%r9b
jne 1428 <func0+0x78>
addl $0x1,(%rax)
jmp 140a <func0+0x5a>
nopl 0x0(%rax,%rax,1)
addl $0x1,0x4(%rax)
jmp 140a <func0+0x5a>
xchg %ax,%ax
|
func0:
endbr64
push rbx
mov ebx, edi
mov edi, 8; size
call _malloc
mov qword ptr [rax], 0
test ebx, ebx
jle short loc_141E
lea r9d, [rbx+1]
mov r8d, 1
nop word ptr [rax+rax+00000000h]
loc_13E0:
mov ecx, r8d
xor esi, esi
nop dword ptr [rax]
loc_13E8:
movsxd rdx, ecx
lea edi, [rsi+rsi*4]
mov esi, ecx
imul rdx, 66666667h
sar esi, 1Fh
sar rdx, 22h
sub edx, esi
lea esi, [rdx+rdx*4]
add esi, esi
sub ecx, esi
lea esi, [rcx+rdi*2]
mov ecx, edx
test edx, edx
jnz short loc_13E8
cmp esi, r8d
jz short loc_1420
loc_1415:
add r8d, 1
cmp r8d, r9d
jnz short loc_13E0
loc_141E:
pop rbx
retn
loc_1420:
test r8b, 1
jnz short loc_1430
add dword ptr [rax], 1
jmp short loc_1415
loc_1430:
add dword ptr [rax+4], 1
jmp short loc_1415
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
int v2; // r8d
int v3; // ecx
int v4; // esi
result = malloc(8uLL);
*(_QWORD *)result = 0LL;
if ( a1 > 0 )
{
v2 = 1;
do
{
v3 = v2;
v4 = 0;
do
{
v4 = v3 % 10 + 10 * v4;
v3 /= 10;
}
while ( v3 );
if ( v4 == v2 )
{
if ( (v2 & 1) != 0 )
++result[1];
else
++*result;
}
++v2;
}
while ( v2 != a1 + 1 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOV EDI,0x8
CALL 0x00101090
MOV qword ptr [RAX],0x0
TEST EBX,EBX
JLE 0x0010141e
LEA R9D,[RBX + 0x1]
MOV R8D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013e0:
MOV ECX,R8D
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_001013e8:
MOVSXD RDX,ECX
LEA EDI,[RSI + RSI*0x4]
MOV ESI,ECX
IMUL RDX,RDX,0x66666667
SAR ESI,0x1f
SAR RDX,0x22
SUB EDX,ESI
LEA ESI,[RDX + RDX*0x4]
ADD ESI,ESI
SUB ECX,ESI
LEA ESI,[RCX + RDI*0x2]
MOV ECX,EDX
TEST EDX,EDX
JNZ 0x001013e8
CMP ESI,R8D
JZ 0x00101420
LAB_00101415:
ADD R8D,0x1
CMP R8D,R9D
JNZ 0x001013e0
LAB_0010141e:
POP RBX
RET
LAB_00101420:
TEST R8B,0x1
JNZ 0x00101430
ADD dword ptr [RAX],0x1
JMP 0x00101415
LAB_00101430:
ADD dword ptr [RAX + 0x4],0x1
JMP 0x00101415
|
void func0(int param_1)
{
uint uVar1;
int *piVar2;
uint uVar3;
uint uVar4;
uint uVar5;
piVar2 = (int *)malloc(8);
piVar2[0] = 0;
piVar2[1] = 0;
if (0 < param_1) {
uVar5 = 1;
do {
uVar4 = 0;
uVar3 = uVar5;
do {
uVar1 = (int)uVar3 / 10;
uVar4 = (int)uVar3 % 10 + uVar4 * 10;
uVar3 = uVar1;
} while (uVar1 != 0);
if (uVar4 == uVar5) {
if ((uVar5 & 1) == 0) {
*piVar2 = *piVar2 + 1;
}
else {
piVar2[1] = piVar2[1] + 1;
}
}
uVar5 = uVar5 + 1;
} while (uVar5 != param_1 + 1U);
}
return;
}
|
1,088 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
sum -= w;
if (sum > 0) num += 1;
}
}
return num;
}
|
#include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == 4);
assert(func0((const int[]){12, 23, 34, -45, -56, 0}, 6) == 5);
assert(func0((const int[]){-0, 1}, 2) == 1);
assert(func0((const int[]){1}, 1) == 1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 123f <func0+0xd6>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 11ae <func0+0x45>
addl $0x1,-0x10(%rbp)
jmpq 123b <func0+0xd2>
movl $0x0,-0x8(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0x4(%rbp)
sub %eax,-0x4(%rbp)
jmp 1225 <func0+0xbc>
mov -0x4(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
add %edx,-0x8(%rbp)
mov -0x4(%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,-0x4(%rbp)
cmpl $0x9,-0x4(%rbp)
jg 11da <func0+0x71>
mov -0x4(%rbp),%eax
sub %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jle 123b <func0+0xd2>
addl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
mov -0x10(%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_10], 0
mov [rbp+var_C], 0
jmp loc_123C
loc_118B:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_11AE
add [rbp+var_10], 1
jmp loc_1238
loc_11AE:
mov [rbp+var_8], 0
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_4], eax
jmp short loc_1222
loc_11D7:
mov ecx, [rbp+var_4]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
add [rbp+var_8], edx
mov eax, [rbp+var_4]
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_4], eax
loc_1222:
cmp [rbp+var_4], 9
jg short loc_11D7
mov eax, [rbp+var_4]
sub [rbp+var_8], eax
cmp [rbp+var_8], 0
jle short loc_1238
add [rbp+var_10], 1
loc_1238:
add [rbp+var_C], 1
loc_123C:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_118B
mov eax, [rbp+var_10]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-10h]
int i; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) <= 0 )
{
v5 = 0;
for ( j = -*(_DWORD *)(4LL * i + a1); j > 9; j /= 10 )
v5 += j % 10;
if ( v5 - j > 0 )
++v3;
}
else
{
++v3;
}
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010123c
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x001011ae
ADD dword ptr [RBP + -0x10],0x1
JMP 0x00101238
LAB_001011ae:
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101222
LAB_001011d7:
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
ADD dword ptr [RBP + -0x8],EDX
MOV EAX,dword ptr [RBP + -0x4]
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 + -0x4],EAX
LAB_00101222:
CMP dword ptr [RBP + -0x4],0x9
JG 0x001011d7
MOV EAX,dword ptr [RBP + -0x4]
SUB dword ptr [RBP + -0x8],EAX
CMP dword ptr [RBP + -0x8],0x0
JLE 0x00101238
ADD dword ptr [RBP + -0x10],0x1
LAB_00101238:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010123c:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) < 1) {
local_10 = 0;
local_c = *(int *)(param_1 + (long)local_14 * 4);
if (local_c < 1) {
local_c = -local_c;
}
for (; 9 < local_c; local_c = local_c / 10) {
local_10 = local_10 + local_c % 10;
}
if (0 < local_10 - local_c) {
local_18 = local_18 + 1;
}
}
else {
local_18 = local_18 + 1;
}
}
return local_18;
}
|
1,089 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
sum -= w;
if (sum > 0) num += 1;
}
}
return num;
}
|
#include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == 4);
assert(func0((const int[]){12, 23, 34, -45, -56, 0}, 6) == 5);
assert(func0((const int[]){-0, 1}, 2) == 1);
assert(func0((const int[]){1}, 1) == 1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11e3 <func0+0x7a>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%edi
jmp 11d7 <func0+0x6e>
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
sub %eax,%edx
cmp $0x9,%edx
jle 11ce <func0+0x65>
mov $0x0,%esi
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
mov %edx,%r10d
sub %ecx,%r10d
add %r10d,%esi
mov %edx,%ecx
mov %eax,%edx
cmp $0x63,%ecx
jg 1196 <func0+0x2d>
sub %eax,%esi
test %esi,%esi
setg %al
movzbl %al,%eax
add %eax,%edi
add $0x4,%r8
cmp %r9,%r8
je 11e8 <func0+0x7f>
mov (%r8),%edx
test %edx,%edx
jle 1183 <func0+0x1a>
add $0x1,%edi
jmp 11ce <func0+0x65>
mov $0x0,%edi
mov %edi,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_11DE
mov r8, rdi
movsxd rsi, esi
lea r10, [rdi+rsi*4]
mov r9d, 0
jmp short loc_11D1
loc_1183:
mov edx, eax
neg edx
cmovs edx, eax
cmp edx, 9
jle short loc_11C8
mov esi, 0
loc_1194:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
mov edi, edx
sub edi, ecx
add esi, edi
mov ecx, edx
mov edx, eax
cmp ecx, 63h ; 'c'
jg short loc_1194
cmp esi, eax
setnle al
movzx eax, al
add r9d, eax
loc_11C8:
add r8, 4
cmp r8, r10
jz short loc_11E4
loc_11D1:
mov eax, [r8]
test eax, eax
jle short loc_1183
add r9d, 1
jmp short loc_11C8
loc_11DE:
mov r9d, 0
loc_11E4:
mov eax, r9d
retn
|
long long func0(int *a1, int a2)
{
int *v2; // r8
int *v3; // r10
unsigned int v4; // r9d
int v5; // edx
int v6; // esi
int v7; // eax
int v8; // ecx
int v9; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
v9 = *v2;
if ( *v2 <= 0 )
{
v5 = -v9;
if ( -v9 > 9 )
{
v6 = 0;
do
{
v7 = v5 / 10;
v6 += v5 % 10;
v8 = v5;
v5 /= 10;
}
while ( v8 > 99 );
v4 += v6 > v7;
}
}
else
{
++v4;
}
++v2;
}
while ( v2 != v3 );
}
return v4;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011de
MOV R8,RDI
MOVSXD RSI,ESI
LEA R10,[RDI + RSI*0x4]
MOV R9D,0x0
JMP 0x001011d1
LAB_00101183:
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
CMP EDX,0x9
JLE 0x001011c8
MOV ESI,0x0
LAB_00101194:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
MOV EDI,EDX
SUB EDI,ECX
ADD ESI,EDI
MOV ECX,EDX
MOV EDX,EAX
CMP ECX,0x63
JG 0x00101194
CMP ESI,EAX
SETG AL
MOVZX EAX,AL
ADD R9D,EAX
LAB_001011c8:
ADD R8,0x4
CMP R8,R10
JZ 0x001011e4
LAB_001011d1:
MOV EAX,dword ptr [R8]
TEST EAX,EAX
JLE 0x00101183
ADD R9D,0x1
JMP 0x001011c8
LAB_001011de:
MOV R9D,0x0
LAB_001011e4:
MOV EAX,R9D
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
bool bVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar6 = 0;
do {
iVar5 = *param_1;
if (iVar5 < 1) {
iVar3 = -iVar5;
if (0 < iVar5) {
iVar3 = iVar5;
}
if (9 < iVar3) {
iVar5 = 0;
do {
iVar4 = iVar3 / 10;
iVar5 = iVar5 + iVar3 % 10;
bVar2 = 99 < iVar3;
iVar3 = iVar4;
} while (bVar2);
iVar6 = iVar6 + (uint)(iVar4 < iVar5);
}
}
else {
iVar6 = iVar6 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar6;
}
|
1,090 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
sum -= w;
if (sum > 0) num += 1;
}
}
return num;
}
|
#include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == 4);
assert(func0((const int[]){12, 23, 34, -45, -56, 0}, 6) == 5);
assert(func0((const int[]){-0, 1}, 2) == 1);
assert(func0((const int[]){1}, 1) == 1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 149a <func0+0x7a>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%r9d
lea 0x4(%rdi,%rax,4),%r10
jmp 144d <func0+0x2d>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
add $0x4,%rdi
cmp %r10,%rdi
je 1496 <func0+0x76>
mov (%rdi),%eax
test %eax,%eax
jg 1440 <func0+0x20>
mov %eax,%edx
neg %edx
cmp $0xfffffff7,%eax
jge 1444 <func0+0x24>
xor %esi,%esi
xchg %ax,%ax
mov %edx,%eax
mov %edx,%r11d
imul %r9,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r11d
mov %edx,%ecx
mov %eax,%edx
add %r11d,%esi
cmp $0x63,%ecx
jg 1460 <func0+0x40>
sub %eax,%esi
xor %eax,%eax
test %esi,%esi
setg %al
add $0x4,%rdi
add %eax,%r8d
cmp %r10,%rdi
jne 144d <func0+0x2d>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1448
movsxd rsi, esi
xor r9d, r9d
mov r10d, 0CCCCCCCDh
lea r11, [rdi+rsi*4]
jmp short loc_13FD
loc_13F0:
add r9d, 1
loc_13F4:
add rdi, 4
cmp rdi, r11
jz short loc_1444
loc_13FD:
mov eax, [rdi]
test eax, eax
jg short loc_13F0
mov edx, eax
neg edx
cmp eax, 0FFFFFFF7h
jge short loc_13F4
xor esi, esi
xchg ax, ax
loc_1410:
mov eax, edx
mov r8d, edx
imul rax, r10
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub r8d, ecx
mov ecx, edx
mov edx, eax
add esi, r8d
cmp ecx, 63h ; 'c'
jg short loc_1410
xor eax, eax
cmp esi, edx
setnle al
add rdi, 4
add r9d, eax
cmp rdi, r11
jnz short loc_13FD
loc_1444:
mov eax, r9d
retn
loc_1448:
xor r9d, r9d
mov eax, r9d
retn
|
long long func0(int *a1, int a2)
{
unsigned int v2; // r9d
int *v3; // r11
int v4; // eax
unsigned int v5; // edx
int v6; // esi
unsigned int v7; // r8d
int v8; // ecx
if ( a2 > 0 )
{
v2 = 0;
v3 = &a1[a2];
while ( 1 )
{
while ( 1 )
{
v4 = *a1;
if ( *a1 <= 0 )
break;
++v2;
LABEL_4:
if ( ++a1 == v3 )
return v2;
}
v5 = -v4;
if ( v4 >= -9 )
goto LABEL_4;
v6 = 0;
do
{
v7 = v5 % 0xA;
v8 = v5;
v5 /= 0xAu;
v6 += v7;
}
while ( v8 > 99 );
++a1;
v2 += v6 > (int)v5;
if ( a1 == v3 )
return v2;
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101448
MOVSXD RSI,ESI
XOR R9D,R9D
MOV R10D,0xcccccccd
LEA R11,[RDI + RSI*0x4]
JMP 0x001013fd
LAB_001013f0:
ADD R9D,0x1
LAB_001013f4:
ADD RDI,0x4
CMP RDI,R11
JZ 0x00101444
LAB_001013fd:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JG 0x001013f0
MOV EDX,EAX
NEG EDX
CMP EAX,-0x9
JGE 0x001013f4
XOR ESI,ESI
NOP
LAB_00101410:
MOV EAX,EDX
MOV R8D,EDX
IMUL RAX,R10
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB R8D,ECX
MOV ECX,EDX
MOV EDX,EAX
ADD ESI,R8D
CMP ECX,0x63
JG 0x00101410
XOR EAX,EAX
CMP ESI,EDX
SETG AL
ADD RDI,0x4
ADD R9D,EAX
CMP RDI,R11
JNZ 0x001013fd
LAB_00101444:
MOV EAX,R9D
RET
LAB_00101448:
XOR R9D,R9D
MOV EAX,R9D
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
uint uVar4;
uint uVar5;
int iVar6;
int iVar7;
if (0 < param_2) {
iVar7 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
if (iVar2 < 1) {
if (iVar2 < -9) {
iVar6 = 0;
uVar5 = -iVar2;
do {
uVar4 = uVar5 / 10;
iVar6 = iVar6 + uVar5 % 10;
bVar3 = 99 < (int)uVar5;
uVar5 = uVar4;
} while (bVar3);
iVar7 = iVar7 + (uint)((int)uVar4 < iVar6);
}
}
else {
iVar7 = iVar7 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar7;
}
return 0;
}
|
1,091 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
sum -= w;
if (sum > 0) num += 1;
}
}
return num;
}
|
#include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == 4);
assert(func0((const int[]){12, 23, 34, -45, -56, 0}, 6) == 5);
assert(func0((const int[]){-0, 1}, 2) == 1);
assert(func0((const int[]){1}, 1) == 1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 145a <func0+0x7a>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%r9d
lea 0x4(%rdi,%rax,4),%r10
jmp 140d <func0+0x2d>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
add $0x4,%rdi
cmp %rdi,%r10
je 1456 <func0+0x76>
mov (%rdi),%eax
test %eax,%eax
jg 1400 <func0+0x20>
mov %eax,%edx
neg %edx
cmp $0xfffffff7,%eax
jge 1404 <func0+0x24>
xor %esi,%esi
xchg %ax,%ax
mov %edx,%eax
mov %edx,%r11d
imul %r9,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r11d
mov %edx,%ecx
mov %eax,%edx
add %r11d,%esi
cmp $0x63,%ecx
jg 1420 <func0+0x40>
sub %eax,%esi
xor %eax,%eax
test %esi,%esi
setg %al
add $0x4,%rdi
add %eax,%r8d
cmp %rdi,%r10
jne 140d <func0+0x2d>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1448
movsxd rsi, esi
xor r9d, r9d
mov r10d, 0CCCCCCCDh
lea r11, [rdi+rsi*4]
jmp short loc_13FD
loc_13F0:
add r9d, 1
loc_13F4:
add rdi, 4
cmp r11, rdi
jz short loc_1444
loc_13FD:
mov eax, [rdi]
test eax, eax
jg short loc_13F0
mov edx, eax
neg edx
cmp eax, 0FFFFFFF7h
jge short loc_13F4
xor esi, esi
xchg ax, ax
loc_1410:
mov eax, edx
mov r8d, edx
imul rax, r10
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub r8d, ecx
mov ecx, edx
mov edx, eax
add esi, r8d
cmp ecx, 63h ; 'c'
jg short loc_1410
xor eax, eax
cmp esi, edx
setnle al
add rdi, 4
add r9d, eax
cmp r11, rdi
jnz short loc_13FD
loc_1444:
mov eax, r9d
retn
loc_1448:
xor r9d, r9d
mov eax, r9d
retn
|
long long func0(int *a1, int a2)
{
unsigned int v2; // r9d
int *v3; // r11
int v4; // eax
unsigned int v5; // edx
int v6; // esi
unsigned int v7; // r8d
int v8; // ecx
if ( a2 > 0 )
{
v2 = 0;
v3 = &a1[a2];
while ( 1 )
{
while ( 1 )
{
v4 = *a1;
if ( *a1 <= 0 )
break;
++v2;
LABEL_4:
if ( v3 == ++a1 )
return v2;
}
v5 = -v4;
if ( v4 >= -9 )
goto LABEL_4;
v6 = 0;
do
{
v7 = v5 % 0xA;
v8 = v5;
v5 /= 0xAu;
v6 += v7;
}
while ( v8 > 99 );
++a1;
v2 += v6 > (int)v5;
if ( v3 == a1 )
return v2;
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101448
MOVSXD RSI,ESI
XOR R9D,R9D
MOV R10D,0xcccccccd
LEA R11,[RDI + RSI*0x4]
JMP 0x001013fd
LAB_001013f0:
ADD R9D,0x1
LAB_001013f4:
ADD RDI,0x4
CMP R11,RDI
JZ 0x00101444
LAB_001013fd:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JG 0x001013f0
MOV EDX,EAX
NEG EDX
CMP EAX,-0x9
JGE 0x001013f4
XOR ESI,ESI
NOP
LAB_00101410:
MOV EAX,EDX
MOV R8D,EDX
IMUL RAX,R10
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB R8D,ECX
MOV ECX,EDX
MOV EDX,EAX
ADD ESI,R8D
CMP ECX,0x63
JG 0x00101410
XOR EAX,EAX
CMP ESI,EDX
SETG AL
ADD RDI,0x4
ADD R9D,EAX
CMP R11,RDI
JNZ 0x001013fd
LAB_00101444:
MOV EAX,R9D
RET
LAB_00101448:
XOR R9D,R9D
MOV EAX,R9D
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
uint uVar4;
uint uVar5;
int iVar6;
int iVar7;
if (0 < param_2) {
iVar7 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
if (iVar2 < 1) {
if (iVar2 < -9) {
iVar6 = 0;
uVar5 = -iVar2;
do {
uVar4 = uVar5 / 10;
iVar6 = iVar6 + uVar5 % 10;
bVar3 = 99 < (int)uVar5;
uVar5 = uVar4;
} while (bVar3);
iVar7 = iVar7 + (uint)((int)uVar4 < iVar6);
}
}
else {
iVar7 = iVar7 + 1;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
return iVar7;
}
return 0;
}
|
1,092 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *arr, int size) {
int num = 0;
if (size == 0) return true;
for (int i = 1; i < size; i++)
if (arr[i] < arr[i - 1]) num += 1;
if (arr[size - 1] > arr[0]) num += 1;
if (num < 2) return true;
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0((const int[]){3, 4, 5, 1, 2}, 5) == true);
assert(func0((const int[]){3, 5, 10, 1, 2}, 5) == true);
assert(func0((const int[]){4, 3, 1, 2}, 4) == false);
assert(func0((const int[]){3, 5, 4, 1, 2}, 5) == false);
assert(func0((const int[]){}, 0) == true);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 118c <func0+0x23>
mov $0x1,%eax
jmp 120b <func0+0xa2>
movl $0x1,-0x4(%rbp)
jmp 11cd <func0+0x64>
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 11c9 <func0+0x60>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1195 <func0+0x2c>
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov (%rax),%eax
cmp %eax,%edx
jle 11f9 <func0+0x90>
addl $0x1,-0x8(%rbp)
cmpl $0x1,-0x8(%rbp)
jg 1206 <func0+0x9d>
mov $0x1,%eax
jmp 120b <func0+0xa2>
mov $0x0,%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
cmp [rbp+var_1C], 0
jnz short loc_118C
mov eax, 1
jmp short loc_120B
loc_118C:
mov [rbp+var_4], 1
jmp short loc_11CD
loc_1195:
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_11C9
add [rbp+var_8], 1
loc_11C9:
add [rbp+var_4], 1
loc_11CD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1195
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_18]
mov eax, [rax]
cmp edx, eax
jle short loc_11F9
add [rbp+var_8], 1
loc_11F9:
cmp [rbp+var_8], 1
jg short loc_1206
mov eax, 1
jmp short loc_120B
loc_1206:
mov eax, 0
loc_120B:
pop rbp
retn
|
_BOOL8 func0(_DWORD *a1, int a2)
{
int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
if ( !a2 )
return 1LL;
for ( i = 1; i < a2; ++i )
{
if ( a1[i] < a1[i - 1] )
++v3;
}
if ( a1[a2 - 1] > *a1 )
++v3;
return v3 <= 1;
}
|
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
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x0010118c
MOV EAX,0x1
JMP 0x0010120b
LAB_0010118c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011cd
LAB_00101195:
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 0x001011c9
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011cd:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101195
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001011f9
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f9:
CMP dword ptr [RBP + -0x8],0x1
JG 0x00101206
MOV EAX,0x1
JMP 0x0010120b
LAB_00101206:
MOV EAX,0x0
LAB_0010120b:
POP RBP
RET
|
int8 func0(int *param_1,int param_2)
{
int8 uVar1;
int local_10;
int local_c;
local_10 = 0;
if (param_2 == 0) {
uVar1 = 1;
}
else {
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (param_1[local_c] < param_1[(long)local_c + -1]) {
local_10 = local_10 + 1;
}
}
if (*param_1 < param_1[(long)param_2 + -1]) {
local_10 = local_10 + 1;
}
if (local_10 < 2) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
}
return uVar1;
}
|
1,093 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *arr, int size) {
int num = 0;
if (size == 0) return true;
for (int i = 1; i < size; i++)
if (arr[i] < arr[i - 1]) num += 1;
if (arr[size - 1] > arr[0]) num += 1;
if (num < 2) return true;
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0((const int[]){3, 4, 5, 1, 2}, 5) == true);
assert(func0((const int[]){3, 5, 10, 1, 2}, 5) == true);
assert(func0((const int[]){4, 3, 1, 2}, 4) == false);
assert(func0((const int[]){3, 5, 4, 1, 2}, 5) == false);
assert(func0((const int[]){}, 0) == true);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov $0x1,%eax
test %esi,%esi
je 11b8 <func0+0x4f>
cmp $0x1,%esi
jle 11b9 <func0+0x50>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%r8
mov $0x0,%edx
mov (%rax),%ecx
cmp %ecx,0x4(%rax)
setl %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %r8,%rax
jne 118b <func0+0x22>
movslq %esi,%rsi
mov (%rdi),%eax
cmp %eax,-0x4(%rdi,%rsi,4)
setg %al
movzbl %al,%eax
add %eax,%edx
cmp $0x1,%edx
setle %al
retq
mov $0x0,%edx
jmp 11a1 <func0+0x38>
|
func0:
endbr64
mov eax, 1
test esi, esi
jz short locret_11B8
cmp esi, 1
jle short loc_11B9
mov rax, rdi
lea edx, [rsi-2]
lea r8, [rdi+rdx*4+4]
mov edx, 0
loc_118B:
mov ecx, [rax]
cmp [rax+4], ecx
setl cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, r8
jnz short loc_118B
loc_11A1:
movsxd rsi, esi
mov eax, [rdi]
cmp [rdi+rsi*4-4], eax
setnle al
movzx eax, al
add edx, eax
cmp edx, 1
setle al
locret_11B8:
retn
loc_11B9:
mov edx, 0
jmp short loc_11A1
|
bool func0(_DWORD *a1, int a2)
{
bool result; // al
_DWORD *v3; // rax
int v4; // edx
result = 1;
if ( a2 )
{
if ( a2 <= 1 )
{
v4 = 0;
}
else
{
v3 = a1;
v4 = 0;
do
{
v4 += v3[1] < *v3;
++v3;
}
while ( v3 != &a1[a2 - 2 + 1] );
}
return (a1[a2 - 1] > *a1) + v4 <= 1;
}
return result;
}
|
func0:
ENDBR64
MOV EAX,0x1
TEST ESI,ESI
JZ 0x001011b8
CMP ESI,0x1
JLE 0x001011b9
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA R8,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_0010118b:
MOV ECX,dword ptr [RAX]
CMP dword ptr [RAX + 0x4],ECX
SETL CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x0010118b
LAB_001011a1:
MOVSXD RSI,ESI
MOV EAX,dword ptr [RDI]
CMP dword ptr [RDI + RSI*0x4 + -0x4],EAX
SETG AL
MOVZX EAX,AL
ADD EDX,EAX
CMP EDX,0x1
SETLE AL
LAB_001011b8:
RET
LAB_001011b9:
MOV EDX,0x0
JMP 0x001011a1
|
bool func0(int *param_1,int param_2)
{
bool bVar1;
int *piVar2;
int iVar3;
bVar1 = true;
if (param_2 != 0) {
if (param_2 < 2) {
iVar3 = 0;
}
else {
iVar3 = 0;
piVar2 = param_1;
do {
iVar3 = iVar3 + (uint)(piVar2[1] < *piVar2);
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 1);
}
bVar1 = (int)(iVar3 + (uint)(*param_1 < param_1[(long)param_2 + -1])) < 2;
}
return bVar1;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.