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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
694 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *numbers, int size) {
if (size <= 0) {
return NULL;
}
int *out = malloc(size * sizeof(int));
if (!out) {
return NULL;
}
int max = numbers[0];
for (int i = 0; i < size; i++) {
if (numbers[i] > max) max = numbers[i];
out[i] = max;
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
// First test case
result = func0((const int[]){}, 0);
assert(result == NULL);
free(result);
// Second test case
int test1[] = {1, 2, 3, 4};
result = func0(test1, 4);
assert(issame(result, (const int[]){1, 2, 3, 4}, 4));
free(result);
// Third test case
int test2[] = {4, 3, 2, 1};
result = func0(test2, 4);
assert(issame(result, (const int[]){4, 4, 4, 4}, 4));
free(result);
// Fourth test case
int test3[] = {3, 2, 3, 100, 3};
result = func0(test3, 5);
assert(issame(result, (const int[]){3, 3, 3, 100, 100}, 5));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 13e0 <func0+0x60>
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %rax,%rax
je 13d4 <func0+0x54>
mov (%rbx),%ecx
lea -0x1(%rbp),%edi
xor %edx,%edx
shl $0x2,%rdi
mov %ecx,%esi
jmp 13c0 <func0+0x40>
nopl 0x0(%rax,%rax,1)
mov 0x4(%rbx,%rdx,1),%esi
add $0x4,%rdx
cmp %esi,%ecx
cmovl %esi,%ecx
mov %ecx,(%rax,%rdx,1)
cmp %rdi,%rdx
jne 13b8 <func0+0x38>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopl (%rax)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
test esi, esi
jle short loc_13A8
push rbp
movsxd rsi, esi
mov rbp, rdi
push rbx
lea rbx, ds:0[rsi*4]
mov rdi, rbx; size
sub rsp, 8
call _malloc
test rax, rax
jz short loc_139C
mov ecx, [rbp+0]
xor edx, edx
xchg ax, ax
loc_1380:
mov esi, [rbp+rdx+0]
cmp ecx, esi
cmovl ecx, esi
mov [rax+rdx], ecx
add rdx, 4
cmp rbx, rdx
jnz short loc_1380
add rsp, 8
pop rbx
pop rbp
retn
loc_139C:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_13A8:
xor eax, eax
retn
|
char * func0(int *a1, int a2)
{
char *result; // rax
int v3; // ecx
long long i; // rdx
if ( a2 <= 0 )
return 0LL;
result = (char *)malloc(4LL * a2);
if ( !result )
return 0LL;
v3 = *a1;
for ( i = 0LL; i != a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
*(_DWORD *)&result[i * 4] = v3;
}
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013a8
PUSH RBP
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
LEA RBX,[RSI*0x4]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010139c
MOV ECX,dword ptr [RBP]
XOR EDX,EDX
NOP
LAB_00101380:
MOV ESI,dword ptr [RBP + RDX*0x1]
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [RAX + RDX*0x1],ECX
ADD RDX,0x4
CMP RBX,RDX
JNZ 0x00101380
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0010139c:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET
LAB_001013a8:
XOR EAX,EAX
RET
|
void * func0(int *param_1,int param_2)
{
void *pvVar1;
int iVar2;
long lVar3;
if (param_2 < 1) {
return (void *)0x0;
}
pvVar1 = malloc((long)param_2 * 4);
if (pvVar1 != (void *)0x0) {
iVar2 = *param_1;
lVar3 = 0;
do {
if (iVar2 < *(int *)((long)param_1 + lVar3)) {
iVar2 = *(int *)((long)param_1 + lVar3);
}
*(int *)((long)pvVar1 + lVar3) = iVar2;
lVar3 = lVar3 + 4;
} while ((long)param_2 * 4 - lVar3 != 0);
return pvVar1;
}
return (void *)0x0;
}
|
695 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int *numbers, int size) {
if (size <= 0) {
return NULL;
}
int *out = malloc(size * sizeof(int));
if (!out) {
return NULL;
}
int max = numbers[0];
for (int i = 0; i < size; i++) {
if (numbers[i] > max) max = numbers[i];
out[i] = max;
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
// First test case
result = func0((const int[]){}, 0);
assert(result == NULL);
free(result);
// Second test case
int test1[] = {1, 2, 3, 4};
result = func0(test1, 4);
assert(issame(result, (const int[]){1, 2, 3, 4}, 4));
free(result);
// Third test case
int test2[] = {4, 3, 2, 1};
result = func0(test2, 4);
assert(issame(result, (const int[]){4, 4, 4, 4}, 4));
free(result);
// Fourth test case
int test3[] = {3, 2, 3, 100, 3};
result = func0(test3, 5);
assert(issame(result, (const int[]){3, 3, 3, 100, 100}, 5));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 13c0 <func0+0x60>
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %rax,%rax
je 13ae <func0+0x4e>
mov (%rbx),%ecx
lea -0x1(%rbp),%edi
xor %edx,%edx
nopl 0x0(%rax,%rax,1)
mov (%rbx,%rdx,4),%esi
cmp %esi,%ecx
cmovl %esi,%ecx
mov %rdx,%rsi
mov %ecx,(%rax,%rdx,4)
add $0x1,%rdx
cmp %rsi,%rdi
jne 1390 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
test esi, esi
jle short loc_1378
push rbp
movsxd rsi, esi
mov rbp, rdi
push rbx
lea rbx, ds:0[rsi*4]
mov rdi, rbx; size
sub rsp, 8
call _malloc
test rax, rax
jz short loc_136C
mov ecx, [rbp+0]
xor edx, edx
xchg ax, ax
loc_1350:
mov esi, [rbp+rdx+0]
cmp ecx, esi
cmovl ecx, esi
mov [rax+rdx], ecx
add rdx, 4
cmp rbx, rdx
jnz short loc_1350
add rsp, 8
pop rbx
pop rbp
retn
loc_136C:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_1378:
xor eax, eax
retn
|
char * func0(int *a1, int a2)
{
char *result; // rax
int v3; // ecx
long long i; // rdx
if ( a2 <= 0 )
return 0LL;
result = (char *)malloc(4LL * a2);
if ( !result )
return 0LL;
v3 = *a1;
for ( i = 0LL; i != a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
*(_DWORD *)&result[i * 4] = v3;
}
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101378
PUSH RBP
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
LEA RBX,[RSI*0x4]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010136c
MOV ECX,dword ptr [RBP]
XOR EDX,EDX
NOP
LAB_00101350:
MOV ESI,dword ptr [RBP + RDX*0x1]
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [RAX + RDX*0x1],ECX
ADD RDX,0x4
CMP RBX,RDX
JNZ 0x00101350
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0010136c:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET
LAB_00101378:
XOR EAX,EAX
RET
|
void * func0(int *param_1,int param_2)
{
void *pvVar1;
int iVar2;
long lVar3;
if (param_2 < 1) {
return (void *)0x0;
}
pvVar1 = malloc((long)param_2 * 4);
if (pvVar1 != (void *)0x0) {
iVar2 = *param_1;
lVar3 = 0;
do {
if (iVar2 < *(int *)((long)param_1 + lVar3)) {
iVar2 = *(int *)((long)param_1 + lVar3);
}
*(int *)((long)pvVar1 + lVar3) = iVar2;
lVar3 = lVar3 + 4;
} while ((long)param_2 * 4 - lVar3 != 0);
return pvVar1;
}
return (void *)0x0;
}
|
696 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
is_palindrome = 0;
break;
}
}
if (is_palindrome) {
strncpy(result, str, len);
for (j = 0; j < i; j++) {
result[len + j] = str[i - j - 1];
}
result[len + i] = '\0';
return result;
}
}
strncpy(result, str, len);
for (j = 0; j < len; j++) {
result[len + j] = str[len - j - 1];
}
result[2 * len] = '\0';
return result;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Third test case
palindrome = func0("xyz");
assert(strcmp(palindrome, "xyzyx") == 0);
free(palindrome);
// Fourth test case
palindrome = func0("xyx");
assert(strcmp(palindrome, "xyx") == 0);
free(palindrome);
// Fifth test case
palindrome = func0("jerry");
assert(strcmp(palindrome, "jerryrrej") == 0);
free(palindrome);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add %eax,%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 122f <func0+0x46>
mov $0x0,%eax
jmpq 1392 <func0+0x1a9>
movl $0x0,-0x18(%rbp)
jmpq 1318 <func0+0x12f>
movl $0x1,-0x10(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1287 <func0+0x9e>
mov -0x18(%rbp),%edx
mov -0x14(%rbp),%eax
add %edx,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xc(%rbp),%eax
sub $0x1,%eax
sub -0x14(%rbp),%eax
movslq %eax,%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 1283 <func0+0x9a>
movl $0x0,-0x10(%rbp)
jmp 129b <func0+0xb2>
addl $0x1,-0x14(%rbp)
mov -0xc(%rbp),%eax
sub -0x18(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x14(%rbp)
jl 124b <func0+0x62>
cmpl $0x0,-0x10(%rbp)
je 1314 <func0+0x12b>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rcx
mov -0x8(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 10b0 <strncpy@plt>
movl $0x0,-0x14(%rbp)
jmp 12f1 <func0+0x108>
mov -0x18(%rbp),%eax
sub -0x14(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%ecx
mov -0x14(%rbp),%edx
add %ecx,%edx
movslq %edx,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jl 12c3 <func0+0xda>
mov -0xc(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
jmp 1392 <func0+0x1a9>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0xc(%rbp),%eax
jl 123b <func0+0x52>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rcx
mov -0x8(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 10b0 <strncpy@plt>
movl $0x0,-0x14(%rbp)
jmp 1374 <func0+0x18b>
mov -0xc(%rbp),%eax
sub -0x14(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%ecx
mov -0x14(%rbp),%edx
add %ecx,%edx
movslq %edx,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0xc(%rbp),%eax
jl 1346 <func0+0x15d>
mov -0xc(%rbp),%eax
add %eax,%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add eax, eax
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
cmp [rbp+dest], 0
jnz short loc_122F
mov eax, 0
jmp locret_1392
loc_122F:
mov [rbp+var_18], 0
jmp loc_1318
loc_123B:
mov [rbp+var_10], 1
mov [rbp+var_14], 0
jmp short loc_1287
loc_124B:
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
add eax, edx
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_C]
sub eax, 1
sub eax, [rbp+var_14]
movsxd rcx, eax
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_1283
mov [rbp+var_10], 0
jmp short loc_129B
loc_1283:
add [rbp+var_14], 1
loc_1287:
mov eax, [rbp+var_C]
sub eax, [rbp+var_18]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_14], eax
jl short loc_124B
loc_129B:
cmp [rbp+var_10], 0
jz short loc_1314
mov eax, [rbp+var_C]
movsxd rdx, eax; n
mov rcx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rcx; src
mov rdi, rax; dest
call _strncpy
mov [rbp+var_14], 0
jmp short loc_12F1
loc_12C3:
mov eax, [rbp+var_18]
sub eax, [rbp+var_14]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
mov ecx, [rbp+var_C]
mov edx, [rbp+var_14]
add edx, ecx
movsxd rcx, edx
mov rdx, [rbp+dest]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
add [rbp+var_14], 1
loc_12F1:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jl short loc_12C3
mov edx, [rbp+var_C]
mov eax, [rbp+var_18]
add eax, edx
movsxd rdx, eax
mov rax, [rbp+dest]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+dest]
jmp short locret_1392
loc_1314:
add [rbp+var_18], 1
loc_1318:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_C]
jl loc_123B
mov eax, [rbp+var_C]
movsxd rdx, eax; n
mov rcx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rcx; src
mov rdi, rax; dest
call _strncpy
mov [rbp+var_14], 0
jmp short loc_1374
loc_1346:
mov eax, [rbp+var_C]
sub eax, [rbp+var_14]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
mov ecx, [rbp+var_C]
mov edx, [rbp+var_14]
add edx, ecx
movsxd rcx, edx
mov rdx, [rbp+dest]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
add [rbp+var_14], 1
loc_1374:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_C]
jl short loc_1346
mov eax, [rbp+var_C]
add eax, eax
movsxd rdx, eax
mov rax, [rbp+dest]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+dest]
locret_1392:
leave
retn
|
char * func0(const char *a1)
{
int i; // [rsp+18h] [rbp-18h]
int k; // [rsp+1Ch] [rbp-14h]
int m; // [rsp+1Ch] [rbp-14h]
int j; // [rsp+1Ch] [rbp-14h]
int v6; // [rsp+20h] [rbp-10h]
int v7; // [rsp+24h] [rbp-Ch]
char *dest; // [rsp+28h] [rbp-8h]
v7 = strlen(a1);
dest = (char *)malloc(2 * v7 + 1);
if ( !dest )
return 0LL;
for ( i = 0; ; ++i )
{
if ( i >= v7 )
{
strncpy(dest, a1, v7);
for ( j = 0; j < v7; ++j )
dest[v7 + j] = a1[v7 - j - 1];
dest[2 * v7] = 0;
return dest;
}
v6 = 1;
for ( k = 0; k < (v7 - i) / 2; ++k )
{
if ( a1[i + k] != a1[v7 - 1 - k] )
{
v6 = 0;
break;
}
}
if ( v6 )
break;
}
strncpy(dest, a1, v7);
for ( m = 0; m < i; ++m )
dest[v7 + m] = a1[i - m - 1];
dest[v7 + i] = 0;
return dest;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EAX
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010122f
MOV EAX,0x0
JMP 0x00101392
LAB_0010122f:
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101318
LAB_0010123b:
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101287
LAB_0010124b:
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x14]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x00101283
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010129b
LAB_00101283:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101287:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x18]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x0010124b
LAB_0010129b:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x00101314
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012f1
LAB_001012c3:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV ECX,dword ptr [RBP + -0xc]
MOV EDX,dword ptr [RBP + -0x14]
ADD EDX,ECX
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x14],0x1
LAB_001012f1:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x001012c3
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
JMP 0x00101392
LAB_00101314:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101318:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0xc]
JL 0x0010123b
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101374
LAB_00101346:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV ECX,dword ptr [RBP + -0xc]
MOV EDX,dword ptr [RBP + -0x14]
ADD EDX,ECX
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x14],0x1
LAB_00101374:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0xc]
JL 0x00101346
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EAX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LAB_00101392:
LEAVE
RET
|
char * func0(char *param_1)
{
bool bVar1;
int iVar2;
size_t sVar3;
char *__dest;
int local_20;
int local_1c;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
__dest = (char *)malloc((long)(iVar2 * 2 + 1));
if (__dest == (char *)0x0) {
__dest = (char *)0x0;
}
else {
for (local_20 = 0; local_20 < iVar2; local_20 = local_20 + 1) {
bVar1 = true;
for (local_1c = 0; local_1c < (iVar2 - local_20) / 2; local_1c = local_1c + 1) {
if (param_1[local_1c + local_20] != param_1[(iVar2 + -1) - local_1c]) {
bVar1 = false;
break;
}
}
if (bVar1) {
strncpy(__dest,param_1,(long)iVar2);
for (local_1c = 0; local_1c < local_20; local_1c = local_1c + 1) {
__dest[local_1c + iVar2] = param_1[(long)(local_20 - local_1c) + -1];
}
__dest[local_20 + iVar2] = '\0';
return __dest;
}
}
strncpy(__dest,param_1,(long)iVar2);
for (local_1c = 0; local_1c < iVar2; local_1c = local_1c + 1) {
__dest[local_1c + iVar2] = param_1[(long)(iVar2 - local_1c) + -1];
}
__dest[iVar2 * 2] = '\0';
}
return __dest;
}
|
697 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
is_palindrome = 0;
break;
}
}
if (is_palindrome) {
strncpy(result, str, len);
for (j = 0; j < i; j++) {
result[len + j] = str[i - j - 1];
}
result[len + i] = '\0';
return result;
}
}
strncpy(result, str, len);
for (j = 0; j < len; j++) {
result[len + j] = str[len - j - 1];
}
result[2 * len] = '\0';
return result;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Third test case
palindrome = func0("xyz");
assert(strcmp(palindrome, "xyzyx") == 0);
free(palindrome);
// Fourth test case
palindrome = func0("xyx");
assert(strcmp(palindrome, "xyx") == 0);
free(palindrome);
// Fifth test case
palindrome = func0("jerry");
assert(strcmp(palindrome, "jerryrrej") == 0);
free(palindrome);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%r12
lea (%r12,%r12,1),%r15d
lea 0x1(%r15),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 1273 <func0+0xca>
mov %r12d,%r13d
test %r12d,%r12d
jle 1223 <func0+0x7a>
mov %r12d,%r9d
lea -0x1(%r12),%eax
mov %eax,0xc(%rsp)
mov %eax,%r8d
mov %rbp,%rsi
mov $0x0,%ebx
movslq %r12d,%rdi
sub $0x1,%rdi
jmp 1291 <func0+0xe8>
mov 0xc(%rsp),%ebx
jmpq 12c8 <func0+0x11f>
movslq %r12d,%rdx
mov %rbp,%rsi
mov %rax,%rdi
callq 1090 <strncpy@plt>
jmp 126b <func0+0xc2>
movslq %ebx,%rbx
mov %rbx,%rdx
mov %rbp,%rsi
mov %r14,%rdi
callq 1090 <strncpy@plt>
lea -0x1(%rbp,%rbx,1),%rax
lea (%r14,%rbx,1),%rdx
lea -0x2(%rbp,%rbx,1),%rsi
mov 0xc(%rsp),%ecx
sub %rcx,%rsi
movzbl (%rax),%ecx
mov %cl,(%rdx)
sub $0x1,%rax
add $0x1,%rdx
cmp %rsi,%rax
jne 1259 <func0+0xb0>
movslq %r15d,%r15
movb $0x0,(%r14,%r15,1)
mov %r14,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
add $0x1,%ebx
add $0x1,%rsi
cmp %ebx,%r13d
je 1233 <func0+0x8a>
mov %r9d,%eax
sub %ebx,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp %r8d,%ebx
je 121a <func0+0x71>
lea 0x0(%rbp,%rdi,1),%rdx
mov $0x0,%eax
movzbl (%rdx),%r10d
cmp %r10b,(%rsi,%rax,1)
jne 1285 <func0+0xdc>
add $0x1,%rax
sub $0x1,%rdx
cmp %eax,%ecx
jg 12b2 <func0+0x109>
movslq %r12d,%r13
mov %r13,%rdx
mov %rbp,%rsi
mov %r14,%rdi
callq 1090 <strncpy@plt>
test %ebx,%ebx
jle 1306 <func0+0x15d>
movslq %ebx,%rcx
lea -0x1(%rbp,%rcx,1),%rax
lea (%r14,%r13,1),%rdx
lea -0x2(%rbp,%rcx,1),%rsi
lea -0x1(%rbx),%ecx
sub %rcx,%rsi
movzbl (%rax),%ecx
mov %cl,(%rdx)
sub $0x1,%rax
add $0x1,%rdx
cmp %rsi,%rax
jne 12f4 <func0+0x14b>
lea (%rbx,%r12,1),%eax
cltq
movb $0x0,(%r14,%rax,1)
jmpq 1273 <func0+0xca>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
call _strlen
mov r13, rax
mov r14d, eax
lea eax, [rax+rax]
mov [rsp+48h+var_3C], eax
add eax, 1
cdqe
mov [rsp+48h+var_48], rax
mov rdi, rax; size
call _malloc
mov r15, rax
test rax, rax
jz loc_1323
test r13d, r13d
jle loc_1335
mov r8d, r13d
lea r12d, [r13-1]
mov rsi, rbp
mov ebx, 0
movsxd rdi, r13d
sub rdi, 1
jmp short loc_125E
loc_124E:
add ebx, 1
add rsi, 1
cmp r14d, ebx
jz loc_12DE
loc_125E:
mov eax, r8d
sub eax, ebx
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp ebx, r12d
jz short loc_12D9
lea rdx, [rbp+rdi+0]
mov eax, 0
loc_127B:
movzx r9d, byte ptr [rdx]
cmp [rsi+rax], r9b
jnz short loc_124E
add rax, 1
sub rdx, 1
cmp ecx, eax
jg short loc_127B
loc_1291:
movsxd r12, r13d
mov rcx, [rsp+48h+var_48]
mov rdx, r12
mov rsi, rbp
mov rdi, r15
call ___strncpy_chk
test ebx, ebx
jle short loc_12CC
movsxd rax, ebx
lea rax, [rbp+rax-1]
add r12, r15
loc_12B5:
movzx edx, byte ptr [rax]
mov [r12], dl
mov rdx, rax
sub rax, 1
add r12, 1
cmp rdx, rbp
jnz short loc_12B5
loc_12CC:
lea eax, [rbx+r13]
cdqe
mov byte ptr [r15+rax], 0
jmp short loc_1323
loc_12D9:
mov ebx, r12d
jmp short loc_1291
loc_12DE:
movsxd rbx, ebx
mov rcx, [rsp+48h+var_48]
mov rdx, rbx
mov rsi, rbp
mov rdi, r15
call ___strncpy_chk
lea rax, [rbp+rbx-1]
lea rdx, [r15+rbx]
lea rsi, [rbp+rbx-2]
mov r12d, r12d
sub rsi, r12
loc_1307:
movzx ecx, byte ptr [rax]
mov [rdx], cl
sub rax, 1
add rdx, 1
cmp rax, rsi
jnz short loc_1307
loc_1319:
movsxd rax, [rsp+48h+var_3C]
mov byte ptr [r15+rax], 0
loc_1323:
mov rax, r15
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1335:
movsxd rdx, r13d
mov rcx, [rsp+48h+var_48]
mov rsi, rbp
mov rdi, rax
call ___strncpy_chk
jmp short loc_1319
|
_BYTE * func0(const char *a1)
{
int v1; // r13d
_BYTE *v2; // rax
_BYTE *v3; // r15
int v4; // r12d
const char *v5; // rsi
int v6; // ebx
const char *v7; // rdx
long long v8; // rax
const char *v9; // rax
char *v10; // r12
const char *v11; // rdx
const char *v12; // rax
_BYTE *v13; // rdx
size_t v15; // [rsp+0h] [rbp-48h]
v1 = strlen(a1);
v15 = 2 * v1 + 1;
v2 = malloc(v15);
v3 = v2;
if ( v2 )
{
if ( v1 <= 0 )
{
__strncpy_chk(v2, a1, v1, v15);
LABEL_16:
v3[2 * v1] = 0;
}
else
{
v4 = v1 - 1;
v5 = a1;
v6 = 0;
while ( v6 != v4 )
{
v7 = &a1[v1 - 1];
v8 = 0LL;
while ( v5[v8] == *v7 )
{
++v8;
--v7;
if ( (v1 - v6) / 2 <= (int)v8 )
goto LABEL_9;
}
++v6;
++v5;
if ( v1 == v6 )
{
__strncpy_chk(v3, a1, v6, v15);
v12 = &a1[v6 - 1];
v13 = &v3[v6];
do
*v13++ = *v12--;
while ( v12 != &a1[v6 - 2 - v4] );
goto LABEL_16;
}
}
v6 = v1 - 1;
LABEL_9:
__strncpy_chk(v3, a1, v1, v15);
if ( v6 > 0 )
{
v9 = &a1[v6 - 1];
v10 = &v3[v1];
do
{
*v10 = *v9;
v11 = v9--;
++v10;
}
while ( v11 != a1 );
}
v3[v6 + v1] = 0;
}
}
return v3;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
CALL 0x001010b0
MOV R13,RAX
MOV R14D,EAX
LEA EAX,[RAX + RAX*0x1]
MOV dword ptr [RSP + 0xc],EAX
ADD EAX,0x1
CDQE
MOV qword ptr [RSP],RAX
MOV RDI,RAX
CALL 0x001010e0
MOV R15,RAX
TEST RAX,RAX
JZ 0x00101323
TEST R13D,R13D
JLE 0x00101335
MOV R8D,R13D
LEA R12D,[R13 + -0x1]
MOV RSI,RBP
MOV EBX,0x0
MOVSXD RDI,R13D
SUB RDI,0x1
JMP 0x0010125e
LAB_0010124e:
ADD EBX,0x1
ADD RSI,0x1
CMP R14D,EBX
JZ 0x001012de
LAB_0010125e:
MOV EAX,R8D
SUB EAX,EBX
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EBX,R12D
JZ 0x001012d9
LEA RDX,[RBP + RDI*0x1]
MOV EAX,0x0
LAB_0010127b:
MOVZX R9D,byte ptr [RDX]
CMP byte ptr [RSI + RAX*0x1],R9B
JNZ 0x0010124e
ADD RAX,0x1
SUB RDX,0x1
CMP ECX,EAX
JG 0x0010127b
LAB_00101291:
MOVSXD R12,R13D
MOV RCX,qword ptr [RSP]
MOV RDX,R12
MOV RSI,RBP
MOV RDI,R15
CALL 0x001010f0
TEST EBX,EBX
JLE 0x001012cc
MOVSXD RAX,EBX
LEA RAX,[RBP + RAX*0x1 + -0x1]
ADD R12,R15
LAB_001012b5:
MOVZX EDX,byte ptr [RAX]
MOV byte ptr [R12],DL
MOV RDX,RAX
SUB RAX,0x1
ADD R12,0x1
CMP RDX,RBP
JNZ 0x001012b5
LAB_001012cc:
LEA EAX,[RBX + R13*0x1]
CDQE
MOV byte ptr [R15 + RAX*0x1],0x0
JMP 0x00101323
LAB_001012d9:
MOV EBX,R12D
JMP 0x00101291
LAB_001012de:
MOVSXD RBX,EBX
MOV RCX,qword ptr [RSP]
MOV RDX,RBX
MOV RSI,RBP
MOV RDI,R15
CALL 0x001010f0
LEA RAX,[RBP + RBX*0x1 + -0x1]
LEA RDX,[R15 + RBX*0x1]
LEA RSI,[RBP + RBX*0x1 + -0x2]
MOV R12D,R12D
SUB RSI,R12
LAB_00101307:
MOVZX ECX,byte ptr [RAX]
MOV byte ptr [RDX],CL
SUB RAX,0x1
ADD RDX,0x1
CMP RAX,RSI
JNZ 0x00101307
LAB_00101319:
MOVSXD RAX,dword ptr [RSP + 0xc]
MOV byte ptr [R15 + RAX*0x1],0x0
LAB_00101323:
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101335:
MOVSXD RDX,R13D
MOV RCX,qword ptr [RSP]
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010f0
JMP 0x00101319
|
void * func0(char *param_1)
{
uint uVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
char *pcVar5;
uint uVar6;
uint uVar7;
char *pcVar8;
uint uVar9;
bool bVar10;
sVar2 = strlen(param_1);
uVar1 = (uint)sVar2;
sVar2 = (size_t)(int)(uVar1 * 2 + 1);
pvVar3 = malloc(sVar2);
if (pvVar3 != (void *)0x0) {
if ((int)uVar1 < 1) {
__strncpy_chk(pvVar3,param_1,(long)(int)uVar1,sVar2);
}
else {
uVar9 = uVar1 - 1;
uVar6 = 0;
pcVar8 = param_1;
do {
uVar7 = uVar9;
if (uVar6 == uVar9) {
LAB_00101291:
__strncpy_chk(pvVar3,param_1,(long)(int)uVar1,sVar2);
if (0 < (int)uVar7) {
pcVar5 = (char *)((long)(int)uVar1 + (long)pvVar3);
pcVar8 = param_1 + (long)(int)uVar7 + -1;
do {
*pcVar5 = *pcVar8;
pcVar5 = pcVar5 + 1;
bVar10 = pcVar8 != param_1;
pcVar8 = pcVar8 + -1;
} while (bVar10);
}
*(int *)((long)pvVar3 + (long)(int)(uVar7 + uVar1)) = 0;
return pvVar3;
}
pcVar5 = param_1 + (long)(int)uVar1 + -1;
lVar4 = 0;
while (pcVar8[lVar4] == *pcVar5) {
lVar4 = lVar4 + 1;
pcVar5 = pcVar5 + -1;
uVar7 = uVar6;
if ((int)(uVar1 - uVar6) / 2 <= (int)lVar4) goto LAB_00101291;
}
uVar6 = uVar6 + 1;
pcVar8 = pcVar8 + 1;
} while (uVar1 != uVar6);
lVar4 = (long)(int)uVar6;
__strncpy_chk(pvVar3,param_1,lVar4,sVar2);
pcVar5 = param_1 + lVar4 + -1;
pcVar8 = (char *)((long)pvVar3 + lVar4);
do {
*pcVar8 = *pcVar5;
pcVar5 = pcVar5 + -1;
pcVar8 = pcVar8 + 1;
} while (pcVar5 != param_1 + ((lVar4 + -2) - (ulong)uVar9));
}
*(int *)((long)pvVar3 + (long)(int)(uVar1 * 2)) = 0;
}
return pvVar3;
}
|
698 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
is_palindrome = 0;
break;
}
}
if (is_palindrome) {
strncpy(result, str, len);
for (j = 0; j < i; j++) {
result[len + j] = str[i - j - 1];
}
result[len + i] = '\0';
return result;
}
}
strncpy(result, str, len);
for (j = 0; j < len; j++) {
result[len + j] = str[len - j - 1];
}
result[2 * len] = '\0';
return result;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Third test case
palindrome = func0("xyz");
assert(strcmp(palindrome, "xyzyx") == 0);
free(palindrome);
// Fourth test case
palindrome = func0("xyx");
assert(strcmp(palindrome, "xyx") == 0);
free(palindrome);
// Fifth test case
palindrome = func0("jerry");
assert(strcmp(palindrome, "jerryrrej") == 0);
free(palindrome);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%ebx
mov %rax,%r12
mov %eax,%r15d
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 1460 <func0+0x100>
movslq %r12d,%r14
test %r12d,%r12d
jle 14c5 <func0+0x165>
xor %ebp,%ebp
mov %r12d,%edx
lea -0x1(%r12),%edi
mov %r13,%rax
sub %ebp,%edx
mov %r12d,%r10d
movslq %edi,%rdi
mov %edx,%ecx
sar %ecx
je 1410 <func0+0xb0>
nopl 0x0(%rax)
lea 0x1(%rax),%r9
sub $0x1,%ecx
lea 0x0(%r13,%rdi,1),%rdx
add %r9,%rcx
jmp 13ed <func0+0x8d>
nopl 0x0(%rax)
add $0x1,%rax
sub $0x1,%rdx
cmp %rcx,%rax
je 1410 <func0+0xb0>
movzbl (%rdx),%esi
cmp %sil,(%rax)
je 13e0 <func0+0x80>
add $0x1,%ebp
cmp %ebp,%r15d
je 1472 <func0+0x112>
mov %r12d,%edx
mov %r9,%rax
sub %ebp,%edx
mov %edx,%ecx
sar %ecx
jne 13c8 <func0+0x68>
nopl 0x0(%rax,%rax,1)
mov %r8,%rdi
mov %r14,%rdx
mov %r13,%rsi
callq 10a0 <strncpy@plt>
mov %rax,%r8
test %ebp,%ebp
je 1454 <func0+0xf4>
movslq %ebp,%rdx
add %r8,%r14
lea -0x2(%r13,%rdx,1),%rcx
lea -0x1(%r13,%rdx,1),%rax
lea -0x1(%rbp),%edx
sub %rdx,%rcx
nopl 0x0(%rax,%rax,1)
movzbl (%rax),%edx
sub $0x1,%rax
add $0x1,%r14
mov %dl,-0x1(%r14)
cmp %rcx,%rax
jne 1440 <func0+0xe0>
lea 0x0(%rbp,%r12,1),%eax
cltq
movb $0x0,(%r8,%rax,1)
add $0x18,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %r14,%rdx
mov %r13,%rsi
mov %r8,%rdi
mov %r10d,0xc(%rsp)
callq 10a0 <strncpy@plt>
mov 0xc(%rsp),%r10d
lea -0x2(%r13,%r14,1),%rsi
mov %rax,%r8
lea -0x1(%r13,%r14,1),%rax
lea -0x1(%r10),%ecx
lea (%r8,%r14,1),%rdx
sub %rcx,%rsi
nopw 0x0(%rax,%rax,1)
movzbl (%rax),%ecx
sub $0x1,%rax
add $0x1,%rdx
mov %cl,-0x1(%rdx)
cmp %rax,%rsi
jne 14a8 <func0+0x148>
movslq %ebx,%rbx
movb $0x0,(%r8,%rbx,1)
jmp 1460 <func0+0x100>
mov %r14,%rdx
mov %r13,%rsi
mov %rax,%rdi
callq 10a0 <strncpy@plt>
mov %rax,%r8
jmp 14bb <func0+0x15b>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
call _strlen
lea ebx, [rax+rax]
mov r13, rax
mov r15d, eax
lea r8d, [rbx+1]
movsxd r8, r8d
mov rdi, r8; size
mov [rsp+48h+var_40], r8
call _malloc
mov rdi, rax
test rax, rax
jz loc_145A
test r13d, r13d
mov r8, [rsp+48h+var_40]
movsxd r14, r13d
jle loc_14B4
lea r9d, [r13-1]
mov rsi, r12
xor ebp, ebp
movsxd r9, r9d
loc_13D0:
mov ecx, r13d
sub ecx, ebp
sar ecx, 1
jz loc_1470
movsxd rcx, ecx
lea rdx, [r12+r9]
mov rax, rsi
add rcx, rsi
jmp short loc_13FD
loc_13F0:
add rax, 1
sub rdx, 1
cmp rax, rcx
jz short loc_1470
loc_13FD:
movzx r10d, byte ptr [rdx]
cmp [rax], r10b
jz short loc_13F0
add ebp, 1
add rsi, 1
cmp r15d, ebp
jnz short loc_13D0
mov rcx, r8
mov rdx, r14
mov rsi, r12
call ___strncpy_chk
lea rsi, [r12+r14-2]
lea ecx, [r13-1]
mov rdi, rax
sub rsi, rcx
lea rax, [r12+r14-1]
lea rdx, [rdi+r14]
nop dword ptr [rax+rax+00000000h]
loc_1440:
movzx ecx, byte ptr [rax]
sub rax, 1
add rdx, 1
mov [rdx-1], cl
cmp rsi, rax
jnz short loc_1440
loc_1453:
movsxd rbx, ebx
mov byte ptr [rdi+rbx], 0
loc_145A:
add rsp, 18h
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1470:
mov rcx, r8
mov rdx, r14
mov rsi, r12
call ___strncpy_chk
mov rdi, rax
test ebp, ebp
jz short loc_14A7
movsxd rax, ebp
add r14, rdi
lea rax, [r12+rax-1]
loc_1490:
movzx edx, byte ptr [rax]
add r14, 1
mov [r14-1], dl
mov rdx, rax
sub rax, 1
cmp rdx, r12
jnz short loc_1490
loc_14A7:
lea eax, [rbp+r13+0]
cdqe
mov byte ptr [rdi+rax], 0
jmp short loc_145A
loc_14B4:
mov rcx, r8
mov rdx, r14
mov rsi, r12
call ___strncpy_chk
mov rdi, rax
jmp short loc_1453
|
_BYTE * func0(const char *a1)
{
int v2; // eax
int v3; // ebx
int v4; // r13d
int v5; // r15d
_BYTE *v6; // rdi
const char *v7; // rsi
int v8; // ebp
const char *v9; // rdx
const char *v10; // rax
const char *v11; // rax
_BYTE *v12; // rdx
char v13; // cl
long long v15; // rax
char *v16; // r14
const char *v17; // rax
const char *v18; // rdx
size_t v19; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v3 = 2 * v2;
v4 = v2;
v5 = v2;
v19 = 2 * v2 + 1;
v6 = malloc(v19);
if ( v6 )
{
if ( v4 <= 0 )
{
v6 = (_BYTE *)__strncpy_chk(v6, a1, v4, v19);
LABEL_11:
v6[v3] = 0;
}
else
{
v7 = a1;
v8 = 0;
while ( (v4 - v8) >> 1 )
{
v9 = &a1[v4 - 1];
v10 = v7;
while ( *v10 == *v9 )
{
++v10;
--v9;
if ( v10 == &v7[(v4 - v8) >> 1] )
goto LABEL_13;
}
++v8;
++v7;
if ( v5 == v8 )
{
v6 = (_BYTE *)__strncpy_chk(v6, a1, v4, v19);
v11 = &a1[v4 - 1];
v12 = &v6[v4];
do
{
v13 = *v11--;
*v12++ = v13;
}
while ( &a1[v4 - 2 - (v4 - 1)] != v11 );
goto LABEL_11;
}
}
LABEL_13:
v15 = __strncpy_chk(v6, a1, v4, v19);
v6 = (_BYTE *)v15;
if ( v8 )
{
v16 = (char *)(v15 + v4);
v17 = &a1[v8 - 1];
do
{
*v16++ = *v17;
v18 = v17--;
}
while ( v18 != a1 );
}
v6[v8 + v4] = 0;
}
}
return v6;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1]
MOV R13,RAX
MOV R15D,EAX
LEA R8D,[RBX + 0x1]
MOVSXD R8,R8D
MOV RDI,R8
MOV qword ptr [RSP + 0x8],R8
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010145a
TEST R13D,R13D
MOV R8,qword ptr [RSP + 0x8]
MOVSXD R14,R13D
JLE 0x001014b4
LEA R9D,[R13 + -0x1]
MOV RSI,R12
XOR EBP,EBP
MOVSXD R9,R9D
LAB_001013d0:
MOV ECX,R13D
SUB ECX,EBP
SAR ECX,0x1
JZ 0x00101470
MOVSXD RCX,ECX
LEA RDX,[R12 + R9*0x1]
MOV RAX,RSI
ADD RCX,RSI
JMP 0x001013fd
LAB_001013f0:
ADD RAX,0x1
SUB RDX,0x1
CMP RAX,RCX
JZ 0x00101470
LAB_001013fd:
MOVZX R10D,byte ptr [RDX]
CMP byte ptr [RAX],R10B
JZ 0x001013f0
ADD EBP,0x1
ADD RSI,0x1
CMP R15D,EBP
JNZ 0x001013d0
MOV RCX,R8
MOV RDX,R14
MOV RSI,R12
CALL 0x001010f0
LEA RSI,[R12 + R14*0x1 + -0x2]
LEA ECX,[R13 + -0x1]
MOV RDI,RAX
SUB RSI,RCX
LEA RAX,[R12 + R14*0x1 + -0x1]
LEA RDX,[RDI + R14*0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101440:
MOVZX ECX,byte ptr [RAX]
SUB RAX,0x1
ADD RDX,0x1
MOV byte ptr [RDX + -0x1],CL
CMP RSI,RAX
JNZ 0x00101440
LAB_00101453:
MOVSXD RBX,EBX
MOV byte ptr [RDI + RBX*0x1],0x0
LAB_0010145a:
ADD RSP,0x18
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101470:
MOV RCX,R8
MOV RDX,R14
MOV RSI,R12
CALL 0x001010f0
MOV RDI,RAX
TEST EBP,EBP
JZ 0x001014a7
MOVSXD RAX,EBP
ADD R14,RDI
LEA RAX,[R12 + RAX*0x1 + -0x1]
LAB_00101490:
MOVZX EDX,byte ptr [RAX]
ADD R14,0x1
MOV byte ptr [R14 + -0x1],DL
MOV RDX,RAX
SUB RAX,0x1
CMP RDX,R12
JNZ 0x00101490
LAB_001014a7:
LEA EAX,[RBP + R13*0x1]
CDQE
MOV byte ptr [RDI + RAX*0x1],0x0
JMP 0x0010145a
LAB_001014b4:
MOV RCX,R8
MOV RDX,R14
MOV RSI,R12
CALL 0x001010f0
MOV RDI,RAX
JMP 0x00101453
|
void * func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
int iVar8;
char *pcVar9;
long lVar10;
bool bVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
pvVar4 = malloc(sVar3);
if (pvVar4 != (void *)0x0) {
lVar10 = (long)iVar2;
if (iVar2 < 1) {
pvVar4 = (void *)__strncpy_chk(pvVar4,param_1,lVar10,sVar3);
}
else {
iVar8 = 0;
pcVar9 = param_1;
do {
iVar6 = iVar2 - iVar8 >> 1;
if (iVar6 == 0) {
LAB_00101470:
pvVar4 = (void *)__strncpy_chk(pvVar4,param_1,lVar10,sVar3);
if (iVar8 != 0) {
pcVar9 = param_1 + (long)iVar8 + -1;
pcVar7 = (char *)(lVar10 + (long)pvVar4);
do {
*pcVar7 = *pcVar9;
bVar11 = pcVar9 != param_1;
pcVar9 = pcVar9 + -1;
pcVar7 = pcVar7 + 1;
} while (bVar11);
}
*(int *)((long)pvVar4 + (long)(iVar8 + iVar2)) = 0;
return pvVar4;
}
pcVar7 = param_1 + (iVar2 + -1);
pcVar5 = pcVar9;
while (*pcVar5 == *pcVar7) {
pcVar5 = pcVar5 + 1;
pcVar7 = pcVar7 + -1;
if (pcVar5 == pcVar9 + iVar6) goto LAB_00101470;
}
iVar8 = iVar8 + 1;
pcVar9 = pcVar9 + 1;
} while (iVar2 != iVar8);
pvVar4 = (void *)__strncpy_chk(pvVar4,param_1,lVar10,sVar3);
pcVar9 = param_1 + lVar10 + -1;
pcVar7 = (char *)((long)pvVar4 + lVar10);
do {
cVar1 = *pcVar9;
pcVar9 = pcVar9 + -1;
*pcVar7 = cVar1;
pcVar7 = pcVar7 + 1;
} while (param_1 + ((lVar10 + -2) - (ulong)(iVar2 - 1)) != pcVar9);
}
*(int *)((long)pvVar4 + (long)(iVar2 * 2)) = 0;
}
return pvVar4;
}
|
699 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
is_palindrome = 0;
break;
}
}
if (is_palindrome) {
strncpy(result, str, len);
for (j = 0; j < i; j++) {
result[len + j] = str[i - j - 1];
}
result[len + i] = '\0';
return result;
}
}
strncpy(result, str, len);
for (j = 0; j < len; j++) {
result[len + j] = str[len - j - 1];
}
result[2 * len] = '\0';
return result;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Third test case
palindrome = func0("xyz");
assert(strcmp(palindrome, "xyzyx") == 0);
free(palindrome);
// Fourth test case
palindrome = func0("xyx");
assert(strcmp(palindrome, "xyx") == 0);
free(palindrome);
// Fifth test case
palindrome = func0("jerry");
assert(strcmp(palindrome, "jerryrrej") == 0);
free(palindrome);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%ebx
mov %rax,%r12
mov %eax,%r15d
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 1460 <func0+0x100>
movslq %r12d,%r14
test %r12d,%r12d
jle 14c5 <func0+0x165>
xor %ebp,%ebp
mov %r12d,%edx
lea -0x1(%r12),%edi
mov %r13,%rax
sub %ebp,%edx
mov %r12d,%r10d
movslq %edi,%rdi
mov %edx,%ecx
sar %ecx
je 1410 <func0+0xb0>
nopl 0x0(%rax)
lea 0x1(%rax),%r9
sub $0x1,%ecx
lea 0x0(%r13,%rdi,1),%rdx
add %r9,%rcx
jmp 13ed <func0+0x8d>
nopl 0x0(%rax)
add $0x1,%rax
sub $0x1,%rdx
cmp %rcx,%rax
je 1410 <func0+0xb0>
movzbl (%rdx),%esi
cmp %sil,(%rax)
je 13e0 <func0+0x80>
add $0x1,%ebp
cmp %ebp,%r15d
je 1472 <func0+0x112>
mov %r12d,%edx
mov %r9,%rax
sub %ebp,%edx
mov %edx,%ecx
sar %ecx
jne 13c8 <func0+0x68>
nopl 0x0(%rax,%rax,1)
mov %r8,%rdi
mov %r14,%rdx
mov %r13,%rsi
callq 10a0 <strncpy@plt>
mov %rax,%r8
test %ebp,%ebp
je 1454 <func0+0xf4>
movslq %ebp,%rdx
add %r8,%r14
lea -0x2(%r13,%rdx,1),%rcx
lea -0x1(%r13,%rdx,1),%rax
lea -0x1(%rbp),%edx
sub %rdx,%rcx
nopl 0x0(%rax,%rax,1)
movzbl (%rax),%edx
sub $0x1,%rax
add $0x1,%r14
mov %dl,-0x1(%r14)
cmp %rcx,%rax
jne 1440 <func0+0xe0>
lea 0x0(%rbp,%r12,1),%eax
cltq
movb $0x0,(%r8,%rax,1)
add $0x18,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %r14,%rdx
mov %r13,%rsi
mov %r8,%rdi
mov %r10d,0xc(%rsp)
callq 10a0 <strncpy@plt>
mov 0xc(%rsp),%r10d
lea -0x2(%r13,%r14,1),%rsi
mov %rax,%r8
lea -0x1(%r13,%r14,1),%rax
lea -0x1(%r10),%ecx
lea (%r8,%r14,1),%rdx
sub %rcx,%rsi
nopw 0x0(%rax,%rax,1)
movzbl (%rax),%ecx
sub $0x1,%rax
add $0x1,%rdx
mov %cl,-0x1(%rdx)
cmp %rax,%rsi
jne 14a8 <func0+0x148>
movslq %ebx,%rbx
movb $0x0,(%r8,%rbx,1)
jmp 1460 <func0+0x100>
mov %r14,%rdx
mov %r13,%rsi
mov %rax,%rdi
callq 10a0 <strncpy@plt>
mov %rax,%r8
jmp 14bb <func0+0x15b>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
call _strlen
lea ebx, [rax+rax]
mov r13, rax
mov r15d, eax
lea r8d, [rbx+1]
movsxd r8, r8d
mov rdi, r8; size
mov [rsp+48h+var_40], r8
call _malloc
mov rdi, rax
test rax, rax
jz loc_145A
test r13d, r13d
mov r8, [rsp+48h+var_40]
movsxd r14, r13d
jle loc_14B4
lea r9d, [r13-1]
mov rsi, r12
xor ebp, ebp
movsxd r9, r9d
loc_13D0:
mov ecx, r13d
sub ecx, ebp
sar ecx, 1
jz loc_1470
movsxd rcx, ecx
lea rdx, [r12+r9]
mov rax, rsi
add rcx, rsi
jmp short loc_13FD
loc_13F0:
add rax, 1
sub rdx, 1
cmp rax, rcx
jz short loc_1470
loc_13FD:
movzx r10d, byte ptr [rdx]
cmp [rax], r10b
jz short loc_13F0
add ebp, 1
add rsi, 1
cmp r15d, ebp
jnz short loc_13D0
mov rcx, r8
mov rdx, r14
mov rsi, r12
call ___strncpy_chk
lea rsi, [r12+r14-2]
lea ecx, [r13-1]
mov rdi, rax
sub rsi, rcx
lea rax, [r12+r14-1]
lea rdx, [rdi+r14]
nop dword ptr [rax+rax+00000000h]
loc_1440:
movzx ecx, byte ptr [rax]
sub rax, 1
add rdx, 1
mov [rdx-1], cl
cmp rsi, rax
jnz short loc_1440
loc_1453:
movsxd rbx, ebx
mov byte ptr [rdi+rbx], 0
loc_145A:
add rsp, 18h
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1470:
mov rcx, r8
mov rdx, r14
mov rsi, r12
call ___strncpy_chk
mov rdi, rax
test ebp, ebp
jz short loc_14A7
movsxd rax, ebp
add r14, rdi
lea rax, [r12+rax-1]
loc_1490:
movzx edx, byte ptr [rax]
add r14, 1
mov [r14-1], dl
mov rdx, rax
sub rax, 1
cmp rdx, r12
jnz short loc_1490
loc_14A7:
lea eax, [rbp+r13+0]
cdqe
mov byte ptr [rdi+rax], 0
jmp short loc_145A
loc_14B4:
mov rcx, r8
mov rdx, r14
mov rsi, r12
call ___strncpy_chk
mov rdi, rax
jmp short loc_1453
|
_BYTE * func0(const char *a1)
{
int v2; // eax
int v3; // ebx
int v4; // r13d
int v5; // r15d
_BYTE *v6; // rdi
const char *v7; // rsi
int v8; // ebp
const char *v9; // rdx
const char *v10; // rax
const char *v11; // rax
_BYTE *v12; // rdx
char v13; // cl
long long v15; // rax
char *v16; // r14
const char *v17; // rax
const char *v18; // rdx
size_t v19; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v3 = 2 * v2;
v4 = v2;
v5 = v2;
v19 = 2 * v2 + 1;
v6 = malloc(v19);
if ( v6 )
{
if ( v4 <= 0 )
{
v6 = (_BYTE *)__strncpy_chk(v6, a1, v4, v19);
LABEL_11:
v6[v3] = 0;
}
else
{
v7 = a1;
v8 = 0;
while ( (v4 - v8) >> 1 )
{
v9 = &a1[v4 - 1];
v10 = v7;
while ( *v10 == *v9 )
{
++v10;
--v9;
if ( v10 == &v7[(v4 - v8) >> 1] )
goto LABEL_13;
}
++v8;
++v7;
if ( v5 == v8 )
{
v6 = (_BYTE *)__strncpy_chk(v6, a1, v4, v19);
v11 = &a1[v4 - 1];
v12 = &v6[v4];
do
{
v13 = *v11--;
*v12++ = v13;
}
while ( &a1[v4 - 2 - (v4 - 1)] != v11 );
goto LABEL_11;
}
}
LABEL_13:
v15 = __strncpy_chk(v6, a1, v4, v19);
v6 = (_BYTE *)v15;
if ( v8 )
{
v16 = (char *)(v15 + v4);
v17 = &a1[v8 - 1];
do
{
*v16++ = *v17;
v18 = v17--;
}
while ( v18 != a1 );
}
v6[v8 + v4] = 0;
}
}
return v6;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1]
MOV R13,RAX
MOV R15D,EAX
LEA R8D,[RBX + 0x1]
MOVSXD R8,R8D
MOV RDI,R8
MOV qword ptr [RSP + 0x8],R8
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010145a
TEST R13D,R13D
MOV R8,qword ptr [RSP + 0x8]
MOVSXD R14,R13D
JLE 0x001014b4
LEA R9D,[R13 + -0x1]
MOV RSI,R12
XOR EBP,EBP
MOVSXD R9,R9D
LAB_001013d0:
MOV ECX,R13D
SUB ECX,EBP
SAR ECX,0x1
JZ 0x00101470
MOVSXD RCX,ECX
LEA RDX,[R12 + R9*0x1]
MOV RAX,RSI
ADD RCX,RSI
JMP 0x001013fd
LAB_001013f0:
ADD RAX,0x1
SUB RDX,0x1
CMP RAX,RCX
JZ 0x00101470
LAB_001013fd:
MOVZX R10D,byte ptr [RDX]
CMP byte ptr [RAX],R10B
JZ 0x001013f0
ADD EBP,0x1
ADD RSI,0x1
CMP R15D,EBP
JNZ 0x001013d0
MOV RCX,R8
MOV RDX,R14
MOV RSI,R12
CALL 0x001010f0
LEA RSI,[R12 + R14*0x1 + -0x2]
LEA ECX,[R13 + -0x1]
MOV RDI,RAX
SUB RSI,RCX
LEA RAX,[R12 + R14*0x1 + -0x1]
LEA RDX,[RDI + R14*0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101440:
MOVZX ECX,byte ptr [RAX]
SUB RAX,0x1
ADD RDX,0x1
MOV byte ptr [RDX + -0x1],CL
CMP RSI,RAX
JNZ 0x00101440
LAB_00101453:
MOVSXD RBX,EBX
MOV byte ptr [RDI + RBX*0x1],0x0
LAB_0010145a:
ADD RSP,0x18
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101470:
MOV RCX,R8
MOV RDX,R14
MOV RSI,R12
CALL 0x001010f0
MOV RDI,RAX
TEST EBP,EBP
JZ 0x001014a7
MOVSXD RAX,EBP
ADD R14,RDI
LEA RAX,[R12 + RAX*0x1 + -0x1]
LAB_00101490:
MOVZX EDX,byte ptr [RAX]
ADD R14,0x1
MOV byte ptr [R14 + -0x1],DL
MOV RDX,RAX
SUB RAX,0x1
CMP RDX,R12
JNZ 0x00101490
LAB_001014a7:
LEA EAX,[RBP + R13*0x1]
CDQE
MOV byte ptr [RDI + RAX*0x1],0x0
JMP 0x0010145a
LAB_001014b4:
MOV RCX,R8
MOV RDX,R14
MOV RSI,R12
CALL 0x001010f0
MOV RDI,RAX
JMP 0x00101453
|
void * func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
int iVar8;
char *pcVar9;
long lVar10;
bool bVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
pvVar4 = malloc(sVar3);
if (pvVar4 != (void *)0x0) {
lVar10 = (long)iVar2;
if (iVar2 < 1) {
pvVar4 = (void *)__strncpy_chk(pvVar4,param_1,lVar10,sVar3);
}
else {
iVar8 = 0;
pcVar9 = param_1;
do {
iVar6 = iVar2 - iVar8 >> 1;
if (iVar6 == 0) {
LAB_00101470:
pvVar4 = (void *)__strncpy_chk(pvVar4,param_1,lVar10,sVar3);
if (iVar8 != 0) {
pcVar9 = param_1 + (long)iVar8 + -1;
pcVar7 = (char *)(lVar10 + (long)pvVar4);
do {
*pcVar7 = *pcVar9;
bVar11 = pcVar9 != param_1;
pcVar9 = pcVar9 + -1;
pcVar7 = pcVar7 + 1;
} while (bVar11);
}
*(int *)((long)pvVar4 + (long)(iVar8 + iVar2)) = 0;
return pvVar4;
}
pcVar7 = param_1 + (iVar2 + -1);
pcVar5 = pcVar9;
while (*pcVar5 == *pcVar7) {
pcVar5 = pcVar5 + 1;
pcVar7 = pcVar7 + -1;
if (pcVar5 == pcVar9 + iVar6) goto LAB_00101470;
}
iVar8 = iVar8 + 1;
pcVar9 = pcVar9 + 1;
} while (iVar2 != iVar8);
pvVar4 = (void *)__strncpy_chk(pvVar4,param_1,lVar10,sVar3);
pcVar9 = param_1 + lVar10 + -1;
pcVar7 = (char *)((long)pvVar4 + lVar10);
do {
cVar1 = *pcVar9;
pcVar9 = pcVar9 + -1;
*pcVar7 = cVar1;
pcVar7 = pcVar7 + 1;
} while (param_1 + ((lVar10 + -2) - (ulong)(iVar2 - 1)) != pcVar9);
}
*(int *)((long)pvVar4 + (long)(iVar2 * 2)) = 0;
}
return pvVar4;
}
|
700 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1';
}
output[min_len] = '\0';
return output;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0("0101", "0000");
assert(strcmp(result, "0101") == 0);
free(result);
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 10a0 <strlen@plt>
mov %eax,-0x14(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %eax,-0x10(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x10(%rbp)
cmovle -0x10(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 122a <func0+0x61>
mov $0x0,%eax
jmp 1292 <func0+0xc9>
movl $0x0,-0x18(%rbp)
jmp 1276 <func0+0xad>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x18(%rbp),%eax
movslq %eax,%rcx
mov -0x30(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 125e <func0+0x95>
mov $0x30,%ecx
jmp 1263 <func0+0x9a>
mov $0x31,%ecx
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov %cl,(%rax)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0xc(%rbp),%eax
jl 1233 <func0+0x6a>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
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_14], eax
mov rax, [rbp+var_30]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], eax
mov edx, [rbp+var_10]
mov eax, [rbp+var_14]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_122B
mov eax, 0
jmp short locret_1293
loc_122B:
mov [rbp+var_18], 0
jmp short loc_1277
loc_1234:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_18]
movsxd rcx, eax
mov rax, [rbp+var_30]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_125F
mov ecx, 30h ; '0'
jmp short loc_1264
loc_125F:
mov ecx, 31h ; '1'
loc_1264:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov [rax], cl
add [rbp+var_18], 1
loc_1277:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_C]
jl short loc_1234
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
locret_1293:
leave
retn
|
_BYTE * func0(const char *a1, const char *a2)
{
int v2; // edx
int v3; // eax
char v5; // cl
int i; // [rsp+18h] [rbp-18h]
int v7; // [rsp+1Ch] [rbp-14h]
int v8; // [rsp+24h] [rbp-Ch]
_BYTE *v9; // [rsp+28h] [rbp-8h]
v7 = strlen(a1);
v2 = strlen(a2);
v3 = v7;
if ( v2 <= v7 )
v3 = v2;
v8 = v3;
v9 = malloc(v3 + 1);
if ( !v9 )
return 0LL;
for ( i = 0; i < v8; ++i )
{
if ( a1[i] == a2[i] )
v5 = 48;
else
v5 = 49;
v9[i] = v5;
}
v9[v8] = 0;
return v9;
}
|
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 0x001010a0
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0x10],EAX
MOV EDX,dword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010122b
MOV EAX,0x0
JMP 0x00101293
LAB_0010122b:
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101277
LAB_00101234:
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 + -0x18]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x0010125f
MOV ECX,0x30
JMP 0x00101264
LAB_0010125f:
MOV ECX,0x31
LAB_00101264:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],CL
ADD dword ptr [RBP + -0x18],0x1
LAB_00101277:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0xc]
JL 0x00101234
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LAB_00101293:
LEAVE
RET
|
void * func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
int uVar5;
int local_20;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
iVar1 = (int)sVar2;
if ((int)sVar3 <= (int)sVar2) {
iVar1 = (int)sVar3;
}
pvVar4 = malloc((long)(iVar1 + 1));
if (pvVar4 == (void *)0x0) {
pvVar4 = (void *)0x0;
}
else {
for (local_20 = 0; local_20 < iVar1; local_20 = local_20 + 1) {
if (param_1[local_20] == param_2[local_20]) {
uVar5 = 0x30;
}
else {
uVar5 = 0x31;
}
*(int *)((long)pvVar4 + (long)local_20) = uVar5;
}
*(int *)((long)pvVar4 + (long)iVar1) = 0;
}
return pvVar4;
}
|
701 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1';
}
output[min_len] = '\0';
return output;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0("0101", "0000");
assert(strcmp(result, "0101") == 0);
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%r12
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdx
mov %rbx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rbx
cmp %edx,%ebx
cmovge %edx,%ebx
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 1090 <malloc@plt>
test %rax,%rax
je 120a <func0+0x81>
test %ebx,%ebx
jle 1203 <func0+0x7a>
lea -0x1(%rbx),%esi
mov $0x0,%edx
jmp 11e7 <func0+0x5e>
mov %rcx,%rdx
movzbl (%r12,%rdx,1),%edi
cmp %dil,0x0(%rbp,%rdx,1)
setne %cl
add $0x30,%ecx
mov %cl,(%rax,%rdx,1)
lea 0x1(%rdx),%rcx
cmp %rsi,%rdx
jne 11e4 <func0+0x5b>
movslq %ebx,%rbx
movb $0x0,(%rax,%rbx,1)
pop %rbx
pop %rbp
pop %r12
retq
|
func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
call _strlen
mov r12, rax
mov rdi, rbp; s
call _strlen
cmp r12d, eax
cmovg r12d, eax
lea edi, [r12+1]
movsxd rdi, edi; size
call _malloc
test rax, rax
jz short loc_1230
test r12d, r12d
jle short loc_1228
movsxd rsi, r12d
mov edx, 0
loc_120D:
movzx edi, byte ptr [rbp+rdx+0]
cmp [rbx+rdx], dil
setnz cl
add ecx, 30h ; '0'
mov [rax+rdx], cl
add rdx, 1
cmp rdx, rsi
jnz short loc_120D
loc_1228:
movsxd r12, r12d
mov byte ptr [rax+r12], 0
loc_1230:
pop rbx
pop rbp
pop r12
retn
|
_BYTE * func0(const char *a1, const char *a2)
{
int v2; // r12d
int v3; // eax
_BYTE *result; // rax
long long i; // rdx
v2 = strlen(a1);
v3 = strlen(a2);
if ( v2 > v3 )
v2 = v3;
result = malloc(v2 + 1);
if ( result )
{
if ( v2 > 0 )
{
for ( i = 0LL; i != v2; ++i )
result[i] = (a1[i] != a2[i]) + 48;
}
result[v2] = 0;
}
return result;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RSI
CALL 0x001010a0
MOV R12,RAX
MOV RDI,RBP
CALL 0x001010a0
CMP R12D,EAX
CMOVG R12D,EAX
LEA EDI,[R12 + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101230
TEST R12D,R12D
JLE 0x00101228
MOVSXD RSI,R12D
MOV EDX,0x0
LAB_0010120d:
MOVZX EDI,byte ptr [RBP + RDX*0x1]
CMP byte ptr [RBX + RDX*0x1],DIL
SETNZ CL
ADD ECX,0x30
MOV byte ptr [RAX + RDX*0x1],CL
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x0010120d
LAB_00101228:
MOVSXD R12,R12D
MOV byte ptr [RAX + R12*0x1],0x0
LAB_00101230:
POP RBX
POP RBP
POP R12
RET
|
void func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
long lVar5;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
iVar1 = (int)sVar2;
if ((int)sVar3 < (int)sVar2) {
iVar1 = (int)sVar3;
}
pvVar4 = malloc((long)(iVar1 + 1));
if (pvVar4 != (void *)0x0) {
if (0 < iVar1) {
lVar5 = 0;
do {
*(char *)((long)pvVar4 + lVar5) = (param_1[lVar5] != param_2[lVar5]) + '0';
lVar5 = lVar5 + 1;
} while (lVar5 != iVar1);
}
*(int *)((long)pvVar4 + (long)iVar1) = 0;
}
return;
}
|
702 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1';
}
output[min_len] = '\0';
return output;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0("0101", "0000");
assert(strcmp(result, "0101") == 0);
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
callq 1090 <strlen@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 1090 <strlen@plt>
cmp %r12d,%eax
cmovl %eax,%r12d
lea 0x1(%r12),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 132e <func0+0x6e>
test %r12d,%r12d
jle 1326 <func0+0x66>
lea -0x1(%r12),%esi
xor %edx,%edx
jmp 130b <func0+0x4b>
nopl (%rax)
mov %rcx,%rdx
movzbl 0x0(%rbp,%rdx,1),%edi
cmp %dil,(%rbx,%rdx,1)
setne %cl
add $0x30,%ecx
mov %cl,(%rax,%rdx,1)
lea 0x1(%rdx),%rcx
cmp %rsi,%rdx
jne 1308 <func0+0x48>
movslq %r12d,%r12
movb $0x0,(%rax,%r12,1)
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
call _strlen
mov rdi, r12; s
mov rbx, rax
call _strlen
cmp ebx, eax
cmovg ebx, eax
lea edi, [rbx+1]
movsxd rdi, edi; size
call _malloc
test rax, rax
jz short loc_132F
movsxd rsi, ebx
xor edx, edx
test ebx, ebx
jle short loc_132B
nop dword ptr [rax+00h]
loc_1310:
movzx ebx, byte ptr [r12+rdx]
cmp [rbp+rdx+0], bl
setnz cl
add ecx, 30h ; '0'
mov [rax+rdx], cl
add rdx, 1
cmp rsi, rdx
jnz short loc_1310
loc_132B:
mov byte ptr [rax+rsi], 0
loc_132F:
pop rbx
pop rbp
pop r12
retn
|
_BYTE * func0(const char *a1, const char *a2)
{
int v2; // ebx
int v3; // eax
_BYTE *result; // rax
long long v5; // rdx
v2 = strlen(a1);
v3 = strlen(a2);
if ( v2 > v3 )
v2 = v3;
result = malloc(v2 + 1);
if ( result )
{
v5 = 0LL;
if ( v2 > 0 )
{
do
{
result[v5] = (a1[v5] != a2[v5]) + 48;
++v5;
}
while ( v2 != v5 );
}
result[v2] = 0;
}
return result;
}
|
func0:
ENDBR64
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x001010a0
MOV RDI,R12
MOV RBX,RAX
CALL 0x001010a0
CMP EBX,EAX
CMOVG EBX,EAX
LEA EDI,[RBX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010132f
MOVSXD RSI,EBX
XOR EDX,EDX
TEST EBX,EBX
JLE 0x0010132b
NOP dword ptr [RAX]
LAB_00101310:
MOVZX EBX,byte ptr [R12 + RDX*0x1]
CMP byte ptr [RBP + RDX*0x1],BL
SETNZ CL
ADD ECX,0x30
MOV byte ptr [RAX + RDX*0x1],CL
ADD RDX,0x1
CMP RSI,RDX
JNZ 0x00101310
LAB_0010132b:
MOV byte ptr [RAX + RSI*0x1],0x0
LAB_0010132f:
POP RBX
POP RBP
POP R12
RET
|
void func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
long lVar5;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
iVar1 = (int)sVar2;
if ((int)sVar3 < (int)sVar2) {
iVar1 = (int)sVar3;
}
pvVar4 = malloc((long)(iVar1 + 1));
if (pvVar4 != (void *)0x0) {
lVar5 = 0;
if (0 < iVar1) {
do {
*(char *)((long)pvVar4 + lVar5) = (param_1[lVar5] != param_2[lVar5]) + '0';
lVar5 = lVar5 + 1;
} while (iVar1 != lVar5);
}
*(int *)((long)pvVar4 + (long)iVar1) = 0;
}
return;
}
|
703 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1';
}
output[min_len] = '\0';
return output;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0("0101", "0000");
assert(strcmp(result, "0101") == 0);
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
callq 1090 <strlen@plt>
mov %rbp,%rdi
mov %rax,%rbx
callq 1090 <strlen@plt>
cmp %ebx,%eax
cmovl %eax,%ebx
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 1557 <func0+0x297>
test %ebx,%ebx
jle 1550 <func0+0x290>
lea -0x1(%rbx),%edx
cmp $0xe,%edx
jbe 155c <func0+0x29c>
mov %ebx,%ecx
movdqa 0xdab(%rip),%xmm3
movdqa 0xdb3(%rip),%xmm2
xor %edx,%edx
shr $0x4,%ecx
shl $0x4,%rcx
nopw %cs:0x0(%rax,%rax,1)
movdqu (%r12,%rdx,1),%xmm0
movdqu 0x0(%rbp,%rdx,1),%xmm4
movdqa %xmm3,%xmm1
pcmpeqb %xmm4,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm1,%xmm0
movups %xmm0,(%rax,%rdx,1)
add $0x10,%rdx
cmp %rcx,%rdx
jne 1330 <func0+0x70>
mov %ebx,%edx
and $0xfffffff0,%edx
test $0xf,%bl
je 1550 <func0+0x290>
movslq %edx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x1(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl (%r12,%rcx,1),%edi
cmp %dil,0x0(%rbp,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x2(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x3(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x4(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x5(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x6(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x7(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x8(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0x9(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0xa(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0xb(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0xc(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
lea 0xd(%rdx),%ecx
cmp %ecx,%ebx
jle 1550 <func0+0x290>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edi
cmp %dil,(%r12,%rcx,1)
setne %sil
add $0xe,%edx
add $0x30,%esi
mov %sil,(%rax,%rcx,1)
cmp %edx,%ebx
jle 1550 <func0+0x290>
movslq %edx,%rdx
movzbl 0x0(%rbp,%rdx,1),%edi
cmp %dil,(%r12,%rdx,1)
setne %cl
add $0x30,%ecx
mov %cl,(%rax,%rdx,1)
nopl (%rax)
movslq %ebx,%rbx
movb $0x0,(%rax,%rbx,1)
pop %rbx
pop %rbp
pop %r12
retq
xor %edx,%edx
jmpq 136b <func0+0xab>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
call _strlen
mov rdi, rbp; s
mov rbx, rax
call _strlen
cmp ebx, eax
cmovg ebx, eax
lea edi, [rbx+1]
movsxd rdi, edi; size
call _malloc
mov rdx, rax
test rax, rax
jz loc_14A0
test ebx, ebx
jle loc_1499
lea eax, [rbx-1]
cmp eax, 0Eh
jbe loc_14A8
mov ecx, ebx
movdqa xmm3, cs:xmmword_20A0
movdqa xmm2, cs:xmmword_20B0
xor eax, eax
shr ecx, 4
shl rcx, 4
nop dword ptr [rax+00000000h]
loc_1340:
movdqu xmm0, xmmword ptr [r12+rax]
movdqu xmm4, xmmword ptr [rbp+rax+0]
movdqa xmm1, xmm3
pcmpeqb xmm0, xmm4
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movups xmmword ptr [rdx+rax], xmm0
add rax, 10h
cmp rcx, rax
jnz short loc_1340
mov eax, ebx
and eax, 0FFFFFFF0h
mov ecx, eax
cmp ebx, eax
jz loc_1499
loc_137C:
mov esi, ebx
sub esi, ecx
lea edi, [rsi-1]
cmp edi, 6
jbe short loc_13C9
movq xmm1, qword ptr [rbp+rcx+0]
movq xmm0, qword ptr [r12+rcx]
movq xmm2, qword ptr cs:xmmword_20B0
pcmpeqb xmm0, xmm1
movq xmm1, qword ptr cs:xmmword_20A0
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movq qword ptr [rdx+rcx], xmm0
mov ecx, esi
and ecx, 0FFFFFFF8h
add eax, ecx
and esi, 7
jz loc_1499
loc_13C9:
movsxd rcx, eax
movzx edi, byte ptr [rbp+rcx+0]
cmp [r12+rcx], dil
setnz sil
add esi, 30h ; '0'
mov [rdx+rcx], sil
lea ecx, [rax+1]
cmp ebx, ecx
jle loc_1499
movsxd rcx, ecx
movzx edi, byte ptr [rbp+rcx+0]
cmp [r12+rcx], dil
setnz sil
add esi, 30h ; '0'
mov [rdx+rcx], sil
lea ecx, [rax+2]
cmp ebx, ecx
jle loc_1499
movsxd rcx, ecx
movzx edi, byte ptr [rbp+rcx+0]
cmp [r12+rcx], dil
setnz sil
add esi, 30h ; '0'
mov [rdx+rcx], sil
lea ecx, [rax+3]
cmp ebx, ecx
jle short loc_1499
movsxd rcx, ecx
movzx edi, byte ptr [rbp+rcx+0]
cmp [r12+rcx], dil
setnz sil
add esi, 30h ; '0'
mov [rdx+rcx], sil
lea ecx, [rax+4]
cmp ebx, ecx
jle short loc_1499
movsxd rcx, ecx
movzx edi, byte ptr [rbp+rcx+0]
cmp [r12+rcx], dil
setnz sil
add esi, 30h ; '0'
mov [rdx+rcx], sil
lea ecx, [rax+5]
cmp ebx, ecx
jle short loc_1499
movsxd rcx, ecx
movzx edi, byte ptr [rbp+rcx+0]
cmp [r12+rcx], dil
setnz sil
add eax, 6
add esi, 30h ; '0'
mov [rdx+rcx], sil
cmp ebx, eax
jle short loc_1499
cdqe
movzx edi, byte ptr [rbp+rax+0]
cmp [r12+rax], dil
setnz cl
add ecx, 30h ; '0'
mov [rdx+rax], cl
loc_1499:
movsxd rbx, ebx
mov byte ptr [rdx+rbx], 0
loc_14A0:
pop rbx
mov rax, rdx
pop rbp
pop r12
retn
loc_14A8:
xor ecx, ecx
xor eax, eax
jmp loc_137C
|
_BYTE * func0(const char *a1, const char *a2)
{
int v3; // ebx
int v4; // eax
_BYTE *v5; // rdx
__m128i si128; // xmm3
__m128i v7; // xmm2
long long v8; // rax
__m128i v9; // xmm0
int v10; // eax
long long v11; // rcx
int v12; // esi
__m128i v13; // xmm0
int v14; // ecx
int v15; // eax
v3 = strlen(a1);
v4 = strlen(a2);
if ( v3 > v4 )
v3 = v4;
v5 = malloc(v3 + 1);
if ( v5 )
{
if ( v3 > 0 )
{
if ( (unsigned int)(v3 - 1) <= 0xE )
{
v11 = 0LL;
v10 = 0;
goto LABEL_9;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_20A0);
v7 = _mm_load_si128((const __m128i *)&xmmword_20B0);
v8 = 0LL;
do
{
v9 = _mm_cmpeq_epi8(_mm_loadu_si128((const __m128i *)&a1[v8]), _mm_loadu_si128((const __m128i *)&a2[v8]));
*(__m128i *)&v5[v8] = _mm_or_si128(_mm_andnot_si128(v9, v7), _mm_and_si128(si128, v9));
v8 += 16LL;
}
while ( 16LL * ((unsigned int)v3 >> 4) != v8 );
v10 = v3 & 0x7FFFFFF0;
v11 = v3 & 0xFFFFFFF0;
if ( v3 != (v3 & 0xFFFFFFF0) )
{
LABEL_9:
v12 = v3 - v11;
if ( (unsigned int)(v3 - v11 - 1) <= 6
|| (v13 = _mm_cmpeq_epi8(
_mm_loadl_epi64((const __m128i *)&a1[v11]),
_mm_loadl_epi64((const __m128i *)&a2[v11])),
*(_QWORD *)&v5[v11] = _mm_or_si128(
_mm_andnot_si128(v13, _mm_loadl_epi64((const __m128i *)&xmmword_20B0)),
_mm_and_si128(_mm_loadl_epi64((const __m128i *)&xmmword_20A0), v13)).m128i_u64[0],
v10 += v12 & 0xFFFFFFF8,
(v12 & 7) != 0) )
{
v5[v10] = (a1[v10] != a2[v10]) + 48;
if ( v3 > v10 + 1 )
{
v5[v10 + 1] = (a1[v10 + 1] != a2[v10 + 1]) + 48;
if ( v3 > v10 + 2 )
{
v5[v10 + 2] = (a1[v10 + 2] != a2[v10 + 2]) + 48;
if ( v3 > v10 + 3 )
{
v5[v10 + 3] = (a1[v10 + 3] != a2[v10 + 3]) + 48;
if ( v3 > v10 + 4 )
{
v5[v10 + 4] = (a1[v10 + 4] != a2[v10 + 4]) + 48;
v14 = v10 + 5;
if ( v3 > v10 + 5 )
{
v15 = v10 + 6;
v5[v14] = (a1[v14] != a2[v14]) + 48;
if ( v3 > v15 )
v5[v15] = (a1[v15] != a2[v15]) + 48;
}
}
}
}
}
}
}
}
v5[v3] = 0;
}
return v5;
}
|
func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
CALL 0x001010a0
MOV RDI,RBP
MOV RBX,RAX
CALL 0x001010a0
CMP EBX,EAX
CMOVG EBX,EAX
LEA EDI,[RBX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
MOV RDX,RAX
TEST RAX,RAX
JZ 0x001014a0
TEST EBX,EBX
JLE 0x00101499
LEA EAX,[RBX + -0x1]
CMP EAX,0xe
JBE 0x001014a8
MOV ECX,EBX
MOVDQA XMM3,xmmword ptr [0x001020a0]
MOVDQA XMM2,xmmword ptr [0x001020b0]
XOR EAX,EAX
SHR ECX,0x4
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_00101340:
MOVDQU XMM0,xmmword ptr [R12 + RAX*0x1]
MOVDQU XMM4,xmmword ptr [RBP + RAX*0x1]
MOVDQA XMM1,XMM3
PCMPEQB XMM0,XMM4
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVUPS xmmword ptr [RDX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RCX,RAX
JNZ 0x00101340
MOV EAX,EBX
AND EAX,0xfffffff0
MOV ECX,EAX
CMP EBX,EAX
JZ 0x00101499
LAB_0010137c:
MOV ESI,EBX
SUB ESI,ECX
LEA EDI,[RSI + -0x1]
CMP EDI,0x6
JBE 0x001013c9
MOVQ XMM1,qword ptr [RBP + RCX*0x1]
MOVQ XMM0,qword ptr [R12 + RCX*0x1]
MOVQ XMM2,qword ptr [0x001020b0]
PCMPEQB XMM0,XMM1
MOVQ XMM1,qword ptr [0x001020a0]
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVQ qword ptr [RDX + RCX*0x1],XMM0
MOV ECX,ESI
AND ECX,0xfffffff8
ADD EAX,ECX
AND ESI,0x7
JZ 0x00101499
LAB_001013c9:
MOVSXD RCX,EAX
MOVZX EDI,byte ptr [RBP + RCX*0x1]
CMP byte ptr [R12 + RCX*0x1],DIL
SETNZ SIL
ADD ESI,0x30
MOV byte ptr [RDX + RCX*0x1],SIL
LEA ECX,[RAX + 0x1]
CMP EBX,ECX
JLE 0x00101499
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RBP + RCX*0x1]
CMP byte ptr [R12 + RCX*0x1],DIL
SETNZ SIL
ADD ESI,0x30
MOV byte ptr [RDX + RCX*0x1],SIL
LEA ECX,[RAX + 0x2]
CMP EBX,ECX
JLE 0x00101499
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RBP + RCX*0x1]
CMP byte ptr [R12 + RCX*0x1],DIL
SETNZ SIL
ADD ESI,0x30
MOV byte ptr [RDX + RCX*0x1],SIL
LEA ECX,[RAX + 0x3]
CMP EBX,ECX
JLE 0x00101499
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RBP + RCX*0x1]
CMP byte ptr [R12 + RCX*0x1],DIL
SETNZ SIL
ADD ESI,0x30
MOV byte ptr [RDX + RCX*0x1],SIL
LEA ECX,[RAX + 0x4]
CMP EBX,ECX
JLE 0x00101499
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RBP + RCX*0x1]
CMP byte ptr [R12 + RCX*0x1],DIL
SETNZ SIL
ADD ESI,0x30
MOV byte ptr [RDX + RCX*0x1],SIL
LEA ECX,[RAX + 0x5]
CMP EBX,ECX
JLE 0x00101499
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RBP + RCX*0x1]
CMP byte ptr [R12 + RCX*0x1],DIL
SETNZ SIL
ADD EAX,0x6
ADD ESI,0x30
MOV byte ptr [RDX + RCX*0x1],SIL
CMP EBX,EAX
JLE 0x00101499
CDQE
MOVZX EDI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [R12 + RAX*0x1],DIL
SETNZ CL
ADD ECX,0x30
MOV byte ptr [RDX + RAX*0x1],CL
LAB_00101499:
MOVSXD RBX,EBX
MOV byte ptr [RDX + RBX*0x1],0x0
LAB_001014a0:
POP RBX
MOV RAX,RDX
POP RBP
POP R12
RET
LAB_001014a8:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x0010137c
|
void * func0(char *param_1,char *param_2)
{
char *pcVar1;
byte *pbVar2;
char *pcVar3;
int8 uVar4;
int8 uVar5;
char cVar6;
char cVar7;
char cVar8;
char cVar9;
char cVar10;
char cVar11;
char cVar12;
char cVar13;
char cVar14;
char cVar15;
char cVar16;
char cVar17;
char cVar18;
char cVar19;
char cVar20;
char cVar21;
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;
byte bVar36;
byte bVar37;
byte bVar38;
byte bVar39;
byte bVar40;
byte bVar41;
byte bVar42;
byte bVar43;
byte bVar44;
byte bVar45;
byte bVar46;
byte bVar47;
byte bVar48;
byte bVar49;
byte bVar50;
byte bVar51;
byte bVar52;
byte bVar53;
byte bVar54;
byte bVar55;
byte bVar56;
byte bVar57;
byte bVar58;
byte bVar59;
byte bVar60;
byte bVar61;
byte bVar62;
byte bVar63;
byte bVar64;
byte bVar65;
byte bVar66;
byte bVar67;
uint uVar68;
uint uVar69;
size_t sVar70;
size_t sVar71;
void *pvVar72;
long lVar73;
ulong uVar74;
uint uVar75;
ulong uVar76;
sVar70 = strlen(param_1);
sVar71 = strlen(param_2);
uVar68 = (uint)sVar70;
if ((int)(uint)sVar71 < (int)(uint)sVar70) {
uVar68 = (uint)sVar71;
}
pvVar72 = malloc((long)(int)(uVar68 + 1));
bVar67 = UNK_001020bf;
bVar66 = UNK_001020be;
bVar65 = UNK_001020bd;
bVar64 = UNK_001020bc;
bVar63 = UNK_001020bb;
bVar62 = UNK_001020ba;
bVar61 = UNK_001020b9;
bVar60 = UNK_001020b8;
bVar59 = DAT_001020b0._7_1_;
bVar58 = DAT_001020b0._6_1_;
bVar57 = DAT_001020b0._5_1_;
bVar56 = DAT_001020b0._4_1_;
bVar55 = DAT_001020b0._3_1_;
bVar54 = DAT_001020b0._2_1_;
bVar53 = DAT_001020b0._1_1_;
bVar52 = (byte)DAT_001020b0;
bVar51 = UNK_001020af;
bVar50 = UNK_001020ae;
bVar49 = UNK_001020ad;
bVar48 = UNK_001020ac;
bVar47 = UNK_001020ab;
bVar46 = UNK_001020aa;
bVar45 = UNK_001020a9;
bVar44 = UNK_001020a8;
bVar43 = DAT_001020a0._7_1_;
bVar42 = DAT_001020a0._6_1_;
bVar41 = DAT_001020a0._5_1_;
bVar40 = DAT_001020a0._4_1_;
bVar39 = DAT_001020a0._3_1_;
bVar38 = DAT_001020a0._2_1_;
bVar37 = DAT_001020a0._1_1_;
bVar36 = (byte)DAT_001020a0;
if (pvVar72 == (void *)0x0) {
return (void *)0x0;
}
if (0 < (int)uVar68) {
if (uVar68 - 1 < 0xf) {
uVar74 = 0;
uVar69 = 0;
}
else {
lVar73 = 0;
do {
pcVar1 = param_1 + lVar73;
cVar6 = pcVar1[1];
cVar7 = pcVar1[2];
cVar8 = pcVar1[3];
cVar9 = pcVar1[4];
cVar10 = pcVar1[5];
cVar11 = pcVar1[6];
cVar12 = pcVar1[7];
cVar13 = pcVar1[8];
cVar14 = pcVar1[9];
cVar15 = pcVar1[10];
cVar16 = pcVar1[0xb];
cVar17 = pcVar1[0xc];
cVar18 = pcVar1[0xd];
cVar19 = pcVar1[0xe];
cVar20 = pcVar1[0xf];
pcVar3 = param_2 + lVar73;
cVar21 = pcVar3[1];
cVar22 = pcVar3[2];
cVar23 = pcVar3[3];
cVar24 = pcVar3[4];
cVar25 = pcVar3[5];
cVar26 = pcVar3[6];
cVar27 = pcVar3[7];
cVar28 = pcVar3[8];
cVar29 = pcVar3[9];
cVar30 = pcVar3[10];
cVar31 = pcVar3[0xb];
cVar32 = pcVar3[0xc];
cVar33 = pcVar3[0xd];
cVar34 = pcVar3[0xe];
cVar35 = pcVar3[0xf];
pbVar2 = (byte *)((long)pvVar72 + lVar73);
*pbVar2 = ~-(*pcVar1 == *pcVar3) & bVar52 | bVar36 & -(*pcVar1 == *pcVar3);
pbVar2[1] = ~-(cVar6 == cVar21) & bVar53 | bVar37 & -(cVar6 == cVar21);
pbVar2[2] = ~-(cVar7 == cVar22) & bVar54 | bVar38 & -(cVar7 == cVar22);
pbVar2[3] = ~-(cVar8 == cVar23) & bVar55 | bVar39 & -(cVar8 == cVar23);
pbVar2[4] = ~-(cVar9 == cVar24) & bVar56 | bVar40 & -(cVar9 == cVar24);
pbVar2[5] = ~-(cVar10 == cVar25) & bVar57 | bVar41 & -(cVar10 == cVar25);
pbVar2[6] = ~-(cVar11 == cVar26) & bVar58 | bVar42 & -(cVar11 == cVar26);
pbVar2[7] = ~-(cVar12 == cVar27) & bVar59 | bVar43 & -(cVar12 == cVar27);
pbVar2[8] = ~-(cVar13 == cVar28) & bVar60 | bVar44 & -(cVar13 == cVar28);
pbVar2[9] = ~-(cVar14 == cVar29) & bVar61 | bVar45 & -(cVar14 == cVar29);
pbVar2[10] = ~-(cVar15 == cVar30) & bVar62 | bVar46 & -(cVar15 == cVar30);
pbVar2[0xb] = ~-(cVar16 == cVar31) & bVar63 | bVar47 & -(cVar16 == cVar31);
pbVar2[0xc] = ~-(cVar17 == cVar32) & bVar64 | bVar48 & -(cVar17 == cVar32);
pbVar2[0xd] = ~-(cVar18 == cVar33) & bVar65 | bVar49 & -(cVar18 == cVar33);
pbVar2[0xe] = ~-(cVar19 == cVar34) & bVar66 | bVar50 & -(cVar19 == cVar34);
pbVar2[0xf] = ~-(cVar20 == cVar35) & bVar67 | bVar51 & -(cVar20 == cVar35);
lVar73 = lVar73 + 0x10;
} while ((ulong)(uVar68 >> 4) << 4 != lVar73);
uVar69 = uVar68 & 0xfffffff0;
uVar74 = (ulong)uVar69;
if (uVar68 == uVar69) goto LAB_00101499;
}
uVar75 = uVar68 - (int)uVar74;
if (6 < uVar75 - 1) {
uVar4 = *(int8 *)(param_2 + uVar74);
uVar5 = *(int8 *)(param_1 + uVar74);
uVar76 = CONCAT17(-((char)((ulong)uVar5 >> 0x38) == (char)((ulong)uVar4 >> 0x38)),
CONCAT16(-((char)((ulong)uVar5 >> 0x30) == (char)((ulong)uVar4 >> 0x30)),
CONCAT15(-((char)((ulong)uVar5 >> 0x28) ==
(char)((ulong)uVar4 >> 0x28)),
CONCAT14(-((char)((ulong)uVar5 >> 0x20) ==
(char)((ulong)uVar4 >> 0x20)),
CONCAT13(-((char)((ulong)uVar5 >> 0x18) ==
(char)((ulong)uVar4 >> 0x18)),
CONCAT12(-((char)((ulong)uVar5 >> 0x10)
== (char)((ulong)uVar4 >> 0x10
)),
CONCAT11(-((char)((ulong)uVar5
>> 8) ==
(char)((ulong)uVar4
>> 8)),
-((char)uVar5 ==
(char)uVar4))))))));
*(ulong *)((long)pvVar72 + uVar74) =
~uVar76 & CONCAT17(DAT_001020b0._7_1_,
CONCAT16(DAT_001020b0._6_1_,
CONCAT15(DAT_001020b0._5_1_,
CONCAT14(DAT_001020b0._4_1_,
CONCAT13(DAT_001020b0._3_1_,
CONCAT12(DAT_001020b0._2_1_,
CONCAT11(DAT_001020b0.
_1_1_,(byte)
DAT_001020b0))))))) |
CONCAT17(DAT_001020a0._7_1_,
CONCAT16(DAT_001020a0._6_1_,
CONCAT15(DAT_001020a0._5_1_,
CONCAT14(DAT_001020a0._4_1_,
CONCAT13(DAT_001020a0._3_1_,
CONCAT12(DAT_001020a0._2_1_,
CONCAT11(DAT_001020a0._1_1_,
(byte)DAT_001020a0)))))))
& uVar76;
uVar69 = uVar69 + (uVar75 & 0xfffffff8);
if ((uVar75 & 7) == 0) goto LAB_00101499;
}
lVar73 = (long)(int)uVar69;
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
if ((int)(uVar69 + 1) < (int)uVar68) {
lVar73 = (long)(int)(uVar69 + 1);
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
if ((int)(uVar69 + 2) < (int)uVar68) {
lVar73 = (long)(int)(uVar69 + 2);
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
if ((int)(uVar69 + 3) < (int)uVar68) {
lVar73 = (long)(int)(uVar69 + 3);
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
if ((int)(uVar69 + 4) < (int)uVar68) {
lVar73 = (long)(int)(uVar69 + 4);
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
if ((int)(uVar69 + 5) < (int)uVar68) {
lVar73 = (long)(int)(uVar69 + 5);
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
if ((int)(uVar69 + 6) < (int)uVar68) {
lVar73 = (long)(int)(uVar69 + 6);
*(char *)((long)pvVar72 + lVar73) = (param_1[lVar73] != param_2[lVar73]) + '0';
}
}
}
}
}
}
}
LAB_00101499:
*(int *)((long)pvVar72 + (long)(int)uVar68) = 0;
return pvVar72;
}
|
704 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(strcmp(func0(array2, 6), "zzzz") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
lea 0xe45(%rip),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1226 <func0+0x7d>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1222 <func0+0x79>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
mov -0xc(%rbp),%eax
mov %eax,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11d7 <func0+0x2e>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
lea rax, unk_2008
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_1226
loc_11D7:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jle short loc_1222
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov [rbp+var_8], rax
mov eax, [rbp+var_C]
mov [rbp+var_14], eax
loc_1222:
add [rbp+var_10], 1
loc_1226:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl short loc_11D7
mov rax, [rbp+var_8]
leave
retn
|
void * func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v5; // [rsp+24h] [rbp-Ch]
void *v6; // [rsp+28h] [rbp-8h]
v6 = &unk_2008;
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = strlen(*(const char **)(8LL * i + a1));
if ( v5 > v3 )
{
v6 = *(void **)(8LL * i + a1);
v3 = v5;
}
}
return v6;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101226
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101222
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
LAB_00101222:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101226:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011d7
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int * func0(long param_1,int param_2)
{
size_t sVar1;
int local_1c;
int local_18;
int *local_10;
local_10 = &DAT_00102008;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
sVar1 = strlen(*(char **)(param_1 + (long)local_18 * 8));
if (local_1c < (int)sVar1) {
local_10 = *(int **)(param_1 + (long)local_18 * 8);
local_1c = (int)sVar1;
}
}
return local_10;
}
|
705 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(strcmp(func0(array2, 6), "zzzz") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
lea 0xea7(%rip),%r11
test %esi,%esi
jle 11bf <func0+0x56>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r10
mov $0x0,%r8d
mov $0xffffffffffffffff,%r9
mov $0x0,%eax
jmp 11a0 <func0+0x37>
add $0x8,%rdx
cmp %r10,%rdx
je 11bf <func0+0x56>
mov (%rdx),%rsi
mov %r9,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp %r8d,%ecx
jle 1197 <func0+0x2e>
mov %ecx,%r8d
mov %rsi,%r11
jmp 1197 <func0+0x2e>
mov %r11,%rax
retq
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
lea r13, aAbc+3; ""
test esi, esi
jle short loc_11EC
mov rbx, rdi
movsxd rsi, esi
lea r14, [rdi+rsi*8]
mov ebp, 0
loc_11CF:
mov r12, [rbx]
mov rdi, r12; s
call _strlen
cmp eax, ebp
cmovg ebp, eax
cmovg r13, r12
add rbx, 8
cmp rbx, r14
jnz short loc_11CF
loc_11EC:
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
|
char * func0(const char **a1, int a2)
{
char *v2; // r13
const char **v3; // rbx
int v4; // ebp
const char *v5; // r12
int v6; // eax
v2 = "";
if ( a2 > 0 )
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = strlen(*v3);
if ( v6 > v4 )
{
v4 = v6;
v2 = (char *)v5;
}
++v3;
}
while ( v3 != &a1[a2] );
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA R13,[0x10201b]
TEST ESI,ESI
JLE 0x001011ec
MOV RBX,RDI
MOVSXD RSI,ESI
LEA R14,[RDI + RSI*0x8]
MOV EBP,0x0
LAB_001011cf:
MOV R12,qword ptr [RBX]
MOV RDI,R12
CALL 0x00101080
CMP EAX,EBP
CMOVG EBP,EAX
CMOVG R13,R12
ADD RBX,0x8
CMP RBX,R14
JNZ 0x001011cf
LAB_001011ec:
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
|
char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
size_t sVar2;
int iVar3;
char *pcVar4;
pcVar4 = "";
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
__s = (char *)*param_1;
sVar2 = strlen(__s);
if (iVar3 < (int)sVar2) {
pcVar4 = __s;
iVar3 = (int)sVar2;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return pcVar4;
}
|
706 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(strcmp(func0(array2, 6), "zzzz") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
lea 0xd7a(%rip),%r12
push %rbp
push %rbx
test %esi,%esi
jle 12d5 <func0+0x45>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %ebp,%ebp
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax)
mov (%rbx),%r14
mov %r14,%rdi
callq 1070 <strlen@plt>
cmp %ebp,%eax
jle 12cc <func0+0x3c>
mov %eax,%ebp
mov %r14,%r12
add $0x8,%rbx
cmp %r13,%rbx
jne 12b8 <func0+0x28>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
lea r14, aAbc+3; ""
push r13
push r12
push rbp
push rbx
test esi, esi
jle short loc_1365
movsxd rsi, esi
mov rbx, rdi
xor ebp, ebp
lea r13, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_1348:
mov r12, [rbx]
mov rdi, r12; s
call _strlen
cmp eax, ebp
cmovg ebp, eax
cmovg r14, r12
add rbx, 8
cmp rbx, r13
jnz short loc_1348
loc_1365:
pop rbx
mov rax, r14
pop rbp
pop r12
pop r13
pop r14
retn
|
char * func0(const char **a1, int a2)
{
char *v2; // r14
const char **v3; // rbx
int v4; // ebp
const char *v5; // r12
int v6; // eax
v2 = "";
if ( a2 > 0 )
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = strlen(*v3);
if ( v6 > v4 )
{
v4 = v6;
v2 = (char *)v5;
}
++v3;
}
while ( v3 != &a1[a2] );
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
LEA R14,[0x10201b]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x00101365
MOVSXD RSI,ESI
MOV RBX,RDI
XOR EBP,EBP
LEA R13,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101348:
MOV R12,qword ptr [RBX]
MOV RDI,R12
CALL 0x00101080
CMP EAX,EBP
CMOVG EBP,EAX
CMOVG R14,R12
ADD RBX,0x8
CMP RBX,R13
JNZ 0x00101348
LAB_00101365:
POP RBX
MOV RAX,R14
POP RBP
POP R12
POP R13
POP R14
RET
|
char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
size_t sVar2;
int iVar3;
char *pcVar4;
pcVar4 = "";
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + param_2;
do {
__s = (char *)*param_1;
sVar2 = strlen(__s);
if (iVar3 < (int)sVar2) {
pcVar4 = __s;
iVar3 = (int)sVar2;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return pcVar4;
}
|
707 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(strcmp(func0(array2, 6), "zzzz") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
lea 0xd2a(%rip),%r12
push %rbp
push %rbx
test %esi,%esi
jle 1325 <func0+0x45>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %ebp,%ebp
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax)
mov (%rbx),%r14
mov %r14,%rdi
callq 1070 <strlen@plt>
cmp %ebp,%eax
jle 131c <func0+0x3c>
mov %eax,%ebp
mov %r14,%r12
add $0x8,%rbx
cmp %r13,%rbx
jne 1308 <func0+0x28>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
lea r14, unk_2004
push r13
push r12
push rbp
push rbx
test esi, esi
jle short loc_11A5
movsxd rsi, esi
mov rbx, rdi
xor ebp, ebp
lea r13, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_1188:
mov r12, [rbx]
mov rdi, r12; s
call _strlen
cmp eax, ebp
cmovg ebp, eax
cmovg r14, r12
add rbx, 8
cmp rbx, r13
jnz short loc_1188
loc_11A5:
pop rbx
mov rax, r14
pop rbp
pop r12
pop r13
pop r14
retn
|
const char * func0(const char **a1, int a2)
{
const char *v2; // r14
const char **v3; // rbx
int v4; // ebp
const char *v5; // r12
int v6; // eax
v2 = (const char *)&unk_2004;
if ( a2 > 0 )
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = strlen(*v3);
if ( v6 > v4 )
{
v4 = v6;
v2 = v5;
}
++v3;
}
while ( v3 != &a1[a2] );
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
LEA R14,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001011a5
MOVSXD RSI,ESI
MOV RBX,RDI
XOR EBP,EBP
LEA R13,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101188:
MOV R12,qword ptr [RBX]
MOV RDI,R12
CALL 0x00101050
CMP EAX,EBP
CMOVG EBP,EAX
CMOVG R14,R12
ADD RBX,0x8
CMP RBX,R13
JNZ 0x00101188
LAB_001011a5:
POP RBX
MOV RAX,R14
POP RBP
POP R12
POP R13
POP R14
RET
|
char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
size_t sVar2;
int iVar3;
char *pcVar4;
pcVar4 = "";
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + param_2;
do {
__s = (char *)*param_1;
sVar2 = strlen(__s);
if (iVar3 < (int)sVar2) {
pcVar4 = __s;
iVar3 = (int)sVar2;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return pcVar4;
}
|
708 |
func0
|
#include <stdio.h>
|
int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
}
|
#include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
jmp 116f <func0+0x26>
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x4(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
jne 1159 <func0+0x10>
mov -0x14(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
jmp short loc_116F
loc_1159:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_4], edx
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
mov [rbp+var_18], eax
loc_116F:
cmp [rbp+var_18], 0
jnz short loc_1159
mov eax, [rbp+var_14]
pop rbp
retn
|
long long func0(int a1, int a2)
{
int v5; // [rsp+14h] [rbp-4h]
while ( a2 )
{
v5 = a1 % a2;
a1 = a2;
a2 = v5;
}
return (unsigned int)a1;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
JMP 0x0010116f
LAB_00101159:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EDX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x18],EAX
LAB_0010116f:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00101159
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET
|
int func0(int param_1,int param_2)
{
int iVar1;
int4 local_20;
int4 local_1c;
local_20 = param_2;
local_1c = param_1;
while (local_20 != 0) {
iVar1 = local_1c % local_20;
local_1c = local_20;
local_20 = iVar1;
}
return local_1c;
}
|
709 |
func0
|
#include <stdio.h>
|
int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
}
|
#include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %edi,%eax
test %esi,%esi
je 1163 <func0+0x1a>
mov %esi,%ecx
cltd
idiv %esi
mov %edx,%esi
mov %ecx,%eax
test %edx,%edx
jne 1153 <func0+0xa>
mov %ecx,%eax
retq
mov %edi,%ecx
jmp 1160 <func0+0x17>
|
func0:
endbr64
mov eax, edi
test esi, esi
jz short loc_1163
loc_1153:
mov ecx, esi
cdq
idiv esi
mov esi, edx
mov eax, ecx
test edx, edx
jnz short loc_1153
loc_1160:
mov eax, ecx
retn
loc_1163:
mov ecx, edi
jmp short loc_1160
|
long long func0(unsigned int a1, int a2)
{
signed int v2; // eax
unsigned int v3; // ecx
v2 = a1;
if ( a2 )
{
do
{
v3 = a2;
a2 = v2 % a2;
v2 = v3;
}
while ( a2 );
}
else
{
return a1;
}
return v3;
}
|
func0:
ENDBR64
MOV EAX,EDI
TEST ESI,ESI
JZ 0x00101163
LAB_00101153:
MOV ECX,ESI
CDQ
IDIV ESI
MOV ESI,EDX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101153
LAB_00101160:
MOV EAX,ECX
RET
LAB_00101163:
MOV ECX,EDI
JMP 0x00101160
|
int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_1;
if (param_2 != 0) {
do {
param_1 = param_2;
param_2 = iVar1 % param_1;
iVar1 = param_1;
} while (param_2 != 0);
}
return param_1;
}
|
710 |
func0
|
#include <stdio.h>
|
int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
}
|
#include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %edi,%eax
mov %esi,%edx
test %esi,%esi
je 1298 <func0+0x28>
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 1280 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
mov eax, edi
mov edx, esi
test esi, esi
jz short loc_1290
nop dword ptr [rax+00h]
loc_1280:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1280
mov eax, ecx
retn
loc_1290:
mov ecx, edi
mov eax, ecx
retn
|
long long func0(unsigned int a1, int a2)
{
signed int v2; // eax
int v3; // edx
unsigned int v4; // ecx
v2 = a1;
v3 = a2;
if ( !a2 )
return a1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return v4;
}
|
func0:
ENDBR64
MOV EAX,EDI
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101290
NOP dword ptr [RAX]
LAB_00101280:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101280
MOV EAX,ECX
RET
LAB_00101290:
MOV ECX,EDI
MOV EAX,ECX
RET
|
int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
do {
iVar1 = param_2;
param_2 = param_1 % iVar1;
param_1 = iVar1;
} while (param_2 != 0);
return iVar1;
}
return param_1;
}
|
711 |
func0
|
#include <stdio.h>
|
int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
}
|
#include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov %edi,%eax
mov %esi,%edx
test %esi,%esi
je 1298 <func0+0x28>
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 1280 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
mov eax, edi
mov edx, esi
test esi, esi
jz short loc_1290
nop dword ptr [rax+00h]
loc_1280:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1280
mov eax, ecx
retn
loc_1290:
mov ecx, edi
mov eax, ecx
retn
|
long long func0(unsigned int a1, int a2)
{
signed int v2; // eax
int v3; // edx
unsigned int v4; // ecx
v2 = a1;
v3 = a2;
if ( !a2 )
return a1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return v4;
}
|
func0:
ENDBR64
MOV EAX,EDI
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101290
NOP dword ptr [RAX]
LAB_00101280:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101280
MOV EAX,ECX
RET
LAB_00101290:
MOV ECX,EDI
MOV EAX,ECX
RET
|
int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
do {
iVar1 = param_2;
param_2 = param_1 % iVar1;
param_1 = iVar1;
} while (param_2 != 0);
return iVar1;
}
return param_1;
}
|
712 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
current[current_len] = str[i];
current[current_len + 1] = '\0';
out[i] = malloc(strlen(current) + 1);
strcpy(out[i], current);
}
free(current);
*count = len;
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < count; i++) {
free(prefixes[i]);
}
free(prefixes);
}
int main() {
int count;
char **result;
result = func0("", &count);
assert(issame(result, 0, NULL, 0));
free_prefixes(result, count);
char *expected1[] = {"a", "as", "asd", "asdf", "asdfg", "asdfgh"};
result = func0("asdfgh", &count);
assert(issame(result, count, expected1, 6));
free_prefixes(result, count);
char *expected2[] = {"W", "WW", "WWW"};
result = func0("WWW", &count);
assert(issame(result, count, expected2, 3));
free_prefixes(result, count);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %eax,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x2c(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rax
movb $0x0,(%rax)
movl $0x0,-0x30(%rbp)
jmpq 133e <func0+0x115>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
lea 0x2(%rax),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <realloc@plt>
mov %rax,-0x28(%rbp)
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
mov -0x18(%rbp),%rax
lea 0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
add $0x1,%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,(%rbx)
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <strcpy@plt>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1289 <func0+0x60>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <free@plt>
mov -0x40(%rbp),%rax
mov -0x2c(%rbp),%edx
mov %edx,(%rax)
mov -0x20(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov eax, [rbp+var_2C]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+src], rax
mov rax, [rbp+src]
mov byte ptr [rax], 0
mov [rbp+var_30], 0
jmp loc_133E
loc_1289:
mov rax, [rbp+src]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
lea rdx, [rax+2]
mov rax, [rbp+src]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+src], rax
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
mov rcx, [rbp+src]
mov rdx, [rbp+var_18]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
mov rax, [rbp+var_18]
lea rdx, [rax+1]
mov rax, [rbp+src]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+src]
mov rdi, rax; s
call _strlen
add rax, 1
mov edx, [rbp+var_30]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_20]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_20]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+src]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
add [rbp+var_30], 1
loc_133E:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_2C]
jl loc_1289
mov rax, [rbp+src]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_40]
mov edx, [rbp+var_2C]
mov [rax], edx
mov rax, [rbp+var_20]
mov rbx, [rbp+var_8]
leave
retn
|
_QWORD * func0(const char *a1, _DWORD *a2)
{
size_t v2; // rax
int i; // [rsp+10h] [rbp-30h]
int v5; // [rsp+14h] [rbp-2Ch]
char *src; // [rsp+18h] [rbp-28h]
_QWORD *v7; // [rsp+20h] [rbp-20h]
size_t v8; // [rsp+28h] [rbp-18h]
v5 = strlen(a1);
v7 = malloc(8LL * v5);
src = (char *)malloc(v5 + 1);
*src = 0;
for ( i = 0; i < v5; ++i )
{
v8 = strlen(src);
src = (char *)realloc(src, v8 + 2);
src[v8] = a1[i];
src[v8 + 1] = 0;
v2 = strlen(src);
v7[i] = malloc(v2 + 1);
strcpy((char *)v7[i], src);
}
free(src);
*a2 = v5;
return v7;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010e0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010133e
LAB_00101289:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010e0
ADD RAX,0x1
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
ADD dword ptr [RBP + -0x30],0x1
LAB_0010133e:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101289
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
void *pvVar4;
int local_38;
char *local_30;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pvVar3 = malloc((long)iVar1 << 3);
local_30 = (char *)malloc((long)(iVar1 + 1));
*local_30 = '\0';
for (local_38 = 0; local_38 < iVar1; local_38 = local_38 + 1) {
sVar2 = strlen(local_30);
local_30 = (char *)realloc(local_30,sVar2 + 2);
local_30[sVar2] = param_1[local_38];
local_30[sVar2 + 1] = '\0';
sVar2 = strlen(local_30);
pvVar4 = malloc(sVar2 + 1);
*(void **)((long)local_38 * 8 + (long)pvVar3) = pvVar4;
strcpy(*(char **)((long)pvVar3 + (long)local_38 * 8),local_30);
}
free(local_30);
*param_2 = iVar1;
return pvVar3;
}
|
713 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
current[current_len] = str[i];
current[current_len + 1] = '\0';
out[i] = malloc(strlen(current) + 1);
strcpy(out[i], current);
}
free(current);
*count = len;
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < count; i++) {
free(prefixes[i]);
}
free(prefixes);
}
int main() {
int count;
char **result;
result = func0("", &count);
assert(issame(result, 0, NULL, 0));
free_prefixes(result, count);
char *expected1[] = {"a", "as", "asd", "asdf", "asdfg", "asdfgh"};
result = func0("asdfgh", &count);
assert(issame(result, count, expected1, 6));
free_prefixes(result, count);
char *expected2[] = {"W", "WW", "WWW"};
result = func0("WWW", &count);
assert(issame(result, count, expected2, 3));
free_prefixes(result, count);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r15
mov %rsi,0x18(%rsp)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r14
mov %r14,0x10(%rsp)
movslq %r14d,%rdi
shl $0x3,%rdi
callq 1100 <malloc@plt>
mov %rax,(%rsp)
lea 0x1(%r14),%edi
movslq %edi,%rdi
callq 1100 <malloc@plt>
mov %rax,%rbx
movb $0x0,(%rax)
test %r14d,%r14d
jle 12e8 <func0+0xdf>
lea -0x1(%r14),%eax
mov %rax,0x8(%rsp)
mov $0x0,%r13d
mov $0x0,%ebp
mov $0xffffffffffffffff,%rcx
mov %rbx,%rdi
mov %ebp,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%r12
lea 0x1(%rcx),%rsi
mov %rbx,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbx
movzbl (%r15,%r13,1),%eax
mov %al,-0x1(%rbx,%r12,1)
movb $0x0,(%rbx,%r12,1)
mov $0xffffffffffffffff,%rcx
mov %rbx,%rdi
mov %ebp,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
callq 1100 <malloc@plt>
mov %rax,%rdi
mov (%rsp),%rax
mov %rdi,(%rax,%r13,8)
mov %rbx,%rsi
callq 10c0 <strcpy@plt>
mov %r13,%rax
add $0x1,%r13
cmp 0x8(%rsp),%rax
jne 1277 <func0+0x6e>
mov %rbx,%rdi
callq 10b0 <free@plt>
mov 0x18(%rsp),%rax
mov 0x10(%rsp),%edx
mov %edx,(%rax)
mov (%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r14, rdi
mov [rsp+48h+var_48], rsi
call _strlen
mov r15, rax
mov [rsp+48h+var_40], rax
movsxd rdi, eax
shl rdi, 3; size
call _malloc
mov r13, rax
lea edi, [r15+1]
movsxd rdi, edi; size
call _malloc
mov rbx, rax
mov byte ptr [rax], 0
test r15d, r15d
jle short loc_12D9
lea r15d, [r15-1]
mov r12d, 0
loc_127F:
mov rdi, rbx; s
call _strlen
mov rbp, rax
lea rsi, [rax+2]; size
mov rdi, rbx; ptr
call _realloc
mov rbx, rax
movzx eax, byte ptr [r14+r12]
mov [rbx+rbp], al
mov byte ptr [rbx+rbp+1], 0
mov rdi, rbx; s
call _strlen
lea rbp, [rax+1]
mov rdi, rbp; size
call _malloc
mov rdi, rax
mov [r13+r12*8+0], rax
mov rdx, rbp
mov rsi, rbx
call ___strcpy_chk
mov rax, r12
add r12, 1
cmp rax, r15
jnz short loc_127F
loc_12D9:
mov rdi, rbx; ptr
call _free
mov rax, [rsp+48h+var_48]
mov ecx, dword ptr [rsp+48h+var_40]
mov [rax], ecx
mov rax, r13
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
_QWORD * func0(const char *a1, int *a2)
{
int v2; // r15d
_QWORD *v3; // r13
char *v4; // rbx
long long v5; // r15
long long v6; // r12
size_t v7; // rbp
size_t v8; // rbp
void *v9; // rax
long long v10; // rax
int v12; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v12 = v2;
v3 = malloc(8LL * v2);
v4 = (char *)malloc(v2 + 1);
*v4 = 0;
if ( v2 > 0 )
{
v5 = (unsigned int)(v2 - 1);
v6 = 0LL;
do
{
v7 = strlen(v4);
v4 = (char *)realloc(v4, v7 + 2);
*(_WORD *)&v4[v7] = (unsigned __int8)a1[v6];
v8 = strlen(v4) + 1;
v9 = malloc(v8);
v3[v6] = v9;
__strcpy_chk(v9, v4, v8);
v10 = v6++;
}
while ( v10 != v5 );
}
free(v4);
*a2 = v12;
return v3;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV qword ptr [RSP],RSI
CALL 0x001010d0
MOV R15,RAX
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00101110
MOV R13,RAX
LEA EDI,[R15 + 0x1]
MOVSXD RDI,EDI
CALL 0x00101110
MOV RBX,RAX
MOV byte ptr [RAX],0x0
TEST R15D,R15D
JLE 0x001012d9
LEA R15D,[R15 + -0x1]
MOV R12D,0x0
LAB_0010127f:
MOV RDI,RBX
CALL 0x001010d0
MOV RBP,RAX
LEA RSI,[RAX + 0x2]
MOV RDI,RBX
CALL 0x00101120
MOV RBX,RAX
MOVZX EAX,byte ptr [R14 + R12*0x1]
MOV byte ptr [RBX + RBP*0x1],AL
MOV byte ptr [RBX + RBP*0x1 + 0x1],0x0
MOV RDI,RBX
CALL 0x001010d0
LEA RBP,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101110
MOV RDI,RAX
MOV qword ptr [R13 + R12*0x8],RAX
MOV RDX,RBP
MOV RSI,RBX
CALL 0x00101130
MOV RAX,R12
ADD R12,0x1
CMP RAX,R15
JNZ 0x0010127f
LAB_001012d9:
MOV RDI,RBX
CALL 0x001010c0
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RSP + 0x8]
MOV dword ptr [RAX],ECX
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
char *__s;
void *pvVar4;
ulong uVar5;
bool bVar6;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pvVar3 = malloc((long)iVar1 << 3);
__s = (char *)malloc((long)(iVar1 + 1));
*__s = '\0';
if (0 < iVar1) {
uVar5 = 0;
do {
sVar2 = strlen(__s);
__s = (char *)realloc(__s,sVar2 + 2);
__s[sVar2] = param_1[uVar5];
__s[sVar2 + 1] = '\0';
sVar2 = strlen(__s);
pvVar4 = malloc(sVar2 + 1);
*(void **)((long)pvVar3 + uVar5 * 8) = pvVar4;
__strcpy_chk(pvVar4,__s,sVar2 + 1);
bVar6 = uVar5 != iVar1 - 1;
uVar5 = uVar5 + 1;
} while (bVar6);
}
free(__s);
*param_2 = iVar1;
return pvVar3;
}
|
714 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
current[current_len] = str[i];
current[current_len + 1] = '\0';
out[i] = malloc(strlen(current) + 1);
strcpy(out[i], current);
}
free(current);
*count = len;
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < count; i++) {
free(prefixes[i]);
}
free(prefixes);
}
int main() {
int count;
char **result;
result = func0("", &count);
assert(issame(result, 0, NULL, 0));
free_prefixes(result, count);
char *expected1[] = {"a", "as", "asd", "asdf", "asdfg", "asdfgh"};
result = func0("asdfgh", &count);
assert(issame(result, count, expected1, 6));
free_prefixes(result, count);
char *expected2[] = {"W", "WW", "WWW"};
result = func0("WWW", &count);
assert(issame(result, count, expected2, 3));
free_prefixes(result, count);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
mov %rsi,(%rsp)
callq 10d0 <strlen@plt>
movslq %eax,%rdi
mov %rax,%rbx
mov %rax,0x8(%rsp)
shl $0x3,%rdi
callq 1120 <malloc@plt>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
mov %rax,%r12
callq 1120 <malloc@plt>
movb $0x0,(%rax)
mov %rax,%r15
test %ebx,%ebx
jle 156c <func0+0x11c>
lea -0x1(%rbx),%r13d
xor %ebx,%ebx
nopl 0x0(%rax)
mov %r15,%r14
mov (%r14),%ecx
add $0x4,%r14
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 14ab <func0+0x5b>
mov %eax,%ecx
mov %r15,%rdi
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%r14),%rcx
cmove %rcx,%r14
mov %eax,%esi
add %al,%sil
sbb $0x3,%r14
sub %r15,%r14
lea 0x2(%r14),%rsi
callq 1130 <realloc@plt>
mov %rax,%r15
movzbl 0x0(%rbp,%rbx,1),%eax
movb $0x0,0x1(%r15,%r14,1)
mov %r15,%rdx
mov %al,(%r15,%r14,1)
mov (%rdx),%eax
add $0x4,%rdx
lea -0x1010101(%rax),%ecx
not %eax
and %eax,%ecx
and $0x80808080,%ecx
je 1505 <func0+0xb5>
mov %ecx,%eax
shr $0x10,%eax
test $0x8080,%ecx
cmove %eax,%ecx
lea 0x2(%rdx),%rax
cmove %rax,%rdx
mov %ecx,%eax
add %cl,%al
sbb $0x3,%rdx
sub %r15,%rdx
lea 0x1(%rdx),%r14
mov %r14,%rdi
callq 1120 <malloc@plt>
mov %r14,%rdx
mov %r15,%rsi
mov %rax,%rdi
mov %rax,(%r12,%rbx,8)
callq 1110 <memcpy@plt>
mov %rbx,%rax
add $0x1,%rbx
cmp %r13,%rax
jne 14a8 <func0+0x58>
mov %r15,%rdi
callq 10c0 <free@plt>
mov (%rsp),%rax
mov 0x8(%rsp),%ebx
mov %ebx,(%rax)
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rsi
call _strlen
movsxd rdi, eax
mov r14, rax
mov [rsp+48h+var_40], rax
shl rdi, 3; size
call _malloc
lea edi, [r14+1]
movsxd rdi, edi; size
mov r12, rax
call _malloc
mov byte ptr [rax], 0
mov rbx, rax
test r14d, r14d
jle short loc_1527
sub r14d, 1
xor ebp, ebp
nop word ptr [rax+rax+00h]
loc_14C8:
mov rdi, rbx; s
call _strlen
mov rdi, rbx; ptr
lea rsi, [rax+2]; size
mov r15, rax
call _realloc
mov rbx, rax
movzx eax, byte ptr [r13+rbp+0]
mov byte ptr [rbx+r15+1], 0
mov rdi, rbx; s
mov [rbx+r15], al
call _strlen
lea r15, [rax+1]
mov rdi, r15; size
call _malloc
mov rcx, r15
mov rdx, r15
mov rsi, rbx
mov [r12+rbp*8], rax
mov rdi, rax
call ___memcpy_chk
mov rax, rbp
add rbp, 1
cmp rax, r14
jnz short loc_14C8
loc_1527:
mov rdi, rbx; ptr
call _free
mov rax, [rsp+48h+var_48]
mov edx, dword ptr [rsp+48h+var_40]
mov [rax], edx
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
_QWORD * func0(const char *a1, int *a2)
{
int v2; // r14d
_QWORD *v3; // r12
char *v4; // rax
char *v5; // rbx
long long v6; // r14
long long v7; // rbp
size_t v8; // r15
char v9; // al
size_t v10; // r15
void *v11; // rax
long long v12; // rax
int v14; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v14 = v2;
v3 = malloc(8LL * v2);
v4 = (char *)malloc(v2 + 1);
*v4 = 0;
v5 = v4;
if ( v2 > 0 )
{
v6 = (unsigned int)(v2 - 1);
v7 = 0LL;
do
{
v8 = strlen(v5);
v5 = (char *)realloc(v5, v8 + 2);
v9 = a1[v7];
v5[v8 + 1] = 0;
v5[v8] = v9;
v10 = strlen(v5) + 1;
v11 = malloc(v10);
v3[v7] = v11;
__memcpy_chk(v11, v5, v10, v10);
v12 = v7++;
}
while ( v12 != v6 );
}
free(v5);
*a2 = v14;
return v3;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RSI
CALL 0x001010d0
MOVSXD RDI,EAX
MOV R14,RAX
MOV qword ptr [RSP + 0x8],RAX
SHL RDI,0x3
CALL 0x00101120
LEA EDI,[R14 + 0x1]
MOVSXD RDI,EDI
MOV R12,RAX
CALL 0x00101120
MOV byte ptr [RAX],0x0
MOV RBX,RAX
TEST R14D,R14D
JLE 0x00101527
SUB R14D,0x1
XOR EBP,EBP
NOP word ptr [RAX + RAX*0x1]
LAB_001014c8:
MOV RDI,RBX
CALL 0x001010d0
MOV RDI,RBX
LEA RSI,[RAX + 0x2]
MOV R15,RAX
CALL 0x00101130
MOV RBX,RAX
MOVZX EAX,byte ptr [R13 + RBP*0x1]
MOV byte ptr [RBX + R15*0x1 + 0x1],0x0
MOV RDI,RBX
MOV byte ptr [RBX + R15*0x1],AL
CALL 0x001010d0
LEA R15,[RAX + 0x1]
MOV RDI,R15
CALL 0x00101120
MOV RCX,R15
MOV RDX,R15
MOV RSI,RBX
MOV qword ptr [R12 + RBP*0x8],RAX
MOV RDI,RAX
CALL 0x00101110
MOV RAX,RBP
ADD RBP,0x1
CMP RAX,R14
JNZ 0x001014c8
LAB_00101527:
MOV RDI,RBX
CALL 0x001010c0
MOV RAX,qword ptr [RSP]
MOV EDX,dword ptr [RSP + 0x8]
MOV dword ptr [RAX],EDX
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void * func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *__s;
void *pvVar5;
ulong uVar6;
bool bVar7;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
__s = (char *)malloc((long)(iVar2 + 1));
*__s = '\0';
if (0 < iVar2) {
uVar6 = 0;
do {
sVar3 = strlen(__s);
__s = (char *)realloc(__s,sVar3 + 2);
cVar1 = param_1[uVar6];
__s[sVar3 + 1] = '\0';
__s[sVar3] = cVar1;
sVar3 = strlen(__s);
sVar3 = sVar3 + 1;
pvVar5 = malloc(sVar3);
*(void **)((long)pvVar4 + uVar6 * 8) = pvVar5;
__memcpy_chk(pvVar5,__s,sVar3,sVar3);
bVar7 = uVar6 != iVar2 - 1;
uVar6 = uVar6 + 1;
} while (bVar7);
}
free(__s);
*param_2 = iVar2;
return pvVar4;
}
|
715 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
current[current_len] = str[i];
current[current_len + 1] = '\0';
out[i] = malloc(strlen(current) + 1);
strcpy(out[i], current);
}
free(current);
*count = len;
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < count; i++) {
free(prefixes[i]);
}
free(prefixes);
}
int main() {
int count;
char **result;
result = func0("", &count);
assert(issame(result, 0, NULL, 0));
free_prefixes(result, count);
char *expected1[] = {"a", "as", "asd", "asdf", "asdfg", "asdfgh"};
result = func0("asdfgh", &count);
assert(issame(result, count, expected1, 6));
free_prefixes(result, count);
char *expected2[] = {"W", "WW", "WWW"};
result = func0("WWW", &count);
assert(issame(result, count, expected2, 3));
free_prefixes(result, count);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
mov %rsi,(%rsp)
callq 10d0 <strlen@plt>
movslq %eax,%rdi
mov %rax,%rbx
mov %rax,0x8(%rsp)
shl $0x3,%rdi
callq 1120 <malloc@plt>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
mov %rax,%r12
callq 1120 <malloc@plt>
movb $0x0,(%rax)
mov %rax,%r15
test %ebx,%ebx
jle 159c <func0+0x11c>
lea -0x1(%rbx),%r13d
xor %ebx,%ebx
nopl 0x0(%rax)
mov %r15,%r14
mov (%r14),%ecx
add $0x4,%r14
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 14db <func0+0x5b>
mov %eax,%ecx
mov %r15,%rdi
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%r14),%rcx
cmove %rcx,%r14
mov %eax,%esi
add %al,%sil
sbb $0x3,%r14
sub %r15,%r14
lea 0x2(%r14),%rsi
callq 1130 <realloc@plt>
mov %rax,%r15
movzbl 0x0(%rbp,%rbx,1),%eax
movb $0x0,0x1(%r15,%r14,1)
mov %r15,%rdx
mov %al,(%r15,%r14,1)
mov (%rdx),%eax
add $0x4,%rdx
lea -0x1010101(%rax),%ecx
not %eax
and %eax,%ecx
and $0x80808080,%ecx
je 1535 <func0+0xb5>
mov %ecx,%eax
shr $0x10,%eax
test $0x8080,%ecx
cmove %eax,%ecx
lea 0x2(%rdx),%rax
cmove %rax,%rdx
mov %ecx,%eax
add %cl,%al
sbb $0x3,%rdx
sub %r15,%rdx
lea 0x1(%rdx),%r14
mov %r14,%rdi
callq 1120 <malloc@plt>
mov %r14,%rdx
mov %r15,%rsi
mov %rax,%rdi
mov %rax,(%r12,%rbx,8)
callq 1110 <memcpy@plt>
mov %rbx,%rax
add $0x1,%rbx
cmp %r13,%rax
jne 14d8 <func0+0x58>
mov %r15,%rdi
callq 10c0 <free@plt>
mov (%rsp),%rax
mov 0x8(%rsp),%ebx
mov %ebx,(%rax)
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rsi
call _strlen
movsxd rdi, eax
mov r14, rax
mov [rsp+48h+var_40], rax
shl rdi, 3; size
call _malloc
lea edi, [r14+1]
movsxd rdi, edi; size
mov r12, rax
call _malloc
mov byte ptr [rax], 0
mov rbx, rax
test r14d, r14d
jle short loc_1527
sub r14d, 1
xor ebp, ebp
nop word ptr [rax+rax+00h]
loc_14C8:
mov rdi, rbx; s
call _strlen
mov rdi, rbx; ptr
lea rsi, [rax+2]; size
mov r15, rax
call _realloc
mov rbx, rax
movzx eax, byte ptr [r13+rbp+0]
mov byte ptr [rbx+r15+1], 0
mov rdi, rbx; s
mov [rbx+r15], al
call _strlen
lea r15, [rax+1]
mov rdi, r15; size
call _malloc
mov rcx, r15
mov rdx, r15
mov rsi, rbx
mov [r12+rbp*8], rax
mov rdi, rax
call ___memcpy_chk
mov rax, rbp
add rbp, 1
cmp r14, rax
jnz short loc_14C8
loc_1527:
mov rdi, rbx; ptr
call _free
mov rax, [rsp+48h+var_48]
mov edx, dword ptr [rsp+48h+var_40]
mov [rax], edx
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
_QWORD * func0(const char *a1, int *a2)
{
int v2; // r14d
_QWORD *v3; // r12
char *v4; // rax
char *v5; // rbx
long long v6; // r14
long long v7; // rbp
size_t v8; // r15
char v9; // al
size_t v10; // r15
void *v11; // rax
long long v12; // rax
int v14; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v14 = v2;
v3 = malloc(8LL * v2);
v4 = (char *)malloc(v2 + 1);
*v4 = 0;
v5 = v4;
if ( v2 > 0 )
{
v6 = (unsigned int)(v2 - 1);
v7 = 0LL;
do
{
v8 = strlen(v5);
v5 = (char *)realloc(v5, v8 + 2);
v9 = a1[v7];
v5[v8 + 1] = 0;
v5[v8] = v9;
v10 = strlen(v5) + 1;
v11 = malloc(v10);
v3[v7] = v11;
__memcpy_chk(v11, v5, v10, v10);
v12 = v7++;
}
while ( v6 != v12 );
}
free(v5);
*a2 = v14;
return v3;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RSI
CALL 0x001010d0
MOVSXD RDI,EAX
MOV R14,RAX
MOV qword ptr [RSP + 0x8],RAX
SHL RDI,0x3
CALL 0x00101120
LEA EDI,[R14 + 0x1]
MOVSXD RDI,EDI
MOV R12,RAX
CALL 0x00101120
MOV byte ptr [RAX],0x0
MOV RBX,RAX
TEST R14D,R14D
JLE 0x00101527
SUB R14D,0x1
XOR EBP,EBP
NOP word ptr [RAX + RAX*0x1]
LAB_001014c8:
MOV RDI,RBX
CALL 0x001010d0
MOV RDI,RBX
LEA RSI,[RAX + 0x2]
MOV R15,RAX
CALL 0x00101130
MOV RBX,RAX
MOVZX EAX,byte ptr [R13 + RBP*0x1]
MOV byte ptr [RBX + R15*0x1 + 0x1],0x0
MOV RDI,RBX
MOV byte ptr [RBX + R15*0x1],AL
CALL 0x001010d0
LEA R15,[RAX + 0x1]
MOV RDI,R15
CALL 0x00101120
MOV RCX,R15
MOV RDX,R15
MOV RSI,RBX
MOV qword ptr [R12 + RBP*0x8],RAX
MOV RDI,RAX
CALL 0x00101110
MOV RAX,RBP
ADD RBP,0x1
CMP R14,RAX
JNZ 0x001014c8
LAB_00101527:
MOV RDI,RBX
CALL 0x001010c0
MOV RAX,qword ptr [RSP]
MOV EDX,dword ptr [RSP + 0x8]
MOV dword ptr [RAX],EDX
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void * func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *__s;
void *pvVar5;
ulong uVar6;
bool bVar7;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
__s = (char *)malloc((long)(iVar2 + 1));
*__s = '\0';
if (0 < iVar2) {
uVar6 = 0;
do {
sVar3 = strlen(__s);
__s = (char *)realloc(__s,sVar3 + 2);
cVar1 = param_1[uVar6];
__s[sVar3 + 1] = '\0';
__s[sVar3] = cVar1;
sVar3 = strlen(__s);
sVar3 = sVar3 + 1;
pvVar5 = malloc(sVar3);
*(void **)((long)pvVar4 + uVar6 * 8) = pvVar5;
__memcpy_chk(pvVar5,__s,sVar3,sVar3);
bVar7 = iVar2 - 1 != uVar6;
uVar6 = uVar6 + 1;
} while (bVar7);
}
free(__s);
*param_2 = iVar2;
return pvVar4;
}
|
716 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d", i);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0);
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
movl $0x2,-0x1c(%rbp)
movl $0x1,-0x18(%rbp)
jmp 122f <func0+0x46>
mov -0x18(%rbp),%eax
mov %eax,%ecx
lea 0xdf4(%rip),%rdx
mov $0x0,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 10b0 <snprintf@plt>
add %eax,-0x1c(%rbp)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 1208 <func0+0x1f>
mov -0x1c(%rbp),%eax
cltq
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 1256 <func0+0x6d>
mov $0x0,%eax
jmp 12b6 <func0+0xcd>
mov -0x8(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
lea 0xda3(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10f0 <sprintf@plt>
cltq
add %rax,-0x10(%rbp)
movl $0x1,-0x14(%rbp)
jmp 12aa <func0+0xc1>
mov -0x14(%rbp),%edx
mov -0x10(%rbp),%rax
lea 0xd75(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10f0 <sprintf@plt>
cltq
add %rax,-0x10(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 1285 <func0+0x9c>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_1C], 2
mov [rbp+var_18], 1
jmp short loc_1232
loc_1208:
mov eax, [rbp+var_18]
mov ecx, eax
lea rax, format; " %d"
mov rdx, rax; format
mov esi, 0; maxlen
mov edi, 0; s
mov eax, 0
call _snprintf
add [rbp+var_1C], eax
add [rbp+var_18], 1
loc_1232:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_24]
jle short loc_1208
mov eax, [rbp+var_1C]
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_1259
mov eax, 0
jmp short locret_12BF
loc_1259:
mov rax, [rbp+var_8]
mov [rbp+s], rax
mov rax, [rbp+s]
lea rdx, s2; "0"
mov rsi, rdx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
cdqe
add [rbp+s], rax
mov [rbp+var_14], 1
jmp short loc_12B3
loc_128B:
mov edx, [rbp+var_14]
mov rax, [rbp+s]
lea rcx, format; " %d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
cdqe
add [rbp+s], rax
add [rbp+var_14], 1
loc_12B3:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jle short loc_128B
mov rax, [rbp+var_8]
locret_12BF:
leave
retn
|
char * func0(int a1)
{
int v2; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
char *s; // [rsp+20h] [rbp-10h]
char *v6; // [rsp+28h] [rbp-8h]
v2 = 2;
for ( i = 1; i <= a1; ++i )
v2 += snprintf(0LL, 0LL, " %d", i);
v6 = (char *)malloc(v2);
if ( !v6 )
return 0LL;
s = &v6[sprintf(v6, "0")];
for ( j = 1; j <= a1; ++j )
s += sprintf(s, " %d", j);
return v6;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x1c],0x2
MOV dword ptr [RBP + -0x18],0x1
JMP 0x00101232
LAB_00101208:
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,EAX
LEA RAX,[0x102008]
MOV RDX,RAX
MOV ESI,0x0
MOV EDI,0x0
MOV EAX,0x0
CALL 0x001010b0
ADD dword ptr [RBP + -0x1c],EAX
ADD dword ptr [RBP + -0x18],0x1
LAB_00101232:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x00101208
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x00101259
MOV EAX,0x0
JMP 0x001012bf
LAB_00101259:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[0x10200c]
MOV RSI,RDX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010f0
CDQE
ADD qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001012b3
LAB_0010128b:
MOV EDX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010f0
CDQE
ADD qword ptr [RBP + -0x10],RAX
ADD dword ptr [RBP + -0x14],0x1
LAB_001012b3:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x0010128b
MOV RAX,qword ptr [RBP + -0x8]
LAB_001012bf:
LEAVE
RET
|
char * func0(int param_1)
{
int iVar1;
char *__s;
int local_24;
uint local_20;
uint local_1c;
char *local_18;
local_24 = 2;
for (local_20 = 1; (int)local_20 <= param_1; local_20 = local_20 + 1) {
iVar1 = snprintf((char *)0x0,0," %d",(ulong)local_20);
local_24 = local_24 + iVar1;
}
__s = (char *)malloc((long)local_24);
if (__s == (char *)0x0) {
__s = (char *)0x0;
}
else {
iVar1 = sprintf(__s,"0");
local_18 = __s + iVar1;
for (local_1c = 1; (int)local_1c <= param_1; local_1c = local_1c + 1) {
iVar1 = sprintf(local_18," %d",(ulong)local_1c);
local_18 = local_18 + iVar1;
}
}
return __s;
}
|
717 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d", i);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0);
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %edi,%edi
jle 1283 <func0+0xba>
mov %edi,%r12d
lea 0x1(%rdi),%r14d
mov $0x1,%ebx
mov $0x2,%ebp
lea 0xe0f(%rip),%r13
mov %ebx,%r9d
mov %r13,%r8
mov $0xffffffffffffffff,%rcx
mov $0x1,%edx
mov $0x0,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 1090 <__snprintf_chk@plt>
add %eax,%ebp
add $0x1,%ebx
cmp %r14d,%ebx
jne 11f5 <func0+0x2c>
movslq %ebp,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 1277 <func0+0xae>
movw $0x30,(%r14)
lea 0x1(%r14),%rbp
mov $0x1,%ebx
lea 0xdb9(%rip),%r13
mov %ebx,%r8d
mov %r13,%rcx
mov $0xffffffffffffffff,%rdx
mov $0x1,%esi
mov %rbp,%rdi
mov $0x0,%eax
callq 10d0 <__sprintf_chk@plt>
cltq
add %rax,%rbp
add $0x1,%ebx
cmp %ebx,%r12d
jge 124b <func0+0x82>
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x2,%edi
callq 10c0 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 1277 <func0+0xae>
movw $0x30,(%rax)
jmp 1277 <func0+0xae>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r14d, edi
test edi, edi
jle loc_1328
lea r13d, [rdi+1]
mov ebx, 1
mov ebp, 2
lea r12, unk_2004
loc_123B:
mov r9d, ebx
mov r8, r12
mov rcx, 0FFFFFFFFFFFFFFFFh
mov edx, 2
mov esi, 0
mov edi, 0
mov eax, 0
call ___snprintf_chk
add ebp, eax
add ebx, 1
cmp r13d, ebx
jnz short loc_123B
movsxd rbp, ebp
mov rdi, rbp; size
call _malloc
mov [rsp+48h+var_40], rax
test rax, rax
jz loc_1314
lea rcx, assertion+17h; "0"
mov rdx, rbp
mov esi, 2
mov r15, [rsp+48h+var_40]
mov rdi, r15
mov eax, 0
call ___sprintf_chk
test rbp, rbp
mov ebx, 1
cmovnz rbx, rbp
sub rbx, 1
lea r13, [r15+1]
loc_12B9:
add r14d, 1
mov r12d, 1
lea r15, unk_2004
loc_12CA:
mov r8d, r12d
mov rcx, r15
mov rdx, rbx
mov esi, 2
mov rdi, r13
mov eax, 0
call ___sprintf_chk
cdqe
cmp rbx, rbp
mov rcx, rbp
cmovnb rcx, rbx
lea rsi, [rax+rcx]
mov rdx, rsi
sub rdx, rbx
cmp rdx, rcx
cmovb rdx, rcx
sub rbx, rsi
add rbx, rdx
add r13, rax
add r12d, 1
cmp r12d, r14d
jnz short loc_12CA
loc_1314:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1328:
mov edi, 2; size
call _malloc
mov rdi, rax; s
mov [rsp+48h+var_40], rax
test rax, rax
jz short loc_1314
lea rsi, assertion+17h; format
mov eax, 0
call _sprintf
test r14d, r14d
jle short loc_1314
mov rax, [rsp+48h+var_40]
lea r13, [rax+1]
mov ebx, 1
mov ebp, 2
jmp loc_12B9
|
char * func0(int a1)
{
unsigned int v2; // ebx
unsigned long long v3; // rbp
long long v4; // rbx
unsigned long long v5; // rbx
char *v6; // r13
int v7; // r14d
int v8; // r12d
int v9; // eax
unsigned long long v10; // rcx
unsigned long long v11; // rdx
char *v13; // rdi
char *v14; // [rsp+8h] [rbp-40h]
if ( a1 <= 0 )
{
v13 = (char *)malloc(2uLL);
v14 = v13;
if ( !v13 )
return v14;
sprintf(v13, "0");
if ( a1 <= 0 )
return v14;
v6 = v13 + 1;
v5 = 1LL;
v3 = 2LL;
}
else
{
v2 = 1;
LODWORD(v3) = 2;
do
LODWORD(v3) = __snprintf_chk(0LL, 0LL, 2LL, -1LL, &unk_2004, v2++) + v3;
while ( a1 + 1 != v2 );
v3 = (int)v3;
v14 = (char *)malloc((int)v3);
if ( !v14 )
return v14;
__sprintf_chk(v14, 2LL, (int)v3, "0");
v4 = 1LL;
if ( (_DWORD)v3 )
v4 = (int)v3;
v5 = v4 - 1;
v6 = v14 + 1;
}
v7 = a1 + 1;
v8 = 1;
do
{
v9 = __sprintf_chk(v6, 2LL, v5, &unk_2004);
v10 = v3;
if ( v5 >= v3 )
v10 = v5;
v11 = v9 + v10 - v5;
if ( v11 < v10 )
v11 = v10;
v5 = v11 + v5 - (v9 + v10);
v6 += v9;
++v8;
}
while ( v8 != v7 );
return v14;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R14D,EDI
TEST EDI,EDI
JLE 0x00101328
LEA R13D,[RDI + 0x1]
MOV EBX,0x1
MOV EBP,0x2
LEA R12,[0x102004]
LAB_0010123b:
MOV R9D,EBX
MOV R8,R12
MOV RCX,-0x1
MOV EDX,0x2
MOV ESI,0x0
MOV EDI,0x0
MOV EAX,0x0
CALL 0x001010b0
ADD EBP,EAX
ADD EBX,0x1
CMP R13D,EBX
JNZ 0x0010123b
MOVSXD RBP,EBP
MOV RDI,RBP
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x00101314
LEA RCX,[0x10201f]
MOV RDX,RBP
MOV ESI,0x2
MOV R15,qword ptr [RSP + 0x8]
MOV RDI,R15
MOV EAX,0x0
CALL 0x00101110
TEST RBP,RBP
MOV EBX,0x1
CMOVNZ RBX,RBP
SUB RBX,0x1
LEA R13,[R15 + 0x1]
LAB_001012b9:
ADD R14D,0x1
MOV R12D,0x1
LEA R15,[0x102004]
LAB_001012ca:
MOV R8D,R12D
MOV RCX,R15
MOV RDX,RBX
MOV ESI,0x2
MOV RDI,R13
MOV EAX,0x0
CALL 0x00101110
CDQE
CMP RBX,RBP
MOV RCX,RBP
CMOVNC RCX,RBX
LEA RSI,[RAX + RCX*0x1]
MOV RDX,RSI
SUB RDX,RBX
CMP RDX,RCX
CMOVC RDX,RCX
SUB RBX,RSI
ADD RBX,RDX
ADD R13,RAX
ADD R12D,0x1
CMP R12D,R14D
JNZ 0x001012ca
LAB_00101314:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101328:
MOV EDI,0x2
CALL 0x001010f0
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x00101314
LEA RSI,[0x10201f]
MOV EAX,0x0
CALL 0x00101100
TEST R14D,R14D
JLE 0x00101314
MOV RAX,qword ptr [RSP + 0x8]
LEA R13,[RAX + 0x1]
MOV EBX,0x1
MOV EBP,0x2
JMP 0x001012b9
|
char * func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int iVar8;
ulong __size;
char *pcVar9;
char *local_40;
size_t sVar7;
if (param_1 < 1) {
local_40 = (char *)malloc(2);
if (local_40 == (char *)0x0) {
return (char *)0x0;
}
sprintf(local_40,"0");
if (param_1 < 1) {
return local_40;
}
uVar6 = 1;
__size = 2;
}
else {
iVar5 = 1;
iVar8 = 2;
do {
iVar2 = __snprintf_chk(0,0,2,0xffffffffffffffff,&DAT_00102004,iVar5);
iVar8 = iVar8 + iVar2;
iVar5 = iVar5 + 1;
} while (param_1 + 1 != iVar5);
__size = (ulong)iVar8;
local_40 = (char *)malloc(__size);
if (local_40 == (char *)0x0) {
return (char *)0x0;
}
__sprintf_chk(local_40,2,__size,"0");
sVar7 = 1;
if (__size != 0) {
sVar7 = __size;
}
uVar6 = sVar7 - 1;
}
pcVar9 = local_40 + 1;
iVar5 = 1;
do {
iVar8 = __sprintf_chk(pcVar9,2,uVar6,&DAT_00102004,iVar5);
uVar3 = __size;
if (__size <= uVar6) {
uVar3 = uVar6;
}
lVar1 = (long)iVar8 + uVar3;
uVar4 = lVar1 - uVar6;
if (uVar4 < uVar3) {
uVar4 = uVar3;
}
uVar6 = (uVar6 - lVar1) + uVar4;
pcVar9 = pcVar9 + iVar8;
iVar5 = iVar5 + 1;
} while (iVar5 != param_1 + 1);
return local_40;
}
|
718 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d", i);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0);
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %edi,%edi
jle 1380 <func0+0xc0>
lea 0x1(%rdi),%r12d
mov $0x1,%ebx
mov $0x2,%ebp
lea 0xd1b(%rip),%r13
nopl 0x0(%rax)
mov %ebx,%r9d
mov %r13,%r8
mov $0xffffffffffffffff,%rcx
xor %esi,%esi
mov $0x1,%edx
xor %edi,%edi
xor %eax,%eax
mov %ebx,%r14d
callq 1090 <__snprintf_chk@plt>
lea 0x1(%rbx),%ebx
add %eax,%ebp
cmp %r12d,%ebx
jne 12f0 <func0+0x30>
movslq %ebp,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 13a6 <func0+0xe6>
mov $0x30,%eax
lea 0x1(%r13),%rbp
mov $0x1,%ebx
mov %ax,0x0(%r13)
lea 0xcc0(%rip),%r12
nopl 0x0(%rax)
mov %ebx,%r8d
mov %rbp,%rdi
mov %r12,%rcx
mov $0xffffffffffffffff,%rdx
mov $0x1,%esi
xor %eax,%eax
callq 10d0 <__sprintf_chk@plt>
cltq
add %rax,%rbp
mov %ebx,%eax
add $0x1,%ebx
cmp %eax,%r14d
jne 1348 <func0+0x88>
pop %rbx
mov %r13,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x2,%edi
callq 10c0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 13a6 <func0+0xe6>
mov $0x30,%edx
mov %dx,(%rax)
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r13d,%r13d
jmp 1373 <func0+0xb3>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test edi, edi
jle loc_13F0
lea r12d, [rdi+1]
mov ebx, 1
mov ebp, 2
lea r13, unk_2004
nop
loc_1310:
mov r9d, ebx
mov r8, r13
mov rcx, 0FFFFFFFFFFFFFFFFh
xor esi, esi
mov edx, 2
xor edi, edi
xor eax, eax
add ebx, 1
call ___snprintf_chk
add ebp, eax
cmp r12d, ebx
jnz short loc_1310
movsxd rbp, ebp
mov rdi, rbp; size
call _malloc
mov [rsp+48h+var_40], rax
test rax, rax
jz loc_13D7
mov r14, [rsp+48h+var_40]
xor eax, eax
mov rdx, rbp
mov esi, 2
lea rcx, assertion+17h; "0"
mov ebx, 1
mov r15d, 1
mov rdi, r14
lea r13, unk_2004
call ___sprintf_chk
test rbp, rbp
cmovnz rbx, rbp
add r14, 1
sub rbx, 1
nop
loc_1390:
mov rdx, rbx
mov r8d, r15d
mov rcx, r13
mov esi, 2
mov rdi, r14
xor eax, eax
call ___sprintf_chk
cmp rbp, rbx
mov rcx, rbx
cmovnb rcx, rbp
cdqe
lea rsi, [rax+rcx]
mov rdx, rsi
sub rdx, rbx
cmp rdx, rcx
cmovb rdx, rcx
sub rbx, rsi
add r15d, 1
add r14, rax
add rbx, rdx
cmp r15d, r12d
jnz short loc_1390
loc_13D7:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13F0:
mov edi, 2; size
call _malloc
mov [rsp+48h+var_40], rax
mov rdi, rax; s
test rax, rax
jz short loc_13D7
lea rsi, assertion+17h; format
xor eax, eax
call _sprintf
jmp short loc_13D7
|
char * func0(int a1)
{
int v1; // r12d
unsigned int v2; // ebx
int v3; // ebp
long long v4; // r9
long long v5; // rbx
int v6; // r15d
char *v7; // r14
unsigned long long v8; // rbx
int v9; // eax
unsigned long long v10; // rcx
unsigned long long v11; // rdx
char *v13; // [rsp+8h] [rbp-40h]
if ( a1 <= 0 )
{
v13 = (char *)malloc(2uLL);
if ( v13 )
sprintf(v13, "0");
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 2;
do
{
v4 = v2++;
v3 += __snprintf_chk(0LL, 0LL, 2LL, -1LL, &unk_2004, v4);
}
while ( v1 != v2 );
v13 = (char *)malloc(v3);
if ( v13 )
{
v5 = 1LL;
v6 = 1;
__sprintf_chk(v13, 2LL, v3, "0");
if ( v3 )
v5 = v3;
v7 = v13 + 1;
v8 = v5 - 1;
do
{
v9 = __sprintf_chk(v7, 2LL, v8, &unk_2004);
v10 = v8;
if ( v3 >= v8 )
v10 = v3;
v11 = v9 + v10 - v8;
if ( v11 < v10 )
v11 = v10;
++v6;
v7 += v9;
v8 = v11 + v8 - (v9 + v10);
}
while ( v6 != v1 );
}
}
return v13;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x001013f0
LEA R12D,[RDI + 0x1]
MOV EBX,0x1
MOV EBP,0x2
LEA R13,[0x102004]
NOP
LAB_00101310:
MOV R9D,EBX
MOV R8,R13
MOV RCX,-0x1
XOR ESI,ESI
MOV EDX,0x2
XOR EDI,EDI
XOR EAX,EAX
ADD EBX,0x1
CALL 0x001010b0
ADD EBP,EAX
CMP R12D,EBX
JNZ 0x00101310
MOVSXD RBP,EBP
MOV RDI,RBP
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x001013d7
MOV R14,qword ptr [RSP + 0x8]
XOR EAX,EAX
MOV RDX,RBP
MOV ESI,0x2
LEA RCX,[0x10201f]
MOV EBX,0x1
MOV R15D,0x1
MOV RDI,R14
LEA R13,[0x102004]
CALL 0x00101110
TEST RBP,RBP
CMOVNZ RBX,RBP
ADD R14,0x1
SUB RBX,0x1
NOP
LAB_00101390:
MOV RDX,RBX
MOV R8D,R15D
MOV RCX,R13
MOV ESI,0x2
MOV RDI,R14
XOR EAX,EAX
CALL 0x00101110
CMP RBP,RBX
MOV RCX,RBX
CMOVNC RCX,RBP
CDQE
LEA RSI,[RAX + RCX*0x1]
MOV RDX,RSI
SUB RDX,RBX
CMP RDX,RCX
CMOVC RDX,RCX
SUB RBX,RSI
ADD R15D,0x1
ADD R14,RAX
ADD RBX,RDX
CMP R15D,R12D
JNZ 0x00101390
LAB_001013d7:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013f0:
MOV EDI,0x2
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001013d7
LEA RSI,[0x10201f]
XOR EAX,EAX
CALL 0x00101100
JMP 0x001013d7
|
char * func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
size_t sVar6;
ulong uVar7;
int iVar8;
size_t __size;
char *pcVar9;
char *local_40;
if (param_1 < 1) {
local_40 = (char *)malloc(2);
if (local_40 != (char *)0x0) {
sprintf(local_40,"0");
}
}
else {
iVar8 = 2;
iVar2 = 1;
do {
iVar5 = iVar2 + 1;
iVar2 = __snprintf_chk(0,0,2,0xffffffffffffffff,&DAT_00102004,iVar2);
iVar8 = iVar8 + iVar2;
iVar2 = iVar5;
} while (param_1 + 1 != iVar5);
__size = (size_t)iVar8;
local_40 = (char *)malloc(__size);
if (local_40 != (char *)0x0) {
iVar2 = 1;
__sprintf_chk(local_40,2,__size,"0");
sVar6 = 1;
if (__size != 0) {
sVar6 = __size;
}
pcVar9 = local_40 + 1;
uVar7 = sVar6 - 1;
do {
iVar8 = __sprintf_chk(pcVar9,2,uVar7,&DAT_00102004,iVar2);
uVar3 = uVar7;
if (uVar7 <= __size) {
uVar3 = __size;
}
lVar1 = (long)iVar8 + uVar3;
uVar4 = lVar1 - uVar7;
if (uVar4 < uVar3) {
uVar4 = uVar3;
}
iVar2 = iVar2 + 1;
pcVar9 = pcVar9 + iVar8;
uVar7 = (uVar7 - lVar1) + uVar4;
} while (iVar2 != param_1 + 1);
}
}
return local_40;
}
|
719 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d", i);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0);
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %edi,%edi
jle 1380 <func0+0xc0>
lea 0x1(%rdi),%r12d
mov $0x1,%ebx
mov $0x2,%ebp
lea 0xd1b(%rip),%r13
nopl 0x0(%rax)
mov %ebx,%r9d
mov %r13,%r8
mov $0xffffffffffffffff,%rcx
xor %esi,%esi
mov $0x1,%edx
xor %edi,%edi
xor %eax,%eax
mov %ebx,%r14d
callq 1090 <__snprintf_chk@plt>
lea 0x1(%rbx),%ebx
add %eax,%ebp
cmp %r12d,%ebx
jne 12f0 <func0+0x30>
movslq %ebp,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 13a6 <func0+0xe6>
mov $0x30,%eax
lea 0x1(%r13),%rbp
mov $0x1,%ebx
mov %ax,0x0(%r13)
lea 0xcc0(%rip),%r12
nopl 0x0(%rax)
mov %ebx,%r8d
mov %rbp,%rdi
mov %r12,%rcx
mov $0xffffffffffffffff,%rdx
mov $0x1,%esi
xor %eax,%eax
callq 10d0 <__sprintf_chk@plt>
cltq
add %rax,%rbp
mov %ebx,%eax
add $0x1,%ebx
cmp %eax,%r14d
jne 1348 <func0+0x88>
pop %rbx
mov %r13,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x2,%edi
callq 10c0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 13a6 <func0+0xe6>
mov $0x30,%edx
mov %dx,(%rax)
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r13d,%r13d
jmp 1373 <func0+0xb3>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test edi, edi
jle loc_13F0
lea r12d, [rdi+1]
mov ebx, 1
mov ebp, 2
lea r13, unk_2004
nop
loc_1310:
mov r9d, ebx
mov r8, r13
mov rcx, 0FFFFFFFFFFFFFFFFh
xor esi, esi
mov edx, 2
xor edi, edi
xor eax, eax
add ebx, 1
call ___snprintf_chk
add ebp, eax
cmp r12d, ebx
jnz short loc_1310
movsxd rbp, ebp
mov rdi, rbp; size
call _malloc
mov [rsp+48h+var_40], rax
test rax, rax
jz loc_13D7
mov r14, rax
mov rdi, rax
lea rcx, assertion+17h; "0"
xor eax, eax
mov rdx, rbp
mov esi, 2
mov ebx, 1
mov r15d, 1
call ___sprintf_chk
test rbp, rbp
lea r13, unk_2004
cmovnz rbx, rbp
add r14, 1
sub rbx, 1
nop dword ptr [rax]
loc_1390:
mov rdx, rbx
mov r8d, r15d
mov rcx, r13
mov esi, 2
mov rdi, r14
xor eax, eax
call ___sprintf_chk
cmp rbp, rbx
mov rcx, rbx
cmovnb rcx, rbp
cdqe
lea rsi, [rax+rcx]
mov rdx, rsi
sub rdx, rbx
cmp rdx, rcx
cmovb rdx, rcx
sub rbx, rsi
add r15d, 1
add r14, rax
add rbx, rdx
cmp r12d, r15d
jnz short loc_1390
loc_13D7:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13F0:
mov edi, 2; size
call _malloc
mov [rsp+48h+var_40], rax
mov rdi, rax; s
test rax, rax
jz short loc_13D7
lea rsi, assertion+17h; format
xor eax, eax
call _sprintf
jmp short loc_13D7
|
char * func0(int a1)
{
int v1; // r12d
unsigned int v2; // ebx
int v3; // ebp
long long v4; // r9
char *v5; // rax
char *v6; // r14
long long v7; // rbx
int v8; // r15d
char *v9; // r14
unsigned long long v10; // rbx
int v11; // eax
unsigned long long v12; // rcx
unsigned long long v13; // rdx
char *v15; // [rsp+8h] [rbp-40h]
if ( a1 <= 0 )
{
v15 = (char *)malloc(2uLL);
if ( v15 )
sprintf(v15, "0");
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 2;
do
{
v4 = v2++;
v3 += __snprintf_chk(0LL, 0LL, 2LL, -1LL, &unk_2004, v4);
}
while ( v1 != v2 );
v5 = (char *)malloc(v3);
v15 = v5;
if ( v5 )
{
v6 = v5;
v7 = 1LL;
v8 = 1;
__sprintf_chk(v5, 2LL, v3, "0");
if ( v3 )
v7 = v3;
v9 = v6 + 1;
v10 = v7 - 1;
do
{
v11 = __sprintf_chk(v9, 2LL, v10, &unk_2004);
v12 = v10;
if ( v3 >= v10 )
v12 = v3;
v13 = v11 + v12 - v10;
if ( v13 < v12 )
v13 = v12;
++v8;
v9 += v11;
v10 = v13 + v10 - (v11 + v12);
}
while ( v1 != v8 );
}
}
return v15;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x001013f0
LEA R12D,[RDI + 0x1]
MOV EBX,0x1
MOV EBP,0x2
LEA R13,[0x102004]
NOP
LAB_00101310:
MOV R9D,EBX
MOV R8,R13
MOV RCX,-0x1
XOR ESI,ESI
MOV EDX,0x2
XOR EDI,EDI
XOR EAX,EAX
ADD EBX,0x1
CALL 0x001010b0
ADD EBP,EAX
CMP R12D,EBX
JNZ 0x00101310
MOVSXD RBP,EBP
MOV RDI,RBP
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x001013d7
MOV R14,RAX
MOV RDI,RAX
LEA RCX,[0x10201f]
XOR EAX,EAX
MOV RDX,RBP
MOV ESI,0x2
MOV EBX,0x1
MOV R15D,0x1
CALL 0x00101110
TEST RBP,RBP
LEA R13,[0x102004]
CMOVNZ RBX,RBP
ADD R14,0x1
SUB RBX,0x1
NOP dword ptr [RAX]
LAB_00101390:
MOV RDX,RBX
MOV R8D,R15D
MOV RCX,R13
MOV ESI,0x2
MOV RDI,R14
XOR EAX,EAX
CALL 0x00101110
CMP RBP,RBX
MOV RCX,RBX
CMOVNC RCX,RBP
CDQE
LEA RSI,[RAX + RCX*0x1]
MOV RDX,RSI
SUB RDX,RBX
CMP RDX,RCX
CMOVC RDX,RCX
SUB RBX,RSI
ADD R15D,0x1
ADD R14,RAX
ADD RBX,RDX
CMP R12D,R15D
JNZ 0x00101390
LAB_001013d7:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013f0:
MOV EDI,0x2
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001013d7
LEA RSI,[0x10201f]
XOR EAX,EAX
CALL 0x00101100
JMP 0x001013d7
|
char * func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
size_t sVar6;
ulong uVar7;
int iVar8;
size_t __size;
char *pcVar9;
char *local_40;
if (param_1 < 1) {
local_40 = (char *)malloc(2);
if (local_40 != (char *)0x0) {
sprintf(local_40,"0");
}
}
else {
iVar8 = 2;
iVar2 = 1;
do {
iVar5 = iVar2 + 1;
iVar2 = __snprintf_chk(0,0,2,0xffffffffffffffff,&DAT_00102004,iVar2);
iVar8 = iVar8 + iVar2;
iVar2 = iVar5;
} while (param_1 + 1 != iVar5);
__size = (size_t)iVar8;
local_40 = (char *)malloc(__size);
if (local_40 != (char *)0x0) {
iVar2 = 1;
__sprintf_chk(local_40,2,__size,"0");
sVar6 = 1;
if (__size != 0) {
sVar6 = __size;
}
pcVar9 = local_40 + 1;
uVar7 = sVar6 - 1;
do {
iVar8 = __sprintf_chk(pcVar9,2,uVar7,&DAT_00102004,iVar2);
uVar3 = uVar7;
if (uVar7 <= __size) {
uVar3 = __size;
}
lVar1 = (long)iVar8 + uVar3;
uVar4 = lVar1 - uVar7;
if (uVar4 < uVar3) {
uVar4 = uVar3;
}
iVar2 = iVar2 + 1;
pcVar9 = pcVar9 + iVar8;
uVar7 = (uVar7 - lVar1) + uVar4;
} while (param_1 + 1 != iVar2);
}
}
return local_40;
}
|
720 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x418(%rbp)
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x414(%rbp)
jmpq 1281 <func0+0xd8>
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
mov %eax,%edi
callq 10a0 <tolower@plt>
mov %al,-0x419(%rbp)
movsbl -0x419(%rbp),%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
test %eax,%eax
jne 127a <func0+0xd1>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
movzbl -0x419(%rbp),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x400,%eax
test %eax,%eax
je 127a <func0+0xd1>
movsbl -0x419(%rbp),%eax
cltq
movl $0x1,-0x410(%rbp,%rax,4)
addl $0x1,-0x418(%rbp)
addl $0x1,-0x414(%rbp)
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11fe <func0+0x55>
mov -0x418(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 12b9 <func0+0x110>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+var_428], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_418], 0
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_414], 0
jmp loc_1281
loc_11FE:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
mov edi, eax; c
call _tolower
mov [rbp+var_419], al
movsx eax, [rbp+var_419]
cdqe
mov eax, [rbp+rax*4+var_410]
test eax, eax
jnz short loc_127A
call ___ctype_b_loc
mov rax, [rax]
movzx edx, [rbp+var_419]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 400h
test eax, eax
jz short loc_127A
movsx eax, [rbp+var_419]
cdqe
mov [rbp+rax*4+var_410], 1
add [rbp+var_418], 1
loc_127A:
add [rbp+var_414], 1
loc_1281:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11FE
mov eax, [rbp+var_418]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12B9
call ___stack_chk_fail
locret_12B9:
leave
retn
|
long long func0(long long a1)
{
unsigned __int8 v2; // [rsp+17h] [rbp-419h]
unsigned int v3; // [rsp+18h] [rbp-418h]
int i; // [rsp+1Ch] [rbp-414h]
_DWORD v5[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v6; // [rsp+428h] [rbp-8h]
v6 = __readfsqword(0x28u);
v3 = 0;
memset(v5, 0, 0x400uLL);
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
v2 = tolower(*(unsigned __int8 *)(i + a1));
if ( !v5[(char)v2] && ((*__ctype_b_loc())[v2] & 0x400) != 0 )
{
v5[(char)v2] = 1;
++v3;
}
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x418],0x0
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x414],0x0
JMP 0x00101281
LAB_001011fe:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
MOV EDI,EAX
CALL 0x001010a0
MOV byte ptr [RBP + -0x419],AL
MOVSX EAX,byte ptr [RBP + -0x419]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
TEST EAX,EAX
JNZ 0x0010127a
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOVZX EDX,byte ptr [RBP + -0x419]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x400
TEST EAX,EAX
JZ 0x0010127a
MOVSX EAX,byte ptr [RBP + -0x419]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x410],0x1
ADD dword ptr [RBP + -0x418],0x1
LAB_0010127a:
ADD dword ptr [RBP + -0x414],0x1
LAB_00101281:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011fe
MOV EAX,dword ptr [RBP + -0x418]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012b9
CALL 0x00101080
LAB_001012b9:
LEAVE
RET
|
int func0(long param_1)
{
byte bVar1;
int iVar2;
ushort **ppuVar3;
long lVar4;
int *piVar5;
long in_FS_OFFSET;
int local_420;
int local_41c;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_420 = 0;
piVar5 = local_418;
for (lVar4 = 0x80; lVar4 != 0; lVar4 = lVar4 + -1) {
piVar5[0] = 0;
piVar5[1] = 0;
piVar5 = piVar5 + 2;
}
for (local_41c = 0; *(char *)(param_1 + local_41c) != '\0'; local_41c = local_41c + 1) {
iVar2 = tolower((uint)*(byte *)(param_1 + local_41c));
bVar1 = (byte)iVar2;
if (local_418[(int)(char)bVar1] == 0) {
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[bVar1] & 0x400) != 0) {
local_418[(int)(char)bVar1] = 1;
local_420 = local_420 + 1;
}
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_420;
}
|
721 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x410,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
movzbl 0x0(%rbp),%ebx
test %bl,%bl
je 123d <func0+0x94>
callq 10a0 <__ctype_tolower_loc@plt>
mov (%rax),%r12
add $0x1,%rbp
mov $0x0,%r13d
jmp 1205 <func0+0x5c>
add $0x1,%rbp
movzbl -0x1(%rbp),%ebx
test %bl,%bl
je 1243 <func0+0x9a>
movzbl %bl,%ebx
mov (%r12,%rbx,4),%ebx
movsbl %bl,%r14d
movsbq %bl,%rax
cmpl $0x0,(%rsp,%rax,4)
jne 11f9 <func0+0x50>
callq 10b0 <__ctype_b_loc@plt>
movzbl %bl,%ebx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rbx,2)
je 11f9 <func0+0x50>
movslq %r14d,%r14
movl $0x1,(%rsp,%r14,4)
add $0x1,%r13d
jmp 11f9 <func0+0x50>
mov $0x0,%r13d
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1269 <func0+0xc0>
mov %r13d,%eax
add $0x410,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1080 <__stack_chk_fail@plt>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 410h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+438h+var_30], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_123D
call ___ctype_tolower_loc
mov r12, [rax]
add rbp, 1
mov r13d, 0
jmp short loc_1205
loc_11F9:
add rbp, 1
movzx ebx, byte ptr [rbp-1]
test bl, bl
jz short loc_1243
loc_1205:
movzx ebx, bl
mov ebx, [r12+rbx*4]
movsx r14d, bl
movsx rax, bl
cmp [rsp+rax*4+438h+var_438], 0
jnz short loc_11F9
call ___ctype_b_loc
movzx ebx, bl
mov rax, [rax]
test byte ptr [rax+rbx*2+1], 4
jz short loc_11F9
movsxd r14, r14d
mov [rsp+r14*4+438h+var_438], 1
add r13d, 1
jmp short loc_11F9
loc_123D:
mov r13d, 0
loc_1243:
mov rax, [rsp+438h+var_30]
sub rax, fs:28h
jnz short loc_1269
mov eax, r13d
add rsp, 410h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1269:
call ___stack_chk_fail
|
long long func0(unsigned __int8 *a1)
{
unsigned __int8 v1; // bl
const __int32_t *v2; // r12
unsigned __int8 *v3; // rbp
unsigned int v4; // r13d
__int32_t v5; // ebx
_DWORD v7[258]; // [rsp+0h] [rbp-438h] BYREF
unsigned long long v8; // [rsp+408h] [rbp-30h]
v8 = __readfsqword(0x28u);
memset(v7, 0, 0x400uLL);
v1 = *a1;
if ( *a1 )
{
v2 = *__ctype_tolower_loc();
v3 = a1 + 1;
v4 = 0;
do
{
v5 = v2[v1];
if ( !v7[(char)v5] && ((*__ctype_b_loc())[(unsigned __int8)v5] & 0x400) != 0 )
{
v7[(char)v5] = 1;
++v4;
}
v1 = *v3++;
}
while ( v1 );
}
else
{
return 0;
}
return v4;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x410
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x0010123d
CALL 0x001010a0
MOV R12,qword ptr [RAX]
ADD RBP,0x1
MOV R13D,0x0
JMP 0x00101205
LAB_001011f9:
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP + -0x1]
TEST BL,BL
JZ 0x00101243
LAB_00101205:
MOVZX EBX,BL
MOV EBX,dword ptr [R12 + RBX*0x4]
MOVSX R14D,BL
MOVSX RAX,BL
CMP dword ptr [RSP + RAX*0x4],0x0
JNZ 0x001011f9
CALL 0x001010b0
MOVZX EBX,BL
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + RBX*0x2 + 0x1],0x4
JZ 0x001011f9
MOVSXD R14,R14D
MOV dword ptr [RSP + R14*0x4],0x1
ADD R13D,0x1
JMP 0x001011f9
LAB_0010123d:
MOV R13D,0x0
LAB_00101243:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101269
MOV EAX,R13D
ADD RSP,0x410
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101269:
CALL 0x00101080
|
int func0(byte *param_1)
{
uint uVar1;
__int32_t *p_Var2;
__int32_t **pp_Var3;
ushort **ppuVar4;
long lVar5;
byte bVar6;
char cVar7;
byte *pbVar8;
int *piVar9;
int iVar10;
long in_FS_OFFSET;
int aiStack_438 [258];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar9 = aiStack_438;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
*(int8 *)piVar9 = 0;
piVar9 = (int *)((long)piVar9 + 8);
}
bVar6 = *param_1;
if (bVar6 == 0) {
iVar10 = 0;
}
else {
pp_Var3 = __ctype_tolower_loc();
p_Var2 = *pp_Var3;
iVar10 = 0;
pbVar8 = param_1 + 1;
do {
uVar1 = p_Var2[bVar6];
cVar7 = (char)uVar1;
if (aiStack_438[cVar7] == 0) {
ppuVar4 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar4 + (ulong)(uVar1 & 0xff) * 2 + 1) & 4) != 0) {
aiStack_438[(int)cVar7] = 1;
iVar10 = iVar10 + 1;
}
}
bVar6 = *pbVar8;
pbVar8 = pbVar8 + 1;
} while (bVar6 != 0);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar10;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
722 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
mov $0x80,%ecx
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x410,%rsp
movzbl 0x0(%rbp),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %bl,%bl
je 1370 <func0+0xb0>
callq 10a0 <__ctype_tolower_loc@plt>
add $0x1,%rbp
xor %r12d,%r12d
mov (%rax),%r14
nopl 0x0(%rax,%rax,1)
mov (%r14,%rbx,4),%ebx
movsbq %bl,%r13
mov (%rsp,%r13,4),%eax
test %eax,%eax
jne 133e <func0+0x7e>
callq 10b0 <__ctype_b_loc@plt>
movzbl %bl,%ebx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rbx,2)
je 133e <func0+0x7e>
movl $0x1,(%rsp,%r13,4)
add $0x1,%r12d
movzbl 0x0(%rbp),%ebx
add $0x1,%rbp
test %bl,%bl
jne 1310 <func0+0x50>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1375 <func0+0xb5>
add $0x410,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r12d,%r12d
jmp 134a <func0+0x8a>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
mov ecx, 80h
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 410h
movzx ebx, byte ptr [rbp+0]
mov rax, fs:28h
mov [rsp+438h+var_30], rax
xor eax, eax
mov rdi, rsp
rep stosq
test bl, bl
jz short loc_1370
call ___ctype_tolower_loc
add rbp, 1
xor r12d, r12d
mov r14, [rax]
nop dword ptr [rax+rax+00h]
loc_1310:
mov ebx, [r14+rbx*4]
movsx r13, bl
mov eax, [rsp+r13*4+438h+var_438]
test eax, eax
jnz short loc_133E
call ___ctype_b_loc
movzx ebx, bl
mov rax, [rax]
test byte ptr [rax+rbx*2+1], 4
jz short loc_133E
mov [rsp+r13*4+438h+var_438], 1
add r12d, 1
loc_133E:
movzx ebx, byte ptr [rbp+0]
add rbp, 1
test bl, bl
jnz short loc_1310
loc_134A:
mov rax, [rsp+438h+var_30]
sub rax, fs:28h
jnz short loc_1375
add rsp, 410h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1370:
xor r12d, r12d
jmp short loc_134A
loc_1375:
call ___stack_chk_fail
|
long long func0(unsigned __int8 *a1)
{
long long v1; // rbx
unsigned __int8 *v2; // rbp
unsigned int v3; // r12d
const __int32_t *v4; // r14
__int32_t v5; // ebx
_DWORD v7[258]; // [rsp+0h] [rbp-438h] BYREF
unsigned long long v8; // [rsp+408h] [rbp-30h]
v1 = *a1;
v8 = __readfsqword(0x28u);
memset(v7, 0, 0x400uLL);
if ( (_BYTE)v1 )
{
v2 = a1 + 1;
v3 = 0;
v4 = *__ctype_tolower_loc();
do
{
v5 = v4[v1];
if ( !v7[(char)v5] && ((*__ctype_b_loc())[(unsigned __int8)v5] & 0x400) != 0 )
{
v7[(char)v5] = 1;
++v3;
}
v1 = *v2++;
}
while ( (_BYTE)v1 );
}
else
{
return 0;
}
return v3;
}
|
func0:
ENDBR64
PUSH R14
MOV ECX,0x80
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x410
MOVZX EBX,byte ptr [RBP]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
TEST BL,BL
JZ 0x00101370
CALL 0x001010a0
ADD RBP,0x1
XOR R12D,R12D
MOV R14,qword ptr [RAX]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101310:
MOV EBX,dword ptr [R14 + RBX*0x4]
MOVSX R13,BL
MOV EAX,dword ptr [RSP + R13*0x4]
TEST EAX,EAX
JNZ 0x0010133e
CALL 0x001010b0
MOVZX EBX,BL
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + RBX*0x2 + 0x1],0x4
JZ 0x0010133e
MOV dword ptr [RSP + R13*0x4],0x1
ADD R12D,0x1
LAB_0010133e:
MOVZX EBX,byte ptr [RBP]
ADD RBP,0x1
TEST BL,BL
JNZ 0x00101310
LAB_0010134a:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101375
ADD RSP,0x410
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101370:
XOR R12D,R12D
JMP 0x0010134a
LAB_00101375:
CALL 0x00101080
|
int func0(byte *param_1)
{
byte bVar1;
uint uVar2;
__int32_t *p_Var3;
__int32_t **pp_Var4;
ushort **ppuVar5;
long lVar6;
char cVar7;
int *piVar8;
int iVar9;
long in_FS_OFFSET;
int aiStack_438 [258];
long local_30;
bVar1 = *param_1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = aiStack_438;
for (lVar6 = 0x80; lVar6 != 0; lVar6 = lVar6 + -1) {
*(int8 *)piVar8 = 0;
piVar8 = (int *)((long)piVar8 + 8);
}
if (bVar1 == 0) {
iVar9 = 0;
}
else {
pp_Var4 = __ctype_tolower_loc();
param_1 = param_1 + 1;
iVar9 = 0;
p_Var3 = *pp_Var4;
do {
uVar2 = p_Var3[bVar1];
cVar7 = (char)uVar2;
if (aiStack_438[cVar7] == 0) {
ppuVar5 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar5 + (ulong)(uVar2 & 0xff) * 2 + 1) & 4) != 0) {
aiStack_438[cVar7] = 1;
iVar9 = iVar9 + 1;
}
}
bVar1 = *param_1;
param_1 = param_1 + 1;
} while (bVar1 != 0);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar9;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
723 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
}
return count;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
mov $0x80,%ecx
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x410,%rsp
movzbl 0x0(%rbp),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %bl,%bl
je 1370 <func0+0xb0>
callq 10a0 <__ctype_tolower_loc@plt>
add $0x1,%rbp
xor %r12d,%r12d
mov (%rax),%r14
nopl 0x0(%rax,%rax,1)
mov (%r14,%rbx,4),%ebx
movsbq %bl,%r13
mov (%rsp,%r13,4),%eax
test %eax,%eax
jne 133e <func0+0x7e>
callq 10b0 <__ctype_b_loc@plt>
movzbl %bl,%ebx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rbx,2)
je 133e <func0+0x7e>
movl $0x1,(%rsp,%r13,4)
add $0x1,%r12d
movzbl 0x0(%rbp),%ebx
add $0x1,%rbp
test %bl,%bl
jne 1310 <func0+0x50>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1375 <func0+0xb5>
add $0x410,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r12d,%r12d
jmp 134a <func0+0x8a>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
mov ecx, 80h
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 410h
movzx ebx, byte ptr [rbp+0]
mov rax, fs:28h
mov [rsp+438h+var_30], rax
xor eax, eax
mov rdi, rsp
rep stosq
test bl, bl
jz short loc_1370
call ___ctype_tolower_loc
add rbp, 1
xor r12d, r12d
mov r14, [rax]
nop dword ptr [rax+rax+00h]
loc_1310:
mov ebx, [r14+rbx*4]
movsx r13, bl
mov eax, [rsp+r13*4+438h+var_438]
test eax, eax
jnz short loc_133E
call ___ctype_b_loc
movzx ebx, bl
mov rax, [rax]
test byte ptr [rax+rbx*2+1], 4
jz short loc_133E
mov [rsp+r13*4+438h+var_438], 1
add r12d, 1
loc_133E:
movzx ebx, byte ptr [rbp+0]
add rbp, 1
test bl, bl
jnz short loc_1310
loc_134A:
mov rax, [rsp+438h+var_30]
sub rax, fs:28h
jnz short loc_1375
add rsp, 410h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1370:
xor r12d, r12d
jmp short loc_134A
loc_1375:
call ___stack_chk_fail
|
long long func0(unsigned __int8 *a1)
{
long long v1; // rbx
unsigned __int8 *v2; // rbp
unsigned int v3; // r12d
const __int32_t *v4; // r14
__int32_t v5; // ebx
_DWORD v7[258]; // [rsp+0h] [rbp-438h] BYREF
unsigned long long v8; // [rsp+408h] [rbp-30h]
v1 = *a1;
v8 = __readfsqword(0x28u);
memset(v7, 0, 0x400uLL);
if ( (_BYTE)v1 )
{
v2 = a1 + 1;
v3 = 0;
v4 = *__ctype_tolower_loc();
do
{
v5 = v4[v1];
if ( !v7[(char)v5] && ((*__ctype_b_loc())[(unsigned __int8)v5] & 0x400) != 0 )
{
v7[(char)v5] = 1;
++v3;
}
v1 = *v2++;
}
while ( (_BYTE)v1 );
}
else
{
return 0;
}
return v3;
}
|
func0:
ENDBR64
PUSH R14
MOV ECX,0x80
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x410
MOVZX EBX,byte ptr [RBP]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
TEST BL,BL
JZ 0x00101370
CALL 0x001010a0
ADD RBP,0x1
XOR R12D,R12D
MOV R14,qword ptr [RAX]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101310:
MOV EBX,dword ptr [R14 + RBX*0x4]
MOVSX R13,BL
MOV EAX,dword ptr [RSP + R13*0x4]
TEST EAX,EAX
JNZ 0x0010133e
CALL 0x001010b0
MOVZX EBX,BL
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + RBX*0x2 + 0x1],0x4
JZ 0x0010133e
MOV dword ptr [RSP + R13*0x4],0x1
ADD R12D,0x1
LAB_0010133e:
MOVZX EBX,byte ptr [RBP]
ADD RBP,0x1
TEST BL,BL
JNZ 0x00101310
LAB_0010134a:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101375
ADD RSP,0x410
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101370:
XOR R12D,R12D
JMP 0x0010134a
LAB_00101375:
CALL 0x00101080
|
int func0(byte *param_1)
{
byte bVar1;
uint uVar2;
__int32_t *p_Var3;
__int32_t **pp_Var4;
ushort **ppuVar5;
long lVar6;
char cVar7;
int *piVar8;
int iVar9;
long in_FS_OFFSET;
int aiStack_438 [258];
long local_30;
bVar1 = *param_1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = aiStack_438;
for (lVar6 = 0x80; lVar6 != 0; lVar6 = lVar6 + -1) {
*(int8 *)piVar8 = 0;
piVar8 = (int *)((long)piVar8 + 8);
}
if (bVar1 == 0) {
iVar9 = 0;
}
else {
pp_Var4 = __ctype_tolower_loc();
param_1 = param_1 + 1;
iVar9 = 0;
p_Var3 = *pp_Var4;
do {
uVar2 = p_Var3[bVar1];
cVar7 = (char)uVar2;
if (aiStack_438[cVar7] == 0) {
ppuVar5 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar5 + (ulong)(uVar2 & 0xff) * 2 + 1) & 4) != 0) {
aiStack_438[cVar7] = 1;
iVar9 = iVar9 + 1;
}
}
bVar1 = *param_1;
param_1 = param_1 + 1;
} while (bVar1 != 0);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar9;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
724 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_music_string, " ");
for (int i = 0; i < music_string_length; i++) {
if (temp_music_string[i] == ' ') {
if (strcmp(current, "o") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 4;
}
if (strcmp(current, "o|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 2;
}
if (strcmp(current, ".|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 1;
}
strcpy(current, "");
} else {
size_t len = strlen(current);
if (len < sizeof(current) - 1) {
current[len] = temp_music_string[i];
current[len + 1] = '\0';
}
}
}
free(temp_music_string);
*count = size;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
assert(issame(result, count, (const int[]){}, 0));
free(result);
result = func0("o o o o", &count);
assert(issame(result, count, (const int[]){4, 4, 4, 4}, 4));
free(result);
result = func0(".| .| .| .|", &count);
assert(issame(result, count, (const int[]){1, 1, 1, 1}, 4));
free(result);
result = func0("o| o| .| .| o o o o", &count);
assert(issame(result, count, (const int[]){2, 2, 1, 1, 4, 4, 4, 4}, 8));
free(result);
result = func0("o| .| o| .| o o| o o|", &count);
assert(issame(result, count, (const int[]){2, 1, 2, 1, 4, 2, 4, 2}, 8));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movq $0x0,-0x28(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
movw $0x0,-0xb(%rbp)
movb $0x0,-0x9(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
add $0x1,%eax
mov %eax,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x48(%rbp),%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <strcpy@plt>
mov -0x20(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movw $0x20,(%rax)
movl $0x0,-0x30(%rbp)
jmpq 149e <func0+0x275>
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 1459 <func0+0x230>
lea -0xb(%rbp),%rax
lea 0xd06(%rip),%rsi
mov %rax,%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 136b <func0+0x142>
mov -0x38(%rbp),%eax
cmp -0x34(%rbp),%eax
jne 134b <func0+0x122>
cmpl $0x0,-0x34(%rbp)
jle 1323 <func0+0xfa>
mov -0x34(%rbp),%eax
add %eax,%eax
jmp 1328 <func0+0xff>
mov $0x4,%eax
mov %eax,-0x34(%rbp)
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <realloc@plt>
mov %rax,-0x28(%rbp)
mov -0x38(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x38(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movl $0x4,(%rax)
lea -0xb(%rbp),%rax
lea 0xc94(%rip),%rsi
mov %rax,%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 13df <func0+0x1b6>
mov -0x38(%rbp),%eax
cmp -0x34(%rbp),%eax
jne 13bf <func0+0x196>
cmpl $0x0,-0x34(%rbp)
jle 1397 <func0+0x16e>
mov -0x34(%rbp),%eax
add %eax,%eax
jmp 139c <func0+0x173>
mov $0x4,%eax
mov %eax,-0x34(%rbp)
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <realloc@plt>
mov %rax,-0x28(%rbp)
mov -0x38(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x38(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movl $0x2,(%rax)
lea -0xb(%rbp),%rax
lea 0xc23(%rip),%rsi
mov %rax,%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 1453 <func0+0x22a>
mov -0x38(%rbp),%eax
cmp -0x34(%rbp),%eax
jne 1433 <func0+0x20a>
cmpl $0x0,-0x34(%rbp)
jle 140b <func0+0x1e2>
mov -0x34(%rbp),%eax
add %eax,%eax
jmp 1410 <func0+0x1e7>
mov $0x4,%eax
mov %eax,-0x34(%rbp)
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <realloc@plt>
mov %rax,-0x28(%rbp)
mov -0x38(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x38(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movl $0x1,(%rax)
movb $0x0,-0xb(%rbp)
jmp 149a <func0+0x271>
lea -0xb(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %rax,-0x18(%rbp)
cmpq $0x1,-0x18(%rbp)
ja 149a <func0+0x271>
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
lea -0xb(%rbp),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov %al,(%rdx)
mov -0x18(%rbp),%rax
add $0x1,%rax
movb $0x0,-0xb(%rbp,%rax,1)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 12df <func0+0xb6>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10c0 <free@plt>
mov -0x50(%rbp),%rax
mov -0x38(%rbp),%edx
mov %edx,(%rax)
mov -0x28(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 14d7 <func0+0x2ae>
callq 10f0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+ptr], 0
mov [rbp+var_38], 0
mov [rbp+var_34], 0
mov word ptr [rbp+s1], 0
mov [rbp+var_9], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
add eax, 1
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
mov rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 20h ; ' '
mov [rbp+var_30], 0
jmp loc_1494
loc_12CC:
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, [rbp+dest]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz loc_144F
lea rax, [rbp+s1]
lea rdx, s2; "o"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_135B
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jnz short loc_133B
cmp [rbp+var_34], 0
jle short loc_1313
mov eax, [rbp+var_34]
add eax, eax
jmp short loc_1318
loc_1313:
mov eax, 4
loc_1318:
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
loc_133B:
mov eax, [rbp+var_38]
lea edx, [rax+1]
mov [rbp+var_38], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov dword ptr [rax], 4
loc_135B:
lea rax, [rbp+s1]
lea rdx, aO; "o|"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_13D2
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jnz short loc_13B2
cmp [rbp+var_34], 0
jle short loc_138A
mov eax, [rbp+var_34]
add eax, eax
jmp short loc_138F
loc_138A:
mov eax, 4
loc_138F:
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
loc_13B2:
mov eax, [rbp+var_38]
lea edx, [rax+1]
mov [rbp+var_38], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov dword ptr [rax], 2
loc_13D2:
lea rax, [rbp+s1]
lea rdx, asc_200D; ".|"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1449
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jnz short loc_1429
cmp [rbp+var_34], 0
jle short loc_1401
mov eax, [rbp+var_34]
add eax, eax
jmp short loc_1406
loc_1401:
mov eax, 4
loc_1406:
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
loc_1429:
mov eax, [rbp+var_38]
lea edx, [rax+1]
mov [rbp+var_38], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov dword ptr [rax], 1
loc_1449:
mov [rbp+s1], 0
jmp short loc_1490
loc_144F:
lea rax, [rbp+s1]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], rax
cmp [rbp+var_18], 1
ja short loc_1490
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, [rbp+dest]
add rax, rdx
movzx eax, byte ptr [rax]
lea rcx, [rbp+s1]
mov rdx, [rbp+var_18]
add rdx, rcx
mov [rdx], al
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+rax+s1], 0
loc_1490:
add [rbp+var_30], 1
loc_1494:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_2C]
jl loc_12CC
mov rax, [rbp+dest]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_50]
mov edx, [rbp+var_38]
mov [rax], edx
mov rax, [rbp+ptr]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_14CD
call ___stack_chk_fail
locret_14CD:
leave
retn
|
long long func0(const char *a1, _DWORD *a2)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
int v10; // [rsp+18h] [rbp-38h]
int v11; // [rsp+1Ch] [rbp-34h]
int i; // [rsp+20h] [rbp-30h]
_BYTE v13[12]; // [rsp+24h] [rbp-2Ch]
char *dest; // [rsp+30h] [rbp-20h]
size_t v15; // [rsp+38h] [rbp-18h]
char s1[2]; // [rsp+45h] [rbp-Bh] BYREF
char v17; // [rsp+47h] [rbp-9h]
unsigned long long v18; // [rsp+48h] [rbp-8h]
v18 = __readfsqword(0x28u);
*(_DWORD *)&v13[8] = 0;
v10 = 0;
v11 = 0;
*(_WORD *)s1 = 0;
v17 = 0;
v2 = strlen(a1);
*(_QWORD *)v13 = (unsigned int)(v2 + 1);
dest = (char *)malloc(v2 + 2);
strcpy(dest, a1);
*(_WORD *)&dest[strlen(dest)] = 32;
for ( i = 0; i < *(int *)v13; ++i )
{
if ( dest[i] == 32 )
{
if ( !strcmp(s1, "o") )
{
if ( v10 == v11 )
{
if ( v11 <= 0 )
v3 = 4;
else
v3 = 2 * v11;
v11 = v3;
*(_QWORD *)&v13[4] = realloc(*(void **)&v13[4], 4LL * v3);
}
v4 = v10++;
*(_DWORD *)(4LL * v4 + *(_QWORD *)&v13[4]) = 4;
}
if ( !strcmp(s1, "o|") )
{
if ( v10 == v11 )
{
if ( v11 <= 0 )
v5 = 4;
else
v5 = 2 * v11;
v11 = v5;
*(_QWORD *)&v13[4] = realloc(*(void **)&v13[4], 4LL * v5);
}
v6 = v10++;
*(_DWORD *)(4LL * v6 + *(_QWORD *)&v13[4]) = 2;
}
if ( !strcmp(s1, ".|") )
{
if ( v10 == v11 )
{
if ( v11 <= 0 )
v7 = 4;
else
v7 = 2 * v11;
v11 = v7;
*(_QWORD *)&v13[4] = realloc(*(void **)&v13[4], 4LL * v7);
}
v8 = v10++;
*(_DWORD *)(4LL * v8 + *(_QWORD *)&v13[4]) = 1;
}
s1[0] = 0;
}
else
{
v15 = strlen(s1);
if ( v15 <= 1 )
{
s1[v15] = dest[i];
s1[v15 + 1] = 0;
}
}
}
free(dest);
*a2 = v10;
return *(_QWORD *)&v13[4];
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0x0
MOV word ptr [RBP + -0xb],0x0
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010e0
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x20],RAX
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010e0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV word ptr [RAX],0x20
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00101494
LAB_001012cc:
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x0010144f
LEA RAX,[RBP + -0xb]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x0010135b
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x0010133b
CMP dword ptr [RBP + -0x34],0x0
JLE 0x00101313
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,EAX
JMP 0x00101318
LAB_00101313:
MOV EAX,0x4
LAB_00101318:
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x28],RAX
LAB_0010133b:
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x38],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV dword ptr [RAX],0x4
LAB_0010135b:
LEA RAX,[RBP + -0xb]
LEA RDX,[0x10200a]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x001013d2
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x001013b2
CMP dword ptr [RBP + -0x34],0x0
JLE 0x0010138a
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,EAX
JMP 0x0010138f
LAB_0010138a:
MOV EAX,0x4
LAB_0010138f:
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x28],RAX
LAB_001013b2:
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x38],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV dword ptr [RAX],0x2
LAB_001013d2:
LEA RAX,[RBP + -0xb]
LEA RDX,[0x10200d]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x00101449
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00101429
CMP dword ptr [RBP + -0x34],0x0
JLE 0x00101401
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,EAX
JMP 0x00101406
LAB_00101401:
MOV EAX,0x4
LAB_00101406:
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x28],RAX
LAB_00101429:
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x38],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV dword ptr [RAX],0x1
LAB_00101449:
MOV byte ptr [RBP + -0xb],0x0
JMP 0x00101490
LAB_0010144f:
LEA RAX,[RBP + -0xb]
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x1
JA 0x00101490
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
LEA RCX,[RBP + -0xb]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV byte ptr [RDX],AL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV byte ptr [RBP + RAX*0x1 + -0xb],0x0
LAB_00101490:
ADD dword ptr [RBP + -0x30],0x1
LAB_00101494:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001012cc
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010c0
MOV RAX,qword ptr [RBP + -0x50]
MOV EDX,dword ptr [RBP + -0x38]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014cd
CALL 0x001010f0
LAB_001014cd:
LEAVE
RET
|
void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *__dest;
size_t sVar3;
long in_FS_OFFSET;
int local_40;
int local_3c;
int local_38;
void *local_30;
int2 local_13;
int local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = (void *)0x0;
local_40 = 0;
local_3c = 0;
local_13 = 0;
local_11 = 0;
sVar2 = strlen(param_1);
__dest = (char *)malloc((long)((int)sVar2 + 2));
strcpy(__dest,param_1);
sVar3 = strlen(__dest);
(__dest + sVar3)[0] = ' ';
(__dest + sVar3)[1] = '\0';
for (local_38 = 0; local_38 < (int)sVar2 + 1; local_38 = local_38 + 1) {
if (__dest[local_38] == ' ') {
iVar1 = strcmp((char *)&local_13,"o");
if (iVar1 == 0) {
if (local_40 == local_3c) {
if (local_3c < 1) {
local_3c = 4;
}
else {
local_3c = local_3c * 2;
}
local_30 = realloc(local_30,(long)local_3c * 4);
}
*(int4 *)((long)local_30 + (long)local_40 * 4) = 4;
local_40 = local_40 + 1;
}
iVar1 = strcmp((char *)&local_13,"o|");
if (iVar1 == 0) {
if (local_40 == local_3c) {
if (local_3c < 1) {
local_3c = 4;
}
else {
local_3c = local_3c * 2;
}
local_30 = realloc(local_30,(long)local_3c * 4);
}
*(int4 *)((long)local_30 + (long)local_40 * 4) = 2;
local_40 = local_40 + 1;
}
iVar1 = strcmp((char *)&local_13,".|");
if (iVar1 == 0) {
if (local_40 == local_3c) {
if (local_3c < 1) {
local_3c = 4;
}
else {
local_3c = local_3c * 2;
}
local_30 = realloc(local_30,(long)local_3c * 4);
}
*(int4 *)((long)local_30 + (long)local_40 * 4) = 1;
local_40 = local_40 + 1;
}
local_13 = local_13 & 0xff00;
}
else {
sVar3 = strlen((char *)&local_13);
if (sVar3 < 2) {
*(char *)((long)&local_13 + sVar3) = __dest[local_38];
*(int *)((long)&local_13 + sVar3 + 1) = 0;
}
}
}
free(__dest);
*param_2 = local_40;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_30;
}
|
725 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_music_string, " ");
for (int i = 0; i < music_string_length; i++) {
if (temp_music_string[i] == ' ') {
if (strcmp(current, "o") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 4;
}
if (strcmp(current, "o|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 2;
}
if (strcmp(current, ".|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 1;
}
strcpy(current, "");
} else {
size_t len = strlen(current);
if (len < sizeof(current) - 1) {
current[len] = temp_music_string[i];
current[len + 1] = '\0';
}
}
}
free(temp_music_string);
*count = size;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
assert(issame(result, count, (const int[]){}, 0));
free(result);
result = func0("o o o o", &count);
assert(issame(result, count, (const int[]){4, 4, 4, 4}, 4));
free(result);
result = func0(".| .| .| .|", &count);
assert(issame(result, count, (const int[]){1, 1, 1, 1}, 4));
free(result);
result = func0("o| o| .| .| o o o o", &count);
assert(issame(result, count, (const int[]){2, 2, 1, 1, 4, 4, 4, 4}, 8));
free(result);
result = func0("o| .| o| .| o o| o o|", &count);
assert(issame(result, count, (const int[]){2, 1, 2, 1, 4, 2, 4, 2}, 8));
free(result);
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 %rsi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movw $0x0,0x15(%rsp)
movb $0x0,0x17(%rsp)
mov $0xffffffffffffffff,%r13
mov $0x0,%ebx
mov %r13,%rcx
mov %ebx,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
lea 0x1(%rcx),%edi
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r14
mov %r12,%rsi
mov %rax,%rdi
callq 10b0 <strcpy@plt>
mov %r13,%rcx
mov %r14,(%rsp)
mov %r14,%rdi
mov %ebx,%eax
repnz scas %es:(%rdi),%al
not %rcx
movw $0x20,-0x1(%r14,%rcx,1)
lea 0x1(%rbp),%eax
test %eax,%eax
jle 13f0 <func0+0x207>
mov %r14,%rbx
mov %ebp,%ebp
lea 0x1(%r14,%rbp,1),%r15
mov $0x0,%r13d
mov $0x0,%ebp
mov $0x0,%r14d
lea 0x15(%rsp),%r12
jmpq 1340 <func0+0x157>
mov $0x2,%ecx
mov %r12,%rsi
lea 0xd78(%rip),%rdi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
jne 12cc <func0+0xe3>
cmp %r13d,%ebp
je 1375 <func0+0x18c>
movslq %ebp,%rax
movl $0x4,(%r14,%rax,4)
lea 0x1(%rbp),%ebp
mov $0x3,%ecx
mov %r12,%rsi
lea 0xd5c(%rip),%rdi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
jne 12fd <func0+0x114>
cmp %r13d,%ebp
je 139e <func0+0x1b5>
movslq %ebp,%rax
movl $0x2,(%r14,%rax,4)
lea 0x1(%rbp),%ebp
mov $0x3,%ecx
mov %r12,%rsi
lea 0xd01(%rip),%rdi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
jne 132e <func0+0x145>
cmp %r13d,%ebp
je 13c7 <func0+0x1de>
movslq %ebp,%rax
movl $0x1,(%r14,%rax,4)
lea 0x1(%rbp),%ebp
movb $0x0,0x15(%rsp)
add $0x1,%rbx
cmp %r15,%rbx
je 13fb <func0+0x212>
movzbl (%rbx),%edx
cmp $0x20,%dl
je 129b <func0+0xb2>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r12,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x1,%rcx
ja 1333 <func0+0x14a>
mov %dl,0x15(%rsp,%rcx,1)
movb $0x0,0x16(%rsp,%rcx,1)
jmp 1333 <func0+0x14a>
lea 0x0(%r13,%r13,1),%eax
test %r13d,%r13d
mov $0x4,%r13d
cmovg %eax,%r13d
movslq %r13d,%rsi
shl $0x2,%rsi
mov %r14,%rdi
callq 10f0 <realloc@plt>
mov %rax,%r14
jmpq 12be <func0+0xd5>
lea 0x0(%r13,%r13,1),%eax
test %r13d,%r13d
mov $0x4,%r13d
cmovg %eax,%r13d
movslq %r13d,%rsi
shl $0x2,%rsi
mov %r14,%rdi
callq 10f0 <realloc@plt>
mov %rax,%r14
jmpq 12ef <func0+0x106>
lea 0x0(%r13,%r13,1),%eax
test %r13d,%r13d
mov $0x4,%r13d
cmovg %eax,%r13d
movslq %r13d,%rsi
shl $0x2,%rsi
mov %r14,%rdi
callq 10f0 <realloc@plt>
mov %rax,%r14
jmpq 1320 <func0+0x137>
mov $0x0,%ebp
mov $0x0,%r14d
mov (%rsp),%rdi
callq 10a0 <free@plt>
mov 0x8(%rsp),%rax
mov %ebp,(%rax)
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 142d <func0+0x244>
mov %r14,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10c0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r12, rdi
mov [rsp+68h+var_50], rsi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov word ptr [rsp+68h+s1], 0
mov [rsp+68h+var_41], 0
call _strlen
mov rbp, rax
lea ebx, [rax+2]
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov r15, rax
mov [rsp+68h+var_58], rax
mov rdx, rbx
mov rsi, r12
mov rdi, rax
call ___strcpy_chk
mov rdx, rbx
lea rsi, unk_2004
mov rdi, r15
call ___strcat_chk
lea eax, [rbp+1]
test eax, eax
jle loc_1438
mov rbx, r15
mov ebp, ebp
lea r15, [r15+rbp+1]
mov r14d, 0
mov ebp, 0
mov [rsp+68h+ptr], 0
lea r13, [rsp+68h+s1]
jmp loc_138C
loc_12F0:
lea rsi, aOOOOOO+12h; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jnz short loc_131E
cmp ebp, r14d
jz loc_13B4
loc_130C:
movsxd rax, ebp
mov rcx, [rsp+68h+ptr]
mov dword ptr [rcx+rax*4], 4
lea ebp, [rbp+1]
loc_131E:
lea rsi, aOOOOOO_0+13h; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jnz short loc_134C
cmp ebp, r14d
jz loc_13E0
loc_133A:
movsxd rax, ebp
mov rdx, [rsp+68h+ptr]
mov dword ptr [rdx+rax*4], 2
lea ebp, [rbp+1]
loc_134C:
lea rsi, asc_2006+9; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jnz short loc_137A
cmp ebp, r14d
jz loc_140C
loc_1368:
movsxd rax, ebp
mov rcx, [rsp+68h+ptr]
mov dword ptr [rcx+rax*4], 1
lea ebp, [rbp+1]
loc_137A:
mov [rsp+68h+s1], 0
loc_137F:
add rbx, 1
cmp rbx, r15
jz loc_1446
loc_138C:
movzx r12d, byte ptr [rbx]
cmp r12b, 20h ; ' '
jz loc_12F0
mov rdi, r13; s
call _strlen
cmp rax, 1
ja short loc_137F
mov [rsp+rax+68h+s1], r12b
mov [rsp+rax+68h+s1+1], 0
jmp short loc_137F
loc_13B4:
lea eax, [r14+r14]
test r14d, r14d
mov r14d, 4
cmovg r14d, eax
movsxd rsi, r14d
shl rsi, 2; size
mov rdi, [rsp+68h+ptr]; ptr
call _realloc
mov [rsp+68h+ptr], rax
jmp loc_130C
loc_13E0:
lea eax, [r14+r14]
test r14d, r14d
mov r14d, 4
cmovg r14d, eax
movsxd rsi, r14d
shl rsi, 2; size
mov rdi, [rsp+68h+ptr]; ptr
call _realloc
mov [rsp+68h+ptr], rax
jmp loc_133A
loc_140C:
lea eax, [r14+r14]
test r14d, r14d
mov r14d, 4
cmovg r14d, eax
movsxd rsi, r14d
shl rsi, 2; size
mov rdi, [rsp+68h+ptr]; ptr
call _realloc
mov [rsp+68h+ptr], rax
jmp loc_1368
loc_1438:
mov ebp, 0
mov [rsp+68h+ptr], 0
loc_1446:
mov rdi, [rsp+68h+var_58]; ptr
call _free
mov rax, [rsp+68h+var_50]
mov [rax], ebp
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_147B
mov rax, [rsp+68h+ptr]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_147B:
call ___stack_chk_fail
|
void * func0(const char *a1, _DWORD *a2)
{
unsigned int v2; // ebp
size_t v3; // rbx
void *v4; // r15
char *v5; // rbx
long long v6; // r15
int v7; // r14d
int v8; // ebp
char v9; // r12
size_t v10; // rax
int v11; // eax
bool v12; // cc
int v13; // eax
int v14; // eax
void *ptr; // [rsp+8h] [rbp-60h]
void *v17; // [rsp+10h] [rbp-58h]
char s1[2]; // [rsp+25h] [rbp-43h] BYREF
char v19; // [rsp+27h] [rbp-41h]
unsigned long long v20; // [rsp+28h] [rbp-40h]
v20 = __readfsqword(0x28u);
*(_WORD *)s1 = 0;
v19 = 0;
v2 = strlen(a1);
v3 = (int)(v2 + 2);
v4 = malloc(v3);
v17 = v4;
__strcpy_chk(v4, a1, v3);
__strcat_chk(v4, &unk_2004, v3);
if ( (int)(v2 + 1) <= 0 )
{
v8 = 0;
ptr = 0LL;
}
else
{
v5 = (char *)v4;
v6 = (long long)v4 + v2 + 1;
v7 = 0;
v8 = 0;
ptr = 0LL;
do
{
v9 = *v5;
if ( *v5 == 32 )
{
if ( !strcmp(s1, "o") )
{
if ( v8 == v7 )
{
v11 = 2 * v7;
v12 = v7 <= 0;
v7 = 4;
if ( !v12 )
v7 = v11;
ptr = realloc(ptr, 4LL * v7);
}
*((_DWORD *)ptr + v8++) = 4;
}
if ( !strcmp(s1, "o|") )
{
if ( v8 == v7 )
{
v13 = 2 * v7;
v12 = v7 <= 0;
v7 = 4;
if ( !v12 )
v7 = v13;
ptr = realloc(ptr, 4LL * v7);
}
*((_DWORD *)ptr + v8++) = 2;
}
if ( !strcmp(s1, ".|") )
{
if ( v8 == v7 )
{
v14 = 2 * v7;
v12 = v7 <= 0;
v7 = 4;
if ( !v12 )
v7 = v14;
ptr = realloc(ptr, 4LL * v7);
}
*((_DWORD *)ptr + v8++) = 1;
}
s1[0] = 0;
}
else
{
v10 = strlen(s1);
if ( v10 <= 1 )
{
s1[v10] = v9;
s1[v10 + 1] = 0;
}
}
++v5;
}
while ( v5 != (char *)v6 );
}
free(v17);
*a2 = v8;
return ptr;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R12,RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV word ptr [RSP + 0x25],0x0
MOV byte ptr [RSP + 0x27],0x0
CALL 0x001010f0
MOV RBP,RAX
LEA EBX,[RAX + 0x2]
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x00101130
MOV R15,RAX
MOV qword ptr [RSP + 0x10],RAX
MOV RDX,RBX
MOV RSI,R12
MOV RDI,RAX
CALL 0x00101150
MOV RDX,RBX
LEA RSI,[0x102004]
MOV RDI,R15
CALL 0x001010d0
LEA EAX,[RBP + 0x1]
TEST EAX,EAX
JLE 0x00101438
MOV RBX,R15
MOV EBP,EBP
LEA R15,[R15 + RBP*0x1 + 0x1]
MOV R14D,0x0
MOV EBP,0x0
MOV qword ptr [RSP + 0x8],0x0
LEA R13,[RSP + 0x25]
JMP 0x0010138c
LAB_001012f0:
LEA RSI,[0x102024]
MOV RDI,R13
CALL 0x00101120
TEST EAX,EAX
JNZ 0x0010131e
CMP EBP,R14D
JZ 0x001013b4
LAB_0010130c:
MOVSXD RAX,EBP
MOV RCX,qword ptr [RSP + 0x8]
MOV dword ptr [RCX + RAX*0x4],0x4
LEA EBP,[RBP + 0x1]
LAB_0010131e:
LEA RSI,[0x102039]
MOV RDI,R13
CALL 0x00101120
TEST EAX,EAX
JNZ 0x0010134c
CMP EBP,R14D
JZ 0x001013e0
LAB_0010133a:
MOVSXD RAX,EBP
MOV RDX,qword ptr [RSP + 0x8]
MOV dword ptr [RDX + RAX*0x4],0x2
LEA EBP,[RBP + 0x1]
LAB_0010134c:
LEA RSI,[0x10200f]
MOV RDI,R13
CALL 0x00101120
TEST EAX,EAX
JNZ 0x0010137a
CMP EBP,R14D
JZ 0x0010140c
LAB_00101368:
MOVSXD RAX,EBP
MOV RCX,qword ptr [RSP + 0x8]
MOV dword ptr [RCX + RAX*0x4],0x1
LEA EBP,[RBP + 0x1]
LAB_0010137a:
MOV byte ptr [RSP + 0x25],0x0
LAB_0010137f:
ADD RBX,0x1
CMP RBX,R15
JZ 0x00101446
LAB_0010138c:
MOVZX R12D,byte ptr [RBX]
CMP R12B,0x20
JZ 0x001012f0
MOV RDI,R13
CALL 0x001010f0
CMP RAX,0x1
JA 0x0010137f
MOV byte ptr [RSP + RAX*0x1 + 0x25],R12B
MOV byte ptr [RSP + RAX*0x1 + 0x26],0x0
JMP 0x0010137f
LAB_001013b4:
LEA EAX,[R14 + R14*0x1]
TEST R14D,R14D
MOV R14D,0x4
CMOVG R14D,EAX
MOVSXD RSI,R14D
SHL RSI,0x2
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0010130c
LAB_001013e0:
LEA EAX,[R14 + R14*0x1]
TEST R14D,R14D
MOV R14D,0x4
CMOVG R14D,EAX
MOVSXD RSI,R14D
SHL RSI,0x2
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0010133a
LAB_0010140c:
LEA EAX,[R14 + R14*0x1]
TEST R14D,R14D
MOV R14D,0x4
CMOVG R14D,EAX
MOVSXD RSI,R14D
SHL RSI,0x2
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00101368
LAB_00101438:
MOV EBP,0x0
MOV qword ptr [RSP + 0x8],0x0
LAB_00101446:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],EBP
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010147b
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010147b:
CALL 0x00101100
|
void * func0(char *param_1,int *param_2)
{
char cVar1;
bool bVar2;
int iVar3;
size_t sVar4;
char *__ptr;
size_t sVar5;
char *pcVar6;
int iVar7;
int iVar8;
long in_FS_OFFSET;
void *local_60;
int2 local_43;
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_43 = 0;
local_41 = 0;
sVar4 = strlen(param_1);
sVar5 = (size_t)((int)sVar4 + 2);
__ptr = (char *)malloc(sVar5);
__strcpy_chk(__ptr,param_1,sVar5);
__strcat_chk(__ptr,&DAT_00102004,sVar5);
if ((int)sVar4 + 1 < 1) {
iVar7 = 0;
local_60 = (void *)0x0;
}
else {
iVar8 = 0;
iVar7 = 0;
local_60 = (void *)0x0;
pcVar6 = __ptr;
do {
cVar1 = *pcVar6;
if (cVar1 == ' ') {
iVar3 = strcmp((char *)&local_43,"o");
if (iVar3 == 0) {
if (iVar7 == iVar8) {
iVar3 = iVar8 * 2;
bVar2 = 0 < iVar8;
iVar8 = 4;
if (bVar2) {
iVar8 = iVar3;
}
local_60 = realloc(local_60,(long)iVar8 << 2);
}
*(int4 *)((long)local_60 + (long)iVar7 * 4) = 4;
iVar7 = iVar7 + 1;
}
iVar3 = strcmp((char *)&local_43,"o|");
if (iVar3 == 0) {
if (iVar7 == iVar8) {
iVar3 = iVar8 * 2;
bVar2 = 0 < iVar8;
iVar8 = 4;
if (bVar2) {
iVar8 = iVar3;
}
local_60 = realloc(local_60,(long)iVar8 << 2);
}
*(int4 *)((long)local_60 + (long)iVar7 * 4) = 2;
iVar7 = iVar7 + 1;
}
iVar3 = strcmp((char *)&local_43,".|");
if (iVar3 == 0) {
if (iVar7 == iVar8) {
iVar3 = iVar8 * 2;
bVar2 = 0 < iVar8;
iVar8 = 4;
if (bVar2) {
iVar8 = iVar3;
}
local_60 = realloc(local_60,(long)iVar8 << 2);
}
*(int4 *)((long)local_60 + (long)iVar7 * 4) = 1;
iVar7 = iVar7 + 1;
}
local_43 = local_43 & 0xff00;
}
else {
sVar5 = strlen((char *)&local_43);
if (sVar5 < 2) {
*(char *)((long)&local_43 + sVar5) = cVar1;
*(int *)((long)&local_43 + sVar5 + 1) = 0;
}
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != __ptr + (sVar4 & 0xffffffff) + 1);
}
free(__ptr);
*param_2 = iVar7;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_60;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
726 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_music_string, " ");
for (int i = 0; i < music_string_length; i++) {
if (temp_music_string[i] == ' ') {
if (strcmp(current, "o") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 4;
}
if (strcmp(current, "o|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 2;
}
if (strcmp(current, ".|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 1;
}
strcpy(current, "");
} else {
size_t len = strlen(current);
if (len < sizeof(current) - 1) {
current[len] = temp_music_string[i];
current[len + 1] = '\0';
}
}
}
free(temp_music_string);
*count = size;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
assert(issame(result, count, (const int[]){}, 0));
free(result);
result = func0("o o o o", &count);
assert(issame(result, count, (const int[]){4, 4, 4, 4}, 4));
free(result);
result = func0(".| .| .| .|", &count);
assert(issame(result, count, (const int[]){1, 1, 1, 1}, 4));
free(result);
result = func0("o| o| .| .| o o o o", &count);
assert(issame(result, count, (const int[]){2, 2, 1, 1, 4, 4, 4, 4}, 8));
free(result);
result = func0("o| .| o| .| o o| o o|", &count);
assert(issame(result, count, (const int[]){2, 1, 2, 1, 4, 2, 4, 2}, 8));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
xor %eax,%eax
movb $0x0,0x27(%rsp)
mov %ax,0x25(%rsp)
callq 10c0 <strlen@plt>
lea 0x2(%rax),%edi
mov %rax,%rbp
movslq %edi,%rdi
callq 1100 <malloc@plt>
mov %rbp,%rdx
mov %r12,%rsi
mov %rax,%rdi
mov %rax,%rbx
mov %rax,0x10(%rsp)
callq 10f0 <memcpy@plt>
mov $0x20,%edx
lea 0x1(%rbp),%eax
mov %dx,(%rbx,%rbp,1)
test %eax,%eax
jle 1700 <func0+0x240>
mov %ebp,%ebp
movl $0x0,0xc(%rsp)
xor %r15d,%r15d
lea 0x25(%rsp),%r14
lea 0x1(%rbx,%rbp,1),%r12
xor %ebp,%ebp
jmp 1575 <func0+0xb5>
xchg %ax,%ax
mov %r14,%rdi
callq 10c0 <strlen@plt>
cmp $0x2,%rax
je 1568 <func0+0xa8>
mov %r13b,0x25(%rsp,%rax,1)
movb $0x0,0x26(%rsp,%rax,1)
add $0x1,%rbx
cmp %r12,%rbx
je 1614 <func0+0x154>
movzbl (%rbx),%r13d
cmp $0x20,%r13b
jne 1550 <func0+0x90>
cmpb $0x6f,(%r14)
jne 15a6 <func0+0xe6>
cmpb $0x0,0x1(%r14)
jne 15a6 <func0+0xe6>
cmp %r15d,0xc(%rsp)
je 1650 <func0+0x190>
movslq %r15d,%rax
add $0x1,%r15d
movl $0x4,0x0(%rbp,%rax,4)
cmpb $0x6f,(%r14)
jne 15d4 <func0+0x114>
cmpb $0x7c,0x1(%r14)
jne 15d4 <func0+0x114>
cmpb $0x0,0x2(%r14)
jne 15d4 <func0+0x114>
cmp 0xc(%rsp),%r15d
je 16a0 <func0+0x1e0>
movslq %r15d,%rax
add $0x1,%r15d
movl $0x2,0x0(%rbp,%rax,4)
cmpb $0x2e,(%r14)
jne 1602 <func0+0x142>
cmpb $0x7c,0x1(%r14)
jne 1602 <func0+0x142>
cmpb $0x0,0x2(%r14)
jne 1602 <func0+0x142>
cmp 0xc(%rsp),%r15d
je 1678 <func0+0x1b8>
movslq %r15d,%rax
add $0x1,%r15d
movl $0x1,0x0(%rbp,%rax,4)
add $0x1,%rbx
movb $0x0,0x25(%rsp)
cmp %r12,%rbx
jne 1575 <func0+0xb5>
mov 0x10(%rsp),%rdi
callq 10b0 <free@plt>
mov 0x18(%rsp),%rax
mov %r15d,(%rax)
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 170a <func0+0x24a>
add $0x38,%rsp
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov 0xc(%rsp),%eax
test %eax,%eax
je 16c8 <func0+0x208>
add %eax,%eax
mov %eax,0xc(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
mov %rbp,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbp
jmpq 1597 <func0+0xd7>
nopl (%rax)
test %r15d,%r15d
je 16f0 <func0+0x230>
lea (%r15,%r15,1),%eax
mov %eax,0xc(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
mov %rbp,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbp
jmpq 15f3 <func0+0x133>
nopl 0x0(%rax)
test %r15d,%r15d
je 16e0 <func0+0x220>
lea (%r15,%r15,1),%eax
mov %eax,0xc(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
mov %rbp,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbp
jmpq 15c5 <func0+0x105>
nopl 0x0(%rax)
movl $0x4,0xc(%rsp)
mov $0x10,%esi
jmp 1665 <func0+0x1a5>
nopw 0x0(%rax,%rax,1)
movl $0x4,0xc(%rsp)
mov $0x10,%esi
jmp 16b4 <func0+0x1f4>
movl $0x4,0xc(%rsp)
mov $0x10,%esi
jmp 168c <func0+0x1cc>
xor %r15d,%r15d
xor %ebp,%ebp
jmpq 1614 <func0+0x154>
callq 10d0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_50], rsi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
xor eax, eax
mov [rsp+68h+var_41], 0
mov word ptr [rsp+68h+s], ax
call _strlen
lea ebx, [rax+2]
mov rbp, rax
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rcx, rbx
mov rdx, rbp
mov rsi, r12
mov rdi, rax
mov r15, rax
mov [rsp+68h+ptr], rax
call ___memcpy_chk
mov rcx, rbx
lea rdi, [r15+rbp]
mov edx, 2
sub rcx, rbp
lea rsi, unk_2004
call ___memcpy_chk
lea eax, [rbp+1]
test eax, eax
jle loc_16F0
mov ebp, ebp
mov rbx, r15
lea r13, [rsp+68h+s]
mov [rsp+68h+var_5C], 0
lea r12, [r15+rbp+1]
xor r15d, r15d
xor ebp, ebp
jmp short loc_1565
loc_1540:
mov rdi, r13; s
call _strlen
cmp rax, 2
jz short loc_1558
mov [rsp+rax+68h+s], r14b
mov [rsp+rax+68h+s+1], 0
loc_1558:
add rbx, 1
cmp r12, rbx
jz loc_160D
loc_1565:
movzx r14d, byte ptr [rbx]
cmp r14b, 20h ; ' '
jnz short loc_1540
cmp byte ptr [r13+0], 6Fh ; 'o'
jnz short loc_1599
cmp byte ptr [r13+1], 0
jnz short loc_1599
mov eax, [rsp+68h+var_5C]
cmp r15d, eax
jz loc_1648
loc_158A:
movsxd rax, r15d
add r15d, 1
mov dword ptr [rbp+rax*4+0], 4
loc_1599:
cmp byte ptr [r13+0], 6Fh ; 'o'
jnz short loc_15CA
cmp byte ptr [r13+1], 7Ch ; '|'
jnz short loc_15CA
cmp byte ptr [r13+2], 0
jnz short loc_15CA
mov eax, [rsp+68h+var_5C]
cmp r15d, eax
jz loc_1698
loc_15BB:
movsxd rax, r15d
add r15d, 1
mov dword ptr [rbp+rax*4+0], 2
loc_15CA:
cmp byte ptr [r13+0], 2Eh ; '.'
jnz short loc_15FB
cmp byte ptr [r13+1], 7Ch ; '|'
jnz short loc_15FB
cmp byte ptr [r13+2], 0
jnz short loc_15FB
mov eax, [rsp+68h+var_5C]
cmp r15d, eax
jz loc_1670
loc_15EC:
movsxd rax, r15d
add r15d, 1
mov dword ptr [rbp+rax*4+0], 1
loc_15FB:
add rbx, 1
mov [rsp+68h+s], 0
cmp r12, rbx
jnz loc_1565
loc_160D:
mov rdi, [rsp+68h+ptr]; ptr
call _free
mov rax, [rsp+68h+var_50]
mov [rax], r15d
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_16FA
add rsp, 38h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1648:
test r15d, r15d
jle short loc_16C0
lea eax, [r15+r15]
mov [rsp+68h+var_5C], eax
movsxd rsi, eax
shl rsi, 2; size
loc_165C:
mov rdi, rbp; ptr
call _realloc
mov rbp, rax
jmp loc_158A
loc_1670:
test r15d, r15d
jle short loc_16E0
lea eax, [r15+r15]
mov [rsp+68h+var_5C], eax
movsxd rsi, eax
shl rsi, 2; size
loc_1684:
mov rdi, rbp; ptr
call _realloc
mov rbp, rax
jmp loc_15EC
loc_1698:
test r15d, r15d
jle short loc_16D0
lea eax, [r15+r15]
mov [rsp+68h+var_5C], eax
movsxd rsi, eax
shl rsi, 2; size
loc_16AC:
mov rdi, rbp; ptr
call _realloc
mov rbp, rax
jmp loc_15BB
loc_16C0:
mov [rsp+68h+var_5C], 4
mov esi, 10h
jmp short loc_165C
loc_16D0:
mov [rsp+68h+var_5C], 4
mov esi, 10h
jmp short loc_16AC
loc_16E0:
mov [rsp+68h+var_5C], 4
mov esi, 10h
jmp short loc_1684
loc_16F0:
xor r15d, r15d
xor ebp, ebp
jmp loc_160D
loc_16FA:
call ___stack_chk_fail
|
void * func0(const char *a1, int *a2)
{
size_t v2; // rbp
size_t v3; // rbx
char *v4; // r15
char *v5; // rbx
long long v6; // r12
int v7; // r15d
void *v8; // rbp
size_t v9; // rax
char v10; // r14
long long v11; // rax
long long v12; // rax
long long v13; // rax
size_t v15; // rsi
size_t v16; // rsi
size_t v17; // rsi
int v18; // [rsp+Ch] [rbp-5Ch]
void *ptr; // [rsp+10h] [rbp-58h]
char s[2]; // [rsp+25h] [rbp-43h] BYREF
char v22; // [rsp+27h] [rbp-41h]
unsigned long long v23; // [rsp+28h] [rbp-40h]
v23 = __readfsqword(0x28u);
v22 = 0;
*(_WORD *)s = 0;
v2 = strlen(a1);
v3 = (int)v2 + 2;
v4 = (char *)malloc(v3);
ptr = v4;
__memcpy_chk(v4, a1, v2, v3);
__memcpy_chk(&v4[v2], &unk_2004, 2LL, v3 - v2);
if ( (int)v2 + 1 <= 0 )
{
v7 = 0;
v8 = 0LL;
}
else
{
v5 = v4;
v18 = 0;
v6 = (long long)&v4[(unsigned int)v2 + 1];
v7 = 0;
v8 = 0LL;
do
{
while ( 1 )
{
v10 = *v5;
if ( *v5 != 32 )
break;
if ( s[0] == 111 && !s[1] )
{
if ( v7 == v18 )
{
if ( v7 <= 0 )
{
v18 = 4;
v15 = 16LL;
}
else
{
v18 = 2 * v7;
v15 = 8LL * v7;
}
v8 = realloc(v8, v15);
}
v11 = v7++;
*((_DWORD *)v8 + v11) = 4;
}
if ( s[0] == 111 && s[1] == 124 && !v22 )
{
if ( v7 == v18 )
{
if ( v7 <= 0 )
{
v18 = 4;
v17 = 16LL;
}
else
{
v18 = 2 * v7;
v17 = 8LL * v7;
}
v8 = realloc(v8, v17);
}
v12 = v7++;
*((_DWORD *)v8 + v12) = 2;
}
if ( s[0] == 46 && s[1] == 124 && !v22 )
{
if ( v7 == v18 )
{
if ( v7 <= 0 )
{
v18 = 4;
v16 = 16LL;
}
else
{
v18 = 2 * v7;
v16 = 8LL * v7;
}
v8 = realloc(v8, v16);
}
v13 = v7++;
*((_DWORD *)v8 + v13) = 1;
}
++v5;
s[0] = 0;
if ( (char *)v6 == v5 )
goto LABEL_22;
}
v9 = strlen(s);
if ( v9 != 2 )
{
s[v9] = v10;
s[v9 + 1] = 0;
}
++v5;
}
while ( (char *)v6 != v5 );
}
LABEL_22:
free(ptr);
*a2 = v7;
return v8;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x27],0x0
MOV word ptr [RSP + 0x25],AX
CALL 0x001010c0
LEA EBX,[RAX + 0x2]
MOV RBP,RAX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x00101100
MOV RCX,RBX
MOV RDX,RBP
MOV RSI,R12
MOV RDI,RAX
MOV R15,RAX
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
MOV RCX,RBX
LEA RDI,[R15 + RBP*0x1]
MOV EDX,0x2
SUB RCX,RBP
LEA RSI,[0x102004]
CALL 0x001010f0
LEA EAX,[RBP + 0x1]
TEST EAX,EAX
JLE 0x001016f0
MOV EBP,EBP
MOV RBX,R15
LEA R13,[RSP + 0x25]
MOV dword ptr [RSP + 0xc],0x0
LEA R12,[R15 + RBP*0x1 + 0x1]
XOR R15D,R15D
XOR EBP,EBP
JMP 0x00101565
LAB_00101540:
MOV RDI,R13
CALL 0x001010c0
CMP RAX,0x2
JZ 0x00101558
MOV byte ptr [RSP + RAX*0x1 + 0x25],R14B
MOV byte ptr [RSP + RAX*0x1 + 0x26],0x0
LAB_00101558:
ADD RBX,0x1
CMP R12,RBX
JZ 0x0010160d
LAB_00101565:
MOVZX R14D,byte ptr [RBX]
CMP R14B,0x20
JNZ 0x00101540
CMP byte ptr [R13],0x6f
JNZ 0x00101599
CMP byte ptr [R13 + 0x1],0x0
JNZ 0x00101599
MOV EAX,dword ptr [RSP + 0xc]
CMP R15D,EAX
JZ 0x00101648
LAB_0010158a:
MOVSXD RAX,R15D
ADD R15D,0x1
MOV dword ptr [RBP + RAX*0x4],0x4
LAB_00101599:
CMP byte ptr [R13],0x6f
JNZ 0x001015ca
CMP byte ptr [R13 + 0x1],0x7c
JNZ 0x001015ca
CMP byte ptr [R13 + 0x2],0x0
JNZ 0x001015ca
MOV EAX,dword ptr [RSP + 0xc]
CMP R15D,EAX
JZ 0x00101698
LAB_001015bb:
MOVSXD RAX,R15D
ADD R15D,0x1
MOV dword ptr [RBP + RAX*0x4],0x2
LAB_001015ca:
CMP byte ptr [R13],0x2e
JNZ 0x001015fb
CMP byte ptr [R13 + 0x1],0x7c
JNZ 0x001015fb
CMP byte ptr [R13 + 0x2],0x0
JNZ 0x001015fb
MOV EAX,dword ptr [RSP + 0xc]
CMP R15D,EAX
JZ 0x00101670
LAB_001015ec:
MOVSXD RAX,R15D
ADD R15D,0x1
MOV dword ptr [RBP + RAX*0x4],0x1
LAB_001015fb:
ADD RBX,0x1
MOV byte ptr [RSP + 0x25],0x0
CMP R12,RBX
JNZ 0x00101565
LAB_0010160d:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R15D
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016fa
ADD RSP,0x38
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101648:
TEST R15D,R15D
JLE 0x001016c0
LEA EAX,[R15 + R15*0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
LAB_0010165c:
MOV RDI,RBP
CALL 0x00101110
MOV RBP,RAX
JMP 0x0010158a
LAB_00101670:
TEST R15D,R15D
JLE 0x001016e0
LEA EAX,[R15 + R15*0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
LAB_00101684:
MOV RDI,RBP
CALL 0x00101110
MOV RBP,RAX
JMP 0x001015ec
LAB_00101698:
TEST R15D,R15D
JLE 0x001016d0
LEA EAX,[R15 + R15*0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
LAB_001016ac:
MOV RDI,RBP
CALL 0x00101110
MOV RBP,RAX
JMP 0x001015bb
LAB_001016c0:
MOV dword ptr [RSP + 0xc],0x4
MOV ESI,0x10
JMP 0x0010165c
LAB_001016d0:
MOV dword ptr [RSP + 0xc],0x4
MOV ESI,0x10
JMP 0x001016ac
LAB_001016e0:
MOV dword ptr [RSP + 0xc],0x4
MOV ESI,0x10
JMP 0x00101684
LAB_001016f0:
XOR R15D,R15D
XOR EBP,EBP
JMP 0x0010160d
LAB_001016fa:
CALL 0x001010d0
|
void * func0(char *param_1,int *param_2)
{
char cVar1;
size_t sVar2;
char *__ptr;
long lVar3;
void *__ptr_00;
size_t sVar4;
char *pcVar5;
int iVar6;
long in_FS_OFFSET;
int local_5c;
char local_43 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_43[2] = '\0';
local_43[0] = '\0';
local_43[1] = '\0';
sVar2 = strlen(param_1);
sVar4 = (size_t)((int)sVar2 + 2);
__ptr = (char *)malloc(sVar4);
__memcpy_chk(__ptr,param_1,sVar2,sVar4);
__memcpy_chk(__ptr + sVar2,&DAT_00102004,2,sVar4 - sVar2);
if ((int)sVar2 + 1 < 1) {
iVar6 = 0;
__ptr_00 = (void *)0x0;
}
else {
local_5c = 0;
iVar6 = 0;
__ptr_00 = (void *)0x0;
pcVar5 = __ptr;
do {
while (cVar1 = *pcVar5, cVar1 == ' ') {
if ((local_43[0] == 'o') && (local_43[1] == '\0')) {
if (iVar6 == local_5c) {
if (iVar6 < 1) {
local_5c = 4;
sVar4 = 0x10;
}
else {
local_5c = iVar6 * 2;
sVar4 = (long)local_5c << 2;
}
__ptr_00 = realloc(__ptr_00,sVar4);
}
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int4 *)((long)__ptr_00 + lVar3 * 4) = 4;
}
if (((local_43[0] == 'o') && (local_43[1] == '|')) && (local_43[2] == '\0')) {
if (iVar6 == local_5c) {
if (iVar6 < 1) {
local_5c = 4;
sVar4 = 0x10;
}
else {
local_5c = iVar6 * 2;
sVar4 = (long)local_5c << 2;
}
__ptr_00 = realloc(__ptr_00,sVar4);
}
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int4 *)((long)__ptr_00 + lVar3 * 4) = 2;
}
if (((local_43[0] == '.') && (local_43[1] == '|')) && (local_43[2] == '\0')) {
if (iVar6 == local_5c) {
if (iVar6 < 1) {
local_5c = 4;
sVar4 = 0x10;
}
else {
local_5c = iVar6 * 2;
sVar4 = (long)local_5c << 2;
}
__ptr_00 = realloc(__ptr_00,sVar4);
}
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int4 *)((long)__ptr_00 + lVar3 * 4) = 1;
}
pcVar5 = pcVar5 + 1;
local_43[0] = '\0';
if (__ptr + (sVar2 & 0xffffffff) + 1 == pcVar5) goto LAB_0010160d;
}
sVar4 = strlen(local_43);
if (sVar4 != 2) {
local_43[sVar4] = cVar1;
local_43[sVar4 + 1] = '\0';
}
pcVar5 = pcVar5 + 1;
} while (__ptr + (sVar2 & 0xffffffff) + 1 != pcVar5);
}
LAB_0010160d:
free(__ptr);
*param_2 = iVar6;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return __ptr_00;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
727 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_music_string, " ");
for (int i = 0; i < music_string_length; i++) {
if (temp_music_string[i] == ' ') {
if (strcmp(current, "o") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 4;
}
if (strcmp(current, "o|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 2;
}
if (strcmp(current, ".|") == 0) {
if (size == capacity) {
capacity = capacity > 0 ? 2 * capacity : 4;
out = realloc(out, capacity * sizeof(int));
}
out[size++] = 1;
}
strcpy(current, "");
} else {
size_t len = strlen(current);
if (len < sizeof(current) - 1) {
current[len] = temp_music_string[i];
current[len + 1] = '\0';
}
}
}
free(temp_music_string);
*count = size;
return out;
}
|
#include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
assert(issame(result, count, (const int[]){}, 0));
free(result);
result = func0("o o o o", &count);
assert(issame(result, count, (const int[]){4, 4, 4, 4}, 4));
free(result);
result = func0(".| .| .| .|", &count);
assert(issame(result, count, (const int[]){1, 1, 1, 1}, 4));
free(result);
result = func0("o| o| .| .| o o o o", &count);
assert(issame(result, count, (const int[]){2, 2, 1, 1, 4, 4, 4, 4}, 8));
free(result);
result = func0("o| .| o| .| o o| o o|", &count);
assert(issame(result, count, (const int[]){2, 1, 2, 1, 4, 2, 4, 2}, 8));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
xor %eax,%eax
movb $0x0,0x27(%rsp)
mov %ax,0x25(%rsp)
callq 10c0 <strlen@plt>
lea 0x2(%rax),%edi
mov %rax,%rbp
movslq %edi,%rdi
callq 1100 <malloc@plt>
mov %rbp,%rdx
mov %r12,%rsi
mov %rax,%rdi
mov %rax,%rbx
mov %rax,0x10(%rsp)
callq 10f0 <memcpy@plt>
mov $0x20,%edx
lea 0x1(%rbp),%eax
mov %dx,(%rbx,%rbp,1)
test %eax,%eax
jle 16e0 <func0+0x240>
mov %ebp,%ebp
movl $0x0,0xc(%rsp)
xor %r15d,%r15d
lea 0x25(%rsp),%r14
lea 0x1(%rbx,%rbp,1),%r12
xor %ebp,%ebp
jmp 1555 <func0+0xb5>
xchg %ax,%ax
mov %r14,%rdi
callq 10c0 <strlen@plt>
cmp $0x2,%rax
je 1548 <func0+0xa8>
mov %r13b,0x25(%rsp,%rax,1)
movb $0x0,0x26(%rsp,%rax,1)
add $0x1,%rbx
cmp %rbx,%r12
je 15f4 <func0+0x154>
movzbl (%rbx),%r13d
cmp $0x20,%r13b
jne 1530 <func0+0x90>
cmpb $0x6f,(%r14)
jne 1586 <func0+0xe6>
cmpb $0x0,0x1(%r14)
jne 1586 <func0+0xe6>
cmp %r15d,0xc(%rsp)
je 1630 <func0+0x190>
movslq %r15d,%rax
add $0x1,%r15d
movl $0x4,0x0(%rbp,%rax,4)
cmpb $0x6f,(%r14)
jne 15b4 <func0+0x114>
cmpb $0x7c,0x1(%r14)
jne 15b4 <func0+0x114>
cmpb $0x0,0x2(%r14)
jne 15b4 <func0+0x114>
cmp 0xc(%rsp),%r15d
je 1680 <func0+0x1e0>
movslq %r15d,%rax
add $0x1,%r15d
movl $0x2,0x0(%rbp,%rax,4)
cmpb $0x2e,(%r14)
jne 15e2 <func0+0x142>
cmpb $0x7c,0x1(%r14)
jne 15e2 <func0+0x142>
cmpb $0x0,0x2(%r14)
jne 15e2 <func0+0x142>
cmp 0xc(%rsp),%r15d
je 1658 <func0+0x1b8>
movslq %r15d,%rax
add $0x1,%r15d
movl $0x1,0x0(%rbp,%rax,4)
add $0x1,%rbx
movb $0x0,0x25(%rsp)
cmp %rbx,%r12
jne 1555 <func0+0xb5>
mov 0x10(%rsp),%rdi
callq 10b0 <free@plt>
mov 0x18(%rsp),%rax
mov %r15d,(%rax)
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 16ea <func0+0x24a>
add $0x38,%rsp
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov 0xc(%rsp),%eax
test %eax,%eax
je 16a8 <func0+0x208>
add %eax,%eax
mov %eax,0xc(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
mov %rbp,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbp
jmpq 1577 <func0+0xd7>
nopl (%rax)
test %r15d,%r15d
je 16d0 <func0+0x230>
lea (%r15,%r15,1),%eax
mov %eax,0xc(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
mov %rbp,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbp
jmpq 15d3 <func0+0x133>
nopl 0x0(%rax)
test %r15d,%r15d
je 16c0 <func0+0x220>
lea (%r15,%r15,1),%eax
mov %eax,0xc(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
mov %rbp,%rdi
callq 1110 <realloc@plt>
mov %rax,%rbp
jmpq 15a5 <func0+0x105>
nopl 0x0(%rax)
movl $0x4,0xc(%rsp)
mov $0x10,%esi
jmp 1645 <func0+0x1a5>
nopw 0x0(%rax,%rax,1)
movl $0x4,0xc(%rsp)
mov $0x10,%esi
jmp 1694 <func0+0x1f4>
movl $0x4,0xc(%rsp)
mov $0x10,%esi
jmp 166c <func0+0x1cc>
xor %r15d,%r15d
xor %ebp,%ebp
jmpq 15f4 <func0+0x154>
callq 10d0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_50], rsi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
xor eax, eax
mov [rsp+68h+var_41], 0
mov word ptr [rsp+68h+s], ax
call _strlen
lea ebx, [rax+2]
mov rbp, rax
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rcx, rbx
mov rdx, rbp
mov rsi, r12
mov rdi, rax
mov r15, rax
mov [rsp+68h+ptr], rax
call ___memcpy_chk
mov rcx, rbx
lea rdi, [r15+rbp]
mov edx, 2
sub rcx, rbp
lea rsi, unk_2004
call ___memcpy_chk
lea eax, [rbp+1]
test eax, eax
jle loc_16F0
mov ebp, ebp
mov rbx, r15
lea r13, [rsp+68h+s]
mov [rsp+68h+var_5C], 0
lea r12, [r15+rbp+1]
xor r15d, r15d
xor ebp, ebp
jmp short loc_1565
loc_1540:
mov rdi, r13; s
call _strlen
cmp rax, 2
jz short loc_1558
mov [rsp+rax+68h+s], r14b
mov [rsp+rax+68h+s+1], 0
loc_1558:
add rbx, 1
cmp rbx, r12
jz loc_160D
loc_1565:
movzx r14d, byte ptr [rbx]
cmp r14b, 20h ; ' '
jnz short loc_1540
cmp byte ptr [r13+0], 6Fh ; 'o'
jnz short loc_1599
cmp byte ptr [r13+1], 0
jnz short loc_1599
mov eax, [rsp+68h+var_5C]
cmp r15d, eax
jz loc_1648
loc_158A:
movsxd rax, r15d
add r15d, 1
mov dword ptr [rbp+rax*4+0], 4
loc_1599:
cmp byte ptr [r13+0], 6Fh ; 'o'
jnz short loc_15CA
cmp byte ptr [r13+1], 7Ch ; '|'
jnz short loc_15CA
cmp byte ptr [r13+2], 0
jnz short loc_15CA
mov eax, [rsp+68h+var_5C]
cmp r15d, eax
jz loc_1698
loc_15BB:
movsxd rax, r15d
add r15d, 1
mov dword ptr [rbp+rax*4+0], 2
loc_15CA:
cmp byte ptr [r13+0], 2Eh ; '.'
jnz short loc_15FB
cmp byte ptr [r13+1], 7Ch ; '|'
jnz short loc_15FB
cmp byte ptr [r13+2], 0
jnz short loc_15FB
mov eax, [rsp+68h+var_5C]
cmp r15d, eax
jz loc_1670
loc_15EC:
movsxd rax, r15d
add r15d, 1
mov dword ptr [rbp+rax*4+0], 1
loc_15FB:
add rbx, 1
mov [rsp+68h+s], 0
cmp rbx, r12
jnz loc_1565
loc_160D:
mov rdi, [rsp+68h+ptr]; ptr
call _free
mov rax, [rsp+68h+var_50]
mov [rax], r15d
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_16FA
add rsp, 38h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1648:
test r15d, r15d
jle short loc_16C0
lea eax, [r15+r15]
mov [rsp+68h+var_5C], eax
movsxd rsi, eax
shl rsi, 2; size
loc_165C:
mov rdi, rbp; ptr
call _realloc
mov rbp, rax
jmp loc_158A
loc_1670:
test r15d, r15d
jle short loc_16E0
lea eax, [r15+r15]
mov [rsp+68h+var_5C], eax
movsxd rsi, eax
shl rsi, 2; size
loc_1684:
mov rdi, rbp; ptr
call _realloc
mov rbp, rax
jmp loc_15EC
loc_1698:
test r15d, r15d
jle short loc_16D0
lea eax, [r15+r15]
mov [rsp+68h+var_5C], eax
movsxd rsi, eax
shl rsi, 2; size
loc_16AC:
mov rdi, rbp; ptr
call _realloc
mov rbp, rax
jmp loc_15BB
loc_16C0:
mov [rsp+68h+var_5C], 4
mov esi, 10h
jmp short loc_165C
loc_16D0:
mov [rsp+68h+var_5C], 4
mov esi, 10h
jmp short loc_16AC
loc_16E0:
mov [rsp+68h+var_5C], 4
mov esi, 10h
jmp short loc_1684
loc_16F0:
xor r15d, r15d
xor ebp, ebp
jmp loc_160D
loc_16FA:
call ___stack_chk_fail
|
void * func0(const char *a1, int *a2)
{
size_t v2; // rbp
size_t v3; // rbx
char *v4; // r15
char *v5; // rbx
long long v6; // r12
int v7; // r15d
void *v8; // rbp
size_t v9; // rax
char v10; // r14
long long v11; // rax
long long v12; // rax
long long v13; // rax
size_t v15; // rsi
size_t v16; // rsi
size_t v17; // rsi
int v18; // [rsp+Ch] [rbp-5Ch]
void *ptr; // [rsp+10h] [rbp-58h]
char s[2]; // [rsp+25h] [rbp-43h] BYREF
char v22; // [rsp+27h] [rbp-41h]
unsigned long long v23; // [rsp+28h] [rbp-40h]
v23 = __readfsqword(0x28u);
v22 = 0;
*(_WORD *)s = 0;
v2 = strlen(a1);
v3 = (int)v2 + 2;
v4 = (char *)malloc(v3);
ptr = v4;
__memcpy_chk(v4, a1, v2, v3);
__memcpy_chk(&v4[v2], &unk_2004, 2LL, v3 - v2);
if ( (int)v2 + 1 <= 0 )
{
v7 = 0;
v8 = 0LL;
}
else
{
v5 = v4;
v18 = 0;
v6 = (long long)&v4[(unsigned int)v2 + 1];
v7 = 0;
v8 = 0LL;
do
{
while ( 1 )
{
v10 = *v5;
if ( *v5 != 32 )
break;
if ( s[0] == 111 && !s[1] )
{
if ( v7 == v18 )
{
if ( v7 <= 0 )
{
v18 = 4;
v15 = 16LL;
}
else
{
v18 = 2 * v7;
v15 = 8LL * v7;
}
v8 = realloc(v8, v15);
}
v11 = v7++;
*((_DWORD *)v8 + v11) = 4;
}
if ( s[0] == 111 && s[1] == 124 && !v22 )
{
if ( v7 == v18 )
{
if ( v7 <= 0 )
{
v18 = 4;
v17 = 16LL;
}
else
{
v18 = 2 * v7;
v17 = 8LL * v7;
}
v8 = realloc(v8, v17);
}
v12 = v7++;
*((_DWORD *)v8 + v12) = 2;
}
if ( s[0] == 46 && s[1] == 124 && !v22 )
{
if ( v7 == v18 )
{
if ( v7 <= 0 )
{
v18 = 4;
v16 = 16LL;
}
else
{
v18 = 2 * v7;
v16 = 8LL * v7;
}
v8 = realloc(v8, v16);
}
v13 = v7++;
*((_DWORD *)v8 + v13) = 1;
}
++v5;
s[0] = 0;
if ( v5 == (char *)v6 )
goto LABEL_22;
}
v9 = strlen(s);
if ( v9 != 2 )
{
s[v9] = v10;
s[v9 + 1] = 0;
}
++v5;
}
while ( v5 != (char *)v6 );
}
LABEL_22:
free(ptr);
*a2 = v7;
return v8;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x27],0x0
MOV word ptr [RSP + 0x25],AX
CALL 0x001010c0
LEA EBX,[RAX + 0x2]
MOV RBP,RAX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x00101100
MOV RCX,RBX
MOV RDX,RBP
MOV RSI,R12
MOV RDI,RAX
MOV R15,RAX
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
MOV RCX,RBX
LEA RDI,[R15 + RBP*0x1]
MOV EDX,0x2
SUB RCX,RBP
LEA RSI,[0x102004]
CALL 0x001010f0
LEA EAX,[RBP + 0x1]
TEST EAX,EAX
JLE 0x001016f0
MOV EBP,EBP
MOV RBX,R15
LEA R13,[RSP + 0x25]
MOV dword ptr [RSP + 0xc],0x0
LEA R12,[R15 + RBP*0x1 + 0x1]
XOR R15D,R15D
XOR EBP,EBP
JMP 0x00101565
LAB_00101540:
MOV RDI,R13
CALL 0x001010c0
CMP RAX,0x2
JZ 0x00101558
MOV byte ptr [RSP + RAX*0x1 + 0x25],R14B
MOV byte ptr [RSP + RAX*0x1 + 0x26],0x0
LAB_00101558:
ADD RBX,0x1
CMP RBX,R12
JZ 0x0010160d
LAB_00101565:
MOVZX R14D,byte ptr [RBX]
CMP R14B,0x20
JNZ 0x00101540
CMP byte ptr [R13],0x6f
JNZ 0x00101599
CMP byte ptr [R13 + 0x1],0x0
JNZ 0x00101599
MOV EAX,dword ptr [RSP + 0xc]
CMP R15D,EAX
JZ 0x00101648
LAB_0010158a:
MOVSXD RAX,R15D
ADD R15D,0x1
MOV dword ptr [RBP + RAX*0x4],0x4
LAB_00101599:
CMP byte ptr [R13],0x6f
JNZ 0x001015ca
CMP byte ptr [R13 + 0x1],0x7c
JNZ 0x001015ca
CMP byte ptr [R13 + 0x2],0x0
JNZ 0x001015ca
MOV EAX,dword ptr [RSP + 0xc]
CMP R15D,EAX
JZ 0x00101698
LAB_001015bb:
MOVSXD RAX,R15D
ADD R15D,0x1
MOV dword ptr [RBP + RAX*0x4],0x2
LAB_001015ca:
CMP byte ptr [R13],0x2e
JNZ 0x001015fb
CMP byte ptr [R13 + 0x1],0x7c
JNZ 0x001015fb
CMP byte ptr [R13 + 0x2],0x0
JNZ 0x001015fb
MOV EAX,dword ptr [RSP + 0xc]
CMP R15D,EAX
JZ 0x00101670
LAB_001015ec:
MOVSXD RAX,R15D
ADD R15D,0x1
MOV dword ptr [RBP + RAX*0x4],0x1
LAB_001015fb:
ADD RBX,0x1
MOV byte ptr [RSP + 0x25],0x0
CMP RBX,R12
JNZ 0x00101565
LAB_0010160d:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R15D
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016fa
ADD RSP,0x38
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101648:
TEST R15D,R15D
JLE 0x001016c0
LEA EAX,[R15 + R15*0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
LAB_0010165c:
MOV RDI,RBP
CALL 0x00101110
MOV RBP,RAX
JMP 0x0010158a
LAB_00101670:
TEST R15D,R15D
JLE 0x001016e0
LEA EAX,[R15 + R15*0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
LAB_00101684:
MOV RDI,RBP
CALL 0x00101110
MOV RBP,RAX
JMP 0x001015ec
LAB_00101698:
TEST R15D,R15D
JLE 0x001016d0
LEA EAX,[R15 + R15*0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
LAB_001016ac:
MOV RDI,RBP
CALL 0x00101110
MOV RBP,RAX
JMP 0x001015bb
LAB_001016c0:
MOV dword ptr [RSP + 0xc],0x4
MOV ESI,0x10
JMP 0x0010165c
LAB_001016d0:
MOV dword ptr [RSP + 0xc],0x4
MOV ESI,0x10
JMP 0x001016ac
LAB_001016e0:
MOV dword ptr [RSP + 0xc],0x4
MOV ESI,0x10
JMP 0x00101684
LAB_001016f0:
XOR R15D,R15D
XOR EBP,EBP
JMP 0x0010160d
LAB_001016fa:
CALL 0x001010d0
|
void * func0(char *param_1,int *param_2)
{
char cVar1;
size_t sVar2;
char *__ptr;
long lVar3;
void *__ptr_00;
size_t sVar4;
char *pcVar5;
int iVar6;
long in_FS_OFFSET;
int local_5c;
char local_43 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_43[2] = '\0';
local_43[0] = '\0';
local_43[1] = '\0';
sVar2 = strlen(param_1);
sVar4 = (size_t)((int)sVar2 + 2);
__ptr = (char *)malloc(sVar4);
__memcpy_chk(__ptr,param_1,sVar2,sVar4);
__memcpy_chk(__ptr + sVar2,&DAT_00102004,2,sVar4 - sVar2);
if ((int)sVar2 + 1 < 1) {
iVar6 = 0;
__ptr_00 = (void *)0x0;
}
else {
local_5c = 0;
iVar6 = 0;
__ptr_00 = (void *)0x0;
pcVar5 = __ptr;
do {
while (cVar1 = *pcVar5, cVar1 == ' ') {
if ((local_43[0] == 'o') && (local_43[1] == '\0')) {
if (iVar6 == local_5c) {
if (iVar6 < 1) {
local_5c = 4;
sVar4 = 0x10;
}
else {
local_5c = iVar6 * 2;
sVar4 = (long)local_5c << 2;
}
__ptr_00 = realloc(__ptr_00,sVar4);
}
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int4 *)((long)__ptr_00 + lVar3 * 4) = 4;
}
if (((local_43[0] == 'o') && (local_43[1] == '|')) && (local_43[2] == '\0')) {
if (iVar6 == local_5c) {
if (iVar6 < 1) {
local_5c = 4;
sVar4 = 0x10;
}
else {
local_5c = iVar6 * 2;
sVar4 = (long)local_5c << 2;
}
__ptr_00 = realloc(__ptr_00,sVar4);
}
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int4 *)((long)__ptr_00 + lVar3 * 4) = 2;
}
if (((local_43[0] == '.') && (local_43[1] == '|')) && (local_43[2] == '\0')) {
if (iVar6 == local_5c) {
if (iVar6 < 1) {
local_5c = 4;
sVar4 = 0x10;
}
else {
local_5c = iVar6 * 2;
sVar4 = (long)local_5c << 2;
}
__ptr_00 = realloc(__ptr_00,sVar4);
}
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int4 *)((long)__ptr_00 + lVar3 * 4) = 1;
}
pcVar5 = pcVar5 + 1;
local_43[0] = '\0';
if (pcVar5 == __ptr + (sVar2 & 0xffffffff) + 1) goto LAB_0010160d;
}
sVar4 = strlen(local_43);
if (sVar4 != 2) {
local_43[sVar4] = cVar1;
local_43[sVar4 + 1] = '\0';
}
pcVar5 = pcVar5 + 1;
} while (pcVar5 != __ptr + (sVar2 & 0xffffffff) + 1);
}
LAB_0010160d:
free(__ptr);
*param_2 = iVar6;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return __ptr_00;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
728 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
}
|
#include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x8(%rbp)
jne 11cf <func0+0x46>
mov $0x0,%eax
jmp 1214 <func0+0x8b>
movl $0x0,-0xc(%rbp)
jmp 1206 <func0+0x7d>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0xc(%rbp),%eax
movslq %eax,%rcx
mov -0x18(%rbp),%rax
add %rax,%rcx
mov -0x20(%rbp),%rax
mov %rax,%rsi
mov %rcx,%rdi
callq 1070 <strncmp@plt>
test %eax,%eax
jne 1202 <func0+0x79>
addl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0x8(%rbp),%eax
sub -0x4(%rbp),%eax
cmp %eax,-0xc(%rbp)
jle 11d8 <func0+0x4f>
mov -0x10(%rbp),%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+s2], rsi
mov [rbp+var_10], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+s2]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
cmp [rbp+var_8], 0
jnz short loc_11CF
mov eax, 0
jmp short locret_1214
loc_11CF:
mov [rbp+var_C], 0
jmp short loc_1206
loc_11D8:
mov eax, [rbp+var_4]
movsxd rdx, eax; n
mov eax, [rbp+var_C]
movsxd rcx, eax
mov rax, [rbp+s]
add rcx, rax
mov rax, [rbp+s2]
mov rsi, rax; s2
mov rdi, rcx; s1
call _strncmp
test eax, eax
jnz short loc_1202
add [rbp+var_10], 1
loc_1202:
add [rbp+var_C], 1
loc_1206:
mov eax, [rbp+var_8]
sub eax, [rbp+var_4]
cmp [rbp+var_C], eax
jle short loc_11D8
mov eax, [rbp+var_10]
locret_1214:
leave
retn
|
long long func0(const char *a1, const char *a2)
{
unsigned int v3; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
int v5; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v5 = strlen(a1);
v6 = strlen(a2);
if ( !v5 )
return 0LL;
for ( i = 0; i <= v5 - v6; ++i )
{
if ( !strncmp(&a1[i], a2, v6) )
++v3;
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x001011cf
MOV EAX,0x0
JMP 0x00101214
LAB_001011cf:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101206
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RAX
MOV RDI,RCX
CALL 0x00101070
TEST EAX,EAX
JNZ 0x00101202
ADD dword ptr [RBP + -0x10],0x1
LAB_00101202:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101206:
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0x4]
CMP dword ptr [RBP + -0xc],EAX
JLE 0x001011d8
MOV EAX,dword ptr [RBP + -0x10]
LAB_00101214:
LEAVE
RET
|
int func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
int local_18;
int local_14;
local_18 = 0;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
if ((int)sVar2 == 0) {
local_18 = 0;
}
else {
for (local_14 = 0; local_14 <= (int)sVar2 - (int)sVar3; local_14 = local_14 + 1) {
iVar1 = strncmp(param_1 + local_14,param_2,(long)(int)sVar3);
if (iVar1 == 0) {
local_18 = local_18 + 1;
}
}
}
return local_18;
}
|
729 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
}
|
#include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdx
mov %edx,%ebp
test %edx,%edx
je 11dc <func0+0x73>
mov %rsi,%r12
mov $0xffffffffffffffff,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
sub %ecx,%edx
js 11e7 <func0+0x7e>
mov %r8,%rbx
mov %edx,%edx
lea 0x1(%r8,%rdx,1),%r14
mov $0x0,%ebp
movslq %ecx,%r13
mov %r13,%rdx
mov %r12,%rsi
mov %rbx,%rdi
callq 1060 <strncmp@plt>
cmp $0x1,%eax
adc $0x0,%ebp
add $0x1,%rbx
cmp %r14,%rbx
jne 11bf <func0+0x56>
mov %ebp,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x0,%ebp
jmp 11dc <func0+0x73>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r12, rsi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_11E3
mov rdi, r12; s
call _strlen
mov edx, ebp
sub edx, eax
js short loc_11EE
mov rbx, r14
mov edx, edx
lea r14, [r14+rdx+1]
mov ebp, 0
movsxd r13, eax
loc_11C6:
mov rdx, r13; n
mov rsi, r12; s2
mov rdi, rbx; s1
call _strncmp
cmp eax, 1
adc ebp, 0
add rbx, 1
cmp rbx, r14
jnz short loc_11C6
loc_11E3:
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_11EE:
mov ebp, 0
jmp short loc_11E3
|
long long func0(char *s1, char *s2)
{
unsigned int v2; // ebp
int v3; // eax
const char *v4; // rbx
char *v5; // r14
size_t v6; // r13
v2 = strlen(s1);
if ( v2 )
{
v3 = strlen(s2);
if ( (int)(v2 - v3) < 0 )
{
return 0;
}
else
{
v4 = s1;
v5 = &s1[v2 - v3 + 1];
v2 = 0;
v6 = v3;
do
v2 += strncmp(v4++, s2, v6) == 0;
while ( v4 != v5 );
}
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R12,RSI
CALL 0x00101080
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001011e3
MOV RDI,R12
CALL 0x00101080
MOV EDX,EBP
SUB EDX,EAX
JS 0x001011ee
MOV RBX,R14
MOV EDX,EDX
LEA R14,[R14 + RDX*0x1 + 0x1]
MOV EBP,0x0
MOVSXD R13,EAX
LAB_001011c6:
MOV RDX,R13
MOV RSI,R12
MOV RDI,RBX
CALL 0x00101070
CMP EAX,0x1
ADC EBP,0x0
ADD RBX,0x1
CMP RBX,R14
JNZ 0x001011c6
LAB_001011e3:
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001011ee:
MOV EBP,0x0
JMP 0x001011e3
|
ulong func0(char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
uint uVar5;
ulong uVar6;
sVar3 = strlen(param_1);
uVar6 = sVar3 & 0xffffffff;
if ((int)sVar3 != 0) {
sVar4 = strlen(param_2);
uVar5 = (int)sVar3 - (int)sVar4;
if ((int)uVar5 < 0) {
uVar6 = 0;
}
else {
pcVar1 = param_1 + (ulong)uVar5 + 1;
uVar6 = 0;
do {
iVar2 = strncmp(param_1,param_2,(long)(int)sVar4);
uVar6 = (ulong)((int)uVar6 + (uint)(iVar2 == 0));
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
}
}
return uVar6;
}
|
730 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
}
|
#include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 1080 <strlen@plt>
mov %eax,%r14d
test %eax,%eax
je 12de <func0+0x5e>
mov %r12,%rdi
mov %rax,%r13
callq 1080 <strlen@plt>
sub %eax,%r13d
js 12f0 <func0+0x70>
movslq %r13d,%r13
movslq %eax,%rbp
xor %r14d,%r14d
lea 0x1(%rbx,%r13,1),%r13
nopl 0x0(%rax)
mov %rbx,%rdi
mov %rbp,%rdx
mov %r12,%rsi
callq 1070 <strncmp@plt>
cmp $0x1,%eax
adc $0x0,%r14d
add $0x1,%rbx
cmp %r13,%rbx
jne 12c0 <func0+0x40>
pop %rbx
mov %r14d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
xor %r14d,%r14d
jmp 12de <func0+0x5e>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_12DD
mov rdi, r13; s
mov r14, rax
call _strlen
sub r14d, eax
js short loc_12F0
movsxd r14, r14d
movsxd r12, eax
xor ebp, ebp
lea r14, [rbx+r14+1]
nop word ptr [rax+rax+00h]
loc_12C0:
mov rdi, rbx; s1
mov rdx, r12; n
mov rsi, r13; s2
call _strncmp
cmp eax, 1
adc ebp, 0
add rbx, 1
cmp rbx, r14
jnz short loc_12C0
loc_12DD:
pop rbx
mov eax, ebp
pop rbp
pop r12
pop r13
pop r14
retn
loc_12F0:
xor ebp, ebp
jmp short loc_12DD
|
long long func0(char *s1, char *s2)
{
const char *v2; // rbx
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // r14d
int v6; // eax
int v7; // r14d
size_t v8; // r12
char *v9; // r14
v2 = s1;
v3 = strlen(s1);
v4 = v3;
if ( v3 )
{
v5 = v3;
v6 = strlen(s2);
v7 = v5 - v6;
if ( v7 < 0 )
{
return 0;
}
else
{
v8 = v6;
v4 = 0;
v9 = &s1[v7 + 1];
do
v4 += strncmp(v2++, s2, v8) == 0;
while ( v2 != v9 );
}
}
return v4;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001012dd
MOV RDI,R13
MOV R14,RAX
CALL 0x00101080
SUB R14D,EAX
JS 0x001012f0
MOVSXD R14,R14D
MOVSXD R12,EAX
XOR EBP,EBP
LEA R14,[RBX + R14*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV RDI,RBX
MOV RDX,R12
MOV RSI,R13
CALL 0x00101070
CMP EAX,0x1
ADC EBP,0x0
ADD RBX,0x1
CMP RBX,R14
JNZ 0x001012c0
LAB_001012dd:
POP RBX
MOV EAX,EBP
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012f0:
XOR EBP,EBP
JMP 0x001012dd
|
ulong func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
size_t sVar3;
ulong uVar4;
int iVar5;
sVar2 = strlen(param_1);
uVar4 = sVar2 & 0xffffffff;
if ((int)sVar2 != 0) {
sVar3 = strlen(param_2);
iVar5 = (int)sVar2 - (int)sVar3;
if (iVar5 < 0) {
uVar4 = 0;
}
else {
uVar4 = 0;
pcVar1 = param_1 + (long)iVar5 + 1;
do {
iVar5 = strncmp(param_1,param_2,(long)(int)sVar3);
uVar4 = (ulong)((int)uVar4 + (uint)(iVar5 == 0));
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
}
}
return uVar4;
}
|
731 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
}
|
#include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 1080 <strlen@plt>
mov %eax,%r14d
test %eax,%eax
je 12de <func0+0x5e>
mov %r12,%rdi
mov %rax,%r13
callq 1080 <strlen@plt>
sub %eax,%r13d
js 12f0 <func0+0x70>
movslq %r13d,%r13
movslq %eax,%rbp
xor %r14d,%r14d
lea 0x1(%rbx,%r13,1),%r13
nopl 0x0(%rax)
mov %rbx,%rdi
mov %rbp,%rdx
mov %r12,%rsi
callq 1070 <strncmp@plt>
cmp $0x1,%eax
adc $0x0,%r14d
add $0x1,%rbx
cmp %r13,%rbx
jne 12c0 <func0+0x40>
pop %rbx
mov %r14d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
xor %r14d,%r14d
jmp 12de <func0+0x5e>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_12DD
mov rdi, r13; s
mov r14, rax
call _strlen
sub r14d, eax
js short loc_12F0
movsxd r14, r14d
movsxd r12, eax
xor ebp, ebp
lea r14, [rbx+r14+1]
nop word ptr [rax+rax+00h]
loc_12C0:
mov rdi, rbx; s1
mov rdx, r12; n
mov rsi, r13; s2
call _strncmp
cmp eax, 1
adc ebp, 0
add rbx, 1
cmp rbx, r14
jnz short loc_12C0
loc_12DD:
pop rbx
mov eax, ebp
pop rbp
pop r12
pop r13
pop r14
retn
loc_12F0:
xor ebp, ebp
jmp short loc_12DD
|
long long func0(char *s1, char *s2)
{
const char *v2; // rbx
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // r14d
int v6; // eax
int v7; // r14d
size_t v8; // r12
char *v9; // r14
v2 = s1;
v3 = strlen(s1);
v4 = v3;
if ( v3 )
{
v5 = v3;
v6 = strlen(s2);
v7 = v5 - v6;
if ( v7 < 0 )
{
return 0;
}
else
{
v8 = v6;
v4 = 0;
v9 = &s1[v7 + 1];
do
v4 += strncmp(v2++, s2, v8) == 0;
while ( v2 != v9 );
}
}
return v4;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001012dd
MOV RDI,R13
MOV R14,RAX
CALL 0x00101080
SUB R14D,EAX
JS 0x001012f0
MOVSXD R14,R14D
MOVSXD R12,EAX
XOR EBP,EBP
LEA R14,[RBX + R14*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV RDI,RBX
MOV RDX,R12
MOV RSI,R13
CALL 0x00101070
CMP EAX,0x1
ADC EBP,0x0
ADD RBX,0x1
CMP RBX,R14
JNZ 0x001012c0
LAB_001012dd:
POP RBX
MOV EAX,EBP
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012f0:
XOR EBP,EBP
JMP 0x001012dd
|
ulong func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
size_t sVar3;
ulong uVar4;
int iVar5;
sVar2 = strlen(param_1);
uVar4 = sVar2 & 0xffffffff;
if ((int)sVar2 != 0) {
sVar3 = strlen(param_2);
iVar5 = (int)sVar2 - (int)sVar3;
if (iVar5 < 0) {
uVar4 = 0;
}
else {
uVar4 = 0;
pcVar1 = param_1 + (long)iVar5 + 1;
do {
iVar5 = strncmp(param_1,param_2,(long)(int)sVar3);
uVar4 = (ulong)((int)uVar4 + (uint)(iVar5 == 0));
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
}
}
return uVar4;
}
|
732 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = 0; numbers[i] != ' ' && numbers[i] != '\0'; ++i) {
current[i] = numbers[i];
}
current[i] = '\0';
for (j = 0; j < 10; ++j) {
if (strcmp(current, numto[j]) == 0) {
count[j]++;
break;
}
}
numbers += i + 1;
} while (numbers[-1]);
}
for (i = 0; i < 10; ++i) {
for (j = 0; j < count[i]; ++j) {
for (k = 0; numto[i][k] != '\0'; ++k, ++index) {
out[index] = numto[i][k];
}
out[index++] = ' ';
}
}
if (index > 0) {
out[index - 1] = '\0';
} else {
out[0] = '\0';
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
assert(strcmp(func0("six five four three two one zero"), "zero one two three four five six") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xb0,%rsp
mov %rdi,-0xa8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movq $0x0,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
movq $0x0,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
lea 0xe25(%rip),%rax
mov %rax,-0x60(%rbp)
lea 0xe1f(%rip),%rax
mov %rax,-0x58(%rbp)
lea 0xe18(%rip),%rax
mov %rax,-0x50(%rbp)
lea 0xe11(%rip),%rax
mov %rax,-0x48(%rbp)
lea 0xe0c(%rip),%rax
mov %rax,-0x40(%rbp)
lea 0xe06(%rip),%rax
mov %rax,-0x38(%rbp)
lea 0xe00(%rip),%rax
mov %rax,-0x30(%rbp)
lea 0xdf9(%rip),%rax
mov %rax,-0x28(%rbp)
lea 0xdf4(%rip),%rax
mov %rax,-0x20(%rbp)
lea 0xdef(%rip),%rax
mov %rax,-0x18(%rbp)
movl $0x0,-0xa0(%rbp)
mov -0xa8(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 1364 <func0+0x1db>
movl $0x0,-0x9c(%rbp)
jmp 129b <func0+0x112>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x9c(%rbp),%eax
cltq
mov %dl,-0xe(%rbp,%rax,1)
addl $0x1,-0x9c(%rbp)
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 12cf <func0+0x146>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1272 <func0+0xe9>
mov -0x9c(%rbp),%eax
cltq
movb $0x0,-0xe(%rbp,%rax,1)
movl $0x0,-0x98(%rbp)
jmp 1332 <func0+0x1a9>
mov -0x98(%rbp),%eax
cltq
mov -0x60(%rbp,%rax,8),%rdx
lea -0xe(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jne 132b <func0+0x1a2>
mov -0x98(%rbp),%eax
cltq
mov -0x90(%rbp,%rax,4),%eax
lea 0x1(%rax),%edx
mov -0x98(%rbp),%eax
cltq
mov %edx,-0x90(%rbp,%rax,4)
jmp 133b <func0+0x1b2>
addl $0x1,-0x98(%rbp)
cmpl $0x9,-0x98(%rbp)
jle 12e8 <func0+0x15f>
mov -0x9c(%rbp),%eax
cltq
add $0x1,%rax
add %rax,-0xa8(%rbp)
mov -0xa8(%rbp),%rax
sub $0x1,%rax
movzbl (%rax),%eax
test %al,%al
jne 1266 <func0+0xdd>
movl $0x0,-0x9c(%rbp)
jmpq 142d <func0+0x2a4>
movl $0x0,-0x98(%rbp)
jmpq 140b <func0+0x282>
movl $0x0,-0x94(%rbp)
jmp 13c9 <func0+0x240>
mov -0x9c(%rbp),%eax
cltq
mov -0x60(%rbp,%rax,8),%rdx
mov -0x94(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%edx
mov -0xa0(%rbp),%eax
cltq
lea 0x2c88(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x94(%rbp)
addl $0x1,-0xa0(%rbp)
mov -0x9c(%rbp),%eax
cltq
mov -0x60(%rbp,%rax,8),%rdx
mov -0x94(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 138e <func0+0x205>
mov -0xa0(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xa0(%rbp)
cltq
lea 0x2c40(%rip),%rdx
movb $0x20,(%rax,%rdx,1)
addl $0x1,-0x98(%rbp)
mov -0x9c(%rbp),%eax
cltq
mov -0x90(%rbp,%rax,4),%eax
cmp %eax,-0x98(%rbp)
jl 1382 <func0+0x1f9>
addl $0x1,-0x9c(%rbp)
cmpl $0x9,-0x9c(%rbp)
jle 1373 <func0+0x1ea>
cmpl $0x0,-0xa0(%rbp)
jle 145b <func0+0x2d2>
mov -0xa0(%rbp),%eax
sub $0x1,%eax
cltq
lea 0x2beb(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
jmp 1462 <func0+0x2d9>
movb $0x0,0x2bde(%rip)
lea 0x2bd7(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 147d <func0+0x2f4>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_A8], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_90], xmm0
movaps [rbp+var_80], xmm0
movq [rbp+var_70], xmm0
lea rax, aZero; "zero"
mov [rbp+s2], rax
lea rax, aOne; "one"
mov [rbp+var_58], rax
lea rax, aTwo; "two"
mov [rbp+var_50], rax
lea rax, s2; "three"
mov [rbp+var_48], rax
lea rax, aFour; "four"
mov [rbp+var_40], rax
lea rax, aFive; "five"
mov [rbp+var_38], rax
lea rax, aSix; "six"
mov [rbp+var_30], rax
lea rax, aSeven; "seven"
mov [rbp+var_28], rax
lea rax, aEight; "eight"
mov [rbp+var_20], rax
lea rax, aNine; "nine"
mov [rbp+var_18], rax
mov [rbp+var_A0], 0
mov rax, [rbp+var_A8]
movzx eax, byte ptr [rax]
test al, al
jz loc_134A
loc_124C:
mov [rbp+var_9C], 0
jmp short loc_1281
loc_1258:
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+var_A8]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_9C]
cdqe
mov [rbp+rax+s1], dl
add [rbp+var_9C], 1
loc_1281:
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+var_A8]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_12B5
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+var_A8]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1258
loc_12B5:
mov eax, [rbp+var_9C]
cdqe
mov [rbp+rax+s1], 0
mov [rbp+var_98], 0
jmp short loc_1318
loc_12CE:
mov eax, [rbp+var_98]
cdqe
mov rdx, [rbp+rax*8+s2]
lea rax, [rbp+s1]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1311
mov eax, [rbp+var_98]
cdqe
mov eax, dword ptr [rbp+rax*4+var_90]
lea edx, [rax+1]
mov eax, [rbp+var_98]
cdqe
mov dword ptr [rbp+rax*4+var_90], edx
jmp short loc_1321
loc_1311:
add [rbp+var_98], 1
loc_1318:
cmp [rbp+var_98], 9
jle short loc_12CE
loc_1321:
mov eax, [rbp+var_9C]
cdqe
add rax, 1
add [rbp+var_A8], rax
mov rax, [rbp+var_A8]
sub rax, 1
movzx eax, byte ptr [rax]
test al, al
jnz loc_124C
loc_134A:
mov [rbp+var_9C], 0
jmp loc_1413
loc_1359:
mov [rbp+var_98], 0
jmp loc_13F1
loc_1368:
mov [rbp+var_94], 0
jmp short loc_13AF
loc_1374:
mov eax, [rbp+var_9C]
cdqe
mov rdx, [rbp+rax*8+s2]
mov eax, [rbp+var_94]
cdqe
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_A0]
cdqe
lea rcx, out_1
mov [rax+rcx], dl
add [rbp+var_94], 1
add [rbp+var_A0], 1
loc_13AF:
mov eax, [rbp+var_9C]
cdqe
mov rdx, [rbp+rax*8+s2]
mov eax, [rbp+var_94]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1374
mov eax, [rbp+var_A0]
lea edx, [rax+1]
mov [rbp+var_A0], edx
cdqe
lea rdx, out_1
mov byte ptr [rax+rdx], 20h ; ' '
add [rbp+var_98], 1
loc_13F1:
mov eax, [rbp+var_9C]
cdqe
mov eax, dword ptr [rbp+rax*4+var_90]
cmp [rbp+var_98], eax
jl loc_1368
add [rbp+var_9C], 1
loc_1413:
cmp [rbp+var_9C], 9
jle loc_1359
cmp [rbp+var_A0], 0
jle short loc_1441
mov eax, [rbp+var_A0]
sub eax, 1
cdqe
lea rdx, out_1
mov byte ptr [rax+rdx], 0
jmp short loc_1448
loc_1441:
mov cs:out_1, 0
loc_1448:
lea rax, out_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1463
call ___stack_chk_fail
locret_1463:
leave
retn
|
char * func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v3; // [rsp+8h] [rbp-A8h]
int v4; // [rsp+10h] [rbp-A0h]
int i; // [rsp+14h] [rbp-9Ch]
int k; // [rsp+14h] [rbp-9Ch]
int j; // [rsp+18h] [rbp-98h]
int m; // [rsp+18h] [rbp-98h]
int n; // [rsp+1Ch] [rbp-94h]
_OWORD v10[2]; // [rsp+20h] [rbp-90h] BYREF
long long v11; // [rsp+40h] [rbp-70h]
char *s2[10]; // [rsp+50h] [rbp-60h]
char s1[6]; // [rsp+A2h] [rbp-Eh] BYREF
unsigned long long v14; // [rsp+A8h] [rbp-8h]
v3 = a1;
v14 = __readfsqword(0x28u);
memset(v10, 0, sizeof(v10));
v11 = 0LL;
s2[0] = "zero";
s2[1] = "one";
s2[2] = "two";
s2[3] = "three";
s2[4] = "four";
s2[5] = "five";
s2[6] = "six";
s2[7] = "seven";
s2[8] = "eight";
s2[9] = "nine";
v4 = 0;
if ( *a1 )
{
do
{
for ( i = 0; v3[i] != 32 && v3[i]; ++i )
s1[i] = v3[i];
s1[i] = 0;
for ( j = 0; j <= 9; ++j )
{
if ( !strcmp(s1, s2[j]) )
{
++*((_DWORD *)v10 + j);
break;
}
}
v3 += i + 1;
}
while ( *(v3 - 1) );
}
for ( k = 0; k <= 9; ++k )
{
for ( m = 0; m < *((_DWORD *)v10 + k); ++m )
{
for ( n = 0; s2[k][n]; ++n )
out_1[v4++] = s2[k][n];
v1 = v4++;
out_1[v1] = 32;
}
}
if ( v4 <= 0 )
out_1[0] = 0;
else
out_1[v4 - 1] = 0;
return out_1;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0xa8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVQ qword ptr [RBP + -0x70],XMM0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[0x102011]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x102015]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[0x10201b]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x102020]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x102025]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x102029]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x10202f]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x102035]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0xa0],0x0
MOV RAX,qword ptr [RBP + -0xa8]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x0010134a
LAB_0010124c:
MOV dword ptr [RBP + -0x9c],0x0
JMP 0x00101281
LAB_00101258:
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x9c]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xe],DL
ADD dword ptr [RBP + -0x9c],0x1
LAB_00101281:
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x001012b5
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101258
LAB_001012b5:
MOV EAX,dword ptr [RBP + -0x9c]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xe],0x0
MOV dword ptr [RBP + -0x98],0x0
JMP 0x00101318
LAB_001012ce:
MOV EAX,dword ptr [RBP + -0x98]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x60]
LEA RAX,[RBP + -0xe]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JNZ 0x00101311
MOV EAX,dword ptr [RBP + -0x98]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x90]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x98]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x90],EDX
JMP 0x00101321
LAB_00101311:
ADD dword ptr [RBP + -0x98],0x1
LAB_00101318:
CMP dword ptr [RBP + -0x98],0x9
JLE 0x001012ce
LAB_00101321:
MOV EAX,dword ptr [RBP + -0x9c]
CDQE
ADD RAX,0x1
ADD qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
SUB RAX,0x1
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010124c
LAB_0010134a:
MOV dword ptr [RBP + -0x9c],0x0
JMP 0x00101413
LAB_00101359:
MOV dword ptr [RBP + -0x98],0x0
JMP 0x001013f1
LAB_00101368:
MOV dword ptr [RBP + -0x94],0x0
JMP 0x001013af
LAB_00101374:
MOV EAX,dword ptr [RBP + -0x9c]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x60]
MOV EAX,dword ptr [RBP + -0x94]
CDQE
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xa0]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
ADD dword ptr [RBP + -0x94],0x1
ADD dword ptr [RBP + -0xa0],0x1
LAB_001013af:
MOV EAX,dword ptr [RBP + -0x9c]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x60]
MOV EAX,dword ptr [RBP + -0x94]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101374
MOV EAX,dword ptr [RBP + -0xa0]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xa0],EDX
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x20
ADD dword ptr [RBP + -0x98],0x1
LAB_001013f1:
MOV EAX,dword ptr [RBP + -0x9c]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x90]
CMP dword ptr [RBP + -0x98],EAX
JL 0x00101368
ADD dword ptr [RBP + -0x9c],0x1
LAB_00101413:
CMP dword ptr [RBP + -0x9c],0x9
JLE 0x00101359
CMP dword ptr [RBP + -0xa0],0x0
JLE 0x00101441
MOV EAX,dword ptr [RBP + -0xa0]
SUB EAX,0x1
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
JMP 0x00101448
LAB_00101441:
MOV byte ptr [0x00104040],0x0
LAB_00101448:
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101463
CALL 0x00101070
LAB_00101463:
LEAVE
RET
|
int1 * func0(char *param_1)
{
char cVar1;
int iVar2;
long in_FS_OFFSET;
int local_a8;
int local_a4;
int local_a0;
int local_9c;
int local_98 [16];
int local_88 [16];
int8 local_78;
char *local_68 [10];
char local_16 [6];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_98 = (int [16])0x0;
local_88 = (int [16])0x0;
local_78 = 0;
local_68[0] = "zero";
local_68[1] = "one";
local_68[2] = "two";
local_68[3] = "three";
local_68[4] = "four";
local_68[5] = "five";
local_68[6] = "six";
local_68[7] = "seven";
local_68[8] = "eight";
local_68[9] = "nine";
local_a8 = 0;
cVar1 = *param_1;
do {
if (cVar1 == '\0') {
for (local_a4 = 0; local_a4 < 10; local_a4 = local_a4 + 1) {
for (local_a0 = 0; local_a0 < *(int *)(local_98 + (long)local_a4 * 4);
local_a0 = local_a0 + 1) {
for (local_9c = 0; local_68[local_a4][local_9c] != '\0'; local_9c = local_9c + 1) {
out_1[local_a8] = local_68[local_a4][local_9c];
local_a8 = local_a8 + 1;
}
out_1[local_a8] = 0x20;
local_a8 = local_a8 + 1;
}
}
if (local_a8 < 1) {
out_1[0] = 0;
}
else {
out_1[local_a8 + -1] = 0;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return out_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
for (local_a4 = 0; (param_1[local_a4] != ' ' && (param_1[local_a4] != '\0'));
local_a4 = local_a4 + 1) {
local_16[local_a4] = param_1[local_a4];
}
local_16[local_a4] = '\0';
for (local_a0 = 0; local_a0 < 10; local_a0 = local_a0 + 1) {
iVar2 = strcmp(local_16,local_68[local_a0]);
if (iVar2 == 0) {
*(int *)(local_98 + (long)local_a0 * 4) = *(int *)(local_98 + (long)local_a0 * 4) + 1;
break;
}
}
param_1 = param_1 + (long)local_a4 + 1;
cVar1 = param_1[-1];
} while( true );
}
|
733 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = 0; numbers[i] != ' ' && numbers[i] != '\0'; ++i) {
current[i] = numbers[i];
}
current[i] = '\0';
for (j = 0; j < 10; ++j) {
if (strcmp(current, numto[j]) == 0) {
count[j]++;
break;
}
}
numbers += i + 1;
} while (numbers[-1]);
}
for (i = 0; i < 10; ++i) {
for (j = 0; j < count[i]; ++j) {
for (k = 0; numto[i][k] != '\0'; ++k, ++index) {
out[index] = numto[i][k];
}
out[index++] = ' ';
}
}
if (index > 0) {
out[index - 1] = '\0';
} else {
out[0] = '\0';
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
assert(strcmp(func0("six five four three two one zero"), "zero one two three four five six") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
lea 0xe20(%rip),%rax
mov %rax,0x30(%rsp)
lea 0xe19(%rip),%rax
mov %rax,0x38(%rsp)
lea 0xe11(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xe09(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xe03(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xdfc(%rip),%rax
mov %rax,0x58(%rsp)
lea 0xdf5(%rip),%rax
mov %rax,0x60(%rsp)
lea 0xded(%rip),%rax
mov %rax,0x68(%rsp)
lea 0xde7(%rip),%rax
mov %rax,0x70(%rsp)
lea 0xe07(%rip),%rax
mov %rax,0x78(%rsp)
cmpb $0x0,(%rdi)
je 12e5 <func0+0x15c>
mov %rdi,%rbp
lea 0x81(%rsp),%r15
lea 0x82(%rsp),%r14
jmp 1293 <func0+0x10a>
mov $0x0,%ecx
mov $0x0,%r13d
jmp 12b8 <func0+0x12f>
movslq %ebx,%r12
addl $0x1,(%rsp,%r12,4)
lea 0x1(%rbp,%r13,1),%rbp
cmpb $0x0,-0x1(%rbp)
je 12e5 <func0+0x15c>
movzbl 0x0(%rbp),%edx
test $0xdf,%dl
je 1273 <func0+0xea>
mov $0x1,%eax
mov %dl,(%r15,%rax,1)
mov %eax,%ecx
movzbl 0x0(%rbp,%rax,1),%edx
mov %rax,%r13
add $0x1,%rax
test $0xdf,%dl
jne 12a1 <func0+0x118>
movslq %ecx,%rcx
movb $0x0,0x82(%rsp,%rcx,1)
mov $0x0,%ebx
mov 0x30(%rsp,%rbx,8),%rsi
mov %r14,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1280 <func0+0xf7>
add $0x1,%rbx
cmp $0xa,%rbx
jne 12c8 <func0+0x13f>
jmp 1288 <func0+0xff>
mov $0x0,%r13d
mov $0x0,%r8d
lea 0x2d47(%rip),%rdi
lea 0x1(%rdi),%r12
jmp 134a <func0+0x1c1>
mov %dl,(%rax,%rdi,1)
mov %eax,%ecx
add $0x1,%rax
movzbl -0x1(%rsi,%rax,1),%edx
test %dl,%dl
jne 12fe <func0+0x175>
lea 0x1(%rcx),%r8d
movslq %ecx,%rcx
movb $0x20,(%r12,%rcx,1)
add $0x1,%r9d
cmp %r10d,%r9d
je 1340 <func0+0x1b7>
lea 0x1(%r8),%eax
cltq
mov %ebp,%edx
movslq %r8d,%rcx
mov %rbx,%rsi
sub %rcx,%rsi
mov %r8d,%ecx
test %r11b,%r11b
jne 12fe <func0+0x175>
jmp 1310 <func0+0x187>
add $0x1,%r13
cmp $0xa,%r13
je 1367 <func0+0x1de>
mov (%rsp,%r13,4),%r10d
test %r10d,%r10d
jle 1340 <func0+0x1b7>
mov 0x30(%rsp,%r13,8),%rbx
movzbl (%rbx),%r11d
mov $0x0,%r9d
mov %r11d,%ebp
jmp 1325 <func0+0x19c>
test %r8d,%r8d
jle 13a9 <func0+0x220>
lea -0x1(%r8),%eax
cltq
lea 0x2cc7(%rip),%rdx
movb $0x0,(%rdx,%rax,1)
mov 0x88(%rsp),%rax
xor %fs:0x28,%rax
jne 13b2 <func0+0x229>
lea 0x2ca9(%rip),%rax
add $0x98,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movb $0x0,0x2c90(%rip)
jmp 137d <func0+0x1f4>
callq 1070 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rsp+0C8h+var_C8], xmm0
movaps [rsp+0C8h+var_B8], xmm0
mov [rsp+0C8h+var_A8], 0
lea rax, aZero; "zero"
mov [rsp+0C8h+s2], rax
lea rax, aOne; "one"
mov [rsp+0C8h+var_90], rax
lea rax, aTwo; "two"
mov [rsp+0C8h+var_88], rax
lea rax, s2; "three"
mov [rsp+0C8h+var_80], rax
lea rax, aFour; "four"
mov [rsp+0C8h+var_78], rax
lea rax, aFive; "five"
mov [rsp+0C8h+var_70], rax
lea rax, aSix; "six"
mov [rsp+0C8h+var_68], rax
lea rax, aSeven; "seven"
mov [rsp+0C8h+var_60], rax
lea rax, aEight; "eight"
mov [rsp+0C8h+var_58], rax
lea rax, aThreeFiveNine+0Bh; "nine"
mov [rsp+0C8h+var_50], rax
cmp byte ptr [rdi], 0
jz loc_12D1
mov rbp, rdi
mov r15d, 0
lea r14, [rsp+0C8h+var_47]
lea r13, [rsp+0C8h+s1]
jmp short loc_127F
loc_1263:
mov eax, 0
mov r12, r15
jmp short loc_12A5
loc_126D:
movsxd rbx, ebx
add dword ptr [rsp+rbx*4+0C8h+var_C8], 1
loc_1274:
lea rbp, [rbp+r12+1]
cmp byte ptr [rbp-1], 0
jz short loc_12D1
loc_127F:
movzx edx, byte ptr [rbp+0]
test dl, 0DFh
jz short loc_1263
mov eax, 1
loc_128D:
mov [r14+rax], dl
movzx edx, byte ptr [rbp+rax+0]
mov r12, rax
add rax, 1
test dl, 0DFh
jnz short loc_128D
mov eax, r12d
loc_12A5:
cdqe
mov [rsp+rax+0C8h+s1], 0
mov ebx, 0
loc_12B4:
mov rsi, [rsp+rbx*8+0C8h+s2]; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jz short loc_126D
add rbx, 1
cmp rbx, 0Ah
jnz short loc_12B4
jmp short loc_1274
loc_12D1:
mov r12d, 0
mov r8d, 0
lea rdi, unk_403F
lea rbp, [rdi+1]
jmp short loc_1338
loc_12EA:
mov [rax+rdi], dl
mov rcx, rax
add rax, 1
movzx edx, byte ptr [rsi+rax-1]
test dl, dl
jnz short loc_12EA
loc_12FD:
lea r8d, [rcx+1]
movsxd rcx, ecx
mov byte ptr [rbp+rcx+0], 20h ; ' '
add r9d, 1
cmp r9d, r11d
jz short loc_132E
loc_1312:
lea eax, [r8+1]
cdqe
mov edx, r10d
movsxd rcx, r8d
mov rsi, rbx
sub rsi, rcx
mov ecx, r8d
test r10b, r10b
jnz short loc_12EA
jmp short loc_12FD
loc_132E:
add r12, 1
cmp r12, 0Ah
jz short loc_1352
loc_1338:
mov r11d, dword ptr [rsp+r12*4+0C8h+var_C8]
test r11d, r11d
jle short loc_132E
mov rbx, [rsp+r12*8+0C8h+s2]
movzx r10d, byte ptr [rbx]
mov r9d, 0
jmp short loc_1312
loc_1352:
test r8d, r8d
jle short loc_1394
lea eax, [r8-1]
cdqe
lea rdx, out_1
mov byte ptr [rdx+rax], 0
loc_1368:
mov rax, [rsp+0C8h+var_40]
sub rax, fs:28h
jnz short loc_139D
lea rax, out_1
add rsp, 98h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1394:
mov cs:out_1, 0
jmp short loc_1368
loc_139D:
call ___stack_chk_fail
|
char * func0(char *a1)
{
char *v1; // rbp
int v2; // eax
long long v3; // r12
char v4; // dl
long long v5; // rax
long long v6; // rbx
long long v7; // r12
int v8; // r8d
int j; // ecx
long long v10; // rax
char v11; // dl
int i; // r9d
int v13; // r11d
char *v14; // rbx
char v15; // r10
_OWORD v17[2]; // [rsp+0h] [rbp-C8h] BYREF
long long v18; // [rsp+20h] [rbp-A8h]
_WORD s2[41]; // [rsp+30h] [rbp-98h]
char s1[6]; // [rsp+82h] [rbp-46h] BYREF
unsigned long long v21; // [rsp+88h] [rbp-40h]
v21 = __readfsqword(0x28u);
memset(v17, 0, sizeof(v17));
v18 = 0LL;
*(_QWORD *)s2 = "zero";
*(_QWORD *)&s2[4] = "one";
*(_QWORD *)&s2[8] = "two";
*(_QWORD *)&s2[12] = "three";
*(_QWORD *)&s2[16] = "four";
*(_QWORD *)&s2[20] = "five";
*(_QWORD *)&s2[24] = "six";
*(_QWORD *)&s2[28] = "seven";
*(_QWORD *)&s2[32] = "eight";
*(_QWORD *)&s2[36] = "nine";
if ( *a1 )
{
v1 = a1;
do
{
v4 = *v1;
if ( (*v1 & 0xDF) != 0 )
{
v5 = 1LL;
do
{
*((_BYTE *)&s2[40] + v5 + 1) = v4;
v4 = v1[v5];
v3 = v5++;
}
while ( (v4 & 0xDF) != 0 );
v2 = v3;
}
else
{
v2 = 0;
v3 = 0LL;
}
s1[v2] = 0;
v6 = 0LL;
while ( strcmp(s1, *(const char **)&s2[4 * v6]) )
{
if ( ++v6 == 10 )
goto LABEL_5;
}
++*((_DWORD *)v17 + (int)v6);
LABEL_5:
v1 += v3 + 1;
}
while ( *(v1 - 1) );
}
v7 = 0LL;
v8 = 0;
do
{
v13 = *((_DWORD *)v17 + v7);
if ( v13 > 0 )
{
v14 = *(char **)&s2[4 * v7];
v15 = *v14;
for ( i = 0; i != v13; ++i )
{
v10 = v8 + 1;
v11 = v15;
for ( j = v8; v11; v11 = v14[v10 - v8 - 1] )
{
*((_BYTE *)&unk_403F + v10) = v11;
j = v10++;
}
v8 = j + 1;
*((_BYTE *)&unk_403F + j + 1) = 32;
}
}
++v7;
}
while ( v7 != 10 );
if ( v8 <= 0 )
out_1[0] = 0;
else
out_1[v8 - 1] = 0;
return out_1;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x30],RAX
LEA RAX,[0x102009]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x102011]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[0x102017]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x10201c]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x102021]
MOV qword ptr [RSP + 0x60],RAX
LEA RAX,[0x102025]
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[0x10202b]
MOV qword ptr [RSP + 0x70],RAX
LEA RAX,[0x102057]
MOV qword ptr [RSP + 0x78],RAX
CMP byte ptr [RDI],0x0
JZ 0x001012d1
MOV RBP,RDI
MOV R15D,0x0
LEA R14,[RSP + 0x81]
LEA R13,[RSP + 0x82]
JMP 0x0010127f
LAB_00101263:
MOV EAX,0x0
MOV R12,R15
JMP 0x001012a5
LAB_0010126d:
MOVSXD RBX,EBX
ADD dword ptr [RSP + RBX*0x4],0x1
LAB_00101274:
LEA RBP,[RBP + R12*0x1 + 0x1]
CMP byte ptr [RBP + -0x1],0x0
JZ 0x001012d1
LAB_0010127f:
MOVZX EDX,byte ptr [RBP]
TEST DL,0xdf
JZ 0x00101263
MOV EAX,0x1
LAB_0010128d:
MOV byte ptr [R14 + RAX*0x1],DL
MOVZX EDX,byte ptr [RBP + RAX*0x1]
MOV R12,RAX
ADD RAX,0x1
TEST DL,0xdf
JNZ 0x0010128d
MOV EAX,R12D
LAB_001012a5:
CDQE
MOV byte ptr [RSP + RAX*0x1 + 0x82],0x0
MOV EBX,0x0
LAB_001012b4:
MOV RSI,qword ptr [RSP + RBX*0x8 + 0x30]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JZ 0x0010126d
ADD RBX,0x1
CMP RBX,0xa
JNZ 0x001012b4
JMP 0x00101274
LAB_001012d1:
MOV R12D,0x0
MOV R8D,0x0
LEA RDI,[0x10403f]
LEA RBP,[RDI + 0x1]
JMP 0x00101338
LAB_001012ea:
MOV byte ptr [RAX + RDI*0x1],DL
MOV RCX,RAX
ADD RAX,0x1
MOVZX EDX,byte ptr [RSI + RAX*0x1 + -0x1]
TEST DL,DL
JNZ 0x001012ea
LAB_001012fd:
LEA R8D,[RCX + 0x1]
MOVSXD RCX,ECX
MOV byte ptr [RBP + RCX*0x1],0x20
ADD R9D,0x1
CMP R9D,R11D
JZ 0x0010132e
LAB_00101312:
LEA EAX,[R8 + 0x1]
CDQE
MOV EDX,R10D
MOVSXD RCX,R8D
MOV RSI,RBX
SUB RSI,RCX
MOV ECX,R8D
TEST R10B,R10B
JNZ 0x001012ea
JMP 0x001012fd
LAB_0010132e:
ADD R12,0x1
CMP R12,0xa
JZ 0x00101352
LAB_00101338:
MOV R11D,dword ptr [RSP + R12*0x4]
TEST R11D,R11D
JLE 0x0010132e
MOV RBX,qword ptr [RSP + R12*0x8 + 0x30]
MOVZX R10D,byte ptr [RBX]
MOV R9D,0x0
JMP 0x00101312
LAB_00101352:
TEST R8D,R8D
JLE 0x00101394
LEA EAX,[R8 + -0x1]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RDX + RAX*0x1],0x0
LAB_00101368:
MOV RAX,qword ptr [RSP + 0x88]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010139d
LEA RAX,[0x104040]
ADD RSP,0x98
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101394:
MOV byte ptr [0x00104040],0x0
JMP 0x00101368
LAB_0010139d:
CALL 0x00101070
|
int1 * func0(byte *param_1)
{
char cVar1;
char cVar2;
char *pcVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
byte bVar8;
long lVar9;
ulong uVar10;
int iVar11;
long lVar12;
long in_FS_OFFSET;
int local_c8 [16];
int local_b8 [16];
int8 local_a8;
char *local_98 [10];
byte local_47 [7];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_c8 = (int [16])0x0;
local_b8 = (int [16])0x0;
local_a8 = 0;
local_98[0] = "zero";
local_98[1] = "one";
local_98[2] = "two";
local_98[3] = "three";
local_98[4] = "four";
local_98[5] = "five";
local_98[6] = "six";
local_98[7] = "seven";
local_98[8] = "eight";
local_98[9] = "nine";
if (*param_1 != 0) {
do {
bVar8 = *param_1;
if ((bVar8 & 0xdf) == 0) {
iVar7 = 0;
lVar12 = 0;
}
else {
lVar9 = 1;
do {
lVar12 = lVar9;
local_47[lVar12] = bVar8;
bVar8 = param_1[lVar12];
lVar9 = lVar12 + 1;
} while ((bVar8 & 0xdf) != 0);
iVar7 = (int)lVar12;
}
local_47[(long)iVar7 + 1] = 0;
lVar9 = 0;
do {
iVar7 = strcmp((char *)(local_47 + 1),local_98[lVar9]);
if (iVar7 == 0) {
*(int *)(local_c8 + (long)(int)lVar9 * 4) = *(int *)(local_c8 + (long)(int)lVar9 * 4) + 1;
break;
}
lVar9 = lVar9 + 1;
} while (lVar9 != 10);
param_1 = param_1 + lVar12 + 1;
} while (param_1[-1] != 0);
}
lVar12 = 0;
uVar10 = 0;
do {
iVar7 = *(int *)(local_c8 + lVar12 * 4);
if (0 < iVar7) {
pcVar3 = local_98[lVar12];
cVar2 = *pcVar3;
iVar11 = 0;
do {
cVar1 = cVar2;
uVar6 = (long)((int)uVar10 + 1);
uVar5 = uVar10;
while (uVar4 = uVar6, cVar1 != '\0') {
(&DAT_0010403f)[uVar4] = cVar1;
uVar6 = uVar4 + 1;
uVar5 = uVar4;
cVar1 = pcVar3[uVar4 + 1 + (-1 - (long)(int)uVar10)];
}
uVar10 = (ulong)((int)uVar5 + 1);
(&out_1)[(int)uVar5] = 0x20;
iVar11 = iVar11 + 1;
} while (iVar11 != iVar7);
}
lVar12 = lVar12 + 1;
} while (lVar12 != 10);
if ((int)uVar10 < 1) {
out_1 = 0;
}
else {
(&out_1)[(int)uVar10 + -1] = 0;
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return &out_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
734 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = 0; numbers[i] != ' ' && numbers[i] != '\0'; ++i) {
current[i] = numbers[i];
}
current[i] = '\0';
for (j = 0; j < 10; ++j) {
if (strcmp(current, numto[j]) == 0) {
count[j]++;
break;
}
}
numbers += i + 1;
} while (numbers[-1]);
}
for (i = 0; i < 10; ++i) {
for (j = 0; j < count[i]; ++j) {
for (k = 0; numto[i][k] != '\0'; ++k, ++index) {
out[index] = numto[i][k];
}
out[index++] = ' ';
}
}
if (index > 0) {
out[index - 1] = '\0';
} else {
out[0] = '\0';
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
assert(strcmp(func0("six five four three two one zero"), "zero one two three four five six") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
pxor %xmm0,%xmm0
xor %r10d,%r10d
push %r14
lea 0xcfe(%rip),%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
movzbl (%rdi),%edx
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0xcd9(%rip),%rax
mov %r14,0x40(%rsp)
mov %rax,0x48(%rsp)
lea 0xccc(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xcc4(%rip),%rax
mov %rax,0x58(%rsp)
lea 0xcbe(%rip),%rax
mov %rax,0x60(%rsp)
lea 0xcb7(%rip),%rax
mov %rax,0x68(%rsp)
lea 0xcb0(%rip),%rax
mov %rax,0x70(%rsp)
lea 0xca8(%rip),%rax
mov %rax,0x78(%rsp)
lea 0xca2(%rip),%rax
mov %rax,0x80(%rsp)
lea 0xcbf(%rip),%rax
movq $0x0,0x30(%rsp)
mov %rax,0x88(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
test %dl,%dl
je 145c <func0+0x16c>
mov %r14,0x8(%rsp)
mov %rdi,%rbx
lea 0x92(%rsp),%r12
lea 0x91(%rsp),%r13
test $0xdf,%dl
je 143f <func0+0x14f>
mov $0x1,%eax
nopl (%rax)
mov %dl,0x0(%r13,%rax,1)
movzbl (%rbx,%rax,1),%edx
movslq %eax,%rcx
add $0x1,%rax
test $0xdf,%dl
jne 13e0 <func0+0xf0>
mov %rax,%rbp
movb $0x0,0x92(%rsp,%rcx,1)
mov 0x8(%rsp),%rsi
xor %r14d,%r14d
jmp 1415 <func0+0x125>
nopw 0x0(%rax,%rax,1)
mov 0x40(%rsp,%r14,8),%rsi
mov %r12,%rdi
movslq %r14d,%r15
callq 1090 <strcmp@plt>
test %eax,%eax
je 1448 <func0+0x158>
add $0x1,%r14
cmp $0xa,%r14
jne 1410 <func0+0x120>
add %rbp,%rbx
cmpb $0x0,-0x1(%rbx)
je 1457 <func0+0x167>
movzbl (%rbx),%edx
test $0xdf,%dl
jne 13d8 <func0+0xe8>
mov $0x1,%ebp
xor %ecx,%ecx
jmp 13f8 <func0+0x108>
add %rbp,%rbx
addl $0x1,0x10(%rsp,%r15,4)
cmpb $0x0,-0x1(%rbx)
jne 1437 <func0+0x147>
mov 0x10(%rsp),%r10d
lea 0x2bdd(%rip),%r11
xor %ebp,%ebp
xor %esi,%esi
lea -0x1(%r11),%rdi
nopl 0x0(%rax,%rax,1)
test %r10d,%r10d
jle 14cc <func0+0x1dc>
mov 0x40(%rsp,%rbp,2),%rbx
xor %r8d,%r8d
movzbl (%rbx),%r9d
nopl 0x0(%rax)
movslq %esi,%rcx
test %r9b,%r9b
je 14bb <func0+0x1cb>
lea 0x1(%rsi),%eax
mov %rbx,%rcx
movslq %esi,%rsi
mov %r9d,%edx
sub %rsi,%rcx
cltq
mov %rcx,%rsi
nopl 0x0(%rax)
mov %dl,(%rdi,%rax,1)
movslq %eax,%rcx
add $0x1,%rax
movzbl -0x1(%rsi,%rax,1),%edx
test %dl,%dl
jne 14a8 <func0+0x1b8>
add $0x1,%r8d
movb $0x20,(%r11,%rcx,1)
lea 0x1(%rcx),%esi
cmp %r10d,%r8d
jne 1488 <func0+0x198>
add $0x4,%rbp
cmp $0x28,%rbp
je 14dd <func0+0x1ed>
mov 0x10(%rsp,%rbp,1),%r10d
jmp 1470 <func0+0x180>
test %esi,%esi
je 1517 <func0+0x227>
lea -0x1(%rsi),%eax
cltq
movb $0x0,(%r11,%rax,1)
mov 0x98(%rsp),%rax
xor %fs:0x28,%rax
jne 1520 <func0+0x230>
add $0xa8,%rsp
lea 0x2b34(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movb $0x0,0x2b22(%rip)
jmp 14eb <func0+0x1fb>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
lea rbx, aZero; "zero"
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
lea rax, aOne; "one"
movaps [rsp+0C8h+var_C8], xmm0
movq xmm1, rax
movaps [rsp+0C8h+var_B8], xmm0
movq xmm0, rbx
lea rax, s2; "three"
punpcklqdq xmm0, xmm1
lea rbx, aTwo; "two"
movq xmm2, rax
mov [rsp+0C8h+var_A8], 0
movaps [rsp+0C8h+var_98], xmm0
movq xmm0, rbx
lea rax, aFive; "five"
lea rbx, aFour; "four"
punpcklqdq xmm0, xmm2
movq xmm3, rax
lea rax, aSeven; "seven"
movaps [rsp+0C8h+var_88], xmm0
movq xmm0, rbx
movq xmm4, rax
lea rbx, aSix; "six"
punpcklqdq xmm0, xmm3
lea rax, aThreeFiveNine+0Bh; "nine"
movaps [rsp+0C8h+var_78], xmm0
movq xmm0, rbx
movq xmm5, rax
lea rbx, aEight; "eight"
punpcklqdq xmm0, xmm4
movzx eax, byte ptr [rdi]
movaps [rsp+0C8h+var_68], xmm0
movq xmm0, rbx
punpcklqdq xmm0, xmm5
movaps [rsp+0C8h+var_58], xmm0
test al, al
jz loc_1451
mov r12, rdi
lea r15, [rsp+0C8h+var_98]
lea r13, [rsp+0C8h+s1]
mov ebx, 1
lea r14, [rsp+0C8h+var_47]
test al, 0DFh
jz short loc_143B
nop
loc_13E0:
mov [r14+rbx], al
movzx eax, byte ptr [r12+rbx]
mov rdx, rbx
add rbx, 1
test al, 0DFh
jnz short loc_13E0
loc_13F4:
movsxd rax, edx
xor ebp, ebp
mov [rsp+rax+0C8h+s1], 0
nop dword ptr [rax+00000000h]
loc_1408:
mov rsi, [r15+rbp*8]; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jz short loc_143F
add rbp, 1
cmp rbp, 0Ah
jnz short loc_1408
add r12, rbx
cmp byte ptr [r12-1], 0
jz short loc_1451
loc_142D:
movzx eax, byte ptr [r12]
mov ebx, 1
test al, 0DFh
jnz short loc_13E0
loc_143B:
xor edx, edx
jmp short loc_13F4
loc_143F:
movsxd rbp, ebp
add r12, rbx
add dword ptr [rsp+rbp*4+0C8h+var_C8], 1
cmp byte ptr [r12-1], 0
jnz short loc_142D
loc_1451:
lea rbx, out_1
xor ebp, ebp
xor esi, esi
mov r12, rsp
lea rdi, [rbx-1]
nop dword ptr [rax+rax+00h]
loc_1468:
mov r10d, [r12+rbp*4]
test r10d, r10d
jle short loc_14C6
mov r11, qword ptr [rsp+rbp*8+0C8h+var_98]
xor r8d, r8d
movzx r9d, byte ptr [r11]
nop dword ptr [rax]
loc_1480:
mov ecx, esi
test r9b, r9b
jz short loc_14B3
lea eax, [rsi+1]
movsxd rcx, esi
mov rsi, r11
mov edx, r9d
cdqe
sub rsi, rcx
nop dword ptr [rax+rax+00000000h]
loc_14A0:
mov [rdi+rax], dl
mov rcx, rax
add rax, 1
movzx edx, byte ptr [rsi+rax-1]
test dl, dl
jnz short loc_14A0
loc_14B3:
lea esi, [rcx+1]
add r8d, 1
movsxd rcx, ecx
mov byte ptr [rbx+rcx], 20h ; ' '
cmp r8d, r10d
jnz short loc_1480
loc_14C6:
add rbp, 1
cmp rbp, 0Ah
jnz short loc_1468
test esi, esi
jle short loc_1505
lea eax, [rsi-1]
cdqe
mov byte ptr [rbx+rax], 0
loc_14DD:
mov rax, [rsp+0C8h+var_40]
sub rax, fs:28h
jnz short loc_150E
add rsp, 98h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1505:
mov cs:out_1, 0
jmp short loc_14DD
loc_150E:
call ___stack_chk_fail
|
char * func0(char *a1)
{
char v1; // al
char *v2; // r12
long long v3; // rbx
int v4; // edx
long long v5; // rbp
long long v6; // rbp
int v7; // esi
int v8; // r10d
char *v9; // r11
int v10; // r8d
char v11; // r9
int v12; // ecx
char v13; // dl
long long v14; // rax
char *v15; // rsi
_OWORD v17[2]; // [rsp+0h] [rbp-C8h] BYREF
long long v18; // [rsp+20h] [rbp-A8h]
_WORD v19[41]; // [rsp+30h] [rbp-98h]
char s1[6]; // [rsp+82h] [rbp-46h] BYREF
unsigned long long v21; // [rsp+88h] [rbp-40h]
v21 = __readfsqword(0x28u);
memset(v17, 0, sizeof(v17));
v18 = 0LL;
*(__m128i *)v19 = _mm_unpacklo_epi64((__m128i)(unsigned long long)"zero", (__m128i)(unsigned long long)"one");
*(__m128i *)&v19[8] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"two", (__m128i)(unsigned long long)"three");
*(__m128i *)&v19[16] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"four", (__m128i)(unsigned long long)"five");
v1 = *a1;
*(__m128i *)&v19[24] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"six", (__m128i)(unsigned long long)"seven");
*(__m128i *)&v19[32] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"eight", (__m128i)(unsigned long long)"nine");
if ( v1 )
{
v2 = a1;
v3 = 1LL;
if ( (v1 & 0xDF) != 0 )
{
do
{
LABEL_3:
*((_BYTE *)&v19[40] + v3 + 1) = v1;
v1 = v2[v3];
v4 = v3++;
}
while ( (v1 & 0xDF) != 0 );
}
else
{
LABEL_9:
v4 = 0;
}
v5 = 0LL;
s1[v4] = 0;
while ( strcmp(s1, *(const char **)&v19[4 * v5]) )
{
if ( ++v5 == 10 )
{
v2 += v3;
if ( !*(v2 - 1) )
goto LABEL_11;
LABEL_8:
v1 = *v2;
v3 = 1LL;
if ( (*v2 & 0xDF) != 0 )
goto LABEL_3;
goto LABEL_9;
}
}
v2 += v3;
++*((_DWORD *)v17 + (int)v5);
if ( *(v2 - 1) )
goto LABEL_8;
}
LABEL_11:
v6 = 0LL;
v7 = 0;
do
{
v8 = *((_DWORD *)v17 + v6);
if ( v8 > 0 )
{
v9 = *(char **)&v19[4 * v6];
v10 = 0;
v11 = *v9;
do
{
v12 = v7;
if ( v11 )
{
v13 = v11;
v14 = v7 + 1;
v15 = &v9[-v7];
do
{
out_1[v14 - 1] = v13;
v12 = v14++;
v13 = v15[v14 - 1];
}
while ( v13 );
}
v7 = v12 + 1;
++v10;
out_1[v12] = 32;
}
while ( v10 != v8 );
}
++v6;
}
while ( v6 != 10 );
if ( v7 <= 0 )
out_1[0] = 0;
else
out_1[v7 - 1] = 0;
return out_1;
}
|
func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x102004]
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RAX,[0x102009]
MOVAPS xmmword ptr [RSP],XMM0
MOVQ XMM1,RAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,RBX
LEA RAX,[0x102011]
PUNPCKLQDQ XMM0,XMM1
LEA RBX,[0x10200d]
MOVQ XMM2,RAX
MOV qword ptr [RSP + 0x20],0x0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVQ XMM0,RBX
LEA RAX,[0x10201c]
LEA RBX,[0x102017]
PUNPCKLQDQ XMM0,XMM2
MOVQ XMM3,RAX
LEA RAX,[0x102025]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVQ XMM0,RBX
MOVQ XMM4,RAX
LEA RBX,[0x102021]
PUNPCKLQDQ XMM0,XMM3
LEA RAX,[0x102057]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVQ XMM0,RBX
MOVQ XMM5,RAX
LEA RBX,[0x10202b]
PUNPCKLQDQ XMM0,XMM4
MOVZX EAX,byte ptr [RDI]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVQ XMM0,RBX
PUNPCKLQDQ XMM0,XMM5
MOVAPS xmmword ptr [RSP + 0x70],XMM0
TEST AL,AL
JZ 0x00101451
MOV R12,RDI
LEA R15,[RSP + 0x30]
LEA R13,[RSP + 0x82]
MOV EBX,0x1
LEA R14,[RSP + 0x81]
TEST AL,0xdf
JZ 0x0010143b
NOP
LAB_001013e0:
MOV byte ptr [R14 + RBX*0x1],AL
MOVZX EAX,byte ptr [R12 + RBX*0x1]
MOV RDX,RBX
ADD RBX,0x1
TEST AL,0xdf
JNZ 0x001013e0
LAB_001013f4:
MOVSXD RAX,EDX
XOR EBP,EBP
MOV byte ptr [RSP + RAX*0x1 + 0x82],0x0
NOP dword ptr [RAX]
LAB_00101408:
MOV RSI,qword ptr [R15 + RBP*0x8]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JZ 0x0010143f
ADD RBP,0x1
CMP RBP,0xa
JNZ 0x00101408
ADD R12,RBX
CMP byte ptr [R12 + -0x1],0x0
JZ 0x00101451
LAB_0010142d:
MOVZX EAX,byte ptr [R12]
MOV EBX,0x1
TEST AL,0xdf
JNZ 0x001013e0
LAB_0010143b:
XOR EDX,EDX
JMP 0x001013f4
LAB_0010143f:
MOVSXD RBP,EBP
ADD R12,RBX
ADD dword ptr [RSP + RBP*0x4],0x1
CMP byte ptr [R12 + -0x1],0x0
JNZ 0x0010142d
LAB_00101451:
LEA RBX,[0x104040]
XOR EBP,EBP
XOR ESI,ESI
MOV R12,RSP
LEA RDI,[RBX + -0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101468:
MOV R10D,dword ptr [R12 + RBP*0x4]
TEST R10D,R10D
JLE 0x001014c6
MOV R11,qword ptr [RSP + RBP*0x8 + 0x30]
XOR R8D,R8D
MOVZX R9D,byte ptr [R11]
NOP dword ptr [RAX]
LAB_00101480:
MOV ECX,ESI
TEST R9B,R9B
JZ 0x001014b3
LEA EAX,[RSI + 0x1]
MOVSXD RCX,ESI
MOV RSI,R11
MOV EDX,R9D
CDQE
SUB RSI,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_001014a0:
MOV byte ptr [RDI + RAX*0x1],DL
MOV RCX,RAX
ADD RAX,0x1
MOVZX EDX,byte ptr [RSI + RAX*0x1 + -0x1]
TEST DL,DL
JNZ 0x001014a0
LAB_001014b3:
LEA ESI,[RCX + 0x1]
ADD R8D,0x1
MOVSXD RCX,ECX
MOV byte ptr [RBX + RCX*0x1],0x20
CMP R8D,R10D
JNZ 0x00101480
LAB_001014c6:
ADD RBP,0x1
CMP RBP,0xa
JNZ 0x00101468
TEST ESI,ESI
JLE 0x00101505
LEA EAX,[RSI + -0x1]
CDQE
MOV byte ptr [RBX + RAX*0x1],0x0
LAB_001014dd:
MOV RAX,qword ptr [RSP + 0x88]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010150e
ADD RSP,0x98
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101505:
MOV byte ptr [0x00104040],0x0
JMP 0x001014dd
LAB_0010150e:
CALL 0x00101070
|
int1 * func0(byte *param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
byte bVar4;
int iVar5;
long lVar6;
int iVar7;
char cVar8;
long lVar9;
long lVar10;
int iVar11;
long in_FS_OFFSET;
int local_c8 [16];
int local_b8 [16];
int8 local_a8;
char *local_98 [10];
byte local_47 [7];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_c8 = (int [16])0x0;
local_b8 = (int [16])0x0;
local_a8 = 0;
local_98[0] = "zero";
local_98[1] = "one";
local_98[2] = "two";
local_98[3] = "three";
local_98[4] = "four";
local_98[5] = "five";
bVar4 = *param_1;
local_98[6] = "six";
local_98[7] = "seven";
local_98[8] = "eight";
local_98[9] = "nine";
if (bVar4 == 0) {
LAB_00101451:
lVar9 = 0;
iVar5 = 0;
do {
iVar2 = *(int *)(local_c8 + lVar9 * 4);
if (0 < iVar2) {
pcVar3 = local_98[lVar9];
iVar11 = 0;
cVar1 = *pcVar3;
iVar7 = iVar5;
do {
if (cVar1 != '\0') {
lVar10 = (long)iVar7;
lVar6 = (long)(iVar7 + 1);
cVar8 = cVar1;
do {
(&DAT_0010403f)[lVar6] = cVar8;
iVar7 = (int)lVar6;
lVar6 = lVar6 + 1;
cVar8 = pcVar3[lVar6 + (-1 - lVar10)];
} while (cVar8 != '\0');
}
iVar5 = iVar7 + 1;
iVar11 = iVar11 + 1;
(&out_1)[iVar7] = 0x20;
iVar7 = iVar5;
} while (iVar11 != iVar2);
}
lVar9 = lVar9 + 1;
} while (lVar9 != 10);
if (iVar5 < 1) {
out_1 = 0;
}
else {
(&out_1)[iVar5 + -1] = 0;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &out_1;
}
lVar9 = 1;
if ((bVar4 & 0xdf) == 0) goto LAB_0010143b;
LAB_001013e0:
do {
lVar6 = lVar9;
local_47[lVar6] = bVar4;
bVar4 = param_1[lVar6];
lVar9 = lVar6 + 1;
} while ((bVar4 & 0xdf) != 0);
do {
lVar10 = 0;
local_47[(long)(int)lVar6 + 1] = 0;
do {
iVar5 = strcmp((char *)(local_47 + 1),local_98[lVar10]);
if (iVar5 == 0) {
*(int *)(local_c8 + (long)(int)lVar10 * 4) = *(int *)(local_c8 + (long)(int)lVar10 * 4) + 1;
bVar4 = param_1[lVar9 + -1];
goto joined_r0x0010144f;
}
lVar10 = lVar10 + 1;
} while (lVar10 != 10);
bVar4 = param_1[lVar9 + -1];
joined_r0x0010144f:
if (bVar4 == 0) goto LAB_00101451;
param_1 = param_1 + lVar9;
bVar4 = *param_1;
lVar9 = 1;
if ((bVar4 & 0xdf) != 0) goto LAB_001013e0;
LAB_0010143b:
lVar9 = 1;
lVar6 = 0;
} while( true );
}
|
735 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = 0; numbers[i] != ' ' && numbers[i] != '\0'; ++i) {
current[i] = numbers[i];
}
current[i] = '\0';
for (j = 0; j < 10; ++j) {
if (strcmp(current, numto[j]) == 0) {
count[j]++;
break;
}
}
numbers += i + 1;
} while (numbers[-1]);
}
for (i = 0; i < 10; ++i) {
for (j = 0; j < count[i]; ++j) {
for (k = 0; numto[i][k] != '\0'; ++k, ++index) {
out[index] = numto[i][k];
}
out[index++] = ' ';
}
}
if (index > 0) {
out[index - 1] = '\0';
} else {
out[0] = '\0';
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
assert(strcmp(func0("six five four three two one zero"), "zero one two three four five six") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
lea 0xcfb(%rip),%rbx
sub $0xd8,%rsp
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
lea 0xcdf(%rip),%rax
movaps %xmm0,0x40(%rsp)
movq %rax,%xmm1
movaps %xmm0,0x50(%rsp)
movq %rbx,%xmm0
lea 0xccc(%rip),%rax
punpcklqdq %xmm1,%xmm0
lea 0xcbd(%rip),%rbx
movq %rax,%xmm2
movq $0x0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movq %rbx,%xmm0
lea 0xcad(%rip),%rax
lea 0xca1(%rip),%rbx
punpcklqdq %xmm2,%xmm0
movq %rax,%xmm3
lea 0xc9f(%rip),%rax
movaps %xmm0,0x80(%rsp)
movq %rbx,%xmm0
lea 0xc87(%rip),%rbx
movq %rax,%xmm4
punpcklqdq %xmm3,%xmm0
lea 0xcad(%rip),%rax
movaps %xmm0,0x90(%rsp)
movq %rbx,%xmm0
lea 0xc6d(%rip),%rbx
movq %rax,%xmm5
punpcklqdq %xmm4,%xmm0
movzbl (%rdi),%eax
movaps %xmm0,0xa0(%rsp)
movq %rbx,%xmm0
punpcklqdq %xmm5,%xmm0
movaps %xmm0,0xb0(%rsp)
test %al,%al
je 15e4 <func0+0x2f4>
mov 0x88(%rsp),%rbx
mov 0x70(%rsp),%r13
mov %rdi,%rbp
mov 0x78(%rsp),%r15
mov 0x80(%rsp),%r14
mov %rbx,0x8(%rsp)
mov 0x90(%rsp),%rbx
mov %rbx,0x18(%rsp)
mov 0x98(%rsp),%rbx
mov %rbx,0x10(%rsp)
mov 0xa0(%rsp),%rbx
mov %rbx,0x28(%rsp)
mov 0xa8(%rsp),%rbx
mov %rbx,0x20(%rsp)
mov 0xb0(%rsp),%rbx
mov %rbx,0x38(%rsp)
mov 0xb8(%rsp),%rbx
mov %rbx,0x30(%rsp)
lea 0xc2(%rsp),%rbx
jmpq 15ba <func0+0x2ca>
mov %al,0xc2(%rsp)
movzbl 0x1(%rbp),%eax
test $0xdf,%al
je 16a2 <func0+0x3b2>
mov %al,0xc3(%rsp)
movzbl 0x2(%rbp),%eax
test $0xdf,%al
je 16b2 <func0+0x3c2>
mov %al,0xc4(%rsp)
movzbl 0x3(%rbp),%eax
test $0xdf,%al
je 16cb <func0+0x3db>
mov %al,0xc5(%rsp)
movzbl 0x4(%rbp),%eax
test $0xdf,%al
je 16db <func0+0x3eb>
mov %al,0xc6(%rsp)
movzbl 0x5(%rbp),%eax
test $0xdf,%al
je 16eb <func0+0x3fb>
mov %al,0xc7(%rsp)
mov $0x6,%r12d
mov $0x6,%eax
add $0x1,%r12
mov %r13,%rsi
mov %rbx,%rdi
movb $0x0,0xc2(%rsp,%rax,1)
callq 1090 <strcmp@plt>
test %eax,%eax
je 15d4 <func0+0x2e4>
mov %r15,%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 16fb <func0+0x40b>
mov %r14,%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 171d <func0+0x42d>
mov 0x8(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 170c <func0+0x41c>
mov 0x18(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 173f <func0+0x44f>
mov 0x10(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 172e <func0+0x43e>
mov 0x28(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1761 <func0+0x471>
mov 0x20(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1772 <func0+0x482>
mov 0x38(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 15cf <func0+0x2df>
mov 0x30(%rsp),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1750 <func0+0x460>
add %r12,%rbp
cmpb $0x0,-0x1(%rbp)
je 15e4 <func0+0x2f4>
movzbl 0x0(%rbp),%eax
test $0xdf,%al
jne 1468 <func0+0x178>
mov $0x1,%r12d
xor %eax,%eax
jmpq 14dd <func0+0x1ed>
mov $0x8,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
add %r12,%rbp
cmpb $0x0,-0x1(%rbp)
jne 15b6 <func0+0x2c6>
lea 0x2a55(%rip),%rbx
xor %ebp,%ebp
lea 0x40(%rsp),%r12
xor %esi,%esi
lea -0x1(%rbx),%rdi
nopl 0x0(%rax,%rax,1)
mov (%r12,%rbp,4),%r10d
test %r10d,%r10d
jle 165b <func0+0x36b>
mov 0x70(%rsp,%rbp,8),%r11
xor %r8d,%r8d
movzbl (%r11),%r9d
nopl (%rax)
movslq %esi,%rcx
test %r9b,%r9b
je 164b <func0+0x35b>
lea 0x1(%rsi),%eax
mov %r11,%rcx
movslq %esi,%rsi
mov %r9d,%edx
sub %rsi,%rcx
cltq
mov %rcx,%rsi
nopl 0x0(%rax)
mov %dl,(%rdi,%rax,1)
movslq %eax,%rcx
add $0x1,%rax
movzbl -0x1(%rsi,%rax,1),%edx
test %dl,%dl
jne 1638 <func0+0x348>
add $0x1,%r8d
movb $0x20,(%rbx,%rcx,1)
lea 0x1(%rcx),%esi
cmp %r8d,%r10d
jne 1618 <func0+0x328>
add $0x1,%rbp
cmp $0xa,%rbp
jne 1600 <func0+0x310>
test %esi,%esi
je 16c2 <func0+0x3d2>
lea -0x1(%rsi),%eax
cltq
movb $0x0,(%rbx,%rax,1)
mov 0xc8(%rsp),%rax
xor %fs:0x28,%rax
jne 1783 <func0+0x493>
add $0xd8,%rsp
lea 0x29a9(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%eax
mov $0x1,%r12d
jmpq 14d9 <func0+0x1e9>
mov $0x2,%eax
mov $0x2,%r12d
jmpq 14d9 <func0+0x1e9>
movb $0x0,0x2977(%rip)
jmp 1672 <func0+0x382>
mov $0x3,%eax
mov $0x3,%r12d
jmpq 14d9 <func0+0x1e9>
mov $0x4,%eax
mov $0x4,%r12d
jmpq 14d9 <func0+0x1e9>
mov $0x5,%eax
mov $0x5,%r12d
jmpq 14d9 <func0+0x1e9>
mov $0x1,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x3,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x2,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x5,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x4,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x9,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x6,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
mov $0x7,%eax
cltq
addl $0x1,0x40(%rsp,%rax,4)
jmpq 15db <func0+0x2eb>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
pxor xmm0, xmm0
lea r15, aSix; "six"
push r14
lea r14, aTwo; "two"
push r13
lea r13, aZero; "zero"
push r12
push rbp
push rbx
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
movaps [rsp+0C8h+var_C8], xmm0
movzx eax, byte ptr [rdi]
movaps [rsp+0C8h+var_B8], xmm0
movq xmm0, r13
mov [rsp+0C8h+var_A8], 0
movhps xmm0, cs:off_3D80; "one"
movaps [rsp+0C8h+var_98], xmm0
movq xmm0, r14
movhps xmm0, cs:off_3D88; "three"
movaps [rsp+0C8h+var_88], xmm0
movq xmm0, cs:off_3D90; "four"
movhps xmm0, cs:off_3D98; "five"
movaps [rsp+0C8h+var_78], xmm0
movq xmm0, r15
movhps xmm0, cs:off_3DA0; "seven"
movaps [rsp+0C8h+var_68], xmm0
movq xmm0, cs:off_3DA8; "eight"
movhps xmm0, cs:off_3DB0; "nine"
movaps [rsp+0C8h+var_58], xmm0
test al, al
jz loc_1526
mov rbp, rdi
lea rbx, [rsp+0C8h+s1]
jmp loc_14FD
loc_1399:
mov [rsp+0C8h+s1], al
movzx eax, byte ptr [rbp+1]
test al, 0DFh
jz loc_15D9
mov [rsp+0C8h+var_45], al
movzx eax, byte ptr [rbp+2]
test al, 0DFh
jz loc_15E9
mov [rsp+0C8h+var_44], al
movzx eax, byte ptr [rbp+3]
test al, 0DFh
jz loc_1602
mov [rsp+0C8h+var_43], al
movzx eax, byte ptr [rbp+4]
test al, 0DFh
jz loc_1612
mov [rsp+0C8h+var_42], al
movzx eax, byte ptr [rbp+5]
test al, 0DFh
jz loc_1622
mov [rsp+0C8h+var_41], al
mov r12d, 6
mov eax, 6
loc_140A:
add r12, 1
loc_140E:
mov rsi, r13; s2
mov rdi, rbx; s1
mov [rsp+rax+0C8h+s1], 0
call _strcmp
test eax, eax
jz loc_1517
lea rsi, aOne; "one"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1512
mov rsi, r14; s2
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1642
lea rsi, s2; "three"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1632
lea rsi, aFour; "four"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1662
lea rsi, aFive; "five"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1652
mov rsi, r15; s2
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1682
lea rsi, aSeven; "seven"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1692
lea rsi, aEight; "eight"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_16A2
lea rsi, aThreeFiveNine+0Bh; s2
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz loc_1672
add rbp, r12
cmp byte ptr [rbp-1], 0
jz short loc_1526
loc_14F9:
movzx eax, byte ptr [rbp+0]
loc_14FD:
test al, 0DFh
jnz loc_1399
mov r12d, 1
xor eax, eax
jmp loc_140E
loc_1512:
mov eax, 1
loc_1517:
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
loc_151D:
add rbp, r12
cmp byte ptr [rbp-1], 0
jnz short loc_14F9
loc_1526:
lea rbx, out_1
xor ebp, ebp
xor esi, esi
mov r12, rsp
lea rdi, [rbx-1]
nop dword ptr [rax+rax+00000000h]
loc_1540:
mov r10d, [r12+rbp*4]
test r10d, r10d
jle short loc_1596
mov r11, qword ptr [rsp+rbp*8+0C8h+var_98]
xor r8d, r8d
movzx r9d, byte ptr [r11]
nop dword ptr [rax]
loc_1558:
mov ecx, esi
test r9b, r9b
jz short loc_1583
lea eax, [rsi+1]
movsxd rcx, esi
mov rsi, r11
mov edx, r9d
cdqe
sub rsi, rcx
loc_1570:
mov [rdi+rax], dl
mov rcx, rax
add rax, 1
movzx edx, byte ptr [rsi+rax-1]
test dl, dl
jnz short loc_1570
loc_1583:
lea esi, [rcx+1]
add r8d, 1
movsxd rcx, ecx
mov byte ptr [rbx+rcx], 20h ; ' '
cmp r8d, r10d
jnz short loc_1558
loc_1596:
add rbp, 1
cmp rbp, 0Ah
jnz short loc_1540
test esi, esi
jle short loc_15F9
lea eax, [rsi-1]
cdqe
mov byte ptr [rbx+rax], 0
loc_15AD:
mov rax, [rsp+0C8h+var_40]
sub rax, fs:28h
jnz loc_16B2
add rsp, 98h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15D9:
mov eax, 1
mov r12d, 1
jmp loc_140A
loc_15E9:
mov eax, 2
mov r12d, 2
jmp loc_140A
loc_15F9:
mov cs:out_1, 0
jmp short loc_15AD
loc_1602:
mov eax, 3
mov r12d, 3
jmp loc_140A
loc_1612:
mov eax, 4
mov r12d, 4
jmp loc_140A
loc_1622:
mov eax, 5
mov r12d, 5
jmp loc_140A
loc_1632:
mov eax, 3
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_1642:
mov eax, 2
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_1652:
mov eax, 5
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_1662:
mov eax, 4
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_1672:
mov eax, 9
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_1682:
mov eax, 6
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_1692:
mov eax, 7
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_16A2:
mov eax, 8
cdqe
add dword ptr [rsp+rax*4+0C8h+var_C8], 1
jmp loc_151D
loc_16B2:
call ___stack_chk_fail
|
char * func0(char *a1)
{
char v1; // al
char *i; // rbp
long long v3; // r12
long long v4; // rax
long long v5; // r12
int v6; // eax
long long v7; // rbp
int v8; // esi
int v9; // r10d
char *v10; // r11
int v11; // r8d
char v12; // r9
int v13; // ecx
char v14; // dl
long long v15; // rax
char *v16; // rsi
__int128 v18; // [rsp+0h] [rbp-C8h]
__int128 v19; // [rsp+10h] [rbp-B8h]
long long v20; // [rsp+20h] [rbp-A8h]
_OWORD v21[5]; // [rsp+30h] [rbp-98h]
char s1[6]; // [rsp+82h] [rbp-46h] BYREF
unsigned long long v23; // [rsp+88h] [rbp-40h]
v23 = __readfsqword(0x28u);
v18 = 0LL;
v1 = *a1;
v19 = 0LL;
v20 = 0LL;
v21[0] = _mm_loadh_ps((const double *)off_3D80);
v21[1] = _mm_loadh_ps((const double *)off_3D88);
v21[2] = _mm_loadh_ps((const double *)off_3D98);
v21[3] = _mm_loadh_ps((const double *)off_3DA0);
v21[4] = _mm_loadh_ps((const double *)&off_3DB0);
if ( v1 )
{
for ( i = a1; ; v1 = *i )
{
if ( (v1 & 0xDF) != 0 )
{
s1[0] = v1;
if ( (i[1] & 0xDF) != 0 )
{
s1[1] = i[1];
if ( (i[2] & 0xDF) != 0 )
{
s1[2] = i[2];
if ( (i[3] & 0xDF) != 0 )
{
s1[3] = i[3];
if ( (i[4] & 0xDF) != 0 )
{
s1[4] = i[4];
if ( (i[5] & 0xDF) != 0 )
{
s1[5] = i[5];
v3 = 6LL;
v4 = 6LL;
}
else
{
v4 = 5LL;
v3 = 5LL;
}
}
else
{
v4 = 4LL;
v3 = 4LL;
}
}
else
{
v4 = 3LL;
v3 = 3LL;
}
}
else
{
v4 = 2LL;
v3 = 2LL;
}
}
else
{
v4 = 1LL;
v3 = 1LL;
}
v5 = v3 + 1;
}
else
{
v5 = 1LL;
v4 = 0LL;
}
s1[v4] = 0;
v6 = strcmp(s1, "zero");
if ( !v6 )
goto LABEL_25;
if ( !strcmp(s1, "one") )
break;
if ( !strcmp(s1, "two") )
{
++DWORD2(v18);
}
else if ( !strcmp(s1, "three") )
{
++HIDWORD(v18);
}
else if ( !strcmp(s1, "four") )
{
LODWORD(v19) = v19 + 1;
}
else if ( !strcmp(s1, "five") )
{
++DWORD1(v19);
}
else if ( !strcmp(s1, "six") )
{
++DWORD2(v19);
}
else if ( !strcmp(s1, "seven") )
{
++HIDWORD(v19);
}
else if ( !strcmp(s1, "eight") )
{
LODWORD(v20) = v20 + 1;
}
else
{
if ( strcmp(s1, "nine") )
{
i += v5;
if ( !*(i - 1) )
goto LABEL_27;
continue;
}
++HIDWORD(v20);
}
LABEL_26:
i += v5;
if ( !*(i - 1) )
goto LABEL_27;
}
v6 = 1;
LABEL_25:
++*((_DWORD *)&v18 + v6);
goto LABEL_26;
}
LABEL_27:
v7 = 0LL;
v8 = 0;
do
{
v9 = *((_DWORD *)&v18 + v7);
if ( v9 > 0 )
{
v10 = (char *)*((_QWORD *)v21 + v7);
v11 = 0;
v12 = *v10;
do
{
v13 = v8;
if ( v12 )
{
v14 = v12;
v15 = v8 + 1;
v16 = &v10[-v8];
do
{
out_1[v15 - 1] = v14;
v13 = v15++;
v14 = v16[v15 - 1];
}
while ( v14 );
}
v8 = v13 + 1;
++v11;
out_1[v13] = 32;
}
while ( v11 != v9 );
}
++v7;
}
while ( v7 != 10 );
if ( v8 <= 0 )
out_1[0] = 0;
else
out_1[v8 - 1] = 0;
return out_1;
}
|
func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
LEA R15,[0x102021]
PUSH R14
LEA R14,[0x10200d]
PUSH R13
LEA R13,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOVZX EAX,byte ptr [RDI]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,R13
MOV qword ptr [RSP + 0x20],0x0
MOVHPS XMM0,qword ptr [0x00103d80]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVQ XMM0,R14
MOVHPS XMM0,qword ptr [0x00103d88]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVQ XMM0,qword ptr [0x00103d90]
MOVHPS XMM0,qword ptr [0x00103d98]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVQ XMM0,R15
MOVHPS XMM0,qword ptr [0x00103da0]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVQ XMM0,qword ptr [0x00103da8]
MOVHPS XMM0,qword ptr [0x00103db0]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
TEST AL,AL
JZ 0x00101526
MOV RBP,RDI
LEA RBX,[RSP + 0x82]
JMP 0x001014fd
LAB_00101399:
MOV byte ptr [RSP + 0x82],AL
MOVZX EAX,byte ptr [RBP + 0x1]
TEST AL,0xdf
JZ 0x001015d9
MOV byte ptr [RSP + 0x83],AL
MOVZX EAX,byte ptr [RBP + 0x2]
TEST AL,0xdf
JZ 0x001015e9
MOV byte ptr [RSP + 0x84],AL
MOVZX EAX,byte ptr [RBP + 0x3]
TEST AL,0xdf
JZ 0x00101602
MOV byte ptr [RSP + 0x85],AL
MOVZX EAX,byte ptr [RBP + 0x4]
TEST AL,0xdf
JZ 0x00101612
MOV byte ptr [RSP + 0x86],AL
MOVZX EAX,byte ptr [RBP + 0x5]
TEST AL,0xdf
JZ 0x00101622
MOV byte ptr [RSP + 0x87],AL
MOV R12D,0x6
MOV EAX,0x6
LAB_0010140a:
ADD R12,0x1
LAB_0010140e:
MOV RSI,R13
MOV RDI,RBX
MOV byte ptr [RSP + RAX*0x1 + 0x82],0x0
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101517
LEA RSI,[0x102009]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101512
MOV RSI,R14
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101642
LEA RSI,[0x102011]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101632
LEA RSI,[0x102017]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101662
LEA RSI,[0x10201c]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101652
MOV RSI,R15
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101682
LEA RSI,[0x102025]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101692
LEA RSI,[0x10202b]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x001016a2
LEA RSI,[0x102057]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101672
ADD RBP,R12
CMP byte ptr [RBP + -0x1],0x0
JZ 0x00101526
LAB_001014f9:
MOVZX EAX,byte ptr [RBP]
LAB_001014fd:
TEST AL,0xdf
JNZ 0x00101399
MOV R12D,0x1
XOR EAX,EAX
JMP 0x0010140e
LAB_00101512:
MOV EAX,0x1
LAB_00101517:
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
LAB_0010151d:
ADD RBP,R12
CMP byte ptr [RBP + -0x1],0x0
JNZ 0x001014f9
LAB_00101526:
LEA RBX,[0x104040]
XOR EBP,EBP
XOR ESI,ESI
MOV R12,RSP
LEA RDI,[RBX + -0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101540:
MOV R10D,dword ptr [R12 + RBP*0x4]
TEST R10D,R10D
JLE 0x00101596
MOV R11,qword ptr [RSP + RBP*0x8 + 0x30]
XOR R8D,R8D
MOVZX R9D,byte ptr [R11]
NOP dword ptr [RAX]
LAB_00101558:
MOV ECX,ESI
TEST R9B,R9B
JZ 0x00101583
LEA EAX,[RSI + 0x1]
MOVSXD RCX,ESI
MOV RSI,R11
MOV EDX,R9D
CDQE
SUB RSI,RCX
LAB_00101570:
MOV byte ptr [RDI + RAX*0x1],DL
MOV RCX,RAX
ADD RAX,0x1
MOVZX EDX,byte ptr [RSI + RAX*0x1 + -0x1]
TEST DL,DL
JNZ 0x00101570
LAB_00101583:
LEA ESI,[RCX + 0x1]
ADD R8D,0x1
MOVSXD RCX,ECX
MOV byte ptr [RBX + RCX*0x1],0x20
CMP R8D,R10D
JNZ 0x00101558
LAB_00101596:
ADD RBP,0x1
CMP RBP,0xa
JNZ 0x00101540
TEST ESI,ESI
JLE 0x001015f9
LEA EAX,[RSI + -0x1]
CDQE
MOV byte ptr [RBX + RAX*0x1],0x0
LAB_001015ad:
MOV RAX,qword ptr [RSP + 0x88]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016b2
ADD RSP,0x98
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015d9:
MOV EAX,0x1
MOV R12D,0x1
JMP 0x0010140a
LAB_001015e9:
MOV EAX,0x2
MOV R12D,0x2
JMP 0x0010140a
LAB_001015f9:
MOV byte ptr [0x00104040],0x0
JMP 0x001015ad
LAB_00101602:
MOV EAX,0x3
MOV R12D,0x3
JMP 0x0010140a
LAB_00101612:
MOV EAX,0x4
MOV R12D,0x4
JMP 0x0010140a
LAB_00101622:
MOV EAX,0x5
MOV R12D,0x5
JMP 0x0010140a
LAB_00101632:
MOV EAX,0x3
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_00101642:
MOV EAX,0x2
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_00101652:
MOV EAX,0x5
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_00101662:
MOV EAX,0x4
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_00101672:
MOV EAX,0x9
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_00101682:
MOV EAX,0x6
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_00101692:
MOV EAX,0x7
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_001016a2:
MOV EAX,0x8
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
JMP 0x0010151d
LAB_001016b2:
CALL 0x00101070
|
int1 * func0(byte *param_1)
{
byte bVar1;
byte bVar2;
byte bVar3;
char cVar4;
int iVar5;
char *pcVar6;
int iVar7;
int iVar8;
long lVar9;
char cVar10;
long lVar11;
int iVar12;
long lVar13;
long in_FS_OFFSET;
int local_c8 [16];
int local_b8 [16];
int8 local_a8;
int *local_98 [10];
byte local_46 [6];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_c8 = (int [16])0x0;
bVar1 = *param_1;
local_b8 = (int [16])0x0;
local_a8 = 0;
local_98[0] = &DAT_00102004;
local_98[1] = PTR_DAT_00103d80;
local_98[2] = &DAT_0010200d;
local_98[3] = PTR_s_three_00103d88;
local_98[4] = PTR_DAT_00103d90;
local_98[5] = PTR_DAT_00103d98;
local_98[6] = &DAT_00102021;
local_98[7] = PTR_s_seven_00103da0;
local_98[8] = PTR_s_eight_00103da8;
local_98[9] = PTR_s_nine_00103db0;
if (bVar1 == 0) {
LAB_00101526:
lVar11 = 0;
iVar7 = 0;
do {
iVar5 = *(int *)(local_c8 + lVar11 * 4);
if (0 < iVar5) {
pcVar6 = local_98[lVar11];
iVar12 = 0;
cVar4 = *pcVar6;
iVar8 = iVar7;
do {
if (cVar4 != '\0') {
lVar9 = (long)iVar8;
lVar13 = (long)(iVar8 + 1);
cVar10 = cVar4;
do {
(&DAT_0010403f)[lVar13] = cVar10;
iVar8 = (int)lVar13;
lVar13 = lVar13 + 1;
cVar10 = pcVar6[lVar13 + (-1 - lVar9)];
} while (cVar10 != '\0');
}
iVar7 = iVar8 + 1;
iVar12 = iVar12 + 1;
(&out_1)[iVar8] = 0x20;
iVar8 = iVar7;
} while (iVar12 != iVar5);
}
lVar11 = lVar11 + 1;
} while (lVar11 != 10);
if (iVar7 < 1) {
out_1 = 0;
}
else {
(&out_1)[iVar7 + -1] = 0;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &out_1;
}
do {
if ((bVar1 & 0xdf) == 0) {
lVar13 = 1;
lVar11 = 0;
}
else {
bVar2 = param_1[1];
if ((bVar2 & 0xdf) == 0) {
lVar11 = 1;
lVar13 = 1;
}
else {
bVar3 = param_1[2];
local_46[1] = bVar2;
if ((bVar3 & 0xdf) == 0) {
lVar11 = 2;
lVar13 = 2;
}
else {
bVar2 = param_1[3];
local_46[2] = bVar3;
if ((bVar2 & 0xdf) == 0) {
lVar11 = 3;
lVar13 = 3;
}
else {
bVar3 = param_1[4];
local_46[3] = bVar2;
if ((bVar3 & 0xdf) == 0) {
lVar11 = 4;
lVar13 = 4;
}
else {
local_46[4] = bVar3;
if ((param_1[5] & 0xdf) == 0) {
lVar11 = 5;
lVar13 = 5;
}
else {
lVar13 = 6;
lVar11 = 6;
local_46[5] = param_1[5];
}
}
}
}
}
lVar13 = lVar13 + 1;
local_46[0] = bVar1;
}
local_46[lVar11] = 0;
iVar7 = strcmp((char *)local_46,"zero");
if (iVar7 == 0) {
LAB_00101517:
*(int *)(local_c8 + (long)iVar7 * 4) = *(int *)(local_c8 + (long)iVar7 * 4) + 1;
LAB_0010151d:
bVar1 = param_1[lVar13 + -1];
}
else {
iVar7 = strcmp((char *)local_46,"one");
if (iVar7 == 0) {
iVar7 = 1;
goto LAB_00101517;
}
iVar7 = strcmp((char *)local_46,"two");
if (iVar7 == 0) {
local_c8._8_4_ = local_c8._8_4_ + 1;
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"three");
if (iVar7 == 0) {
local_c8._12_4_ = local_c8._12_4_ + 1;
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"four");
if (iVar7 == 0) {
local_b8._0_4_ = local_b8._0_4_ + 1;
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"five");
if (iVar7 == 0) {
local_b8._4_4_ = local_b8._4_4_ + 1;
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"six");
if (iVar7 == 0) {
local_b8._8_4_ = local_b8._8_4_ + 1;
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"seven");
if (iVar7 == 0) {
local_b8._12_4_ = local_b8._12_4_ + 1;
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"eight");
if (iVar7 == 0) {
local_a8 = CONCAT44(local_a8._4_4_,(int)local_a8 + 1);
goto LAB_0010151d;
}
iVar7 = strcmp((char *)local_46,"nine");
if (iVar7 == 0) {
local_a8 = CONCAT44(local_a8._4_4_ + 1,(int)local_a8);
goto LAB_0010151d;
}
bVar1 = param_1[lVar13 + -1];
}
if (bVar1 == 0) goto LAB_00101526;
param_1 = param_1 + lVar13;
bVar1 = *param_1;
} while( true );
}
|
736 |
func0
|
#include <stdio.h>
#include <math.h>
#include <float.h>
|
void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
min_diff = diff;
out[0] = numbers[i];
out[1] = numbers[j];
}
}
}
if (out[0] > out[1]) {
float temp = out[0];
out[0] = out[1];
out[1] = temp;
}
}
|
#include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
float expected1[] = {3.9, 4.0};
func0(test1, 6, result);
assert(issame(result, expected1, 2));
float test2[] = {1.0, 2.0, 5.9, 4.0, 5.0};
float expected2[] = {5.0, 5.9};
func0(test2, 5, result);
assert(issame(result, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.2};
float expected3[] = {2.0, 2.2};
func0(test3, 6, result);
assert(issame(result, expected3, 2));
float test4[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.0};
float expected4[] = {2.0, 2.0};
func0(test4, 6, result);
assert(issame(result, expected4, 2));
float test5[] = {1.1, 2.2, 3.1, 4.1, 5.1};
float expected5[] = {2.2, 3.1};
func0(test5, 5, result);
assert(issame(result, expected5, 2));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
movss 0xf64(%rip),%xmm0
movss %xmm0,-0x14(%rbp)
mov -0x28(%rbp),%rax
movss (%rax),%xmm0
mov -0x38(%rbp),%rax
movss %xmm0,(%rax)
mov -0x38(%rbp),%rax
lea 0x4(%rax),%rdx
mov -0x28(%rbp),%rax
movss 0x4(%rax),%xmm0
movss %xmm0,(%rdx)
movl $0x0,-0x10(%rbp)
jmpq 1279 <func0+0x110>
mov -0x10(%rbp),%eax
add $0x1,%eax
mov %eax,-0xc(%rbp)
jmpq 1269 <func0+0x100>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
subss %xmm1,%xmm0
movss 0xeec(%rip),%xmm1
andps %xmm1,%xmm0
movss %xmm0,-0x4(%rbp)
movss -0x14(%rbp),%xmm0
comiss -0x4(%rbp),%xmm0
jbe 1265 <func0+0xfc>
movss -0x4(%rbp),%xmm0
movss %xmm0,-0x14(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
mov -0x38(%rbp),%rax
movss %xmm0,(%rax)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x38(%rbp),%rax
add $0x4,%rax
movss (%rdx),%xmm0
movss %xmm0,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11c8 <func0+0x5f>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11ba <func0+0x51>
mov -0x38(%rbp),%rax
movss (%rax),%xmm0
mov -0x38(%rbp),%rax
add $0x4,%rax
movss (%rax),%xmm1
comiss %xmm1,%xmm0
ja 12a0 <func0+0x137>
jmp 12cf <func0+0x166>
mov -0x38(%rbp),%rax
movss (%rax),%xmm0
movss %xmm0,-0x8(%rbp)
mov -0x38(%rbp),%rax
movss 0x4(%rax),%xmm0
mov -0x38(%rbp),%rax
movss %xmm0,(%rax)
mov -0x38(%rbp),%rax
add $0x4,%rax
movss -0x8(%rbp),%xmm0
movss %xmm0,(%rax)
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
movss xmm0, cs:dword_20C8
movss [rbp+var_14], xmm0
mov rax, [rbp+var_28]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_38]
movss dword ptr [rax], xmm0
mov rax, [rbp+var_38]
lea rdx, [rax+4]
mov rax, [rbp+var_28]
movss xmm0, dword ptr [rax+4]
movss dword ptr [rdx], xmm0
mov [rbp+var_10], 0
jmp loc_1279
loc_11BA:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_C], eax
jmp loc_1269
loc_11C8:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm1, dword ptr [rax]
subss xmm0, xmm1
movss xmm1, cs:dword_20D0
andps xmm0, xmm1
movss [rbp+var_4], xmm0
movss xmm0, [rbp+var_14]
comiss xmm0, [rbp+var_4]
jbe short loc_1265
movss xmm0, [rbp+var_4]
movss [rbp+var_14], xmm0
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_38]
movss dword ptr [rax], xmm0
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov rax, [rbp+var_38]
add rax, 4
movss xmm0, dword ptr [rdx]
movss dword ptr [rax], xmm0
loc_1265:
add [rbp+var_C], 1
loc_1269:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl loc_11C8
add [rbp+var_10], 1
loc_1279:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl loc_11BA
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_38]
add rax, 4
movss xmm1, dword ptr [rax]
comiss xmm0, xmm1
ja short loc_12A0
jmp short loc_12CF
loc_12A0:
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax]
movss [rbp+var_8], xmm0
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax+4]
mov rax, [rbp+var_38]
movss dword ptr [rax], xmm0
mov rax, [rbp+var_38]
add rax, 4
movss xmm0, [rbp+var_8]
movss dword ptr [rax], xmm0
loc_12CF:
nop
pop rbp
retn
|
_DWORD * func0(float *a1, int a2, float *a3)
{
_DWORD *result; // rax
float v4; // [rsp+24h] [rbp-14h]
int i; // [rsp+28h] [rbp-10h]
int j; // [rsp+2Ch] [rbp-Ch]
float v7; // [rsp+30h] [rbp-8h]
float v8; // [rsp+34h] [rbp-4h]
v4 = 3.4028235e38;
*a3 = *a1;
a3[1] = a1[1];
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
v8 = fabs(a1[i] - a1[j]);
if ( v4 > v8 )
{
v4 = v8;
*a3 = a1[i];
a3[1] = a1[j];
}
}
}
result = a3 + 1;
if ( *a3 > a3[1] )
{
v7 = *a3;
*a3 = a3[1];
result = a3 + 1;
a3[1] = v7;
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOVSS XMM0,dword ptr [0x001020c8]
MOVSS dword ptr [RBP + -0x14],XMM0
MOV RAX,qword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RAX + 0x4]
MOVSS dword ptr [RDX],XMM0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101279
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101269
LAB_001011c8:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX]
SUBSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x001020d0]
ANDPS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
COMISS XMM0,dword ptr [RBP + -0x4]
JBE 0x00101265
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVSS dword ptr [RBP + -0x14],XMM0
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOVSS XMM0,dword ptr [RDX]
MOVSS dword ptr [RAX],XMM0
LAB_00101265:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101269:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011c8
ADD dword ptr [RBP + -0x10],0x1
LAB_00101279:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011ba
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,XMM1
JA 0x001012a0
JMP 0x001012cf
LAB_001012a0:
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x8],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOVSS XMM0,dword ptr [RBP + -0x8]
MOVSS dword ptr [RAX],XMM0
LAB_001012cf:
NOP
POP RBP
RET
|
void func0(float *param_1,int param_2,float *param_3)
{
float fVar1;
float local_1c;
int local_18;
int local_14;
local_1c = DAT_001020c8;
*param_3 = *param_1;
param_3[1] = param_1[1];
for (local_18 = 0; local_14 = local_18, local_18 < param_2; local_18 = local_18 + 1) {
while (local_14 = local_14 + 1, local_14 < param_2) {
fVar1 = (float)((uint)(param_1[local_18] - param_1[local_14]) & DAT_001020d0);
if (fVar1 < local_1c) {
*param_3 = param_1[local_18];
param_3[1] = param_1[local_14];
local_1c = fVar1;
}
}
}
if (param_3[1] < *param_3) {
fVar1 = *param_3;
*param_3 = param_3[1];
param_3[1] = fVar1;
}
return;
}
|
737 |
func0
|
#include <stdio.h>
#include <math.h>
#include <float.h>
|
void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
min_diff = diff;
out[0] = numbers[i];
out[1] = numbers[j];
}
}
}
if (out[0] > out[1]) {
float temp = out[0];
out[0] = out[1];
out[1] = temp;
}
}
|
#include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
float expected1[] = {3.9, 4.0};
func0(test1, 6, result);
assert(issame(result, expected1, 2));
float test2[] = {1.0, 2.0, 5.9, 4.0, 5.0};
float expected2[] = {5.0, 5.9};
func0(test2, 5, result);
assert(issame(result, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.2};
float expected3[] = {2.0, 2.2};
func0(test3, 6, result);
assert(issame(result, expected3, 2));
float test4[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.0};
float expected4[] = {2.0, 2.0};
func0(test4, 6, result);
assert(issame(result, expected4, 2));
float test5[] = {1.1, 2.2, 3.1, 4.1, 5.1};
float expected5[] = {2.2, 3.1};
func0(test5, 5, result);
assert(issame(result, expected5, 2));
return 0;
}
|
O1
|
c
|
func0:
endbr64
movss (%rdi),%xmm0
movss %xmm0,(%rdx)
movss 0x4(%rdi),%xmm0
movss %xmm0,0x4(%rdx)
test %esi,%esi
jle 11e7 <func0+0x7e>
mov %rdi,%rcx
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
movss 0xf44(%rip),%xmm2
movss 0xf6c(%rip),%xmm3
jmp 11dd <func0+0x74>
add $0x1,%rax
cmp %eax,%esi
jle 11d5 <func0+0x6c>
movss (%rcx),%xmm1
movaps %xmm1,%xmm0
subss (%rdi,%rax,4),%xmm0
andps %xmm3,%xmm0
comiss %xmm0,%xmm2
jbe 11a6 <func0+0x3d>
movss %xmm1,(%rdx)
movss (%rdi,%rax,4),%xmm1
movss %xmm1,0x4(%rdx)
movaps %xmm0,%xmm2
jmp 11a6 <func0+0x3d>
add $0x1,%r8
add $0x4,%rcx
cmp %r9,%r8
je 11e7 <func0+0x7e>
mov %r8,%rax
jmp 11ae <func0+0x45>
movss (%rdx),%xmm0
movss 0x4(%rdx),%xmm1
comiss %xmm1,%xmm0
jbe 11fe <func0+0x95>
movss %xmm1,(%rdx)
movss %xmm0,0x4(%rdx)
retq
|
func0:
endbr64
mov rcx, rdx
movss xmm0, dword ptr [rdi]
movss dword ptr [rdx], xmm0
movss xmm0, dword ptr [rdi+4]
movss dword ptr [rdx+4], xmm0
test esi, esi
jle loc_120C
lea rdx, [rdi+4]
lea r11d, [rsi-1]
mov r10d, esi
movsxd r9, esi
mov r8d, 1
movss xmm2, cs:dword_2004
add rdi, 8
movss xmm3, cs:dword_20E0
jmp short loc_11F3
loc_11B4:
add rax, 4
cmp rax, rsi
jz short loc_11E3
loc_11BD:
movss xmm1, dword ptr [rdx-4]
movaps xmm0, xmm1
subss xmm0, dword ptr [rax]
andps xmm0, xmm3
comiss xmm2, xmm0
jbe short loc_11B4
movss dword ptr [rcx], xmm1
movss xmm1, dword ptr [rax]
movss dword ptr [rcx+4], xmm1
movaps xmm2, xmm0
jmp short loc_11B4
loc_11E3:
lea rax, [r8+1]
add rdx, 4
cmp r8, r9
jz short loc_120C
mov r8, rax
loc_11F3:
cmp r8, r10
jz short loc_120C
mov eax, r11d
sub eax, r8d
lea rax, [r8+rax-1]
lea rsi, [rdi+rax*4]
mov rax, rdx
jmp short loc_11BD
loc_120C:
movss xmm0, dword ptr [rcx]
movss xmm1, dword ptr [rcx+4]
comiss xmm0, xmm1
jbe short locret_1223
movss dword ptr [rcx], xmm1
movss dword ptr [rcx+4], xmm0
locret_1223:
retn
|
void func0(_DWORD *a1, int a2, float *a3)
{
float *v4; // rdx
long long v5; // r8
float v6; // xmm2_4
_DWORD *v7; // rdi
float *v8; // rax
float v9; // xmm0_4
float v10; // xmm0_4
float v11; // xmm1_4
*a3 = *(float *)a1;
a3[1] = *((float *)a1 + 1);
if ( a2 > 0 )
{
v4 = (float *)(a1 + 1);
v5 = 1LL;
v6 = 3.4028235e38;
v7 = a1 + 2;
while ( v5 != a2 )
{
v8 = v4;
do
{
v9 = fabs(*(v4 - 1) - *v8);
if ( v6 > v9 )
{
*a3 = *(v4 - 1);
a3[1] = *v8;
v6 = v9;
}
++v8;
}
while ( v8 != (float *)&v7[v5 - 1 + (unsigned int)(a2 - 1 - v5)] );
++v4;
if ( v5 == a2 )
break;
++v5;
}
}
v10 = *a3;
v11 = a3[1];
if ( *a3 > v11 )
{
*a3 = v11;
a3[1] = v10;
}
}
|
func0:
ENDBR64
MOV RCX,RDX
MOVSS XMM0,dword ptr [RDI]
MOVSS dword ptr [RDX],XMM0
MOVSS XMM0,dword ptr [RDI + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM0
TEST ESI,ESI
JLE 0x0010120c
LEA RDX,[RDI + 0x4]
LEA R11D,[RSI + -0x1]
MOV R10D,ESI
MOVSXD R9,ESI
MOV R8D,0x1
MOVSS XMM2,dword ptr [0x00102004]
ADD RDI,0x8
MOVSS XMM3,dword ptr [0x001020e0]
JMP 0x001011f3
LAB_001011b4:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x001011e3
LAB_001011bd:
MOVSS XMM1,dword ptr [RDX + -0x4]
MOVAPS XMM0,XMM1
SUBSS XMM0,dword ptr [RAX]
ANDPS XMM0,XMM3
COMISS XMM2,XMM0
JBE 0x001011b4
MOVSS dword ptr [RCX],XMM1
MOVSS XMM1,dword ptr [RAX]
MOVSS dword ptr [RCX + 0x4],XMM1
MOVAPS XMM2,XMM0
JMP 0x001011b4
LAB_001011e3:
LEA RAX,[R8 + 0x1]
ADD RDX,0x4
CMP R8,R9
JZ 0x0010120c
MOV R8,RAX
LAB_001011f3:
CMP R8,R10
JZ 0x0010120c
MOV EAX,R11D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RSI,[RDI + RAX*0x4]
MOV RAX,RDX
JMP 0x001011bd
LAB_0010120c:
MOVSS XMM0,dword ptr [RCX]
MOVSS XMM1,dword ptr [RCX + 0x4]
COMISS XMM0,XMM1
JBE 0x00101223
MOVSS dword ptr [RCX],XMM1
MOVSS dword ptr [RCX + 0x4],XMM0
LAB_00101223:
RET
|
void func0(float *param_1,uint param_2,float *param_3)
{
uint uVar1;
float *pfVar2;
float *pfVar3;
ulong uVar4;
bool bVar5;
float fVar6;
float fVar7;
*param_3 = *param_1;
param_3[1] = param_1[1];
uVar1 = DAT_001020e0;
if (0 < (int)param_2) {
pfVar3 = param_1 + 1;
uVar4 = 1;
fVar7 = DAT_00102004;
do {
if (uVar4 == param_2) break;
pfVar2 = pfVar3;
do {
fVar6 = (float)((uint)(pfVar3[-1] - *pfVar2) & uVar1);
if (fVar6 < fVar7) {
*param_3 = pfVar3[-1];
param_3[1] = *pfVar2;
fVar7 = fVar6;
}
pfVar2 = pfVar2 + 1;
} while (pfVar2 != param_1 + uVar4 + ((param_2 - 1) - (int)uVar4) + 1);
pfVar3 = pfVar3 + 1;
bVar5 = uVar4 != (long)(int)param_2;
uVar4 = uVar4 + 1;
} while (bVar5);
}
fVar7 = *param_3;
if (param_3[1] < fVar7) {
*param_3 = param_3[1];
param_3[1] = fVar7;
}
return;
}
|
738 |
func0
|
#include <stdio.h>
#include <math.h>
#include <float.h>
|
void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
min_diff = diff;
out[0] = numbers[i];
out[1] = numbers[j];
}
}
}
if (out[0] > out[1]) {
float temp = out[0];
out[0] = out[1];
out[1] = temp;
}
}
|
#include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
float expected1[] = {3.9, 4.0};
func0(test1, 6, result);
assert(issame(result, expected1, 2));
float test2[] = {1.0, 2.0, 5.9, 4.0, 5.0};
float expected2[] = {5.0, 5.9};
func0(test2, 5, result);
assert(issame(result, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.2};
float expected3[] = {2.0, 2.2};
func0(test3, 6, result);
assert(issame(result, expected3, 2));
float test4[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.0};
float expected4[] = {2.0, 2.0};
func0(test4, 6, result);
assert(issame(result, expected4, 2));
float test5[] = {1.1, 2.2, 3.1, 4.1, 5.1};
float expected5[] = {2.2, 3.1};
func0(test5, 5, result);
assert(issame(result, expected5, 2));
return 0;
}
|
O2
|
c
|
func0:
endbr64
movss (%rdi),%xmm0
movss %xmm0,(%rdx)
movss 0x4(%rdi),%xmm1
movss %xmm1,0x4(%rdx)
test %esi,%esi
jle 150b <func0+0x8b>
lea -0x1(%rsi),%r9d
mov $0x1,%r8d
mov %rdi,%rcx
movss 0xc31(%rip),%xmm2
add $0x1,%r9
movss 0xc55(%rip),%xmm3
cmp %r8,%r9
je 1502 <func0+0x82>
mov %r8,%rax
nopl 0x0(%rax,%rax,1)
movss (%rcx),%xmm1
movaps %xmm1,%xmm0
subss (%rdi,%rax,4),%xmm0
andps %xmm3,%xmm0
comiss %xmm0,%xmm2
jbe 14ed <func0+0x6d>
movss %xmm1,(%rdx)
movss (%rdi,%rax,4),%xmm1
movaps %xmm0,%xmm2
movss %xmm1,0x4(%rdx)
add $0x1,%rax
cmp %eax,%esi
jg 14c8 <func0+0x48>
add $0x1,%r8
add $0x4,%rcx
cmp %r8,%r9
jne 14c0 <func0+0x40>
movss (%rdx),%xmm0
movss 0x4(%rdx),%xmm1
comiss %xmm1,%xmm0
jbe 1519 <func0+0x99>
movss %xmm1,(%rdx)
movss %xmm0,0x4(%rdx)
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
movss xmm0, dword ptr [rdi]
movss dword ptr [rdx], xmm0
movss xmm1, dword ptr [rdi+4]
movss dword ptr [rdx+4], xmm1
test esi, esi
jle short loc_146B
cmp esi, 1
jz short loc_1462
movss xmm2, cs:dword_2004
mov rcx, rdi
mov r9d, esi
mov r8d, 1
movss xmm3, cs:dword_20D0
nop dword ptr [rax+rax+00h]
loc_1420:
mov rax, r8
nop dword ptr [rax+rax+00h]
loc_1428:
movss xmm1, dword ptr [rcx]
movaps xmm0, xmm1
subss xmm0, dword ptr [rdi+rax*4]
andps xmm0, xmm3
comiss xmm2, xmm0
jbe short loc_144D
movss dword ptr [rdx], xmm1
movss xmm1, dword ptr [rdi+rax*4]
movaps xmm2, xmm0
movss dword ptr [rdx+4], xmm1
loc_144D:
add rax, 1
cmp esi, eax
jg short loc_1428
add r8, 1
add rcx, 4
cmp r8, r9
jnz short loc_1420
loc_1462:
movss xmm0, dword ptr [rdx]
movss xmm1, dword ptr [rdx+4]
loc_146B:
comiss xmm0, xmm1
jbe short locret_1479
movss dword ptr [rdx], xmm1
movss dword ptr [rdx+4], xmm0
locret_1479:
retn
|
void func0(float *a1, int a2, float *a3)
{
float v3; // xmm0_4
float v4; // xmm1_4
float v5; // xmm2_4
float *v6; // rcx
long long i; // r8
long long v8; // rax
float v9; // xmm0_4
v3 = *a1;
*a3 = *a1;
v4 = a1[1];
a3[1] = v4;
if ( a2 > 0 )
{
if ( a2 != 1 )
{
v5 = 3.4028235e38;
v6 = a1;
for ( i = 1LL; i != a2; ++i )
{
v8 = i;
do
{
v9 = fabs(*v6 - a1[v8]);
if ( v5 > v9 )
{
*a3 = *v6;
v5 = v9;
a3[1] = a1[v8];
}
++v8;
}
while ( a2 > (int)v8 );
++v6;
}
}
v3 = *a3;
v4 = a3[1];
}
if ( v3 > v4 )
{
*a3 = v4;
a3[1] = v3;
}
}
|
func0:
ENDBR64
MOVSS XMM0,dword ptr [RDI]
MOVSS dword ptr [RDX],XMM0
MOVSS XMM1,dword ptr [RDI + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM1
TEST ESI,ESI
JLE 0x0010146b
CMP ESI,0x1
JZ 0x00101462
MOVSS XMM2,dword ptr [0x00102004]
MOV RCX,RDI
MOV R9D,ESI
MOV R8D,0x1
MOVSS XMM3,dword ptr [0x001020d0]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101420:
MOV RAX,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_00101428:
MOVSS XMM1,dword ptr [RCX]
MOVAPS XMM0,XMM1
SUBSS XMM0,dword ptr [RDI + RAX*0x4]
ANDPS XMM0,XMM3
COMISS XMM2,XMM0
JBE 0x0010144d
MOVSS dword ptr [RDX],XMM1
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
MOVAPS XMM2,XMM0
MOVSS dword ptr [RDX + 0x4],XMM1
LAB_0010144d:
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101428
ADD R8,0x1
ADD RCX,0x4
CMP R8,R9
JNZ 0x00101420
LAB_00101462:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDX + 0x4]
LAB_0010146b:
COMISS XMM0,XMM1
JBE 0x00101479
MOVSS dword ptr [RDX],XMM1
MOVSS dword ptr [RDX + 0x4],XMM0
LAB_00101479:
RET
|
void func0(float *param_1,uint param_2,float *param_3)
{
uint uVar1;
float *pfVar2;
ulong uVar3;
ulong uVar4;
float fVar5;
float fVar6;
fVar6 = *param_1;
*param_3 = fVar6;
fVar5 = param_1[1];
param_3[1] = fVar5;
uVar1 = DAT_001020d0;
if (0 < (int)param_2) {
if (param_2 != 1) {
uVar3 = 1;
fVar6 = DAT_00102004;
uVar4 = uVar3;
pfVar2 = param_1;
do {
do {
fVar5 = (float)((uint)(*pfVar2 - param_1[uVar3]) & uVar1);
if (fVar5 < fVar6) {
*param_3 = *pfVar2;
param_3[1] = param_1[uVar3];
fVar6 = fVar5;
}
uVar3 = uVar3 + 1;
} while ((int)uVar3 < (int)param_2);
uVar3 = uVar4 + 1;
pfVar2 = pfVar2 + 1;
uVar4 = uVar3;
} while (uVar3 != param_2);
}
fVar6 = *param_3;
fVar5 = param_3[1];
}
if (fVar5 < fVar6) {
*param_3 = fVar5;
param_3[1] = fVar6;
}
return;
}
|
739 |
func0
|
#include <stdio.h>
#include <math.h>
#include <float.h>
|
void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
min_diff = diff;
out[0] = numbers[i];
out[1] = numbers[j];
}
}
}
if (out[0] > out[1]) {
float temp = out[0];
out[0] = out[1];
out[1] = temp;
}
}
|
#include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
float expected1[] = {3.9, 4.0};
func0(test1, 6, result);
assert(issame(result, expected1, 2));
float test2[] = {1.0, 2.0, 5.9, 4.0, 5.0};
float expected2[] = {5.0, 5.9};
func0(test2, 5, result);
assert(issame(result, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.2};
float expected3[] = {2.0, 2.2};
func0(test3, 6, result);
assert(issame(result, expected3, 2));
float test4[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.0};
float expected4[] = {2.0, 2.0};
func0(test4, 6, result);
assert(issame(result, expected4, 2));
float test5[] = {1.1, 2.2, 3.1, 4.1, 5.1};
float expected5[] = {2.2, 3.1};
func0(test5, 5, result);
assert(issame(result, expected5, 2));
return 0;
}
|
O3
|
c
|
func0:
endbr64
movss (%rdi),%xmm0
movss %xmm0,(%rdx)
movss 0x4(%rdi),%xmm1
movss %xmm1,0x4(%rdx)
test %esi,%esi
jle 14cb <func0+0x8b>
cmp $0x1,%esi
je 14c2 <func0+0x82>
lea -0x2(%rsi),%r9d
mov %rdi,%rcx
movss 0xc72(%rip),%xmm2
mov $0x1,%r8d
add $0x2,%r9
movss 0xc90(%rip),%xmm3
mov %r8,%rax
nopl 0x0(%rax,%rax,1)
movss (%rcx),%xmm1
movaps %xmm1,%xmm0
subss (%rdi,%rax,4),%xmm0
andps %xmm3,%xmm0
comiss %xmm0,%xmm2
jbe 14ad <func0+0x6d>
movss %xmm1,(%rdx)
movss (%rdi,%rax,4),%xmm1
movaps %xmm0,%xmm2
movss %xmm1,0x4(%rdx)
add $0x1,%rax
cmp %eax,%esi
jg 1488 <func0+0x48>
add $0x1,%r8
add $0x4,%rcx
cmp %r8,%r9
jne 1480 <func0+0x40>
movss (%rdx),%xmm0
movss 0x4(%rdx),%xmm1
comiss %xmm1,%xmm0
jbe 14d9 <func0+0x99>
movss %xmm1,(%rdx)
movss %xmm0,0x4(%rdx)
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
movss xmm0, dword ptr [rdi]
movss dword ptr [rdx], xmm0
movss xmm1, dword ptr [rdi+4]
movss dword ptr [rdx+4], xmm1
test esi, esi
jle short loc_14CB
cmp esi, 1
jz short loc_14C2
movss xmm2, cs:dword_2004
mov rcx, rdi
mov r9d, esi
mov r8d, 1
movss xmm3, cs:dword_20D0
nop dword ptr [rax+rax+00h]
loc_1480:
mov rax, r8
nop dword ptr [rax+rax+00h]
loc_1488:
movss xmm1, dword ptr [rcx]
movaps xmm0, xmm1
subss xmm0, dword ptr [rdi+rax*4]
andps xmm0, xmm3
comiss xmm2, xmm0
jbe short loc_14AD
movss dword ptr [rdx], xmm1
movss xmm1, dword ptr [rdi+rax*4]
movaps xmm2, xmm0
movss dword ptr [rdx+4], xmm1
loc_14AD:
add rax, 1
cmp esi, eax
jg short loc_1488
add r8, 1
add rcx, 4
cmp r9, r8
jnz short loc_1480
loc_14C2:
movss xmm0, dword ptr [rdx]
movss xmm1, dword ptr [rdx+4]
loc_14CB:
comiss xmm0, xmm1
jbe short locret_14D9
movss dword ptr [rdx], xmm1
movss dword ptr [rdx+4], xmm0
locret_14D9:
retn
|
void func0(float *a1, int a2, float *a3)
{
float v3; // xmm0_4
float v4; // xmm1_4
float v5; // xmm2_4
float *v6; // rcx
long long i; // r8
long long v8; // rax
float v9; // xmm0_4
v3 = *a1;
*a3 = *a1;
v4 = a1[1];
a3[1] = v4;
if ( a2 > 0 )
{
if ( a2 != 1 )
{
v5 = 3.4028235e38;
v6 = a1;
for ( i = 1LL; i != a2; ++i )
{
v8 = i;
do
{
v9 = fabs(*v6 - a1[v8]);
if ( v5 > v9 )
{
*a3 = *v6;
v5 = v9;
a3[1] = a1[v8];
}
++v8;
}
while ( a2 > (int)v8 );
++v6;
}
}
v3 = *a3;
v4 = a3[1];
}
if ( v3 > v4 )
{
*a3 = v4;
a3[1] = v3;
}
}
|
func0:
ENDBR64
MOVSS XMM0,dword ptr [RDI]
MOVSS dword ptr [RDX],XMM0
MOVSS XMM1,dword ptr [RDI + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM1
TEST ESI,ESI
JLE 0x001014cb
CMP ESI,0x1
JZ 0x001014c2
MOVSS XMM2,dword ptr [0x00102004]
MOV RCX,RDI
MOV R9D,ESI
MOV R8D,0x1
MOVSS XMM3,dword ptr [0x001020d0]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101480:
MOV RAX,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_00101488:
MOVSS XMM1,dword ptr [RCX]
MOVAPS XMM0,XMM1
SUBSS XMM0,dword ptr [RDI + RAX*0x4]
ANDPS XMM0,XMM3
COMISS XMM2,XMM0
JBE 0x001014ad
MOVSS dword ptr [RDX],XMM1
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
MOVAPS XMM2,XMM0
MOVSS dword ptr [RDX + 0x4],XMM1
LAB_001014ad:
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101488
ADD R8,0x1
ADD RCX,0x4
CMP R9,R8
JNZ 0x00101480
LAB_001014c2:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDX + 0x4]
LAB_001014cb:
COMISS XMM0,XMM1
JBE 0x001014d9
MOVSS dword ptr [RDX],XMM1
MOVSS dword ptr [RDX + 0x4],XMM0
LAB_001014d9:
RET
|
void func0(float *param_1,uint param_2,float *param_3)
{
uint uVar1;
float *pfVar2;
ulong uVar3;
ulong uVar4;
float fVar5;
float fVar6;
fVar6 = *param_1;
*param_3 = fVar6;
fVar5 = param_1[1];
param_3[1] = fVar5;
uVar1 = DAT_001020d0;
if (0 < (int)param_2) {
if (param_2 != 1) {
uVar3 = 1;
fVar6 = DAT_00102004;
uVar4 = uVar3;
pfVar2 = param_1;
do {
do {
fVar5 = (float)((uint)(*pfVar2 - param_1[uVar3]) & uVar1);
if (fVar5 < fVar6) {
*param_3 = *pfVar2;
param_3[1] = param_1[uVar3];
fVar6 = fVar5;
}
uVar3 = uVar3 + 1;
} while ((int)uVar3 < (int)param_2);
uVar3 = uVar4 + 1;
pfVar2 = pfVar2 + 1;
uVar4 = uVar3;
} while (param_2 != uVar3);
}
fVar6 = *param_3;
fVar5 = param_3[1];
}
if (fVar5 < fVar6) {
*param_3 = fVar5;
param_3[1] = fVar6;
}
return;
}
|
740 |
func0
|
#include <stdio.h>
#include <math.h>
|
void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
}
}
|
#include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert(issame(test1, expected1, 2));
float test2[] = {100.0, 49.9};
float expected2[] = {1.0, 0.0};
func0(test2, 2);
assert(issame(test2, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
float expected3[] = {0.0, 0.25, 0.5, 0.75, 1.0};
func0(test3, 5);
assert(issame(test3, expected3, 5));
float test4[] = {2.0, 1.0, 5.0, 3.0, 4.0};
float expected4[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test4, 5);
assert(issame(test4, expected4, 5));
float test5[] = {12.0, 11.0, 15.0, 13.0, 14.0};
float expected5[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test5, 5);
assert(issame(test5, expected5, 5));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
movss (%rax),%xmm0
movss %xmm0,-0x10(%rbp)
mov -0x18(%rbp),%rax
movss (%rax),%xmm0
movss %xmm0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1219 <func0+0xb0>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm1
movss -0x10(%rbp),%xmm0
comiss %xmm1,%xmm0
jbe 11da <func0+0x71>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
movss %xmm0,-0x10(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
comiss -0xc(%rbp),%xmm0
jbe 1215 <func0+0xac>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
movss %xmm0,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119b <func0+0x32>
movl $0x0,-0x4(%rbp)
jmp 1275 <func0+0x10c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
subss -0x10(%rbp),%xmm0
movss -0xc(%rbp),%xmm1
subss -0x10(%rbp),%xmm1
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
divss %xmm1,%xmm0
movss %xmm0,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 122e <func0+0xc5>
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
movss [rbp+var_10], xmm0
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
movss [rbp+var_C], xmm0
mov [rbp+var_8], 1
jmp short loc_1219
loc_119B:
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]
movss xmm0, [rbp+var_10]
comiss xmm0, xmm1
jbe short loc_11DA
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
movss [rbp+var_10], xmm0
loc_11DA:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
comiss xmm0, [rbp+var_C]
jbe short loc_1215
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
movss [rbp+var_C], xmm0
loc_1215:
add [rbp+var_8], 1
loc_1219:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_119B
mov [rbp+var_4], 0
jmp short loc_1275
loc_122E:
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]
subss xmm0, [rbp+var_10]
movss xmm1, [rbp+var_C]
subss xmm1, [rbp+var_10]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
divss xmm0, xmm1
movss dword ptr [rax], xmm0
add [rbp+var_4], 1
loc_1275:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_122E
nop
nop
pop rbp
retn
|
long long func0(float *a1, int a2)
{
long long result; // rax
float v3; // [rsp+Ch] [rbp-10h]
float v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = *a1;
v4 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v3 > a1[i] )
v3 = a1[i];
if ( a1[i] > v4 )
v4 = a1[i];
}
for ( j = 0; ; ++j )
{
result = (unsigned int)j;
if ( j >= a2 )
break;
a1[j] = (float)(a1[j] - v3) / (float)(v4 - v3);
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x10],XMM0
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0xc],XMM0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101219
LAB_0010119b:
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]
MOVSS XMM0,dword ptr [RBP + -0x10]
COMISS XMM0,XMM1
JBE 0x001011da
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x10],XMM0
LAB_001011da:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
COMISS XMM0,dword ptr [RBP + -0xc]
JBE 0x00101215
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0xc],XMM0
LAB_00101215:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101219:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119b
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101275
LAB_0010122e:
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]
SUBSS XMM0,dword ptr [RBP + -0x10]
MOVSS XMM1,dword ptr [RBP + -0xc]
SUBSS XMM1,dword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
DIVSS XMM0,XMM1
MOVSS dword ptr [RAX],XMM0
ADD dword ptr [RBP + -0x4],0x1
LAB_00101275:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010122e
NOP
NOP
POP RBP
RET
|
void func0(float *param_1,int param_2)
{
float local_18;
float local_14;
int local_10;
int local_c;
local_18 = *param_1;
local_14 = *param_1;
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
if (param_1[local_10] < local_18) {
local_18 = param_1[local_10];
}
if (local_14 < param_1[local_10]) {
local_14 = param_1[local_10];
}
}
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
param_1[local_c] = (param_1[local_c] - local_18) / (local_14 - local_18);
}
return;
}
|
741 |
func0
|
#include <stdio.h>
#include <math.h>
|
void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
}
}
|
#include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert(issame(test1, expected1, 2));
float test2[] = {100.0, 49.9};
float expected2[] = {1.0, 0.0};
func0(test2, 2);
assert(issame(test2, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
float expected3[] = {0.0, 0.25, 0.5, 0.75, 1.0};
func0(test3, 5);
assert(issame(test3, expected3, 5));
float test4[] = {2.0, 1.0, 5.0, 3.0, 4.0};
float expected4[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test4, 5);
assert(issame(test4, expected4, 5));
float test5[] = {12.0, 11.0, 15.0, 13.0, 14.0};
float expected5[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test5, 5);
assert(issame(test5, expected5, 5));
return 0;
}
|
O1
|
c
|
func0:
endbr64
movss (%rdi),%xmm1
cmp $0x1,%esi
jle 11c7 <func0+0x5e>
lea 0x4(%rdi),%rax
lea -0x2(%rsi),%edx
lea 0x8(%rdi,%rdx,4),%rdx
movaps %xmm1,%xmm0
movss (%rax),%xmm2
movaps %xmm2,%xmm3
minss %xmm1,%xmm3
movaps %xmm3,%xmm1
maxss %xmm0,%xmm2
movaps %xmm2,%xmm0
add $0x4,%rax
cmp %rdx,%rax
jne 1185 <func0+0x1c>
mov $0x0,%eax
subss %xmm3,%xmm2
movss (%rdi,%rax,4),%xmm0
subss %xmm1,%xmm0
divss %xmm2,%xmm0
movss %xmm0,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 11ac <func0+0x43>
retq
je 11ca <func0+0x61>
retq
movss (%rdi),%xmm0
subss %xmm1,%xmm0
subss %xmm1,%xmm1
divss %xmm1,%xmm0
movss %xmm0,(%rdi)
jmp 11c9 <func0+0x60>
|
func0:
endbr64
movss xmm1, dword ptr [rdi]
cmp esi, 1
jle short loc_11CE
lea rax, [rdi+4]
lea edx, [rsi-2]
lea rdx, [rdi+rdx*4+8]
movaps xmm0, xmm1
loc_1185:
movss xmm2, dword ptr [rax]
movaps xmm3, xmm2
minss xmm3, xmm1
movaps xmm1, xmm3
maxss xmm2, xmm0
movaps xmm0, xmm2
add rax, 4
cmp rax, rdx
jnz short loc_1185
loc_11A3:
mov rax, rdi
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
movaps xmm2, xmm0
subss xmm2, xmm1
loc_11B4:
movss xmm0, dword ptr [rax]
subss xmm0, xmm1
divss xmm0, xmm2
movss dword ptr [rax], xmm0
add rax, 4
cmp rax, rdx
jnz short loc_11B4
locret_11CD:
retn
loc_11CE:
test esi, esi
jle short locret_11CD
movaps xmm0, xmm1
jmp short loc_11A3
|
void func0(float *a1, int a2)
{
float v2; // xmm1_4
float *v3; // rax
float v4; // xmm0_4
float *v5; // rax
v2 = *a1;
if ( a2 <= 1 )
{
if ( a2 <= 0 )
return;
v4 = *a1;
}
else
{
v3 = a1 + 1;
v4 = *a1;
do
{
v2 = fminf(*v3, v2);
v4 = fmaxf(*v3++, v4);
}
while ( v3 != &a1[a2 - 2 + 2] );
}
v5 = a1;
do
{
*v5 = (float)(*v5 - v2) / (float)(v4 - v2);
++v5;
}
while ( v5 != &a1[a2] );
}
|
func0:
ENDBR64
MOVSS XMM1,dword ptr [RDI]
CMP ESI,0x1
JLE 0x001011ce
LEA RAX,[RDI + 0x4]
LEA EDX,[RSI + -0x2]
LEA RDX,[RDI + RDX*0x4 + 0x8]
MOVAPS XMM0,XMM1
LAB_00101185:
MOVSS XMM2,dword ptr [RAX]
MOVAPS XMM3,XMM2
MINSS XMM3,XMM1
MOVAPS XMM1,XMM3
MAXSS XMM2,XMM0
MOVAPS XMM0,XMM2
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101185
LAB_001011a3:
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
MOVAPS XMM2,XMM0
SUBSS XMM2,XMM1
LAB_001011b4:
MOVSS XMM0,dword ptr [RAX]
SUBSS XMM0,XMM1
DIVSS XMM0,XMM2
MOVSS dword ptr [RAX],XMM0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011b4
LAB_001011cd:
RET
LAB_001011ce:
TEST ESI,ESI
JLE 0x001011cd
MOVAPS XMM0,XMM1
JMP 0x001011a3
|
void func0(float *param_1,int param_2)
{
float fVar1;
float fVar2;
float *pfVar3;
float fVar4;
float fVar5;
fVar4 = *param_1;
fVar5 = fVar4;
if (param_2 < 2) {
if (param_2 < 1) {
return;
}
}
else {
pfVar3 = param_1 + 1;
do {
fVar1 = *pfVar3;
fVar2 = fVar1;
if (fVar5 <= fVar1) {
fVar2 = fVar5;
}
fVar5 = fVar2;
if (fVar1 <= fVar4) {
fVar1 = fVar4;
}
fVar4 = fVar1;
pfVar3 = pfVar3 + 1;
} while (pfVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
pfVar3 = param_1 + param_2;
do {
*param_1 = (*param_1 - fVar5) / (fVar4 - fVar5);
param_1 = param_1 + 1;
} while (param_1 != pfVar3);
return;
}
|
742 |
func0
|
#include <stdio.h>
#include <math.h>
|
void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
}
}
|
#include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert(issame(test1, expected1, 2));
float test2[] = {100.0, 49.9};
float expected2[] = {1.0, 0.0};
func0(test2, 2);
assert(issame(test2, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
float expected3[] = {0.0, 0.25, 0.5, 0.75, 1.0};
func0(test3, 5);
assert(issame(test3, expected3, 5));
float test4[] = {2.0, 1.0, 5.0, 3.0, 4.0};
float expected4[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test4, 5);
assert(issame(test4, expected4, 5));
float test5[] = {12.0, 11.0, 15.0, 13.0, 14.0};
float expected5[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test5, 5);
assert(issame(test5, expected5, 5));
return 0;
}
|
O2
|
c
|
func0:
endbr64
movss (%rdi),%xmm0
cmp $0x1,%esi
jle 1540 <func0+0x70>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
movaps %xmm0,%xmm1
lea 0x8(%rdi,%rdx,4),%rdx
movaps %xmm0,%xmm2
movss (%rax),%xmm3
add $0x4,%rax
movaps %xmm3,%xmm4
maxss %xmm1,%xmm3
minss %xmm2,%xmm4
movaps %xmm3,%xmm1
movaps %xmm4,%xmm2
cmp %rdx,%rax
jne 14f0 <func0+0x20>
subss %xmm2,%xmm1
xor %eax,%eax
jmp 1525 <func0+0x55>
nopw %cs:0x0(%rax,%rax,1)
movss (%rdi,%rax,4),%xmm0
subss %xmm2,%xmm0
divss %xmm1,%xmm0
movss %xmm0,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 1520 <func0+0x50>
retq
nopl 0x0(%rax,%rax,1)
jne 153a <func0+0x6a>
movaps %xmm0,%xmm1
movaps %xmm0,%xmm2
jmp 150e <func0+0x3e>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
movss xmm1, dword ptr [rdi]
cmp esi, 1
jle short loc_1450
lea edx, [rsi-2]
lea rax, [rdi+4]
movaps xmm0, xmm1
lea rdx, [rdi+rdx*4+8]
nop dword ptr [rax+00h]
loc_1400:
movss xmm2, dword ptr [rax]
add rax, 4
movaps xmm3, xmm2
maxss xmm2, xmm0
minss xmm3, xmm1
movaps xmm0, xmm2
movaps xmm1, xmm3
cmp rax, rdx
jnz short loc_1400
loc_141E:
movaps xmm2, xmm0
movsxd rsi, esi
subss xmm2, xmm1
lea rax, [rdi+rsi*4]
nop dword ptr [rax+00h]
loc_1430:
movss xmm0, dword ptr [rdi]
add rdi, 4
subss xmm0, xmm1
divss xmm0, xmm2
movss dword ptr [rdi-4], xmm0
cmp rax, rdi
jnz short loc_1430
locret_144A:
retn
loc_1450:
jnz short locret_144A
movaps xmm0, xmm1
jmp short loc_141E
|
void func0(float *a1, int a2)
{
float v2; // xmm1_4
float *v3; // rax
float v4; // xmm0_4
float v5; // xmm2_4
float v6; // xmm2_4
float *v7; // rax
float v8; // xmm0_4
v2 = *a1;
if ( a2 <= 1 )
{
if ( a2 != 1 )
return;
v4 = *a1;
}
else
{
v3 = a1 + 1;
v4 = *a1;
do
{
v5 = *v3++;
v4 = fmaxf(v5, v4);
v2 = fminf(v5, v2);
}
while ( v3 != &a1[a2 - 2 + 2] );
}
v6 = v4 - v2;
v7 = &a1[a2];
do
{
v8 = *a1++;
*(a1 - 1) = (float)(v8 - v2) / v6;
}
while ( v7 != a1 );
}
|
func0:
ENDBR64
MOVSS XMM1,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101450
LEA EDX,[RSI + -0x2]
LEA RAX,[RDI + 0x4]
MOVAPS XMM0,XMM1
LEA RDX,[RDI + RDX*0x4 + 0x8]
NOP dword ptr [RAX]
LAB_00101400:
MOVSS XMM2,dword ptr [RAX]
ADD RAX,0x4
MOVAPS XMM3,XMM2
MAXSS XMM2,XMM0
MINSS XMM3,XMM1
MOVAPS XMM0,XMM2
MOVAPS XMM1,XMM3
CMP RAX,RDX
JNZ 0x00101400
LAB_0010141e:
MOVAPS XMM2,XMM0
MOVSXD RSI,ESI
SUBSS XMM2,XMM1
LEA RAX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101430:
MOVSS XMM0,dword ptr [RDI]
ADD RDI,0x4
SUBSS XMM0,XMM1
DIVSS XMM0,XMM2
MOVSS dword ptr [RDI + -0x4],XMM0
CMP RAX,RDI
JNZ 0x00101430
LAB_0010144a:
RET
LAB_00101450:
JNZ 0x0010144a
MOVAPS XMM0,XMM1
JMP 0x0010141e
|
void func0(float *param_1,int param_2)
{
float fVar1;
float fVar2;
float *pfVar3;
float *pfVar4;
float fVar5;
float fVar6;
fVar5 = *param_1;
fVar6 = fVar5;
if (param_2 < 2) {
if (param_2 != 1) {
return;
}
}
else {
pfVar3 = param_1 + 1;
do {
fVar1 = *pfVar3;
pfVar3 = pfVar3 + 1;
fVar2 = fVar1;
if (fVar1 <= fVar5) {
fVar2 = fVar5;
}
fVar5 = fVar2;
if (fVar6 <= fVar1) {
fVar1 = fVar6;
}
fVar6 = fVar1;
} while (pfVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
pfVar3 = param_1;
do {
pfVar4 = pfVar3 + 1;
*pfVar3 = (*pfVar3 - fVar6) / (fVar5 - fVar6);
pfVar3 = pfVar4;
} while (param_1 + param_2 != pfVar4);
return;
}
|
743 |
func0
|
#include <stdio.h>
#include <math.h>
|
void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
}
}
|
#include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert(issame(test1, expected1, 2));
float test2[] = {100.0, 49.9};
float expected2[] = {1.0, 0.0};
func0(test2, 2);
assert(issame(test2, expected2, 2));
float test3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
float expected3[] = {0.0, 0.25, 0.5, 0.75, 1.0};
func0(test3, 5);
assert(issame(test3, expected3, 5));
float test4[] = {2.0, 1.0, 5.0, 3.0, 4.0};
float expected4[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test4, 5);
assert(issame(test4, expected4, 5));
float test5[] = {12.0, 11.0, 15.0, 13.0, 14.0};
float expected5[] = {0.25, 0.0, 1.0, 0.5, 0.75};
func0(test5, 5);
assert(issame(test5, expected5, 5));
return 0;
}
|
O3
|
c
|
func0:
endbr64
movss (%rdi),%xmm1
cmp $0x1,%esi
jle 1650 <func0+0xf0>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
movaps %xmm1,%xmm2
lea 0x8(%rdi,%rdx,4),%rdx
movss (%rax),%xmm0
add $0x4,%rax
movaps %xmm0,%xmm5
maxss %xmm2,%xmm0
minss %xmm1,%xmm5
movaps %xmm0,%xmm2
movaps %xmm5,%xmm1
cmp %rdx,%rax
jne 1580 <func0+0x20>
test %esi,%esi
mov $0x1,%ecx
subss %xmm5,%xmm2
cmovg %esi,%ecx
cmp $0x3,%esi
jle 1653 <func0+0xf3>
mov %ecx,%edx
movaps %xmm5,%xmm4
mov %rdi,%rax
shr $0x2,%edx
movaps %xmm2,%xmm3
shufps $0x0,%xmm4,%xmm4
shl $0x4,%rdx
shufps $0x0,%xmm3,%xmm3
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movups (%rax),%xmm0
add $0x10,%rax
subps %xmm4,%xmm0
divps %xmm3,%xmm0
movups %xmm0,-0x10(%rax)
cmp %rdx,%rax
jne 15d8 <func0+0x78>
mov %ecx,%eax
and $0xfffffffc,%eax
and $0x3,%ecx
je 1652 <func0+0xf2>
movslq %eax,%rdx
add $0x1,%eax
lea (%rdi,%rdx,4),%rdx
movss (%rdx),%xmm0
subss %xmm1,%xmm0
divss %xmm2,%xmm0
movss %xmm0,(%rdx)
cmp %eax,%esi
jle 1652 <func0+0xf2>
movslq %eax,%rdx
add $0x1,%eax
lea (%rdi,%rdx,4),%rdx
movss (%rdx),%xmm0
subss %xmm1,%xmm0
divss %xmm2,%xmm0
movss %xmm0,(%rdx)
cmp %esi,%eax
jge 1652 <func0+0xf2>
cltq
lea (%rdi,%rax,4),%rax
movss (%rax),%xmm0
subss %xmm1,%xmm0
divss %xmm2,%xmm0
movss %xmm0,(%rax)
retq
nopl 0x0(%rax,%rax,1)
je 166a <func0+0x10a>
retq
movss (%rdi),%xmm0
mov $0x1,%eax
subss %xmm5,%xmm0
divss %xmm2,%xmm0
movss %xmm0,(%rdi)
jmp 1616 <func0+0xb6>
subss %xmm1,%xmm1
divss %xmm1,%xmm1
movss %xmm1,(%rdi)
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
movss xmm1, dword ptr [rdi]
mov rcx, rdi
cmp esi, 1
jle loc_15D8
lea rax, [rdi+4]
mov rdx, rdi
lea edi, [rsi-2]
mov r8d, esi
lea rdi, [rcx+rdi*4+8]
movaps xmm0, xmm1
nop dword ptr [rax+00000000h]
loc_1510:
movss xmm2, dword ptr [rax]
add rax, 4
movaps xmm5, xmm2
maxss xmm2, xmm0
minss xmm5, xmm1
movaps xmm0, xmm2
movaps xmm1, xmm5
cmp rdi, rax
jnz short loc_1510
lea eax, [rsi-1]
subss xmm2, xmm5
cmp eax, 2
jbe loc_15E5
mov eax, esi
movaps xmm4, xmm5
movaps xmm3, xmm2
shr eax, 2
shufps xmm4, xmm4, 0
shufps xmm3, xmm3, 0
shl rax, 4
add rax, rcx
nop dword ptr [rax+rax+00000000h]
loc_1560:
movups xmm0, xmmword ptr [rdx]
add rdx, 10h
subps xmm0, xmm4
divps xmm0, xmm3
movups xmmword ptr [rdx-10h], xmm0
cmp rax, rdx
jnz short loc_1560
mov eax, esi
and eax, 0FFFFFFFCh
mov edx, eax
cmp eax, esi
jz short locret_15D4
sub esi, eax
mov r8d, esi
cmp esi, 1
jz short loc_15BE
loc_158B:
lea rdx, [rcx+rdx*4]
movaps xmm3, xmm1
movq xmm0, qword ptr [rdx]
shufps xmm3, xmm3, 0E0h
subps xmm0, xmm3
movaps xmm3, xmm2
shufps xmm3, xmm3, 0E0h
movhps xmm3, cs:qword_20C8
divps xmm0, xmm3
movlps qword ptr [rdx], xmm0
test r8b, 1
jz short locret_15D4
and r8d, 0FFFFFFFEh
add eax, r8d
loc_15BE:
cdqe
lea rax, [rcx+rax*4]
movss xmm0, dword ptr [rax]
subss xmm0, xmm1
divss xmm0, xmm2
movss dword ptr [rax], xmm0
locret_15D4:
retn
loc_15D8:
jnz short locret_15D4
movaps xmm2, xmm1
xor eax, eax
subss xmm2, xmm1
jmp short loc_15BE
loc_15E5:
xor edx, edx
xor eax, eax
jmp short loc_158B
|
void func0(float *a1, int a2)
{
float v2; // xmm1_4
unsigned int *v4; // rax
__m128 *v5; // rdx
int v6; // r8d
long long v7; // rdi
float v8; // xmm0_4
__m128 v9; // xmm2
__m128 v10; // xmm5
__m128 v11; // xmm4
__m128 v12; // xmm3
__m128 v13; // xmm0
signed int v14; // eax
long long v15; // rdx
v2 = *a1;
if ( a2 <= 1 )
{
if ( a2 == 1 )
{
v14 = 0;
v9.m128_f32[0] = v2 - v2;
goto LABEL_11;
}
}
else
{
v4 = (unsigned int *)(a1 + 1);
v5 = (__m128 *)a1;
v6 = a2;
v7 = (long long)&a1[a2 - 2 + 2];
v8 = v2;
do
{
v9 = (__m128)*v4++;
v10 = v9;
v9.m128_f32[0] = fmaxf(v9.m128_f32[0], v8);
v10.m128_f32[0] = fminf(v10.m128_f32[0], v2);
v8 = v9.m128_f32[0];
v2 = v10.m128_f32[0];
}
while ( (unsigned int *)v7 != v4 );
v9.m128_f32[0] = v9.m128_f32[0] - v10.m128_f32[0];
if ( (unsigned int)(a2 - 1) <= 2 )
{
v15 = 0LL;
v14 = 0;
goto LABEL_9;
}
v11 = _mm_shuffle_ps(v10, v10, 0);
v12 = _mm_shuffle_ps(v9, v9, 0);
do
{
v13 = *v5++;
v5[-1] = _mm_div_ps(_mm_sub_ps(v13, v11), v12);
}
while ( &a1[4 * ((unsigned int)a2 >> 2)] != (float *)v5 );
v14 = a2 & 0xFFFFFFFC;
v15 = a2 & 0xFFFFFFFC;
if ( (a2 & 0xFFFFFFFC) != a2 )
{
v6 = a2 - v14;
if ( a2 - v14 != 1 )
{
LABEL_9:
_mm_storel_ps(
(double *)&a1[v15],
_mm_div_ps(
_mm_sub_ps((__m128)_mm_loadl_epi64((const __m128i *)&a1[v15]), _mm_shuffle_ps(v10, v10, 224)),
_mm_loadh_ps((const double *)&qword_20C8)));
if ( (v6 & 1) == 0 )
return;
v14 += v6 & 0xFFFFFFFE;
}
LABEL_11:
a1[v14] = (float)(a1[v14] - v2) / v9.m128_f32[0];
}
}
}
|
func0:
ENDBR64
MOVSS XMM1,dword ptr [RDI]
MOV RCX,RDI
CMP ESI,0x1
JLE 0x001015d8
LEA RAX,[RDI + 0x4]
MOV RDX,RDI
LEA EDI,[RSI + -0x2]
MOV R8D,ESI
LEA RDI,[RCX + RDI*0x4 + 0x8]
MOVAPS XMM0,XMM1
NOP dword ptr [RAX]
LAB_00101510:
MOVSS XMM2,dword ptr [RAX]
ADD RAX,0x4
MOVAPS XMM5,XMM2
MAXSS XMM2,XMM0
MINSS XMM5,XMM1
MOVAPS XMM0,XMM2
MOVAPS XMM1,XMM5
CMP RDI,RAX
JNZ 0x00101510
LEA EAX,[RSI + -0x1]
SUBSS XMM2,XMM5
CMP EAX,0x2
JBE 0x001015e5
MOV EAX,ESI
MOVAPS XMM4,XMM5
MOVAPS XMM3,XMM2
SHR EAX,0x2
SHUFPS XMM4,XMM4,0x0
SHUFPS XMM3,XMM3,0x0
SHL RAX,0x4
ADD RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101560:
MOVUPS XMM0,xmmword ptr [RDX]
ADD RDX,0x10
SUBPS XMM0,XMM4
DIVPS XMM0,XMM3
MOVUPS xmmword ptr [RDX + -0x10],XMM0
CMP RAX,RDX
JNZ 0x00101560
MOV EAX,ESI
AND EAX,0xfffffffc
MOV EDX,EAX
CMP EAX,ESI
JZ 0x001015d4
SUB ESI,EAX
MOV R8D,ESI
CMP ESI,0x1
JZ 0x001015be
LAB_0010158b:
LEA RDX,[RCX + RDX*0x4]
MOVAPS XMM3,XMM1
MOVQ XMM0,qword ptr [RDX]
SHUFPS XMM3,XMM3,0xe0
SUBPS XMM0,XMM3
MOVAPS XMM3,XMM2
SHUFPS XMM3,XMM3,0xe0
MOVHPS XMM3,qword ptr [0x001020c8]
DIVPS XMM0,XMM3
MOVLPS qword ptr [RDX],XMM0
TEST R8B,0x1
JZ 0x001015d4
AND R8D,0xfffffffe
ADD EAX,R8D
LAB_001015be:
CDQE
LEA RAX,[RCX + RAX*0x4]
MOVSS XMM0,dword ptr [RAX]
SUBSS XMM0,XMM1
DIVSS XMM0,XMM2
MOVSS dword ptr [RAX],XMM0
LAB_001015d4:
RET
LAB_001015d8:
JNZ 0x001015d4
MOVAPS XMM2,XMM1
XOR EAX,EAX
SUBSS XMM2,XMM1
JMP 0x001015be
LAB_001015e5:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010158b
|
void func0(int (*param_1) [16],uint param_2)
{
float fVar1;
int8 uVar2;
int auVar3 [16];
float fVar4;
uint uVar5;
float *pfVar6;
int (*pauVar7) [16];
int (*pauVar8) [16];
ulong uVar9;
int auVar10 [16];
int auVar11 [16];
int auVar12 [16];
float fVar13;
float fVar14;
fVar13 = *(float *)*param_1;
if ((int)param_2 < 2) {
if (param_2 != 1) {
return;
}
uVar5 = 0;
fVar14 = fVar13 - fVar13;
}
else {
pfVar6 = (float *)(*param_1 + 4);
fVar4 = fVar13;
do {
fVar1 = *pfVar6;
pfVar6 = pfVar6 + 1;
fVar14 = fVar1;
if (fVar1 <= fVar4) {
fVar14 = fVar4;
}
if (fVar13 <= fVar1) {
fVar1 = fVar13;
}
fVar13 = fVar1;
fVar4 = fVar14;
} while ((float *)(*param_1 + (ulong)(param_2 - 2) * 4 + 8) != pfVar6);
fVar14 = fVar14 - fVar13;
if (param_2 - 1 < 3) {
uVar9 = 0;
uVar5 = 0;
}
else {
pauVar7 = param_1;
do {
pauVar8 = pauVar7 + 1;
auVar10._0_4_ = *(float *)*pauVar7 - fVar13;
auVar10._4_4_ = *(float *)(*pauVar7 + 4) - fVar13;
auVar10._8_4_ = *(float *)(*pauVar7 + 8) - fVar13;
auVar10._12_4_ = *(float *)(*pauVar7 + 0xc) - fVar13;
auVar11._4_4_ = fVar14;
auVar11._0_4_ = fVar14;
auVar11._8_4_ = fVar14;
auVar11._12_4_ = fVar14;
auVar11 = divps(auVar10,auVar11);
*pauVar7 = auVar11;
pauVar7 = pauVar8;
} while (param_1 + (param_2 >> 2) != pauVar8);
uVar5 = param_2 & 0xfffffffc;
uVar9 = (ulong)uVar5;
if (uVar5 == param_2) {
return;
}
param_2 = param_2 - uVar5;
if (param_2 == 1) goto LAB_001015be;
}
uVar2 = *(int8 *)(*param_1 + uVar9 * 4);
auVar12._0_4_ = (float)uVar2 - fVar13;
auVar12._4_4_ = (float)((ulong)uVar2 >> 0x20) - fVar13;
auVar12._8_8_ = 0;
auVar3._4_4_ = fVar14;
auVar3._0_4_ = fVar14;
auVar3._8_4_ = (int)DAT_001020c8;
auVar3._12_4_ = (int)((ulong)DAT_001020c8 >> 0x20);
auVar11 = divps(auVar12,auVar3);
*(long *)(*param_1 + uVar9 * 4) = auVar11._0_8_;
if ((param_2 & 1) == 0) {
return;
}
uVar5 = uVar5 + (param_2 & 0xfffffffe);
}
LAB_001015be:
*(float *)(*param_1 + (long)(int)uVar5 * 4) =
(*(float *)(*param_1 + (long)(int)uVar5 * 4) - fVar13) / fVar14;
return;
}
|
744 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (int) strtol(start, &end, 10);
if (start != end && (*end == ',' || *end == '\0')) {
out[count++] = val;
} else {
while (*end && *end != ',') {
end++;
}
}
start = end;
}
*size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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 size;
// Test 1
int *result1 = func0("", &size);
assert(issame(result1, size, (const int[]){}, 0));
// Test 2
int *result2 = func0("4,,23.2,9,adasd", &size);
assert(issame(result2, size, (const int[]){4, 9}, 2));
// Test 3
int *result3 = func0("3,c,3,3,a,b", &size);
assert(issame(result3, size, (const int[]){3, 3, 3}, 3));
printf("All tests passed.\n");
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x20(%rbp)
mov -0x28(%rbp),%rax
mov %rax,-0x10(%rbp)
jmpq 12d9 <func0+0x110>
addq $0x1,-0x10(%rbp)
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 1243 <func0+0x7a>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rdx
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
movsbq %al,%rax
add %rax,%rax
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
jne 1243 <func0+0x7a>
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp $0x2d,%al
jne 1200 <func0+0x37>
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 12ea <func0+0x121>
lea -0x18(%rbp),%rcx
mov -0x10(%rbp),%rax
mov $0xa,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 <strtol@plt>
mov %eax,-0x1c(%rbp)
mov -0x18(%rbp),%rax
cmp %rax,-0x10(%rbp)
je 12bb <func0+0xf2>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x2c,%al
je 128d <func0+0xc4>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 12bb <func0+0xf2>
mov -0x20(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x20(%rbp)
cltq
lea 0x0(,%rax,4),%rcx
lea 0x2d99(%rip),%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rcx,%rdx,1)
jmp 12d1 <func0+0x108>
mov -0x18(%rbp),%rax
add $0x1,%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 12d1 <func0+0x108>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x2c,%al
jne 12af <func0+0xe6>
mov -0x18(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 1205 <func0+0x3c>
jmp 12eb <func0+0x122>
mov -0x30(%rbp),%rax
mov -0x20(%rbp),%edx
mov %edx,(%rax)
lea 0x2d45(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 130f <func0+0x146>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_20], 0
mov rax, [rbp+var_28]
mov [rbp+nptr], rax
jmp loc_12D9
loc_1200:
add [rbp+nptr], 1
loc_1205:
mov rax, [rbp+nptr]
movzx eax, byte ptr [rax]
test al, al
jz short loc_1243
call ___ctype_b_loc
mov rdx, [rax]
mov rax, [rbp+nptr]
movzx eax, byte ptr [rax]
movsx rax, al
add rax, rax
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jnz short loc_1243
mov rax, [rbp+nptr]
movzx eax, byte ptr [rax]
cmp al, 2Dh ; '-'
jnz short loc_1200
loc_1243:
mov rax, [rbp+nptr]
movzx eax, byte ptr [rax]
test al, al
jz loc_12EA
lea rcx, [rbp+endptr]
mov rax, [rbp+nptr]
mov edx, 0Ah; base
mov rsi, rcx; endptr
mov rdi, rax; nptr
call _strtol
mov [rbp+var_1C], eax
mov rax, [rbp+endptr]
cmp [rbp+nptr], rax
jz short loc_12BB
mov rax, [rbp+endptr]
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jz short loc_128D
mov rax, [rbp+endptr]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_12BB
loc_128D:
mov eax, [rbp+var_20]
lea edx, [rax+1]
mov [rbp+var_20], edx
cdqe
lea rcx, ds:0[rax*4]
lea rdx, out_1
mov eax, [rbp+var_1C]
mov [rcx+rdx], eax
jmp short loc_12D1
loc_12AF:
mov rax, [rbp+endptr]
add rax, 1
mov [rbp+endptr], rax
loc_12BB:
mov rax, [rbp+endptr]
movzx eax, byte ptr [rax]
test al, al
jz short loc_12D1
mov rax, [rbp+endptr]
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jnz short loc_12AF
loc_12D1:
mov rax, [rbp+endptr]
mov [rbp+nptr], rax
loc_12D9:
mov rax, [rbp+nptr]
movzx eax, byte ptr [rax]
test al, al
jnz loc_1205
jmp short loc_12EB
loc_12EA:
nop
loc_12EB:
mov rax, [rbp+var_30]
mov edx, [rbp+var_20]
mov [rax], edx
lea rax, out_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_130F
call ___stack_chk_fail
locret_130F:
leave
retn
|
_DWORD * func0(char *a1, _DWORD *a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-20h]
int v5; // [rsp+14h] [rbp-1Ch]
char *endptr; // [rsp+18h] [rbp-18h] BYREF
char *nptr; // [rsp+20h] [rbp-10h]
unsigned long long v8; // [rsp+28h] [rbp-8h]
v8 = __readfsqword(0x28u);
v4 = 0;
for ( nptr = a1; *nptr; nptr = endptr )
{
while ( *nptr && ((*__ctype_b_loc())[*nptr] & 0x800) == 0 && *nptr != 45 )
++nptr;
if ( !*nptr )
break;
v5 = strtol(nptr, &endptr, 10);
if ( nptr == endptr || *endptr != 44 && *endptr )
{
while ( *endptr && *endptr != 44 )
++endptr;
}
else
{
v2 = v4++;
out_1[v2] = v5;
}
}
*a2 = v4;
return out_1;
}
|
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 FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001012d9
LAB_00101200:
ADD qword ptr [RBP + -0x10],0x1
LAB_00101205:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x00101243
CALL 0x001010d0
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOVSX RAX,AL
ADD RAX,RAX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JNZ 0x00101243
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2d
JNZ 0x00101200
LAB_00101243:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x001012ea
LEA RCX,[RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,0xa
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RBP + -0x10],RAX
JZ 0x001012bb
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JZ 0x0010128d
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001012bb
LAB_0010128d:
MOV EAX,dword ptr [RBP + -0x20]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x20],EDX
CDQE
LEA RCX,[RAX*0x4]
LEA RDX,[0x104040]
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RCX + RDX*0x1],EAX
JMP 0x001012d1
LAB_001012af:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
LAB_001012bb:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x001012d1
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JNZ 0x001012af
LAB_001012d1:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
LAB_001012d9:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101205
JMP 0x001012eb
LAB_001012ea:
NOP
LAB_001012eb:
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010130f
CALL 0x001010a0
LAB_0010130f:
LEAVE
RET
|
int1 * func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
long in_FS_OFFSET;
int local_28;
char *local_20;
char *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = 0;
local_18 = param_1;
while (*local_18 != '\0') {
while (((*local_18 != '\0' && (ppuVar1 = __ctype_b_loc(), ((*ppuVar1)[*local_18] & 0x800) == 0))
&& (*local_18 != '-'))) {
local_18 = local_18 + 1;
}
if (*local_18 == '\0') break;
lVar2 = strtol(local_18,&local_20,10);
if ((local_18 == local_20) || ((*local_20 != ',' && (*local_20 != '\0')))) {
for (; (*local_20 != '\0' && (*local_20 != ',')); local_20 = local_20 + 1) {
}
}
else {
*(int *)(out_1 + (long)local_28 * 4) = (int)lVar2;
local_28 = local_28 + 1;
}
local_18 = local_20;
}
*param_2 = local_28;
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return out_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
745 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (int) strtol(start, &end, 10);
if (start != end && (*end == ',' || *end == '\0')) {
out[count++] = val;
} else {
while (*end && *end != ',') {
end++;
}
}
start = end;
}
*size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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 size;
// Test 1
int *result1 = func0("", &size);
assert(issame(result1, size, (const int[]){}, 0));
// Test 2
int *result2 = func0("4,,23.2,9,adasd", &size);
assert(issame(result2, size, (const int[]){4, 9}, 2));
// Test 3
int *result3 = func0("3,c,3,3,a,b", &size);
assert(issame(result3, size, (const int[]){3, 3, 3}, 3));
printf("All tests passed.\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,%r15
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movzbl (%rdi),%ebx
mov $0x0,%r13d
test %bl,%bl
je 1277 <func0+0xae>
mov %rdi,%rbp
callq 10d0 <__ctype_b_loc@plt>
mov %rax,%r12
mov $0x0,%r13d
lea 0x2e2d(%rip),%r14
jmp 1257 <func0+0x8e>
test %bl,%bl
je 1277 <func0+0xae>
mov %rsp,%rsi
mov $0xa,%edx
mov %rbp,%rdi
callq 10c0 <strtol@plt>
mov (%rsp),%rdx
cmp %rbp,%rdx
je 12a0 <func0+0xd7>
movzbl (%rdx),%ecx
cmp $0x2c,%cl
je 123e <func0+0x75>
test %cl,%cl
jne 12ac <func0+0xe3>
movslq %r13d,%rdx
mov %eax,(%r14,%rdx,4)
lea 0x1(%r13),%r13d
mov (%rsp),%rax
movzbl (%rax),%ebx
test %bl,%bl
je 1277 <func0+0xae>
mov %rax,%rbp
movsbq %bl,%rax
mov (%r12),%rdx
testb $0x8,0x1(%rdx,%rax,2)
jne 1215 <func0+0x4c>
cmp $0x2d,%bl
je 1215 <func0+0x4c>
lea 0x1(%rbp),%rax
movzbl 0x1(%rbp),%ebx
test %bl,%bl
jne 1254 <func0+0x8b>
mov %r13d,(%r15)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 12c6 <func0+0xfd>
lea 0x2daf(%rip),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movzbl 0x0(%rbp),%eax
test %al,%al
je 1249 <func0+0x80>
cmp $0x2c,%al
je 1249 <func0+0x80>
lea 0x1(%rdx),%rax
mov %rax,(%rsp)
movzbl (%rax),%edx
add $0x1,%rax
test %dl,%dl
je 1249 <func0+0x80>
cmp $0x2c,%dl
jne 12b0 <func0+0xe7>
jmp 1249 <func0+0x80>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r14, rsi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov r12d, 0
lea r13, out_1
cmp byte ptr [rdi], 0
jnz short loc_123F
jmp short loc_126B
loc_1203:
mov rsi, rsp; endptr
mov edx, 0Ah; base
mov rdi, rbp; nptr
call _strtol
mov rdx, [rsp+38h+var_38]
cmp rdx, rbp
jz short loc_1292
movzx ecx, byte ptr [rdx]
cmp cl, 2Ch ; ','
jz short loc_1228
test cl, cl
jnz short loc_129D
loc_1228:
movsxd rdx, r12d
mov [r13+rdx*4+0], eax
lea r12d, [r12+1]
loc_1235:
mov rbp, [rsp+38h+var_38]
cmp byte ptr [rbp+0], 0
jz short loc_126B
loc_123F:
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_126B
call ___ctype_b_loc
mov rdx, [rax]
loc_124F:
movsx rax, bl
test byte ptr [rdx+rax*2+1], 8
jnz short loc_1203
cmp bl, 2Dh ; '-'
jz short loc_1203
add rbp, 1
movzx ebx, byte ptr [rbp+0]
test bl, bl
jnz short loc_124F
loc_126B:
mov [r14], r12d
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_12BA
lea rax, out_1
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1292:
movzx eax, byte ptr [rdx]
test al, al
jz short loc_1235
cmp al, 2Ch ; ','
jz short loc_1235
loc_129D:
lea rax, [rdx+1]
loc_12A1:
mov [rsp+38h+var_38], rax
movzx edx, byte ptr [rax]
add rax, 1
test dl, dl
jz short loc_1235
cmp dl, 2Ch ; ','
jnz short loc_12A1
jmp loc_1235
loc_12BA:
call ___stack_chk_fail
|
_DWORD * func0(char *nptr, _DWORD *a2)
{
char *v2; // rbp
int v3; // r12d
int v4; // eax
char v5; // bl
const unsigned __int16 *v6; // rdx
char *v8; // rax
char v9; // dl
char *v10[7]; // [rsp+0h] [rbp-38h] BYREF
v2 = nptr;
v10[1] = (char *)__readfsqword(0x28u);
v3 = 0;
if ( *nptr )
{
do
{
v5 = *v2;
if ( !*v2 )
break;
v6 = *__ctype_b_loc();
while ( (v6[v5] & 0x800) == 0 && v5 != 45 )
{
v5 = *++v2;
if ( !*v2 )
goto LABEL_13;
}
v4 = strtol(v2, v10, 10);
if ( v10[0] == v2 )
{
if ( *v10[0] && *v10[0] != 44 )
{
LABEL_16:
v8 = v10[0] + 1;
do
{
v10[0] = v8;
v9 = *v8++;
}
while ( v9 && v9 != 44 );
}
}
else
{
if ( *v10[0] != 44 && *v10[0] )
goto LABEL_16;
out_1[v3++] = v4;
}
v2 = v10[0];
}
while ( *v10[0] );
}
LABEL_13:
*a2 = v3;
return out_1;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV R12D,0x0
LEA R13,[0x104040]
CMP byte ptr [RDI],0x0
JNZ 0x0010123f
JMP 0x0010126b
LAB_00101203:
MOV RSI,RSP
MOV EDX,0xa
MOV RDI,RBP
CALL 0x001010c0
MOV RDX,qword ptr [RSP]
CMP RDX,RBP
JZ 0x00101292
MOVZX ECX,byte ptr [RDX]
CMP CL,0x2c
JZ 0x00101228
TEST CL,CL
JNZ 0x0010129d
LAB_00101228:
MOVSXD RDX,R12D
MOV dword ptr [R13 + RDX*0x4],EAX
LEA R12D,[R12 + 0x1]
LAB_00101235:
MOV RBP,qword ptr [RSP]
CMP byte ptr [RBP],0x0
JZ 0x0010126b
LAB_0010123f:
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x0010126b
CALL 0x001010d0
MOV RDX,qword ptr [RAX]
LAB_0010124f:
MOVSX RAX,BL
TEST byte ptr [RDX + RAX*0x2 + 0x1],0x8
JNZ 0x00101203
CMP BL,0x2d
JZ 0x00101203
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JNZ 0x0010124f
LAB_0010126b:
MOV dword ptr [R14],R12D
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012ba
LEA RAX,[0x104040]
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101292:
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JZ 0x00101235
CMP AL,0x2c
JZ 0x00101235
LAB_0010129d:
LEA RAX,[RDX + 0x1]
LAB_001012a1:
MOV qword ptr [RSP],RAX
MOVZX EDX,byte ptr [RAX]
ADD RAX,0x1
TEST DL,DL
JZ 0x00101235
CMP DL,0x2c
JNZ 0x001012a1
JMP 0x00101235
LAB_001012ba:
CALL 0x001010a0
|
int4 * func0(char *param_1,int *param_2)
{
long lVar1;
ushort **ppuVar2;
char cVar3;
int iVar4;
long in_FS_OFFSET;
char *local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar4 = 0;
cVar3 = *param_1;
do {
if ((cVar3 == '\0') || (cVar3 = *param_1, cVar3 == '\0')) {
LAB_0010126b:
*param_2 = iVar4;
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &out_1;
}
ppuVar2 = __ctype_b_loc();
while (((*(byte *)((long)*ppuVar2 + (long)cVar3 * 2 + 1) & 8) == 0 && (cVar3 != '-'))) {
param_1 = param_1 + 1;
cVar3 = *param_1;
if (cVar3 == '\0') goto LAB_0010126b;
}
lVar1 = strtol(param_1,&local_38,10);
if (local_38 == param_1) {
cVar3 = *local_38;
if (cVar3 != '\0') goto joined_r0x0010129b;
}
else if ((*local_38 == ',') || (*local_38 == '\0')) {
(&out_1)[iVar4] = (int)lVar1;
iVar4 = iVar4 + 1;
}
else {
do {
local_38 = local_38 + 1;
cVar3 = *local_38;
if (cVar3 == '\0') break;
joined_r0x0010129b:
} while (cVar3 != ',');
}
cVar3 = *local_38;
param_1 = local_38;
} while( true );
}
|
746 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (int) strtol(start, &end, 10);
if (start != end && (*end == ',' || *end == '\0')) {
out[count++] = val;
} else {
while (*end && *end != ',') {
end++;
}
}
start = end;
}
*size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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 size;
// Test 1
int *result1 = func0("", &size);
assert(issame(result1, size, (const int[]){}, 0));
// Test 2
int *result2 = func0("4,,23.2,9,adasd", &size);
assert(issame(result2, size, (const int[]){4, 9}, 2));
// Test 3
int *result3 = func0("3,c,3,3,a,b", &size);
assert(issame(result3, size, (const int[]){3, 3, 3}, 3));
printf("All tests passed.\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movzbl (%rdi),%ebx
mov %rsi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
test %bl,%bl
je 1458 <func0+0xe8>
mov %rdi,%rbp
xor %r15d,%r15d
lea 0x10(%rsp),%r13
callq 10d0 <__ctype_b_loc@plt>
lea 0x2c84(%rip),%r14
mov (%rax),%rcx
mov %rax,%r12
jmp 13dc <func0+0x6c>
nopl 0x0(%rax)
cmp $0x2d,%bl
je 13e7 <func0+0x77>
movzbl 0x1(%rbp),%ebx
lea 0x1(%rbp),%rdx
test %bl,%bl
je 1458 <func0+0xe8>
mov %rdx,%rbp
movsbq %bl,%rax
testb $0x8,0x1(%rcx,%rax,2)
je 13c8 <func0+0x58>
mov $0xa,%edx
mov %r13,%rsi
mov %rbp,%rdi
callq 10c0 <strtol@plt>
mov 0x10(%rsp),%rdx
cmp %rbp,%rdx
je 1428 <func0+0xb8>
movzbl (%rdx),%ecx
cmp $0x2c,%cl
je 140d <func0+0x9d>
test %cl,%cl
jne 1435 <func0+0xc5>
movslq %r15d,%rcx
add $0x1,%r15d
mov %eax,(%r14,%rcx,4)
movzbl (%rdx),%ebx
test %bl,%bl
je 1458 <func0+0xe8>
mov (%r12),%rcx
jmp 13d9 <func0+0x69>
nopl (%rax)
movzbl 0x0(%rbp),%ebx
cmp $0x2c,%bl
je 1486 <func0+0x116>
test %bl,%bl
je 1486 <func0+0x116>
lea 0x1(%rdx),%rax
jmp 1445 <func0+0xd5>
nopl 0x0(%rax,%rax,1)
cmp $0x2c,%bl
je 141b <func0+0xab>
mov %rax,0x10(%rsp)
movzbl (%rax),%ebx
mov %rax,%rdx
add $0x1,%rax
test %bl,%bl
jne 1440 <func0+0xd0>
mov 0x8(%rsp),%rax
mov %r15d,(%rax)
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 148b <func0+0x11b>
add $0x28,%rsp
lea 0x2bc5(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rbp,%rdx
jmp 141b <func0+0xab>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
mov r15, rsi
push r14
lea r14, out_1
push r13
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov r13, rsp
test bl, bl
jz short loc_1420
nop dword ptr [rax+00h]
loc_13B0:
call ___ctype_b_loc
mov rdx, [rax]
jmp short loc_13D1
loc_13C0:
cmp bl, 2Dh ; '-'
jz short loc_13DC
movzx ebx, byte ptr [rbp+1]
add rbp, 1
test bl, bl
jz short loc_1420
loc_13D1:
movsx rax, bl
test byte ptr [rdx+rax*2+1], 8
jz short loc_13C0
loc_13DC:
mov edx, 0Ah; base
mov rsi, r13; endptr
mov rdi, rbp; nptr
call _strtol
mov rdx, [rsp+48h+var_48]
cmp rdx, rbp
jz short loc_1448
movzx ecx, byte ptr [rdx]
cmp cl, 2Ch ; ','
jz short loc_1401
test cl, cl
jnz short loc_1455
loc_1401:
movsxd rcx, r12d
mov rbp, rdx
add r12d, 1
mov [r14+rcx*4], eax
movzx ebx, byte ptr [rdx]
loc_1412:
test bl, bl
jnz short loc_13B0
nop word ptr [rax+rax+00000000h]
loc_1420:
mov [r15], r12d
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz short loc_1479
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1448:
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_1420
cmp bl, 2Ch ; ','
jz short loc_1412
loc_1455:
lea rax, [rdx+1]
jmp short loc_1465
loc_1460:
cmp bl, 2Ch ; ','
jz short loc_1412
loc_1465:
mov [rsp+48h+var_48], rax
movzx ebx, byte ptr [rax]
mov rbp, rax
add rax, 1
test bl, bl
jnz short loc_1460
jmp short loc_1420
loc_1479:
call ___stack_chk_fail
|
_DWORD * func0(char *nptr, _DWORD *a2)
{
int v2; // r12d
const char *v3; // rbp
char v4; // bl
const unsigned __int16 *v5; // rdx
int v6; // eax
char *v7; // rdx
long long v8; // rcx
char *v10; // rax
char *v11[9]; // [rsp+0h] [rbp-48h] BYREF
v2 = 0;
v3 = nptr;
v4 = *nptr;
v11[1] = (char *)__readfsqword(0x28u);
if ( !v4 )
goto LABEL_11;
while ( 1 )
{
v5 = *__ctype_b_loc();
while ( (v5[v4] & 0x800) == 0 && v4 != 45 )
{
v4 = *++v3;
if ( !v4 )
goto LABEL_11;
}
v6 = strtol(v3, v11, 10);
v7 = v11[0];
if ( v11[0] == v3 )
break;
if ( *v11[0] != 44 && *v11[0] )
goto LABEL_14;
v8 = v2;
v3 = v11[0];
++v2;
out_1[v8] = v6;
v4 = *v7;
LABEL_10:
if ( !v4 )
goto LABEL_11;
}
v4 = *v3;
if ( !*v3 )
goto LABEL_11;
if ( v4 == 44 )
goto LABEL_10;
LABEL_14:
v10 = v11[0] + 1;
while ( 1 )
{
v11[0] = v10;
v4 = *v10;
v3 = v10++;
if ( !v4 )
break;
if ( v4 == 44 )
goto LABEL_10;
}
LABEL_11:
*a2 = v2;
return out_1;
}
|
func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[0x104040]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV R13,RSP
TEST BL,BL
JZ 0x00101420
NOP dword ptr [RAX]
LAB_001013b0:
CALL 0x001010d0
MOV RDX,qword ptr [RAX]
JMP 0x001013d1
LAB_001013c0:
CMP BL,0x2d
JZ 0x001013dc
MOVZX EBX,byte ptr [RBP + 0x1]
ADD RBP,0x1
TEST BL,BL
JZ 0x00101420
LAB_001013d1:
MOVSX RAX,BL
TEST byte ptr [RDX + RAX*0x2 + 0x1],0x8
JZ 0x001013c0
LAB_001013dc:
MOV EDX,0xa
MOV RSI,R13
MOV RDI,RBP
CALL 0x001010c0
MOV RDX,qword ptr [RSP]
CMP RDX,RBP
JZ 0x00101448
MOVZX ECX,byte ptr [RDX]
CMP CL,0x2c
JZ 0x00101401
TEST CL,CL
JNZ 0x00101455
LAB_00101401:
MOVSXD RCX,R12D
MOV RBP,RDX
ADD R12D,0x1
MOV dword ptr [R14 + RCX*0x4],EAX
MOVZX EBX,byte ptr [RDX]
LAB_00101412:
TEST BL,BL
JNZ 0x001013b0
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101420:
MOV dword ptr [R15],R12D
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101479
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101448:
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x00101420
CMP BL,0x2c
JZ 0x00101412
LAB_00101455:
LEA RAX,[RDX + 0x1]
JMP 0x00101465
LAB_00101460:
CMP BL,0x2c
JZ 0x00101412
LAB_00101465:
MOV qword ptr [RSP],RAX
MOVZX EBX,byte ptr [RAX]
MOV RBP,RAX
ADD RAX,0x1
TEST BL,BL
JNZ 0x00101460
JMP 0x00101420
LAB_00101479:
CALL 0x001010a0
|
int4 * func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
long lVar3;
char cVar4;
int iVar5;
long in_FS_OFFSET;
char *local_48;
long local_40;
iVar5 = 0;
cVar4 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
do {
if (cVar4 == '\0') {
LAB_00101420:
*param_2 = iVar5;
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &out_1;
}
ppuVar1 = __ctype_b_loc();
while (((*(byte *)((long)*ppuVar1 + (long)cVar4 * 2 + 1) & 8) == 0 && (cVar4 != '-'))) {
cVar4 = param_1[1];
param_1 = param_1 + 1;
if (cVar4 == '\0') goto LAB_00101420;
}
lVar2 = strtol(param_1,&local_48,10);
if (local_48 == param_1) {
cVar4 = *param_1;
if (cVar4 != '\0') goto joined_r0x00101453;
goto LAB_00101420;
}
if ((*local_48 == ',') || (*local_48 == '\0')) {
lVar3 = (long)iVar5;
iVar5 = iVar5 + 1;
(&out_1)[lVar3] = (int)lVar2;
cVar4 = *local_48;
param_1 = local_48;
}
else {
do {
local_48 = local_48 + 1;
cVar4 = *local_48;
param_1 = local_48;
if (cVar4 == '\0') goto LAB_00101420;
joined_r0x00101453:
} while (cVar4 != ',');
}
} while( true );
}
|
747 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (int) strtol(start, &end, 10);
if (start != end && (*end == ',' || *end == '\0')) {
out[count++] = val;
} else {
while (*end && *end != ',') {
end++;
}
}
start = end;
}
*size = count;
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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 size;
// Test 1
int *result1 = func0("", &size);
assert(issame(result1, size, (const int[]){}, 0));
// Test 2
int *result2 = func0("4,,23.2,9,adasd", &size);
assert(issame(result2, size, (const int[]){4, 9}, 2));
// Test 3
int *result3 = func0("3,c,3,3,a,b", &size);
assert(issame(result3, size, (const int[]){3, 3, 3}, 3));
printf("All tests passed.\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movzbl (%rdi),%ebx
mov %rsi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
test %bl,%bl
je 1458 <func0+0xe8>
mov %rdi,%rbp
xor %r15d,%r15d
lea 0x10(%rsp),%r13
callq 10d0 <__ctype_b_loc@plt>
lea 0x2c84(%rip),%r14
mov (%rax),%rcx
mov %rax,%r12
jmp 13dc <func0+0x6c>
nopl 0x0(%rax)
cmp $0x2d,%bl
je 13e7 <func0+0x77>
movzbl 0x1(%rbp),%ebx
lea 0x1(%rbp),%rdx
test %bl,%bl
je 1458 <func0+0xe8>
mov %rdx,%rbp
movsbq %bl,%rax
testb $0x8,0x1(%rcx,%rax,2)
je 13c8 <func0+0x58>
mov $0xa,%edx
mov %r13,%rsi
mov %rbp,%rdi
callq 10c0 <strtol@plt>
mov 0x10(%rsp),%rdx
cmp %rbp,%rdx
je 1428 <func0+0xb8>
movzbl (%rdx),%ecx
cmp $0x2c,%cl
je 140d <func0+0x9d>
test %cl,%cl
jne 1435 <func0+0xc5>
movslq %r15d,%rcx
add $0x1,%r15d
mov %eax,(%r14,%rcx,4)
movzbl (%rdx),%ebx
test %bl,%bl
je 1458 <func0+0xe8>
mov (%r12),%rcx
jmp 13d9 <func0+0x69>
nopl (%rax)
movzbl 0x0(%rbp),%ebx
cmp $0x2c,%bl
je 1486 <func0+0x116>
test %bl,%bl
je 1486 <func0+0x116>
lea 0x1(%rdx),%rax
jmp 1445 <func0+0xd5>
nopl 0x0(%rax,%rax,1)
cmp $0x2c,%bl
je 141b <func0+0xab>
mov %rax,0x10(%rsp)
movzbl (%rax),%ebx
mov %rax,%rdx
add $0x1,%rax
test %bl,%bl
jne 1440 <func0+0xd0>
mov 0x8(%rsp),%rax
mov %r15d,(%rax)
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 148b <func0+0x11b>
add $0x28,%rsp
lea 0x2bc5(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rbp,%rdx
jmp 141b <func0+0xab>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
mov r15, rsi
push r14
lea r14, out_1
push r13
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov r13, rsp
test bl, bl
jz short loc_1420
nop dword ptr [rax+00h]
loc_13B0:
call ___ctype_b_loc
mov rdx, [rax]
jmp short loc_13D1
loc_13C0:
cmp bl, 2Dh ; '-'
jz short loc_13DC
movzx ebx, byte ptr [rbp+1]
add rbp, 1
test bl, bl
jz short loc_1420
loc_13D1:
movsx rax, bl
test byte ptr [rdx+rax*2+1], 8
jz short loc_13C0
loc_13DC:
mov edx, 0Ah; base
mov rsi, r13; endptr
mov rdi, rbp; nptr
call _strtol
mov rdx, [rsp+48h+var_48]
cmp rdx, rbp
jz short loc_1448
movzx ecx, byte ptr [rdx]
cmp cl, 2Ch ; ','
jz short loc_1401
test cl, cl
jnz short loc_1455
loc_1401:
movsxd rcx, r12d
mov rbp, rdx
add r12d, 1
mov [r14+rcx*4], eax
movzx ebx, byte ptr [rdx]
loc_1412:
test bl, bl
jnz short loc_13B0
nop word ptr [rax+rax+00000000h]
loc_1420:
mov [r15], r12d
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz short loc_1479
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1448:
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_1420
cmp bl, 2Ch ; ','
jz short loc_1412
loc_1455:
lea rax, [rdx+1]
jmp short loc_1465
loc_1460:
cmp bl, 2Ch ; ','
jz short loc_1412
loc_1465:
mov [rsp+48h+var_48], rax
movzx ebx, byte ptr [rax]
mov rbp, rax
add rax, 1
test bl, bl
jnz short loc_1460
jmp short loc_1420
loc_1479:
call ___stack_chk_fail
|
_DWORD * func0(char *nptr, _DWORD *a2)
{
int v2; // r12d
const char *v3; // rbp
char v4; // bl
const unsigned __int16 *v5; // rdx
int v6; // eax
char *v7; // rdx
long long v8; // rcx
char *v10; // rax
char *v11[9]; // [rsp+0h] [rbp-48h] BYREF
v2 = 0;
v3 = nptr;
v4 = *nptr;
v11[1] = (char *)__readfsqword(0x28u);
if ( !v4 )
goto LABEL_11;
while ( 1 )
{
v5 = *__ctype_b_loc();
while ( (v5[v4] & 0x800) == 0 && v4 != 45 )
{
v4 = *++v3;
if ( !v4 )
goto LABEL_11;
}
v6 = strtol(v3, v11, 10);
v7 = v11[0];
if ( v11[0] == v3 )
break;
if ( *v11[0] != 44 && *v11[0] )
goto LABEL_14;
v8 = v2;
v3 = v11[0];
++v2;
out_1[v8] = v6;
v4 = *v7;
LABEL_10:
if ( !v4 )
goto LABEL_11;
}
v4 = *v3;
if ( !*v3 )
goto LABEL_11;
if ( v4 == 44 )
goto LABEL_10;
LABEL_14:
v10 = v11[0] + 1;
while ( 1 )
{
v11[0] = v10;
v4 = *v10;
v3 = v10++;
if ( !v4 )
break;
if ( v4 == 44 )
goto LABEL_10;
}
LABEL_11:
*a2 = v2;
return out_1;
}
|
func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[0x104040]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV R13,RSP
TEST BL,BL
JZ 0x00101420
NOP dword ptr [RAX]
LAB_001013b0:
CALL 0x001010d0
MOV RDX,qword ptr [RAX]
JMP 0x001013d1
LAB_001013c0:
CMP BL,0x2d
JZ 0x001013dc
MOVZX EBX,byte ptr [RBP + 0x1]
ADD RBP,0x1
TEST BL,BL
JZ 0x00101420
LAB_001013d1:
MOVSX RAX,BL
TEST byte ptr [RDX + RAX*0x2 + 0x1],0x8
JZ 0x001013c0
LAB_001013dc:
MOV EDX,0xa
MOV RSI,R13
MOV RDI,RBP
CALL 0x001010c0
MOV RDX,qword ptr [RSP]
CMP RDX,RBP
JZ 0x00101448
MOVZX ECX,byte ptr [RDX]
CMP CL,0x2c
JZ 0x00101401
TEST CL,CL
JNZ 0x00101455
LAB_00101401:
MOVSXD RCX,R12D
MOV RBP,RDX
ADD R12D,0x1
MOV dword ptr [R14 + RCX*0x4],EAX
MOVZX EBX,byte ptr [RDX]
LAB_00101412:
TEST BL,BL
JNZ 0x001013b0
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101420:
MOV dword ptr [R15],R12D
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101479
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101448:
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x00101420
CMP BL,0x2c
JZ 0x00101412
LAB_00101455:
LEA RAX,[RDX + 0x1]
JMP 0x00101465
LAB_00101460:
CMP BL,0x2c
JZ 0x00101412
LAB_00101465:
MOV qword ptr [RSP],RAX
MOVZX EBX,byte ptr [RAX]
MOV RBP,RAX
ADD RAX,0x1
TEST BL,BL
JNZ 0x00101460
JMP 0x00101420
LAB_00101479:
CALL 0x001010a0
|
int4 * func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
long lVar3;
char cVar4;
int iVar5;
long in_FS_OFFSET;
char *local_48;
long local_40;
iVar5 = 0;
cVar4 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
do {
if (cVar4 == '\0') {
LAB_00101420:
*param_2 = iVar5;
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &out_1;
}
ppuVar1 = __ctype_b_loc();
while (((*(byte *)((long)*ppuVar1 + (long)cVar4 * 2 + 1) & 8) == 0 && (cVar4 != '-'))) {
cVar4 = param_1[1];
param_1 = param_1 + 1;
if (cVar4 == '\0') goto LAB_00101420;
}
lVar2 = strtol(param_1,&local_48,10);
if (local_48 == param_1) {
cVar4 = *param_1;
if (cVar4 != '\0') goto joined_r0x00101453;
goto LAB_00101420;
}
if ((*local_48 == ',') || (*local_48 == '\0')) {
lVar3 = (long)iVar5;
iVar5 = iVar5 + 1;
(&out_1)[lVar3] = (int)lVar2;
cVar4 = *local_48;
param_1 = local_48;
}
else {
do {
local_48 = local_48 + 1;
cVar4 = *local_48;
param_1 = local_48;
if (cVar4 == '\0') goto LAB_00101420;
joined_r0x00101453:
} while (cVar4 != ',');
}
} while( true );
}
|
748 |
func0
|
#include <stdio.h>
|
int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1162 <func0+0x19>
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 115e <func0+0x15>
mov -0x4(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_1162
loc_115E:
add [rbp+var_4], 1
loc_1162:
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_115E
mov eax, [rbp+var_4]
pop rbp
retn
|
long long func0(long long a1)
{
unsigned int i; // [rsp+14h] [rbp-4h]
for ( i = 0; *(_BYTE *)((int)i + a1); ++i )
;
return i;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101162
LAB_0010115e:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101162:
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 0x0010115e
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int func0(long param_1)
{
int4 local_c;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
}
return local_c;
}
|
749 |
func0
|
#include <stdio.h>
|
int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmpb $0x0,(%rdi)
je 1167 <func0+0x1e>
mov $0x1,%eax
mov %eax,%edx
add $0x1,%rax
cmpb $0x0,-0x1(%rdi,%rax,1)
jne 1157 <func0+0xe>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1164 <func0+0x1b>
|
func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1166
mov edx, 1
loc_1157:
mov rax, rdx
add rdx, 1
cmp byte ptr [rdi+rdx-1], 0
jnz short loc_1157
retn
loc_1166:
mov eax, 0
retn
|
long long func0(_BYTE *a1)
{
long long v1; // rdx
long long result; // rax
if ( !*a1 )
return 0LL;
v1 = 1LL;
do
result = v1++;
while ( a1[v1 - 1] );
return result;
}
|
func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101166
MOV EDX,0x1
LAB_00101157:
MOV RAX,RDX
ADD RDX,0x1
CMP byte ptr [RDI + RDX*0x1 + -0x1],0x0
JNZ 0x00101157
RET
LAB_00101166:
MOV EAX,0x0
RET
|
long func0(char *param_1)
{
char *pcVar1;
long lVar2;
long lVar3;
if (*param_1 != '\0') {
lVar3 = 1;
do {
lVar2 = lVar3;
pcVar1 = param_1 + lVar3;
lVar3 = lVar3 + 1;
} while (*pcVar1 != '\0');
return lVar2;
}
return 0;
}
|
750 |
func0
|
#include <stdio.h>
|
int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmpb $0x0,(%rdi)
je 11c8 <func0+0x28>
mov $0x1,%eax
xchg %ax,%ax
mov %eax,%r8d
add $0x1,%rax
cmpb $0x0,-0x1(%rdi,%rax,1)
jne 11b0 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1180
sub rsp, 8
add rdi, 1; s
call _strlen
add rsp, 8
add eax, 1
retn
loc_1180:
xor eax, eax
retn
|
long long func0(long long a1)
{
if ( *(_BYTE *)a1 )
return (unsigned int)strlen((const char *)(a1 + 1)) + 1;
else
return 0LL;
}
|
func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101180
SUB RSP,0x8
ADD RDI,0x1
CALL 0x00101050
ADD RSP,0x8
ADD EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
RET
|
int func0(char *param_1)
{
size_t sVar1;
if (*param_1 != '\0') {
sVar1 = strlen(param_1 + 1);
return (int)sVar1 + 1;
}
return 0;
}
|
751 |
func0
|
#include <stdio.h>
|
int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
}
|
#include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmpb $0x0,(%rdi)
je 11c8 <func0+0x28>
mov $0x1,%eax
xchg %ax,%ax
mov %eax,%r8d
add $0x1,%rax
cmpb $0x0,-0x1(%rdi,%rax,1)
jne 11b0 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1180
sub rsp, 8
add rdi, 1; s
call _strlen
add rsp, 8
add eax, 1
retn
loc_1180:
xor eax, eax
retn
|
long long func0(long long a1)
{
if ( *(_BYTE *)a1 )
return (unsigned int)strlen((const char *)(a1 + 1)) + 1;
else
return 0LL;
}
|
func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101180
SUB RSP,0x8
ADD RDI,0x1
CALL 0x00101050
ADD RSP,0x8
ADD EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
RET
|
int func0(char *param_1)
{
size_t sVar1;
if (*param_1 != '\0') {
sVar1 = strlen(param_1 + 1);
return (int)sVar1 + 1;
}
return 0;
}
|
752 |
func0
|
#include <stdio.h>
|
int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x2,-0x4(%rbp)
jmp 1177 <func0+0x2e>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1173 <func0+0x2a>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
jmp 1187 <func0+0x3e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 115d <func0+0x14>
mov $0x1,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 2
jmp short loc_1177
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1173
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
jmp short loc_1187
loc_1173:
add [rbp+var_4], 1
loc_1177:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_115D
mov eax, 1
loc_1187:
pop rbp
retn
|
long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 2; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
return (unsigned int)(a1 / i);
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101177
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101173
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
JMP 0x00101187
LAB_00101173:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101177:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010115d
MOV EAX,0x1
LAB_00101187:
POP RBP
RET
|
int [16] func0(int param_1,int8 param_2,ulong param_3)
{
ulong uVar1;
int auVar2 [16];
int4 local_c;
local_c = 2;
do {
if (param_1 < local_c * local_c) {
uVar1 = 1;
LAB_00101187:
auVar2._8_8_ = param_3;
auVar2._0_8_ = uVar1;
return auVar2;
}
param_3 = (long)param_1 % (long)local_c & 0xffffffff;
if ((int)((long)param_1 % (long)local_c) == 0) {
uVar1 = (long)param_1 / (long)local_c & 0xffffffff;
param_3 = (long)param_1 % (long)local_c & 0xffffffff;
goto LAB_00101187;
}
local_c = local_c + 1;
} while( true );
}
|
753 |
func0
|
#include <stdio.h>
|
int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp $0x3,%edi
jle 1185 <func0+0x3c>
test $0x1,%dil
je 1178 <func0+0x2f>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 117f <func0+0x36>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 115d <func0+0x14>
mov %edi,%eax
cltd
idiv %ecx
retq
mov $0x2,%ecx
jmp 1172 <func0+0x29>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
|
func0:
endbr64
cmp edi, 3
jle short loc_1184
mov esi, edi
and esi, 1
jz short loc_117D
mov ecx, 2
loc_115E:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_117A
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_115E
loc_1173:
mov eax, edi
cdq
idiv ecx
mov esi, eax
loc_117A:
mov eax, esi
retn
loc_117D:
mov ecx, 2
jmp short loc_1173
loc_1184:
mov esi, 1
jmp short loc_117A
|
long long func0(int a1)
{
unsigned int v1; // esi
int v2; // ecx
if ( a1 <= 3 )
{
return 1;
}
else
{
v1 = a1 & 1;
if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( 1 )
{
++v2;
if ( v2 * v2 > a1 )
break;
if ( !(a1 % v2) )
return (unsigned int)(a1 / v2);
}
}
else
{
v2 = 2;
return (unsigned int)(a1 / v2);
}
}
return v1;
}
|
func0:
ENDBR64
CMP EDI,0x3
JLE 0x00101184
MOV ESI,EDI
AND ESI,0x1
JZ 0x0010117d
MOV ECX,0x2
LAB_0010115e:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x0010117a
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115e
LAB_00101173:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
LAB_0010117a:
MOV EAX,ESI
RET
LAB_0010117d:
MOV ECX,0x2
JMP 0x00101173
LAB_00101184:
MOV ESI,0x1
JMP 0x0010117a
|
int [16] func0(uint param_1,int8 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
int auVar3 [16];
if ((int)param_1 < 4) {
uVar2 = 1;
}
else {
uVar2 = param_1 & 1;
if (uVar2 == 0) {
iVar1 = 2;
}
else {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)param_1 < iVar1 * iVar1) goto LAB_0010117a;
param_3 = (long)(int)param_1 % (long)iVar1 & 0xffffffff;
} while ((int)((long)(int)param_1 % (long)iVar1) != 0);
}
uVar2 = (int)param_1 / iVar1;
param_3 = (long)(int)param_1 % (long)iVar1 & 0xffffffff;
}
LAB_0010117a:
auVar3._4_4_ = 0;
auVar3._0_4_ = uVar2;
auVar3._8_8_ = param_3;
return auVar3;
}
|
754 |
func0
|
#include <stdio.h>
|
int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x3,%edi
jle 1175 <func0+0x35>
mov $0x2,%ecx
test $0x1,%dil
jne 1169 <func0+0x29>
jmp 1180 <func0+0x40>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <func0+0x40>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1160 <func0+0x20>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
cmp edi, 3
jle short loc_118A
mov esi, edi
mov ecx, 2
and esi, 1
jnz short loc_1169
jmp short loc_1180
loc_1160:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1169:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1160
loc_1175:
mov eax, esi
retn
loc_1180:
mov eax, edi
cdq
idiv ecx
mov esi, eax
mov eax, esi
retn
loc_118A:
mov esi, 1
jmp short loc_1175
|
long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 3 )
return 1;
v1 = 2;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
{
while ( 1 )
{
++v1;
if ( v1 * v1 > a1 )
break;
if ( !(a1 % v1) )
return (unsigned int)(a1 / v1);
}
return v2;
}
return (unsigned int)(a1 / v1);
}
|
func0:
ENDBR64
CMP EDI,0x3
JLE 0x0010118a
MOV ESI,EDI
MOV ECX,0x2
AND ESI,0x1
JNZ 0x00101169
JMP 0x00101180
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101169:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101160
LAB_00101175:
MOV EAX,ESI
RET
LAB_00101180:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
MOV EAX,ESI
RET
LAB_0010118a:
MOV ESI,0x1
JMP 0x00101175
|
int [16] func0(uint param_1,int8 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
int auVar4 [16];
int auVar5 [16];
if ((int)param_1 < 4) {
uVar3 = 1;
}
else {
iVar1 = 2;
uVar3 = param_1 & 1;
uVar2 = uVar3;
while( true ) {
if (uVar2 == 0) {
auVar5._8_8_ = (long)(int)param_1 % (long)iVar1 & 0xffffffff;
auVar5._0_8_ = (long)(int)param_1 / (long)iVar1 & 0xffffffff;
return auVar5;
}
iVar1 = iVar1 + 1;
if ((int)param_1 < iVar1 * iVar1) break;
param_3 = (long)(int)param_1 % (long)iVar1 & 0xffffffff;
uVar2 = (uint)((long)(int)param_1 % (long)iVar1);
}
}
auVar4._4_4_ = 0;
auVar4._0_4_ = uVar3;
auVar4._8_8_ = param_3;
return auVar4;
}
|
755 |
func0
|
#include <stdio.h>
|
int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x3,%edi
jle 1175 <func0+0x35>
mov $0x2,%ecx
test $0x1,%dil
jne 1169 <func0+0x29>
jmp 1180 <func0+0x40>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <func0+0x40>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1160 <func0+0x20>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
cmp edi, 3
jle short loc_118A
mov esi, edi
mov ecx, 2
and esi, 1
jnz short loc_1169
jmp short loc_1180
loc_1160:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1169:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1160
loc_1175:
mov eax, esi
retn
loc_1180:
mov eax, edi
cdq
idiv ecx
mov esi, eax
mov eax, esi
retn
loc_118A:
mov esi, 1
jmp short loc_1175
|
long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 3 )
return 1;
v1 = 2;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
{
while ( 1 )
{
++v1;
if ( v1 * v1 > a1 )
break;
if ( !(a1 % v1) )
return (unsigned int)(a1 / v1);
}
return v2;
}
return (unsigned int)(a1 / v1);
}
|
func0:
ENDBR64
CMP EDI,0x3
JLE 0x0010118a
MOV ESI,EDI
MOV ECX,0x2
AND ESI,0x1
JNZ 0x00101169
JMP 0x00101180
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101169:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101160
LAB_00101175:
MOV EAX,ESI
RET
LAB_00101180:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
MOV EAX,ESI
RET
LAB_0010118a:
MOV ESI,0x1
JMP 0x00101175
|
int [16] func0(uint param_1,int8 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
int auVar4 [16];
int auVar5 [16];
if ((int)param_1 < 4) {
uVar3 = 1;
}
else {
iVar1 = 2;
uVar3 = param_1 & 1;
uVar2 = uVar3;
while( true ) {
if (uVar2 == 0) {
auVar5._8_8_ = (long)(int)param_1 % (long)iVar1 & 0xffffffff;
auVar5._0_8_ = (long)(int)param_1 / (long)iVar1 & 0xffffffff;
return auVar5;
}
iVar1 = iVar1 + 1;
if ((int)param_1 < iVar1 * iVar1) break;
param_3 = (long)(int)param_1 % (long)iVar1 & 0xffffffff;
uVar2 = (uint)((long)(int)param_1 % (long)iVar1);
}
}
auVar4._4_4_ = 0;
auVar4._0_4_ = uVar3;
auVar4._8_8_ = param_3;
return auVar4;
}
|
756 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size);
assert(issame(result, size, (const int[]){2}, 1));
free(result);
result = func0(4, &size);
assert(issame(result, size, (const int[]){2, 2}, 2));
free(result);
result = func0(8, &size);
assert(issame(result, size, (const int[]){2, 2, 2}, 3));
free(result);
result = func0(3 * 19, &size);
assert(issame(result, size, (const int[]){3, 19}, 2));
free(result);
result = func0(3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 19, 19}, 4));
free(result);
result = func0(3 * 19 * 3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 3, 19, 19, 19}, 6));
free(result);
result = func0(3 * 19 * 19 * 19, &size);
assert(issame(result, size, (const int[]){3, 19, 19, 19}, 4));
free(result);
result = func0(3 * 2 * 3, &size);
assert(issame(result, size, (const int[]){2, 3, 3}, 3));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov $0x100,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x20(%rbp),%rax
movl $0x0,(%rax)
movl $0x2,-0xc(%rbp)
jmp 121d <func0+0x74>
mov -0x14(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %eax,-0x14(%rbp)
mov -0x20(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%rdx
mov %ecx,(%rdx)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,%eax
test %eax,%eax
je 11dd <func0+0x34>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 120c <func0+0x63>
cmpl $0x1,-0x14(%rbp)
jle 1253 <func0+0xaa>
mov -0x20(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%rdx
mov %ecx,(%rdx)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
mov %eax,(%rdx)
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov edi, 100h; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
mov [rbp+var_C], 2
jmp short loc_121D
loc_11DD:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_C]
mov [rbp+var_14], eax
mov rax, [rbp+var_20]
mov eax, [rax]
lea ecx, [rax+1]
mov rdx, [rbp+var_20]
mov [rdx], ecx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
loc_120C:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_C]
mov eax, edx
test eax, eax
jz short loc_11DD
add [rbp+var_C], 1
loc_121D:
mov eax, [rbp+var_C]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_120C
cmp [rbp+var_14], 1
jle short loc_1253
mov rax, [rbp+var_20]
mov eax, [rax]
lea ecx, [rax+1]
mov rdx, [rbp+var_20]
mov [rdx], ecx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_14]
mov [rdx], eax
loc_1253:
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(int a1, _DWORD *a2)
{
int v2; // eax
int v3; // eax
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v7; // [rsp+18h] [rbp-8h]
v7 = malloc(0x100uLL);
*a2 = 0;
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) )
{
a1 /= i;
v2 = (*a2)++;
v7[v2] = i;
}
}
if ( a1 > 1 )
{
v3 = (*a2)++;
v7[v3] = a1;
}
return v7;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV EDI,0x100
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0xc],0x2
JMP 0x0010121d
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + 0x1]
MOV RDX,qword ptr [RBP + -0x20]
MOV dword ptr [RDX],ECX
CDQE
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_0010120c:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0xc]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x001011dd
ADD dword ptr [RBP + -0xc],0x1
LAB_0010121d:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010120c
CMP dword ptr [RBP + -0x14],0x1
JLE 0x00101253
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + 0x1]
MOV RDX,qword ptr [RBP + -0x20]
MOV dword ptr [RDX],ECX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RDX],EAX
LAB_00101253:
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(int param_1,int *param_2)
{
int iVar1;
void *pvVar2;
int4 local_1c;
int4 local_14;
pvVar2 = malloc(0x100);
*param_2 = 0;
local_1c = param_1;
for (local_14 = 2; local_14 * local_14 <= local_1c; local_14 = local_14 + 1) {
while (local_1c % local_14 == 0) {
local_1c = local_1c / local_14;
iVar1 = *param_2;
*param_2 = iVar1 + 1;
*(int *)((long)iVar1 * 4 + (long)pvVar2) = local_14;
}
}
if (1 < local_1c) {
iVar1 = *param_2;
*param_2 = iVar1 + 1;
*(int *)((long)iVar1 * 4 + (long)pvVar2) = local_1c;
}
return pvVar2;
}
|
757 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size);
assert(issame(result, size, (const int[]){2}, 1));
free(result);
result = func0(4, &size);
assert(issame(result, size, (const int[]){2, 2}, 2));
free(result);
result = func0(8, &size);
assert(issame(result, size, (const int[]){2, 2, 2}, 3));
free(result);
result = func0(3 * 19, &size);
assert(issame(result, size, (const int[]){3, 19}, 2));
free(result);
result = func0(3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 19, 19}, 4));
free(result);
result = func0(3 * 19 * 3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 3, 19, 19, 19}, 6));
free(result);
result = func0(3 * 19 * 19 * 19, &size);
assert(issame(result, size, (const int[]){3, 19, 19, 19}, 4));
free(result);
result = func0(3 * 2 * 3, &size);
assert(issame(result, size, (const int[]){2, 3, 3}, 3));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %rsi,%rbp
mov $0x100,%edi
callq 10b0 <malloc@plt>
mov %rax,%r8
movl $0x0,0x0(%rbp)
mov $0x2,%ecx
cmp $0x3,%ebx
jg 1225 <func0+0x7c>
cmp $0x1,%ebx
jle 11ea <func0+0x41>
mov 0x0(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,0x0(%rbp)
cltq
mov %ebx,(%r8,%rax,4)
mov %r8,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
mov 0x0(%rbp),%eax
lea 0x1(%rax),%esi
movslq %esi,%rsi
mov %ebx,%eax
cltd
idiv %ecx
mov %eax,%ebx
mov %esi,%edi
mov %ecx,-0x4(%r8,%rsi,4)
add $0x1,%rsi
cltd
idiv %ecx
test %edx,%edx
je 11fd <func0+0x54>
mov %edi,0x0(%rbp)
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %ebx,%eax
jg 11d6 <func0+0x2d>
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
je 11f4 <func0+0x4b>
jmp 1219 <func0+0x70>
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov rbp, rsi
mov edi, 100h; size
call _malloc
mov r10, rax
mov dword ptr [rbp+0], 0
mov ecx, 2
cmp ebx, 3
jg short loc_122E
loc_11D6:
cmp ebx, 1
jle short loc_11EA
mov eax, [rbp+0]
lea edx, [rax+1]
mov [rbp+0], edx
cdqe
mov [r10+rax*4], ebx
loc_11EA:
mov rax, r10
add rsp, 8
pop rbx
pop rbp
retn
loc_11F4:
mov eax, [rbp+0]
lea edi, [rax+1]
movsxd rdi, edi
cdqe
lea rsi, [r10+rax*4]
loc_1203:
mov eax, ebx
cdq
idiv ecx
mov ebx, eax
mov [rsi], ecx
mov r9, rdi
add rdi, 1
add rsi, 4
cdq
idiv ecx
test edx, edx
jz short loc_1203
mov [rbp+0], r9d
loc_1222:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jg short loc_11D6
loc_122E:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jz short loc_11F4
jmp short loc_1222
|
_DWORD * func0(int a1, int *a2)
{
int v2; // ebx
_DWORD *v4; // r10
int v5; // ecx
int v6; // eax
long long v8; // rdi
int *v9; // rsi
int v10; // r9d
v2 = a1;
v4 = malloc(0x100uLL);
*a2 = 0;
v5 = 2;
if ( a1 > 3 )
{
do
{
if ( !(v2 % v5) )
{
v8 = *a2 + 1;
v9 = &v4[*a2];
do
{
v2 /= v5;
*v9 = v5;
v10 = v8++;
++v9;
}
while ( !(v2 % v5) );
*a2 = v10;
}
++v5;
}
while ( v5 * v5 <= v2 );
}
if ( v2 > 1 )
{
v6 = (*a2)++;
v4[v6] = v2;
}
return v4;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV RBP,RSI
MOV EDI,0x100
CALL 0x001010b0
MOV R10,RAX
MOV dword ptr [RBP],0x0
MOV ECX,0x2
CMP EBX,0x3
JG 0x0010122e
LAB_001011d6:
CMP EBX,0x1
JLE 0x001011ea
MOV EAX,dword ptr [RBP]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
CDQE
MOV dword ptr [R10 + RAX*0x4],EBX
LAB_001011ea:
MOV RAX,R10
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011f4:
MOV EAX,dword ptr [RBP]
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CDQE
LEA RSI,[R10 + RAX*0x4]
LAB_00101203:
MOV EAX,EBX
CDQ
IDIV ECX
MOV EBX,EAX
MOV dword ptr [RSI],ECX
MOV R9,RDI
ADD RDI,0x1
ADD RSI,0x4
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101203
MOV dword ptr [RBP],R9D
LAB_00101222:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JG 0x001011d6
LAB_0010122e:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001011f4
JMP 0x00101222
|
void * func0(int param_1,int *param_2)
{
long lVar1;
void *pvVar2;
int iVar3;
int *piVar4;
int iVar5;
pvVar2 = malloc(0x100);
*param_2 = 0;
iVar3 = 2;
if (3 < param_1) {
do {
if (param_1 % iVar3 == 0) {
iVar5 = *param_2;
piVar4 = (int *)((long)pvVar2 + (long)iVar5 * 4);
do {
iVar5 = iVar5 + 1;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar3);
*piVar4 = iVar3;
piVar4 = piVar4 + 1;
} while ((int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar3 & 0xffffffffU) % (long)iVar3) == 0);
*param_2 = iVar5;
}
iVar3 = iVar3 + 1;
} while (iVar3 * iVar3 <= param_1);
}
if (1 < param_1) {
iVar3 = *param_2;
*param_2 = iVar3 + 1;
*(int *)((long)pvVar2 + (long)iVar3 * 4) = param_1;
}
return pvVar2;
}
|
758 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size);
assert(issame(result, size, (const int[]){2}, 1));
free(result);
result = func0(4, &size);
assert(issame(result, size, (const int[]){2, 2}, 2));
free(result);
result = func0(8, &size);
assert(issame(result, size, (const int[]){2, 2, 2}, 3));
free(result);
result = func0(3 * 19, &size);
assert(issame(result, size, (const int[]){3, 19}, 2));
free(result);
result = func0(3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 19, 19}, 4));
free(result);
result = func0(3 * 19 * 3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 3, 19, 19, 19}, 6));
free(result);
result = func0(3 * 19 * 19 * 19, &size);
assert(issame(result, size, (const int[]){3, 19, 19, 19}, 4));
free(result);
result = func0(3 * 2 * 3, &size);
assert(issame(result, size, (const int[]){2, 3, 3}, 3));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %edi,%ebx
mov $0x100,%edi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov $0x2,%ecx
mov %rax,%r9
cmp $0x3,%ebx
jle 15f2 <func0+0x72>
nopl (%rax)
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 15e6 <func0+0x66>
mov 0x0(%rbp),%eax
lea 0x1(%rax),%edi
movslq %edi,%rdi
nopw 0x0(%rax,%rax,1)
mov %ebx,%eax
mov %ecx,-0x4(%r9,%rdi,4)
mov %edi,%r8d
add $0x1,%rdi
cltd
idiv %ecx
cltd
mov %eax,%ebx
idiv %ecx
test %edx,%edx
je 15c8 <func0+0x48>
mov %r8d,0x0(%rbp)
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %ebx,%eax
jle 15b0 <func0+0x30>
cmp $0x1,%ebx
jle 1605 <func0+0x85>
movslq 0x0(%rbp),%rax
lea 0x1(%rax),%edx
mov %ebx,(%r9,%rax,4)
mov %edx,0x0(%rbp)
add $0x8,%rsp
mov %r9,%rax
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov ebx, edi
mov edi, 100h; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
mov ecx, 2
mov r8, rax
cmp ebx, 3
jle short loc_15C1
nop dword ptr [rax]
loc_1580:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_15B5
mov eax, [rbp+0]
lea esi, [rax+1]
movsxd rsi, esi
nop word ptr [rax+rax+00h]
loc_1598:
mov eax, ebx
mov [r8+rsi*4-4], ecx
mov rdi, rsi
add rsi, 1
cdq
idiv ecx
cdq
mov ebx, eax
idiv ecx
test edx, edx
jz short loc_1598
mov [rbp+0], edi
loc_15B5:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jle short loc_1580
loc_15C1:
cmp ebx, 1
jle short loc_15D4
movsxd rax, dword ptr [rbp+0]
lea edx, [rax+1]
mov [r8+rax*4], ebx
mov [rbp+0], edx
loc_15D4:
add rsp, 8
mov rax, r8
pop rbx
pop rbp
retn
|
_DWORD * func0(int a1, int *a2)
{
int v3; // ebx
_DWORD *v4; // rax
int v5; // ecx
_DWORD *v6; // r8
long long v7; // rsi
int v8; // edi
int v9; // edx
long long v10; // rax
v3 = a1;
v4 = malloc(0x100uLL);
*a2 = 0;
v5 = 2;
v6 = v4;
if ( a1 > 3 )
{
do
{
if ( !(v3 % v5) )
{
v7 = *a2 + 1;
do
{
v4[v7 - 1] = v5;
v8 = v7++;
v9 = (v3 / v5) >> 31;
v3 /= v5;
}
while ( !(unsigned int)(__SPAIR64__(v9, v3) % v5) );
*a2 = v8;
}
++v5;
}
while ( v5 * v5 <= v3 );
}
if ( v3 > 1 )
{
v10 = *a2;
v6[v10] = v3;
*a2 = v10 + 1;
}
return v6;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV EBX,EDI
MOV EDI,0x100
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
MOV ECX,0x2
MOV R8,RAX
CMP EBX,0x3
JLE 0x001015c1
NOP dword ptr [RAX]
LAB_00101580:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001015b5
MOV EAX,dword ptr [RBP]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101598:
MOV EAX,EBX
MOV dword ptr [R8 + RSI*0x4 + -0x4],ECX
MOV RDI,RSI
ADD RSI,0x1
CDQ
IDIV ECX
CDQ
MOV EBX,EAX
IDIV ECX
TEST EDX,EDX
JZ 0x00101598
MOV dword ptr [RBP],EDI
LAB_001015b5:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JLE 0x00101580
LAB_001015c1:
CMP EBX,0x1
JLE 0x001015d4
MOVSXD RAX,dword ptr [RBP]
LEA EDX,[RAX + 0x1]
MOV dword ptr [R8 + RAX*0x4],EBX
MOV dword ptr [RBP],EDX
LAB_001015d4:
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
RET
|
void * func0(int param_1,int *param_2)
{
long lVar1;
long lVar2;
void *pvVar3;
int iVar4;
long lVar5;
pvVar3 = malloc(0x100);
*param_2 = 0;
iVar4 = 2;
if (3 < param_1) {
do {
if (param_1 % iVar4 == 0) {
lVar2 = (long)(*param_2 + 1);
do {
lVar5 = lVar2;
*(int *)((long)pvVar3 + lVar5 * 4 + -4) = iVar4;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar4);
lVar2 = lVar5 + 1;
} while ((int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar4 & 0xffffffffU) % (long)iVar4) == 0);
*param_2 = (int)lVar5;
}
iVar4 = iVar4 + 1;
} while (iVar4 * iVar4 <= param_1);
}
if (1 < param_1) {
iVar4 = *param_2;
*(int *)((long)pvVar3 + (long)iVar4 * 4) = param_1;
*param_2 = iVar4 + 1;
}
return pvVar3;
}
|
759 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
}
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size);
assert(issame(result, size, (const int[]){2}, 1));
free(result);
result = func0(4, &size);
assert(issame(result, size, (const int[]){2, 2}, 2));
free(result);
result = func0(8, &size);
assert(issame(result, size, (const int[]){2, 2, 2}, 3));
free(result);
result = func0(3 * 19, &size);
assert(issame(result, size, (const int[]){3, 19}, 2));
free(result);
result = func0(3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 19, 19}, 4));
free(result);
result = func0(3 * 19 * 3 * 19 * 3 * 19, &size);
assert(issame(result, size, (const int[]){3, 3, 3, 19, 19, 19}, 6));
free(result);
result = func0(3 * 19 * 19 * 19, &size);
assert(issame(result, size, (const int[]){3, 19, 19, 19}, 4));
free(result);
result = func0(3 * 2 * 3, &size);
assert(issame(result, size, (const int[]){2, 3, 3}, 3));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %edi,%ebx
mov $0x100,%edi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov $0x2,%ecx
mov %rax,%r9
cmp $0x3,%ebx
jle 15d2 <func0+0x72>
nopl (%rax)
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 15c6 <func0+0x66>
mov 0x0(%rbp),%eax
lea 0x1(%rax),%edi
movslq %edi,%rdi
nopw 0x0(%rax,%rax,1)
mov %ebx,%eax
mov %ecx,-0x4(%r9,%rdi,4)
mov %edi,%r8d
add $0x1,%rdi
cltd
idiv %ecx
cltd
mov %eax,%ebx
idiv %ecx
test %edx,%edx
je 15a8 <func0+0x48>
mov %r8d,0x0(%rbp)
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %ebx,%eax
jle 1590 <func0+0x30>
cmp $0x1,%ebx
jle 15e5 <func0+0x85>
movslq 0x0(%rbp),%rax
lea 0x1(%rax),%edx
mov %ebx,(%r9,%rax,4)
mov %edx,0x0(%rbp)
add $0x8,%rsp
mov %r9,%rax
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov ebx, edi
mov edi, 100h; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
mov ecx, 2
mov r8, rax
cmp ebx, 3
jle short loc_15C1
nop dword ptr [rax]
loc_1580:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_15B5
mov eax, [rbp+0]
lea esi, [rax+1]
movsxd rsi, esi
nop word ptr [rax+rax+00h]
loc_1598:
mov eax, ebx
mov [r8+rsi*4-4], ecx
mov rdi, rsi
add rsi, 1
cdq
idiv ecx
cdq
mov ebx, eax
idiv ecx
test edx, edx
jz short loc_1598
mov [rbp+0], edi
loc_15B5:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jle short loc_1580
loc_15C1:
cmp ebx, 1
jle short loc_15D4
movsxd rax, dword ptr [rbp+0]
lea edx, [rax+1]
mov [r8+rax*4], ebx
mov [rbp+0], edx
loc_15D4:
add rsp, 8
mov rax, r8
pop rbx
pop rbp
retn
|
_DWORD * func0(int a1, int *a2)
{
int v3; // ebx
_DWORD *v4; // rax
int v5; // ecx
_DWORD *v6; // r8
long long v7; // rsi
int v8; // edi
int v9; // edx
long long v10; // rax
v3 = a1;
v4 = malloc(0x100uLL);
*a2 = 0;
v5 = 2;
v6 = v4;
if ( a1 > 3 )
{
do
{
if ( !(v3 % v5) )
{
v7 = *a2 + 1;
do
{
v4[v7 - 1] = v5;
v8 = v7++;
v9 = (v3 / v5) >> 31;
v3 /= v5;
}
while ( !(unsigned int)(__SPAIR64__(v9, v3) % v5) );
*a2 = v8;
}
++v5;
}
while ( v5 * v5 <= v3 );
}
if ( v3 > 1 )
{
v10 = *a2;
v6[v10] = v3;
*a2 = v10 + 1;
}
return v6;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV EBX,EDI
MOV EDI,0x100
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
MOV ECX,0x2
MOV R8,RAX
CMP EBX,0x3
JLE 0x001015c1
NOP dword ptr [RAX]
LAB_00101580:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001015b5
MOV EAX,dword ptr [RBP]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101598:
MOV EAX,EBX
MOV dword ptr [R8 + RSI*0x4 + -0x4],ECX
MOV RDI,RSI
ADD RSI,0x1
CDQ
IDIV ECX
CDQ
MOV EBX,EAX
IDIV ECX
TEST EDX,EDX
JZ 0x00101598
MOV dword ptr [RBP],EDI
LAB_001015b5:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JLE 0x00101580
LAB_001015c1:
CMP EBX,0x1
JLE 0x001015d4
MOVSXD RAX,dword ptr [RBP]
LEA EDX,[RAX + 0x1]
MOV dword ptr [R8 + RAX*0x4],EBX
MOV dword ptr [RBP],EDX
LAB_001015d4:
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
RET
|
void * func0(int param_1,int *param_2)
{
long lVar1;
long lVar2;
void *pvVar3;
int iVar4;
long lVar5;
pvVar3 = malloc(0x100);
*param_2 = 0;
iVar4 = 2;
if (3 < param_1) {
do {
if (param_1 % iVar4 == 0) {
lVar2 = (long)(*param_2 + 1);
do {
lVar5 = lVar2;
*(int *)((long)pvVar3 + lVar5 * 4 + -4) = iVar4;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar4);
lVar2 = lVar5 + 1;
} while ((int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar4 & 0xffffffffU) % (long)iVar4) == 0);
*param_2 = (int)lVar5;
}
iVar4 = iVar4 + 1;
} while (iVar4 * iVar4 <= param_1);
}
if (1 < param_1) {
iVar4 = *param_2;
*(int *)((long)pvVar3 + (long)iVar4 * 4) = param_1;
*param_2 = iVar4 + 1;
}
return pvVar3;
}
|
760 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (in_has2) continue;
int in_has1 = 0;
for (int j = 0; j < has1_count; j++) {
if (has1[j] == num) {
in_has1 = 1;
break;
}
}
if (in_has1) {
has2[has2_count++] = num;
} else {
has1[has1_count++] = num;
}
}
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (!in_has2) {
out[out_count++] = num;
}
}
*new_size = out_count;
free(has1);
free(has2);
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new_size);
assert(issame(result, new_size, (const int[]){}, 0));
free(result);
result = func0((const int[]){1, 2, 3, 4}, 4, &new_size);
assert(issame(result, new_size, (const int[]){1, 2, 3, 4}, 4));
free(result);
result = func0((const int[]){1, 2, 3, 2, 4, 3, 5}, 7, &new_size);
assert(issame(result, new_size, (const int[]){1, 4, 5}, 3));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %rdx,-0x68(%rbp)
mov -0x5c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x18(%rbp)
mov -0x5c(%rbp),%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10c0 <calloc@plt>
mov %rax,-0x10(%rbp)
mov -0x5c(%rbp),%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10c0 <calloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x4c(%rbp)
movl $0x0,-0x48(%rbp)
movl $0x0,-0x44(%rbp)
movl $0x0,-0x40(%rbp)
jmpq 1332 <func0+0x169>
mov -0x40(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x1c(%rbp)
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x38(%rbp)
jmp 1293 <func0+0xca>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
jne 128f <func0+0xc6>
movl $0x1,-0x3c(%rbp)
jmp 129b <func0+0xd2>
addl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x48(%rbp),%eax
jl 126b <func0+0xa2>
cmpl $0x0,-0x3c(%rbp)
jne 132d <func0+0x164>
movl $0x0,-0x34(%rbp)
movl $0x0,-0x30(%rbp)
jmp 12dd <func0+0x114>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
jne 12d9 <func0+0x110>
movl $0x1,-0x34(%rbp)
jmp 12e5 <func0+0x11c>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 12b5 <func0+0xec>
cmpl $0x0,-0x34(%rbp)
je 130c <func0+0x143>
mov -0x48(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x48(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rdx)
jmp 132e <func0+0x165>
mov -0x4c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4c(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rdx)
jmp 132e <func0+0x165>
addl $0x1,-0x40(%rbp)
mov -0x40(%rbp),%eax
cmp -0x5c(%rbp),%eax
jl 1242 <func0+0x79>
movl $0x0,-0x2c(%rbp)
jmpq 13cc <func0+0x203>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x20(%rbp)
movl $0x0,-0x28(%rbp)
movl $0x0,-0x24(%rbp)
jmp 139b <func0+0x1d2>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jne 1397 <func0+0x1ce>
movl $0x1,-0x28(%rbp)
jmp 13a3 <func0+0x1da>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x48(%rbp),%eax
jl 1373 <func0+0x1aa>
cmpl $0x0,-0x28(%rbp)
jne 13c8 <func0+0x1ff>
mov -0x44(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x44(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x5c(%rbp),%eax
jl 134a <func0+0x181>
mov -0x68(%rbp),%rax
mov -0x44(%rbp),%edx
mov %edx,(%rax)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x18(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov [rbp+var_68], rdx
mov eax, [rbp+var_5C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov eax, [rbp+var_5C]
cdqe
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbp+ptr], rax
mov eax, [rbp+var_5C]
cdqe
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbp+var_8], rax
mov [rbp+var_4C], 0
mov [rbp+var_48], 0
mov [rbp+var_44], 0
mov [rbp+var_40], 0
jmp loc_1332
loc_1242:
mov eax, [rbp+var_40]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
mov [rbp+var_1C], eax
mov [rbp+var_3C], 0
mov [rbp+var_38], 0
jmp short loc_1293
loc_126B:
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_1C], eax
jnz short loc_128F
mov [rbp+var_3C], 1
jmp short loc_129B
loc_128F:
add [rbp+var_38], 1
loc_1293:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_48]
jl short loc_126B
loc_129B:
cmp [rbp+var_3C], 0
jnz loc_132D
mov [rbp+var_34], 0
mov [rbp+var_30], 0
jmp short loc_12DD
loc_12B5:
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_1C], eax
jnz short loc_12D9
mov [rbp+var_34], 1
jmp short loc_12E5
loc_12D9:
add [rbp+var_30], 1
loc_12DD:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_4C]
jl short loc_12B5
loc_12E5:
cmp [rbp+var_34], 0
jz short loc_130C
mov eax, [rbp+var_48]
lea edx, [rax+1]
mov [rbp+var_48], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_1C]
mov [rdx], eax
jmp short loc_132E
loc_130C:
mov eax, [rbp+var_4C]
lea edx, [rax+1]
mov [rbp+var_4C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_1C]
mov [rdx], eax
jmp short loc_132E
loc_132D:
nop
loc_132E:
add [rbp+var_40], 1
loc_1332:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_5C]
jl loc_1242
mov [rbp+var_2C], 0
jmp loc_13CC
loc_134A:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
mov [rbp+var_20], eax
mov [rbp+var_28], 0
mov [rbp+var_24], 0
jmp short loc_139B
loc_1373:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jnz short loc_1397
mov [rbp+var_28], 1
jmp short loc_13A3
loc_1397:
add [rbp+var_24], 1
loc_139B:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_48]
jl short loc_1373
loc_13A3:
cmp [rbp+var_28], 0
jnz short loc_13C8
mov eax, [rbp+var_44]
lea edx, [rax+1]
mov [rbp+var_44], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_20]
mov [rdx], eax
loc_13C8:
add [rbp+var_2C], 1
loc_13CC:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_5C]
jl loc_134A
mov rax, [rbp+var_68]
mov edx, [rbp+var_44]
mov [rax], edx
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_18]
leave
retn
|
_DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
_DWORD *v4; // rdx
int v5; // eax
int v6; // eax
int v9; // [rsp+24h] [rbp-4Ch]
int v10; // [rsp+28h] [rbp-48h]
int v11; // [rsp+2Ch] [rbp-44h]
int i; // [rsp+30h] [rbp-40h]
int v13; // [rsp+34h] [rbp-3Ch]
int j; // [rsp+38h] [rbp-38h]
int v15; // [rsp+3Ch] [rbp-34h]
int k; // [rsp+40h] [rbp-30h]
int m; // [rsp+44h] [rbp-2Ch]
int v18; // [rsp+48h] [rbp-28h]
int n; // [rsp+4Ch] [rbp-24h]
int v20; // [rsp+50h] [rbp-20h]
int v21; // [rsp+54h] [rbp-1Ch]
_DWORD *v22; // [rsp+58h] [rbp-18h]
_DWORD *ptr; // [rsp+60h] [rbp-10h]
_DWORD *v24; // [rsp+68h] [rbp-8h]
v22 = malloc(4LL * a2);
ptr = calloc(a2, 4uLL);
v24 = calloc(a2, 4uLL);
v9 = 0;
v10 = 0;
v11 = 0;
for ( i = 0; i < a2; ++i )
{
v21 = *(_DWORD *)(4LL * i + a1);
v13 = 0;
for ( j = 0; j < v10; ++j )
{
if ( v21 == v24[j] )
{
v13 = 1;
break;
}
}
if ( !v13 )
{
v15 = 0;
for ( k = 0; k < v9; ++k )
{
if ( v21 == ptr[k] )
{
v15 = 1;
break;
}
}
if ( v15 )
{
v3 = v10++;
v4 = &v24[v3];
}
else
{
v5 = v9++;
v4 = &ptr[v5];
}
*v4 = v21;
}
}
for ( m = 0; m < a2; ++m )
{
v20 = *(_DWORD *)(4LL * m + a1);
v18 = 0;
for ( n = 0; n < v10; ++n )
{
if ( v20 == v24[n] )
{
v18 = 1;
break;
}
}
if ( !v18 )
{
v6 = v11++;
v22[v6] = v20;
}
}
*a3 = v11;
free(ptr);
free(v24);
return v22;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV qword ptr [RBP + -0x68],RDX
MOV EAX,dword ptr [RBP + -0x5c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x5c]
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x5c]
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x4c],0x0
MOV dword ptr [RBP + -0x48],0x0
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101332
LAB_00101242:
MOV EAX,dword ptr [RBP + -0x40]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x3c],0x0
MOV dword ptr [RBP + -0x38],0x0
JMP 0x00101293
LAB_0010126b:
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
JNZ 0x0010128f
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x0010129b
LAB_0010128f:
ADD dword ptr [RBP + -0x38],0x1
LAB_00101293:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x48]
JL 0x0010126b
LAB_0010129b:
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x0010132d
MOV dword ptr [RBP + -0x34],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001012dd
LAB_001012b5:
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
JNZ 0x001012d9
MOV dword ptr [RBP + -0x34],0x1
JMP 0x001012e5
LAB_001012d9:
ADD dword ptr [RBP + -0x30],0x1
LAB_001012dd:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x001012b5
LAB_001012e5:
CMP dword ptr [RBP + -0x34],0x0
JZ 0x0010130c
MOV EAX,dword ptr [RBP + -0x48]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x48],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX],EAX
JMP 0x0010132e
LAB_0010130c:
MOV EAX,dword ptr [RBP + -0x4c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4c],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX],EAX
JMP 0x0010132e
LAB_0010132d:
NOP
LAB_0010132e:
ADD dword ptr [RBP + -0x40],0x1
LAB_00101332:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x00101242
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001013cc
LAB_0010134a:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010139b
LAB_00101373:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JNZ 0x00101397
MOV dword ptr [RBP + -0x28],0x1
JMP 0x001013a3
LAB_00101397:
ADD dword ptr [RBP + -0x24],0x1
LAB_0010139b:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x48]
JL 0x00101373
LAB_001013a3:
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x001013c8
MOV EAX,dword ptr [RBP + -0x44]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x44],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RDX],EAX
LAB_001013c8:
ADD dword ptr [RBP + -0x2c],0x1
LAB_001013cc:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x0010134a
MOV RAX,qword ptr [RBP + -0x68]
MOV EDX,dword ptr [RBP + -0x44]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x18]
LEAVE
RET
|
void * func0(long param_1,int param_2,int *param_3)
{
int iVar1;
bool bVar2;
void *pvVar3;
void *__ptr;
void *__ptr_00;
int4 local_54;
int4 local_50;
int4 local_4c;
int4 local_48;
int4 local_40;
int4 local_38;
int4 local_34;
int4 local_2c;
pvVar3 = malloc((long)param_2 << 2);
__ptr = calloc((long)param_2,4);
__ptr_00 = calloc((long)param_2,4);
local_54 = 0;
local_50 = 0;
local_4c = 0;
for (local_48 = 0; local_48 < param_2; local_48 = local_48 + 1) {
iVar1 = *(int *)(param_1 + (long)local_48 * 4);
bVar2 = false;
for (local_40 = 0; local_40 < local_50; local_40 = local_40 + 1) {
if (iVar1 == *(int *)((long)__ptr_00 + (long)local_40 * 4)) {
bVar2 = true;
break;
}
}
if (!bVar2) {
bVar2 = false;
for (local_38 = 0; local_38 < local_54; local_38 = local_38 + 1) {
if (iVar1 == *(int *)((long)__ptr + (long)local_38 * 4)) {
bVar2 = true;
break;
}
}
if (bVar2) {
*(int *)((long)local_50 * 4 + (long)__ptr_00) = iVar1;
local_50 = local_50 + 1;
}
else {
*(int *)((long)local_54 * 4 + (long)__ptr) = iVar1;
local_54 = local_54 + 1;
}
}
}
local_34 = 0;
do {
if (param_2 <= local_34) {
*param_3 = local_4c;
free(__ptr);
free(__ptr_00);
return pvVar3;
}
iVar1 = *(int *)(param_1 + (long)local_34 * 4);
bVar2 = false;
for (local_2c = 0; local_2c < local_50; local_2c = local_2c + 1) {
if (iVar1 == *(int *)((long)__ptr_00 + (long)local_2c * 4)) {
bVar2 = true;
break;
}
}
if (!bVar2) {
*(int *)((long)local_4c * 4 + (long)pvVar3) = iVar1;
local_4c = local_4c + 1;
}
local_34 = local_34 + 1;
} while( true );
}
|
761 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (in_has2) continue;
int in_has1 = 0;
for (int j = 0; j < has1_count; j++) {
if (has1[j] == num) {
in_has1 = 1;
break;
}
}
if (in_has1) {
has2[has2_count++] = num;
} else {
has1[has1_count++] = num;
}
}
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (!in_has2) {
out[out_count++] = num;
}
}
*new_size = out_count;
free(has1);
free(has2);
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new_size);
assert(issame(result, new_size, (const int[]){}, 0));
free(result);
result = func0((const int[]){1, 2, 3, 4}, 4, &new_size);
assert(issame(result, new_size, (const int[]){1, 2, 3, 4}, 4));
free(result);
result = func0((const int[]){1, 2, 3, 2, 4, 3, 5}, 7, &new_size);
assert(issame(result, new_size, (const int[]){1, 4, 5}, 3));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r14
mov %esi,%r15d
mov %rdx,%r13
movslq %esi,%rbx
lea 0x0(,%rbx,4),%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
mov $0x4,%esi
mov %rbx,%rdi
callq 10c0 <calloc@plt>
mov %rax,%rbp
mov $0x4,%esi
mov %rbx,%rdi
callq 10c0 <calloc@plt>
mov %rax,%rbx
test %r15d,%r15d
jle 1255 <func0+0x8c>
mov %r14,%rsi
lea -0x1(%r15),%eax
lea 0x4(%r14,%rax,4),%rdi
mov $0x0,%r8d
mov $0x0,%r9d
lea 0x4(%rbp),%r11
lea 0x4(%rbx),%r10
jmpq 12d2 <func0+0x109>
mov %rbx,%r10
lea -0x1(%r8),%eax
lea 0x4(%rbx,%rax,4),%rcx
mov $0x0,%r9d
jmp 1295 <func0+0xcc>
mov $0x0,%r9d
mov %r9d,0x0(%r13)
mov %rbp,%rdi
callq 1090 <free@plt>
mov %rbx,%rdi
callq 1090 <free@plt>
mov %r12,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq %r9d,%rax
mov %edx,(%r12,%rax,4)
lea 0x1(%r9),%r9d
add $0x4,%rsi
cmp %rdi,%rsi
je 125b <func0+0x92>
mov (%rsi),%edx
test %r8d,%r8d
jle 1281 <func0+0xb8>
mov %r10,%rax
cmp %edx,(%rax)
je 128c <func0+0xc3>
add $0x4,%rax
cmp %rax,%rcx
jne 129f <func0+0xd6>
jmp 1281 <func0+0xb8>
movslq %r8d,%rax
mov %edx,(%rbx,%rax,4)
lea 0x1(%r8),%r8d
jmp 12c5 <func0+0xfc>
movslq %r9d,%rax
mov %edx,0x0(%rbp,%rax,4)
lea 0x1(%r9),%r9d
add $0x4,%r14
cmp %rdi,%r14
je 1241 <func0+0x78>
mov (%r14),%edx
test %r8d,%r8d
jle 12f2 <func0+0x129>
mov %rbx,%rax
lea -0x1(%r8),%ecx
lea (%r10,%rcx,4),%rcx
cmp %edx,(%rax)
je 12c5 <func0+0xfc>
add $0x4,%rax
cmp %rcx,%rax
jne 12e5 <func0+0x11c>
test %r9d,%r9d
jle 12ba <func0+0xf1>
mov %rbp,%rax
lea -0x1(%r9),%ecx
lea (%r11,%rcx,4),%rcx
cmp %edx,(%rax)
je 12ae <func0+0xe5>
add $0x4,%rax
cmp %rcx,%rax
jne 1302 <func0+0x139>
jmp 12ba <func0+0xf1>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r15d, esi
mov [rsp+48h+var_40], rdx
movsxd rbp, esi
lea r12, ds:0[rbp*4]
mov rdi, r12; size
call _malloc
mov r14, rax
mov esi, 4; size
mov rdi, rbp; nmemb
call _calloc
mov r13, rax
mov esi, 4; size
mov rdi, rbp; nmemb
call _calloc
mov rbp, rax
test r15d, r15d
jle loc_12C6
mov rsi, rbx
add r12, rbx
mov edi, 0
mov r8d, 0
jmp short loc_124D
loc_1238:
movsxd rax, r8d
mov [r13+rax*4+0], edx
lea r8d, [r8+1]
loc_1244:
add rbx, 4
cmp rbx, r12
jz short loc_128A
loc_124D:
mov edx, [rbx]
test edi, edi
jle short loc_126B
mov rax, rbp
movsxd rcx, edi
lea rcx, [rbp+rcx*4+0]
loc_125E:
cmp [rax], edx
jz short loc_1244
add rax, 4
cmp rax, rcx
jnz short loc_125E
loc_126B:
test r8d, r8d
jle short loc_1238
mov rax, r13
movsxd rcx, r8d
lea rcx, [r13+rcx*4+0]
loc_127B:
cmp [rax], edx
jz short loc_12F6
add rax, 4
cmp rax, rcx
jnz short loc_127B
jmp short loc_1238
loc_128A:
movsxd rax, edi
lea rcx, [rbp+rax*4+0]
mov r8d, 0
jmp short loc_12AE
loc_129A:
movsxd rax, r8d
mov [r14+rax*4], edx
lea r8d, [r8+1]
loc_12A5:
add rsi, 4
cmp rsi, r12
jz short loc_12CC
loc_12AE:
mov edx, [rsi]
test edi, edi
jle short loc_129A
mov rax, rbp
loc_12B7:
cmp [rax], edx
jz short loc_12A5
add rax, 4
cmp rcx, rax
jnz short loc_12B7
jmp short loc_129A
loc_12C6:
mov r8d, 0
loc_12CC:
mov rax, [rsp+48h+var_40]
mov [rax], r8d
mov rdi, r13; ptr
call _free
mov rdi, rbp; ptr
call _free
mov rax, r14
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12F6:
movsxd rax, edi
mov [rbp+rax*4+0], edx
lea edi, [rdi+1]
jmp loc_1244
|
_DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int *v3; // rbx
size_t v4; // r12
_DWORD *v5; // r14
_DWORD *v6; // r13
_DWORD *v7; // rbp
int *v8; // rsi
int *v9; // r12
int v10; // edi
int v11; // r8d
int v12; // edx
_DWORD *v13; // rax
_DWORD *v14; // rax
int v15; // r8d
int v16; // edx
_DWORD *v17; // rax
v3 = a1;
v4 = a2;
v5 = malloc(v4 * 4);
v6 = calloc(a2, 4uLL);
v7 = calloc(a2, 4uLL);
if ( a2 <= 0 )
{
v15 = 0;
}
else
{
v8 = a1;
v9 = &a1[v4];
v10 = 0;
v11 = 0;
do
{
v12 = *v3;
if ( v10 <= 0 )
{
LABEL_9:
if ( v11 <= 0 )
{
LABEL_3:
v6[v11++] = v12;
}
else
{
v14 = v6;
while ( *v14 != v12 )
{
if ( ++v14 == &v6[v11] )
goto LABEL_3;
}
v7[v10++] = v12;
}
}
else
{
v13 = v7;
while ( *v13 != v12 )
{
if ( ++v13 == &v7[v10] )
goto LABEL_9;
}
}
++v3;
}
while ( v3 != v9 );
v15 = 0;
do
{
v16 = *v8;
if ( v10 <= 0 )
{
LABEL_15:
v5[v15++] = v16;
}
else
{
v17 = v7;
while ( *v17 != v16 )
{
if ( &v7[v10] == ++v17 )
goto LABEL_15;
}
}
++v8;
}
while ( v8 != v9 );
}
*a3 = v15;
free(v6);
free(v7);
return v5;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R15D,ESI
MOV qword ptr [RSP + 0x8],RDX
MOVSXD RBP,ESI
LEA R12,[RBP*0x4]
MOV RDI,R12
CALL 0x001010d0
MOV R14,RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x001010c0
MOV R13,RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x001010c0
MOV RBP,RAX
TEST R15D,R15D
JLE 0x001012c6
MOV RSI,RBX
ADD R12,RBX
MOV EDI,0x0
MOV R8D,0x0
JMP 0x0010124d
LAB_00101238:
MOVSXD RAX,R8D
MOV dword ptr [R13 + RAX*0x4],EDX
LEA R8D,[R8 + 0x1]
LAB_00101244:
ADD RBX,0x4
CMP RBX,R12
JZ 0x0010128a
LAB_0010124d:
MOV EDX,dword ptr [RBX]
TEST EDI,EDI
JLE 0x0010126b
MOV RAX,RBP
MOVSXD RCX,EDI
LEA RCX,[RBP + RCX*0x4]
LAB_0010125e:
CMP dword ptr [RAX],EDX
JZ 0x00101244
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010125e
LAB_0010126b:
TEST R8D,R8D
JLE 0x00101238
MOV RAX,R13
MOVSXD RCX,R8D
LEA RCX,[R13 + RCX*0x4]
LAB_0010127b:
CMP dword ptr [RAX],EDX
JZ 0x001012f6
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010127b
JMP 0x00101238
LAB_0010128a:
MOVSXD RAX,EDI
LEA RCX,[RBP + RAX*0x4]
MOV R8D,0x0
JMP 0x001012ae
LAB_0010129a:
MOVSXD RAX,R8D
MOV dword ptr [R14 + RAX*0x4],EDX
LEA R8D,[R8 + 0x1]
LAB_001012a5:
ADD RSI,0x4
CMP RSI,R12
JZ 0x001012cc
LAB_001012ae:
MOV EDX,dword ptr [RSI]
TEST EDI,EDI
JLE 0x0010129a
MOV RAX,RBP
LAB_001012b7:
CMP dword ptr [RAX],EDX
JZ 0x001012a5
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x001012b7
JMP 0x0010129a
LAB_001012c6:
MOV R8D,0x0
LAB_001012cc:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R8D
MOV RDI,R13
CALL 0x00101090
MOV RDI,RBP
CALL 0x00101090
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012f6:
MOVSXD RAX,EDI
MOV dword ptr [RBP + RAX*0x4],EDX
LEA EDI,[RDI + 0x1]
JMP 0x00101244
|
void * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
int *__ptr;
int *__ptr_00;
int *piVar3;
int *piVar4;
size_t __nmemb;
int iVar5;
int iVar6;
int *piVar7;
__nmemb = (size_t)param_2;
pvVar2 = malloc(__nmemb * 4);
__ptr = (int *)calloc(__nmemb,4);
__ptr_00 = (int *)calloc(__nmemb,4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar7 = param_1 + __nmemb;
iVar5 = 0;
iVar6 = 0;
piVar4 = param_1;
do {
iVar1 = *piVar4;
if (0 < iVar5) {
piVar3 = __ptr_00;
do {
if (*piVar3 == iVar1) goto LAB_00101244;
piVar3 = piVar3 + 1;
} while (piVar3 != __ptr_00 + iVar5);
}
if (0 < iVar6) {
piVar3 = __ptr;
do {
if (*piVar3 == iVar1) {
__ptr_00[iVar5] = iVar1;
iVar5 = iVar5 + 1;
goto LAB_00101244;
}
piVar3 = piVar3 + 1;
} while (piVar3 != __ptr + iVar6);
}
__ptr[iVar6] = iVar1;
iVar6 = iVar6 + 1;
LAB_00101244:
piVar4 = piVar4 + 1;
} while (piVar4 != piVar7);
iVar6 = 0;
do {
piVar4 = __ptr_00;
if (0 < iVar5) {
do {
if (*piVar4 == *param_1) goto LAB_001012a5;
piVar4 = piVar4 + 1;
} while (__ptr_00 + iVar5 != piVar4);
}
*(int *)((long)pvVar2 + (long)iVar6 * 4) = *param_1;
iVar6 = iVar6 + 1;
LAB_001012a5:
param_1 = param_1 + 1;
} while (param_1 != piVar7);
}
*param_3 = iVar6;
free(__ptr);
free(__ptr_00);
return pvVar2;
}
|
762 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (in_has2) continue;
int in_has1 = 0;
for (int j = 0; j < has1_count; j++) {
if (has1[j] == num) {
in_has1 = 1;
break;
}
}
if (in_has1) {
has2[has2_count++] = num;
} else {
has1[has1_count++] = num;
}
}
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (!in_has2) {
out[out_count++] = num;
}
}
*new_size = out_count;
free(has1);
free(has2);
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new_size);
assert(issame(result, new_size, (const int[]){}, 0));
free(result);
result = func0((const int[]){1, 2, 3, 4}, 4, &new_size);
assert(issame(result, new_size, (const int[]){1, 2, 3, 4}, 4));
free(result);
result = func0((const int[]){1, 2, 3, 2, 4, 3, 5}, 7, &new_size);
assert(issame(result, new_size, (const int[]){1, 4, 5}, 3));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
movslq %esi,%r13
push %r12
lea 0x0(,%r13,4),%rdi
mov %r13,%r14
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %r13,%rdi
mov $0x4,%esi
mov %rax,%r12
callq 10c0 <calloc@plt>
mov %r13,%rdi
mov $0x4,%esi
mov %rax,%rbp
callq 10c0 <calloc@plt>
mov %rax,%r13
test %r14d,%r14d
jle 1555 <func0+0x185>
lea -0x1(%r14),%eax
mov %r15,%r8
mov %r15,%r9
xor %edx,%edx
lea 0x4(%r15,%rax,4),%rax
xor %r10d,%r10d
lea 0x4(%r13),%r11
lea 0x4(%rbp),%r14
nopl 0x0(%rax,%rax,1)
mov (%r9),%esi
test %edx,%edx
je 14d0 <func0+0x100>
lea -0x1(%rdx),%edi
mov %r13,%rcx
lea (%r11,%rdi,4),%rdi
jmp 1469 <func0+0x99>
add $0x4,%rcx
cmp %rdi,%rcx
je 14d0 <func0+0x100>
cmp %esi,(%rcx)
jne 1460 <func0+0x90>
add $0x4,%r9
cmp %rax,%r9
jne 1448 <func0+0x78>
lea -0x1(%rdx),%ecx
xor %r9d,%r9d
lea (%r11,%rcx,4),%rdi
mov (%r8),%esi
test %edx,%edx
je 1518 <func0+0x148>
mov %r13,%rcx
jmp 1499 <func0+0xc9>
add $0x4,%rcx
cmp %rcx,%rdi
je 1518 <func0+0x148>
cmp %esi,(%rcx)
jne 1490 <func0+0xc0>
add $0x4,%r8
cmp %rax,%r8
jne 1480 <func0+0xb0>
mov %r9d,(%rbx)
mov %rbp,%rdi
callq 1090 <free@plt>
mov %r13,%rdi
callq 1090 <free@plt>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
test %r10d,%r10d
je 1538 <func0+0x168>
lea -0x1(%r10),%edi
mov %rbp,%rcx
lea (%r14,%rdi,4),%rdi
jmp 14f1 <func0+0x121>
nopw 0x0(%rax,%rax,1)
add $0x4,%rcx
cmp %rdi,%rcx
je 1538 <func0+0x168>
cmp %esi,(%rcx)
jne 14e8 <func0+0x118>
movslq %edx,%rcx
add $0x4,%r9
add $0x1,%edx
mov %esi,0x0(%r13,%rcx,4)
cmp %rax,%r9
jne 1448 <func0+0x78>
jmpq 1476 <func0+0xa6>
nopw 0x0(%rax,%rax,1)
movslq %r9d,%rcx
add $0x4,%r8
add $0x1,%r9d
mov %esi,(%r12,%rcx,4)
cmp %rax,%r8
jne 1480 <func0+0xb0>
jmpq 14a6 <func0+0xd6>
nopl (%rax)
movslq %r10d,%rcx
add $0x4,%r9
add $0x1,%r10d
mov %esi,0x0(%rbp,%rcx,4)
cmp %rax,%r9
jne 1448 <func0+0x78>
jmpq 1476 <func0+0xa6>
xor %r9d,%r9d
jmpq 14a6 <func0+0xd6>
nopl (%rax)
|
func0:
endbr64
push r15
push r14
push r13
movsxd r13, esi
push r12
lea r15, ds:0[r13*4]
mov r12, rdx
mov r14, r13
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
mov rdi, r15; size
call _malloc
mov rdi, r13; nmemb
mov esi, 4; size
mov rbp, rax
call _calloc
mov rdi, r13; nmemb
mov esi, 4; size
mov rbx, rax
call _calloc
mov r13, rax
test r14d, r14d
jle loc_151A
mov rsi, [rsp+48h+var_40]
xor r9d, r9d
xor r10d, r10d
xor r11d, r11d
lea r8, [rsi+r15]
mov rdi, rsi
nop dword ptr [rax+00000000h]
loc_1418:
mov edx, [rdi]
test r9d, r9d
jle short loc_1450
lea rcx, [r13+r11*4+0]
loc_1424:
mov rax, r13
jmp short loc_1439
loc_1430:
add rax, 4
cmp rax, rcx
jz short loc_1450
loc_1439:
cmp [rax], edx
jnz short loc_1430
add rdi, 4
cmp rdi, r8
jz short loc_1492
mov edx, [rdi]
jmp short loc_1424
loc_1450:
movsxd r14, r10d
test r10d, r10d
jle loc_14E8
movsxd r14, r10d
mov rax, rbx
lea rcx, [rbx+r14*4]
jmp short loc_1479
loc_1470:
add rax, 4
cmp rax, rcx
jz short loc_14E8
loc_1479:
cmp edx, [rax]
jnz short loc_1470
add r9d, 1
mov [r13+r11*4+0], edx
movsxd r11, r9d
loc_1489:
add rdi, 4
cmp rdi, r8
jnz short loc_1418
loc_1492:
lea rcx, [r13+r11*4+0]
xor edi, edi
nop dword ptr [rax+00000000h]
loc_14A0:
mov edx, [rsi]
test r9d, r9d
jle short loc_14D0
loc_14A7:
mov rax, r13
jmp short loc_14B9
loc_14B0:
add rax, 4
cmp rcx, rax
jz short loc_14D0
loc_14B9:
cmp edx, [rax]
jnz short loc_14B0
add rsi, 4
cmp rsi, r8
jz short loc_14F2
mov edx, [rsi]
jmp short loc_14A7
loc_14D0:
add rsi, 4
mov [rbp+rdi*4+0], edx
lea eax, [rdi+1]
cmp rsi, r8
jz short loc_14F4
movsxd rdi, eax
jmp short loc_14A0
loc_14E8:
mov [rbx+r14*4], edx
add r10d, 1
jmp short loc_1489
loc_14F2:
mov eax, edi
loc_14F4:
mov [r12], eax
mov rdi, rbx; ptr
call _free
mov rdi, r13; ptr
call _free
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_151A:
xor eax, eax
jmp short loc_14F4
|
_DWORD * func0(int *a1, int a2, _DWORD *a3)
{
size_t v3; // r15
_DWORD *v5; // rbp
_DWORD *v6; // rbx
_DWORD *v7; // r13
int *v8; // rsi
int v9; // r9d
int v10; // r10d
long long v11; // r11
int *v12; // r8
int v13; // edx
_DWORD *v14; // rax
long long v15; // r14
_DWORD *v16; // rax
long long i; // rdi
int v18; // edx
_DWORD *v19; // rax
int v20; // eax
v3 = a2;
v5 = malloc(v3 * 4);
v6 = calloc(a2, 4uLL);
v7 = calloc(a2, 4uLL);
if ( a2 <= 0 )
{
v20 = 0;
}
else
{
v8 = a1;
v9 = 0;
v10 = 0;
v11 = 0LL;
v12 = &a1[v3];
while ( 1 )
{
v13 = *a1;
if ( v9 > 0 )
break;
LABEL_9:
v15 = v10;
if ( v10 <= 0 )
{
LABEL_24:
v6[v15] = v13;
++v10;
}
else
{
v15 = v10;
v16 = v6;
while ( v13 != *v16 )
{
if ( ++v16 == &v6[v10] )
goto LABEL_24;
}
++v9;
v7[v11] = v13;
v11 = v9;
}
if ( ++a1 == v12 )
goto LABEL_15;
}
while ( 1 )
{
v14 = v7;
while ( *v14 != v13 )
{
if ( ++v14 == &v7[v11] )
goto LABEL_9;
}
if ( ++a1 == v12 )
break;
v13 = *a1;
}
LABEL_15:
for ( i = 0LL; ; i = v20 )
{
v18 = *v8;
if ( v9 > 0 )
break;
LABEL_22:
++v8;
v5[i] = v18;
v20 = i + 1;
if ( v8 == v12 )
goto LABEL_26;
}
while ( 1 )
{
v19 = v7;
while ( v18 != *v19 )
{
if ( &v7[v11] == ++v19 )
goto LABEL_22;
}
if ( ++v8 == v12 )
break;
v18 = *v8;
}
v20 = i;
}
LABEL_26:
*a3 = v20;
free(v6);
free(v7);
return v5;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
LEA R15,[R13*0x4]
MOV R12,RDX
MOV R14,R13
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,R15
CALL 0x001010d0
MOV RDI,R13
MOV ESI,0x4
MOV RBP,RAX
CALL 0x001010c0
MOV RDI,R13
MOV ESI,0x4
MOV RBX,RAX
CALL 0x001010c0
MOV R13,RAX
TEST R14D,R14D
JLE 0x0010151a
MOV RSI,qword ptr [RSP + 0x8]
XOR R9D,R9D
XOR R10D,R10D
XOR R11D,R11D
LEA R8,[RSI + R15*0x1]
MOV RDI,RSI
NOP dword ptr [RAX]
LAB_00101418:
MOV EDX,dword ptr [RDI]
TEST R9D,R9D
JLE 0x00101450
LEA RCX,[R13 + R11*0x4]
LAB_00101424:
MOV RAX,R13
JMP 0x00101439
LAB_00101430:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101450
LAB_00101439:
CMP dword ptr [RAX],EDX
JNZ 0x00101430
ADD RDI,0x4
CMP RDI,R8
JZ 0x00101492
MOV EDX,dword ptr [RDI]
JMP 0x00101424
LAB_00101450:
MOVSXD R14,R10D
TEST R10D,R10D
JLE 0x001014e8
MOVSXD R14,R10D
MOV RAX,RBX
LEA RCX,[RBX + R14*0x4]
JMP 0x00101479
LAB_00101470:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x001014e8
LAB_00101479:
CMP EDX,dword ptr [RAX]
JNZ 0x00101470
ADD R9D,0x1
MOV dword ptr [R13 + R11*0x4],EDX
MOVSXD R11,R9D
LAB_00101489:
ADD RDI,0x4
CMP RDI,R8
JNZ 0x00101418
LAB_00101492:
LEA RCX,[R13 + R11*0x4]
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001014a0:
MOV EDX,dword ptr [RSI]
TEST R9D,R9D
JLE 0x001014d0
LAB_001014a7:
MOV RAX,R13
JMP 0x001014b9
LAB_001014b0:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x001014d0
LAB_001014b9:
CMP EDX,dword ptr [RAX]
JNZ 0x001014b0
ADD RSI,0x4
CMP RSI,R8
JZ 0x001014f2
MOV EDX,dword ptr [RSI]
JMP 0x001014a7
LAB_001014d0:
ADD RSI,0x4
MOV dword ptr [RBP + RDI*0x4],EDX
LEA EAX,[RDI + 0x1]
CMP RSI,R8
JZ 0x001014f4
MOVSXD RDI,EAX
JMP 0x001014a0
LAB_001014e8:
MOV dword ptr [RBX + R14*0x4],EDX
ADD R10D,0x1
JMP 0x00101489
LAB_001014f2:
MOV EAX,EDI
LAB_001014f4:
MOV dword ptr [R12],EAX
MOV RDI,RBX
CALL 0x00101090
MOV RDI,R13
CALL 0x00101090
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010151a:
XOR EAX,EAX
JMP 0x001014f4
|
void * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
void *pvVar3;
int *__ptr;
int *__ptr_00;
int *piVar4;
int *piVar5;
int iVar6;
long lVar7;
int iVar8;
long lVar9;
size_t __nmemb;
__nmemb = (size_t)param_2;
pvVar3 = malloc(__nmemb * 4);
__ptr = (int *)calloc(__nmemb,4);
__ptr_00 = (int *)calloc(__nmemb,4);
if (param_2 < 1) {
iVar2 = 0;
}
else {
iVar8 = 0;
iVar2 = 0;
lVar9 = 0;
piVar1 = param_1 + __nmemb;
piVar5 = param_1;
do {
iVar6 = *piVar5;
if (0 < iVar8) {
piVar4 = __ptr_00;
do {
while (*piVar4 == iVar6) {
piVar5 = piVar5 + 1;
if (piVar5 == piVar1) goto LAB_00101492;
piVar4 = __ptr_00;
iVar6 = *piVar5;
}
piVar4 = piVar4 + 1;
} while (piVar4 != __ptr_00 + lVar9);
}
if (0 < iVar2) {
piVar4 = __ptr;
do {
if (iVar6 == *piVar4) {
iVar8 = iVar8 + 1;
__ptr_00[lVar9] = iVar6;
lVar9 = (long)iVar8;
goto LAB_00101489;
}
piVar4 = piVar4 + 1;
} while (piVar4 != __ptr + iVar2);
}
__ptr[iVar2] = iVar6;
iVar2 = iVar2 + 1;
LAB_00101489:
piVar5 = piVar5 + 1;
} while (piVar5 != piVar1);
LAB_00101492:
lVar7 = 0;
while( true ) {
iVar6 = *param_1;
iVar2 = (int)lVar7;
piVar5 = __ptr_00;
if (0 < iVar8) {
do {
while (iVar6 == *piVar5) {
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_001014f4;
piVar5 = __ptr_00;
iVar6 = *param_1;
}
piVar5 = piVar5 + 1;
} while (__ptr_00 + lVar9 != piVar5);
}
param_1 = param_1 + 1;
*(int *)((long)pvVar3 + lVar7 * 4) = iVar6;
iVar2 = iVar2 + 1;
if (param_1 == piVar1) break;
lVar7 = (long)iVar2;
}
}
LAB_001014f4:
*param_3 = iVar2;
free(__ptr);
free(__ptr_00);
return pvVar3;
}
|
763 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (in_has2) continue;
int in_has1 = 0;
for (int j = 0; j < has1_count; j++) {
if (has1[j] == num) {
in_has1 = 1;
break;
}
}
if (in_has1) {
has2[has2_count++] = num;
} else {
has1[has1_count++] = num;
}
}
for (int i = 0; i < size; i++) {
int num = numbers[i];
int in_has2 = 0;
for (int j = 0; j < has2_count; j++) {
if (has2[j] == num) {
in_has2 = 1;
break;
}
}
if (!in_has2) {
out[out_count++] = num;
}
}
*new_size = out_count;
free(has1);
free(has2);
return out;
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new_size);
assert(issame(result, new_size, (const int[]){}, 0));
free(result);
result = func0((const int[]){1, 2, 3, 4}, 4, &new_size);
assert(issame(result, new_size, (const int[]){1, 2, 3, 4}, 4));
free(result);
result = func0((const int[]){1, 2, 3, 2, 4, 3, 5}, 7, &new_size);
assert(issame(result, new_size, (const int[]){1, 4, 5}, 3));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
movslq %esi,%r13
push %r12
lea 0x0(,%r13,4),%rdi
mov %r13,%r14
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %r13,%rdi
mov $0x4,%esi
mov %rax,%r12
callq 10c0 <calloc@plt>
mov %r13,%rdi
mov $0x4,%esi
mov %rax,%rbp
callq 10c0 <calloc@plt>
mov %rax,%r13
test %r14d,%r14d
jle 1535 <func0+0x185>
lea -0x1(%r14),%eax
mov %r15,%r8
mov %r15,%r9
xor %edx,%edx
lea 0x4(%r15,%rax,4),%rax
xor %r10d,%r10d
lea 0x4(%r13),%r11
lea 0x4(%rbp),%r14
nopl 0x0(%rax,%rax,1)
mov (%r9),%esi
test %edx,%edx
je 14b0 <func0+0x100>
lea -0x1(%rdx),%edi
mov %r13,%rcx
lea (%r11,%rdi,4),%rdi
jmp 1449 <func0+0x99>
add $0x4,%rcx
cmp %rdi,%rcx
je 14b0 <func0+0x100>
cmp %esi,(%rcx)
jne 1440 <func0+0x90>
add $0x4,%r9
cmp %rax,%r9
jne 1428 <func0+0x78>
lea -0x1(%rdx),%ecx
xor %r9d,%r9d
lea (%r11,%rcx,4),%rdi
mov (%r8),%esi
test %edx,%edx
je 14f8 <func0+0x148>
mov %r13,%rcx
jmp 1479 <func0+0xc9>
add $0x4,%rcx
cmp %rcx,%rdi
je 14f8 <func0+0x148>
cmp %esi,(%rcx)
jne 1470 <func0+0xc0>
add $0x4,%r8
cmp %rax,%r8
jne 1460 <func0+0xb0>
mov %r9d,(%rbx)
mov %rbp,%rdi
callq 1090 <free@plt>
mov %r13,%rdi
callq 1090 <free@plt>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
test %r10d,%r10d
je 1518 <func0+0x168>
lea -0x1(%r10),%edi
mov %rbp,%rcx
lea (%r14,%rdi,4),%rdi
jmp 14d1 <func0+0x121>
nopw 0x0(%rax,%rax,1)
add $0x4,%rcx
cmp %rdi,%rcx
je 1518 <func0+0x168>
cmp %esi,(%rcx)
jne 14c8 <func0+0x118>
movslq %edx,%rcx
add $0x4,%r9
add $0x1,%edx
mov %esi,0x0(%r13,%rcx,4)
cmp %rax,%r9
jne 1428 <func0+0x78>
jmpq 1456 <func0+0xa6>
nopw 0x0(%rax,%rax,1)
movslq %r9d,%rcx
add $0x4,%r8
add $0x1,%r9d
mov %esi,(%r12,%rcx,4)
cmp %rax,%r8
jne 1460 <func0+0xb0>
jmpq 1486 <func0+0xd6>
nopl (%rax)
movslq %r10d,%rcx
add $0x4,%r9
add $0x1,%r10d
mov %esi,0x0(%rbp,%rcx,4)
cmp %rax,%r9
jne 1428 <func0+0x78>
jmpq 1456 <func0+0xa6>
xor %r9d,%r9d
jmpq 1486 <func0+0xd6>
nopl (%rax)
|
func0:
endbr64
push r15
push r14
push r13
movsxd r13, esi
push r12
lea r15, ds:0[r13*4]
mov r12, rdx
mov r14, r13
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
mov rdi, r15; size
call _malloc
mov rdi, r13; nmemb
mov esi, 4; size
mov rbp, rax
call _calloc
mov rdi, r13; nmemb
mov esi, 4; size
mov rbx, rax
call _calloc
mov r13, rax
test r14d, r14d
jle loc_151A
mov rsi, [rsp+48h+var_40]
xor r9d, r9d
xor r10d, r10d
xor r11d, r11d
lea r8, [rsi+r15]
mov rdi, rsi
nop dword ptr [rax+00000000h]
loc_1418:
mov edx, [rdi]
test r9d, r9d
jle short loc_1450
lea rcx, [r13+r11*4+0]
loc_1424:
mov rax, r13
jmp short loc_1439
loc_1430:
add rax, 4
cmp rax, rcx
jz short loc_1450
loc_1439:
cmp [rax], edx
jnz short loc_1430
add rdi, 4
cmp rdi, r8
jz short loc_1492
mov edx, [rdi]
jmp short loc_1424
loc_1450:
movsxd r14, r10d
test r10d, r10d
jle loc_14E8
movsxd r14, r10d
mov rax, rbx
lea rcx, [rbx+r14*4]
jmp short loc_1479
loc_1470:
add rax, 4
cmp rax, rcx
jz short loc_14E8
loc_1479:
cmp edx, [rax]
jnz short loc_1470
add r9d, 1
mov [r13+r11*4+0], edx
movsxd r11, r9d
loc_1489:
add rdi, 4
cmp rdi, r8
jnz short loc_1418
loc_1492:
lea rcx, [r13+r11*4+0]
xor edi, edi
nop dword ptr [rax+00000000h]
loc_14A0:
mov edx, [rsi]
test r9d, r9d
jle short loc_14D0
loc_14A7:
mov rax, r13
jmp short loc_14B9
loc_14B0:
add rax, 4
cmp rcx, rax
jz short loc_14D0
loc_14B9:
cmp edx, [rax]
jnz short loc_14B0
add rsi, 4
cmp rsi, r8
jz short loc_14F2
mov edx, [rsi]
jmp short loc_14A7
loc_14D0:
add rsi, 4
mov [rbp+rdi*4+0], edx
lea eax, [rdi+1]
cmp rsi, r8
jz short loc_14F4
movsxd rdi, eax
jmp short loc_14A0
loc_14E8:
mov [rbx+r14*4], edx
add r10d, 1
jmp short loc_1489
loc_14F2:
mov eax, edi
loc_14F4:
mov [r12], eax
mov rdi, rbx; ptr
call _free
mov rdi, r13; ptr
call _free
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_151A:
xor eax, eax
jmp short loc_14F4
|
_DWORD * func0(int *a1, int a2, _DWORD *a3)
{
size_t v3; // r15
_DWORD *v5; // rbp
_DWORD *v6; // rbx
_DWORD *v7; // r13
int *v8; // rsi
int v9; // r9d
int v10; // r10d
long long v11; // r11
int *v12; // r8
int v13; // edx
_DWORD *v14; // rax
long long v15; // r14
_DWORD *v16; // rax
long long i; // rdi
int v18; // edx
_DWORD *v19; // rax
int v20; // eax
v3 = a2;
v5 = malloc(v3 * 4);
v6 = calloc(a2, 4uLL);
v7 = calloc(a2, 4uLL);
if ( a2 <= 0 )
{
v20 = 0;
}
else
{
v8 = a1;
v9 = 0;
v10 = 0;
v11 = 0LL;
v12 = &a1[v3];
while ( 1 )
{
v13 = *a1;
if ( v9 > 0 )
break;
LABEL_9:
v15 = v10;
if ( v10 <= 0 )
{
LABEL_24:
v6[v15] = v13;
++v10;
}
else
{
v15 = v10;
v16 = v6;
while ( v13 != *v16 )
{
if ( ++v16 == &v6[v10] )
goto LABEL_24;
}
++v9;
v7[v11] = v13;
v11 = v9;
}
if ( ++a1 == v12 )
goto LABEL_15;
}
while ( 1 )
{
v14 = v7;
while ( *v14 != v13 )
{
if ( ++v14 == &v7[v11] )
goto LABEL_9;
}
if ( ++a1 == v12 )
break;
v13 = *a1;
}
LABEL_15:
for ( i = 0LL; ; i = v20 )
{
v18 = *v8;
if ( v9 > 0 )
break;
LABEL_22:
++v8;
v5[i] = v18;
v20 = i + 1;
if ( v8 == v12 )
goto LABEL_26;
}
while ( 1 )
{
v19 = v7;
while ( v18 != *v19 )
{
if ( &v7[v11] == ++v19 )
goto LABEL_22;
}
if ( ++v8 == v12 )
break;
v18 = *v8;
}
v20 = i;
}
LABEL_26:
*a3 = v20;
free(v6);
free(v7);
return v5;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
LEA R15,[R13*0x4]
MOV R12,RDX
MOV R14,R13
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,R15
CALL 0x001010d0
MOV RDI,R13
MOV ESI,0x4
MOV RBP,RAX
CALL 0x001010c0
MOV RDI,R13
MOV ESI,0x4
MOV RBX,RAX
CALL 0x001010c0
MOV R13,RAX
TEST R14D,R14D
JLE 0x0010151a
MOV RSI,qword ptr [RSP + 0x8]
XOR R9D,R9D
XOR R10D,R10D
XOR R11D,R11D
LEA R8,[RSI + R15*0x1]
MOV RDI,RSI
NOP dword ptr [RAX]
LAB_00101418:
MOV EDX,dword ptr [RDI]
TEST R9D,R9D
JLE 0x00101450
LEA RCX,[R13 + R11*0x4]
LAB_00101424:
MOV RAX,R13
JMP 0x00101439
LAB_00101430:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101450
LAB_00101439:
CMP dword ptr [RAX],EDX
JNZ 0x00101430
ADD RDI,0x4
CMP RDI,R8
JZ 0x00101492
MOV EDX,dword ptr [RDI]
JMP 0x00101424
LAB_00101450:
MOVSXD R14,R10D
TEST R10D,R10D
JLE 0x001014e8
MOVSXD R14,R10D
MOV RAX,RBX
LEA RCX,[RBX + R14*0x4]
JMP 0x00101479
LAB_00101470:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x001014e8
LAB_00101479:
CMP EDX,dword ptr [RAX]
JNZ 0x00101470
ADD R9D,0x1
MOV dword ptr [R13 + R11*0x4],EDX
MOVSXD R11,R9D
LAB_00101489:
ADD RDI,0x4
CMP RDI,R8
JNZ 0x00101418
LAB_00101492:
LEA RCX,[R13 + R11*0x4]
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001014a0:
MOV EDX,dword ptr [RSI]
TEST R9D,R9D
JLE 0x001014d0
LAB_001014a7:
MOV RAX,R13
JMP 0x001014b9
LAB_001014b0:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x001014d0
LAB_001014b9:
CMP EDX,dword ptr [RAX]
JNZ 0x001014b0
ADD RSI,0x4
CMP RSI,R8
JZ 0x001014f2
MOV EDX,dword ptr [RSI]
JMP 0x001014a7
LAB_001014d0:
ADD RSI,0x4
MOV dword ptr [RBP + RDI*0x4],EDX
LEA EAX,[RDI + 0x1]
CMP RSI,R8
JZ 0x001014f4
MOVSXD RDI,EAX
JMP 0x001014a0
LAB_001014e8:
MOV dword ptr [RBX + R14*0x4],EDX
ADD R10D,0x1
JMP 0x00101489
LAB_001014f2:
MOV EAX,EDI
LAB_001014f4:
MOV dword ptr [R12],EAX
MOV RDI,RBX
CALL 0x00101090
MOV RDI,R13
CALL 0x00101090
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010151a:
XOR EAX,EAX
JMP 0x001014f4
|
void * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
void *pvVar3;
int *__ptr;
int *__ptr_00;
int *piVar4;
int *piVar5;
int iVar6;
long lVar7;
int iVar8;
long lVar9;
size_t __nmemb;
__nmemb = (size_t)param_2;
pvVar3 = malloc(__nmemb * 4);
__ptr = (int *)calloc(__nmemb,4);
__ptr_00 = (int *)calloc(__nmemb,4);
if (param_2 < 1) {
iVar2 = 0;
}
else {
iVar8 = 0;
iVar2 = 0;
lVar9 = 0;
piVar1 = param_1 + __nmemb;
piVar5 = param_1;
do {
iVar6 = *piVar5;
if (0 < iVar8) {
piVar4 = __ptr_00;
do {
while (*piVar4 == iVar6) {
piVar5 = piVar5 + 1;
if (piVar5 == piVar1) goto LAB_00101492;
piVar4 = __ptr_00;
iVar6 = *piVar5;
}
piVar4 = piVar4 + 1;
} while (piVar4 != __ptr_00 + lVar9);
}
if (0 < iVar2) {
piVar4 = __ptr;
do {
if (iVar6 == *piVar4) {
iVar8 = iVar8 + 1;
__ptr_00[lVar9] = iVar6;
lVar9 = (long)iVar8;
goto LAB_00101489;
}
piVar4 = piVar4 + 1;
} while (piVar4 != __ptr + iVar2);
}
__ptr[iVar2] = iVar6;
iVar2 = iVar2 + 1;
LAB_00101489:
piVar5 = piVar5 + 1;
} while (piVar5 != piVar1);
LAB_00101492:
lVar7 = 0;
while( true ) {
iVar6 = *param_1;
iVar2 = (int)lVar7;
piVar5 = __ptr_00;
if (0 < iVar8) {
do {
while (iVar6 == *piVar5) {
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_001014f4;
piVar5 = __ptr_00;
iVar6 = *param_1;
}
piVar5 = piVar5 + 1;
} while (__ptr_00 + lVar9 != piVar5);
}
param_1 = param_1 + 1;
*(int *)((long)pvVar3 + lVar7 * 4) = iVar6;
iVar2 = iVar2 + 1;
if (param_1 == piVar1) break;
lVar7 = (long)iVar2;
}
}
LAB_001014f4:
*param_3 = iVar2;
free(__ptr);
free(__ptr_00);
return pvVar3;
}
|
764 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
assert(strcmp(result, "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 122d <func0+0x84>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x9(%rbp)
cmpb $0x60,-0x9(%rbp)
jle 1200 <func0+0x57>
cmpb $0x7a,-0x9(%rbp)
jg 1200 <func0+0x57>
movzbl -0x9(%rbp),%eax
sub $0x20,%eax
mov %al,-0x9(%rbp)
jmp 1216 <func0+0x6d>
cmpb $0x40,-0x9(%rbp)
jle 1216 <func0+0x6d>
cmpb $0x5a,-0x9(%rbp)
jg 1216 <func0+0x6d>
movzbl -0x9(%rbp),%eax
add $0x20,%eax
mov %al,-0x9(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
movzbl -0x9(%rbp),%eax
mov %al,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11d5 <func0+0x2c>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_122D
loc_11D5:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_9], al
cmp [rbp+var_9], 60h ; '`'
jle short loc_1200
cmp [rbp+var_9], 7Ah ; 'z'
jg short loc_1200
movzx eax, [rbp+var_9]
sub eax, 20h ; ' '
mov [rbp+var_9], al
jmp short loc_1216
loc_1200:
cmp [rbp+var_9], 40h ; '@'
jle short loc_1216
cmp [rbp+var_9], 5Ah ; 'Z'
jg short loc_1216
movzx eax, [rbp+var_9]
add eax, 20h ; ' '
mov [rbp+var_9], al
loc_1216:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rdx, rax
movzx eax, [rbp+var_9]
mov [rdx], al
add [rbp+var_8], 1
loc_122D:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_11D5
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
nop
leave
retn
|
_BYTE * func0(const char *a1, long long a2)
{
_BYTE *result; // rax
char v3; // [rsp+17h] [rbp-9h]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
v3 = a1[i];
if ( v3 <= 96 || v3 > 122 )
{
if ( v3 > 64 && v3 <= 90 )
v3 += 32;
}
else
{
v3 -= 32;
}
*(_BYTE *)(a2 + i) = v3;
}
result = (_BYTE *)(v5 + a2);
*result = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010122d
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x9],AL
CMP byte ptr [RBP + -0x9],0x60
JLE 0x00101200
CMP byte ptr [RBP + -0x9],0x7a
JG 0x00101200
MOVZX EAX,byte ptr [RBP + -0x9]
SUB EAX,0x20
MOV byte ptr [RBP + -0x9],AL
JMP 0x00101216
LAB_00101200:
CMP byte ptr [RBP + -0x9],0x40
JLE 0x00101216
CMP byte ptr [RBP + -0x9],0x5a
JG 0x00101216
MOVZX EAX,byte ptr [RBP + -0x9]
ADD EAX,0x20
MOV byte ptr [RBP + -0x9],AL
LAB_00101216:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOVZX EAX,byte ptr [RBP + -0x9]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x8],0x1
LAB_0010122d:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011d5
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
LEAVE
RET
|
void func0(char *param_1,long param_2)
{
size_t sVar1;
char local_11;
int local_10;
sVar1 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar1; local_10 = local_10 + 1) {
local_11 = param_1[local_10];
if ((local_11 < 'a') || ('z' < local_11)) {
if (('@' < local_11) && (local_11 < '[')) {
local_11 = local_11 + ' ';
}
}
else {
local_11 = local_11 + -0x20;
}
*(char *)(local_10 + param_2) = local_11;
}
*(int *)(param_2 + (int)sVar1) = 0;
return;
}
|
765 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
assert(strcmp(result, "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r9
test %r9d,%r9d
jle 11c6 <func0+0x5d>
lea -0x1(%r9),%r10d
mov $0x0,%edx
jmp 11b1 <func0+0x48>
lea -0x41(%rax),%edi
add $0x20,%ecx
cmp $0x1a,%dil
cmovb %ecx,%eax
mov %al,(%rsi,%rdx,1)
lea 0x1(%rdx),%rax
cmp %r10,%rdx
je 11c6 <func0+0x5d>
mov %rax,%rdx
movzbl (%r8,%rdx,1),%eax
mov %eax,%ecx
lea -0x61(%rax),%edi
cmp $0x19,%dil
ja 1195 <func0+0x2c>
sub $0x20,%eax
jmp 11a2 <func0+0x39>
movslq %r9d,%r9
movb $0x0,(%rsi,%r9,1)
retq
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
call _strlen
test eax, eax
jle short loc_11FE
lea r8d, [rax-1]
mov ecx, 0
jmp short loc_11E9
loc_11CD:
lea edi, [rdx-41h]
add esi, 20h ; ' '
cmp dil, 1Ah
cmovb edx, esi
loc_11DA:
mov [rbx+rcx], dl
lea rdx, [rcx+1]
cmp rcx, r8
jz short loc_11FE
mov rcx, rdx
loc_11E9:
movzx edx, byte ptr [rbp+rcx+0]
mov esi, edx
lea edi, [rdx-61h]
cmp dil, 19h
ja short loc_11CD
sub edx, 20h ; ' '
jmp short loc_11DA
loc_11FE:
cdqe
mov byte ptr [rbx+rax], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long func0(const char *a1, long long a2)
{
long long result; // rax
long long i; // rcx
char v4; // dl
LODWORD(result) = strlen(a1);
if ( (int)result > 0 )
{
for ( i = 0LL; ; ++i )
{
v4 = a1[i];
if ( (unsigned __int8)(v4 - 97) > 0x19u )
{
if ( (unsigned __int8)(v4 - 65) < 0x1Au )
v4 = a1[i] + 32;
}
else
{
v4 -= 32;
}
*(_BYTE *)(a2 + i) = v4;
if ( i == (_DWORD)result - 1 )
break;
}
}
result = (int)result;
*(_BYTE *)(a2 + (int)result) = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001011fe
LEA R8D,[RAX + -0x1]
MOV ECX,0x0
JMP 0x001011e9
LAB_001011cd:
LEA EDI,[RDX + -0x41]
ADD ESI,0x20
CMP DIL,0x1a
CMOVC EDX,ESI
LAB_001011da:
MOV byte ptr [RBX + RCX*0x1],DL
LEA RDX,[RCX + 0x1]
CMP RCX,R8
JZ 0x001011fe
MOV RCX,RDX
LAB_001011e9:
MOVZX EDX,byte ptr [RBP + RCX*0x1]
MOV ESI,EDX
LEA EDI,[RDX + -0x61]
CMP DIL,0x19
JA 0x001011cd
SUB EDX,0x20
JMP 0x001011da
LAB_001011fe:
CDQE
MOV byte ptr [RBX + RAX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
char cVar4;
bool bVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar3 = 0;
do {
cVar4 = param_1[uVar3];
if ((byte)(cVar4 + 0x9fU) < 0x1a) {
cVar4 = cVar4 + -0x20;
}
else if ((byte)(cVar4 + 0xbfU) < 0x1a) {
cVar4 = cVar4 + ' ';
}
*(char *)(param_2 + uVar3) = cVar4;
bVar5 = uVar3 != iVar1 - 1;
uVar3 = uVar3 + 1;
} while (bVar5);
}
*(int *)(param_2 + iVar1) = 0;
return;
}
|
766 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
assert(strcmp(result, "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 133b <func0+0x5b>
lea -0x1(%rax),%esi
xor %ecx,%ecx
jmp 1312 <func0+0x32>
sub $0x20,%edx
mov %dl,(%rbx,%rcx,1)
lea 0x1(%rcx),%rdx
cmp %rcx,%rsi
je 133b <func0+0x5b>
mov %rdx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edx
lea -0x61(%rdx),%r8d
cmp $0x19,%r8b
jbe 1300 <func0+0x20>
lea -0x41(%rdx),%r8d
lea 0x20(%rdx),%edi
cmp $0x1a,%r8b
cmovb %edi,%edx
mov %dl,(%rbx,%rcx,1)
lea 0x1(%rcx),%rdx
cmp %rcx,%rsi
jne 130f <func0+0x2f>
cltq
movb $0x0,(%rbx,%rax,1)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_133B
lea esi, [rax-1]
xor ecx, ecx
jmp short loc_1312
loc_1300:
sub edx, 20h ; ' '
mov [rbx+rcx], dl
lea rdx, [rcx+1]
cmp rsi, rcx
jz short loc_133B
loc_130F:
mov rcx, rdx
loc_1312:
movzx edx, byte ptr [rbp+rcx+0]
lea r8d, [rdx-61h]
cmp r8b, 19h
jbe short loc_1300
lea r8d, [rdx-41h]
lea edi, [rdx+20h]
cmp r8b, 1Ah
cmovb edx, edi
mov [rbx+rcx], dl
lea rdx, [rcx+1]
cmp rsi, rcx
jnz short loc_130F
loc_133B:
cdqe
mov byte ptr [rbx+rax], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long func0(const char *a1, long long a2)
{
long long result; // rax
long long v4; // rsi
long long i; // rcx
long long v6; // rdx
char v7; // dl
LODWORD(result) = strlen(a1);
if ( (int)result > 0 )
{
v4 = (unsigned int)(result - 1);
for ( i = 0LL; ; i = v6 )
{
v7 = a1[i];
if ( (unsigned __int8)(v7 - 97) <= 0x19u )
{
*(_BYTE *)(a2 + i) = v7 - 32;
v6 = i + 1;
if ( v4 == i )
break;
}
else
{
if ( (unsigned __int8)(v7 - 65) < 0x1Au )
v7 += 32;
*(_BYTE *)(a2 + i) = v7;
v6 = i + 1;
if ( v4 == i )
break;
}
}
}
result = (int)result;
*(_BYTE *)(a2 + (int)result) = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
TEST EAX,EAX
JLE 0x0010133b
LEA ESI,[RAX + -0x1]
XOR ECX,ECX
JMP 0x00101312
LAB_00101300:
SUB EDX,0x20
MOV byte ptr [RBX + RCX*0x1],DL
LEA RDX,[RCX + 0x1]
CMP RSI,RCX
JZ 0x0010133b
LAB_0010130f:
MOV RCX,RDX
LAB_00101312:
MOVZX EDX,byte ptr [RBP + RCX*0x1]
LEA R8D,[RDX + -0x61]
CMP R8B,0x19
JBE 0x00101300
LEA R8D,[RDX + -0x41]
LEA EDI,[RDX + 0x20]
CMP R8B,0x1a
CMOVC EDX,EDI
MOV byte ptr [RBX + RCX*0x1],DL
LEA RDX,[RCX + 0x1]
CMP RSI,RCX
JNZ 0x0010130f
LAB_0010133b:
CDQE
MOV byte ptr [RBX + RAX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
char cVar3;
ulong uVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar4 = 0;
while( true ) {
cVar3 = param_1[uVar4];
if ((byte)(cVar3 + 0x9fU) < 0x1a) {
*(char *)(param_2 + uVar4) = cVar3 + -0x20;
}
else {
if ((byte)(cVar3 + 0xbfU) < 0x1a) {
cVar3 = cVar3 + ' ';
}
*(char *)(param_2 + uVar4) = cVar3;
}
if (iVar1 - 1 == uVar4) break;
uVar4 = uVar4 + 1;
}
}
*(int *)(param_2 + iVar1) = 0;
return;
}
|
767 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
assert(strcmp(result, "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 1657 <func0+0x377>
lea 0xf(%rbp),%rcx
lea -0x1(%rax),%edx
sub %rbx,%rcx
cmp $0x1e,%rcx
jbe 16e0 <func0+0x400>
cmp $0xe,%edx
jbe 16e0 <func0+0x400>
mov %eax,%ecx
movdqa 0xe2c(%rip),%xmm7
xor %edx,%edx
pxor %xmm4,%xmm4
shr $0x4,%ecx
movdqa 0xe2b(%rip),%xmm5
movdqa 0xdf2(%rip),%xmm9
movdqa 0xdf9(%rip),%xmm8
movdqa 0xe21(%rip),%xmm6
shl $0x4,%rcx
nopl 0x0(%rax,%rax,1)
movdqu 0x0(%rbp,%rdx,1),%xmm10
movdqa %xmm10,%xmm2
movdqa %xmm10,%xmm1
movdqa %xmm10,%xmm11
paddb %xmm8,%xmm1
paddb %xmm9,%xmm2
movdqa %xmm1,%xmm0
psubusb %xmm5,%xmm2
movdqa %xmm1,%xmm12
pcmpeqb %xmm4,%xmm2
psubusb %xmm5,%xmm0
pminub %xmm5,%xmm12
pcmpeqb %xmm4,%xmm0
pcmpeqb %xmm12,%xmm1
paddb %xmm7,%xmm11
movdqa %xmm2,%xmm3
pcmpeqb %xmm4,%xmm3
pcmpeqb %xmm4,%xmm0
pand %xmm3,%xmm1
pand %xmm3,%xmm0
movdqa %xmm10,%xmm3
paddb %xmm6,%xmm3
pand %xmm2,%xmm3
pandn %xmm11,%xmm2
pand %xmm1,%xmm11
movdqa %xmm3,%xmm12
movdqa %xmm2,%xmm3
movdqa %xmm10,%xmm2
por %xmm12,%xmm3
pand %xmm0,%xmm2
pandn %xmm3,%xmm1
por %xmm11,%xmm1
pandn %xmm1,%xmm0
por %xmm0,%xmm2
movups %xmm2,(%rbx,%rdx,1)
add $0x10,%rdx
cmp %rcx,%rdx
jne 1358 <func0+0x78>
mov %eax,%edx
and $0xfffffff0,%edx
test $0xf,%al
je 1657 <func0+0x377>
movslq %edx,%rsi
movzbl 0x0(%rbp,%rsi,1),%ecx
lea -0x61(%rcx),%edi
cmp $0x19,%dil
jbe 1668 <func0+0x388>
lea -0x41(%rcx),%r8d
lea 0x20(%rcx),%edi
cmp $0x1a,%r8b
cmovb %edi,%ecx
mov %cl,(%rbx,%rsi,1)
lea 0x1(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1670 <func0+0x390>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x2(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1688 <func0+0x3a8>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x3(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 16a0 <func0+0x3c0>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x4(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 16b8 <func0+0x3d8>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x5(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
jbe 16d0 <func0+0x3f0>
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x6(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1728 <func0+0x448>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x7(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1740 <func0+0x460>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x8(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1758 <func0+0x478>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0x9(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1770 <func0+0x490>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0xa(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 1788 <func0+0x4a8>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0xb(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 17a0 <func0+0x4c0>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0xc(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 17b3 <func0+0x4d3>
sub $0x20,%esi
mov %sil,(%rbx,%rcx,1)
lea 0xd(%rdx),%ecx
cmp %ecx,%eax
jle 1657 <func0+0x377>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%esi
lea -0x61(%rsi),%edi
cmp $0x19,%dil
ja 17c6 <func0+0x4e6>
sub $0x20,%esi
add $0xe,%edx
mov %sil,(%rbx,%rcx,1)
cmp %edx,%eax
jle 1657 <func0+0x377>
movslq %edx,%rdx
movzbl 0x0(%rbp,%rdx,1),%ecx
lea -0x61(%rcx),%esi
cmp $0x19,%sil
ja 17d9 <func0+0x4f9>
sub $0x20,%ecx
mov %cl,(%rbx,%rdx,1)
cltq
movb $0x0,(%rbx,%rax,1)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
sub $0x20,%ecx
jmpq 1434 <func0+0x154>
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 145a <func0+0x17a>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 1481 <func0+0x1a1>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 14a8 <func0+0x1c8>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 14cf <func0+0x1ef>
nopl 0x0(%rax,%rax,1)
sub $0x20,%esi
jmpq 1501 <func0+0x221>
nopl 0x0(%rax,%rax,1)
mov %edx,%esi
xor %ecx,%ecx
jmp 1711 <func0+0x431>
nopw %cs:0x0(%rax,%rax,1)
lea -0x41(%rdx),%r8d
lea 0x20(%rdx),%edi
cmp $0x1a,%r8b
cmovb %edi,%edx
mov %dl,(%rbx,%rcx,1)
lea 0x1(%rcx),%rdx
cmp %rsi,%rcx
je 1657 <func0+0x377>
mov %rdx,%rcx
movzbl 0x0(%rbp,%rcx,1),%edx
lea -0x61(%rdx),%edi
cmp $0x19,%dil
ja 16f0 <func0+0x410>
sub $0x20,%edx
jmp 16fe <func0+0x41e>
nopl 0x0(%rax)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 1528 <func0+0x248>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 154f <func0+0x26f>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 1576 <func0+0x296>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 159d <func0+0x2bd>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 15c4 <func0+0x2e4>
nopl 0x0(%rax,%rax,1)
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 15eb <func0+0x30b>
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 160e <func0+0x32e>
lea -0x41(%rsi),%r8d
lea 0x20(%rsi),%edi
cmp $0x1a,%r8b
cmovb %edi,%esi
jmpq 1631 <func0+0x351>
lea -0x41(%rcx),%edi
lea 0x20(%rcx),%esi
cmp $0x1a,%dil
cmovb %esi,%ecx
jmpq 1654 <func0+0x374>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rcx, rax
test eax, eax
jle short loc_135A
lea edi, [rax-1]
mov esi, eax
cmp edi, 6
jbe short loc_1316
lea rdx, [rbp+1]
mov rax, rbx
sub rax, rdx
cmp rax, 0Eh
ja short loc_1370
loc_1316:
xor edx, edx
jmp short loc_1332
loc_1320:
sub eax, 20h ; ' '
mov [rbx+rdx], al
lea rax, [rdx+1]
cmp rdx, rdi
jz short loc_135A
loc_132F:
mov rdx, rax
loc_1332:
movzx eax, byte ptr [rbp+rdx+0]
lea esi, [rax-61h]
cmp sil, 19h
jbe short loc_1320
lea r8d, [rax-41h]
lea esi, [rax+20h]
cmp r8b, 1Ah
cmovb eax, esi
mov [rbx+rdx], al
lea rax, [rdx+1]
cmp rdx, rdi
jnz short loc_132F
loc_135A:
movsxd rcx, ecx
mov byte ptr [rbx+rcx], 0
add rsp, 8
pop rbx
pop rbp
retn
loc_1370:
cmp edi, 0Eh
jbe loc_1690
mov edx, ecx
movdqa xmm7, cs:xmmword_2130
xor eax, eax
pxor xmm3, xmm3
shr edx, 4
movdqa xmm4, cs:xmmword_2140
movdqa xmm8, cs:xmmword_2120
movdqa xmm6, cs:xmmword_2150
movdqa xmm5, cs:xmmword_2160
shl rdx, 4
loc_13B1:
movdqu xmm2, xmmword ptr [rbp+rax+0]
movdqa xmm1, xmm2
movdqa xmm0, xmm2
movdqa xmm10, xmm2
paddb xmm1, xmm8
paddb xmm0, xmm7
psubusb xmm1, xmm4
psubusb xmm0, xmm4
pcmpeqb xmm1, xmm3
pcmpeqb xmm0, xmm3
paddb xmm10, xmm6
movdqa xmm9, xmm1
pcmpeqb xmm0, xmm3
pcmpeqb xmm9, xmm3
pand xmm0, xmm9
movdqa xmm9, xmm2
paddb xmm2, xmm5
pand xmm9, xmm0
pandn xmm0, xmm10
pand xmm2, xmm1
por xmm0, xmm9
pandn xmm1, xmm0
por xmm1, xmm2
movups xmmword ptr [rbx+rax], xmm1
add rax, 10h
cmp rax, rdx
jnz short loc_13B1
mov edx, ecx
and edx, 0FFFFFFF0h
mov eax, edx
test cl, 0Fh
jz loc_135A
mov esi, ecx
sub esi, edx
lea edi, [rsi-1]
cmp edi, 6
jbe loc_14D5
loc_1446:
movq xmm2, qword ptr [rbp+rdx+0]
pxor xmm3, xmm3
movq xmm1, qword ptr cs:xmmword_2120
movq xmm0, qword ptr cs:xmmword_2130
movq xmm4, qword ptr cs:xmmword_2140
paddb xmm1, xmm2
paddb xmm0, xmm2
psubusb xmm1, xmm4
psubusb xmm0, xmm4
movdqa xmm4, xmm2
pcmpeqb xmm1, xmm3
pcmpeqb xmm0, xmm3
pcmpeqb xmm0, xmm3
pcmpeqb xmm3, xmm1
pand xmm0, xmm3
movq xmm3, qword ptr cs:xmmword_2150
pand xmm4, xmm0
paddb xmm3, xmm2
pandn xmm0, xmm3
movq xmm3, qword ptr cs:xmmword_2160
por xmm0, xmm4
paddb xmm2, xmm3
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movq qword ptr [rbx+rdx], xmm1
mov edx, esi
and edx, 0FFFFFFF8h
add eax, edx
and esi, 7
jz loc_135A
loc_14D5:
movsxd rsi, eax
movzx edx, byte ptr [rbp+rsi+0]
lea edi, [rdx-61h]
cmp dil, 19h
jbe loc_1600
lea r8d, [rdx-41h]
lea edi, [rdx+20h]
cmp r8b, 1Ah
cmovb edx, edi
loc_14F8:
mov [rbx+rsi], dl
lea edx, [rax+1]
cmp ecx, edx
jle loc_135A
movsxd rdx, edx
movzx esi, byte ptr [rbp+rdx+0]
lea edi, [rsi-61h]
cmp dil, 19h
ja loc_1610
sub esi, 20h ; ' '
loc_151E:
mov [rbx+rdx], sil
lea edx, [rax+2]
cmp ecx, edx
jle loc_135A
movsxd rdx, edx
movzx esi, byte ptr [rbp+rdx+0]
lea edi, [rsi-61h]
cmp dil, 19h
ja loc_1628
sub esi, 20h ; ' '
loc_1545:
mov [rbx+rdx], sil
lea edx, [rax+3]
cmp ecx, edx
jle loc_135A
movsxd rdx, edx
movzx esi, byte ptr [rbp+rdx+0]
lea edi, [rsi-61h]
cmp dil, 19h
ja loc_1640
sub esi, 20h ; ' '
loc_156C:
mov [rbx+rdx], sil
lea edx, [rax+4]
cmp ecx, edx
jle loc_135A
movsxd rdx, edx
movzx esi, byte ptr [rbp+rdx+0]
lea edi, [rsi-61h]
cmp dil, 19h
ja loc_1658
sub esi, 20h ; ' '
loc_1593:
mov [rbx+rdx], sil
lea edx, [rax+5]
cmp ecx, edx
jle loc_135A
movsxd rdx, edx
movzx esi, byte ptr [rbp+rdx+0]
lea edi, [rsi-61h]
cmp dil, 19h
ja loc_1670
sub esi, 20h ; ' '
loc_15BA:
add eax, 6
mov [rbx+rdx], sil
cmp ecx, eax
jle loc_135A
cdqe
movzx edx, byte ptr [rbp+rax+0]
lea esi, [rdx-61h]
cmp sil, 19h
jbe loc_1688
lea edi, [rdx-41h]
lea esi, [rdx+20h]
cmp dil, 1Ah
cmovb edx, esi
loc_15EA:
movsxd rcx, ecx
mov [rbx+rax], dl
mov byte ptr [rbx+rcx], 0
add rsp, 8
pop rbx
pop rbp
retn
loc_1600:
sub edx, 20h ; ' '
jmp loc_14F8
loc_1610:
lea r8d, [rsi-41h]
lea edi, [rsi+20h]
cmp r8b, 1Ah
cmovb esi, edi
jmp loc_151E
loc_1628:
lea r8d, [rsi-41h]
lea edi, [rsi+20h]
cmp r8b, 1Ah
cmovb esi, edi
jmp loc_1545
loc_1640:
lea r8d, [rsi-41h]
lea edi, [rsi+20h]
cmp r8b, 1Ah
cmovb esi, edi
jmp loc_156C
loc_1658:
lea r8d, [rsi-41h]
lea edi, [rsi+20h]
cmp r8b, 1Ah
cmovb esi, edi
jmp loc_1593
loc_1670:
lea r8d, [rsi-41h]
lea edi, [rsi+20h]
cmp r8b, 1Ah
cmovb esi, edi
jmp loc_15BA
loc_1688:
sub edx, 20h ; ' '
jmp loc_15EA
loc_1690:
xor edx, edx
xor eax, eax
jmp loc_1446
|
size_t func0(const char *a1, long long a2)
{
size_t result; // rax
int v5; // ecx
long long v6; // rdi
int v7; // esi
size_t i; // rdx
char v9; // al
__m128i si128; // xmm7
long long v11; // rax
__m128i v12; // xmm4
__m128i v13; // xmm8
__m128i v14; // xmm6
__m128i v15; // xmm5
__m128i v16; // xmm2
__m128i v17; // xmm1
__m128i v18; // xmm0
size_t v19; // rdx
__m128i v20; // xmm2
__m128i v21; // xmm4
__m128i v22; // xmm1
__m128i v23; // xmm0
char v24; // dl
int v25; // edx
char v26; // si
int v27; // edx
char v28; // si
int v29; // edx
char v30; // si
int v31; // edx
char v32; // si
int v33; // edx
char v34; // si
char v35; // dl
result = strlen(a1);
v5 = result;
if ( (int)result <= 0 )
goto LABEL_11;
v6 = (unsigned int)(result - 1);
v7 = result;
if ( (unsigned int)v6 <= 6 || (unsigned long long)(a2 - (_QWORD)(a1 + 1)) <= 0xE )
{
for ( i = 0LL; ; i = result )
{
v9 = a1[i];
if ( (unsigned __int8)(v9 - 97) <= 0x19u )
{
*(_BYTE *)(a2 + i) = v9 - 32;
result = i + 1;
if ( i == v6 )
goto LABEL_11;
}
else
{
if ( (unsigned __int8)(v9 - 65) < 0x1Au )
v9 += 32;
*(_BYTE *)(a2 + i) = v9;
result = i + 1;
if ( i == v6 )
goto LABEL_11;
}
}
}
if ( (unsigned int)v6 <= 0xE )
{
v19 = 0LL;
LODWORD(result) = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2130);
v11 = 0LL;
v12 = _mm_load_si128((const __m128i *)&xmmword_2140);
v13 = _mm_load_si128((const __m128i *)&xmmword_2120);
v14 = _mm_load_si128((const __m128i *)&xmmword_2150);
v15 = _mm_load_si128((const __m128i *)&xmmword_2160);
do
{
v16 = _mm_loadu_si128((const __m128i *)&a1[v11]);
v17 = _mm_cmpeq_epi8(_mm_subs_epu8(_mm_add_epi8(v16, v13), v12), (__m128i)0LL);
v18 = _mm_and_si128(
_mm_cmpeq_epi8(_mm_cmpeq_epi8(_mm_subs_epu8(_mm_add_epi8(v16, si128), v12), (__m128i)0LL), (__m128i)0LL),
_mm_cmpeq_epi8(v17, (__m128i)0LL));
*(__m128i *)(a2 + v11) = _mm_or_si128(
_mm_andnot_si128(
v17,
_mm_or_si128(_mm_andnot_si128(v18, _mm_add_epi8(v16, v14)), _mm_and_si128(v16, v18))),
_mm_and_si128(_mm_add_epi8(v16, v15), v17));
v11 += 16LL;
}
while ( v11 != 16LL * ((unsigned int)v5 >> 4) );
v19 = v5 & 0xFFFFFFF0;
result = v19;
if ( (v5 & 0xF) == 0 )
goto LABEL_11;
v7 = v5 - v19;
if ( (unsigned int)(v5 - v19 - 1) <= 6 )
goto LABEL_18;
}
v20 = _mm_loadl_epi64((const __m128i *)&a1[v19]);
v21 = _mm_loadl_epi64((const __m128i *)&xmmword_2140);
v22 = _mm_cmpeq_epi8(
_mm_subs_epu8(_mm_add_epi8(_mm_loadl_epi64((const __m128i *)&xmmword_2120), v20), v21),
(__m128i)0LL);
v23 = _mm_and_si128(
_mm_cmpeq_epi8(
_mm_cmpeq_epi8(
_mm_subs_epu8(_mm_add_epi8(_mm_loadl_epi64((const __m128i *)&xmmword_2130), v20), v21),
(__m128i)0LL),
(__m128i)0LL),
_mm_cmpeq_epi8((__m128i)0LL, v22));
*(_QWORD *)(a2 + v19) = _mm_or_si128(
_mm_andnot_si128(
v22,
_mm_or_si128(
_mm_andnot_si128(
v23,
_mm_add_epi8(_mm_loadl_epi64((const __m128i *)&xmmword_2150), v20)),
_mm_and_si128(v20, v23))),
_mm_and_si128(_mm_add_epi8(v20, _mm_loadl_epi64((const __m128i *)&xmmword_2160)), v22)).m128i_u64[0];
result = (v7 & 0xFFFFFFF8) + (unsigned int)result;
if ( (v7 & 7) == 0 )
{
LABEL_11:
*(_BYTE *)(a2 + v5) = 0;
return result;
}
LABEL_18:
v24 = a1[(int)result];
if ( (unsigned __int8)(v24 - 97) <= 0x19u )
{
v24 -= 32;
}
else if ( (unsigned __int8)(v24 - 65) < 0x1Au )
{
v24 += 32;
}
*(_BYTE *)(a2 + (int)result) = v24;
v25 = result + 1;
if ( v5 <= (int)result + 1 )
goto LABEL_11;
v26 = a1[v25];
if ( (unsigned __int8)(v26 - 97) > 0x19u )
{
if ( (unsigned __int8)(v26 - 65) < 0x1Au )
v26 += 32;
}
else
{
v26 -= 32;
}
*(_BYTE *)(a2 + v25) = v26;
v27 = result + 2;
if ( v5 <= (int)result + 2 )
goto LABEL_11;
v28 = a1[v27];
if ( (unsigned __int8)(v28 - 97) > 0x19u )
{
if ( (unsigned __int8)(v28 - 65) < 0x1Au )
v28 += 32;
}
else
{
v28 -= 32;
}
*(_BYTE *)(a2 + v27) = v28;
v29 = result + 3;
if ( v5 <= (int)result + 3 )
goto LABEL_11;
v30 = a1[v29];
if ( (unsigned __int8)(v30 - 97) > 0x19u )
{
if ( (unsigned __int8)(v30 - 65) < 0x1Au )
v30 += 32;
}
else
{
v30 -= 32;
}
*(_BYTE *)(a2 + v29) = v30;
v31 = result + 4;
if ( v5 <= (int)result + 4 )
goto LABEL_11;
v32 = a1[v31];
if ( (unsigned __int8)(v32 - 97) > 0x19u )
{
if ( (unsigned __int8)(v32 - 65) < 0x1Au )
v32 += 32;
}
else
{
v32 -= 32;
}
*(_BYTE *)(a2 + v31) = v32;
v33 = result + 5;
if ( v5 <= (int)result + 5 )
goto LABEL_11;
v34 = a1[v33];
if ( (unsigned __int8)(v34 - 97) > 0x19u )
{
if ( (unsigned __int8)(v34 - 65) < 0x1Au )
v34 += 32;
}
else
{
v34 -= 32;
}
result = (unsigned int)(result + 6);
*(_BYTE *)(a2 + v33) = v34;
if ( v5 <= (int)result )
goto LABEL_11;
result = (int)result;
v35 = a1[(int)result];
if ( (unsigned __int8)(v35 - 97) <= 0x19u )
{
v35 -= 32;
}
else if ( (unsigned __int8)(v35 - 65) < 0x1Au )
{
v35 += 32;
}
*(_BYTE *)(a2 + (int)result) = v35;
*(_BYTE *)(a2 + v5) = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
MOV RCX,RAX
TEST EAX,EAX
JLE 0x0010135a
LEA EDI,[RAX + -0x1]
MOV ESI,EAX
CMP EDI,0x6
JBE 0x00101316
LEA RDX,[RBP + 0x1]
MOV RAX,RBX
SUB RAX,RDX
CMP RAX,0xe
JA 0x00101370
LAB_00101316:
XOR EDX,EDX
JMP 0x00101332
LAB_00101320:
SUB EAX,0x20
MOV byte ptr [RBX + RDX*0x1],AL
LEA RAX,[RDX + 0x1]
CMP RDX,RDI
JZ 0x0010135a
LAB_0010132f:
MOV RDX,RAX
LAB_00101332:
MOVZX EAX,byte ptr [RBP + RDX*0x1]
LEA ESI,[RAX + -0x61]
CMP SIL,0x19
JBE 0x00101320
LEA R8D,[RAX + -0x41]
LEA ESI,[RAX + 0x20]
CMP R8B,0x1a
CMOVC EAX,ESI
MOV byte ptr [RBX + RDX*0x1],AL
LEA RAX,[RDX + 0x1]
CMP RDX,RDI
JNZ 0x0010132f
LAB_0010135a:
MOVSXD RCX,ECX
MOV byte ptr [RBX + RCX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101370:
CMP EDI,0xe
JBE 0x00101690
MOV EDX,ECX
MOVDQA XMM7,xmmword ptr [0x00102130]
XOR EAX,EAX
PXOR XMM3,XMM3
SHR EDX,0x4
MOVDQA XMM4,xmmword ptr [0x00102140]
MOVDQA XMM8,xmmword ptr [0x00102120]
MOVDQA XMM6,xmmword ptr [0x00102150]
MOVDQA XMM5,xmmword ptr [0x00102160]
SHL RDX,0x4
LAB_001013b1:
MOVDQU XMM2,xmmword ptr [RBP + RAX*0x1]
MOVDQA XMM1,XMM2
MOVDQA XMM0,XMM2
MOVDQA XMM10,XMM2
PADDB XMM1,XMM8
PADDB XMM0,XMM7
PSUBUSB XMM1,XMM4
PSUBUSB XMM0,XMM4
PCMPEQB XMM1,XMM3
PCMPEQB XMM0,XMM3
PADDB XMM10,XMM6
MOVDQA XMM9,XMM1
PCMPEQB XMM0,XMM3
PCMPEQB XMM9,XMM3
PAND XMM0,XMM9
MOVDQA XMM9,XMM2
PADDB XMM2,XMM5
PAND XMM9,XMM0
PANDN XMM0,XMM10
PAND XMM2,XMM1
POR XMM0,XMM9
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVUPS xmmword ptr [RBX + RAX*0x1],XMM1
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x001013b1
MOV EDX,ECX
AND EDX,0xfffffff0
MOV EAX,EDX
TEST CL,0xf
JZ 0x0010135a
MOV ESI,ECX
SUB ESI,EDX
LEA EDI,[RSI + -0x1]
CMP EDI,0x6
JBE 0x001014d5
LAB_00101446:
MOVQ XMM2,qword ptr [RBP + RDX*0x1]
PXOR XMM3,XMM3
MOVQ XMM1,qword ptr [0x00102120]
MOVQ XMM0,qword ptr [0x00102130]
MOVQ XMM4,qword ptr [0x00102140]
PADDB XMM1,XMM2
PADDB XMM0,XMM2
PSUBUSB XMM1,XMM4
PSUBUSB XMM0,XMM4
MOVDQA XMM4,XMM2
PCMPEQB XMM1,XMM3
PCMPEQB XMM0,XMM3
PCMPEQB XMM0,XMM3
PCMPEQB XMM3,XMM1
PAND XMM0,XMM3
MOVQ XMM3,qword ptr [0x00102150]
PAND XMM4,XMM0
PADDB XMM3,XMM2
PANDN XMM0,XMM3
MOVQ XMM3,qword ptr [0x00102160]
POR XMM0,XMM4
PADDB XMM2,XMM3
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVQ qword ptr [RBX + RDX*0x1],XMM1
MOV EDX,ESI
AND EDX,0xfffffff8
ADD EAX,EDX
AND ESI,0x7
JZ 0x0010135a
LAB_001014d5:
MOVSXD RSI,EAX
MOVZX EDX,byte ptr [RBP + RSI*0x1]
LEA EDI,[RDX + -0x61]
CMP DIL,0x19
JBE 0x00101600
LEA R8D,[RDX + -0x41]
LEA EDI,[RDX + 0x20]
CMP R8B,0x1a
CMOVC EDX,EDI
LAB_001014f8:
MOV byte ptr [RBX + RSI*0x1],DL
LEA EDX,[RAX + 0x1]
CMP ECX,EDX
JLE 0x0010135a
MOVSXD RDX,EDX
MOVZX ESI,byte ptr [RBP + RDX*0x1]
LEA EDI,[RSI + -0x61]
CMP DIL,0x19
JA 0x00101610
SUB ESI,0x20
LAB_0010151e:
MOV byte ptr [RBX + RDX*0x1],SIL
LEA EDX,[RAX + 0x2]
CMP ECX,EDX
JLE 0x0010135a
MOVSXD RDX,EDX
MOVZX ESI,byte ptr [RBP + RDX*0x1]
LEA EDI,[RSI + -0x61]
CMP DIL,0x19
JA 0x00101628
SUB ESI,0x20
LAB_00101545:
MOV byte ptr [RBX + RDX*0x1],SIL
LEA EDX,[RAX + 0x3]
CMP ECX,EDX
JLE 0x0010135a
MOVSXD RDX,EDX
MOVZX ESI,byte ptr [RBP + RDX*0x1]
LEA EDI,[RSI + -0x61]
CMP DIL,0x19
JA 0x00101640
SUB ESI,0x20
LAB_0010156c:
MOV byte ptr [RBX + RDX*0x1],SIL
LEA EDX,[RAX + 0x4]
CMP ECX,EDX
JLE 0x0010135a
MOVSXD RDX,EDX
MOVZX ESI,byte ptr [RBP + RDX*0x1]
LEA EDI,[RSI + -0x61]
CMP DIL,0x19
JA 0x00101658
SUB ESI,0x20
LAB_00101593:
MOV byte ptr [RBX + RDX*0x1],SIL
LEA EDX,[RAX + 0x5]
CMP ECX,EDX
JLE 0x0010135a
MOVSXD RDX,EDX
MOVZX ESI,byte ptr [RBP + RDX*0x1]
LEA EDI,[RSI + -0x61]
CMP DIL,0x19
JA 0x00101670
SUB ESI,0x20
LAB_001015ba:
ADD EAX,0x6
MOV byte ptr [RBX + RDX*0x1],SIL
CMP ECX,EAX
JLE 0x0010135a
CDQE
MOVZX EDX,byte ptr [RBP + RAX*0x1]
LEA ESI,[RDX + -0x61]
CMP SIL,0x19
JBE 0x00101688
LEA EDI,[RDX + -0x41]
LEA ESI,[RDX + 0x20]
CMP DIL,0x1a
CMOVC EDX,ESI
LAB_001015ea:
MOVSXD RCX,ECX
MOV byte ptr [RBX + RAX*0x1],DL
MOV byte ptr [RBX + RCX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101600:
SUB EDX,0x20
JMP 0x001014f8
LAB_00101610:
LEA R8D,[RSI + -0x41]
LEA EDI,[RSI + 0x20]
CMP R8B,0x1a
CMOVC ESI,EDI
JMP 0x0010151e
LAB_00101628:
LEA R8D,[RSI + -0x41]
LEA EDI,[RSI + 0x20]
CMP R8B,0x1a
CMOVC ESI,EDI
JMP 0x00101545
LAB_00101640:
LEA R8D,[RSI + -0x41]
LEA EDI,[RSI + 0x20]
CMP R8B,0x1a
CMOVC ESI,EDI
JMP 0x0010156c
LAB_00101658:
LEA R8D,[RSI + -0x41]
LEA EDI,[RSI + 0x20]
CMP R8B,0x1a
CMOVC ESI,EDI
JMP 0x00101593
LAB_00101670:
LEA R8D,[RSI + -0x41]
LEA EDI,[RSI + 0x20]
CMP R8B,0x1a
CMOVC ESI,EDI
JMP 0x001015ba
LAB_00101688:
SUB EDX,0x20
JMP 0x001015ea
LAB_00101690:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x00101446
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(char *param_1,long param_2)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
byte bVar7;
byte bVar8;
byte bVar9;
char cVar10;
char cVar11;
char cVar12;
char cVar13;
char cVar14;
char cVar15;
char cVar16;
char cVar17;
char cVar18;
char cVar19;
char cVar20;
char cVar21;
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;
char cVar38;
char cVar39;
char cVar40;
char cVar41;
char cVar42;
char cVar43;
char cVar44;
char cVar45;
char cVar46;
char cVar47;
char cVar48;
char cVar49;
char cVar50;
char cVar51;
char cVar52;
char cVar53;
char cVar54;
char cVar55;
char cVar56;
char cVar57;
char cVar58;
char cVar59;
char cVar60;
char cVar61;
char cVar62;
char cVar63;
char cVar64;
char cVar65;
char cVar66;
char cVar67;
char cVar68;
char cVar69;
char cVar70;
char cVar71;
char cVar72;
uint uVar73;
int iVar74;
size_t sVar75;
ulong uVar76;
long lVar77;
char cVar78;
uint uVar79;
int iVar80;
uint uVar81;
byte bVar82;
byte bVar86;
byte bVar87;
byte bVar88;
byte bVar89;
byte bVar90;
byte bVar91;
byte bVar92;
int auVar83 [16];
int auVar84 [16];
int auVar85 [16];
byte bVar93;
byte bVar94;
byte bVar97;
byte bVar98;
byte bVar99;
byte bVar100;
byte bVar101;
byte bVar102;
byte bVar103;
byte bVar104;
byte bVar105;
byte bVar106;
byte bVar107;
byte bVar108;
byte bVar109;
byte bVar110;
byte bVar111;
byte bVar112;
byte bVar113;
byte bVar114;
byte bVar115;
byte bVar116;
byte bVar117;
int auVar95 [16];
byte bVar118;
int auVar96 [16];
byte bVar119;
byte bVar120;
byte bVar121;
byte bVar122;
byte bVar123;
byte bVar124;
byte bVar125;
byte bVar126;
int auVar127 [16];
sVar75 = strlen(param_1);
cVar72 = UNK_0010216f;
cVar71 = UNK_0010216e;
cVar70 = UNK_0010216d;
cVar69 = UNK_0010216c;
cVar68 = UNK_0010216b;
cVar67 = UNK_0010216a;
cVar66 = UNK_00102169;
cVar65 = UNK_00102168;
cVar64 = DAT_00102160._7_1_;
cVar63 = DAT_00102160._6_1_;
cVar62 = DAT_00102160._5_1_;
cVar61 = DAT_00102160._4_1_;
cVar60 = DAT_00102160._3_1_;
cVar59 = DAT_00102160._2_1_;
cVar58 = DAT_00102160._1_1_;
cVar57 = (char)DAT_00102160;
cVar56 = UNK_0010215f;
cVar55 = UNK_0010215e;
cVar54 = UNK_0010215d;
cVar53 = UNK_0010215c;
cVar52 = UNK_0010215b;
cVar51 = UNK_0010215a;
cVar50 = UNK_00102159;
cVar49 = UNK_00102158;
cVar48 = DAT_00102150._7_1_;
cVar47 = DAT_00102150._6_1_;
cVar46 = DAT_00102150._5_1_;
cVar45 = DAT_00102150._4_1_;
cVar44 = DAT_00102150._3_1_;
cVar43 = DAT_00102150._2_1_;
cVar42 = DAT_00102150._1_1_;
cVar41 = (char)DAT_00102150;
cVar40 = UNK_0010213f;
cVar39 = UNK_0010213e;
cVar38 = UNK_0010213d;
cVar37 = UNK_0010213c;
cVar36 = UNK_0010213b;
cVar35 = UNK_0010213a;
cVar34 = UNK_00102139;
cVar33 = UNK_00102138;
cVar32 = DAT_00102130._7_1_;
cVar31 = DAT_00102130._6_1_;
cVar30 = DAT_00102130._5_1_;
cVar29 = DAT_00102130._4_1_;
cVar28 = DAT_00102130._3_1_;
cVar27 = DAT_00102130._2_1_;
cVar26 = DAT_00102130._1_1_;
cVar25 = (char)DAT_00102130;
cVar24 = UNK_0010212f;
cVar23 = UNK_0010212e;
cVar22 = UNK_0010212d;
cVar21 = UNK_0010212c;
cVar20 = UNK_0010212b;
cVar19 = UNK_0010212a;
cVar18 = UNK_00102129;
cVar17 = UNK_00102128;
cVar16 = DAT_00102120._7_1_;
cVar15 = DAT_00102120._6_1_;
cVar14 = DAT_00102120._5_1_;
cVar13 = DAT_00102120._4_1_;
cVar12 = DAT_00102120._3_1_;
cVar11 = DAT_00102120._2_1_;
cVar10 = DAT_00102120._1_1_;
cVar78 = (char)DAT_00102120;
uVar73 = (uint)sVar75;
if ((int)uVar73 < 1) goto LAB_0010135a;
uVar81 = uVar73 - 1;
if ((uVar81 < 7) || ((ulong)(param_2 - (long)(param_1 + 1)) < 0xf)) {
uVar76 = 0;
while( true ) {
cVar78 = param_1[uVar76];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
*(char *)(param_2 + uVar76) = cVar78 + -0x20;
}
else {
if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + uVar76) = cVar78;
}
if (uVar76 == uVar81) break;
uVar76 = uVar76 + 1;
}
goto LAB_0010135a;
}
if (uVar81 < 0xf) {
uVar76 = 0;
uVar79 = 0;
uVar81 = uVar73;
LAB_00101446:
pbVar1 = (byte *)(param_1 + uVar76);
bVar2 = *pbVar1;
bVar3 = pbVar1[1];
bVar4 = pbVar1[2];
bVar5 = pbVar1[3];
bVar6 = pbVar1[4];
bVar7 = pbVar1[5];
bVar8 = pbVar1[6];
bVar9 = pbVar1[7];
auVar127._8_8_ = 0;
auVar127._0_8_ = DAT_00102140;
auVar96[0] = (char)DAT_00102120 + bVar2;
auVar96[1] = DAT_00102120._1_1_ + bVar3;
auVar96[2] = DAT_00102120._2_1_ + bVar4;
auVar96[3] = DAT_00102120._3_1_ + bVar5;
auVar96[4] = DAT_00102120._4_1_ + bVar6;
auVar96[5] = DAT_00102120._5_1_ + bVar7;
auVar96[6] = DAT_00102120._6_1_ + bVar8;
auVar96[7] = DAT_00102120._7_1_ + bVar9;
auVar96._8_8_ = 0;
auVar84[0] = (char)DAT_00102130 + bVar2;
auVar84[1] = DAT_00102130._1_1_ + bVar3;
auVar84[2] = DAT_00102130._2_1_ + bVar4;
auVar84[3] = DAT_00102130._3_1_ + bVar5;
auVar84[4] = DAT_00102130._4_1_ + bVar6;
auVar84[5] = DAT_00102130._5_1_ + bVar7;
auVar84[6] = DAT_00102130._6_1_ + bVar8;
auVar84[7] = DAT_00102130._7_1_ + bVar9;
auVar84._8_8_ = 0;
auVar83 = psubusb(auVar96,auVar127);
auVar85 = psubusb(auVar84,auVar127);
bVar94 = -(auVar83[0] == '\0');
bVar98 = -(auVar83[1] == '\0');
bVar100 = -(auVar83[2] == '\0');
bVar102 = -(auVar83[3] == '\0');
bVar104 = -(auVar83[4] == '\0');
bVar106 = -(auVar83[5] == '\0');
bVar108 = -(auVar83[6] == '\0');
bVar110 = -(auVar83[7] == '\0');
bVar82 = -(auVar85[0] != '\0') & -(bVar94 == 0);
bVar86 = -(auVar85[1] != '\0') & -(bVar98 == 0);
bVar87 = -(auVar85[2] != '\0') & -(bVar100 == 0);
bVar88 = -(auVar85[3] != '\0') & -(bVar102 == 0);
bVar89 = -(auVar85[4] != '\0') & -(bVar104 == 0);
bVar90 = -(auVar85[5] != '\0') & -(bVar106 == 0);
bVar91 = -(auVar85[6] != '\0') & -(bVar108 == 0);
bVar92 = -(auVar85[7] != '\0') & -(bVar110 == 0);
bVar126 = DAT_00102150._1_1_ + bVar3;
bVar93 = DAT_00102150._2_1_ + bVar4;
bVar97 = DAT_00102150._3_1_ + bVar5;
bVar99 = DAT_00102150._4_1_ + bVar6;
bVar101 = DAT_00102150._5_1_ + bVar7;
bVar103 = DAT_00102150._6_1_ + bVar8;
bVar105 = DAT_00102150._7_1_ + bVar9;
bVar119 = bVar3 + DAT_00102160._1_1_;
bVar120 = bVar4 + DAT_00102160._2_1_;
bVar121 = bVar5 + DAT_00102160._3_1_;
bVar122 = bVar6 + DAT_00102160._4_1_;
bVar123 = bVar7 + DAT_00102160._5_1_;
bVar124 = bVar8 + DAT_00102160._6_1_;
bVar125 = bVar9 + DAT_00102160._7_1_;
pbVar1 = (byte *)(param_2 + uVar76);
*pbVar1 = ~bVar94 & (~bVar82 & (char)DAT_00102150 + bVar2 | bVar2 & bVar82) |
bVar2 + (char)DAT_00102160 & bVar94;
pbVar1[1] = ~bVar98 & (~bVar86 & bVar126 | bVar3 & bVar86) | bVar119 & bVar98;
pbVar1[2] = ~bVar100 & (~bVar87 & bVar93 | bVar4 & bVar87) | bVar120 & bVar100;
pbVar1[3] = ~bVar102 & (~bVar88 & bVar97 | bVar5 & bVar88) | bVar121 & bVar102;
pbVar1[4] = ~bVar104 & (~bVar89 & bVar99 | bVar6 & bVar89) | bVar122 & bVar104;
pbVar1[5] = ~bVar106 & (~bVar90 & bVar101 | bVar7 & bVar90) | bVar123 & bVar106;
pbVar1[6] = ~bVar108 & (~bVar91 & bVar103 | bVar8 & bVar91) | bVar124 & bVar108;
pbVar1[7] = ~bVar110 & (~bVar92 & bVar105 | bVar9 & bVar92) | bVar125 & bVar110;
uVar79 = uVar79 + (uVar81 & 0xfffffff8);
if ((uVar81 & 7) == 0) goto LAB_0010135a;
}
else {
lVar77 = 0;
auVar85._8_8_ = _UNK_00102148;
auVar85._0_8_ = DAT_00102140;
do {
pbVar1 = (byte *)(param_1 + lVar77);
bVar2 = *pbVar1;
bVar3 = pbVar1[1];
bVar4 = pbVar1[2];
bVar5 = pbVar1[3];
bVar6 = pbVar1[4];
bVar7 = pbVar1[5];
bVar8 = pbVar1[6];
bVar9 = pbVar1[7];
bVar82 = pbVar1[8];
bVar86 = pbVar1[9];
bVar87 = pbVar1[10];
bVar88 = pbVar1[0xb];
bVar89 = pbVar1[0xc];
bVar90 = pbVar1[0xd];
bVar91 = pbVar1[0xe];
bVar92 = pbVar1[0xf];
auVar95[0] = bVar2 + cVar78;
auVar95[1] = bVar3 + cVar10;
auVar95[2] = bVar4 + cVar11;
auVar95[3] = bVar5 + cVar12;
auVar95[4] = bVar6 + cVar13;
auVar95[5] = bVar7 + cVar14;
auVar95[6] = bVar8 + cVar15;
auVar95[7] = bVar9 + cVar16;
auVar95[8] = bVar82 + cVar17;
auVar95[9] = bVar86 + cVar18;
auVar95[10] = bVar87 + cVar19;
auVar95[0xb] = bVar88 + cVar20;
auVar95[0xc] = bVar89 + cVar21;
auVar95[0xd] = bVar90 + cVar22;
auVar95[0xe] = bVar91 + cVar23;
auVar95[0xf] = bVar92 + cVar24;
auVar83[0] = bVar2 + cVar25;
auVar83[1] = bVar3 + cVar26;
auVar83[2] = bVar4 + cVar27;
auVar83[3] = bVar5 + cVar28;
auVar83[4] = bVar6 + cVar29;
auVar83[5] = bVar7 + cVar30;
auVar83[6] = bVar8 + cVar31;
auVar83[7] = bVar9 + cVar32;
auVar83[8] = bVar82 + cVar33;
auVar83[9] = bVar86 + cVar34;
auVar83[10] = bVar87 + cVar35;
auVar83[0xb] = bVar88 + cVar36;
auVar83[0xc] = bVar89 + cVar37;
auVar83[0xd] = bVar90 + cVar38;
auVar83[0xe] = bVar91 + cVar39;
auVar83[0xf] = bVar92 + cVar40;
auVar95 = psubusb(auVar95,auVar85);
auVar83 = psubusb(auVar83,auVar85);
bVar93 = -(auVar95[0] == '\0');
bVar97 = -(auVar95[1] == '\0');
bVar99 = -(auVar95[2] == '\0');
bVar101 = -(auVar95[3] == '\0');
bVar103 = -(auVar95[4] == '\0');
bVar105 = -(auVar95[5] == '\0');
bVar107 = -(auVar95[6] == '\0');
bVar109 = -(auVar95[7] == '\0');
bVar111 = -(auVar95[8] == '\0');
bVar112 = -(auVar95[9] == '\0');
bVar113 = -(auVar95[10] == '\0');
bVar114 = -(auVar95[0xb] == '\0');
bVar115 = -(auVar95[0xc] == '\0');
bVar116 = -(auVar95[0xd] == '\0');
bVar117 = -(auVar95[0xe] == '\0');
bVar118 = -(auVar95[0xf] == '\0');
bVar94 = -(auVar83[0] != '\0') & -(bVar93 == 0);
bVar98 = -(auVar83[1] != '\0') & -(bVar97 == 0);
bVar100 = -(auVar83[2] != '\0') & -(bVar99 == 0);
bVar102 = -(auVar83[3] != '\0') & -(bVar101 == 0);
bVar104 = -(auVar83[4] != '\0') & -(bVar103 == 0);
bVar106 = -(auVar83[5] != '\0') & -(bVar105 == 0);
bVar108 = -(auVar83[6] != '\0') & -(bVar107 == 0);
bVar110 = -(auVar83[7] != '\0') & -(bVar109 == 0);
bVar119 = -(auVar83[8] != '\0') & -(bVar111 == 0);
bVar120 = -(auVar83[9] != '\0') & -(bVar112 == 0);
bVar121 = -(auVar83[10] != '\0') & -(bVar113 == 0);
bVar122 = -(auVar83[0xb] != '\0') & -(bVar114 == 0);
bVar123 = -(auVar83[0xc] != '\0') & -(bVar115 == 0);
bVar124 = -(auVar83[0xd] != '\0') & -(bVar116 == 0);
bVar125 = -(auVar83[0xe] != '\0') & -(bVar117 == 0);
bVar126 = -(auVar83[0xf] != '\0') & -(bVar118 == 0);
pbVar1 = (byte *)(param_2 + lVar77);
*pbVar1 = ~bVar93 & (~bVar94 & bVar2 + cVar41 | bVar2 & bVar94) | bVar2 + cVar57 & bVar93;
pbVar1[1] = ~bVar97 & (~bVar98 & bVar3 + cVar42 | bVar3 & bVar98) | bVar3 + cVar58 & bVar97;
pbVar1[2] = ~bVar99 & (~bVar100 & bVar4 + cVar43 | bVar4 & bVar100) | bVar4 + cVar59 & bVar99;
pbVar1[3] = ~bVar101 & (~bVar102 & bVar5 + cVar44 | bVar5 & bVar102) |
bVar5 + cVar60 & bVar101;
pbVar1[4] = ~bVar103 & (~bVar104 & bVar6 + cVar45 | bVar6 & bVar104) |
bVar6 + cVar61 & bVar103;
pbVar1[5] = ~bVar105 & (~bVar106 & bVar7 + cVar46 | bVar7 & bVar106) |
bVar7 + cVar62 & bVar105;
pbVar1[6] = ~bVar107 & (~bVar108 & bVar8 + cVar47 | bVar8 & bVar108) |
bVar8 + cVar63 & bVar107;
pbVar1[7] = ~bVar109 & (~bVar110 & bVar9 + cVar48 | bVar9 & bVar110) |
bVar9 + cVar64 & bVar109;
pbVar1[8] = ~bVar111 & (~bVar119 & bVar82 + cVar49 | bVar82 & bVar119) |
bVar82 + cVar65 & bVar111;
pbVar1[9] = ~bVar112 & (~bVar120 & bVar86 + cVar50 | bVar86 & bVar120) |
bVar86 + cVar66 & bVar112;
pbVar1[10] = ~bVar113 & (~bVar121 & bVar87 + cVar51 | bVar87 & bVar121) |
bVar87 + cVar67 & bVar113;
pbVar1[0xb] = ~bVar114 & (~bVar122 & bVar88 + cVar52 | bVar88 & bVar122) |
bVar88 + cVar68 & bVar114;
pbVar1[0xc] = ~bVar115 & (~bVar123 & bVar89 + cVar53 | bVar89 & bVar123) |
bVar89 + cVar69 & bVar115;
pbVar1[0xd] = ~bVar116 & (~bVar124 & bVar90 + cVar54 | bVar90 & bVar124) |
bVar90 + cVar70 & bVar116;
pbVar1[0xe] = ~bVar117 & (~bVar125 & bVar91 + cVar55 | bVar91 & bVar125) |
bVar91 + cVar71 & bVar117;
pbVar1[0xf] = ~bVar118 & (~bVar126 & bVar92 + cVar56 | bVar92 & bVar126) |
bVar92 + cVar72 & bVar118;
lVar77 = lVar77 + 0x10;
} while (lVar77 != (sVar75 >> 4 & 0xfffffff) << 4);
uVar79 = uVar73 & 0xfffffff0;
uVar76 = (ulong)uVar79;
if ((sVar75 & 0xf) == 0) goto LAB_0010135a;
uVar81 = uVar73 - uVar79;
if (6 < (uVar73 - uVar79) - 1) goto LAB_00101446;
}
cVar78 = param_1[(int)uVar79];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + (int)uVar79) = cVar78;
iVar80 = uVar79 + 1;
if (iVar80 < (int)uVar73) {
cVar78 = param_1[iVar80];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + iVar80) = cVar78;
iVar80 = uVar79 + 2;
if (iVar80 < (int)uVar73) {
cVar78 = param_1[iVar80];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + iVar80) = cVar78;
iVar80 = uVar79 + 3;
if (iVar80 < (int)uVar73) {
cVar78 = param_1[iVar80];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + iVar80) = cVar78;
iVar80 = uVar79 + 4;
if (iVar80 < (int)uVar73) {
cVar78 = param_1[iVar80];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + iVar80) = cVar78;
iVar80 = uVar79 + 5;
if (iVar80 < (int)uVar73) {
cVar78 = param_1[iVar80];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
iVar74 = uVar79 + 6;
*(char *)(param_2 + iVar80) = cVar78;
if (iVar74 < (int)uVar73) {
cVar78 = param_1[iVar74];
if ((byte)(cVar78 + 0x9fU) < 0x1a) {
cVar78 = cVar78 + -0x20;
}
else if ((byte)(cVar78 + 0xbfU) < 0x1a) {
cVar78 = cVar78 + ' ';
}
*(char *)(param_2 + iVar74) = cVar78;
*(int *)(param_2 + (int)uVar73) = 0;
return;
}
}
}
}
}
}
LAB_0010135a:
*(int *)(param_2 + (int)uVar73) = 0;
return;
}
|
768 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, strings[i]);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(result);
char* strings2[] = {"x", "y", "z", "w", "k"};
result = func0(strings2, 5);
assert(strcmp(result, "xyzwk") == 0);
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1259 <func0+0x50>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,%edx
mov -0x14(%rbp),%eax
add %edx,%eax
mov %eax,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 122c <func0+0x23>
mov -0x14(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 1283 <func0+0x7a>
mov $0x0,%eax
jmp 12c9 <func0+0xc0>
mov -0x8(%rbp),%rax
movb $0x0,(%rax)
movl $0x0,-0xc(%rbp)
jmp 12bd <func0+0xb4>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1110 <strcat@plt>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1293 <func0+0x8a>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_1259
loc_122C:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_14]
add eax, edx
mov [rbp+var_14], eax
add [rbp+var_10], 1
loc_1259:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl short loc_122C
mov eax, [rbp+var_14]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
cmp [rbp+dest], 0
jnz short loc_1283
mov eax, 0
jmp short locret_12C9
loc_1283:
mov rax, [rbp+dest]
mov byte ptr [rax], 0
mov [rbp+var_C], 0
jmp short loc_12BD
loc_1293:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
add [rbp+var_C], 1
loc_12BD:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl short loc_1293
mov rax, [rbp+dest]
locret_12C9:
leave
retn
|
char * func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
char *dest; // [rsp+28h] [rbp-8h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += strlen(*(const char **)(8LL * i + a1));
dest = (char *)malloc(v3 + 1);
if ( !dest )
return 0LL;
*dest = 0;
for ( j = 0; j < a2; ++j )
strcat(dest, *(const char **)(8LL * j + a1));
return dest;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101259
LAB_0010122c:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010c0
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x10],0x1
LAB_00101259:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010122c
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x00101283
MOV EAX,0x0
JMP 0x001012c9
LAB_00101283:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012bd
LAB_00101293:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
ADD dword ptr [RBP + -0xc],0x1
LAB_001012bd:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101293
MOV RAX,qword ptr [RBP + -0x8]
LAB_001012c9:
LEAVE
RET
|
char * func0(long param_1,int param_2)
{
size_t sVar1;
char *__dest;
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
sVar1 = strlen(*(char **)(param_1 + (long)local_18 * 8));
local_1c = local_1c + (int)sVar1;
}
__dest = (char *)malloc((long)(local_1c + 1));
if (__dest == (char *)0x0) {
__dest = (char *)0x0;
}
else {
*__dest = '\0';
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
strcat(__dest,*(char **)(param_1 + (long)local_14 * 8));
}
}
return __dest;
}
|
769 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, strings[i]);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(result);
char* strings2[] = {"x", "y", "z", "w", "k"};
result = func0(strings2, 5);
assert(strcmp(result, "xyzwk") == 0);
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1253 <func0+0x8a>
mov %rdi,%r12
mov %esi,%ebp
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r9
mov $0x0,%esi
mov $0xffffffffffffffff,%r8
mov $0x0,%eax
mov (%rdx),%rdi
mov %r8,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rsi,%rcx,1),%esi
add $0x8,%rdx
cmp %r9,%rdx
jne 11fc <func0+0x33>
lea 0x1(%rsi),%edi
movslq %edi,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 1245 <func0+0x7c>
movb $0x0,0x0(%r13)
mov $0x0,%ebx
mov (%r12,%rbx,8),%rsi
mov %r13,%rdi
callq 10d0 <strcat@plt>
add $0x1,%rbx
cmp %ebx,%ebp
jg 1231 <func0+0x68>
mov %r13,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x1,%edi
callq 10c0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 1245 <func0+0x7c>
movb $0x0,(%rax)
jmp 1245 <func0+0x7c>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r13d, esi
test esi, esi
jle short loc_128C
mov rbx, rdi
movsxd rax, esi
lea r12, [rdi+rax*8]
mov ebp, 0
loc_122E:
mov rdi, [rbx]; s
call _strlen
add eax, ebp
mov ebp, eax
add rbx, 8
cmp rbx, r12
jnz short loc_122E
add eax, 1
movsxd rbx, eax
mov rdi, rbx; size
call _malloc
mov r12, rax
test rax, rax
jz short loc_1280
mov byte ptr [r12], 0
loc_125E:
mov rbp, r14
movsxd r13, r13d
lea r13, [r14+r13*8]
loc_1268:
mov rsi, [rbp+0]
mov rdx, rbx
mov rdi, r12
call ___strcat_chk
add rbp, 8
cmp rbp, r13
jnz short loc_1268
loc_1280:
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_128C:
mov edi, 1; size
call _malloc
mov r12, rax
test rax, rax
jz short loc_1280
mov byte ptr [rax], 0
test r13d, r13d
jle short loc_1280
mov ebx, 1
jmp short loc_125E
|
_BYTE * func0(const char **a1, int a2)
{
const char **v2; // rbx
int v3; // ebp
int v4; // eax
size_t v5; // rbx
_BYTE *v6; // rax
_BYTE *v7; // r12
const char **v8; // rbp
_BYTE *v10; // rax
if ( a2 <= 0 )
{
v10 = malloc(1uLL);
v7 = v10;
if ( v10 )
*v10 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
{
v4 = v3 + strlen(*v2);
v3 = v4;
++v2;
}
while ( v2 != &a1[a2] );
v5 = v4 + 1;
v6 = malloc(v5);
v7 = v6;
if ( v6 )
{
*v6 = 0;
v8 = a1;
do
__strcat_chk(v7, *v8++, v5);
while ( v8 != &a1[a2] );
}
}
return v7;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R13D,ESI
TEST ESI,ESI
JLE 0x0010128c
MOV RBX,RDI
MOVSXD RAX,ESI
LEA R12,[RDI + RAX*0x8]
MOV EBP,0x0
LAB_0010122e:
MOV RDI,qword ptr [RBX]
CALL 0x001010d0
ADD EAX,EBP
MOV EBP,EAX
ADD RBX,0x8
CMP RBX,R12
JNZ 0x0010122e
ADD EAX,0x1
MOVSXD RBX,EAX
MOV RDI,RBX
CALL 0x00101110
MOV R12,RAX
TEST RAX,RAX
JZ 0x00101280
MOV byte ptr [R12],0x0
LAB_0010125e:
MOV RBP,R14
MOVSXD R13,R13D
LEA R13,[R14 + R13*0x8]
LAB_00101268:
MOV RSI,qword ptr [RBP]
MOV RDX,RBX
MOV RDI,R12
CALL 0x001010b0
ADD RBP,0x8
CMP RBP,R13
JNZ 0x00101268
LAB_00101280:
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010128c:
MOV EDI,0x1
CALL 0x00101110
MOV R12,RAX
TEST RAX,RAX
JZ 0x00101280
MOV byte ptr [RAX],0x0
TEST R13D,R13D
JLE 0x00101280
MOV EBX,0x1
JMP 0x0010125e
|
int * func0(int8 *param_1,int param_2)
{
int iVar1;
size_t sVar2;
int *puVar3;
int8 *puVar4;
if (param_2 < 1) {
puVar3 = (int *)malloc(1);
if (puVar3 == (int *)0x0) {
return (int *)0x0;
}
*puVar3 = 0;
if (param_2 < 1) {
return puVar3;
}
sVar2 = 1;
}
else {
iVar1 = 0;
puVar4 = param_1;
do {
sVar2 = strlen((char *)*puVar4);
iVar1 = (int)sVar2 + iVar1;
puVar4 = puVar4 + 1;
} while (puVar4 != param_1 + param_2);
sVar2 = (size_t)(iVar1 + 1);
puVar3 = (int *)malloc(sVar2);
if (puVar3 == (int *)0x0) {
return (int *)0x0;
}
*puVar3 = 0;
}
puVar4 = param_1 + param_2;
do {
__strcat_chk(puVar3,*param_1,sVar2);
param_1 = param_1 + 1;
} while (param_1 != puVar4);
return puVar3;
}
|
770 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, strings[i]);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(result);
char* strings2[] = {"x", "y", "z", "w", "k"};
result = func0(strings2, 5);
assert(strcmp(result, "xyzwk") == 0);
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 13e8 <func0+0x88>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov %rdi,%rbp
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 10b0 <strlen@plt>
add %eax,%r12d
cmp %r13,%rbp
jne 1388 <func0+0x28>
lea 0x1(%r12),%edi
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 140b <func0+0xab>
movb $0x0,(%r8)
nopw %cs:0x0(%rax,%rax,1)
mov (%rbx),%rsi
mov %r8,%rdi
add $0x8,%rbx
callq 10f0 <strcat@plt>
mov %rax,%r8
cmp %r13,%rbx
jne 13c0 <func0+0x60>
add $0x8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl (%rax)
mov $0x1,%edi
callq 10e0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 140b <func0+0xab>
movb $0x0,(%rax)
add $0x8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %r8d,%r8d
jmp 13d7 <func0+0x77>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1420
movsxd rsi, esi
mov rbx, rdi
mov rbp, rdi
xor r12d, r12d
lea r13, [rdi+rsi*8]
nop word ptr [rax+rax+00h]
loc_13B8:
mov rdi, [rbp+0]; s
add rbp, 8
call _strlen
add r12d, eax
cmp r13, rbp
jnz short loc_13B8
add r12d, 1
movsxd r12, r12d
mov rdi, r12; size
call _malloc
mov rcx, rax
test rax, rax
jz short loc_140A
mov byte ptr [rax], 0
nop word ptr [rax+rax+00000000h]
loc_13F0:
mov rsi, [rbx]
mov rdi, rcx
mov rdx, r12
add rbx, 8
call ___strcat_chk
mov rcx, rax
cmp r13, rbx
jnz short loc_13F0
loc_140A:
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1420:
mov edi, 1; size
call _malloc
mov rcx, rax
test rax, rax
jz short loc_140A
mov byte ptr [rax], 0
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
retn
|
_BYTE * func0(const char **a1, int a2)
{
const char **v2; // rbx
const char **v3; // rbp
int v4; // r12d
const char **v5; // r13
const char *v6; // rdi
size_t v7; // r12
_BYTE *v8; // rax
long long v9; // rcx
long long v10; // rsi
_BYTE *result; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = a1;
v4 = 0;
v5 = &a1[a2];
do
{
v6 = *v3++;
v4 += strlen(v6);
}
while ( v5 != v3 );
v7 = v4 + 1;
v8 = malloc(v7);
v9 = (long long)v8;
if ( v8 )
{
*v8 = 0;
do
{
v10 = (long long)*v2++;
v9 = __strcat_chk(v9, v10, v7);
}
while ( v5 != v2 );
}
return (_BYTE *)v9;
}
result = malloc(1uLL);
v9 = (long long)result;
if ( !result )
return (_BYTE *)v9;
*result = 0;
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101420
MOVSXD RSI,ESI
MOV RBX,RDI
MOV RBP,RDI
XOR R12D,R12D
LEA R13,[RDI + RSI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV RDI,qword ptr [RBP]
ADD RBP,0x8
CALL 0x001010d0
ADD R12D,EAX
CMP R13,RBP
JNZ 0x001013b8
ADD R12D,0x1
MOVSXD R12,R12D
MOV RDI,R12
CALL 0x00101110
MOV RCX,RAX
TEST RAX,RAX
JZ 0x0010140a
MOV byte ptr [RAX],0x0
NOP word ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV RSI,qword ptr [RBX]
MOV RDI,RCX
MOV RDX,R12
ADD RBX,0x8
CALL 0x001010b0
MOV RCX,RAX
CMP R13,RBX
JNZ 0x001013f0
LAB_0010140a:
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101420:
MOV EDI,0x1
CALL 0x00101110
MOV RCX,RAX
TEST RAX,RAX
JZ 0x0010140a
MOV byte ptr [RAX],0x0
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
RET
|
int * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
int8 uVar2;
size_t sVar3;
int *puVar4;
int8 *puVar5;
int iVar6;
if (param_2 < 1) {
puVar4 = (int *)malloc(1);
if (puVar4 != (int *)0x0) {
*puVar4 = 0;
return puVar4;
}
}
else {
iVar6 = 0;
puVar1 = param_1 + param_2;
puVar5 = param_1;
do {
__s = (char *)*puVar5;
puVar5 = puVar5 + 1;
sVar3 = strlen(__s);
iVar6 = iVar6 + (int)sVar3;
} while (puVar1 != puVar5);
puVar4 = (int *)malloc((long)(iVar6 + 1));
if (puVar4 != (int *)0x0) {
*puVar4 = 0;
do {
uVar2 = *param_1;
param_1 = param_1 + 1;
puVar4 = (int *)__strcat_chk(puVar4,uVar2,(long)(iVar6 + 1));
} while (puVar1 != param_1);
}
}
return puVar4;
}
|
771 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, strings[i]);
}
return out;
}
|
#include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(result);
char* strings2[] = {"x", "y", "z", "w", "k"};
result = func0(strings2, 5);
assert(strcmp(result, "xyzwk") == 0);
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1408 <func0+0x88>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov %rdi,%rbp
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 10b0 <strlen@plt>
add %eax,%r12d
cmp %rbp,%r13
jne 13a8 <func0+0x28>
lea 0x1(%r12),%edi
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 142b <func0+0xab>
movb $0x0,(%r8)
nopw %cs:0x0(%rax,%rax,1)
mov (%rbx),%rsi
mov %r8,%rdi
add $0x8,%rbx
callq 10f0 <strcat@plt>
mov %rax,%r8
cmp %rbx,%r13
jne 13e0 <func0+0x60>
add $0x8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl (%rax)
mov $0x1,%edi
callq 10e0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 142b <func0+0xab>
movb $0x0,(%rax)
add $0x8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %r8d,%r8d
jmp 13f7 <func0+0x77>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1420
movsxd rsi, esi
mov rbx, rdi
mov rbp, rdi
xor r12d, r12d
lea r13, [rdi+rsi*8]
nop word ptr [rax+rax+00h]
loc_13B8:
mov rdi, [rbp+0]; s
add rbp, 8
call _strlen
add r12d, eax
cmp r13, rbp
jnz short loc_13B8
add r12d, 1
movsxd r12, r12d
mov rdi, r12; size
call _malloc
mov rcx, rax
test rax, rax
jz short loc_140A
mov byte ptr [rax], 0
nop word ptr [rax+rax+00000000h]
loc_13F0:
mov rsi, [rbx]
mov rdi, rcx
mov rdx, r12
add rbx, 8
call ___strcat_chk
mov rcx, rax
cmp r13, rbx
jnz short loc_13F0
loc_140A:
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1420:
mov edi, 1; size
call _malloc
mov rcx, rax
test rax, rax
jz short loc_140A
mov byte ptr [rax], 0
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
retn
|
_BYTE * func0(const char **a1, int a2)
{
const char **v2; // rbx
const char **v3; // rbp
int v4; // r12d
const char **v5; // r13
const char *v6; // rdi
size_t v7; // r12
_BYTE *v8; // rax
long long v9; // rcx
long long v10; // rsi
_BYTE *result; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = a1;
v4 = 0;
v5 = &a1[a2];
do
{
v6 = *v3++;
v4 += strlen(v6);
}
while ( v5 != v3 );
v7 = v4 + 1;
v8 = malloc(v7);
v9 = (long long)v8;
if ( v8 )
{
*v8 = 0;
do
{
v10 = (long long)*v2++;
v9 = __strcat_chk(v9, v10, v7);
}
while ( v5 != v2 );
}
return (_BYTE *)v9;
}
result = malloc(1uLL);
v9 = (long long)result;
if ( !result )
return (_BYTE *)v9;
*result = 0;
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101420
MOVSXD RSI,ESI
MOV RBX,RDI
MOV RBP,RDI
XOR R12D,R12D
LEA R13,[RDI + RSI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV RDI,qword ptr [RBP]
ADD RBP,0x8
CALL 0x001010d0
ADD R12D,EAX
CMP R13,RBP
JNZ 0x001013b8
ADD R12D,0x1
MOVSXD R12,R12D
MOV RDI,R12
CALL 0x00101110
MOV RCX,RAX
TEST RAX,RAX
JZ 0x0010140a
MOV byte ptr [RAX],0x0
NOP word ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV RSI,qword ptr [RBX]
MOV RDI,RCX
MOV RDX,R12
ADD RBX,0x8
CALL 0x001010b0
MOV RCX,RAX
CMP R13,RBX
JNZ 0x001013f0
LAB_0010140a:
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101420:
MOV EDI,0x1
CALL 0x00101110
MOV RCX,RAX
TEST RAX,RAX
JZ 0x0010140a
MOV byte ptr [RAX],0x0
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
RET
|
int * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
int8 uVar2;
size_t sVar3;
int *puVar4;
int8 *puVar5;
int iVar6;
if (param_2 < 1) {
puVar4 = (int *)malloc(1);
if (puVar4 != (int *)0x0) {
*puVar4 = 0;
return puVar4;
}
}
else {
iVar6 = 0;
puVar1 = param_1 + param_2;
puVar5 = param_1;
do {
__s = (char *)*puVar5;
puVar5 = puVar5 + 1;
sVar3 = strlen(__s);
iVar6 = iVar6 + (int)sVar3;
} while (puVar1 != puVar5);
puVar4 = (int *)malloc((long)(iVar6 + 1));
if (puVar4 != (int *)0x0) {
*puVar4 = 0;
do {
uVar2 = *param_1;
param_1 = param_1 + 1;
puVar4 = (int *)__strcat_chk(puVar4,uVar2,(long)(iVar6 + 1));
} while (puVar1 != param_1);
}
}
return puVar4;
}
|
772 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] = strings[i];
}
}
return out_count;
}
|
#include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char** result;
int count;
const char* empty[] = {};
count = func0(empty, 0, "john", &result);
assert(issame(result, count, empty, 0));
free(result);
char* strings[] = {"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"};
char* expected[] = {"xxx", "xxxAAA", "xxx"};
count = func0(strings, 6, "xxx", &result);
assert(issame(result, count, expected, 3));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %eax,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,%rdx
mov -0x30(%rbp),%rax
mov %rdx,(%rax)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 12c7 <func0+0xbe>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%rcx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 <strncmp@plt>
test %eax,%eax
jne 12c3 <func0+0xba>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x30(%rbp),%rax
mov (%rax),%rsi
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
shl $0x3,%rax
lea (%rsi,%rax,1),%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 125e <func0+0x55>
mov -0xc(%rbp),%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+s], rdx
mov [rbp+var_30], rcx
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_30]
mov [rax], rdx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_12C7
loc_125E:
mov eax, [rbp+var_4]
movsxd rdx, eax; n
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax]
mov rcx, [rbp+s]
mov rsi, rcx; s2
mov rdi, rax; s1
call _strncmp
test eax, eax
jnz short loc_12C3
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov rax, [rbp+var_30]
mov rsi, [rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
shl rax, 3
lea rdx, [rsi+rax]
mov rax, [rcx]
mov [rdx], rax
loc_12C3:
add [rbp+var_8], 1
loc_12C7:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_125E
mov eax, [rbp+var_C]
leave
retn
|
long long func0(long long a1, int a2, const char *a3, void **a4)
{
int v4; // eax
unsigned int v8; // [rsp+24h] [rbp-Ch]
int i; // [rsp+28h] [rbp-8h]
int v10; // [rsp+2Ch] [rbp-4h]
v10 = strlen(a3);
*a4 = malloc(8LL * a2);
v8 = 0;
for ( i = 0; i < a2; ++i )
{
if ( !strncmp(*(const char **)(8LL * i + a1), a3, v10) )
{
v4 = v8++;
*((_QWORD *)*a4 + v4) = *(_QWORD *)(8LL * i + a1);
}
}
return v8;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101110
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001012c7
LAB_0010125e:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x001012c3
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
SHL RAX,0x3
LEA RDX,[RSI + RAX*0x1]
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
LAB_001012c3:
ADD dword ptr [RBP + -0x8],0x1
LAB_001012c7:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010125e
MOV EAX,dword ptr [RBP + -0xc]
LEAVE
RET
|
int func0(long param_1,int param_2,char *param_3,long *param_4)
{
int iVar1;
size_t sVar2;
void *pvVar3;
int4 local_14;
int4 local_10;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 << 3);
*param_4 = (long)pvVar3;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = strncmp(*(char **)(param_1 + (long)local_10 * 8),param_3,(long)(int)sVar2);
if (iVar1 == 0) {
*(int8 *)(*param_4 + (long)local_14 * 8) = *(int8 *)((long)local_10 * 8 + param_1)
;
local_14 = local_14 + 1;
}
}
return local_14;
}
|
773 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] = strings[i];
}
}
return out_count;
}
|
#include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char** result;
int count;
const char* empty[] = {};
count = func0(empty, 0, "john", &result);
assert(issame(result, count, empty, 0));
free(result);
char* strings[] = {"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"};
char* expected[] = {"xxx", "xxxAAA", "xxx"};
count = func0(strings, 6, "xxx", &result);
assert(issame(result, count, expected, 3));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r14
mov %esi,%r12d
mov %rdx,%r13
mov %rcx,%r15
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%ebp
movslq %esi,%rdi
shl $0x3,%rdi
callq 10f0 <malloc@plt>
mov %rax,(%r15)
test %r12d,%r12d
jle 1280 <func0+0x97>
mov %r14,%rbx
lea -0x1(%r12),%eax
lea 0x8(%r14,%rax,8),%r14
mov $0x0,%r12d
movslq %ebp,%rax
mov %rax,0x8(%rsp)
jmp 1258 <func0+0x6f>
add $0x8,%rbx
cmp %r14,%rbx
je 1286 <func0+0x9d>
mov (%rbx),%rbp
mov 0x8(%rsp),%rdx
mov %r13,%rsi
mov %rbp,%rdi
callq 10b0 <strncmp@plt>
test %eax,%eax
jne 124f <func0+0x66>
movslq %r12d,%rdx
mov (%r15),%rax
mov %rbp,(%rax,%rdx,8)
lea 0x1(%r12),%r12d
jmp 124f <func0+0x66>
mov $0x0,%r12d
mov %r12d,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, rdi
mov ebx, esi
mov rdi, rdx; s
mov [rsp+48h+s2], rdx
mov r15, rcx
call _strlen
mov r14d, eax
movsxd rbp, ebx
shl rbp, 3
mov rdi, rbp; size
call _malloc
mov [r15], rax
test ebx, ebx
jle short loc_128B
mov rbx, r13
add r13, rbp
mov r12d, 0
movsxd r14, r14d
jmp short loc_1263
loc_125A:
add rbx, 8
cmp rbx, r13
jz short loc_1291
loc_1263:
mov rbp, [rbx]
mov rdx, r14; n
mov rsi, [rsp+48h+s2]; s2
mov rdi, rbp; s1
call _strncmp
test eax, eax
jnz short loc_125A
movsxd rdx, r12d
mov rax, [r15]
mov [rax+rdx*8], rbp
lea r12d, [r12+1]
jmp short loc_125A
loc_128B:
mov r12d, 0
loc_1291:
mov eax, r12d
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
long long func0(const char **a1, int a2, const char *a3, void **a4)
{
int v5; // r14d
const char **v6; // rbx
unsigned int v7; // r12d
const char *v8; // rbp
v5 = strlen(a3);
*a4 = malloc(8LL * a2);
if ( a2 <= 0 )
{
return 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
v8 = *v6;
if ( !strncmp(*v6, a3, v5) )
*((_QWORD *)*a4 + (int)v7++) = v8;
++v6;
}
while ( v6 != &a1[a2] );
}
return v7;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,RDI
MOV EBX,ESI
MOV RDI,RDX
MOV qword ptr [RSP + 0x8],RDX
MOV R15,RCX
CALL 0x001010d0
MOV R14D,EAX
MOVSXD RBP,EBX
SHL RBP,0x3
MOV RDI,RBP
CALL 0x00101110
MOV qword ptr [R15],RAX
TEST EBX,EBX
JLE 0x0010128b
MOV RBX,R13
ADD R13,RBP
MOV R12D,0x0
MOVSXD R14,R14D
JMP 0x00101263
LAB_0010125a:
ADD RBX,0x8
CMP RBX,R13
JZ 0x00101291
LAB_00101263:
MOV RBP,qword ptr [RBX]
MOV RDX,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RBP
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x0010125a
MOVSXD RDX,R12D
MOV RAX,qword ptr [R15]
MOV qword ptr [RAX + RDX*0x8],RBP
LEA R12D,[R12 + 0x1]
JMP 0x0010125a
LAB_0010128b:
MOV R12D,0x0
LAB_00101291:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
int func0(int8 *param_1,int param_2,char *param_3,long *param_4)
{
char *__s1;
int iVar1;
size_t sVar2;
void *pvVar3;
int iVar4;
int8 *puVar5;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 * 8);
*param_4 = (long)pvVar3;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar5 = param_1 + param_2;
iVar4 = 0;
do {
__s1 = (char *)*param_1;
iVar1 = strncmp(__s1,param_3,(long)(int)sVar2);
if (iVar1 == 0) {
*(char **)(*param_4 + (long)iVar4 * 8) = __s1;
iVar4 = iVar4 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar5);
}
return iVar4;
}
|
774 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] = strings[i];
}
}
return out_count;
}
|
#include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char** result;
int count;
const char* empty[] = {};
count = func0(empty, 0, "john", &result);
assert(issame(result, count, empty, 0));
free(result);
char* strings[] = {"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"};
char* expected[] = {"xxx", "xxxAAA", "xxx"};
count = func0(strings, 6, "xxx", &result);
assert(issame(result, count, expected, 3));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
mov %rdx,%rdi
sub $0x18,%rsp
callq 10d0 <strlen@plt>
movslq %r12d,%rdi
shl $0x3,%rdi
mov %rax,%rbp
callq 1110 <malloc@plt>
mov %rax,0x8(%rsp)
mov %rax,(%r15)
test %r12d,%r12d
jle 1470 <func0+0xa0>
lea -0x1(%r12),%eax
movslq %ebp,%rbp
xor %r12d,%r12d
lea 0x8(%rbx,%rax,8),%r15
nopw 0x0(%rax,%rax,1)
mov (%rbx),%r14
mov %rbp,%rdx
mov %r13,%rsi
mov %r14,%rdi
callq 10c0 <strncmp@plt>
test %eax,%eax
jne 144d <func0+0x7d>
mov 0x8(%rsp),%rcx
movslq %r12d,%rax
add $0x1,%r12d
mov %r14,(%rcx,%rax,8)
add $0x8,%rbx
cmp %r15,%rbx
jne 1428 <func0+0x58>
add $0x18,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 1456 <func0+0x86>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
movsxd r15, esi
push r14
push r13
mov r13, rdx
push r12
push rbp
mov rbp, r15
shl r15, 3
push rbx
mov rbx, rdi
mov rdi, rdx; s
sub rsp, 18h
mov [rsp+48h+var_40], rcx
call _strlen
mov rdi, r15; size
mov r12, rax
call _malloc
mov rcx, [rsp+48h+var_40]
mov [rsp+48h+var_48], rax
mov [rcx], rax
test ebp, ebp
jle short loc_1478
movsxd r12, r12d
add r15, rbx
xor ebp, ebp
nop word ptr [rax+rax+00h]
loc_1438:
mov r14, [rbx]
mov rdx, r12; n
mov rsi, r13; s2
mov rdi, r14; s1
call _strncmp
test eax, eax
jnz short loc_145B
mov rcx, [rsp+48h+var_48]
movsxd rax, ebp
add ebp, 1
mov [rcx+rax*8], r14
loc_145B:
add rbx, 8
cmp rbx, r15
jnz short loc_1438
loc_1464:
add rsp, 18h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1478:
xor ebp, ebp
jmp short loc_1464
|
long long func0(const char **a1, int a2, const char *a3, _QWORD *a4)
{
const char **v5; // rbx
int v6; // r12d
unsigned int v7; // ebp
const char *v8; // r14
long long v9; // rax
_QWORD *v11; // [rsp+0h] [rbp-48h]
v5 = a1;
v6 = strlen(a3);
v11 = malloc(8LL * a2);
*a4 = v11;
if ( a2 <= 0 )
{
return 0;
}
else
{
v7 = 0;
do
{
v8 = *v5;
if ( !strncmp(*v5, a3, v6) )
{
v9 = (int)v7++;
v11[v9] = v8;
}
++v5;
}
while ( v5 != &a1[a2] );
}
return v7;
}
|
func0:
ENDBR64
PUSH R15
MOVSXD R15,ESI
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,R15
SHL R15,0x3
PUSH RBX
MOV RBX,RDI
MOV RDI,RDX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001010d0
MOV RDI,R15
MOV R12,RAX
CALL 0x00101110
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
MOV qword ptr [RCX],RAX
TEST EBP,EBP
JLE 0x00101478
MOVSXD R12,R12D
ADD R15,RBX
XOR EBP,EBP
NOP word ptr [RAX + RAX*0x1]
LAB_00101438:
MOV R14,qword ptr [RBX]
MOV RDX,R12
MOV RSI,R13
MOV RDI,R14
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x0010145b
MOV RCX,qword ptr [RSP]
MOVSXD RAX,EBP
ADD EBP,0x1
MOV qword ptr [RCX + RAX*0x8],R14
LAB_0010145b:
ADD RBX,0x8
CMP RBX,R15
JNZ 0x00101438
LAB_00101464:
ADD RSP,0x18
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101478:
XOR EBP,EBP
JMP 0x00101464
|
int func0(int8 *param_1,int param_2,char *param_3,int8 *param_4)
{
char *__s1;
int iVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
int iVar5;
int8 *puVar6;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 * 8);
*param_4 = pvVar3;
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar6 = param_1 + param_2;
iVar5 = 0;
do {
__s1 = (char *)*param_1;
iVar1 = strncmp(__s1,param_3,(long)(int)sVar2);
if (iVar1 == 0) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
*(char **)((long)pvVar3 + lVar4 * 8) = __s1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar6);
}
return iVar5;
}
|
775 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] = strings[i];
}
}
return out_count;
}
|
#include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char** result;
int count;
const char* empty[] = {};
count = func0(empty, 0, "john", &result);
assert(issame(result, count, empty, 0));
free(result);
char* strings[] = {"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"};
char* expected[] = {"xxx", "xxxAAA", "xxx"};
count = func0(strings, 6, "xxx", &result);
assert(issame(result, count, expected, 3));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
mov %rdx,%rdi
sub $0x18,%rsp
callq 10d0 <strlen@plt>
movslq %r12d,%rdi
shl $0x3,%rdi
mov %rax,%rbp
callq 1110 <malloc@plt>
mov %rax,0x8(%rsp)
mov %rax,(%r15)
test %r12d,%r12d
jle 1490 <func0+0xa0>
lea -0x1(%r12),%eax
movslq %ebp,%rbp
xor %r12d,%r12d
lea 0x8(%rbx,%rax,8),%r15
nopw 0x0(%rax,%rax,1)
mov (%rbx),%r14
mov %rbp,%rdx
mov %r13,%rsi
mov %r14,%rdi
callq 10c0 <strncmp@plt>
test %eax,%eax
jne 146d <func0+0x7d>
mov 0x8(%rsp),%rcx
movslq %r12d,%rax
add $0x1,%r12d
mov %r14,(%rcx,%rax,8)
add $0x8,%rbx
cmp %rbx,%r15
jne 1448 <func0+0x58>
add $0x18,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 1476 <func0+0x86>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
movsxd r15, esi
push r14
push r13
mov r13, rdx
push r12
push rbp
mov rbp, r15
shl r15, 3
push rbx
mov rbx, rdi
mov rdi, rdx; s
sub rsp, 18h
mov [rsp+48h+var_40], rcx
call _strlen
mov rdi, r15; size
mov r12, rax
call _malloc
mov rcx, [rsp+48h+var_40]
mov [rsp+48h+var_48], rax
mov [rcx], rax
test ebp, ebp
jle short loc_1478
movsxd r12, r12d
add r15, rbx
xor ebp, ebp
nop word ptr [rax+rax+00h]
loc_1438:
mov r14, [rbx]
mov rdx, r12; n
mov rsi, r13; s2
mov rdi, r14; s1
call _strncmp
test eax, eax
jnz short loc_145B
mov rcx, [rsp+48h+var_48]
movsxd rax, ebp
add ebp, 1
mov [rcx+rax*8], r14
loc_145B:
add rbx, 8
cmp rbx, r15
jnz short loc_1438
loc_1464:
add rsp, 18h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1478:
xor ebp, ebp
jmp short loc_1464
|
long long func0(const char **a1, int a2, const char *a3, _QWORD *a4)
{
const char **v5; // rbx
int v6; // r12d
unsigned int v7; // ebp
const char *v8; // r14
long long v9; // rax
_QWORD *v11; // [rsp+0h] [rbp-48h]
v5 = a1;
v6 = strlen(a3);
v11 = malloc(8LL * a2);
*a4 = v11;
if ( a2 <= 0 )
{
return 0;
}
else
{
v7 = 0;
do
{
v8 = *v5;
if ( !strncmp(*v5, a3, v6) )
{
v9 = (int)v7++;
v11[v9] = v8;
}
++v5;
}
while ( v5 != &a1[a2] );
}
return v7;
}
|
func0:
ENDBR64
PUSH R15
MOVSXD R15,ESI
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,R15
SHL R15,0x3
PUSH RBX
MOV RBX,RDI
MOV RDI,RDX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001010d0
MOV RDI,R15
MOV R12,RAX
CALL 0x00101110
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
MOV qword ptr [RCX],RAX
TEST EBP,EBP
JLE 0x00101478
MOVSXD R12,R12D
ADD R15,RBX
XOR EBP,EBP
NOP word ptr [RAX + RAX*0x1]
LAB_00101438:
MOV R14,qword ptr [RBX]
MOV RDX,R12
MOV RSI,R13
MOV RDI,R14
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x0010145b
MOV RCX,qword ptr [RSP]
MOVSXD RAX,EBP
ADD EBP,0x1
MOV qword ptr [RCX + RAX*0x8],R14
LAB_0010145b:
ADD RBX,0x8
CMP RBX,R15
JNZ 0x00101438
LAB_00101464:
ADD RSP,0x18
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101478:
XOR EBP,EBP
JMP 0x00101464
|
int func0(int8 *param_1,int param_2,char *param_3,int8 *param_4)
{
char *__s1;
int iVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
int iVar5;
int8 *puVar6;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 * 8);
*param_4 = pvVar3;
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar6 = param_1 + param_2;
iVar5 = 0;
do {
__s1 = (char *)*param_1;
iVar1 = strncmp(__s1,param_3,(long)(int)sVar2);
if (iVar1 == 0) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
*(char **)((long)pvVar3 + lVar4 * 8) = __s1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar6);
}
return iVar5;
}
|
776 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
}
|
#include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main() {
float* result;
int count;
result = func0((const float[]){-1, -2, 4, 5, 6}, 5, &count);
assert(issame(result, count, (const float[]){4, 5, 6}, 3));
free(result);
result = func0((const float[]){5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10}, 11, &count);
assert(issame(result, count, (const float[]){5, 3, 2, 3, 3, 9, 123, 1}, 8));
free(result);
result = func0((const float[]){-1, -2}, 2, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
result = func0((const float[]){}, 0, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0xc(%rbp)
jmp 124a <func0+0xa1>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
pxor %xmm1,%xmm1
comiss %xmm1,%xmm0
jbe 1246 <func0+0x9d>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rsi
mov -0x28(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%ecx
mov -0x28(%rbp),%rdx
mov %ecx,(%rdx)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movss (%rsi),%xmm0
movss %xmm0,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11e8 <func0+0x3f>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_28]
mov dword ptr [rax], 0
mov [rbp+var_C], 0
jmp short loc_124A
loc_11E8:
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]
pxor xmm1, xmm1
comiss xmm0, xmm1
jbe short loc_1246
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rsi, [rdx+rax]
mov rax, [rbp+var_28]
mov eax, [rax]
lea ecx, [rax+1]
mov rdx, [rbp+var_28]
mov [rdx], ecx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
movss xmm0, dword ptr [rsi]
movss dword ptr [rax], xmm0
loc_1246:
add [rbp+var_C], 1
loc_124A:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11E8
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v7; // [rsp+28h] [rbp-8h]
v7 = malloc(4LL * a2);
*a3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) > 0.0 )
{
v3 = (*a3)++;
v7[v3] = *(_DWORD *)(4LL * i + a1);
}
}
return v7;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010124a
LAB_001011e8:
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]
PXOR XMM1,XMM1
COMISS XMM0,XMM1
JBE 0x00101246
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RSI,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + 0x1]
MOV RDX,qword ptr [RBP + -0x28]
MOV dword ptr [RDX],ECX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RSI]
MOVSS dword ptr [RAX],XMM0
LAB_00101246:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010124a:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011e8
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(long param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
int4 local_14;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (0.0 < *(float *)(param_1 + (long)local_14 * 4)) {
iVar1 = *param_3;
*param_3 = iVar1 + 1;
*(int4 *)((long)pvVar2 + (long)iVar1 * 4) =
*(int4 *)((long)local_14 * 4 + param_1);
}
}
return pvVar2;
}
|
777 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
}
|
#include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main() {
float* result;
int count;
result = func0((const float[]){-1, -2, 4, 5, 6}, 5, &count);
assert(issame(result, count, (const float[]){4, 5, 6}, 3));
free(result);
result = func0((const float[]){5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10}, 11, &count);
assert(issame(result, count, (const float[]){5, 3, 2, 3, 3, 9, 123, 1}, 8));
free(result);
result = func0((const float[]){-1, -2}, 2, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
result = func0((const float[]){}, 0, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x0,(%rbx)
test %ebp,%ebp
jle 1207 <func0+0x5e>
mov %r12,%rdx
lea -0x1(%rbp),%ecx
lea 0x4(%r12,%rcx,4),%rdi
pxor %xmm1,%xmm1
jmp 11e9 <func0+0x40>
add $0x4,%rdx
cmp %rdi,%rdx
je 1207 <func0+0x5e>
movss (%rdx),%xmm0
comiss %xmm1,%xmm0
jbe 11e0 <func0+0x37>
mov (%rbx),%ecx
lea 0x1(%rcx),%esi
mov %esi,(%rbx)
movslq %ecx,%rcx
movss (%rdx),%xmm0
movss %xmm0,(%rax,%rcx,4)
jmp 11e0 <func0+0x37>
pop %rbx
pop %rbp
pop %r12
retq
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13d, esi
mov rbp, rdx
movsxd r12, esi
shl r12, 2
mov rdi, r12; size
call _malloc
mov dword ptr [rbp+0], 0
test r13d, r13d
jle short loc_1211
mov rdx, rbx
lea rsi, [rbx+r12]
pxor xmm1, xmm1
jmp short loc_1206
loc_11E8:
mov ecx, [rbp+0]
lea edi, [rcx+1]
mov [rbp+0], edi
movsxd rcx, ecx
movss xmm0, dword ptr [rdx]
movss dword ptr [rax+rcx*4], xmm0
loc_11FD:
add rdx, 4
cmp rdx, rsi
jz short loc_1211
loc_1206:
movss xmm0, dword ptr [rdx]
comiss xmm0, xmm1
ja short loc_11E8
jmp short loc_11FD
loc_1211:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
_DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *result; // rax
_DWORD *v5; // rdx
int v6; // ecx
result = malloc(4LL * a2);
*a3 = 0;
if ( a2 > 0 )
{
v5 = a1;
do
{
if ( *(float *)v5 > 0.0 )
{
v6 = (*a3)++;
result[v6] = *v5;
}
++v5;
}
while ( v5 != &a1[a2] );
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13D,ESI
MOV RBP,RDX
MOVSXD R12,ESI
SHL R12,0x2
MOV RDI,R12
CALL 0x001010b0
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101211
MOV RDX,RBX
LEA RSI,[RBX + R12*0x1]
PXOR XMM1,XMM1
JMP 0x00101206
LAB_001011e8:
MOV ECX,dword ptr [RBP]
LEA EDI,[RCX + 0x1]
MOV dword ptr [RBP],EDI
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RDX]
MOVSS dword ptr [RAX + RCX*0x4],XMM0
LAB_001011fd:
ADD RDX,0x4
CMP RDX,RSI
JZ 0x00101211
LAB_00101206:
MOVSS XMM0,dword ptr [RDX]
COMISS XMM0,XMM1
JA 0x001011e8
JMP 0x001011fd
LAB_00101211:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
void func0(float *param_1,int param_2,int *param_3)
{
float *pfVar1;
int iVar2;
void *pvVar3;
pvVar3 = malloc((long)param_2 * 4);
*param_3 = 0;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
do {
if (0.0 < *param_1) {
iVar2 = *param_3;
*param_3 = iVar2 + 1;
*(float *)((long)pvVar3 + (long)iVar2 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
}
return;
}
|
778 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
}
|
#include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main() {
float* result;
int count;
result = func0((const float[]){-1, -2, 4, 5, 6}, 5, &count);
assert(issame(result, count, (const float[]){4, 5, 6}, 3));
free(result);
result = func0((const float[]){5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10}, 11, &count);
assert(issame(result, count, (const float[]){5, 3, 2, 3, 3, 9, 123, 1}, 8));
free(result);
result = func0((const float[]){-1, -2}, 2, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
result = func0((const float[]){}, 0, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
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 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 14e1 <func0+0x61>
lea -0x1(%r12),%edx
mov %rbx,%rdi
pxor %xmm1,%xmm1
lea 0x4(%rbx,%rdx,4),%rsi
nopw 0x0(%rax,%rax,1)
movss (%rdi),%xmm0
comiss %xmm1,%xmm0
jbe 14d8 <func0+0x58>
movslq 0x0(%rbp),%rcx
lea 0x1(%rcx),%edx
movss %xmm0,(%rax,%rcx,4)
mov %edx,0x0(%rbp)
add $0x4,%rdi
cmp %rsi,%rdi
jne 14c0 <func0+0x40>
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
lea rbp, ds:0[rdi*4]
mov r13, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov dword ptr [r12], 0
test r13d, r13d
jle short loc_14AA
mov rcx, rbx
lea rdi, [rbx+rbp]
pxor xmm1, xmm1
nop word ptr [rax+rax+00h]
loc_1488:
movss xmm0, dword ptr [rcx]
comiss xmm0, xmm1
jbe short loc_14A1
movsxd rsi, dword ptr [r12]
lea edx, [rsi+1]
movss dword ptr [rax+rsi*4], xmm0
mov [r12], edx
loc_14A1:
add rcx, 4
cmp rcx, rdi
jnz short loc_1488
loc_14AA:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
_DWORD * func0(_DWORD *a1, int a2, int *a3)
{
size_t v4; // rbp
_DWORD *result; // rax
_DWORD *v6; // rcx
long long v7; // rsi
v4 = a2;
result = malloc(v4 * 4);
*a3 = 0;
if ( a2 > 0 )
{
v6 = a1;
do
{
if ( *(float *)v6 > 0.0 )
{
v7 = *a3;
result[v7] = *v6;
*a3 = v7 + 1;
}
++v6;
}
while ( v6 != &a1[v4] );
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA RBP,[RDI*0x4]
MOV R13,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [R12],0x0
TEST R13D,R13D
JLE 0x001014aa
MOV RCX,RBX
LEA RDI,[RBX + RBP*0x1]
PXOR XMM1,XMM1
NOP word ptr [RAX + RAX*0x1]
LAB_00101488:
MOVSS XMM0,dword ptr [RCX]
COMISS XMM0,XMM1
JBE 0x001014a1
MOVSXD RSI,dword ptr [R12]
LEA EDX,[RSI + 0x1]
MOVSS dword ptr [RAX + RSI*0x4],XMM0
MOV dword ptr [R12],EDX
LAB_001014a1:
ADD RCX,0x4
CMP RCX,RDI
JNZ 0x00101488
LAB_001014aa:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
void func0(float *param_1,int param_2,int *param_3)
{
float *pfVar1;
int iVar2;
void *pvVar3;
pvVar3 = malloc((long)param_2 * 4);
*param_3 = 0;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
do {
if (0.0 < *param_1) {
iVar2 = *param_3;
*(float *)((long)pvVar3 + (long)iVar2 * 4) = *param_1;
*param_3 = iVar2 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
}
return;
}
|
779 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
}
|
#include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main() {
float* result;
int count;
result = func0((const float[]){-1, -2, 4, 5, 6}, 5, &count);
assert(issame(result, count, (const float[]){4, 5, 6}, 3));
free(result);
result = func0((const float[]){5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10}, 11, &count);
assert(issame(result, count, (const float[]){5, 3, 2, 3, 3, 9, 123, 1}, 8));
free(result);
result = func0((const float[]){-1, -2}, 2, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
result = func0((const float[]){}, 0, &count);
assert(issame(result, count, (const float[]){}, 0));
free(result);
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 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 14b1 <func0+0x61>
lea -0x1(%r12),%edx
mov %rbx,%rdi
pxor %xmm1,%xmm1
lea 0x4(%rbx,%rdx,4),%rsi
nopw 0x0(%rax,%rax,1)
movss (%rdi),%xmm0
comiss %xmm1,%xmm0
jbe 14a8 <func0+0x58>
movslq 0x0(%rbp),%rcx
lea 0x1(%rcx),%edx
movss %xmm0,(%rax,%rcx,4)
mov %edx,0x0(%rbp)
add $0x4,%rdi
cmp %rdi,%rsi
jne 1490 <func0+0x40>
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
lea rbp, ds:0[rdi*4]
mov r13, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov dword ptr [r12], 0
test r13d, r13d
jle short loc_14AA
mov rcx, rbx
lea rdi, [rbx+rbp]
pxor xmm1, xmm1
nop word ptr [rax+rax+00h]
loc_1488:
movss xmm0, dword ptr [rcx]
comiss xmm0, xmm1
jbe short loc_14A1
movsxd rsi, dword ptr [r12]
lea edx, [rsi+1]
movss dword ptr [rax+rsi*4], xmm0
mov [r12], edx
loc_14A1:
add rcx, 4
cmp rcx, rdi
jnz short loc_1488
loc_14AA:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
_DWORD * func0(_DWORD *a1, int a2, int *a3)
{
size_t v4; // rbp
_DWORD *result; // rax
_DWORD *v6; // rcx
long long v7; // rsi
v4 = a2;
result = malloc(v4 * 4);
*a3 = 0;
if ( a2 > 0 )
{
v6 = a1;
do
{
if ( *(float *)v6 > 0.0 )
{
v7 = *a3;
result[v7] = *v6;
*a3 = v7 + 1;
}
++v6;
}
while ( v6 != &a1[v4] );
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA RBP,[RDI*0x4]
MOV R13,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [R12],0x0
TEST R13D,R13D
JLE 0x001014aa
MOV RCX,RBX
LEA RDI,[RBX + RBP*0x1]
PXOR XMM1,XMM1
NOP word ptr [RAX + RAX*0x1]
LAB_00101488:
MOVSS XMM0,dword ptr [RCX]
COMISS XMM0,XMM1
JBE 0x001014a1
MOVSXD RSI,dword ptr [R12]
LEA EDX,[RSI + 0x1]
MOVSS dword ptr [RAX + RSI*0x4],XMM0
MOV dword ptr [R12],EDX
LAB_001014a1:
ADD RCX,0x4
CMP RCX,RDI
JNZ 0x00101488
LAB_001014aa:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
void func0(float *param_1,int param_2,int *param_3)
{
float *pfVar1;
int iVar2;
void *pvVar3;
pvVar3 = malloc((long)param_2 * 4);
*param_3 = 0;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
do {
if (0.0 < *param_1) {
iVar2 = *param_3;
*(float *)((long)pvVar3 + (long)iVar2 * 4) = *param_1;
*param_3 = iVar2 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
}
return;
}
|
780 |
func0
|
#include <stdbool.h>
|
bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
assert(func0(17) == true);
assert(func0(5 * 17) == false);
assert(func0(11 * 7) == false);
assert(func0(13441 * 19) == false);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
cmpq $0x1,-0x18(%rbp)
jg 1163 <func0+0x1a>
mov $0x0,%eax
jmp 119e <func0+0x55>
movq $0x2,-0x8(%rbp)
jmp 118b <func0+0x42>
mov -0x18(%rbp),%rax
cqto
idivq -0x8(%rbp)
mov %rdx,%rax
test %rax,%rax
jne 1186 <func0+0x3d>
mov $0x0,%eax
jmp 119e <func0+0x55>
addq $0x1,-0x8(%rbp)
mov -0x8(%rbp),%rax
imul %rax,%rax
cmp %rax,-0x18(%rbp)
jge 116d <func0+0x24>
mov $0x1,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
cmp [rbp+var_18], 1
jg short loc_1163
mov eax, 0
jmp short loc_119E
loc_1163:
mov [rbp+var_8], 2
jmp short loc_118B
loc_116D:
mov rax, [rbp+var_18]
cqo
idiv [rbp+var_8]
mov rax, rdx
test rax, rax
jnz short loc_1186
mov eax, 0
jmp short loc_119E
loc_1186:
add [rbp+var_8], 1
loc_118B:
mov rax, [rbp+var_8]
imul rax, rax
cmp [rbp+var_18], rax
jge short loc_116D
mov eax, 1
loc_119E:
pop rbp
retn
|
long long func0(long long a1)
{
long long i; // [rsp+10h] [rbp-8h]
if ( a1 <= 1 )
return 0LL;
for ( i = 2LL; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x1
JG 0x00101163
MOV EAX,0x0
JMP 0x0010119e
LAB_00101163:
MOV qword ptr [RBP + -0x8],0x2
JMP 0x0010118b
LAB_0010116d:
MOV RAX,qword ptr [RBP + -0x18]
CQO
IDIV qword ptr [RBP + -0x8]
MOV RAX,RDX
TEST RAX,RAX
JNZ 0x00101186
MOV EAX,0x0
JMP 0x0010119e
LAB_00101186:
ADD qword ptr [RBP + -0x8],0x1
LAB_0010118b:
MOV RAX,qword ptr [RBP + -0x8]
IMUL RAX,RAX
CMP qword ptr [RBP + -0x18],RAX
JGE 0x0010116d
MOV EAX,0x1
LAB_0010119e:
POP RBP
RET
|
int8 func0(long param_1)
{
int8 uVar1;
long local_10;
if (param_1 < 2) {
uVar1 = 0;
}
else {
for (local_10 = 2; local_10 * local_10 <= param_1; local_10 = local_10 + 1) {
if (param_1 % local_10 == 0) {
return 0;
}
}
uVar1 = 1;
}
return uVar1;
}
|
781 |
func0
|
#include <stdbool.h>
|
bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
assert(func0(17) == true);
assert(func0(5 * 17) == false);
assert(func0(11 * 7) == false);
assert(func0(13441 * 19) == false);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov $0x0,%eax
cmp $0x1,%rdi
jle 118b <func0+0x42>
cmp $0x3,%rdi
jle 1192 <func0+0x49>
test $0x1,%dil
je 1198 <func0+0x4f>
mov $0x2,%ecx
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rdi,%rax
jg 118c <func0+0x43>
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
jne 1169 <func0+0x20>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
|
func0:
endbr64
mov eax, 0
cmp rdi, 1
jle short locret_118B
cmp rdi, 3
jle short loc_1192
test dil, 1
jz short loc_1198
mov ecx, 2
loc_1169:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rdi
jg short loc_118C
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jnz short loc_1169
mov eax, 0
locret_118B:
retn
loc_118C:
mov eax, 1
retn
loc_1192:
mov eax, 1
retn
loc_1198:
mov eax, 0
retn
|
long long func0(long long a1)
{
long long result; // rax
long long v2; // rcx
result = 0LL;
if ( a1 > 1 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2LL;
while ( 1 )
{
++v2;
if ( v2 * v2 > a1 )
break;
if ( !(a1 % v2) )
return 0LL;
}
return 1LL;
}
else
{
return 0LL;
}
}
return result;
}
|
func0:
ENDBR64
MOV EAX,0x0
CMP RDI,0x1
JLE 0x0010118b
CMP RDI,0x3
JLE 0x00101192
TEST DIL,0x1
JZ 0x00101198
MOV ECX,0x2
LAB_00101169:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RDI
JG 0x0010118c
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JNZ 0x00101169
MOV EAX,0x0
LAB_0010118b:
RET
LAB_0010118c:
MOV EAX,0x1
RET
LAB_00101192:
MOV EAX,0x1
RET
LAB_00101198:
MOV EAX,0x0
RET
|
int8 func0(ulong param_1)
{
int auVar1 [16];
long lVar2;
if (1 < (long)param_1) {
if ((long)param_1 < 4) {
return 1;
}
if ((param_1 & 1) == 0) {
return 0;
}
lVar2 = 2;
do {
lVar2 = lVar2 + 1;
if (lVar2 * lVar2 - param_1 != 0 && (long)param_1 <= lVar2 * lVar2) {
return 1;
}
auVar1._8_8_ = (long)(int7)(param_1 >> 8) >> 0x37;
auVar1._0_8_ = param_1;
} while (SUB168(auVar1 % SEXT816(lVar2),0) != 0);
}
return 0;
}
|
782 |
func0
|
#include <stdbool.h>
|
bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
assert(func0(17) == true);
assert(func0(5 * 17) == false);
assert(func0(11 * 7) == false);
assert(func0(13441 * 19) == false);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x1,%rdi
jle 13e0 <func0+0x10>
jmp 1380 <func0.part.0>
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0_part_0:
cmp rdi, 3
jle short loc_13B5
test dil, 1
jz short loc_13C0
mov ecx, 2
jmp short loc_13A5
loc_1398:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jz short loc_13C0
loc_13A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rdi, rax
jge short loc_1398
loc_13B5:
mov eax, 1
retn
loc_13C0:
xor eax, eax
retn
|
long long func0_part_0(long long a1)
{
long long v1; // rcx
if ( a1 <= 3 )
return 1LL;
if ( (a1 & 1) != 0 )
{
v1 = 2LL;
while ( 1 )
{
++v1;
if ( a1 < v1 * v1 )
break;
if ( !(a1 % v1) )
return 0LL;
}
return 1LL;
}
return 0LL;
}
|
func0.part.0:
CMP RDI,0x3
JLE 0x001013b5
TEST DIL,0x1
JZ 0x001013c0
MOV ECX,0x2
JMP 0x001013a5
LAB_00101398:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JZ 0x001013c0
LAB_001013a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RDI,RAX
JGE 0x00101398
LAB_001013b5:
MOV EAX,0x1
RET
LAB_001013c0:
XOR EAX,EAX
RET
|
int8 func0_part_0(ulong param_1)
{
int auVar1 [16];
long lVar2;
if ((long)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
lVar2 = 2;
do {
lVar2 = lVar2 + 1;
if ((long)param_1 < lVar2 * lVar2) {
return 1;
}
auVar1._8_8_ = (long)(int7)(param_1 >> 8) >> 0x37;
auVar1._0_8_ = param_1;
} while (SUB168(auVar1 % SEXT816(lVar2),0) != 0);
}
return 0;
}
|
783 |
func0
|
#include <stdbool.h>
|
bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
|
#include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
assert(func0(17) == true);
assert(func0(5 * 17) == false);
assert(func0(11 * 7) == false);
assert(func0(13441 * 19) == false);
return 0;
}
|
O3
|
c
|
func0:
endbr64
xor %eax,%eax
cmp $0x1,%rdi
jle 141a <func0+0x4a>
cmp $0x3,%rdi
jle 140d <func0+0x3d>
test $0x1,%dil
je 141a <func0+0x4a>
mov $0x2,%ecx
jmp 13fd <func0+0x2d>
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
je 1418 <func0+0x48>
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rax,%rdi
jge 13f0 <func0+0x20>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
|
func0_part_0:
cmp rdi, 3
jle short loc_13B5
test dil, 1
jz short loc_13C0
mov ecx, 2
jmp short loc_13A5
loc_1398:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jz short loc_13C0
loc_13A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rdi, rax
jge short loc_1398
loc_13B5:
mov eax, 1
retn
loc_13C0:
xor eax, eax
retn
|
long long func0_part_0(long long a1)
{
long long v1; // rcx
if ( a1 <= 3 )
return 1LL;
if ( (a1 & 1) != 0 )
{
v1 = 2LL;
while ( 1 )
{
++v1;
if ( a1 < v1 * v1 )
break;
if ( !(a1 % v1) )
return 0LL;
}
return 1LL;
}
return 0LL;
}
|
func0.part.0:
CMP RDI,0x3
JLE 0x001013b5
TEST DIL,0x1
JZ 0x001013c0
MOV ECX,0x2
JMP 0x001013a5
LAB_00101398:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JZ 0x001013c0
LAB_001013a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RDI,RAX
JGE 0x00101398
LAB_001013b5:
MOV EAX,0x1
RET
LAB_001013c0:
XOR EAX,EAX
RET
|
int8 func0_part_0(ulong param_1)
{
int auVar1 [16];
long lVar2;
if ((long)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
lVar2 = 2;
do {
lVar2 = lVar2 + 1;
if ((long)param_1 < lVar2 * lVar2) {
return 1;
}
auVar1._8_8_ = (long)(int7)(param_1 >> 8) >> 0x37;
auVar1._0_8_ = param_1;
} while (SUB168(auVar1 % SEXT816(lVar2),0) != 0);
}
return 0;
}
|
784 |
func0
|
#include <stdio.h>
#include <math.h>
|
double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1e-6) {
driv = 0.0;
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 1; j < i; j++) {
x_pow *= ans;
}
driv += i * xs[i] * x_pow;
}
ans = ans - value / driv;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
}
return ans;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] * term;
}
return result;
}
int main() {
double solution;
int ncoeff;
for (int i = 0; i < 100; i++) {
ncoeff = 2 * (1 + rand() % 4);
double coeffs[ncoeff];
for (int j = 0; j < ncoeff; j++) {
double coeff = -10 + rand() % 21;
if (coeff == 0) coeff = 1;
coeffs[j] = coeff;
}
solution = func0(coeffs, ncoeff);
assert(fabs(evaluate_polynomial(coeffs, ncoeff, solution)) < 1e-3);
}
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x20(%rbp)
mov -0x38(%rbp),%rax
movsd (%rax),%xmm0
movsd %xmm0,-0x18(%rbp)
movl $0x1,-0x30(%rbp)
jmp 1217 <func0+0x8e>
movsd 0xed1(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 11e0 <func0+0x57>
movsd -0x8(%rbp),%xmm0
mulsd -0x20(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 11cd <func0+0x44>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movsd (%rax),%xmm0
mulsd -0x8(%rbp),%xmm0
movsd -0x18(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x18(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 11b7 <func0+0x2e>
jmpq 1341 <func0+0x1b8>
pxor %xmm0,%xmm0
movsd %xmm0,-0x10(%rbp)
movl $0x1,-0x30(%rbp)
jmp 129f <func0+0x116>
movsd 0xe52(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x1,-0x28(%rbp)
jmp 125f <func0+0xd6>
movsd -0x8(%rbp),%xmm0
mulsd -0x20(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 124c <func0+0xc3>
cvtsi2sdl -0x30(%rbp),%xmm1
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movsd (%rax),%xmm0
mulsd %xmm1,%xmm0
mulsd -0x8(%rbp),%xmm0
movsd -0x10(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1236 <func0+0xad>
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
divsd -0x10(%rbp),%xmm1
movsd -0x20(%rbp),%xmm0
subsd %xmm1,%xmm0
movsd %xmm0,-0x20(%rbp)
mov -0x38(%rbp),%rax
movsd (%rax),%xmm0
movsd %xmm0,-0x18(%rbp)
movl $0x1,-0x30(%rbp)
jmp 1339 <func0+0x1b0>
movsd 0xdaf(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x0,-0x24(%rbp)
jmp 1302 <func0+0x179>
movsd -0x8(%rbp),%xmm0
mulsd -0x20(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 12ef <func0+0x166>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movsd (%rax),%xmm0
mulsd -0x8(%rbp),%xmm0
movsd -0x18(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x18(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 12d9 <func0+0x150>
movsd -0x18(%rbp),%xmm0
movq 0xd52(%rip),%xmm1
andpd %xmm1,%xmm0
comisd 0xd56(%rip),%xmm0
ja 1224 <func0+0x9b>
movsd -0x20(%rbp),%xmm0
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
pxor xmm0, xmm0
movsd [rbp+var_20], xmm0
mov rax, [rbp+var_38]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_18], xmm0
mov [rbp+var_30], 1
jmp short loc_1217
loc_11B7:
movsd xmm0, cs:qword_2070
movsd [rbp+var_8], xmm0
mov [rbp+var_2C], 0
jmp short loc_11E0
loc_11CD:
movsd xmm0, [rbp+var_8]
mulsd xmm0, [rbp+var_20]
movsd [rbp+var_8], xmm0
add [rbp+var_2C], 1
loc_11E0:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_30]
jl short loc_11CD
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
movsd xmm0, qword ptr [rax]
mulsd xmm0, [rbp+var_8]
movsd xmm1, [rbp+var_18]
addsd xmm0, xmm1
movsd [rbp+var_18], xmm0
add [rbp+var_30], 1
loc_1217:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_3C]
jl short loc_11B7
jmp loc_1345
loc_1224:
pxor xmm0, xmm0
movsd [rbp+var_10], xmm0
mov [rbp+var_30], 1
jmp short loc_12A3
loc_1236:
movsd xmm0, cs:qword_2070
movsd [rbp+var_8], xmm0
mov [rbp+var_28], 1
jmp short loc_125F
loc_124C:
movsd xmm0, [rbp+var_8]
mulsd xmm0, [rbp+var_20]
movsd [rbp+var_8], xmm0
add [rbp+var_28], 1
loc_125F:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_30]
jl short loc_124C
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_30]
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
movsd xmm0, qword ptr [rax]
mulsd xmm0, xmm1
mulsd xmm0, [rbp+var_8]
movsd xmm1, [rbp+var_10]
addsd xmm0, xmm1
movsd [rbp+var_10], xmm0
add [rbp+var_30], 1
loc_12A3:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_3C]
jl short loc_1236
movsd xmm0, [rbp+var_18]
movapd xmm1, xmm0
divsd xmm1, [rbp+var_10]
movsd xmm0, [rbp+var_20]
subsd xmm0, xmm1
movsd [rbp+var_20], xmm0
mov rax, [rbp+var_38]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_18], xmm0
mov [rbp+var_30], 1
jmp short loc_133D
loc_12DD:
movsd xmm0, cs:qword_2070
movsd [rbp+var_8], xmm0
mov [rbp+var_24], 0
jmp short loc_1306
loc_12F3:
movsd xmm0, [rbp+var_8]
mulsd xmm0, [rbp+var_20]
movsd [rbp+var_8], xmm0
add [rbp+var_24], 1
loc_1306:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_30]
jl short loc_12F3
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
movsd xmm0, qword ptr [rax]
mulsd xmm0, [rbp+var_8]
movsd xmm1, [rbp+var_18]
addsd xmm0, xmm1
movsd [rbp+var_18], xmm0
add [rbp+var_30], 1
loc_133D:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_3C]
jl short loc_12DD
loc_1345:
movsd xmm0, [rbp+var_18]
movq xmm1, cs:qword_2080
andpd xmm0, xmm1
comisd xmm0, cs:qword_2090
ja loc_1224
movsd xmm0, [rbp+var_20]
pop rbp
retn
|
double func0(double *a1, int a2)
{
int i; // [rsp+Ch] [rbp-30h]
int k; // [rsp+Ch] [rbp-30h]
int n; // [rsp+Ch] [rbp-30h]
int j; // [rsp+10h] [rbp-2Ch]
int m; // [rsp+14h] [rbp-28h]
int ii; // [rsp+18h] [rbp-24h]
double v9; // [rsp+1Ch] [rbp-20h]
double v10; // [rsp+24h] [rbp-18h]
double v11; // [rsp+2Ch] [rbp-10h]
double v12; // [rsp+34h] [rbp-8h]
double v13; // [rsp+34h] [rbp-8h]
double v14; // [rsp+34h] [rbp-8h]
v9 = 0.0;
v10 = *a1;
for ( i = 1; i < a2; ++i )
{
v12 = 1.0;
for ( j = 0; j < i; ++j )
v12 = v12 * 0.0;
v10 = a1[i] * v12 + v10;
}
while ( fabs(v10) > 0.000001 )
{
v11 = 0.0;
for ( k = 1; k < a2; ++k )
{
v13 = 1.0;
for ( m = 1; m < k; ++m )
v13 = v13 * v9;
v11 = a1[k] * (double)k * v13 + v11;
}
v9 = v9 - v10 / v11;
v10 = *a1;
for ( n = 1; n < a2; ++n )
{
v14 = 1.0;
for ( ii = 0; ii < n; ++ii )
v14 = v14 * v9;
v10 = a1[n] * v14 + v10;
}
}
return v9;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x20],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x18],XMM0
MOV dword ptr [RBP + -0x30],0x1
JMP 0x00101217
LAB_001011b7:
MOVSD XMM0,qword ptr [0x00102070]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001011e0
LAB_001011cd:
MOVSD XMM0,qword ptr [RBP + -0x8]
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x8],XMM0
ADD dword ptr [RBP + -0x2c],0x1
LAB_001011e0:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001011cd
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVSD XMM0,qword ptr [RAX]
MULSD XMM0,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RBP + -0x18]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x18],XMM0
ADD dword ptr [RBP + -0x30],0x1
LAB_00101217:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001011b7
JMP 0x00101345
LAB_00101224:
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x30],0x1
JMP 0x001012a3
LAB_00101236:
MOVSD XMM0,qword ptr [0x00102070]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0x28],0x1
JMP 0x0010125f
LAB_0010124c:
MOVSD XMM0,qword ptr [RBP + -0x8]
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x8],XMM0
ADD dword ptr [RBP + -0x28],0x1
LAB_0010125f:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x0010124c
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVSD XMM0,qword ptr [RAX]
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RBP + -0x10]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
ADD dword ptr [RBP + -0x30],0x1
LAB_001012a3:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101236
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
DIVSD XMM1,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RBP + -0x20]
SUBSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x20],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x18],XMM0
MOV dword ptr [RBP + -0x30],0x1
JMP 0x0010133d
LAB_001012dd:
MOVSD XMM0,qword ptr [0x00102070]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101306
LAB_001012f3:
MOVSD XMM0,qword ptr [RBP + -0x8]
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x8],XMM0
ADD dword ptr [RBP + -0x24],0x1
LAB_00101306:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001012f3
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVSD XMM0,qword ptr [RAX]
MULSD XMM0,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RBP + -0x18]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x18],XMM0
ADD dword ptr [RBP + -0x30],0x1
LAB_0010133d:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001012dd
LAB_00101345:
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVQ XMM1,qword ptr [0x00102080]
ANDPD XMM0,XMM1
COMISD XMM0,qword ptr [0x00102090]
JA 0x00101224
MOVSD XMM0,qword ptr [RBP + -0x20]
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double *param_1,int param_2)
{
int local_38;
int local_34;
int local_30;
int local_2c;
double local_28;
double local_20;
double local_18;
double local_10;
local_28 = 0.0;
local_20 = *param_1;
for (local_38 = 1; local_38 < param_2; local_38 = local_38 + 1) {
local_10 = DAT_00102070;
for (local_34 = 0; local_34 < local_38; local_34 = local_34 + 1) {
local_10 = local_10 * 0.0;
}
local_20 = param_1[local_38] * local_10 + local_20;
}
while (_DAT_00102090 < (double)((ulong)local_20 & DAT_00102080)) {
local_18 = 0.0;
for (local_38 = 1; local_38 < param_2; local_38 = local_38 + 1) {
local_10 = DAT_00102070;
for (local_30 = 1; local_30 < local_38; local_30 = local_30 + 1) {
local_10 = local_10 * local_28;
}
local_18 = param_1[local_38] * (double)local_38 * local_10 + local_18;
}
local_28 = local_28 - local_20 / local_18;
local_20 = *param_1;
for (local_38 = 1; local_38 < param_2; local_38 = local_38 + 1) {
local_10 = DAT_00102070;
for (local_2c = 0; local_2c < local_38; local_2c = local_2c + 1) {
local_10 = local_10 * local_28;
}
local_20 = param_1[local_38] * local_10 + local_20;
}
}
return local_28;
}
|
785 |
func0
|
#include <stdio.h>
#include <math.h>
|
double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1e-6) {
driv = 0.0;
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 1; j < i; j++) {
x_pow *= ans;
}
driv += i * xs[i] * x_pow;
}
ans = ans - value / driv;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
}
return ans;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] * term;
}
return result;
}
int main() {
double solution;
int ncoeff;
for (int i = 0; i < 100; i++) {
ncoeff = 2 * (1 + rand() % 4);
double coeffs[ncoeff];
for (int j = 0; j < ncoeff; j++) {
double coeff = -10 + rand() % 21;
if (coeff == 0) coeff = 1;
coeffs[j] = coeff;
}
solution = func0(coeffs, ncoeff);
assert(fabs(evaluate_polynomial(coeffs, ncoeff, solution)) < 1e-3);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%r8
mov %esi,%r9d
movsd (%rdi),%xmm5
cmp $0x1,%esi
jle 11e5 <func0+0x5c>
lea -0x2(%rsi),%esi
add $0x2,%rsi
movapd %xmm5,%xmm3
mov $0x1,%ecx
pxor %xmm1,%xmm1
jmp 11d0 <func0+0x47>
mulsd %xmm1,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 11b2 <func0+0x29>
mulsd (%r8,%rcx,8),%xmm0
addsd %xmm0,%xmm3
add $0x1,%rcx
cmp %rsi,%rcx
je 11e9 <func0+0x60>
mov %ecx,%edx
mov $0x0,%eax
movsd 0xea9(%rip),%xmm0
test %ecx,%ecx
jg 11b2 <func0+0x29>
jmp 11bd <func0+0x34>
movapd %xmm5,%xmm3
movapd %xmm3,%xmm0
andpd 0xebb(%rip),%xmm0
pxor %xmm1,%xmm1
comisd 0xe97(%rip),%xmm0
jbe 121e <func0+0x95>
mov $0x1,%r10d
movq 0xe9f(%rip),%xmm7
movsd 0xe7f(%rip),%xmm6
jmpq 12cb <func0+0x142>
pxor %xmm1,%xmm1
movapd %xmm1,%xmm0
retq
mov $0x1,%eax
movsd 0xe54(%rip),%xmm0
mulsd %xmm1,%xmm0
mov %eax,%edx
add $0x1,%eax
cmp %edx,%ecx
jne 1234 <func0+0xab>
add $0x8,%rdi
mov %esi,%ecx
pxor %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulsd (%rdi),%xmm2
mulsd %xmm2,%xmm0
addsd %xmm0,%xmm4
lea 0x1(%rcx),%esi
cmp %esi,%r9d
je 12e9 <func0+0x160>
cmp $0x1,%esi
jg 1227 <func0+0x9e>
movsd 0xe14(%rip),%xmm0
jmp 1241 <func0+0xb8>
mulsd %xmm1,%xmm0
add $0x1,%eax
cmp %eax,%edx
jne 1276 <func0+0xed>
mulsd (%r8,%rcx,8),%xmm0
addsd %xmm0,%xmm3
add $0x1,%rcx
cmp %rcx,%rsi
je 12b9 <func0+0x130>
mov %ecx,%edx
mov $0x0,%eax
movsd 0xde5(%rip),%xmm0
test %ecx,%ecx
jg 1276 <func0+0xed>
jmp 1281 <func0+0xf8>
divsd 0xddf(%rip),%xmm3
subsd %xmm3,%xmm1
movapd %xmm5,%xmm3
movapd %xmm3,%xmm0
andpd %xmm7,%xmm0
comisd %xmm6,%xmm0
jbe 1222 <func0+0x99>
cmp $0x1,%r9d
jle 12a9 <func0+0x120>
lea 0x8(%r8),%rdi
mov %r10d,%ecx
pxor %xmm4,%xmm4
movsd 0xda4(%rip),%xmm0
jmpq 1247 <func0+0xbe>
divsd %xmm4,%xmm3
subsd %xmm3,%xmm1
lea -0x1(%rcx),%esi
add $0x2,%rsi
movapd %xmm5,%xmm3
mov $0x1,%ecx
jmp 1294 <func0+0x10b>
|
func0:
endbr64
mov r9d, esi
movsd xmm5, qword ptr [rdi]
cmp esi, 1
jle short loc_1213
mov esi, esi
movapd xmm3, xmm5
mov ecx, 1
pxor xmm1, xmm1
loc_11A8:
mov edx, ecx
mov eax, 0
movsd xmm0, cs:qword_2068
test ecx, ecx
jle loc_12E1
loc_11BF:
mulsd xmm0, xmm1
add eax, 1
cmp eax, edx
jnz short loc_11BF
mulsd xmm0, qword ptr [rdi+rcx*8]
addsd xmm3, xmm0
add rcx, 1
cmp rcx, rsi
jnz short loc_11A8
loc_11DC:
movapd xmm0, xmm3
andpd xmm0, cs:xmmword_2080
pxor xmm1, xmm1
comisd xmm0, cs:qword_2070
jbe short loc_1219
movapd xmm8, xmm1
mov r8d, r9d
movq xmm7, qword ptr cs:xmmword_2080
movsd xmm6, cs:qword_2070
jmp loc_12B6
loc_1213:
movapd xmm3, xmm5
jmp short loc_11DC
loc_1219:
pxor xmm1, xmm1
loc_121D:
movapd xmm0, xmm1
retn
loc_1222:
mulsd xmm0, xmm1
add eax, 1
cmp eax, edx
jnz short loc_1222
loc_122D:
pxor xmm2, xmm2
cvtsi2sd xmm2, esi
mulsd xmm2, qword ptr [rdi+rcx*8]
mulsd xmm0, xmm2
addsd xmm4, xmm0
add rcx, 1
cmp r8, rcx
jz short loc_1263
loc_124B:
mov esi, ecx
mov edx, ecx
mov eax, 1
movsd xmm0, cs:qword_2068
cmp ecx, 1
jg short loc_1222
jmp short loc_122D
loc_1263:
divsd xmm3, xmm4
subsd xmm1, xmm3
movapd xmm3, xmm5
mov ecx, 1
loc_1274:
mov edx, ecx
mov eax, 0
movsd xmm0, cs:qword_2068
test ecx, ecx
jle short loc_12D6
loc_1287:
mulsd xmm0, xmm1
add eax, 1
cmp edx, eax
jnz short loc_1287
mulsd xmm0, qword ptr [rdi+rcx*8]
addsd xmm3, xmm0
add rcx, 1
cmp rcx, r8
jnz short loc_1274
loc_12A4:
movapd xmm0, xmm3
andpd xmm0, xmm7
comisd xmm0, xmm6
jbe loc_121D
loc_12B6:
cmp r9d, 1
jle short loc_12C7
mov ecx, 1
pxor xmm4, xmm4
jmp short loc_124B
loc_12C7:
divsd xmm3, xmm8
subsd xmm1, xmm3
movapd xmm3, xmm5
jmp short loc_12A4
loc_12D6:
addsd xmm3, qword ptr [rdi+rcx*8]
add rcx, 1
jmp short loc_1274
loc_12E1:
addsd xmm3, qword ptr [rdi+rcx*8]
add rcx, 1
jmp loc_11A8
|
__int128 __usercall func0@<xmm0>(double *a1@<rdi>, int a2@<esi>)
{
double v2; // xmm3_8
long long i; // rcx
int v4; // eax
double v5; // xmm0_8
__int128 v6; // xmm1
double v8; // xmm0_8
int v9; // eax
double v10; // xmm4_8
long long v11; // rcx
long long j; // rcx
int v13; // eax
double v14; // xmm0_8
if ( a2 <= 1 )
{
v2 = *a1;
}
else
{
v2 = *a1;
for ( i = 1LL; i != a2; v2 = v2 + v5 * a1[i++] )
{
while ( 1 )
{
v4 = 0;
v5 = 1.0;
if ( (int)i > 0 )
break;
v2 = v2 + a1[i++];
}
do
{
v5 = v5 * 0.0;
++v4;
}
while ( v4 != (_DWORD)i );
}
}
v6 = 0LL;
if ( fabs(v2) <= 0.000001 )
return 0LL;
do
{
if ( a2 <= 1 )
{
*(double *)&v6 = *(double *)&v6 - v2 / 0.0;
v2 = *a1;
}
else
{
v11 = 1LL;
v10 = 0.0;
do
{
v9 = 1;
v8 = 1.0;
if ( (int)v11 > 1 )
{
do
{
v8 = v8 * *(double *)&v6;
++v9;
}
while ( v9 != (_DWORD)v11 );
}
v10 = v10 + v8 * ((double)(int)v11 * a1[v11]);
++v11;
}
while ( a2 != v11 );
*(double *)&v6 = *(double *)&v6 - v2 / v10;
v2 = *a1;
for ( j = 1LL; j != a2; v2 = v2 + v14 * a1[j++] )
{
while ( 1 )
{
v13 = 0;
v14 = 1.0;
if ( (int)j > 0 )
break;
v2 = v2 + a1[j++];
}
do
{
v14 = v14 * *(double *)&v6;
++v13;
}
while ( (_DWORD)j != v13 );
}
}
}
while ( fabs(v2) > 0.000001 );
return v6;
}
|
func0:
ENDBR64
MOV R9D,ESI
MOVSD XMM5,qword ptr [RDI]
CMP ESI,0x1
JLE 0x00101213
MOV ESI,ESI
MOVAPD XMM3,XMM5
MOV ECX,0x1
PXOR XMM1,XMM1
LAB_001011a8:
MOV EDX,ECX
MOV EAX,0x0
MOVSD XMM0,qword ptr [0x00102068]
TEST ECX,ECX
JLE 0x001012e1
LAB_001011bf:
MULSD XMM0,XMM1
ADD EAX,0x1
CMP EAX,EDX
JNZ 0x001011bf
MULSD XMM0,qword ptr [RDI + RCX*0x8]
ADDSD XMM3,XMM0
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001011a8
LAB_001011dc:
MOVAPD XMM0,XMM3
ANDPD XMM0,xmmword ptr [0x00102080]
PXOR XMM1,XMM1
COMISD XMM0,qword ptr [0x00102070]
JBE 0x00101219
MOVAPD XMM8,XMM1
MOV R8D,R9D
MOVQ XMM7,qword ptr [0x00102080]
MOVSD XMM6,qword ptr [0x00102070]
JMP 0x001012b6
LAB_00101213:
MOVAPD XMM3,XMM5
JMP 0x001011dc
LAB_00101219:
PXOR XMM1,XMM1
LAB_0010121d:
MOVAPD XMM0,XMM1
RET
LAB_00101222:
MULSD XMM0,XMM1
ADD EAX,0x1
CMP EAX,EDX
JNZ 0x00101222
LAB_0010122d:
PXOR XMM2,XMM2
CVTSI2SD XMM2,ESI
MULSD XMM2,qword ptr [RDI + RCX*0x8]
MULSD XMM0,XMM2
ADDSD XMM4,XMM0
ADD RCX,0x1
CMP R8,RCX
JZ 0x00101263
LAB_0010124b:
MOV ESI,ECX
MOV EDX,ECX
MOV EAX,0x1
MOVSD XMM0,qword ptr [0x00102068]
CMP ECX,0x1
JG 0x00101222
JMP 0x0010122d
LAB_00101263:
DIVSD XMM3,XMM4
SUBSD XMM1,XMM3
MOVAPD XMM3,XMM5
MOV ECX,0x1
LAB_00101274:
MOV EDX,ECX
MOV EAX,0x0
MOVSD XMM0,qword ptr [0x00102068]
TEST ECX,ECX
JLE 0x001012d6
LAB_00101287:
MULSD XMM0,XMM1
ADD EAX,0x1
CMP EDX,EAX
JNZ 0x00101287
MULSD XMM0,qword ptr [RDI + RCX*0x8]
ADDSD XMM3,XMM0
ADD RCX,0x1
CMP RCX,R8
JNZ 0x00101274
LAB_001012a4:
MOVAPD XMM0,XMM3
ANDPD XMM0,XMM7
COMISD XMM0,XMM6
JBE 0x0010121d
LAB_001012b6:
CMP R9D,0x1
JLE 0x001012c7
MOV ECX,0x1
PXOR XMM4,XMM4
JMP 0x0010124b
LAB_001012c7:
DIVSD XMM3,XMM8
SUBSD XMM1,XMM3
MOVAPD XMM3,XMM5
JMP 0x001012a4
LAB_001012d6:
ADDSD XMM3,qword ptr [RDI + RCX*0x8]
ADD RCX,0x1
JMP 0x00101274
LAB_001012e1:
ADDSD XMM3,qword ptr [RDI + RCX*0x8]
ADD RCX,0x1
JMP 0x001011a8
|
double func0(double *param_1,uint param_2)
{
double dVar1;
int iVar2;
int iVar3;
ulong uVar4;
double dVar5;
double dVar6;
double dVar7;
double dVar8;
dVar1 = *param_1;
dVar7 = dVar1;
if (1 < (int)param_2) {
uVar4 = 1;
do {
while( true ) {
iVar2 = 0;
dVar5 = DAT_00102068;
if (0 < (int)uVar4) break;
dVar7 = dVar7 + param_1[uVar4];
uVar4 = uVar4 + 1;
}
do {
dVar5 = dVar5 * 0.0;
iVar2 = iVar2 + 1;
} while (iVar2 != (int)uVar4);
dVar7 = dVar7 + dVar5 * param_1[uVar4];
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
dVar5 = 0.0;
if ((double)((ulong)dVar7 & DAT_00102080) <= DAT_00102070) {
dVar5 = 0.0;
}
else {
do {
if ((int)param_2 < 2) {
dVar5 = dVar5 - dVar7 / 0.0;
dVar7 = dVar1;
}
else {
uVar4 = 1;
dVar8 = 0.0;
do {
iVar3 = (int)uVar4;
iVar2 = 1;
dVar6 = DAT_00102068;
if (1 < iVar3) {
do {
dVar6 = dVar6 * dVar5;
iVar2 = iVar2 + 1;
} while (iVar2 != iVar3);
}
dVar8 = dVar8 + dVar6 * (double)iVar3 * param_1[uVar4];
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
dVar5 = dVar5 - dVar7 / dVar8;
uVar4 = 1;
dVar7 = dVar1;
do {
while( true ) {
iVar2 = 0;
dVar8 = DAT_00102068;
if (0 < (int)uVar4) break;
dVar7 = dVar7 + param_1[uVar4];
uVar4 = uVar4 + 1;
}
do {
dVar8 = dVar8 * dVar5;
iVar2 = iVar2 + 1;
} while ((int)uVar4 != iVar2);
dVar7 = dVar7 + dVar8 * param_1[uVar4];
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
} while (DAT_00102070 < (double)((ulong)dVar7 & DAT_00102080));
}
return dVar5;
}
|
786 |
func0
|
#include <stdio.h>
#include <math.h>
|
double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1e-6) {
driv = 0.0;
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 1; j < i; j++) {
x_pow *= ans;
}
driv += i * xs[i] * x_pow;
}
ans = ans - value / driv;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
}
return ans;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] * term;
}
return result;
}
int main() {
double solution;
int ncoeff;
for (int i = 0; i < 100; i++) {
ncoeff = 2 * (1 + rand() % 4);
double coeffs[ncoeff];
for (int j = 0; j < ncoeff; j++) {
double coeff = -10 + rand() % 21;
if (coeff == 0) coeff = 1;
coeffs[j] = coeff;
}
solution = func0(coeffs, ncoeff);
assert(fabs(evaluate_polynomial(coeffs, ncoeff, solution)) < 1e-3);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
movsd (%rdi),%xmm7
mov %rdi,%r9
mov %esi,%r8d
cmp $0x1,%esi
jle 14c9 <func0+0x179>
lea -0x2(%rsi),%ecx
movapd %xmm7,%xmm3
pxor %xmm6,%xmm6
mov $0x1,%edx
movsd 0xd09(%rip),%xmm1
add $0x2,%rcx
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
movapd %xmm1,%xmm0
xchg %ax,%ax
mulsd %xmm6,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 1390 <func0+0x40>
mulsd (%r9,%rdx,8),%xmm0
add $0x1,%rdx
addsd %xmm0,%xmm3
cmp %rdx,%rcx
jne 1388 <func0+0x38>
movapd %xmm3,%xmm0
movsd 0xcce(%rip),%xmm5
movapd %xmm6,%xmm1
movq 0xcd9(%rip),%xmm9
movsd 0xcc0(%rip),%xmm8
andpd %xmm9,%xmm0
comisd %xmm8,%xmm0
jbe 14a2 <func0+0x152>
cmp $0x1,%r8d
jle 14a7 <func0+0x157>
lea 0x8(%r9),%rdi
movapd %xmm6,%xmm4
mov $0x1,%ecx
movapd %xmm5,%xmm0
nopl 0x0(%rax,%rax,1)
pxor %xmm2,%xmm2
lea 0x1(%rcx),%esi
cvtsi2sd %ecx,%xmm2
mulsd (%rdi),%xmm2
mulsd %xmm2,%xmm0
addsd %xmm0,%xmm4
cmp %esi,%r8d
je 1440 <func0+0xf0>
mov $0x1,%eax
movapd %xmm5,%xmm0
nopl (%rax)
mulsd %xmm1,%xmm0
mov %eax,%edx
add $0x1,%eax
cmp %ecx,%edx
jne 1428 <func0+0xd8>
add $0x8,%rdi
mov %esi,%ecx
jmp 1400 <func0+0xb0>
nopl (%rax)
divsd %xmm4,%xmm3
sub $0x1,%ecx
mov $0x1,%edx
add $0x2,%rcx
subsd %xmm3,%xmm1
movapd %xmm7,%xmm3
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
movapd %xmm5,%xmm0
nopw %cs:0x0(%rax,%rax,1)
mulsd %xmm1,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 1470 <func0+0x120>
mulsd (%r9,%rdx,8),%xmm0
add $0x1,%rdx
addsd %xmm0,%xmm3
cmp %rdx,%rcx
jne 1460 <func0+0x110>
movapd %xmm3,%xmm0
andpd %xmm9,%xmm0
comisd %xmm8,%xmm0
ja 13e0 <func0+0x90>
movapd %xmm1,%xmm0
retq
divsd %xmm6,%xmm3
subsd %xmm3,%xmm1
movapd %xmm7,%xmm3
movapd %xmm3,%xmm0
andpd %xmm9,%xmm0
comisd %xmm8,%xmm0
ja 13e0 <func0+0x90>
jmp 14a2 <func0+0x152>
movapd %xmm7,%xmm3
pxor %xmm6,%xmm6
jmpq 13ae <func0+0x5e>
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
movsd xmm6, qword ptr [rdi]
mov ecx, esi
cmp esi, 1
jle loc_14C9
mov r8d, esi
movapd xmm3, xmm6
pxor xmm1, xmm1
mov edx, 1
movsd xmm5, cs:qword_2068
nop dword ptr [rax+rax+00h]
loc_1370:
xor eax, eax
movapd xmm0, xmm5
test dl, 1
jz short loc_1390
mov eax, 1
pxor xmm0, xmm0
cmp eax, edx
jz short loc_139F
nop dword ptr [rax+rax+00000000h]
loc_1390:
mulsd xmm0, xmm1
add eax, 2
mulsd xmm0, xmm1
cmp eax, edx
jnz short loc_1390
loc_139F:
mulsd xmm0, qword ptr [rdi+rdx*8]
add rdx, 1
addsd xmm3, xmm0
cmp r8, rdx
jnz short loc_1370
loc_13B1:
movq xmm7, qword ptr cs:xmmword_2080
movapd xmm0, xmm3
pxor xmm1, xmm1
movsd xmm8, cs:qword_2070
andpd xmm0, xmm7
comisd xmm0, xmm8
jbe loc_14C4
cmp ecx, 1
jle loc_14D2
movsd xmm5, cs:qword_2068
mov r8d, ecx
nop dword ptr [rax]
loc_13F0:
mov edx, 1
pxor xmm4, xmm4
nop dword ptr [rax+00000000h]
loc_1400:
mov esi, edx
mov ecx, edx
movapd xmm0, xmm5
mov eax, 1
cmp edx, 1
jz short loc_1437
test dl, 1
jnz short loc_1428
mulsd xmm0, xmm1
mov eax, 2
cmp eax, edx
jz short loc_1437
nop dword ptr [rax+00h]
loc_1428:
mulsd xmm0, xmm1
add eax, 2
mulsd xmm0, xmm1
cmp eax, ecx
jnz short loc_1428
loc_1437:
pxor xmm2, xmm2
cvtsi2sd xmm2, esi
mulsd xmm2, qword ptr [rdi+rdx*8]
add rdx, 1
mulsd xmm0, xmm2
addsd xmm4, xmm0
cmp r8, rdx
jnz short loc_1400
divsd xmm3, xmm4
mov edx, 1
subsd xmm1, xmm3
movapd xmm3, xmm6
nop word ptr [rax+rax+00000000h]
loc_1470:
xor eax, eax
movapd xmm0, xmm5
test dl, 1
jz short loc_1490
mov eax, 1
movapd xmm0, xmm1
cmp eax, edx
jz short loc_149F
nop dword ptr [rax+rax+00000000h]
loc_1490:
mulsd xmm0, xmm1
add eax, 2
mulsd xmm0, xmm1
cmp eax, edx
jnz short loc_1490
loc_149F:
mulsd xmm0, qword ptr [rdi+rdx*8]
add rdx, 1
addsd xmm3, xmm0
cmp r8, rdx
jnz short loc_1470
movapd xmm0, xmm3
andpd xmm0, xmm7
comisd xmm0, xmm8
ja loc_13F0
loc_14C4:
movapd xmm0, xmm1
retn
loc_14C9:
movapd xmm3, xmm6
jmp loc_13B1
loc_14D2:
movapd xmm0, xmm1
andpd xmm7, xmm6
jmp short loc_14E0
loc_14DC:
movapd xmm3, xmm6
loc_14E0:
divsd xmm3, xmm0
comisd xmm7, xmm8
subsd xmm1, xmm3
ja short loc_14DC
jmp short loc_14C4
|
__int128 __usercall func0@<xmm0>(double *a1@<rdi>, int a2@<esi>)
{
double v2; // xmm3_8
long long v3; // rdx
int v4; // eax
double v5; // xmm0_8
double v6; // xmm0_8
__int128 v7; // xmm1
long long v8; // rdx
double v9; // xmm4_8
double v10; // xmm0_8
int v11; // eax
double v12; // xmm2_8
long long v13; // rdx
int v14; // eax
double v15; // xmm0_8
double v16; // xmm0_8
double v18; // xmm7_8
if ( a2 <= 1 )
{
v2 = *a1;
}
else
{
v2 = *a1;
v3 = 1LL;
do
{
v4 = 0;
v5 = 1.0;
if ( (v3 & 1) == 0 || (v4 = 1, v5 = 0.0, (_DWORD)v3 != 1) )
{
do
{
v4 += 2;
v5 = v5 * 0.0 * 0.0;
}
while ( v4 != (_DWORD)v3 );
}
v6 = v5 * a1[v3++];
v2 = v2 + v6;
}
while ( a2 != v3 );
}
v7 = 0LL;
if ( fabs(v2) > 0.000001 )
{
if ( a2 <= 1 )
{
v18 = fabs(*a1);
while ( 1 )
{
*(double *)&v7 = *(double *)&v7 - v2 / 0.0;
if ( v18 <= 0.000001 )
break;
v2 = *a1;
}
}
else
{
do
{
v8 = 1LL;
v9 = 0.0;
do
{
v10 = 1.0;
v11 = 1;
if ( (_DWORD)v8 != 1 )
{
if ( (v8 & 1) != 0 || (v10 = 1.0 * *(double *)&v7, v11 = 2, (_DWORD)v8 != 2) )
{
do
{
v11 += 2;
v10 = v10 * *(double *)&v7 * *(double *)&v7;
}
while ( v11 != (_DWORD)v8 );
}
}
v12 = (double)(int)v8 * a1[v8];
++v8;
v9 = v9 + v10 * v12;
}
while ( a2 != v8 );
v13 = 1LL;
*(double *)&v7 = *(double *)&v7 - v2 / v9;
v2 = *a1;
do
{
v14 = 0;
v15 = 1.0;
if ( (v13 & 1) == 0 || (v14 = 1, v15 = *(double *)&v7, (_DWORD)v13 != 1) )
{
do
{
v14 += 2;
v15 = v15 * *(double *)&v7 * *(double *)&v7;
}
while ( v14 != (_DWORD)v13 );
}
v16 = v15 * a1[v13++];
v2 = v2 + v16;
}
while ( a2 != v13 );
}
while ( fabs(v2) > 0.000001 );
}
}
return v7;
}
|
func0:
ENDBR64
MOVSD XMM6,qword ptr [RDI]
MOV ECX,ESI
CMP ESI,0x1
JLE 0x001014c9
MOV R8D,ESI
MOVAPD XMM3,XMM6
PXOR XMM1,XMM1
MOV EDX,0x1
MOVSD XMM5,qword ptr [0x00102068]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101370:
XOR EAX,EAX
MOVAPD XMM0,XMM5
TEST DL,0x1
JZ 0x00101390
MOV EAX,0x1
PXOR XMM0,XMM0
CMP EAX,EDX
JZ 0x0010139f
NOP dword ptr [RAX + RAX*0x1]
LAB_00101390:
MULSD XMM0,XMM1
ADD EAX,0x2
MULSD XMM0,XMM1
CMP EAX,EDX
JNZ 0x00101390
LAB_0010139f:
MULSD XMM0,qword ptr [RDI + RDX*0x8]
ADD RDX,0x1
ADDSD XMM3,XMM0
CMP R8,RDX
JNZ 0x00101370
LAB_001013b1:
MOVQ XMM7,qword ptr [0x00102080]
MOVAPD XMM0,XMM3
PXOR XMM1,XMM1
MOVSD XMM8,qword ptr [0x00102070]
ANDPD XMM0,XMM7
COMISD XMM0,XMM8
JBE 0x001014c4
CMP ECX,0x1
JLE 0x001014d2
MOVSD XMM5,qword ptr [0x00102068]
MOV R8D,ECX
NOP dword ptr [RAX]
LAB_001013f0:
MOV EDX,0x1
PXOR XMM4,XMM4
NOP dword ptr [RAX]
LAB_00101400:
MOV ESI,EDX
MOV ECX,EDX
MOVAPD XMM0,XMM5
MOV EAX,0x1
CMP EDX,0x1
JZ 0x00101437
TEST DL,0x1
JNZ 0x00101428
MULSD XMM0,XMM1
MOV EAX,0x2
CMP EAX,EDX
JZ 0x00101437
NOP dword ptr [RAX]
LAB_00101428:
MULSD XMM0,XMM1
ADD EAX,0x2
MULSD XMM0,XMM1
CMP EAX,ECX
JNZ 0x00101428
LAB_00101437:
PXOR XMM2,XMM2
CVTSI2SD XMM2,ESI
MULSD XMM2,qword ptr [RDI + RDX*0x8]
ADD RDX,0x1
MULSD XMM0,XMM2
ADDSD XMM4,XMM0
CMP R8,RDX
JNZ 0x00101400
DIVSD XMM3,XMM4
MOV EDX,0x1
SUBSD XMM1,XMM3
MOVAPD XMM3,XMM6
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101470:
XOR EAX,EAX
MOVAPD XMM0,XMM5
TEST DL,0x1
JZ 0x00101490
MOV EAX,0x1
MOVAPD XMM0,XMM1
CMP EAX,EDX
JZ 0x0010149f
NOP dword ptr [RAX + RAX*0x1]
LAB_00101490:
MULSD XMM0,XMM1
ADD EAX,0x2
MULSD XMM0,XMM1
CMP EAX,EDX
JNZ 0x00101490
LAB_0010149f:
MULSD XMM0,qword ptr [RDI + RDX*0x8]
ADD RDX,0x1
ADDSD XMM3,XMM0
CMP R8,RDX
JNZ 0x00101470
MOVAPD XMM0,XMM3
ANDPD XMM0,XMM7
COMISD XMM0,XMM8
JA 0x001013f0
LAB_001014c4:
MOVAPD XMM0,XMM1
RET
LAB_001014c9:
MOVAPD XMM3,XMM6
JMP 0x001013b1
LAB_001014d2:
MOVAPD XMM0,XMM1
ANDPD XMM7,XMM6
JMP 0x001014e0
LAB_001014dc:
MOVAPD XMM3,XMM6
LAB_001014e0:
DIVSD XMM3,XMM0
COMISD XMM7,XMM8
SUBSD XMM1,XMM3
JA 0x001014dc
JMP 0x001014c4
|
double func0(double *param_1,uint param_2)
{
double *pdVar1;
double dVar2;
int iVar3;
int iVar4;
ulong uVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
dVar2 = *param_1;
dVar8 = dVar2;
if (1 < (int)param_2) {
uVar5 = 1;
do {
iVar3 = 0;
dVar6 = DAT_00102068;
if ((uVar5 & 1) == 0) {
LAB_00101390:
do {
iVar3 = iVar3 + 2;
dVar6 = dVar6 * 0.0 * 0.0;
} while (iVar3 != (int)uVar5);
}
else {
iVar3 = 1;
dVar6 = 0.0;
if ((int)uVar5 != 1) goto LAB_00101390;
}
pdVar1 = param_1 + uVar5;
uVar5 = uVar5 + 1;
dVar8 = dVar8 + dVar6 * *pdVar1;
} while (param_2 != uVar5);
}
dVar6 = 0.0;
if (DAT_00102070 < (double)((ulong)dVar8 & DAT_00102080)) {
if ((int)param_2 < 2) {
do {
dVar6 = dVar6 - dVar8 / 0.0;
dVar8 = dVar2;
} while (DAT_00102070 < (double)(DAT_00102080 & (ulong)dVar2));
}
else {
do {
uVar5 = 1;
dVar9 = 0.0;
do {
iVar4 = (int)uVar5;
iVar3 = 1;
dVar7 = DAT_00102068;
if (iVar4 != 1) {
if ((uVar5 & 1) == 0) {
dVar7 = DAT_00102068 * dVar6;
iVar3 = 2;
if (iVar4 == 2) goto LAB_00101437;
}
do {
iVar3 = iVar3 + 2;
dVar7 = dVar7 * dVar6 * dVar6;
} while (iVar3 != iVar4);
}
LAB_00101437:
pdVar1 = param_1 + uVar5;
uVar5 = uVar5 + 1;
dVar9 = dVar9 + dVar7 * (double)iVar4 * *pdVar1;
} while (param_2 != uVar5);
uVar5 = 1;
dVar6 = dVar6 - dVar8 / dVar9;
dVar8 = dVar2;
do {
iVar3 = 0;
dVar9 = DAT_00102068;
if (((uVar5 & 1) == 0) || (iVar3 = 1, dVar9 = dVar6, (int)uVar5 != 1)) {
do {
iVar3 = iVar3 + 2;
dVar9 = dVar9 * dVar6 * dVar6;
} while (iVar3 != (int)uVar5);
}
pdVar1 = param_1 + uVar5;
uVar5 = uVar5 + 1;
dVar8 = dVar8 + dVar9 * *pdVar1;
} while (param_2 != uVar5);
} while (DAT_00102070 < (double)((ulong)dVar8 & DAT_00102080));
}
}
return dVar6;
}
|
787 |
func0
|
#include <stdio.h>
#include <math.h>
|
double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1e-6) {
driv = 0.0;
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 1; j < i; j++) {
x_pow *= ans;
}
driv += i * xs[i] * x_pow;
}
ans = ans - value / driv;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
}
return ans;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] * term;
}
return result;
}
int main() {
double solution;
int ncoeff;
for (int i = 0; i < 100; i++) {
ncoeff = 2 * (1 + rand() % 4);
double coeffs[ncoeff];
for (int j = 0; j < ncoeff; j++) {
double coeff = -10 + rand() % 21;
if (coeff == 0) coeff = 1;
coeffs[j] = coeff;
}
solution = func0(coeffs, ncoeff);
assert(fabs(evaluate_polynomial(coeffs, ncoeff, solution)) < 1e-3);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
movsd (%rdi),%xmm8
mov %esi,%r10d
cmp $0x1,%esi
jle 1589 <func0+0x189>
lea -0x2(%rsi),%ecx
movapd %xmm8,%xmm3
mov $0x1,%edx
movsd 0xc5e(%rip),%xmm5
add $0x2,%rcx
pxor %xmm6,%xmm6
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
movapd %xmm5,%xmm0
xchg %ax,%ax
mulsd %xmm6,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 1440 <func0+0x40>
mulsd (%rdi,%rdx,8),%xmm0
add $0x1,%rdx
addsd %xmm0,%xmm3
cmp %rdx,%rcx
jne 1438 <func0+0x38>
movq 0xc3a(%rip),%xmm9
movapd %xmm3,%xmm0
movapd %xmm6,%xmm1
movsd 0xc19(%rip),%xmm10
andpd %xmm9,%xmm0
comisd %xmm10,%xmm0
jbe 1561 <func0+0x161>
movsd 0xbf9(%rip),%xmm7
lea -0x2(%r10),%r8d
lea -0x3(%r10),%r9d
add $0x2,%r8
add $0x3,%r9
movq %xmm7,%r11
nopl 0x0(%rax)
cmp $0x1,%r10d
jle 1566 <func0+0x166>
movsd 0x8(%rdi),%xmm4
movq %r11,%xmm5
addsd %xmm6,%xmm4
cmp $0x2,%r10d
je 1509 <func0+0x109>
mov $0x2,%esi
movapd %xmm7,%xmm5
mov %esi,%ecx
mov %esi,%edx
movapd %xmm7,%xmm0
mov $0x1,%eax
nopl (%rax)
mulsd %xmm1,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 14e0 <func0+0xe0>
pxor %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulsd (%rdi,%rsi,8),%xmm2
add $0x1,%rsi
mulsd %xmm2,%xmm0
addsd %xmm0,%xmm4
cmp %rsi,%r9
jne 14d0 <func0+0xd0>
divsd %xmm4,%xmm3
mov $0x1,%edx
subsd %xmm3,%xmm1
movapd %xmm8,%xmm3
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
movapd %xmm5,%xmm0
nopw %cs:0x0(%rax,%rax,1)
mulsd %xmm1,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 1530 <func0+0x130>
mulsd (%rdi,%rdx,8),%xmm0
add $0x1,%rdx
addsd %xmm0,%xmm3
cmp %r8,%rdx
jne 1520 <func0+0x120>
movapd %xmm3,%xmm0
andpd %xmm9,%xmm0
comisd %xmm10,%xmm0
ja 14a8 <func0+0xa8>
movapd %xmm1,%xmm0
retq
divsd %xmm6,%xmm3
subsd %xmm3,%xmm1
movapd %xmm8,%xmm3
movapd %xmm3,%xmm0
andpd %xmm9,%xmm0
comisd %xmm10,%xmm0
ja 14a8 <func0+0xa8>
jmp 1561 <func0+0x161>
movapd %xmm8,%xmm3
pxor %xmm6,%xmm6
jmpq 145d <func0+0x5d>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
mov rcx, rdi
mov edi, esi
movsd xmm7, qword ptr [rcx]
cmp esi, 1
jle loc_15A9
mov esi, esi
movapd xmm2, xmm7
pxor xmm1, xmm1
mov edx, 1
movsd xmm5, cs:qword_2068
nop dword ptr [rax]
loc_1440:
xor eax, eax
movapd xmm0, xmm5
test dl, 1
jz short loc_1460
mov eax, 1
pxor xmm0, xmm0
cmp eax, edx
jz short loc_146F
nop dword ptr [rax+rax+00000000h]
loc_1460:
mulsd xmm0, xmm1
add eax, 2
mulsd xmm0, xmm1
cmp eax, edx
jnz short loc_1460
loc_146F:
mulsd xmm0, qword ptr [rcx+rdx*8]
add rdx, 1
addsd xmm2, xmm0
cmp rsi, rdx
jnz short loc_1440
loc_1481:
movq xmm6, qword ptr cs:xmmword_2080
movapd xmm0, xmm2
pxor xmm1, xmm1
movsd xmm8, cs:qword_2070
andpd xmm0, xmm6
comisd xmm0, xmm8
jbe loc_15A4
cmp edi, 1
jle loc_15B2
movsd xmm5, cs:qword_2068
mov esi, edi
lea r10, [rcx+8]
movapd xmm9, xmm1
nop dword ptr [rax]
loc_14C8:
movsd xmm4, qword ptr [r10]
mov edx, 2
addsd xmm4, xmm9
cmp edi, 2
jz short loc_153D
loc_14DC:
mov r9d, edx
movapd xmm0, xmm5
mov eax, 2
mov r8d, edx
mulsd xmm0, xmm1
and r9d, 1
cmp eax, edx
jge short loc_151F
test r9d, r9d
jz short loc_1510
mulsd xmm0, xmm1
mov eax, 3
cmp eax, edx
jge short loc_151F
nop dword ptr [rax+00000000h]
loc_1510:
mulsd xmm0, xmm1
add eax, 2
mulsd xmm0, xmm1
cmp eax, edx
jl short loc_1510
loc_151F:
pxor xmm3, xmm3
cvtsi2sd xmm3, r8d
mulsd xmm3, qword ptr [rcx+rdx*8]
add rdx, 1
mulsd xmm0, xmm3
addsd xmm4, xmm0
cmp edi, edx
jg short loc_14DC
loc_153D:
divsd xmm2, xmm4
mov edx, 1
subsd xmm1, xmm2
movapd xmm2, xmm7
xchg ax, ax
loc_1550:
xor eax, eax
movapd xmm0, xmm5
test dl, 1
jz short loc_1570
mov eax, 1
movapd xmm0, xmm1
cmp eax, edx
jz short loc_157F
nop dword ptr [rax+rax+00000000h]
loc_1570:
mulsd xmm0, xmm1
add eax, 2
mulsd xmm0, xmm1
cmp eax, edx
jnz short loc_1570
loc_157F:
mulsd xmm0, qword ptr [rcx+rdx*8]
add rdx, 1
addsd xmm2, xmm0
cmp rdx, rsi
jnz short loc_1550
movapd xmm0, xmm2
andpd xmm0, xmm6
comisd xmm0, xmm8
ja loc_14C8
loc_15A4:
movapd xmm0, xmm1
retn
loc_15A9:
movapd xmm2, xmm7
jmp loc_1481
loc_15B2:
movapd xmm0, xmm1
andpd xmm6, xmm7
jmp short loc_15C0
loc_15BC:
movapd xmm2, xmm7
loc_15C0:
divsd xmm2, xmm0
comisd xmm6, xmm8
subsd xmm1, xmm2
ja short loc_15BC
jmp short loc_15A4
|
__int128 __usercall func0@<xmm0>(double *a1@<rdi>, int a2@<esi>)
{
double v2; // xmm2_8
long long v3; // rdx
int v4; // eax
double v5; // xmm0_8
double v6; // xmm0_8
__int128 v7; // xmm1
long long v8; // rdx
double v9; // xmm4_8
int v10; // eax
double v11; // xmm0_8
double v12; // xmm3_8
long long v13; // rdx
int v14; // eax
double v15; // xmm0_8
double v16; // xmm0_8
double v18; // xmm6_8
if ( a2 <= 1 )
{
v2 = *a1;
}
else
{
v2 = *a1;
v3 = 1LL;
do
{
v4 = 0;
v5 = 1.0;
if ( (v3 & 1) == 0 || (v4 = 1, v5 = 0.0, (_DWORD)v3 != 1) )
{
do
{
v4 += 2;
v5 = v5 * 0.0 * 0.0;
}
while ( v4 != (_DWORD)v3 );
}
v6 = v5 * a1[v3++];
v2 = v2 + v6;
}
while ( a2 != v3 );
}
v7 = 0LL;
if ( fabs(v2) > 0.000001 )
{
if ( a2 <= 1 )
{
v18 = fabs(*a1);
while ( 1 )
{
*(double *)&v7 = *(double *)&v7 - v2 / 0.0;
if ( v18 <= 0.000001 )
break;
v2 = *a1;
}
}
else
{
do
{
v8 = 2LL;
v9 = a1[1] + 0.0;
if ( a2 != 2 )
{
do
{
v10 = 2;
v11 = 1.0 * *(double *)&v7;
if ( (int)v8 > 2 )
{
if ( (v8 & 1) == 0 || (v11 = v11 * *(double *)&v7, v10 = 3, (int)v8 > 3) )
{
do
{
v10 += 2;
v11 = v11 * *(double *)&v7 * *(double *)&v7;
}
while ( v10 < (int)v8 );
}
}
v12 = (double)(int)v8 * a1[v8];
++v8;
v9 = v9 + v11 * v12;
}
while ( a2 > (int)v8 );
}
v13 = 1LL;
*(double *)&v7 = *(double *)&v7 - v2 / v9;
v2 = *a1;
do
{
v14 = 0;
v15 = 1.0;
if ( (v13 & 1) == 0 || (v14 = 1, v15 = *(double *)&v7, (_DWORD)v13 != 1) )
{
do
{
v14 += 2;
v15 = v15 * *(double *)&v7 * *(double *)&v7;
}
while ( v14 != (_DWORD)v13 );
}
v16 = v15 * a1[v13++];
v2 = v2 + v16;
}
while ( v13 != a2 );
}
while ( fabs(v2) > 0.000001 );
}
}
return v7;
}
|
func0:
ENDBR64
MOV RCX,RDI
MOV EDI,ESI
MOVSD XMM7,qword ptr [RCX]
CMP ESI,0x1
JLE 0x001015a9
MOV ESI,ESI
MOVAPD XMM2,XMM7
PXOR XMM1,XMM1
MOV EDX,0x1
MOVSD XMM5,qword ptr [0x00102068]
NOP dword ptr [RAX]
LAB_00101440:
XOR EAX,EAX
MOVAPD XMM0,XMM5
TEST DL,0x1
JZ 0x00101460
MOV EAX,0x1
PXOR XMM0,XMM0
CMP EAX,EDX
JZ 0x0010146f
NOP dword ptr [RAX + RAX*0x1]
LAB_00101460:
MULSD XMM0,XMM1
ADD EAX,0x2
MULSD XMM0,XMM1
CMP EAX,EDX
JNZ 0x00101460
LAB_0010146f:
MULSD XMM0,qword ptr [RCX + RDX*0x8]
ADD RDX,0x1
ADDSD XMM2,XMM0
CMP RSI,RDX
JNZ 0x00101440
LAB_00101481:
MOVQ XMM6,qword ptr [0x00102080]
MOVAPD XMM0,XMM2
PXOR XMM1,XMM1
MOVSD XMM8,qword ptr [0x00102070]
ANDPD XMM0,XMM6
COMISD XMM0,XMM8
JBE 0x001015a4
CMP EDI,0x1
JLE 0x001015b2
MOVSD XMM5,qword ptr [0x00102068]
MOV ESI,EDI
LEA R10,[RCX + 0x8]
MOVAPD XMM9,XMM1
NOP dword ptr [RAX]
LAB_001014c8:
MOVSD XMM4,qword ptr [R10]
MOV EDX,0x2
ADDSD XMM4,XMM9
CMP EDI,0x2
JZ 0x0010153d
LAB_001014dc:
MOV R9D,EDX
MOVAPD XMM0,XMM5
MOV EAX,0x2
MOV R8D,EDX
MULSD XMM0,XMM1
AND R9D,0x1
CMP EAX,EDX
JGE 0x0010151f
TEST R9D,R9D
JZ 0x00101510
MULSD XMM0,XMM1
MOV EAX,0x3
CMP EAX,EDX
JGE 0x0010151f
NOP dword ptr [RAX]
LAB_00101510:
MULSD XMM0,XMM1
ADD EAX,0x2
MULSD XMM0,XMM1
CMP EAX,EDX
JL 0x00101510
LAB_0010151f:
PXOR XMM3,XMM3
CVTSI2SD XMM3,R8D
MULSD XMM3,qword ptr [RCX + RDX*0x8]
ADD RDX,0x1
MULSD XMM0,XMM3
ADDSD XMM4,XMM0
CMP EDI,EDX
JG 0x001014dc
LAB_0010153d:
DIVSD XMM2,XMM4
MOV EDX,0x1
SUBSD XMM1,XMM2
MOVAPD XMM2,XMM7
NOP
LAB_00101550:
XOR EAX,EAX
MOVAPD XMM0,XMM5
TEST DL,0x1
JZ 0x00101570
MOV EAX,0x1
MOVAPD XMM0,XMM1
CMP EAX,EDX
JZ 0x0010157f
NOP dword ptr [RAX + RAX*0x1]
LAB_00101570:
MULSD XMM0,XMM1
ADD EAX,0x2
MULSD XMM0,XMM1
CMP EAX,EDX
JNZ 0x00101570
LAB_0010157f:
MULSD XMM0,qword ptr [RCX + RDX*0x8]
ADD RDX,0x1
ADDSD XMM2,XMM0
CMP RDX,RSI
JNZ 0x00101550
MOVAPD XMM0,XMM2
ANDPD XMM0,XMM6
COMISD XMM0,XMM8
JA 0x001014c8
LAB_001015a4:
MOVAPD XMM0,XMM1
RET
LAB_001015a9:
MOVAPD XMM2,XMM7
JMP 0x00101481
LAB_001015b2:
MOVAPD XMM0,XMM1
ANDPD XMM6,XMM7
JMP 0x001015c0
LAB_001015bc:
MOVAPD XMM2,XMM7
LAB_001015c0:
DIVSD XMM2,XMM0
COMISD XMM6,XMM8
SUBSD XMM1,XMM2
JA 0x001015bc
JMP 0x001015a4
|
double func0(double *param_1,uint param_2)
{
double *pdVar1;
double dVar2;
int iVar3;
int iVar4;
ulong uVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
dVar2 = *param_1;
dVar8 = dVar2;
if (1 < (int)param_2) {
uVar5 = 1;
do {
iVar3 = 0;
dVar6 = DAT_00102068;
if ((uVar5 & 1) == 0) {
LAB_00101460:
do {
iVar3 = iVar3 + 2;
dVar6 = dVar6 * 0.0 * 0.0;
} while (iVar3 != (int)uVar5);
}
else {
iVar3 = 1;
dVar6 = 0.0;
if ((int)uVar5 != 1) goto LAB_00101460;
}
pdVar1 = param_1 + uVar5;
uVar5 = uVar5 + 1;
dVar8 = dVar8 + dVar6 * *pdVar1;
} while (param_2 != uVar5);
}
dVar6 = 0.0;
if (DAT_00102070 < (double)((ulong)dVar8 & DAT_00102080)) {
if ((int)param_2 < 2) {
do {
dVar6 = dVar6 - dVar8 / 0.0;
dVar8 = dVar2;
} while (DAT_00102070 < (double)(DAT_00102080 & (ulong)dVar2));
}
else {
do {
uVar5 = 2;
dVar9 = param_1[1] + 0.0;
if (param_2 != 2) {
do {
iVar4 = (int)uVar5;
iVar3 = 2;
dVar7 = DAT_00102068 * dVar6;
if (2 < iVar4) {
if ((uVar5 & 1) != 0) {
dVar7 = dVar7 * dVar6;
iVar3 = 3;
if (iVar4 < 4) goto LAB_0010151f;
}
do {
iVar3 = iVar3 + 2;
dVar7 = dVar7 * dVar6 * dVar6;
} while (iVar3 < iVar4);
}
LAB_0010151f:
pdVar1 = param_1 + uVar5;
uVar5 = uVar5 + 1;
dVar9 = dVar9 + dVar7 * (double)iVar4 * *pdVar1;
} while ((int)uVar5 < (int)param_2);
}
uVar5 = 1;
dVar6 = dVar6 - dVar8 / dVar9;
dVar8 = dVar2;
do {
iVar3 = 0;
dVar9 = DAT_00102068;
if (((uVar5 & 1) == 0) || (iVar3 = 1, dVar9 = dVar6, (int)uVar5 != 1)) {
do {
iVar3 = iVar3 + 2;
dVar9 = dVar9 * dVar6 * dVar6;
} while (iVar3 != (int)uVar5);
}
pdVar1 = param_1 + uVar5;
uVar5 = uVar5 + 1;
dVar8 = dVar8 + dVar9 * *pdVar1;
} while (uVar5 != param_2);
} while (DAT_00102070 < (double)((ulong)dVar8 & DAT_00102080));
}
}
return dVar6;
}
|
788 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k < third_size; k++) {
if (third[k] < third[min_idx])
min_idx = k;
}
if (min_idx != i) {
int temp = third[i];
third[i] = third[min_idx];
third[min_idx] = temp;
}
}
for (i = 0; i < size; i++) {
if (i % 3 == 0) {
out[i] = third[i / 3];
} else {
out[i] = l[i];
}
}
free(third);
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
int result2[11];
func0(test2, 11, result2);
assert(issame(result2, result2, 11));
int test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
int result3[10];
func0(test3, 10, result3);
assert(issame(result3, result3, 10));
int test4[] = {5, 6, 3, 4, 8, 9, 2};
int correct4[] = {2, 6, 3, 4, 8, 9, 5};
int result4[7];
func0(test4, 7, result4);
assert(issame(result4, correct4, 7));
int test5[] = {5, 8, 3, 4, 6, 9, 2};
int correct5[] = {2, 8, 3, 4, 6, 9, 5};
int result5[7];
func0(test5, 7, result5);
assert(issame(result5, correct5, 7));
int test6[] = {5, 6, 9, 4, 8, 3, 2};
int correct6[] = {2, 6, 9, 4, 8, 3, 5};
int result6[7];
func0(test6, 7, result6);
assert(issame(result6, correct6, 7));
int test7[] = {5, 6, 3, 4, 8, 9, 2, 1};
int correct7[] = {2, 6, 3, 4, 8, 9, 5, 1};
int result7[8];
func0(test7, 8, result7);
assert(issame(result7, correct7, 8));
printf("All tests passed!\n");
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
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%esi
sub %eax,%esi
mov %esi,%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 1261 <func0+0x98>
mov -0x1c(%rbp),%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
cmp %eax,-0x2c(%rbp)
jg 1226 <func0+0x5d>
movl $0x0,-0x1c(%rbp)
jmpq 1339 <func0+0x170>
mov -0x1c(%rbp),%eax
mov %eax,-0x10(%rbp)
mov -0x1c(%rbp),%eax
add $0x1,%eax
mov %eax,-0x18(%rbp)
jmp 12c6 <func0+0xfd>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 12c2 <func0+0xf9>
mov -0x18(%rbp),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 128c <func0+0xc3>
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
je 1335 <func0+0x16c>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x14(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1c(%rbp)
jl 127b <func0+0xb2>
movl $0x0,-0x1c(%rbp)
jmpq 13f8 <func0+0x22f>
mov -0x1c(%rbp),%ecx
movslq %ecx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %rax,%rdx
mov %ecx,%eax
sar $0x1f,%eax
mov %edx,%edi
sub %eax,%edi
mov %edi,%eax
mov %eax,%edx
add %edx,%edx
add %eax,%edx
mov %ecx,%eax
sub %edx,%eax
test %eax,%eax
jne 13c7 <func0+0x1fe>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%esi
sub %eax,%esi
mov %esi,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
jmp 13f4 <func0+0x22b>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1354 <func0+0x18b>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1090 <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]
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
sar eax, 1Fh
sub edx, eax
lea eax, [rdx+1]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_1C], 0
jmp short loc_125D
loc_1222:
mov edx, [rbp+var_1C]
mov eax, edx
add eax, eax
add eax, edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_14], 1
add [rbp+var_1C], 1
loc_125D:
mov edx, [rbp+var_1C]
mov eax, edx
add eax, eax
add eax, edx
cmp [rbp+var_2C], eax
jg short loc_1222
mov [rbp+var_1C], 0
jmp loc_1335
loc_1277:
mov eax, [rbp+var_1C]
mov [rbp+var_10], eax
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_18], eax
jmp short loc_12C2
loc_1288:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_12BE
mov eax, [rbp+var_18]
mov [rbp+var_10], eax
loc_12BE:
add [rbp+var_18], 1
loc_12C2:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jl short loc_1288
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jz short loc_1331
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
loc_1331:
add [rbp+var_1C], 1
loc_1335:
mov eax, [rbp+var_14]
sub eax, 1
cmp [rbp+var_1C], eax
jl loc_1277
mov [rbp+var_1C], 0
jmp loc_13ED
loc_1350:
mov ecx, [rbp+var_1C]
movsxd rax, ecx
imul rax, 55555556h
shr rax, 20h
mov rdx, rax
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
add eax, eax
add eax, edx
sub ecx, eax
mov edx, ecx
test edx, edx
jnz short loc_13BC
mov eax, [rbp+var_1C]
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
sar eax, 1Fh
sub edx, eax
movsxd rax, edx
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_38]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
jmp short loc_13E9
loc_13BC:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_38]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
loc_13E9:
add [rbp+var_1C], 1
loc_13ED:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jl loc_1350
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
int i; // [rsp+24h] [rbp-1Ch]
int j; // [rsp+24h] [rbp-1Ch]
int m; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int v9; // [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 / 3 + 1));
v9 = 0;
for ( i = 0; a2 > 3 * i; ++i )
{
ptr[i] = *(_DWORD *)(12LL * i + a1);
++v9;
}
for ( j = 0; j < v9 - 1; ++j )
{
v10 = j;
for ( k = j + 1; k < v9; ++k )
{
if ( ptr[k] < ptr[v10] )
v10 = k;
}
if ( v10 != j )
{
v11 = ptr[j];
ptr[j] = ptr[v10];
ptr[v10] = v11;
}
}
for ( m = 0; m < a2; ++m )
{
if ( m % 3 )
v3 = *(_DWORD *)(4LL * m + a1);
else
v3 = ptr[m / 3];
*(_DWORD *)(4LL * m + a3) = v3;
}
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]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
SAR EAX,0x1f
SUB EDX,EAX
LEA EAX,[RDX + 0x1]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010125d
LAB_00101222:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
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
ADD dword ptr [RBP + -0x14],0x1
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010125d:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
CMP dword ptr [RBP + -0x2c],EAX
JG 0x00101222
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101335
LAB_00101277:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x001012c2
LAB_00101288:
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 + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001012be
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x10],EAX
LAB_001012be:
ADD dword ptr [RBP + -0x18],0x1
LAB_001012c2:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101288
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JZ 0x00101331
MOV EAX,dword ptr [RBP + -0x1c]
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 + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
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 + -0x10]
CDQE
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_00101331:
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101335:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JL 0x00101277
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001013ed
LAB_00101350:
MOV ECX,dword ptr [RBP + -0x1c]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV RDX,RAX
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
TEST EDX,EDX
JNZ 0x001013bc
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
SAR EAX,0x1f
SUB EDX,EAX
MOVSXD RAX,EDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
JMP 0x001013e9
LAB_001013bc:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
LAB_001013e9:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001013ed:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101350
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101090
NOP
LEAVE
RET
|
void func0(long param_1,int param_2,long param_3)
{
int4 uVar1;
void *__ptr;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
__ptr = malloc((long)(param_2 / 3 + 1) << 2);
local_1c = 0;
for (local_24 = 0; local_24 * 3 < param_2; local_24 = local_24 + 1) {
*(int4 *)((long)__ptr + (long)local_24 * 4) =
*(int4 *)(param_1 + (long)(local_24 * 3) * 4);
local_1c = local_1c + 1;
}
for (local_24 = 0; local_24 < local_1c + -1; local_24 = local_24 + 1) {
local_18 = local_24;
local_20 = local_24;
while (local_20 = local_20 + 1, local_20 < local_1c) {
if (*(int *)((long)__ptr + (long)local_20 * 4) < *(int *)((long)__ptr + (long)local_18 * 4)) {
local_18 = local_20;
}
}
if (local_18 != local_24) {
uVar1 = *(int4 *)((long)__ptr + (long)local_24 * 4);
*(int4 *)((long)__ptr + (long)local_24 * 4) =
*(int4 *)((long)__ptr + (long)local_18 * 4);
*(int4 *)((long)local_18 * 4 + (long)__ptr) = uVar1;
}
}
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
if (local_24 % 3 == 0) {
*(int4 *)(param_3 + (long)local_24 * 4) =
*(int4 *)((long)__ptr + (long)(local_24 / 3) * 4);
}
else {
*(int4 *)(param_3 + (long)local_24 * 4) = *(int4 *)(param_1 + (long)local_24 * 4);
}
}
free(__ptr);
return;
}
|
789 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k < third_size; k++) {
if (third[k] < third[min_idx])
min_idx = k;
}
if (min_idx != i) {
int temp = third[i];
third[i] = third[min_idx];
third[min_idx] = temp;
}
}
for (i = 0; i < size; i++) {
if (i % 3 == 0) {
out[i] = third[i / 3];
} else {
out[i] = l[i];
}
}
free(third);
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
int result2[11];
func0(test2, 11, result2);
assert(issame(result2, result2, 11));
int test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
int result3[10];
func0(test3, 10, result3);
assert(issame(result3, result3, 10));
int test4[] = {5, 6, 3, 4, 8, 9, 2};
int correct4[] = {2, 6, 3, 4, 8, 9, 5};
int result4[7];
func0(test4, 7, result4);
assert(issame(result4, correct4, 7));
int test5[] = {5, 8, 3, 4, 6, 9, 2};
int correct5[] = {2, 8, 3, 4, 6, 9, 5};
int result5[7];
func0(test5, 7, result5);
assert(issame(result5, correct5, 7));
int test6[] = {5, 6, 9, 4, 8, 3, 2};
int correct6[] = {2, 6, 9, 4, 8, 3, 5};
int result6[7];
func0(test6, 7, result6);
assert(issame(result6, correct6, 7));
int test7[] = {5, 6, 3, 4, 8, 9, 2, 1};
int correct7[] = {2, 6, 3, 4, 8, 9, 5, 1};
int result7[8];
func0(test7, 8, result7);
assert(issame(result7, correct7, 8));
printf("All tests passed!\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
mov %rdx,%r12
movslq %esi,%rdi
imul $0x55555556,%rdi,%rdi
shr $0x20,%rdi
mov %esi,%eax
sar $0x1f,%eax
sub %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rdi
test %ebp,%ebp
jle 12eb <func0+0x122>
mov $0x0,%edx
mov $0x0,%eax
mov %eax,%r10d
mov (%rbx,%rdx,4),%ecx
mov %ecx,(%rdi,%rax,4)
mov %rax,%r9
add $0x1,%rax
add $0x3,%rdx
cmp %edx,%ebp
jg 1218 <func0+0x4f>
test %r10d,%r10d
jle 12fb <func0+0x132>
sub $0x1,%r9d
mov %r9d,%r11d
mov $0x0,%esi
jmp 1257 <func0+0x8e>
lea 0x1(%rsi),%rax
cmp %r11,%rsi
je 12fb <func0+0x132>
mov %rax,%rsi
mov %esi,%ecx
mov %esi,%r13d
cmp %r10d,%esi
jge 1247 <func0+0x7e>
lea 0x1(%rsi),%rdx
mov %r9d,%eax
sub %esi,%eax
lea 0x2(%rsi,%rax,1),%r8
movslq %ecx,%rax
mov (%rdi,%rax,4),%eax
cmp %eax,(%rdi,%rdx,4)
cmovl %edx,%ecx
add $0x1,%rdx
cmp %r8,%rdx
jne 126f <func0+0xa6>
cmp %r13d,%ecx
je 1247 <func0+0x7e>
mov (%rdi,%rsi,4),%edx
movslq %ecx,%rcx
lea (%rdi,%rcx,4),%rax
mov (%rax),%ecx
mov %ecx,(%rdi,%rsi,4)
mov %edx,(%rax)
jmp 1247 <func0+0x7e>
mov (%rbx,%rdx,4),%eax
mov %eax,(%r12,%rdx,4)
lea 0x1(%rdx),%rax
cmp %rcx,%rdx
je 12eb <func0+0x122>
mov %rax,%rdx
movslq %edx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %edx,%esi
sar $0x1f,%esi
sub %esi,%eax
lea (%rax,%rax,2),%eax
cmp %edx,%eax
jne 129c <func0+0xd3>
movslq %edx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %edx,%esi
sar $0x1f,%esi
sub %esi,%eax
cltq
mov (%rdi,%rax,4),%eax
mov %eax,(%r12,%rdx,4)
jmp 12a3 <func0+0xda>
callq 1090 <free@plt>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
lea -0x1(%rbp),%ecx
mov $0x0,%edx
jmp 12af <func0+0xe6>
|
func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
mov r12, rdx
movsxd rdi, esi
imul rdi, 55555556h
shr rdi, 20h
mov eax, esi
sar eax, 1Fh
sub edi, eax
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_12DB
mov rcx, rax
mov eax, 0
mov edx, 0
loc_1215:
mov esi, [rbp+rax*4+0]
mov [rcx], esi
mov r9d, edx
add edx, 1
add rax, 3
add rcx, 4
cmp ebx, eax
jg short loc_1215
cmp edx, 1
jle loc_12E5
mov r8d, 0
jmp short loc_124B
loc_123E:
add r8, 1
cmp r9d, r8d
jle loc_12E5
loc_124B:
mov edx, r8d
mov r10d, r8d
cmp r8d, r9d
jge short loc_123E
lea rax, [r8+1]
mov esi, r9d
sub esi, r8d
add rsi, rax
loc_1263:
movsxd rcx, edx
mov ecx, [rdi+rcx*4]
cmp [rdi+rax*4], ecx
cmovl edx, eax
add rax, 1
cmp rax, rsi
jnz short loc_1263
cmp edx, r10d
jz short loc_123E
mov ecx, [rdi+r8*4]
movsxd rdx, edx
lea rax, [rdi+rdx*4]
mov edx, [rax]
mov [rdi+r8*4], edx
mov [rax], ecx
jmp short loc_123E
loc_1292:
mov eax, [rbp+rdx*4+0]
loc_1296:
mov [r12+rdx*4], eax
add rdx, 1
cmp rbx, rdx
jz short loc_12DB
loc_12A3:
movsxd rax, edx
imul rax, 55555556h
shr rax, 20h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
lea eax, [rax+rax*2]
cmp eax, edx
jnz short loc_1292
movsxd rax, edx
imul rax, 55555556h
shr rax, 20h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
cdqe
mov eax, [rdi+rax*4]
jmp short loc_1296
loc_12DB:
call _free
pop rbx
pop rbp
pop r12
retn
loc_12E5:
movsxd rbx, ebx
mov edx, 0
jmp short loc_12A3
|
void func0(long long a1, int a2, long long a3)
{
_DWORD *v5; // rax
_DWORD *v6; // rdi
_DWORD *v7; // rcx
long long v8; // rax
int v9; // edx
int v10; // r9d
long long v11; // r8
int v12; // edx
long long v13; // rax
int v14; // ecx
_DWORD *v15; // rax
int v16; // eax
long long i; // rdx
v5 = malloc(4LL * (a2 / 3 + 1));
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = 0LL;
v9 = 0;
do
{
*v7 = *(_DWORD *)(a1 + 4 * v8);
v10 = v9++;
v8 += 3LL;
++v7;
}
while ( a2 > (int)v8 );
if ( v9 > 1 )
{
v11 = 0LL;
do
{
v12 = v11;
if ( (int)v11 < v10 )
{
v13 = v11 + 1;
do
{
if ( v6[v13] < v6[v12] )
v12 = v13;
++v13;
}
while ( v13 != v11 + 1 + (unsigned int)(v10 - v11) );
if ( v12 != (_DWORD)v11 )
{
v14 = v6[v11];
v15 = &v6[v12];
v6[v11] = *v15;
*v15 = v14;
}
}
++v11;
}
while ( v10 > (int)v11 );
}
for ( i = 0LL; i != a2; *(_DWORD *)(a3 + 4 * i++) = v16 )
{
if ( 3 * ((int)i / 3) == (_DWORD)i )
v16 = v6[(int)i / 3];
else
v16 = *(_DWORD *)(a1 + 4 * i);
}
}
free(v6);
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
MOV R12,RDX
MOVSXD RDI,ESI
IMUL RDI,RDI,0x55555556
SHR RDI,0x20
MOV EAX,ESI
SAR EAX,0x1f
SUB EDI,EAX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x001012db
MOV RCX,RAX
MOV EAX,0x0
MOV EDX,0x0
LAB_00101215:
MOV ESI,dword ptr [RBP + RAX*0x4]
MOV dword ptr [RCX],ESI
MOV R9D,EDX
ADD EDX,0x1
ADD RAX,0x3
ADD RCX,0x4
CMP EBX,EAX
JG 0x00101215
CMP EDX,0x1
JLE 0x001012e5
MOV R8D,0x0
JMP 0x0010124b
LAB_0010123e:
ADD R8,0x1
CMP R9D,R8D
JLE 0x001012e5
LAB_0010124b:
MOV EDX,R8D
MOV R10D,R8D
CMP R8D,R9D
JGE 0x0010123e
LEA RAX,[R8 + 0x1]
MOV ESI,R9D
SUB ESI,R8D
ADD RSI,RAX
LAB_00101263:
MOVSXD RCX,EDX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
CMOVL EDX,EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101263
CMP EDX,R10D
JZ 0x0010123e
MOV ECX,dword ptr [RDI + R8*0x4]
MOVSXD RDX,EDX
LEA RAX,[RDI + RDX*0x4]
MOV EDX,dword ptr [RAX]
MOV dword ptr [RDI + R8*0x4],EDX
MOV dword ptr [RAX],ECX
JMP 0x0010123e
LAB_00101292:
MOV EAX,dword ptr [RBP + RDX*0x4]
LAB_00101296:
MOV dword ptr [R12 + RDX*0x4],EAX
ADD RDX,0x1
CMP RBX,RDX
JZ 0x001012db
LAB_001012a3:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA EAX,[RAX + RAX*0x2]
CMP EAX,EDX
JNZ 0x00101292
MOVSXD RAX,EDX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
CDQE
MOV EAX,dword ptr [RDI + RAX*0x4]
JMP 0x00101296
LAB_001012db:
CALL 0x00101090
POP RBX
POP RBP
POP R12
RET
LAB_001012e5:
MOVSXD RBX,EBX
MOV EDX,0x0
JMP 0x001012a3
|
void func0(long param_1,int param_2,long param_3)
{
int4 uVar1;
int4 *__ptr;
long lVar2;
ulong uVar3;
int4 *puVar4;
int iVar5;
int iVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
__ptr = (int4 *)malloc((long)(param_2 / 3 + 1) << 2);
if (0 < param_2) {
lVar2 = 0;
puVar4 = __ptr;
iVar6 = 0;
do {
iVar5 = iVar6;
*puVar4 = *(int4 *)(param_1 + lVar2 * 4);
lVar2 = lVar2 + 3;
puVar4 = puVar4 + 1;
iVar6 = iVar5 + 1;
} while ((int)lVar2 < param_2);
if (1 < iVar5 + 1) {
uVar9 = 0;
do {
iVar6 = (int)uVar9;
uVar7 = uVar9 & 0xffffffff;
if (iVar6 < iVar5) {
uVar3 = uVar9 + 1;
uVar8 = (uint)(iVar5 - iVar6) + uVar3;
do {
if ((int)__ptr[uVar3] < (int)__ptr[(int)uVar7]) {
uVar7 = uVar3 & 0xffffffff;
}
uVar3 = uVar3 + 1;
} while (uVar3 != uVar8);
if ((int)uVar7 != iVar6) {
uVar1 = __ptr[uVar9];
__ptr[uVar9] = __ptr[(int)uVar7];
__ptr[(int)uVar7] = uVar1;
}
}
uVar9 = uVar9 + 1;
} while ((int)uVar9 < iVar5);
}
lVar2 = 0;
do {
iVar6 = (int)lVar2;
if ((iVar6 / 3) * 3 == iVar6) {
uVar1 = __ptr[iVar6 / 3];
}
else {
uVar1 = *(int4 *)(param_1 + lVar2 * 4);
}
*(int4 *)(param_3 + lVar2 * 4) = uVar1;
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
}
free(__ptr);
return;
}
|
790 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k < third_size; k++) {
if (third[k] < third[min_idx])
min_idx = k;
}
if (min_idx != i) {
int temp = third[i];
third[i] = third[min_idx];
third[min_idx] = temp;
}
}
for (i = 0; i < size; i++) {
if (i % 3 == 0) {
out[i] = third[i / 3];
} else {
out[i] = l[i];
}
}
free(third);
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
int result2[11];
func0(test2, 11, result2);
assert(issame(result2, result2, 11));
int test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
int result3[10];
func0(test3, 10, result3);
assert(issame(result3, result3, 10));
int test4[] = {5, 6, 3, 4, 8, 9, 2};
int correct4[] = {2, 6, 3, 4, 8, 9, 5};
int result4[7];
func0(test4, 7, result4);
assert(issame(result4, correct4, 7));
int test5[] = {5, 8, 3, 4, 6, 9, 2};
int correct5[] = {2, 8, 3, 4, 6, 9, 5};
int result5[7];
func0(test5, 7, result5);
assert(issame(result5, correct5, 7));
int test6[] = {5, 6, 9, 4, 8, 3, 2};
int correct6[] = {2, 6, 9, 4, 8, 3, 5};
int result6[7];
func0(test6, 7, result6);
assert(issame(result6, correct6, 7));
int test7[] = {5, 6, 3, 4, 8, 9, 2, 1};
int correct7[] = {2, 6, 3, 4, 8, 9, 5, 1};
int result7[8];
func0(test7, 8, result7);
assert(issame(result7, correct7, 8));
printf("All tests passed!\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
imul $0x55555556,%rdi,%rdi
mov %r12d,%eax
sar $0x1f,%eax
shr $0x20,%rdi
sub %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 1750 <func0+0xe0>
xor %ecx,%ecx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rbx,%rcx,4),%edx
add $0x3,%rcx
mov %eax,%r11d
mov %edx,(%r8,%rax,4)
add $0x1,%rax
cmp %ecx,%r12d
jg 16c0 <func0+0x50>
test %r11d,%r11d
je 1760 <func0+0xf0>
lea -0x1(%r11),%r13d
xor %r9d,%r9d
mov %r13,%rsi
nopw 0x0(%rax,%rax,1)
mov %r9d,%edi
mov %r9d,%r14d
lea 0x1(%r9),%rdx
cmp %r9d,%r11d
jle 173f <func0+0xcf>
mov %esi,%eax
mov %rdx,%rcx
sub %r9d,%eax
lea 0x2(%r9,%rax,1),%r10
nopl 0x0(%rax)
movslq %edi,%rax
mov (%r8,%rax,4),%eax
cmp %eax,(%r8,%rcx,4)
cmovl %ecx,%edi
add $0x1,%rcx
cmp %r10,%rcx
jne 1710 <func0+0xa0>
cmp %r14d,%edi
je 173f <func0+0xcf>
movslq %edi,%rdi
mov (%r8,%r9,4),%ecx
lea (%r8,%rdi,4),%rax
mov (%rax),%edi
mov %edi,(%r8,%r9,4)
mov %ecx,(%rax)
cmp %r9,%r13
je 1760 <func0+0xf0>
mov %rdx,%r9
jmp 16f0 <func0+0x80>
nopl 0x0(%rax)
pop %rbx
mov %r8,%rdi
pop %rbp
pop %r12
pop %r13
pop %r14
jmpq 1090 <free@plt>
lea -0x1(%r12),%esi
xor %eax,%eax
mov $0xaaaaaaab,%edi
jmp 178e <func0+0x11e>
xchg %ax,%ax
mov %eax,%ecx
imul %rdi,%rcx
shr $0x21,%rcx
mov (%r8,%rcx,4),%edx
mov %edx,0x0(%rbp,%rax,4)
lea 0x1(%rax),%rdx
cmp %rax,%rsi
je 1750 <func0+0xe0>
mov %rdx,%rax
imul $0xaaaaaaab,%eax,%edx
cmp $0x55555555,%edx
jbe 1770 <func0+0x100>
mov (%rbx,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
jmp 1782 <func0+0x112>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov eax, r12d
mov rbp, rdx
push rbx
mov rbx, rdi
imul rdi, r12, 55555556h
sar eax, 1Fh
shr rdi, 20h
sub rsp, 8
sub edi, eax
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test r12d, r12d
jle loc_1698
mov rdx, rax
mov r13, r12
xor eax, eax
xor ecx, ecx
nop
loc_15D0:
mov esi, [rbx+rax*4]
add rax, 3
mov r9d, ecx
add rdx, 4
lea ecx, [rcx+1]
mov [rdx-4], esi
cmp r13d, eax
jg short loc_15D0
xor r8d, r8d
cmp ecx, 1
jz short loc_164F
nop dword ptr [rax+00000000h]
loc_15F8:
mov edx, r8d
mov r11d, r8d
lea r10, [r8+1]
cmp r8d, r9d
jge short loc_1647
mov esi, r9d
mov rax, r10
sub esi, r8d
add rsi, r10
nop dword ptr [rax+rax+00h]
loc_1618:
movsxd rcx, edx
mov r13d, [rdi+rax*4]
cmp [rdi+rcx*4], r13d
cmovg edx, eax
add rax, 1
cmp rax, rsi
jnz short loc_1618
cmp edx, r11d
jz short loc_1647
movsxd rdx, edx
mov ecx, [rdi+r8*4]
lea rax, [rdi+rdx*4]
mov edx, [rax]
mov [rdi+r8*4], edx
mov [rax], ecx
loc_1647:
mov r8, r10
cmp r9d, r10d
jg short loc_15F8
loc_164F:
xor eax, eax
mov ecx, 0AAAAAAABh
jmp short loc_167A
loc_1660:
mov edx, eax
imul rdx, rcx
shr rdx, 21h
mov edx, [rdi+rdx*4]
mov [rbp+rax*4+0], edx
add rax, 1
cmp r12, rax
jz short loc_1698
loc_167A:
imul edx, eax, 0AAAAAAABh
cmp edx, 55555555h
jbe short loc_1660
mov edx, [rbx+rax*4]
mov [rbp+rax*4+0], edx
add rax, 1
cmp r12, rax
jnz short loc_167A
loc_1698:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
jmp _free
|
void func0(long long a1, int a2, long long a3)
{
long long v3; // r12
_DWORD *v6; // rax
_DWORD *v7; // rdi
_DWORD *v8; // rdx
long long v9; // rax
int v10; // ecx
int v11; // esi
int v12; // r9d
long long v13; // r8
int v14; // edx
long long v15; // r10
long long v16; // rax
int v17; // ecx
_DWORD *v18; // rax
long long v19; // rax
v3 = a2;
v6 = malloc(4LL * (a2 / 3 + 1));
v7 = v6;
if ( a2 > 0 )
{
v8 = v6;
v9 = 0LL;
v10 = 0;
do
{
v11 = *(_DWORD *)(a1 + 4 * v9);
v9 += 3LL;
v12 = v10;
++v8;
++v10;
*(v8 - 1) = v11;
}
while ( (int)v3 > (int)v9 );
v13 = 0LL;
if ( v10 != 1 )
{
do
{
v14 = v13;
v15 = v13 + 1;
if ( (int)v13 < v12 )
{
v16 = v13 + 1;
do
{
if ( v7[v14] > v7[v16] )
v14 = v16;
++v16;
}
while ( v16 != v15 + (unsigned int)(v12 - v13) );
if ( v14 != (_DWORD)v13 )
{
v17 = v7[v13];
v18 = &v7[v14];
v7[v13] = *v18;
*v18 = v17;
}
}
++v13;
}
while ( v12 > (int)v15 );
}
v19 = 0LL;
do
{
while ( (unsigned int)(-1431655765 * v19) <= 0x55555555 )
{
*(_DWORD *)(a3 + 4 * v19) = v7[(unsigned int)v19 / 3uLL];
if ( v3 == ++v19 )
goto LABEL_17;
}
*(_DWORD *)(a3 + 4 * v19) = *(_DWORD *)(a1 + 4 * v19);
++v19;
}
while ( v3 != v19 );
}
LABEL_17:
free(v7);
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV EAX,R12D
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
IMUL RDI,R12,0x55555556
SAR EAX,0x1f
SHR RDI,0x20
SUB RSP,0x8
SUB EDI,EAX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST R12D,R12D
JLE 0x00101698
MOV RDX,RAX
MOV R13,R12
XOR EAX,EAX
XOR ECX,ECX
NOP
LAB_001015d0:
MOV ESI,dword ptr [RBX + RAX*0x4]
ADD RAX,0x3
MOV R9D,ECX
ADD RDX,0x4
LEA ECX,[RCX + 0x1]
MOV dword ptr [RDX + -0x4],ESI
CMP R13D,EAX
JG 0x001015d0
XOR R8D,R8D
CMP ECX,0x1
JZ 0x0010164f
NOP dword ptr [RAX]
LAB_001015f8:
MOV EDX,R8D
MOV R11D,R8D
LEA R10,[R8 + 0x1]
CMP R8D,R9D
JGE 0x00101647
MOV ESI,R9D
MOV RAX,R10
SUB ESI,R8D
ADD RSI,R10
NOP dword ptr [RAX + RAX*0x1]
LAB_00101618:
MOVSXD RCX,EDX
MOV R13D,dword ptr [RDI + RAX*0x4]
CMP dword ptr [RDI + RCX*0x4],R13D
CMOVG EDX,EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101618
CMP EDX,R11D
JZ 0x00101647
MOVSXD RDX,EDX
MOV ECX,dword ptr [RDI + R8*0x4]
LEA RAX,[RDI + RDX*0x4]
MOV EDX,dword ptr [RAX]
MOV dword ptr [RDI + R8*0x4],EDX
MOV dword ptr [RAX],ECX
LAB_00101647:
MOV R8,R10
CMP R9D,R10D
JG 0x001015f8
LAB_0010164f:
XOR EAX,EAX
MOV ECX,0xaaaaaaab
JMP 0x0010167a
LAB_00101660:
MOV EDX,EAX
IMUL RDX,RCX
SHR RDX,0x21
MOV EDX,dword ptr [RDI + RDX*0x4]
MOV dword ptr [RBP + RAX*0x4],EDX
ADD RAX,0x1
CMP R12,RAX
JZ 0x00101698
LAB_0010167a:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
JBE 0x00101660
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV dword ptr [RBP + RAX*0x4],EDX
ADD RAX,0x1
CMP R12,RAX
JNZ 0x0010167a
LAB_00101698:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
JMP 0x00101090
|
void func0(long param_1,int param_2,long param_3)
{
ulong uVar1;
long lVar2;
int4 uVar3;
int4 *__ptr;
long lVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
int4 *puVar8;
ulong uVar9;
int iVar10;
__ptr = (int4 *)malloc((long)(param_2 / 3 + 1) << 2);
if (0 < param_2) {
lVar4 = 0;
puVar8 = __ptr;
iVar10 = 0;
do {
iVar7 = iVar10;
lVar2 = lVar4 * 4;
lVar4 = lVar4 + 3;
*puVar8 = *(int4 *)(param_1 + lVar2);
puVar8 = puVar8 + 1;
iVar10 = iVar7 + 1;
} while ((int)lVar4 < param_2);
uVar6 = 0;
if (iVar7 + 1 != 1) {
do {
iVar10 = (int)uVar6;
uVar9 = uVar6 & 0xffffffff;
uVar1 = uVar6 + 1;
if (iVar10 < iVar7) {
uVar5 = uVar1;
do {
if ((int)__ptr[uVar5] < (int)__ptr[(int)uVar9]) {
uVar9 = uVar5 & 0xffffffff;
}
uVar5 = uVar5 + 1;
} while (uVar5 != (uint)(iVar7 - iVar10) + uVar1);
if ((int)uVar9 != iVar10) {
uVar3 = __ptr[uVar6];
__ptr[uVar6] = __ptr[(int)uVar9];
__ptr[(int)uVar9] = uVar3;
}
}
uVar6 = uVar1;
} while ((int)uVar1 < iVar7);
}
uVar6 = 0;
do {
while (0x55555555 < (uint)((int)uVar6 * -0x55555555)) {
*(int4 *)(param_3 + uVar6 * 4) = *(int4 *)(param_1 + uVar6 * 4);
uVar6 = uVar6 + 1;
if ((long)param_2 == uVar6) goto LAB_00101698;
}
*(int4 *)(param_3 + uVar6 * 4) = __ptr[(uVar6 & 0xffffffff) / 3];
uVar6 = uVar6 + 1;
} while ((long)param_2 != uVar6);
}
LAB_00101698:
free(__ptr);
return;
}
|
791 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k < third_size; k++) {
if (third[k] < third[min_idx])
min_idx = k;
}
if (min_idx != i) {
int temp = third[i];
third[i] = third[min_idx];
third[min_idx] = temp;
}
}
for (i = 0; i < size; i++) {
if (i % 3 == 0) {
out[i] = third[i / 3];
} else {
out[i] = l[i];
}
}
free(third);
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int test2[] = {5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10};
int result2[11];
func0(test2, 11, result2);
assert(issame(result2, result2, 11));
int test3[] = {5, 8, -12, 4, 23, 2, 3, 11, 12, -10};
int result3[10];
func0(test3, 10, result3);
assert(issame(result3, result3, 10));
int test4[] = {5, 6, 3, 4, 8, 9, 2};
int correct4[] = {2, 6, 3, 4, 8, 9, 5};
int result4[7];
func0(test4, 7, result4);
assert(issame(result4, correct4, 7));
int test5[] = {5, 8, 3, 4, 6, 9, 2};
int correct5[] = {2, 8, 3, 4, 6, 9, 5};
int result5[7];
func0(test5, 7, result5);
assert(issame(result5, correct5, 7));
int test6[] = {5, 6, 9, 4, 8, 3, 2};
int correct6[] = {2, 6, 9, 4, 8, 3, 5};
int result6[7];
func0(test6, 7, result6);
assert(issame(result6, correct6, 7));
int test7[] = {5, 6, 3, 4, 8, 9, 2, 1};
int correct7[] = {2, 6, 3, 4, 8, 9, 5, 1};
int result7[8];
func0(test7, 8, result7);
assert(issame(result7, correct7, 8));
printf("All tests passed!\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
imul $0x55555556,%rdi,%rdi
mov %r12d,%eax
sar $0x1f,%eax
sub $0x8,%rsp
shr $0x20,%rdi
sub %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbp
test %r12d,%r12d
jle 18b6 <func0+0x1e6>
lea -0x1(%r12),%esi
mov $0xaaaaaaab,%eax
mov %rsi,%r15
imul %rax,%rsi
shr $0x21,%rsi
add $0x1,%esi
cmp $0x8,%r15d
jbe 18e0 <func0+0x210>
mov %esi,%ecx
movdqa 0x998(%rip),%xmm2
mov %rbx,%rax
mov %rbp,%rdx
shr $0x2,%ecx
movdqa 0x997(%rip),%xmm4
shl $0x4,%rcx
add %rbp,%rcx
movd (%rax),%xmm0
add $0x10,%rdx
movdqa %xmm2,%xmm3
add $0x30,%rax
movd -0x18(%rax),%xmm1
movd -0xc(%rax),%xmm5
paddd %xmm4,%xmm2
movd -0x24(%rax),%xmm6
punpckldq %xmm5,%xmm1
punpckldq %xmm6,%xmm0
punpcklqdq %xmm1,%xmm0
movups %xmm0,-0x10(%rdx)
cmp %rcx,%rdx
jne 1760 <func0+0x90>
mov %esi,%edx
pshufd $0xff,%xmm3,%xmm3
and $0xfffffffc,%edx
movd %xmm3,%r10d
lea (%rdx,%rdx,2),%eax
cmp %esi,%edx
je 18cf <func0+0x1ff>
cltq
movslq %edx,%rcx
mov (%rbx,%rax,4),%eax
mov %eax,0x0(%rbp,%rcx,4)
lea 0x1(%rdx),%ecx
lea (%rcx,%rcx,2),%eax
cmp %eax,%r12d
jle 18cc <func0+0x1fc>
movslq %eax,%rdi
movslq %ecx,%rsi
lea 0x2(%rdx),%r10d
add $0x3,%eax
mov (%rbx,%rdi,4),%edi
mov %edi,0x0(%rbp,%rsi,4)
cmp %r12d,%eax
jge 18e9 <func0+0x219>
cltq
movslq %r10d,%rdx
mov (%rbx,%rax,4),%eax
mov %eax,0x0(%rbp,%rdx,4)
lea 0x4(%rbp),%rdx
xor %eax,%eax
nopl 0x0(%rax)
mov -0x4(%rdx),%r14d
mov %eax,%r12d
add $0x1,%eax
mov %rdx,%rcx
mov %r12d,%r11d
mov %eax,%esi
mov %r14d,%r8d
jmp 1836 <func0+0x166>
nopw 0x0(%rax,%rax,1)
movslq %r11d,%rdi
add $0x4,%rcx
lea 0x0(%rbp,%rdi,4),%r9
lea 0x1(%rsi),%edi
cmp %r10d,%esi
jge 1852 <func0+0x182>
mov %edi,%esi
mov (%rcx),%edi
mov %rcx,%r9
cmp %edi,%r8d
jle 1820 <func0+0x150>
mov %edi,%r8d
mov %esi,%r11d
lea 0x1(%rsi),%edi
add $0x4,%rcx
cmp %r10d,%esi
jl 1834 <func0+0x164>
cmp %r12d,%r11d
je 185e <func0+0x18e>
mov %r8d,-0x4(%rdx)
mov %r14d,(%r9)
add $0x4,%rdx
cmp %r10d,%eax
jne 1800 <func0+0x130>
mov %r15d,%r15d
xor %eax,%eax
mov $0xaaaaaaab,%ecx
jmp 1897 <func0+0x1c7>
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %rcx,%rdx
shr $0x21,%rdx
mov 0x0(%rbp,%rdx,4),%edx
mov %edx,0x0(%r13,%rax,4)
lea 0x1(%rax),%rdx
cmp %rax,%r15
je 18b6 <func0+0x1e6>
mov %rdx,%rax
imul $0xaaaaaaab,%eax,%edx
cmp $0x55555555,%edx
jbe 1878 <func0+0x1a8>
mov (%rbx,%rax,4),%edx
mov %edx,0x0(%r13,%rax,4)
lea 0x1(%rax),%rdx
cmp %rax,%r15
jne 1894 <func0+0x1c4>
add $0x8,%rsp
mov %rbp,%rdi
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
jmpq 1090 <free@plt>
mov %edx,%r10d
test %r10d,%r10d
jg 17f6 <func0+0x126>
jmp 1867 <func0+0x197>
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
xor %eax,%eax
jmpq 17b2 <func0+0xe2>
mov %ecx,%r10d
jmpq 17f6 <func0+0x126>
data16 nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
push r15
push r14
push r13
movsxd r13, esi
push r12
mov eax, r13d
mov r12, rdx
push rbp
mov rbp, rdi
imul rdi, r13, 55555556h
sar eax, 1Fh
push rbx
shr rdi, 20h
sub edi, eax
sub rsp, 8
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov r10, rax
test r13d, r13d
jle loc_1789
lea eax, [r13-1]
mov ecx, 0AAAAAAABh
mov rbx, r13
mov rdx, rax
imul rax, rcx
mov rcx, rax
shr rax, 21h
shr rcx, 20h
mov rsi, rax
cmp edx, 0Bh
jbe loc_17C8
shr rcx, 3
mov rax, rbp
mov rdx, r10
shl rcx, 4
add rcx, r10
nop dword ptr [rax+00h]
loc_1648:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
add rdx, 10h
add rax, 30h ; '0'
movdqa xmm0, xmm2
shufps xmm1, xmm2, 0Ah
shufps xmm0, xmm1, 8Ch
movdqu xmm1, xmmword ptr [rax-10h]
shufps xmm1, xmm0, 0A5h
shufps xmm0, xmm1, 24h ; '$'
movups xmmword ptr [rdx-10h], xmm0
cmp rdx, rcx
jnz short loc_1648
mov eax, esi
and eax, 0FFFFFFFCh
lea edx, [rax+rax*2]
loc_1683:
movsxd rdx, edx
movsxd rsi, eax
lea r9d, [rax+1]
mov edx, [rbp+rdx*4+0]
lea rcx, ds:0[rsi*4]
mov [r10+rsi*4], edx
lea edx, [r9+r9*2]
cmp ebx, edx
jle loc_17B3
movsxd rsi, edx
lea rdi, ds:0[rsi*4]
mov esi, [rbp+rsi*4+0]
mov [r10+rcx+4], esi
lea esi, [rdx+3]
cmp ebx, esi
jle short loc_16E5
mov esi, [rbp+rdi+0Ch]
add edx, 6
lea r9d, [rax+3]
mov [r10+rcx+8], esi
cmp edx, ebx
jge loc_17D1
mov eax, [rbp+rdi+18h]
mov [r10+rcx+0Ch], eax
loc_16E5:
lea rbx, [r10+4]
xor r11d, r11d
nop dword ptr [rax+00h]
loc_16F0:
mov r15d, [rbx-4]
mov r14d, r11d
add r11d, 1
mov rax, rbx
mov r8d, r14d
mov edx, r11d
mov esi, r15d
jmp short loc_1725
loc_1710:
movsxd rcx, r8d
add rax, 4
lea rdi, [r10+rcx*4]
lea ecx, [rdx+1]
cmp edx, r9d
jge short loc_173F
loc_1723:
mov edx, ecx
loc_1725:
mov ecx, [rax]
mov rdi, rax
cmp esi, ecx
jle short loc_1710
mov esi, ecx
mov r8d, edx
lea ecx, [rdx+1]
add rax, 4
cmp edx, r9d
jl short loc_1723
loc_173F:
cmp r8d, r14d
jz short loc_174A
mov [rbx-4], esi
mov [rdi], r15d
loc_174A:
add rbx, 4
cmp r11d, r9d
jnz short loc_16F0
loc_1753:
xor eax, eax
mov ecx, 0AAAAAAABh
nop word ptr [rax+rax+00h]
loc_1760:
imul edx, eax, 0AAAAAAABh
cmp edx, 55555555h
ja short loc_17A0
mov edx, eax
imul rdx, rcx
shr rdx, 21h
mov edx, [r10+rdx*4]
mov [r12+rax*4], edx
add rax, 1
cmp rax, r13
jnz short loc_1760
loc_1789:
add rsp, 8
mov rdi, r10; ptr
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
jmp _free
loc_17A0:
mov edx, [rbp+rax*4+0]
mov [r12+rax*4], edx
add rax, 1
cmp rax, r13
jnz short loc_1760
jmp short loc_1789
loc_17B3:
cmp r9d, 1
jz short loc_1753
test eax, eax
jle short loc_1753
mov r9d, eax
jmp loc_16E5
loc_17C8:
xor eax, eax
xor edx, edx
jmp loc_1683
loc_17D1:
lea r9d, [rax+2]
jmp loc_16E5
|
void func0(const __m128i *a1, int a2, long long a3)
{
long long v3; // r13
__m128 *v6; // r10
long long v7; // rdx
unsigned long long v8; // rcx
unsigned int v9; // esi
const __m128i *v10; // rax
__m128 *v11; // rdx
__m128 *v12; // rcx
__m128 v13; // xmm2
__m128 v14; // xmm1
__m128 v15; // xmm0
signed int v16; // eax
signed int v17; // edx
signed int v18; // r9d
long long v19; // rcx
int v20; // edx
long long v21; // rdi
__int32 *v22; // rbx
signed int v23; // r11d
int v24; // r15d
int v25; // r14d
__int32 *v26; // rax
signed int v27; // r8d
signed int v28; // edx
int v29; // esi
__int32 *v30; // rdi
signed int v31; // ecx
long long v32; // rax
v3 = a2;
v6 = (__m128 *)malloc(4LL * (a2 / 3 + 1));
if ( a2 > 0 )
{
v7 = (unsigned int)(a2 - 1);
v8 = (unsigned long long)(2863311531LL * v7) >> 32;
v9 = (a2 - 1) / 3u;
if ( (unsigned int)v7 <= 0xB )
{
v16 = 0;
v17 = 0;
}
else
{
v10 = a1;
v11 = v6;
v12 = &v6[v8 >> 3];
do
{
v13 = (__m128)_mm_loadu_si128(v10);
v14 = (__m128)_mm_loadu_si128(v10 + 1);
++v11;
v10 += 3;
v15 = _mm_shuffle_ps(v13, _mm_shuffle_ps(v14, v13, 10), 140);
v11[-1] = _mm_shuffle_ps(v15, _mm_shuffle_ps((__m128)_mm_loadu_si128(v10 - 1), v15, 165), 36);
}
while ( v11 != v12 );
v16 = v9 & 0xFFFFFFFC;
v17 = 3 * (v9 & 0xFFFFFFFC);
}
v18 = v16 + 1;
v19 = v16;
v6->m128_i32[v19] = a1->m128i_i32[v17];
v20 = 3 * (v16 + 1);
if ( (int)v3 > v20 )
{
v21 = v20;
v6->m128_i32[v19 + 1] = a1->m128i_i32[v21];
if ( (int)v3 > v20 + 3 )
{
v18 = v16 + 3;
v6->m128_i32[v19 + 2] = a1->m128i_i32[v21 + 3];
if ( v20 + 6 >= (int)v3 )
v18 = v16 + 2;
else
v6->m128_i32[v19 + 3] = a1[1].m128i_i32[v21 + 2];
}
goto LABEL_10;
}
if ( v16 > 0 )
{
v18 = v16;
LABEL_10:
v22 = &v6->m128_i32[1];
v23 = 0;
do
{
v24 = *(v22 - 1);
v25 = v23++;
v26 = v22;
v27 = v25;
v28 = v23;
v29 = v24;
while ( 1 )
{
v30 = v26;
if ( v29 > *v26 )
break;
++v26;
v30 = &v6->m128_i32[v27];
v31 = v28 + 1;
if ( v28 >= v18 )
goto LABEL_16;
LABEL_13:
v28 = v31;
}
v29 = *v26;
v27 = v28;
v31 = v28 + 1;
++v26;
if ( v28 < v18 )
goto LABEL_13;
LABEL_16:
if ( v27 != v25 )
{
*(v22 - 1) = v29;
*v30 = v24;
}
++v22;
}
while ( v23 != v18 );
}
v32 = 0LL;
do
{
while ( (unsigned int)(-1431655765 * v32) <= 0x55555555 )
{
*(_DWORD *)(a3 + 4 * v32) = v6->m128_i32[(unsigned int)v32 / 3uLL];
if ( ++v32 == v3 )
goto LABEL_22;
}
*(_DWORD *)(a3 + 4 * v32) = a1->m128i_i32[v32];
++v32;
}
while ( v32 != v3 );
}
LABEL_22:
free(v6);
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV EAX,R13D
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
IMUL RDI,R13,0x55555556
SAR EAX,0x1f
PUSH RBX
SHR RDI,0x20
SUB EDI,EAX
SUB RSP,0x8
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R10,RAX
TEST R13D,R13D
JLE 0x00101789
LEA EAX,[R13 + -0x1]
MOV ECX,0xaaaaaaab
MOV RBX,R13
MOV RDX,RAX
IMUL RAX,RCX
MOV RCX,RAX
SHR RAX,0x21
SHR RCX,0x20
MOV RSI,RAX
CMP EDX,0xb
JBE 0x001017c8
SHR RCX,0x3
MOV RAX,RBP
MOV RDX,R10
SHL RCX,0x4
ADD RCX,R10
NOP dword ptr [RAX]
LAB_00101648:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
ADD RDX,0x10
ADD RAX,0x30
MOVDQA XMM0,XMM2
SHUFPS XMM1,XMM2,0xa
SHUFPS XMM0,XMM1,0x8c
MOVDQU XMM1,xmmword ptr [RAX + -0x10]
SHUFPS XMM1,XMM0,0xa5
SHUFPS XMM0,XMM1,0x24
MOVUPS xmmword ptr [RDX + -0x10],XMM0
CMP RDX,RCX
JNZ 0x00101648
MOV EAX,ESI
AND EAX,0xfffffffc
LEA EDX,[RAX + RAX*0x2]
LAB_00101683:
MOVSXD RDX,EDX
MOVSXD RSI,EAX
LEA R9D,[RAX + 0x1]
MOV EDX,dword ptr [RBP + RDX*0x4]
LEA RCX,[RSI*0x4]
MOV dword ptr [R10 + RSI*0x4],EDX
LEA EDX,[R9 + R9*0x2]
CMP EBX,EDX
JLE 0x001017b3
MOVSXD RSI,EDX
LEA RDI,[RSI*0x4]
MOV ESI,dword ptr [RBP + RSI*0x4]
MOV dword ptr [R10 + RCX*0x1 + 0x4],ESI
LEA ESI,[RDX + 0x3]
CMP EBX,ESI
JLE 0x001016e5
MOV ESI,dword ptr [RBP + RDI*0x1 + 0xc]
ADD EDX,0x6
LEA R9D,[RAX + 0x3]
MOV dword ptr [R10 + RCX*0x1 + 0x8],ESI
CMP EDX,EBX
JGE 0x001017d1
MOV EAX,dword ptr [RBP + RDI*0x1 + 0x18]
MOV dword ptr [R10 + RCX*0x1 + 0xc],EAX
LAB_001016e5:
LEA RBX,[R10 + 0x4]
XOR R11D,R11D
NOP dword ptr [RAX]
LAB_001016f0:
MOV R15D,dword ptr [RBX + -0x4]
MOV R14D,R11D
ADD R11D,0x1
MOV RAX,RBX
MOV R8D,R14D
MOV EDX,R11D
MOV ESI,R15D
JMP 0x00101725
LAB_00101710:
MOVSXD RCX,R8D
ADD RAX,0x4
LEA RDI,[R10 + RCX*0x4]
LEA ECX,[RDX + 0x1]
CMP EDX,R9D
JGE 0x0010173f
LAB_00101723:
MOV EDX,ECX
LAB_00101725:
MOV ECX,dword ptr [RAX]
MOV RDI,RAX
CMP ESI,ECX
JLE 0x00101710
MOV ESI,ECX
MOV R8D,EDX
LEA ECX,[RDX + 0x1]
ADD RAX,0x4
CMP EDX,R9D
JL 0x00101723
LAB_0010173f:
CMP R8D,R14D
JZ 0x0010174a
MOV dword ptr [RBX + -0x4],ESI
MOV dword ptr [RDI],R15D
LAB_0010174a:
ADD RBX,0x4
CMP R11D,R9D
JNZ 0x001016f0
LAB_00101753:
XOR EAX,EAX
MOV ECX,0xaaaaaaab
NOP word ptr [RAX + RAX*0x1]
LAB_00101760:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
JA 0x001017a0
MOV EDX,EAX
IMUL RDX,RCX
SHR RDX,0x21
MOV EDX,dword ptr [R10 + RDX*0x4]
MOV dword ptr [R12 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R13
JNZ 0x00101760
LAB_00101789:
ADD RSP,0x8
MOV RDI,R10
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
JMP 0x00101090
LAB_001017a0:
MOV EDX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R13
JNZ 0x00101760
JMP 0x00101789
LAB_001017b3:
CMP R9D,0x1
JZ 0x00101753
TEST EAX,EAX
JLE 0x00101753
MOV R9D,EAX
JMP 0x001016e5
LAB_001017c8:
XOR EAX,EAX
XOR EDX,EDX
JMP 0x00101683
LAB_001017d1:
LEA R9D,[RAX + 0x2]
JMP 0x001016e5
|
void func0(int *param_1,int param_2,long param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
int *__ptr;
int *piVar4;
int *piVar5;
ulong uVar6;
uint uVar7;
int iVar8;
int *piVar9;
int iVar10;
uint uVar11;
uint uVar12;
uint uVar13;
__ptr = (int *)malloc((long)(param_2 / 3 + 1) << 2);
if (param_2 < 1) goto LAB_00101789;
uVar3 = param_2 - 1;
if (uVar3 < 0xc) {
uVar3 = 0;
iVar8 = 0;
}
else {
piVar4 = param_1;
piVar5 = __ptr;
do {
iVar8 = piVar4[3];
iVar10 = piVar4[6];
piVar9 = piVar5 + 4;
iVar1 = piVar4[9];
*piVar5 = *piVar4;
piVar5[1] = iVar8;
piVar5[2] = iVar10;
piVar5[3] = iVar1;
piVar4 = piVar4 + 0xc;
piVar5 = piVar9;
} while (piVar9 != __ptr + ((ulong)uVar3 / 0xc) * 4);
uVar3 = uVar3 / 3 & 0xfffffffc;
iVar8 = uVar3 * 3;
}
uVar12 = uVar3 + 1;
__ptr[(int)uVar3] = param_1[iVar8];
iVar8 = uVar12 * 3;
if (param_2 == iVar8 || SBORROW4(param_2,iVar8) != (int)(param_2 + uVar12 * -3) < 0) {
if ((uVar12 != 1) && (uVar12 = uVar3, uVar3 != 0)) goto LAB_001016e5;
}
else {
__ptr[(long)(int)uVar3 + 1] = param_1[iVar8];
if (iVar8 + 3 < param_2) {
__ptr[(long)(int)uVar3 + 2] = param_1[(long)iVar8 + 3];
if (iVar8 + 6 < param_2) {
__ptr[(long)(int)uVar3 + 3] = param_1[(long)iVar8 + 6];
uVar12 = uVar3 + 3;
}
else {
uVar12 = uVar3 + 2;
}
}
LAB_001016e5:
uVar3 = 0;
piVar4 = __ptr;
do {
iVar8 = *piVar4;
uVar13 = uVar3 + 1;
piVar5 = piVar4 + 1;
uVar7 = uVar13;
iVar10 = iVar8;
uVar11 = uVar3;
while( true ) {
piVar9 = piVar5;
iVar1 = *piVar5;
uVar2 = uVar7;
if (iVar10 <= *piVar5) {
piVar9 = __ptr + (int)uVar11;
iVar1 = iVar10;
uVar2 = uVar11;
}
uVar11 = uVar2;
iVar10 = iVar1;
if ((int)uVar12 <= (int)uVar7) break;
uVar7 = uVar7 + 1;
piVar5 = piVar5 + 1;
}
if (uVar11 != uVar3) {
*piVar4 = iVar10;
*piVar9 = iVar8;
}
uVar3 = uVar13;
piVar4 = piVar4 + 1;
} while (uVar13 != uVar12);
}
uVar6 = 0;
do {
while ((uint)((int)uVar6 * -0x55555555) < 0x55555556) {
*(int *)(param_3 + uVar6 * 4) = __ptr[(uVar6 & 0xffffffff) / 3];
uVar6 = uVar6 + 1;
if (uVar6 == (long)param_2) goto LAB_00101789;
}
*(int *)(param_3 + uVar6 * 4) = param_1[uVar6];
uVar6 = uVar6 + 1;
} while (uVar6 != (long)param_2);
LAB_00101789:
free(__ptr);
return;
}
|
792 |
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;
}
|
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
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 129a <func0+0xd1>
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1255 <func0+0x8c>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 1251 <func0+0x88>
movl $0x1,-0x1c(%rbp)
jmp 125d <func0+0x94>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x18(%rbp),%eax
jl 1218 <func0+0x4f>
cmpl $0x0,-0x1c(%rbp)
jne 1296 <func0+0xcd>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1208 <func0+0x3f>
movl $0x0,-0x14(%rbp)
jmpq 1363 <func0+0x19a>
mov -0x14(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
jmpq 1353 <func0+0x18a>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 134f <func0+0x186>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x18(%rbp),%eax
jl 12c0 <func0+0xf7>
addl $0x1,-0x14(%rbp)
mov -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jl 12b2 <func0+0xe9>
mov -0x38(%rbp),%rax
mov -0x18(%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 eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_129A
loc_1208:
mov [rbp+var_1C], 0
mov [rbp+var_10], 0
jmp short loc_1255
loc_1218:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_1251
mov [rbp+var_1C], 1
jmp short loc_125D
loc_1251:
add [rbp+var_10], 1
loc_1255:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_18]
jl short loc_1218
loc_125D:
cmp [rbp+var_1C], 0
jnz short loc_1296
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1296:
add [rbp+var_14], 1
loc_129A:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl loc_1208
mov [rbp+var_14], 0
jmp loc_1363
loc_12B2:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_10], eax
jmp loc_1353
loc_12C0:
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_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_134F
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rbp+var_14]
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_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
loc_134F:
add [rbp+var_10], 1
loc_1353:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_18]
jl loc_12C0
add [rbp+var_14], 1
loc_1363:
mov eax, [rbp+var_18]
sub eax, 1
cmp [rbp+var_14], eax
jl loc_12B2
mov rax, [rbp+var_38]
mov edx, [rbp+var_18]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+24h] [rbp-1Ch]
int v7; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int k; // [rsp+2Ch] [rbp-14h]
int j; // [rsp+30h] [rbp-10h]
int m; // [rsp+30h] [rbp-10h]
int v12; // [rsp+34h] [rbp-Ch]
_DWORD *v13; // [rsp+38h] [rbp-8h]
v13 = malloc(4LL * a2);
v7 = 0;
for ( i = 0; i < a2; ++i )
{
v6 = 0;
for ( j = 0; j < v7; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == v13[j] )
{
v6 = 1;
break;
}
}
if ( !v6 )
{
v3 = v7++;
v13[v3] = *(_DWORD *)(4LL * i + a1);
}
}
for ( k = 0; k < v7 - 1; ++k )
{
for ( m = k + 1; m < v7; ++m )
{
if ( v13[k] > v13[m] )
{
v12 = v13[k];
v13[k] = v13[m];
v13[m] = v12;
}
}
}
*a3 = v7;
return v13;
}
|
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]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010129a
LAB_00101208:
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101255
LAB_00101218:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101251
MOV dword ptr [RBP + -0x1c],0x1
JMP 0x0010125d
LAB_00101251:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101255:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x00101218
LAB_0010125d:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00101296
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101296:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010129a:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101208
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101363
LAB_001012b2:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00101353
LAB_001012c0:
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 + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010134f
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
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 + -0x10]
CDQE
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_0010134f:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101353:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x001012c0
ADD dword ptr [RBP + -0x14],0x1
LAB_00101363:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x001012b2
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(long param_1,int param_2,int *param_3)
{
int4 uVar1;
bool bVar2;
void *pvVar3;
int4 local_20;
int4 local_1c;
int4 local_18;
pvVar3 = malloc((long)param_2 << 2);
local_20 = 0;
local_1c = 0;
do {
if (param_2 <= local_1c) {
for (local_1c = 0; local_18 = local_1c, local_1c < local_20 + -1; local_1c = local_1c + 1) {
while (local_18 = local_18 + 1, local_18 < local_20) {
if (*(int *)((long)pvVar3 + (long)local_18 * 4) <
*(int *)((long)pvVar3 + (long)local_1c * 4)) {
uVar1 = *(int4 *)((long)pvVar3 + (long)local_1c * 4);
*(int4 *)((long)pvVar3 + (long)local_1c * 4) =
*(int4 *)((long)pvVar3 + (long)local_18 * 4);
*(int4 *)((long)local_18 * 4 + (long)pvVar3) = uVar1;
}
}
}
*param_3 = local_20;
return pvVar3;
}
bVar2 = false;
for (local_18 = 0; local_18 < local_20; local_18 = local_18 + 1) {
if (*(int *)(param_1 + (long)local_1c * 4) == *(int *)((long)pvVar3 + (long)local_18 * 4)) {
bVar2 = true;
break;
}
}
if (!bVar2) {
*(int4 *)((long)local_20 * 4 + (long)pvVar3) =
*(int4 *)((long)local_1c * 4 + param_1);
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
} while( true );
}
|
793 |
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;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1249 <func0+0x80>
mov %r12,%rdi
lea -0x1(%rbp),%edx
lea 0x4(%r12,%rdx,4),%r9
mov $0x0,%r8d
lea 0x4(%rax),%r10
jmp 126c <func0+0xa3>
cmp $0x1,%r8d
jle 124f <func0+0x86>
mov %rax,%rdi
lea -0x2(%r8),%r10d
add $0x2,%r10
mov $0x1,%r9d
jmp 123f <func0+0x76>
add $0x1,%rdx
cmp %edx,%r8d
jle 1232 <func0+0x69>
mov (%rdi),%ecx
mov (%rax,%rdx,4),%esi
cmp %esi,%ecx
jle 1219 <func0+0x50>
mov %esi,(%rdi)
mov %ecx,(%rax,%rdx,4)
jmp 1219 <func0+0x50>
add $0x1,%r9
add $0x4,%rdi
cmp %r10,%r9
je 124f <func0+0x86>
cmp %r9d,%r8d
jle 1232 <func0+0x69>
mov %r9,%rdx
jmp 1222 <func0+0x59>
mov $0x0,%r8d
mov %r8d,(%rbx)
pop %rbx
pop %rbp
pop %r12
retq
movslq %r8d,%rdx
mov (%rdi),%ecx
mov %ecx,(%rax,%rdx,4)
lea 0x1(%r8),%r8d
add $0x4,%rdi
cmp %r9,%rdi
je 1200 <func0+0x37>
test %r8d,%r8d
jle 1257 <func0+0x8e>
mov (%rdi),%ecx
mov %rax,%rdx
lea -0x1(%r8),%esi
lea (%r10,%rsi,4),%rsi
cmp (%rdx),%ecx
je 1263 <func0+0x9a>
add $0x4,%rdx
cmp %rsi,%rdx
jne 127e <func0+0xb5>
jmp 1257 <func0+0x8e>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12d, esi
mov rbx, rdx
movsxd r13, esi
shl r13, 2
mov rdi, r13; size
call _malloc
mov r10, rax
test r12d, r12d
jle loc_129E
mov rsi, rbp
lea rdi, [rbp+r13+0]
mov r9d, 0
jmp short loc_1221
loc_120B:
movsxd rax, r9d
mov edx, [rsi]
mov [r10+rax*4], edx
lea r9d, [r9+1]
loc_1218:
add rsi, 4
cmp rsi, rdi
jz short loc_1241
loc_1221:
test r9d, r9d
jle short loc_120B
mov edx, [rsi]
mov rax, r10
movsxd rcx, r9d
lea rcx, [r10+rcx*4]
loc_1232:
cmp edx, [rax]
jz short loc_1218
add rax, 4
cmp rax, rcx
jnz short loc_1232
jmp short loc_120B
loc_1241:
cmp r9d, 1
jle short loc_12A4
lea rsi, [r10+4]
mov r11d, r9d
mov r8d, 1
lea r12d, [r9-1]
lea rbp, [r10+8]
jmp short loc_1284
loc_125E:
add rax, 4
cmp rax, rdi
jz short loc_1277
loc_1267:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_125E
mov [rsi-4], ecx
mov [rax], edx
jmp short loc_125E
loc_1277:
add r8, 1
add rsi, 4
cmp r8, r11
jz short loc_12A4
loc_1284:
cmp r9d, r8d
jle short loc_1277
mov eax, r12d
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [rbp+rax*4+0]
mov rax, rsi
jmp short loc_1267
loc_129E:
mov r9d, 0
loc_12A4:
mov [rbx], r9d
mov rax, r10
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
_DWORD * func0(_DWORD *a1, int a2, int *a3)
{
size_t v4; // r13
_DWORD *v5; // r10
_DWORD *v6; // rsi
int v7; // r9d
_DWORD *v8; // rax
_DWORD *v9; // rsi
long long i; // r8
_DWORD *v11; // rax
int v12; // edx
v4 = a2;
v5 = malloc(v4 * 4);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( v7 <= 0 )
{
LABEL_3:
v5[v7++] = *v6;
}
else
{
v8 = v5;
while ( *v6 != *v8 )
{
if ( ++v8 == &v5[v7] )
goto LABEL_3;
}
}
++v6;
}
while ( v6 != &a1[v4] );
if ( v7 > 1 )
{
v9 = v5 + 1;
for ( i = 1LL; i != v7; ++i )
{
if ( v7 > (int)i )
{
v11 = v9;
do
{
v12 = *(v9 - 1);
if ( v12 > *v11 )
{
*(v9 - 1) = *v11;
*v11 = v12;
}
++v11;
}
while ( v11 != &v5[i + 1 + (unsigned int)(v7 - 1 - i)] );
}
++v9;
}
}
}
*a3 = v7;
return v5;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12D,ESI
MOV RBX,RDX
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010d0
MOV R10,RAX
TEST R12D,R12D
JLE 0x0010129e
MOV RSI,RBP
LEA RDI,[RBP + R13*0x1]
MOV R9D,0x0
JMP 0x00101221
LAB_0010120b:
MOVSXD RAX,R9D
MOV EDX,dword ptr [RSI]
MOV dword ptr [R10 + RAX*0x4],EDX
LEA R9D,[R9 + 0x1]
LAB_00101218:
ADD RSI,0x4
CMP RSI,RDI
JZ 0x00101241
LAB_00101221:
TEST R9D,R9D
JLE 0x0010120b
MOV EDX,dword ptr [RSI]
MOV RAX,R10
MOVSXD RCX,R9D
LEA RCX,[R10 + RCX*0x4]
LAB_00101232:
CMP EDX,dword ptr [RAX]
JZ 0x00101218
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101232
JMP 0x0010120b
LAB_00101241:
CMP R9D,0x1
JLE 0x001012a4
LEA RSI,[R10 + 0x4]
MOV R11D,R9D
MOV R8D,0x1
LEA R12D,[R9 + -0x1]
LEA RBP,[R10 + 0x8]
JMP 0x00101284
LAB_0010125e:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101277
LAB_00101267:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x0010125e
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
JMP 0x0010125e
LAB_00101277:
ADD R8,0x1
ADD RSI,0x4
CMP R8,R11
JZ 0x001012a4
LAB_00101284:
CMP R9D,R8D
JLE 0x00101277
MOV EAX,R12D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[RBP + RAX*0x4]
MOV RAX,RSI
JMP 0x00101267
LAB_0010129e:
MOV R9D,0x0
LAB_001012a4:
MOV dword ptr [RBX],R9D
MOV RAX,R10
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
int * func0(int *param_1,int param_2,uint *param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
uint uVar6;
piVar3 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
uVar6 = 0;
}
else {
piVar2 = param_1 + param_2;
uVar6 = 0;
do {
if (0 < (int)uVar6) {
piVar4 = piVar3;
do {
if (*param_1 == *piVar4) goto LAB_00101218;
piVar4 = piVar4 + 1;
} while (piVar4 != piVar3 + (int)uVar6);
}
piVar3[(int)uVar6] = *param_1;
uVar6 = uVar6 + 1;
LAB_00101218:
param_1 = param_1 + 1;
} while (param_1 != piVar2);
if (1 < (int)uVar6) {
uVar5 = 1;
piVar2 = piVar3;
do {
if ((int)uVar5 < (int)uVar6) {
piVar4 = piVar2 + 1;
do {
iVar1 = *piVar2;
if (*piVar4 < iVar1) {
*piVar2 = *piVar4;
*piVar4 = iVar1;
}
piVar4 = piVar4 + 1;
} while (piVar4 != piVar3 + uVar5 + ((uVar6 - 1) - (int)uVar5) + 1);
}
uVar5 = uVar5 + 1;
piVar2 = piVar2 + 1;
} while (uVar5 != uVar6);
}
}
*param_3 = uVar6;
return piVar3;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.