index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
794 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *l, int size, int *out_size) {
int *out = malloc(size * sizeof(int));
int found, out_count = 0, i, j;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < out_count; j++) {
if (l[i] == out[j]) {
found = 1;
break;
}
}
if (!found) {
out[out_count++] = l[i];
}
}
for (i = 0; i < out_count - 1; i++) {
for (j = i + 1; j < out_count; j++) {
if (out[i] > out[j]) {
int temp = out[i];
out[i] = out[j];
out[j] = temp;
}
}
}
*out_size = out_count;
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int main() {
int test_array[] = {5, 3, 5, 2, 3, 3, 9, 0, 123};
int expected_array[] = {0, 2, 3, 5, 9, 123};
int unique_size;
int *unique_array = func0(test_array, sizeof(test_array) / sizeof(test_array[0]), &unique_size);
assert(unique_size == sizeof(expected_array) / sizeof(expected_array[0]));
for (int i = 0; i < unique_size; i++) {
assert(unique_array[i] == expected_array[i]);
}
free(unique_array);
printf("All tests passed!\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %r12d,%r12d
jle 13c9 <func0+0xd9>
lea -0x1(%r12),%edx
mov %rbx,%r8
lea 0x4(%rax),%r11
xor %r9d,%r9d
lea 0x4(%rbx,%rdx,4),%r10
nopw 0x0(%rax,%rax,1)
mov (%r8),%esi
test %r9d,%r9d
je 13b0 <func0+0xc0>
lea -0x1(%r9),%edx
mov %rax,%rcx
lea (%r11,%rdx,4),%rdi
jmp 1351 <func0+0x61>
nopl (%rax)
add $0x4,%rcx
cmp %rdi,%rcx
je 13b0 <func0+0xc0>
cmp %esi,(%rcx)
jne 1348 <func0+0x58>
add $0x4,%r8
cmp %r10,%r8
jne 1330 <func0+0x40>
cmp $0x1,%r9d
je 13a6 <func0+0xb6>
lea -0x2(%r9),%edx
mov %rax,%r8
mov $0x1,%r10d
add $0x2,%rdx
nopl (%rax)
mov %r10,%rcx
cmp %r10d,%r9d
jle 1399 <func0+0xa9>
mov (%r8),%esi
mov (%rax,%rcx,4),%edi
cmp %edi,%esi
jle 1390 <func0+0xa0>
mov %edi,(%r8)
mov %esi,(%rax,%rcx,4)
add $0x1,%rcx
cmp %ecx,%r9d
jg 1380 <func0+0x90>
add $0x1,%r10
add $0x4,%r8
cmp %rdx,%r10
jne 1378 <func0+0x88>
pop %rbx
mov %r9d,0x0(%rbp)
pop %rbp
pop %r12
retq
movslq %r9d,%rdx
add $0x4,%r8
add $0x1,%r9d
mov %esi,(%rax,%rdx,4)
cmp %r10,%r8
jne 1330 <func0+0x40>
jmp 135e <func0+0x6e>
xor %r9d,%r9d
pop %rbx
mov %r9d,0x0(%rbp)
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
movsxd rdi, esi
lea r12, ds:0[rdi*4]
mov r13, rdi
mov rdi, r12; size
sub rsp, 8
call _malloc
mov r10, rax
test r13d, r13d
jle loc_13C6
mov rsi, rbx
lea rdi, [rbx+r12]
xor r9d, r9d
loc_1310:
movsxd r8, r9d
mov edx, [rsi]
lea rcx, [r10+r8*4]
test r9d, r9d
jle short loc_1348
loc_131E:
mov rax, r10
jmp short loc_1331
loc_1328:
add rax, 4
cmp rax, rcx
jz short loc_1348
loc_1331:
cmp [rax], edx
jnz short loc_1328
add rsi, 4
cmp rsi, rdi
jz short loc_1359
mov edx, [rsi]
jmp short loc_131E
loc_1348:
add rsi, 4
mov [r10+r8*4], edx
add r9d, 1
cmp rsi, rdi
jnz short loc_1310
loc_1359:
cmp r9d, 1
jle short loc_13B4
lea rsi, [r10+4]
mov r11d, r9d
mov r8d, 1
lea r12d, [r9-1]
lea rbx, [r10+8]
nop dword ptr [rax+00h]
loc_1378:
cmp r9d, r8d
jle short loc_13A7
mov eax, r12d
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [rbx+rax*4]
mov rax, rsi
nop
loc_1390:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_139E
mov [rsi-4], ecx
mov [rax], edx
loc_139E:
add rax, 4
cmp rax, rdi
jnz short loc_1390
loc_13A7:
add r8, 1
add rsi, 4
cmp r8, r11
jnz short loc_1378
loc_13B4:
mov [rbp+0], r9d
add rsp, 8
mov rax, r10
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13C6:
xor r9d, r9d
jmp short loc_13B4
|
_DWORD * func0(int *a1, int a2, int *a3)
{
size_t v4; // r12
_DWORD *v5; // r10
int *v6; // rsi
int *v7; // rdi
int v8; // r9d
int v9; // edx
_DWORD *v10; // rax
_DWORD *v11; // rsi
long long i; // r8
_DWORD *v13; // rax
int v14; // edx
v4 = a2;
v5 = malloc(v4 * 4);
if ( a2 <= 0 )
{
v8 = 0;
}
else
{
v6 = a1;
v7 = &a1[v4];
v8 = 0;
while ( 1 )
{
v9 = *v6;
if ( v8 > 0 )
break;
LABEL_9:
++v6;
v5[v8++] = v9;
if ( v6 == v7 )
goto LABEL_10;
}
while ( 1 )
{
v10 = v5;
while ( *v10 != v9 )
{
if ( ++v10 == &v5[v8] )
goto LABEL_9;
}
if ( ++v6 == v7 )
break;
v9 = *v6;
}
LABEL_10:
if ( v8 > 1 )
{
v11 = v5 + 1;
for ( i = 1LL; i != v8; ++i )
{
if ( v8 > (int)i )
{
v13 = v11;
do
{
v14 = *(v11 - 1);
if ( v14 > *v13 )
{
*(v11 - 1) = *v13;
*v13 = v14;
}
++v13;
}
while ( v13 != &v5[i + 1 + (unsigned int)(v8 - 1 - i)] );
}
++v11;
}
}
}
*a3 = v8;
return v5;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA R12,[RDI*0x4]
MOV R13,RDI
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010d0
MOV R10,RAX
TEST R13D,R13D
JLE 0x001013c6
MOV RSI,RBX
LEA RDI,[RBX + R12*0x1]
XOR R9D,R9D
LAB_00101310:
MOVSXD R8,R9D
MOV EDX,dword ptr [RSI]
LEA RCX,[R10 + R8*0x4]
TEST R9D,R9D
JLE 0x00101348
LAB_0010131e:
MOV RAX,R10
JMP 0x00101331
LAB_00101328:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101348
LAB_00101331:
CMP dword ptr [RAX],EDX
JNZ 0x00101328
ADD RSI,0x4
CMP RSI,RDI
JZ 0x00101359
MOV EDX,dword ptr [RSI]
JMP 0x0010131e
LAB_00101348:
ADD RSI,0x4
MOV dword ptr [R10 + R8*0x4],EDX
ADD R9D,0x1
CMP RSI,RDI
JNZ 0x00101310
LAB_00101359:
CMP R9D,0x1
JLE 0x001013b4
LEA RSI,[R10 + 0x4]
MOV R11D,R9D
MOV R8D,0x1
LEA R12D,[R9 + -0x1]
LEA RBX,[R10 + 0x8]
NOP dword ptr [RAX]
LAB_00101378:
CMP R9D,R8D
JLE 0x001013a7
MOV EAX,R12D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[RBX + RAX*0x4]
MOV RAX,RSI
NOP
LAB_00101390:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x0010139e
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_0010139e:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101390
LAB_001013a7:
ADD R8,0x1
ADD RSI,0x4
CMP R8,R11
JNZ 0x00101378
LAB_001013b4:
MOV dword ptr [RBP],R9D
ADD RSP,0x8
MOV RAX,R10
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013c6:
XOR R9D,R9D
JMP 0x001013b4
|
int * func0(int *param_1,int param_2,uint *param_3)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
ulong uVar5;
uint uVar6;
piVar2 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
uVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
uVar6 = 0;
do {
iVar4 = *param_1;
piVar3 = piVar2;
if (0 < (int)uVar6) {
do {
while (*piVar3 == iVar4) {
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_00101359;
piVar3 = piVar2;
iVar4 = *param_1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != piVar2 + (int)uVar6);
}
param_1 = param_1 + 1;
piVar2[(int)uVar6] = iVar4;
uVar6 = uVar6 + 1;
} while (param_1 != piVar1);
LAB_00101359:
if (1 < (int)uVar6) {
uVar5 = 1;
piVar1 = piVar2;
do {
if ((int)uVar5 < (int)uVar6) {
piVar3 = piVar1 + 1;
do {
iVar4 = *piVar1;
if (*piVar3 < iVar4) {
*piVar1 = *piVar3;
*piVar3 = iVar4;
}
piVar3 = piVar3 + 1;
} while (piVar3 != piVar2 + uVar5 + ((uVar6 - 1) - (int)uVar5) + 1);
}
uVar5 = uVar5 + 1;
piVar1 = piVar1 + 1;
} while (uVar5 != uVar6);
}
}
*param_3 = uVar6;
return piVar2;
}
|
795 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *l, int size, int *out_size) {
int *out = malloc(size * sizeof(int));
int found, out_count = 0, i, j;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < out_count; j++) {
if (l[i] == out[j]) {
found = 1;
break;
}
}
if (!found) {
out[out_count++] = l[i];
}
}
for (i = 0; i < out_count - 1; i++) {
for (j = i + 1; j < out_count; j++) {
if (out[i] > out[j]) {
int temp = out[i];
out[i] = out[j];
out[j] = temp;
}
}
}
*out_size = out_count;
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int main() {
int test_array[] = {5, 3, 5, 2, 3, 3, 9, 0, 123};
int expected_array[] = {0, 2, 3, 5, 9, 123};
int unique_size;
int *unique_array = func0(test_array, sizeof(test_array) / sizeof(test_array[0]), &unique_size);
assert(unique_size == sizeof(expected_array) / sizeof(expected_array[0]));
for (int i = 0; i < unique_size; i++) {
assert(unique_array[i] == expected_array[i]);
}
free(unique_array);
printf("All tests passed!\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %r12d,%r12d
jle 13a9 <func0+0xd9>
lea -0x1(%r12),%edx
mov %rbx,%r8
lea 0x4(%rax),%r11
xor %r9d,%r9d
lea 0x4(%rbx,%rdx,4),%r10
nopw 0x0(%rax,%rax,1)
mov (%r8),%esi
test %r9d,%r9d
je 1390 <func0+0xc0>
lea -0x1(%r9),%edx
mov %rax,%rcx
lea (%r11,%rdx,4),%rdi
jmp 1331 <func0+0x61>
nopl (%rax)
add $0x4,%rcx
cmp %rcx,%rdi
je 1390 <func0+0xc0>
cmp %esi,(%rcx)
jne 1328 <func0+0x58>
add $0x4,%r8
cmp %r10,%r8
jne 1310 <func0+0x40>
cmp $0x1,%r9d
je 1386 <func0+0xb6>
lea -0x2(%r9),%edx
mov %rax,%r8
mov $0x1,%r10d
add $0x2,%rdx
nopl (%rax)
mov %r10,%rcx
cmp %r10d,%r9d
jle 1379 <func0+0xa9>
mov (%r8),%esi
mov (%rax,%rcx,4),%edi
cmp %edi,%esi
jle 1370 <func0+0xa0>
mov %edi,(%r8)
mov %esi,(%rax,%rcx,4)
add $0x1,%rcx
cmp %ecx,%r9d
jg 1360 <func0+0x90>
add $0x1,%r10
add $0x4,%r8
cmp %r10,%rdx
jne 1358 <func0+0x88>
pop %rbx
mov %r9d,0x0(%rbp)
pop %rbp
pop %r12
retq
movslq %r9d,%rdx
add $0x4,%r8
add $0x1,%r9d
mov %esi,(%rax,%rdx,4)
cmp %r10,%r8
jne 1310 <func0+0x40>
jmp 133e <func0+0x6e>
xor %r9d,%r9d
pop %rbx
mov %r9d,0x0(%rbp)
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
movsxd rdi, esi
lea r12, ds:0[rdi*4]
mov r13, rdi
mov rdi, r12; size
sub rsp, 8
call _malloc
mov r10, rax
test r13d, r13d
jle loc_13B6
mov rsi, rbx
lea rdi, [rbx+r12]
xor r9d, r9d
loc_1300:
movsxd r8, r9d
mov edx, [rsi]
lea rcx, [r10+r8*4]
test r9d, r9d
jle short loc_1338
loc_130E:
mov rax, r10
jmp short loc_1321
loc_1318:
add rax, 4
cmp rax, rcx
jz short loc_1338
loc_1321:
cmp [rax], edx
jnz short loc_1318
add rsi, 4
cmp rsi, rdi
jz short loc_1349
mov edx, [rsi]
jmp short loc_130E
loc_1338:
add rsi, 4
mov [r10+r8*4], edx
add r9d, 1
cmp rsi, rdi
jnz short loc_1300
loc_1349:
cmp r9d, 1
jle short loc_13A4
lea rsi, [r10+4]
mov r11d, r9d
mov r8d, 1
lea r12d, [r9-1]
lea rbx, [r10+8]
nop dword ptr [rax+00h]
loc_1368:
cmp r9d, r8d
jle short loc_1397
mov eax, r12d
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [rbx+rax*4]
mov rax, rsi
nop
loc_1380:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_138E
mov [rsi-4], ecx
mov [rax], edx
loc_138E:
add rax, 4
cmp rdi, rax
jnz short loc_1380
loc_1397:
add r8, 1
add rsi, 4
cmp r8, r11
jnz short loc_1368
loc_13A4:
mov [rbp+0], r9d
add rsp, 8
mov rax, r10
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13B6:
xor r9d, r9d
jmp short loc_13A4
|
_DWORD * func0(int *a1, int a2, int *a3)
{
size_t v4; // r12
_DWORD *v5; // r10
int *v6; // rsi
int *v7; // rdi
int v8; // r9d
int v9; // edx
_DWORD *v10; // rax
_DWORD *v11; // rsi
long long i; // r8
_DWORD *v13; // rax
int v14; // edx
v4 = a2;
v5 = malloc(v4 * 4);
if ( a2 <= 0 )
{
v8 = 0;
}
else
{
v6 = a1;
v7 = &a1[v4];
v8 = 0;
while ( 1 )
{
v9 = *v6;
if ( v8 > 0 )
break;
LABEL_9:
++v6;
v5[v8++] = v9;
if ( v6 == v7 )
goto LABEL_10;
}
while ( 1 )
{
v10 = v5;
while ( *v10 != v9 )
{
if ( ++v10 == &v5[v8] )
goto LABEL_9;
}
if ( ++v6 == v7 )
break;
v9 = *v6;
}
LABEL_10:
if ( v8 > 1 )
{
v11 = v5 + 1;
for ( i = 1LL; i != v8; ++i )
{
if ( v8 > (int)i )
{
v13 = v11;
do
{
v14 = *(v11 - 1);
if ( v14 > *v13 )
{
*(v11 - 1) = *v13;
*v13 = v14;
}
++v13;
}
while ( &v5[i + 1 + (unsigned int)(v8 - 1 - i)] != v13 );
}
++v11;
}
}
}
*a3 = v8;
return v5;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA R12,[RDI*0x4]
MOV R13,RDI
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010d0
MOV R10,RAX
TEST R13D,R13D
JLE 0x001013b6
MOV RSI,RBX
LEA RDI,[RBX + R12*0x1]
XOR R9D,R9D
LAB_00101300:
MOVSXD R8,R9D
MOV EDX,dword ptr [RSI]
LEA RCX,[R10 + R8*0x4]
TEST R9D,R9D
JLE 0x00101338
LAB_0010130e:
MOV RAX,R10
JMP 0x00101321
LAB_00101318:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101338
LAB_00101321:
CMP dword ptr [RAX],EDX
JNZ 0x00101318
ADD RSI,0x4
CMP RSI,RDI
JZ 0x00101349
MOV EDX,dword ptr [RSI]
JMP 0x0010130e
LAB_00101338:
ADD RSI,0x4
MOV dword ptr [R10 + R8*0x4],EDX
ADD R9D,0x1
CMP RSI,RDI
JNZ 0x00101300
LAB_00101349:
CMP R9D,0x1
JLE 0x001013a4
LEA RSI,[R10 + 0x4]
MOV R11D,R9D
MOV R8D,0x1
LEA R12D,[R9 + -0x1]
LEA RBX,[R10 + 0x8]
NOP dword ptr [RAX]
LAB_00101368:
CMP R9D,R8D
JLE 0x00101397
MOV EAX,R12D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[RBX + RAX*0x4]
MOV RAX,RSI
NOP
LAB_00101380:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x0010138e
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_0010138e:
ADD RAX,0x4
CMP RDI,RAX
JNZ 0x00101380
LAB_00101397:
ADD R8,0x1
ADD RSI,0x4
CMP R8,R11
JNZ 0x00101368
LAB_001013a4:
MOV dword ptr [RBP],R9D
ADD RSP,0x8
MOV RAX,R10
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013b6:
XOR R9D,R9D
JMP 0x001013a4
|
int * func0(int *param_1,int param_2,uint *param_3)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
ulong uVar5;
uint uVar6;
piVar2 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
uVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
uVar6 = 0;
do {
iVar4 = *param_1;
piVar3 = piVar2;
if (0 < (int)uVar6) {
do {
while (*piVar3 == iVar4) {
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_00101349;
piVar3 = piVar2;
iVar4 = *param_1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != piVar2 + (int)uVar6);
}
param_1 = param_1 + 1;
piVar2[(int)uVar6] = iVar4;
uVar6 = uVar6 + 1;
} while (param_1 != piVar1);
LAB_00101349:
if (1 < (int)uVar6) {
uVar5 = 1;
piVar1 = piVar2;
do {
if ((int)uVar5 < (int)uVar6) {
piVar3 = piVar1 + 1;
do {
iVar4 = *piVar1;
if (*piVar3 < iVar4) {
*piVar1 = *piVar3;
*piVar3 = iVar4;
}
piVar3 = piVar3 + 1;
} while (piVar2 + uVar5 + ((uVar6 - 1) - (int)uVar5) + 1 != piVar3);
}
uVar5 = uVar5 + 1;
piVar1 = piVar1 + 1;
} while (uVar5 != uVar6);
}
}
*param_3 = uVar6;
return piVar2;
}
|
796 |
func0
|
#include <stdio.h>
|
float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movss 0xf24(%rip),%xmm0
movss %xmm0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cd <func0+0x64>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
comiss -0x8(%rbp),%xmm0
jbe 11c9 <func0+0x60>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
movss %xmm0,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118e <func0+0x25>
movss -0x8(%rbp),%xmm0
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
movss xmm0, cs:dword_2084
movss [rbp+var_8], xmm0
mov [rbp+var_4], 0
jmp short loc_11CD
loc_118E:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
comiss xmm0, [rbp+var_8]
jbe short loc_11C9
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
movss [rbp+var_8], xmm0
loc_11C9:
add [rbp+var_4], 1
loc_11CD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118E
movss xmm0, [rbp+var_8]
pop rbp
retn
|
float func0(long long a1, int a2)
{
float v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = -10000.0;
for ( i = 0; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) > v3 )
v3 = *(float *)(4LL * i + a1);
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOVSS XMM0,dword ptr [0x00102084]
MOVSS dword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cd
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
COMISS XMM0,dword ptr [RBP + -0x8]
JBE 0x001011c9
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x8],XMM0
LAB_001011c9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011cd:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118e
MOVSS XMM0,dword ptr [RBP + -0x8]
POP RBP
RET
|
float func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = DAT_00102084;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_10 < *(float *)(param_1 + (long)local_c * 4)) {
local_10 = *(float *)(param_1 + (long)local_c * 4);
}
}
return local_10;
}
|
797 |
func0
|
#include <stdio.h>
|
float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 1199 <func0+0x30>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
movss 0xf18(%rip),%xmm0
movss (%rax),%xmm1
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
add $0x4,%rax
cmp %rdx,%rax
jne 1184 <func0+0x1b>
retq
movss 0xefb(%rip),%xmm0
retq
|
func0:
endbr64
test esi, esi
jle short loc_1198
mov rax, rdi
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
movss xmm0, cs:dword_2004
loc_1183:
movss xmm1, dword ptr [rax]
maxss xmm1, xmm0
movaps xmm0, xmm1
add rax, 4
cmp rax, rdx
jnz short loc_1183
retn
loc_1198:
movss xmm0, cs:dword_2004
retn
|
float func0(float *a1, int a2)
{
float *v2; // rax
float result; // xmm0_4
if ( a2 <= 0 )
return -10000.0;
v2 = a1;
result = -10000.0;
do
result = fmaxf(*v2++, result);
while ( v2 != &a1[a2] );
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101198
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
MOVSS XMM0,dword ptr [0x00102004]
LAB_00101183:
MOVSS XMM1,dword ptr [RAX]
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101183
RET
LAB_00101198:
MOVSS XMM0,dword ptr [0x00102004]
RET
|
float func0(float *param_1,int param_2)
{
float *pfVar1;
float fVar2;
float fVar3;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
fVar3 = DAT_00102004;
do {
fVar2 = *param_1;
if (*param_1 <= fVar3) {
fVar2 = fVar3;
}
fVar3 = fVar2;
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
return fVar3;
}
return DAT_00102004;
}
|
798 |
func0
|
#include <stdio.h>
|
float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1298 <func0+0x38>
lea -0x1(%rsi),%eax
movss 0xe01(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm1
add $0x4,%rdi
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
cmp %rax,%rdi
jne 1280 <func0+0x20>
retq
nopl (%rax)
movss 0xdd4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1278
movsxd rsi, esi
movss xmm0, cs:dword_2004
lea rax, [rdi+rsi*4]
nop word ptr [rax+rax+00000000h]
loc_1260:
movss xmm1, dword ptr [rdi]
add rdi, 4
maxss xmm1, xmm0
movaps xmm0, xmm1
cmp rax, rdi
jnz short loc_1260
retn
loc_1278:
movss xmm0, cs:dword_2004
retn
|
float func0(float *a1, int a2)
{
float result; // xmm0_4
float *v3; // rax
float v4; // xmm1_4
if ( a2 <= 0 )
return -10000.0;
result = -10000.0;
v3 = &a1[a2];
do
{
v4 = *a1++;
result = fmaxf(v4, result);
}
while ( v3 != a1 );
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101278
MOVSXD RSI,ESI
MOVSS XMM0,dword ptr [0x00102004]
LEA RAX,[RDI + RSI*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101260:
MOVSS XMM1,dword ptr [RDI]
ADD RDI,0x4
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
CMP RAX,RDI
JNZ 0x00101260
RET
LAB_00101278:
MOVSS XMM0,dword ptr [0x00102004]
RET
|
float func0(float *param_1,int param_2)
{
float *pfVar1;
float fVar2;
float fVar3;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
fVar3 = DAT_00102004;
do {
fVar2 = *param_1;
param_1 = param_1 + 1;
if (fVar2 <= fVar3) {
fVar2 = fVar3;
}
fVar3 = fVar2;
} while (pfVar1 != param_1);
return fVar3;
}
return DAT_00102004;
}
|
799 |
func0
|
#include <stdio.h>
|
float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 12c8 <func0+0x38>
lea -0x1(%rsi),%eax
movss 0xdd1(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm1
add $0x4,%rdi
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
cmp %rax,%rdi
jne 12b0 <func0+0x20>
retq
nopl (%rax)
movss 0xda4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1178
movsxd rsi, esi
movss xmm0, cs:dword_2004
lea rax, [rdi+rsi*4]
nop word ptr [rax+rax+00000000h]
loc_1160:
movss xmm1, dword ptr [rdi]
add rdi, 4
maxss xmm1, xmm0
movaps xmm0, xmm1
cmp rax, rdi
jnz short loc_1160
retn
loc_1178:
movss xmm0, cs:dword_2004
retn
|
float func0(float *a1, int a2)
{
float result; // xmm0_4
float *v3; // rax
float v4; // xmm1_4
if ( a2 <= 0 )
return -10000.0;
result = -10000.0;
v3 = &a1[a2];
do
{
v4 = *a1++;
result = fmaxf(v4, result);
}
while ( v3 != a1 );
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOVSXD RSI,ESI
MOVSS XMM0,dword ptr [0x00102004]
LEA RAX,[RDI + RSI*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
MOVSS XMM1,dword ptr [RDI]
ADD RDI,0x4
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
CMP RAX,RDI
JNZ 0x00101160
RET
LAB_00101178:
MOVSS XMM0,dword ptr [0x00102004]
RET
|
float func0(float *param_1,int param_2)
{
float *pfVar1;
float fVar2;
float fVar3;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
fVar3 = DAT_00102004;
do {
fVar2 = *param_1;
param_1 = param_1 + 1;
if (fVar2 <= fVar3) {
fVar2 = fVar3;
}
fVar3 = fVar2;
} while (pfVar1 != param_1);
return fVar3;
}
return DAT_00102004;
}
|
800 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1229 <func0+0xe0>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar %edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
add %edx,%eax
sub %eax,%ecx
mov %ecx,%edx
test %edx,%edx
je 11c6 <func0+0x7d>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x4ec4ec4f,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
shl $0x2,%eax
add %edx,%eax
sub %eax,%ecx
mov %ecx,%edx
test %edx,%edx
jne 1225 <func0+0xdc>
mov -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 121f <func0+0xd6>
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
cmp $0x7,%edx
jne 1201 <func0+0xb8>
addl $0x1,-0xc(%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 $0x0,-0x4(%rbp)
jg 11ce <func0+0x85>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 1167 <func0+0x1e>
mov -0xc(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp loc_1229
loc_1167:
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 2E8BA2E9h
shr rax, 20h
mov edx, eax
sar edx, 1
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
add eax, edx
sub ecx, eax
mov edx, ecx
test edx, edx
jz short loc_11C6
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 4EC4EC4Fh
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
add eax, eax
add eax, edx
shl eax, 2
add eax, edx
sub ecx, eax
mov edx, ecx
test edx, edx
jnz short loc_1225
loc_11C6:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp short loc_121F
loc_11CE:
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
cmp edx, 7
jnz short loc_1201
add [rbp+var_C], 1
loc_1201:
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_121F:
cmp [rbp+var_4], 0
jg short loc_11CE
loc_1225:
add [rbp+var_8], 1
loc_1229:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jl loc_1167
mov eax, [rbp+var_C]
pop rbp
retn
|
long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 0; i < a1; ++i )
{
if ( !(i % 11) || !(i % 13) )
{
for ( j = i; j > 0; j /= 10 )
{
if ( j % 10 == 7 )
++v2;
}
}
}
return v2;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101229
LAB_00101167:
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x2e8ba2e9
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x1
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
TEST EDX,EDX
JZ 0x001011c6
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x4ec4ec4f
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
TEST EDX,EDX
JNZ 0x00101225
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010121f
LAB_001011ce:
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
CMP EDX,0x7
JNZ 0x00101201
ADD dword ptr [RBP + -0xc],0x1
LAB_00101201:
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_0010121f:
CMP dword ptr [RBP + -0x4],0x0
JG 0x001011ce
LAB_00101225:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101229:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101167
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int func0(int param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_1; local_10 = local_10 + 1) {
if ((local_10 % 0xb == 0) || (local_10 % 0xd == 0)) {
for (local_c = local_10; 0 < local_c; local_c = local_c / 10) {
if (local_c % 10 == 7) {
local_14 = local_14 + 1;
}
}
}
}
return local_14;
}
|
801 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
}
|
O1
|
c
|
func0:
endbr64
test %edi,%edi
jle 1204 <func0+0xbb>
mov $0x0,%ecx
mov $0x0,%esi
jmp 116c <func0+0x23>
add $0x1,%ecx
cmp %ecx,%edi
je 1209 <func0+0xc0>
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
sar $0x21,%rax
mov %ecx,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%edx
lea (%rax,%rdx,2),%eax
cmp %eax,%ecx
je 11aa <func0+0x61>
movslq %ecx,%rax
imul $0x4ec4ec4f,%rax,%rax
sar $0x22,%rax
mov %ecx,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,2),%edx
lea (%rax,%rdx,4),%eax
cmp %eax,%ecx
jne 1161 <func0+0x18>
test %ecx,%ecx
jle 1161 <func0+0x18>
mov %ecx,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%r8d
sar $0x1f,%r8d
sub %r8d,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
mov %edx,%r9d
sub %eax,%r9d
cmp $0x7,%r9d
sete %al
movzbl %al,%eax
add %eax,%esi
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%r8d
sar $0x1f,%r8d
sub %r8d,%eax
cmp $0x9,%edx
jle 1161 <func0+0x18>
mov %eax,%edx
jmp 11b0 <func0+0x67>
mov $0x0,%esi
mov %esi,%eax
retq
|
func0:
endbr64
test edi, edi
jle loc_1200
mov ecx, 0
mov esi, 0
jmp short loc_11B6
loc_1161:
mov edx, eax
loc_1163:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov r8d, edx
sar r8d, 1Fh
sub eax, r8d
lea eax, [rax+rax*4]
add eax, eax
mov r8d, edx
sub r8d, eax
cmp r8d, 7
setz al
movzx eax, al
add esi, eax
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov r8d, edx
sar r8d, 1Fh
sub eax, r8d
cmp edx, 9
jg short loc_1161
loc_11AF:
add ecx, 1
cmp edi, ecx
jz short loc_1205
loc_11B6:
movsxd rax, ecx
imul rax, 2E8BA2E9h
sar rax, 21h
mov edx, ecx
sar edx, 1Fh
sub eax, edx
lea edx, [rax+rax*4]
lea eax, [rax+rdx*2]
cmp ecx, eax
jz short loc_11F4
movsxd rax, ecx
imul rax, 4EC4EC4Fh
sar rax, 22h
mov edx, ecx
sar edx, 1Fh
sub eax, edx
lea edx, [rax+rax*2]
lea eax, [rax+rdx*4]
cmp ecx, eax
jnz short loc_11AF
loc_11F4:
mov edx, ecx
test ecx, ecx
jg loc_1163
jmp short loc_11AF
loc_1200:
mov esi, 0
loc_1205:
mov eax, esi
retn
|
long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
int v3; // edx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 0;
v2 = 0;
do
{
if ( v1 == 11 * (v1 / 11) || v1 == 13 * (v1 / 13) )
{
v3 = v1;
if ( v1 > 0 )
{
while ( 1 )
{
v2 += v3 % 10 == 7;
if ( v3 <= 9 )
break;
v3 /= 10;
}
}
}
++v1;
}
while ( a1 != v1 );
}
return v2;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101200
MOV ECX,0x0
MOV ESI,0x0
JMP 0x001011b6
LAB_00101161:
MOV EDX,EAX
LAB_00101163:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV R8D,EDX
SAR R8D,0x1f
SUB EAX,R8D
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
MOV R8D,EDX
SUB R8D,EAX
CMP R8D,0x7
SETZ AL
MOVZX EAX,AL
ADD ESI,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV R8D,EDX
SAR R8D,0x1f
SUB EAX,R8D
CMP EDX,0x9
JG 0x00101161
LAB_001011af:
ADD ECX,0x1
CMP EDI,ECX
JZ 0x00101205
LAB_001011b6:
MOVSXD RAX,ECX
IMUL RAX,RAX,0x2e8ba2e9
SAR RAX,0x21
MOV EDX,ECX
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x4]
LEA EAX,[RAX + RDX*0x2]
CMP ECX,EAX
JZ 0x001011f4
MOVSXD RAX,ECX
IMUL RAX,RAX,0x4ec4ec4f
SAR RAX,0x22
MOV EDX,ECX
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
LEA EAX,[RAX + RDX*0x4]
CMP ECX,EAX
JNZ 0x001011af
LAB_001011f4:
MOV EDX,ECX
TEST ECX,ECX
JG 0x00101163
JMP 0x001011af
LAB_00101200:
MOV ESI,0x0
LAB_00101205:
MOV EAX,ESI
RET
|
int func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = 0;
do {
if (((iVar2 == (iVar2 / 0xb) * 0xb) || (iVar2 == (iVar2 / 0xd) * 0xd)) &&
(iVar3 = iVar2, 0 < iVar2)) {
do {
iVar4 = iVar4 + (uint)(iVar3 % 10 == 7);
bVar1 = 9 < iVar3;
iVar3 = iVar3 / 10;
} while (bVar1);
}
iVar2 = iVar2 + 1;
} while (param_1 != iVar2);
}
return iVar4;
}
|
802 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
}
|
O2
|
c
|
func0:
endbr64
test %edi,%edi
jle 167c <func0+0x7c>
xor %esi,%esi
xor %r8d,%r8d
mov $0xcccccccd,%r9d
jmp 162c <func0+0x2c>
nopl (%rax)
imul $0xc4ec4ec5,%esi,%eax
cmp $0x13b13b13,%eax
jbe 1639 <func0+0x39>
add $0x1,%esi
cmp %esi,%edi
je 1678 <func0+0x78>
imul $0xba2e8ba3,%esi,%eax
cmp $0x1745d174,%eax
ja 1618 <func0+0x18>
mov %esi,%edx
test %esi,%esi
jne 164a <func0+0x4a>
jmp 1625 <func0+0x25>
nopl 0x0(%rax)
mov %eax,%edx
mov %edx,%eax
mov %edx,%r10d
imul %r9,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r10d
cmp $0x7,%r10d
sete %cl
movzbl %cl,%ecx
add %ecx,%r8d
cmp $0x9,%edx
jg 1648 <func0+0x48>
add $0x1,%esi
cmp %esi,%edi
jne 162c <func0+0x2c>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
xor r8d, r8d
xor esi, esi
mov r9d, 0CCCCCCCDh
test edi, edi
jle short loc_135B
nop dword ptr [rax+rax+00h]
loc_1308:
add r8d, 1
cmp edi, r8d
jz short loc_135B
loc_1311:
imul eax, r8d, 0BA2E8BA3h
cmp eax, 1745D174h
jbe short loc_132D
imul eax, r8d, 0C4EC4EC5h
cmp eax, 13B13B13h
ja short loc_1308
loc_132D:
mov edx, r8d
loc_1330:
mov eax, edx
imul rax, r9
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
cmp edx, 7
setz dl
movzx edx, dl
add esi, edx
mov edx, eax
test eax, eax
jnz short loc_1330
add r8d, 1
cmp edi, r8d
jnz short loc_1311
loc_135B:
mov eax, esi
retn
|
long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // esi
unsigned int v3; // edx
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
while ( a1 != ++v1 )
{
while ( -1171354717 * v1 <= 0x1745D174 || -991146299 * v1 <= 0x13B13B13 )
{
v3 = v1;
do
{
v2 += v3 % 0xA == 7;
v3 /= 0xAu;
}
while ( v3 );
if ( a1 == ++v1 )
return v2;
}
}
}
return v2;
}
|
func0:
ENDBR64
XOR R8D,R8D
XOR ESI,ESI
MOV R9D,0xcccccccd
TEST EDI,EDI
JLE 0x0010135b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101308:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010135b
LAB_00101311:
IMUL EAX,R8D,-0x45d1745d
CMP EAX,0x1745d174
JBE 0x0010132d
IMUL EAX,R8D,-0x3b13b13b
CMP EAX,0x13b13b13
JA 0x00101308
LAB_0010132d:
MOV EDX,R8D
LAB_00101330:
MOV EAX,EDX
IMUL RAX,R9
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
CMP EDX,0x7
SETZ DL
MOVZX EDX,DL
ADD ESI,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x00101330
ADD R8D,0x1
CMP EDI,R8D
JNZ 0x00101311
LAB_0010135b:
MOV EAX,ESI
RET
|
int func0(uint param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uVar3 = 0;
iVar2 = 0;
if (0 < (int)param_1) {
while (uVar3 = uVar3 + 1, param_1 != uVar3) {
while ((uVar1 = uVar3, uVar3 * -0x45d1745d < 0x1745d175 || (uVar3 * -0x3b13b13b < 0x13b13b14))
) {
do {
iVar2 = iVar2 + (uint)(uVar1 % 10 == 7);
uVar1 = uVar1 / 10;
} while (uVar1 != 0);
uVar3 = uVar3 + 1;
if (param_1 == uVar3) {
return iVar2;
}
}
}
}
return iVar2;
}
|
803 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
}
|
O3
|
c
|
func0:
endbr64
test %edi,%edi
jle 167c <func0+0x7c>
mov $0x1,%esi
xor %r8d,%r8d
mov $0xcccccccd,%r9d
cmp $0x1,%edi
jne 1634 <func0+0x34>
jmp 1678 <func0+0x78>
nopl (%rax)
imul $0xc4ec4ec5,%esi,%eax
cmp $0x13b13b13,%eax
jbe 1641 <func0+0x41>
add $0x1,%esi
cmp %esi,%edi
je 1678 <func0+0x78>
imul $0xba2e8ba3,%esi,%eax
cmp $0x1745d174,%eax
ja 1620 <func0+0x20>
mov %esi,%edx
jmp 164a <func0+0x4a>
nopl (%rax)
mov %eax,%edx
mov %edx,%eax
mov %edx,%r10d
imul %r9,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r10d
cmp $0x7,%r10d
sete %cl
movzbl %cl,%ecx
add %ecx,%r8d
cmp $0x9,%edx
jg 1648 <func0+0x48>
add $0x1,%esi
cmp %esi,%edi
jne 1634 <func0+0x34>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
xor r8d, r8d
xor esi, esi
mov r9d, 0CCCCCCCDh
test edi, edi
jle short loc_168B
nop dword ptr [rax+rax+00h]
loc_1638:
add r8d, 1
cmp edi, r8d
jz short loc_168B
loc_1641:
imul eax, r8d, 0BA2E8BA3h
cmp eax, 1745D174h
jbe short loc_165D
imul eax, r8d, 0C4EC4EC5h
cmp eax, 13B13B13h
ja short loc_1638
loc_165D:
mov edx, r8d
loc_1660:
mov eax, edx
imul rax, r9
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
cmp edx, 7
setz dl
movzx edx, dl
add esi, edx
mov edx, eax
test eax, eax
jnz short loc_1660
add r8d, 1
cmp edi, r8d
jnz short loc_1641
loc_168B:
mov eax, esi
retn
|
long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // esi
unsigned int v3; // edx
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
while ( a1 != ++v1 )
{
while ( -1171354717 * v1 <= 0x1745D174 || -991146299 * v1 <= 0x13B13B13 )
{
v3 = v1;
do
{
v2 += v3 % 0xA == 7;
v3 /= 0xAu;
}
while ( v3 );
if ( a1 == ++v1 )
return v2;
}
}
}
return v2;
}
|
func0:
ENDBR64
XOR R8D,R8D
XOR ESI,ESI
MOV R9D,0xcccccccd
TEST EDI,EDI
JLE 0x0010168b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101638:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010168b
LAB_00101641:
IMUL EAX,R8D,-0x45d1745d
CMP EAX,0x1745d174
JBE 0x0010165d
IMUL EAX,R8D,-0x3b13b13b
CMP EAX,0x13b13b13
JA 0x00101638
LAB_0010165d:
MOV EDX,R8D
LAB_00101660:
MOV EAX,EDX
IMUL RAX,R9
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
CMP EDX,0x7
SETZ DL
MOVZX EDX,DL
ADD ESI,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x00101660
ADD R8D,0x1
CMP EDI,R8D
JNZ 0x00101641
LAB_0010168b:
MOV EAX,ESI
RET
|
int func0(uint param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uVar3 = 0;
iVar2 = 0;
if (0 < (int)param_1) {
while (uVar3 = uVar3 + 1, param_1 != uVar3) {
while ((uVar1 = uVar3, uVar3 * -0x45d1745d < 0x1745d175 || (uVar3 * -0x3b13b13b < 0x13b13b14))
) {
do {
iVar2 = iVar2 + (uint)(uVar1 % 10 == 7);
uVar1 = uVar1 / 10;
} while (uVar1 != 0);
uVar3 = uVar3 + 1;
if (param_1 == uVar3) {
return iVar2;
}
}
}
}
return iVar2;
}
|
804 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if (even[j] > even[j + 1]) {
float temp = even[j];
even[j] = even[j + 1];
even[j + 1] = temp;
}
}
}
// Merging even-indexed sorted and odd-indexed as they are
for (i = 0; i < size; i++) {
if (i % 2 == 0) {
out[i] = even[i / 2];
} else {
out[i] = l[i];
}
}
free(even);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, result1);
float expected1[] = {1, 2, 3};
assert(issame(result1, expected1, 3));
float test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
float result2[11];
func0(test2, 11, result2);
float expected2[] = {-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123};
assert(issame(result2, expected2, 11));
float test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
float result3[10];
func0(test3, 10, result3);
float expected3[] = {-12, 8, 3, 4, 5, 2, 12, 11, 23, -10};
assert(issame(result3, expected3, 10));
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 -0x2c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0x18(%rbp)
jmp 122c <func0+0x83>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movss (%rcx),%xmm0
movss %xmm0,(%rax)
addl $0x2,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11f1 <func0+0x48>
movl $0x0,-0x18(%rbp)
jmpq 1311 <func0+0x168>
movl $0x0,-0x14(%rbp)
jmpq 12fb <func0+0x152>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
comiss %xmm1,%xmm0
jbe 12f7 <func0+0x14e>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
movss %xmm0,-0xc(%rbp)
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
movss (%rdx),%xmm0
movss %xmm0,(%rax)
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movss -0xc(%rbp),%xmm0
movss %xmm0,(%rax)
addl $0x1,-0x14(%rbp)
mov -0x10(%rbp),%eax
sub -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jl 124c <func0+0xa3>
addl $0x1,-0x18(%rbp)
mov -0x10(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x18(%rbp)
jl 1240 <func0+0x97>
movl $0x0,-0x18(%rbp)
jmp 13a2 <func0+0x1f9>
mov -0x18(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 136e <func0+0x1c5>
mov -0x18(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
movss (%rdx),%xmm0
movss %xmm0,(%rax)
jmp 139e <func0+0x1f5>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
movss (%rdx),%xmm0
movss %xmm0,(%rax)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1329 <func0+0x180>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
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 eax, [rbp+var_2C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_10], 0
mov [rbp+var_18], 0
jmp short loc_122C
loc_11F1:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
movss xmm0, dword ptr [rcx]
movss dword ptr [rax], xmm0
add [rbp+var_18], 2
loc_122C:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_11F1
mov [rbp+var_18], 0
jmp loc_1311
loc_1240:
mov [rbp+var_14], 0
jmp loc_12FB
loc_124C:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
movss xmm0, dword ptr [rax]
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
movss xmm1, dword ptr [rax]
comiss xmm0, xmm1
jbe short loc_12F7
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
movss xmm0, dword ptr [rax]
movss [rbp+var_C], xmm0
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
movss xmm0, dword ptr [rdx]
movss dword ptr [rax], xmm0
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
movss xmm0, [rbp+var_C]
movss dword ptr [rax], xmm0
loc_12F7:
add [rbp+var_14], 1
loc_12FB:
mov eax, [rbp+var_10]
sub eax, [rbp+var_18]
sub eax, 1
cmp [rbp+var_14], eax
jl loc_124C
add [rbp+var_18], 1
loc_1311:
mov eax, [rbp+var_10]
sub eax, 1
cmp [rbp+var_18], eax
jl loc_1240
mov [rbp+var_18], 0
jmp short loc_13A2
loc_1329:
mov eax, [rbp+var_18]
and eax, 1
test eax, eax
jnz short loc_136E
mov eax, [rbp+var_18]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_18]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
movss xmm0, dword ptr [rdx]
movss dword ptr [rax], xmm0
jmp short loc_139E
loc_136E:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_18]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
movss xmm0, dword ptr [rdx]
movss dword ptr [rax], xmm0
loc_139E:
add [rbp+var_18], 1
loc_13A2:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl loc_1329
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
nop
leave
retn
|
void func0(long long a1, int a2, long long a3)
{
int v3; // eax
_DWORD *v4; // rdx
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+28h] [rbp-18h]
int m; // [rsp+28h] [rbp-18h]
int k; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+30h] [rbp-10h]
int v11; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38h] [rbp-8h]
ptr = malloc(4LL * (a2 / 2 + 1));
v10 = 0;
for ( i = 0; i < a2; i += 2 )
{
v3 = v10++;
ptr[v3] = *(_DWORD *)(4LL * i + a1);
}
for ( j = 0; j < v10 - 1; ++j )
{
for ( k = 0; k < v10 - j - 1; ++k )
{
if ( *(float *)&ptr[k] > *(float *)&ptr[k + 1] )
{
v11 = ptr[k];
ptr[k] = ptr[k + 1];
ptr[k + 1] = v11;
}
}
}
for ( m = 0; m < a2; ++m )
{
if ( (m & 1) != 0 )
v4 = (_DWORD *)(a1 + 4LL * m);
else
v4 = &ptr[m / 2];
*(_DWORD *)(4LL * m + a3) = *v4;
}
free(ptr);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010122c
LAB_001011f1:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RCX]
MOVSS dword ptr [RAX],XMM0
ADD dword ptr [RBP + -0x18],0x2
LAB_0010122c:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011f1
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101311
LAB_00101240:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012fb
LAB_0010124c:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,XMM1
JBE 0x001012f7
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0xc],XMM0
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOVSS XMM0,dword ptr [RDX]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RBP + -0xc]
MOVSS dword ptr [RAX],XMM0
LAB_001012f7:
ADD dword ptr [RBP + -0x14],0x1
LAB_001012fb:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x0010124c
ADD dword ptr [RBP + -0x18],0x1
LAB_00101311:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x1
CMP dword ptr [RBP + -0x18],EAX
JL 0x00101240
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001013a2
LAB_00101329:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x0010136e
MOV EAX,dword ptr [RBP + -0x18]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOVSS XMM0,dword ptr [RDX]
MOVSS dword ptr [RAX],XMM0
JMP 0x0010139e
LAB_0010136e:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOVSS XMM0,dword ptr [RDX]
MOVSS dword ptr [RAX],XMM0
LAB_0010139e:
ADD dword ptr [RBP + -0x18],0x1
LAB_001013a2:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101329
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101080
NOP
LEAVE
RET
|
void func0(long param_1,int param_2,long param_3)
{
int4 uVar1;
void *__ptr;
int4 local_20;
int4 local_1c;
int4 local_18;
__ptr = malloc((long)(param_2 / 2 + 1) << 2);
local_18 = 0;
for (local_20 = 0; (int)local_20 < param_2; local_20 = local_20 + 2) {
*(int4 *)((long)__ptr + (long)local_18 * 4) =
*(int4 *)((long)(int)local_20 * 4 + param_1);
local_18 = local_18 + 1;
}
for (local_20 = 0; (int)local_20 < local_18 + -1; local_20 = local_20 + 1) {
for (local_1c = 0; local_1c < (int)((local_18 - local_20) + -1); local_1c = local_1c + 1) {
if (*(float *)((long)__ptr + ((long)local_1c + 1) * 4) <
*(float *)((long)__ptr + (long)local_1c * 4)) {
uVar1 = *(int4 *)((long)__ptr + (long)local_1c * 4);
*(int4 *)((long)__ptr + (long)local_1c * 4) =
*(int4 *)(((long)local_1c + 1) * 4 + (long)__ptr);
*(int4 *)((long)__ptr + ((long)local_1c + 1) * 4) = uVar1;
}
}
}
for (local_20 = 0; (int)local_20 < param_2; local_20 = local_20 + 1) {
if ((local_20 & 1) == 0) {
*(int4 *)(param_3 + (long)(int)local_20 * 4) =
*(int4 *)((long)((int)local_20 / 2) * 4 + (long)__ptr);
}
else {
*(int4 *)(param_3 + (long)(int)local_20 * 4) =
*(int4 *)((long)(int)local_20 * 4 + param_1);
}
}
free(__ptr);
return;
}
|
805 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if (even[j] > even[j + 1]) {
float temp = even[j];
even[j] = even[j + 1];
even[j + 1] = temp;
}
}
}
// Merging even-indexed sorted and odd-indexed as they are
for (i = 0; i < size; i++) {
if (i % 2 == 0) {
out[i] = even[i / 2];
} else {
out[i] = l[i];
}
}
free(even);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, result1);
float expected1[] = {1, 2, 3};
assert(issame(result1, expected1, 3));
float test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
float result2[11];
func0(test2, 11, result2);
float expected2[] = {-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123};
assert(issame(result2, expected2, 11));
float test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
float result3[10];
func0(test3, 10, result3);
float expected3[] = {-12, 8, 3, 4, 5, 2, 12, 11, 23, -10};
assert(issame(result3, expected3, 10));
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
mov %rdx,%r12
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 126e <func0+0xc5>
mov $0x0,%edx
movss 0x0(%rbp,%rdx,4),%xmm0
movss %xmm0,(%rdi,%rdx,2)
add $0x2,%rdx
cmp %edx,%ebx
jg 11e1 <func0+0x38>
lea -0x1(%rbx),%esi
shr %esi
je 1278 <func0+0xcf>
lea 0x4(%rdi),%r8
jmp 1228 <func0+0x7f>
add $0x4,%rdx
cmp %rcx,%rdx
je 1223 <func0+0x7a>
movss (%rdx),%xmm0
movss 0x4(%rdx),%xmm1
comiss %xmm1,%xmm0
jbe 1201 <func0+0x58>
movss %xmm1,(%rdx)
movss %xmm0,0x4(%rdx)
jmp 1201 <func0+0x58>
sub $0x1,%esi
je 1278 <func0+0xcf>
test %esi,%esi
jle 1223 <func0+0x7a>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea (%r8,%rax,4),%rcx
jmp 120a <func0+0x61>
movss 0x0(%rbp,%rdx,4),%xmm0
movss %xmm0,(%r12,%rdx,4)
lea 0x1(%rdx),%rax
cmp %rdx,%rsi
je 126e <func0+0xc5>
mov %rax,%rdx
test $0x1,%dl
jne 1238 <func0+0x8f>
mov %edx,%ecx
shr $0x1f,%ecx
add %edx,%ecx
sar %ecx
movslq %ecx,%rcx
movss (%rdi,%rcx,4),%xmm0
movss %xmm0,(%r12,%rdx,4)
jmp 1244 <func0+0x9b>
callq 1080 <free@plt>
pop %rbx
pop %rbp
pop %r12
retq
lea -0x1(%rbx),%esi
mov $0x0,%edx
jmp 1250 <func0+0xa7>
|
func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
mov r12, rdx
mov edi, esi
shr edi, 1Fh
add edi, esi
sar edi, 1
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_127F
mov eax, 0
loc_11E1:
movss xmm0, dword ptr [rbp+rax*4+0]
movss dword ptr [rdi+rax*2], xmm0
add rax, 2
cmp ebx, eax
jg short loc_11E1
lea esi, [rbx-1]
shr esi, 1
jz loc_1289
mov ecx, 0
lea r8d, [rsi+1]
lea r10d, [rsi-1]
lea r9, [rdi+4]
jmp short loc_123B
loc_1212:
add rax, 4
cmp rax, rdx
jz short loc_1234
loc_121B:
movss xmm0, dword ptr [rax]
movss xmm1, dword ptr [rax+4]
comiss xmm0, xmm1
jbe short loc_1212
movss dword ptr [rax], xmm1
movss dword ptr [rax+4], xmm0
jmp short loc_1212
loc_1234:
add ecx, 1
cmp esi, ecx
jle short loc_1289
loc_123B:
mov eax, r8d
sub eax, ecx
cmp eax, 1
jle short loc_1234
mov rax, rdi
mov edx, r10d
sub edx, ecx
lea rdx, [r9+rdx*4]
jmp short loc_121B
loc_1253:
movss xmm0, dword ptr [rbp+rax*4+0]
loc_1259:
movss dword ptr [r12+rax*4], xmm0
add rax, 1
cmp rax, rbx
jz short loc_127F
loc_1268:
test al, 1
jnz short loc_1253
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
movsxd rdx, edx
movss xmm0, dword ptr [rdi+rdx*4]
jmp short loc_1259
loc_127F:
call _free
pop rbx
pop rbp
pop r12
retn
loc_1289:
movsxd rbx, ebx
mov eax, 0
jmp short loc_1268
|
void func0(long long a1, int a2, long long a3)
{
float *v6; // rdi
long long v7; // rax
signed int v8; // esi
signed int v9; // ecx
float *v10; // rax
float v11; // xmm0_4
float v12; // xmm1_4
float v13; // xmm0_4
long long v14; // rax
v6 = (float *)malloc(4LL * (a2 / 2 + 1));
if ( a2 > 0 )
{
v7 = 0LL;
do
{
v6[v7] = *(float *)(a1 + 2 * v7);
++v7;
}
while ( a2 > (int)(v7 * 2) );
v8 = (unsigned int)(a2 - 1) >> 1;
if ( (unsigned int)(a2 - 1) >> 1 )
{
v9 = 0;
do
{
if ( v8 + 1 - v9 > 1 )
{
v10 = v6;
do
{
v11 = *v10;
v12 = v10[1];
if ( *v10 > v12 )
{
*v10 = v12;
v10[1] = v11;
}
++v10;
}
while ( v10 != &v6[v8 - 1 - v9 + 1] );
}
++v9;
}
while ( v8 > v9 );
}
v14 = 0LL;
do
{
if ( (v14 & 1) != 0 )
v13 = *(float *)(a1 + 4 * v14);
else
v13 = v6[(int)v14 / 2];
*(float *)(a3 + 4 * v14++) = v13;
}
while ( v14 != a2 );
}
free(v6);
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
MOV R12,RDX
MOV EDI,ESI
SHR EDI,0x1f
ADD EDI,ESI
SAR EDI,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x0010127f
MOV EAX,0x0
LAB_001011e1:
MOVSS XMM0,dword ptr [RBP + RAX*0x4]
MOVSS dword ptr [RDI + RAX*0x2],XMM0
ADD RAX,0x2
CMP EBX,EAX
JG 0x001011e1
LEA ESI,[RBX + -0x1]
SHR ESI,0x1
JZ 0x00101289
MOV ECX,0x0
LEA R8D,[RSI + 0x1]
LEA R10D,[RSI + -0x1]
LEA R9,[RDI + 0x4]
JMP 0x0010123b
LAB_00101212:
ADD RAX,0x4
CMP RAX,RDX
JZ 0x00101234
LAB_0010121b:
MOVSS XMM0,dword ptr [RAX]
MOVSS XMM1,dword ptr [RAX + 0x4]
COMISS XMM0,XMM1
JBE 0x00101212
MOVSS dword ptr [RAX],XMM1
MOVSS dword ptr [RAX + 0x4],XMM0
JMP 0x00101212
LAB_00101234:
ADD ECX,0x1
CMP ESI,ECX
JLE 0x00101289
LAB_0010123b:
MOV EAX,R8D
SUB EAX,ECX
CMP EAX,0x1
JLE 0x00101234
MOV RAX,RDI
MOV EDX,R10D
SUB EDX,ECX
LEA RDX,[R9 + RDX*0x4]
JMP 0x0010121b
LAB_00101253:
MOVSS XMM0,dword ptr [RBP + RAX*0x4]
LAB_00101259:
MOVSS dword ptr [R12 + RAX*0x4],XMM0
ADD RAX,0x1
CMP RAX,RBX
JZ 0x0010127f
LAB_00101268:
TEST AL,0x1
JNZ 0x00101253
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
MOVSXD RDX,EDX
MOVSS XMM0,dword ptr [RDI + RDX*0x4]
JMP 0x00101259
LAB_0010127f:
CALL 0x00101080
POP RBX
POP RBP
POP R12
RET
LAB_00101289:
MOVSXD RBX,EBX
MOV EAX,0x0
JMP 0x00101268
|
void func0(long param_1,int param_2,long param_3)
{
float *__ptr;
long lVar1;
float *pfVar2;
ulong uVar3;
int iVar4;
uint uVar5;
float fVar6;
__ptr = (float *)malloc((long)(param_2 / 2 + 1) << 2);
if (0 < param_2) {
lVar1 = 0;
do {
*(int4 *)((long)__ptr + lVar1 * 2) = *(int4 *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 2;
} while ((int)lVar1 < param_2);
uVar5 = param_2 - 1U >> 1;
if (uVar5 != 0) {
iVar4 = 0;
do {
if (1 < (int)((uVar5 + 1) - iVar4)) {
pfVar2 = __ptr;
do {
fVar6 = *pfVar2;
if (pfVar2[1] < fVar6) {
*pfVar2 = pfVar2[1];
pfVar2[1] = fVar6;
}
pfVar2 = pfVar2 + 1;
} while (pfVar2 != __ptr + (ulong)((uVar5 - 1) - iVar4) + 1);
}
iVar4 = iVar4 + 1;
} while (iVar4 < (int)uVar5);
}
uVar3 = 0;
do {
if ((uVar3 & 1) == 0) {
fVar6 = __ptr[(int)(((uint)(uVar3 >> 0x1f) & 1) + (int)uVar3) >> 1];
}
else {
fVar6 = *(float *)(param_1 + uVar3 * 4);
}
*(float *)(param_3 + uVar3 * 4) = fVar6;
uVar3 = uVar3 + 1;
} while (uVar3 != (long)param_2);
}
free(__ptr);
return;
}
|
806 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if (even[j] > even[j + 1]) {
float temp = even[j];
even[j] = even[j + 1];
even[j + 1] = temp;
}
}
}
// Merging even-indexed sorted and odd-indexed as they are
for (i = 0; i < size; i++) {
if (i % 2 == 0) {
out[i] = even[i / 2];
} else {
out[i] = l[i];
}
}
free(even);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, result1);
float expected1[] = {1, 2, 3};
assert(issame(result1, expected1, 3));
float test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
float result2[11];
func0(test2, 11, result2);
float expected2[] = {-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123};
assert(issame(result2, expected2, 11));
float test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
float result3[10];
func0(test3, 10, result3);
float expected3[] = {-12, 8, 3, 4, 5, 2, 12, 11, 23, -10};
assert(issame(result3, expected3, 10));
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
mov %esi,%edi
shr $0x1f,%edi
push %rbx
mov %esi,%ebx
add %esi,%edi
sar %edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 15f8 <func0+0xd8>
xor %ecx,%ecx
nopl (%rax)
movss 0x0(%rbp,%rcx,4),%xmm0
movss %xmm0,(%r8,%rcx,2)
add $0x2,%rcx
cmp %ecx,%ebx
jg 1558 <func0+0x38>
sub $0x1,%ebx
mov %ebx,%esi
shr %esi
je 15b6 <func0+0x96>
lea 0x4(%r8),%rdx
nopl 0x0(%rax)
lea -0x1(%rsi),%eax
mov %r8,%rcx
mov %rax,%rdi
lea (%rdx,%rax,4),%rsi
nopl (%rax)
movss (%rcx),%xmm0
movss 0x4(%rcx),%xmm1
comiss %xmm1,%xmm0
jbe 15a7 <func0+0x87>
movss %xmm1,(%rcx)
movss %xmm0,0x4(%rcx)
add $0x4,%rcx
cmp %rsi,%rcx
jne 1590 <func0+0x70>
mov %edi,%esi
test %edi,%edi
jne 1580 <func0+0x60>
mov %ebx,%esi
xor %ecx,%ecx
jmp 15de <func0+0xbe>
nopl 0x0(%rax)
mov %ecx,%eax
sar %eax
cltq
movss (%r8,%rax,4),%xmm0
lea 0x1(%rcx),%rax
movss %xmm0,(%r12,%rcx,4)
cmp %rcx,%rsi
je 15f8 <func0+0xd8>
mov %rax,%rcx
test $0x1,%cl
je 15c0 <func0+0xa0>
movss 0x0(%rbp,%rcx,4),%xmm0
lea 0x1(%rcx),%rax
movss %xmm0,(%r12,%rcx,4)
cmp %rcx,%rsi
jne 15db <func0+0xbb>
pop %rbx
mov %r8,%rdi
pop %rbp
pop %r12
jmpq 1080 <free@plt>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
movsxd rbx, esi
mov edi, ebx
shr edi, 1Fh
add edi, ebx
sar edi, 1
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
xor eax, eax
test ebx, ebx
jle loc_14C4
nop word ptr [rax+rax+00000000h]
loc_1410:
movss xmm0, dword ptr [rbp+rax*4+0]
movss dword ptr [rdi+rax*2], xmm0
add rax, 2
cmp ebx, eax
jg short loc_1410
lea esi, [rbx-1]
mov ecx, 0
lea r9, [rdi+4]
shr esi, 1
lea r8d, [rsi+1]
lea r10d, [rsi-1]
jz short loc_1487
nop dword ptr [rax+rax+00h]
loc_1440:
mov eax, r8d
sub eax, ecx
cmp eax, 1
jle short loc_1480
mov edx, r10d
mov rax, rdi
sub edx, ecx
lea rdx, [r9+rdx*4]
nop word ptr [rax+rax+00000000h]
loc_1460:
movq xmm0, qword ptr [rax]
movaps xmm3, xmm0
shufps xmm3, xmm3, 0E5h
comiss xmm0, xmm3
jbe short loc_1477
shufps xmm0, xmm0, 0E1h
movlps qword ptr [rax], xmm0
loc_1477:
add rax, 4
cmp rax, rdx
jnz short loc_1460
loc_1480:
add ecx, 1
cmp ecx, esi
jl short loc_1440
loc_1487:
xor eax, eax
jmp short loc_14AB
loc_1490:
mov edx, eax
sar edx, 1
movsxd rdx, edx
movss xmm0, dword ptr [rdi+rdx*4]
movss dword ptr [r12+rax*4], xmm0
add rax, 1
cmp rax, rbx
jz short loc_14C4
loc_14AB:
test al, 1
jz short loc_1490
movss xmm0, dword ptr [rbp+rax*4+0]
movss dword ptr [r12+rax*4], xmm0
add rax, 1
cmp rax, rbx
jnz short loc_14AB
loc_14C4:
pop rbx
pop rbp
pop r12
jmp _free
|
void func0(long long a1, int a2, long long a3)
{
long long v5; // rbx
__m128i *v6; // rdi
long long v7; // rax
signed int v8; // ecx
signed int v9; // esi
__m128i *v10; // rax
__m128 v11; // xmm0
long long v12; // rax
v5 = a2;
v6 = (__m128i *)malloc(4LL * (a2 / 2 + 1));
v7 = 0LL;
if ( a2 > 0 )
{
do
{
v6->m128i_i32[v7] = *(_DWORD *)(a1 + 2 * v7);
++v7;
}
while ( a2 > (int)(v7 * 2) );
v8 = 0;
v9 = (unsigned int)(a2 - 1) >> 1;
if ( v9 )
{
do
{
if ( v9 + 1 - v8 > 1 )
{
v10 = v6;
do
{
v11 = (__m128)_mm_loadl_epi64(v10);
if ( v11.m128_f32[0] > _mm_shuffle_ps(v11, v11, 229).m128_f32[0] )
_mm_storel_ps((double *)v10->m128i_i64, _mm_shuffle_ps(v11, v11, 225));
v10 = (__m128i *)((char *)v10 + 4);
}
while ( v10 != (__m128i *)((char *)v6->m128i_i64 + 4 * (unsigned int)(v9 - 1 - v8) + 4) );
}
++v8;
}
while ( v8 < v9 );
}
v12 = 0LL;
do
{
while ( (v12 & 1) == 0 )
{
*(_DWORD *)(a3 + 4 * v12) = v6->m128i_i32[(int)v12 >> 1];
if ( ++v12 == v5 )
goto LABEL_14;
}
*(_DWORD *)(a3 + 4 * v12) = *(_DWORD *)(a1 + 4 * v12);
++v12;
}
while ( v12 != v5 );
}
LABEL_14:
free(v6);
}
|
func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVSXD RBX,ESI
MOV EDI,EBX
SHR EDI,0x1f
ADD EDI,EBX
SAR EDI,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
XOR EAX,EAX
TEST EBX,EBX
JLE 0x001014c4
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101410:
MOVSS XMM0,dword ptr [RBP + RAX*0x4]
MOVSS dword ptr [RDI + RAX*0x2],XMM0
ADD RAX,0x2
CMP EBX,EAX
JG 0x00101410
LEA ESI,[RBX + -0x1]
MOV ECX,0x0
LEA R9,[RDI + 0x4]
SHR ESI,0x1
LEA R8D,[RSI + 0x1]
LEA R10D,[RSI + -0x1]
JZ 0x00101487
NOP dword ptr [RAX + RAX*0x1]
LAB_00101440:
MOV EAX,R8D
SUB EAX,ECX
CMP EAX,0x1
JLE 0x00101480
MOV EDX,R10D
MOV RAX,RDI
SUB EDX,ECX
LEA RDX,[R9 + RDX*0x4]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101460:
MOVQ XMM0,qword ptr [RAX]
MOVAPS XMM3,XMM0
SHUFPS XMM3,XMM3,0xe5
COMISS XMM0,XMM3
JBE 0x00101477
SHUFPS XMM0,XMM0,0xe1
MOVLPS qword ptr [RAX],XMM0
LAB_00101477:
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101460
LAB_00101480:
ADD ECX,0x1
CMP ECX,ESI
JL 0x00101440
LAB_00101487:
XOR EAX,EAX
JMP 0x001014ab
LAB_00101490:
MOV EDX,EAX
SAR EDX,0x1
MOVSXD RDX,EDX
MOVSS XMM0,dword ptr [RDI + RDX*0x4]
MOVSS dword ptr [R12 + RAX*0x4],XMM0
ADD RAX,0x1
CMP RAX,RBX
JZ 0x001014c4
LAB_001014ab:
TEST AL,0x1
JZ 0x00101490
MOVSS XMM0,dword ptr [RBP + RAX*0x4]
MOVSS dword ptr [R12 + RAX*0x4],XMM0
ADD RAX,0x1
CMP RAX,RBX
JNZ 0x001014ab
LAB_001014c4:
POP RBX
POP RBP
POP R12
JMP 0x00101080
|
void func0(long param_1,int param_2,long param_3)
{
int8 *__ptr;
long lVar1;
int8 *puVar2;
ulong uVar3;
int iVar4;
uint uVar5;
float fVar6;
float fVar7;
__ptr = (int8 *)malloc((long)(param_2 / 2 + 1) << 2);
lVar1 = 0;
if (0 < param_2) {
do {
*(int4 *)((long)__ptr + lVar1 * 2) = *(int4 *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 2;
} while ((int)lVar1 < param_2);
iVar4 = 0;
uVar5 = param_2 - 1U >> 1;
if (uVar5 != 0) {
do {
if (1 < (int)((uVar5 + 1) - iVar4)) {
puVar2 = __ptr;
do {
fVar6 = (float)*puVar2;
fVar7 = (float)((ulong)*puVar2 >> 0x20);
if (fVar7 < fVar6) {
*puVar2 = CONCAT44(fVar6,fVar7);
}
puVar2 = (int8 *)((long)puVar2 + 4);
} while (puVar2 != (int8 *)((long)__ptr + (ulong)((uVar5 - 1) - iVar4) * 4 + 4));
}
iVar4 = iVar4 + 1;
} while (iVar4 < (int)uVar5);
}
uVar3 = 0;
do {
while ((uVar3 & 1) == 0) {
*(int4 *)(param_3 + uVar3 * 4) =
*(int4 *)((long)__ptr + (long)((int)uVar3 >> 1) * 4);
uVar3 = uVar3 + 1;
if (uVar3 == (long)param_2) goto LAB_001014c4;
}
*(int4 *)(param_3 + uVar3 * 4) = *(int4 *)(param_1 + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3 != (long)param_2);
}
LAB_001014c4:
free(__ptr);
return;
}
|
807 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
|
void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if (even[j] > even[j + 1]) {
float temp = even[j];
even[j] = even[j + 1];
even[j + 1] = temp;
}
}
}
// Merging even-indexed sorted and odd-indexed as they are
for (i = 0; i < size; i++) {
if (i % 2 == 0) {
out[i] = even[i / 2];
} else {
out[i] = l[i];
}
}
free(even);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, result1);
float expected1[] = {1, 2, 3};
assert(issame(result1, expected1, 3));
float test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
float result2[11];
func0(test2, 11, result2);
float expected2[] = {-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123};
assert(issame(result2, expected2, 11));
float test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
float result3[10];
func0(test3, 10, result3);
float expected3[] = {-12, 8, 3, 4, 5, 2, 12, 11, 23, -10};
assert(issame(result3, expected3, 10));
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r12
mov %esi,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 182f <func0+0x16f>
lea -0x1(%r12),%edx
mov %edx,%edi
shr %edi
cmp $0x7,%edx
jbe 1860 <func0+0x1a0>
mov %edx,%eax
xor %ecx,%ecx
shr $0x3,%eax
mov %eax,%esi
shl $0x4,%rsi
nopl 0x0(%rax)
movups (%rbx,%rcx,2),%xmm0
movups 0x10(%rbx,%rcx,2),%xmm2
shufps $0x88,%xmm2,%xmm0
movups %xmm0,(%r8,%rcx,1)
add $0x10,%rcx
cmp %rsi,%rcx
jne 1718 <func0+0x58>
lea 0x0(,%rax,4),%ecx
shl $0x3,%eax
movslq %eax,%r10
movslq %ecx,%rsi
lea 0x1(%rcx),%r9d
movss (%rbx,%r10,4),%xmm0
movss %xmm0,(%r8,%rsi,4)
lea 0x2(%rax),%esi
cmp %r12d,%esi
jge 184d <func0+0x18d>
movslq %esi,%rsi
movslq %r9d,%r9
add $0x2,%ecx
movss (%rbx,%rsi,4),%xmm0
lea 0x4(%rax),%esi
movss %xmm0,(%r8,%r9,4)
cmp %esi,%r12d
jle 17aa <func0+0xea>
movslq %esi,%rsi
movslq %ecx,%rcx
add $0x6,%eax
movss (%rbx,%rsi,4),%xmm0
lea 0x0(,%rcx,4),%r9
movss %xmm0,(%r8,%rcx,4)
cmp %eax,%r12d
jle 17aa <func0+0xea>
cltq
movss (%rbx,%rax,4),%xmm0
movss %xmm0,0x4(%r8,%r9,1)
lea 0x4(%r8),%r9
xchg %ax,%ax
test %edi,%edi
jle 1840 <func0+0x180>
lea -0x1(%rdi),%eax
mov %r8,%rcx
mov %rax,%rdi
lea (%r9,%rax,4),%rsi
nopl (%rax)
movss (%rcx),%xmm0
movss 0x4(%rcx),%xmm1
comiss %xmm1,%xmm0
jbe 17df <func0+0x11f>
movss %xmm1,(%rcx)
movss %xmm0,0x4(%rcx)
add $0x4,%rcx
cmp %rsi,%rcx
jne 17c8 <func0+0x108>
test %edi,%edi
jne 17b0 <func0+0xf0>
mov %edx,%edx
xor %ecx,%ecx
jmp 1816 <func0+0x156>
nopw 0x0(%rax,%rax,1)
mov %ecx,%eax
sar %eax
cltq
movss (%r8,%rax,4),%xmm0
lea 0x1(%rcx),%rax
movss %xmm0,0x0(%rbp,%rcx,4)
cmp %rdx,%rcx
je 182f <func0+0x16f>
mov %rax,%rcx
test $0x1,%cl
je 17f8 <func0+0x138>
movss (%rbx,%rcx,4),%xmm0
lea 0x1(%rcx),%rax
movss %xmm0,0x0(%rbp,%rcx,4)
cmp %rdx,%rcx
jne 1813 <func0+0x153>
pop %rbx
mov %r8,%rdi
pop %rbp
pop %r12
jmpq 1080 <free@plt>
nopl 0x0(%rax,%rax,1)
sub $0x1,%edi
test %edi,%edi
jne 17b0 <func0+0xf0>
jmp 17ec <func0+0x12c>
test %edi,%edi
jne 17aa <func0+0xea>
jmp 17ec <func0+0x12c>
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
xor %eax,%eax
jmpq 173d <func0+0x7d>
nopl 0x0(%rax)
|
func0:
endbr64
push r12
mov r12, rdx
push rbp
movsxd rbp, esi
push rbx
mov rbx, rdi
mov edi, ebp
shr edi, 1Fh
add edi, ebp
sar edi, 1
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebp, ebp
jle loc_1787
lea eax, [rbp-1]
mov esi, eax
shr esi, 1
cmp eax, 7
jbe loc_17C5
shr eax, 3
mov ecx, eax
xor eax, eax
mov rdx, rcx
shl rcx, 4
nop word ptr [rax+rax+00h]
loc_1688:
movups xmm0, xmmword ptr [rbx+rax*2]
movups xmm4, xmmword ptr [rbx+rax*2+10h]
shufps xmm0, xmm4, 88h
movups xmmword ptr [rdi+rax], xmm0
add rax, 10h
cmp rcx, rax
jnz short loc_1688
lea ecx, ds:0[rdx*4]
lea eax, ds:0[rdx*8]
loc_16B0:
movsxd r9, eax
movsxd rdx, ecx
movss xmm0, dword ptr [rbx+r9*4]
lea rcx, ds:0[rdx*4]
lea r8, ds:0[r9*4]
movss dword ptr [rdi+rdx*4], xmm0
lea edx, [rax+2]
cmp ebp, edx
jle loc_17B8
movss xmm0, dword ptr [rbx+r8+8]
lea edx, [rax+4]
movss dword ptr [rdi+rcx+4], xmm0
cmp ebp, edx
jle short loc_1711
movss xmm0, dword ptr [rbx+r8+10h]
add eax, 6
movss dword ptr [rdi+rcx+8], xmm0
cmp ebp, eax
jle short loc_1711
movss xmm0, dword ptr [rbx+r8+18h]
movss dword ptr [rdi+rcx+0Ch], xmm0
loc_1711:
lea ecx, [rsi+1]
loc_1714:
lea rsi, [rdi+4]
nop dword ptr [rax+rax+00000000h]
loc_1720:
cmp ecx, 1
jle loc_17B0
lea edx, [rcx-2]
mov rax, rdi
lea rdx, [rsi+rdx*4]
nop dword ptr [rax+rax+00h]
loc_1738:
movq xmm0, qword ptr [rax]
movaps xmm3, xmm0
shufps xmm3, xmm3, 0E5h
comiss xmm0, xmm3
jbe short loc_174F
shufps xmm0, xmm0, 0E1h
movlps qword ptr [rax], xmm0
loc_174F:
add rax, 4
cmp rdx, rax
jnz short loc_1738
sub ecx, 1
cmp ecx, 1
jnz short loc_1720
loc_1760:
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1768:
test al, 1
jnz short loc_1790
mov edx, eax
sar edx, 1
movsxd rdx, edx
movss xmm0, dword ptr [rdi+rdx*4]
movss dword ptr [r12+rax*4], xmm0
add rax, 1
cmp rax, rbp
jnz short loc_1768
loc_1787:
pop rbx
pop rbp
pop r12
jmp _free
loc_1790:
movss xmm0, dword ptr [rbx+rax*4]
movss dword ptr [r12+rax*4], xmm0
add rax, 1
cmp rbp, rax
jnz short loc_1768
pop rbx
pop rbp
pop r12
jmp _free
loc_17B0:
sub ecx, 1
jmp loc_1720
loc_17B8:
lea ecx, [rsi+1]
test esi, esi
jnz loc_1714
jmp short loc_1760
loc_17C5:
xor ecx, ecx
xor eax, eax
jmp loc_16B0
|
void func0(long long a1, int a2, long long a3)
{
long long v4; // rbp
__m128i *v6; // rdi
unsigned int v7; // esi
unsigned long long v8; // rax
unsigned int v9; // edx
int v10; // ecx
int v11; // eax
long long v12; // rcx
long long v13; // r8
int v14; // ecx
__m128i *v15; // rax
__m128 v16; // xmm0
long long v17; // rax
v4 = a2;
v6 = (__m128i *)malloc(4LL * (a2 / 2 + 1));
if ( a2 <= 0 )
goto LABEL_20;
v7 = (unsigned int)(a2 - 1) >> 1;
if ( (unsigned int)(v4 - 1) <= 7 )
{
v10 = 0;
v11 = 0;
}
else
{
v8 = 0LL;
v9 = (unsigned int)(v4 - 1) >> 3;
do
{
v6[v8 / 0x10] = (__m128i)_mm_shuffle_ps(*(__m128 *)(a1 + 2 * v8), *(__m128 *)(a1 + 2 * v8 + 16), 136);
v8 += 16LL;
}
while ( 16LL * ((unsigned int)(v4 - 1) >> 3) != v8 );
v10 = 4 * v9;
v11 = 8 * v9;
}
v12 = v10;
v13 = 4LL * v11;
v6->m128i_i32[v12] = *(_DWORD *)(a1 + v13);
if ( (int)v4 <= v11 + 2 )
{
v14 = v7 + 1;
if ( !v7 )
goto LABEL_17;
}
else
{
v6->m128i_i32[v12 + 1] = *(_DWORD *)(a1 + v13 + 8);
if ( (int)v4 > v11 + 4 )
{
v6->m128i_i32[v12 + 2] = *(_DWORD *)(a1 + v13 + 16);
if ( (int)v4 > v11 + 6 )
v6->m128i_i32[v12 + 3] = *(_DWORD *)(a1 + v13 + 24);
}
v14 = v7 + 1;
}
do
{
while ( v14 <= 1 )
--v14;
v15 = v6;
do
{
v16 = (__m128)_mm_loadl_epi64(v15);
if ( v16.m128_f32[0] > _mm_shuffle_ps(v16, v16, 229).m128_f32[0] )
_mm_storel_ps((double *)v15->m128i_i64, _mm_shuffle_ps(v16, v16, 225));
v15 = (__m128i *)((char *)v15 + 4);
}
while ( (__m128i *)((char *)v6->m128i_i64 + 4 * (unsigned int)(v14 - 2) + 4) != v15 );
--v14;
}
while ( v14 != 1 );
LABEL_17:
v17 = 0LL;
do
{
while ( (v17 & 1) == 0 )
{
*(_DWORD *)(a3 + 4 * v17) = v6->m128i_i32[(int)v17 >> 1];
if ( ++v17 == v4 )
goto LABEL_20;
}
*(_DWORD *)(a3 + 4 * v17) = *(_DWORD *)(a1 + 4 * v17);
++v17;
}
while ( v4 != v17 );
LABEL_20:
free(v6);
}
|
func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RDI
MOV EDI,EBP
SHR EDI,0x1f
ADD EDI,EBP
SAR EDI,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST EBP,EBP
JLE 0x00101787
LEA EAX,[RBP + -0x1]
MOV ESI,EAX
SHR ESI,0x1
CMP EAX,0x7
JBE 0x001017c5
SHR EAX,0x3
MOV ECX,EAX
XOR EAX,EAX
MOV RDX,RCX
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101688:
MOVUPS XMM0,xmmword ptr [RBX + RAX*0x2]
MOVUPS XMM4,xmmword ptr [RBX + RAX*0x2 + 0x10]
SHUFPS XMM0,XMM4,0x88
MOVUPS xmmword ptr [RDI + RAX*0x1],XMM0
ADD RAX,0x10
CMP RCX,RAX
JNZ 0x00101688
LEA ECX,[RDX*0x4]
LEA EAX,[RDX*0x8]
LAB_001016b0:
MOVSXD R9,EAX
MOVSXD RDX,ECX
MOVSS XMM0,dword ptr [RBX + R9*0x4]
LEA RCX,[RDX*0x4]
LEA R8,[R9*0x4]
MOVSS dword ptr [RDI + RDX*0x4],XMM0
LEA EDX,[RAX + 0x2]
CMP EBP,EDX
JLE 0x001017b8
MOVSS XMM0,dword ptr [RBX + R8*0x1 + 0x8]
LEA EDX,[RAX + 0x4]
MOVSS dword ptr [RDI + RCX*0x1 + 0x4],XMM0
CMP EBP,EDX
JLE 0x00101711
MOVSS XMM0,dword ptr [RBX + R8*0x1 + 0x10]
ADD EAX,0x6
MOVSS dword ptr [RDI + RCX*0x1 + 0x8],XMM0
CMP EBP,EAX
JLE 0x00101711
MOVSS XMM0,dword ptr [RBX + R8*0x1 + 0x18]
MOVSS dword ptr [RDI + RCX*0x1 + 0xc],XMM0
LAB_00101711:
LEA ECX,[RSI + 0x1]
LAB_00101714:
LEA RSI,[RDI + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101720:
CMP ECX,0x1
JLE 0x001017b0
LEA EDX,[RCX + -0x2]
MOV RAX,RDI
LEA RDX,[RSI + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101738:
MOVQ XMM0,qword ptr [RAX]
MOVAPS XMM3,XMM0
SHUFPS XMM3,XMM3,0xe5
COMISS XMM0,XMM3
JBE 0x0010174f
SHUFPS XMM0,XMM0,0xe1
MOVLPS qword ptr [RAX],XMM0
LAB_0010174f:
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x00101738
SUB ECX,0x1
CMP ECX,0x1
JNZ 0x00101720
LAB_00101760:
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101768:
TEST AL,0x1
JNZ 0x00101790
MOV EDX,EAX
SAR EDX,0x1
MOVSXD RDX,EDX
MOVSS XMM0,dword ptr [RDI + RDX*0x4]
MOVSS dword ptr [R12 + RAX*0x4],XMM0
ADD RAX,0x1
CMP RAX,RBP
JNZ 0x00101768
LAB_00101787:
POP RBX
POP RBP
POP R12
JMP 0x00101080
LAB_00101790:
MOVSS XMM0,dword ptr [RBX + RAX*0x4]
MOVSS dword ptr [R12 + RAX*0x4],XMM0
ADD RAX,0x1
CMP RBP,RAX
JNZ 0x00101768
POP RBX
POP RBP
POP R12
JMP 0x00101080
LAB_001017b0:
SUB ECX,0x1
JMP 0x00101720
LAB_001017b8:
LEA ECX,[RSI + 0x1]
TEST ESI,ESI
JNZ 0x00101714
JMP 0x00101760
LAB_001017c5:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x001016b0
|
void func0(long param_1,int param_2,long param_3)
{
int4 *puVar1;
long lVar2;
int4 *puVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
uint uVar7;
uint uVar8;
int iVar9;
int8 *__ptr;
long lVar10;
int8 *puVar11;
ulong uVar12;
int iVar13;
float fVar14;
float fVar15;
__ptr = (int8 *)malloc((long)(param_2 / 2 + 1) << 2);
if (param_2 < 1) goto LAB_00101787;
uVar7 = param_2 - 1;
if (uVar7 < 8) {
iVar13 = 0;
iVar9 = 0;
}
else {
uVar8 = uVar7 >> 3;
lVar10 = 0;
do {
puVar1 = (int4 *)(param_1 + lVar10 * 2);
uVar4 = puVar1[2];
puVar3 = (int4 *)(param_1 + 0x10 + lVar10 * 2);
uVar5 = *puVar3;
uVar6 = puVar3[2];
puVar3 = (int4 *)((long)__ptr + lVar10);
*puVar3 = *puVar1;
puVar3[1] = uVar4;
puVar3[2] = uVar5;
puVar3[3] = uVar6;
lVar10 = lVar10 + 0x10;
} while ((ulong)uVar8 << 4 != lVar10);
iVar13 = uVar8 * 4;
iVar9 = uVar8 * 8;
}
lVar10 = (long)iVar13 * 4;
lVar2 = (long)iVar9 * 4;
*(int4 *)((long)__ptr + (long)iVar13 * 4) = *(int4 *)(param_1 + (long)iVar9 * 4);
if (iVar9 + 2 < param_2) {
*(int4 *)((long)__ptr + lVar10 + 4) = *(int4 *)(param_1 + 8 + lVar2);
if ((iVar9 + 4 < param_2) &&
(*(int4 *)((long)__ptr + lVar10 + 8) = *(int4 *)(param_1 + 0x10 + lVar2),
iVar9 + 6 < param_2)) {
*(int4 *)((long)__ptr + lVar10 + 0xc) = *(int4 *)(param_1 + 0x18 + lVar2);
}
LAB_00101714:
iVar9 = (uVar7 >> 1) + 1;
do {
for (; iVar9 < 2; iVar9 = iVar9 + -1) {
}
puVar11 = __ptr;
do {
fVar14 = (float)*puVar11;
fVar15 = (float)((ulong)*puVar11 >> 0x20);
if (fVar15 < fVar14) {
*puVar11 = CONCAT44(fVar14,fVar15);
}
puVar11 = (int8 *)((long)puVar11 + 4);
} while ((int8 *)((long)__ptr + (ulong)(iVar9 - 2) * 4 + 4) != puVar11);
iVar9 = iVar9 + -1;
} while (iVar9 != 1);
}
else if (uVar7 >> 1 != 0) goto LAB_00101714;
uVar12 = 0;
do {
while ((uVar12 & 1) != 0) {
*(int4 *)(param_3 + uVar12 * 4) = *(int4 *)(param_1 + uVar12 * 4);
uVar12 = uVar12 + 1;
if ((long)param_2 == uVar12) {
free(__ptr);
return;
}
}
*(int4 *)(param_3 + uVar12 * 4) =
*(int4 *)((long)__ptr + (long)((int)uVar12 >> 1) * 4);
uVar12 = uVar12 + 1;
} while (uVar12 != (long)param_2);
LAB_00101787:
free(__ptr);
return;
}
|
808 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char temp = x[2];
x[2] = x[1];
x[1] = x[0];
x[0] = temp;
} else {
char temp = x[0];
x[0] = x[1];
x[1] = x[2];
x[2] = temp;
}
}
strncpy(s + i * 3, x, len);
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] = 'a' + rand() % 26;
}
str[l] = '\0';
strcpy(temp, str);
func0(temp, 1); // Encode
strcpy(decoded_str, temp);
func0(decoded_str, 0); // Decode
assert(strcmp(decoded_str, str) == 0);
}
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
add $0x2,%eax
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%ecx
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0x14(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 1376 <func0+0x12d>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
cmp %eax,-0x18(%rbp)
jge 12c8 <func0+0x7f>
mov -0x1c(%rbp),%eax
mov %eax,%edx
shl $0x2,%eax
sub %eax,%edx
mov -0x18(%rbp),%eax
add %edx,%eax
jmp 12cd <func0+0x84>
mov $0x3,%eax
mov %eax,-0x10(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rcx
mov -0x1c(%rbp),%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rsi
lea -0xc(%rbp),%rax
mov %rcx,%rdx
mov %rax,%rdi
callq 10d0 <strncpy@plt>
mov -0x10(%rbp),%eax
cltq
movb $0x0,-0xc(%rbp,%rax,1)
cmpl $0x3,-0x10(%rbp)
jne 1349 <func0+0x100>
cmpl $0x0,-0x2c(%rbp)
je 132d <func0+0xe4>
movzbl -0xa(%rbp),%eax
mov %al,-0x1d(%rbp)
movzbl -0xb(%rbp),%eax
mov %al,-0xa(%rbp)
movzbl -0xc(%rbp),%eax
mov %al,-0xb(%rbp)
movzbl -0x1d(%rbp),%eax
mov %al,-0xc(%rbp)
jmp 1349 <func0+0x100>
movzbl -0xc(%rbp),%eax
mov %al,-0x1e(%rbp)
movzbl -0xb(%rbp),%eax
mov %al,-0xc(%rbp)
movzbl -0xa(%rbp),%eax
mov %al,-0xb(%rbp)
movzbl -0x1e(%rbp),%eax
mov %al,-0xa(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rcx
mov -0x1c(%rbp),%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rdi
lea -0xc(%rbp),%rax
mov %rcx,%rdx
mov %rax,%rsi
callq 10d0 <strncpy@plt>
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 12a6 <func0+0x5d>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 1397 <func0+0x14e>
callq 1100 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
add eax, 2
movsxd rdx, eax
imul rdx, 55555556h
mov rcx, rdx
shr rcx, 20h
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_14], eax
mov [rbp+var_1C], 0
jmp loc_1375
loc_12A5:
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov eax, edx
add eax, eax
add eax, edx
cmp [rbp+var_18], eax
jge short loc_12C7
mov eax, [rbp+var_1C]
mov edx, eax
shl eax, 2
sub edx, eax
mov eax, [rbp+var_18]
add eax, edx
jmp short loc_12CC
loc_12C7:
mov eax, 3
loc_12CC:
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
movsxd rcx, eax
mov edx, [rbp+var_1C]
mov eax, edx
add eax, eax
add eax, edx
movsxd rdx, eax
mov rax, [rbp+s]
lea rsi, [rdx+rax]; src
lea rax, [rbp+dest]
mov rdx, rcx; n
mov rdi, rax; dest
call _strncpy
mov eax, [rbp+var_10]
cdqe
mov [rbp+rax+dest], 0
cmp [rbp+var_10], 3
jnz short loc_1348
cmp [rbp+var_2C], 0
jz short loc_132C
movzx eax, [rbp+var_A]
mov [rbp+var_1D], al
movzx eax, [rbp+var_B]
mov [rbp+var_A], al
movzx eax, [rbp+dest]
mov [rbp+var_B], al
movzx eax, [rbp+var_1D]
mov [rbp+dest], al
jmp short loc_1348
loc_132C:
movzx eax, [rbp+dest]
mov [rbp+var_1E], al
movzx eax, [rbp+var_B]
mov [rbp+dest], al
movzx eax, [rbp+var_A]
mov [rbp+var_B], al
movzx eax, [rbp+var_1E]
mov [rbp+var_A], al
loc_1348:
mov eax, [rbp+var_10]
movsxd rcx, eax
mov edx, [rbp+var_1C]
mov eax, edx
add eax, eax
add eax, edx
movsxd rdx, eax
mov rax, [rbp+s]
lea rdi, [rdx+rax]; dest
lea rax, [rbp+dest]
mov rdx, rcx; n
mov rsi, rax; src
call _strncpy
add [rbp+var_1C], 1
loc_1375:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_14]
jl loc_12A5
nop
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_1396
call ___stack_chk_fail
locret_1396:
leave
retn
|
unsigned long long func0(const char *a1, int a2)
{
int v2; // eax
char v4; // [rsp+12h] [rbp-1Eh]
char v5; // [rsp+13h] [rbp-1Dh]
int i; // [rsp+14h] [rbp-1Ch]
int v7; // [rsp+18h] [rbp-18h]
int v8; // [rsp+20h] [rbp-10h]
char dest; // [rsp+24h] [rbp-Ch] BYREF
char v10; // [rsp+25h] [rbp-Bh]
char v11; // [rsp+26h] [rbp-Ah]
unsigned long long v12; // [rsp+28h] [rbp-8h]
v12 = __readfsqword(0x28u);
v7 = strlen(a1);
for ( i = 0; i < (v7 + 2) / 3; ++i )
{
if ( v7 >= 3 * (i + 1) )
v2 = 3;
else
v2 = -3 * i + v7;
v8 = v2;
strncpy(&dest, &a1[3 * i], v2);
*(&dest + v8) = 0;
if ( v8 == 3 )
{
if ( a2 )
{
v5 = v11;
v11 = v10;
v10 = dest;
dest = v5;
}
else
{
v4 = dest;
dest = v10;
v10 = v11;
v11 = v4;
}
}
strncpy((char *)&a1[3 * i], &dest, v8);
}
return v12 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x2
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
MOV RCX,RDX
SHR RCX,0x20
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101375
LAB_001012a5:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
CMP dword ptr [RBP + -0x18],EAX
JGE 0x001012c7
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHL EAX,0x2
SUB EDX,EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
JMP 0x001012cc
LAB_001012c7:
MOV EAX,0x3
LAB_001012cc:
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RCX,EAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RSI,[RDX + RAX*0x1]
LEA RAX,[RBP + -0xc]
MOV RDX,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV EAX,dword ptr [RBP + -0x10]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xc],0x0
CMP dword ptr [RBP + -0x10],0x3
JNZ 0x00101348
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0010132c
MOVZX EAX,byte ptr [RBP + -0xa]
MOV byte ptr [RBP + -0x1d],AL
MOVZX EAX,byte ptr [RBP + -0xb]
MOV byte ptr [RBP + -0xa],AL
MOVZX EAX,byte ptr [RBP + -0xc]
MOV byte ptr [RBP + -0xb],AL
MOVZX EAX,byte ptr [RBP + -0x1d]
MOV byte ptr [RBP + -0xc],AL
JMP 0x00101348
LAB_0010132c:
MOVZX EAX,byte ptr [RBP + -0xc]
MOV byte ptr [RBP + -0x1e],AL
MOVZX EAX,byte ptr [RBP + -0xb]
MOV byte ptr [RBP + -0xc],AL
MOVZX EAX,byte ptr [RBP + -0xa]
MOV byte ptr [RBP + -0xb],AL
MOVZX EAX,byte ptr [RBP + -0x1e]
MOV byte ptr [RBP + -0xa],AL
LAB_00101348:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RCX,EAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDI,[RDX + RAX*0x1]
LEA RAX,[RBP + -0xc]
MOV RDX,RCX
MOV RSI,RAX
CALL 0x001010d0
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101375:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x001012a5
NOP
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101396
CALL 0x00101100
LAB_00101396:
LEAVE
RET
|
void func0(char *param_1,int param_2)
{
char cVar1;
char cVar2;
int iVar3;
int iVar4;
size_t sVar5;
long in_FS_OFFSET;
int local_24;
char local_14 [4];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar5 = strlen(param_1);
iVar3 = (int)sVar5;
for (local_24 = 0; local_24 < (iVar3 + 2) / 3; local_24 = local_24 + 1) {
if (iVar3 < (local_24 + 1) * 3) {
iVar4 = iVar3 + local_24 * -3;
}
else {
iVar4 = 3;
}
strncpy(local_14,param_1 + local_24 * 3,(long)iVar4);
local_14[iVar4] = '\0';
cVar2 = local_14[2];
cVar1 = local_14[0];
if (iVar4 == 3) {
if (param_2 == 0) {
local_14[0] = local_14[1];
local_14[1] = local_14[2];
local_14[2] = cVar1;
}
else {
local_14[2] = local_14[1];
local_14[1] = local_14[0];
local_14[0] = cVar2;
}
}
strncpy(param_1 + local_24 * 3,local_14,(long)iVar4);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
809 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char temp = x[2];
x[2] = x[1];
x[1] = x[0];
x[0] = temp;
} else {
char temp = x[0];
x[0] = x[1];
x[1] = x[2];
x[2] = temp;
}
}
strncpy(s + i * 3, x, len);
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] = 'a' + rand() % 26;
}
str[l] = '\0';
strcpy(temp, str);
func0(temp, 1); // Encode
strcpy(decoded_str, temp);
func0(decoded_str, 0); // Decode
assert(strcmp(decoded_str, str) == 0);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
mov %ebp,0x8(%rsp)
lea 0x2(%rbp),%eax
movslq %eax,%r15
imul $0x55555556,%r15,%r15
shr $0x20,%r15
sar $0x1f,%eax
sub %eax,%r15d
test %ebp,%ebp
jle 1360 <func0+0x117>
mov $0x0,%ebx
lea 0x14(%rsp),%r14
jmp 12f1 <func0+0xa8>
movslq %ebp,%r13
mov %r12,(%rsp)
mov $0x4,%ecx
mov %r13,%rdx
mov %r12,%rsi
mov %r14,%rdi
callq 1130 <__strncpy_chk@plt>
movb $0x0,0x14(%rsp,%r13,1)
cmp $0x3,%ebp
je 131c <func0+0xd3>
mov %r13,%rdx
mov %r14,%rsi
mov (%rsp),%rdi
callq 10d0 <strncpy@plt>
add $0x3,%r12
sub $0x3,%ebp
cmp %r15d,%ebx
jge 1360 <func0+0x117>
add $0x1,%ebx
lea (%rbx,%rbx,2),%eax
cmp %eax,0x8(%rsp)
jl 12b1 <func0+0x68>
mov %r12,(%rsp)
mov $0x3,%edx
mov %r12,%rsi
mov %r14,%rdi
callq 10d0 <strncpy@plt>
movb $0x0,0x17(%rsp)
mov $0x3,%r13d
cmpl $0x0,0xc(%rsp)
je 1340 <func0+0xf7>
movzbl 0x16(%rsp),%eax
movzbl 0x15(%rsp),%edx
mov %dl,0x16(%rsp)
movzbl 0x14(%rsp),%edx
mov %dl,0x15(%rsp)
mov %al,0x14(%rsp)
jmp 12d6 <func0+0x8d>
movzbl 0x14(%rsp),%eax
movzbl 0x15(%rsp),%edx
mov %dl,0x14(%rsp)
movzbl 0x16(%rsp),%edx
mov %dl,0x15(%rsp)
mov %al,0x16(%rsp)
jmpq 12d6 <func0+0x8d>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 137f <func0+0x136>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10e0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbp, rdi
mov [rsp+58h+var_4C], esi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strlen
mov r12, rax
mov [rsp+58h+var_50], eax
lea eax, [rax+2]
movsxd r15, eax
imul r15, 55555556h
shr r15, 20h
sar eax, 1Fh
sub r15d, eax
test r12d, r12d
jle loc_137B
mov ebx, 0
lea r14, [rsp+58h+src]
jmp short loc_130C
loc_12CA:
movsxd r13, r12d
mov [rsp+58h+dest], rbp
mov ecx, 4
mov rdx, r13
mov rsi, rbp
mov rdi, r14
call ___strncpy_chk
mov [rsp+r13+58h+src], 0
cmp r12d, 3
jz short loc_1337
loc_12F0:
mov rdx, r13; n
mov rsi, r14; src
mov rdi, [rsp+58h+dest]; dest
call _strncpy
add rbp, 3
sub r12d, 3
cmp ebx, r15d
jge short loc_137B
loc_130C:
add ebx, 1
lea eax, [rbx+rbx*2]
cmp [rsp+58h+var_50], eax
jl short loc_12CA
mov [rsp+58h+dest], rbp
mov edx, 3; n
mov rsi, rbp; src
mov rdi, r14; dest
call _strncpy
mov [rsp+58h+var_41], 0
mov r13d, 3
loc_1337:
cmp [rsp+58h+var_4C], 0
jz short loc_135B
movzx eax, [rsp+58h+var_42]
movzx edx, [rsp+58h+var_43]
mov [rsp+58h+var_42], dl
movzx edx, [rsp+58h+src]
mov [rsp+58h+var_43], dl
mov [rsp+58h+src], al
jmp short loc_12F0
loc_135B:
movzx eax, [rsp+58h+src]
movzx edx, [rsp+58h+var_43]
mov [rsp+58h+src], dl
movzx edx, [rsp+58h+var_42]
mov [rsp+58h+var_43], dl
mov [rsp+58h+var_42], al
jmp loc_12F0
loc_137B:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_139A
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_139A:
call ___stack_chk_fail
|
unsigned long long func0(char *src, int a2)
{
const char *v2; // rbp
int v3; // r12d
int v4; // r15d
int v5; // ebx
size_t v6; // r13
char v7; // al
char v8; // al
char *dest; // [rsp+0h] [rbp-58h]
int v11; // [rsp+8h] [rbp-50h]
char srca[4]; // [rsp+14h] [rbp-44h] BYREF
unsigned long long v13; // [rsp+18h] [rbp-40h]
v2 = src;
v13 = __readfsqword(0x28u);
v3 = strlen(src);
v11 = v3;
v4 = (v3 + 2) / 3;
if ( v3 > 0 )
{
v5 = 0;
while ( 1 )
{
++v5;
if ( v11 >= 3 * v5 )
break;
v6 = v3;
dest = (char *)v2;
__strncpy_chk(srca, v2, v3, 4LL);
srca[v3] = 0;
if ( v3 == 3 )
goto LABEL_7;
LABEL_4:
strncpy(dest, srca, v6);
v2 += 3;
v3 -= 3;
if ( v5 >= v4 )
return v13 - __readfsqword(0x28u);
}
dest = (char *)v2;
strncpy(srca, v2, 3uLL);
srca[3] = 0;
v6 = 3LL;
LABEL_7:
if ( a2 )
{
v7 = srca[2];
*(_WORD *)&srca[1] = *(_WORD *)srca;
srca[0] = v7;
}
else
{
v8 = srca[0];
*(_WORD *)srca = *(_WORD *)&srca[1];
srca[2] = v8;
}
goto LABEL_4;
}
return v13 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBP,RDI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV R12,RAX
MOV dword ptr [RSP + 0x8],EAX
LEA EAX,[RAX + 0x2]
MOVSXD R15,EAX
IMUL R15,R15,0x55555556
SHR R15,0x20
SAR EAX,0x1f
SUB R15D,EAX
TEST R12D,R12D
JLE 0x0010137b
MOV EBX,0x0
LEA R14,[RSP + 0x14]
JMP 0x0010130c
LAB_001012ca:
MOVSXD R13,R12D
MOV qword ptr [RSP],RBP
MOV ECX,0x4
MOV RDX,R13
MOV RSI,RBP
MOV RDI,R14
CALL 0x00101150
MOV byte ptr [RSP + R13*0x1 + 0x14],0x0
CMP R12D,0x3
JZ 0x00101337
LAB_001012f0:
MOV RDX,R13
MOV RSI,R14
MOV RDI,qword ptr [RSP]
CALL 0x001010e0
ADD RBP,0x3
SUB R12D,0x3
CMP EBX,R15D
JGE 0x0010137b
LAB_0010130c:
ADD EBX,0x1
LEA EAX,[RBX + RBX*0x2]
CMP dword ptr [RSP + 0x8],EAX
JL 0x001012ca
MOV qword ptr [RSP],RBP
MOV EDX,0x3
MOV RSI,RBP
MOV RDI,R14
CALL 0x001010e0
MOV byte ptr [RSP + 0x17],0x0
MOV R13D,0x3
LAB_00101337:
CMP dword ptr [RSP + 0xc],0x0
JZ 0x0010135b
MOVZX EAX,byte ptr [RSP + 0x16]
MOVZX EDX,byte ptr [RSP + 0x15]
MOV byte ptr [RSP + 0x16],DL
MOVZX EDX,byte ptr [RSP + 0x14]
MOV byte ptr [RSP + 0x15],DL
MOV byte ptr [RSP + 0x14],AL
JMP 0x001012f0
LAB_0010135b:
MOVZX EAX,byte ptr [RSP + 0x14]
MOVZX EDX,byte ptr [RSP + 0x15]
MOV byte ptr [RSP + 0x14],DL
MOVZX EDX,byte ptr [RSP + 0x16]
MOV byte ptr [RSP + 0x15],DL
MOV byte ptr [RSP + 0x16],AL
JMP 0x001012f0
LAB_0010137b:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010139a
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010139a:
CALL 0x00101100
|
void func0(char *param_1,int param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
int iVar4;
int iVar5;
long in_FS_OFFSET;
char local_44 [4];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (0 < iVar2) {
iVar4 = 0;
do {
iVar4 = iVar4 + 1;
iVar5 = (int)sVar3;
if (SBORROW4(iVar2,iVar4 * 3) == iVar2 + iVar4 * -3 < 0) {
strncpy(local_44,param_1,3);
local_44[3] = 0;
sVar3 = 3;
LAB_00101337:
cVar1 = local_44[0];
if (param_2 == 0) {
local_44[0] = local_44[1];
local_44[1] = local_44[2];
local_44[2] = cVar1;
}
else {
cVar1 = local_44[2];
local_44[2] = local_44[1];
local_44[1] = local_44[0];
local_44[0] = cVar1;
}
}
else {
sVar3 = (size_t)iVar5;
__strncpy_chk(local_44,param_1,sVar3,4);
local_44[sVar3] = '\0';
if (iVar5 == 3) goto LAB_00101337;
}
strncpy(param_1,local_44,sVar3);
param_1 = param_1 + 3;
sVar3 = (size_t)(iVar5 - 3);
} while (iVar4 < (iVar2 + 2) / 3);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
810 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char temp = x[2];
x[2] = x[1];
x[1] = x[0];
x[0] = temp;
} else {
char temp = x[0];
x[0] = x[1];
x[1] = x[2];
x[2] = temp;
}
}
strncpy(s + i * 3, x, len);
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] = 'a' + rand() % 26;
}
str[l] = '\0';
strcpy(temp, str);
func0(temp, 1); // Encode
strcpy(decoded_str, temp);
func0(decoded_str, 0); // Decode
assert(strcmp(decoded_str, str) == 0);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
lea 0x2(%rax),%edx
lea (%rax,%rbx,1),%edi
mov %eax,0x4(%rsp)
movslq %edx,%r12
sar $0x1f,%edx
mov %edi,0x8(%rsp)
imul $0x55555556,%r12,%r12
shr $0x20,%r12
sub %edx,%r12d
test %eax,%eax
jle 14f0 <func0+0x120>
xor %r15d,%r15d
lea 0x14(%rsp),%rbp
jmp 1497 <func0+0xc7>
nopw 0x0(%rax,%rax,1)
mov $0x3,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10e0 <strncpy@plt>
movb $0x0,0x17(%rsp)
mov 0xc(%rsp),%esi
movzbl 0x15(%rsp),%ecx
movzbl 0x16(%rsp),%edx
movzbl 0x14(%rsp),%eax
test %esi,%esi
je 14d8 <func0+0x108>
mov %cl,0x16(%rsp)
mov $0x3,%r14d
mov %al,0x15(%rsp)
mov %dl,0x14(%rsp)
nopw %cs:0x0(%rax,%rax,1)
mov %rbx,%rdi
mov %r14,%rdx
mov %rbp,%rsi
add $0x3,%rbx
callq 10e0 <strncpy@plt>
cmp %r12d,%r15d
jge 14f0 <func0+0x120>
add $0x1,%r15d
lea (%r15,%r15,2),%eax
cmp 0x4(%rsp),%eax
jle 1438 <func0+0x68>
mov 0x8(%rsp),%r13d
mov $0x4,%ecx
mov %rbx,%rsi
mov %rbp,%rdi
sub %ebx,%r13d
movslq %r13d,%r14
mov %r14,%rdx
callq 1150 <__strncpy_chk@plt>
movb $0x0,0x14(%rsp,%r14,1)
cmp $0x3,%r13d
jne 1480 <func0+0xb0>
jmpq 144d <func0+0x7d>
nopl 0x0(%rax)
mov %cl,0x14(%rsp)
mov $0x3,%r14d
mov %dl,0x15(%rsp)
mov %al,0x16(%rsp)
jmp 1480 <func0+0xb0>
nopl 0x0(%rax)
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 150f <func0+0x13f>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1100 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov [rsp+58h+var_4C], esi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strlen
mov rbp, rax
mov r14d, eax
add eax, 2
movsxd r13, eax
sar eax, 1Fh
imul r13, 55555556h
shr r13, 20h
sub r13d, eax
test ebp, ebp
jle loc_14D0
xor r15d, r15d
lea r12, [rsp+58h+dest]
jmp short loc_1486
loc_1430:
mov edx, 3; n
mov rsi, rbx; src
mov rdi, r12; dest
call _strncpy
mov [rsp+58h+var_41], 0
loc_1445:
mov esi, [rsp+58h+var_4C]
movzx eax, word ptr [rsp+58h+dest+1]
movzx ecx, [rsp+58h+var_42]
movzx edx, [rsp+58h+dest]
test esi, esi
jz short loc_14C0
mov [rsp+58h+var_42], al
movzx eax, cl
mov ah, dl
mov word ptr [rsp+58h+dest], ax
loc_146A:
mov edx, 3; n
loc_146F:
mov rdi, rbx; dest
mov rsi, r12; src
add rbx, 3
sub ebp, 3
call _strncpy
cmp r15d, r13d
jge short loc_14D0
loc_1486:
add r15d, 1
lea eax, [r15+r15*2]
cmp eax, r14d
jle short loc_1430
movsxd rdx, ebp
mov ecx, 4
mov rsi, rbx
mov rdi, r12
mov [rsp+58h+var_58], rdx
call ___strncpy_chk
mov rdx, [rsp+58h+var_58]
mov [rsp+rdx+58h+dest], 0
cmp ebp, 3
jnz short loc_146F
jmp short loc_1445
loc_14C0:
mov word ptr [rsp+58h+dest], ax
mov [rsp+58h+var_42], dl
jmp short loc_146A
loc_14D0:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_14EF
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14EF:
call ___stack_chk_fail
|
unsigned long long func0(char *dest, int a2)
{
const char *v2; // rbx
int v3; // ebp
int v4; // r14d
int v5; // r13d
int v6; // r15d
char v7; // cl
char v8; // dl
__int16 v9; // ax
size_t v10; // rdx
char *v11; // rdi
_BYTE desta[3]; // [rsp+14h] [rbp-44h] BYREF
char v14; // [rsp+17h] [rbp-41h]
unsigned long long v15; // [rsp+18h] [rbp-40h]
v2 = dest;
v15 = __readfsqword(0x28u);
v3 = strlen(dest);
v4 = v3;
v5 = (v3 + 2) / 3;
if ( v3 > 0 )
{
v6 = 0;
while ( 1 )
{
++v6;
if ( 3 * v6 <= v4 )
break;
__strncpy_chk(desta, v2, v3, 4LL);
v10 = v3;
desta[v3] = 0;
if ( v3 == 3 )
goto LABEL_4;
LABEL_7:
v11 = (char *)v2;
v2 += 3;
v3 -= 3;
strncpy(v11, desta, v10);
if ( v6 >= v5 )
return v15 - __readfsqword(0x28u);
}
strncpy(desta, v2, 3uLL);
v14 = 0;
LABEL_4:
v7 = desta[2];
v8 = desta[0];
if ( a2 )
{
desta[2] = desta[1];
LOBYTE(v9) = v7;
HIBYTE(v9) = desta[0];
*(_WORD *)desta = v9;
}
else
{
*(_WORD *)desta = *(_WORD *)&desta[1];
desta[2] = v8;
}
v10 = 3LL;
goto LABEL_7;
}
return v15 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV R14D,EAX
ADD EAX,0x2
MOVSXD R13,EAX
SAR EAX,0x1f
IMUL R13,R13,0x55555556
SHR R13,0x20
SUB R13D,EAX
TEST EBP,EBP
JLE 0x001014d0
XOR R15D,R15D
LEA R12,[RSP + 0x14]
JMP 0x00101486
LAB_00101430:
MOV EDX,0x3
MOV RSI,RBX
MOV RDI,R12
CALL 0x001010e0
MOV byte ptr [RSP + 0x17],0x0
LAB_00101445:
MOV ESI,dword ptr [RSP + 0xc]
MOVZX EAX,word ptr [RSP + 0x15]
MOVZX ECX,byte ptr [RSP + 0x16]
MOVZX EDX,byte ptr [RSP + 0x14]
TEST ESI,ESI
JZ 0x001014c0
MOV byte ptr [RSP + 0x16],AL
MOVZX EAX,CL
MOV AH,DL
MOV word ptr [RSP + 0x14],AX
LAB_0010146a:
MOV EDX,0x3
LAB_0010146f:
MOV RDI,RBX
MOV RSI,R12
ADD RBX,0x3
SUB EBP,0x3
CALL 0x001010e0
CMP R15D,R13D
JGE 0x001014d0
LAB_00101486:
ADD R15D,0x1
LEA EAX,[R15 + R15*0x2]
CMP EAX,R14D
JLE 0x00101430
MOVSXD RDX,EBP
MOV ECX,0x4
MOV RSI,RBX
MOV RDI,R12
MOV qword ptr [RSP],RDX
CALL 0x00101150
MOV RDX,qword ptr [RSP]
MOV byte ptr [RSP + RDX*0x1 + 0x14],0x0
CMP EBP,0x3
JNZ 0x0010146f
JMP 0x00101445
LAB_001014c0:
MOV word ptr [RSP + 0x14],AX
MOV byte ptr [RSP + 0x16],DL
JMP 0x0010146a
LAB_001014d0:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014ef
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014ef:
CALL 0x00101100
|
void func0(char *param_1,int param_2)
{
int2 uVar1;
int iVar2;
size_t sVar3;
size_t __n;
int iVar4;
int iVar5;
long in_FS_OFFSET;
int local_44 [2];
char cStack_42;
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (0 < iVar2) {
iVar5 = 0;
do {
iVar5 = iVar5 + 1;
iVar4 = (int)sVar3;
if (iVar2 < iVar5 * 3) {
__n = (size_t)iVar4;
__strncpy_chk(local_44,param_1,__n,4);
local_44[__n] = 0;
if (iVar4 == 3) goto LAB_00101445;
}
else {
strncpy(local_44,param_1,3);
local_41 = 0;
LAB_00101445:
uVar1 = stack0xffffffffffffffbd;
if (param_2 == 0) {
_local_44 = CONCAT12(local_44[0],uVar1);
}
else {
_local_44 = CONCAT12((char)((uint3)_local_44 >> 8),CONCAT11(local_44[0],cStack_42));
}
__n = 3;
}
sVar3 = (size_t)(iVar4 - 3);
strncpy(param_1,local_44,__n);
param_1 = param_1 + 3;
} while (iVar5 < (iVar2 + 2) / 3);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
811 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char temp = x[2];
x[2] = x[1];
x[1] = x[0];
x[0] = temp;
} else {
char temp = x[0];
x[0] = x[1];
x[1] = x[2];
x[2] = temp;
}
}
strncpy(s + i * 3, x, len);
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] = 'a' + rand() % 26;
}
str[l] = '\0';
strcpy(temp, str);
func0(temp, 1); // Encode
strcpy(decoded_str, temp);
func0(decoded_str, 0); // Decode
assert(strcmp(decoded_str, str) == 0);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
mov %esi,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
mov %rax,%rbp
mov %eax,%r13d
add $0x2,%eax
movslq %eax,%r12
sar $0x1f,%eax
imul $0x55555556,%r12,%r12
shr $0x20,%r12
sub %eax,%r12d
test %ebp,%ebp
jle 1688 <func0+0xe8>
test %r15d,%r15d
jne 16b0 <func0+0x110>
lea 0x14(%rsp),%r14
jmp 164c <func0+0xac>
nopw 0x0(%rax,%rax,1)
mov $0x3,%edx
mov %rbx,%rsi
mov %r14,%rdi
callq 10e0 <strncpy@plt>
movb $0x0,0x17(%rsp)
movzbl 0x14(%rsp),%eax
movzwl 0x15(%rsp),%edx
mov %al,0x16(%rsp)
mov %dx,0x14(%rsp)
mov $0x3,%edx
mov %rbx,%rdi
mov %r14,%rsi
add $0x3,%rbx
sub $0x3,%ebp
callq 10e0 <strncpy@plt>
cmp %r15d,%r12d
jle 1688 <func0+0xe8>
add $0x1,%r15d
lea (%r15,%r15,2),%eax
cmp %eax,%r13d
jge 1608 <func0+0x68>
movslq %ebp,%rdx
mov $0x4,%ecx
mov %rbx,%rsi
mov %r14,%rdi
mov %rdx,0x8(%rsp)
callq 1160 <__strncpy_chk@plt>
mov 0x8(%rsp),%rdx
movb $0x0,0x14(%rsp,%rdx,1)
cmp $0x3,%ebp
jne 1635 <func0+0x95>
jmp 161d <func0+0x7d>
nopw 0x0(%rax,%rax,1)
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 173a <func0+0x19a>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %r15d,%r15d
lea 0x14(%rsp),%r14
jmp 1704 <func0+0x164>
nopw 0x0(%rax,%rax,1)
mov $0x3,%edx
mov %rbx,%rsi
mov %r14,%rdi
callq 10e0 <strncpy@plt>
movb $0x0,0x17(%rsp)
movzbl 0x16(%rsp),%eax
movzwl 0x14(%rsp),%edx
mov %al,0x14(%rsp)
mov %dx,0x15(%rsp)
mov $0x3,%edx
mov %rbx,%rdi
mov %r14,%rsi
add $0x3,%rbx
sub $0x3,%ebp
callq 10e0 <strncpy@plt>
cmp %r12d,%r15d
jge 1688 <func0+0xe8>
add $0x1,%r15d
lea (%r15,%r15,2),%eax
cmp %eax,%r13d
jge 16c0 <func0+0x120>
movslq %ebp,%rdx
mov $0x4,%ecx
mov %rbx,%rsi
mov %r14,%rdi
mov %rdx,0x8(%rsp)
callq 1160 <__strncpy_chk@plt>
mov 0x8(%rsp),%rdx
movb $0x0,0x14(%rsp,%rdx,1)
cmp $0x3,%ebp
jne 16ed <func0+0x14d>
jmp 16d5 <func0+0x135>
callq 1100 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
mov r15d, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strlen
mov rbp, rax
mov r14d, eax
add eax, 2
movsxd r13, eax
sar eax, 1Fh
imul r13, 55555556h
shr r13, 20h
sub r13d, eax
test ebp, ebp
jle loc_1698
test r15d, r15d
jnz loc_16C0
lea r12, [rsp+58h+dest]
jmp short loc_165C
loc_1618:
mov edx, 3; n
mov rsi, rbx; src
mov rdi, r12; dest
call _strncpy
mov [rsp+58h+var_41], 0
loc_162D:
movzx eax, [rsp+58h+dest]
movzx edx, word ptr [rsp+58h+dest+1]
mov [rsp+58h+var_42], al
mov word ptr [rsp+58h+dest], dx
mov edx, 3; n
loc_1645:
mov rdi, rbx; dest
mov rsi, r12; src
add rbx, 3
sub ebp, 3
call _strncpy
cmp r13d, r15d
jle short loc_1698
loc_165C:
add r15d, 1
lea eax, [r15+r15*2]
cmp r14d, eax
jge short loc_1618
movsxd rdx, ebp
mov ecx, 4
mov rsi, rbx
mov rdi, r12
mov [rsp+58h+var_50], rdx
call ___strncpy_chk
mov rdx, [rsp+58h+var_50]
mov [rsp+rdx+58h+dest], 0
cmp ebp, 3
jnz short loc_1645
jmp short loc_162D
loc_1698:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz loc_174E
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16C0:
xor r15d, r15d
lea r12, [rsp+58h+dest]
jmp short loc_1718
loc_16D0:
mov edx, 3; n
mov rsi, rbx; src
mov rdi, r12; dest
call _strncpy
mov [rsp+58h+var_41], 0
loc_16E5:
movzx eax, [rsp+58h+var_42]
mov ah, [rsp+58h+dest]
movzx edx, [rsp+58h+dest+1]
mov word ptr [rsp+58h+dest], ax
mov [rsp+58h+var_42], dl
mov edx, 3; n
loc_1701:
mov rdi, rbx; dest
mov rsi, r12; src
add rbx, 3
sub ebp, 3
call _strncpy
cmp r15d, r13d
jge short loc_1698
loc_1718:
add r15d, 1
lea eax, [r15+r15*2]
cmp r14d, eax
jge short loc_16D0
movsxd rdx, ebp
mov ecx, 4
mov rsi, rbx
mov rdi, r12
mov [rsp+58h+var_50], rdx
call ___strncpy_chk
mov rdx, [rsp+58h+var_50]
mov [rsp+rdx+58h+dest], 0
cmp ebp, 3
jnz short loc_1701
jmp short loc_16E5
loc_174E:
call ___stack_chk_fail
|
unsigned long long func0(char *dest, int a2)
{
int v2; // r15d
const char *v3; // rbx
int v4; // ebp
int v5; // r14d
int v6; // r13d
__int16 v7; // dx
size_t v8; // rdx
char *v9; // rdi
int v11; // r15d
__int16 v12; // ax
char v13; // dl
size_t v14; // rdx
char *v15; // rdi
_BYTE desta[3]; // [rsp+14h] [rbp-44h] BYREF
char v17; // [rsp+17h] [rbp-41h]
unsigned long long v18; // [rsp+18h] [rbp-40h]
v2 = a2;
v3 = dest;
v18 = __readfsqword(0x28u);
v4 = strlen(dest);
v5 = v4;
v6 = (v4 + 2) / 3;
if ( v4 > 0 )
{
if ( !a2 )
{
while ( 1 )
{
++v2;
if ( v5 >= 3 * v2 )
{
strncpy(desta, v3, 3uLL);
v17 = 0;
}
else
{
__strncpy_chk(desta, v3, v4, 4LL);
v8 = v4;
desta[v4] = 0;
if ( v4 != 3 )
goto LABEL_6;
}
v7 = *(_WORD *)&desta[1];
desta[2] = desta[0];
*(_WORD *)desta = v7;
v8 = 3LL;
LABEL_6:
v9 = (char *)v3;
v3 += 3;
v4 -= 3;
strncpy(v9, desta, v8);
if ( v6 <= v2 )
return v18 - __readfsqword(0x28u);
}
}
v11 = 0;
do
{
++v11;
if ( v5 >= 3 * v11 )
{
strncpy(desta, v3, 3uLL);
v17 = 0;
}
else
{
__strncpy_chk(desta, v3, v4, 4LL);
v14 = v4;
desta[v4] = 0;
if ( v4 != 3 )
goto LABEL_14;
}
LOBYTE(v12) = desta[2];
HIBYTE(v12) = desta[0];
v13 = desta[1];
*(_WORD *)desta = v12;
desta[2] = v13;
v14 = 3LL;
LABEL_14:
v15 = (char *)v3;
v3 += 3;
v4 -= 3;
strncpy(v15, desta, v14);
}
while ( v11 < v6 );
}
return v18 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV R14D,EAX
ADD EAX,0x2
MOVSXD R13,EAX
SAR EAX,0x1f
IMUL R13,R13,0x55555556
SHR R13,0x20
SUB R13D,EAX
TEST EBP,EBP
JLE 0x00101698
TEST R15D,R15D
JNZ 0x001016c0
LEA R12,[RSP + 0x14]
JMP 0x0010165c
LAB_00101618:
MOV EDX,0x3
MOV RSI,RBX
MOV RDI,R12
CALL 0x001010e0
MOV byte ptr [RSP + 0x17],0x0
LAB_0010162d:
MOVZX EAX,byte ptr [RSP + 0x14]
MOVZX EDX,word ptr [RSP + 0x15]
MOV byte ptr [RSP + 0x16],AL
MOV word ptr [RSP + 0x14],DX
MOV EDX,0x3
LAB_00101645:
MOV RDI,RBX
MOV RSI,R12
ADD RBX,0x3
SUB EBP,0x3
CALL 0x001010e0
CMP R13D,R15D
JLE 0x00101698
LAB_0010165c:
ADD R15D,0x1
LEA EAX,[R15 + R15*0x2]
CMP R14D,EAX
JGE 0x00101618
MOVSXD RDX,EBP
MOV ECX,0x4
MOV RSI,RBX
MOV RDI,R12
MOV qword ptr [RSP + 0x8],RDX
CALL 0x00101160
MOV RDX,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + RDX*0x1 + 0x14],0x0
CMP EBP,0x3
JNZ 0x00101645
JMP 0x0010162d
LAB_00101698:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010174e
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016c0:
XOR R15D,R15D
LEA R12,[RSP + 0x14]
JMP 0x00101718
LAB_001016d0:
MOV EDX,0x3
MOV RSI,RBX
MOV RDI,R12
CALL 0x001010e0
MOV byte ptr [RSP + 0x17],0x0
LAB_001016e5:
MOVZX EAX,byte ptr [RSP + 0x16]
MOV AH,byte ptr [RSP + 0x14]
MOVZX EDX,byte ptr [RSP + 0x15]
MOV word ptr [RSP + 0x14],AX
MOV byte ptr [RSP + 0x16],DL
MOV EDX,0x3
LAB_00101701:
MOV RDI,RBX
MOV RSI,R12
ADD RBX,0x3
SUB EBP,0x3
CALL 0x001010e0
CMP R15D,R13D
JGE 0x00101698
LAB_00101718:
ADD R15D,0x1
LEA EAX,[R15 + R15*0x2]
CMP R14D,EAX
JGE 0x001016d0
MOVSXD RDX,EBP
MOV ECX,0x4
MOV RSI,RBX
MOV RDI,R12
MOV qword ptr [RSP + 0x8],RDX
CALL 0x00101160
MOV RDX,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + RDX*0x1 + 0x14],0x0
CMP EBP,0x3
JNZ 0x00101701
JMP 0x001016e5
LAB_0010174e:
CALL 0x00101100
|
void func0(char *param_1,int param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
int iVar5;
int iVar6;
long in_FS_OFFSET;
int local_44;
int2 uStack_43;
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
iVar1 = (iVar2 + 2) / 3;
if (0 < iVar2) {
if (param_2 == 0) {
iVar6 = 0;
do {
iVar6 = iVar6 + 1;
iVar5 = (int)sVar3;
if (iVar2 < iVar6 * 3) {
sVar4 = (size_t)iVar5;
__strncpy_chk(&local_44,param_1,sVar4,4);
(&local_44)[sVar4] = 0;
if (iVar5 == 3) goto LAB_0010162d;
}
else {
strncpy(&local_44,param_1,3);
local_41 = 0;
LAB_0010162d:
_local_44 = CONCAT12((char)_local_44,uStack_43);
sVar4 = 3;
}
sVar3 = (size_t)(iVar5 - 3);
strncpy(param_1,&local_44,sVar4);
param_1 = param_1 + 3;
} while (iVar6 < iVar1);
}
else {
iVar6 = 0;
do {
iVar6 = iVar6 + 1;
iVar5 = (int)sVar3;
if (SBORROW4(iVar2,iVar6 * 3) == iVar2 + iVar6 * -3 < 0) {
strncpy(&local_44,param_1,3);
local_41 = 0;
LAB_001016e5:
_local_44 = CONCAT12((int)uStack_43,CONCAT11(local_44,uStack_43._1_1_));
sVar4 = 3;
}
else {
sVar4 = (size_t)iVar5;
__strncpy_chk(&local_44,param_1,sVar4,4);
(&local_44)[sVar4] = 0;
if (iVar5 == 3) goto LAB_001016e5;
}
sVar3 = (size_t)(iVar5 - 3);
strncpy(param_1,&local_44,sVar4);
param_1 = param_1 + 3;
} while (iVar6 < iVar1);
}
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
812 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (isprime) count += 1;
if (count == n) return f1;
}
return 0;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
assert(func0(10) == 433494437);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movl $0x1,-0x18(%rbp)
movl $0x2,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11cf <func0+0x86>
mov -0x14(%rbp),%eax
add %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x14(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x2,-0x8(%rbp)
jmp 11ad <func0+0x64>
mov -0x18(%rbp),%eax
cltd
idivl -0x8(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11a9 <func0+0x60>
movl $0x0,-0xc(%rbp)
jmp 11b8 <func0+0x6f>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x18(%rbp)
jge 1193 <func0+0x4a>
cmpl $0x0,-0xc(%rbp)
je 11c2 <func0+0x79>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x24(%rbp),%eax
jne 11cf <func0+0x86>
mov -0x18(%rbp),%eax
jmp 11dc <func0+0x93>
mov -0x10(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 116b <func0+0x22>
mov $0x0,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_18], 1
mov [rbp+var_14], 2
mov [rbp+var_10], 0
jmp short loc_11CF
loc_116B:
mov eax, [rbp+var_14]
add [rbp+var_18], eax
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
mov [rbp+var_18], eax
mov eax, [rbp+var_4]
mov [rbp+var_14], eax
mov [rbp+var_C], 1
mov [rbp+var_8], 2
jmp short loc_11AD
loc_1193:
mov eax, [rbp+var_18]
cdq
idiv [rbp+var_8]
mov eax, edx
test eax, eax
jnz short loc_11A9
mov [rbp+var_C], 0
jmp short loc_11B8
loc_11A9:
add [rbp+var_8], 1
loc_11AD:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_18], eax
jge short loc_1193
loc_11B8:
cmp [rbp+var_C], 0
jz short loc_11C2
add [rbp+var_10], 1
loc_11C2:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_24]
jnz short loc_11CF
mov eax, [rbp+var_18]
jmp short loc_11DC
loc_11CF:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_24]
jl short loc_116B
mov eax, 0
loc_11DC:
pop rbp
retn
|
long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-18h]
int v3; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int v5; // [rsp+18h] [rbp-Ch]
int i; // [rsp+1Ch] [rbp-8h]
int v7; // [rsp+20h] [rbp-4h]
v2 = 1;
v3 = 2;
v4 = 0;
while ( v4 < a1 )
{
v7 = v3 + v2;
v2 = v3;
v3 = v7;
v5 = 1;
for ( i = 2; v2 >= i * i; ++i )
{
if ( !(v2 % i) )
{
v5 = 0;
break;
}
}
if ( v5 )
++v4;
if ( v4 == a1 )
return (unsigned int)v2;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x18],0x1
MOV dword ptr [RBP + -0x14],0x2
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011cf
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x2
JMP 0x001011ad
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x18]
CDQ
IDIV dword ptr [RBP + -0x8]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011a9
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011b8
LAB_001011a9:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x18],EAX
JGE 0x00101193
LAB_001011b8:
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011c2
ADD dword ptr [RBP + -0x10],0x1
LAB_001011c2:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x24]
JNZ 0x001011cf
MOV EAX,dword ptr [RBP + -0x18]
JMP 0x001011dc
LAB_001011cf:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010116b
MOV EAX,0x0
LAB_001011dc:
POP RBP
RET
|
int func0(int param_1)
{
int iVar1;
bool bVar2;
int local_20;
int local_1c;
int local_18;
int local_10;
local_20 = 1;
local_1c = 2;
local_18 = 0;
iVar1 = local_1c;
do {
local_1c = iVar1;
if (param_1 <= local_18) {
return 0;
}
iVar1 = local_20 + local_1c;
local_20 = local_1c;
bVar2 = true;
for (local_10 = 2; local_10 * local_10 <= local_1c; local_10 = local_10 + 1) {
if (local_1c % local_10 == 0) {
bVar2 = false;
break;
}
}
if (bVar2) {
local_18 = local_18 + 1;
}
if (local_18 == param_1) {
return local_1c;
}
} while( true );
}
|
813 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (isprime) count += 1;
if (count == n) return f1;
}
return 0;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
assert(func0(10) == 433494437);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov $0x0,%r8d
mov $0x2,%esi
mov $0x1,%eax
jmp 1175 <func0+0x2c>
mov $0x0,%esi
mov %esi,%eax
retq
add $0x1,%r8d
cmp %r8d,%edi
je 1164 <func0+0x1b>
mov %esi,%eax
mov %r9d,%esi
cmp %edi,%r8d
jge 115f <func0+0x16>
lea (%rax,%rsi,1),%r9d
cmp $0x3,%esi
jle 1167 <func0+0x1e>
test $0x1,%sil
je 1170 <func0+0x27>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jg 1167 <func0+0x1e>
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 118e <func0+0x45>
jmp 1170 <func0+0x27>
|
func0:
endbr64
mov r8d, 0
mov esi, 2
mov eax, 1
jmp short loc_116D
loc_115F:
add r8d, 1
cmp edi, r8d
jz short loc_11A2
loc_1168:
mov eax, esi
mov esi, r9d
loc_116D:
cmp r8d, edi
jge short loc_119D
lea r9d, [rax+rsi]
cmp esi, 3
jle short loc_115F
test sil, 1
jz short loc_1168
mov ecx, 2
loc_1186:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jg short loc_115F
mov eax, esi
cdq
idiv ecx
test edx, edx
jnz short loc_1186
jmp short loc_1168
loc_119D:
mov esi, 0
loc_11A2:
mov eax, esi
retn
|
long long func0(int a1)
{
int v1; // r8d
int v2; // esi
int v3; // eax
int v4; // r9d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
while ( v1 < a1 )
{
v4 = v3 + v2;
if ( v2 > 3 )
{
if ( (v2 & 1) == 0 )
goto LABEL_3;
v5 = 2;
while ( 1 )
{
++v5;
if ( v5 * v5 > v2 )
break;
if ( !(v2 % v5) )
goto LABEL_3;
}
}
if ( a1 == ++v1 )
return (unsigned int)v2;
LABEL_3:
v3 = v2;
v2 = v4;
}
return 0;
}
|
func0:
ENDBR64
MOV R8D,0x0
MOV ESI,0x2
MOV EAX,0x1
JMP 0x0010116d
LAB_0010115f:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x001011a2
LAB_00101168:
MOV EAX,ESI
MOV ESI,R9D
LAB_0010116d:
CMP R8D,EDI
JGE 0x0010119d
LEA R9D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x0010115f
TEST SIL,0x1
JZ 0x00101168
MOV ECX,0x2
LAB_00101186:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JG 0x0010115f
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101186
JMP 0x00101168
LAB_0010119d:
MOV ESI,0x0
LAB_001011a2:
MOV EAX,ESI
RET
|
uint func0(int param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
uint uVar4;
int iVar5;
iVar5 = 0;
uVar1 = 2;
uVar2 = 1;
do {
do {
while( true ) {
uVar4 = uVar1;
if (param_1 <= iVar5) {
return 0;
}
uVar1 = uVar2 + uVar4;
uVar2 = uVar4;
if (3 < (int)uVar4) break;
LAB_0010115f:
iVar5 = iVar5 + 1;
if (param_1 == iVar5) {
return uVar4;
}
}
} while ((uVar4 & 1) == 0);
iVar3 = 2;
do {
iVar3 = iVar3 + 1;
if ((int)uVar4 < iVar3 * iVar3) goto LAB_0010115f;
} while ((int)uVar4 % iVar3 != 0);
} while( true );
}
|
814 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (isprime) count += 1;
if (count == n) return f1;
}
return 0;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
assert(func0(10) == 433494437);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %edi,%edi
jle 16b8 <func0+0x58>
xor %r9d,%r9d
mov $0x2,%esi
mov $0x1,%eax
nopl (%rax)
mov %esi,%r8d
add %eax,%esi
cmp $0x3,%r8d
jle 16a7 <func0+0x47>
test $0x1,%r8b
je 16b0 <func0+0x50>
mov $0x2,%ecx
jmp 169a <func0+0x3a>
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 16b0 <func0+0x50>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %r8d,%eax
jle 1690 <func0+0x30>
add $0x1,%r9d
cmp %r9d,%edi
je 16bb <func0+0x5b>
mov %r8d,%eax
cmp %r9d,%edi
jg 1678 <func0+0x18>
xor %r8d,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
xor r8d, r8d
mov esi, 2
mov eax, 1
cmp r8d, edi
jge short loc_13C8
nop word ptr [rax+rax+00000000h]
loc_1380:
lea r9d, [rax+rsi]
cmp esi, 3
jle short loc_13B5
test sil, 1
jz short loc_13BE
mov ecx, 2
jmp short loc_13A9
loc_13A0:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_13BE
loc_13A9:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_13A0
loc_13B5:
add r8d, 1
cmp edi, r8d
jz short loc_13CA
loc_13BE:
mov eax, esi
mov esi, r9d
cmp r8d, edi
jl short loc_1380
loc_13C8:
xor esi, esi
loc_13CA:
mov eax, esi
retn
|
long long func0(int a1)
{
int v1; // r8d
int v2; // esi
int v3; // eax
int v4; // r9d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
if ( a1 > 0 )
{
while ( 1 )
{
v4 = v3 + v2;
if ( v2 <= 3 )
goto LABEL_7;
if ( (v2 & 1) != 0 )
break;
LABEL_8:
v3 = v2;
v2 = v4;
if ( v1 >= a1 )
return 0;
}
v5 = 2;
while ( 1 )
{
++v5;
if ( v5 * v5 > v2 )
break;
if ( !(v2 % v5) )
goto LABEL_8;
}
LABEL_7:
if ( a1 == ++v1 )
return (unsigned int)v2;
goto LABEL_8;
}
return 0;
}
|
func0:
ENDBR64
XOR R8D,R8D
MOV ESI,0x2
MOV EAX,0x1
CMP R8D,EDI
JGE 0x001013c8
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101380:
LEA R9D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x001013b5
TEST SIL,0x1
JZ 0x001013be
MOV ECX,0x2
JMP 0x001013a9
LAB_001013a0:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013be
LAB_001013a9:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x001013a0
LAB_001013b5:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x001013ca
LAB_001013be:
MOV EAX,ESI
MOV ESI,R9D
CMP R8D,EDI
JL 0x00101380
LAB_001013c8:
XOR ESI,ESI
LAB_001013ca:
MOV EAX,ESI
RET
|
uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
uint uVar5;
iVar4 = 0;
uVar3 = 2;
uVar1 = 1;
if (0 < param_1) {
do {
uVar5 = uVar1 + uVar3;
if ((int)uVar3 < 4) {
LAB_001013b5:
iVar4 = iVar4 + 1;
if (param_1 == iVar4) {
return uVar3;
}
}
else if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_001013b5;
} while ((int)uVar3 % iVar2 != 0);
}
uVar1 = uVar3;
uVar3 = uVar5;
} while (iVar4 < param_1);
}
return 0;
}
|
815 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (isprime) count += 1;
if (count == n) return f1;
}
return 0;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
assert(func0(10) == 433494437);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %edi,%edi
jle 16b8 <func0+0x58>
xor %r9d,%r9d
mov $0x2,%esi
mov $0x1,%eax
nopl (%rax)
mov %esi,%r8d
add %eax,%esi
cmp $0x3,%r8d
jle 16a7 <func0+0x47>
test $0x1,%r8b
je 16b0 <func0+0x50>
mov $0x2,%ecx
jmp 169a <func0+0x3a>
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 16b0 <func0+0x50>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %r8d,%eax
jle 1690 <func0+0x30>
add $0x1,%r9d
cmp %r9d,%edi
je 16bb <func0+0x5b>
mov %r8d,%eax
cmp %r9d,%edi
jg 1678 <func0+0x18>
xor %r8d,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
xor r8d, r8d
mov esi, 2
mov eax, 1
cmp r8d, edi
jge short loc_1618
nop word ptr [rax+rax+00000000h]
loc_15D0:
lea r9d, [rax+rsi]
cmp esi, 3
jle short loc_1605
test sil, 1
jz short loc_160E
mov ecx, 2
jmp short loc_15F9
loc_15F0:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_160E
loc_15F9:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_15F0
loc_1605:
add r8d, 1
cmp edi, r8d
jz short loc_161A
loc_160E:
mov eax, esi
mov esi, r9d
cmp r8d, edi
jl short loc_15D0
loc_1618:
xor esi, esi
loc_161A:
mov eax, esi
retn
|
long long func0(int a1)
{
int v1; // r8d
int v2; // esi
int v3; // eax
int v4; // r9d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
if ( a1 > 0 )
{
while ( 1 )
{
v4 = v3 + v2;
if ( v2 <= 3 )
goto LABEL_7;
if ( (v2 & 1) != 0 )
break;
LABEL_8:
v3 = v2;
v2 = v4;
if ( v1 >= a1 )
return 0;
}
v5 = 2;
while ( 1 )
{
++v5;
if ( v5 * v5 > v2 )
break;
if ( !(v2 % v5) )
goto LABEL_8;
}
LABEL_7:
if ( a1 == ++v1 )
return (unsigned int)v2;
goto LABEL_8;
}
return 0;
}
|
func0:
ENDBR64
XOR R8D,R8D
MOV ESI,0x2
MOV EAX,0x1
CMP R8D,EDI
JGE 0x00101618
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001015d0:
LEA R9D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x00101605
TEST SIL,0x1
JZ 0x0010160e
MOV ECX,0x2
JMP 0x001015f9
LAB_001015f0:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x0010160e
LAB_001015f9:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x001015f0
LAB_00101605:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010161a
LAB_0010160e:
MOV EAX,ESI
MOV ESI,R9D
CMP R8D,EDI
JL 0x001015d0
LAB_00101618:
XOR ESI,ESI
LAB_0010161a:
MOV EAX,ESI
RET
|
uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
uint uVar5;
iVar4 = 0;
uVar3 = 2;
uVar1 = 1;
if (0 < param_1) {
do {
uVar5 = uVar1 + uVar3;
if ((int)uVar3 < 4) {
LAB_00101605:
iVar4 = iVar4 + 1;
if (param_1 == iVar4) {
return uVar3;
}
}
else if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_00101605;
} while ((int)uVar3 % iVar2 != 0);
}
uVar1 = uVar3;
uVar3 = uVar5;
} while (iVar4 < param_1);
}
return 0;
}
|
816 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
assert(func0(test4, 4) == false);
int test5[] = {1, 2, 5, 7};
assert(func0(test5, 4) == false);
int test6[] = {2, 4, -5, 3, 9, 7};
assert(func0(test6, 6) == true);
int test7[] = {1};
assert(func0(test7, 1) == false);
int test8[] = {1, 3, 5, -100};
assert(func0(test8, 4) == false);
int test9[] = {100, 3, 5, -100};
assert(func0(test9, 4) == false);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1207 <func0+0x9e>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 11fb <func0+0x92>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11ef <func0+0x86>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %eax,%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %edx,%eax
test %eax,%eax
jne 11eb <func0+0x82>
mov $0x1,%eax
jmp 1218 <func0+0xaf>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119a <func0+0x31>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118f <func0+0x26>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1184 <func0+0x1b>
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_C], 0
jmp loc_1207
loc_1184:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp short loc_11FB
loc_118F:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11EF
loc_119A:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
add edx, eax
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
add eax, edx
test eax, eax
jnz short loc_11EB
mov eax, 1
jmp short loc_1218
loc_11EB:
add [rbp+var_4], 1
loc_11EF:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_119A
add [rbp+var_8], 1
loc_11FB:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_118F
add [rbp+var_C], 1
loc_1207:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_1184
mov eax, 0
loc_1218:
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
int j; // [rsp+14h] [rbp-8h]
int k; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
for ( k = j + 1; k < a2; ++k )
{
if ( !(*(_DWORD *)(4LL * j + a1) + *(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4LL * k + a1)) )
return 1LL;
}
}
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101207
LAB_00101184:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011fb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011ef
LAB_0010119a:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
TEST EAX,EAX
JNZ 0x001011eb
MOV EAX,0x1
JMP 0x00101218
LAB_001011eb:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ef:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119a
ADD dword ptr [RBP + -0x8],0x1
LAB_001011fb:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118f
ADD dword ptr [RBP + -0xc],0x1
LAB_00101207:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101184
MOV EAX,0x0
LAB_00101218:
POP RBP
RET
|
int8 func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
do {
local_10 = local_14;
if (param_2 <= local_14) {
return 0;
}
while (local_10 = local_10 + 1, local_c = local_10, local_10 < param_2) {
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_c * 4) +
*(int *)(param_1 + (long)local_14 * 4) + *(int *)(param_1 + (long)local_10 * 4) == 0) {
return 1;
}
}
}
local_14 = local_14 + 1;
} while( true );
}
|
817 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
assert(func0(test4, 4) == false);
int test5[] = {1, 2, 5, 7};
assert(func0(test5, 4) == false);
int test6[] = {2, 4, -5, 3, 9, 7};
assert(func0(test6, 6) == true);
int test7[] = {1};
assert(func0(test7, 1) == false);
int test8[] = {1, 3, 5, -100};
assert(func0(test8, 4) == false);
int test9[] = {100, 3, 5, -100};
assert(func0(test9, 4) == false);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11b7 <func0+0x4e>
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
cmp %r9,%r8
je 11bd <func0+0x54>
lea 0x1(%r8),%r10
mov %r10,%rcx
cmp %ecx,%esi
jle 11b2 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
add -0x4(%rdi,%r8,4),%edx
mov %rcx,%rax
mov %edx,%r11d
add (%rdi,%rax,4),%r11d
je 11c3 <func0+0x5a>
add $0x1,%rax
cmp %eax,%esi
jg 119b <func0+0x32>
add $0x1,%rcx
jmp 118b <func0+0x22>
mov %r10,%r8
jmp 117f <func0+0x16>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_11D8
lea r11d, [rsi+1]
movsxd rax, esi
lea r10, [rax+2]
mov r9d, 2
cmp r9, r11
jz short loc_11EC
push rbx
jmp short loc_1198
loc_118A:
add r9, 1
cmp r9, r10
jz short loc_11D1
cmp r9, r11
jz short loc_11DE
loc_1198:
mov eax, esi
sub eax, r9d
lea rbx, [r9+rax+1]
mov r8, r9
loc_11A5:
cmp esi, r8d
jle short loc_118A
mov edx, [rdi+r8*4-4]
add edx, [rdi+r9*4-8]
mov rax, r8
loc_11B7:
mov ecx, edx
add ecx, [rdi+rax*4]
jz short loc_11E5
add rax, 1
cmp esi, eax
jg short loc_11B7
add r8, 1
cmp r8, rbx
jnz short loc_11A5
jmp short loc_118A
loc_11D1:
mov eax, 0
jmp short loc_11EA
loc_11D8:
mov eax, 0
retn
loc_11DE:
mov eax, 0
jmp short loc_11EA
loc_11E5:
mov eax, 1
loc_11EA:
pop rbx
retn
loc_11EC:
mov eax, 0
retn
|
long long func0(long long a1, int a2)
{
long long v2; // r11
long long v3; // r9
long long v4; // r8
long long v5; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (unsigned int)(a2 + 1);
v3 = 2LL;
if ( v2 == 2 )
return 0LL;
do
{
v4 = v3;
while ( 2 )
{
if ( a2 > (int)v4 )
{
v5 = v4;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v5) + *(_DWORD *)(a1 + 4 * v3 - 8) + *(_DWORD *)(a1 + 4 * v4 - 4)) )
return 1LL;
++v5;
}
while ( a2 > (int)v5 );
if ( ++v4 != v3 + (unsigned int)(a2 - v3) + 1 )
continue;
}
break;
}
if ( ++v3 == a2 + 2LL )
return 0LL;
}
while ( v3 != v2 );
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011d8
LEA R11D,[RSI + 0x1]
MOVSXD RAX,ESI
LEA R10,[RAX + 0x2]
MOV R9D,0x2
CMP R9,R11
JZ 0x001011ec
PUSH RBX
JMP 0x00101198
LAB_0010118a:
ADD R9,0x1
CMP R9,R10
JZ 0x001011d1
CMP R9,R11
JZ 0x001011de
LAB_00101198:
MOV EAX,ESI
SUB EAX,R9D
LEA RBX,[R9 + RAX*0x1 + 0x1]
MOV R8,R9
LAB_001011a5:
CMP ESI,R8D
JLE 0x0010118a
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
ADD EDX,dword ptr [RDI + R9*0x4 + -0x8]
MOV RAX,R8
LAB_001011b7:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JZ 0x001011e5
ADD RAX,0x1
CMP ESI,EAX
JG 0x001011b7
ADD R8,0x1
CMP R8,RBX
JNZ 0x001011a5
JMP 0x0010118a
LAB_001011d1:
MOV EAX,0x0
JMP 0x001011ea
LAB_001011d8:
MOV EAX,0x0
RET
LAB_001011de:
MOV EAX,0x0
JMP 0x001011ea
LAB_001011e5:
MOV EAX,0x1
LAB_001011ea:
POP RBX
RET
LAB_001011ec:
MOV EAX,0x0
RET
|
int8 func0(long param_1,int param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
if (param_2 < 1) {
return 0;
}
uVar3 = 2;
if ((ulong)(param_2 + 1) == 2) {
return 0;
}
do {
uVar2 = uVar3;
do {
if (param_2 <= (int)uVar2) break;
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + -8 + uVar3 * 4) +
*(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < param_2);
uVar2 = uVar2 + 1;
} while (uVar2 != uVar3 + 1 + (ulong)(uint)(param_2 - (int)uVar3));
uVar3 = uVar3 + 1;
if (uVar3 == (long)param_2 + 2U) {
return 0;
}
if (uVar3 == param_2 + 1) {
return 0;
}
} while( true );
}
|
818 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
assert(func0(test4, 4) == false);
int test5[] = {1, 2, 5, 7};
assert(func0(test5, 4) == false);
int test6[] = {2, 4, -5, 3, 9, 7};
assert(func0(test6, 6) == true);
int test7[] = {1};
assert(func0(test7, 1) == false);
int test8[] = {1, 3, 5, -100};
assert(func0(test8, 4) == false);
int test9[] = {100, 3, 5, -100};
assert(func0(test9, 4) == false);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 14cd <func0+0x5d>
lea -0x1(%rsi),%r9d
mov $0x1,%r8d
add $0x1,%r9
cmp %r9,%r8
je 14cd <func0+0x5d>
lea 0x1(%r8),%r10
mov %r10,%rcx
cmp %ecx,%esi
jle 14c8 <func0+0x58>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
add -0x4(%rdi,%r8,4),%edx
jmp 14b0 <func0+0x40>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%esi
jle 14c0 <func0+0x50>
mov %edx,%r11d
add (%rdi,%rax,4),%r11d
jne 14a8 <func0+0x38>
mov $0x1,%eax
retq
add $0x1,%rcx
cmp %ecx,%esi
jg 1496 <func0+0x26>
mov %r10,%r8
jmp 1486 <func0+0x16>
xor %eax,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_1477
lea r10d, [rsi+1]
mov r9d, 2
loc_1432:
cmp r10, r9
jz short loc_1477
mov r8, r9
cmp esi, r8d
jle short loc_1471
loc_143F:
mov edx, [rdi+r8*4-4]
mov rax, r8
add edx, [rdi+r9*4-8]
jmp short loc_1458
loc_1450:
add rax, 1
cmp esi, eax
jle short loc_1468
loc_1458:
mov ecx, edx
add ecx, [rdi+rax*4]
jnz short loc_1450
mov eax, 1
retn
loc_1468:
add r8, 1
cmp esi, r8d
jg short loc_143F
loc_1471:
add r9, 1
jmp short loc_1432
loc_1477:
xor eax, eax
retn
|
long long func0(long long a1, int a2)
{
long long i; // r9
long long j; // r8
long long v4; // rax
if ( a2 > 0 )
{
for ( i = 2LL; a2 + 1 != i; ++i )
{
for ( j = i; a2 > (int)j; ++j )
{
v4 = j;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v4) + *(_DWORD *)(a1 + 4 * i - 8) + *(_DWORD *)(a1 + 4 * j - 4)) )
return 1LL;
++v4;
}
while ( a2 > (int)v4 );
}
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101477
LEA R10D,[RSI + 0x1]
MOV R9D,0x2
LAB_00101432:
CMP R10,R9
JZ 0x00101477
MOV R8,R9
CMP ESI,R8D
JLE 0x00101471
LAB_0010143f:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
ADD EDX,dword ptr [RDI + R9*0x4 + -0x8]
JMP 0x00101458
LAB_00101450:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101468
LAB_00101458:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101450
MOV EAX,0x1
RET
LAB_00101468:
ADD R8,0x1
CMP ESI,R8D
JG 0x0010143f
LAB_00101471:
ADD R9,0x1
JMP 0x00101432
LAB_00101477:
XOR EAX,EAX
RET
|
int8 func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
if (0 < param_2) {
for (uVar4 = 2; param_2 + 1 != uVar4; uVar4 = uVar4 + 1) {
iVar2 = (int)uVar4;
uVar3 = uVar4;
while (iVar2 < param_2) {
uVar1 = uVar3;
do {
if (*(int *)(param_1 + -4 + uVar3 * 4) + *(int *)(param_1 + -8 + uVar4 * 4) +
*(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < param_2);
uVar3 = uVar3 + 1;
iVar2 = (int)uVar3;
}
}
}
return 0;
}
|
819 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
assert(func0(test4, 4) == false);
int test5[] = {1, 2, 5, 7};
assert(func0(test5, 4) == false);
int test6[] = {2, 4, -5, 3, 9, 7};
assert(func0(test6, 6) == true);
int test7[] = {1};
assert(func0(test7, 1) == false);
int test8[] = {1, 3, 5, -100};
assert(func0(test8, 4) == false);
int test9[] = {100, 3, 5, -100};
assert(func0(test9, 4) == false);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 147d <func0+0x5d>
lea -0x1(%rsi),%r9d
mov $0x1,%r8d
add $0x1,%r9
cmp %r9,%r8
je 147d <func0+0x5d>
lea 0x1(%r8),%r10
mov %r10,%rcx
cmp %ecx,%esi
jle 1478 <func0+0x58>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
add -0x4(%rdi,%r8,4),%edx
jmp 1460 <func0+0x40>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%esi
jle 1470 <func0+0x50>
mov %edx,%r11d
add (%rdi,%rax,4),%r11d
jne 1458 <func0+0x38>
mov $0x1,%eax
retq
add $0x1,%rcx
cmp %ecx,%esi
jg 1446 <func0+0x26>
mov %r10,%r8
jmp 1436 <func0+0x16>
xor %eax,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_1477
lea r10d, [rsi+1]
mov r9d, 2
loc_1432:
cmp r10, r9
jz short loc_1477
mov r8, r9
cmp esi, r8d
jle short loc_1471
loc_143F:
mov edx, [rdi+r8*4-4]
mov rax, r8
add edx, [rdi+r9*4-8]
jmp short loc_1458
loc_1450:
add rax, 1
cmp esi, eax
jle short loc_1468
loc_1458:
mov ecx, edx
add ecx, [rdi+rax*4]
jnz short loc_1450
mov eax, 1
retn
loc_1468:
add r8, 1
cmp esi, r8d
jg short loc_143F
loc_1471:
add r9, 1
jmp short loc_1432
loc_1477:
xor eax, eax
retn
|
long long func0(long long a1, int a2)
{
long long i; // r9
long long j; // r8
long long v4; // rax
if ( a2 > 0 )
{
for ( i = 2LL; a2 + 1 != i; ++i )
{
for ( j = i; a2 > (int)j; ++j )
{
v4 = j;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v4) + *(_DWORD *)(a1 + 4 * i - 8) + *(_DWORD *)(a1 + 4 * j - 4)) )
return 1LL;
++v4;
}
while ( a2 > (int)v4 );
}
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101477
LEA R10D,[RSI + 0x1]
MOV R9D,0x2
LAB_00101432:
CMP R10,R9
JZ 0x00101477
MOV R8,R9
CMP ESI,R8D
JLE 0x00101471
LAB_0010143f:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
ADD EDX,dword ptr [RDI + R9*0x4 + -0x8]
JMP 0x00101458
LAB_00101450:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101468
LAB_00101458:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101450
MOV EAX,0x1
RET
LAB_00101468:
ADD R8,0x1
CMP ESI,R8D
JG 0x0010143f
LAB_00101471:
ADD R9,0x1
JMP 0x00101432
LAB_00101477:
XOR EAX,EAX
RET
|
int8 func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
if (0 < param_2) {
for (uVar4 = 2; param_2 + 1 != uVar4; uVar4 = uVar4 + 1) {
iVar2 = (int)uVar4;
uVar3 = uVar4;
while (iVar2 < param_2) {
uVar1 = uVar3;
do {
if (*(int *)(param_1 + -4 + uVar3 * 4) + *(int *)(param_1 + -8 + uVar4 * 4) +
*(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < param_2);
uVar3 = uVar3 + 1;
iVar2 = (int)uVar3;
}
}
}
return 0;
}
|
820 |
func0
|
#include <stdio.h>
|
int func0(int n) {
return n * n;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
imul eax, eax
pop rbp
retn
|
long long func0(int a1)
{
return (unsigned int)(a1 * a1);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
POP RBP
RET
|
int func0(int param_1)
{
return param_1 * param_1;
}
|
821 |
func0
|
#include <stdio.h>
|
int func0(int n) {
return n * n;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
}
|
O1
|
c
|
func0:
endbr64
imul %edi,%edi
mov %edi,%eax
retq
|
func0:
endbr64
imul edi, edi
mov eax, edi
retn
|
long long func0(int a1)
{
return (unsigned int)(a1 * a1);
}
|
func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET
|
int func0(int param_1)
{
return param_1 * param_1;
}
|
822 |
func0
|
#include <stdio.h>
|
int func0(int n) {
return n * n;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %edi,%eax
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
imul edi, edi
mov eax, edi
retn
|
long long func0(int a1)
{
return (unsigned int)(a1 * a1);
}
|
func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET
|
int func0(int param_1)
{
return param_1 * param_1;
}
|
823 |
func0
|
#include <stdio.h>
|
int func0(int n) {
return n * n;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov %edi,%eax
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
imul edi, edi
mov eax, edi
retn
|
long long func0(int a1)
{
return (unsigned int)(a1 * a1);
}
|
func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET
|
int func0(int param_1)
{
return param_1 * param_1;
}
|
824 |
func0
|
#include <stdio.h>
|
void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(issame(list1, 0, result1, 0));
int list2[] = {3, 2, 1};
int result2[] = {4, 3, 2};
func0(list2, 3);
assert(issame(list2, 3, result2, 3));
int list3[] = {5, 2, 5, 2, 3, 3, 9, 0, 123};
int result3[] = {6, 3, 6, 3, 4, 4, 10, 1, 124};
func0(list3, 9);
assert(issame(list3, 9, result3, 9));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b4 <func0+0x4b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11B4
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
add edx, 1
mov [rax], edx
add [rbp+var_4], 1
loc_11B4:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
nop
nop
pop rbp
retn
|
long long func0(long long a1, int a2)
{
long long result; // rax
unsigned int i; // [rsp+18h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
++*(_DWORD *)(4LL * (int)i + a1);
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b4
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
ADD EDX,0x1
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011b4:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
NOP
NOP
POP RBP
RET
|
void func0(long param_1,int param_2)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int *)(param_1 + (long)local_c * 4) = *(int *)(param_1 + (long)local_c * 4) + 1;
}
return;
}
|
825 |
func0
|
#include <stdio.h>
|
void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(issame(list1, 0, result1, 0));
int list2[] = {3, 2, 1};
int result2[] = {4, 3, 2};
func0(list2, 3);
assert(issame(list2, 3, result2, 3));
int list3[] = {5, 2, 5, 2, 3, 3, 9, 0, 123};
int result3[] = {6, 3, 6, 3, 4, 4, 10, 1, 124};
func0(list3, 9);
assert(issame(list3, 9, result3, 9));
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 1188 <func0+0x1f>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
addl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 117c <func0+0x13>
retq
|
func0:
endbr64
test esi, esi
jle short locret_1187
mov rax, rdi
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
loc_117B:
add dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_117B
locret_1187:
retn
|
void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 > 0 )
{
v2 = a1;
do
++*v2++;
while ( v2 != &a1[a2] );
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101187
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
LAB_0010117b:
ADD dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117b
LAB_00101187:
RET
|
void func0(int *param_1,int param_2)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
*param_1 = *param_1 + 1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return;
}
|
826 |
func0
|
#include <stdio.h>
|
void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(issame(list1, 0, result1, 0));
int list2[] = {3, 2, 1};
int result2[] = {4, 3, 2};
func0(list2, 3);
assert(issame(list2, 3, result2, 3));
int list3[] = {5, 2, 5, 2, 3, 3, 9, 0, 123};
int result3[] = {6, 3, 6, 3, 4, 4, 10, 1, 124};
func0(list3, 9);
assert(issame(list3, 9, result3, 9));
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 135c <func0+0x1c>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
addl $0x1,(%rdi)
add $0x4,%rdi
cmp %rax,%rdi
jne 1350 <func0+0x10>
retq
nopl (%rax)
|
func0:
endbr64
test esi, esi
jle short locret_1350
movsxd rsi, esi
lea rax, [rdi+rsi*4]
and esi, 1
jz short loc_1340
add dword ptr [rdi], 1
add rdi, 4
cmp rdi, rax
jz short locret_1351
loc_1340:
add dword ptr [rdi], 1
add dword ptr [rdi+4], 1
add rdi, 8
cmp rdi, rax
jnz short loc_1340
locret_1350:
retn
locret_1351:
retn
|
void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 > 0 )
{
v2 = &a1[a2];
if ( (a2 & 1) == 0 || (++*a1, ++a1, a1 != v2) )
{
do
{
++*a1;
++a1[1];
a1 += 2;
}
while ( a1 != v2 );
}
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101350
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
AND ESI,0x1
JZ 0x00101340
ADD dword ptr [RDI],0x1
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101351
LAB_00101340:
ADD dword ptr [RDI],0x1
ADD dword ptr [RDI + 0x4],0x1
ADD RDI,0x8
CMP RDI,RAX
JNZ 0x00101340
LAB_00101350:
RET
LAB_00101351:
RET
|
void func0(int *param_1,uint param_2)
{
int *piVar1;
if (0 < (int)param_2) {
piVar1 = param_1 + (int)param_2;
if ((param_2 & 1) != 0) {
*param_1 = *param_1 + 1;
param_1 = param_1 + 1;
if (param_1 == piVar1) {
return;
}
}
do {
*param_1 = *param_1 + 1;
param_1[1] = param_1[1] + 1;
param_1 = param_1 + 2;
} while (param_1 != piVar1);
}
return;
}
|
827 |
func0
|
#include <stdio.h>
|
void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(issame(list1, 0, result1, 0));
int list2[] = {3, 2, 1};
int result2[] = {4, 3, 2};
func0(list2, 3);
assert(issame(list2, 3, result2, 3));
int list3[] = {5, 2, 5, 2, 3, 3, 9, 0, 123};
int result3[] = {6, 3, 6, 3, 4, 4, 10, 1, 124};
func0(list3, 9);
assert(issame(list3, 9, result3, 9));
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1362 <func0+0x72>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1369 <func0+0x79>
mov %esi,%edx
movdqa 0xda6(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
paddd %xmm1,%xmm0
movups %xmm0,-0x10(%rax)
cmp %rdx,%rax
jne 1320 <func0+0x30>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 1368 <func0+0x78>
movslq %eax,%rdx
addl $0x1,(%rdi,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%esi
jle 1362 <func0+0x72>
movslq %edx,%rdx
add $0x2,%eax
addl $0x1,(%rdi,%rdx,4)
cmp %eax,%esi
jle 1362 <func0+0x72>
cltq
addl $0x1,(%rdi,%rax,4)
retq
nopl 0x0(%rax,%rax,1)
retq
xor %eax,%eax
jmp 1340 <func0+0x50>
nopl (%rax)
|
func0:
endbr64
test esi, esi
jle short locret_1373
lea eax, [rsi-1]
cmp eax, 2
jbe short loc_1379
mov edx, esi
movdqa xmm1, cs:xmmword_2090
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00000000h]
loc_1330:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm1
movups xmmword ptr [rax-10h], xmm0
cmp rax, rdx
jnz short loc_1330
mov edx, esi
and edx, 0FFFFFFFCh
test sil, 3
jz short locret_1378
loc_1350:
movsxd rax, edx
lea ecx, [rdx+1]
shl rax, 2
add dword ptr [rdi+rax], 1
cmp esi, ecx
jle short locret_1373
add edx, 2
add dword ptr [rdi+rax+4], 1
cmp esi, edx
jle short locret_1373
add dword ptr [rdi+rax+8], 1
locret_1373:
retn
locret_1378:
retn
loc_1379:
xor edx, edx
jmp short loc_1350
|
void func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm1
const __m128i *v3; // rax
__m128i v4; // xmm0
int v5; // edx
long long v6; // rax
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2090);
v3 = a1;
do
{
v4 = _mm_loadu_si128(v3++);
v3[-1] = _mm_add_epi32(v4, si128);
}
while ( v3 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
if ( (a2 & 3) == 0 )
return;
}
v6 = v5;
++a1->m128i_i32[v6];
if ( a2 > v5 + 1 )
{
++a1->m128i_i32[v6 + 1];
if ( a2 > v5 + 2 )
++a1->m128i_i32[v6 + 2];
}
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101373
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101379
MOV EDX,ESI
MOVDQA XMM1,xmmword ptr [0x00102090]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101330:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM1
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RDX
JNZ 0x00101330
MOV EDX,ESI
AND EDX,0xfffffffc
TEST SIL,0x3
JZ 0x00101378
LAB_00101350:
MOVSXD RAX,EDX
LEA ECX,[RDX + 0x1]
SHL RAX,0x2
ADD dword ptr [RDI + RAX*0x1],0x1
CMP ESI,ECX
JLE 0x00101373
ADD EDX,0x2
ADD dword ptr [RDI + RAX*0x1 + 0x4],0x1
CMP ESI,EDX
JLE 0x00101373
ADD dword ptr [RDI + RAX*0x1 + 0x8],0x1
LAB_00101373:
RET
LAB_00101378:
RET
LAB_00101379:
XOR EDX,EDX
JMP 0x00101350
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int *piVar5;
int *piVar6;
uint uVar7;
iVar4 = _UNK_0010209c;
iVar3 = _UNK_00102098;
iVar2 = _UNK_00102094;
iVar1 = _DAT_00102090;
if (0 < (int)param_2) {
if (param_2 - 1 < 3) {
uVar7 = 0;
}
else {
piVar5 = param_1;
do {
piVar6 = piVar5 + 4;
*piVar5 = *piVar5 + iVar1;
piVar5[1] = piVar5[1] + iVar2;
piVar5[2] = piVar5[2] + iVar3;
piVar5[3] = piVar5[3] + iVar4;
piVar5 = piVar6;
} while (piVar6 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar7 = param_2 & 0xfffffffc;
if ((param_2 & 3) == 0) {
return;
}
}
param_1[(int)uVar7] = param_1[(int)uVar7] + 1;
if (((int)(uVar7 + 1) < (int)param_2) &&
(param_1[(long)(int)uVar7 + 1] = param_1[(long)(int)uVar7 + 1] + 1,
(int)(uVar7 + 2) < (int)param_2)) {
param_1[(long)(int)uVar7 + 2] = param_1[(long)(int)uVar7 + 2] + 1;
}
}
return;
}
|
828 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
assert(func0(test4, 6) == true);
int test5[] = {1};
assert(func0(test5, 1) == false);
int test6[] = {-3, 9, -1, 3, 2, 30};
assert(func0(test6, 6) == true);
int test7[] = {-3, 9, -1, 3, 2, 31};
assert(func0(test7, 6) == true);
int test8[] = {-3, 9, -1, 4, 2, 30};
assert(func0(test8, 6) == false);
int test9[] = {-3, 9, -1, 4, 2, 31};
assert(func0(test9, 6) == false);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d5 <func0+0x6c>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11c9 <func0+0x60>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %edx,%eax
test %eax,%eax
jne 11c5 <func0+0x5c>
mov $0x1,%eax
jmp 11e2 <func0+0x79>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118c <func0+0x23>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
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
jmp short loc_11D5
loc_1181:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11C9
loc_118C:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
add eax, edx
test eax, eax
jnz short loc_11C5
mov eax, 1
jmp short loc_11E2
loc_11C5:
add [rbp+var_4], 1
loc_11C9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118C
add [rbp+var_8], 1
loc_11D5:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0
loc_11E2:
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( !(*(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4LL * j + a1)) )
return 1LL;
}
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d5
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011c9
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
TEST EAX,EAX
JNZ 0x001011c5
MOV EAX,0x1
JMP 0x001011e2
LAB_001011c5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118c
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x0
LAB_001011e2:
POP RBP
RET
|
int8 func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
do {
local_c = local_10;
if (param_2 <= local_10) {
return 0;
}
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_c * 4) + *(int *)(param_1 + (long)local_10 * 4) == 0) {
return 1;
}
}
local_10 = local_10 + 1;
} while( true );
}
|
829 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
assert(func0(test4, 6) == true);
int test5[] = {1};
assert(func0(test5, 1) == false);
int test6[] = {-3, 9, -1, 3, 2, 30};
assert(func0(test6, 6) == true);
int test7[] = {-3, 9, -1, 3, 2, 31};
assert(func0(test7, 6) == true);
int test8[] = {-3, 9, -1, 4, 2, 30};
assert(func0(test8, 6) == false);
int test9[] = {-3, 9, -1, 4, 2, 31};
assert(func0(test9, 6) == false);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11a1 <func0+0x38>
lea -0x1(%rsi),%r8d
add $0x1,%r8
mov $0x1,%ecx
cmp %r8,%rcx
je 11a7 <func0+0x3e>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
mov %edx,%r9d
add (%rdi,%rax,4),%r9d
je 11ad <func0+0x44>
add $0x1,%rax
cmp %eax,%esi
jg 118a <func0+0x21>
add $0x1,%rcx
jmp 117e <func0+0x15>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_11AD
mov r9d, esi
movsxd r10, esi
mov r8d, 1
loc_117D:
cmp r8, r9
jz short loc_11B3
mov edx, [rdi+r8*4-4]
mov rax, r8
loc_118A:
mov ecx, edx
add ecx, [rdi+rax*4]
jz short loc_11B9
add rax, 1
cmp esi, eax
jg short loc_118A
lea rax, [r8+1]
cmp r8, r10
jz short loc_11A7
mov r8, rax
jmp short loc_117D
loc_11A7:
mov eax, 0
retn
loc_11AD:
mov eax, 0
retn
loc_11B3:
mov eax, 0
retn
loc_11B9:
mov eax, 1
retn
|
long long func0(long long a1, int a2)
{
long long v2; // r8
long long v3; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
while ( 2 )
{
if ( v2 == a2 )
return 0LL;
v3 = v2;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v3) + *(_DWORD *)(a1 + 4 * v2 - 4)) )
return 1LL;
++v3;
}
while ( a2 > (int)v3 );
if ( v2 != a2 )
{
++v2;
continue;
}
break;
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ad
MOV R9D,ESI
MOVSXD R10,ESI
MOV R8D,0x1
LAB_0010117d:
CMP R8,R9
JZ 0x001011b3
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
LAB_0010118a:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JZ 0x001011b9
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118a
LEA RAX,[R8 + 0x1]
CMP R8,R10
JZ 0x001011a7
MOV R8,RAX
JMP 0x0010117d
LAB_001011a7:
MOV EAX,0x0
RET
LAB_001011ad:
MOV EAX,0x0
RET
LAB_001011b3:
MOV EAX,0x0
RET
LAB_001011b9:
MOV EAX,0x1
RET
|
int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
bool bVar3;
if ((int)param_2 < 1) {
return 0;
}
uVar2 = 1;
do {
if (uVar2 == param_2) {
return 0;
}
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
bVar3 = uVar2 != (long)(int)param_2;
uVar2 = uVar2 + 1;
} while (bVar3);
return 0;
}
|
830 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
assert(func0(test4, 6) == true);
int test5[] = {1};
assert(func0(test5, 1) == false);
int test6[] = {-3, 9, -1, 3, 2, 30};
assert(func0(test6, 6) == true);
int test7[] = {-3, 9, -1, 3, 2, 31};
assert(func0(test7, 6) == true);
int test8[] = {-3, 9, -1, 4, 2, 30};
assert(func0(test8, 6) == false);
int test9[] = {-3, 9, -1, 4, 2, 31};
assert(func0(test9, 6) == false);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1649 <func0+0x49>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %r8,%rcx
je 1649 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 1630 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 1640 <func0+0x40>
mov %edx,%r9d
add (%rdi,%rax,4),%r9d
jne 1628 <func0+0x28>
mov $0x1,%eax
retq
add $0x1,%rcx
cmp %r8,%rcx
jne 161a <func0+0x1a>
xor %eax,%eax
retq
nopl 0x0(%rax)
|
func0:
endbr64
test esi, esi
jle short loc_1481
mov r9d, esi
mov r8d, 1
cmp r8, r9
jz short loc_1481
loc_1456:
mov edx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_1468
loc_1460:
add rax, 1
cmp esi, eax
jle short loc_1478
loc_1468:
mov ecx, edx
add ecx, [rdi+rax*4]
jnz short loc_1460
mov eax, 1
retn
loc_1478:
add r8, 1
cmp r8, r9
jnz short loc_1456
loc_1481:
xor eax, eax
retn
|
long long func0(long long a1, int a2)
{
long long i; // r8
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; i != a2; ++i )
{
v3 = i;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v3) + *(_DWORD *)(a1 + 4 * i - 4)) )
return 1LL;
++v3;
}
while ( a2 > (int)v3 );
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101481
MOV R9D,ESI
MOV R8D,0x1
CMP R8,R9
JZ 0x00101481
LAB_00101456:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x00101468
LAB_00101460:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101478
LAB_00101468:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101460
MOV EAX,0x1
RET
LAB_00101478:
ADD R8,0x1
CMP R8,R9
JNZ 0x00101456
LAB_00101481:
XOR EAX,EAX
RET
|
int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_2) {
uVar2 = 1;
if ((ulong)param_2 != 1) {
do {
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
}
return 0;
}
|
831 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
assert(func0(test4, 6) == true);
int test5[] = {1};
assert(func0(test5, 1) == false);
int test6[] = {-3, 9, -1, 3, 2, 30};
assert(func0(test6, 6) == true);
int test7[] = {-3, 9, -1, 3, 2, 31};
assert(func0(test7, 6) == true);
int test8[] = {-3, 9, -1, 4, 2, 30};
assert(func0(test8, 6) == false);
int test9[] = {-3, 9, -1, 4, 2, 31};
assert(func0(test9, 6) == false);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1669 <func0+0x49>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %rcx,%r8
je 1669 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 1650 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 1660 <func0+0x40>
mov %edx,%r9d
add (%rdi,%rax,4),%r9d
jne 1648 <func0+0x28>
mov $0x1,%eax
retq
add $0x1,%rcx
cmp %rcx,%r8
jne 163a <func0+0x1a>
xor %eax,%eax
retq
nopl 0x0(%rax)
|
func0:
endbr64
test esi, esi
jle short loc_1181
mov r9d, esi
mov r8d, 1
cmp r9, r8
jz short loc_1181
loc_1156:
mov edx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_1168
loc_1160:
add rax, 1
cmp esi, eax
jle short loc_1178
loc_1168:
mov ecx, edx
add ecx, [rdi+rax*4]
jnz short loc_1160
mov eax, 1
retn
loc_1178:
add r8, 1
cmp r9, r8
jnz short loc_1156
loc_1181:
xor eax, eax
retn
|
long long func0(long long a1, int a2)
{
long long i; // r8
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; a2 != i; ++i )
{
v3 = i;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v3) + *(_DWORD *)(a1 + 4 * i - 4)) )
return 1LL;
++v3;
}
while ( a2 > (int)v3 );
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101181
MOV R9D,ESI
MOV R8D,0x1
CMP R9,R8
JZ 0x00101181
LAB_00101156:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x00101168
LAB_00101160:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101178
LAB_00101168:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101160
MOV EAX,0x1
RET
LAB_00101178:
ADD R8,0x1
CMP R9,R8
JNZ 0x00101156
LAB_00101181:
XOR EAX,EAX
RET
|
int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_2) {
uVar2 = 1;
if ((ulong)param_2 != 1) {
do {
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
uVar2 = uVar2 + 1;
} while (param_2 != uVar2);
}
}
return 0;
}
|
832 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
func0(16, 2, buffer);
assert(strcmp(buffer, "10000") == 0);
func0(8, 2, buffer);
assert(strcmp(buffer, "1000") == 0);
func0(7, 2, buffer);
assert(strcmp(buffer, "111") == 0);
for (int x = 2; x < 8; x++) {
char expected[33];
sprintf(expected, "%d", x);
func0(x, x + 1, buffer);
assert(strcmp(buffer, expected) == 0);
}
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %rdx,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x38(%rbp)
jmp 11fe <func0+0x55>
mov -0x44(%rbp),%eax
cltd
idivl -0x48(%rbp)
mov %edx,%eax
lea 0x30(%rax),%ecx
mov -0x38(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x38(%rbp)
mov %ecx,%edx
cltq
mov %dl,-0x30(%rbp,%rax,1)
mov -0x44(%rbp),%eax
cltd
idivl -0x48(%rbp)
mov %eax,-0x44(%rbp)
cmpl $0x0,-0x44(%rbp)
jg 11d7 <func0+0x2e>
movl $0x0,-0x34(%rbp)
jmp 1230 <func0+0x87>
subl $0x1,-0x38(%rbp)
mov -0x34(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x34(%rbp)
movslq %eax,%rdx
mov -0x50(%rbp),%rax
add %rax,%rdx
mov -0x38(%rbp),%eax
cltq
movzbl -0x30(%rbp,%rax,1),%eax
mov %al,(%rdx)
cmpl $0x0,-0x38(%rbp)
jg 120d <func0+0x64>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x50(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 125b <func0+0xb2>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_44], edi
mov [rbp+var_48], esi
mov [rbp+var_50], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_38], 0
jmp short loc_11FE
loc_11D7:
mov eax, [rbp+var_44]
cdq
idiv [rbp+var_48]
mov eax, edx
lea ecx, [rax+30h]
mov eax, [rbp+var_38]
lea edx, [rax+1]
mov [rbp+var_38], edx
mov edx, ecx
cdqe
mov [rbp+rax+var_30], dl
mov eax, [rbp+var_44]
cdq
idiv [rbp+var_48]
mov [rbp+var_44], eax
loc_11FE:
cmp [rbp+var_44], 0
jg short loc_11D7
mov [rbp+var_34], 0
jmp short loc_1230
loc_120D:
sub [rbp+var_38], 1
mov eax, [rbp+var_34]
lea edx, [rax+1]
mov [rbp+var_34], edx
movsxd rdx, eax
mov rax, [rbp+var_50]
add rdx, rax
mov eax, [rbp+var_38]
cdqe
movzx eax, [rbp+rax+var_30]
mov [rdx], al
loc_1230:
cmp [rbp+var_38], 0
jg short loc_120D
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+var_50]
add rax, rdx
mov byte ptr [rax], 0
nop
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_125B
call ___stack_chk_fail
locret_125B:
leave
retn
|
unsigned long long func0(int a1, int a2, long long a3)
{
int v3; // eax
int v4; // eax
int v7; // [rsp+18h] [rbp-38h]
int v8; // [rsp+1Ch] [rbp-34h]
_BYTE v9[40]; // [rsp+20h] [rbp-30h]
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = 0;
while ( a1 > 0 )
{
v3 = v7++;
v9[v3] = a1 % a2 + 48;
a1 /= a2;
}
v8 = 0;
while ( v7 > 0 )
{
--v7;
v4 = v8++;
*(_BYTE *)(a3 + v4) = v9[v7];
}
*(_BYTE *)(v8 + a3) = 0;
return v10 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x44],EDI
MOV dword ptr [RBP + -0x48],ESI
MOV qword ptr [RBP + -0x50],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001011fe
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x44]
CDQ
IDIV dword ptr [RBP + -0x48]
MOV EAX,EDX
LEA ECX,[RAX + 0x30]
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x38],EDX
MOV EDX,ECX
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x30],DL
MOV EAX,dword ptr [RBP + -0x44]
CDQ
IDIV dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x44],EAX
LAB_001011fe:
CMP dword ptr [RBP + -0x44],0x0
JG 0x001011d7
MOV dword ptr [RBP + -0x34],0x0
JMP 0x00101230
LAB_0010120d:
SUB dword ptr [RBP + -0x38],0x1
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x34],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x30]
MOV byte ptr [RDX],AL
LAB_00101230:
CMP dword ptr [RBP + -0x38],0x0
JG 0x0010120d
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010125b
CALL 0x00101080
LAB_0010125b:
LEAVE
RET
|
void func0(int param_1,int param_2,long param_3)
{
long in_FS_OFFSET;
int local_4c;
int local_40;
int local_3c;
char acStack_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = 0;
for (local_4c = param_1; 0 < local_4c; local_4c = local_4c / param_2) {
acStack_38[local_40] = (char)(local_4c % param_2) + '0';
local_40 = local_40 + 1;
}
local_3c = 0;
while (0 < local_40) {
local_40 = local_40 + -1;
*(char *)(local_3c + param_3) = acStack_38[local_40];
local_3c = local_3c + 1;
}
*(int *)(param_3 + local_3c) = 0;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
833 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
func0(16, 2, buffer);
assert(strcmp(buffer, "10000") == 0);
func0(8, 2, buffer);
assert(strcmp(buffer, "1000") == 0);
func0(7, 2, buffer);
assert(strcmp(buffer, "111") == 0);
for (int x = 2; x < 8; x++) {
char expected[33];
sprintf(expected, "%d", x);
func0(x, x + 1, buffer);
assert(strcmp(buffer, expected) == 0);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
sub $0x38,%rsp
mov %rdx,%r9
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
test %edi,%edi
jle 1236 <func0+0x8d>
mov $0x1,%ecx
lea -0x1(%rsp),%r11
mov %ecx,%r8d
mov %edi,%eax
cltd
idiv %esi
lea 0x30(%rdx),%edi
mov %dil,(%r11,%rcx,1)
mov %eax,%edi
add $0x1,%rcx
test %eax,%eax
jg 11d2 <func0+0x29>
test %r8d,%r8d
jle 123e <func0+0x95>
movslq %r8d,%rcx
lea (%rsp,%rcx,1),%rax
mov %r9,%rdx
lea -0x1(%rsp,%rcx,1),%rsi
lea -0x1(%r8),%ecx
sub %rcx,%rsi
movzbl -0x1(%rax),%ecx
mov %cl,(%rdx)
sub $0x1,%rax
add $0x1,%rdx
cmp %rsi,%rax
jne 1206 <func0+0x5d>
movslq %r8d,%r8
movb $0x0,(%r9,%r8,1)
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 1246 <func0+0x9d>
add $0x38,%rsp
retq
mov $0x0,%r8d
jmp 1219 <func0+0x70>
mov $0x0,%r8d
jmp 1219 <func0+0x70>
callq 1080 <__stack_chk_fail@plt>
|
func0:
endbr64
sub rsp, 38h
mov r10, rdx
mov rax, fs:28h
mov [rsp+38h+var_10], rax
xor eax, eax
test edi, edi
jle short loc_1236
mov ecx, 1
lea r9, [rsp+38h+var_39]
loc_11D2:
mov eax, edi
cdq
idiv esi
add edx, 30h ; '0'
mov [r9+rcx], dl
mov edi, eax
mov r8, rcx
add rcx, 1
test eax, eax
jg short loc_11D2
mov edi, r8d
test r8d, r8d
jle short loc_123D
movsxd rax, r8d
lea rdx, [rsp+rax+38h+var_39]
mov rax, r10
lea ecx, [r8-1]
lea rsi, [r10+rcx+1]
loc_1207:
movzx ecx, byte ptr [rdx]
mov [rax], cl
sub rdx, 1
add rax, 1
cmp rax, rsi
jnz short loc_1207
loc_1219:
movsxd rax, edi
mov byte ptr [r10+rax], 0
mov rax, [rsp+38h+var_10]
sub rax, fs:28h
jnz short loc_1244
add rsp, 38h
retn
loc_1236:
mov edi, 0
jmp short loc_1219
loc_123D:
mov edi, 0
jmp short loc_1219
loc_1244:
call ___stack_chk_fail
|
unsigned long long func0(int a1, int a2, _BYTE *a3)
{
long long v4; // rcx
int v5; // r8d
int v6; // edi
_BYTE *v7; // rdx
_BYTE *v8; // rax
_BYTE v10[41]; // [rsp+1h] [rbp-39h] BYREF
unsigned long long v11; // [rsp+2Ah] [rbp-10h]
v11 = __readfsqword(0x28u);
if ( a1 <= 0 )
{
v6 = 0;
}
else
{
v4 = 1LL;
do
{
v10[v4] = a1 % a2 + 48;
a1 /= a2;
v5 = v4++;
}
while ( a1 > 0 );
v6 = v5;
if ( v5 <= 0 )
{
v6 = 0;
}
else
{
v7 = &v10[v5];
v8 = a3;
do
*v8++ = *v7--;
while ( v8 != &a3[v5 - 1 + 1] );
}
}
a3[v6] = 0;
return v11 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
SUB RSP,0x38
MOV R10,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101236
MOV ECX,0x1
LEA R9,[RSP + -0x1]
LAB_001011d2:
MOV EAX,EDI
CDQ
IDIV ESI
ADD EDX,0x30
MOV byte ptr [R9 + RCX*0x1],DL
MOV EDI,EAX
MOV R8,RCX
ADD RCX,0x1
TEST EAX,EAX
JG 0x001011d2
MOV EDI,R8D
TEST R8D,R8D
JLE 0x0010123d
MOVSXD RAX,R8D
LEA RDX,[RSP + RAX*0x1 + -0x1]
MOV RAX,R10
LEA ECX,[R8 + -0x1]
LEA RSI,[R10 + RCX*0x1 + 0x1]
LAB_00101207:
MOVZX ECX,byte ptr [RDX]
MOV byte ptr [RAX],CL
SUB RDX,0x1
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101207
LAB_00101219:
MOVSXD RAX,EDI
MOV byte ptr [R10 + RAX*0x1],0x0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101244
ADD RSP,0x38
RET
LAB_00101236:
MOV EDI,0x0
JMP 0x00101219
LAB_0010123d:
MOV EDI,0x0
JMP 0x00101219
LAB_00101244:
CALL 0x00101080
|
void func0(int param_1,int param_2,char *param_3)
{
long lVar1;
int iVar2;
char *pcVar3;
long lVar4;
char *pcVar5;
long in_FS_OFFSET;
int8 uStack_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 < 1) {
iVar2 = 0;
}
else {
lVar1 = 1;
do {
lVar4 = lVar1;
iVar2 = param_1 / param_2;
local_38[lVar4 + -1] = (char)(param_1 % param_2) + '0';
lVar1 = lVar4 + 1;
param_1 = iVar2;
} while (0 < iVar2);
iVar2 = (int)lVar4;
if (iVar2 < 1) {
iVar2 = 0;
}
else {
pcVar5 = local_38 + (long)iVar2 + -1;
pcVar3 = param_3;
do {
*pcVar3 = *pcVar5;
pcVar5 = pcVar5 + -1;
pcVar3 = pcVar3 + 1;
} while (pcVar3 != param_3 + (ulong)(iVar2 - 1) + 1);
}
}
param_3[iVar2] = '\0';
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
uStack_40 = main;
__stack_chk_fail();
}
|
834 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
func0(16, 2, buffer);
assert(strcmp(buffer, "10000") == 0);
func0(8, 2, buffer);
assert(strcmp(buffer, "1000") == 0);
func0(7, 2, buffer);
assert(strcmp(buffer, "111") == 0);
for (int x = 2; x < 8; x++) {
char expected[33];
sprintf(expected, "%d", x);
func0(x, x + 1, buffer);
assert(strcmp(buffer, expected) == 0);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
sub $0x38,%rsp
mov %edi,%eax
mov %rdx,%r8
mov %fs:0x28,%rdi
mov %rdi,0x28(%rsp)
xor %edi,%edi
test %eax,%eax
jle 15d6 <func0+0x76>
mov $0x1,%ecx
lea -0x1(%rsp),%r10
nopl 0x0(%rax,%rax,1)
cltd
movslq %ecx,%rdi
mov %rcx,%r9
idiv %esi
add $0x30,%edx
mov %dl,(%r10,%rcx,1)
add $0x1,%rcx
test %eax,%eax
jg 1590 <func0+0x30>
lea -0x1(%r9),%esi
mov %r8,%rax
lea (%rsp,%rdi,1),%rcx
add %r8,%rsi
jmp 15c8 <func0+0x68>
nopl 0x0(%rax,%rax,1)
movzbl -0x1(%rcx),%edx
add $0x1,%rax
mov %dl,(%rax)
sub $0x1,%rcx
cmp %rax,%rsi
jne 15c0 <func0+0x60>
add %rdi,%r8
movb $0x0,(%r8)
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 15ef <func0+0x8f>
add $0x38,%rsp
retq
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
sub rsp, 38h
mov r9, rdx
mov rdx, fs:28h
mov [rsp+38h+var_10], rdx
xor edx, edx
test edi, edi
jle short loc_14C6
mov eax, edi
mov ecx, 1
lea r8, [rsp+38h+var_39]
nop dword ptr [rax+rax+00h]
loc_1480:
cdq
mov rdi, rcx
idiv esi
add edx, 30h ; '0'
mov [r8+rcx], dl
add rcx, 1
test eax, eax
jg short loc_1480
mov rax, rsp
movsxd r8, edi
lea ecx, [rdi-1]
lea rdx, [rax+r8-1]
lea rsi, [r9+rcx+1]
mov rax, r9
nop dword ptr [rax+rax+00h]
loc_14B0:
movzx ecx, byte ptr [rdx]
add rax, 1
sub rdx, 1
mov [rax-1], cl
cmp rax, rsi
jnz short loc_14B0
add r9, r8
loc_14C6:
mov byte ptr [r9], 0
mov rax, [rsp+38h+var_10]
sub rax, fs:28h
jnz short loc_14DF
add rsp, 38h
retn
loc_14DF:
call ___stack_chk_fail
|
unsigned long long func0(int a1, int a2, _BYTE *a3)
{
int v4; // eax
long long v5; // rcx
int v6; // edi
int v7; // et2
char *v8; // rdx
_BYTE *v9; // rax
char v10; // cl
_BYTE v12[41]; // [rsp+1h] [rbp-39h] BYREF
unsigned long long v13; // [rsp+2Ah] [rbp-10h]
v13 = __readfsqword(0x28u);
if ( a1 > 0 )
{
v4 = a1;
v5 = 1LL;
do
{
v6 = v5;
v7 = v4 % a2;
v4 /= a2;
v12[v5++] = v7 + 48;
}
while ( v4 > 0 );
v8 = &v12[v6];
v9 = a3;
do
{
v10 = *v8;
++v9;
--v8;
*(v9 - 1) = v10;
}
while ( v9 != &a3[v6 - 1 + 1] );
a3 += v6;
}
*a3 = 0;
return v13 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
SUB RSP,0x38
MOV R9,RDX
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
XOR EDX,EDX
TEST EDI,EDI
JLE 0x001014c6
MOV EAX,EDI
MOV ECX,0x1
LEA R8,[RSP + -0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101480:
CDQ
MOV RDI,RCX
IDIV ESI
ADD EDX,0x30
MOV byte ptr [R8 + RCX*0x1],DL
ADD RCX,0x1
TEST EAX,EAX
JG 0x00101480
MOV RAX,RSP
MOVSXD R8,EDI
LEA ECX,[RDI + -0x1]
LEA RDX,[RAX + R8*0x1 + -0x1]
LEA RSI,[R9 + RCX*0x1 + 0x1]
MOV RAX,R9
NOP dword ptr [RAX + RAX*0x1]
LAB_001014b0:
MOVZX ECX,byte ptr [RDX]
ADD RAX,0x1
SUB RDX,0x1
MOV byte ptr [RAX + -0x1],CL
CMP RAX,RSI
JNZ 0x001014b0
ADD R9,R8
LAB_001014c6:
MOV byte ptr [R9],0x0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014df
ADD RSP,0x38
RET
LAB_001014df:
CALL 0x00101080
|
void func0(ulong param_1,char *param_2,char *param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
char *pcVar8;
long in_FS_OFFSET;
int8 uStack_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar8 = (char *)0x0;
if (0 < (int)param_1) {
uVar5 = param_1 & 0xffffffff;
uVar3 = 1;
do {
param_1 = uVar3;
iVar4 = (int)uVar5;
uVar2 = (long)iVar4 / (long)(int)param_2;
uVar5 = uVar2 & 0xffffffff;
local_38[param_1 - 1] = (char)(iVar4 % (int)param_2) + '0';
uVar3 = param_1 + 1;
} while (0 < (int)uVar2);
iVar4 = (int)param_1;
pcVar8 = local_38 + (long)iVar4 + -1;
param_2 = param_3 + (ulong)(iVar4 - 1) + 1;
pcVar6 = param_3;
do {
cVar1 = *pcVar8;
pcVar7 = pcVar6 + 1;
pcVar8 = pcVar8 + -1;
*pcVar6 = cVar1;
pcVar6 = pcVar7;
} while (pcVar7 != param_2);
param_3 = param_3 + iVar4;
}
*param_3 = '\0';
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
uStack_40 = _fini;
__stack_chk_fail(param_1,param_2,pcVar8);
}
|
835 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
func0(16, 2, buffer);
assert(strcmp(buffer, "10000") == 0);
func0(8, 2, buffer);
assert(strcmp(buffer, "1000") == 0);
func0(7, 2, buffer);
assert(strcmp(buffer, "111") == 0);
for (int x = 2; x < 8; x++) {
char expected[33];
sprintf(expected, "%d", x);
func0(x, x + 1, buffer);
assert(strcmp(buffer, expected) == 0);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
sub $0x38,%rsp
mov %edi,%eax
mov %rdx,%r8
mov %fs:0x28,%rdi
mov %rdi,0x28(%rsp)
xor %edi,%edi
test %eax,%eax
jle 1506 <func0+0x76>
mov $0x1,%ecx
lea -0x1(%rsp),%r10
nopl 0x0(%rax,%rax,1)
cltd
movslq %ecx,%rdi
mov %rcx,%r9
idiv %esi
add $0x30,%edx
mov %dl,(%r10,%rcx,1)
add $0x1,%rcx
test %eax,%eax
jg 14c0 <func0+0x30>
mov %rsp,%rax
lea -0x1(%r9),%ecx
lea -0x1(%rax,%rdi,1),%rdx
lea 0x1(%r8,%rcx,1),%rsi
mov %r8,%rax
nopl 0x0(%rax)
movzbl (%rdx),%ecx
add $0x1,%rax
sub $0x1,%rdx
mov %cl,-0x1(%rax)
cmp %rsi,%rax
jne 14f0 <func0+0x60>
add %rdi,%r8
movb $0x0,(%r8)
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 151f <func0+0x8f>
add $0x38,%rsp
retq
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
sub rsp, 38h
mov r9, rdx
mov rdx, fs:28h
mov [rsp+38h+var_10], rdx
xor edx, edx
test edi, edi
jle short loc_1456
mov eax, edi
mov ecx, 1
lea r8, [rsp+38h+var_39]
nop dword ptr [rax+rax+00h]
loc_1410:
cdq
mov rdi, rcx
idiv esi
add edx, 30h ; '0'
mov [r8+rcx], dl
add rcx, 1
test eax, eax
jg short loc_1410
mov rax, rsp
movsxd r8, edi
lea ecx, [rdi-1]
lea rdx, [rax+r8-1]
lea rsi, [r9+rcx+1]
mov rax, r9
nop dword ptr [rax+rax+00h]
loc_1440:
movzx ecx, byte ptr [rdx]
add rax, 1
sub rdx, 1
mov [rax-1], cl
cmp rax, rsi
jnz short loc_1440
add r9, r8
loc_1456:
mov byte ptr [r9], 0
mov rax, [rsp+38h+var_10]
sub rax, fs:28h
jnz short loc_146F
add rsp, 38h
retn
loc_146F:
call ___stack_chk_fail
|
unsigned long long func0(int a1, int a2, _BYTE *a3)
{
int v4; // eax
long long v5; // rcx
int v6; // edi
int v7; // et2
char *v8; // rdx
_BYTE *v9; // rax
char v10; // cl
_BYTE v12[41]; // [rsp+1h] [rbp-39h] BYREF
unsigned long long v13; // [rsp+2Ah] [rbp-10h]
v13 = __readfsqword(0x28u);
if ( a1 > 0 )
{
v4 = a1;
v5 = 1LL;
do
{
v6 = v5;
v7 = v4 % a2;
v4 /= a2;
v12[v5++] = v7 + 48;
}
while ( v4 > 0 );
v8 = &v12[v6];
v9 = a3;
do
{
v10 = *v8;
++v9;
--v8;
*(v9 - 1) = v10;
}
while ( v9 != &a3[v6 - 1 + 1] );
a3 += v6;
}
*a3 = 0;
return v13 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
SUB RSP,0x38
MOV R9,RDX
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
XOR EDX,EDX
TEST EDI,EDI
JLE 0x00101456
MOV EAX,EDI
MOV ECX,0x1
LEA R8,[RSP + -0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101410:
CDQ
MOV RDI,RCX
IDIV ESI
ADD EDX,0x30
MOV byte ptr [R8 + RCX*0x1],DL
ADD RCX,0x1
TEST EAX,EAX
JG 0x00101410
MOV RAX,RSP
MOVSXD R8,EDI
LEA ECX,[RDI + -0x1]
LEA RDX,[RAX + R8*0x1 + -0x1]
LEA RSI,[R9 + RCX*0x1 + 0x1]
MOV RAX,R9
NOP dword ptr [RAX + RAX*0x1]
LAB_00101440:
MOVZX ECX,byte ptr [RDX]
ADD RAX,0x1
SUB RDX,0x1
MOV byte ptr [RAX + -0x1],CL
CMP RAX,RSI
JNZ 0x00101440
ADD R9,R8
LAB_00101456:
MOV byte ptr [R9],0x0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010146f
ADD RSP,0x38
RET
LAB_0010146f:
CALL 0x00101080
|
void func0(ulong param_1,char *param_2,char *param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
char *pcVar8;
long in_FS_OFFSET;
int8 uStack_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar8 = (char *)0x0;
if (0 < (int)param_1) {
uVar5 = param_1 & 0xffffffff;
uVar3 = 1;
do {
param_1 = uVar3;
iVar4 = (int)uVar5;
uVar2 = (long)iVar4 / (long)(int)param_2;
uVar5 = uVar2 & 0xffffffff;
local_38[param_1 - 1] = (char)(iVar4 % (int)param_2) + '0';
uVar3 = param_1 + 1;
} while (0 < (int)uVar2);
iVar4 = (int)param_1;
pcVar8 = local_38 + (long)iVar4 + -1;
param_2 = param_3 + (ulong)(iVar4 - 1) + 1;
pcVar6 = param_3;
do {
cVar1 = *pcVar8;
pcVar7 = pcVar6 + 1;
pcVar8 = pcVar8 + -1;
*pcVar6 = cVar1;
pcVar6 = pcVar7;
} while (pcVar7 != param_2);
param_3 = param_3 + iVar4;
}
*param_3 = '\0';
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
uStack_40 = _fini;
__stack_chk_fail(param_1,param_2,pcVar8);
}
|
836 |
func0
|
#include <stdio.h>
#include <math.h>
|
float func0(float a, float h) {
return (a * h) * 0.5;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss -0x8(%rbp),%xmm1
movss 0xf48(%rip),%xmm0
mulss %xmm1,%xmm0
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, [rbp+var_8]
movss xmm0, cs:dword_2098
mulss xmm0, xmm1
pop rbp
retn
|
float func0(float a1, float a2)
{
return 0.5 * (float)(a1 * a2);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,dword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [0x00102098]
MULSS XMM0,XMM1
POP RBP
RET
|
float func0(float param_1,float param_2)
{
return DAT_00102098 * param_1 * param_2;
}
|
837 |
func0
|
#include <stdio.h>
#include <math.h>
|
float func0(float a, float h) {
return (a * h) * 0.5;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mulss %xmm1,%xmm0
mulss 0xecb(%rip),%xmm0
retq
|
func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn
|
float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
}
|
func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
}
|
838 |
func0
|
#include <stdio.h>
#include <math.h>
|
float func0(float a, float h) {
return (a * h) * 0.5;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mulss %xmm1,%xmm0
mulss 0xeb4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn
|
float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
}
|
func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
}
|
839 |
func0
|
#include <stdio.h>
#include <math.h>
|
float func0(float a, float h) {
return (a * h) * 0.5;
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mulss %xmm1,%xmm0
mulss 0xeb4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn
|
float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
}
|
func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
}
|
840 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1c0,%rsp
mov %edi,-0x1b4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x1a0(%rbp)
movl $0x0,-0x19c(%rbp)
movl $0x2,-0x198(%rbp)
movl $0x0,-0x194(%rbp)
movl $0x4,-0x1a4(%rbp)
jmp 1225 <func0+0xbc>
mov -0x1a4(%rbp),%eax
sub $0x1,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%edx
mov -0x1a4(%rbp),%eax
sub $0x2,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
add %eax,%edx
mov -0x1a4(%rbp),%eax
sub $0x3,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
add %eax,%edx
mov -0x1a4(%rbp),%eax
sub $0x4,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
add %eax,%edx
mov -0x1a4(%rbp),%eax
cltq
mov %edx,-0x1a0(%rbp,%rax,4)
addl $0x1,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1b4(%rbp),%eax
jle 11c1 <func0+0x58>
mov -0x1b4(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1256 <func0+0xed>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_1B4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1A0], 0
mov [rbp+var_19C], 0
mov [rbp+var_198], 2
mov [rbp+var_194], 0
mov [rbp+var_1A4], 4
jmp short loc_1225
loc_11C1:
mov eax, [rbp+var_1A4]
sub eax, 1
cdqe
mov edx, [rbp+rax*4+var_1A0]
mov eax, [rbp+var_1A4]
sub eax, 2
cdqe
mov eax, [rbp+rax*4+var_1A0]
add edx, eax
mov eax, [rbp+var_1A4]
sub eax, 3
cdqe
mov eax, [rbp+rax*4+var_1A0]
add edx, eax
mov eax, [rbp+var_1A4]
sub eax, 4
cdqe
mov eax, [rbp+rax*4+var_1A0]
add edx, eax
mov eax, [rbp+var_1A4]
cdqe
mov [rbp+rax*4+var_1A0], edx
add [rbp+var_1A4], 1
loc_1225:
mov eax, [rbp+var_1A4]
cmp eax, [rbp+var_1B4]
jle short loc_11C1
mov eax, [rbp+var_1B4]
cdqe
mov eax, [rbp+rax*4+var_1A0]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1256
call ___stack_chk_fail
locret_1256:
leave
retn
|
long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-1A4h]
_DWORD v3[102]; // [rsp+20h] [rbp-1A0h]
unsigned long long v4; // [rsp+1B8h] [rbp-8h]
v4 = __readfsqword(0x28u);
v3[0] = 0;
v3[1] = 0;
v3[2] = 2;
v3[3] = 0;
for ( i = 4; i <= a1; ++i )
v3[i] = v3[i - 4] + v3[i - 3] + v3[i - 2] + v3[i - 1];
return (unsigned int)v3[a1];
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV dword ptr [RBP + -0x1b4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1a0],0x0
MOV dword ptr [RBP + -0x19c],0x0
MOV dword ptr [RBP + -0x198],0x2
MOV dword ptr [RBP + -0x194],0x0
MOV dword ptr [RBP + -0x1a4],0x4
JMP 0x00101225
LAB_001011c1:
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x2
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x3
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x4
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX
ADD dword ptr [RBP + -0x1a4],0x1
LAB_00101225:
MOV EAX,dword ptr [RBP + -0x1a4]
CMP EAX,dword ptr [RBP + -0x1b4]
JLE 0x001011c1
MOV EAX,dword ptr [RBP + -0x1b4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101256
CALL 0x00101060
LAB_00101256:
LEAVE
RET
|
int func0(int param_1)
{
long in_FS_OFFSET;
int local_1ac;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 2;
local_1a8[3] = 0;
for (local_1ac = 4; local_1ac <= param_1; local_1ac = local_1ac + 1) {
local_1a8[local_1ac] =
local_1a8[local_1ac + -1] + local_1a8[local_1ac + -2] + local_1a8[local_1ac + -3] +
local_1a8[local_1ac + -4];
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1a8[param_1];
}
|
841 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
}
|
O1
|
c
|
func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movl $0x0,(%rsp)
movl $0x0,0x4(%rsp)
movl $0x2,0x8(%rsp)
movl $0x0,0xc(%rsp)
cmp $0x3,%edi
jle 11cd <func0+0x64>
mov %rsp,%rax
lea -0x4(%rdi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov 0x8(%rax),%edx
add 0xc(%rax),%edx
add 0x4(%rax),%edx
add (%rax),%edx
mov %edx,0x10(%rax)
add $0x4,%rax
cmp %rcx,%rax
jne 11b6 <func0+0x4d>
movslq %edi,%rdi
mov (%rsp,%rdi,4),%eax
mov 0x198(%rsp),%rsi
xor %fs:0x28,%rsi
jne 11ee <func0+0x85>
add $0x1a8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
|
func0:
endbr64
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov [rsp+1A8h+var_1A8], 0
mov [rsp+1A8h+var_1A4], 0
mov [rsp+1A8h+var_1A0], 2
mov [rsp+1A8h+var_19C], 0
cmp edi, 3
jle short loc_11CD
mov rax, rsp
lea edx, [rdi-4]
lea rcx, [rsp+rdx*4+1A8h+var_1A4]
loc_11B6:
mov edx, [rax+8]
add edx, [rax+0Ch]
add edx, [rax+4]
add edx, [rax]
mov [rax+10h], edx
add rax, 4
cmp rax, rcx
jnz short loc_11B6
loc_11CD:
movsxd rdi, edi
mov eax, [rsp+rdi*4+1A8h+var_1A8]
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_11EE
add rsp, 1A8h
retn
loc_11EE:
call ___stack_chk_fail
|
long long func0(int a1)
{
int *v1; // rax
int v3; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v4[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v5; // [rsp+198h] [rbp-10h]
v5 = __readfsqword(0x28u);
v3 = 0;
v4[0] = 0;
v4[1] = 2;
v4[2] = 0;
if ( a1 > 3 )
{
v1 = &v3;
do
{
v1[4] = *v1 + v1[1] + v1[3] + v1[2];
++v1;
}
while ( v1 != &v4[a1 - 4] );
}
return (unsigned int)v4[a1 - 1];
}
|
func0:
ENDBR64
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP + 0x8],0x2
MOV dword ptr [RSP + 0xc],0x0
CMP EDI,0x3
JLE 0x001011cd
MOV RAX,RSP
LEA EDX,[RDI + -0x4]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011b6:
MOV EDX,dword ptr [RAX + 0x8]
ADD EDX,dword ptr [RAX + 0xc]
ADD EDX,dword ptr [RAX + 0x4]
ADD EDX,dword ptr [RAX]
MOV dword ptr [RAX + 0x10],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011b6
LAB_001011cd:
MOVSXD RDI,EDI
MOV EAX,dword ptr [RSP + RDI*0x4]
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001011ee
ADD RSP,0x1a8
RET
LAB_001011ee:
CALL 0x00101060
|
int func0(int param_1)
{
int *piVar1;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar1 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 2;
local_1a8[3] = 0;
if (3 < param_1) {
do {
piVar1[4] = piVar1[2] + piVar1[3] + piVar1[1] + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != local_1a8 + (ulong)(param_1 - 4) + 1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_1a8[param_1];
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
842 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
}
|
O2
|
c
|
func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x2,0x8(%rsp)
cmp $0x3,%edi
jle 12af <func0+0x6f>
lea -0x4(%rdi),%eax
lea 0x4(%rsp),%rdx
xor %r8d,%r8d
xor %esi,%esi
lea 0x8(%rsp,%rax,4),%r9
mov $0x2,%ecx
xor %eax,%eax
jmp 129c <func0+0x5c>
mov 0x8(%rdx),%eax
mov 0x4(%rdx),%ecx
mov (%rdx),%esi
mov -0x4(%rdx),%r8d
add %ecx,%eax
add $0x4,%rdx
add %esi,%eax
add %r8d,%eax
mov %eax,0x8(%rdx)
cmp %r9,%rdx
jne 1290 <func0+0x50>
movslq %edi,%rdi
mov (%rsp,%rdi,4),%eax
mov 0x198(%rsp),%rdi
xor %fs:0x28,%rdi
jne 12d0 <func0+0x90>
add $0x1a8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
sub rsp, 1A8h
movdqa xmm0, cs:xmmword_2070
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
movaps [rsp+1A8h+var_1A8], xmm0
cmp edi, 3
jle short loc_12A4
lea eax, [rdi-4]
mov rdx, rsp
mov ecx, 2
xor r8d, r8d
lea r9, [rsp+rax*4+1A8h+var_1A8+4]
xor eax, eax
nop dword ptr [rax+00h]
loc_1288:
mov esi, eax
lea eax, [rax+rcx]
add rdx, 4
add eax, r8d
add eax, [rdx-4]
mov r8d, ecx
mov ecx, esi
mov [rdx+0Ch], eax
cmp r9, rdx
jnz short loc_1288
loc_12A4:
movsxd rdi, edi
mov eax, dword ptr [rsp+rdi*4+1A8h+var_1A8]
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_12C5
add rsp, 1A8h
retn
loc_12C5:
call ___stack_chk_fail
|
long long func0(int a1)
{
__m128i *p_si128; // rdx
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // esi
__m128i si128; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v8; // [rsp+198h] [rbp-10h]
v8 = __readfsqword(0x28u);
si128 = _mm_load_si128((const __m128i *)&xmmword_2070);
if ( a1 > 3 )
{
p_si128 = &si128;
v2 = 2;
v3 = 0;
v4 = 0;
do
{
v5 = v4;
p_si128 = (__m128i *)((char *)p_si128 + 4);
v4 += p_si128[-1].m128i_i32[3] + v3 + v2;
v3 = v2;
v2 = v5;
p_si128->m128i_i32[3] = v4;
}
while ( (__m128i *)((char *)si128.m128i_i64 + 4 * (unsigned int)(a1 - 4) + 4) != p_si128 );
}
return si128.m128i_u32[a1];
}
|
func0:
ENDBR64
SUB RSP,0x1a8
MOVDQA XMM0,xmmword ptr [0x00102070]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
CMP EDI,0x3
JLE 0x001012a4
LEA EAX,[RDI + -0x4]
MOV RDX,RSP
MOV ECX,0x2
XOR R8D,R8D
LEA R9,[RSP + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101288:
MOV ESI,EAX
LEA EAX,[RAX + RCX*0x1]
ADD RDX,0x4
ADD EAX,R8D
ADD EAX,dword ptr [RDX + -0x4]
MOV R8D,ECX
MOV ECX,ESI
MOV dword ptr [RDX + 0xc],EAX
CMP R9,RDX
JNZ 0x00101288
LAB_001012a4:
MOVSXD RDI,EDI
MOV EAX,dword ptr [RSP + RDI*0x4]
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012c5
ADD RSP,0x1a8
RET
LAB_001012c5:
CALL 0x00101060
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
int8 local_1a8;
int8 uStack_1a0;
int local_198 [98];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8 = _DAT_00102070;
uStack_1a0 = _UNK_00102078;
if (3 < param_1) {
piVar4 = (int *)&local_1a8;
iVar2 = 0;
iVar1 = 2;
iVar6 = 0;
do {
iVar3 = iVar1;
iVar1 = iVar2;
piVar5 = piVar4 + 1;
iVar2 = iVar1 + iVar3 + iVar6 + *piVar4;
piVar4[4] = iVar2;
piVar4 = piVar5;
iVar6 = iVar3;
} while ((int *)((long)&local_1a8 + (ulong)(param_1 - 4) * 4 + 4) != piVar5);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)&local_1a8 + (long)param_1 * 4);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
843 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
}
|
O3
|
c
|
func0:
endbr64
sub $0x1a8,%rsp
movdqa 0xe3d(%rip),%xmm0
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movaps %xmm0,(%rsp)
cmp $0x3,%edi
jle 12fa <func0+0xba>
lea -0x1(%rdi),%r11d
cmp $0x6,%edi
jle 131b <func0+0xdb>
mov %rsp,%r10
mov 0x8(%rsp),%esi
mov 0xc(%rsp),%edx
mov $0x4,%ecx
mov 0x4(%rsp),%r8d
mov %r10,%rax
lea (%rsi,%rdx,1),%r9d
add $0xc,%rax
add %r9d,%r8d
add -0xc(%rax),%r8d
lea (%r8,%rdx,1),%r9d
mov %r8d,0x4(%rax)
add %r9d,%esi
add -0x8(%rax),%esi
lea (%r8,%rsi,1),%r9d
mov %esi,0x8(%rax)
add %r9d,%edx
mov %ecx,%r9d
add -0x4(%rax),%edx
add $0x3,%ecx
add $0x4,%r9d
mov %edx,0xc(%rax)
cmp %r9d,%r11d
jg 1298 <func0+0x58>
movslq %ecx,%rax
lea (%r10,%rax,4),%rdx
nopl 0x0(%rax,%rax,1)
mov -0x4(%rdx),%eax
add $0x1,%ecx
add -0x8(%rdx),%eax
add $0x4,%rdx
add -0x10(%rdx),%eax
add -0x14(%rdx),%eax
mov %eax,-0x4(%rdx)
cmp %ecx,%edi
jge 12e0 <func0+0xa0>
mov 0x198(%rsp),%rsi
xor %fs:0x28,%rsi
movslq %edi,%rdi
mov (%rsp,%rdi,4),%eax
jne 1325 <func0+0xe5>
add $0x1a8,%rsp
retq
mov $0x4,%ecx
mov %rsp,%r10
jmp 12d4 <func0+0x94>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
sub rsp, 1A8h
movdqa xmm0, cs:xmmword_2070
movsxd rsi, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
movaps [rsp+1A8h+var_1A8], xmm0
cmp esi, 3
jle loc_12FA
lea r11d, [rsi-1]
cmp esi, 6
jle loc_1318
mov r10, rsp
xor r8d, r8d
mov edi, 2
xor edx, edx
mov rax, r10
mov ecx, 4
loc_1298:
lea r9d, [r8+rdi]
add rax, 0Ch
add edx, r9d
add edx, [rax-0Ch]
lea r9d, [rdx+r8]
mov [rax+4], edx
add edi, r9d
add edi, [rax-8]
lea r9d, [rdx+rdi]
mov [rax+8], edi
add r8d, r9d
mov r9d, ecx
add r8d, [rax-4]
add ecx, 3
add r9d, 4
mov [rax+0Ch], r8d
cmp r11d, r9d
jg short loc_1298
loc_12D4:
movsxd rax, ecx
lea rdx, [r10+rax*4]
nop dword ptr [rax+rax+00h]
loc_12E0:
mov eax, [rdx-4]
add ecx, 1
add eax, [rdx-8]
add rdx, 4
add eax, [rdx-10h]
add eax, [rdx-14h]
mov [rdx-4], eax
cmp esi, ecx
jge short loc_12E0
loc_12FA:
mov eax, dword ptr [rsp+rsi*4+1A8h+var_1A8]
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_1322
add rsp, 1A8h
retn
loc_1318:
mov ecx, 4
mov r10, rsp
jmp short loc_12D4
loc_1322:
call ___stack_chk_fail
|
long long func0(int a1)
{
long long v1; // rsi
int v2; // r8d
int v3; // edi
int v4; // edx
__m128i *p_si128; // rax
int v6; // ecx
int v7; // r9d
char *v8; // rdx
int v9; // eax
__m128i si128; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v12; // [rsp+198h] [rbp-10h]
v1 = a1;
v12 = __readfsqword(0x28u);
si128 = _mm_load_si128((const __m128i *)&xmmword_2070);
if ( a1 > 3 )
{
if ( a1 <= 6 )
{
v6 = 4;
}
else
{
v2 = 0;
v3 = 2;
v4 = 0;
p_si128 = &si128;
v6 = 4;
do
{
p_si128 = (__m128i *)((char *)p_si128 + 12);
v4 += p_si128[-1].m128i_i32[1] + v2 + v3;
p_si128->m128i_i32[1] = v4;
v3 += p_si128[-1].m128i_i32[2] + v4 + v2;
p_si128->m128i_i32[2] = v3;
v7 = v6;
v2 += p_si128[-1].m128i_i32[3] + v4 + v3;
v6 += 3;
p_si128->m128i_i32[3] = v2;
}
while ( (int)v1 - 1 > v7 + 4 );
}
v8 = &si128.m128i_i8[4 * v6];
do
{
++v6;
v9 = *((_DWORD *)v8 - 2) + *((_DWORD *)v8 - 1);
v8 += 4;
*((_DWORD *)v8 - 1) = *((_DWORD *)v8 - 5) + *((_DWORD *)v8 - 4) + v9;
}
while ( (int)v1 >= v6 );
}
return si128.m128i_u32[v1];
}
|
func0:
ENDBR64
SUB RSP,0x1a8
MOVDQA XMM0,xmmword ptr [0x00102070]
MOVSXD RSI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
CMP ESI,0x3
JLE 0x001012fa
LEA R11D,[RSI + -0x1]
CMP ESI,0x6
JLE 0x00101318
MOV R10,RSP
XOR R8D,R8D
MOV EDI,0x2
XOR EDX,EDX
MOV RAX,R10
MOV ECX,0x4
LAB_00101298:
LEA R9D,[R8 + RDI*0x1]
ADD RAX,0xc
ADD EDX,R9D
ADD EDX,dword ptr [RAX + -0xc]
LEA R9D,[RDX + R8*0x1]
MOV dword ptr [RAX + 0x4],EDX
ADD EDI,R9D
ADD EDI,dword ptr [RAX + -0x8]
LEA R9D,[RDX + RDI*0x1]
MOV dword ptr [RAX + 0x8],EDI
ADD R8D,R9D
MOV R9D,ECX
ADD R8D,dword ptr [RAX + -0x4]
ADD ECX,0x3
ADD R9D,0x4
MOV dword ptr [RAX + 0xc],R8D
CMP R11D,R9D
JG 0x00101298
LAB_001012d4:
MOVSXD RAX,ECX
LEA RDX,[R10 + RAX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e0:
MOV EAX,dword ptr [RDX + -0x4]
ADD ECX,0x1
ADD EAX,dword ptr [RDX + -0x8]
ADD RDX,0x4
ADD EAX,dword ptr [RDX + -0x10]
ADD EAX,dword ptr [RDX + -0x14]
MOV dword ptr [RDX + -0x4],EAX
CMP ESI,ECX
JGE 0x001012e0
LAB_001012fa:
MOV EAX,dword ptr [RSP + RSI*0x4]
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101322
ADD RSP,0x1a8
RET
LAB_00101318:
MOV ECX,0x4
MOV R10,RSP
JMP 0x001012d4
LAB_00101322:
CALL 0x00101060
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(int param_1)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int8 local_1a8;
int8 uStack_1a0;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8 = _DAT_00102070;
uStack_1a0 = _UNK_00102078;
if (3 < param_1) {
if (param_1 < 7) {
iVar3 = 4;
}
else {
iVar6 = 0;
iVar5 = 2;
iVar4 = 0;
piVar1 = (int *)&local_1a8;
iVar2 = 4;
do {
iVar4 = iVar4 + iVar6 + iVar5 + *piVar1;
piVar1[4] = iVar4;
iVar5 = iVar5 + iVar4 + iVar6 + piVar1[1];
piVar1[5] = iVar5;
iVar6 = iVar6 + iVar4 + iVar5 + piVar1[2];
iVar3 = iVar2 + 3;
iVar7 = iVar2 + 4;
piVar1[6] = iVar6;
piVar1 = piVar1 + 3;
iVar2 = iVar3;
} while (iVar7 < param_1 + -1);
}
piVar1 = (int *)((long)&local_1a8 + (long)iVar3 * 4);
do {
iVar3 = iVar3 + 1;
*piVar1 = piVar1[-1] + piVar1[-2] + piVar1[-3] + piVar1[-4];
piVar1 = piVar1 + 1;
} while (iVar3 <= param_1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)&local_1a8 + (long)param_1 * 4);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
844 |
func0
|
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
|
float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
return 0.5 * (l[size / 2] + l[size / 2 - 1]);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4);
float list4[] = {6, 5};
assert(fabs(func0(list4, 2) - 5.5) < 1e-4);
float list5[] = {8, 1, 3, 9, 9, 2, 7};
assert(fabs(func0(list5, 7) - 7) < 1e-4);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1245 <func0+0xdc>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 1235 <func0+0xcc>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
comiss %xmm1,%xmm0
jbe 1231 <func0+0xc8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
movss %xmm0,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
movss (%rdx),%xmm0
movss %xmm0,(%rax)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss -0x4(%rbp),%xmm0
movss %xmm0,(%rax)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1192 <func0+0x29>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1184 <func0+0x1b>
mov -0x1c(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1287 <func0+0x11e>
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
jmp 12d9 <func0+0x170>
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
addss %xmm0,%xmm1
movss 0xe43(%rip),%xmm0
mulss %xmm1,%xmm0
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
jmp loc_1245
loc_1184:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp loc_1235
loc_1192:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm1, dword ptr [rax]
comiss xmm0, xmm1
jbe short loc_1231
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
movss [rbp+var_4], xmm0
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
movss xmm0, dword ptr [rdx]
movss dword ptr [rax], xmm0
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, [rbp+var_4]
movss dword ptr [rax], xmm0
loc_1231:
add [rbp+var_8], 1
loc_1235:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_1192
add [rbp+var_C], 1
loc_1245:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_1184
mov edx, [rbp+var_1C]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_128D
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
jmp short loc_12DF
loc_128D:
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm1, dword ptr [rax]
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
addss xmm1, xmm0
movss xmm0, cs:dword_20F8
mulss xmm0, xmm1
loc_12DF:
pop rbp
retn
|
float func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
int j; // [rsp+14h] [rbp-8h]
int v5; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(float *)(4LL * i + a1) > *(float *)(4LL * j + a1) )
{
v5 = *(_DWORD *)(4LL * i + a1);
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(a1 + 4LL * j);
*(_DWORD *)(4LL * j + a1) = v5;
}
}
}
if ( a2 % 2 == 1 )
return *(float *)(4LL * (a2 / 2) + a1);
else
return 0.5 * (float)(*(float *)(4LL * (a2 / 2) + a1) + *(float *)(4LL * (a2 / 2) - 4 + a1));
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101245
LAB_00101184:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101235
LAB_00101192:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,XMM1
JBE 0x00101231
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x4],XMM0
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOVSS XMM0,dword ptr [RDX]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVSS dword ptr [RAX],XMM0
LAB_00101231:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101235:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101192
ADD dword ptr [RBP + -0xc],0x1
LAB_00101245:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101184
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x0010128d
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
JMP 0x001012df
LAB_0010128d:
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [0x001020f8]
MULSS XMM0,XMM1
LAB_001012df:
POP RBP
RET
|
float func0(long param_1,int param_2)
{
int4 uVar1;
float fVar2;
int4 local_14;
int4 local_10;
for (local_14 = 0; local_10 = local_14, local_14 < param_2; local_14 = local_14 + 1) {
while (local_10 = local_10 + 1, local_10 < param_2) {
if (*(float *)(param_1 + (long)local_10 * 4) < *(float *)(param_1 + (long)local_14 * 4)) {
uVar1 = *(int4 *)(param_1 + (long)local_14 * 4);
*(int4 *)(param_1 + (long)local_14 * 4) =
*(int4 *)((long)local_10 * 4 + param_1);
*(int4 *)(param_1 + (long)local_10 * 4) = uVar1;
}
}
}
if (param_2 % 2 == 1) {
fVar2 = *(float *)(param_1 + (long)(param_2 / 2) * 4);
}
else {
fVar2 = DAT_001020f8 *
(*(float *)(param_1 + (long)(param_2 / 2) * 4) +
*(float *)(param_1 + (long)(param_2 / 2) * 4 + -4));
}
return fVar2;
}
|
845 |
func0
|
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
|
float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
return 0.5 * (l[size / 2] + l[size / 2 - 1]);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4);
float list4[] = {6, 5};
assert(fabs(func0(list4, 2) - 5.5) < 1e-4);
float list5[] = {8, 1, 3, 9, 9, 2, 7};
assert(fabs(func0(list5, 7) - 7) < 1e-4);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11b6 <func0+0x4d>
mov %rdi,%rdx
lea -0x1(%rsi),%r8d
add $0x1,%r8
mov $0x1,%ecx
jmp 11ac <func0+0x43>
add $0x1,%rax
cmp %eax,%esi
jle 11a4 <func0+0x3b>
movss (%rdx),%xmm0
movss (%rdi,%rax,4),%xmm1
comiss %xmm1,%xmm0
jbe 1183 <func0+0x1a>
movss %xmm1,(%rdx)
movss %xmm0,(%rdi,%rax,4)
jmp 1183 <func0+0x1a>
add $0x1,%rcx
add $0x4,%rdx
cmp %r8,%rcx
je 11b6 <func0+0x4d>
mov %rcx,%rax
jmp 118b <func0+0x22>
mov %esi,%edx
shr $0x1f,%edx
lea (%rsi,%rdx,1),%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
je 11e8 <func0+0x7f>
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
sar %esi
movslq %esi,%rax
movss -0x4(%rdi,%rax,4),%xmm0
addss (%rdi,%rax,4),%xmm0
mulss 0xf29(%rip),%xmm0
retq
mov %edx,%eax
add %esi,%eax
sar %eax
cltq
movss (%rdi,%rax,4),%xmm0
retq
|
func0:
endbr64
push rbx
mov r11, rdi
mov edi, esi
test esi, esi
jle short loc_11EA
lea rdx, [r11+4]
lea ebx, [rsi-1]
mov r8d, esi
movsxd r10, esi
mov esi, 1
lea r9, [r11+8]
jmp short loc_11C1
loc_118F:
add rax, 4
cmp rax, rcx
jz short loc_11B1
loc_1198:
movss xmm0, dword ptr [rdx-4]
movss xmm1, dword ptr [rax]
comiss xmm0, xmm1
jbe short loc_118F
movss dword ptr [rdx-4], xmm1
movss dword ptr [rax], xmm0
jmp short loc_118F
loc_11B1:
lea rax, [rsi+1]
add rdx, 4
cmp rsi, r10
jz short loc_11D8
mov rsi, rax
loc_11C1:
cmp rsi, r8
jz short loc_11D8
mov eax, ebx
sub eax, esi
lea rax, [rsi+rax-1]
lea rcx, [r9+rax*4]
mov rax, rdx
jmp short loc_1198
loc_11D8:
mov edx, edi
shr edx, 1Fh
lea eax, [rdi+rdx]
and eax, 1
sub eax, edx
cmp eax, 1
jz short loc_120C
loc_11EA:
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
cdqe
movss xmm0, dword ptr [r11+rax*4-4]
addss xmm0, dword ptr [r11+rax*4]
mulss xmm0, cs:dword_2004
loc_120A:
pop rbx
retn
loc_120C:
mov eax, edx
add eax, edi
sar eax, 1
cdqe
movss xmm0, dword ptr [r11+rax*4]
jmp short loc_120A
|
float func0(long long a1, int a2)
{
_DWORD *v4; // rdx
int v5; // ebx
long long v6; // r8
long long v7; // r10
long long i; // rsi
_DWORD *v9; // rax
float v10; // xmm0_4
if ( a2 <= 0 )
return (float)(*(float *)(a1 + 4LL * (a2 / 2) - 4) + *(float *)(a1 + 4LL * (a2 / 2))) * 0.5;
v4 = (_DWORD *)(a1 + 4);
v5 = a2 - 1;
v6 = (unsigned int)a2;
v7 = a2;
for ( i = 1LL; i != v6; ++i )
{
v9 = v4;
do
{
v10 = *((float *)v4 - 1);
if ( v10 > *(float *)v9 )
{
*(v4 - 1) = *v9;
*(float *)v9 = v10;
}
++v9;
}
while ( v9 != (_DWORD *)(a1 + 8 + 4 * (i + (unsigned int)(v5 - i) - 1)) );
++v4;
if ( i == v7 )
break;
}
if ( a2 % 2 == 1 )
return *(float *)(a1 + 4LL * (a2 / 2));
else
return (float)(*(float *)(a1 + 4LL * (a2 / 2) - 4) + *(float *)(a1 + 4LL * (a2 / 2))) * 0.5;
}
|
func0:
ENDBR64
PUSH RBX
MOV R11,RDI
MOV EDI,ESI
TEST ESI,ESI
JLE 0x001011ea
LEA RDX,[R11 + 0x4]
LEA EBX,[RSI + -0x1]
MOV R8D,ESI
MOVSXD R10,ESI
MOV ESI,0x1
LEA R9,[R11 + 0x8]
JMP 0x001011c1
LAB_0010118f:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x001011b1
LAB_00101198:
MOVSS XMM0,dword ptr [RDX + -0x4]
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,XMM1
JBE 0x0010118f
MOVSS dword ptr [RDX + -0x4],XMM1
MOVSS dword ptr [RAX],XMM0
JMP 0x0010118f
LAB_001011b1:
LEA RAX,[RSI + 0x1]
ADD RDX,0x4
CMP RSI,R10
JZ 0x001011d8
MOV RSI,RAX
LAB_001011c1:
CMP RSI,R8
JZ 0x001011d8
MOV EAX,EBX
SUB EAX,ESI
LEA RAX,[RSI + RAX*0x1 + -0x1]
LEA RCX,[R9 + RAX*0x4]
MOV RAX,RDX
JMP 0x00101198
LAB_001011d8:
MOV EDX,EDI
SHR EDX,0x1f
LEA EAX,[RDI + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JZ 0x0010120c
LAB_001011ea:
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
CDQE
MOVSS XMM0,dword ptr [R11 + RAX*0x4 + -0x4]
ADDSS XMM0,dword ptr [R11 + RAX*0x4]
MULSS XMM0,dword ptr [0x00102004]
LAB_0010120a:
POP RBX
RET
LAB_0010120c:
MOV EAX,EDX
ADD EAX,EDI
SAR EAX,0x1
CDQE
MOVSS XMM0,dword ptr [R11 + RAX*0x4]
JMP 0x0010120a
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(long param_1,uint param_2)
{
float fVar1;
float *pfVar2;
float *pfVar3;
ulong uVar4;
bool bVar5;
if (0 < (int)param_2) {
pfVar3 = (float *)(param_1 + 4);
uVar4 = 1;
do {
if (uVar4 == param_2) break;
pfVar2 = pfVar3;
do {
fVar1 = pfVar3[-1];
if (*pfVar2 < fVar1) {
pfVar3[-1] = *pfVar2;
*pfVar2 = fVar1;
}
pfVar2 = pfVar2 + 1;
} while (pfVar2 != (float *)(param_1 + 8 +
((uVar4 - 1) + (ulong)((param_2 - 1) - (int)uVar4)) * 4));
pfVar3 = pfVar3 + 1;
bVar5 = uVar4 != (long)(int)param_2;
uVar4 = uVar4 + 1;
} while (bVar5);
if ((int)param_2 % 2 == 1) {
return *(float *)(param_1 + (long)((int)param_2 / 2) * 4);
}
}
return (*(float *)(param_1 + -4 + (long)((int)param_2 / 2) * 4) +
*(float *)(param_1 + (long)((int)param_2 / 2) * 4)) * _DAT_00102004;
}
|
846 |
func0
|
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
|
float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
return 0.5 * (l[size / 2] + l[size / 2 - 1]);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4);
float list4[] = {6, 5};
assert(fabs(func0(list4, 2) - 5.5) < 1e-4);
float list5[] = {8, 1, 3, 9, 9, 2, 7};
assert(fabs(func0(list5, 7) - 7) < 1e-4);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1424 <func0+0x54>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
mov %rdi,%rdx
add $0x1,%r8
cmp %rcx,%r8
je 1424 <func0+0x54>
nopl (%rax)
mov %rcx,%rax
nopl 0x0(%rax,%rax,1)
movss (%rdx),%xmm0
movss (%rdi,%rax,4),%xmm1
comiss %xmm1,%xmm0
jbe 140f <func0+0x3f>
movss %xmm1,(%rdx)
movss %xmm0,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 13f8 <func0+0x28>
add $0x1,%rcx
add $0x4,%rdx
cmp %rcx,%r8
jne 13f0 <func0+0x20>
mov %esi,%eax
shr $0x1f,%eax
add %esi,%eax
sar %eax
cltq
movss (%rdi,%rax,4),%xmm0
lea 0x0(,%rax,4),%rdx
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
and $0x1,%esi
sub %eax,%esi
cmp $0x1,%esi
je 145b <func0+0x8b>
addss -0x4(%rdi,%rdx,1),%xmm0
mulss 0xcb5(%rip),%xmm0
retq
nopl 0x0(%rax)
|
func0:
endbr64
test esi, esi
jle short loc_13EA
cmp esi, 1
jz short loc_1409
mov rdx, rdi
mov r8d, esi
mov ecx, 1
nop dword ptr [rax+rax+00000000h]
loc_13B0:
mov rax, rcx
nop dword ptr [rax+rax+00h]
loc_13B8:
movss xmm0, dword ptr [rdx]
movss xmm1, dword ptr [rdi+rax*4]
comiss xmm0, xmm1
jbe short loc_13CF
movss dword ptr [rdx], xmm1
movss dword ptr [rdi+rax*4], xmm0
loc_13CF:
add rax, 1
cmp esi, eax
jg short loc_13B8
add rcx, 1
add rdx, 4
cmp rcx, r8
jnz short loc_13B0
test sil, 1
jnz short loc_1409
loc_13EA:
mov eax, esi
shr eax, 1Fh
add eax, esi
sar eax, 1
cdqe
movss xmm0, dword ptr [rdi+rax*4-4]
addss xmm0, dword ptr [rdi+rax*4]
mulss xmm0, cs:dword_2004
retn
loc_1409:
sar esi, 1
movsxd rax, esi
movss xmm0, dword ptr [rdi+rax*4]
retn
|
float func0(float *a1, int a2)
{
float *v2; // rdx
long long i; // rcx
long long v4; // rax
float v5; // xmm0_4
float v6; // xmm1_4
if ( a2 <= 0 )
return (float)(a1[a2 / 2 - 1] + a1[a2 / 2]) * 0.5;
if ( a2 == 1 )
return a1[a2 >> 1];
v2 = a1;
for ( i = 1LL; i != a2; ++i )
{
v4 = i;
do
{
v5 = *v2;
v6 = a1[v4];
if ( *v2 > v6 )
{
*v2 = v6;
a1[v4] = v5;
}
++v4;
}
while ( a2 > (int)v4 );
++v2;
}
if ( (a2 & 1) != 0 )
return a1[a2 >> 1];
else
return (float)(a1[a2 / 2 - 1] + a1[a2 / 2]) * 0.5;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013ea
CMP ESI,0x1
JZ 0x00101409
MOV RDX,RDI
MOV R8D,ESI
MOV ECX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b8:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
COMISS XMM0,XMM1
JBE 0x001013cf
MOVSS dword ptr [RDX],XMM1
MOVSS dword ptr [RDI + RAX*0x4],XMM0
LAB_001013cf:
ADD RAX,0x1
CMP ESI,EAX
JG 0x001013b8
ADD RCX,0x1
ADD RDX,0x4
CMP RCX,R8
JNZ 0x001013b0
TEST SIL,0x1
JNZ 0x00101409
LAB_001013ea:
MOV EAX,ESI
SHR EAX,0x1f
ADD EAX,ESI
SAR EAX,0x1
CDQE
MOVSS XMM0,dword ptr [RDI + RAX*0x4 + -0x4]
ADDSS XMM0,dword ptr [RDI + RAX*0x4]
MULSS XMM0,dword ptr [0x00102004]
RET
LAB_00101409:
SAR ESI,0x1
MOVSXD RAX,ESI
MOVSS XMM0,dword ptr [RDI + RAX*0x4]
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float *param_1,uint param_2)
{
float fVar1;
ulong uVar2;
ulong uVar3;
float *pfVar4;
if ((int)param_2 < 1) {
LAB_001013ea:
return (param_1[(long)((int)param_2 / 2) + -1] + param_1[(int)param_2 / 2]) * _DAT_00102004;
}
if (param_2 != 1) {
uVar2 = 1;
pfVar4 = param_1;
uVar3 = uVar2;
do {
do {
fVar1 = *pfVar4;
if (param_1[uVar2] < fVar1) {
*pfVar4 = param_1[uVar2];
param_1[uVar2] = fVar1;
}
uVar2 = uVar2 + 1;
} while ((int)uVar2 < (int)param_2);
uVar2 = uVar3 + 1;
pfVar4 = pfVar4 + 1;
uVar3 = uVar2;
} while (uVar2 != param_2);
if ((param_2 & 1) == 0) goto LAB_001013ea;
}
return param_1[(int)param_2 >> 1];
}
|
847 |
func0
|
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
|
float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
return 0.5 * (l[size / 2] + l[size / 2 - 1]);
}
|
#include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4);
float list4[] = {6, 5};
assert(fabs(func0(list4, 2) - 5.5) < 1e-4);
float list5[] = {8, 1, 3, 9, 9, 2, 7};
assert(fabs(func0(list5, 7) - 7) < 1e-4);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 13e4 <func0+0x54>
cmp $0x1,%esi
je 13e4 <func0+0x54>
lea -0x2(%rsi),%r8d
mov %rdi,%rdx
mov $0x1,%ecx
add $0x2,%r8
nopl (%rax)
mov %rcx,%rax
nopl 0x0(%rax,%rax,1)
movss (%rdx),%xmm0
movss (%rdi,%rax,4),%xmm1
comiss %xmm1,%xmm0
jbe 13cf <func0+0x3f>
movss %xmm1,(%rdx)
movss %xmm0,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 13b8 <func0+0x28>
add $0x1,%rcx
add $0x4,%rdx
cmp %rcx,%r8
jne 13b0 <func0+0x20>
mov %esi,%eax
shr $0x1f,%eax
add %esi,%eax
sar %eax
cltq
movss (%rdi,%rax,4),%xmm0
lea 0x0(,%rax,4),%rdx
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
and $0x1,%esi
sub %eax,%esi
cmp $0x1,%esi
je 141b <func0+0x8b>
addss -0x4(%rdi,%rdx,1),%xmm0
mulss 0xcf5(%rip),%xmm0
retq
nopl 0x0(%rax)
|
func0:
endbr64
test esi, esi
jle short loc_12BA
cmp esi, 1
jz short loc_12D9
mov rdx, rdi
mov r8d, esi
mov ecx, 1
nop dword ptr [rax+rax+00000000h]
loc_1280:
mov rax, rcx
nop dword ptr [rax+rax+00h]
loc_1288:
movss xmm0, dword ptr [rdx]
movss xmm1, dword ptr [rdi+rax*4]
comiss xmm0, xmm1
jbe short loc_129F
movss dword ptr [rdx], xmm1
movss dword ptr [rdi+rax*4], xmm0
loc_129F:
add rax, 1
cmp esi, eax
jg short loc_1288
add rcx, 1
add rdx, 4
cmp r8, rcx
jnz short loc_1280
test sil, 1
jnz short loc_12D9
loc_12BA:
mov eax, esi
shr eax, 1Fh
add eax, esi
sar eax, 1
cdqe
movss xmm0, dword ptr [rdi+rax*4-4]
addss xmm0, dword ptr [rdi+rax*4]
mulss xmm0, cs:dword_2004
retn
loc_12D9:
sar esi, 1
movsxd rax, esi
movss xmm0, dword ptr [rdi+rax*4]
retn
|
float func0(float *a1, int a2)
{
float *v2; // rdx
long long i; // rcx
long long v4; // rax
float v5; // xmm0_4
float v6; // xmm1_4
if ( a2 <= 0 )
return (float)(a1[a2 / 2 - 1] + a1[a2 / 2]) * 0.5;
if ( a2 == 1 )
return a1[a2 >> 1];
v2 = a1;
for ( i = 1LL; i != a2; ++i )
{
v4 = i;
do
{
v5 = *v2;
v6 = a1[v4];
if ( *v2 > v6 )
{
*v2 = v6;
a1[v4] = v5;
}
++v4;
}
while ( a2 > (int)v4 );
++v2;
}
if ( (a2 & 1) != 0 )
return a1[a2 >> 1];
else
return (float)(a1[a2 / 2 - 1] + a1[a2 / 2]) * 0.5;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012ba
CMP ESI,0x1
JZ 0x001012d9
MOV RDX,RDI
MOV R8D,ESI
MOV ECX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101280:
MOV RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101288:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
COMISS XMM0,XMM1
JBE 0x0010129f
MOVSS dword ptr [RDX],XMM1
MOVSS dword ptr [RDI + RAX*0x4],XMM0
LAB_0010129f:
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101288
ADD RCX,0x1
ADD RDX,0x4
CMP R8,RCX
JNZ 0x00101280
TEST SIL,0x1
JNZ 0x001012d9
LAB_001012ba:
MOV EAX,ESI
SHR EAX,0x1f
ADD EAX,ESI
SAR EAX,0x1
CDQE
MOVSS XMM0,dword ptr [RDI + RAX*0x4 + -0x4]
ADDSS XMM0,dword ptr [RDI + RAX*0x4]
MULSS XMM0,dword ptr [0x00102004]
RET
LAB_001012d9:
SAR ESI,0x1
MOVSXD RAX,ESI
MOVSS XMM0,dword ptr [RDI + RAX*0x4]
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float *param_1,uint param_2)
{
float fVar1;
ulong uVar2;
ulong uVar3;
float *pfVar4;
if ((int)param_2 < 1) {
LAB_001012ba:
return (param_1[(long)((int)param_2 / 2) + -1] + param_1[(int)param_2 / 2]) * _DAT_00102004;
}
if (param_2 != 1) {
uVar2 = 1;
pfVar4 = param_1;
uVar3 = uVar2;
do {
do {
fVar1 = *pfVar4;
if (param_1[uVar2] < fVar1) {
*pfVar4 = param_1[uVar2];
param_1[uVar2] = fVar1;
}
uVar2 = uVar2 + 1;
} while ((int)uVar2 < (int)param_2);
uVar2 = uVar3 + 1;
pfVar4 = pfVar4 + 1;
uVar3 = uVar2;
} while (param_2 != uVar2);
if ((param_2 & 1) == 0) goto LAB_001012ba;
}
return param_1[(int)param_2 >> 1];
}
|
848 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11c6 <func0+0x5d>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x4(%rbp),%eax
sub $0x1,%eax
sub -0x8(%rbp),%eax
movslq %eax,%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 11c2 <func0+0x59>
mov $0x0,%eax
jmp 11dc <func0+0x73>
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x8(%rbp)
jl 1191 <func0+0x28>
mov $0x1,%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11C6
loc_1191:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_4]
sub eax, 1
sub eax, [rbp+var_8]
movsxd rcx, eax
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_11C2
mov eax, 0
jmp short locret_11DC
loc_11C2:
add [rbp+var_8], 1
loc_11C6:
mov eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_8], eax
jl short loc_1191
mov eax, 1
locret_11DC:
leave
retn
|
long long func0(const char *a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = strlen(a1);
for ( i = 0; i < v3 / 2; ++i )
{
if ( a1[i] != a1[v3 - 1 - i] )
return 0LL;
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011c6
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x8]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x001011c2
MOV EAX,0x0
JMP 0x001011dc
LAB_001011c2:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x8],EAX
JL 0x00101191
MOV EAX,0x1
LAB_001011dc:
LEAVE
RET
|
int8 func0(char *param_1)
{
size_t sVar1;
int local_10;
sVar1 = strlen(param_1);
local_10 = 0;
while( true ) {
if ((int)sVar1 / 2 <= local_10) {
return 1;
}
if (param_1[local_10] != param_1[((int)sVar1 + -1) - local_10]) break;
local_10 = local_10 + 1;
}
return 0;
}
|
849 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 119d <func0+0x54>
cltq
lea -0x1(%rsi,%rax,1),%rdx
mov $0x0,%eax
movzbl (%rdx),%edi
cmp %dil,(%rsi,%rax,1)
jne 11a3 <func0+0x5a>
add $0x1,%rax
sub $0x1,%rdx
cmp %eax,%ecx
jg 1182 <func0+0x39>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
|
func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_11AC
cdqe
lea rdx, [rbx+rax-1]
mov eax, 0
loc_1190:
movzx esi, byte ptr [rdx]
cmp [rbx+rax], sil
jnz short loc_11B3
add rax, 1
sub rdx, 1
cmp ecx, eax
jg short loc_1190
mov eax, 1
jmp short loc_11B8
loc_11AC:
mov eax, 1
jmp short loc_11B8
loc_11B3:
mov eax, 0
loc_11B8:
pop rbx
retn
|
long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
const char *v3; // rdx
long long v4; // rax
v1 = strlen(a1);
v2 = v1 / 2;
if ( v1 <= 1 )
return 1LL;
v3 = &a1[v1 - 1];
v4 = 0LL;
while ( a1[v4] == *v3 )
{
++v4;
--v3;
if ( v2 <= (int)v4 )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x001011ac
CDQE
LEA RDX,[RBX + RAX*0x1 + -0x1]
MOV EAX,0x0
LAB_00101190:
MOVZX ESI,byte ptr [RDX]
CMP byte ptr [RBX + RAX*0x1],SIL
JNZ 0x001011b3
ADD RAX,0x1
SUB RDX,0x1
CMP ECX,EAX
JG 0x00101190
MOV EAX,0x1
JMP 0x001011b8
LAB_001011ac:
MOV EAX,0x1
JMP 0x001011b8
LAB_001011b3:
MOV EAX,0x0
LAB_001011b8:
POP RBX
RET
|
int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (1 < iVar1) {
pcVar4 = param_1 + (long)iVar1 + -1;
lVar3 = 0;
do {
if (param_1[lVar3] != *pcVar4) {
return 0;
}
lVar3 = lVar3 + 1;
pcVar4 = pcVar4 + -1;
} while ((int)lVar3 < (int)(((uint)(sVar2 >> 0x1f) & 1) + iVar1) >> 1);
}
return 1;
}
|
850 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 1330 <func0+0x50>
sub $0x1,%eax
xor %edx,%edx
cltq
add %rbx,%rax
jmp 131c <func0+0x3c>
nopw 0x0(%rax,%rax,1)
add $0x1,%rdx
sub $0x1,%rax
cmp %edx,%ecx
jle 1330 <func0+0x50>
movzbl (%rax),%esi
cmp %sil,(%rbx,%rdx,1)
je 1310 <func0+0x30>
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1330
sub eax, 1
xor edx, edx
cdqe
add rax, rbx
jmp short loc_131C
loc_1310:
add rdx, 1
sub rax, 1
cmp ecx, edx
jle short loc_1330
loc_131C:
movzx esi, byte ptr [rax]
cmp [rbx+rdx], sil
jz short loc_1310
xor eax, eax
pop rbx
retn
loc_1330:
mov eax, 1
pop rbx
retn
|
long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
long long v3; // rdx
const char *i; // rax
v1 = strlen(a1);
v2 = v1 / 2;
if ( v1 <= 1 )
return 1LL;
v3 = 0LL;
for ( i = &a1[v1 - 1]; a1[v3] == *i; --i )
{
if ( v2 <= (int)++v3 )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101330
SUB EAX,0x1
XOR EDX,EDX
CDQE
ADD RAX,RBX
JMP 0x0010131c
LAB_00101310:
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,EDX
JLE 0x00101330
LAB_0010131c:
MOVZX ESI,byte ptr [RAX]
CMP byte ptr [RBX + RDX*0x1],SIL
JZ 0x00101310
XOR EAX,EAX
POP RBX
RET
LAB_00101330:
MOV EAX,0x1
POP RBX
RET
|
int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (1 < iVar1) {
lVar4 = 0;
pcVar3 = param_1 + (iVar1 + -1);
do {
if (param_1[lVar4] != *pcVar3) {
return 0;
}
lVar4 = lVar4 + 1;
pcVar3 = pcVar3 + -1;
} while ((int)lVar4 < (int)(((uint)(sVar2 >> 0x1f) & 1) + iVar1) >> 1);
}
return 1;
}
|
851 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 1330 <func0+0x50>
sub $0x1,%eax
xor %edx,%edx
cltq
add %rbx,%rax
jmp 131c <func0+0x3c>
nopw 0x0(%rax,%rax,1)
add $0x1,%rdx
sub $0x1,%rax
cmp %edx,%ecx
jle 1330 <func0+0x50>
movzbl (%rax),%esi
cmp %sil,(%rbx,%rdx,1)
je 1310 <func0+0x30>
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1330
sub eax, 1
xor edx, edx
cdqe
add rax, rbx
jmp short loc_131C
loc_1310:
add rdx, 1
sub rax, 1
cmp ecx, edx
jle short loc_1330
loc_131C:
movzx esi, byte ptr [rax]
cmp [rbx+rdx], sil
jz short loc_1310
xor eax, eax
pop rbx
retn
loc_1330:
mov eax, 1
pop rbx
retn
|
long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
long long v3; // rdx
const char *i; // rax
v1 = strlen(a1);
v2 = v1 / 2;
if ( v1 <= 1 )
return 1LL;
v3 = 0LL;
for ( i = &a1[v1 - 1]; a1[v3] == *i; --i )
{
if ( v2 <= (int)++v3 )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101330
SUB EAX,0x1
XOR EDX,EDX
CDQE
ADD RAX,RBX
JMP 0x0010131c
LAB_00101310:
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,EDX
JLE 0x00101330
LAB_0010131c:
MOVZX ESI,byte ptr [RAX]
CMP byte ptr [RBX + RDX*0x1],SIL
JZ 0x00101310
XOR EAX,EAX
POP RBX
RET
LAB_00101330:
MOV EAX,0x1
POP RBX
RET
|
int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (1 < iVar1) {
lVar4 = 0;
pcVar3 = param_1 + (iVar1 + -1);
do {
if (param_1[lVar4] != *pcVar3) {
return 0;
}
lVar4 = lVar4 + 1;
pcVar3 = pcVar3 + -1;
} while ((int)lVar4 < (int)(((uint)(sVar2 >> 0x1f) & 1) + iVar1) >> 1);
}
return 1;
}
|
852 |
func0
|
#include <stdio.h>
|
int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1197 <func0+0x2e>
mov -0x8(%rbp),%eax
add %eax,%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 1187 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1197
loc_1187:
mov eax, [rbp+var_8]
add eax, eax
cdq
idiv [rbp+var_18]
mov [rbp+var_8], edx
add [rbp+var_4], 1
loc_1197:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jl short loc_1187
mov eax, [rbp+var_8]
pop rbp
retn
|
long long func0(int a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v3 = 1;
for ( i = 0; i < a1; ++i )
v3 = (int)(2 * v3) % a2;
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101197
LAB_00101187:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x8],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101197:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101187
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
int func0(int param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 0; local_c < param_1; local_c = local_c + 1) {
local_10 = (local_10 * 2) % param_2;
}
return local_10;
}
|
853 |
func0
|
#include <stdio.h>
|
int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %edi,%edi
jle 118b <func0+0x22>
mov $0x0,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
cltd
idiv %esi
add $0x1,%ecx
cmp %ecx,%edi
jne 117b <func0+0x12>
mov %edx,%eax
retq
mov $0x1,%edx
jmp 1188 <func0+0x1f>
|
func0:
endbr64
test edi, edi
jle short loc_118B
mov ecx, 0
mov edx, 1
loc_117B:
lea eax, [rdx+rdx]
cdq
idiv esi
add ecx, 1
cmp edi, ecx
jnz short loc_117B
loc_1188:
mov eax, edx
retn
loc_118B:
mov edx, 1
jmp short loc_1188
|
long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
{
return 1;
}
else
{
v2 = 0;
v3 = 1;
do
{
v3 = (int)(2 * v3) % a2;
++v2;
}
while ( a1 != v2 );
}
return v3;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010118b
MOV ECX,0x0
MOV EDX,0x1
LAB_0010117b:
LEA EAX,[RDX + RDX*0x1]
CDQ
IDIV ESI
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010117b
LAB_00101188:
MOV EAX,EDX
RET
LAB_0010118b:
MOV EDX,0x1
JMP 0x00101188
|
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 1;
}
else {
iVar1 = 0;
iVar2 = 1;
do {
iVar2 = (iVar2 * 2) % param_2;
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
}
return iVar2;
}
|
854 |
func0
|
#include <stdio.h>
|
int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %edi,%edi
jle 1310 <func0+0x20>
xor %ecx,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
add $0x1,%ecx
cltd
idiv %esi
cmp %ecx,%edi
jne 1300 <func0+0x10>
mov %edx,%eax
retq
mov $0x1,%edx
mov %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test edi, edi
jle short loc_1310
xor ecx, ecx
mov edx, 1
nop
loc_1300:
lea eax, [rdx+rdx]
add ecx, 1
cdq
idiv esi
cmp edi, ecx
jnz short loc_1300
mov eax, edx
retn
loc_1310:
mov edx, 1
mov eax, edx
retn
|
long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
return 1LL;
v2 = 0;
v3 = 1;
do
{
++v2;
v3 = (int)(2 * v3) % a2;
}
while ( a1 != v2 );
return v3;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101310
XOR ECX,ECX
MOV EDX,0x1
NOP
LAB_00101300:
LEA EAX,[RDX + RDX*0x1]
ADD ECX,0x1
CDQ
IDIV ESI
CMP EDI,ECX
JNZ 0x00101300
MOV EAX,EDX
RET
LAB_00101310:
MOV EDX,0x1
MOV EAX,EDX
RET
|
ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar2 = iVar2 + 1;
uVar1 = (long)(iVar3 * 2) % (long)param_2;
iVar3 = (int)uVar1;
} while (param_1 != iVar2);
return uVar1 & 0xffffffff;
}
return 1;
}
|
855 |
func0
|
#include <stdio.h>
|
int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %edi,%edi
jle 1310 <func0+0x20>
xor %ecx,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
add $0x1,%ecx
cltd
idiv %esi
cmp %ecx,%edi
jne 1300 <func0+0x10>
mov %edx,%eax
retq
mov $0x1,%edx
mov %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test edi, edi
jle short loc_1310
xor ecx, ecx
mov edx, 1
nop
loc_1300:
lea eax, [rdx+rdx]
add ecx, 1
cdq
idiv esi
cmp edi, ecx
jnz short loc_1300
mov eax, edx
retn
loc_1310:
mov edx, 1
mov eax, edx
retn
|
long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
return 1LL;
v2 = 0;
v3 = 1;
do
{
++v2;
v3 = (int)(2 * v3) % a2;
}
while ( a1 != v2 );
return v3;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101310
XOR ECX,ECX
MOV EDX,0x1
NOP
LAB_00101300:
LEA EAX,[RDX + RDX*0x1]
ADD ECX,0x1
CDQ
IDIV ESI
CMP EDI,ECX
JNZ 0x00101300
MOV EAX,EDX
RET
LAB_00101310:
MOV EDX,0x1
MOV EAX,EDX
RET
|
ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar2 = iVar2 + 1;
uVar1 = (long)(iVar3 * 2) % (long)param_2;
iVar3 = (int)uVar1;
} while (param_1 != iVar2);
return uVar1 & 0xffffffff;
}
return 1;
}
|
856 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr = 'a' + rand() % 26;
str[j] = chr;
}
str[l] = '\0';
char *encoded_str = (char *)malloc(l + 1);
strcpy(encoded_str, str);
func0(encoded_str, 1);
func0(encoded_str, 0);
assert(strcmp(encoded_str, str) == 0);
free(str);
free(encoded_str);
}
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)
je 1269 <func0+0x20>
mov $0x5,%eax
jmp 126e <func0+0x25>
mov $0x15,%eax
mov %eax,-0x18(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %rax,-0x8(%rbp)
movq $0x0,-0x10(%rbp)
jmp 12e2 <func0+0x99>
mov -0x28(%rbp),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
lea -0x61(%rax),%edx
mov -0x18(%rbp),%eax
add %eax,%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,-0x14(%rbp)
mov -0x28(%rbp),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
mov %dl,(%rax)
addq $0x1,-0x10(%rbp)
mov -0x10(%rbp),%rax
cmp -0x8(%rbp),%rax
jb 128b <func0+0x42>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_2C], esi
cmp [rbp+var_2C], 0
jz short loc_1269
mov eax, 5
jmp short loc_126E
loc_1269:
mov eax, 15h
loc_126E:
mov [rbp+var_18], eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp short loc_12DE
loc_128B:
mov rdx, [rbp+s]
mov rax, [rbp+var_10]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
lea edx, [rax-61h]
mov eax, [rbp+var_18]
add edx, eax
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_14], eax
mov rdx, [rbp+s]
mov rax, [rbp+var_10]
add rax, rdx
mov edx, [rbp+var_14]
mov [rax], dl
add [rbp+var_10], 1
loc_12DE:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_8]
jb short loc_128B
nop
nop
leave
retn
|
size_t func0(const char *a1, int a2)
{
int v2; // eax
size_t result; // rax
int v4; // [rsp+18h] [rbp-18h]
size_t i; // [rsp+20h] [rbp-10h]
size_t v6; // [rsp+28h] [rbp-8h]
if ( a2 )
v2 = 5;
else
v2 = 21;
v4 = v2;
v6 = strlen(a1);
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= v6 )
break;
a1[i] = (v4 + a1[i] - 97) % 26 + 97;
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00101269
MOV EAX,0x5
JMP 0x0010126e
LAB_00101269:
MOV EAX,0x15
LAB_0010126e:
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x10],0x0
JMP 0x001012de
LAB_0010128b:
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
LEA EDX,[RAX + -0x61]
MOV EAX,dword ptr [RBP + -0x18]
ADD EDX,EAX
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 + -0x14],EAX
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX],DL
ADD qword ptr [RBP + -0x10],0x1
LAB_001012de:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x8]
JC 0x0010128b
NOP
NOP
LEAVE
RET
|
void func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
int iVar3;
ulong local_18;
if (param_2 == 0) {
iVar1 = 0x15;
}
else {
iVar1 = 5;
}
sVar2 = strlen(param_1);
for (local_18 = 0; local_18 < sVar2; local_18 = local_18 + 1) {
iVar3 = param_1[local_18] + -0x61 + iVar1;
param_1[local_18] = (char)iVar3 + (char)(iVar3 / 0x1a) * -0x1a + 'a';
}
return;
}
|
857 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr = 'a' + rand() % 26;
str[j] = chr;
}
str[l] = '\0';
char *encoded_str = (char *)malloc(l + 1);
strcpy(encoded_str, str);
func0(encoded_str, 1);
func0(encoded_str, 0);
assert(strcmp(encoded_str, str) == 0);
free(str);
free(encoded_str);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%rdx
cmp $0x1,%esi
sbb %r8d,%r8d
and $0x10,%r8d
add $0x5,%r8d
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
sub $0x1,%rdi
je 128e <func0+0x65>
mov %rdx,%rcx
add %rdx,%rdi
movsbl (%rcx),%eax
lea -0x61(%r8,%rax,1),%edx
movslq %edx,%rax
imul $0x4ec4ec4f,%rax,%rax
sar $0x23,%rax
mov %edx,%esi
sar $0x1f,%esi
sub %esi,%eax
imul $0x1a,%eax,%eax
sub %eax,%edx
add $0x61,%edx
mov %dl,(%rcx)
add $0x1,%rcx
cmp %rdi,%rcx
jne 125e <func0+0x35>
retq
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
cmp esi, 1
sbb ebx, ebx
and ebx, 10h
add ebx, 5
call _strlen
test rax, rax
jz short loc_12A2
mov rcx, rbp
lea rdi, [rbp+rax+0]
loc_1273:
movsx eax, byte ptr [rcx]
lea edx, [rbx+rax-61h]
movsxd rax, edx
imul rax, 4EC4EC4Fh
sar rax, 23h
mov esi, edx
sar esi, 1Fh
sub eax, esi
imul eax, 1Ah
sub edx, eax
add edx, 61h ; 'a'
mov [rcx], dl
add rcx, 1
cmp rcx, rdi
jnz short loc_1273
loc_12A2:
add rsp, 8
pop rbx
pop rbp
retn
|
size_t func0(const char *a1, int a2)
{
size_t result; // rax
char *v3; // rcx
char *v4; // rdi
int v5; // edx
result = strlen(a1);
if ( result )
{
v3 = (char *)a1;
v4 = (char *)&a1[result];
do
{
v5 = (a2 == 0 ? 21 : 5) + *v3 - 97;
result = (unsigned int)(26 * (v5 / 26));
*v3++ = v5 % 26 + 97;
}
while ( v3 != v4 );
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
CMP ESI,0x1
SBB EBX,EBX
AND EBX,0x10
ADD EBX,0x5
CALL 0x001010e0
TEST RAX,RAX
JZ 0x001012a2
MOV RCX,RBP
LEA RDI,[RBP + RAX*0x1]
LAB_00101273:
MOVSX EAX,byte ptr [RCX]
LEA EDX,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x4ec4ec4f
SAR RAX,0x23
MOV ESI,EDX
SAR ESI,0x1f
SUB EAX,ESI
IMUL EAX,EAX,0x1a
SUB EDX,EAX
ADD EDX,0x61
MOV byte ptr [RCX],DL
ADD RCX,0x1
CMP RCX,RDI
JNZ 0x00101273
LAB_001012a2:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void func0(char *param_1,int param_2)
{
int iVar1;
char *pcVar2;
size_t sVar3;
sVar3 = strlen(param_1);
if (sVar3 != 0) {
pcVar2 = param_1 + sVar3;
do {
iVar1 = ((-(uint)(param_2 == 0) & 0x10) - 0x5c) + (int)*param_1;
*param_1 = (char)iVar1 + (char)(iVar1 / 0x1a) * -0x1a + 'a';
param_1 = param_1 + 1;
} while (param_1 != pcVar2);
}
return;
}
|
858 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr = 'a' + rand() % 26;
str[j] = chr;
}
str[l] = '\0';
char *encoded_str = (char *)malloc(l + 1);
strcpy(encoded_str, str);
func0(encoded_str, 1);
func0(encoded_str, 0);
assert(strcmp(encoded_str, str) == 0);
free(str);
free(encoded_str);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
cmp $0x1,%esi
sbb %ebp,%ebp
and $0x10,%ebp
add $0x5,%ebp
callq 10f0 <strlen@plt>
test %rax,%rax
je 13f0 <func0+0x60>
mov %rbx,%rdi
lea (%rbx,%rax,1),%rsi
nopl 0x0(%rax)
movsbl (%rdi),%eax
add $0x1,%rdi
lea -0x61(%rbp,%rax,1),%edx
movslq %edx,%rax
mov %edx,%ecx
imul $0x4ec4ec4f,%rax,%rax
sar $0x1f,%ecx
sar $0x23,%rax
sub %ecx,%eax
imul $0x1a,%eax,%eax
sub %eax,%edx
add $0x61,%edx
mov %dl,-0x1(%rdi)
cmp %rdi,%rsi
jne 13c0 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
cmp esi, 1
sbb ebp, ebp
and ebp, 10h
add ebp, 5
call _strlen
test rax, rax
jz short loc_1460
mov rdi, rbx
add rax, rbx
nop dword ptr [rax+rax+00000000h]
loc_1430:
movsx edx, byte ptr [rdi]
add rdi, 1
lea ecx, [rbp+rdx-61h]
movsxd rdx, ecx
mov esi, ecx
imul rdx, 4EC4EC4Fh
sar esi, 1Fh
sar rdx, 23h
sub edx, esi
imul edx, 1Ah
sub ecx, edx
add ecx, 61h ; 'a'
mov [rdi-1], cl
cmp rdi, rax
jnz short loc_1430
loc_1460:
add rsp, 8
pop rbx
pop rbp
retn
|
size_t func0(const char *a1, int a2)
{
size_t result; // rax
int v3; // edx
result = strlen(a1);
if ( result )
{
result += (size_t)a1;
do
{
v3 = *a1++;
*((_BYTE *)a1 - 1) = ((a2 == 0 ? 21 : 5) + v3 - 97) % 26 + 97;
}
while ( a1 != (const char *)result );
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CMP ESI,0x1
SBB EBP,EBP
AND EBP,0x10
ADD EBP,0x5
CALL 0x001010e0
TEST RAX,RAX
JZ 0x00101460
MOV RDI,RBX
ADD RAX,RBX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101430:
MOVSX EDX,byte ptr [RDI]
ADD RDI,0x1
LEA ECX,[RBP + RDX*0x1 + -0x61]
MOVSXD RDX,ECX
MOV ESI,ECX
IMUL RDX,RDX,0x4ec4ec4f
SAR ESI,0x1f
SAR RDX,0x23
SUB EDX,ESI
IMUL EDX,EDX,0x1a
SUB ECX,EDX
ADD ECX,0x61
MOV byte ptr [RDI + -0x1],CL
CMP RDI,RAX
JNZ 0x00101430
LAB_00101460:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
sVar2 = strlen(param_1);
if (sVar2 != 0) {
pcVar3 = param_1;
do {
pcVar4 = pcVar3 + 1;
iVar1 = ((-(uint)(param_2 == 0) & 0x10) - 0x5c) + (int)*pcVar3;
*pcVar3 = (char)iVar1 + (char)(iVar1 / 0x1a) * -0x1a + 'a';
pcVar3 = pcVar4;
} while (pcVar4 != param_1 + sVar2);
}
return;
}
|
859 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr = 'a' + rand() % 26;
str[j] = chr;
}
str[l] = '\0';
char *encoded_str = (char *)malloc(l + 1);
strcpy(encoded_str, str);
func0(encoded_str, 1);
func0(encoded_str, 0);
assert(strcmp(encoded_str, str) == 0);
free(str);
free(encoded_str);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
cmp $0x1,%esi
sbb %ebp,%ebp
and $0x10,%ebp
add $0x5,%ebp
callq 10f0 <strlen@plt>
test %rax,%rax
je 212c <func0+0x4bc>
lea -0x1(%rax),%rdx
cmp $0xe,%rdx
jbe 2133 <func0+0x4c3>
movd %ebp,%xmm2
mov %rax,%rcx
movdqa 0x13bd(%rip),%xmm5
movdqa 0x13c5(%rip),%xmm4
punpcklwd %xmm2,%xmm2
and $0xfffffffffffffff0,%rcx
pxor %xmm6,%xmm6
mov %rbx,%rdx
movdqa 0x13be(%rip),%xmm3
movdqa 0x13c6(%rip),%xmm7
pshufd $0x0,%xmm2,%xmm2
add %rbx,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rdx),%xmm1
movdqa %xmm6,%xmm0
add $0x10,%rdx
pcmpgtb %xmm1,%xmm0
movdqa %xmm1,%xmm8
punpcklbw %xmm0,%xmm8
punpckhbw %xmm0,%xmm1
paddw %xmm5,%xmm8
movdqa %xmm1,%xmm0
paddw %xmm2,%xmm8
paddw %xmm5,%xmm0
movdqa %xmm8,%xmm1
movdqa %xmm8,%xmm9
paddw %xmm2,%xmm0
pmulhw %xmm4,%xmm1
psraw $0xf,%xmm9
psraw $0x3,%xmm1
psubw %xmm9,%xmm1
movdqa %xmm1,%xmm9
psllw $0x1,%xmm1
paddw %xmm9,%xmm1
psllw $0x2,%xmm1
paddw %xmm9,%xmm1
movdqa %xmm0,%xmm9
psllw $0x1,%xmm1
psraw $0xf,%xmm9
psubw %xmm1,%xmm8
movdqa %xmm0,%xmm1
pmulhw %xmm4,%xmm1
psraw $0x3,%xmm1
psubw %xmm9,%xmm1
movdqa %xmm1,%xmm9
psllw $0x1,%xmm1
paddw %xmm9,%xmm1
psllw $0x2,%xmm1
paddw %xmm9,%xmm1
psllw $0x1,%xmm1
psubw %xmm1,%xmm0
movdqa %xmm0,%xmm1
movdqa %xmm8,%xmm0
pand %xmm3,%xmm0
pand %xmm3,%xmm1
packuswb %xmm1,%xmm0
paddb %xmm7,%xmm0
movups %xmm0,-0x10(%rdx)
cmp %rcx,%rdx
jne 1ce8 <func0+0x78>
mov %rax,%rcx
and $0xfffffffffffffff0,%rcx
test $0xf,%al
je 212c <func0+0x4bc>
lea (%rbx,%rcx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x1(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x2(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x3(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x4(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x5(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x6(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x7(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x8(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0x9(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0xa(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0xb(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0xc(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
lea 0xd(%rcx),%rdx
add $0x61,%esi
mov %sil,(%rdi)
cmp %rdx,%rax
jbe 212c <func0+0x4bc>
lea (%rbx,%rdx,1),%rdi
add $0xe,%rcx
movsbl (%rdi),%edx
lea -0x61(%rbp,%rdx,1),%esi
movslq %esi,%rdx
mov %esi,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%esi
add $0x61,%esi
mov %sil,(%rdi)
cmp %rcx,%rax
jbe 212c <func0+0x4bc>
add %rcx,%rbx
movsbl (%rbx),%eax
lea -0x61(%rbp,%rax,1),%edx
movslq %edx,%rax
mov %edx,%ecx
imul $0x4ec4ec4f,%rax,%rax
sar $0x1f,%ecx
sar $0x23,%rax
sub %ecx,%eax
imul $0x1a,%eax,%eax
sub %eax,%edx
add $0x61,%edx
mov %dl,(%rbx)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
xor %ecx,%ecx
jmpq 1dd1 <func0+0x161>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
cmp esi, 1
sbb ebx, ebx
and ebx, 10h
add ebx, 5
call _strlen
test rax, rax
jz loc_294C
mov rdx, rax
lea rax, [rax-1]
cmp rax, 0Eh
jbe loc_2953
pxor xmm5, xmm5
movd xmm7, ebx
mov rcx, rdx
mov rax, rbp
movdqa xmm4, cs:xmmword_3060
movdqa xmm6, xmm5
punpcklwd xmm7, xmm7
and rcx, 0FFFFFFFFFFFFFFF0h
pshufd xmm7, xmm7, 0
lea rsi, [rbp+rcx+0]
pxor xmm10, xmm10
movdqa xmm9, cs:xmmword_3070
pcmpgtd xmm6, xmm4
paddw xmm7, cs:xmmword_3050
pxor xmm8, xmm8
movdqa xmm11, cs:xmmword_3080
nop dword ptr [rax+rax+00h]
loc_2270:
movdqu xmm2, xmmword ptr [rax]
movdqa xmm0, xmm10
movdqa xmm3, xmm8
movdqa xmm13, xmm5
movdqa xmm12, xmm8
movdqa xmm14, xmm6
movdqa xmm15, xmm6
add rax, 10h
pcmpgtb xmm0, xmm2
movdqa xmm1, xmm2
punpcklbw xmm1, xmm0
punpckhbw xmm2, xmm0
paddw xmm1, xmm7
paddw xmm2, xmm7
pcmpgtw xmm3, xmm1
pcmpgtw xmm12, xmm2
movdqa xmm0, xmm1
punpcklwd xmm0, xmm3
punpckhwd xmm1, xmm3
movdqa xmm3, xmm2
pcmpgtd xmm13, xmm0
pmuludq xmm14, xmm0
punpcklwd xmm3, xmm12
punpckhwd xmm2, xmm12
movdqa xmm12, xmm0
pmuludq xmm12, xmm4
pmuludq xmm13, xmm4
paddq xmm13, xmm14
movdqa xmm14, xmm5
psllq xmm13, 20h ; ' '
paddq xmm12, xmm13
movdqa xmm13, xmm0
psrlq xmm13, 20h ; ' '
pcmpgtd xmm14, xmm13
pmuludq xmm15, xmm13
pmuludq xmm13, xmm4
pmuludq xmm14, xmm4
paddq xmm14, xmm15
movdqa xmm15, xmm6
psllq xmm14, 20h ; ' '
paddq xmm13, xmm14
movdqa xmm14, xmm6
shufps xmm12, xmm13, 0DDh
movdqa xmm13, xmm0
pshufd xmm12, xmm12, 0D8h
psrad xmm13, 1Fh
psrad xmm12, 3
psubd xmm12, xmm13
pmuludq xmm14, xmm1
movdqa xmm13, xmm12
pslld xmm13, 1
paddd xmm13, xmm12
pslld xmm13, 2
paddd xmm12, xmm13
movdqa xmm13, xmm5
pcmpgtd xmm13, xmm1
pslld xmm12, 1
psubd xmm0, xmm12
movdqa xmm12, xmm1
pmuludq xmm12, xmm4
pmuludq xmm13, xmm4
paddq xmm13, xmm14
movdqa xmm14, xmm5
psllq xmm13, 20h ; ' '
paddq xmm12, xmm13
movdqa xmm13, xmm1
psrlq xmm13, 20h ; ' '
pcmpgtd xmm14, xmm13
pmuludq xmm15, xmm13
pmuludq xmm13, xmm4
pmuludq xmm14, xmm4
paddq xmm14, xmm15
psllq xmm14, 20h ; ' '
paddq xmm13, xmm14
movdqa xmm14, xmm6
shufps xmm12, xmm13, 0DDh
movdqa xmm13, xmm1
pshufd xmm12, xmm12, 0D8h
psrad xmm13, 1Fh
psrad xmm12, 3
psubd xmm12, xmm13
movdqa xmm13, xmm12
pslld xmm13, 1
paddd xmm13, xmm12
pslld xmm13, 2
paddd xmm12, xmm13
movdqa xmm13, xmm6
pslld xmm12, 1
pmuludq xmm13, xmm3
psubd xmm1, xmm12
movdqa xmm12, xmm0
punpcklwd xmm0, xmm1
punpckhwd xmm12, xmm1
movdqa xmm1, xmm0
punpcklwd xmm0, xmm12
punpckhwd xmm1, xmm12
movdqa xmm12, xmm5
pcmpgtd xmm12, xmm3
punpcklwd xmm0, xmm1
movdqa xmm1, xmm3
pmuludq xmm1, xmm4
pand xmm0, xmm9
pmuludq xmm12, xmm4
paddq xmm12, xmm13
movdqa xmm13, xmm5
psllq xmm12, 20h ; ' '
paddq xmm1, xmm12
movdqa xmm12, xmm3
psrlq xmm12, 20h ; ' '
pcmpgtd xmm13, xmm12
pmuludq xmm14, xmm12
pmuludq xmm12, xmm4
pmuludq xmm13, xmm4
paddq xmm13, xmm14
movdqa xmm14, xmm6
psllq xmm13, 20h ; ' '
paddq xmm12, xmm13
movdqa xmm13, xmm6
shufps xmm1, xmm12, 0DDh
movdqa xmm12, xmm3
pshufd xmm1, xmm1, 0D8h
psrad xmm12, 1Fh
psrad xmm1, 3
psubd xmm1, xmm12
pmuludq xmm13, xmm2
movdqa xmm12, xmm1
pslld xmm12, 1
paddd xmm12, xmm1
pslld xmm12, 2
paddd xmm12, xmm1
movdqa xmm1, xmm3
movdqa xmm3, xmm5
pcmpgtd xmm3, xmm2
pslld xmm12, 1
psubd xmm1, xmm12
movdqa xmm12, xmm2
pmuludq xmm12, xmm4
pmuludq xmm3, xmm4
paddq xmm3, xmm13
movdqa xmm13, xmm5
psllq xmm3, 20h ; ' '
paddq xmm12, xmm3
movdqa xmm3, xmm2
psrlq xmm3, 20h ; ' '
pcmpgtd xmm13, xmm3
pmuludq xmm14, xmm3
pmuludq xmm3, xmm4
pmuludq xmm13, xmm4
paddq xmm13, xmm14
psllq xmm13, 20h ; ' '
paddq xmm3, xmm13
shufps xmm12, xmm3, 0DDh
movdqa xmm3, xmm2
pshufd xmm12, xmm12, 0D8h
psrad xmm3, 1Fh
psrad xmm12, 3
psubd xmm12, xmm3
movdqa xmm3, xmm12
pslld xmm3, 1
paddd xmm3, xmm12
pslld xmm3, 2
paddd xmm3, xmm12
pslld xmm3, 1
psubd xmm2, xmm3
movdqa xmm3, xmm1
punpcklwd xmm1, xmm2
punpckhwd xmm3, xmm2
movdqa xmm2, xmm1
punpcklwd xmm1, xmm3
punpckhwd xmm2, xmm3
punpcklwd xmm1, xmm2
pand xmm1, xmm9
packuswb xmm0, xmm1
paddb xmm0, xmm11
movups xmmword ptr [rax-10h], xmm0
cmp rsi, rax
jnz loc_2270
cmp rdx, rcx
jz loc_294C
loc_25E6:
movsx eax, byte ptr [rsi]
lea edi, [rbx+rax-61h]
movsxd rax, edi
mov r8d, edi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub edi, eax
lea rax, [rcx+1]
add edi, 61h ; 'a'
mov [rsi], dil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+2]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+3]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+4]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+5]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+6]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+7]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+8]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+9]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+0Ah]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+0Bh]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+0Ch]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb loc_294C
lea rdi, [rbp+rax+0]
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
lea rax, [rcx+0Dh]
add esi, 61h ; 'a'
mov [rdi], sil
cmp rax, rdx
jnb short loc_294C
lea rdi, [rbp+rax+0]
add rcx, 0Eh
movsx eax, byte ptr [rdi]
lea esi, [rbx+rax-61h]
movsxd rax, esi
mov r8d, esi
imul rax, 4EC4EC4Fh
sar r8d, 1Fh
sar rax, 23h
sub eax, r8d
imul eax, 1Ah
sub esi, eax
add esi, 61h ; 'a'
mov [rdi], sil
cmp rcx, rdx
jnb short loc_294C
add rbp, rcx
movsx eax, byte ptr [rbp+0]
lea edx, [rbx+rax-61h]
movsxd rax, edx
mov ecx, edx
imul rax, 4EC4EC4Fh
sar ecx, 1Fh
sar rax, 23h
sub eax, ecx
imul eax, 1Ah
sub edx, eax
add edx, 61h ; 'a'
mov [rbp+0], dl
loc_294C:
add rsp, 8
pop rbx
pop rbp
retn
loc_2953:
xor ecx, ecx
mov rsi, rbp
jmp loc_25E6
|
size_t func0(const char *a1, int a2)
{
unsigned int v3; // ebx
size_t result; // rax
unsigned long long v5; // rdx
__m128i v6; // xmm7
__m128i si128; // xmm4
unsigned long long v8; // rcx
char *v9; // rsi
__m128i v10; // xmm9
__m128i v11; // xmm6
__m128i v12; // xmm7
__m128i v13; // xmm11
__m128i v14; // xmm2
__m128i v15; // xmm0
__m128i v16; // xmm1
__m128i v17; // xmm2
__m128i v18; // xmm3
__m128i v19; // xmm12
__m128i v20; // xmm0
__m128i v21; // xmm1
__m128i v22; // xmm3
__m128i v23; // xmm2
__m128i v24; // xmm13
__m128i v25; // xmm12
__m128i v26; // xmm0
__m128i v27; // xmm13
__m128i v28; // xmm12
__m128i v29; // xmm1
__m128i v30; // xmm12
__m128i v31; // xmm1
__m128i v32; // xmm0
__m128i v33; // xmm12
__m128i v34; // xmm1
__m128i v35; // xmm1
__m128i v36; // xmm3
__m128i v37; // xmm12
__m128i v38; // xmm2
__m128i v39; // xmm3
__m128i v40; // xmm2
char *v41; // rdi
int v42; // esi
char *v43; // rdi
int v44; // esi
char *v45; // rdi
int v46; // esi
char *v47; // rdi
int v48; // esi
char *v49; // rdi
int v50; // esi
char *v51; // rdi
int v52; // esi
char *v53; // rdi
int v54; // esi
char *v55; // rdi
int v56; // esi
char *v57; // rdi
int v58; // esi
char *v59; // rdi
int v60; // esi
char *v61; // rdi
int v62; // esi
char *v63; // rdi
int v64; // esi
char *v65; // rdi
unsigned long long v66; // rcx
int v67; // esi
char *v68; // rbp
int v69; // edx
v3 = a2 == 0 ? 21 : 5;
result = strlen(a1);
if ( result )
{
v5 = result;
if ( result - 1 <= 0xE )
{
v8 = 0LL;
v9 = (char *)a1;
}
else
{
v6 = _mm_cvtsi32_si128(v3);
result = (size_t)a1;
si128 = _mm_load_si128((const __m128i *)&xmmword_3060);
v8 = v5 & 0xFFFFFFFFFFFFFFF0LL;
v9 = (char *)&a1[v5 & 0xFFFFFFFFFFFFFFF0LL];
v10 = _mm_load_si128((const __m128i *)&xmmword_3070);
v11 = _mm_cmpgt_epi32((__m128i)0LL, si128);
v12 = _mm_add_epi16(_mm_shuffle_epi32(_mm_unpacklo_epi16(v6, v6), 0), (__m128i)xmmword_3050);
v13 = _mm_load_si128((const __m128i *)&xmmword_3080);
do
{
v14 = _mm_loadu_si128((const __m128i *)result);
result += 16LL;
v15 = _mm_cmpgt_epi8((__m128i)0LL, v14);
v16 = _mm_add_epi16(_mm_unpacklo_epi8(v14, v15), v12);
v17 = _mm_add_epi16(_mm_unpackhi_epi8(v14, v15), v12);
v18 = _mm_cmpgt_epi16((__m128i)0LL, v16);
v19 = _mm_cmpgt_epi16((__m128i)0LL, v17);
v20 = _mm_unpacklo_epi16(v16, v18);
v21 = _mm_unpackhi_epi16(v16, v18);
v22 = _mm_unpacklo_epi16(v17, v19);
v23 = _mm_unpackhi_epi16(v17, v19);
v24 = _mm_srli_epi64(v20, 0x20u);
v25 = _mm_sub_epi32(
_mm_srai_epi32(
_mm_shuffle_epi32(
(__m128i)_mm_shuffle_ps(
(__m128)_mm_add_epi64(
_mm_mul_epu32(v20, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v20), si128),
_mm_mul_epu32(v11, v20)),
0x20u)),
(__m128)_mm_add_epi64(
_mm_mul_epu32(v24, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v24), si128),
_mm_mul_epu32(v11, v24)),
0x20u)),
221),
216),
3u),
_mm_srai_epi32(v20, 0x1Fu));
v26 = _mm_sub_epi32(
v20,
_mm_slli_epi32(_mm_add_epi32(v25, _mm_slli_epi32(_mm_add_epi32(_mm_slli_epi32(v25, 1u), v25), 2u)), 1u));
v27 = _mm_srli_epi64(v21, 0x20u);
v28 = _mm_sub_epi32(
_mm_srai_epi32(
_mm_shuffle_epi32(
(__m128i)_mm_shuffle_ps(
(__m128)_mm_add_epi64(
_mm_mul_epu32(v21, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v21), si128),
_mm_mul_epu32(v11, v21)),
0x20u)),
(__m128)_mm_add_epi64(
_mm_mul_epu32(v27, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v27), si128),
_mm_mul_epu32(v11, v27)),
0x20u)),
221),
216),
3u),
_mm_srai_epi32(v21, 0x1Fu));
v29 = _mm_sub_epi32(
v21,
_mm_slli_epi32(_mm_add_epi32(v28, _mm_slli_epi32(_mm_add_epi32(_mm_slli_epi32(v28, 1u), v28), 2u)), 1u));
v30 = _mm_unpackhi_epi16(v26, v29);
v31 = _mm_unpacklo_epi16(v26, v29);
v32 = _mm_unpacklo_epi16(_mm_unpacklo_epi16(v31, v30), _mm_unpackhi_epi16(v31, v30));
v33 = _mm_srli_epi64(v22, 0x20u);
v34 = _mm_sub_epi32(
_mm_srai_epi32(
_mm_shuffle_epi32(
(__m128i)_mm_shuffle_ps(
(__m128)_mm_add_epi64(
_mm_mul_epu32(v22, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v22), si128),
_mm_mul_epu32(v11, v22)),
0x20u)),
(__m128)_mm_add_epi64(
_mm_mul_epu32(v33, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v33), si128),
_mm_mul_epu32(v11, v33)),
0x20u)),
221),
216),
3u),
_mm_srai_epi32(v22, 0x1Fu));
v35 = _mm_sub_epi32(
v22,
_mm_slli_epi32(_mm_add_epi32(_mm_slli_epi32(_mm_add_epi32(_mm_slli_epi32(v34, 1u), v34), 2u), v34), 1u));
v36 = _mm_srli_epi64(v23, 0x20u);
v37 = _mm_sub_epi32(
_mm_srai_epi32(
_mm_shuffle_epi32(
(__m128i)_mm_shuffle_ps(
(__m128)_mm_add_epi64(
_mm_mul_epu32(v23, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v23), si128),
_mm_mul_epu32(v11, v23)),
0x20u)),
(__m128)_mm_add_epi64(
_mm_mul_epu32(v36, si128),
_mm_slli_epi64(
_mm_add_epi64(
_mm_mul_epu32(_mm_cmpgt_epi32((__m128i)0LL, v36), si128),
_mm_mul_epu32(v11, v36)),
0x20u)),
221),
216),
3u),
_mm_srai_epi32(v23, 0x1Fu));
v38 = _mm_sub_epi32(
v23,
_mm_slli_epi32(_mm_add_epi32(_mm_slli_epi32(_mm_add_epi32(_mm_slli_epi32(v37, 1u), v37), 2u), v37), 1u));
v39 = _mm_unpackhi_epi16(v35, v38);
v40 = _mm_unpacklo_epi16(v35, v38);
*(__m128i *)(result - 16) = _mm_add_epi8(
_mm_packus_epi16(
_mm_and_si128(v32, v10),
_mm_and_si128(
_mm_unpacklo_epi16(_mm_unpacklo_epi16(v40, v39), _mm_unpackhi_epi16(v40, v39)),
v10)),
v13);
}
while ( v9 != (char *)result );
if ( v5 == v8 )
return result;
}
result = v8 + 1;
*v9 = (int)(v3 + *v9 - 97) % 26 + 97;
if ( v8 + 1 < v5 )
{
v41 = (char *)&a1[result];
v42 = v3 + a1[result] - 97;
result = v8 + 2;
*v41 = v42 % 26 + 97;
if ( v8 + 2 < v5 )
{
v43 = (char *)&a1[result];
v44 = v3 + a1[result] - 97;
result = v8 + 3;
*v43 = v44 % 26 + 97;
if ( v8 + 3 < v5 )
{
v45 = (char *)&a1[result];
v46 = v3 + a1[result] - 97;
result = v8 + 4;
*v45 = v46 % 26 + 97;
if ( v8 + 4 < v5 )
{
v47 = (char *)&a1[result];
v48 = v3 + a1[result] - 97;
result = v8 + 5;
*v47 = v48 % 26 + 97;
if ( v8 + 5 < v5 )
{
v49 = (char *)&a1[result];
v50 = v3 + a1[result] - 97;
result = v8 + 6;
*v49 = v50 % 26 + 97;
if ( v8 + 6 < v5 )
{
v51 = (char *)&a1[result];
v52 = v3 + a1[result] - 97;
result = v8 + 7;
*v51 = v52 % 26 + 97;
if ( v8 + 7 < v5 )
{
v53 = (char *)&a1[result];
v54 = v3 + a1[result] - 97;
result = v8 + 8;
*v53 = v54 % 26 + 97;
if ( v8 + 8 < v5 )
{
v55 = (char *)&a1[result];
v56 = v3 + a1[result] - 97;
result = v8 + 9;
*v55 = v56 % 26 + 97;
if ( v8 + 9 < v5 )
{
v57 = (char *)&a1[result];
v58 = v3 + a1[result] - 97;
result = v8 + 10;
*v57 = v58 % 26 + 97;
if ( v8 + 10 < v5 )
{
v59 = (char *)&a1[result];
v60 = v3 + a1[result] - 97;
result = v8 + 11;
*v59 = v60 % 26 + 97;
if ( v8 + 11 < v5 )
{
v61 = (char *)&a1[result];
v62 = v3 + a1[result] - 97;
result = v8 + 12;
*v61 = v62 % 26 + 97;
if ( v8 + 12 < v5 )
{
v63 = (char *)&a1[result];
v64 = v3 + a1[result] - 97;
result = v8 + 13;
*v63 = v64 % 26 + 97;
if ( v8 + 13 < v5 )
{
v65 = (char *)&a1[result];
v66 = v8 + 14;
v67 = v3 + a1[result] - 97;
result = (unsigned int)(26 * (v67 / 26));
*v65 = v67 % 26 + 97;
if ( v66 < v5 )
{
v68 = (char *)&a1[v66];
v69 = v3 + *v68 - 97;
result = (unsigned int)(26 * (v69 / 26));
*v68 = v69 % 26 + 97;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CMP ESI,0x1
SBB EBX,EBX
AND EBX,0x10
ADD EBX,0x5
CALL 0x001010e0
TEST RAX,RAX
JZ 0x0010294c
MOV RDX,RAX
LEA RAX,[RAX + -0x1]
CMP RAX,0xe
JBE 0x00102953
PXOR XMM5,XMM5
MOVD XMM7,EBX
MOV RCX,RDX
MOV RAX,RBP
MOVDQA XMM4,xmmword ptr [0x00103060]
MOVDQA XMM6,XMM5
PUNPCKLWD XMM7,XMM7
AND RCX,-0x10
PSHUFD XMM7,XMM7,0x0
LEA RSI,[RBP + RCX*0x1]
PXOR XMM10,XMM10
MOVDQA XMM9,xmmword ptr [0x00103070]
PCMPGTD XMM6,XMM4
PADDW XMM7,xmmword ptr [0x00103050]
PXOR XMM8,XMM8
MOVDQA XMM11,xmmword ptr [0x00103080]
NOP dword ptr [RAX + RAX*0x1]
LAB_00102270:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQA XMM0,XMM10
MOVDQA XMM3,XMM8
MOVDQA XMM13,XMM5
MOVDQA XMM12,XMM8
MOVDQA XMM14,XMM6
MOVDQA XMM15,XMM6
ADD RAX,0x10
PCMPGTB XMM0,XMM2
MOVDQA XMM1,XMM2
PUNPCKLBW XMM1,XMM0
PUNPCKHBW XMM2,XMM0
PADDW XMM1,XMM7
PADDW XMM2,XMM7
PCMPGTW XMM3,XMM1
PCMPGTW XMM12,XMM2
MOVDQA XMM0,XMM1
PUNPCKLWD XMM0,XMM3
PUNPCKHWD XMM1,XMM3
MOVDQA XMM3,XMM2
PCMPGTD XMM13,XMM0
PMULUDQ XMM14,XMM0
PUNPCKLWD XMM3,XMM12
PUNPCKHWD XMM2,XMM12
MOVDQA XMM12,XMM0
PMULUDQ XMM12,XMM4
PMULUDQ XMM13,XMM4
PADDQ XMM13,XMM14
MOVDQA XMM14,XMM5
PSLLQ XMM13,0x20
PADDQ XMM12,XMM13
MOVDQA XMM13,XMM0
PSRLQ XMM13,0x20
PCMPGTD XMM14,XMM13
PMULUDQ XMM15,XMM13
PMULUDQ XMM13,XMM4
PMULUDQ XMM14,XMM4
PADDQ XMM14,XMM15
MOVDQA XMM15,XMM6
PSLLQ XMM14,0x20
PADDQ XMM13,XMM14
MOVDQA XMM14,XMM6
SHUFPS XMM12,XMM13,0xdd
MOVDQA XMM13,XMM0
PSHUFD XMM12,XMM12,0xd8
PSRAD XMM13,0x1f
PSRAD XMM12,0x3
PSUBD XMM12,XMM13
PMULUDQ XMM14,XMM1
MOVDQA XMM13,XMM12
PSLLD XMM13,0x1
PADDD XMM13,XMM12
PSLLD XMM13,0x2
PADDD XMM12,XMM13
MOVDQA XMM13,XMM5
PCMPGTD XMM13,XMM1
PSLLD XMM12,0x1
PSUBD XMM0,XMM12
MOVDQA XMM12,XMM1
PMULUDQ XMM12,XMM4
PMULUDQ XMM13,XMM4
PADDQ XMM13,XMM14
MOVDQA XMM14,XMM5
PSLLQ XMM13,0x20
PADDQ XMM12,XMM13
MOVDQA XMM13,XMM1
PSRLQ XMM13,0x20
PCMPGTD XMM14,XMM13
PMULUDQ XMM15,XMM13
PMULUDQ XMM13,XMM4
PMULUDQ XMM14,XMM4
PADDQ XMM14,XMM15
PSLLQ XMM14,0x20
PADDQ XMM13,XMM14
MOVDQA XMM14,XMM6
SHUFPS XMM12,XMM13,0xdd
MOVDQA XMM13,XMM1
PSHUFD XMM12,XMM12,0xd8
PSRAD XMM13,0x1f
PSRAD XMM12,0x3
PSUBD XMM12,XMM13
MOVDQA XMM13,XMM12
PSLLD XMM13,0x1
PADDD XMM13,XMM12
PSLLD XMM13,0x2
PADDD XMM12,XMM13
MOVDQA XMM13,XMM6
PSLLD XMM12,0x1
PMULUDQ XMM13,XMM3
PSUBD XMM1,XMM12
MOVDQA XMM12,XMM0
PUNPCKLWD XMM0,XMM1
PUNPCKHWD XMM12,XMM1
MOVDQA XMM1,XMM0
PUNPCKLWD XMM0,XMM12
PUNPCKHWD XMM1,XMM12
MOVDQA XMM12,XMM5
PCMPGTD XMM12,XMM3
PUNPCKLWD XMM0,XMM1
MOVDQA XMM1,XMM3
PMULUDQ XMM1,XMM4
PAND XMM0,XMM9
PMULUDQ XMM12,XMM4
PADDQ XMM12,XMM13
MOVDQA XMM13,XMM5
PSLLQ XMM12,0x20
PADDQ XMM1,XMM12
MOVDQA XMM12,XMM3
PSRLQ XMM12,0x20
PCMPGTD XMM13,XMM12
PMULUDQ XMM14,XMM12
PMULUDQ XMM12,XMM4
PMULUDQ XMM13,XMM4
PADDQ XMM13,XMM14
MOVDQA XMM14,XMM6
PSLLQ XMM13,0x20
PADDQ XMM12,XMM13
MOVDQA XMM13,XMM6
SHUFPS XMM1,XMM12,0xdd
MOVDQA XMM12,XMM3
PSHUFD XMM1,XMM1,0xd8
PSRAD XMM12,0x1f
PSRAD XMM1,0x3
PSUBD XMM1,XMM12
PMULUDQ XMM13,XMM2
MOVDQA XMM12,XMM1
PSLLD XMM12,0x1
PADDD XMM12,XMM1
PSLLD XMM12,0x2
PADDD XMM12,XMM1
MOVDQA XMM1,XMM3
MOVDQA XMM3,XMM5
PCMPGTD XMM3,XMM2
PSLLD XMM12,0x1
PSUBD XMM1,XMM12
MOVDQA XMM12,XMM2
PMULUDQ XMM12,XMM4
PMULUDQ XMM3,XMM4
PADDQ XMM3,XMM13
MOVDQA XMM13,XMM5
PSLLQ XMM3,0x20
PADDQ XMM12,XMM3
MOVDQA XMM3,XMM2
PSRLQ XMM3,0x20
PCMPGTD XMM13,XMM3
PMULUDQ XMM14,XMM3
PMULUDQ XMM3,XMM4
PMULUDQ XMM13,XMM4
PADDQ XMM13,XMM14
PSLLQ XMM13,0x20
PADDQ XMM3,XMM13
SHUFPS XMM12,XMM3,0xdd
MOVDQA XMM3,XMM2
PSHUFD XMM12,XMM12,0xd8
PSRAD XMM3,0x1f
PSRAD XMM12,0x3
PSUBD XMM12,XMM3
MOVDQA XMM3,XMM12
PSLLD XMM3,0x1
PADDD XMM3,XMM12
PSLLD XMM3,0x2
PADDD XMM3,XMM12
PSLLD XMM3,0x1
PSUBD XMM2,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM1,XMM2
PUNPCKHWD XMM3,XMM2
MOVDQA XMM2,XMM1
PUNPCKLWD XMM1,XMM3
PUNPCKHWD XMM2,XMM3
PUNPCKLWD XMM1,XMM2
PAND XMM1,XMM9
PACKUSWB XMM0,XMM1
PADDB XMM0,XMM11
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RSI,RAX
JNZ 0x00102270
CMP RDX,RCX
JZ 0x0010294c
LAB_001025e6:
MOVSX EAX,byte ptr [RSI]
LEA EDI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,EDI
MOV R8D,EDI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB EDI,EAX
LEA RAX,[RCX + 0x1]
ADD EDI,0x61
MOV byte ptr [RSI],DIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x2]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x3]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x4]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x5]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x6]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x7]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x8]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0x9]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0xa]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0xb]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0xc]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
LEA RAX,[RCX + 0xd]
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RAX,RDX
JNC 0x0010294c
LEA RDI,[RBP + RAX*0x1]
ADD RCX,0xe
MOVSX EAX,byte ptr [RDI]
LEA ESI,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,ESI
MOV R8D,ESI
IMUL RAX,RAX,0x4ec4ec4f
SAR R8D,0x1f
SAR RAX,0x23
SUB EAX,R8D
IMUL EAX,EAX,0x1a
SUB ESI,EAX
ADD ESI,0x61
MOV byte ptr [RDI],SIL
CMP RCX,RDX
JNC 0x0010294c
ADD RBP,RCX
MOVSX EAX,byte ptr [RBP]
LEA EDX,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,EDX
MOV ECX,EDX
IMUL RAX,RAX,0x4ec4ec4f
SAR ECX,0x1f
SAR RAX,0x23
SUB EAX,ECX
IMUL EAX,EAX,0x1a
SUB EDX,EAX
ADD EDX,0x61
MOV byte ptr [RBP],DL
LAB_0010294c:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00102953:
XOR ECX,ECX
MOV RSI,RBP
JMP 0x001025e6
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int (*param_1) [16],int param_2)
{
ushort uVar1;
ushort uVar2;
ushort uVar3;
ushort uVar4;
ushort uVar5;
ushort uVar6;
ushort uVar7;
ushort uVar8;
int auVar9 [14];
int auVar10 [12];
unkbyte10 Var11;
int auVar12 [12];
int auVar13 [12];
int auVar14 [16];
int auVar15 [16];
int auVar16 [16];
int auVar17 [16];
uint uVar18;
uint uVar19;
uint uVar20;
int auVar21 [16];
char cVar22;
char cVar23;
char cVar24;
char cVar25;
char cVar26;
char cVar27;
char cVar28;
char cVar29;
char cVar30;
char cVar31;
char cVar32;
char cVar33;
char cVar34;
char cVar35;
char cVar36;
char cVar37;
size_t sVar38;
int (*pauVar39) [16];
int (*pauVar40) [16];
ulong uVar41;
uint uVar42;
uint uVar43;
int iVar44;
uint uVar58;
int iVar59;
ulong uVar60;
int auVar46 [16];
int auVar50 [16];
int auVar54 [16];
int auVar57 [16];
short sVar61;
int iVar62;
short sVar86;
short sVar88;
uint6 uVar63;
int2 uVar87;
int2 uVar89;
int iVar91;
int2 uVar94;
short sVar97;
uint uVar95;
int iVar96;
int auVar65 [12];
short sVar92;
uint uVar90;
short sVar93;
short sVar98;
int auVar66 [16];
short sVar100;
uint uVar99;
int auVar74 [16];
int auVar78 [16];
int auVar82 [16];
int auVar85 [16];
short sVar101;
int4 uVar102;
int iVar103;
short sVar112;
short sVar113;
uint6 uVar105;
short sVar115;
uint uVar114;
short sVar116;
short sVar117;
short sVar118;
short sVar119;
short sVar120;
uint uVar121;
short sVar123;
int iVar124;
ulong uVar125;
int auVar122 [16];
int auVar126 [16];
short sVar127;
short sVar128;
short sVar129;
short sVar130;
short sVar131;
short sVar132;
short sVar133;
short sVar134;
short sVar135;
short sVar137;
int auVar136 [16];
int auVar138 [16];
int auVar139 [16];
ulong uVar140;
int auVar45 [12];
int auVar47 [16];
int auVar51 [16];
int auVar48 [16];
int auVar52 [16];
int auVar55 [16];
int auVar49 [16];
int auVar53 [16];
int auVar56 [16];
int auVar64 [12];
int auVar75 [16];
int auVar79 [16];
int auVar67 [16];
int auVar68 [16];
int auVar76 [16];
int auVar80 [16];
int auVar83 [16];
int auVar69 [16];
int auVar70 [16];
int auVar73 [16];
int auVar77 [16];
int auVar81 [16];
int auVar84 [16];
int auVar71 [16];
int auVar72 [16];
int6 uVar104;
int8 uVar106;
int auVar108 [12];
int auVar107 [12];
int auVar109 [14];
int auVar111 [16];
int auVar110 [16];
uVar42 = -(uint)(param_2 == 0) & 0x10;
sVar38 = strlen((char *)param_1);
cVar37 = UNK_0010308f;
cVar36 = UNK_0010308e;
cVar35 = UNK_0010308d;
cVar34 = UNK_0010308c;
cVar33 = UNK_0010308b;
cVar32 = UNK_0010308a;
cVar31 = UNK_00103089;
cVar30 = UNK_00103088;
cVar29 = UNK_00103087;
cVar28 = UNK_00103086;
cVar27 = UNK_00103085;
cVar26 = UNK_00103084;
cVar25 = UNK_00103083;
cVar24 = UNK_00103082;
cVar23 = UNK_00103081;
cVar22 = DAT_00103080;
auVar21 = _DAT_00103070;
uVar20 = _UNK_00103068;
uVar19 = _DAT_00103060;
if (sVar38 != 0) {
if (sVar38 - 1 < 0xf) {
uVar41 = 0;
pauVar39 = param_1;
}
else {
sVar134 = (short)(uVar42 + 5);
uVar41 = sVar38 & 0xfffffffffffffff0;
auVar126._0_4_ = -(uint)((int)_DAT_00103060 < 0);
auVar126._4_4_ = -(uint)(_UNK_00103064 < 0);
auVar126._8_4_ = -(uint)((int)_UNK_00103068 < 0);
auVar126._12_4_ = -(uint)(_UNK_0010306c < 0);
sVar127 = sVar134 + _DAT_00103050;
sVar128 = sVar134 + _UNK_00103052;
sVar129 = sVar134 + _UNK_00103054;
sVar130 = sVar134 + _UNK_00103056;
sVar131 = sVar134 + _UNK_00103058;
sVar132 = sVar134 + _UNK_0010305a;
sVar133 = sVar134 + _UNK_0010305c;
sVar134 = sVar134 + _UNK_0010305e;
pauVar39 = param_1;
do {
auVar46 = *pauVar39;
pauVar40 = pauVar39 + 1;
auVar72._0_14_ = auVar46._0_14_;
auVar72[0xe] = auVar46[7];
auVar72[0xf] = -(auVar46[7] < '\0');
auVar71._14_2_ = auVar72._14_2_;
auVar71._0_13_ = auVar46._0_13_;
auVar71[0xd] = -(auVar46[6] < '\0');
auVar70._13_3_ = auVar71._13_3_;
auVar70._0_12_ = auVar46._0_12_;
auVar70[0xc] = auVar46[6];
auVar69._12_4_ = auVar70._12_4_;
auVar69._0_11_ = auVar46._0_11_;
auVar69[0xb] = -(auVar46[5] < '\0');
auVar68._11_5_ = auVar69._11_5_;
auVar68._0_10_ = auVar46._0_10_;
auVar68[10] = auVar46[5];
auVar67._10_6_ = auVar68._10_6_;
auVar67._0_9_ = auVar46._0_9_;
auVar67[9] = -(auVar46[4] < '\0');
auVar66._9_7_ = auVar67._9_7_;
auVar66._0_8_ = auVar46._0_8_;
auVar66[8] = auVar46[4];
Var11 = CONCAT91(CONCAT81(auVar66._8_8_,-(auVar46[3] < '\0')),auVar46[3]);
auVar10._2_10_ = Var11;
auVar10[1] = -(auVar46[2] < '\0');
auVar10[0] = auVar46[2];
auVar9._2_12_ = auVar10;
auVar9[1] = -(auVar46[1] < '\0');
auVar9[0] = auVar46[1];
sVar101 = CONCAT11(-(auVar46[8] < '\0'),auVar46[8]);
uVar102 = CONCAT13(-(auVar46[9] < '\0'),CONCAT12(auVar46[9],sVar101));
uVar104 = CONCAT15(-(auVar46[10] < '\0'),CONCAT14(auVar46[10],uVar102));
uVar106 = CONCAT17(-(auVar46[0xb] < '\0'),CONCAT16(auVar46[0xb],uVar104));
auVar107._0_10_ = CONCAT19(-(auVar46[0xc] < '\0'),CONCAT18(auVar46[0xc],uVar106));
auVar107[10] = auVar46[0xd];
auVar107[0xb] = -(auVar46[0xd] < '\0');
auVar109[0xc] = auVar46[0xe];
auVar109._0_12_ = auVar107;
auVar109[0xd] = -(auVar46[0xe] < '\0');
auVar110[0xe] = auVar46[0xf];
auVar110._0_14_ = auVar109;
auVar110[0xf] = -(auVar46[0xf] < '\0');
sVar61 = CONCAT11(-(auVar46[0] < '\0'),auVar46[0]) + sVar127;
sVar86 = auVar9._0_2_ + sVar128;
sVar88 = auVar10._0_2_ + sVar129;
sVar92 = (short)Var11 + sVar130;
sVar93 = auVar66._8_2_ + sVar131;
sVar97 = auVar68._10_2_ + sVar132;
sVar98 = auVar70._12_2_ + sVar133;
sVar100 = auVar71._14_2_ + sVar134;
sVar101 = sVar101 + sVar127;
sVar112 = (short)((uint)uVar102 >> 0x10) + sVar128;
sVar113 = (short)((uint6)uVar104 >> 0x20) + sVar129;
sVar115 = (short)((ulong)uVar106 >> 0x30) + sVar130;
sVar116 = (short)((unkuint10)auVar107._0_10_ >> 0x40) + sVar131;
sVar117 = auVar107._10_2_ + sVar132;
sVar118 = auVar109._12_2_ + sVar133;
sVar119 = auVar110._14_2_ + sVar134;
uVar1 = (ushort)(sVar61 < 0);
sVar120 = -uVar1;
uVar3 = (ushort)(sVar92 < 0);
uVar5 = (ushort)(sVar93 < 0);
sVar123 = -uVar5;
uVar7 = (ushort)(sVar97 < 0);
uVar2 = (ushort)(sVar101 < 0);
sVar135 = -uVar2;
uVar4 = (ushort)(sVar115 < 0);
uVar6 = (ushort)(sVar116 < 0);
sVar137 = -uVar6;
uVar8 = (ushort)(sVar117 < 0);
uVar114 = CONCAT22(-uVar3,sVar92);
Var11 = CONCAT64(CONCAT42(uVar114,-(ushort)(sVar88 < 0)),CONCAT22(sVar88,sVar92));
uVar60 = (ulong)((unkuint10)Var11 >> 0x10);
auVar12._4_8_ = uVar60;
auVar12._2_2_ = -(ushort)(sVar86 < 0);
auVar12._0_2_ = sVar86;
uVar43 = CONCAT22(sVar120,sVar61);
iVar62 = CONCAT22(sVar123,sVar93);
uVar63 = CONCAT24(sVar97,iVar62);
auVar64._0_8_ = CONCAT26(-uVar7,uVar63);
auVar64._8_2_ = sVar98;
auVar64._10_2_ = -(ushort)(sVar98 < 0);
auVar73._12_2_ = sVar100;
auVar73._0_12_ = auVar64;
auVar73._14_2_ = -(ushort)(sVar100 < 0);
auVar138._0_4_ = -(uint)(uVar1 != 0);
uVar58 = auVar12._0_4_;
auVar138._4_4_ = -(uint)((int)uVar58 < 0);
iVar91 = (int)((unkuint10)Var11 >> 0x10);
auVar138._8_4_ = -(uint)(iVar91 < 0);
auVar138._12_4_ = -(uint)(uVar3 != 0);
uVar140 = auVar126._8_8_;
uVar18 = CONCAT22(-uVar4,sVar115);
Var11 = CONCAT64(CONCAT42(uVar18,-(ushort)(sVar113 < 0)),CONCAT22(sVar113,sVar115));
uVar125 = (ulong)((unkuint10)Var11 >> 0x10);
auVar13._4_8_ = uVar125;
auVar13._2_2_ = -(ushort)(sVar112 < 0);
auVar13._0_2_ = sVar112;
uVar121 = CONCAT22(sVar135,sVar101);
iVar103 = CONCAT22(sVar137,sVar116);
uVar105 = CONCAT24(sVar117,iVar103);
auVar108._0_8_ = CONCAT26(-uVar8,uVar105);
auVar108._8_2_ = sVar118;
auVar108._10_2_ = -(ushort)(sVar118 < 0);
auVar111._12_2_ = sVar119;
auVar111._0_12_ = auVar108;
auVar111._14_2_ = -(ushort)(sVar119 < 0);
uVar95 = auVar64._8_4_;
auVar139._0_4_ = -(uint)(uVar5 != 0);
uVar90 = (uint)((ulong)auVar64._0_8_ >> 0x20);
auVar139._4_4_ = -(uint)(uVar7 != 0);
auVar139._8_4_ = -(uint)((int)uVar95 < 0);
uVar99 = auVar73._12_4_;
auVar139._12_4_ = -(uint)((int)uVar99 < 0);
iVar44 = uVar43 + ((int)((long)((ulong)uVar43 * (ulong)uVar19 +
((ulong)auVar138._0_4_ * (ulong)uVar19 +
(ulong)auVar126._0_4_ * (ulong)uVar43 << 0x20)) >> 0x23) -
((int)sVar120 >> 0xf)) * -0x1a;
iVar59 = uVar58 + ((int)((long)((ulong)uVar58 * (ulong)uVar19 +
((ulong)-(uint)((int)uVar58 < 0) * (ulong)uVar19 +
(ulong)auVar126._0_4_ * (ulong)uVar58 << 0x20)) >> 0x23) -
((int)uVar58 >> 0x1f)) * -0x1a;
auVar45._0_8_ = CONCAT44(iVar59,iVar44);
auVar45._8_4_ =
iVar91 + ((int)((long)((uVar60 & 0xffffffff) * (ulong)uVar20 +
((auVar138._8_8_ & 0xffffffff) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (uVar60 & 0xffffffff) << 0x20)) >> 0x23
) - (iVar91 >> 0x1f)) * -0x1a;
iVar124 = (int)((unkuint10)Var11 >> 0x10);
iVar62 = iVar62 + ((int)((long)(((ulong)uVar63 & 0xffffffff) * (ulong)uVar19 +
((ulong)auVar139._0_4_ * (ulong)uVar19 +
(ulong)auVar126._0_4_ * ((ulong)uVar63 & 0xffffffff) << 0x20
)) >> 0x23) - ((int)sVar123 >> 0xf)) * -0x1a;
iVar91 = uVar90 + ((int)((long)((ulong)uVar90 * (ulong)uVar19 +
((ulong)-(uint)(uVar7 != 0) * (ulong)uVar19 +
(ulong)auVar126._0_4_ * (ulong)uVar90 << 0x20)) >> 0x23) -
((int)uVar90 >> 0x1f)) * -0x1a;
iVar96 = uVar95 + ((int)((long)((auVar73._8_8_ & 0xffffffff) * (ulong)uVar20 +
((auVar139._8_8_ & 0xffffffff) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (ulong)uVar95 << 0x20)) >> 0x23) -
((int)uVar95 >> 0x1f)) * -0x1a;
auVar49._12_2_ = (short)((uint)iVar59 >> 0x10);
auVar49._0_12_ = auVar45;
auVar49._14_2_ = (short)((uint)iVar91 >> 0x10);
auVar48._12_4_ = auVar49._12_4_;
auVar48._0_10_ = auVar45._0_10_;
uVar89 = (int2)iVar91;
auVar48._10_2_ = uVar89;
auVar47._10_6_ = auVar48._10_6_;
auVar47._8_2_ = (short)iVar59;
auVar47._0_8_ = auVar45._0_8_;
uVar87 = (int2)((uint)iVar62 >> 0x10);
auVar14._2_8_ = auVar47._8_8_;
auVar14._0_2_ = uVar87;
auVar14._10_6_ = 0;
auVar57._0_2_ = (int2)iVar44;
auVar46._12_4_ = 0;
auVar46._0_12_ = SUB1612(auVar14 << 0x30,4);
auVar46 = auVar46 << 0x20;
uVar94 = (int2)iVar96;
auVar53._0_12_ = auVar46._0_12_;
auVar53._12_2_ = uVar87;
auVar53._14_2_ = (short)((uint)iVar96 >> 0x10);
auVar52._12_4_ = auVar53._12_4_;
auVar52._0_10_ = auVar46._0_10_;
auVar52._10_2_ = (short)((uint)auVar45._8_4_ >> 0x10);
auVar51._10_6_ = auVar52._10_6_;
auVar51._0_8_ = auVar46._0_8_;
auVar51._8_2_ = (short)((uint)iVar44 >> 0x10);
auVar15._2_8_ = auVar51._8_8_;
auVar15._0_2_ = uVar94;
auVar15._10_6_ = 0;
auVar50._12_4_ = 0;
auVar50._0_12_ = SUB1612(auVar15 << 0x30,4);
auVar50 = auVar50 << 0x20;
auVar136._0_4_ = -(uint)(uVar2 != 0);
uVar90 = auVar13._0_4_;
auVar136._4_4_ = -(uint)((int)uVar90 < 0);
auVar136._8_4_ = -(uint)(iVar124 < 0);
auVar136._12_4_ = -(uint)(uVar4 != 0);
auVar56._0_12_ = auVar50._0_12_;
auVar56._12_2_ = uVar94;
auVar56._14_2_ =
(short)(uVar99 + ((int)((long)((auVar73._8_8_ >> 0x20) * (ulong)uVar20 +
((ulong)-(uint)((int)uVar99 < 0) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (ulong)uVar99 << 0x20)) >> 0x23
) - ((int)uVar99 >> 0x1f)) * -0x1a);
auVar55._12_4_ = auVar56._12_4_;
auVar55._0_10_ = auVar50._0_10_;
auVar55._10_2_ = uVar89;
auVar54._10_6_ = auVar55._10_6_;
auVar54._0_8_ = auVar50._0_8_;
auVar54._8_2_ = (short)iVar62;
auVar57._8_8_ = auVar54._8_8_;
auVar57._6_2_ =
(short)(uVar114 +
((int)((long)((uVar60 >> 0x20) * (ulong)uVar20 +
((ulong)-(uint)(uVar3 != 0) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (ulong)uVar114 << 0x20)) >> 0x23) -
((int)(short)-uVar3 >> 0xf)) * -0x1a);
auVar57._4_2_ = (short)auVar45._8_4_;
auVar57._2_2_ = (short)iVar59;
auVar57 = auVar57 & auVar21;
uVar43 = auVar108._8_4_;
auVar122._0_4_ = -(uint)(uVar6 != 0);
uVar114 = (uint)((ulong)auVar108._0_8_ >> 0x20);
auVar122._4_4_ = -(uint)(uVar8 != 0);
auVar122._8_4_ = -(uint)((int)uVar43 < 0);
uVar58 = auVar111._12_4_;
auVar122._12_4_ = -(uint)((int)uVar58 < 0);
iVar44 = uVar121 + ((int)((long)((ulong)uVar121 * (ulong)uVar19 +
((ulong)auVar136._0_4_ * (ulong)uVar19 +
(ulong)auVar126._0_4_ * (ulong)uVar121 << 0x20)) >> 0x23) -
((int)sVar135 >> 0xf)) * -0x1a;
iVar59 = uVar90 + ((int)((long)((ulong)uVar90 * (ulong)uVar19 +
((ulong)-(uint)((int)uVar90 < 0) * (ulong)uVar19 +
(ulong)auVar126._0_4_ * (ulong)uVar90 << 0x20)) >> 0x23) -
((int)uVar90 >> 0x1f)) * -0x1a;
auVar65._0_8_ = CONCAT44(iVar59,iVar44);
auVar65._8_4_ =
iVar124 + ((int)((long)((uVar125 & 0xffffffff) * (ulong)uVar20 +
((auVar136._8_8_ & 0xffffffff) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (uVar125 & 0xffffffff) << 0x20)) >>
0x23) - (iVar124 >> 0x1f)) * -0x1a;
iVar103 = iVar103 + ((int)((long)(((ulong)uVar105 & 0xffffffff) * (ulong)uVar19 +
((ulong)auVar122._0_4_ * (ulong)uVar19 +
(ulong)auVar126._0_4_ * ((ulong)uVar105 & 0xffffffff) <<
0x20)) >> 0x23) - ((int)sVar137 >> 0xf)) * -0x1a;
iVar91 = uVar114 + ((int)((long)((ulong)uVar114 * (ulong)uVar19 +
((ulong)-(uint)(uVar8 != 0) * (ulong)uVar19 +
(ulong)auVar126._0_4_ * (ulong)uVar114 << 0x20)) >> 0x23) -
((int)uVar114 >> 0x1f)) * -0x1a;
iVar62 = uVar43 + ((int)((long)((auVar111._8_8_ & 0xffffffff) * (ulong)uVar20 +
((auVar122._8_8_ & 0xffffffff) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (ulong)uVar43 << 0x20)) >> 0x23) -
((int)uVar43 >> 0x1f)) * -0x1a;
auVar77._12_2_ = (short)((uint)iVar59 >> 0x10);
auVar77._0_12_ = auVar65;
auVar77._14_2_ = (short)((uint)iVar91 >> 0x10);
auVar76._12_4_ = auVar77._12_4_;
auVar76._0_10_ = auVar65._0_10_;
uVar89 = (int2)iVar91;
auVar76._10_2_ = uVar89;
auVar75._10_6_ = auVar76._10_6_;
auVar75._8_2_ = (short)iVar59;
auVar75._0_8_ = auVar65._0_8_;
uVar87 = (int2)((uint)iVar103 >> 0x10);
auVar16._2_8_ = auVar75._8_8_;
auVar16._0_2_ = uVar87;
auVar16._10_6_ = 0;
auVar85._0_2_ = (int2)iVar44;
auVar74._12_4_ = 0;
auVar74._0_12_ = SUB1612(auVar16 << 0x30,4);
auVar74 = auVar74 << 0x20;
uVar94 = (int2)iVar62;
auVar81._0_12_ = auVar74._0_12_;
auVar81._12_2_ = uVar87;
auVar81._14_2_ = (short)((uint)iVar62 >> 0x10);
auVar80._12_4_ = auVar81._12_4_;
auVar80._0_10_ = auVar74._0_10_;
auVar80._10_2_ = (short)((uint)auVar65._8_4_ >> 0x10);
auVar79._10_6_ = auVar80._10_6_;
auVar79._0_8_ = auVar74._0_8_;
auVar79._8_2_ = (short)((uint)iVar44 >> 0x10);
auVar17._2_8_ = auVar79._8_8_;
auVar17._0_2_ = uVar94;
auVar17._10_6_ = 0;
auVar78._12_4_ = 0;
auVar78._0_12_ = SUB1612(auVar17 << 0x30,4);
auVar78 = auVar78 << 0x20;
auVar84._0_12_ = auVar78._0_12_;
auVar84._12_2_ = uVar94;
auVar84._14_2_ =
(short)(uVar58 + ((int)((long)((auVar111._8_8_ >> 0x20) * (ulong)uVar20 +
((ulong)-(uint)((int)uVar58 < 0) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (ulong)uVar58 << 0x20)) >> 0x23
) - ((int)uVar58 >> 0x1f)) * -0x1a);
auVar83._12_4_ = auVar84._12_4_;
auVar83._0_10_ = auVar78._0_10_;
auVar83._10_2_ = uVar89;
auVar82._10_6_ = auVar83._10_6_;
auVar82._0_8_ = auVar78._0_8_;
auVar82._8_2_ = (short)iVar103;
auVar85._8_8_ = auVar82._8_8_;
auVar85._6_2_ =
(short)(uVar18 + ((int)((long)((uVar125 >> 0x20) * (ulong)uVar20 +
((ulong)-(uint)(uVar4 != 0) * (ulong)uVar20 +
(uVar140 & 0xffffffff) * (ulong)uVar18 << 0x20)) >> 0x23
) - ((int)(short)-uVar4 >> 0xf)) * -0x1a);
auVar85._4_2_ = (short)auVar65._8_4_;
auVar85._2_2_ = (short)iVar59;
auVar85 = auVar85 & auVar21;
sVar61 = auVar57._0_2_;
sVar86 = auVar57._2_2_;
sVar88 = auVar57._4_2_;
sVar92 = auVar57._6_2_;
sVar93 = auVar57._8_2_;
sVar97 = auVar57._10_2_;
sVar98 = auVar57._12_2_;
sVar100 = auVar57._14_2_;
sVar101 = auVar85._0_2_;
sVar112 = auVar85._2_2_;
sVar113 = auVar85._4_2_;
sVar115 = auVar85._6_2_;
sVar116 = auVar85._8_2_;
sVar117 = auVar85._10_2_;
sVar118 = auVar85._12_2_;
sVar119 = auVar85._14_2_;
(*pauVar39)[0] = ((0 < sVar61) * (sVar61 < 0x100) * auVar57[0] - (0xff < sVar61)) + cVar22;
(*pauVar39)[1] = ((0 < sVar86) * (sVar86 < 0x100) * auVar57[2] - (0xff < sVar86)) + cVar23;
(*pauVar39)[2] = ((0 < sVar88) * (sVar88 < 0x100) * auVar57[4] - (0xff < sVar88)) + cVar24;
(*pauVar39)[3] = ((0 < sVar92) * (sVar92 < 0x100) * auVar57[6] - (0xff < sVar92)) + cVar25;
(*pauVar39)[4] = ((0 < sVar93) * (sVar93 < 0x100) * auVar57[8] - (0xff < sVar93)) + cVar26;
(*pauVar39)[5] = ((0 < sVar97) * (sVar97 < 0x100) * auVar57[10] - (0xff < sVar97)) + cVar27;
(*pauVar39)[6] = ((0 < sVar98) * (sVar98 < 0x100) * auVar57[0xc] - (0xff < sVar98)) + cVar28
;
(*pauVar39)[7] =
((0 < sVar100) * (sVar100 < 0x100) * auVar57[0xe] - (0xff < sVar100)) + cVar29;
(*pauVar39)[8] =
((0 < sVar101) * (sVar101 < 0x100) * auVar85[0] - (0xff < sVar101)) + cVar30;
(*pauVar39)[9] =
((0 < sVar112) * (sVar112 < 0x100) * auVar85[2] - (0xff < sVar112)) + cVar31;
(*pauVar39)[10] =
((0 < sVar113) * (sVar113 < 0x100) * auVar85[4] - (0xff < sVar113)) + cVar32;
(*pauVar39)[0xb] =
((0 < sVar115) * (sVar115 < 0x100) * auVar85[6] - (0xff < sVar115)) + cVar33;
(*pauVar39)[0xc] =
((0 < sVar116) * (sVar116 < 0x100) * auVar85[8] - (0xff < sVar116)) + cVar34;
(*pauVar39)[0xd] =
((0 < sVar117) * (sVar117 < 0x100) * auVar85[10] - (0xff < sVar117)) + cVar35;
(*pauVar39)[0xe] =
((0 < sVar118) * (sVar118 < 0x100) * auVar85[0xc] - (0xff < sVar118)) + cVar36;
(*pauVar39)[0xf] =
((0 < sVar119) * (sVar119 < 0x100) * auVar85[0xe] - (0xff < sVar119)) + cVar37;
pauVar39 = pauVar40;
} while ((int (*) [16])(*param_1 + uVar41) != pauVar40);
pauVar39 = (int (*) [16])(*param_1 + uVar41);
if (sVar38 == uVar41) {
return;
}
}
iVar44 = (uVar42 - 0x5c) + (int)(char)(*pauVar39)[0];
(*pauVar39)[0] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 1 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 1];
(*param_1)[uVar41 + 1] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 2 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 2];
(*param_1)[uVar41 + 2] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 3 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 3];
(*param_1)[uVar41 + 3] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 4 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 4];
(*param_1)[uVar41 + 4] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 5 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 5];
(*param_1)[uVar41 + 5] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 6 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 6];
(*param_1)[uVar41 + 6] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 7 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 7];
(*param_1)[uVar41 + 7] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 8 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 8];
(*param_1)[uVar41 + 8] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 9 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 9];
(*param_1)[uVar41 + 9] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 10 < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 10];
(*param_1)[uVar41 + 10] = (char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a'
;
if (uVar41 + 0xb < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 0xb];
(*param_1)[uVar41 + 0xb] =
(char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 0xc < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 0xc];
(*param_1)[uVar41 + 0xc] =
(char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 0xd < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 0xd];
(*param_1)[uVar41 + 0xd] =
(char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
if (uVar41 + 0xe < sVar38) {
iVar44 = (uVar42 - 0x5c) + (int)(char)(*param_1)[uVar41 + 0xe];
(*param_1)[uVar41 + 0xe] =
(char)iVar44 + (char)(iVar44 / 0x1a) * -0x1a + 'a';
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return;
}
|
860 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
assert(strcmp(test3, "fdcb") == 0);
char test4[] = "eeeee";
func0(test4);
assert(strcmp(test4, "") == 0);
char test5[] = "acBAA";
func0(test5);
assert(strcmp(test5, "cB") == 0);
char test6[] = "EcBOO";
func0(test6);
assert(strcmp(test6, "cB") == 0);
char test7[] = "ybcd";
func0(test7);
assert(strcmp(test7, "ybcd") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
lea 0xe48(%rip),%rax
mov %rax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,-0x10(%rbp)
jmp 1205 <func0+0x5c>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x8(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
jne 1200 <func0+0x57>
mov -0x10(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x10(%rbp)
mov -0x18(%rbp),%rdx
movzbl (%rdx),%edx
mov %dl,(%rax)
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 11ce <func0+0x25>
mov -0x10(%rbp),%rax
movb $0x0,(%rax)
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
lea rax, aAeiouaeiou; "AEIOUaeiou"
mov [rbp+s], rax
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
jmp short loc_1205
loc_11CE:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+s]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jnz short loc_1200
mov rax, [rbp+var_10]
lea rdx, [rax+1]
mov [rbp+var_10], rdx
mov rdx, [rbp+var_18]
movzx edx, byte ptr [rdx]
mov [rax], dl
loc_1200:
add [rbp+var_18], 1
loc_1205:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_11CE
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
nop
leave
retn
|
_BYTE * func0(_BYTE *a1)
{
_BYTE *v1; // rax
_BYTE *result; // rax
_BYTE *v3; // [rsp+8h] [rbp-18h]
_BYTE *v4; // [rsp+10h] [rbp-10h]
v3 = a1;
v4 = a1;
while ( *v3 )
{
if ( !strchr("AEIOUaeiou", (char)*v3) )
{
v1 = v4++;
*v1 = *v3;
}
++v3;
}
result = v4;
*v4 = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00101205
LAB_001011ce:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101090
TEST RAX,RAX
JNZ 0x00101200
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x10],RDX
MOV RDX,qword ptr [RBP + -0x18]
MOVZX EDX,byte ptr [RDX]
MOV byte ptr [RAX],DL
LAB_00101200:
ADD qword ptr [RBP + -0x18],0x1
LAB_00101205:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011ce
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
NOP
LEAVE
RET
|
void func0(char *param_1)
{
char *pcVar1;
char *local_20;
char *local_18;
local_18 = param_1;
for (local_20 = param_1; *local_20 != '\0'; local_20 = local_20 + 1) {
pcVar1 = strchr("AEIOUaeiou",(int)*local_20);
if (pcVar1 == (char *)0x0) {
*local_18 = *local_20;
local_18 = local_18 + 1;
}
}
*local_18 = '\0';
return;
}
|
861 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
assert(strcmp(test3, "fdcb") == 0);
char test4[] = "eeeee";
func0(test4);
assert(strcmp(test4, "") == 0);
char test5[] = "acBAA";
func0(test5);
assert(strcmp(test5, "cB") == 0);
char test6[] = "EcBOO";
func0(test6);
assert(strcmp(test6, "cB") == 0);
char test7[] = "ybcd";
func0(test7);
assert(strcmp(test7, "ybcd") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
movzbl (%rdi),%ebp
test %bpl,%bpl
je 11d6 <func0+0x4d>
mov %rdi,%r12
lea 0xe58(%rip),%r13
jmp 11c3 <func0+0x3a>
mov %bpl,(%r12)
lea 0x1(%r12),%r12
add $0x1,%rbx
movzbl (%rbx),%ebp
test %bpl,%bpl
je 11d9 <func0+0x50>
movsbl %bpl,%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
jne 11b7 <func0+0x2e>
jmp 11ae <func0+0x25>
mov %rdi,%r12
movb $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
movzx ebp, byte ptr [rdi]
test bpl, bpl
jz short loc_11F6
mov r12, rdi
lea r13, s; "AEIOUaeiou"
jmp short loc_11DA
loc_11CE:
add rbx, 1
movzx ebp, byte ptr [rbx]
test bpl, bpl
jz short loc_11F9
loc_11DA:
movsx esi, bpl; c
mov rdi, r13; s
call _strchr
test rax, rax
jnz short loc_11CE
mov [r12], bpl
lea r12, [r12+1]
jmp short loc_11CE
loc_11F6:
mov r12, rdi
loc_11F9:
mov byte ptr [r12], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
void func0(_BYTE *a1)
{
_BYTE *v1; // rbx
char v2; // bp
_BYTE *v3; // r12
v1 = a1;
v2 = *a1;
if ( *a1 )
{
v3 = a1;
do
{
if ( !strchr("AEIOUaeiou", v2) )
*v3++ = v2;
v2 = *++v1;
}
while ( *v1 );
}
else
{
v3 = a1;
}
*v3 = 0;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOVZX EBP,byte ptr [RDI]
TEST BPL,BPL
JZ 0x001011f6
MOV R12,RDI
LEA R13,[0x102004]
JMP 0x001011da
LAB_001011ce:
ADD RBX,0x1
MOVZX EBP,byte ptr [RBX]
TEST BPL,BPL
JZ 0x001011f9
LAB_001011da:
MOVSX ESI,BPL
MOV RDI,R13
CALL 0x00101090
TEST RAX,RAX
JNZ 0x001011ce
MOV byte ptr [R12],BPL
LEA R12,[R12 + 0x1]
JMP 0x001011ce
LAB_001011f6:
MOV R12,RDI
LAB_001011f9:
MOV byte ptr [R12],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
void func0(char *param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
cVar1 = *param_1;
pcVar3 = param_1;
while (cVar1 != '\0') {
pcVar2 = strchr("AEIOUaeiou",(int)cVar1);
if (pcVar2 == (char *)0x0) {
*pcVar3 = cVar1;
pcVar3 = pcVar3 + 1;
}
param_1 = param_1 + 1;
cVar1 = *param_1;
}
*pcVar3 = '\0';
return;
}
|
862 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
assert(strcmp(test3, "fdcb") == 0);
char test4[] = "eeeee";
func0(test4);
assert(strcmp(test4, "") == 0);
char test5[] = "acBAA";
func0(test5);
assert(strcmp(test5, "cB") == 0);
char test6[] = "EcBOO";
func0(test6);
assert(strcmp(test6, "cB") == 0);
char test7[] = "ybcd";
func0(test7);
assert(strcmp(test7, "ybcd") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1468 <func0+0x58>
mov %rdi,%rbp
lea 0xbd2(%rip),%r13
jmp 1444 <func0+0x34>
nopl 0x0(%rax)
movzbl 0x1(%rbp),%ebx
add $0x1,%rbp
test %bl,%bl
je 1468 <func0+0x58>
movsbl %bl,%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
jne 1438 <func0+0x28>
add $0x1,%rbp
mov %bl,(%r12)
add $0x1,%r12
movzbl 0x0(%rbp),%ebx
test %bl,%bl
jne 1444 <func0+0x34>
movb $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1468
mov rbp, rdi
lea r13, s; "AEIOUaeiou"
jmp short loc_1444
loc_1438:
movzx ebx, byte ptr [rbp+1]
add rbp, 1
test bl, bl
jz short loc_1468
loc_1444:
movsx esi, bl; c
mov rdi, r13; s
call _strchr
test rax, rax
jnz short loc_1438
add rbp, 1
mov [r12], bl
add r12, 1
movzx ebx, byte ptr [rbp+0]
test bl, bl
jnz short loc_1444
loc_1468:
mov byte ptr [r12], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
void func0(_BYTE *a1)
{
_BYTE *v1; // r12
char v2; // bl
char *v3; // rbp
v1 = a1;
v2 = *a1;
if ( *a1 )
{
v3 = a1;
do
{
while ( strchr("AEIOUaeiou", v2) )
{
v2 = *++v3;
if ( !v2 )
goto LABEL_6;
}
++v3;
*v1++ = v2;
v2 = *v3;
}
while ( *v3 );
}
LABEL_6:
*v1 = 0;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101468
MOV RBP,RDI
LEA R13,[0x102004]
JMP 0x00101444
LAB_00101438:
MOVZX EBX,byte ptr [RBP + 0x1]
ADD RBP,0x1
TEST BL,BL
JZ 0x00101468
LAB_00101444:
MOVSX ESI,BL
MOV RDI,R13
CALL 0x00101090
TEST RAX,RAX
JNZ 0x00101438
ADD RBP,0x1
MOV byte ptr [R12],BL
ADD R12,0x1
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JNZ 0x00101444
LAB_00101468:
MOV byte ptr [R12],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
void func0(char *param_1)
{
char *pcVar1;
char cVar2;
char *pcVar3;
cVar2 = *param_1;
pcVar3 = param_1;
while (cVar2 != '\0') {
while (pcVar1 = strchr("AEIOUaeiou",(int)cVar2), pcVar1 == (char *)0x0) {
param_1 = param_1 + 1;
*pcVar3 = cVar2;
pcVar3 = pcVar3 + 1;
cVar2 = *param_1;
if (cVar2 == '\0') goto LAB_00101468;
}
pcVar1 = param_1 + 1;
param_1 = param_1 + 1;
cVar2 = *pcVar1;
}
LAB_00101468:
*pcVar3 = '\0';
return;
}
|
863 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
assert(strcmp(test3, "fdcb") == 0);
char test4[] = "eeeee";
func0(test4);
assert(strcmp(test4, "") == 0);
char test5[] = "acBAA";
func0(test5);
assert(strcmp(test5, "cB") == 0);
char test6[] = "EcBOO";
func0(test6);
assert(strcmp(test6, "cB") == 0);
char test7[] = "ybcd";
func0(test7);
assert(strcmp(test7, "ybcd") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
movzbl (%rdi),%ebp
test %bpl,%bpl
je 1456 <func0+0x46>
lea 0xbd1(%rip),%r13
nopl 0x0(%rax,%rax,1)
movsbl %bpl,%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 1470 <func0+0x60>
movzbl 0x1(%rbx),%ebp
add $0x1,%rbx
test %bpl,%bpl
jne 1438 <func0+0x28>
movb $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%rbx
mov %bpl,(%r12)
lea 0x1(%r12),%rax
movzbl (%rbx),%ebp
mov %rax,%r12
test %bpl,%bpl
jne 1438 <func0+0x28>
movb $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
movzx ebp, byte ptr [rdi]
test bpl, bpl
jz short loc_1456
lea r13, s; "AEIOUaeiou"
nop dword ptr [rax+rax+00h]
loc_1438:
movsx esi, bpl; c
mov rdi, r13; s
call _strchr
test rax, rax
jz short loc_1470
movzx ebp, byte ptr [rbx+1]
add rbx, 1
test bpl, bpl
jnz short loc_1438
loc_1456:
mov byte ptr [r12], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1470:
add rbx, 1
mov [r12], bpl
lea rax, [r12+1]
movzx ebp, byte ptr [rbx]
mov r12, rax
test bpl, bpl
jnz short loc_1438
mov byte ptr [r12], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
void func0(_BYTE *a1)
{
_BYTE *v1; // r12
char *v2; // rbx
char v3; // bp
v1 = a1;
v2 = a1;
v3 = *a1;
if ( *a1 )
{
do
{
while ( strchr("AEIOUaeiou", v3) )
{
v3 = *++v2;
if ( !v3 )
goto LABEL_4;
}
++v2;
*v1 = v3;
v3 = *v2;
++v1;
}
while ( *v2 );
*v1 = 0;
}
else
{
LABEL_4:
*v1 = 0;
}
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOVZX EBP,byte ptr [RDI]
TEST BPL,BPL
JZ 0x00101456
LEA R13,[0x102004]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101438:
MOVSX ESI,BPL
MOV RDI,R13
CALL 0x00101090
TEST RAX,RAX
JZ 0x00101470
MOVZX EBP,byte ptr [RBX + 0x1]
ADD RBX,0x1
TEST BPL,BPL
JNZ 0x00101438
LAB_00101456:
MOV byte ptr [R12],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101470:
ADD RBX,0x1
MOV byte ptr [R12],BPL
LEA RAX,[R12 + 0x1]
MOVZX EBP,byte ptr [RBX]
MOV R12,RAX
TEST BPL,BPL
JNZ 0x00101438
MOV byte ptr [R12],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
void func0(char *param_1)
{
char *pcVar1;
char cVar2;
char *pcVar3;
cVar2 = *param_1;
pcVar3 = param_1;
do {
if (cVar2 == '\0') {
*pcVar3 = '\0';
return;
}
while (pcVar1 = strchr("AEIOUaeiou",(int)cVar2), pcVar1 == (char *)0x0) {
param_1 = param_1 + 1;
*pcVar3 = cVar2;
pcVar3 = pcVar3 + 1;
cVar2 = *param_1;
if (cVar2 == '\0') {
*pcVar3 = '\0';
return;
}
}
cVar2 = param_1[1];
param_1 = param_1 + 1;
} while( true );
}
|
864 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
}
|
#include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
int list5[] = {1, 8, 4, 10};
assert(func0(list5, 4, 11));
int list6[] = {1, 8, 4, 10};
assert(!func0(list6, 4, 10));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11aa <func0+0x41>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jg 11a6 <func0+0x3d>
mov $0x0,%eax
jmp 11b7 <func0+0x4e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1184 <func0+0x1b>
mov $0x1,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_4], 0
jmp short loc_11AA
loc_1184:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jg short loc_11A6
mov eax, 0
jmp short loc_11B7
loc_11A6:
add [rbp+var_4], 1
loc_11AA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1184
mov eax, 1
loc_11B7:
pop rbp
retn
|
long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( a3 <= *(_DWORD *)(4LL * i + a1) )
return 0LL;
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011aa
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JG 0x001011a6
MOV EAX,0x0
JMP 0x001011b7
LAB_001011a6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101184
MOV EAX,0x1
LAB_001011b7:
POP RBP
RET
|
int8 func0(long param_1,int param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (param_3 <= *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
}
|
865 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
}
|
#include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
int list5[] = {1, 8, 4, 10};
assert(func0(list5, 4, 11));
int list6[] = {1, 8, 4, 10};
assert(!func0(list6, 4, 10));
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rcx
cmp %edx,(%rax)
jge 1195 <func0+0x2c>
add $0x4,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_118E
mov rax, rdi
movsxd rsi, esi
lea rcx, [rdi+rsi*4]
loc_117B:
cmp [rax], edx
jge short loc_1194
add rax, 4
cmp rax, rcx
jnz short loc_117B
mov eax, 1
retn
loc_118E:
mov eax, 1
retn
loc_1194:
mov eax, 0
retn
|
long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = a1;
while ( *v3 < a3 )
{
if ( ++v3 == &a1[a2] )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118e
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RCX,[RDI + RSI*0x4]
LAB_0010117b:
CMP dword ptr [RAX],EDX
JGE 0x00101194
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010117b
MOV EAX,0x1
RET
LAB_0010118e:
MOV EAX,0x1
RET
LAB_00101194:
MOV EAX,0x0
RET
|
int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (param_2 < 1) {
return 1;
}
piVar1 = param_1 + param_2;
do {
if (param_3 <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 1;
}
|
866 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
}
|
#include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
int list5[] = {1, 8, 4, 10};
assert(func0(list5, 4, 11));
int list6[] = {1, 8, 4, 10};
assert(!func0(list6, 4, 10));
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jl 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1370
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1361
loc_1358:
add rdi, 4
cmp rdi, rax
jz short loc_1370
loc_1361:
cmp [rdi], edx
jl short loc_1358
xor eax, eax
retn
loc_1370:
mov eax, 1
retn
|
long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = &a1[a2];
while ( *a1 < a3 )
{
if ( ++a1 == v3 )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101370
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101361
LAB_00101358:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101370
LAB_00101361:
CMP dword ptr [RDI],EDX
JL 0x00101358
XOR EAX,EAX
RET
LAB_00101370:
MOV EAX,0x1
RET
|
int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (param_3 <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
}
|
867 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
}
|
#include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
int list5[] = {1, 8, 4, 10};
assert(func0(list5, 4, 11));
int list6[] = {1, 8, 4, 10};
assert(!func0(list6, 4, 10));
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jl 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
cmp [rdi], edx
jl short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn
|
long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = &a1[a2];
while ( *a1 < a3 )
{
if ( ++a1 == v3 )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
CMP dword ptr [RDI],EDX
JL 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET
|
int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (param_3 <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
}
|
868 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
return x + y;
}
|
#include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
assert(func0(x, y) == x + y);
}
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
pop rbp
retn
|
long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
POP RBP
RET
|
int func0(int param_1,int param_2)
{
return param_2 + param_1;
}
|
869 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
return x + y;
}
|
#include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
assert(func0(x, y) == x + y);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
lea (%rdi,%rsi,1),%eax
retq
|
func0:
endbr64
lea eax, [rdi+rsi]
retn
|
long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
}
|
func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET
|
int func0(int param_1,int param_2)
{
return param_1 + param_2;
}
|
870 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
return x + y;
}
|
#include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
assert(func0(x, y) == x + y);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
lea (%rdi,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
lea eax, [rdi+rsi]
retn
|
long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
}
|
func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET
|
int func0(int param_1,int param_2)
{
return param_1 + param_2;
}
|
871 |
func0
|
#include <stdio.h>
|
int func0(int x, int y) {
return x + y;
}
|
#include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
assert(func0(x, y) == x + y);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
lea (%rdi,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
lea eax, [rdi+rsi]
retn
|
long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
}
|
func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET
|
int func0(int param_1,int param_2)
{
return param_1 + param_2;
}
|
872 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (!found) return false;
}
for (int i = 0; i < len1; i++) {
bool found = false;
for (int j = 0; j < len0; j++) {
if (s1[i] == s0[j]) {
found = true;
break;
}
}
if (!found) return false;
}
return true;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
assert(func0("eabcdzzzz", "dddzzzzzzzddddabc") == false);
assert(func0("aabb", "aaccc") == false);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x18(%rbp)
jmp 11fd <func0+0x94>
movb $0x0,-0x1a(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11df <func0+0x76>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x14(%rbp),%eax
movslq %eax,%rcx
mov -0x30(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 11db <func0+0x72>
movb $0x1,-0x1a(%rbp)
jmp 11e7 <func0+0x7e>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11b1 <func0+0x48>
movzbl -0x1a(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 11f9 <func0+0x90>
mov $0x0,%eax
jmp 1274 <func0+0x10b>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 11a4 <func0+0x3b>
movl $0x0,-0x10(%rbp)
jmp 1267 <func0+0xfe>
movb $0x0,-0x19(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1249 <func0+0xe0>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xc(%rbp),%eax
movslq %eax,%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 1245 <func0+0xdc>
movb $0x1,-0x19(%rbp)
jmp 1251 <func0+0xe8>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 121b <func0+0xb2>
movzbl -0x19(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 1263 <func0+0xfa>
mov $0x0,%eax
jmp 1274 <func0+0x10b>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 120e <func0+0xa5>
mov $0x1,%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+var_30]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_18], 0
jmp short loc_11FD
loc_11A4:
mov [rbp+var_1A], 0
mov [rbp+var_14], 0
jmp short loc_11DF
loc_11B1:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_14]
movsxd rcx, eax
mov rax, [rbp+var_30]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_11DB
mov [rbp+var_1A], 1
jmp short loc_11E7
loc_11DB:
add [rbp+var_14], 1
loc_11DF:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_4]
jl short loc_11B1
loc_11E7:
movzx eax, [rbp+var_1A]
xor eax, 1
test al, al
jz short loc_11F9
mov eax, 0
jmp short locret_1274
loc_11F9:
add [rbp+var_18], 1
loc_11FD:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_8]
jl short loc_11A4
mov [rbp+var_10], 0
jmp short loc_1267
loc_120E:
mov [rbp+var_19], 0
mov [rbp+var_C], 0
jmp short loc_1249
loc_121B:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_C]
movsxd rcx, eax
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_1245
mov [rbp+var_19], 1
jmp short loc_1251
loc_1245:
add [rbp+var_C], 1
loc_1249:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jl short loc_121B
loc_1251:
movzx eax, [rbp+var_19]
xor eax, 1
test al, al
jz short loc_1263
mov eax, 0
jmp short locret_1274
loc_1263:
add [rbp+var_10], 1
loc_1267:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_4]
jl short loc_120E
mov eax, 1
locret_1274:
leave
retn
|
long long func0(const char *a1, const char *a2)
{
char v3; // [rsp+16h] [rbp-1Ah]
char v4; // [rsp+17h] [rbp-19h]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int k; // [rsp+20h] [rbp-10h]
int m; // [rsp+24h] [rbp-Ch]
int v9; // [rsp+28h] [rbp-8h]
int v10; // [rsp+2Ch] [rbp-4h]
v9 = strlen(a1);
v10 = strlen(a2);
for ( i = 0; i < v9; ++i )
{
v3 = 0;
for ( j = 0; j < v10; ++j )
{
if ( a1[i] == a2[j] )
{
v3 = 1;
break;
}
}
if ( v3 != 1 )
return 0LL;
}
for ( k = 0; k < v10; ++k )
{
v4 = 0;
for ( m = 0; m < v9; ++m )
{
if ( a2[k] == a1[m] )
{
v4 = 1;
break;
}
}
if ( v4 != 1 )
return 0LL;
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001011fd
LAB_001011a4:
MOV byte ptr [RBP + -0x1a],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011df
LAB_001011b1:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001011db
MOV byte ptr [RBP + -0x1a],0x1
JMP 0x001011e7
LAB_001011db:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011df:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011b1
LAB_001011e7:
MOVZX EAX,byte ptr [RBP + -0x1a]
XOR EAX,0x1
TEST AL,AL
JZ 0x001011f9
MOV EAX,0x0
JMP 0x00101274
LAB_001011f9:
ADD dword ptr [RBP + -0x18],0x1
LAB_001011fd:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001011a4
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101267
LAB_0010120e:
MOV byte ptr [RBP + -0x19],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101249
LAB_0010121b:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x00101245
MOV byte ptr [RBP + -0x19],0x1
JMP 0x00101251
LAB_00101245:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101249:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x0010121b
LAB_00101251:
MOVZX EAX,byte ptr [RBP + -0x19]
XOR EAX,0x1
TEST AL,AL
JZ 0x00101263
MOV EAX,0x0
JMP 0x00101274
LAB_00101263:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101267:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x0010120e
MOV EAX,0x1
LAB_00101274:
LEAVE
RET
|
int8 func0(char *param_1,char *param_2)
{
bool bVar1;
size_t sVar2;
size_t sVar3;
int local_20;
int local_1c;
int local_18;
int local_14;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
for (local_20 = 0; local_20 < (int)sVar2; local_20 = local_20 + 1) {
bVar1 = false;
for (local_1c = 0; local_1c < (int)sVar3; local_1c = local_1c + 1) {
if (param_1[local_20] == param_2[local_1c]) {
bVar1 = true;
break;
}
}
if (!bVar1) {
return 0;
}
}
local_18 = 0;
do {
if ((int)sVar3 <= local_18) {
return 1;
}
bVar1 = false;
for (local_14 = 0; local_14 < (int)sVar2; local_14 = local_14 + 1) {
if (param_2[local_18] == param_1[local_14]) {
bVar1 = true;
break;
}
}
if (!bVar1) {
return 0;
}
local_18 = local_18 + 1;
} while( true );
}
|
873 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (!found) return false;
}
for (int i = 0; i < len1; i++) {
bool found = false;
for (int j = 0; j < len0; j++) {
if (s1[i] == s0[j]) {
found = true;
break;
}
}
if (!found) return false;
}
return true;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
assert(func0("eabcdzzzz", "dddzzzzzzzddddabc") == false);
assert(func0("aabb", "aaccc") == false);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbp
push %rbx
mov %rdi,%r8
mov $0xffffffffffffffff,%rdx
mov $0x0,%eax
mov %rdx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r11
mov %r11d,%r10d
mov %rdx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%r9
test %r11d,%r11d
jle 11a5 <func0+0x5c>
mov %r9d,%ebx
mov %r8,%rdi
lea -0x1(%r11),%eax
lea 0x1(%r8,%rax,1),%rbp
lea -0x1(%r9),%eax
lea 0x1(%rsi,%rax,1),%rcx
jmp 1205 <func0+0xbc>
mov $0x0,%eax
jmp 1221 <func0+0xd8>
mov $0x1,%eax
test %r9d,%r9d
jle 1221 <func0+0xd8>
mov %rsi,%rdi
lea -0x1(%r9),%eax
lea 0x1(%rsi,%rax,1),%rsi
lea -0x1(%r11),%eax
lea 0x1(%r8,%rax,1),%rcx
jmp 11d6 <func0+0x8d>
mov $0x0,%eax
jmp 1221 <func0+0xd8>
add $0x1,%rdi
cmp %rsi,%rdi
je 11f5 <func0+0xac>
test %r10d,%r10d
jle 11c6 <func0+0x7d>
movzbl (%rdi),%edx
mov %r8,%rax
cmp (%rax),%dl
je 11cd <func0+0x84>
add $0x1,%rax
cmp %rcx,%rax
jne 11e1 <func0+0x98>
mov $0x0,%eax
jmp 1221 <func0+0xd8>
mov $0x1,%eax
jmp 1221 <func0+0xd8>
add $0x1,%rdi
cmp %rbp,%rdi
je 11af <func0+0x66>
test %ebx,%ebx
jle 119e <func0+0x55>
movzbl (%rdi),%edx
mov %rsi,%rax
cmp (%rax),%dl
je 11fc <func0+0xb3>
add $0x1,%rax
cmp %rcx,%rax
jne 120f <func0+0xc6>
mov $0x0,%eax
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
call _strlen
mov r13, rax
mov r12d, eax
mov rdi, rbx; s
call _strlen
mov r10, rax
test r13d, r13d
jle short loc_11EA
mov r8d, eax
mov rdi, rbp
lea eax, [r13-1]
lea r9, [rbp+rax+1]
lea eax, [r10-1]
lea rsi, [rbx+rax+1]
jmp short loc_11BB
loc_11B2:
add rdi, 1
cmp rdi, r9
jz short loc_11F4
loc_11BB:
test r8d, r8d
jle short loc_11E3
movzx ecx, byte ptr [rdi]
mov rdx, rbx
loc_11C6:
cmp cl, [rdx]
jz short loc_11B2
add rdx, 1
cmp rdx, rsi
jnz short loc_11C6
mov eax, 0
loc_11D8:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11E3:
mov eax, 0
jmp short loc_11D8
loc_11EA:
mov eax, 1
test r10d, r10d
jle short loc_11D8
loc_11F4:
mov rsi, rbx
lea eax, [r10-1]
lea rdi, [rbx+rax+1]
lea eax, [r13-1]
lea rcx, [rbp+rax+1]
jmp short loc_1214
loc_120B:
add rsi, 1
cmp rsi, rdi
jz short loc_123A
loc_1214:
test r12d, r12d
jle short loc_1233
movzx edx, byte ptr [rsi]
mov rax, rbp
loc_121F:
cmp dl, [rax]
jz short loc_120B
add rax, 1
cmp rax, rcx
jnz short loc_121F
mov eax, 0
jmp short loc_11D8
loc_1233:
mov eax, 0
jmp short loc_11D8
loc_123A:
mov eax, 1
jmp short loc_11D8
|
long long func0(const char *a1, const char *a2)
{
const char *v2; // rbp
int v4; // r13d
int v5; // eax
int v6; // r10d
long long v7; // rsi
const char *v8; // rdx
long long result; // rax
const char *v10; // rsi
const char *v11; // rax
v2 = a1;
v4 = strlen(a1);
v5 = strlen(a2);
v6 = v5;
if ( v4 <= 0 )
{
result = 1LL;
if ( v6 > 0 )
{
LABEL_12:
v10 = a2;
while ( 2 )
{
if ( v4 <= 0 )
{
return 0LL;
}
else
{
v11 = v2;
while ( *v10 != *v11 )
{
if ( ++v11 == &v2[v4 - 1 + 1] )
return 0LL;
}
if ( ++v10 != &a2[v6 - 1 + 1] )
continue;
return 1LL;
}
}
}
}
else
{
v7 = (long long)&a2[v5 - 1 + 1];
while ( v5 > 0 )
{
v8 = a2;
while ( *a1 != *v8 )
{
if ( ++v8 == (const char *)v7 )
return 0LL;
}
if ( ++a1 == &v2[v4 - 1 + 1] )
goto LABEL_12;
}
return 0LL;
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
CALL 0x00101060
MOV R13,RAX
MOV R12D,EAX
MOV RDI,RBX
CALL 0x00101060
MOV R10,RAX
TEST R13D,R13D
JLE 0x001011ea
MOV R8D,EAX
MOV RDI,RBP
LEA EAX,[R13 + -0x1]
LEA R9,[RBP + RAX*0x1 + 0x1]
LEA EAX,[R10 + -0x1]
LEA RSI,[RBX + RAX*0x1 + 0x1]
JMP 0x001011bb
LAB_001011b2:
ADD RDI,0x1
CMP RDI,R9
JZ 0x001011f4
LAB_001011bb:
TEST R8D,R8D
JLE 0x001011e3
MOVZX ECX,byte ptr [RDI]
MOV RDX,RBX
LAB_001011c6:
CMP CL,byte ptr [RDX]
JZ 0x001011b2
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x001011c6
MOV EAX,0x0
LAB_001011d8:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011e3:
MOV EAX,0x0
JMP 0x001011d8
LAB_001011ea:
MOV EAX,0x1
TEST R10D,R10D
JLE 0x001011d8
LAB_001011f4:
MOV RSI,RBX
LEA EAX,[R10 + -0x1]
LEA RDI,[RBX + RAX*0x1 + 0x1]
LEA EAX,[R13 + -0x1]
LEA RCX,[RBP + RAX*0x1 + 0x1]
JMP 0x00101214
LAB_0010120b:
ADD RSI,0x1
CMP RSI,RDI
JZ 0x0010123a
LAB_00101214:
TEST R12D,R12D
JLE 0x00101233
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBP
LAB_0010121f:
CMP DL,byte ptr [RAX]
JZ 0x0010120b
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x0010121f
MOV EAX,0x0
JMP 0x001011d8
LAB_00101233:
MOV EAX,0x0
JMP 0x001011d8
LAB_0010123a:
MOV EAX,0x1
JMP 0x001011d8
|
int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
sVar2 = strlen(param_2);
iVar5 = (int)sVar2;
if (iVar1 < 1) {
if (iVar5 < 1) {
return 1;
}
}
else {
pcVar4 = param_1;
do {
if (iVar5 < 1) {
return 0;
}
pcVar3 = param_2;
while (*pcVar4 != *pcVar3) {
pcVar3 = pcVar3 + 1;
if (pcVar3 == param_2 + (ulong)(iVar5 - 1) + 1) {
return 0;
}
}
pcVar4 = pcVar4 + 1;
} while (pcVar4 != param_1 + (ulong)(iVar1 - 1) + 1);
}
pcVar4 = param_2 + (ulong)(iVar5 - 1) + 1;
do {
if (iVar1 < 1) {
return 0;
}
pcVar3 = param_1;
while (*param_2 != *pcVar3) {
pcVar3 = pcVar3 + 1;
if (pcVar3 == param_1 + (ulong)(iVar1 - 1) + 1) {
return 0;
}
}
param_2 = param_2 + 1;
} while (param_2 != pcVar4);
return 1;
}
|
874 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (!found) return false;
}
for (int i = 0; i < len1; i++) {
bool found = false;
for (int j = 0; j < len0; j++) {
if (s1[i] == s0[j]) {
found = true;
break;
}
}
if (!found) return false;
}
return true;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
assert(func0("eabcdzzzz", "dddzzzzzzzddddabc") == false);
assert(func0("aabb", "aaccc") == false);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
mov %rax,%r12
callq 1060 <strlen@plt>
test %r12d,%r12d
jle 13c7 <func0+0xb7>
lea -0x1(%r12),%r9d
mov %eax,%esi
lea 0x1(%rbp),%rdi
sub $0x1,%eax
mov %r9,%r12
mov %rbp,%r8
lea 0x1(%rbx,%rax,1),%rcx
add %rdi,%r9
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 13c0 <func0+0xb0>
movzbl (%r8),%edx
mov %rbx,%rax
jmp 1371 <func0+0x61>
nopl (%rax)
add $0x1,%rax
cmp %rcx,%rax
je 13c0 <func0+0xb0>
cmp (%rax),%dl
jne 1368 <func0+0x58>
add $0x1,%r8
cmp %r9,%r8
jne 1358 <func0+0x48>
xor %r8d,%r8d
lea (%rdi,%r12,1),%rcx
nopl (%rax)
movzbl (%rbx,%r8,1),%edx
mov %rbp,%rax
jmp 13a1 <func0+0x91>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rcx,%rax
je 13c0 <func0+0xb0>
cmp (%rax),%dl
jne 1398 <func0+0x88>
add $0x1,%r8
cmp %r8d,%esi
jg 1388 <func0+0x78>
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
retq
test %eax,%eax
setle %al
jmp 13c2 <func0+0xb2>
xchg %ax,%ax
|
func0:
endbr64
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
call _strlen
mov rdi, rbx; s
mov r12, rax
call _strlen
mov rdx, rax
test r12d, r12d
jle loc_13D7
lea eax, [r12-1]
mov rsi, rbp
lea rdi, [rbp+rax+1]
test edx, edx
jle loc_13D0
lea ecx, [rdx-1]
lea r8, [rbx+1]
mov r9, rcx
add rcx, r8
nop dword ptr [rax+00h]
loc_1360:
movzx edx, byte ptr [rsi]
mov rax, rbx
jmp short loc_1379
loc_1370:
add rax, 1
cmp rax, rcx
jz short loc_13D0
loc_1379:
cmp dl, [rax]
jnz short loc_1370
add rsi, 1
cmp rsi, rdi
jnz short loc_1360
loc_1386:
mov rsi, rbx
lea rdi, [r8+r9]
test r12d, r12d
jle short loc_13D0
lea eax, [r12-1]
lea rcx, [rbp+rax+1]
nop dword ptr [rax+00h]
loc_13A0:
movzx edx, byte ptr [rsi]
mov rax, rbp
jmp short loc_13B9
loc_13B0:
add rax, 1
cmp rax, rcx
jz short loc_13D0
loc_13B9:
cmp dl, [rax]
jnz short loc_13B0
add rsi, 1
cmp rsi, rdi
jnz short loc_13A0
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_13D0:
xor eax, eax
loc_13D2:
pop rbx
pop rbp
pop r12
retn
loc_13D7:
mov eax, 1
test edx, edx
jle short loc_13D2
lea r8, [rbx+1]
lea r9d, [rdx-1]
jmp short loc_1386
|
long long func0(const char *a1, const char *a2)
{
int v3; // r12d
int v4; // edx
const char *v5; // rsi
const char *v6; // r8
long long v7; // r9
const char *v8; // rax
const char *v9; // rsi
const char *v10; // rax
long long result; // rax
v3 = strlen(a1);
v4 = strlen(a2);
if ( v3 <= 0 )
{
result = 1LL;
if ( v4 <= 0 )
return result;
v6 = a2 + 1;
v7 = (unsigned int)(v4 - 1);
}
else
{
v5 = a1;
if ( v4 <= 0 )
return 0LL;
v6 = a2 + 1;
v7 = (unsigned int)(v4 - 1);
do
{
v8 = a2;
while ( *v5 != *v8 )
{
if ( ++v8 == &a2[v7 + 1] )
return 0LL;
}
++v5;
}
while ( v5 != &a1[v3 - 1 + 1] );
}
v9 = a2;
if ( v3 <= 0 )
return 0LL;
do
{
v10 = a1;
while ( *v9 != *v10 )
{
if ( ++v10 == &a1[v3 - 1 + 1] )
return 0LL;
}
++v9;
}
while ( v9 != &v6[v7] );
return 1LL;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
CALL 0x00101060
MOV RDI,RBX
MOV R12,RAX
CALL 0x00101060
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001013d7
LEA EAX,[R12 + -0x1]
MOV RSI,RBP
LEA RDI,[RBP + RAX*0x1 + 0x1]
TEST EDX,EDX
JLE 0x001013d0
LEA ECX,[RDX + -0x1]
LEA R8,[RBX + 0x1]
MOV R9,RCX
ADD RCX,R8
NOP dword ptr [RAX]
LAB_00101360:
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBX
JMP 0x00101379
LAB_00101370:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001013d0
LAB_00101379:
CMP DL,byte ptr [RAX]
JNZ 0x00101370
ADD RSI,0x1
CMP RSI,RDI
JNZ 0x00101360
LAB_00101386:
MOV RSI,RBX
LEA RDI,[R8 + R9*0x1]
TEST R12D,R12D
JLE 0x001013d0
LEA EAX,[R12 + -0x1]
LEA RCX,[RBP + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_001013a0:
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBP
JMP 0x001013b9
LAB_001013b0:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001013d0
LAB_001013b9:
CMP DL,byte ptr [RAX]
JNZ 0x001013b0
ADD RSI,0x1
CMP RSI,RDI
JNZ 0x001013a0
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_001013d0:
XOR EAX,EAX
LAB_001013d2:
POP RBX
POP RBP
POP R12
RET
LAB_001013d7:
MOV EAX,0x1
TEST EDX,EDX
JLE 0x001013d2
LEA R8,[RBX + 0x1]
LEA R9D,[RDX + -0x1]
JMP 0x00101386
|
int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
char *pcVar3;
ulong uVar4;
int iVar5;
char *pcVar6;
int iVar7;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
iVar7 = (int)sVar1;
iVar5 = (int)sVar2;
if (iVar7 < 1) {
if (iVar5 < 1) {
return 1;
}
uVar4 = (ulong)(iVar5 - 1);
}
else {
if (iVar5 < 1) {
return 0;
}
uVar4 = (ulong)(iVar5 - 1);
pcVar6 = param_1;
do {
pcVar3 = param_2;
while (*pcVar6 != *pcVar3) {
pcVar3 = pcVar3 + 1;
if (pcVar3 == param_2 + uVar4 + 1) {
return 0;
}
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != param_1 + (ulong)(iVar7 - 1) + 1);
}
pcVar6 = param_2 + uVar4 + 1;
if (iVar7 < 1) {
return 0;
}
do {
pcVar3 = param_1;
while (*param_2 != *pcVar3) {
pcVar3 = pcVar3 + 1;
if (pcVar3 == param_1 + (ulong)(iVar7 - 1) + 1) {
return 0;
}
}
param_2 = param_2 + 1;
} while (param_2 != pcVar6);
return 1;
}
|
875 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (!found) return false;
}
for (int i = 0; i < len1; i++) {
bool found = false;
for (int j = 0; j < len0; j++) {
if (s1[i] == s0[j]) {
found = true;
break;
}
}
if (!found) return false;
}
return true;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
assert(func0("eabcdzzzz", "dddzzzzzzzddddabc") == false);
assert(func0("aabb", "aaccc") == false);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
callq 1060 <strlen@plt>
mov %r12,%rdi
mov %rax,%rbx
callq 1060 <strlen@plt>
test %ebx,%ebx
jle 13c7 <func0+0xb7>
lea -0x1(%rbx),%esi
mov %eax,%r8d
lea 0x1(%rbp),%r9
sub $0x1,%eax
mov %rsi,%rbx
mov %rbp,%rdi
lea 0x1(%r12,%rax,1),%rcx
add %r9,%rsi
nopl 0x0(%rax)
test %r8d,%r8d
jle 13c0 <func0+0xb0>
movzbl (%rdi),%edx
mov %r12,%rax
jmp 1371 <func0+0x61>
nopl (%rax)
add $0x1,%rax
cmp %rcx,%rax
je 13c0 <func0+0xb0>
cmp (%rax),%dl
jne 1368 <func0+0x58>
add $0x1,%rdi
cmp %rsi,%rdi
jne 1358 <func0+0x48>
xor %esi,%esi
lea (%rbx,%r9,1),%rdx
nopl 0x0(%rax)
movzbl (%r12,%rsi,1),%ecx
mov %rbp,%rax
jmp 13a1 <func0+0x91>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rax,%rdx
je 13c0 <func0+0xb0>
cmp (%rax),%cl
jne 1398 <func0+0x88>
add $0x1,%rsi
cmp %esi,%r8d
jg 1388 <func0+0x78>
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
retq
test %eax,%eax
setle %al
jmp 13c2 <func0+0xb2>
xchg %ax,%ax
|
func0:
endbr64
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
call _strlen
mov rdi, rbx; s
mov r12, rax
call _strlen
mov rdx, rax
test r12d, r12d
jle loc_13D7
lea eax, [r12-1]
mov rsi, rbp
lea rdi, [rbp+rax+1]
test edx, edx
jle loc_13D0
lea ecx, [rdx-1]
lea r8, [rbx+1]
mov r9, rcx
add rcx, r8
nop dword ptr [rax+00h]
loc_1360:
movzx edx, byte ptr [rsi]
mov rax, rbx
jmp short loc_1379
loc_1370:
add rax, 1
cmp rax, rcx
jz short loc_13D0
loc_1379:
cmp dl, [rax]
jnz short loc_1370
add rsi, 1
cmp rsi, rdi
jnz short loc_1360
loc_1386:
mov rsi, rbx
lea rdi, [r8+r9]
test r12d, r12d
jle short loc_13D0
lea eax, [r12-1]
lea rcx, [rbp+rax+1]
nop dword ptr [rax+00h]
loc_13A0:
movzx edx, byte ptr [rsi]
mov rax, rbp
jmp short loc_13B9
loc_13B0:
add rax, 1
cmp rcx, rax
jz short loc_13D0
loc_13B9:
cmp dl, [rax]
jnz short loc_13B0
add rsi, 1
cmp rsi, rdi
jnz short loc_13A0
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_13D0:
xor eax, eax
loc_13D2:
pop rbx
pop rbp
pop r12
retn
loc_13D7:
mov eax, 1
test edx, edx
jle short loc_13D2
lea r8, [rbx+1]
lea r9d, [rdx-1]
jmp short loc_1386
|
long long func0(const char *a1, const char *a2)
{
int v3; // r12d
int v4; // edx
const char *v5; // rsi
const char *v6; // r8
long long v7; // r9
const char *v8; // rax
const char *v9; // rsi
const char *v10; // rax
long long result; // rax
v3 = strlen(a1);
v4 = strlen(a2);
if ( v3 <= 0 )
{
result = 1LL;
if ( v4 <= 0 )
return result;
v6 = a2 + 1;
v7 = (unsigned int)(v4 - 1);
}
else
{
v5 = a1;
if ( v4 <= 0 )
return 0LL;
v6 = a2 + 1;
v7 = (unsigned int)(v4 - 1);
do
{
v8 = a2;
while ( *v5 != *v8 )
{
if ( ++v8 == &a2[v7 + 1] )
return 0LL;
}
++v5;
}
while ( v5 != &a1[v3 - 1 + 1] );
}
v9 = a2;
if ( v3 <= 0 )
return 0LL;
do
{
v10 = a1;
while ( *v9 != *v10 )
{
if ( &a1[v3 - 1 + 1] == ++v10 )
return 0LL;
}
++v9;
}
while ( v9 != &v6[v7] );
return 1LL;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
CALL 0x00101060
MOV RDI,RBX
MOV R12,RAX
CALL 0x00101060
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001013d7
LEA EAX,[R12 + -0x1]
MOV RSI,RBP
LEA RDI,[RBP + RAX*0x1 + 0x1]
TEST EDX,EDX
JLE 0x001013d0
LEA ECX,[RDX + -0x1]
LEA R8,[RBX + 0x1]
MOV R9,RCX
ADD RCX,R8
NOP dword ptr [RAX]
LAB_00101360:
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBX
JMP 0x00101379
LAB_00101370:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001013d0
LAB_00101379:
CMP DL,byte ptr [RAX]
JNZ 0x00101370
ADD RSI,0x1
CMP RSI,RDI
JNZ 0x00101360
LAB_00101386:
MOV RSI,RBX
LEA RDI,[R8 + R9*0x1]
TEST R12D,R12D
JLE 0x001013d0
LEA EAX,[R12 + -0x1]
LEA RCX,[RBP + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_001013a0:
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBP
JMP 0x001013b9
LAB_001013b0:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x001013d0
LAB_001013b9:
CMP DL,byte ptr [RAX]
JNZ 0x001013b0
ADD RSI,0x1
CMP RSI,RDI
JNZ 0x001013a0
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_001013d0:
XOR EAX,EAX
LAB_001013d2:
POP RBX
POP RBP
POP R12
RET
LAB_001013d7:
MOV EAX,0x1
TEST EDX,EDX
JLE 0x001013d2
LEA R8,[RBX + 0x1]
LEA R9D,[RDX + -0x1]
JMP 0x00101386
|
int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
char *pcVar3;
ulong uVar4;
int iVar5;
char *pcVar6;
int iVar7;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
iVar7 = (int)sVar1;
iVar5 = (int)sVar2;
if (iVar7 < 1) {
if (iVar5 < 1) {
return 1;
}
uVar4 = (ulong)(iVar5 - 1);
}
else {
if (iVar5 < 1) {
return 0;
}
uVar4 = (ulong)(iVar5 - 1);
pcVar6 = param_1;
do {
pcVar3 = param_2;
while (*pcVar6 != *pcVar3) {
pcVar3 = pcVar3 + 1;
if (pcVar3 == param_2 + uVar4 + 1) {
return 0;
}
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != param_1 + (ulong)(iVar7 - 1) + 1);
}
pcVar6 = param_2 + uVar4 + 1;
if (iVar7 < 1) {
return 0;
}
do {
pcVar3 = param_1;
while (*param_2 != *pcVar3) {
pcVar3 = pcVar3 + 1;
if (param_1 + (ulong)(iVar7 - 1) + 1 == pcVar3) {
return 0;
}
}
param_2 = param_2 + 1;
} while (param_2 != pcVar6);
return 1;
}
|
876 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
}
|
#include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xfd0,%rsp
mov %edi,-0xfc4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0xfb0(%rbp),%rdx
mov $0x0,%eax
mov $0x1f4,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0xfb0(%rbp)
movl $0x1,-0xfac(%rbp)
movl $0x2,-0xfb4(%rbp)
jmp 1200 <func0+0x97>
mov -0xfb4(%rbp),%eax
sub $0x1,%eax
cltq
mov -0xfb0(%rbp,%rax,4),%edx
mov -0xfb4(%rbp),%eax
sub $0x2,%eax
cltq
mov -0xfb0(%rbp,%rax,4),%eax
add %eax,%edx
mov -0xfb4(%rbp),%eax
cltq
mov %edx,-0xfb0(%rbp,%rax,4)
addl $0x1,-0xfb4(%rbp)
mov -0xfb4(%rbp),%eax
cmp -0xfc4(%rbp),%eax
jle 11c4 <func0+0x5b>
mov -0xfc4(%rbp),%eax
cltq
mov -0xfb0(%rbp,%rax,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1231 <func0+0xc8>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0FD0h
mov [rbp+var_FC4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_FB0]
mov eax, 0
mov ecx, 1F4h
mov rdi, rdx
rep stosq
mov [rbp+var_FB0], 0
mov [rbp+var_FAC], 1
mov [rbp+var_FB4], 2
jmp short loc_1200
loc_11C4:
mov eax, [rbp+var_FB4]
sub eax, 1
cdqe
mov edx, [rbp+rax*4+var_FB0]
mov eax, [rbp+var_FB4]
sub eax, 2
cdqe
mov eax, [rbp+rax*4+var_FB0]
add edx, eax
mov eax, [rbp+var_FB4]
cdqe
mov [rbp+rax*4+var_FB0], edx
add [rbp+var_FB4], 1
loc_1200:
mov eax, [rbp+var_FB4]
cmp eax, [rbp+var_FC4]
jle short loc_11C4
mov eax, [rbp+var_FC4]
cdqe
mov eax, [rbp+rax*4+var_FB0]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1231
call ___stack_chk_fail
locret_1231:
leave
retn
|
long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-FB4h]
_DWORD v3[1002]; // [rsp+20h] [rbp-FB0h] BYREF
unsigned long long v4; // [rsp+FC8h] [rbp-8h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0xFA0uLL);
v3[0] = 0;
v3[1] = 1;
for ( i = 2; i <= a1; ++i )
v3[i] = v3[i - 2] + v3[i - 1];
return (unsigned int)v3[a1];
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xfd0
MOV dword ptr [RBP + -0xfc4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0xfb0]
MOV EAX,0x0
MOV ECX,0x1f4
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0xfb0],0x0
MOV dword ptr [RBP + -0xfac],0x1
MOV dword ptr [RBP + -0xfb4],0x2
JMP 0x00101200
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0xfb4]
SUB EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0xfb0]
MOV EAX,dword ptr [RBP + -0xfb4]
SUB EAX,0x2
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xfb0]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0xfb4]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0xfb0],EDX
ADD dword ptr [RBP + -0xfb4],0x1
LAB_00101200:
MOV EAX,dword ptr [RBP + -0xfb4]
CMP EAX,dword ptr [RBP + -0xfc4]
JLE 0x001011c4
MOV EAX,dword ptr [RBP + -0xfc4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xfb0]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101231
CALL 0x00101060
LAB_00101231:
LEAVE
RET
|
int func0(int param_1)
{
long lVar1;
int *piVar2;
long in_FS_OFFSET;
int local_fbc;
int local_fb8 [1002];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = local_fb8;
for (lVar1 = 500; lVar1 != 0; lVar1 = lVar1 + -1) {
piVar2[0] = 0;
piVar2[1] = 0;
piVar2 = piVar2 + 2;
}
local_fb8[0] = 0;
local_fb8[1] = 1;
for (local_fbc = 2; local_fbc <= param_1; local_fbc = local_fbc + 1) {
local_fb8[local_fbc] = local_fb8[local_fbc + -1] + local_fb8[local_fbc + -2];
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_fb8[param_1];
}
|
877 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
}
|
#include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
}
|
O1
|
c
|
func0:
endbr64
sub $0xfb8,%rsp
mov %edi,%esi
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1f4,%ecx
rep stos %rax,%es:(%rdi)
movl $0x1,0x4(%rsp)
cmp $0x1,%esi
jle 11bd <func0+0x54>
mov %rsp,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov (%rax),%edx
add 0x4(%rax),%edx
mov %edx,0x8(%rax)
add $0x4,%rax
cmp %rcx,%rax
jne 11ac <func0+0x43>
movslq %esi,%rsi
mov (%rsp,%rsi,4),%eax
mov 0xfa8(%rsp),%rdi
xor %fs:0x28,%rdi
jne 11de <func0+0x75>
add $0xfb8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
|
func0:
endbr64
sub rsp, 0FB8h
mov esi, edi
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 1F4h
rep stosq
mov [rsp+0FB8h+var_FB4], 1
cmp esi, 1
jle short loc_11BD
mov rax, rsp
lea edx, [rsi-2]
lea rcx, [rsp+rdx*4+0FB8h+var_FB4]
loc_11AC:
mov edx, [rax]
add edx, [rax+4]
mov [rax+8], edx
add rax, 4
cmp rax, rcx
jnz short loc_11AC
loc_11BD:
movsxd rsi, esi
mov eax, [rsp+rsi*4+0FB8h+var_FB8]
mov rdx, [rsp+0FB8h+var_10]
sub rdx, fs:28h
jnz short loc_11DE
add rsp, 0FB8h
retn
loc_11DE:
call ___stack_chk_fail
|
long long func0(int a1)
{
_DWORD *v1; // rax
_DWORD v3[1002]; // [rsp+0h] [rbp-FB8h] BYREF
unsigned long long v4; // [rsp+FA8h] [rbp-10h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0xFA0uLL);
v3[1] = 1;
if ( a1 > 1 )
{
v1 = v3;
do
{
v1[2] = v1[1] + *v1;
++v1;
}
while ( v1 != &v3[a1 - 2 + 1] );
}
return (unsigned int)v3[a1];
}
|
func0:
ENDBR64
SUB RSP,0xfb8
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x1f4
STOSQ.REP RDI
MOV dword ptr [RSP + 0x4],0x1
CMP ESI,0x1
JLE 0x001011bd
MOV RAX,RSP
LEA EDX,[RSI + -0x2]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011ac:
MOV EDX,dword ptr [RAX]
ADD EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RAX + 0x8],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011ac
LAB_001011bd:
MOVSXD RSI,ESI
MOV EAX,dword ptr [RSP + RSI*0x4]
MOV RDX,qword ptr [RSP + 0xfa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001011de
ADD RSP,0xfb8
RET
LAB_001011de:
CALL 0x00101060
|
int func0(int param_1)
{
int *piVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
int local_fb8 [1002];
long local_10;
piVar1 = local_fb8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_fb8;
for (lVar2 = 500; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (int *)((long)piVar3 + 8);
}
local_fb8[1] = 1;
if (1 < param_1) {
do {
piVar1[2] = *piVar1 + piVar1[1];
piVar1 = piVar1 + 1;
} while (piVar1 != local_fb8 + (ulong)(param_1 - 2) + 1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_fb8[param_1];
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
878 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
}
|
#include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
}
|
O2
|
c
|
func0:
endbr64
sub $0xfb8,%rsp
movslq %edi,%r8
mov $0x1f4,%ecx
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movabs $0x100000000,%rax
mov %rax,(%rsp)
cmp $0x1,%r8d
jle 12d8 <func0+0x68>
lea -0x2(%r8),%edx
lea 0x8(%rsp),%rax
lea (%rax,%rdx,4),%rsi
mov $0x1,%edx
jmp 12cf <func0+0x5f>
nopl 0x0(%rax)
mov -0x4(%rax),%ecx
add $0x4,%rax
add %ecx,%edx
mov %edx,(%rax)
cmp %rsi,%rax
jne 12c8 <func0+0x58>
mov 0xfa8(%rsp),%rdi
xor %fs:0x28,%rdi
mov (%rsp,%r8,4),%eax
jne 12f7 <func0+0x87>
add $0xfb8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
func0:
endbr64
sub rsp, 0FB8h
movsxd r8, edi
mov ecx, 1F4h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov [rsp+0FB8h+var_FB4], 1
cmp r8d, 1
jle short loc_12D2
lea eax, [r8-2]
lea rdx, [rsp+0FB8h+var_FB0]
lea rdi, [rsp+rax*4+0FB8h+var_FAC]
mov eax, 1
nop dword ptr [rax]
loc_12C0:
mov esi, eax
add eax, ecx
add rdx, 4
mov [rdx-4], eax
mov ecx, esi
cmp rdx, rdi
jnz short loc_12C0
loc_12D2:
mov eax, [rsp+r8*4+0FB8h+var_FB8]
mov rdx, [rsp+0FB8h+var_10]
sub rdx, fs:28h
jnz short loc_12F1
add rsp, 0FB8h
retn
loc_12F1:
call ___stack_chk_fail
|
long long func0(int a1)
{
int v1; // ecx
_DWORD *v2; // rdx
int v3; // eax
int v4; // esi
_DWORD v6[1002]; // [rsp+0h] [rbp-FB8h] BYREF
unsigned long long v7; // [rsp+FA8h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 0xFA0uLL);
v1 = 0;
v6[1] = 1;
if ( a1 > 1 )
{
v2 = &v6[2];
v3 = 1;
do
{
v4 = v3;
v3 += v1;
*v2++ = v3;
v1 = v4;
}
while ( v2 != &v6[a1 - 2 + 3] );
}
return (unsigned int)v6[a1];
}
|
func0:
ENDBR64
SUB RSP,0xfb8
MOVSXD R8,EDI
MOV ECX,0x1f4
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RSP + 0x4],0x1
CMP R8D,0x1
JLE 0x001012d2
LEA EAX,[R8 + -0x2]
LEA RDX,[RSP + 0x8]
LEA RDI,[RSP + RAX*0x4 + 0xc]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001012c0:
MOV ESI,EAX
ADD EAX,ECX
ADD RDX,0x4
MOV dword ptr [RDX + -0x4],EAX
MOV ECX,ESI
CMP RDX,RDI
JNZ 0x001012c0
LAB_001012d2:
MOV EAX,dword ptr [RSP + R8*0x4]
MOV RDX,qword ptr [RSP + 0xfa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012f1
ADD RSP,0xfb8
RET
LAB_001012f1:
CALL 0x00101060
|
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
int *piVar5;
int *piVar6;
int8 *puVar7;
long in_FS_OFFSET;
int8 uStack_fb8;
int local_fb0 [1000];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
puVar7 = &uStack_fb8;
for (lVar4 = 500; lVar4 != 0; lVar4 = lVar4 + -1) {
*puVar7 = 0;
puVar7 = puVar7 + 1;
}
uStack_fb8._4_4_ = 1;
if (1 < param_1) {
piVar5 = local_fb0;
iVar2 = 1;
iVar3 = 0;
do {
iVar1 = iVar2;
iVar2 = iVar1 + iVar3;
piVar6 = piVar5 + 1;
*piVar5 = iVar2;
piVar5 = piVar6;
iVar3 = iVar1;
} while (piVar6 != local_fb0 + (ulong)(param_1 - 2) + 1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)&uStack_fb8 + (long)param_1 * 4);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
879 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
}
|
#include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
}
|
O3
|
c
|
func0:
endbr64
sub $0xfb8,%rsp
movslq %edi,%rsi
mov $0x1f4,%ecx
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
mov %rsp,%r9
mov %r9,%rdi
rep stos %rax,%es:(%rdi)
movabs $0x100000000,%rax
mov %rax,(%rsp)
cmp $0x1,%esi
jle 1304 <func0+0x94>
cmp $0x3,%esi
jle 1322 <func0+0xb2>
lea -0x4(%rsi),%eax
lea 0x8(%rsp),%r8
mov $0x1,%edi
xor %edx,%edx
and $0xfffffffe,%eax
mov $0x2,%ecx
add $0x4,%eax
add %edi,%edx
add $0x2,%ecx
add $0x8,%r8
add %edx,%edi
mov %edx,-0x8(%r8)
mov %edi,-0x4(%r8)
cmp %eax,%ecx
jne 12d1 <func0+0x61>
movslq %ecx,%rax
lea (%r9,%rax,4),%rax
mov -0x8(%rax),%edx
add $0x1,%ecx
add -0x4(%rax),%edx
add $0x4,%rax
mov %edx,-0x4(%rax)
cmp %ecx,%esi
jge 12f0 <func0+0x80>
mov 0xfa8(%rsp),%rdi
xor %fs:0x28,%rdi
mov (%rsp,%rsi,4),%eax
jne 1329 <func0+0xb9>
add $0xfb8,%rsp
retq
mov $0x2,%ecx
jmp 12e8 <func0+0x78>
callq 1060 <__stack_chk_fail@plt>
xchg %ax,%ax
|
func0:
endbr64
sub rsp, 0FB8h
movsxd rsi, edi
mov ecx, 1F4h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov r8, rsp
mov rdi, r8
rep stosq
mov [rsp+0FB8h+var_FB4], 1
cmp esi, 1
jle short loc_1304
cmp esi, 3
jle short loc_1322
lea ecx, [rsi-4]
lea rdi, [rsp+0FB8h+var_FB0]
mov edx, 1
mov r9d, 2
and ecx, 0FFFFFFFEh
add ecx, 4
loc_12CA:
add eax, edx
add r9d, 2
add rdi, 8
add edx, eax
mov [rdi-8], eax
mov [rdi-4], edx
cmp r9d, ecx
jnz short loc_12CA
loc_12E1:
movsxd rax, ecx
lea rax, [r8+rax*4]
nop dword ptr [rax+rax+00000000h]
loc_12F0:
mov edx, [rax-8]
add ecx, 1
add edx, [rax-4]
add rax, 4
mov [rax-4], edx
cmp esi, ecx
jge short loc_12F0
loc_1304:
mov eax, [rsp+rsi*4+0FB8h+var_FB8]
mov rdx, [rsp+0FB8h+var_10]
sub rdx, fs:28h
jnz short loc_1329
add rsp, 0FB8h
retn
loc_1322:
mov ecx, 2
jmp short loc_12E1
loc_1329:
call ___stack_chk_fail
|
long long func0(int a1)
{
long long v1; // rsi
int v2; // eax
_DWORD *v3; // rdi
int v4; // edx
int v5; // r9d
int v6; // ecx
_DWORD *v7; // rax
int v8; // edx
_DWORD v10[1002]; // [rsp+0h] [rbp-FB8h] BYREF
unsigned long long v11; // [rsp+FA8h] [rbp-10h]
v1 = a1;
v11 = __readfsqword(0x28u);
v2 = 0;
memset(v10, 0, 0xFA0uLL);
v10[1] = 1;
if ( a1 > 1 )
{
if ( a1 <= 3 )
{
v6 = 2;
}
else
{
v3 = &v10[2];
v4 = 1;
v5 = 2;
v6 = ((v1 - 4) & 0xFFFFFFFE) + 4;
do
{
v2 += v4;
v5 += 2;
v3 += 2;
v4 += v2;
*(v3 - 2) = v2;
*(v3 - 1) = v4;
}
while ( v5 != v6 );
}
v7 = &v10[v6];
do
{
++v6;
v8 = *(v7 - 1) + *(v7 - 2);
*v7++ = v8;
}
while ( (int)v1 >= v6 );
}
return (unsigned int)v10[v1];
}
|
func0:
ENDBR64
SUB RSP,0xfb8
MOVSXD RSI,EDI
MOV ECX,0x1f4
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV R8,RSP
MOV RDI,R8
STOSQ.REP RDI
MOV dword ptr [RSP + 0x4],0x1
CMP ESI,0x1
JLE 0x00101304
CMP ESI,0x3
JLE 0x00101322
LEA ECX,[RSI + -0x4]
LEA RDI,[RSP + 0x8]
MOV EDX,0x1
MOV R9D,0x2
AND ECX,0xfffffffe
ADD ECX,0x4
LAB_001012ca:
ADD EAX,EDX
ADD R9D,0x2
ADD RDI,0x8
ADD EDX,EAX
MOV dword ptr [RDI + -0x8],EAX
MOV dword ptr [RDI + -0x4],EDX
CMP R9D,ECX
JNZ 0x001012ca
LAB_001012e1:
MOVSXD RAX,ECX
LEA RAX,[R8 + RAX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012f0:
MOV EDX,dword ptr [RAX + -0x8]
ADD ECX,0x1
ADD EDX,dword ptr [RAX + -0x4]
ADD RAX,0x4
MOV dword ptr [RAX + -0x4],EDX
CMP ESI,ECX
JGE 0x001012f0
LAB_00101304:
MOV EAX,dword ptr [RSP + RSI*0x4]
MOV RDX,qword ptr [RSP + 0xfa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101329
ADD RSP,0xfb8
RET
LAB_00101322:
MOV ECX,0x2
JMP 0x001012e1
LAB_00101329:
CALL 0x00101060
|
int func0(int param_1)
{
int iVar1;
int *piVar2;
int iVar3;
long lVar4;
int iVar5;
int iVar6;
long in_FS_OFFSET;
int local_fb8 [1002];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = 0;
piVar2 = local_fb8;
for (lVar4 = 500; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)piVar2 = 0;
piVar2 = (int *)((long)piVar2 + 8);
}
local_fb8[1] = 1;
if (1 < param_1) {
if (param_1 < 4) {
iVar3 = 2;
}
else {
piVar2 = local_fb8;
iVar5 = 1;
iVar6 = 2;
iVar3 = (param_1 - 4U & 0xfffffffe) + 4;
do {
piVar2 = piVar2 + 2;
iVar1 = iVar1 + iVar5;
iVar6 = iVar6 + 2;
iVar5 = iVar5 + iVar1;
*piVar2 = iVar1;
piVar2[1] = iVar5;
} while (iVar6 != iVar3);
}
piVar2 = local_fb8 + iVar3;
do {
iVar3 = iVar3 + 1;
*piVar2 = piVar2[-2] + piVar2[-1];
piVar2 = piVar2 + 1;
} while (iVar3 <= param_1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_fb8[param_1];
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
880 |
func0
|
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
|
bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
assert(!func0("<<>"));
assert(!func0("<><><<><>><>><<>"));
assert(!func0("<><><<><>><>>><>"));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a6 <func0+0x5d>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x3c,%al
jne 117d <func0+0x34>
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x3e,%al
jne 1195 <func0+0x4c>
subl $0x1,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jns 11a2 <func0+0x59>
mov $0x0,%eax
jmp 11cc <func0+0x83>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1165 <func0+0x1c>
cmpl $0x0,-0x8(%rbp)
je 11c7 <func0+0x7e>
mov $0x0,%eax
jmp 11cc <func0+0x83>
mov $0x1,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A6
loc_1165:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 3Ch ; '<'
jnz short loc_117D
add [rbp+var_8], 1
loc_117D:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 3Eh ; '>'
jnz short loc_1195
sub [rbp+var_8], 1
loc_1195:
cmp [rbp+var_8], 0
jns short loc_11A2
mov eax, 0
jmp short loc_11CC
loc_11A2:
add [rbp+var_4], 1
loc_11A6:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1165
cmp [rbp+var_8], 0
jz short loc_11C7
mov eax, 0
jmp short loc_11CC
loc_11C7:
mov eax, 1
loc_11CC:
pop rbp
retn
|
_BOOL8 func0(long long a1)
{
int v2; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v2 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(_BYTE *)(i + a1) == 60 )
++v2;
if ( *(_BYTE *)(i + a1) == 62 )
--v2;
if ( v2 < 0 )
return 0LL;
}
return v2 == 0;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a6
LAB_00101165:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x3c
JNZ 0x0010117d
ADD dword ptr [RBP + -0x8],0x1
LAB_0010117d:
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,0x3e
JNZ 0x00101195
SUB dword ptr [RBP + -0x8],0x1
LAB_00101195:
CMP dword ptr [RBP + -0x8],0x0
JNS 0x001011a2
MOV EAX,0x0
JMP 0x001011cc
LAB_001011a2:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a6:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101165
CMP dword ptr [RBP + -0x8],0x0
JZ 0x001011c7
MOV EAX,0x0
JMP 0x001011cc
LAB_001011c7:
MOV EAX,0x1
LAB_001011cc:
POP RBP
RET
|
bool func0(long param_1)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while( true ) {
if (*(char *)(param_1 + local_c) == '\0') {
return local_10 == 0;
}
if (*(char *)(param_1 + local_c) == '<') {
local_10 = local_10 + 1;
}
if (*(char *)(param_1 + local_c) == '>') {
local_10 = local_10 + -1;
}
if (local_10 < 0) break;
local_c = local_c + 1;
}
return false;
}
|
881 |
func0
|
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
|
bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
assert(!func0("<<>"));
assert(!func0("<><><<><>><>><<>"));
assert(!func0("<><><<><>><>>><>"));
return 0;
}
|
O1
|
c
|
func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 1182 <func0+0x39>
add $0x1,%rdi
mov $0x0,%edx
jmp 1179 <func0+0x30>
cmp $0x3e,%al
sete %al
movzbl %al,%eax
sub %eax,%edx
test %edx,%edx
js 118d <func0+0x44>
add $0x1,%rdi
movzbl -0x1(%rdi),%eax
test %al,%al
je 1187 <func0+0x3e>
cmp $0x3c,%al
jne 115f <func0+0x16>
add $0x1,%edx
jmp 1169 <func0+0x20>
mov $0x0,%edx
test %edx,%edx
sete %al
retq
mov $0x0,%eax
retq
|
func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_1181
add rdi, 1
mov edx, 0
jmp short loc_116E
loc_115F:
add edx, 1
loc_1162:
add rdi, 1
movzx eax, byte ptr [rdi-1]
test al, al
jz short loc_1186
loc_116E:
cmp al, 3Ch ; '<'
jz short loc_115F
cmp al, 3Eh ; '>'
jnz short loc_1162
sub edx, 1
jns short loc_1162
mov eax, 0
retn
loc_1181:
mov edx, 0
loc_1186:
test edx, edx
setz al
retn
|
bool func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0;
while ( 1 )
{
if ( v1 == 60 )
{
++v3;
}
else if ( v1 == 62 && --v3 < 0 )
{
return 0;
}
v1 = *v2++;
if ( !v1 )
return v3 == 0;
}
}
v3 = 0;
return v3 == 0;
}
|
func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101181
ADD RDI,0x1
MOV EDX,0x0
JMP 0x0010116e
LAB_0010115f:
ADD EDX,0x1
LAB_00101162:
ADD RDI,0x1
MOVZX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JZ 0x00101186
LAB_0010116e:
CMP AL,0x3c
JZ 0x0010115f
CMP AL,0x3e
JNZ 0x00101162
SUB EDX,0x1
JNS 0x00101162
MOV EAX,0x0
RET
LAB_00101181:
MOV EDX,0x0
LAB_00101186:
TEST EDX,EDX
SETZ AL
RET
|
bool func0(char *param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar2 = 0;
}
else {
iVar2 = 0;
pcVar3 = param_1 + 1;
do {
if (cVar1 == '<') {
iVar2 = iVar2 + 1;
}
else if (cVar1 == '>') {
iVar2 = iVar2 + -1;
if (iVar2 < 0) {
return false;
}
}
cVar1 = *pcVar3;
pcVar3 = pcVar3 + 1;
} while (cVar1 != '\0');
}
return iVar2 == 0;
}
|
882 |
func0
|
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
|
bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
assert(!func0("<<>"));
assert(!func0("<><><<><>><>><<>"));
assert(!func0("<><><<><>><>>><>"));
return 0;
}
|
O2
|
c
|
func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 14f3 <func0+0x53>
add $0x1,%rdi
xor %edx,%edx
jmp 14cf <func0+0x2f>
nopl 0x0(%rax,%rax,1)
cmp $0x3e,%al
jne 14c4 <func0+0x24>
sub $0x1,%edx
cmp $0xffffffff,%edx
je 14f0 <func0+0x50>
movzbl (%rdi),%eax
add $0x1,%rdi
test %al,%al
je 14e1 <func0+0x41>
cmp $0x3c,%al
jne 14b8 <func0+0x18>
movzbl (%rdi),%eax
add $0x1,%rdi
add $0x1,%edx
test %al,%al
jne 14cf <func0+0x2f>
test %edx,%edx
sete %al
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
mov $0x1,%eax
retq
nopl 0x0(%rax)
|
func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_140B
add rdi, 1
xor edx, edx
jmp short loc_13EC
loc_13D8:
cmp al, 3Eh ; '>'
jnz short loc_13E1
sub edx, 1
jb short loc_1408
loc_13E1:
movzx eax, byte ptr [rdi]
add rdi, 1
test al, al
jz short loc_13FE
loc_13EC:
cmp al, 3Ch ; '<'
jnz short loc_13D8
movzx eax, byte ptr [rdi]
add rdi, 1
add edx, 1
test al, al
jnz short loc_13EC
loc_13FE:
test edx, edx
setz al
retn
loc_1408:
xor eax, eax
retn
loc_140B:
mov eax, 1
retn
|
char func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
v1 = *a1;
if ( !*a1 )
return 1;
v2 = a1 + 1;
v3 = 0;
while ( 1 )
{
while ( v1 == 60 )
{
v1 = *v2++;
++v3;
if ( !v1 )
return v3 == 0;
}
if ( v1 == 62 && v3-- == 0 )
break;
v1 = *v2++;
if ( !v1 )
return v3 == 0;
}
return 0;
}
|
func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x0010140b
ADD RDI,0x1
XOR EDX,EDX
JMP 0x001013ec
LAB_001013d8:
CMP AL,0x3e
JNZ 0x001013e1
SUB EDX,0x1
JC 0x00101408
LAB_001013e1:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
JZ 0x001013fe
LAB_001013ec:
CMP AL,0x3c
JNZ 0x001013d8
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
ADD EDX,0x1
TEST AL,AL
JNZ 0x001013ec
LAB_001013fe:
TEST EDX,EDX
SETZ AL
RET
LAB_00101408:
XOR EAX,EAX
RET
LAB_0010140b:
MOV EAX,0x1
RET
|
bool func0(char *param_1)
{
char cVar1;
int iVar2;
bool bVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
return true;
}
param_1 = param_1 + 1;
iVar2 = 0;
do {
while (cVar1 == '<') {
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar2 = iVar2 + 1;
if (cVar1 == '\0') goto LAB_001013fe;
}
if (cVar1 == '>') {
bVar3 = iVar2 == 0;
iVar2 = iVar2 + -1;
if (bVar3) {
return false;
}
}
cVar1 = *param_1;
param_1 = param_1 + 1;
} while (cVar1 != '\0');
LAB_001013fe:
return iVar2 == 0;
}
|
883 |
func0
|
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
|
bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
assert(!func0("<<>"));
assert(!func0("<><><<><>><>><<>"));
assert(!func0("<><><<><>><>>><>"));
return 0;
}
|
O3
|
c
|
func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 14f3 <func0+0x53>
add $0x1,%rdi
xor %edx,%edx
jmp 14cf <func0+0x2f>
nopl 0x0(%rax,%rax,1)
cmp $0x3e,%al
jne 14c4 <func0+0x24>
sub $0x1,%edx
cmp $0xffffffff,%edx
je 14f0 <func0+0x50>
movzbl (%rdi),%eax
add $0x1,%rdi
test %al,%al
je 14e1 <func0+0x41>
cmp $0x3c,%al
jne 14b8 <func0+0x18>
movzbl (%rdi),%eax
add $0x1,%rdi
add $0x1,%edx
test %al,%al
jne 14cf <func0+0x2f>
test %edx,%edx
sete %al
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
mov $0x1,%eax
retq
nopl 0x0(%rax)
|
func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_153B
add rdi, 1
xor edx, edx
jmp short loc_151C
loc_1508:
cmp al, 3Eh ; '>'
jnz short loc_1511
sub edx, 1
jb short loc_1538
loc_1511:
movzx eax, byte ptr [rdi]
add rdi, 1
test al, al
jz short loc_152E
loc_151C:
cmp al, 3Ch ; '<'
jnz short loc_1508
movzx eax, byte ptr [rdi]
add rdi, 1
add edx, 1
test al, al
jnz short loc_151C
loc_152E:
test edx, edx
setz al
retn
loc_1538:
xor eax, eax
retn
loc_153B:
mov eax, 1
retn
|
char func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
v1 = *a1;
if ( !*a1 )
return 1;
v2 = a1 + 1;
v3 = 0;
while ( 1 )
{
while ( v1 == 60 )
{
v1 = *v2++;
++v3;
if ( !v1 )
return v3 == 0;
}
if ( v1 == 62 && v3-- == 0 )
break;
v1 = *v2++;
if ( !v1 )
return v3 == 0;
}
return 0;
}
|
func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x0010153b
ADD RDI,0x1
XOR EDX,EDX
JMP 0x0010151c
LAB_00101508:
CMP AL,0x3e
JNZ 0x00101511
SUB EDX,0x1
JC 0x00101538
LAB_00101511:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
JZ 0x0010152e
LAB_0010151c:
CMP AL,0x3c
JNZ 0x00101508
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
ADD EDX,0x1
TEST AL,AL
JNZ 0x0010151c
LAB_0010152e:
TEST EDX,EDX
SETZ AL
RET
LAB_00101538:
XOR EAX,EAX
RET
LAB_0010153b:
MOV EAX,0x1
RET
|
bool func0(char *param_1)
{
char cVar1;
int iVar2;
bool bVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
return true;
}
param_1 = param_1 + 1;
iVar2 = 0;
do {
while (cVar1 == '<') {
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar2 = iVar2 + 1;
if (cVar1 == '\0') goto LAB_0010152e;
}
if (cVar1 == '>') {
bVar3 = iVar2 == 0;
iVar2 = iVar2 + -1;
if (bVar3) {
return false;
}
}
cVar1 = *param_1;
param_1 = param_1 + 1;
} while (cVar1 != '\0');
LAB_0010152e:
return iVar2 == 0;
}
|
884 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
}
|
#include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9, 9};
assert(func0(list1, 4) == true);
assert(func0(list2, 4) == true);
assert(func0(list3, 4) == false);
assert(func0(list4, 4) == true);
assert(func0(list5, 4) == true);
assert(func0(list6, 6) == false);
assert(func0(list7, 6) == true);
assert(func0(list8, 4) == true);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
movl $0x1,-0x4(%rbp)
jmp 120a <func0+0xa1>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
comiss %xmm1,%xmm0
jbe 11ca <func0+0x61>
movl $0x1,-0xc(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
comiss %xmm1,%xmm0
jbe 1206 <func0+0x9d>
movl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118e <func0+0x25>
mov -0xc(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cmp $0x2,%eax
jne 122a <func0+0xc1>
mov $0x0,%eax
jmp 122f <func0+0xc6>
mov $0x1,%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 eax, [rbp+var_8]
mov [rbp+var_C], eax
mov [rbp+var_4], 1
jmp short loc_120A
loc_118E:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm1, dword ptr [rax]
comiss xmm0, xmm1
jbe short loc_11CA
mov [rbp+var_C], 1
loc_11CA:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm1, dword ptr [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
comiss xmm0, xmm1
jbe short loc_1206
mov [rbp+var_8], 1
loc_1206:
add [rbp+var_4], 1
loc_120A:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_118E
mov edx, [rbp+var_C]
mov eax, [rbp+var_8]
add eax, edx
cmp eax, 2
jnz short loc_122A
mov eax, 0
jmp short loc_122F
loc_122A:
mov eax, 1
loc_122F:
pop rbp
retn
|
_BOOL8 func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0;
v3 = 0;
for ( i = 1; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) > *(float *)(4LL * i - 4 + a1) )
v3 = 1;
if ( *(float *)(4LL * i - 4 + a1) > *(float *)(4LL * i + a1) )
v4 = 1;
}
return v3 + v4 != 2;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010120a
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,XMM1
JBE 0x001011ca
MOV dword ptr [RBP + -0xc],0x1
LAB_001011ca:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
COMISS XMM0,XMM1
JBE 0x00101206
MOV dword ptr [RBP + -0x8],0x1
LAB_00101206:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118e
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
CMP EAX,0x2
JNZ 0x0010122a
MOV EAX,0x0
JMP 0x0010122f
LAB_0010122a:
MOV EAX,0x1
LAB_0010122f:
POP RBP
RET
|
bool func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_10 = 0;
local_14 = 0;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (*(float *)(param_1 + (long)local_c * 4 + -4) < *(float *)(param_1 + (long)local_c * 4)) {
local_14 = 1;
}
if (*(float *)(param_1 + (long)local_c * 4) < *(float *)(param_1 + (long)local_c * 4 + -4)) {
local_10 = 1;
}
}
return local_10 + local_14 != 2;
}
|
885 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
}
|
#include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9, 9};
assert(func0(list1, 4) == true);
assert(func0(list2, 4) == true);
assert(func0(list3, 4) == false);
assert(func0(list4, 4) == true);
assert(func0(list5, 4) == true);
assert(func0(list6, 6) == false);
assert(func0(list7, 6) == true);
assert(func0(list8, 4) == true);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 11b3 <func0+0x4a>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x0,%ecx
mov $0x0,%edx
mov $0x1,%esi
movss 0x4(%rax),%xmm0
movss (%rax),%xmm1
ucomiss %xmm1,%xmm0
cmova %esi,%edx
ucomiss %xmm0,%xmm1
cmova %esi,%ecx
add $0x4,%rax
cmp %rdi,%rax
jne 118c <func0+0x23>
add %ecx,%edx
cmp $0x2,%edx
setne %al
retq
mov $0x0,%ecx
mov $0x0,%edx
jmp 11aa <func0+0x41>
|
func0:
endbr64
cmp esi, 1
jle short loc_11AF
mov rax, rdi
lea edx, [rsi-2]
lea rsi, [rdi+rdx*4+4]
mov edx, 0
mov edi, 0
mov ecx, 1
jmp short loc_1199
loc_118E:
mov edi, ecx
loc_1190:
add rax, 4
cmp rax, rsi
jz short loc_11B9
loc_1199:
movss xmm0, dword ptr [rax+4]
movss xmm1, dword ptr [rax]
comiss xmm0, xmm1
ja short loc_118E
ucomiss xmm1, xmm0
cmova edx, ecx
jmp short loc_1190
loc_11AF:
mov edx, 0
mov edi, 0
loc_11B9:
add edi, edx
cmp edi, 2
setnz al
retn
|
bool func0(float *a1, int a2)
{
float *v2; // rax
long long v3; // rsi
int v4; // edx
int v5; // edi
float v6; // xmm0_4
if ( a2 <= 1 )
{
v4 = 0;
v5 = 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 2 + 1];
v4 = 0;
v5 = 0;
do
{
v6 = v2[1];
if ( v6 > *v2 )
{
v5 = 1;
}
else if ( *v2 > v6 )
{
v4 = 1;
}
++v2;
}
while ( v2 != (float *)v3 );
}
return v4 + v5 != 2;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011af
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
MOV EDI,0x0
MOV ECX,0x1
JMP 0x00101199
LAB_0010118e:
MOV EDI,ECX
LAB_00101190:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x001011b9
LAB_00101199:
MOVSS XMM0,dword ptr [RAX + 0x4]
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,XMM1
JA 0x0010118e
UCOMISS XMM1,XMM0
CMOVA EDX,ECX
JMP 0x00101190
LAB_001011af:
MOV EDX,0x0
MOV EDI,0x0
LAB_001011b9:
ADD EDI,EDX
CMP EDI,0x2
SETNZ AL
RET
|
bool func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
int iVar3;
if (param_2 < 2) {
iVar2 = 0;
iVar3 = 0;
}
else {
pfVar1 = param_1 + (ulong)(param_2 - 2) + 1;
iVar2 = 0;
iVar3 = 0;
do {
if (*param_1 < param_1[1]) {
iVar3 = 1;
}
else if (param_1[1] < *param_1) {
iVar2 = 1;
}
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
}
return iVar3 + iVar2 != 2;
}
|
886 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
}
|
#include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9, 9};
assert(func0(list1, 4) == true);
assert(func0(list2, 4) == true);
assert(func0(list3, 4) == false);
assert(func0(list4, 4) == true);
assert(func0(list5, 4) == true);
assert(func0(list6, 6) == false);
assert(func0(list7, 6) == true);
assert(func0(list8, 4) == true);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1300 <func0+0x50>
lea -0x2(%rsi),%eax
xor %edx,%edx
mov $0x1,%ecx
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
movss 0x4(%rdi),%xmm0
movss (%rdi),%xmm1
ucomiss %xmm1,%xmm0
cmova %ecx,%eax
ucomiss %xmm0,%xmm1
cmova %ecx,%edx
add $0x4,%rdi
cmp %rsi,%rdi
jne 12d0 <func0+0x20>
add %edx,%eax
cmp $0x2,%eax
setne %al
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
cmp esi, 1
jle short loc_1440
lea edx, [rsi-2]
movss xmm0, dword ptr [rdi]
lea rax, [rdi+4]
xor esi, esi
lea rcx, [rdi+rdx*4+8]
xor edx, edx
mov edi, 1
jmp short loc_1417
loc_1408:
ucomiss xmm1, xmm0
cmova edx, edi
add rax, 4
cmp rax, rcx
jz short loc_1431
loc_1417:
movaps xmm1, xmm0
movss xmm0, dword ptr [rax]
comiss xmm0, xmm1
jbe short loc_1408
add rax, 4
mov esi, 1
cmp rax, rcx
jnz short loc_1417
loc_1431:
add edx, esi
cmp edx, 2
setnz al
retn
loc_1440:
mov eax, 1
retn
|
char func0(float *a1, int a2)
{
long long v2; // rdx
float v3; // xmm0_4
float *v4; // rax
int v5; // esi
long long v6; // rcx
int v7; // edx
float v8; // xmm1_4
if ( a2 <= 1 )
return 1;
v2 = (unsigned int)(a2 - 2);
v3 = *a1;
v4 = a1 + 1;
v5 = 0;
v6 = (long long)&a1[v2 + 2];
v7 = 0;
do
{
while ( 1 )
{
v8 = v3;
v3 = *v4;
if ( *v4 <= v8 )
break;
++v4;
v5 = 1;
if ( v4 == (float *)v6 )
return v5 + v7 != 2;
}
if ( v8 > v3 )
v7 = 1;
++v4;
}
while ( v4 != (float *)v6 );
return v5 + v7 != 2;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101440
LEA EDX,[RSI + -0x2]
MOVSS XMM0,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
XOR ESI,ESI
LEA RCX,[RDI + RDX*0x4 + 0x8]
XOR EDX,EDX
MOV EDI,0x1
JMP 0x00101417
LAB_00101408:
UCOMISS XMM1,XMM0
CMOVA EDX,EDI
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101431
LAB_00101417:
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [RAX]
COMISS XMM0,XMM1
JBE 0x00101408
ADD RAX,0x4
MOV ESI,0x1
CMP RAX,RCX
JNZ 0x00101417
LAB_00101431:
ADD EDX,ESI
CMP EDX,0x2
SETNZ AL
RET
LAB_00101440:
MOV EAX,0x1
RET
|
int8 func0(float *param_1,int param_2)
{
float fVar1;
float *pfVar2;
float *pfVar3;
int iVar4;
int iVar5;
float fVar6;
if (param_2 < 2) {
return 1;
}
iVar5 = 0;
iVar4 = 0;
pfVar2 = param_1 + 1;
fVar6 = *param_1;
do {
while (pfVar3 = pfVar2, fVar1 = *pfVar3, fVar6 < fVar1) {
iVar5 = 1;
pfVar2 = pfVar3 + 1;
fVar6 = fVar1;
if (pfVar3 + 1 == param_1 + (ulong)(param_2 - 2) + 2) goto LAB_00101431;
}
if (fVar1 < fVar6) {
iVar4 = 1;
}
pfVar2 = pfVar3 + 1;
fVar6 = fVar1;
} while (pfVar3 + 1 != param_1 + (ulong)(param_2 - 2) + 2);
LAB_00101431:
return CONCAT71((int7)((ulong)(pfVar3 + 1) >> 8),iVar4 + iVar5 != 2);
}
|
887 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
}
|
#include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9, 9};
assert(func0(list1, 4) == true);
assert(func0(list2, 4) == true);
assert(func0(list3, 4) == false);
assert(func0(list4, 4) == true);
assert(func0(list5, 4) == true);
assert(func0(list6, 6) == false);
assert(func0(list7, 6) == true);
assert(func0(list8, 4) == true);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1320 <func0+0xa0>
cmp $0x3,%esi
jle 1326 <func0+0xa6>
lea -0x4(%rsi),%eax
movss (%rdi),%xmm0
mov $0x3,%r8d
xor %ecx,%ecx
shr %eax
xor %edx,%edx
mov $0x1,%r9d
lea 0x5(%rax,%rax,1),%r10
movss -0x8(%rdi,%r8,4),%xmm1
movslq %r8d,%rax
ucomiss %xmm0,%xmm1
cmova %r9d,%edx
ucomiss %xmm1,%xmm0
movss -0x4(%rdi,%r8,4),%xmm0
cmova %r9d,%ecx
ucomiss %xmm1,%xmm0
cmova %r9d,%edx
ucomiss %xmm0,%xmm1
cmova %r9d,%ecx
add $0x2,%r8
cmp %r10,%r8
jne 12b4 <func0+0x34>
mov $0x1,%r8d
movss (%rdi,%rax,4),%xmm0
movss -0x4(%rdi,%rax,4),%xmm1
ucomiss %xmm1,%xmm0
cmova %r8d,%edx
ucomiss %xmm0,%xmm1
cmova %r8d,%ecx
add $0x1,%rax
cmp %eax,%esi
jg 12f0 <func0+0x70>
add %ecx,%edx
cmp $0x2,%edx
setne %al
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
mov $0x1,%eax
xor %ecx,%ecx
xor %edx,%edx
jmp 12ea <func0+0x6a>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
cmp esi, 1
jle loc_1620
lea eax, [rsi-2]
lea r11d, [rsi-1]
cmp eax, 2
jbe loc_1626
mov edx, r11d
pxor xmm3, xmm3
movdqa xmm5, cs:xmmword_2080
mov rax, rdi
shr edx, 2
movdqa xmm4, xmm3
shl rdx, 4
add rdx, rdi
nop dword ptr [rax]
loc_1340:
movups xmm6, xmmword ptr [rax+4]
movups xmm0, xmmword ptr [rax]
add rax, 10h
movups xmm7, xmmword ptr [rax-10h]
cmpltps xmm0, xmm6
movaps xmm2, xmm6
cmpltps xmm2, xmm7
movdqa xmm1, xmm0
pandn xmm1, xmm2
movdqa xmm2, xmm5
pand xmm2, xmm1
pandn xmm1, xmm3
movdqa xmm3, xmm1
movdqa xmm1, xmm5
pand xmm1, xmm0
pandn xmm0, xmm4
por xmm3, xmm2
movdqa xmm4, xmm0
por xmm4, xmm1
cmp rdx, rax
jnz short loc_1340
movdqa xmm1, xmm4
mov ecx, r11d
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
movdqa xmm0, xmm1
add ecx, 1
pcmpgtd xmm0, xmm4
pand xmm1, xmm0
pandn xmm0, xmm4
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
movdqa xmm1, xmm3
psrldq xmm1, 8
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm3
pand xmm1, xmm0
pandn xmm0, xmm3
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd edx, xmm1
test r11b, 3
jz loc_1588
loc_141E:
movsxd r9, ecx
lea r10d, [rcx+1]
push rbx
lea r8, ds:0[r9*4]
lea rbx, [rdi+r8]
cmp r11d, r10d
jle short loc_148E
cmp esi, ecx
jle short loc_148E
movss xmm1, dword ptr [rbx-4]
movss xmm0, dword ptr [rbx]
comiss xmm0, xmm1
ja loc_1510
ucomiss xmm1, xmm0
movss xmm1, dword ptr [rdi+r8+4]
mov r9d, 1
cmova edx, r9d
comiss xmm1, xmm0
ja loc_1525
loc_146A:
ucomiss xmm0, xmm1
mov r9d, 1
cmova edx, r9d
lea r9d, [rcx+3]
cmp r11d, r9d
jg loc_1537
loc_1484:
add ecx, 2
movsxd r9, ecx
lea r10d, [rcx+1]
loc_148E:
lea r8, ds:0[r9*4]
movss xmm0, dword ptr [rdi+r9*4]
movss xmm1, dword ptr [rdi+r8-4]
comiss xmm0, xmm1
ja loc_1598
ucomiss xmm1, xmm0
mov r9d, 1
cmova edx, r9d
loc_14B9:
cmp esi, r10d
jle short loc_1504
movss xmm1, dword ptr [rdi+r8+4]
comiss xmm1, xmm0
ja loc_1600
ucomiss xmm0, xmm1
mov r9d, 1
cmova edx, r9d
loc_14DB:
add ecx, 2
cmp esi, ecx
jle short loc_1504
movss xmm0, dword ptr [rdi+r8+8]
movss xmm1, dword ptr [rdi+r8+4]
comiss xmm0, xmm1
ja loc_1610
ucomiss xmm1, xmm0
mov ecx, 1
cmova edx, ecx
loc_1504:
add eax, edx
pop rbx
cmp eax, 2
setnz al
retn
loc_1510:
movss xmm1, dword ptr [rdi+r8+4]
mov eax, 1
comiss xmm1, xmm0
jbe loc_146A
loc_1525:
lea r9d, [rcx+3]
mov eax, 1
cmp r11d, r9d
jle loc_1484
loc_1537:
movss xmm0, dword ptr [rdi+r8+8]
comiss xmm0, xmm1
ja short loc_15A8
ucomiss xmm1, xmm0
movss xmm1, dword ptr [rdi+r8+0Ch]
mov r9d, 1
cmova edx, r9d
comiss xmm1, xmm0
ja short loc_15B9
loc_155C:
ucomiss xmm0, xmm1
mov r9d, 1
cmova edx, r9d
lea r9d, [rcx+5]
cmp r11d, r9d
jg short loc_15C7
loc_1572:
add ecx, 4
movsxd r9, ecx
lea r10d, [rcx+1]
jmp loc_148E
loc_1588:
add eax, edx
cmp eax, 2
setnz al
retn
loc_1598:
mov eax, 1
jmp loc_14B9
loc_15A8:
movss xmm1, dword ptr [rdi+r8+0Ch]
mov eax, 1
comiss xmm1, xmm0
jbe short loc_155C
loc_15B9:
lea r9d, [rcx+5]
mov eax, 1
cmp r11d, r9d
jle short loc_1572
loc_15C7:
movss xmm0, dword ptr [rdi+r8+10h]
comiss xmm0, xmm1
jbe short loc_1643
mov eax, 1
loc_15D8:
movss xmm1, dword ptr [rdi+r8+14h]
comiss xmm1, xmm0
jbe short loc_1634
mov eax, 1
loc_15E9:
add ecx, 6
movsxd r9, ecx
lea r10d, [rcx+1]
jmp loc_148E
loc_1600:
mov eax, 1
jmp loc_14DB
loc_1610:
mov eax, 1
pop rbx
add eax, edx
cmp eax, 2
setnz al
retn
loc_1620:
mov eax, 1
retn
loc_1626:
mov ecx, 1
xor edx, edx
xor eax, eax
jmp loc_141E
loc_1634:
ucomiss xmm0, xmm1
mov r8d, 1
cmova edx, r8d
jmp short loc_15E9
loc_1643:
ucomiss xmm1, xmm0
mov r9d, 1
cmova edx, r9d
jmp short loc_15D8
|
char func0(__m128 *a1, int a2)
{
int v2; // r11d
__m128i v3; // xmm3
__m128i si128; // xmm5
__m128 *v5; // rax
__m128i v6; // xmm4
__m128 v7; // xmm6
__m128 v8; // xmm0
__m128i v9; // xmm0
__m128i v10; // xmm1
__m128i v11; // xmm1
signed int v12; // ecx
__m128i v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm2
__m128i v16; // xmm1
int v17; // eax
__m128i v18; // xmm1
__m128i v19; // xmm0
__m128i v20; // xmm0
__m128i v21; // xmm2
__m128i v22; // xmm1
int v23; // edx
long long v24; // r9
int v25; // r10d
long long v26; // r8
float *v27; // rbx
float v28; // xmm1_4
float v29; // xmm0_4
bool v30; // cc
float v31; // xmm1_4
long long v32; // r8
float v33; // xmm0_4
float v34; // xmm1_4
float v35; // xmm1_4
float v36; // xmm0_4
float v37; // xmm1_4
float v39; // xmm0_4
float v40; // xmm1_4
float v41; // xmm0_4
float v42; // xmm1_4
if ( a2 <= 1 )
return 1;
v2 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v12 = 1;
v23 = 0;
v17 = 0;
}
else
{
v3 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2080);
v5 = a1;
v6 = 0LL;
do
{
v7 = *(__m128 *)((char *)v5 + 4);
v8 = *v5++;
v9 = (__m128i)_mm_cmplt_ps(v8, v7);
v10 = _mm_andnot_si128(v9, (__m128i)_mm_cmplt_ps(v7, v5[-1]));
v3 = _mm_or_si128(_mm_andnot_si128(v10, v3), _mm_and_si128(si128, v10));
v6 = _mm_or_si128(_mm_andnot_si128(v9, v6), _mm_and_si128(si128, v9));
}
while ( &a1[(unsigned int)v2 >> 2] != v5 );
v11 = _mm_srli_si128(v6, 8);
v12 = (v2 & 0xFFFFFFFC) + 1;
v13 = _mm_cmpgt_epi32(v11, v6);
v14 = _mm_or_si128(_mm_andnot_si128(v13, v6), _mm_and_si128(v11, v13));
v15 = _mm_srli_si128(v14, 4);
v16 = _mm_cmpgt_epi32(v15, v14);
v17 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v16, v14), _mm_and_si128(v15, v16)));
v18 = _mm_srli_si128(v3, 8);
v19 = _mm_cmpgt_epi32(v18, v3);
v20 = _mm_or_si128(_mm_andnot_si128(v19, v3), _mm_and_si128(v18, v19));
v21 = _mm_srli_si128(v20, 4);
v22 = _mm_cmpgt_epi32(v21, v20);
v23 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v22, v20), _mm_and_si128(v21, v22)));
if ( (v2 & 3) == 0 )
return v23 + v17 != 2;
}
v24 = v12;
v25 = v12 + 1;
v26 = v12;
v27 = &a1->m128_f32[v26];
if ( v2 > v12 + 1 && a2 > v12 )
{
v28 = *(v27 - 1);
v29 = *v27;
if ( *v27 > v28 )
{
v31 = a1->m128_f32[v26 + 1];
v17 = 1;
if ( v31 <= v29 )
goto LABEL_12;
}
else
{
v30 = v28 == v29;
v31 = a1->m128_f32[v26 + 1];
if ( !v30 )
v23 = 1;
if ( v31 <= v29 )
{
LABEL_12:
if ( v29 > v31 )
v23 = 1;
if ( v2 <= v12 + 3 )
goto LABEL_15;
goto LABEL_30;
}
}
v17 = 1;
if ( v2 <= v12 + 3 )
{
LABEL_15:
v12 += 2;
v24 = v12;
v25 = v12 + 1;
goto LABEL_16;
}
LABEL_30:
v39 = a1->m128_f32[v26 + 2];
if ( v39 > v31 )
{
v40 = a1->m128_f32[v26 + 3];
v17 = 1;
if ( v40 <= v39 )
goto LABEL_34;
}
else
{
v30 = v31 == v39;
v40 = a1->m128_f32[v26 + 3];
if ( !v30 )
v23 = 1;
if ( v40 <= v39 )
{
LABEL_34:
if ( v39 > v40 )
v23 = 1;
if ( v2 <= v12 + 5 )
goto LABEL_37;
goto LABEL_42;
}
}
v17 = 1;
if ( v2 <= v12 + 5 )
{
LABEL_37:
v12 += 4;
v24 = v12;
v25 = v12 + 1;
goto LABEL_16;
}
LABEL_42:
v41 = a1[1].m128_f32[v26];
if ( v41 <= v40 )
{
if ( v40 > v41 )
v23 = 1;
}
else
{
v17 = 1;
}
v42 = a1[1].m128_f32[v26 + 1];
if ( v42 <= v41 )
{
if ( v41 > v42 )
v23 = 1;
}
else
{
v17 = 1;
}
v12 += 6;
v24 = v12;
v25 = v12 + 1;
}
LABEL_16:
v32 = v24;
v33 = a1->m128_f32[v24];
v34 = a1->m128_f32[v24 - 1];
if ( v33 > v34 )
{
v17 = 1;
}
else if ( v34 > v33 )
{
v23 = 1;
}
if ( a2 <= v25 )
return v23 + v17 != 2;
v35 = a1->m128_f32[v32 + 1];
if ( v35 > v33 )
{
v17 = 1;
}
else if ( v33 > v35 )
{
v23 = 1;
}
if ( a2 <= v12 + 2 )
return v23 + v17 != 2;
v36 = a1->m128_f32[v32 + 2];
v37 = a1->m128_f32[v32 + 1];
if ( v36 <= v37 )
{
if ( v37 > v36 )
v23 = 1;
return v23 + v17 != 2;
}
return v23 != 1;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101620
LEA EAX,[RSI + -0x2]
LEA R11D,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101626
MOV EDX,R11D
PXOR XMM3,XMM3
MOVDQA XMM5,xmmword ptr [0x00102080]
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM4,XMM3
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101340:
MOVUPS XMM6,xmmword ptr [RAX + 0x4]
MOVUPS XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVUPS XMM7,xmmword ptr [RAX + -0x10]
CMPLTPS XMM0,XMM6
MOVAPS XMM2,XMM6
CMPLTPS XMM2,XMM7
MOVDQA XMM1,XMM0
PANDN XMM1,XMM2
MOVDQA XMM2,XMM5
PAND XMM2,XMM1
PANDN XMM1,XMM3
MOVDQA XMM3,XMM1
MOVDQA XMM1,XMM5
PAND XMM1,XMM0
PANDN XMM0,XMM4
POR XMM3,XMM2
MOVDQA XMM4,XMM0
POR XMM4,XMM1
CMP RDX,RAX
JNZ 0x00101340
MOVDQA XMM1,XMM4
MOV ECX,R11D
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
MOVDQA XMM0,XMM1
ADD ECX,0x1
PCMPGTD XMM0,XMM4
PAND XMM1,XMM0
PANDN XMM0,XMM4
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
MOVDQA XMM1,XMM3
PSRLDQ XMM1,0x8
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM3
PAND XMM1,XMM0
PANDN XMM0,XMM3
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EDX,XMM1
TEST R11B,0x3
JZ 0x00101588
LAB_0010141e:
MOVSXD R9,ECX
LEA R10D,[RCX + 0x1]
PUSH RBX
LEA R8,[R9*0x4]
LEA RBX,[RDI + R8*0x1]
CMP R11D,R10D
JLE 0x0010148e
CMP ESI,ECX
JLE 0x0010148e
MOVSS XMM1,dword ptr [RBX + -0x4]
MOVSS XMM0,dword ptr [RBX]
COMISS XMM0,XMM1
JA 0x00101510
UCOMISS XMM1,XMM0
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0x4]
MOV R9D,0x1
CMOVA EDX,R9D
COMISS XMM1,XMM0
JA 0x00101525
LAB_0010146a:
UCOMISS XMM0,XMM1
MOV R9D,0x1
CMOVA EDX,R9D
LEA R9D,[RCX + 0x3]
CMP R11D,R9D
JG 0x00101537
LAB_00101484:
ADD ECX,0x2
MOVSXD R9,ECX
LEA R10D,[RCX + 0x1]
LAB_0010148e:
LEA R8,[R9*0x4]
MOVSS XMM0,dword ptr [RDI + R9*0x4]
MOVSS XMM1,dword ptr [RDI + R8*0x1 + -0x4]
COMISS XMM0,XMM1
JA 0x00101598
UCOMISS XMM1,XMM0
MOV R9D,0x1
CMOVA EDX,R9D
LAB_001014b9:
CMP ESI,R10D
JLE 0x00101504
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0x4]
COMISS XMM1,XMM0
JA 0x00101600
UCOMISS XMM0,XMM1
MOV R9D,0x1
CMOVA EDX,R9D
LAB_001014db:
ADD ECX,0x2
CMP ESI,ECX
JLE 0x00101504
MOVSS XMM0,dword ptr [RDI + R8*0x1 + 0x8]
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0x4]
COMISS XMM0,XMM1
JA 0x00101610
UCOMISS XMM1,XMM0
MOV ECX,0x1
CMOVA EDX,ECX
LAB_00101504:
ADD EAX,EDX
POP RBX
CMP EAX,0x2
SETNZ AL
RET
LAB_00101510:
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0x4]
MOV EAX,0x1
COMISS XMM1,XMM0
JBE 0x0010146a
LAB_00101525:
LEA R9D,[RCX + 0x3]
MOV EAX,0x1
CMP R11D,R9D
JLE 0x00101484
LAB_00101537:
MOVSS XMM0,dword ptr [RDI + R8*0x1 + 0x8]
COMISS XMM0,XMM1
JA 0x001015a8
UCOMISS XMM1,XMM0
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0xc]
MOV R9D,0x1
CMOVA EDX,R9D
COMISS XMM1,XMM0
JA 0x001015b9
LAB_0010155c:
UCOMISS XMM0,XMM1
MOV R9D,0x1
CMOVA EDX,R9D
LEA R9D,[RCX + 0x5]
CMP R11D,R9D
JG 0x001015c7
LAB_00101572:
ADD ECX,0x4
MOVSXD R9,ECX
LEA R10D,[RCX + 0x1]
JMP 0x0010148e
LAB_00101588:
ADD EAX,EDX
CMP EAX,0x2
SETNZ AL
RET
LAB_00101598:
MOV EAX,0x1
JMP 0x001014b9
LAB_001015a8:
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0xc]
MOV EAX,0x1
COMISS XMM1,XMM0
JBE 0x0010155c
LAB_001015b9:
LEA R9D,[RCX + 0x5]
MOV EAX,0x1
CMP R11D,R9D
JLE 0x00101572
LAB_001015c7:
MOVSS XMM0,dword ptr [RDI + R8*0x1 + 0x10]
COMISS XMM0,XMM1
JBE 0x00101643
MOV EAX,0x1
LAB_001015d8:
MOVSS XMM1,dword ptr [RDI + R8*0x1 + 0x14]
COMISS XMM1,XMM0
JBE 0x00101634
MOV EAX,0x1
LAB_001015e9:
ADD ECX,0x6
MOVSXD R9,ECX
LEA R10D,[RCX + 0x1]
JMP 0x0010148e
LAB_00101600:
MOV EAX,0x1
JMP 0x001014db
LAB_00101610:
MOV EAX,0x1
POP RBX
ADD EAX,EDX
CMP EAX,0x2
SETNZ AL
RET
LAB_00101620:
MOV EAX,0x1
RET
LAB_00101626:
MOV ECX,0x1
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010141e
LAB_00101634:
UCOMISS XMM0,XMM1
MOV R8D,0x1
CMOVA EDX,R8D
JMP 0x001015e9
LAB_00101643:
UCOMISS XMM1,XMM0
MOV R9D,0x1
CMOVA EDX,R9D
JMP 0x001015d8
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(float *param_1,int param_2)
{
float fVar1;
uint uVar2;
float *pfVar3;
float *pfVar4;
int iVar5;
int iVar6;
uint uVar7;
long lVar8;
int iVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
float fVar18;
float fVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uint uVar26;
if (param_2 < 2) {
return 1;
}
uVar10 = param_2 - 1;
if (param_2 - 2U < 3) {
iVar5 = 1;
uVar7 = 0;
uVar2 = 0;
}
else {
uVar7 = 0;
uVar23 = 0;
uVar17 = 0;
uVar24 = 0;
uVar2 = 0;
uVar25 = 0;
uVar16 = 0;
uVar26 = 0;
pfVar3 = param_1;
do {
pfVar4 = pfVar3 + 4;
uVar11 = -(uint)(*pfVar3 < pfVar3[1]);
uVar12 = -(uint)(pfVar3[1] < pfVar3[2]);
uVar13 = -(uint)(pfVar3[2] < pfVar3[3]);
uVar14 = -(uint)(pfVar3[3] < pfVar3[4]);
uVar15 = ~uVar11 & -(uint)(pfVar3[1] < *pfVar3);
uVar20 = ~uVar12 & -(uint)(pfVar3[2] < pfVar3[1]);
uVar21 = ~uVar13 & -(uint)(pfVar3[3] < pfVar3[2]);
uVar22 = ~uVar14 & -(uint)(pfVar3[4] < pfVar3[3]);
uVar7 = ~uVar15 & uVar7 | _DAT_00102080 & uVar15;
uVar23 = ~uVar20 & uVar23 | _UNK_00102084 & uVar20;
uVar17 = ~uVar21 & uVar17 | _UNK_00102088 & uVar21;
uVar24 = ~uVar22 & uVar24 | _UNK_0010208c & uVar22;
uVar2 = ~uVar11 & uVar2 | _DAT_00102080 & uVar11;
uVar25 = ~uVar12 & uVar25 | _UNK_00102084 & uVar12;
uVar16 = ~uVar13 & uVar16 | _UNK_00102088 & uVar13;
uVar26 = ~uVar14 & uVar26 | _UNK_0010208c & uVar14;
pfVar3 = pfVar4;
} while (param_1 + (ulong)(uVar10 >> 2) * 4 != pfVar4);
iVar5 = (uVar10 & 0xfffffffc) + 1;
uVar2 = ~-(uint)((int)uVar2 < (int)uVar16) & uVar2 | uVar16 & -(uint)((int)uVar2 < (int)uVar16);
uVar25 = ~-(uint)((int)uVar25 < (int)uVar26) & uVar25 |
uVar26 & -(uint)((int)uVar25 < (int)uVar26);
uVar16 = -(uint)((int)uVar2 < (int)uVar25);
uVar2 = ~uVar16 & uVar2 | uVar25 & uVar16;
uVar7 = ~-(uint)((int)uVar7 < (int)uVar17) & uVar7 | uVar17 & -(uint)((int)uVar7 < (int)uVar17);
uVar23 = ~-(uint)((int)uVar23 < (int)uVar24) & uVar23 |
uVar24 & -(uint)((int)uVar23 < (int)uVar24);
uVar17 = -(uint)((int)uVar7 < (int)uVar23);
uVar7 = ~uVar17 & uVar7 | uVar23 & uVar17;
if ((uVar10 & 3) == 0) {
return CONCAT31((int3)(uVar2 + uVar7 >> 8),uVar2 + uVar7 != 2);
}
}
lVar8 = (long)iVar5;
iVar9 = iVar5 + 1;
iVar6 = iVar5;
if (((int)uVar10 <= iVar9) || (param_2 <= iVar5)) goto LAB_0010148e;
fVar1 = (param_1 + lVar8)[-1];
fVar19 = param_1[lVar8];
if (fVar1 < fVar19) {
fVar18 = param_1[lVar8 + 1];
uVar2 = 1;
if (fVar19 < fVar18) goto LAB_00101525;
LAB_0010146a:
if (fVar18 < fVar19) {
uVar7 = 1;
}
}
else {
fVar18 = param_1[lVar8 + 1];
if (fVar19 < fVar1) {
uVar7 = 1;
}
if (fVar18 <= fVar19) goto LAB_0010146a;
LAB_00101525:
uVar2 = 1;
}
if ((int)uVar10 <= iVar5 + 3) {
iVar6 = iVar5 + 2;
lVar8 = (long)iVar6;
iVar9 = iVar5 + 3;
goto LAB_0010148e;
}
fVar1 = param_1[lVar8 + 2];
if (fVar18 < fVar1) {
fVar19 = param_1[lVar8 + 3];
uVar2 = 1;
if (fVar1 < fVar19) goto LAB_001015b9;
LAB_0010155c:
if (fVar19 < fVar1) {
uVar7 = 1;
}
}
else {
fVar19 = param_1[lVar8 + 3];
if (fVar1 < fVar18) {
uVar7 = 1;
}
if (fVar19 <= fVar1) goto LAB_0010155c;
LAB_001015b9:
uVar2 = 1;
}
if (iVar5 + 5 < (int)uVar10) {
fVar1 = param_1[lVar8 + 4];
if (fVar1 <= fVar19) {
if (fVar1 < fVar19) {
uVar7 = 1;
}
}
else {
uVar2 = 1;
}
if (param_1[lVar8 + 5] <= fVar1) {
if (param_1[lVar8 + 5] < fVar1) {
uVar7 = 1;
}
}
else {
uVar2 = 1;
}
iVar6 = iVar5 + 6;
lVar8 = (long)iVar6;
iVar9 = iVar5 + 7;
}
else {
iVar6 = iVar5 + 4;
lVar8 = (long)iVar6;
iVar9 = iVar5 + 5;
}
LAB_0010148e:
fVar1 = param_1[lVar8];
if (param_1[lVar8 + -1] < fVar1) {
uVar2 = 1;
}
else if (fVar1 < param_1[lVar8 + -1]) {
uVar7 = 1;
}
if (iVar9 < param_2) {
if (fVar1 < param_1[lVar8 + 1]) {
uVar2 = 1;
}
else if (param_1[lVar8 + 1] < fVar1) {
uVar7 = 1;
}
if (iVar6 + 2 < param_2) {
if (param_1[lVar8 + 1] < param_1[lVar8 + 2]) {
return CONCAT31((int3)(uVar7 + 1 >> 8),uVar7 + 1 != 2);
}
if (param_1[lVar8 + 2] < param_1[lVar8 + 1]) {
uVar7 = 1;
}
}
}
return CONCAT31((int3)(uVar2 + uVar7 >> 8),uVar2 + uVar7 != 2);
}
|
888 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
break;
}
}
if (!exists_in_out) {
for (j = 0; j < size2; j++) {
if (l1[i] == l2[j]) {
out[k++] = l1[i];
break;
}
}
}
}
for (i = 0; i < k - 1; i++) {
for (j = 0; j < k - i - 1; j++) {
if (out[j] > out[j + 1]) {
int temp = out[j];
out[j] = out[j + 1];
out[j + 1] = temp;
}
}
}
*out_size = k;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int l3[] = {5, 3, 2, 8};
int l4[] = {3, 2};
int expected2[] = {2, 3};
int *result2 = func0(l3, 4, l4, 2, &size);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int l5[] = {4, 3, 2, 8};
int l6[] = {3, 2, 4};
int expected3[] = {2, 3, 4};
int *result3 = func0(l5, 4, l6, 3, &size);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
int l7[] = {4, 3, 2, 8};
int l8[] = {};
int *result4 = func0(l7, 4, l8, 0, &size);
assert(size == 0); // Since l8 is empty, result4 should be empty as well
free(result4);
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 %ecx,-0x30(%rbp)
mov %r8,-0x40(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 12c8 <func0+0x11f>
movl $0x0,-0x10(%rbp)
movl $0x0,-0x14(%rbp)
jmp 123c <func0+0x93>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 1238 <func0+0x8f>
movl $0x1,-0x10(%rbp)
jmp 1244 <func0+0x9b>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11ff <func0+0x56>
cmpl $0x0,-0x10(%rbp)
jne 12c4 <func0+0x11b>
movl $0x0,-0x18(%rbp)
jmp 12bc <func0+0x113>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 12b8 <func0+0x10f>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x20(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x20(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
jmp 12c4 <func0+0x11b>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1253 <func0+0xaa>
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11ef <func0+0x46>
movl $0x0,-0x1c(%rbp)
jmpq 13a1 <func0+0x1f8>
movl $0x0,-0x18(%rbp)
jmpq 138b <func0+0x1e2>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1387 <func0+0x1de>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x20(%rbp),%eax
sub -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x18(%rbp)
jl 12ec <func0+0x143>
addl $0x1,-0x1c(%rbp)
mov -0x20(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1c(%rbp)
jl 12e0 <func0+0x137>
mov -0x40(%rbp),%rax
mov -0x20(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
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_30], ecx
mov [rbp+var_40], r8
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp loc_12C8
loc_11EF:
mov [rbp+var_10], 0
mov [rbp+var_14], 0
jmp short loc_123C
loc_11FF:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_1C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_1238
mov [rbp+var_10], 1
jmp short loc_1244
loc_1238:
add [rbp+var_14], 1
loc_123C:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_20]
jl short loc_11FF
loc_1244:
cmp [rbp+var_10], 0
jnz short loc_12C4
mov [rbp+var_18], 0
jmp short loc_12BC
loc_1253:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_12B8
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_20]
lea edx, [rax+1]
mov [rbp+var_20], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
jmp short loc_12C4
loc_12B8:
add [rbp+var_18], 1
loc_12BC:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_30]
jl short loc_1253
loc_12C4:
add [rbp+var_1C], 1
loc_12C8:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jl loc_11EF
mov [rbp+var_1C], 0
jmp loc_13A1
loc_12E0:
mov [rbp+var_18], 0
jmp loc_138B
loc_12EC:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1387
mov eax, [rbp+var_18]
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_18]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rbp+var_18]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_18]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
loc_1387:
add [rbp+var_18], 1
loc_138B:
mov eax, [rbp+var_20]
sub eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_18], eax
jl loc_12EC
add [rbp+var_1C], 1
loc_13A1:
mov eax, [rbp+var_20]
sub eax, 1
cmp [rbp+var_1C], eax
jl loc_12E0
mov rax, [rbp+var_40]
mov edx, [rbp+var_20]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v5; // eax
int v10; // [rsp+20h] [rbp-20h]
int i; // [rsp+24h] [rbp-1Ch]
int m; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int n; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
int v16; // [rsp+30h] [rbp-10h]
int v17; // [rsp+34h] [rbp-Ch]
_DWORD *v18; // [rsp+38h] [rbp-8h]
v18 = malloc(4LL * a2);
v10 = 0;
for ( i = 0; i < a2; ++i )
{
v16 = 0;
for ( j = 0; j < v10; ++j )
{
if ( v18[j] == *(_DWORD *)(4LL * i + a1) )
{
v16 = 1;
break;
}
}
if ( !v16 )
{
for ( k = 0; k < a4; ++k )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * k + a3) )
{
v5 = v10++;
v18[v5] = *(_DWORD *)(4LL * i + a1);
break;
}
}
}
}
for ( m = 0; m < v10 - 1; ++m )
{
for ( n = 0; n < v10 - m - 1; ++n )
{
if ( v18[n] > v18[n + 1] )
{
v17 = v18[n];
v18[n] = v18[n + 1];
v18[n + 1] = v17;
}
}
}
*a5 = v10;
return v18;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x30],ECX
MOV qword ptr [RBP + -0x40],R8
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001012c8
LAB_001011ef:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010123c
LAB_001011ff:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101238
MOV dword ptr [RBP + -0x10],0x1
JMP 0x00101244
LAB_00101238:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010123c:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011ff
LAB_00101244:
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x001012c4
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001012bc
LAB_00101253:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001012b8
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x20]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x20],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
JMP 0x001012c4
LAB_001012b8:
ADD dword ptr [RBP + -0x18],0x1
LAB_001012bc:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101253
LAB_001012c4:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012c8:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011ef
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001013a1
LAB_001012e0:
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010138b
LAB_001012ec:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101387
MOV EAX,dword ptr [RBP + -0x18]
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 + -0x18]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RDX],EAX
LAB_00101387:
ADD dword ptr [RBP + -0x18],0x1
LAB_0010138b:
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x18],EAX
JL 0x001012ec
ADD dword ptr [RBP + -0x1c],0x1
LAB_001013a1:
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JL 0x001012e0
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
int4 uVar1;
bool bVar2;
void *pvVar3;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
pvVar3 = malloc((long)param_2 << 2);
local_28 = 0;
local_24 = 0;
do {
if (param_2 <= local_24) {
for (local_24 = 0; local_24 < local_28 + -1; local_24 = local_24 + 1) {
for (local_20 = 0; local_20 < (local_28 - local_24) + -1; local_20 = local_20 + 1) {
if (*(int *)((long)pvVar3 + ((long)local_20 + 1) * 4) <
*(int *)((long)pvVar3 + (long)local_20 * 4)) {
uVar1 = *(int4 *)((long)pvVar3 + (long)local_20 * 4);
*(int4 *)((long)pvVar3 + (long)local_20 * 4) =
*(int4 *)((long)pvVar3 + ((long)local_20 + 1) * 4);
*(int4 *)(((long)local_20 + 1) * 4 + (long)pvVar3) = uVar1;
}
}
}
*param_5 = local_28;
return pvVar3;
}
bVar2 = false;
for (local_1c = 0; local_1c < local_28; local_1c = local_1c + 1) {
if (*(int *)((long)pvVar3 + (long)local_1c * 4) == *(int *)(param_1 + (long)local_24 * 4)) {
bVar2 = true;
break;
}
}
if (!bVar2) {
for (local_20 = 0; local_20 < param_4; local_20 = local_20 + 1) {
if (*(int *)(param_1 + (long)local_24 * 4) == *(int *)(param_3 + (long)local_20 * 4)) {
*(int4 *)((long)local_28 * 4 + (long)pvVar3) =
*(int4 *)((long)local_24 * 4 + param_1);
local_28 = local_28 + 1;
break;
}
}
}
local_24 = local_24 + 1;
} while( true );
}
|
889 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
break;
}
}
if (!exists_in_out) {
for (j = 0; j < size2; j++) {
if (l1[i] == l2[j]) {
out[k++] = l1[i];
break;
}
}
}
}
for (i = 0; i < k - 1; i++) {
for (j = 0; j < k - i - 1; j++) {
if (out[j] > out[j + 1]) {
int temp = out[j];
out[j] = out[j + 1];
out[j + 1] = temp;
}
}
}
*out_size = k;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int l3[] = {5, 3, 2, 8};
int l4[] = {3, 2};
int expected2[] = {2, 3};
int *result2 = func0(l3, 4, l4, 2, &size);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int l5[] = {4, 3, 2, 8};
int l6[] = {3, 2, 4};
int expected3[] = {2, 3, 4};
int *result3 = func0(l5, 4, l6, 3, &size);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
int l7[] = {4, 3, 2, 8};
int l8[] = {};
int *result4 = func0(l7, 4, l8, 0, &size);
assert(size == 0); // Since l8 is empty, result4 should be empty as well
free(result4);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %esi,%r12d
mov %rdx,%r13
mov %ecx,%ebp
mov %r8,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 1286 <func0+0xdd>
mov %r14,%rdi
lea -0x1(%r12),%edx
lea 0x4(%r14,%rdx,4),%r10
mov %r13,%r11
lea -0x1(%rbp),%edx
lea 0x4(%r13,%rdx,4),%r8
mov $0x0,%r9d
lea 0x4(%rax),%r12
jmp 120f <func0+0x66>
movslq %r9d,%rdx
mov %ecx,(%rax,%rdx,4)
lea 0x1(%r9),%r9d
add $0x4,%rdi
cmp %r10,%rdi
je 1246 <func0+0x9d>
test %r9d,%r9d
jle 122e <func0+0x85>
mov (%rdi),%ecx
mov %rax,%rdx
lea -0x1(%r9),%esi
lea (%r12,%rsi,4),%rsi
cmp %ecx,(%rdx)
je 1206 <func0+0x5d>
add $0x4,%rdx
cmp %rsi,%rdx
jne 1221 <func0+0x78>
test %ebp,%ebp
jle 1206 <func0+0x5d>
mov (%rdi),%ecx
mov %r11,%rdx
cmp (%rdx),%ecx
je 11fc <func0+0x53>
add $0x4,%rdx
cmp %r8,%rdx
jne 1237 <func0+0x8e>
jmp 1206 <func0+0x5d>
lea -0x1(%r9),%r8d
test %r8d,%r8d
jle 128c <func0+0xe3>
lea 0x4(%rax),%r10
jmp 1274 <func0+0xcb>
add $0x4,%rdx
cmp %rdx,%rdi
je 126e <func0+0xc5>
mov (%rdx),%ecx
mov 0x4(%rdx),%esi
cmp %esi,%ecx
jle 1255 <func0+0xac>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
jmp 1255 <func0+0xac>
sub $0x1,%r8d
je 128c <func0+0xe3>
test %r8d,%r8d
jle 126e <func0+0xc5>
mov %rax,%rdx
lea -0x1(%r8),%ecx
lea (%r10,%rcx,4),%rdi
jmp 125e <func0+0xb5>
mov $0x0,%r9d
mov %r9d,(%rbx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r15, rdi
mov r14d, esi
mov r12, rdx
mov ebp, ecx
mov rbx, r8
movsxd r13, esi
shl r13, 2
mov rdi, r13; size
call _malloc
mov rdi, rax
test r14d, r14d
jle loc_1287
mov rsi, r15
add r13, r15
movsxd rax, ebp
lea r8, [r12+rax*4]
mov r9d, 0
jmp short loc_120C
loc_11F9:
movsxd rax, r9d
mov [rdi+rax*4], edx
lea r9d, [r9+1]
loc_1203:
add rsi, 4
cmp rsi, r13
jz short loc_1242
loc_120C:
test r9d, r9d
jle short loc_122A
mov edx, [rsi]
mov rax, rdi
movsxd rcx, r9d
lea rcx, [rdi+rcx*4]
loc_121D:
cmp [rax], edx
jz short loc_1203
add rax, 4
cmp rax, rcx
jnz short loc_121D
loc_122A:
test ebp, ebp
jle short loc_1203
mov edx, [rsi]
mov rax, r12
loc_1233:
cmp edx, [rax]
jz short loc_11F9
add rax, 4
cmp rax, r8
jnz short loc_1233
jmp short loc_1203
loc_1242:
cmp r9d, 1
jle short loc_128D
mov r8d, r9d
lea r10, [rdi+4]
jmp short loc_1274
loc_1251:
add rax, 4
cmp rsi, rax
jz short loc_126A
loc_125A:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_1251
mov [rax], ecx
mov [rax+4], edx
jmp short loc_1251
loc_126A:
sub r8d, 1
cmp r8d, 1
jz short loc_128D
loc_1274:
cmp r8d, 1
jle short loc_12A2
mov rax, rdi
lea edx, [r8-2]
lea rsi, [r10+rdx*4]
jmp short loc_125A
loc_1287:
mov r9d, 0
loc_128D:
mov [rbx], r9d
mov rax, rdi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12A2:
sub r8d, 1
jmp short loc_1274
|
_DWORD * func0(int *a1, int a2, _DWORD *a3, int a4, int *a5)
{
size_t v9; // r13
_DWORD *v10; // rdi
int *v11; // rsi
int *v12; // r13
int v13; // r9d
_DWORD *v14; // rax
int v15; // edx
_DWORD *v16; // rax
int i; // r8d
int *v18; // rax
int v19; // edx
int v20; // ecx
v9 = a2;
v10 = malloc(v9 * 4);
if ( a2 <= 0 )
{
v13 = 0;
}
else
{
v11 = a1;
v12 = &a1[v9];
v13 = 0;
do
{
if ( v13 <= 0 )
{
LABEL_9:
if ( a4 > 0 )
{
v15 = *v11;
v16 = a3;
while ( v15 != *v16 )
{
if ( ++v16 == &a3[a4] )
goto LABEL_4;
}
v10[v13++] = v15;
}
}
else
{
v14 = v10;
while ( *v14 != *v11 )
{
if ( ++v14 == &v10[v13] )
goto LABEL_9;
}
}
LABEL_4:
++v11;
}
while ( v11 != v12 );
if ( v13 > 1 )
{
for ( i = v13; i != 1; --i )
{
while ( i <= 1 )
--i;
v18 = v10;
do
{
v19 = *v18;
v20 = v18[1];
if ( *v18 > v20 )
{
*v18 = v20;
v18[1] = v19;
}
++v18;
}
while ( &v10[i - 2 + 1] != v18 );
}
}
}
*a5 = v13;
return v10;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R15,RDI
MOV R14D,ESI
MOV R12,RDX
MOV EBP,ECX
MOV RBX,R8
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010b0
MOV RDI,RAX
TEST R14D,R14D
JLE 0x00101287
MOV RSI,R15
ADD R13,R15
MOVSXD RAX,EBP
LEA R8,[R12 + RAX*0x4]
MOV R9D,0x0
JMP 0x0010120c
LAB_001011f9:
MOVSXD RAX,R9D
MOV dword ptr [RDI + RAX*0x4],EDX
LEA R9D,[R9 + 0x1]
LAB_00101203:
ADD RSI,0x4
CMP RSI,R13
JZ 0x00101242
LAB_0010120c:
TEST R9D,R9D
JLE 0x0010122a
MOV EDX,dword ptr [RSI]
MOV RAX,RDI
MOVSXD RCX,R9D
LEA RCX,[RDI + RCX*0x4]
LAB_0010121d:
CMP dword ptr [RAX],EDX
JZ 0x00101203
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010121d
LAB_0010122a:
TEST EBP,EBP
JLE 0x00101203
MOV EDX,dword ptr [RSI]
MOV RAX,R12
LAB_00101233:
CMP EDX,dword ptr [RAX]
JZ 0x001011f9
ADD RAX,0x4
CMP RAX,R8
JNZ 0x00101233
JMP 0x00101203
LAB_00101242:
CMP R9D,0x1
JLE 0x0010128d
MOV R8D,R9D
LEA R10,[RDI + 0x4]
JMP 0x00101274
LAB_00101251:
ADD RAX,0x4
CMP RSI,RAX
JZ 0x0010126a
LAB_0010125a:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x00101251
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
JMP 0x00101251
LAB_0010126a:
SUB R8D,0x1
CMP R8D,0x1
JZ 0x0010128d
LAB_00101274:
CMP R8D,0x1
JLE 0x001012a2
MOV RAX,RDI
LEA EDX,[R8 + -0x2]
LEA RSI,[R10 + RDX*0x4]
JMP 0x0010125a
LAB_00101287:
MOV R9D,0x0
LAB_0010128d:
MOV dword ptr [RBX],R9D
MOV RAX,RDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012a2:
SUB R8D,0x1
JMP 0x00101274
|
int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
int iVar6;
piVar2 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar4 = param_1 + param_2;
iVar6 = 0;
do {
if (0 < iVar6) {
piVar3 = piVar2;
do {
if (*piVar3 == *param_1) goto LAB_00101203;
piVar3 = piVar3 + 1;
} while (piVar3 != piVar2 + iVar6);
}
if (0 < param_4) {
piVar3 = param_3;
do {
if (*param_1 == *piVar3) {
piVar2[iVar6] = *param_1;
iVar6 = iVar6 + 1;
break;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_3 + param_4);
}
LAB_00101203:
param_1 = param_1 + 1;
} while (param_1 != piVar4);
iVar5 = iVar6;
if (1 < iVar6) {
do {
for (; iVar5 < 2; iVar5 = iVar5 + -1) {
}
piVar4 = piVar2;
do {
iVar1 = *piVar4;
if (piVar4[1] < iVar1) {
*piVar4 = piVar4[1];
piVar4[1] = iVar1;
}
piVar4 = piVar4 + 1;
} while (piVar2 + (ulong)(iVar5 - 2) + 1 != piVar4);
iVar5 = iVar5 + -1;
} while (iVar5 != 1);
}
}
*param_5 = iVar6;
return piVar2;
}
|
890 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
break;
}
}
if (!exists_in_out) {
for (j = 0; j < size2; j++) {
if (l1[i] == l2[j]) {
out[k++] = l1[i];
break;
}
}
}
}
for (i = 0; i < k - 1; i++) {
for (j = 0; j < k - i - 1; j++) {
if (out[j] > out[j + 1]) {
int temp = out[j];
out[j] = out[j + 1];
out[j + 1] = temp;
}
}
}
*out_size = k;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int l3[] = {5, 3, 2, 8};
int l4[] = {3, 2};
int expected2[] = {2, 3};
int *result2 = func0(l3, 4, l4, 2, &size);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int l5[] = {4, 3, 2, 8};
int l6[] = {3, 2, 4};
int expected3[] = {2, 3, 4};
int *result3 = func0(l5, 4, l6, 3, &size);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
int l7[] = {4, 3, 2, 8};
int l8[] = {};
int *result4 = func0(l7, 4, l8, 0, &size);
assert(size == 0); // Since l8 is empty, result4 should be empty as well
free(result4);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %ecx,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %r8,%rbx
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 15b1 <func0+0x111>
lea -0x1(%r13),%edx
mov %r14,%r10
lea 0x4(%rax),%r13
xor %r8d,%r8d
lea 0x4(%r14,%rdx,4),%rcx
lea -0x1(%r12),%edx
lea 0x4(%rbp,%rdx,4),%r11
nopl (%rax)
test %r8d,%r8d
je 1578 <func0+0xd8>
lea -0x1(%r8),%edx
mov (%r10),%edi
mov %rax,%rsi
lea 0x0(%r13,%rdx,4),%r9
jmp 1519 <func0+0x79>
nopw 0x0(%rax,%rax,1)
add $0x4,%rsi
cmp %r9,%rsi
je 1578 <func0+0xd8>
cmp %edi,(%rsi)
jne 1510 <func0+0x70>
add $0x4,%r10
cmp %rcx,%r10
jne 14f0 <func0+0x50>
lea -0x1(%r8),%ecx
test %ecx,%ecx
jle 1567 <func0+0xc7>
lea 0x4(%rax),%r10
nopw 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rax,%rdx
mov %rcx,%r9
lea (%r10,%rcx,4),%rdi
nopl (%rax)
mov (%rdx),%ecx
mov 0x4(%rdx),%esi
cmp %esi,%ecx
jle 1556 <func0+0xb6>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
add $0x4,%rdx
cmp %rdx,%rdi
jne 1548 <func0+0xa8>
mov %r9d,%ecx
test %r9d,%r9d
jne 1538 <func0+0x98>
mov %r8d,(%rbx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
test %r12d,%r12d
jle 151d <func0+0x7d>
mov (%r10),%edi
mov %rbp,%rsi
jmp 1591 <func0+0xf1>
nopl (%rax)
add $0x4,%rsi
cmp %rsi,%r11
je 151d <func0+0x7d>
cmp (%rsi),%edi
jne 1588 <func0+0xe8>
movslq %r8d,%rdx
add $0x4,%r10
add $0x1,%r8d
mov %edi,(%rax,%rdx,4)
cmp %rcx,%r10
jne 14f0 <func0+0x50>
jmpq 1526 <func0+0x86>
xor %r8d,%r8d
mov %r8d,(%rbx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
|
func0:
endbr64
push r15
movsxd r10, esi
push r14
lea r14, ds:0[r10*4]
mov r15, r10
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
mov rbp, r8
push rbx
mov rbx, rdi
mov rdi, r14; size
sub rsp, 8
call _malloc
mov r8, rax
test r15d, r15d
jle loc_1580
movsxd rax, r13d
mov rsi, rbx
lea r10, [rbx+r14]
xor r9d, r9d
lea rdi, [r12+rax*4]
nop dword ptr [rax+00000000h]
loc_1498:
movsxd rax, r9d
lea rcx, [r8+rax*4]
test r9d, r9d
jle loc_1538
loc_14A8:
mov edx, [rsi]
mov rax, r8
jmp short loc_14B9
loc_14B0:
add rax, 4
cmp rax, rcx
jz short loc_1538
loc_14B9:
cmp [rax], edx
jnz short loc_14B0
add rsi, 4
cmp rsi, r10
jnz short loc_14A8
loc_14C6:
cmp r9d, 1
jle short loc_151F
mov edi, r9d
lea r10, [r8+4]
nop dword ptr [rax+rax+00h]
loc_14D8:
cmp edi, 1
jle loc_1578
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r10+rdx*4]
nop dword ptr [rax+rax+00h]
loc_14F0:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd edx, xmm0
movd ecx, xmm1
cmp ecx, edx
jge short loc_150E
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_150E:
add rax, 4
cmp rsi, rax
jnz short loc_14F0
sub edi, 1
cmp edi, 1
jnz short loc_14D8
loc_151F:
mov [rbp+0], r9d
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1538:
test r13d, r13d
jle short loc_1560
mov edx, [rsi]
mov rax, r12
jmp short loc_1551
loc_1548:
add rax, 4
cmp rax, rdi
jz short loc_1560
loc_1551:
cmp edx, [rax]
jnz short loc_1548
movsxd rax, r9d
add r9d, 1
mov [r8+rax*4], edx
loc_1560:
add rsi, 4
cmp rsi, r10
jnz loc_1498
jmp loc_14C6
loc_1578:
sub edi, 1
jmp loc_14D8
loc_1580:
xor r9d, r9d
jmp short loc_151F
|
__m128i * func0(__int32 *a1, int a2, _DWORD *a3, int a4, int *a5)
{
size_t v5; // r14
__m128i *v9; // r8
__int32 *v10; // rsi
__int32 *v11; // r10
int v12; // r9d
__m128i *v13; // rax
int i; // edi
__m128i *v15; // rax
__m128i v16; // xmm0
__int32 v18; // edx
_DWORD *v19; // rax
long long v20; // rax
v5 = a2;
v9 = (__m128i *)malloc(v5 * 4);
if ( a2 <= 0 )
{
v12 = 0;
}
else
{
v10 = a1;
v11 = &a1[v5];
v12 = 0;
while ( v12 <= 0 )
{
LABEL_17:
if ( a4 > 0 )
{
v18 = *v10;
v19 = a3;
while ( v18 != *v19 )
{
if ( ++v19 == &a3[a4] )
goto LABEL_22;
}
v20 = v12++;
v9->m128i_i32[v20] = v18;
}
LABEL_22:
if ( ++v10 == v11 )
goto LABEL_8;
}
do
{
v13 = v9;
while ( v13->m128i_i32[0] != *v10 )
{
v13 = (__m128i *)((char *)v13 + 4);
if ( v13 == (__m128i *)((char *)v9 + 4 * v12) )
goto LABEL_17;
}
++v10;
}
while ( v10 != v11 );
LABEL_8:
if ( v12 > 1 )
{
for ( i = v12; i != 1; --i )
{
while ( i <= 1 )
--i;
v15 = v9;
do
{
v16 = _mm_loadl_epi64(v15);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v16, 229)) < _mm_cvtsi128_si32(v16) )
v15->m128i_i64[0] = _mm_shuffle_epi32(v16, 225).m128i_u64[0];
v15 = (__m128i *)((char *)v15 + 4);
}
while ( (__m128i *)((char *)v9->m128i_i64 + 4 * (unsigned int)(i - 2) + 4) != v15 );
}
}
}
*a5 = v12;
return v9;
}
|
func0:
ENDBR64
PUSH R15
MOVSXD R10,ESI
PUSH R14
LEA R14,[R10*0x4]
MOV R15,R10
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,R8
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R15D,R15D
JLE 0x00101580
MOVSXD RAX,R13D
MOV RSI,RBX
LEA R10,[RBX + R14*0x1]
XOR R9D,R9D
LEA RDI,[R12 + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101498:
MOVSXD RAX,R9D
LEA RCX,[R8 + RAX*0x4]
TEST R9D,R9D
JLE 0x00101538
LAB_001014a8:
MOV EDX,dword ptr [RSI]
MOV RAX,R8
JMP 0x001014b9
LAB_001014b0:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101538
LAB_001014b9:
CMP dword ptr [RAX],EDX
JNZ 0x001014b0
ADD RSI,0x4
CMP RSI,R10
JNZ 0x001014a8
LAB_001014c6:
CMP R9D,0x1
JLE 0x0010151f
MOV EDI,R9D
LEA R10,[R8 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014d8:
CMP EDI,0x1
JLE 0x00101578
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R10 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014f0:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM1
CMP ECX,EDX
JGE 0x0010150e
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_0010150e:
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x001014f0
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001014d8
LAB_0010151f:
MOV dword ptr [RBP],R9D
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101538:
TEST R13D,R13D
JLE 0x00101560
MOV EDX,dword ptr [RSI]
MOV RAX,R12
JMP 0x00101551
LAB_00101548:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101560
LAB_00101551:
CMP EDX,dword ptr [RAX]
JNZ 0x00101548
MOVSXD RAX,R9D
ADD R9D,0x1
MOV dword ptr [R8 + RAX*0x4],EDX
LAB_00101560:
ADD RSI,0x4
CMP RSI,R10
JNZ 0x00101498
JMP 0x001014c6
LAB_00101578:
SUB EDI,0x1
JMP 0x001014d8
LAB_00101580:
XOR R9D,R9D
JMP 0x0010151f
|
int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
piVar1 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar2 = param_1 + param_2;
iVar6 = 0;
do {
if (0 < iVar6) {
do {
piVar3 = piVar1;
while (*piVar3 != *param_1) {
piVar3 = piVar3 + 1;
if (piVar3 == piVar1 + iVar6) goto LAB_00101538;
}
param_1 = param_1 + 1;
} while (param_1 != piVar2);
break;
}
LAB_00101538:
if (0 < param_4) {
piVar3 = param_3;
do {
if (*param_1 == *piVar3) {
lVar4 = (long)iVar6;
iVar6 = iVar6 + 1;
piVar1[lVar4] = *param_1;
break;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_3 + param_4);
}
param_1 = param_1 + 1;
} while (param_1 != piVar2);
iVar5 = iVar6;
if (1 < iVar6) {
do {
for (; iVar5 < 2; iVar5 = iVar5 + -1) {
}
piVar2 = piVar1;
do {
iVar7 = (int)*(int8 *)piVar2;
iVar8 = (int)((ulong)*(int8 *)piVar2 >> 0x20);
if (iVar8 < iVar7) {
*(ulong *)piVar2 = CONCAT44(iVar7,iVar8);
}
piVar2 = piVar2 + 1;
} while (piVar1 + (ulong)(iVar5 - 2) + 1 != piVar2);
iVar5 = iVar5 + -1;
} while (iVar5 != 1);
}
}
*param_5 = iVar6;
return piVar1;
}
|
891 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
break;
}
}
if (!exists_in_out) {
for (j = 0; j < size2; j++) {
if (l1[i] == l2[j]) {
out[k++] = l1[i];
break;
}
}
}
}
for (i = 0; i < k - 1; i++) {
for (j = 0; j < k - i - 1; j++) {
if (out[j] > out[j + 1]) {
int temp = out[j];
out[j] = out[j + 1];
out[j + 1] = temp;
}
}
}
*out_size = k;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int l3[] = {5, 3, 2, 8};
int l4[] = {3, 2};
int expected2[] = {2, 3};
int *result2 = func0(l3, 4, l4, 2, &size);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int l5[] = {4, 3, 2, 8};
int l6[] = {3, 2, 4};
int expected3[] = {2, 3, 4};
int *result3 = func0(l5, 4, l6, 3, &size);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
int l7[] = {4, 3, 2, 8};
int l8[] = {};
int *result4 = func0(l7, 4, l8, 0, &size);
assert(size == 0); // Since l8 is empty, result4 should be empty as well
free(result4);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %ecx,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %r8,%rbx
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 1541 <func0+0x111>
lea -0x1(%r13),%edx
mov %r14,%r10
lea 0x4(%rax),%r13
xor %r8d,%r8d
lea 0x4(%r14,%rdx,4),%rcx
lea -0x1(%r12),%edx
lea 0x4(%rbp,%rdx,4),%r11
nopl (%rax)
test %r8d,%r8d
je 1508 <func0+0xd8>
lea -0x1(%r8),%edx
mov (%r10),%edi
mov %rax,%rsi
lea 0x0(%r13,%rdx,4),%r9
jmp 14a9 <func0+0x79>
nopw 0x0(%rax,%rax,1)
add $0x4,%rsi
cmp %r9,%rsi
je 1508 <func0+0xd8>
cmp %edi,(%rsi)
jne 14a0 <func0+0x70>
add $0x4,%r10
cmp %rcx,%r10
jne 1480 <func0+0x50>
lea -0x1(%r8),%ecx
test %ecx,%ecx
jle 14f7 <func0+0xc7>
lea 0x4(%rax),%r10
nopw 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rax,%rdx
mov %rcx,%r9
lea (%r10,%rcx,4),%rdi
nopl (%rax)
mov (%rdx),%ecx
mov 0x4(%rdx),%esi
cmp %esi,%ecx
jle 14e6 <func0+0xb6>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
add $0x4,%rdx
cmp %rdx,%rdi
jne 14d8 <func0+0xa8>
mov %r9d,%ecx
test %r9d,%r9d
jne 14c8 <func0+0x98>
mov %r8d,(%rbx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
test %r12d,%r12d
jle 14ad <func0+0x7d>
mov (%r10),%edi
mov %rbp,%rsi
jmp 1521 <func0+0xf1>
nopl (%rax)
add $0x4,%rsi
cmp %rsi,%r11
je 14ad <func0+0x7d>
cmp (%rsi),%edi
jne 1518 <func0+0xe8>
movslq %r8d,%rdx
add $0x4,%r10
add $0x1,%r8d
mov %edi,(%rax,%rdx,4)
cmp %rcx,%r10
jne 1480 <func0+0x50>
jmpq 14b6 <func0+0x86>
xor %r8d,%r8d
mov %r8d,(%rbx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
|
func0:
endbr64
push r15
movsxd r10, esi
push r14
lea r14, ds:0[r10*4]
mov r15, r10
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
mov rbp, r8
push rbx
mov rbx, rdi
mov rdi, r14; size
sub rsp, 8
call _malloc
mov r8, rax
test r15d, r15d
jle loc_1550
movsxd rax, r13d
mov rsi, rbx
lea r10, [rbx+r14]
xor r9d, r9d
lea rdi, [r12+rax*4]
nop dword ptr [rax+00000000h]
loc_1468:
movsxd rax, r9d
lea rcx, [r8+rax*4]
test r9d, r9d
jle loc_1508
loc_1478:
mov edx, [rsi]
mov rax, r8
jmp short loc_1489
loc_1480:
add rax, 4
cmp rax, rcx
jz short loc_1508
loc_1489:
cmp [rax], edx
jnz short loc_1480
add rsi, 4
cmp rsi, r10
jnz short loc_1478
loc_1496:
cmp r9d, 1
jle short loc_14EF
mov edi, r9d
lea r10, [r8+4]
nop dword ptr [rax+rax+00h]
loc_14A8:
cmp edi, 1
jle loc_1548
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r10+rdx*4]
nop dword ptr [rax+rax+00h]
loc_14C0:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_14DE
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_14DE:
add rax, 4
cmp rax, rsi
jnz short loc_14C0
sub edi, 1
cmp edi, 1
jnz short loc_14A8
loc_14EF:
mov [rbp+0], r9d
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1508:
test r13d, r13d
jle short loc_1530
mov edx, [rsi]
mov rax, r12
jmp short loc_1521
loc_1518:
add rax, 4
cmp rax, rdi
jz short loc_1530
loc_1521:
cmp edx, [rax]
jnz short loc_1518
movsxd rax, r9d
add r9d, 1
mov [r8+rax*4], edx
loc_1530:
add rsi, 4
cmp rsi, r10
jnz loc_1468
jmp loc_1496
loc_1548:
sub edi, 1
jmp loc_14A8
loc_1550:
xor r9d, r9d
jmp short loc_14EF
|
__m128i * func0(__int32 *a1, int a2, _DWORD *a3, int a4, int *a5)
{
size_t v5; // r14
__m128i *v9; // r8
__int32 *v10; // rsi
__int32 *v11; // r10
int v12; // r9d
__m128i *v13; // rax
int i; // edi
__m128i *v15; // rax
__m128i v16; // xmm0
__int32 v18; // edx
_DWORD *v19; // rax
long long v20; // rax
v5 = a2;
v9 = (__m128i *)malloc(v5 * 4);
if ( a2 <= 0 )
{
v12 = 0;
}
else
{
v10 = a1;
v11 = &a1[v5];
v12 = 0;
while ( v12 <= 0 )
{
LABEL_17:
if ( a4 > 0 )
{
v18 = *v10;
v19 = a3;
while ( v18 != *v19 )
{
if ( ++v19 == &a3[a4] )
goto LABEL_22;
}
v20 = v12++;
v9->m128i_i32[v20] = v18;
}
LABEL_22:
if ( ++v10 == v11 )
goto LABEL_8;
}
do
{
v13 = v9;
while ( v13->m128i_i32[0] != *v10 )
{
v13 = (__m128i *)((char *)v13 + 4);
if ( v13 == (__m128i *)((char *)v9 + 4 * v12) )
goto LABEL_17;
}
++v10;
}
while ( v10 != v11 );
LABEL_8:
if ( v12 > 1 )
{
for ( i = v12; i != 1; --i )
{
while ( i <= 1 )
--i;
v15 = v9;
do
{
v16 = _mm_loadl_epi64(v15);
if ( _mm_cvtsi128_si32(v16) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v16, 229)) )
v15->m128i_i64[0] = _mm_shuffle_epi32(v16, 225).m128i_u64[0];
v15 = (__m128i *)((char *)v15 + 4);
}
while ( v15 != (__m128i *)((char *)v9->m128i_i64 + 4 * (unsigned int)(i - 2) + 4) );
}
}
}
*a5 = v12;
return v9;
}
|
func0:
ENDBR64
PUSH R15
MOVSXD R10,ESI
PUSH R14
LEA R14,[R10*0x4]
MOV R15,R10
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,R8
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R15D,R15D
JLE 0x00101550
MOVSXD RAX,R13D
MOV RSI,RBX
LEA R10,[RBX + R14*0x1]
XOR R9D,R9D
LEA RDI,[R12 + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101468:
MOVSXD RAX,R9D
LEA RCX,[R8 + RAX*0x4]
TEST R9D,R9D
JLE 0x00101508
LAB_00101478:
MOV EDX,dword ptr [RSI]
MOV RAX,R8
JMP 0x00101489
LAB_00101480:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101508
LAB_00101489:
CMP dword ptr [RAX],EDX
JNZ 0x00101480
ADD RSI,0x4
CMP RSI,R10
JNZ 0x00101478
LAB_00101496:
CMP R9D,0x1
JLE 0x001014ef
MOV EDI,R9D
LEA R10,[R8 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014a8:
CMP EDI,0x1
JLE 0x00101548
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R10 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014c0:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x001014de
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001014de:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001014c0
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001014a8
LAB_001014ef:
MOV dword ptr [RBP],R9D
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101508:
TEST R13D,R13D
JLE 0x00101530
MOV EDX,dword ptr [RSI]
MOV RAX,R12
JMP 0x00101521
LAB_00101518:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101530
LAB_00101521:
CMP EDX,dword ptr [RAX]
JNZ 0x00101518
MOVSXD RAX,R9D
ADD R9D,0x1
MOV dword ptr [R8 + RAX*0x4],EDX
LAB_00101530:
ADD RSI,0x4
CMP RSI,R10
JNZ 0x00101468
JMP 0x00101496
LAB_00101548:
SUB EDI,0x1
JMP 0x001014a8
LAB_00101550:
XOR R9D,R9D
JMP 0x001014ef
|
int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
piVar1 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar2 = param_1 + param_2;
iVar6 = 0;
do {
if (0 < iVar6) {
do {
piVar3 = piVar1;
while (*piVar3 != *param_1) {
piVar3 = piVar3 + 1;
if (piVar3 == piVar1 + iVar6) goto LAB_00101508;
}
param_1 = param_1 + 1;
} while (param_1 != piVar2);
break;
}
LAB_00101508:
if (0 < param_4) {
piVar3 = param_3;
do {
if (*param_1 == *piVar3) {
lVar4 = (long)iVar6;
iVar6 = iVar6 + 1;
piVar1[lVar4] = *param_1;
break;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_3 + param_4);
}
param_1 = param_1 + 1;
} while (param_1 != piVar2);
iVar5 = iVar6;
if (1 < iVar6) {
do {
for (; iVar5 < 2; iVar5 = iVar5 + -1) {
}
piVar2 = piVar1;
do {
iVar7 = (int)*(int8 *)piVar2;
iVar8 = (int)((ulong)*(int8 *)piVar2 >> 0x20);
if (iVar8 < iVar7) {
*(ulong *)piVar2 = CONCAT44(iVar7,iVar8);
}
piVar2 = piVar2 + 1;
} while (piVar2 != piVar1 + (ulong)(iVar5 - 2) + 1);
iVar5 = iVar5 + -1;
} while (iVar5 != 1);
}
}
*param_5 = iVar6;
return piVar1;
}
|
892 |
func0
|
#include <stdio.h>
|
int func0(int n) {
for (int i = 2; i * i <= n; i++)
while (n % i == 0 && n > i) n = n / i;
return n;
}
|
#include <assert.h>
int main() {
assert(func0(15) == 5);
assert(func0(27) == 3);
assert(func0(63) == 7);
assert(func0(330) == 11);
assert(func0(13195) == 29);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x2,-0x4(%rbp)
jmp 1180 <func0+0x37>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 117c <func0+0x33>
mov -0x14(%rbp),%eax
cmp -0x4(%rbp),%eax
jg 115d <func0+0x14>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 1167 <func0+0x1e>
mov -0x14(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 2
jmp short loc_1180
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
loc_1167:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_117C
mov eax, [rbp+var_14]
cmp eax, [rbp+var_4]
jg short loc_115D
loc_117C:
add [rbp+var_4], 1
loc_1180:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_1167
mov eax, [rbp+var_14]
pop rbp
retn
|
long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) && a1 > i )
a1 /= i;
}
return (unsigned int)a1;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101180
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x0010117c
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x4]
JG 0x0010115d
LAB_0010117c:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101180:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x00101167
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET
|
int func0(int param_1)
{
int4 local_1c;
int4 local_c;
local_1c = param_1;
for (local_c = 2; local_c * local_c <= local_1c; local_c = local_c + 1) {
for (; (local_1c % local_c == 0 && (local_c < local_1c)); local_1c = local_1c / local_c) {
}
}
return local_1c;
}
|
893 |
func0
|
#include <stdio.h>
|
int func0(int n) {
for (int i = 2; i * i <= n; i++)
while (n % i == 0 && n > i) n = n / i;
return n;
}
|
#include <assert.h>
int main() {
assert(func0(15) == 5);
assert(func0(27) == 3);
assert(func0(63) == 7);
assert(func0(330) == 11);
assert(func0(13195) == 29);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov $0x2,%ecx
cmp $0x3,%edi
jg 1166 <func0+0x1d>
mov %edi,%eax
retq
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 1157 <func0+0xe>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 115a <func0+0x11>
cmp %ecx,%edi
jle 115a <func0+0x11>
mov %edi,%eax
cltd
idiv %ecx
mov %eax,%esi
mov %eax,%edi
cltd
idiv %ecx
test %edx,%edx
jne 115a <func0+0x11>
cmp %ecx,%esi
jg 1173 <func0+0x2a>
jmp 115a <func0+0x11>
|
func0:
endbr64
mov ecx, 2
cmp edi, 3
jg short loc_1166
loc_1157:
mov eax, edi
retn
loc_115A:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_1157
loc_1166:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_115A
cmp edi, ecx
jle short loc_115A
loc_1173:
mov eax, edi
cdq
idiv ecx
mov esi, eax
mov edi, eax
cdq
idiv ecx
test edx, edx
jnz short loc_115A
cmp esi, ecx
jg short loc_1173
jmp short loc_115A
|
long long func0(int a1)
{
int v1; // ecx
int v3; // esi
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) && a1 > v1 )
{
do
{
v3 = a1 / v1;
a1 = v3;
}
while ( !(v3 % v1) && v3 > v1 );
}
++v1;
}
while ( v1 * v1 <= a1 );
}
return (unsigned int)a1;
}
|
func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JG 0x00101166
LAB_00101157:
MOV EAX,EDI
RET
LAB_0010115a:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x00101157
LAB_00101166:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115a
CMP EDI,ECX
JLE 0x0010115a
LAB_00101173:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
MOV EDI,EAX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115a
CMP ESI,ECX
JG 0x00101173
JMP 0x0010115a
|
int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
iVar2 = 2;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while ((iVar3 == 0 && (iVar2 < param_1))) {
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar3 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
return param_1;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.