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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
4,282 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
typedef struct {
Pair *pairs;
int size;
int capacity;
} Dictionary;
void init_dictionary(Dictionary *dict) {
dict->capacity = 10;
dict->size = 0;
dict->pairs = (Pair *)malloc(dict->capacity * sizeof(Pair));
}
void free_dictionary(Dictionary *dict) {
free(dict->pairs);
}
void dictionary_add(Dictionary *dict, int key) {
for (int i = 0; i < dict->size; i++) {
if (dict->pairs[i].key == key) {
dict->pairs[i].value += 1;
return;
}
}
if (dict->size == dict->capacity) {
dict->capacity *= 2;
dict->pairs = (Pair *)realloc(dict->pairs, dict->capacity * sizeof(Pair));
}
dict->pairs[dict->size].key = key;
dict->pairs[dict->size].value = 1;
dict->size += 1;
}
| Dictionary func0(int list1[][4], int numLists) {
Dictionary dict;
init_dictionary(&dict);
for (int i = 0; i < numLists; i++) {
for (int j = 0; j < 4; j++) {
dictionary_add(&dict, list1[i][j]);
}
}
return dict;
}
| int main() {
int list1[3][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}};
Dictionary result1 = func0(list1, 3);
assert(result1.size == 9);
assert(result1.pairs[1].value == 3);
assert(result1.pairs[4].value == 2);
int list2[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Dictionary result2 = func0(list2, 3);
assert(result2.size == 12);
for (int i = 0; i < result2.size; i++) {
assert(result2.pairs[i].value == 1);
}
int list3[3][4] = {{20, 30, 40, 17}, {18, 16, 14, 13}, {10, 20, 30, 40}};
Dictionary result3 = func0(list3, 3);
assert(result3.size == 9);
assert(result3.pairs[0].value == 2);
assert(result3.pairs[1].value == 2);
assert(result3.pairs[2].value == 2);
free_dictionary(&result1);
free_dictionary(&result2);
free_dictionary(&result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
mov $0x50,%edi
push %rbp
push %rbx
mov %esi,%ebx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movabs $0xa00000000,%rax
mov %rax,0x8(%rsp)
callq 10c0 <malloc@plt>
mov %rax,(%rsp)
test %ebx,%ebx
jle 1650 <func0+0x80>
lea -0x1(%rbx),%eax
lea 0x10(%r12),%rbp
shl $0x4,%rax
lea 0x20(%r12,%rax,1),%r13
mov %rsp,%r12
nopl 0x0(%rax,%rax,1)
lea -0x10(%rbp),%rbx
mov (%rbx),%esi
mov %r12,%rdi
add $0x4,%rbx
callq 1530 <dictionary_add>
cmp %rbp,%rbx
jne 1634 <func0+0x64>
add $0x10,%rbp
cmp %r13,%rbp
jne 1630 <func0+0x60>
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
mov (%rsp),%rax
mov 0x8(%rsp),%rdx
jne 1674 <func0+0xa4>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 10a0 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r13
push r12
mov r12, rdi
mov edi, 50h ; 'P'
push rbp
push rbx
mov ebx, esi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
mov rax, 0A00000000h
mov [rsp+48h+var_40], rax
call _malloc
mov [rsp+48h+var_48], rax
test ebx, ebx
jle short loc_1650
lea eax, [rbx-1]
lea rbp, [r12+10h]
shl rax, 4
lea r13, [r12+rax+20h]
mov r12, rsp
nop word ptr [rax+rax+00000000h]
loc_1630:
lea rbx, [rbp-10h]
loc_1634:
mov esi, [rbx]
mov rdi, r12
add rbx, 4
call dictionary_add
cmp rbx, rbp
jnz short loc_1634
add rbp, 10h
cmp rbp, r13
jnz short loc_1630
loc_1650:
mov rax, [rsp+48h+var_48]
mov rdx, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_30]
sub rcx, fs:28h
jnz short loc_1674
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1674:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
unsigned int *v2; // rbp
long long v3; // r13
unsigned int *v4; // rbx
long long v5; // rsi
_QWORD v7[9]; // [rsp+0h] [rbp-48h] BYREF
v7[3] = __readfsqword(0x28u);
v7[1] = 0xA00000000LL;
v7[0] = malloc(80LL);
if ( a2 > 0 )
{
v2 = (unsigned int *)(a1 + 16);
v3 = a1 + 16LL * (unsigned int)(a2 - 1) + 32;
do
{
v4 = v2 - 4;
do
{
v5 = *v4++;
dictionary_add(v7, v5);
}
while ( v4 != v2 );
v2 += 4;
}
while ( v2 != (unsigned int *)v3 );
}
return v7[0];
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
MOV EDI,0x50
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,0xa00000000
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001010c0
MOV qword ptr [RSP],RAX
TEST EBX,EBX
JLE 0x00101650
LEA EAX,[RBX + -0x1]
LEA RBP,[R12 + 0x10]
SHL RAX,0x4
LEA R13,[R12 + RAX*0x1 + 0x20]
MOV R12,RSP
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101630:
LEA RBX,[RBP + -0x10]
LAB_00101634:
MOV ESI,dword ptr [RBX]
MOV RDI,R12
ADD RBX,0x4
CALL 0x00101530
CMP RBX,RBP
JNZ 0x00101634
ADD RBP,0x10
CMP RBP,R13
JNZ 0x00101630
LAB_00101650:
MOV RAX,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
SUB RCX,qword ptr FS:[0x28]
JNZ 0x00101674
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101674:
CALL 0x001010a0 | void * func0(long param_1,int param_2)
{
int4 uVar1;
int4 *puVar2;
int4 *puVar3;
long in_FS_OFFSET;
void *local_48;
int8 local_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = 0xa00000000;
local_48 = malloc(0x50);
if (0 < param_2) {
puVar3 = (int4 *)(param_1 + 0x10);
do {
puVar2 = puVar3 + -4;
do {
uVar1 = *puVar2;
puVar2 = puVar2 + 1;
dictionary_add(&local_48,uVar1);
} while (puVar2 != puVar3);
puVar3 = puVar3 + 4;
} while (puVar3 != (int4 *)(param_1 + 0x20 + (ulong)(param_2 - 1) * 0x10));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_48;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,283 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
typedef struct {
Pair *pairs;
int size;
int capacity;
} Dictionary;
void init_dictionary(Dictionary *dict) {
dict->capacity = 10;
dict->size = 0;
dict->pairs = (Pair *)malloc(dict->capacity * sizeof(Pair));
}
void free_dictionary(Dictionary *dict) {
free(dict->pairs);
}
void dictionary_add(Dictionary *dict, int key) {
for (int i = 0; i < dict->size; i++) {
if (dict->pairs[i].key == key) {
dict->pairs[i].value += 1;
return;
}
}
if (dict->size == dict->capacity) {
dict->capacity *= 2;
dict->pairs = (Pair *)realloc(dict->pairs, dict->capacity * sizeof(Pair));
}
dict->pairs[dict->size].key = key;
dict->pairs[dict->size].value = 1;
dict->size += 1;
}
| Dictionary func0(int list1[][4], int numLists) {
Dictionary dict;
init_dictionary(&dict);
for (int i = 0; i < numLists; i++) {
for (int j = 0; j < 4; j++) {
dictionary_add(&dict, list1[i][j]);
}
}
return dict;
}
| int main() {
int list1[3][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}};
Dictionary result1 = func0(list1, 3);
assert(result1.size == 9);
assert(result1.pairs[1].value == 3);
assert(result1.pairs[4].value == 2);
int list2[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Dictionary result2 = func0(list2, 3);
assert(result2.size == 12);
for (int i = 0; i < result2.size; i++) {
assert(result2.pairs[i].value == 1);
}
int list3[3][4] = {{20, 30, 40, 17}, {18, 16, 14, 13}, {10, 20, 30, 40}};
Dictionary result3 = func0(list3, 3);
assert(result3.size == 9);
assert(result3.pairs[0].value == 2);
assert(result3.pairs[1].value == 2);
assert(result3.pairs[2].value == 2);
free_dictionary(&result1);
free_dictionary(&result2);
free_dictionary(&result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
mov $0x50,%edi
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
callq 10c0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 1674 <func0+0xd4>
lea -0x1(%rbx),%eax
lea 0x10(%rbp),%r13
mov $0xa,%r14d
shl $0x4,%rax
lea 0x20(%rbp,%rax,1),%r15
xor %ebp,%ebp
nopl 0x0(%rax)
lea -0x10(%r13),%rbx
mov (%rbx),%r12d
test %ebp,%ebp
je 1640 <func0+0xa0>
lea -0x1(%rbp),%eax
mov %rdi,%rdx
lea 0x8(%rdi,%rax,8),%rax
jmp 1609 <func0+0x69>
add $0x8,%rdx
cmp %rax,%rdx
je 1640 <func0+0xa0>
cmp (%rdx),%r12d
jne 1600 <func0+0x60>
addl $0x1,0x4(%rdx)
add $0x4,%rbx
cmp %r13,%rbx
jne 15ec <func0+0x4c>
add $0x10,%r13
cmp %r15,%r13
jne 15e8 <func0+0x48>
add $0x8,%rsp
shl $0x20,%r14
mov %ebp,%edx
mov %rdi,%rax
pop %rbx
or %r14,%rdx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
cmp %ebp,%r14d
je 1660 <func0+0xc0>
movslq %ebp,%rax
add $0x1,%ebp
lea (%rdi,%rax,8),%rax
mov %r12d,(%rax)
movl $0x1,0x4(%rax)
jmp 1612 <func0+0x72>
nopl 0x0(%rax,%rax,1)
add %r14d,%r14d
movslq %r14d,%rsi
shl $0x3,%rsi
callq 10d0 <realloc@plt>
mov %rax,%rdi
jmp 1645 <func0+0xa5>
mov $0xa,%r14d
xor %ebp,%ebp
jmp 1624 <func0+0x84>
xchg %ax,%ax
| func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
mov ebx, esi
sub rsp, 18h
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_167E
movsxd rcx, ebx
add r14, 10h
mov r15d, 0Ah
xor r12d, r12d
shl rcx, 4
add rcx, r14
nop dword ptr [rax+rax+00h]
loc_15D8:
lea rbp, [r14-10h]
loc_15DC:
mov ebx, [rbp+0]
movsxd r13, r12d
test r12d, r12d
jle short loc_1640
movsxd r13, r12d
mov rax, rdi
lea rdx, [rdi+r13*8]
jmp short loc_1601
loc_15F8:
add rax, 8
cmp rdx, rax
jz short loc_1640
loc_1601:
cmp ebx, [rax]
jnz short loc_15F8
add dword ptr [rax+4], 1
loc_1609:
add rbp, 4
cmp rbp, r14
jnz short loc_15DC
add r14, 10h
cmp r14, rcx
jnz short loc_15D8
loc_161B:
add rsp, 18h
shl r15, 20h
mov edx, r12d
mov rax, rdi
pop rbx
or rdx, r15
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1640:
cmp r15d, r12d
jz short loc_1660
loc_1645:
lea rax, [rdi+r13*8]
add r12d, 1
mov [rax], ebx
mov dword ptr [rax+4], 1
jmp short loc_1609
loc_1660:
add r15d, r15d
mov [rsp+48h+var_40], rcx
movsxd rsi, r15d
shl rsi, 3; size
call _realloc
mov rcx, [rsp+48h+var_40]
mov rdi, rax
jmp short loc_1645
loc_167E:
mov r15d, 0Ah
xor r12d, r12d
jmp short loc_161B | char * func0(long long a1, int a2)
{
char *v3; // rdi
int *v4; // r14
int v5; // r15d
int v6; // r12d
int *v7; // rcx
int *v8; // rbp
int v9; // ebx
long long v10; // r13
char *v11; // rax
char *v13; // rax
char *v14; // rax
int *v15; // [rsp+8h] [rbp-40h]
v3 = (char *)malloc(0x50uLL);
if ( a2 > 0 )
{
v4 = (int *)(a1 + 16);
v5 = 10;
v6 = 0;
v7 = &v4[4 * a2];
do
{
v8 = v4 - 4;
do
{
v9 = *v8;
v10 = v6;
if ( v6 <= 0 )
{
LABEL_12:
if ( v5 == v6 )
{
v5 *= 2;
v15 = v7;
v14 = (char *)realloc(v3, 8LL * v5);
v7 = v15;
v3 = v14;
}
v13 = &v3[8 * v10];
++v6;
*(_DWORD *)v13 = v9;
*((_DWORD *)v13 + 1) = 1;
}
else
{
v10 = v6;
v11 = v3;
while ( v9 != *(_DWORD *)v11 )
{
v11 += 8;
if ( &v3[8 * v6] == v11 )
goto LABEL_12;
}
++*((_DWORD *)v11 + 1);
}
++v8;
}
while ( v8 != v4 );
v4 += 4;
}
while ( v4 != v7 );
}
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x18
CALL 0x001010c0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x0010167e
MOVSXD RCX,EBX
ADD R14,0x10
MOV R15D,0xa
XOR R12D,R12D
SHL RCX,0x4
ADD RCX,R14
NOP dword ptr [RAX + RAX*0x1]
LAB_001015d8:
LEA RBP,[R14 + -0x10]
LAB_001015dc:
MOV EBX,dword ptr [RBP]
MOVSXD R13,R12D
TEST R12D,R12D
JLE 0x00101640
MOVSXD R13,R12D
MOV RAX,RDI
LEA RDX,[RDI + R13*0x8]
JMP 0x00101601
LAB_001015f8:
ADD RAX,0x8
CMP RDX,RAX
JZ 0x00101640
LAB_00101601:
CMP EBX,dword ptr [RAX]
JNZ 0x001015f8
ADD dword ptr [RAX + 0x4],0x1
LAB_00101609:
ADD RBP,0x4
CMP RBP,R14
JNZ 0x001015dc
ADD R14,0x10
CMP R14,RCX
JNZ 0x001015d8
LAB_0010161b:
ADD RSP,0x18
SHL R15,0x20
MOV EDX,R12D
MOV RAX,RDI
POP RBX
OR RDX,R15
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101640:
CMP R15D,R12D
JZ 0x00101660
LAB_00101645:
LEA RAX,[RDI + R13*0x8]
ADD R12D,0x1
MOV dword ptr [RAX],EBX
MOV dword ptr [RAX + 0x4],0x1
JMP 0x00101609
LAB_00101660:
ADD R15D,R15D
MOV qword ptr [RSP + 0x8],RCX
MOVSXD RSI,R15D
SHL RSI,0x3
CALL 0x001010d0
MOV RCX,qword ptr [RSP + 0x8]
MOV RDI,RAX
JMP 0x00101645
LAB_0010167e:
MOV R15D,0xa
XOR R12D,R12D
JMP 0x0010161b | int [16] func0(long param_1,int param_2)
{
int iVar1;
int *__ptr;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
int *piVar7;
int iVar8;
int auVar9 [16];
__ptr = (int *)malloc(0x50);
if (param_2 < 1) {
iVar8 = 10;
iVar5 = 0;
}
else {
piVar7 = (int *)(param_1 + 0x10);
iVar8 = 10;
iVar5 = 0;
piVar3 = piVar7 + (long)param_2 * 4;
do {
piVar4 = piVar7 + -4;
do {
iVar1 = *piVar4;
if (0 < iVar5) {
piVar2 = __ptr;
do {
if (iVar1 == *piVar2) {
piVar2[1] = piVar2[1] + 1;
goto LAB_00101609;
}
piVar2 = piVar2 + 2;
} while (__ptr + (long)iVar5 * 2 != piVar2);
}
lVar6 = (long)iVar5;
if (iVar8 == iVar5) {
iVar8 = iVar8 * 2;
__ptr = (int *)realloc(__ptr,(long)iVar8 << 3);
}
iVar5 = iVar5 + 1;
__ptr[lVar6 * 2] = iVar1;
(__ptr + lVar6 * 2)[1] = 1;
LAB_00101609:
piVar4 = piVar4 + 1;
} while (piVar4 != piVar7);
piVar7 = piVar7 + 4;
} while (piVar7 != piVar3);
}
auVar9._12_4_ = iVar8;
auVar9._8_4_ = iVar5;
auVar9._0_8_ = __ptr;
return auVar9;
} |
4,284 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movsd 0xf18(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11ba <func0+0x51>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm0
movsd -0x8(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118e <func0+0x25>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd -0x8(%rbp),%xmm0
divsd %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
movsd xmm0, cs:qword_2078
movsd [rbp+var_8], xmm0
mov [rbp+var_C], 0
jmp short loc_11BE
loc_118E:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, [rbp+var_8]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
add [rbp+var_C], 1
loc_11BE:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_118E
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_1C]
movsd xmm0, [rbp+var_8]
divsd xmm0, xmm1
pop rbp
retn | double func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
double v4; // [rsp+14h] [rbp-8h]
v4 = 1.0;
for ( i = 0; i < a2; ++i )
v4 = (double)*(int *)(4LL * i + a1) * v4;
return v4 / (double)a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOVSD XMM0,qword ptr [0x00102078]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011be
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [RBP + -0x8]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
ADD dword ptr [RBP + -0xc],0x1
LAB_001011be:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118e
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x1c]
MOVSD XMM0,qword ptr [RBP + -0x8]
DIVSD XMM0,XMM1
POP RBP
RET | double func0(long param_1,int param_2)
{
int4 local_14;
int8 local_10;
local_10 = DAT_00102078;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = (double)*(int *)(param_1 + (long)local_14 * 4) * local_10;
}
return local_10 / (double)param_2;
} |
4,285 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a6 <func0+0x3d>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
movsd 0xf14(%rip),%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl (%rax),%xmm1
mulsd %xmm1,%xmm0
add $0x4,%rax
cmp %rdx,%rax
jne 1184 <func0+0x1b>
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
movsd 0xeea(%rip),%xmm0
jmp 1199 <func0+0x30>
| func0:
endbr64
test esi, esi
jle short loc_11A6
mov rax, rdi
lea edx, [rsi-1]
lea rdx, [rdi+rdx*4+4]
movsd xmm0, cs:qword_2078
loc_1184:
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rax]
mulsd xmm0, xmm1
add rax, 4
cmp rax, rdx
jnz short loc_1184
loc_1199:
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_11A6:
movsd xmm0, cs:qword_2078
jmp short loc_1199 | double func0(int *a1, int a2)
{
int *v2; // rax
double v3; // xmm0_8
if ( a2 <= 0 )
{
v3 = 1.0;
}
else
{
v2 = a1;
v3 = 1.0;
do
v3 = v3 * (double)*v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a6
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDX,[RDI + RDX*0x4 + 0x4]
MOVSD XMM0,qword ptr [0x00102078]
LAB_00101184:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RAX]
MULSD XMM0,XMM1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101184
LAB_00101199:
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_001011a6:
MOVSD XMM0,qword ptr [0x00102078]
JMP 0x00101199 | double func0(int *param_1,int param_2)
{
int *piVar1;
double dVar2;
dVar2 = DAT_00102078;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
dVar2 = dVar2 * (double)*param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return dVar2 / (double)param_2;
} |
4,286 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1188 <func0+0x48>
lea -0x1(%rsi),%eax
movsd 0xeb5(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
add $0x4,%rdi
cvtsi2sdl -0x4(%rdi),%xmm1
mulsd %xmm1,%xmm0
cmp %rax,%rdi
jne 1160 <func0+0x20>
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
movsd 0xe74(%rip),%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1278
lea eax, [rsi-1]
movsd xmm0, cs:qword_2040
lea rax, [rdi+rax*4+4]
nop dword ptr [rax+rax+00000000h]
loc_1250:
pxor xmm1, xmm1
add rdi, 4
cvtsi2sd xmm1, dword ptr [rdi-4]
mulsd xmm0, xmm1
cmp rdi, rax
jnz short loc_1250
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_1278:
pxor xmm1, xmm1
movsd xmm0, cs:qword_2040
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn | double func0(long long a1, int a2)
{
double v2; // xmm0_8
long long v3; // rax
if ( a2 <= 0 )
return 1.0 / (double)a2;
v2 = 1.0;
v3 = a1 + 4LL * (unsigned int)(a2 - 1) + 4;
do
{
a1 += 4LL;
v2 = v2 * (double)*(int *)(a1 - 4);
}
while ( a1 != v3 );
return v2 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101278
LEA EAX,[RSI + -0x1]
MOVSD XMM0,qword ptr [0x00102040]
LEA RAX,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101250:
PXOR XMM1,XMM1
ADD RDI,0x4
CVTSI2SD XMM1,dword ptr [RDI + -0x4]
MULSD XMM0,XMM1
CMP RDI,RAX
JNZ 0x00101250
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_00101278:
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102040]
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET | double func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
double dVar3;
if (0 < param_2) {
piVar1 = param_1;
dVar3 = DAT_00102040;
do {
piVar2 = piVar1 + 1;
dVar3 = dVar3 * (double)*piVar1;
piVar1 = piVar2;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
return dVar3 / (double)param_2;
}
return DAT_00102040 / (double)param_2;
} |
4,287 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1268 <func0+0x48>
lea -0x1(%rsi),%eax
movsd 0xe2d(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
add $0x4,%rdi
cvtsi2sdl -0x4(%rdi),%xmm1
mulsd %xmm1,%xmm0
cmp %rdi,%rax
jne 1240 <func0+0x20>
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
movsd 0xdec(%rip),%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1188
movsxd rax, esi
movsd xmm0, cs:qword_2008
lea rax, [rdi+rax*4]
nop word ptr [rax+rax+00000000h]
loc_1160:
pxor xmm1, xmm1
add rdi, 4
cvtsi2sd xmm1, dword ptr [rdi-4]
mulsd xmm0, xmm1
cmp rax, rdi
jnz short loc_1160
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_1188:
pxor xmm1, xmm1
movsd xmm0, cs:qword_2008
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn | double func0(long long a1, int a2)
{
double v2; // xmm0_8
long long v3; // rax
if ( a2 <= 0 )
return 1.0 / (double)a2;
v2 = 1.0;
v3 = a1 + 4LL * a2;
do
{
a1 += 4LL;
v2 = v2 * (double)*(int *)(a1 - 4);
}
while ( v3 != a1 );
return v2 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101188
MOVSXD RAX,ESI
MOVSD XMM0,qword ptr [0x00102008]
LEA RAX,[RDI + RAX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
PXOR XMM1,XMM1
ADD RDI,0x4
CVTSI2SD XMM1,dword ptr [RDI + -0x4]
MULSD XMM0,XMM1
CMP RAX,RDI
JNZ 0x00101160
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_00101188:
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102008]
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET | double func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
double dVar3;
if (0 < param_2) {
piVar1 = param_1;
dVar3 = DAT_00102008;
do {
piVar2 = piVar1 + 1;
dVar3 = dVar3 * (double)*piVar1;
piVar1 = piVar2;
} while (param_1 + param_2 != piVar2);
return dVar3 / (double)param_2;
}
return DAT_00102008 / (double)param_2;
} |
4,288 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[start];
binary[start] = binary[end];
binary[end] = temp;
start++;
end--;
}
return binary;
}
| int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11b2 <func0+0x49>
mov -0x14(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
lea 0x30(%rax),%ecx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x2ea0(%rip),%rdx
mov %cl,(%rax,%rdx,1)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 117d <func0+0x14>
mov -0xc(%rbp),%eax
cltq
lea 0x2e7c(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
movl $0x0,-0x8(%rbp)
mov -0xc(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 1227 <func0+0xbe>
mov -0x8(%rbp),%eax
cltq
lea 0x2e5a(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
mov %al,-0xd(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x2e47(%rip),%rdx
movzbl (%rax,%rdx,1),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x2e37(%rip),%rcx
mov %dl,(%rax,%rcx,1)
mov -0x4(%rbp),%eax
cltq
lea 0x2e28(%rip),%rcx
movzbl -0xd(%rbp),%edx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x8(%rbp)
subl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11da <func0+0x71>
lea 0x2e0a(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
jmp short loc_11B8
loc_117D:
mov edx, [rbp+var_14]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
lea ecx, [rax+30h]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, binary_1
mov [rax+rdx], cl
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_14], eax
loc_11B8:
cmp [rbp+var_14], 0
jg short loc_117D
mov eax, [rbp+var_C]
cdqe
lea rdx, binary_1
mov byte ptr [rax+rdx], 0
mov [rbp+var_8], 0
mov eax, [rbp+var_C]
sub eax, 1
mov [rbp+var_4], eax
jmp short loc_122D
loc_11E0:
mov eax, [rbp+var_8]
cdqe
lea rdx, binary_1
movzx eax, byte ptr [rax+rdx]
mov [rbp+var_D], al
mov eax, [rbp+var_4]
cdqe
lea rdx, binary_1
movzx edx, byte ptr [rax+rdx]
mov eax, [rbp+var_8]
cdqe
lea rcx, binary_1
mov [rax+rcx], dl
mov eax, [rbp+var_4]
cdqe
lea rcx, binary_1
movzx edx, [rbp+var_D]
mov [rax+rcx], dl
add [rbp+var_8], 1
sub [rbp+var_4], 1
loc_122D:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_11E0
lea rax, binary_1
pop rbp
retn | _BYTE * func0(int a1)
{
int v1; // eax
char v4; // [rsp+7h] [rbp-Dh]
int v5; // [rsp+8h] [rbp-Ch]
int v6; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v5 = 0;
while ( a1 > 0 )
{
v1 = v5++;
binary_1[v1] = a1 % 2 + 48;
a1 /= 2;
}
binary_1[v5] = 0;
v6 = 0;
for ( i = v5 - 1; v6 < i; --i )
{
v4 = binary_1[v6];
binary_1[v6] = binary_1[i];
binary_1[i] = v4;
++v6;
}
return binary_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011b8
LAB_0010117d:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
LEA ECX,[RAX + 0x30]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],CL
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
LAB_001011b8:
CMP dword ptr [RBP + -0x14],0x0
JG 0x0010117d
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010122d
LAB_001011e0:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
MOV byte ptr [RBP + -0xd],AL
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EDX,byte ptr [RAX + RDX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[0x104040]
MOVZX EDX,byte ptr [RBP + -0xd]
MOV byte ptr [RAX + RCX*0x1],DL
ADD dword ptr [RBP + -0x8],0x1
SUB dword ptr [RBP + -0x4],0x1
LAB_0010122d:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011e0
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(int param_1)
{
int uVar1;
char cVar2;
int local_1c;
int local_14;
int local_10;
int local_c;
local_14 = 0;
for (local_1c = param_1; 0 < local_1c; local_1c = local_1c / 2) {
cVar2 = (char)(local_1c >> 0x1f);
binary_1[local_14] = ((char)local_1c - cVar2 & 1U) + cVar2 + '0';
local_14 = local_14 + 1;
}
binary_1[local_14] = 0;
for (local_10 = 0; local_c = local_14 + -1, local_10 < local_c; local_10 = local_10 + 1) {
uVar1 = binary_1[local_10];
binary_1[local_10] = binary_1[local_c];
binary_1[local_c] = uVar1;
local_14 = local_c;
}
return binary_1;
} |
4,289 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[start];
binary[start] = binary[end];
binary[end] = temp;
start++;
end--;
}
return binary;
}
| int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 11d9 <func0+0x90>
lea 0x2ee4(%rip),%rcx
mov $0x0,%edx
mov %edx,%r8d
add $0x1,%edx
mov %edi,%esi
shr $0x1f,%esi
lea (%rdi,%rsi,1),%eax
and $0x1,%eax
sub %esi,%eax
add $0x30,%eax
mov %al,(%rcx)
mov %edi,%eax
mov %edi,%esi
shr $0x1f,%esi
add %esi,%edi
sar %edi
add $0x1,%rcx
cmp $0x1,%eax
jg 1161 <func0+0x18>
movslq %edx,%rdx
lea 0x2ea9(%rip),%rax
movb $0x0,(%rax,%rdx,1)
test %r8d,%r8d
jle 11d1 <func0+0x88>
movslq %r8d,%rdx
add %rax,%rdx
mov $0x0,%eax
lea 0x2e8e(%rip),%rcx
movzbl (%rcx,%rax,1),%esi
movzbl (%rdx),%edi
mov %dil,(%rcx,%rax,1)
mov %sil,(%rdx)
add $0x1,%rax
sub $0x1,%rdx
mov %r8d,%esi
sub %eax,%esi
cmp %eax,%esi
jg 11b2 <func0+0x69>
lea 0x2e68(%rip),%rax
retq
movb $0x0,0x2e60(%rip)
jmp 11d1 <func0+0x88>
| func0:
endbr64
test edi, edi
jle loc_11F9
lea rcx, binary_1
mov edx, 0
loc_1181:
mov r8d, edx
add edx, 1
mov esi, edi
shr esi, 1Fh
lea eax, [rdi+rsi]
and eax, 1
sub eax, esi
add eax, 30h ; '0'
mov [rcx], al
mov eax, edi
mov esi, edi
shr esi, 1Fh
add edi, esi
sar edi, 1
add rcx, 1
cmp eax, 1
jg short loc_1181
movsxd rdx, edx
lea rax, binary_1
mov byte ptr [rax+rdx], 0
test r8d, r8d
jle short loc_11F1
movsxd rdx, r8d
add rdx, rax
mov eax, 0
lea rcx, binary_1
loc_11D2:
movzx esi, byte ptr [rcx+rax]
movzx edi, byte ptr [rdx]
mov [rcx+rax], dil
mov [rdx], sil
add rax, 1
sub rdx, 1
mov esi, r8d
sub esi, eax
cmp esi, eax
jg short loc_11D2
loc_11F1:
lea rax, binary_1
retn
loc_11F9:
mov cs:binary_1, 0
jmp short loc_11F1 | char * func0(int a1)
{
char *v1; // rcx
int v2; // edx
int v3; // r8d
int v4; // eax
char *v5; // rdx
long long v6; // rax
char v7; // si
if ( a1 <= 0 )
{
binary_1[0] = 0;
}
else
{
v1 = binary_1;
v2 = 0;
do
{
v3 = v2++;
*v1 = a1 % 2 + 48;
v4 = a1;
a1 /= 2;
++v1;
}
while ( v4 > 1 );
binary_1[v2] = 0;
if ( v3 > 0 )
{
v5 = &binary_1[v3];
v6 = 0LL;
do
{
v7 = binary_1[v6];
binary_1[v6] = *v5;
*v5 = v7;
++v6;
--v5;
}
while ( v3 - (int)v6 > (int)v6 );
}
}
return binary_1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011f9
LEA RCX,[0x104040]
MOV EDX,0x0
LAB_00101181:
MOV R8D,EDX
ADD EDX,0x1
MOV ESI,EDI
SHR ESI,0x1f
LEA EAX,[RDI + RSI*0x1]
AND EAX,0x1
SUB EAX,ESI
ADD EAX,0x30
MOV byte ptr [RCX],AL
MOV EAX,EDI
MOV ESI,EDI
SHR ESI,0x1f
ADD EDI,ESI
SAR EDI,0x1
ADD RCX,0x1
CMP EAX,0x1
JG 0x00101181
MOVSXD RDX,EDX
LEA RAX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
TEST R8D,R8D
JLE 0x001011f1
MOVSXD RDX,R8D
ADD RDX,RAX
MOV EAX,0x0
LEA RCX,[0x104040]
LAB_001011d2:
MOVZX ESI,byte ptr [RCX + RAX*0x1]
MOVZX EDI,byte ptr [RDX]
MOV byte ptr [RCX + RAX*0x1],DIL
MOV byte ptr [RDX],SIL
ADD RAX,0x1
SUB RDX,0x1
MOV ESI,R8D
SUB ESI,EAX
CMP ESI,EAX
JG 0x001011d2
LAB_001011f1:
LEA RAX,[0x104040]
RET
LAB_001011f9:
MOV byte ptr [0x00104040],0x0
JMP 0x001011f1 | int1 * func0(int param_1)
{
int1 uVar1;
bool bVar2;
char cVar3;
int iVar4;
long lVar5;
char *pcVar6;
int iVar7;
int1 *puVar8;
if (param_1 < 1) {
binary_1 = 0;
}
else {
pcVar6 = &binary_1;
iVar4 = 0;
do {
iVar7 = iVar4;
cVar3 = (char)(param_1 >> 0x1f);
*pcVar6 = ((char)param_1 - cVar3 & 1U) + cVar3 + '0';
pcVar6 = pcVar6 + 1;
bVar2 = 1 < param_1;
param_1 = param_1 / 2;
iVar4 = iVar7 + 1;
} while (bVar2);
(&binary_1)[iVar7 + 1] = 0;
if (0 < iVar7) {
puVar8 = &binary_1 + iVar7;
lVar5 = 0;
do {
uVar1 = (&binary_1)[lVar5];
(&binary_1)[lVar5] = *puVar8;
*puVar8 = uVar1;
lVar5 = lVar5 + 1;
puVar8 = puVar8 + -1;
} while ((int)lVar5 < iVar7 - (int)lVar5);
}
}
return &binary_1;
} |
4,290 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[start];
binary[start] = binary[end];
binary[end] = temp;
start++;
end--;
}
return binary;
}
| int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1350 <func0+0x80>
lea 0x2d61(%rip),%rsi
xor %r8d,%r8d
mov %rsi,%rdx
nopl (%rax)
mov %edi,%eax
add $0x1,%rdx
mov %r8d,%ecx
and $0x1,%eax
lea 0x1(%r8),%r8d
add $0x30,%eax
mov %al,-0x1(%rdx)
sar %edi
jne 12e8 <func0+0x18>
movslq %r8d,%r8
movb $0x0,(%rsi,%r8,1)
test %ecx,%ecx
je 1340 <func0+0x70>
movslq %ecx,%rdx
xor %eax,%eax
add %rsi,%rdx
nopw %cs:0x0(%rax,%rax,1)
movzbl (%rsi,%rax,1),%edi
movzbl (%rdx),%r8d
sub $0x1,%rdx
mov %r8b,(%rsi,%rax,1)
add $0x1,%rax
mov %dil,0x1(%rdx)
mov %ecx,%edi
sub %eax,%edi
cmp %eax,%edi
jg 1320 <func0+0x50>
lea 0x2cf9(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
movb $0x0,0x2ce9(%rip)
lea 0x2ce2(%rip),%rax
retq
| func0:
endbr64
test edi, edi
jle short loc_12B0
lea r8, binary_1
xor esi, esi
mov rdx, r8
nop dword ptr [rax+00h]
loc_1258:
mov eax, edi
add rdx, 1
mov ecx, esi
and eax, 1
lea esi, [rsi+1]
add eax, 30h ; '0'
mov [rdx-1], al
sar edi, 1
jnz short loc_1258
movsxd rsi, esi
mov byte ptr [r8+rsi], 0
test ecx, ecx
jz short loc_12A8
movsxd rdx, ecx
xor eax, eax
add rdx, r8
nop dword ptr [rax+00h]
loc_1288:
movzx esi, byte ptr [r8+rax]
movzx edi, byte ptr [rdx]
sub rdx, 1
mov [r8+rax], dil
add rax, 1
mov [rdx+1], sil
mov esi, ecx
sub esi, eax
cmp esi, eax
jg short loc_1288
loc_12A8:
mov rax, r8
retn
loc_12B0:
lea r8, binary_1
mov cs:binary_1, 0
mov rax, r8
retn | char * func0(int a1)
{
int v1; // esi
char *v2; // rdx
int v3; // ecx
long long v4; // rax
char *v5; // rdx
char v6; // si
char v7; // di
if ( a1 <= 0 )
{
binary_1[0] = 0;
return binary_1;
}
else
{
v1 = 0;
v2 = binary_1;
do
{
++v2;
v3 = v1++;
*(v2 - 1) = (a1 & 1) + 48;
a1 >>= 1;
}
while ( a1 );
binary_1[v1] = 0;
if ( v3 )
{
v4 = 0LL;
v5 = &binary_1[v3];
do
{
v6 = binary_1[v4];
v7 = *v5--;
binary_1[v4++] = v7;
v5[1] = v6;
}
while ( v3 - (int)v4 > (int)v4 );
}
return binary_1;
}
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012b0
LEA R8,[0x104040]
XOR ESI,ESI
MOV RDX,R8
NOP dword ptr [RAX]
LAB_00101258:
MOV EAX,EDI
ADD RDX,0x1
MOV ECX,ESI
AND EAX,0x1
LEA ESI,[RSI + 0x1]
ADD EAX,0x30
MOV byte ptr [RDX + -0x1],AL
SAR EDI,0x1
JNZ 0x00101258
MOVSXD RSI,ESI
MOV byte ptr [R8 + RSI*0x1],0x0
TEST ECX,ECX
JZ 0x001012a8
MOVSXD RDX,ECX
XOR EAX,EAX
ADD RDX,R8
NOP dword ptr [RAX]
LAB_00101288:
MOVZX ESI,byte ptr [R8 + RAX*0x1]
MOVZX EDI,byte ptr [RDX]
SUB RDX,0x1
MOV byte ptr [R8 + RAX*0x1],DIL
ADD RAX,0x1
MOV byte ptr [RDX + 0x1],SIL
MOV ESI,ECX
SUB ESI,EAX
CMP ESI,EAX
JG 0x00101288
LAB_001012a8:
MOV RAX,R8
RET
LAB_001012b0:
LEA R8,[0x104040]
MOV byte ptr [0x00104040],0x0
MOV RAX,R8
RET | int1 * func0(int param_1)
{
int1 uVar1;
int iVar2;
long lVar3;
char *pcVar4;
int1 *puVar5;
int iVar6;
if (0 < param_1) {
pcVar4 = &binary_1;
iVar2 = 0;
do {
iVar6 = iVar2;
*pcVar4 = ((byte)param_1 & 1) + 0x30;
param_1 = param_1 >> 1;
pcVar4 = pcVar4 + 1;
iVar2 = iVar6 + 1;
} while (param_1 != 0);
(&binary_1)[iVar6 + 1] = 0;
if (iVar6 != 0) {
lVar3 = 0;
puVar5 = &binary_1 + iVar6;
do {
uVar1 = (&binary_1)[lVar3];
(&binary_1)[lVar3] = *puVar5;
lVar3 = lVar3 + 1;
*puVar5 = uVar1;
puVar5 = puVar5 + -1;
} while ((int)lVar3 < iVar6 - (int)lVar3);
}
return &binary_1;
}
binary_1 = 0;
return &binary_1;
} |
4,291 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[start];
binary[start] = binary[end];
binary[end] = temp;
start++;
end--;
}
return binary;
}
| int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 14c8 <func0+0x278>
lea 0x2ddd(%rip),%r8
xor %esi,%esi
mov %r8,%rdx
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
add $0x1,%rdx
mov %esi,%ecx
and $0x1,%eax
lea 0x1(%rsi),%esi
add $0x30,%eax
mov %al,-0x1(%rdx)
sar %edi
jne 1270 <func0+0x20>
movslq %esi,%rsi
movb $0x0,(%r8,%rsi,1)
test %ecx,%ecx
je 14b9 <func0+0x269>
movslq %ecx,%rax
movzbl 0x2d9e(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2d92(%rip)
mov %dl,(%r8,%rax,1)
lea -0x1(%rcx),%eax
cmp $0x1,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2d7a(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2d6e(%rip)
mov %dl,(%r8,%rax,1)
lea -0x2(%rcx),%eax
cmp $0x2,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2d56(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2d4a(%rip)
mov %dl,(%r8,%rax,1)
lea -0x3(%rcx),%eax
cmp $0x3,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2d32(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2d26(%rip)
mov %dl,(%r8,%rax,1)
lea -0x4(%rcx),%eax
cmp $0x4,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2d0e(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2d02(%rip)
mov %dl,(%r8,%rax,1)
lea -0x5(%rcx),%eax
cmp $0x5,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2cea(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2cde(%rip)
mov %dl,(%r8,%rax,1)
lea -0x6(%rcx),%eax
cmp $0x6,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2cc6(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2cba(%rip)
mov %dl,(%r8,%rax,1)
lea -0x7(%rcx),%eax
cmp $0x7,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2ca2(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2c96(%rip)
mov %dl,(%r8,%rax,1)
lea -0x8(%rcx),%eax
cmp $0x8,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2c7e(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2c72(%rip)
mov %dl,(%r8,%rax,1)
lea -0x9(%rcx),%eax
cmp $0x9,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2c5a(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2c4e(%rip)
mov %dl,(%r8,%rax,1)
lea -0xa(%rcx),%eax
cmp $0xa,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2c36(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2c2a(%rip)
mov %dl,(%r8,%rax,1)
lea -0xb(%rcx),%eax
cmp $0xb,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2c12(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2c06(%rip)
mov %dl,(%r8,%rax,1)
lea -0xc(%rcx),%eax
cmp $0xc,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2bf2(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2be6(%rip)
mov %dl,(%r8,%rax,1)
lea -0xd(%rcx),%eax
cmp $0xd,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2bd2(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2bc6(%rip)
mov %dl,(%r8,%rax,1)
lea -0xe(%rcx),%eax
cmp $0xe,%eax
jle 14b9 <func0+0x269>
cltq
movzbl 0x2bb2(%rip),%edx
movzbl (%r8,%rax,1),%esi
mov %sil,0x2ba6(%rip)
mov %dl,(%r8,%rax,1)
cmp $0x1f,%ecx
jne 14b9 <func0+0x269>
rolw $0x8,0x2b96(%rip)
lea 0x2b80(%rip),%rax
retq
nopl 0x0(%rax)
movb $0x0,0x2b71(%rip)
lea 0x2b6a(%rip),%rax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_12B8
lea rsi, binary_1
xor r8d, r8d
mov rdx, rsi
nop dword ptr [rax]
loc_1258:
mov eax, edi
add rdx, 1
mov ecx, r8d
and eax, 1
lea r8d, [r8+1]
add eax, 30h ; '0'
mov [rdx-1], al
sar edi, 1
jnz short loc_1258
movsxd r8, r8d
mov byte ptr [rsi+r8], 0
test ecx, ecx
jz short loc_12B0
movsxd rdx, ecx
xor eax, eax
add rdx, rsi
nop word ptr [rax+rax+00000000h]
loc_1290:
movzx edi, byte ptr [rsi+rax]
movzx r8d, byte ptr [rdx]
sub rdx, 1
mov [rsi+rax], r8b
add rax, 1
mov [rdx+1], dil
mov edi, ecx
sub edi, eax
cmp edi, eax
jg short loc_1290
loc_12B0:
mov rax, rsi
retn
loc_12B8:
lea rsi, binary_1
mov cs:binary_1, 0
mov rax, rsi
retn | char * func0(int a1)
{
int v1; // r8d
char *v2; // rdx
int v3; // ecx
long long v4; // rax
char *v5; // rdx
char v6; // di
char v7; // r8
if ( a1 <= 0 )
{
binary_1[0] = 0;
return binary_1;
}
else
{
v1 = 0;
v2 = binary_1;
do
{
++v2;
v3 = v1++;
*(v2 - 1) = (a1 & 1) + 48;
a1 >>= 1;
}
while ( a1 );
binary_1[v1] = 0;
if ( v3 )
{
v4 = 0LL;
v5 = &binary_1[v3];
do
{
v6 = binary_1[v4];
v7 = *v5--;
binary_1[v4++] = v7;
v5[1] = v6;
}
while ( v3 - (int)v4 > (int)v4 );
}
return binary_1;
}
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012b8
LEA RSI,[0x104040]
XOR R8D,R8D
MOV RDX,RSI
NOP dword ptr [RAX]
LAB_00101258:
MOV EAX,EDI
ADD RDX,0x1
MOV ECX,R8D
AND EAX,0x1
LEA R8D,[R8 + 0x1]
ADD EAX,0x30
MOV byte ptr [RDX + -0x1],AL
SAR EDI,0x1
JNZ 0x00101258
MOVSXD R8,R8D
MOV byte ptr [RSI + R8*0x1],0x0
TEST ECX,ECX
JZ 0x001012b0
MOVSXD RDX,ECX
XOR EAX,EAX
ADD RDX,RSI
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
MOVZX EDI,byte ptr [RSI + RAX*0x1]
MOVZX R8D,byte ptr [RDX]
SUB RDX,0x1
MOV byte ptr [RSI + RAX*0x1],R8B
ADD RAX,0x1
MOV byte ptr [RDX + 0x1],DIL
MOV EDI,ECX
SUB EDI,EAX
CMP EDI,EAX
JG 0x00101290
LAB_001012b0:
MOV RAX,RSI
RET
LAB_001012b8:
LEA RSI,[0x104040]
MOV byte ptr [0x00104040],0x0
MOV RAX,RSI
RET | int1 * func0(int param_1)
{
int uVar1;
int iVar2;
long lVar3;
char *pcVar4;
int1 *puVar5;
int iVar6;
if (0 < param_1) {
pcVar4 = &binary_1;
iVar2 = 0;
do {
iVar6 = iVar2;
*pcVar4 = ((byte)param_1 & 1) + 0x30;
param_1 = param_1 >> 1;
pcVar4 = pcVar4 + 1;
iVar2 = iVar6 + 1;
} while (param_1 != 0);
(&binary_1)[iVar6 + 1] = 0;
if (iVar6 != 0) {
lVar3 = 0;
puVar5 = &binary_1 + iVar6;
do {
uVar1 = (&binary_1)[lVar3];
(&binary_1)[lVar3] = *puVar5;
lVar3 = lVar3 + 1;
*puVar5 = uVar1;
puVar5 = puVar5 + -1;
} while ((int)lVar3 < iVar6 - (int)lVar3);
}
return &binary_1;
}
binary_1 = 0;
return &binary_1;
} |
4,292 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
isPalindrome = 0;
break;
}
}
if (isPalindrome) {
return i;
}
}
return -1;
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x34(%rbp),%eax
add $0x1,%eax
mov %eax,-0x30(%rbp)
jmpq 125a <func0+0xb1>
mov -0x30(%rbp),%edx
lea -0x20(%rbp),%rax
lea 0xe25(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10b0 <sprintf@plt>
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x24(%rbp)
movl $0x1,-0x2c(%rbp)
movl $0x0,-0x28(%rbp)
jmp 123a <func0+0x91>
mov -0x28(%rbp),%eax
cltq
movzbl -0x20(%rbp,%rax,1),%edx
mov -0x24(%rbp),%eax
sub $0x1,%eax
sub -0x28(%rbp),%eax
cltq
movzbl -0x20(%rbp,%rax,1),%eax
cmp %al,%dl
je 1236 <func0+0x8d>
movl $0x0,-0x2c(%rbp)
jmp 124b <func0+0xa2>
addl $0x1,-0x28(%rbp)
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x28(%rbp)
jl 120f <func0+0x66>
cmpl $0x0,-0x2c(%rbp)
je 1256 <func0+0xad>
mov -0x30(%rbp),%eax
jmp 126c <func0+0xc3>
addl $0x1,-0x30(%rbp)
cmpl $0x7fffffff,-0x30(%rbp)
jne 11d5 <func0+0x2c>
mov $0xffffffff,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1280 <func0+0xd7>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_30], eax
jmp loc_125D
loc_11D5:
mov edx, [rbp+var_30]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_24], eax
mov [rbp+var_2C], 1
mov [rbp+var_28], 0
jmp short loc_123D
loc_1212:
mov eax, [rbp+var_28]
cdqe
movzx edx, [rbp+rax+s]
mov eax, [rbp+var_24]
sub eax, 1
sub eax, [rbp+var_28]
cdqe
movzx eax, [rbp+rax+s]
cmp dl, al
jz short loc_1239
mov [rbp+var_2C], 0
jmp short loc_124E
loc_1239:
add [rbp+var_28], 1
loc_123D:
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_28], eax
jl short loc_1212
loc_124E:
cmp [rbp+var_2C], 0
jz short loc_1259
mov eax, [rbp+var_30]
jmp short loc_126F
loc_1259:
add [rbp+var_30], 1
loc_125D:
cmp [rbp+var_30], 7FFFFFFFh
jnz loc_11D5
mov eax, 0FFFFFFFFh
loc_126F:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1283
call ___stack_chk_fail
locret_1283:
leave
retn | long long func0(int a1)
{
unsigned int i; // [rsp+10h] [rbp-30h]
int v3; // [rsp+14h] [rbp-2Ch]
int j; // [rsp+18h] [rbp-28h]
int v5; // [rsp+1Ch] [rbp-24h]
char s[24]; // [rsp+20h] [rbp-20h] BYREF
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
for ( i = a1 + 1; i != 0x7FFFFFFF; ++i )
{
sprintf(s, "%d", i);
v5 = strlen(s);
v3 = 1;
for ( j = 0; j < v5 / 2; ++j )
{
if ( s[j] != s[v5 - 1 - j] )
{
v3 = 0;
break;
}
}
if ( v3 )
return i;
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0010125d
LAB_001011d5:
MOV EDX,dword ptr [RBP + -0x30]
LEA RAX,[RBP + -0x20]
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010b0
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x2c],0x1
MOV dword ptr [RBP + -0x28],0x0
JMP 0x0010123d
LAB_00101212:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
MOVZX EDX,byte ptr [RBP + RAX*0x1 + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x28]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x20]
CMP DL,AL
JZ 0x00101239
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0010124e
LAB_00101239:
ADD dword ptr [RBP + -0x28],0x1
LAB_0010123d:
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x28],EAX
JL 0x00101212
LAB_0010124e:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00101259
MOV EAX,dword ptr [RBP + -0x30]
JMP 0x0010126f
LAB_00101259:
ADD dword ptr [RBP + -0x30],0x1
LAB_0010125d:
CMP dword ptr [RBP + -0x30],0x7fffffff
JNZ 0x001011d5
MOV EAX,0xffffffff
LAB_0010126f:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101283
CALL 0x00101090
LAB_00101283:
LEAVE
RET | uint func0(int param_1)
{
bool bVar1;
size_t sVar2;
long in_FS_OFFSET;
uint local_38;
int local_30;
char local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
for (local_38 = param_1 + 1; local_38 != 0x7fffffff; local_38 = local_38 + 1) {
sprintf(local_28,"%d",(ulong)local_38);
sVar2 = strlen(local_28);
bVar1 = true;
for (local_30 = 0; local_30 < (int)sVar2 / 2; local_30 = local_30 + 1) {
if (local_28[local_30] != local_28[((int)sVar2 + -1) - local_30]) {
bVar1 = false;
break;
}
}
if (bVar1) goto LAB_0010126f;
}
local_38 = 0xffffffff;
LAB_0010126f:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_38;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,293 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
isPalindrome = 0;
break;
}
}
if (isPalindrome) {
return i;
}
}
return -1;
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp $0x7ffffffe,%edi
je 11b3 <func0+0x2a>
lea 0x1(%rdi),%ebp
mov %rsp,%rbx
jmp 11c9 <func0+0x40>
mov $0xffffffff,%ebp
jmp 1233 <func0+0xaa>
add $0x1,%ebp
cmp $0x7fffffff,%ebp
je 124c <func0+0xc3>
mov %ebp,%r8d
lea 0xe31(%rip),%rcx
mov $0x14,%edx
mov $0x1,%esi
mov %rbx,%rdi
mov $0x0,%eax
callq 1090 <__sprintf_chk@plt>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 1233 <func0+0xaa>
cltq
add %rbx,%rax
mov $0x0,%edx
movzbl -0x1(%rax),%esi
cmp %sil,(%rbx,%rdx,1)
jne 11ba <func0+0x31>
add $0x1,%rdx
sub $0x1,%rax
cmp %edx,%ecx
jg 121d <func0+0x94>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1253 <func0+0xca>
mov %ebp,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
mov $0xffffffff,%ebp
jmp 1233 <func0+0xaa>
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
cmp edi, 7FFFFFFEh
jz short loc_11D9
lea ebx, [rdi+1]
lea rbp, unk_2004
jmp short loc_11EB
loc_11D9:
mov ebx, 0FFFFFFFFh
jmp short loc_1242
loc_11E0:
add ebx, 1
cmp ebx, 7FFFFFFFh
jz short loc_125D
loc_11EB:
mov r12, rsp
mov r8d, ebx
mov rcx, rbp
mov edx, 14h
mov esi, 1
mov rdi, r12
mov eax, 0
call ___sprintf_chk
mov rdi, r12
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1242
cdqe
lea rdx, [rsp+rax+38h+var_38]
mov eax, 0
loc_122C:
movzx esi, byte ptr [rdx-1]
cmp [rsp+rax+38h+var_38], sil
jnz short loc_11E0
add rax, 1
sub rdx, 1
cmp ecx, eax
jg short loc_122C
loc_1242:
mov rax, [rsp+38h+var_20]
sub rax, fs:28h
jnz short loc_1264
mov eax, ebx
add rsp, 20h
pop rbx
pop rbp
pop r12
retn
loc_125D:
mov ebx, 0FFFFFFFFh
jmp short loc_1242
loc_1264:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // ebx
int v2; // eax
int v3; // ecx
_BYTE *v4; // rdx
long long v5; // rax
_BYTE v7[24]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v8; // [rsp+18h] [rbp-20h]
v8 = __readfsqword(0x28u);
if ( a1 == 2147483646 )
{
return (unsigned int)-1;
}
else
{
v1 = a1 + 1;
while ( 1 )
{
__sprintf_chk(v7, 1LL, 20LL, &unk_2004, v1);
v2 = strlen(v7);
v3 = v2 / 2;
if ( v2 <= 1 )
break;
v4 = &v7[v2];
v5 = 0LL;
while ( v7[v5] == *(v4 - 1) )
{
++v5;
--v4;
if ( v3 <= (int)v5 )
return v1;
}
if ( ++v1 == 0x7FFFFFFF )
return (unsigned int)-1;
}
}
return v1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CMP EDI,0x7ffffffe
JZ 0x001011d9
LEA EBX,[RDI + 0x1]
LEA RBP,[0x102004]
JMP 0x001011eb
LAB_001011d9:
MOV EBX,0xffffffff
JMP 0x00101242
LAB_001011e0:
ADD EBX,0x1
CMP EBX,0x7fffffff
JZ 0x0010125d
LAB_001011eb:
MOV R12,RSP
MOV R8D,EBX
MOV RCX,RBP
MOV EDX,0x14
MOV ESI,0x1
MOV RDI,R12
MOV EAX,0x0
CALL 0x001010b0
MOV RDI,R12
CALL 0x00101080
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101242
CDQE
LEA RDX,[RSP + RAX*0x1]
MOV EAX,0x0
LAB_0010122c:
MOVZX ESI,byte ptr [RDX + -0x1]
CMP byte ptr [RSP + RAX*0x1],SIL
JNZ 0x001011e0
ADD RAX,0x1
SUB RDX,0x1
CMP ECX,EAX
JG 0x0010122c
LAB_00101242:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101264
MOV EAX,EBX
ADD RSP,0x20
POP RBX
POP RBP
POP R12
RET
LAB_0010125d:
MOV EBX,0xffffffff
JMP 0x00101242
LAB_00101264:
CALL 0x00101090 | int func0(int param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == 0x7ffffffe) {
param_1 = -1;
}
else {
param_1 = param_1 + 1;
do {
__sprintf_chk(local_38,1,0x14,&DAT_00102004,param_1);
sVar2 = strlen(local_38);
iVar1 = (int)sVar2;
if (iVar1 < 2) goto LAB_00101242;
pcVar4 = local_38 + iVar1;
lVar3 = 0;
while (local_38[lVar3] == pcVar4[-1]) {
lVar3 = lVar3 + 1;
pcVar4 = pcVar4 + -1;
if ((int)(((uint)(sVar2 >> 0x1f) & 1) + iVar1) >> 1 <= (int)lVar3) goto LAB_00101242;
}
param_1 = param_1 + 1;
} while (param_1 != 0x7fffffff);
param_1 = -1;
}
LAB_00101242:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,294 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
isPalindrome = 0;
break;
}
}
if (isPalindrome) {
return i;
}
}
return -1;
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp $0x7ffffffe,%edi
je 1307 <func0+0xd7>
lea 0x1(%rdi),%r12d
mov %rsp,%rbp
lea 0x1(%rsp),%rbx
nopl 0x0(%rax)
mov %r12d,%r8d
lea 0xd92(%rip),%rcx
mov %rbp,%rdi
xor %eax,%eax
mov $0x14,%edx
mov $0x1,%esi
callq 1090 <__sprintf_chk@plt>
mov %rbp,%rax
mov (%rax),%ecx
add $0x4,%rax
lea -0x1010101(%rcx),%edx
not %ecx
and %ecx,%edx
and $0x80808080,%edx
je 1289 <func0+0x59>
mov %edx,%ecx
shr $0x10,%ecx
test $0x8080,%edx
cmove %ecx,%edx
lea 0x2(%rax),%rcx
cmove %rcx,%rax
mov %edx,%edi
add %dl,%dil
sbb $0x3,%rax
sub %rbp,%rax
mov %eax,%ecx
sar %ecx
je 1310 <func0+0xe0>
cltq
sub $0x1,%ecx
mov %rbp,%rdx
add %rbp,%rax
add %rbx,%rcx
jmp 12ed <func0+0xbd>
nopl 0x0(%rax)
add $0x1,%rdx
sub $0x1,%rax
cmp %rcx,%rdx
je 1310 <func0+0xe0>
movzbl -0x1(%rax),%esi
cmp %sil,(%rdx)
je 12e0 <func0+0xb0>
add $0x1,%r12d
cmp $0x7fffffff,%r12d
jne 1268 <func0+0x38>
mov $0xffffffff,%r12d
nopl (%rax)
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 132c <func0+0xfc>
add $0x20,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
cmp edi, 7FFFFFFEh
jz short loc_12F3
lea r12d, [rdi+1]
mov r13, rsp
lea rbp, [rsp+48h+var_47]
lea rbx, unk_2004
nop dword ptr [rax+00000000h]
loc_1290:
mov rcx, rbx
mov r8d, r12d
mov edx, 14h
mov esi, 1
mov rdi, r13
xor eax, eax
call ___sprintf_chk
mov rdi, r13
call _strlen
mov ecx, eax
sar ecx, 1
jz short loc_1300
cdqe
sub ecx, 1
mov rdx, r13
add rax, r13
add rcx, rbp
jmp short loc_12DD
loc_12D0:
add rdx, 1
sub rax, 1
cmp rdx, rcx
jz short loc_1300
loc_12DD:
movzx esi, byte ptr [rax-1]
cmp [rdx], sil
jz short loc_12D0
add r12d, 1
cmp r12d, 7FFFFFFFh
jnz short loc_1290
loc_12F3:
mov r12d, 0FFFFFFFFh
nop dword ptr [rax+00000000h]
loc_1300:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_131E
add rsp, 28h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
retn
loc_131E:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // r12d
int v2; // eax
int v3; // ecx
char *v4; // rdx
char *v5; // rax
char *v6; // rcx
_QWORD v8[9]; // [rsp+0h] [rbp-48h] BYREF
v8[3] = __readfsqword(0x28u);
if ( a1 == 2147483646 )
{
return (unsigned int)-1;
}
else
{
v1 = a1 + 1;
while ( 1 )
{
__sprintf_chk(v8, 1LL, 20LL, &unk_2004, v1);
v2 = strlen(v8);
v3 = v2 >> 1;
if ( !(v2 >> 1) )
break;
v4 = (char *)v8;
v5 = (char *)v8 + v2;
v6 = (char *)v8 + (unsigned int)(v3 - 1) + 1;
while ( *v4 == *(v5 - 1) )
{
++v4;
--v5;
if ( v4 == v6 )
return v1;
}
if ( ++v1 == 0x7FFFFFFF )
return (unsigned int)-1;
}
}
return v1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CMP EDI,0x7ffffffe
JZ 0x001012f3
LEA R12D,[RDI + 0x1]
MOV R13,RSP
LEA RBP,[RSP + 0x1]
LEA RBX,[0x102004]
NOP dword ptr [RAX]
LAB_00101290:
MOV RCX,RBX
MOV R8D,R12D
MOV EDX,0x14
MOV ESI,0x1
MOV RDI,R13
XOR EAX,EAX
CALL 0x001010b0
MOV RDI,R13
CALL 0x00101080
MOV ECX,EAX
SAR ECX,0x1
JZ 0x00101300
CDQE
SUB ECX,0x1
MOV RDX,R13
ADD RAX,R13
ADD RCX,RBP
JMP 0x001012dd
LAB_001012d0:
ADD RDX,0x1
SUB RAX,0x1
CMP RDX,RCX
JZ 0x00101300
LAB_001012dd:
MOVZX ESI,byte ptr [RAX + -0x1]
CMP byte ptr [RDX],SIL
JZ 0x001012d0
ADD R12D,0x1
CMP R12D,0x7fffffff
JNZ 0x00101290
LAB_001012f3:
MOV R12D,0xffffffff
NOP dword ptr [RAX]
LAB_00101300:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010131e
ADD RSP,0x28
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010131e:
CALL 0x00101090 | int func0(int param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != 0x7ffffffe) {
param_1 = param_1 + 1;
do {
__sprintf_chk(local_48,1,0x14,&DAT_00102004,param_1);
sVar1 = strlen(local_48);
iVar3 = (int)sVar1 >> 1;
if (iVar3 == 0) goto LAB_00101300;
pcVar2 = local_48 + (int)sVar1;
pcVar4 = local_48;
while (*pcVar4 == pcVar2[-1]) {
pcVar4 = pcVar4 + 1;
pcVar2 = pcVar2 + -1;
if (pcVar4 == local_48 + (ulong)(iVar3 - 1) + 1) goto LAB_00101300;
}
param_1 = param_1 + 1;
} while (param_1 != 0x7fffffff);
}
param_1 = -1;
LAB_00101300:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,295 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
isPalindrome = 0;
break;
}
}
if (isPalindrome) {
return i;
}
}
return -1;
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp $0x7ffffffe,%edi
je 13d1 <func0+0x1a1>
lea 0x1(%rdi),%r12d
mov %rsp,%rbp
lea 0xd9e(%rip),%rbx
nopw %cs:0x0(%rax,%rax,1)
mov %r12d,%r8d
mov %rbx,%rcx
mov $0x14,%edx
mov $0x1,%esi
mov %rbp,%rdi
xor %eax,%eax
callq 1090 <__sprintf_chk@plt>
mov %rbp,%rax
mov (%rax),%ecx
add $0x4,%rax
lea -0x1010101(%rcx),%edx
not %ecx
and %ecx,%edx
and $0x80808080,%edx
je 128d <func0+0x5d>
mov %edx,%ecx
shr $0x10,%ecx
test $0x8080,%edx
cmove %ecx,%edx
lea 0x2(%rax),%rcx
cmove %rcx,%rax
mov %edx,%esi
add %dl,%sil
sbb $0x3,%rax
sub %rbp,%rax
mov %eax,%ecx
mov %eax,%edx
sar %ecx
je 139a <func0+0x16a>
sub $0x1,%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,(%rsp)
jne 13c0 <func0+0x190>
cmp $0x1,%ecx
je 139a <func0+0x16a>
lea -0x2(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x1(%rsp)
jne 13c0 <func0+0x190>
cmp $0x2,%ecx
je 139a <func0+0x16a>
lea -0x3(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x2(%rsp)
jne 13c0 <func0+0x190>
cmp $0x3,%ecx
je 139a <func0+0x16a>
lea -0x4(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x3(%rsp)
jne 13c0 <func0+0x190>
cmp $0x4,%ecx
je 139a <func0+0x16a>
lea -0x5(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x4(%rsp)
jne 13c0 <func0+0x190>
cmp $0x5,%ecx
je 139a <func0+0x16a>
lea -0x6(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x5(%rsp)
jne 13c0 <func0+0x190>
cmp $0x6,%ecx
je 139a <func0+0x16a>
lea -0x7(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x6(%rsp)
jne 13c0 <func0+0x190>
cmp $0x7,%ecx
je 139a <func0+0x16a>
lea -0x8(%rdx),%eax
cltq
movzbl (%rsp,%rax,1),%eax
cmp %al,0x7(%rsp)
jne 13c0 <func0+0x190>
cmp $0x9,%ecx
jne 139a <func0+0x16a>
sub $0x9,%edx
movslq %edx,%rdx
movzbl (%rsp,%rdx,1),%eax
cmp %al,0x8(%rsp)
jne 13c0 <func0+0x190>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 13d9 <func0+0x1a9>
add $0x20,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%r12d
cmp $0x7fffffff,%r12d
jne 1270 <func0+0x40>
mov $0xffffffff,%r12d
jmp 139a <func0+0x16a>
callq 1070 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r12
lea r12d, [rdi+1]
push rbp
lea rbp, unk_2004
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov rbx, rsp
cmp edi, 7FFFFFFEh
jz loc_13C9
nop word ptr [rax+rax+00000000h]
loc_1290:
mov edx, 14h
mov r8d, r12d
mov rcx, rbp
mov esi, 2
mov rdi, rbx
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strlen
mov edx, eax
sar edx, 1
jz loc_1396
lea ecx, [rax-1]
movsxd rcx, ecx
movzx esi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_38], sil
jnz loc_13B8
cmp edx, 1
jz loc_1396
lea ecx, [rax-2]
movsxd rcx, ecx
movzx edi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_37], dil
jnz loc_13B8
cmp edx, 2
jz loc_1396
lea ecx, [rax-3]
movsxd rcx, ecx
movzx esi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_36], sil
jnz loc_13B8
cmp edx, 3
jz loc_1396
lea ecx, [rax-4]
movsxd rcx, ecx
movzx edi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_35], dil
jnz loc_13B8
cmp edx, 4
jz short loc_1396
lea ecx, [rax-5]
movsxd rcx, ecx
movzx esi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_34], sil
jnz short loc_13B8
cmp edx, 5
jz short loc_1396
lea ecx, [rax-6]
movsxd rcx, ecx
movzx edi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_33], dil
jnz short loc_13B8
cmp edx, 6
jz short loc_1396
lea ecx, [rax-7]
movsxd rcx, ecx
movzx esi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_32], sil
jnz short loc_13B8
cmp edx, 7
jz short loc_1396
lea ecx, [rax-8]
movsxd rcx, ecx
movzx esi, [rsp+rcx+38h+var_38]
cmp [rsp+38h+var_31], sil
jnz short loc_13B8
cmp edx, 9
jnz short loc_1396
sub eax, 9
cdqe
movzx eax, [rsp+rax+38h+var_38]
cmp [rsp+38h+var_30], al
jnz short loc_13B8
loc_1396:
mov rax, [rsp+38h+var_20]
sub rax, fs:28h
jnz short loc_13D1
add rsp, 20h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_13B8:
add r12d, 1
cmp r12d, 7FFFFFFFh
jnz loc_1290
loc_13C9:
mov r12d, 0FFFFFFFFh
jmp short loc_1396
loc_13D1:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // r12d
int v2; // eax
int v3; // edx
char v5[24]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v6; // [rsp+18h] [rbp-20h]
v1 = a1 + 1;
v6 = __readfsqword(0x28u);
if ( a1 == 2147483646 )
{
return (unsigned int)-1;
}
else
{
while ( 1 )
{
__sprintf_chk(v5, 2LL, 20LL, &unk_2004, v1);
v2 = strlen(v5);
v3 = v2 >> 1;
if ( !(v2 >> 1)
|| v5[0] == v5[v2 - 1]
&& (v3 == 1
|| v5[1] == v5[v2 - 2]
&& (v3 == 2
|| v5[2] == v5[v2 - 3]
&& (v3 == 3
|| v5[3] == v5[v2 - 4]
&& (v3 == 4
|| v5[4] == v5[v2 - 5]
&& (v3 == 5
|| v5[5] == v5[v2 - 6]
&& (v3 == 6 || v5[6] == v5[v2 - 7] && (v3 == 7 || v5[7] == v5[v2 - 8] && (v3 != 9 || v5[8] == v5[v2 - 9])))))))) )
{
break;
}
if ( ++v1 == 0x7FFFFFFF )
return (unsigned int)-1;
}
}
return v1;
} | func0:
ENDBR64
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
LEA RBP,[0x102004]
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RBX,RSP
CMP EDI,0x7ffffffe
JZ 0x001013c9
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
MOV EDX,0x14
MOV R8D,R12D
MOV RCX,RBP
MOV ESI,0x2
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001010b0
MOV RDI,RBX
CALL 0x00101080
MOV EDX,EAX
SAR EDX,0x1
JZ 0x00101396
LEA ECX,[RAX + -0x1]
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP],SIL
JNZ 0x001013b8
CMP EDX,0x1
JZ 0x00101396
LEA ECX,[RAX + -0x2]
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x1],DIL
JNZ 0x001013b8
CMP EDX,0x2
JZ 0x00101396
LEA ECX,[RAX + -0x3]
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x2],SIL
JNZ 0x001013b8
CMP EDX,0x3
JZ 0x00101396
LEA ECX,[RAX + -0x4]
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x3],DIL
JNZ 0x001013b8
CMP EDX,0x4
JZ 0x00101396
LEA ECX,[RAX + -0x5]
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x4],SIL
JNZ 0x001013b8
CMP EDX,0x5
JZ 0x00101396
LEA ECX,[RAX + -0x6]
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x5],DIL
JNZ 0x001013b8
CMP EDX,0x6
JZ 0x00101396
LEA ECX,[RAX + -0x7]
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x6],SIL
JNZ 0x001013b8
CMP EDX,0x7
JZ 0x00101396
LEA ECX,[RAX + -0x8]
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RSP + RCX*0x1]
CMP byte ptr [RSP + 0x7],SIL
JNZ 0x001013b8
CMP EDX,0x9
JNZ 0x00101396
SUB EAX,0x9
CDQE
MOVZX EAX,byte ptr [RSP + RAX*0x1]
CMP byte ptr [RSP + 0x8],AL
JNZ 0x001013b8
LAB_00101396:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013d1
ADD RSP,0x20
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_001013b8:
ADD R12D,0x1
CMP R12D,0x7fffffff
JNZ 0x00101290
LAB_001013c9:
MOV R12D,0xffffffff
JMP 0x00101396
LAB_001013d1:
CALL 0x00101090 | int func0(int param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
char local_38 [4];
char local_34;
char local_33;
char local_32;
char local_31;
char local_30;
long local_20;
iVar4 = param_1 + 1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != 0x7ffffffe) {
do {
__sprintf_chk(local_38,2,0x14,&DAT_00102004,iVar4);
sVar2 = strlen(local_38);
iVar1 = (int)sVar2;
iVar3 = iVar1 >> 1;
if ((iVar3 == 0) ||
((local_38[0] == local_38[iVar1 + -1] &&
((iVar3 == 1 ||
((local_38[1] == local_38[iVar1 + -2] &&
((iVar3 == 2 ||
((local_38[2] == local_38[iVar1 + -3] &&
((iVar3 == 3 ||
((local_38[3] == local_38[iVar1 + -4] &&
((iVar3 == 4 ||
((local_34 == local_38[iVar1 + -5] &&
((iVar3 == 5 ||
((local_33 == local_38[iVar1 + -6] &&
((iVar3 == 6 ||
((local_32 == local_38[iVar1 + -7] &&
((iVar3 == 7 ||
((local_31 == local_38[iVar1 + -8] &&
((iVar3 != 9 || (local_30 == local_38[iVar1 + -9])))))))))))))))))))))))))))
))))))) goto LAB_00101396;
iVar4 = iVar4 + 1;
} while (iVar4 != 0x7fffffff);
}
iVar4 = -1;
LAB_00101396:
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar4;
} |
4,296 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr[k - 1];
}
| int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1248 <func0+0xdf>
movl $0x0,-0x8(%rbp)
jmpq 1232 <func0+0xc9>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 122e <func0+0xc5>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x1c(%rbp),%eax
sub -0xc(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x8(%rbp)
jl 1193 <func0+0x2a>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1187 <func0+0x1e>
mov -0x20(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 0
jmp loc_1248
loc_1187:
mov [rbp+var_8], 0
jmp loc_1232
loc_1193:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_122E
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_122E:
add [rbp+var_8], 1
loc_1232:
mov eax, [rbp+var_1C]
sub eax, [rbp+var_C]
sub eax, 1
cmp [rbp+var_8], eax
jl loc_1193
add [rbp+var_C], 1
loc_1248:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_1187
mov eax, [rbp+var_20]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) > *(_DWORD *)(4 * (j + 1LL) + a1) )
{
v6 = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(4LL * j + a1) = *(_DWORD *)(4 * (j + 1LL) + a1);
*(_DWORD *)(a1 + 4 * (j + 1LL)) = v6;
}
}
}
return *(unsigned int *)(4LL * a3 - 4 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101248
LAB_00101187:
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101232
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010122e
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_0010122e:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101232:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
CMP dword ptr [RBP + -0x8],EAX
JL 0x00101193
ADD dword ptr [RBP + -0xc],0x1
LAB_00101248:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101187
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
POP RBP
RET | int4 func0(long param_1,int param_2,int param_3)
{
int4 uVar1;
int4 local_14;
int4 local_10;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
for (local_10 = 0; local_10 < (param_2 - local_14) + -1; local_10 = local_10 + 1) {
if (*(int *)(param_1 + ((long)local_10 + 1) * 4) < *(int *)(param_1 + (long)local_10 * 4)) {
uVar1 = *(int4 *)(param_1 + (long)local_10 * 4);
*(int4 *)(param_1 + (long)local_10 * 4) =
*(int4 *)(param_1 + ((long)local_10 + 1) * 4);
*(int4 *)(((long)local_10 + 1) * 4 + param_1) = uVar1;
}
}
}
return *(int4 *)(param_1 + (long)param_3 * 4 + -4);
} |
4,297 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr[k - 1];
}
| int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 119e <func0+0x35>
lea -0x1(%rsi),%r9d
lea 0x4(%rdi),%r10
jmp 11aa <func0+0x41>
add $0x4,%rax
cmp %r8,%rax
je 11a6 <func0+0x3d>
mov (%rax),%ecx
mov 0x4(%rax),%esi
cmp %esi,%ecx
jle 117b <func0+0x12>
mov %esi,(%rax)
mov %ecx,0x4(%rax)
jmp 117b <func0+0x12>
sub $0x1,%r9d
cmp $0xffffffff,%r9d
jne 11aa <func0+0x41>
movslq %edx,%rax
mov -0x4(%rdi,%rax,4),%eax
retq
sub $0x1,%r9d
test %r9d,%r9d
jle 1194 <func0+0x2b>
mov %rdi,%rax
lea -0x1(%r9),%ecx
lea (%r10,%rcx,4),%r8
jmp 1184 <func0+0x1b>
| func0:
endbr64
test esi, esi
jle short loc_119E
lea r9d, [rsi-1]
lea r10, [rdi+4]
jmp short loc_11AA
loc_117B:
add rax, 4
cmp rax, r8
jz short loc_11A6
loc_1184:
mov ecx, [rax]
mov esi, [rax+4]
cmp ecx, esi
jle short loc_117B
mov [rax], esi
mov [rax+4], ecx
jmp short loc_117B
loc_1194:
sub r9d, 1
cmp r9d, 0FFFFFFFFh
jnz short loc_11AA
loc_119E:
movsxd rax, edx
mov eax, [rdi+rax*4-4]
retn
loc_11A6:
sub r9d, 1
loc_11AA:
test r9d, r9d
jle short loc_1194
mov rax, rdi
lea ecx, [r9-1]
lea r8, [r10+rcx*4]
jmp short loc_1184 | long long func0(int *a1, int a2, int a3)
{
int v3; // r9d
int *v4; // rax
int v5; // ecx
int v6; // esi
if ( a2 > 0 )
{
v3 = a2 - 1;
do
{
while ( v3 > 0 )
{
v4 = a1;
do
{
v5 = *v4;
v6 = v4[1];
if ( *v4 > v6 )
{
*v4 = v6;
v4[1] = v5;
}
++v4;
}
while ( v4 != &a1[v3 - 1 + 1] );
--v3;
}
--v3;
}
while ( v3 != -1 );
}
return (unsigned int)a1[a3 - 1];
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119e
LEA R9D,[RSI + -0x1]
LEA R10,[RDI + 0x4]
JMP 0x001011aa
LAB_0010117b:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001011a6
LAB_00101184:
MOV ECX,dword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x4]
CMP ECX,ESI
JLE 0x0010117b
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],ECX
JMP 0x0010117b
LAB_00101194:
SUB R9D,0x1
CMP R9D,-0x1
JNZ 0x001011aa
LAB_0010119e:
MOVSXD RAX,EDX
MOV EAX,dword ptr [RDI + RAX*0x4 + -0x4]
RET
LAB_001011a6:
SUB R9D,0x1
LAB_001011aa:
TEST R9D,R9D
JLE 0x00101194
MOV RAX,RDI
LEA ECX,[R9 + -0x1]
LEA R8,[R10 + RCX*0x4]
JMP 0x00101184 | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
if (0 < param_2) {
param_2 = param_2 + -1;
do {
for (; 0 < param_2; param_2 = param_2 + -1) {
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
}
param_2 = param_2 + -1;
} while (param_2 != -1);
}
return param_1[(long)param_3 + -1];
} |
4,298 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr[k - 1];
}
| int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1306 <func0+0x46>
lea -0x1(%rsi),%ecx
lea 0x4(%rdi),%r10
test %ecx,%ecx
je 1306 <func0+0x46>
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rdi,%rax
mov %rcx,%r9
lea (%r10,%rcx,4),%r8
nopl (%rax)
mov (%rax),%ecx
mov 0x4(%rax),%esi
cmp %esi,%ecx
jle 12f6 <func0+0x36>
mov %esi,(%rax)
mov %ecx,0x4(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 12e8 <func0+0x28>
mov %r9d,%ecx
test %ecx,%ecx
jne 12d8 <func0+0x18>
movslq %edx,%rax
mov -0x4(%rdi,%rax,4),%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov r9, rdi
test esi, esi
jle short loc_130E
lea ecx, [rsi-1]
lea r10, [rdi+4]
test ecx, ecx
jz short loc_130E
nop word ptr [rax+rax+00000000h]
loc_12E0:
sub ecx, 1
mov rax, r9
mov r8, rcx
lea rdi, [r10+rcx*4]
nop dword ptr [rax]
loc_12F0:
mov ecx, [rax]
mov esi, [rax+4]
cmp ecx, esi
jle short loc_12FE
mov [rax], esi
mov [rax+4], ecx
loc_12FE:
add rax, 4
cmp rax, rdi
jnz short loc_12F0
mov ecx, r8d
test ecx, ecx
jnz short loc_12E0
loc_130E:
movsxd rax, edx
mov eax, [r9+rax*4-4]
retn | long long func0(int *a1, int a2, int a3)
{
int v4; // ecx
_DWORD *v5; // r10
int *v6; // rax
int v7; // r8d
int *v8; // rdi
int v9; // ecx
int v10; // esi
if ( a2 > 0 )
{
v4 = a2 - 1;
v5 = a1 + 1;
if ( a2 != 1 )
{
do
{
v6 = a1;
v7 = v4 - 1;
v8 = &v5[v4 - 1];
do
{
v9 = *v6;
v10 = v6[1];
if ( *v6 > v10 )
{
*v6 = v10;
v6[1] = v9;
}
++v6;
}
while ( v6 != v8 );
v4 = v7;
}
while ( v7 );
}
}
return (unsigned int)a1[a3 - 1];
} | func0:
ENDBR64
MOV R9,RDI
TEST ESI,ESI
JLE 0x0010130e
LEA ECX,[RSI + -0x1]
LEA R10,[RDI + 0x4]
TEST ECX,ECX
JZ 0x0010130e
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001012e0:
SUB ECX,0x1
MOV RAX,R9
MOV R8,RCX
LEA RDI,[R10 + RCX*0x4]
NOP dword ptr [RAX]
LAB_001012f0:
MOV ECX,dword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x4]
CMP ECX,ESI
JLE 0x001012fe
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],ECX
LAB_001012fe:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x001012f0
MOV ECX,R8D
TEST ECX,ECX
JNZ 0x001012e0
LAB_0010130e:
MOVSXD RAX,EDX
MOV EAX,dword ptr [R9 + RAX*0x4 + -0x4]
RET | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
uint uVar3;
ulong uVar4;
if (0 < param_2) {
uVar3 = param_2 - 1;
uVar4 = (ulong)uVar3;
while (uVar3 != 0) {
uVar3 = (int)uVar4 - 1;
uVar4 = (ulong)uVar3;
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + uVar4 + 1);
}
}
return param_1[(long)param_3 + -1];
} |
4,299 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr[k - 1];
}
| int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 12d6 <func0+0x46>
lea -0x1(%rsi),%ecx
lea 0x4(%rdi),%r10
test %ecx,%ecx
je 12d6 <func0+0x46>
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rdi,%rax
mov %rcx,%r9
lea (%r10,%rcx,4),%r8
nopl (%rax)
mov (%rax),%ecx
mov 0x4(%rax),%esi
cmp %esi,%ecx
jle 12c6 <func0+0x36>
mov %esi,(%rax)
mov %ecx,0x4(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 12b8 <func0+0x28>
mov %r9d,%ecx
test %ecx,%ecx
jne 12a8 <func0+0x18>
movslq %edx,%rax
mov -0x4(%rdi,%rax,4),%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov r9, rdi
test esi, esi
jle short loc_12EC
lea r10, [rdi+4]
loc_129F:
cmp esi, 1
jle short loc_12E7
nop dword ptr [rax+00h]
loc_12A8:
lea ecx, [rsi-2]
mov rax, r9
lea r8, [r10+rcx*4]
nop word ptr [rax+rax+00h]
loc_12B8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edi, xmm1
cmp edi, ecx
jge short loc_12D6
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_12D6:
add rax, 4
cmp rax, r8
jnz short loc_12B8
sub esi, 1
cmp esi, 1
jg short loc_12A8
loc_12E7:
sub esi, 1
jnz short loc_129F
loc_12EC:
movsxd rax, edx
mov eax, [r9+rax*4-4]
retn | long long func0(__m128i *a1, int a2, int a3)
{
__m128i *v3; // rax
__m128i v4; // xmm0
if ( a2 > 0 )
{
do
{
for ( ; a2 > 1; --a2 )
{
v3 = a1;
do
{
v4 = _mm_loadl_epi64(v3);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v4, 229)) < _mm_cvtsi128_si32(v4) )
v3->m128i_i64[0] = _mm_shuffle_epi32(v4, 225).m128i_u64[0];
v3 = (__m128i *)((char *)v3 + 4);
}
while ( v3 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(a2 - 2) + 4) );
}
--a2;
}
while ( a2 );
}
return a1->m128i_u32[a3 - 1];
} | func0:
ENDBR64
MOV R9,RDI
TEST ESI,ESI
JLE 0x001012ec
LEA R10,[RDI + 0x4]
LAB_0010129f:
CMP ESI,0x1
JLE 0x001012e7
NOP dword ptr [RAX]
LAB_001012a8:
LEA ECX,[RSI + -0x2]
MOV RAX,R9
LEA R8,[R10 + RCX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001012b8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDI,XMM1
CMP EDI,ECX
JGE 0x001012d6
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001012d6:
ADD RAX,0x4
CMP RAX,R8
JNZ 0x001012b8
SUB ESI,0x1
CMP ESI,0x1
JG 0x001012a8
LAB_001012e7:
SUB ESI,0x1
JNZ 0x0010129f
LAB_001012ec:
MOVSXD RAX,EDX
MOV EAX,dword ptr [R9 + RAX*0x4 + -0x4]
RET | int4 func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
do {
for (; 1 < param_2; param_2 = param_2 + -1) {
puVar1 = param_1;
do {
iVar2 = (int)*puVar1;
iVar3 = (int)((ulong)*puVar1 >> 0x20);
if (iVar3 < iVar2) {
*puVar1 = CONCAT44(iVar2,iVar3);
}
puVar1 = (int8 *)((long)puVar1 + 4);
} while (puVar1 != (int8 *)((long)param_1 + (ulong)(param_2 - 2) * 4 + 4));
}
param_2 = param_2 + -1;
} while (param_2 != 0);
}
return *(int4 *)((long)param_1 + (long)param_3 * 4 + -4);
} |
4,300 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
output[output_index++] = toupper(word[word_index]);
capitalize_next = 0;
} else {
output[output_index++] = word[word_index];
}
}
word_index++;
}
output[output_index] = '\0';
return output;
}
| int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmpq 1260 <func0+0xb7>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5f,%al
jne 11f4 <func0+0x4b>
movl $0x1,-0x4(%rbp)
jmp 125c <func0+0xb3>
cmpl $0x0,-0x4(%rbp)
je 1236 <func0+0x8d>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 1080 <toupper@plt>
mov %eax,%ecx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
movl $0x0,-0x4(%rbp)
jmp 125c <func0+0xb3>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11d7 <func0+0x2e>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x20(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp loc_1260
loc_11D7:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 5Fh ; '_'
jnz short loc_11F4
mov [rbp+var_4], 1
jmp short loc_125C
loc_11F4:
cmp [rbp+var_4], 0
jz short loc_1236
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _toupper
mov ecx, eax
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov edx, ecx
mov [rax], dl
mov [rbp+var_4], 0
jmp short loc_125C
loc_1236:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
movsxd rdx, eax
mov rax, [rbp+var_20]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_125C:
add [rbp+var_C], 1
loc_1260:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11D7
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_20]
leave
retn | long long func0(long long a1, long long a2)
{
char v2; // cl
int v3; // eax
int v4; // eax
int v6; // [rsp+14h] [rbp-Ch]
int v7; // [rsp+18h] [rbp-8h]
int v8; // [rsp+1Ch] [rbp-4h]
v6 = 0;
v7 = 0;
v8 = 1;
while ( *(_BYTE *)(v6 + a1) )
{
if ( *(_BYTE *)(v6 + a1) == 95 )
{
v8 = 1;
}
else if ( v8 )
{
v2 = toupper(*(char *)(v6 + a1));
v3 = v7++;
*(_BYTE *)(v3 + a2) = v2;
v8 = 0;
}
else
{
v4 = v7++;
*(_BYTE *)(a2 + v4) = *(_BYTE *)(v6 + a1);
}
++v6;
}
*(_BYTE *)(v7 + a2) = 0;
return a2;
} | 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 + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101260
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x5f
JNZ 0x001011f4
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010125c
LAB_001011f4:
CMP dword ptr [RBP + -0x4],0x0
JZ 0x00101236
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x00101080
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010125c
LAB_00101236:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_0010125c:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101260:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011d7
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
LEAVE
RET | long func0(long param_1,long param_2)
{
bool bVar1;
int iVar2;
int4 local_14;
int4 local_10;
local_10 = 0;
bVar1 = true;
for (local_14 = 0; *(char *)(param_1 + local_14) != '\0'; local_14 = local_14 + 1) {
if (*(char *)(param_1 + local_14) == '_') {
bVar1 = true;
}
else if (bVar1) {
iVar2 = toupper((int)*(char *)(param_1 + local_14));
*(char *)(param_2 + local_10) = (char)iVar2;
bVar1 = false;
local_10 = local_10 + 1;
}
else {
*(int *)(local_10 + param_2) = *(int *)(local_14 + param_1);
local_10 = local_10 + 1;
}
}
*(int *)(param_2 + local_10) = 0;
return param_2;
} |
4,301 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
output[output_index++] = toupper(word[word_index]);
capitalize_next = 0;
} else {
output[output_index++] = word[word_index];
}
}
word_index++;
}
output[output_index] = '\0';
return output;
}
| int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rsi,%r13
movzbl (%rdi),%ebx
test %bl,%bl
je 120d <func0+0x84>
lea 0x1(%rdi),%rbp
mov $0x0,%r12d
mov $0x1,%eax
mov $0x1,%r14d
mov $0x0,%r15d
jmp 11e0 <func0+0x57>
movslq %r12d,%rdx
mov %bl,0x0(%r13,%rdx,1)
lea 0x1(%r12),%r12d
jmp 11d4 <func0+0x4b>
mov %r14d,%eax
add $0x1,%rbp
movzbl -0x1(%rbp),%ebx
test %bl,%bl
je 1213 <func0+0x8a>
cmp $0x5f,%bl
je 11d1 <func0+0x48>
test %eax,%eax
je 11c2 <func0+0x39>
callq 1070 <__ctype_toupper_loc@plt>
mov %rax,%rdx
movslq %r12d,%rax
movsbq %bl,%rbx
mov (%rdx),%rdx
mov (%rdx,%rbx,4),%edx
mov %dl,0x0(%r13,%rax,1)
lea 0x1(%r12),%r12d
mov %r15d,%eax
jmp 11d4 <func0+0x4b>
mov $0x0,%r12d
movslq %r12d,%r12
movb $0x0,0x0(%r13,%r12,1)
mov %r13,%rax
add $0x8,%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, 8
mov r13, rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_122D
lea rbp, [rdi+1]
mov r12d, 0
mov eax, 1
mov r14d, 1
mov r15d, 0
jmp short loc_1200
loc_11E2:
movsxd rdx, r12d
mov [r13+rdx+0], bl
lea r12d, [r12+1]
jmp short loc_11F4
loc_11F1:
mov eax, r14d
loc_11F4:
add rbp, 1
movzx ebx, byte ptr [rbp-1]
test bl, bl
jz short loc_1233
loc_1200:
cmp bl, 5Fh ; '_'
jz short loc_11F1
test eax, eax
jz short loc_11E2
call ___ctype_toupper_loc
mov rdx, rax
movsxd rax, r12d
movsx rbx, bl
mov rdx, [rdx]
mov edx, [rdx+rbx*4]
mov [r13+rax+0], dl
lea r12d, [r12+1]
mov eax, r15d
jmp short loc_11F4
loc_122D:
mov r12d, 0
loc_1233:
movsxd r12, r12d
mov byte ptr [r13+r12+0], 0
mov rax, r13
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char *a1, long long a2)
{
char v2; // bl
char *v3; // rbp
int v4; // r12d
int v5; // eax
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 1;
do
{
if ( v2 == 95 )
{
v5 = 1;
}
else if ( v5 )
{
*(_BYTE *)(a2 + v4++) = *(_DWORD *)(*(_QWORD *)__ctype_toupper_loc() + 4LL * v2);
v5 = 0;
}
else
{
*(_BYTE *)(a2 + v4++) = v2;
}
v2 = *v3++;
}
while ( v2 );
}
else
{
v4 = 0;
}
*(_BYTE *)(a2 + v4) = 0;
return a2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x0010122d
LEA RBP,[RDI + 0x1]
MOV R12D,0x0
MOV EAX,0x1
MOV R14D,0x1
MOV R15D,0x0
JMP 0x00101200
LAB_001011e2:
MOVSXD RDX,R12D
MOV byte ptr [R13 + RDX*0x1],BL
LEA R12D,[R12 + 0x1]
JMP 0x001011f4
LAB_001011f1:
MOV EAX,R14D
LAB_001011f4:
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP + -0x1]
TEST BL,BL
JZ 0x00101233
LAB_00101200:
CMP BL,0x5f
JZ 0x001011f1
TEST EAX,EAX
JZ 0x001011e2
CALL 0x00101080
MOV RDX,RAX
MOVSXD RAX,R12D
MOVSX RBX,BL
MOV RDX,qword ptr [RDX]
MOV EDX,dword ptr [RDX + RBX*0x4]
MOV byte ptr [R13 + RAX*0x1],DL
LEA R12D,[R12 + 0x1]
MOV EAX,R15D
JMP 0x001011f4
LAB_0010122d:
MOV R12D,0x0
LAB_00101233:
MOVSXD R12,R12D
MOV byte ptr [R13 + R12*0x1],0x0
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | long func0(char *param_1,long param_2)
{
bool bVar1;
__int32_t **pp_Var2;
char cVar3;
char *pcVar4;
int iVar5;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar5 = 0;
}
else {
iVar5 = 0;
bVar1 = true;
pcVar4 = param_1 + 1;
do {
if (cVar3 == '_') {
bVar1 = true;
}
else if (bVar1) {
pp_Var2 = __ctype_toupper_loc();
*(char *)(param_2 + iVar5) = (char)(*pp_Var2)[cVar3];
iVar5 = iVar5 + 1;
bVar1 = false;
}
else {
*(char *)(param_2 + iVar5) = cVar3;
iVar5 = iVar5 + 1;
}
cVar3 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar3 != '\0');
}
*(int1 *)(param_2 + iVar5) = 0;
return param_2;
} |
4,302 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
output[output_index++] = toupper(word[word_index]);
capitalize_next = 0;
} else {
output[output_index++] = word[word_index];
}
}
word_index++;
}
output[output_index] = '\0';
return output;
}
| int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
xor %r15d,%r15d
mov $0x1,%eax
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%r15d
movslq %r15d,%r13
lea (%r14,%r13,1),%rdx
test %eax,%eax
je 1358 <func0+0xa8>
mov %rdx,0x8(%rsp)
callq 1070 <__ctype_toupper_loc@plt>
mov 0x8(%rsp),%rdx
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,(%r12)
mov %rdx,%r12
xor %eax,%eax
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
test %bl,%bl
je 133d <func0+0x8d>
lea (%r14,%r13,1),%r12
cmp $0x5f,%bl
jne 12e8 <func0+0x38>
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
mov $0x1,%eax
test %bl,%bl
jne 1322 <func0+0x72>
movb $0x0,(%r12)
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %bl,(%r12)
mov %rdx,%r12
jmp 1315 <func0+0x65>
nopl 0x0(%rax)
mov %rsi,%r12
jmp 133d <func0+0x8d>
nopl (%rax)
| func0:
endbr64
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
xor r12d, r12d
mov edx, 1
jmp short loc_1305
loc_12D8:
movsxd rax, r12d
add r12d, 1
lea r13, [r14+rax]
test edx, edx
jz short loc_1338
call ___ctype_toupper_loc
xor edx, edx
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [r13+0], al
loc_12F8:
movsx rbx, byte ptr [rbp+0]
add rbp, 1
test bl, bl
jz short loc_131C
loc_1305:
cmp bl, 5Fh ; '_'
jnz short loc_12D8
movsx rbx, byte ptr [rbp+0]
add rbp, 1
mov edx, 1
test bl, bl
jnz short loc_1305
loc_131C:
movsxd r12, r12d
add r12, r14
loc_1322:
mov byte ptr [r12], 0
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1338:
mov [r13+0], bl
jmp short loc_12F8
loc_1340:
mov r12, rsi
jmp short loc_1322 | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // r12d
int v5; // edx
long long v6; // rax
_BYTE *v7; // r13
_QWORD *v8; // rax
_BYTE *v9; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 1;
do
{
while ( (_BYTE)v2 == 95 )
{
v2 = *v3++;
v5 = 1;
if ( !(_BYTE)v2 )
goto LABEL_8;
}
v6 = v4++;
v7 = &a2[v6];
if ( v5 )
{
v8 = (_QWORD *)__ctype_toupper_loc();
v5 = 0;
*v7 = *(_DWORD *)(*v8 + 4 * v2);
}
else
{
*v7 = v2;
}
v2 = *v3++;
}
while ( (_BYTE)v2 );
LABEL_8:
v9 = &a2[v4];
}
else
{
v9 = a2;
}
*v9 = 0;
return a2;
} | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
XOR R12D,R12D
MOV EDX,0x1
JMP 0x00101305
LAB_001012d8:
MOVSXD RAX,R12D
ADD R12D,0x1
LEA R13,[R14 + RAX*0x1]
TEST EDX,EDX
JZ 0x00101338
CALL 0x00101080
XOR EDX,EDX
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [R13],AL
LAB_001012f8:
MOVSX RBX,byte ptr [RBP]
ADD RBP,0x1
TEST BL,BL
JZ 0x0010131c
LAB_00101305:
CMP BL,0x5f
JNZ 0x001012d8
MOVSX RBX,byte ptr [RBP]
ADD RBP,0x1
MOV EDX,0x1
TEST BL,BL
JNZ 0x00101305
LAB_0010131c:
MOVSXD R12,R12D
ADD R12,R14
LAB_00101322:
MOV byte ptr [R12],0x0
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101338:
MOV byte ptr [R13],BL
JMP 0x001012f8
LAB_00101340:
MOV R12,RSI
JMP 0x00101322 | int1 * func0(char *param_1,int1 *param_2)
{
char cVar1;
bool bVar2;
long lVar3;
__int32_t **pp_Var4;
long lVar5;
int iVar6;
int1 *puVar7;
lVar5 = (long)*param_1;
puVar7 = param_2;
if (*param_1 != '\0') {
param_1 = param_1 + 1;
iVar6 = 0;
bVar2 = true;
do {
while ((char)lVar5 != '_') {
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
if (bVar2) {
pp_Var4 = __ctype_toupper_loc();
bVar2 = false;
param_2[lVar3] = (char)(*pp_Var4)[lVar5];
}
else {
param_2[lVar3] = (char)lVar5;
}
cVar1 = *param_1;
lVar5 = (long)cVar1;
param_1 = param_1 + 1;
if (cVar1 == '\0') goto LAB_0010131c;
}
cVar1 = *param_1;
lVar5 = (long)cVar1;
param_1 = param_1 + 1;
bVar2 = true;
} while (cVar1 != '\0');
LAB_0010131c:
puVar7 = param_2 + iVar6;
}
*puVar7 = 0;
return param_2;
} |
4,303 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
output[output_index++] = toupper(word[word_index]);
capitalize_next = 0;
} else {
output[output_index++] = word[word_index];
}
}
word_index++;
}
output[output_index] = '\0';
return output;
}
| int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
xor %r15d,%r15d
mov $0x1,%eax
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%r15d
movslq %r15d,%r13
lea (%r14,%r13,1),%rdx
test %eax,%eax
je 1358 <func0+0xa8>
mov %rdx,0x8(%rsp)
callq 1070 <__ctype_toupper_loc@plt>
mov 0x8(%rsp),%rdx
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,(%r12)
mov %rdx,%r12
xor %eax,%eax
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
test %bl,%bl
je 133d <func0+0x8d>
lea (%r14,%r13,1),%r12
cmp $0x5f,%bl
jne 12e8 <func0+0x38>
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
mov $0x1,%eax
test %bl,%bl
jne 1322 <func0+0x72>
movb $0x0,(%r12)
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %bl,(%r12)
mov %rdx,%r12
jmp 1315 <func0+0x65>
nopl 0x0(%rax)
mov %rsi,%r12
jmp 133d <func0+0x8d>
nopl (%rax)
| func0:
endbr64
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
xor r12d, r12d
mov eax, 1
jmp short loc_130B
loc_12E0:
test eax, eax
jz short loc_12F0
call ___ctype_toupper_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+rbx*4]
loc_12F0:
movsxd rax, r12d
add rbp, 1
add r12d, 1
mov [r13+rax+0], bl
movsx rbx, byte ptr [rbp-1]
xor eax, eax
test bl, bl
jz short loc_1322
loc_130B:
cmp bl, 5Fh ; '_'
jnz short loc_12E0
movsx rbx, byte ptr [rbp+0]
add rbp, 1
mov eax, 1
test bl, bl
jnz short loc_130B
loc_1322:
movsxd r12, r12d
add r12, r13
loc_1328:
mov byte ptr [r12], 0
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1340:
mov r12, rsi
jmp short loc_1328 | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // r12d
int v5; // eax
long long v6; // rax
_BYTE *v7; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 1;
do
{
while ( (_BYTE)v2 == 95 )
{
v2 = *v3++;
v5 = 1;
if ( !(_BYTE)v2 )
goto LABEL_8;
}
if ( v5 )
LOBYTE(v2) = (*__ctype_toupper_loc())[v2];
v6 = v4;
++v3;
++v4;
a2[v6] = v2;
v2 = *(v3 - 1);
v5 = 0;
}
while ( (_BYTE)v2 );
LABEL_8:
v7 = &a2[v4];
}
else
{
v7 = a2;
}
*v7 = 0;
return a2;
} | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
XOR R12D,R12D
MOV EAX,0x1
JMP 0x0010130b
LAB_001012e0:
TEST EAX,EAX
JZ 0x001012f0
CALL 0x00101080
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + RBX*0x4]
LAB_001012f0:
MOVSXD RAX,R12D
ADD RBP,0x1
ADD R12D,0x1
MOV byte ptr [R13 + RAX*0x1],BL
MOVSX RBX,byte ptr [RBP + -0x1]
XOR EAX,EAX
TEST BL,BL
JZ 0x00101322
LAB_0010130b:
CMP BL,0x5f
JNZ 0x001012e0
MOVSX RBX,byte ptr [RBP]
ADD RBP,0x1
MOV EAX,0x1
TEST BL,BL
JNZ 0x0010130b
LAB_00101322:
MOVSXD R12,R12D
ADD R12,R13
LAB_00101328:
MOV byte ptr [R12],0x0
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101340:
MOV R12,RSI
JMP 0x00101328 | int * func0(char *param_1,int *param_2)
{
char cVar1;
bool bVar2;
__int32_t **pp_Var3;
long lVar4;
ulong uVar5;
char *pcVar6;
int iVar7;
int *puVar8;
uVar5 = (ulong)*param_1;
puVar8 = param_2;
if (*param_1 != '\0') {
iVar7 = 0;
bVar2 = true;
pcVar6 = param_1 + 1;
do {
while ((char)uVar5 != '_') {
if (bVar2) {
pp_Var3 = __ctype_toupper_loc();
uVar5 = (ulong)*(byte *)(*pp_Var3 + uVar5);
}
lVar4 = (long)iVar7;
iVar7 = iVar7 + 1;
param_2[lVar4] = (char)uVar5;
cVar1 = *pcVar6;
uVar5 = (ulong)cVar1;
bVar2 = false;
pcVar6 = pcVar6 + 1;
if (cVar1 == '\0') goto LAB_00101322;
}
cVar1 = *pcVar6;
uVar5 = (ulong)cVar1;
bVar2 = true;
pcVar6 = pcVar6 + 1;
} while (cVar1 != '\0');
LAB_00101322:
puVar8 = param_2 + iVar7;
}
*puVar8 = 0;
return param_2;
} |
4,304 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 116c <func0+0x23>
cmpl $0x0,-0x14(%rbp)
jne 1173 <func0+0x2a>
mov $0x0,%eax
jmp 11bf <func0+0x76>
cmpl $0x0,-0x18(%rbp)
jne 1180 <func0+0x37>
mov $0x1,%eax
jmp 11bf <func0+0x76>
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
mov %eax,%ebx
mov -0x18(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
imul %eax,%ebx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%r12d
mov -0x14(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%eax
mov %eax,%esi
mov %edx,%edi
callq 1149 <func0>
imul %r12d,%eax
add %ebx,%eax
add $0x10,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 10h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_116C
cmp [rbp+var_14], 0
jnz short loc_1173
loc_116C:
mov eax, 0
jmp short loc_11BF
loc_1173:
cmp [rbp+var_18], 0
jnz short loc_1180
mov eax, 1
jmp short loc_11BF
loc_1180:
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
mov ebx, eax
mov eax, [rbp+var_18]
lea edx, [rax-1]
mov eax, [rbp+var_14]
sub eax, 1
mov esi, edx
mov edi, eax
call func0
imul ebx, eax
mov eax, [rbp+var_18]
lea r12d, [rax+1]
mov eax, [rbp+var_14]
lea edx, [rax-1]
mov eax, [rbp+var_18]
mov esi, eax
mov edi, edx
call func0
imul eax, r12d
add eax, ebx
loc_11BF:
add rsp, 10h
pop rbx
pop r12
pop rbp
retn | long long func0(int a1, unsigned int a2)
{
int v3; // ebx
if ( (int)a2 >= a1 || !a1 )
return 0LL;
if ( !a2 )
return 1LL;
v3 = func0((unsigned int)(a1 - 1), a2 - 1) * (a1 - a2);
return v3 + (a2 + 1) * (unsigned int)func0((unsigned int)(a1 - 1), a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x0010116c
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101173
LAB_0010116c:
MOV EAX,0x0
JMP 0x001011bf
LAB_00101173:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00101180
MOV EAX,0x1
JMP 0x001011bf
LAB_00101180:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
IMUL EBX,EAX
MOV EAX,dword ptr [RBP + -0x18]
LEA R12D,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x18]
MOV ESI,EAX
MOV EDI,EDX
CALL 0x00101149
IMUL EAX,R12D
ADD EAX,EBX
LAB_001011bf:
ADD RSP,0x10
POP RBX
POP R12
POP RBP
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if ((param_2 < param_1) && (param_1 != 0)) {
if (param_2 == 0) {
iVar1 = 1;
}
else {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar1 = iVar2 * (param_2 + 1) + (param_1 - param_2) * iVar1;
}
}
else {
iVar1 = 0;
}
return iVar1;
} |
4,305 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edi,%esi
jge 119d <func0+0x54>
push %r12
push %rbp
push %rbx
mov %esi,%ebx
test %edi,%edi
je 1196 <func0+0x4d>
mov $0x1,%eax
test %esi,%esi
jne 1169 <func0+0x20>
pop %rbx
pop %rbp
pop %r12
retq
mov %edi,%r12d
sub %esi,%r12d
lea -0x1(%rdi),%ebp
lea -0x1(%rsi),%esi
mov %ebp,%edi
callq 1149 <func0>
imul %eax,%r12d
mov %ebx,%esi
mov %ebp,%edi
callq 1149 <func0>
mov %eax,%esi
lea 0x1(%rbx),%eax
imul %esi,%eax
add %r12d,%eax
jmp 1164 <func0+0x1b>
mov $0x0,%eax
jmp 1164 <func0+0x1b>
mov $0x0,%eax
retq
| func0:
endbr64
cmp esi, edi
jge short loc_119C
push r12
push rbp
push rbx
mov ebx, esi
test edi, edi
jz short loc_1195
mov eax, 1
test esi, esi
jnz short loc_1169
loc_1164:
pop rbx
pop rbp
pop r12
retn
loc_1169:
mov r12d, edi
sub r12d, esi
lea ebp, [rdi-1]
lea esi, [rsi-1]
mov edi, ebp
call func0
imul r12d, eax
mov esi, ebx
mov edi, ebp
call func0
add ebx, 1
imul ebx, eax
lea eax, [rbx+r12]
jmp short loc_1164
loc_1195:
mov eax, 0
jmp short loc_1164
loc_119C:
mov eax, 0
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
if ( (int)a2 >= a1 )
return 0LL;
if ( !a1 )
return 0LL;
result = 1LL;
if ( a2 )
{
v3 = func0((unsigned int)(a1 - 1), a2 - 1) * (a1 - a2);
return (unsigned int)func0((unsigned int)(a1 - 1), a2) * (a2 + 1) + v3;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDI
JGE 0x0010119c
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
TEST EDI,EDI
JZ 0x00101195
MOV EAX,0x1
TEST ESI,ESI
JNZ 0x00101169
LAB_00101164:
POP RBX
POP RBP
POP R12
RET
LAB_00101169:
MOV R12D,EDI
SUB R12D,ESI
LEA EBP,[RDI + -0x1]
LEA ESI,[RSI + -0x1]
MOV EDI,EBP
CALL 0x00101149
IMUL R12D,EAX
MOV ESI,EBX
MOV EDI,EBP
CALL 0x00101149
ADD EBX,0x1
IMUL EBX,EAX
LEA EAX,[RBX + R12*0x1]
JMP 0x00101164
LAB_00101195:
MOV EAX,0x0
JMP 0x00101164
LAB_0010119c:
MOV EAX,0x0
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_2 < param_1) {
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = 1;
if (param_2 != 0) {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar1 = (param_2 + 1) * iVar2 + (param_1 - param_2) * iVar1;
}
}
return iVar1;
}
return 0;
} |
4,306 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
je 1280 <func0+0x80>
mov %edi,%ebx
mov %esi,%r13d
cmp %esi,%edi
jle 1280 <func0+0x80>
test %esi,%esi
je 1288 <func0+0x88>
lea 0x1(%rsi),%eax
lea -0x1(%rsi),%r12d
mov $0x1,%r15d
xor %ebp,%ebp
mov %eax,0xc(%rsp)
nopw %cs:0x0(%rax,%rax,1)
mov %ebx,%r14d
sub $0x1,%ebx
mov %r12d,%esi
mov %ebx,%edi
sub %r13d,%r14d
callq 1200 <func0>
imul %r14d,%eax
imul %r15d,%eax
imul 0xc(%rsp),%r15d
add %eax,%ebp
cmp %r13d,%ebx
jle 126c <func0+0x6c>
test %ebx,%ebx
jne 1240 <func0+0x40>
add $0x18,%rsp
mov %ebp,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %ebp,%ebp
jmp 126c <func0+0x6c>
nopl 0x0(%rax)
mov $0x1,%ebp
jmp 126c <func0+0x6c>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test edi, edi
jz short loc_1280
mov ebx, edi
mov r13d, esi
cmp edi, esi
jle short loc_1280
test esi, esi
jz short loc_1288
lea eax, [rsi+1]
lea r12d, [rsi-1]
mov r15d, 1
xor ebp, ebp
mov [rsp+48h+var_3C], eax
nop word ptr [rax+rax+00000000h]
loc_1240:
mov r14d, ebx
sub ebx, 1
mov esi, r12d
mov edi, ebx
sub r14d, r13d
call func0
imul eax, r14d
imul eax, r15d
imul r15d, [rsp+48h+var_3C]
add ebp, eax
cmp ebx, r13d
jle short loc_126C
test ebx, ebx
jnz short loc_1240
loc_126C:
add rsp, 18h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1280:
xor ebp, ebp
jmp short loc_126C
loc_1288:
mov ebp, 1
jmp short loc_126C | long long func0(int a1, int a2)
{
unsigned int v2; // ebx
int v3; // r15d
unsigned int v4; // ebp
int v5; // r14d
int v6; // eax
if ( a1 && (v2 = a1, a1 > a2) )
{
if ( a2 )
{
v3 = 1;
v4 = 0;
do
{
v5 = v2--;
v6 = v3 * (v5 - a2) * func0(v2, (unsigned int)(a2 - 1));
v3 *= a2 + 1;
v4 += v6;
}
while ( (int)v2 > a2 && v2 );
}
else
{
return 1;
}
}
else
{
return 0;
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JZ 0x00101280
MOV EBX,EDI
MOV R13D,ESI
CMP EDI,ESI
JLE 0x00101280
TEST ESI,ESI
JZ 0x00101288
LEA EAX,[RSI + 0x1]
LEA R12D,[RSI + -0x1]
MOV R15D,0x1
XOR EBP,EBP
MOV dword ptr [RSP + 0xc],EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101240:
MOV R14D,EBX
SUB EBX,0x1
MOV ESI,R12D
MOV EDI,EBX
SUB R14D,R13D
CALL 0x00101200
IMUL EAX,R14D
IMUL EAX,R15D
IMUL R15D,dword ptr [RSP + 0xc]
ADD EBP,EAX
CMP EBX,R13D
JLE 0x0010126c
TEST EBX,EBX
JNZ 0x00101240
LAB_0010126c:
ADD RSP,0x18
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101280:
XOR EBP,EBP
JMP 0x0010126c
LAB_00101288:
MOV EBP,0x1
JMP 0x0010126c | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if ((param_1 == 0) || (param_1 <= param_2)) {
iVar3 = 0;
}
else if (param_2 == 0) {
iVar3 = 1;
}
else {
iVar4 = 1;
iVar3 = 0;
do {
iVar2 = param_1 + -1;
iVar1 = func0(iVar2,param_2 + -1);
iVar1 = iVar1 * (param_1 - param_2) * iVar4;
iVar4 = iVar4 * (param_2 + 1);
iVar3 = iVar3 + iVar1;
if (iVar2 <= param_2) {
return iVar3;
}
param_1 = iVar2;
} while (iVar2 != 0);
}
return iVar3;
} |
4,307 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
je 1280 <func0+0x80>
mov %edi,%ebx
mov %esi,%r13d
cmp %esi,%edi
jle 1280 <func0+0x80>
test %esi,%esi
je 1288 <func0+0x88>
lea 0x1(%rsi),%eax
lea -0x1(%rsi),%r12d
mov $0x1,%r15d
xor %ebp,%ebp
mov %eax,0xc(%rsp)
nopw %cs:0x0(%rax,%rax,1)
mov %ebx,%r14d
sub $0x1,%ebx
mov %r12d,%esi
mov %ebx,%edi
sub %r13d,%r14d
callq 1200 <func0>
imul %r14d,%eax
imul %r15d,%eax
imul 0xc(%rsp),%r15d
add %eax,%ebp
cmp %r13d,%ebx
jle 126c <func0+0x6c>
test %ebx,%ebx
jne 1240 <func0+0x40>
add $0x18,%rsp
mov %ebp,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %ebp,%ebp
jmp 126c <func0+0x6c>
nopl 0x0(%rax)
mov $0x1,%ebp
jmp 126c <func0+0x6c>
| func0_constprop_1:
xor edx, edx
cmp edi, 1
jle short loc_1221
mov eax, 1
nop dword ptr [rax+00h]
loc_1210:
sub edi, 1
mov ecx, edi
imul ecx, eax
add eax, eax
add edx, ecx
cmp edi, 1
jnz short loc_1210
loc_1221:
mov eax, edx
retn | long long func0_constprop_1(int a1)
{
unsigned int v1; // edx
int v2; // eax
int v3; // ecx
v1 = 0;
if ( a1 > 1 )
{
v2 = 1;
do
{
--a1;
v3 = v2 * a1;
v2 *= 2;
v1 += v3;
}
while ( a1 != 1 );
}
return v1;
} | func0.constprop.1:
XOR EDX,EDX
CMP EDI,0x1
JLE 0x00101221
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101210:
SUB EDI,0x1
MOV ECX,EDI
IMUL ECX,EAX
ADD EAX,EAX
ADD EDX,ECX
CMP EDI,0x1
JNZ 0x00101210
LAB_00101221:
MOV EAX,EDX
RET | int func0_constprop_1(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 0;
if (1 < param_1) {
iVar1 = 1;
do {
param_1 = param_1 + -1;
iVar2 = param_1 * iVar1;
iVar1 = iVar1 * 2;
iVar3 = iVar3 + iVar2;
} while (param_1 != 1);
}
return iVar3;
} |
4,308 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list[i][j];
qsort((*result)[i], lengths[i], sizeof(char*), compare);
}
}
| int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
char* expected1_3[] = {"black", "orange", "white"};
char** expected1[] = {expected1_1, expected1_2, expected1_3};
char*** result1;
func0(input1, lengths1, 3, &result1);
for (int i = 0; i < 3; i++)
for (int j = 0; j < lengths1[i]; j++)
assert(strcmp(expected1[i][j], result1[i][j]) == 0);
// Free memory
for (int i = 0; i < 3; i++) free(result1[i]);
free(result1);
// Note: Additional tests analogous to the other assertions in the Python code have been skipped for brevity.
// They would be written and checked in a similar manner.
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %rcx,-0x40(%rbp)
mov -0x34(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rdx
mov -0x40(%rbp),%rax
mov %rdx,(%rax)
movl $0x0,-0x18(%rbp)
jmpq 1366 <func0+0x13e>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
shl $0x3,%rax
mov -0x40(%rbp),%rdx
mov (%rdx),%rdx
mov -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl $0x3,%rcx
lea (%rdx,%rcx,1),%rbx
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x14(%rbp)
jmp 1303 <func0+0xdb>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
lea (%rax,%rdx,1),%rcx
mov -0x40(%rbp),%rax
mov (%rax),%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
add %rdx,%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x14(%rbp)
jl 12b0 <func0+0x88>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
movslq %eax,%rsi
mov -0x40(%rbp),%rax
mov (%rax),%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
add %rdx,%rax
mov (%rax),%rax
lea -0x16c(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
callq 10b0 <qsort@plt>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 126b <func0+0x43>
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_40], rcx
mov eax, [rbp+var_34]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_40]
mov [rax], rdx
mov [rbp+var_18], 0
jmp loc_1369
loc_126B:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov eax, [rax]
cdqe
shl rax, 3
mov rdx, [rbp+var_40]
mov rdx, [rdx]
mov ecx, [rbp+var_18]
movsxd rcx, ecx
shl rcx, 3
lea rbx, [rdx+rcx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov [rbp+var_14], 0
jmp short loc_1303
loc_12B0:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 3
lea rcx, [rax+rdx]
mov rax, [rbp+var_40]
mov rax, [rax]
mov edx, [rbp+var_18]
movsxd rdx, edx
shl rdx, 3
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 3
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
add [rbp+var_14], 1
loc_1303:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_14], eax
jl short loc_12B0
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov eax, [rax]
movsxd rsi, eax; nmemb
mov rax, [rbp+var_40]
mov rax, [rax]
mov edx, [rbp+var_18]
movsxd rdx, edx
shl rdx, 3
add rax, rdx
mov rax, [rax]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 8; size
mov rdi, rax; base
call _qsort
add [rbp+var_18], 1
loc_1369:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_34]
jl loc_126B
nop
nop
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, int a3, void **a4)
{
void **v4; // rbx
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
*a4 = malloc(8LL * a3);
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
v4 = (void **)((char *)*a4 + 8 * (int)i);
*v4 = malloc(8LL * *(int *)(4LL * (int)i + a2));
for ( j = 0; j < *(_DWORD *)(4LL * (int)i + a2); ++j )
*(_QWORD *)(*((_QWORD *)*a4 + (int)i) + 8LL * j) = *(_QWORD *)(*(_QWORD *)(8LL * (int)i + a1) + 8LL * j);
qsort(*((void **)*a4 + (int)i), *(int *)(4LL * (int)i + a2), 8uLL, compare);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RDX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101369
LAB_0010126b:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x3
MOV RDX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x18]
MOVSXD RCX,ECX
SHL RCX,0x3
LEA RBX,[RDX + RCX*0x1]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101303
LAB_001012b0:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x3
LEA RCX,[RAX + RDX*0x1]
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
SHL RDX,0x3
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x3
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
ADD dword ptr [RBP + -0x14],0x1
LAB_00101303:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x14],EAX
JL 0x001012b0
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
SHL RDX,0x3
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1011e9]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
CALL 0x001010b0
ADD dword ptr [RBP + -0x18],0x1
LAB_00101369:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x0010126b
NOP
NOP
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void func0(long param_1,long param_2,int param_3,long *param_4)
{
long lVar1;
void *pvVar2;
int local_20;
int local_1c;
pvVar2 = malloc((long)param_3 << 3);
*param_4 = (long)pvVar2;
for (local_20 = 0; local_20 < param_3; local_20 = local_20 + 1) {
lVar1 = *param_4;
pvVar2 = malloc((long)*(int *)(param_2 + (long)local_20 * 4) << 3);
*(void **)(lVar1 + (long)local_20 * 8) = pvVar2;
for (local_1c = 0; local_1c < *(int *)(param_2 + (long)local_20 * 4); local_1c = local_1c + 1) {
*(int8 *)((long)local_1c * 8 + *(long *)(*param_4 + (long)local_20 * 8)) =
*(int8 *)(*(long *)(param_1 + (long)local_20 * 8) + (long)local_1c * 8);
}
qsort(*(void **)(*param_4 + (long)local_20 * 8),(long)*(int *)(param_2 + (long)local_20 * 4),8,
compare);
}
return;
} |
4,309 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list[i][j];
qsort((*result)[i], lengths[i], sizeof(char*), compare);
}
}
| int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
char* expected1_3[] = {"black", "orange", "white"};
char** expected1[] = {expected1_1, expected1_2, expected1_3};
char*** result1;
func0(input1, lengths1, 3, &result1);
for (int i = 0; i < 3; i++)
for (int j = 0; j < lengths1[i]; j++)
assert(strcmp(expected1[i][j], result1[i][j]) == 0);
// Free memory
for (int i = 0; i < 3; i++) free(result1[i]);
free(result1);
// Note: Additional tests analogous to the other assertions in the Python code have been skipped for brevity.
// They would be written and checked in a similar manner.
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r13
mov %rsi,%r14
mov %edx,%ebx
mov %rcx,%r12
movslq %edx,%rdi
shl $0x3,%rdi
callq 10f0 <malloc@plt>
mov %rax,(%r12)
test %ebx,%ebx
jle 12c3 <func0+0xc2>
mov %r13,%rbp
lea -0x1(%rbx),%eax
lea 0x8(%r13,%rax,8),%rax
mov %rax,0x8(%rsp)
mov $0x0,%ebx
jmp 127c <func0+0x7b>
movslq %esi,%rsi
mov (%r12),%rax
mov (%rax,%rbx,1),%rdi
lea -0x76(%rip),%rcx
mov $0x8,%edx
callq 10b0 <qsort@plt>
add $0x4,%r14
add $0x8,%rbx
add $0x8,%rbp
cmp 0x8(%rsp),%rbp
je 12c3 <func0+0xc2>
mov %r14,%r13
mov %rbx,%r15
add (%r12),%r15
movslq (%r14),%rdi
shl $0x3,%rdi
callq 10f0 <malloc@plt>
mov %rax,(%r15)
mov (%r14),%esi
test %esi,%esi
jle 124d <func0+0x4c>
mov $0x0,%eax
mov 0x0(%rbp),%rdx
mov (%rdx,%rax,8),%rcx
mov (%r12),%rdx
mov (%rdx,%rbx,1),%rdx
mov %rcx,(%rdx,%rax,8)
mov 0x0(%r13),%esi
add $0x1,%rax
cmp %eax,%esi
jg 12a1 <func0+0xa0>
jmp 124d <func0+0x4c>
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 r14, rsi
mov ebx, edx
mov r12, rcx
movsxd rdi, edx
shl rdi, 3
call _malloc
mov [r12], rax
test ebx, ebx
jle loc_12BF
mov rbp, r13
lea eax, [rbx-1]
lea rax, [r13+rax*8+8]
mov [rsp+48h+var_40], rax
mov ebx, 0
loc_124B:
mov r13, r14
mov r15, rbx
add r15, [r12]
movsxd rdi, dword ptr [r14]
shl rdi, 3
call _malloc
mov [r15], rax
mov esi, [r14]
test esi, esi
jle short loc_1290
mov eax, 0
loc_1270:
mov rdx, [rbp+0]
mov rcx, [rdx+rax*8]
mov rdx, [r12]
mov rdx, [rdx+rbx]
mov [rdx+rax*8], rcx
mov esi, [r13+0]
add rax, 1
cmp esi, eax
jg short loc_1270
loc_1290:
movsxd rsi, esi
mov rax, [r12]
mov rdi, [rax+rbx]
lea rcx, compare
mov edx, 8
call _qsort
add r14, 4
add rbx, 8
add rbp, 8
cmp rbp, [rsp+48h+var_40]
jnz short loc_124B
loc_12BF:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(_QWORD *a1, int *a2, int a3, long long *a4)
{
long long result; // rax
_QWORD *v8; // rbp
long long v9; // rbx
_QWORD *v10; // r15
int v11; // esi
long long v12; // rax
long long v13; // [rsp+8h] [rbp-40h]
result = malloc(8LL * a3);
*a4 = result;
if ( a3 > 0 )
{
v8 = a1;
v13 = (long long)&a1[(unsigned int)(a3 - 1) + 1];
v9 = 0LL;
do
{
v10 = (_QWORD *)(*a4 + v9);
*v10 = malloc(8LL * *a2);
v11 = *a2;
if ( *a2 > 0 )
{
v12 = 0LL;
do
{
*(_QWORD *)(*(_QWORD *)(*a4 + v9) + 8 * v12) = *(_QWORD *)(*v8 + 8 * v12);
v11 = *a2;
++v12;
}
while ( *a2 > (int)v12 );
}
result = qsort(*(_QWORD *)(*a4 + v9), v11, 8LL, compare);
++a2;
v9 += 8LL;
++v8;
}
while ( v8 != (_QWORD *)v13 );
}
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,RDI
MOV R14,RSI
MOV EBX,EDX
MOV R12,RCX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x001010f0
MOV qword ptr [R12],RAX
TEST EBX,EBX
JLE 0x001012bf
MOV RBP,R13
LEA EAX,[RBX + -0x1]
LEA RAX,[R13 + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV EBX,0x0
LAB_0010124b:
MOV R13,R14
MOV R15,RBX
ADD R15,qword ptr [R12]
MOVSXD RDI,dword ptr [R14]
SHL RDI,0x3
CALL 0x001010f0
MOV qword ptr [R15],RAX
MOV ESI,dword ptr [R14]
TEST ESI,ESI
JLE 0x00101290
MOV EAX,0x0
LAB_00101270:
MOV RDX,qword ptr [RBP]
MOV RCX,qword ptr [RDX + RAX*0x8]
MOV RDX,qword ptr [R12]
MOV RDX,qword ptr [RDX + RBX*0x1]
MOV qword ptr [RDX + RAX*0x8],RCX
MOV ESI,dword ptr [R13]
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101270
LAB_00101290:
MOVSXD RSI,ESI
MOV RAX,qword ptr [R12]
MOV RDI,qword ptr [RAX + RBX*0x1]
LEA RCX,[0x1011e9]
MOV EDX,0x8
CALL 0x001010b0
ADD R14,0x4
ADD RBX,0x8
ADD RBP,0x8
CMP RBP,qword ptr [RSP + 0x8]
JNZ 0x0010124b
LAB_001012bf:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(long *param_1,int *param_2,int param_3,long *param_4)
{
long *plVar1;
void *pvVar2;
long lVar3;
long lVar4;
int iVar5;
pvVar2 = malloc((long)param_3 << 3);
*param_4 = (long)pvVar2;
if (0 < param_3) {
plVar1 = param_1 + (ulong)(param_3 - 1) + 1;
lVar4 = 0;
do {
lVar3 = *param_4;
pvVar2 = malloc((long)*param_2 << 3);
*(void **)(lVar4 + lVar3) = pvVar2;
iVar5 = *param_2;
if (0 < iVar5) {
lVar3 = 0;
do {
*(int8 *)(*(long *)(*param_4 + lVar4) + lVar3 * 8) =
*(int8 *)(*param_1 + lVar3 * 8);
iVar5 = *param_2;
lVar3 = lVar3 + 1;
} while ((int)lVar3 < iVar5);
}
qsort(*(void **)(*param_4 + lVar4),(long)iVar5,8,compare);
param_2 = param_2 + 1;
lVar4 = lVar4 + 8;
param_1 = param_1 + 1;
} while (param_1 != plVar1);
}
return;
} |
4,310 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list[i][j];
qsort((*result)[i], lengths[i], sizeof(char*), compare);
}
}
| int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
char* expected1_3[] = {"black", "orange", "white"};
char** expected1[] = {expected1_1, expected1_2, expected1_3};
char*** result1;
func0(input1, lengths1, 3, &result1);
for (int i = 0; i < 3; i++)
for (int j = 0; j < lengths1[i]; j++)
assert(strcmp(expected1[i][j], result1[i][j]) == 0);
// Free memory
for (int i = 0; i < 3; i++) free(result1[i]);
free(result1);
// Note: Additional tests analogous to the other assertions in the Python code have been skipped for brevity.
// They would be written and checked in a similar manner.
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x18(%rsp)
movslq %edx,%rdi
mov %rdi,%r13
shl $0x3,%rdi
mov %rsi,0x8(%rsp)
callq 10f0 <malloc@plt>
mov %rax,0x0(%rbp)
test %r13d,%r13d
jle 14d0 <func0+0xd0>
mov %rax,%r14
lea -0x1(%r13),%eax
xor %r15d,%r15d
mov %rax,0x10(%rsp)
lea -0x61(%rip),%r13
nopl 0x0(%rax)
mov 0x8(%rsp),%rax
movslq (%rax,%r15,4),%r12
lea 0x0(,%r12,8),%rdi
callq 10f0 <malloc@plt>
mov %rax,(%r14,%r15,8)
mov %rax,%rdi
test %r12d,%r12d
jle 14a4 <func0+0xa4>
mov 0x18(%rsp),%rax
xor %edx,%edx
mov (%rax,%r15,8),%r8
lea -0x1(%r12),%eax
nopw 0x0(%rax,%rax,1)
mov (%r8,%rdx,8),%rcx
mov %rcx,(%rdi,%rdx,8)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rax
jne 1490 <func0+0x90>
mov %r13,%rcx
mov $0x8,%edx
mov %r12,%rsi
callq 10b0 <qsort@plt>
lea 0x1(%r15),%rax
cmp %r15,0x10(%rsp)
je 14d0 <func0+0xd0>
mov 0x0(%rbp),%r14
mov %rax,%r15
jmp 1458 <func0+0x58>
nopl 0x0(%rax,%rax,1)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
movsxd rax, edx
push r14
mov r14, rax
push r13
push r12
push rbp
mov rbp, rcx
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], rdi
lea rdi, ds:0[rax*8]
mov [rsp+58h+var_50], rsi
mov [rsp+58h+var_48], rax
call _malloc
mov [rbp+0], rax
test r14d, r14d
jle short loc_14A8
mov r13, rax
xor r12d, r12d
lea r14, compare
nop dword ptr [rax]
loc_1440:
mov rax, [rsp+58h+var_50]
movsxd r15, dword ptr [rax+r12*4]
lea rdi, ds:0[r15*8]
call _malloc
mov [r13+r12*8+0], rax
mov rdi, rax
test r15d, r15d
jle short loc_1481
mov rax, [rsp+58h+var_40]
mov rcx, [rax+r12*8]
xor eax, eax
xchg ax, ax
loc_1470:
mov rdx, [rcx+rax*8]
mov [rdi+rax*8], rdx
add rax, 1
cmp r15, rax
jnz short loc_1470
loc_1481:
mov rcx, r14
mov edx, 8
mov rsi, r15
add r12, 1
call _qsort
cmp [rsp+58h+var_48], r12
jz short loc_14A8
mov r13, [rbp+0]
jmp short loc_1440
loc_14A8:
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, int a3, long long *a4)
{
long long result; // rax
long long v7; // r13
long long v8; // r12
long long v9; // r15
long long v10; // rax
long long v11; // rdi
long long v12; // rcx
long long i; // rax
long long v14; // [rsp+10h] [rbp-48h]
v14 = a3;
result = malloc(8LL * a3);
*a4 = result;
if ( a3 > 0 )
{
v7 = result;
v8 = 0LL;
while ( 1 )
{
v9 = *(int *)(a2 + 4 * v8);
v10 = malloc(8 * v9);
*(_QWORD *)(v7 + 8 * v8) = v10;
v11 = v10;
if ( (int)v9 > 0 )
{
v12 = *(_QWORD *)(a1 + 8 * v8);
for ( i = 0LL; i != v9; ++i )
*(_QWORD *)(v11 + 8 * i) = *(_QWORD *)(v12 + 8 * i);
}
++v8;
result = qsort(v11, v9, 8LL, compare);
if ( v14 == v8 )
break;
v7 = *a4;
}
}
return result;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,EDX
PUSH R14
MOV R14,RAX
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
LEA RDI,[RAX*0x8]
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
MOV qword ptr [RBP],RAX
TEST R14D,R14D
JLE 0x001014a8
MOV R13,RAX
XOR R12D,R12D
LEA R14,[0x1013e0]
NOP dword ptr [RAX]
LAB_00101440:
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD R15,dword ptr [RAX + R12*0x4]
LEA RDI,[R15*0x8]
CALL 0x001010f0
MOV qword ptr [R13 + R12*0x8],RAX
MOV RDI,RAX
TEST R15D,R15D
JLE 0x00101481
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + R12*0x8]
XOR EAX,EAX
NOP
LAB_00101470:
MOV RDX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],RDX
ADD RAX,0x1
CMP R15,RAX
JNZ 0x00101470
LAB_00101481:
MOV RCX,R14
MOV EDX,0x8
MOV RSI,R15
ADD R12,0x1
CALL 0x001010b0
CMP qword ptr [RSP + 0x10],R12
JZ 0x001014a8
MOV R13,qword ptr [RBP]
JMP 0x00101440
LAB_001014a8:
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(long param_1,long param_2,int param_3,int8 *param_4)
{
int iVar1;
long lVar2;
void *pvVar3;
void *__base;
size_t sVar4;
long lVar5;
size_t __nmemb;
pvVar3 = malloc((long)param_3 * 8);
*param_4 = pvVar3;
if (0 < param_3) {
lVar5 = 0;
while( true ) {
iVar1 = *(int *)(param_2 + lVar5 * 4);
__nmemb = (size_t)iVar1;
__base = malloc(__nmemb * 8);
*(void **)((long)pvVar3 + lVar5 * 8) = __base;
if (0 < iVar1) {
lVar2 = *(long *)(param_1 + lVar5 * 8);
sVar4 = 0;
do {
*(int8 *)((long)__base + sVar4 * 8) = *(int8 *)(lVar2 + sVar4 * 8);
sVar4 = sVar4 + 1;
} while (__nmemb != sVar4);
}
lVar5 = lVar5 + 1;
qsort(__base,__nmemb,8,compare);
if (param_3 == lVar5) break;
pvVar3 = (void *)*param_4;
}
}
return;
} |
4,311 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list[i][j];
qsort((*result)[i], lengths[i], sizeof(char*), compare);
}
}
| int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
char* expected1_3[] = {"black", "orange", "white"};
char** expected1[] = {expected1_1, expected1_2, expected1_3};
char*** result1;
func0(input1, lengths1, 3, &result1);
for (int i = 0; i < 3; i++)
for (int j = 0; j < lengths1[i]; j++)
assert(strcmp(expected1[i][j], result1[i][j]) == 0);
// Free memory
for (int i = 0; i < 3; i++) free(result1[i]);
free(result1);
// Note: Additional tests analogous to the other assertions in the Python code have been skipped for brevity.
// They would be written and checked in a similar manner.
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x18(%rsp)
movslq %edx,%rdi
mov %rdi,%r13
shl $0x3,%rdi
mov %rsi,0x8(%rsp)
callq 10f0 <malloc@plt>
mov %rax,0x0(%rbp)
test %r13d,%r13d
jle 1530 <func0+0x120>
mov %rax,%r14
lea -0x1(%r13),%eax
xor %r15d,%r15d
mov %rax,0x10(%rsp)
lea -0x61(%rip),%r13
nopl 0x0(%rax)
mov 0x8(%rsp),%rax
movslq (%rax,%r15,4),%r12
lea 0x0(,%r12,8),%rdi
mov %r12,%rbx
callq 10f0 <malloc@plt>
mov %rax,(%r14,%r15,8)
mov %rax,%rdi
test %r12d,%r12d
jle 14e4 <func0+0xd4>
mov 0x18(%rsp),%rax
lea 0xf(%rdi),%rcx
lea -0x1(%r12),%edx
mov (%rax,%r15,8),%rax
sub %rax,%rcx
cmp $0x1e,%rcx
jbe 1510 <func0+0x100>
cmp $0x3,%edx
jbe 1510 <func0+0x100>
mov %r12d,%ecx
xor %edx,%edx
shr %ecx
shl $0x4,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax,%rdx,1),%xmm0
movups %xmm0,(%rdi,%rdx,1)
add $0x10,%rdx
cmp %rcx,%rdx
jne 14c0 <func0+0xb0>
mov %ebx,%edx
and $0xfffffffe,%edx
and $0x1,%ebx
je 14e4 <func0+0xd4>
mov (%rax,%rdx,8),%rax
mov %rax,(%rdi,%rdx,8)
mov %r13,%rcx
mov $0x8,%edx
mov %r12,%rsi
callq 10b0 <qsort@plt>
lea 0x1(%r15),%rax
cmp 0x10(%rsp),%r15
je 1530 <func0+0x120>
mov 0x0(%rbp),%r14
mov %rax,%r15
jmpq 1468 <func0+0x58>
nopl 0x0(%rax,%rax,1)
mov %edx,%ecx
xor %edx,%edx
nopl 0x0(%rax)
mov (%rax,%rdx,8),%r8
mov %r8,(%rdi,%rdx,8)
mov %rdx,%r8
add $0x1,%rdx
cmp %r8,%rcx
jne 1518 <func0+0x108>
jmp 14e4 <func0+0xd4>
xchg %ax,%ax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
mov r15, rcx
push r14
movsxd r14, edx
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 28h
mov [rsp+58h+var_48], rdi
lea rdi, ds:0[r14*8]; size
mov [rsp+58h+var_40], rcx
call _malloc
mov [r15], rax
test r14d, r14d
jle loc_1520
mov r13, rax
lea rax, [rbx+r14*4]
xor ebp, ebp
mov [rsp+58h+var_50], rax
nop dword ptr [rax+00h]
loc_1440:
movsxd r14, dword ptr [rbx]
lea r15, ds:0[r14*8]
mov r12, r14
mov rdi, r15; size
call _malloc
mov [r13+rbp+0], rax
mov rdi, rax; base
test r14d, r14d
jle short loc_14A0
mov rax, [rsp+58h+var_48]
mov rdx, [rax+rbp]
lea eax, [r14-1]
cmp eax, 2
jbe loc_1510
lea r9, [rdx+8]
xor eax, eax
cmp rdi, r9
jnz short loc_14D8
nop dword ptr [rax+00h]
loc_1488:
mov rcx, [rdx+rax]
mov [rdi+rax], rcx
add rax, 8
cmp r15, rax
jnz short loc_1488
nop dword ptr [rax+00000000h]
loc_14A0:
mov edx, 8; size
mov rsi, r14; nmemb
add rbx, 4
add rbp, 8
lea rcx, compare; compar
call _qsort
mov rax, [rsp+58h+var_50]
cmp rbx, rax
jz short loc_1520
mov rax, [rsp+58h+var_40]
mov r13, [rax]
jmp loc_1440
loc_14D8:
mov r8d, r14d
shr r8d, 1
shl r8, 4
nop word ptr [rax+rax+00h]
loc_14E8:
movdqu xmm0, xmmword ptr [rdx+rax]
movups xmmword ptr [rdi+rax], xmm0
add rax, 10h
cmp rax, r8
jnz short loc_14E8
mov eax, r12d
and eax, 0FFFFFFFEh
and r12d, 1
jz short loc_14A0
mov rdx, [rdx+rax*8]
mov [rdi+rax*8], rdx
jmp short loc_14A0
loc_1510:
xor eax, eax
jmp loc_1488
loc_1520:
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | char * func0(long long a1, int *a2, int a3, char **a4)
{
long long v5; // r14
int *v6; // rbx
char *result; // rax
char *v8; // r13
long long v9; // rbp
size_t v10; // r14
int v11; // r12d
_QWORD *v12; // rax
_QWORD *v13; // rdi
long long v14; // rdx
long long i; // rax
int *v16; // [rsp+8h] [rbp-50h]
v5 = a3;
v6 = a2;
result = (char *)malloc(8LL * a3);
*a4 = result;
if ( (int)v5 > 0 )
{
v8 = result;
v9 = 0LL;
v16 = &a2[v5];
while ( 1 )
{
v10 = *v6;
v11 = *v6;
v12 = malloc(8 * v10);
*(_QWORD *)&v8[v9] = v12;
v13 = v12;
if ( (int)v10 <= 0 )
goto LABEL_7;
v14 = *(_QWORD *)(a1 + v9);
if ( (unsigned int)(v10 - 1) <= 2 )
break;
i = 0LL;
if ( v13 == (_QWORD *)(v14 + 8) )
goto LABEL_6;
do
{
*(__m128i *)&v13[i] = _mm_loadu_si128((const __m128i *)(v14 + i * 8));
i += 2LL;
}
while ( i != 2LL * ((unsigned int)v10 >> 1) );
if ( (v11 & 1) != 0 )
v13[v11 & 0xFFFFFFFE] = *(_QWORD *)(v14 + 8LL * (v11 & 0xFFFFFFFE));
LABEL_7:
++v6;
v9 += 8LL;
qsort(v13, v10, 8uLL, compare);
result = (char *)v16;
if ( v6 == v16 )
return result;
v8 = *a4;
}
for ( i = 0LL; i != v10; ++i )
LABEL_6:
v13[i] = *(_QWORD *)(v14 + i * 8);
goto LABEL_7;
}
return result;
} | func0:
ENDBR64
PUSH R15
MOV R15,RCX
PUSH R14
MOVSXD R14,EDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
LEA RDI,[R14*0x8]
MOV qword ptr [RSP + 0x18],RCX
CALL 0x001010f0
MOV qword ptr [R15],RAX
TEST R14D,R14D
JLE 0x00101520
MOV R13,RAX
LEA RAX,[RBX + R14*0x4]
XOR EBP,EBP
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX]
LAB_00101440:
MOVSXD R14,dword ptr [RBX]
LEA R15,[R14*0x8]
MOV R12,R14
MOV RDI,R15
CALL 0x001010f0
MOV qword ptr [R13 + RBP*0x1],RAX
MOV RDI,RAX
TEST R14D,R14D
JLE 0x001014a0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RAX + RBP*0x1]
LEA EAX,[R14 + -0x1]
CMP EAX,0x2
JBE 0x00101510
LEA R9,[RDX + 0x8]
XOR EAX,EAX
CMP RDI,R9
JNZ 0x001014d8
NOP dword ptr [RAX]
LAB_00101488:
MOV RCX,qword ptr [RDX + RAX*0x1]
MOV qword ptr [RDI + RAX*0x1],RCX
ADD RAX,0x8
CMP R15,RAX
JNZ 0x00101488
NOP dword ptr [RAX]
LAB_001014a0:
MOV EDX,0x8
MOV RSI,R14
ADD RBX,0x4
ADD RBP,0x8
LEA RCX,[0x1013e0]
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x8]
CMP RBX,RAX
JZ 0x00101520
MOV RAX,qword ptr [RSP + 0x18]
MOV R13,qword ptr [RAX]
JMP 0x00101440
LAB_001014d8:
MOV R8D,R14D
SHR R8D,0x1
SHL R8,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_001014e8:
MOVDQU XMM0,xmmword ptr [RDX + RAX*0x1]
MOVUPS xmmword ptr [RDI + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,R8
JNZ 0x001014e8
MOV EAX,R12D
AND EAX,0xfffffffe
AND R12D,0x1
JZ 0x001014a0
MOV RDX,qword ptr [RDX + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],RDX
JMP 0x001014a0
LAB_00101510:
XOR EAX,EAX
JMP 0x00101488
LAB_00101520:
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(long param_1,uint *param_2,int param_3,int8 *param_4)
{
uint *puVar1;
size_t __size;
uint uVar2;
long lVar3;
int8 uVar4;
void *pvVar5;
void *__base;
long lVar6;
long lVar7;
pvVar5 = malloc((long)param_3 * 8);
*param_4 = pvVar5;
if (param_3 < 1) {
return;
}
puVar1 = param_2 + param_3;
lVar7 = 0;
do {
uVar2 = *param_2;
__size = (long)(int)uVar2 * 8;
__base = malloc(__size);
*(void **)((long)pvVar5 + lVar7) = __base;
if (0 < (int)uVar2) {
lVar3 = *(long *)(param_1 + lVar7);
if (uVar2 - 1 < 3) {
lVar6 = 0;
}
else {
lVar6 = 0;
if (__base != (void *)(lVar3 + 8)) {
do {
uVar4 = ((int8 *)(lVar3 + lVar6))[1];
*(int8 *)((long)__base + lVar6) = *(int8 *)(lVar3 + lVar6);
((int8 *)((long)__base + lVar6))[1] = uVar4;
lVar6 = lVar6 + 0x10;
} while (lVar6 != (ulong)(uVar2 >> 1) << 4);
if ((uVar2 & 1) != 0) {
*(int8 *)((long)__base + (ulong)(uVar2 & 0xfffffffe) * 8) =
*(int8 *)(lVar3 + (ulong)(uVar2 & 0xfffffffe) * 8);
}
goto LAB_001014a0;
}
}
do {
*(int8 *)((long)__base + lVar6) = *(int8 *)(lVar3 + lVar6);
lVar6 = lVar6 + 8;
} while (__size - lVar6 != 0);
}
LAB_001014a0:
param_2 = param_2 + 1;
lVar7 = lVar7 + 8;
qsort(__base,(long)(int)uVar2,8,compare);
if (param_2 == puVar1) {
return;
}
pvVar5 = (void *)*param_4;
} while( true );
} |
4,312 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_11A5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
4,313 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0
jmp short loc_118C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0x0
JMP 0x0010118c | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
4,314 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1168
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
add eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1158
retn
loc_1168:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = (unsigned int)(*a1++ + result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101168
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101158
RET
LAB_00101168:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
4,315 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11e0 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 11e8 <func0+0xa8>
movslq %edx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add $0x3,%edx
add (%rdi,%rcx,4),%eax
cmp %edx,%esi
jle 11e2 <func0+0xa2>
movslq %edx,%rdx
add (%rdi,%rdx,4),%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11aa <func0+0x6a>
| func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rax, rdx
jnz short loc_1170
movdqa xmm1, xmm0
mov edx, esi
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short locret_11E0
loc_11AA:
movsxd rdi, edx
lea r8, ds:0[rdi*4]
add eax, [rcx+rdi*4]
lea edi, [rdx+1]
cmp esi, edi
jle short locret_11DA
add edx, 2
add eax, [rcx+r8+4]
cmp esi, edx
jle short locret_11DA
add eax, [rcx+r8+8]
retn
loc_11D8:
xor eax, eax
locret_11DA:
retn
locret_11E0:
retn
loc_11E1:
xor edx, edx
xor eax, eax
jmp short loc_11AA | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = _mm_loadu_si128(v2++);
v3 = _mm_add_epi32(v3, v4);
}
while ( v2 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v8 = v5;
result = (unsigned int)(a1->m128i_i32[v8] + result);
if ( a2 > v5 + 1 )
{
result = (unsigned int)(a1->m128i_i32[v8 + 1] + result);
if ( a2 > v5 + 2 )
return (unsigned int)(a1->m128i_i32[v8 + 2] + result);
}
return result;
} | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x001011e0
LAB_001011aa:
MOVSXD RDI,EDX
LEA R8,[RDI*0x4]
ADD EAX,dword ptr [RCX + RDI*0x4]
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JLE 0x001011da
ADD EDX,0x2
ADD EAX,dword ptr [RCX + R8*0x1 + 0x4]
CMP ESI,EDX
JLE 0x001011da
ADD EAX,dword ptr [RCX + R8*0x1 + 0x8]
RET
LAB_001011d8:
XOR EAX,EAX
LAB_001011da:
RET
LAB_001011e0:
RET
LAB_001011e1:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011aa | int func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
iVar7 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar7 = iVar7 + iVar1;
iVar8 = iVar8 + *piVar2;
iVar9 = iVar9 + *piVar3;
iVar10 = iVar10 + *piVar4;
} while (piVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) {
return iVar7;
}
}
iVar7 = iVar7 + param_1[(int)uVar6];
if ((int)(uVar6 + 1) < (int)param_2) {
iVar7 = iVar7 + param_1[(long)(int)uVar6 + 1];
if ((int)(uVar6 + 2) < (int)param_2) {
return iVar7 + param_1[(long)(int)uVar6 + 2];
}
}
}
return iVar7;
} |
4,316 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}
| int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && res1[4] == 7);
func0(list2, 3, tup2, 2, res2, 5);
assert(res2[0] == 10 && res2[1] == 11 && res2[2] == 6 && res2[3] == 7 && res2[4] == 8);
func0(list3, 3, tup3, 2, res3, 5);
assert(res3[0] == 11 && res3[1] == 12 && res3[2] == 7 && res3[3] == 8 && res3[4] == 9);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov %r8,-0x30(%rbp)
mov %r9d,-0x34(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e1 <func0+0x58>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x30(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11b0 <func0+0x27>
movl $0x0,-0x4(%rbp)
jmp 1228 <func0+0x9f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%ecx
mov -0x4(%rbp),%edx
add %ecx,%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x30(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11f2 <func0+0x69>
mov -0x30(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov [rbp+var_8], 0
jmp short loc_11E1
loc_11B0:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_30]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_8], 1
loc_11E1:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
jl short loc_11B0
mov [rbp+var_4], 0
jmp short loc_1228
loc_11F2:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rbp+var_8]
mov edx, [rbp+var_4]
add edx, ecx
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_30]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4], 1
loc_1228:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11F2
mov rax, [rbp+var_30]
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
int i; // [rsp+2Ch] [rbp-8h]
int j; // [rsp+30h] [rbp-4h]
for ( i = 0; i < a4; ++i )
*(_DWORD *)(4LL * i + a5) = *(_DWORD *)(4LL * i + a3);
for ( j = 0; j < a2; ++j )
*(_DWORD *)(4LL * (i + j) + a5) = *(_DWORD *)(4LL * j + a1);
return a5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011e1
LAB_001011b0:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x30]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011b0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101228
LAB_001011f2:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x4]
ADD EDX,ECX
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x30]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101228:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011f2
MOV RAX,qword ptr [RBP + -0x30]
POP RBP
RET | long func0(long param_1,int param_2,long param_3,int param_4,long param_5)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
*(int4 *)(param_5 + (long)local_10 * 4) = *(int4 *)(param_3 + (long)local_10 * 4);
}
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int4 *)(param_5 + (long)(local_c + local_10) * 4) =
*(int4 *)(param_1 + (long)local_c * 4);
}
return param_5;
} |
4,317 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}
| int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && res1[4] == 7);
func0(list2, 3, tup2, 2, res2, 5);
assert(res2[0] == 10 && res2[1] == 11 && res2[2] == 6 && res2[3] == 7 && res2[4] == 8);
func0(list3, 3, tup3, 2, res3, 5);
assert(res3[0] == 11 && res3[1] == 12 && res3[2] == 7 && res3[3] == 8 && res3[4] == 9);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
mov %r8,%rax
test %ecx,%ecx
jle 11d9 <func0+0x50>
lea -0x1(%rcx),%r8d
mov $0x0,%r9d
mov (%rdx,%r9,4),%r10d
mov %r10d,(%rax,%r9,4)
mov %r9,%r10
add $0x1,%r9
cmp %r8,%r10
jne 119e <func0+0x15>
test %esi,%esi
jle 11d8 <func0+0x4f>
lea -0x1(%rsi),%r8d
movslq %ecx,%rcx
lea (%rax,%rcx,4),%rsi
mov $0x0,%edx
mov (%rdi,%rdx,4),%ecx
mov %ecx,(%rsi,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%r8
jne 11c6 <func0+0x3d>
retq
mov $0x0,%ecx
jmp 11b2 <func0+0x29>
| func0:
endbr64
mov r10, rdi
mov rax, r8
test ecx, ecx
jle short loc_11D3
mov r8d, ecx
mov edi, 0
loc_119F:
mov r9d, [rdx+rdi*4]
mov [rax+rdi*4], r9d
add rdi, 1
cmp rdi, r8
jnz short loc_119F
loc_11B0:
test esi, esi
jle short locret_11D2
mov esi, esi
movsxd rcx, ecx
lea rdi, [rax+rcx*4]
mov edx, 0
loc_11C2:
mov ecx, [r10+rdx*4]
mov [rdi+rdx*4], ecx
add rdx, 1
cmp rdx, rsi
jnz short loc_11C2
locret_11D2:
retn
loc_11D3:
mov ecx, 0
jmp short loc_11B0 | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long result; // rax
long long i; // rdi
long long j; // rdx
result = a5;
if ( a4 <= 0 )
{
a4 = 0;
}
else
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a5 + 4 * i) = *(_DWORD *)(a3 + 4 * i);
}
if ( a2 > 0 )
{
for ( j = 0LL; j != a2; ++j )
*(_DWORD *)(a5 + 4LL * a4 + 4 * j) = *(_DWORD *)(a1 + 4 * j);
}
return result;
} | func0:
ENDBR64
MOV R10,RDI
MOV RAX,R8
TEST ECX,ECX
JLE 0x001011d3
MOV R8D,ECX
MOV EDI,0x0
LAB_0010119f:
MOV R9D,dword ptr [RDX + RDI*0x4]
MOV dword ptr [RAX + RDI*0x4],R9D
ADD RDI,0x1
CMP RDI,R8
JNZ 0x0010119f
LAB_001011b0:
TEST ESI,ESI
JLE 0x001011d2
MOV ESI,ESI
MOVSXD RCX,ECX
LEA RDI,[RAX + RCX*0x4]
MOV EDX,0x0
LAB_001011c2:
MOV ECX,dword ptr [R10 + RDX*0x4]
MOV dword ptr [RDI + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x001011c2
LAB_001011d2:
RET
LAB_001011d3:
MOV ECX,0x0
JMP 0x001011b0 | void func0(long param_1,uint param_2,long param_3,uint param_4,long param_5)
{
ulong uVar1;
if ((int)param_4 < 1) {
param_4 = 0;
}
else {
uVar1 = 0;
do {
*(int4 *)(param_5 + uVar1 * 4) = *(int4 *)(param_3 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
if (0 < (int)param_2) {
uVar1 = 0;
do {
*(int4 *)(param_5 + (long)(int)param_4 * 4 + uVar1 * 4) =
*(int4 *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return;
} |
4,318 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}
| int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && res1[4] == 7);
func0(list2, 3, tup2, 2, res2, 5);
assert(res2[0] == 10 && res2[1] == 11 && res2[2] == 6 && res2[3] == 7 && res2[4] == 8);
func0(list3, 3, tup3, 2, res3, 5);
assert(res3[0] == 11 && res3[1] == 12 && res3[2] == 7 && res3[3] == 8 && res3[4] == 9);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
mov %r8,%rax
test %ecx,%ecx
jle 11c8 <func0+0x58>
lea -0x1(%rcx),%r8d
xor %r9d,%r9d
nopw 0x0(%rax,%rax,1)
mov (%rdx,%r9,4),%r10d
mov %r10d,(%rax,%r9,4)
mov %r9,%r10
add $0x1,%r9
cmp %r8,%r10
jne 1188 <func0+0x18>
test %esi,%esi
jle 11c2 <func0+0x52>
movslq %ecx,%rcx
lea -0x1(%rsi),%r8d
xor %edx,%edx
lea (%rax,%rcx,4),%rsi
nopl (%rax)
mov (%rdi,%rdx,4),%ecx
mov %ecx,(%rsi,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%r8
jne 11b0 <func0+0x40>
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
jmp 119c <func0+0x2c>
nopl 0x0(%rax)
| func0:
endbr64
mov r10, rdi
mov rax, r8
test ecx, ecx
jle short loc_1418
movsxd r8, ecx
xor edi, edi
nop dword ptr [rax+rax+00h]
loc_13D8:
mov r9d, [rdx+rdi*4]
mov [rax+rdi*4], r9d
add rdi, 1
cmp rdi, r8
jnz short loc_13D8
loc_13E9:
test esi, esi
jle short locret_1410
movsxd rcx, ecx
movsxd rsi, esi
xor edx, edx
lea rdi, [rax+rcx*4]
nop dword ptr [rax+00000000h]
loc_1400:
mov ecx, [r10+rdx*4]
mov [rdi+rdx*4], ecx
add rdx, 1
cmp rsi, rdx
jnz short loc_1400
locret_1410:
retn
loc_1418:
xor ecx, ecx
jmp short loc_13E9 | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long result; // rax
long long i; // rdi
long long j; // rdx
result = a5;
if ( a4 <= 0 )
{
a4 = 0;
}
else
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a5 + 4 * i) = *(_DWORD *)(a3 + 4 * i);
}
if ( a2 > 0 )
{
for ( j = 0LL; j != a2; ++j )
*(_DWORD *)(a5 + 4LL * a4 + 4 * j) = *(_DWORD *)(a1 + 4 * j);
}
return result;
} | func0:
ENDBR64
MOV R10,RDI
MOV RAX,R8
TEST ECX,ECX
JLE 0x00101418
MOVSXD R8,ECX
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d8:
MOV R9D,dword ptr [RDX + RDI*0x4]
MOV dword ptr [RAX + RDI*0x4],R9D
ADD RDI,0x1
CMP RDI,R8
JNZ 0x001013d8
LAB_001013e9:
TEST ESI,ESI
JLE 0x00101410
MOVSXD RCX,ECX
MOVSXD RSI,ESI
XOR EDX,EDX
LEA RDI,[RAX + RCX*0x4]
NOP dword ptr [RAX]
LAB_00101400:
MOV ECX,dword ptr [R10 + RDX*0x4]
MOV dword ptr [RDI + RDX*0x4],ECX
ADD RDX,0x1
CMP RSI,RDX
JNZ 0x00101400
LAB_00101410:
RET
LAB_00101418:
XOR ECX,ECX
JMP 0x001013e9 | void func0(long param_1,int param_2,long param_3,int param_4,long param_5)
{
long lVar1;
if (param_4 < 1) {
param_4 = 0;
}
else {
lVar1 = 0;
do {
*(int4 *)(param_5 + lVar1 * 4) = *(int4 *)(param_3 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_4);
}
if (0 < param_2) {
lVar1 = 0;
do {
*(int4 *)(param_5 + (long)param_4 * 4 + lVar1 * 4) =
*(int4 *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return;
} |
4,319 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}
| int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && res1[4] == 7);
func0(list2, 3, tup2, 2, res2, 5);
assert(res2[0] == 10 && res2[1] == 11 && res2[2] == 6 && res2[3] == 7 && res2[4] == 8);
func0(list3, 3, tup3, 2, res3, 5);
assert(res3[0] == 11 && res3[1] == 12 && res3[2] == 7 && res3[3] == 8 && res3[4] == 9);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
mov %r8,%rax
test %ecx,%ecx
jle 1300 <func0+0x190>
lea 0xf(%rax),%r9
lea -0x1(%rcx),%r8d
sub %rdx,%r9
cmp $0x1e,%r9
jbe 12d0 <func0+0x160>
cmp $0x3,%r8d
jbe 12d0 <func0+0x160>
mov %ecx,%r8d
xor %r9d,%r9d
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax)
movdqu (%rdx,%r9,1),%xmm0
movups %xmm0,(%rax,%r9,1)
add $0x10,%r9
cmp %r8,%r9
jne 11b0 <func0+0x40>
mov %ecx,%r8d
and $0xfffffffc,%r8d
test $0x3,%cl
je 1203 <func0+0x93>
mov %r8d,%r9d
mov (%rdx,%r9,4),%r10d
mov %r10d,(%rax,%r9,4)
lea 0x1(%r8),%r9d
cmp %r9d,%ecx
jle 1203 <func0+0x93>
movslq %r9d,%r9
add $0x2,%r8d
mov (%rdx,%r9,4),%r10d
mov %r10d,(%rax,%r9,4)
cmp %r8d,%ecx
jle 1203 <func0+0x93>
movslq %r8d,%r8
mov (%rdx,%r8,4),%edx
mov %edx,(%rax,%r8,4)
test %esi,%esi
jle 12cb <func0+0x15b>
movslq %ecx,%r8
lea -0x1(%rsi),%edx
lea (%rax,%r8,4),%r9
lea 0x10(%rax,%r8,4),%r8
cmp %r8,%rdi
lea 0x10(%rdi),%r8
setae %r10b
cmp %r8,%r9
setae %r8b
or %r8b,%r10b
je 12b0 <func0+0x140>
cmp $0x3,%edx
jbe 12b0 <func0+0x140>
mov %esi,%r8d
xor %edx,%edx
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax,%rax,1)
movdqu (%rdi,%rdx,1),%xmm1
movups %xmm1,(%r9,%rdx,1)
add $0x10,%rdx
cmp %r8,%rdx
jne 1248 <func0+0xd8>
mov %esi,%edx
and $0xfffffffc,%edx
test $0x3,%sil
je 12cb <func0+0x15b>
mov %edx,%r8d
mov (%rdi,%r8,4),%r9d
lea (%rcx,%rdx,1),%r8d
movslq %r8d,%r8
mov %r9d,(%rax,%r8,4)
lea 0x1(%rdx),%r8d
cmp %esi,%r8d
jge 12cb <func0+0x15b>
movslq %r8d,%r9
add %ecx,%r8d
add $0x2,%edx
mov (%rdi,%r9,4),%r9d
movslq %r8d,%r8
mov %r9d,(%rax,%r8,4)
cmp %edx,%esi
jle 12cb <func0+0x15b>
movslq %edx,%rsi
add %edx,%ecx
mov (%rdi,%rsi,4),%esi
movslq %ecx,%rcx
mov %esi,(%rax,%rcx,4)
retq
nopl 0x0(%rax,%rax,1)
mov %edx,%ecx
xor %edx,%edx
nopl 0x0(%rax)
mov (%rdi,%rdx,4),%esi
mov %esi,(%r9,%rdx,4)
mov %rdx,%rsi
add $0x1,%rdx
cmp %rcx,%rsi
jne 12b8 <func0+0x148>
retq
nopl 0x0(%rax)
mov %r8d,%r9d
xor %r8d,%r8d
nopw %cs:0x0(%rax,%rax,1)
mov (%rdx,%r8,4),%r10d
mov %r10d,(%rax,%r8,4)
mov %r8,%r10
add $0x1,%r8
cmp %r9,%r10
jne 12e0 <func0+0x170>
jmpq 1203 <func0+0x93>
nopl 0x0(%rax)
xor %ecx,%ecx
jmpq 1203 <func0+0x93>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test ecx, ecx
jle loc_1300
lea eax, [rcx-1]
cmp eax, 2
jbe short loc_1194
lea r9, [rdx+4]
mov rax, r8
sub rax, r9
cmp rax, 8
ja short loc_1200
loc_1194:
movsxd r10, ecx
xor eax, eax
shl r10, 2
nop dword ptr [rax]
loc_11A0:
mov r9d, [rdx+rax]
mov [r8+rax], r9d
add rax, 4
cmp rax, r10
jnz short loc_11A0
loc_11B1:
test esi, esi
jle short loc_11F7
lea eax, [rsi-1]
movsxd r10, ecx
cmp eax, 2
jbe short loc_11D8
lea r9, [r8+r10*4]
lea rdx, [rdi+4]
mov rax, r9
sub rax, rdx
cmp rax, 8
ja loc_1278
loc_11D8:
movsxd rsi, esi
lea rcx, [r8+r10*4]
xor eax, eax
shl rsi, 2
nop dword ptr [rax]
loc_11E8:
mov edx, [rdi+rax]
mov [rcx+rax], edx
add rax, 4
cmp rsi, rax
jnz short loc_11E8
loc_11F7:
mov rax, r8
retn
loc_1200:
mov r9d, ecx
xor eax, eax
shr r9d, 2
shl r9, 4
nop dword ptr [rax]
loc_1210:
movdqu xmm0, xmmword ptr [rdx+rax]
movups xmmword ptr [r8+rax], xmm0
add rax, 10h
cmp rax, r9
jnz short loc_1210
mov eax, ecx
and eax, 0FFFFFFFCh
test cl, 3
jz short loc_11B1
mov r10d, eax
mov r11d, [rdx+r10*4]
lea r9, ds:0[r10*4]
mov [r8+r10*4], r11d
lea r10d, [rax+1]
cmp ecx, r10d
jle loc_11B1
mov r10d, [rdx+r9+4]
add eax, 2
mov [r8+r9+4], r10d
cmp ecx, eax
jle loc_11B1
mov eax, [rdx+r9+8]
mov [r8+r9+8], eax
jmp loc_11B1
loc_1278:
mov edx, esi
xor eax, eax
shr edx, 2
shl rdx, 4
nop dword ptr [rax+rax+00h]
loc_1288:
movdqu xmm1, xmmword ptr [rdi+rax]
movups xmmword ptr [r9+rax], xmm1
add rax, 10h
cmp rax, rdx
jnz short loc_1288
mov eax, esi
and eax, 0FFFFFFFCh
test sil, 3
jz loc_11F7
mov edx, eax
mov r10d, [rdi+rdx*4]
lea r9, ds:0[rdx*4]
lea edx, [rax+rcx]
movsxd rdx, edx
mov [r8+rdx*4], r10d
lea edx, [rax+1]
cmp edx, esi
jge loc_11F7
mov r10d, [rdi+r9+4]
add edx, ecx
add eax, 2
movsxd rdx, edx
mov [r8+rdx*4], r10d
cmp esi, eax
jle loc_11F7
add ecx, eax
mov edx, [rdi+r9+8]
mov rax, r8
movsxd rcx, ecx
mov [r8+rcx*4], edx
retn
loc_1300:
xor ecx, ecx
jmp loc_11B1 | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long v5; // rax
long long v6; // rax
long long v7; // rsi
long long result; // rax
long long v9; // rax
unsigned int v10; // eax
long long v11; // r9
long long v12; // rax
unsigned int v13; // eax
long long v14; // r9
unsigned int v15; // edx
int v16; // eax
int v17; // ecx
if ( a4 <= 0 )
{
a4 = 0;
}
else if ( (unsigned int)(a4 - 1) > 2 && (unsigned long long)(a5 - (a3 + 4)) > 8 )
{
v9 = 0LL;
do
{
*(__m128i *)(a5 + v9) = _mm_loadu_si128((const __m128i *)(a3 + v9));
v9 += 16LL;
}
while ( v9 != 16LL * ((unsigned int)a4 >> 2) );
v10 = a4 & 0x7FFFFFFC;
if ( (a4 & 3) != 0 )
{
v11 = 4LL * v10;
*(_DWORD *)(a5 + v11) = *(_DWORD *)(a3 + v11);
if ( a4 > (int)(v10 + 1) )
{
*(_DWORD *)(a5 + v11 + 4) = *(_DWORD *)(a3 + v11 + 4);
if ( a4 > (int)(v10 + 2) )
*(_DWORD *)(a5 + v11 + 8) = *(_DWORD *)(a3 + v11 + 8);
}
}
}
else
{
v5 = 0LL;
do
{
*(_DWORD *)(a5 + v5) = *(_DWORD *)(a3 + v5);
v5 += 4LL;
}
while ( v5 != 4LL * a4 );
}
if ( a2 <= 0 )
return a5;
if ( (unsigned int)(a2 - 1) <= 2 || (unsigned long long)(a5 + 4LL * a4 - (a1 + 4)) <= 8 )
{
v6 = 0LL;
v7 = 4LL * a2;
do
{
*(_DWORD *)(a5 + 4LL * a4 + v6) = *(_DWORD *)(a1 + v6);
v6 += 4LL;
}
while ( v7 != v6 );
return a5;
}
v12 = 0LL;
do
{
*(__m128i *)(a5 + 4LL * a4 + v12) = _mm_loadu_si128((const __m128i *)(a1 + v12));
v12 += 16LL;
}
while ( v12 != 16LL * ((unsigned int)a2 >> 2) );
v13 = a2 & 0x7FFFFFFC;
if ( (a2 & 3) == 0 )
return a5;
v14 = 4LL * v13;
*(_DWORD *)(a5 + 4LL * (int)(v13 + a4)) = *(_DWORD *)(a1 + v14);
v15 = v13 + 1;
if ( (int)(v13 + 1) >= a2 )
return a5;
v16 = v13 + 2;
*(_DWORD *)(a5 + 4LL * (int)(a4 + v15)) = *(_DWORD *)(a1 + v14 + 4);
if ( a2 <= v16 )
return a5;
v17 = v16 + a4;
result = a5;
*(_DWORD *)(a5 + 4LL * v17) = *(_DWORD *)(a1 + v14 + 8);
return result;
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101300
LEA EAX,[RCX + -0x1]
CMP EAX,0x2
JBE 0x00101194
LEA R9,[RDX + 0x4]
MOV RAX,R8
SUB RAX,R9
CMP RAX,0x8
JA 0x00101200
LAB_00101194:
MOVSXD R10,ECX
XOR EAX,EAX
SHL R10,0x2
NOP dword ptr [RAX]
LAB_001011a0:
MOV R9D,dword ptr [RDX + RAX*0x1]
MOV dword ptr [R8 + RAX*0x1],R9D
ADD RAX,0x4
CMP RAX,R10
JNZ 0x001011a0
LAB_001011b1:
TEST ESI,ESI
JLE 0x001011f7
LEA EAX,[RSI + -0x1]
MOVSXD R10,ECX
CMP EAX,0x2
JBE 0x001011d8
LEA R9,[R8 + R10*0x4]
LEA RDX,[RDI + 0x4]
MOV RAX,R9
SUB RAX,RDX
CMP RAX,0x8
JA 0x00101278
LAB_001011d8:
MOVSXD RSI,ESI
LEA RCX,[R8 + R10*0x4]
XOR EAX,EAX
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_001011e8:
MOV EDX,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RCX + RAX*0x1],EDX
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x001011e8
LAB_001011f7:
MOV RAX,R8
RET
LAB_00101200:
MOV R9D,ECX
XOR EAX,EAX
SHR R9D,0x2
SHL R9,0x4
NOP dword ptr [RAX]
LAB_00101210:
MOVDQU XMM0,xmmword ptr [RDX + RAX*0x1]
MOVUPS xmmword ptr [R8 + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,R9
JNZ 0x00101210
MOV EAX,ECX
AND EAX,0xfffffffc
TEST CL,0x3
JZ 0x001011b1
MOV R10D,EAX
MOV R11D,dword ptr [RDX + R10*0x4]
LEA R9,[R10*0x4]
MOV dword ptr [R8 + R10*0x4],R11D
LEA R10D,[RAX + 0x1]
CMP ECX,R10D
JLE 0x001011b1
MOV R10D,dword ptr [RDX + R9*0x1 + 0x4]
ADD EAX,0x2
MOV dword ptr [R8 + R9*0x1 + 0x4],R10D
CMP ECX,EAX
JLE 0x001011b1
MOV EAX,dword ptr [RDX + R9*0x1 + 0x8]
MOV dword ptr [R8 + R9*0x1 + 0x8],EAX
JMP 0x001011b1
LAB_00101278:
MOV EDX,ESI
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101288:
MOVDQU XMM1,xmmword ptr [RDI + RAX*0x1]
MOVUPS xmmword ptr [R9 + RAX*0x1],XMM1
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101288
MOV EAX,ESI
AND EAX,0xfffffffc
TEST SIL,0x3
JZ 0x001011f7
MOV EDX,EAX
MOV R10D,dword ptr [RDI + RDX*0x4]
LEA R9,[RDX*0x4]
LEA EDX,[RAX + RCX*0x1]
MOVSXD RDX,EDX
MOV dword ptr [R8 + RDX*0x4],R10D
LEA EDX,[RAX + 0x1]
CMP EDX,ESI
JGE 0x001011f7
MOV R10D,dword ptr [RDI + R9*0x1 + 0x4]
ADD EDX,ECX
ADD EAX,0x2
MOVSXD RDX,EDX
MOV dword ptr [R8 + RDX*0x4],R10D
CMP ESI,EAX
JLE 0x001011f7
ADD ECX,EAX
MOV EDX,dword ptr [RDI + R9*0x1 + 0x8]
MOV RAX,R8
MOVSXD RCX,ECX
MOV dword ptr [R8 + RCX*0x4],EDX
RET
LAB_00101300:
XOR ECX,ECX
JMP 0x001011b1 | long func0(long param_1,uint param_2,long param_3,uint param_4,long param_5)
{
int8 *puVar1;
int8 uVar2;
uint uVar3;
long lVar4;
long lVar5;
ulong uVar6;
if ((int)param_4 < 1) {
param_4 = 0;
}
else if ((param_4 - 1 < 3) || ((ulong)(param_5 - (param_3 + 4)) < 9)) {
lVar4 = 0;
do {
*(int4 *)(param_5 + lVar4) = *(int4 *)(param_3 + lVar4);
lVar4 = lVar4 + 4;
} while (lVar4 != (long)(int)param_4 * 4);
}
else {
lVar4 = 0;
do {
uVar2 = ((int8 *)(param_3 + lVar4))[1];
*(int8 *)(param_5 + lVar4) = *(int8 *)(param_3 + lVar4);
((int8 *)(param_5 + lVar4))[1] = uVar2;
lVar4 = lVar4 + 0x10;
} while (lVar4 != (ulong)(param_4 >> 2) << 4);
uVar3 = param_4 & 0xfffffffc;
if ((param_4 & 3) != 0) {
uVar6 = (ulong)uVar3;
lVar4 = uVar6 * 4;
*(int4 *)(param_5 + uVar6 * 4) = *(int4 *)(param_3 + uVar6 * 4);
if (((int)(uVar3 + 1) < (int)param_4) &&
(*(int4 *)(param_5 + 4 + lVar4) = *(int4 *)(param_3 + 4 + lVar4),
(int)(uVar3 + 2) < (int)param_4)) {
*(int4 *)(param_5 + 8 + lVar4) = *(int4 *)(param_3 + 8 + lVar4);
}
}
}
if (0 < (int)param_2) {
if ((param_2 - 1 < 3) ||
(lVar4 = param_5 + (long)(int)param_4 * 4, (ulong)(lVar4 - (param_1 + 4)) < 9)) {
lVar4 = 0;
do {
*(int4 *)(param_5 + (long)(int)param_4 * 4 + lVar4) = *(int4 *)(param_1 + lVar4)
;
lVar4 = lVar4 + 4;
} while ((long)(int)param_2 * 4 != lVar4);
}
else {
lVar5 = 0;
do {
uVar2 = ((int8 *)(param_1 + lVar5))[1];
puVar1 = (int8 *)(lVar4 + lVar5);
*puVar1 = *(int8 *)(param_1 + lVar5);
puVar1[1] = uVar2;
lVar5 = lVar5 + 0x10;
} while (lVar5 != (ulong)(param_2 >> 2) << 4);
uVar3 = param_2 & 0xfffffffc;
if ((param_2 & 3) != 0) {
lVar4 = (ulong)uVar3 * 4;
*(int4 *)(param_5 + (long)(int)(uVar3 + param_4) * 4) =
*(int4 *)(param_1 + (ulong)uVar3 * 4);
if ((int)(uVar3 + 1) < (int)param_2) {
*(int4 *)(param_5 + (long)(int)(uVar3 + 1 + param_4) * 4) =
*(int4 *)(param_1 + 4 + lVar4);
if ((int)(uVar3 + 2) < (int)param_2) {
*(int4 *)(param_5 + (long)(int)(param_4 + uVar3 + 2) * 4) =
*(int4 *)(param_1 + 8 + lVar4);
return param_5;
}
}
}
}
}
return param_5;
} |
4,320 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
k = k / 16;
}
}
}
return count;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11b8 <func0+0x6f>
cmpl $0x9,-0x8(%rbp)
jle 1178 <func0+0x2f>
cmpl $0xf,-0x8(%rbp)
jg 1178 <func0+0x2f>
addl $0x1,-0xc(%rbp)
jmp 11b4 <func0+0x6b>
cmpl $0xf,-0x8(%rbp)
jle 11b4 <func0+0x6b>
mov -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 11ae <func0+0x65>
mov -0x4(%rbp),%eax
cltd
shr $0x1c,%edx
add %edx,%eax
and $0xf,%eax
sub %edx,%eax
cmp $0x9,%eax
jle 119d <func0+0x54>
addl $0x1,-0xc(%rbp)
mov -0x4(%rbp),%eax
lea 0xf(%rax),%edx
test %eax,%eax
cmovs %edx,%eax
sar $0x4,%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 1186 <func0+0x3d>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 1166 <func0+0x1d>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11BE
loc_1166:
cmp [rbp+var_8], 9
jle short loc_1178
cmp [rbp+var_8], 0Fh
jg short loc_1178
add [rbp+var_C], 1
jmp short loc_11BA
loc_1178:
cmp [rbp+var_8], 0Fh
jle short loc_11BA
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp short loc_11B4
loc_1186:
mov edx, [rbp+var_4]
mov eax, edx
sar eax, 1Fh
shr eax, 1Ch
add edx, eax
and edx, 0Fh
sub edx, eax
mov eax, edx
cmp eax, 9
jle short loc_11A3
add [rbp+var_C], 1
loc_11A3:
mov eax, [rbp+var_4]
lea edx, [rax+0Fh]
test eax, eax
cmovs eax, edx
sar eax, 4
mov [rbp+var_4], eax
loc_11B4:
cmp [rbp+var_4], 0
jnz short loc_1186
loc_11BA:
add [rbp+var_8], 1
loc_11BE:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_18]
jle short loc_1166
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(int a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-Ch]
int i; // [rsp+14h] [rbp-4h]
v3 = 0;
while ( a1 <= a2 )
{
if ( a1 <= 9 || a1 > 15 )
{
if ( a1 > 15 )
{
for ( i = a1; i; i /= 16 )
{
if ( i % 16 > 9 )
++v3;
}
}
}
else
{
++v3;
}
++a1;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011be
LAB_00101166:
CMP dword ptr [RBP + -0x8],0x9
JLE 0x00101178
CMP dword ptr [RBP + -0x8],0xf
JG 0x00101178
ADD dword ptr [RBP + -0xc],0x1
JMP 0x001011ba
LAB_00101178:
CMP dword ptr [RBP + -0x8],0xf
JLE 0x001011ba
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011b4
LAB_00101186:
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1c
ADD EDX,EAX
AND EDX,0xf
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x9
JLE 0x001011a3
ADD dword ptr [RBP + -0xc],0x1
LAB_001011a3:
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0xf]
TEST EAX,EAX
CMOVS EAX,EDX
SAR EAX,0x4
MOV dword ptr [RBP + -0x4],EAX
LAB_001011b4:
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x00101186
LAB_001011ba:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011be:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x00101166
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = param_1; local_10 <= param_2; local_10 = local_10 + 1) {
if ((local_10 < 10) || (0xf < local_10)) {
if (0xf < local_10) {
for (local_c = local_10; local_c != 0; local_c = local_c >> 4) {
if (9 < local_c % 0x10) {
local_14 = local_14 + 1;
}
if (local_c < 0) {
local_c = local_c + 0xf;
}
}
}
}
else {
local_14 = local_14 + 1;
}
}
return local_14;
} |
4,321 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
k = k / 16;
}
}
}
return count;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
jg 11a4 <func0+0x5b>
lea 0x1(%rsi),%r8d
mov $0x0,%esi
jmp 1169 <func0+0x20>
cmp $0xf,%edi
jg 1176 <func0+0x2d>
add $0x1,%edi
cmp %r8d,%edi
je 11a9 <func0+0x60>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
ja 115c <func0+0x13>
add $0x1,%esi
jmp 1161 <func0+0x18>
mov %edi,%edx
mov %edx,%ecx
sar $0x1f,%ecx
shr $0x1c,%ecx
lea (%rdx,%rcx,1),%eax
and $0xf,%eax
sub %ecx,%eax
cmp $0x9,%eax
setg %al
movzbl %al,%eax
add %eax,%esi
lea 0xf(%rdx),%eax
test %edx,%edx
cmovns %edx,%eax
sar $0x4,%eax
mov %eax,%edx
jne 1178 <func0+0x2f>
jmp 1161 <func0+0x18>
mov $0x0,%esi
mov %esi,%eax
retq
| func0:
endbr64
cmp edi, esi
jg short loc_11A5
add esi, 1
mov r8d, 0
jmp short loc_1168
loc_115C:
cmp edi, 0Fh
jg short loc_1176
loc_1161:
add edi, 1
cmp edi, esi
jz short loc_11AB
loc_1168:
lea eax, [rdi-0Ah]
cmp eax, 5
ja short loc_115C
add r8d, 1
jmp short loc_1161
loc_1176:
mov edx, edi
loc_1178:
mov ecx, edx
sar ecx, 1Fh
shr ecx, 1Ch
lea eax, [rdx+rcx]
and eax, 0Fh
sub eax, ecx
cmp eax, 9
setnle al
movzx eax, al
add r8d, eax
lea eax, [rdx+0Fh]
test edx, edx
cmovns eax, edx
sar eax, 4
mov edx, eax
jnz short loc_1178
jmp short loc_1161
loc_11A5:
mov r8d, 0
loc_11AB:
mov eax, r8d
retn | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // esi
unsigned int v4; // r8d
int v5; // edx
if ( a1 > a2 )
{
return 0;
}
else
{
v3 = a2 + 1;
v4 = 0;
do
{
if ( (unsigned int)(a1 - 10) > 5 )
{
if ( a1 > 15 )
{
v5 = a1;
do
{
v4 += v5 % 16 > 9;
v5 /= 16;
}
while ( v2 >> 4 );
}
}
else
{
++v4;
}
++a1;
}
while ( a1 != v3 );
}
return v4;
} | func0:
ENDBR64
CMP EDI,ESI
JG 0x001011a5
ADD ESI,0x1
MOV R8D,0x0
JMP 0x00101168
LAB_0010115c:
CMP EDI,0xf
JG 0x00101176
LAB_00101161:
ADD EDI,0x1
CMP EDI,ESI
JZ 0x001011ab
LAB_00101168:
LEA EAX,[RDI + -0xa]
CMP EAX,0x5
JA 0x0010115c
ADD R8D,0x1
JMP 0x00101161
LAB_00101176:
MOV EDX,EDI
LAB_00101178:
MOV ECX,EDX
SAR ECX,0x1f
SHR ECX,0x1c
LEA EAX,[RDX + RCX*0x1]
AND EAX,0xf
SUB EAX,ECX
CMP EAX,0x9
SETG AL
MOVZX EAX,AL
ADD R8D,EAX
LEA EAX,[RDX + 0xf]
TEST EDX,EDX
CMOVNS EAX,EDX
SAR EAX,0x4
MOV EDX,EAX
JNZ 0x00101178
JMP 0x00101161
LAB_001011a5:
MOV R8D,0x0
LAB_001011ab:
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 < param_1) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
if (param_1 - 10U < 6) {
iVar3 = iVar3 + 1;
}
else {
iVar1 = param_1;
if (0xf < param_1) {
do {
iVar3 = iVar3 + (uint)(9 < iVar1 % 0x10);
iVar2 = iVar1 + 0xf;
if (-1 < iVar1) {
iVar2 = iVar1;
}
iVar1 = iVar2 >> 4;
} while (iVar2 >> 4 != 0);
}
}
param_1 = param_1 + 1;
} while (param_1 != param_2 + 1);
}
return iVar3;
} |
4,322 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
k = k / 16;
}
}
}
return count;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
jg 1198 <func0+0x58>
add $0x1,%esi
xor %r8d,%r8d
jmp 115b <func0+0x1b>
add $0x1,%r8d
add $0x1,%edi
cmp %edi,%esi
je 118d <func0+0x4d>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
jbe 1150 <func0+0x10>
cmp $0xf,%edi
jle 1154 <func0+0x14>
mov %edi,%eax
nopw 0x0(%rax,%rax,1)
mov %eax,%edx
and $0xf,%edx
cmp $0x9,%edx
setg %dl
movzbl %dl,%edx
add %edx,%r8d
sar $0x4,%eax
jne 1170 <func0+0x30>
add $0x1,%edi
cmp %edi,%esi
jne 115b <func0+0x1b>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp edi, esi
jg short loc_1258
add esi, 1
xor r8d, r8d
jmp short loc_121B
loc_1210:
add r8d, 1
loc_1214:
add edi, 1
cmp esi, edi
jz short loc_124D
loc_121B:
lea eax, [rdi-0Ah]
cmp eax, 5
jbe short loc_1210
cmp edi, 0Fh
jle short loc_1214
mov eax, edi
nop word ptr [rax+rax+00h]
loc_1230:
mov edx, eax
and edx, 0Fh
cmp edx, 9
setnle dl
movzx edx, dl
add r8d, edx
sar eax, 4
jnz short loc_1230
add edi, 1
cmp esi, edi
jnz short loc_121B
loc_124D:
mov eax, r8d
retn
loc_1258:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1, int a2)
{
int v2; // esi
unsigned int v3; // r8d
int v4; // eax
if ( a1 <= a2 )
{
v2 = a2 + 1;
v3 = 0;
while ( 1 )
{
while ( (unsigned int)(a1 - 10) <= 5 )
{
++v3;
LABEL_4:
if ( v2 == ++a1 )
return v3;
}
if ( a1 <= 15 )
goto LABEL_4;
v4 = a1;
do
{
v3 += (v4 & 0xFu) > 9;
v4 >>= 4;
}
while ( v4 );
if ( v2 == ++a1 )
return v3;
}
}
return 0LL;
} | func0:
ENDBR64
CMP EDI,ESI
JG 0x00101258
ADD ESI,0x1
XOR R8D,R8D
JMP 0x0010121b
LAB_00101210:
ADD R8D,0x1
LAB_00101214:
ADD EDI,0x1
CMP ESI,EDI
JZ 0x0010124d
LAB_0010121b:
LEA EAX,[RDI + -0xa]
CMP EAX,0x5
JBE 0x00101210
CMP EDI,0xf
JLE 0x00101214
MOV EAX,EDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101230:
MOV EDX,EAX
AND EDX,0xf
CMP EDX,0x9
SETG DL
MOVZX EDX,DL
ADD R8D,EDX
SAR EAX,0x4
JNZ 0x00101230
ADD EDI,0x1
CMP ESI,EDI
JNZ 0x0010121b
LAB_0010124d:
MOV EAX,R8D
RET
LAB_00101258:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(uint param_1,int param_2)
{
uint uVar1;
int iVar2;
if ((int)param_1 <= param_2) {
iVar2 = 0;
do {
if (param_1 - 10 < 6) {
iVar2 = iVar2 + 1;
}
else {
uVar1 = param_1;
if (0xf < (int)param_1) {
do {
iVar2 = iVar2 + (uint)(9 < (uVar1 & 0xf));
uVar1 = (int)uVar1 >> 4;
} while (uVar1 != 0);
}
}
param_1 = param_1 + 1;
} while (param_2 + 1U != param_1);
return iVar2;
}
return 0;
} |
4,323 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
k = k / 16;
}
}
}
return count;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
jg 1308 <func0+0x1c8>
cmp $0xf,%edi
jg 1300 <func0+0x1c0>
cmp $0xf,%esi
mov $0xf,%edx
mov $0x1,%eax
cmovle %esi,%edx
lea 0x1(%rdx),%ecx
sub %edi,%ecx
cmp %edx,%edi
cmovg %eax,%ecx
mov %edx,%eax
sub %edi,%eax
cmp $0x5,%eax
jbe 130f <func0+0x1cf>
cmp %edx,%edi
jg 130f <func0+0x1cf>
movd %edi,%xmm6
movdqa 0xec0(%rip),%xmm5
mov %ecx,%r8d
xor %eax,%eax
movdqa 0xea3(%rip),%xmm4
pshufd $0x0,%xmm6,%xmm2
movdqa 0xe75(%rip),%xmm9
shr $0x2,%r8d
paddd 0xe59(%rip),%xmm2
movdqa 0xea1(%rip),%xmm7
pxor %xmm3,%xmm3
pcmpeqd %xmm6,%xmm6
movdqa 0xe60(%rip),%xmm8
psubd %xmm5,%xmm4
nopl 0x0(%rax)
movdqa %xmm2,%xmm1
add $0x1,%eax
paddd %xmm9,%xmm2
movdqa %xmm1,%xmm0
paddd %xmm7,%xmm1
paddd %xmm8,%xmm0
psubd %xmm5,%xmm0
pcmpgtd %xmm4,%xmm0
pandn %xmm6,%xmm0
psubd %xmm0,%xmm3
cmp %eax,%r8d
jne 11d8 <func0+0x98>
movdqa %xmm3,%xmm0
mov %ecx,%r9d
pshufd $0xff,%xmm1,%xmm1
psrldq $0x8,%xmm0
and $0xfffffffc,%r9d
movd %xmm1,%eax
paddd %xmm0,%xmm3
add %r9d,%edi
movdqa %xmm3,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm3
movd %xmm3,%r8d
cmp %r9d,%ecx
je 12b0 <func0+0x170>
lea -0xa(%rdi),%eax
cmp $0x6,%eax
lea 0x1(%rdi),%eax
adc $0x0,%r8d
cmp %eax,%edx
jl 12b0 <func0+0x170>
lea -0x9(%rdi),%eax
cmp $0x6,%eax
lea 0x2(%rdi),%eax
adc $0x0,%r8d
cmp %edx,%eax
jg 12b0 <func0+0x170>
lea -0x8(%rdi),%eax
cmp $0x6,%eax
lea 0x3(%rdi),%eax
adc $0x0,%r8d
cmp %edx,%eax
jg 12b0 <func0+0x170>
lea -0x7(%rdi),%eax
cmp $0x6,%eax
lea 0x4(%rdi),%eax
adc $0x0,%r8d
cmp %edx,%eax
jg 12b0 <func0+0x170>
lea -0x6(%rdi),%eax
cmp $0x6,%eax
lea 0x5(%rdi),%eax
adc $0x0,%r8d
cmp %eax,%edx
jl 12b0 <func0+0x170>
lea -0x5(%rdi),%eax
cmp $0x6,%eax
adc $0x0,%r8d
add $0x6,%edi
cmp %edi,%esi
jge 12c3 <func0+0x183>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %eax,%edi
jmp 12bf <func0+0x17f>
nopl 0x0(%rax)
add $0x1,%r8d
add $0x1,%edi
cmp %edi,%esi
jl 12a3 <func0+0x163>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
jbe 12b8 <func0+0x178>
mov %edi,%eax
mov %eax,%ecx
sar $0x1f,%ecx
shr $0x1c,%ecx
lea (%rax,%rcx,1),%edx
and $0xf,%edx
sub %ecx,%edx
cmp $0x9,%edx
setg %dl
movzbl %dl,%edx
add %edx,%r8d
test %eax,%eax
lea 0xf(%rax),%edx
cmovs %edx,%eax
sar $0x4,%eax
jne 12cd <func0+0x18d>
jmp 12bc <func0+0x17c>
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
jmp 12c3 <func0+0x183>
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
xor %r8d,%r8d
jmpq 123d <func0+0xfd>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, edi
mov r8d, esi
xor edi, edi
cmp ecx, esi
jg short loc_11A0
cmp ecx, 0Fh
jg short loc_116B
jmp short loc_11A8
loc_1160:
add edi, 1
loc_1163:
add ecx, 1
loc_1166:
cmp r8d, ecx
jl short loc_11A0
loc_116B:
lea eax, [rcx-0Ah]
cmp eax, 5
jbe short loc_1160
mov eax, ecx
loc_1175:
mov esi, eax
sar esi, 1Fh
shr esi, 1Ch
lea edx, [rax+rsi]
and edx, 0Fh
sub edx, esi
cmp edx, 9
setnle dl
movzx edx, dl
add edi, edx
test eax, eax
lea edx, [rax+0Fh]
cmovs eax, edx
sar eax, 4
jnz short loc_1175
jmp short loc_1163
loc_11A0:
mov eax, edi
retn
loc_11A8:
mov edx, 0Fh
cmp esi, edx
cmovle edx, esi
mov esi, 1
mov eax, edx
sub eax, ecx
cmp ecx, edx
lea r9d, [rax+1]
cmovg r9d, esi
jg loc_12E1
cmp eax, 3
jbe loc_12E1
movd xmm5, ecx
mov esi, r9d
pxor xmm2, xmm2
xor eax, eax
pshufd xmm1, xmm5, 0
movdqa xmm7, cs:xmmword_2030
paddd xmm1, cs:xmmword_2010
shr esi, 2
movdqa xmm6, cs:xmmword_2040
movdqa xmm5, cs:xmmword_2060
movdqa xmm8, cs:xmmword_2020
nop word ptr [rax+rax+00h]
loc_1218:
movdqa xmm3, xmm1
movdqa xmm4, xmm5
paddd xmm1, xmm8
add eax, 1
movdqa xmm0, xmm3
paddd xmm0, xmm7
psubd xmm0, xmm6
pcmpgtd xmm4, xmm0
psubd xmm2, xmm4
cmp esi, eax
jnz short loc_1218
movdqa xmm0, xmm2
mov eax, r9d
psrldq xmm0, 8
and eax, 0FFFFFFFCh
paddd xmm2, xmm0
add eax, ecx
and r9d, 3
movdqa xmm0, xmm2
psrldq xmm0, 4
paddd xmm2, xmm0
movd edi, xmm2
jz short loc_1285
loc_126C:
lea ecx, [rax-0Ah]
cmp ecx, 5
ja short loc_129B
lea ecx, [rax+1]
lea esi, [rdi+1]
cmp ecx, edx
jle short loc_12E7
mov edi, esi
jmp loc_1166
loc_1285:
paddd xmm3, cs:xmmword_2050
pshufd xmm0, xmm3, 0FFh
movd ecx, xmm0
jmp loc_1166
loc_129B:
lea ecx, [rax+1]
cmp edx, ecx
jl loc_1166
lea ecx, [rax-9]
cmp ecx, 6
lea ecx, [rax+2]
adc edi, 0
cmp ecx, edx
jg loc_1166
lea ecx, [rax-8]
cmp ecx, 5
ja short loc_12C5
loc_12C2:
add edi, 1
loc_12C5:
lea ecx, [rax+3]
cmp edx, ecx
jl loc_1166
lea edx, [rax-7]
lea ecx, [rax+4]
cmp edx, 6
adc edi, 0
jmp loc_1166
loc_12E1:
mov eax, ecx
xor edi, edi
jmp short loc_126C
loc_12E7:
lea ecx, [rax+2]
add edi, 2
cmp ecx, edx
jg loc_1166
jmp short loc_12C2 | long long func0(signed int a1, int a2)
{
unsigned int v3; // edi
signed int v4; // eax
int v6; // edx
unsigned int v7; // r9d
__m128i v8; // xmm2
int v9; // eax
__m128i si128; // xmm7
__m128i v11; // xmm1
__m128i v12; // xmm6
__m128i v13; // xmm5
__m128i v14; // xmm8
__m128i v15; // xmm3
__m128i v16; // xmm2
signed int v17; // eax
v3 = 0;
if ( a1 > a2 )
return v3;
if ( a1 > 15 )
goto LABEL_7;
v6 = 15;
if ( a2 <= 15 )
v6 = a2;
v7 = v6 - a1 + 1;
if ( a1 > v6 || (unsigned int)(v6 - a1) <= 3 )
{
v17 = a1;
v3 = 0;
}
else
{
v8 = 0LL;
v9 = 0;
si128 = _mm_load_si128((const __m128i *)&xmmword_2030);
v11 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(a1), 0), (__m128i)xmmword_2010);
v12 = _mm_load_si128((const __m128i *)&xmmword_2040);
v13 = _mm_load_si128((const __m128i *)&xmmword_2060);
v14 = _mm_load_si128((const __m128i *)&xmmword_2020);
do
{
v15 = v11;
v11 = _mm_add_epi32(v11, v14);
++v9;
v8 = _mm_sub_epi32(v8, _mm_cmpgt_epi32(v13, _mm_sub_epi32(_mm_add_epi32(v15, si128), v12)));
}
while ( v7 >> 2 != v9 );
v16 = _mm_add_epi32(v8, _mm_srli_si128(v8, 8));
v17 = a1 + (v7 & 0xFFFFFFFC);
v3 = _mm_cvtsi128_si32(_mm_add_epi32(v16, _mm_srli_si128(v16, 4)));
if ( (v7 & 3) == 0 )
{
a1 = _mm_cvtsi128_si32(_mm_shuffle_epi32(_mm_add_epi32(v15, (__m128i)xmmword_2050), 255));
goto LABEL_6;
}
}
if ( (unsigned int)(v17 - 10) > 5 )
{
a1 = v17 + 1;
if ( v6 < v17 + 1 )
goto LABEL_6;
a1 = v17 + 2;
v3 += (unsigned int)(v17 - 9) < 6;
if ( v17 + 2 > v6 )
goto LABEL_6;
if ( (unsigned int)(v17 - 8) > 5 )
goto LABEL_27;
goto LABEL_26;
}
a1 = v17 + 1;
if ( v17 + 1 > v6 )
{
++v3;
goto LABEL_6;
}
a1 = v17 + 2;
v3 += 2;
if ( v17 + 2 <= v6 )
{
LABEL_26:
++v3;
LABEL_27:
a1 = v17 + 3;
if ( v6 >= v17 + 3 )
{
a1 = v17 + 4;
v3 += (unsigned int)(v17 - 7) < 6;
}
}
LABEL_6:
while ( a2 >= a1 )
{
LABEL_7:
if ( (unsigned int)(a1 - 10) <= 5 )
{
++v3;
}
else
{
v4 = a1;
do
{
v3 += v4 % 16 > 9;
v4 /= 16;
}
while ( v4 );
}
++a1;
}
return v3;
} | func0:
ENDBR64
MOV ECX,EDI
MOV R8D,ESI
XOR EDI,EDI
CMP ECX,ESI
JG 0x001011a0
CMP ECX,0xf
JG 0x0010116b
JMP 0x001011a8
LAB_00101160:
ADD EDI,0x1
LAB_00101163:
ADD ECX,0x1
LAB_00101166:
CMP R8D,ECX
JL 0x001011a0
LAB_0010116b:
LEA EAX,[RCX + -0xa]
CMP EAX,0x5
JBE 0x00101160
MOV EAX,ECX
LAB_00101175:
MOV ESI,EAX
SAR ESI,0x1f
SHR ESI,0x1c
LEA EDX,[RAX + RSI*0x1]
AND EDX,0xf
SUB EDX,ESI
CMP EDX,0x9
SETG DL
MOVZX EDX,DL
ADD EDI,EDX
TEST EAX,EAX
LEA EDX,[RAX + 0xf]
CMOVS EAX,EDX
SAR EAX,0x4
JNZ 0x00101175
JMP 0x00101163
LAB_001011a0:
MOV EAX,EDI
RET
LAB_001011a8:
MOV EDX,0xf
CMP ESI,EDX
CMOVLE EDX,ESI
MOV ESI,0x1
MOV EAX,EDX
SUB EAX,ECX
CMP ECX,EDX
LEA R9D,[RAX + 0x1]
CMOVG R9D,ESI
JG 0x001012e1
CMP EAX,0x3
JBE 0x001012e1
MOVD XMM5,ECX
MOV ESI,R9D
PXOR XMM2,XMM2
XOR EAX,EAX
PSHUFD XMM1,XMM5,0x0
MOVDQA XMM7,xmmword ptr [0x00102030]
PADDD XMM1,xmmword ptr [0x00102010]
SHR ESI,0x2
MOVDQA XMM6,xmmword ptr [0x00102040]
MOVDQA XMM5,xmmword ptr [0x00102060]
MOVDQA XMM8,xmmword ptr [0x00102020]
NOP word ptr [RAX + RAX*0x1]
LAB_00101218:
MOVDQA XMM3,XMM1
MOVDQA XMM4,XMM5
PADDD XMM1,XMM8
ADD EAX,0x1
MOVDQA XMM0,XMM3
PADDD XMM0,XMM7
PSUBD XMM0,XMM6
PCMPGTD XMM4,XMM0
PSUBD XMM2,XMM4
CMP ESI,EAX
JNZ 0x00101218
MOVDQA XMM0,XMM2
MOV EAX,R9D
PSRLDQ XMM0,0x8
AND EAX,0xfffffffc
PADDD XMM2,XMM0
ADD EAX,ECX
AND R9D,0x3
MOVDQA XMM0,XMM2
PSRLDQ XMM0,0x4
PADDD XMM2,XMM0
MOVD EDI,XMM2
JZ 0x00101285
LAB_0010126c:
LEA ECX,[RAX + -0xa]
CMP ECX,0x5
JA 0x0010129b
LEA ECX,[RAX + 0x1]
LEA ESI,[RDI + 0x1]
CMP ECX,EDX
JLE 0x001012e7
MOV EDI,ESI
JMP 0x00101166
LAB_00101285:
PADDD XMM3,xmmword ptr [0x00102050]
PSHUFD XMM0,XMM3,0xff
MOVD ECX,XMM0
JMP 0x00101166
LAB_0010129b:
LEA ECX,[RAX + 0x1]
CMP EDX,ECX
JL 0x00101166
LEA ECX,[RAX + -0x9]
CMP ECX,0x6
LEA ECX,[RAX + 0x2]
ADC EDI,0x0
CMP ECX,EDX
JG 0x00101166
LEA ECX,[RAX + -0x8]
CMP ECX,0x5
JA 0x001012c5
LAB_001012c2:
ADD EDI,0x1
LAB_001012c5:
LEA ECX,[RAX + 0x3]
CMP EDX,ECX
JL 0x00101166
LEA EDX,[RAX + -0x7]
LEA ECX,[RAX + 0x4]
CMP EDX,0x6
ADC EDI,0x0
JMP 0x00101166
LAB_001012e1:
MOV EAX,ECX
XOR EDI,EDI
JMP 0x0010126c
LAB_001012e7:
LEA ECX,[RAX + 0x2]
ADD EDI,0x2
CMP ECX,EDX
JG 0x00101166
JMP 0x001012c2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1,int param_2)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
iVar5 = 0;
if (param_2 < param_1) {
return 0;
}
if (0xf < param_1) goto LAB_0010116b;
iVar4 = 0xf;
if (param_2 < 0x10) {
iVar4 = param_2;
}
uVar1 = (iVar4 - param_1) + 1;
if ((iVar4 < param_1) || ((uint)(iVar4 - param_1) < 4)) {
iVar6 = 0;
iVar7 = param_1;
}
else {
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
uVar3 = 0;
iVar5 = param_1 + _DAT_00102010;
iVar6 = param_1 + _UNK_00102014;
iVar7 = param_1 + _UNK_00102018;
iVar2 = param_1 + _UNK_0010201c;
do {
iVar8 = iVar2;
uVar3 = uVar3 + 1;
iVar9 = iVar9 + (uint)((iVar5 + _DAT_00102030) - _DAT_00102040 < _DAT_00102060);
iVar10 = iVar10 + (uint)((iVar6 + _UNK_00102034) - _UNK_00102044 < _UNK_00102064);
iVar11 = iVar11 + (uint)((iVar7 + _UNK_00102038) - _UNK_00102048 < _UNK_00102068);
iVar12 = iVar12 + (uint)((iVar8 + _UNK_0010203c) - _UNK_0010204c < _UNK_0010206c);
iVar5 = iVar5 + _DAT_00102020;
iVar6 = iVar6 + _UNK_00102024;
iVar7 = iVar7 + _UNK_00102028;
iVar2 = iVar8 + _UNK_0010202c;
} while (uVar1 >> 2 != uVar3);
iVar5 = iVar9 + iVar11 + iVar10 + iVar12;
iVar6 = iVar5;
iVar7 = (uVar1 & 0xfffffffc) + param_1;
if ((uVar1 & 3) == 0) {
param_1 = iVar8 + _UNK_0010205c;
goto LAB_00101166;
}
}
if (iVar7 - 10U < 6) {
param_1 = iVar7 + 1;
iVar5 = iVar6 + 1;
if (iVar4 < param_1) goto LAB_00101166;
param_1 = iVar7 + 2;
iVar5 = iVar6 + 2;
if (iVar4 < param_1) goto LAB_00101166;
LAB_001012c2:
iVar5 = iVar5 + 1;
}
else {
param_1 = iVar7 + 1;
iVar5 = iVar6;
if (iVar4 < param_1) goto LAB_00101166;
param_1 = iVar7 + 2;
iVar5 = iVar6 + (uint)(iVar7 - 9U < 6);
if (iVar4 < param_1) goto LAB_00101166;
if (iVar7 - 8U < 6) goto LAB_001012c2;
}
param_1 = iVar7 + 3;
if (param_1 <= iVar4) {
param_1 = iVar7 + 4;
iVar5 = iVar5 + (uint)(iVar7 - 7U < 6);
}
LAB_00101166:
for (; param_1 <= param_2; param_1 = param_1 + 1) {
LAB_0010116b:
iVar4 = param_1;
if (param_1 - 10U < 6) {
iVar5 = iVar5 + 1;
}
else {
do {
iVar5 = iVar5 + (uint)(9 < iVar4 % 0x10);
iVar6 = iVar4;
if (iVar4 < 0) {
iVar6 = iVar4 + 0xf;
}
iVar4 = iVar6 >> 4;
} while (iVar6 >> 4 != 0);
}
}
return iVar5;
} |
4,324 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
*result_size = size1 + size2 + size3;
int *result = malloc(*result_size * sizeof(int));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
// Merge the sorted arrays
int i = 0, j = 0, k = 0, l = 0;
while (i < size1 && j < size2 && k < size3) {
if (num1[i] <= num2[j] && num1[i] <= num3[k]) {
result[l++] = num1[i++];
} else if (num2[j] <= num1[i] && num2[j] <= num3[k]) {
result[l++] = num2[j++];
} else {
result[l++] = num3[k++];
}
}
// Merge remaining elements from num1 and num2
while (i < size1 && j < size2) {
result[l++] = (num1[i] <= num2[j]) ? num1[i++] : num2[j++];
}
// Merge remaining elements from num1 and num3
while (i < size1 && k < size3) {
result[l++] = (num1[i] <= num3[k]) ? num1[i++] : num3[k++];
}
// Merge remaining elements from num2 and num3
while (j < size2 && k < size3) {
result[l++] = (num2[j] <= num3[k]) ? num2[j++] : num3[k++];
}
// Copy any remaining elements
while (i < size1) {
result[l++] = num1[i++];
}
while (j < size2) {
result[l++] = num2[j++];
}
while (k < size3) {
result[l++] = num3[k++];
}
return result;
}
| int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) / sizeof(num3_1[0]);
int expected1[] = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
int expected_size1 = sizeof(expected1) / sizeof(expected1[0]);
int result_size1;
int *result1 = func0(num1_1, size1_1, num2_1, size2_1, num3_1, size3_1, &result_size1);
assert(result_size1 == expected_size1);
for(int i = 0; i < expected_size1; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int num1_2[] = {1, 3, 5, 6, 8, 9};
int size1_2 = sizeof(num1_2) / sizeof(num1_2[0]);
int num2_2[] = {2, 5, 7, 11};
int size2_2 = sizeof(num2_2) / sizeof(num2_2[0]);
int num3_2[] = {1, 4, 7, 8, 12};
int size3_2 = sizeof(num3_2) / sizeof(num3_2[0]);
int expected2[] = {1, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9, 11, 12};
int expected_size2 = sizeof(expected2) / sizeof(expected2[0]);
int result_size2;
int *result2 = func0(num1_2, size1_2, num2_2, size2_2, num3_2, size3_2, &result_size2);
assert(result_size2 == expected_size2);
for(int i = 0; i < expected_size2; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int num1_3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size1_3 = sizeof(num1_3) / sizeof(num1_3[0]);
int num2_3[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2_3 = sizeof(num2_3) / sizeof(num2_3[0]);
int num3_3[] = {12, 74, 9, 50, 61, 41};
int size3_3 = sizeof(num3_3) / sizeof(num3_3[0]);
int expected3[] = {1, 2, 3, 4, 7, 8, 9, 9, 9, 10, 12, 14, 14, 18, 22, 25, 25, 35, 41, 50, 58, 61, 65, 74, 75, 85};
int expected_size3 = sizeof(expected3) / sizeof(expected3[0]);
int result_size3;
int *result3 = func0(num1_3, size1_3, num2_3, size2_3, num3_3, size3_3, &result_size3);
assert(result_size3 == expected_size3);
for(int i = 0; i < expected_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %ecx,-0x30(%rbp)
mov %r8,-0x40(%rbp)
mov %r9d,-0x44(%rbp)
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
mov -0x28(%rbp),%rax
lea -0x73(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10c0 <qsort@plt>
mov -0x30(%rbp),%eax
movslq %eax,%rsi
mov -0x38(%rbp),%rax
lea -0x91(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10c0 <qsort@plt>
mov -0x44(%rbp),%eax
movslq %eax,%rsi
mov -0x40(%rbp),%rax
lea -0xaf(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10c0 <qsort@plt>
mov -0x2c(%rbp),%edx
mov -0x30(%rbp),%eax
add %eax,%edx
mov -0x44(%rbp),%eax
add %eax,%edx
mov 0x10(%rbp),%rax
mov %edx,(%rax)
mov 0x10(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 130d <func0+0xc4>
lea 0xd0a(%rip),%rdi
callq 1100 <perror@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 14a0 <func0+0x257>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 13cc <func0+0x183>
mov -0x18(%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 -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 13cc <func0+0x183>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
jmpq 14a0 <func0+0x257>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 1467 <func0+0x21e>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 1467 <func0+0x21e>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
jmp 14a0 <func0+0x257>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 1550 <func0+0x307>
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jge 1550 <func0+0x307>
mov -0x10(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 132e <func0+0xe5>
jmpq 1550 <func0+0x307>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 1517 <func0+0x2ce>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 1533 <func0+0x2ea>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0xc(%rbp),%edx
lea 0x1(%rdx),%ecx
mov %ecx,-0xc(%rbp)
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 15f4 <func0+0x3ab>
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 14c9 <func0+0x280>
jmpq 15f4 <func0+0x3ab>
mov -0x18(%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 -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 15bb <func0+0x372>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 15d7 <func0+0x38e>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0xc(%rbp),%edx
lea 0x1(%rdx),%ecx
mov %ecx,-0xc(%rbp)
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 1698 <func0+0x44f>
mov -0x10(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 156d <func0+0x324>
jmpq 1698 <func0+0x44f>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 165f <func0+0x416>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 167b <func0+0x432>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0xc(%rbp),%edx
lea 0x1(%rdx),%ecx
mov %ecx,-0xc(%rbp)
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jge 16e7 <func0+0x49e>
mov -0x10(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1611 <func0+0x3c8>
jmp 16e7 <func0+0x49e>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 16ae <func0+0x465>
jmp 172a <func0+0x4e1>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 16f1 <func0+0x4a8>
jmp 176d <func0+0x524>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1734 <func0+0x4eb>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+base], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_30], ecx
mov [rbp+var_40], r8
mov [rbp+var_44], r9d
mov eax, [rbp+var_2C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_30]
movsxd rsi, eax; nmemb
mov rax, [rbp+var_38]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_44]
movsxd rsi, eax; nmemb
mov rax, [rbp+var_40]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov edx, [rbp+var_2C]
mov eax, [rbp+var_30]
add edx, eax
mov eax, [rbp+var_44]
add edx, eax
mov rax, [rbp+arg_0]
mov [rax], edx
mov rax, [rbp+arg_0]
mov eax, [rax]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_1319
lea rax, s; "Failed to allocate memory"
mov rdi, rax; s
call _perror
mov edi, 1; status
call _exit
loc_1319:
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_14AC
loc_133A:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_13D8
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_13D8
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
jmp loc_14AC
loc_13D8:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_1473
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_1473
mov eax, [rbp+var_14]
lea edx, [rax+1]
mov [rbp+var_14], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
jmp short loc_14AC
loc_1473:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_14AC:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jge loc_155C
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jge loc_155C
mov eax, [rbp+var_10]
cmp eax, [rbp+var_44]
jl loc_133A
jmp loc_155C
loc_14D5:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_1523
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov eax, [rax]
jmp short loc_153F
loc_1523:
mov eax, [rbp+var_14]
lea edx, [rax+1]
mov [rbp+var_14], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
loc_153F:
mov edx, [rbp+var_C]
lea ecx, [rdx+1]
mov [rbp+var_C], ecx
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov [rdx], eax
loc_155C:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jge loc_1600
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jl loc_14D5
jmp loc_1600
loc_1579:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_15C7
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov eax, [rax]
jmp short loc_15E3
loc_15C7:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
loc_15E3:
mov edx, [rbp+var_C]
lea ecx, [rdx+1]
mov [rbp+var_C], ecx
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov [rdx], eax
loc_1600:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jge loc_16A4
mov eax, [rbp+var_10]
cmp eax, [rbp+var_44]
jl loc_1579
jmp loc_16A4
loc_161D:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_166B
mov eax, [rbp+var_14]
lea edx, [rax+1]
mov [rbp+var_14], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
jmp short loc_1687
loc_166B:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
loc_1687:
mov edx, [rbp+var_C]
lea ecx, [rdx+1]
mov [rbp+var_C], ecx
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov [rdx], eax
loc_16A4:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jge short loc_16F3
mov eax, [rbp+var_10]
cmp eax, [rbp+var_44]
jl loc_161D
jmp short loc_16F3
loc_16BA:
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_16F3:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_16BA
jmp short loc_1736
loc_16FD:
mov eax, [rbp+var_14]
lea edx, [rax+1]
mov [rbp+var_14], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1736:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jl short loc_16FD
jmp short loc_1779
loc_1740:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1779:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_44]
jl short loc_1740
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(char *a1, int a2, char *a3, int a4, char *a5, int a6, int *a7)
{
int v7; // eax
char *v8; // rcx
int v9; // eax
int v10; // eax
char *v11; // rcx
int v12; // eax
int v13; // eax
char *v14; // rcx
int v15; // eax
int v16; // eax
int v17; // eax
int v18; // eax
int v19; // edx
int v20; // eax
int v21; // eax
int v22; // eax
int v23; // edx
int v24; // eax
int v25; // eax
int v26; // eax
int v27; // edx
int v28; // eax
char *v29; // rcx
int v30; // eax
int v31; // eax
char *v32; // rcx
int v33; // eax
int v34; // eax
char *v35; // rcx
int v36; // eax
int v42; // [rsp+38h] [rbp-18h]
int v43; // [rsp+3Ch] [rbp-14h]
int v44; // [rsp+40h] [rbp-10h]
int v45; // [rsp+44h] [rbp-Ch]
_DWORD *v46; // [rsp+48h] [rbp-8h]
qsort(a1, a2, 4uLL, compare);
qsort(a3, a4, 4uLL, compare);
qsort(a5, a6, 4uLL, compare);
*a7 = a6 + a4 + a2;
v46 = malloc(4LL * *a7);
if ( !v46 )
{
perror("Failed to allocate memory");
exit(1);
}
v42 = 0;
v43 = 0;
v44 = 0;
v45 = 0;
while ( v42 < a2 && v43 < a4 && v44 < a6 )
{
if ( *(_DWORD *)&a1[4 * v42] > *(_DWORD *)&a3[4 * v43] || *(_DWORD *)&a1[4 * v42] > *(_DWORD *)&a5[4 * v44] )
{
if ( *(_DWORD *)&a3[4 * v43] > *(_DWORD *)&a1[4 * v42] || *(_DWORD *)&a3[4 * v43] > *(_DWORD *)&a5[4 * v44] )
{
v13 = v44++;
v14 = &a5[4 * v13];
v15 = v45++;
v46[v15] = *(_DWORD *)v14;
}
else
{
v10 = v43++;
v11 = &a3[4 * v10];
v12 = v45++;
v46[v12] = *(_DWORD *)v11;
}
}
else
{
v7 = v42++;
v8 = &a1[4 * v7];
v9 = v45++;
v46[v9] = *(_DWORD *)v8;
}
}
while ( v42 < a2 && v43 < a4 )
{
if ( *(_DWORD *)&a1[4 * v42] > *(_DWORD *)&a3[4 * v43] )
{
v18 = v43++;
v17 = *(_DWORD *)&a3[4 * v18];
}
else
{
v16 = v42++;
v17 = *(_DWORD *)&a1[4 * v16];
}
v19 = v45++;
v46[v19] = v17;
}
while ( v42 < a2 && v44 < a6 )
{
if ( *(_DWORD *)&a1[4 * v42] > *(_DWORD *)&a5[4 * v44] )
{
v22 = v44++;
v21 = *(_DWORD *)&a5[4 * v22];
}
else
{
v20 = v42++;
v21 = *(_DWORD *)&a1[4 * v20];
}
v23 = v45++;
v46[v23] = v21;
}
while ( v43 < a4 && v44 < a6 )
{
if ( *(_DWORD *)&a3[4 * v43] > *(_DWORD *)&a5[4 * v44] )
{
v26 = v44++;
v25 = *(_DWORD *)&a5[4 * v26];
}
else
{
v24 = v43++;
v25 = *(_DWORD *)&a3[4 * v24];
}
v27 = v45++;
v46[v27] = v25;
}
while ( v42 < a2 )
{
v28 = v42++;
v29 = &a1[4 * v28];
v30 = v45++;
v46[v30] = *(_DWORD *)v29;
}
while ( v43 < a4 )
{
v31 = v43++;
v32 = &a3[4 * v31];
v33 = v45++;
v46[v33] = *(_DWORD *)v32;
}
while ( v44 < a6 )
{
v34 = v44++;
v35 = &a5[4 * v34];
v36 = v45++;
v46[v36] = *(_DWORD *)v35;
}
return v46;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x30],ECX
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],R9D
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[0x101209]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[0x101209]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x40]
LEA RDX,[0x101209]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV EDX,dword ptr [RBP + -0x2c]
MOV EAX,dword ptr [RBP + -0x30]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + 0x10]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x00101319
LEA RAX,[0x102008]
MOV RDI,RAX
CALL 0x00101100
MOV EDI,0x1
CALL 0x00101110
LAB_00101319:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001014ac
LAB_0010133a:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x001013d8
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x001013d8
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 + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
JMP 0x001014ac
LAB_001013d8:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x00101473
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x00101473
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x14],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
JMP 0x001014ac
LAB_00101473:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_001014ac:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x0010155c
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JGE 0x0010155c
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x0010133a
JMP 0x0010155c
LAB_001014d5:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x00101523
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 + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x0010153f
LAB_00101523:
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x14],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
LAB_0010153f:
MOV EDX,dword ptr [RBP + -0xc]
LEA ECX,[RDX + 0x1]
MOV dword ptr [RBP + -0xc],ECX
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV dword ptr [RDX],EAX
LAB_0010155c:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x00101600
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001014d5
JMP 0x00101600
LAB_00101579:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x001015c7
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 + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x001015e3
LAB_001015c7:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
LAB_001015e3:
MOV EDX,dword ptr [RBP + -0xc]
LEA ECX,[RDX + 0x1]
MOV dword ptr [RBP + -0xc],ECX
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV dword ptr [RDX],EAX
LAB_00101600:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x001016a4
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x00101579
JMP 0x001016a4
LAB_0010161d:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x0010166b
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x14],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x00101687
LAB_0010166b:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
LAB_00101687:
MOV EDX,dword ptr [RBP + -0xc]
LEA ECX,[RDX + 0x1]
MOV dword ptr [RBP + -0xc],ECX
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV dword ptr [RDX],EAX
LAB_001016a4:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JGE 0x001016f3
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x0010161d
JMP 0x001016f3
LAB_001016ba:
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 + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_001016f3:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001016ba
JMP 0x00101736
LAB_001016fd:
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x14],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101736:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001016fd
JMP 0x00101779
LAB_00101740:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101779:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x00101740
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int4 uVar1;
void *pvVar2;
int local_20;
int local_1c;
int local_18;
int local_14;
qsort(param_1,(long)param_2,4,compare);
qsort(param_3,(long)param_4,4,compare);
qsort(param_5,(long)param_6,4,compare);
*param_7 = param_2 + param_4 + param_6;
pvVar2 = malloc((long)*param_7 << 2);
if (pvVar2 != (void *)0x0) {
local_20 = 0;
local_1c = 0;
local_18 = 0;
local_14 = 0;
while (((local_20 < param_2 && (local_1c < param_4)) && (local_18 < param_6))) {
if ((*(int *)((long)param_3 + (long)local_1c * 4) <
*(int *)((long)param_1 + (long)local_20 * 4)) ||
(*(int *)((long)param_5 + (long)local_18 * 4) <
*(int *)((long)param_1 + (long)local_20 * 4))) {
if ((*(int *)((long)param_1 + (long)local_20 * 4) <
*(int *)((long)param_3 + (long)local_1c * 4)) ||
(*(int *)((long)param_5 + (long)local_18 * 4) <
*(int *)((long)param_3 + (long)local_1c * 4))) {
*(int4 *)((long)local_14 * 4 + (long)pvVar2) =
*(int4 *)((long)local_18 * 4 + (long)param_5);
local_18 = local_18 + 1;
local_14 = local_14 + 1;
}
else {
*(int4 *)((long)local_14 * 4 + (long)pvVar2) =
*(int4 *)((long)local_1c * 4 + (long)param_3);
local_1c = local_1c + 1;
local_14 = local_14 + 1;
}
}
else {
*(int4 *)((long)local_14 * 4 + (long)pvVar2) =
*(int4 *)((long)local_20 * 4 + (long)param_1);
local_20 = local_20 + 1;
local_14 = local_14 + 1;
}
}
while ((local_20 < param_2 && (local_1c < param_4))) {
if (*(int *)((long)param_3 + (long)local_1c * 4) <
*(int *)((long)param_1 + (long)local_20 * 4)) {
uVar1 = *(int4 *)((long)param_3 + (long)local_1c * 4);
local_1c = local_1c + 1;
}
else {
uVar1 = *(int4 *)((long)param_1 + (long)local_20 * 4);
local_20 = local_20 + 1;
}
*(int4 *)((long)pvVar2 + (long)local_14 * 4) = uVar1;
local_14 = local_14 + 1;
}
while ((local_20 < param_2 && (local_18 < param_6))) {
if (*(int *)((long)param_5 + (long)local_18 * 4) <
*(int *)((long)param_1 + (long)local_20 * 4)) {
uVar1 = *(int4 *)((long)param_5 + (long)local_18 * 4);
local_18 = local_18 + 1;
}
else {
uVar1 = *(int4 *)((long)param_1 + (long)local_20 * 4);
local_20 = local_20 + 1;
}
*(int4 *)((long)pvVar2 + (long)local_14 * 4) = uVar1;
local_14 = local_14 + 1;
}
while ((local_1c < param_4 && (local_18 < param_6))) {
if (*(int *)((long)param_5 + (long)local_18 * 4) <
*(int *)((long)param_3 + (long)local_1c * 4)) {
uVar1 = *(int4 *)((long)param_5 + (long)local_18 * 4);
local_18 = local_18 + 1;
}
else {
uVar1 = *(int4 *)((long)param_3 + (long)local_1c * 4);
local_1c = local_1c + 1;
}
*(int4 *)((long)pvVar2 + (long)local_14 * 4) = uVar1;
local_14 = local_14 + 1;
}
while (local_20 < param_2) {
*(int4 *)((long)local_14 * 4 + (long)pvVar2) =
*(int4 *)((long)local_20 * 4 + (long)param_1);
local_20 = local_20 + 1;
local_14 = local_14 + 1;
}
while (local_1c < param_4) {
*(int4 *)((long)local_14 * 4 + (long)pvVar2) =
*(int4 *)((long)local_1c * 4 + (long)param_3);
local_1c = local_1c + 1;
local_14 = local_14 + 1;
}
while (local_18 < param_6) {
*(int4 *)((long)local_14 * 4 + (long)pvVar2) =
*(int4 *)((long)local_18 * 4 + (long)param_5);
local_18 = local_18 + 1;
local_14 = local_14 + 1;
}
return pvVar2;
}
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
} |
4,325 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
*result_size = size1 + size2 + size3;
int *result = malloc(*result_size * sizeof(int));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
// Merge the sorted arrays
int i = 0, j = 0, k = 0, l = 0;
while (i < size1 && j < size2 && k < size3) {
if (num1[i] <= num2[j] && num1[i] <= num3[k]) {
result[l++] = num1[i++];
} else if (num2[j] <= num1[i] && num2[j] <= num3[k]) {
result[l++] = num2[j++];
} else {
result[l++] = num3[k++];
}
}
// Merge remaining elements from num1 and num2
while (i < size1 && j < size2) {
result[l++] = (num1[i] <= num2[j]) ? num1[i++] : num2[j++];
}
// Merge remaining elements from num1 and num3
while (i < size1 && k < size3) {
result[l++] = (num1[i] <= num3[k]) ? num1[i++] : num3[k++];
}
// Merge remaining elements from num2 and num3
while (j < size2 && k < size3) {
result[l++] = (num2[j] <= num3[k]) ? num2[j++] : num3[k++];
}
// Copy any remaining elements
while (i < size1) {
result[l++] = num1[i++];
}
while (j < size2) {
result[l++] = num2[j++];
}
while (k < size3) {
result[l++] = num3[k++];
}
return result;
}
| int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) / sizeof(num3_1[0]);
int expected1[] = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
int expected_size1 = sizeof(expected1) / sizeof(expected1[0]);
int result_size1;
int *result1 = func0(num1_1, size1_1, num2_1, size2_1, num3_1, size3_1, &result_size1);
assert(result_size1 == expected_size1);
for(int i = 0; i < expected_size1; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int num1_2[] = {1, 3, 5, 6, 8, 9};
int size1_2 = sizeof(num1_2) / sizeof(num1_2[0]);
int num2_2[] = {2, 5, 7, 11};
int size2_2 = sizeof(num2_2) / sizeof(num2_2[0]);
int num3_2[] = {1, 4, 7, 8, 12};
int size3_2 = sizeof(num3_2) / sizeof(num3_2[0]);
int expected2[] = {1, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9, 11, 12};
int expected_size2 = sizeof(expected2) / sizeof(expected2[0]);
int result_size2;
int *result2 = func0(num1_2, size1_2, num2_2, size2_2, num3_2, size3_2, &result_size2);
assert(result_size2 == expected_size2);
for(int i = 0; i < expected_size2; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int num1_3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size1_3 = sizeof(num1_3) / sizeof(num1_3[0]);
int num2_3[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2_3 = sizeof(num2_3) / sizeof(num2_3[0]);
int num3_3[] = {12, 74, 9, 50, 61, 41};
int size3_3 = sizeof(num3_3) / sizeof(num3_3[0]);
int expected3[] = {1, 2, 3, 4, 7, 8, 9, 9, 9, 10, 12, 14, 14, 18, 22, 25, 25, 35, 41, 50, 58, 61, 65, 74, 75, 85};
int expected_size3 = sizeof(expected3) / sizeof(expected3[0]);
int result_size3;
int *result3 = func0(num1_3, size1_3, num2_3, size2_3, num3_3, size3_3, &result_size3);
assert(result_size3 == expected_size3);
for(int i = 0; i < expected_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r15
mov %esi,%ebx
mov %rdx,%r14
mov %ecx,%ebp
mov %r8,%r12
mov %r9d,%r13d
movslq %esi,%rsi
lea -0x45(%rip),%rcx
mov $0x4,%edx
callq 10c0 <qsort@plt>
movslq %ebp,%rsi
lea -0x59(%rip),%rcx
mov $0x4,%edx
mov %r14,%rdi
callq 10c0 <qsort@plt>
movslq %r13d,%rsi
lea -0x70(%rip),%rcx
mov $0x4,%edx
mov %r12,%rdi
callq 10c0 <qsort@plt>
lea (%rbx,%rbp,1),%edi
add %r13d,%edi
mov 0x40(%rsp),%rax
mov %edi,(%rax)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
test %rax,%rax
je 1301 <func0+0xdf>
test %ebp,%ebp
setg %cl
test %r13d,%r13d
setg %dl
test %dl,%cl
je 12d0 <func0+0xae>
test %ebx,%ebx
jle 12d0 <func0+0xae>
mov $0x0,%esi
mov $0x0,%edx
mov $0x0,%edi
mov $0x0,%ecx
jmpq 1359 <func0+0x137>
mov $0x0,%r8d
mov $0x0,%edx
mov $0x0,%edi
mov $0x0,%ecx
cmp %ecx,%ebx
jle 13b4 <func0+0x192>
cmp %edi,%ebp
jle 13b4 <func0+0x192>
add $0x1,%r8d
movslq %r8d,%rsi
jmpq 139c <func0+0x17a>
lea 0xcfc(%rip),%rdi
callq 1100 <perror@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
movslq %edx,%r8
cmp (%r12,%r8,4),%r10d
jg 132d <func0+0x10b>
add $0x1,%edi
lea 0x1(%rsi),%r8d
mov %r10d,(%rax,%rsi,4)
jmp 133f <func0+0x11d>
lea 0x1(%rsi),%r8d
movslq %edx,%r9
mov (%r12,%r9,4),%r9d
mov %r9d,(%rax,%rsi,4)
lea 0x1(%rdx),%edx
add $0x1,%rsi
cmp %ecx,%ebx
setg %r10b
cmp %ebp,%edi
setl %r9b
test %r9b,%r10b
je 12e5 <func0+0xc3>
cmp %r13d,%edx
jge 12e5 <func0+0xc3>
movslq %ecx,%r8
mov (%r15,%r8,4),%r9d
movslq %edi,%r8
mov (%r14,%r8,4),%r10d
cmp %r10d,%r9d
jg 1317 <func0+0xf5>
movslq %edx,%r8
cmp (%r12,%r8,4),%r9d
jg 132d <func0+0x10b>
add $0x1,%ecx
lea 0x1(%rsi),%r8d
mov %r9d,(%rax,%rsi,4)
jmp 133f <func0+0x11d>
add $0x1,%edi
mov %r8d,%r9d
mov %esi,%r8d
mov %r9d,-0x4(%rax,%rsi,4)
add $0x1,%rsi
cmp %ebx,%ecx
jge 13b4 <func0+0x192>
cmp %ebp,%edi
jge 13b4 <func0+0x192>
movslq %ecx,%r8
mov (%r15,%r8,4),%r9d
movslq %edi,%r8
mov (%r14,%r8,4),%r8d
cmp %r8d,%r9d
jg 1382 <func0+0x160>
add $0x1,%ecx
jmp 1388 <func0+0x166>
cmp %ecx,%ebx
jle 13f9 <func0+0x1d7>
cmp %edx,%r13d
jle 13f9 <func0+0x1d7>
add $0x1,%r8d
movslq %r8d,%rsi
jmp 13e1 <func0+0x1bf>
add $0x1,%edx
mov %r8d,%r9d
mov %esi,%r8d
mov %r9d,-0x4(%rax,%rsi,4)
add $0x1,%rsi
cmp %ebx,%ecx
jge 13f9 <func0+0x1d7>
cmp %r13d,%edx
jge 13f9 <func0+0x1d7>
movslq %ecx,%r8
mov (%r15,%r8,4),%r9d
movslq %edx,%r8
mov (%r12,%r8,4),%r8d
cmp %r8d,%r9d
jg 13c6 <func0+0x1a4>
add $0x1,%ecx
jmp 13cc <func0+0x1aa>
cmp %edi,%ebp
jle 143e <func0+0x21c>
cmp %edx,%r13d
jle 143e <func0+0x21c>
add $0x1,%r8d
movslq %r8d,%rsi
jmp 1426 <func0+0x204>
add $0x1,%edx
mov %r8d,%r9d
mov %esi,%r8d
mov %r9d,-0x4(%rax,%rsi,4)
add $0x1,%rsi
cmp %ebp,%edi
jge 143e <func0+0x21c>
cmp %r13d,%edx
jge 143e <func0+0x21c>
movslq %edi,%r8
mov (%r14,%r8,4),%r9d
movslq %edx,%r8
mov (%r12,%r8,4),%r8d
cmp %r8d,%r9d
jg 140b <func0+0x1e9>
add $0x1,%edi
jmp 1411 <func0+0x1ef>
cmp %ecx,%ebx
jle 1464 <func0+0x242>
movslq %ecx,%rsi
movslq %r8d,%r9
sub %rsi,%r9
lea (%rax,%r9,4),%r10
mov (%r15,%rsi,4),%r9d
mov %r9d,(%r10,%rsi,4)
add $0x1,%rsi
cmp %esi,%ebx
jg 144f <func0+0x22d>
sub %ecx,%ebx
add %ebx,%r8d
cmp %edi,%ebp
jle 148a <func0+0x268>
movslq %edi,%rcx
movslq %r8d,%rsi
sub %rcx,%rsi
lea (%rax,%rsi,4),%r9
mov (%r14,%rcx,4),%esi
mov %esi,(%r9,%rcx,4)
add $0x1,%rcx
cmp %ecx,%ebp
jg 1475 <func0+0x253>
sub %edi,%ebp
add %ebp,%r8d
cmp %edx,%r13d
jle 14ac <func0+0x28a>
movslq %edx,%rdx
movslq %r8d,%r8
sub %rdx,%r8
lea (%rax,%r8,4),%rsi
mov (%r12,%rdx,4),%ecx
mov %ecx,(%rsi,%rdx,4)
add $0x1,%rdx
cmp %edx,%r13d
jg 149c <func0+0x27a>
add $0x8,%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, 8
mov r15, rdi
mov ebx, esi
mov r14, rdx
mov ebp, ecx
mov r12, r8
mov r13d, r9d
movsxd rsi, esi
lea rcx, compare
mov edx, 4
call _qsort
movsxd rsi, ebp
lea rcx, compare
mov edx, 4
mov rdi, r14
call _qsort
movsxd rsi, r13d
lea rcx, compare
mov edx, 4
mov rdi, r12
call _qsort
lea edi, [rbx+rbp]
add edi, r13d
mov rax, [rsp+38h+arg_0]
mov [rax], edi
movsxd rdi, edi
shl rdi, 2
call _malloc
test rax, rax
jz short loc_1305
mov rdi, rax
test ebp, ebp
setnle dl
test r13d, r13d
setnle al
test dl, al
jz short loc_12D5
test ebx, ebx
jle short loc_12D5
mov r9, rdi
mov r8d, 1
mov eax, 0
mov ecx, 0
mov edx, 0
jmp loc_135D
loc_12D5:
mov esi, 0
mov eax, 0
mov ecx, 0
mov edx, 0
loc_12E9:
cmp ebx, edx
jle loc_13B6
cmp ebp, ecx
jle loc_13B6
lea r8d, [rsi+1]
movsxd r8, r8d
jmp loc_139E
loc_1305:
lea rdi, aFailedToAlloca; "Failed to allocate memory"
call _perror
mov edi, 1
call _exit
loc_131B:
movsxd rsi, eax
cmp r11d, [r12+rsi*4]
jg short loc_132F
add ecx, 1
mov esi, r8d
mov [r9], r11d
jmp short loc_133F
loc_132F:
mov esi, r8d
movsxd r10, eax
mov r10d, [r12+r10*4]
mov [r9], r10d
lea eax, [rax+1]
loc_133F:
add r8d, 1
add r9, 4
cmp ebx, edx
setnle r11b
cmp ecx, ebp
setl r10b
test r11b, r10b
jz short loc_12E9
cmp eax, r13d
jge short loc_12E9
loc_135D:
movsxd rsi, edx
mov r10d, [r15+rsi*4]
movsxd rsi, ecx
mov r11d, [r14+rsi*4]
cmp r10d, r11d
jg short loc_131B
movsxd rsi, eax
cmp r10d, [r12+rsi*4]
jg short loc_132F
add edx, 1
mov esi, r8d
mov [r9], r10d
jmp short loc_133F
loc_1384:
add ecx, 1
mov r9d, esi
loc_138A:
mov esi, r8d
mov [rdi+r8*4-4], r9d
add r8, 1
cmp edx, ebx
jge short loc_13B6
cmp ecx, ebp
jge short loc_13B6
loc_139E:
movsxd rsi, edx
mov r9d, [r15+rsi*4]
movsxd rsi, ecx
mov esi, [r14+rsi*4]
cmp r9d, esi
jg short loc_1384
add edx, 1
jmp short loc_138A
loc_13B6:
cmp ebx, edx
jle short loc_13FB
cmp r13d, eax
jle short loc_13FB
lea r8d, [rsi+1]
movsxd r8, r8d
jmp short loc_13E3
loc_13C8:
add eax, 1
mov r9d, esi
loc_13CE:
mov esi, r8d
mov [rdi+r8*4-4], r9d
add r8, 1
cmp edx, ebx
jge short loc_13FB
cmp eax, r13d
jge short loc_13FB
loc_13E3:
movsxd rsi, edx
mov r9d, [r15+rsi*4]
movsxd rsi, eax
mov esi, [r12+rsi*4]
cmp r9d, esi
jg short loc_13C8
add edx, 1
jmp short loc_13CE
loc_13FB:
cmp ebp, ecx
jle short loc_1440
cmp r13d, eax
jle short loc_1440
lea r8d, [rsi+1]
movsxd r8, r8d
jmp short loc_1428
loc_140D:
add eax, 1
mov r9d, esi
loc_1413:
mov esi, r8d
mov [rdi+r8*4-4], r9d
add r8, 1
cmp ecx, ebp
jge short loc_1440
cmp eax, r13d
jge short loc_1440
loc_1428:
movsxd rsi, ecx
mov r9d, [r14+rsi*4]
movsxd rsi, eax
mov esi, [r12+rsi*4]
cmp r9d, esi
jg short loc_140D
add ecx, 1
jmp short loc_1413
loc_1440:
cmp ebx, edx
jle short loc_1466
movsxd r8, edx
movsxd r9, esi
sub r9, r8
lea r10, [rdi+r9*4]
loc_1451:
mov r9d, [r15+r8*4]
mov [r10+r8*4], r9d
add r8, 1
cmp ebx, r8d
jg short loc_1451
sub ebx, edx
add esi, ebx
loc_1466:
cmp ebp, ecx
jle short loc_148B
movsxd rdx, ecx
movsxd r8, esi
sub r8, rdx
lea r9, [rdi+r8*4]
loc_1477:
mov r8d, [r14+rdx*4]
mov [r9+rdx*4], r8d
add rdx, 1
cmp ebp, edx
jg short loc_1477
sub ebp, ecx
add esi, ebp
loc_148B:
cmp r13d, eax
jle short loc_14AC
cdqe
movsxd rsi, esi
sub rsi, rax
lea rcx, [rdi+rsi*4]
loc_149C:
mov edx, [r12+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp r13d, eax
jg short loc_149C
loc_14AC:
mov rax, rdi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2, long long a3, int a4, long long a5, int a6, int *a7)
{
int v13; // edi
long long v14; // rax
long long v15; // rdi
_DWORD *v16; // r9
int v17; // r8d
int v18; // ecx
int v19; // edx
int v20; // esi
long long v21; // r8
int v22; // r10d
int v23; // r11d
int v24; // r9d
int v25; // esi
long long v26; // r8
int v27; // r9d
int v28; // esi
long long v29; // r8
int v30; // r9d
int v31; // esi
long long v32; // r8
long long v33; // rdx
long long v34; // rsi
qsort(a1, a2, 4LL, compare);
qsort(a3, a4, 4LL, compare);
qsort(a5, a6, 4LL, compare);
v13 = a6 + a2 + a4;
*a7 = v13;
v14 = malloc(4LL * v13);
if ( !v14 )
{
perror("Failed to allocate memory");
exit(1LL);
}
v15 = v14;
if ( a6 > 0 && a4 > 0 && a2 > 0 )
{
v16 = (_DWORD *)v14;
v17 = 1;
LODWORD(v14) = 0;
v18 = 0;
v19 = 0;
while ( 1 )
{
v22 = *(_DWORD *)(a1 + 4LL * v19);
v23 = *(_DWORD *)(a3 + 4LL * v18);
if ( v22 > v23 )
break;
if ( v22 > *(_DWORD *)(a5 + 4LL * (int)v14) )
goto LABEL_12;
++v19;
v20 = v17;
*v16 = v22;
LABEL_13:
++v17;
++v16;
if ( v18 >= a4 || a2 <= v19 || (int)v14 >= a6 )
goto LABEL_6;
}
if ( v23 <= *(_DWORD *)(a5 + 4LL * (int)v14) )
{
++v18;
v20 = v17;
*v16 = v23;
goto LABEL_13;
}
LABEL_12:
v20 = v17;
*v16 = *(_DWORD *)(a5 + 4LL * (int)v14);
LODWORD(v14) = v14 + 1;
goto LABEL_13;
}
v20 = 0;
LODWORD(v14) = 0;
v18 = 0;
v19 = 0;
LABEL_6:
if ( a2 > v19 && a4 > v18 )
{
v21 = v20 + 1;
do
{
v24 = *(_DWORD *)(a1 + 4LL * v19);
v25 = *(_DWORD *)(a3 + 4LL * v18);
if ( v24 > v25 )
{
++v18;
v24 = v25;
}
else
{
++v19;
}
v20 = v21;
*(_DWORD *)(v15 + 4 * v21++ - 4) = v24;
}
while ( v19 < a2 && v18 < a4 );
}
if ( a2 > v19 && a6 > (int)v14 )
{
v26 = v20 + 1;
do
{
v27 = *(_DWORD *)(a1 + 4LL * v19);
v28 = *(_DWORD *)(a5 + 4LL * (int)v14);
if ( v27 > v28 )
{
LODWORD(v14) = v14 + 1;
v27 = v28;
}
else
{
++v19;
}
v20 = v26;
*(_DWORD *)(v15 + 4 * v26++ - 4) = v27;
}
while ( v19 < a2 && (int)v14 < a6 );
}
if ( a4 > v18 && a6 > (int)v14 )
{
v29 = v20 + 1;
do
{
v30 = *(_DWORD *)(a3 + 4LL * v18);
v31 = *(_DWORD *)(a5 + 4LL * (int)v14);
if ( v30 > v31 )
{
LODWORD(v14) = v14 + 1;
v30 = v31;
}
else
{
++v18;
}
v20 = v29;
*(_DWORD *)(v15 + 4 * v29++ - 4) = v30;
}
while ( v18 < a4 && (int)v14 < a6 );
}
if ( a2 > v19 )
{
v32 = v19;
do
{
*(_DWORD *)(v15 + 4 * (v20 - (long long)v19) + 4 * v32) = *(_DWORD *)(a1 + 4 * v32);
++v32;
}
while ( a2 > (int)v32 );
v20 += a2 - v19;
}
if ( a4 > v18 )
{
v33 = v18;
do
{
*(_DWORD *)(v15 + 4 * (v20 - (long long)v18) + 4 * v33) = *(_DWORD *)(a3 + 4 * v33);
++v33;
}
while ( a4 > (int)v33 );
v20 += a4 - v18;
}
if ( a6 > (int)v14 )
{
v14 = (int)v14;
v34 = v20 - (long long)(int)v14;
do
{
*(_DWORD *)(v15 + 4 * v34 + 4 * v14) = *(_DWORD *)(a5 + 4 * v14);
++v14;
}
while ( a6 > (int)v14 );
}
return v15;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R15,RDI
MOV EBX,ESI
MOV R14,RDX
MOV EBP,ECX
MOV R12,R8
MOV R13D,R9D
MOVSXD RSI,ESI
LEA RCX,[0x101209]
MOV EDX,0x4
CALL 0x001010c0
MOVSXD RSI,EBP
LEA RCX,[0x101209]
MOV EDX,0x4
MOV RDI,R14
CALL 0x001010c0
MOVSXD RSI,R13D
LEA RCX,[0x101209]
MOV EDX,0x4
MOV RDI,R12
CALL 0x001010c0
LEA EDI,[RBX + RBP*0x1]
ADD EDI,R13D
MOV RAX,qword ptr [RSP + 0x40]
MOV dword ptr [RAX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010f0
TEST RAX,RAX
JZ 0x00101305
MOV RDI,RAX
TEST EBP,EBP
SETG DL
TEST R13D,R13D
SETG AL
TEST DL,AL
JZ 0x001012d5
TEST EBX,EBX
JLE 0x001012d5
MOV R9,RDI
MOV R8D,0x1
MOV EAX,0x0
MOV ECX,0x0
MOV EDX,0x0
JMP 0x0010135d
LAB_001012d5:
MOV ESI,0x0
MOV EAX,0x0
MOV ECX,0x0
MOV EDX,0x0
LAB_001012e9:
CMP EBX,EDX
JLE 0x001013b6
CMP EBP,ECX
JLE 0x001013b6
LEA R8D,[RSI + 0x1]
MOVSXD R8,R8D
JMP 0x0010139e
LAB_00101305:
LEA RDI,[0x102004]
CALL 0x00101100
MOV EDI,0x1
CALL 0x00101110
LAB_0010131b:
MOVSXD RSI,EAX
CMP R11D,dword ptr [R12 + RSI*0x4]
JG 0x0010132f
ADD ECX,0x1
MOV ESI,R8D
MOV dword ptr [R9],R11D
JMP 0x0010133f
LAB_0010132f:
MOV ESI,R8D
MOVSXD R10,EAX
MOV R10D,dword ptr [R12 + R10*0x4]
MOV dword ptr [R9],R10D
LEA EAX,[RAX + 0x1]
LAB_0010133f:
ADD R8D,0x1
ADD R9,0x4
CMP EBX,EDX
SETG R11B
CMP ECX,EBP
SETL R10B
TEST R11B,R10B
JZ 0x001012e9
CMP EAX,R13D
JGE 0x001012e9
LAB_0010135d:
MOVSXD RSI,EDX
MOV R10D,dword ptr [R15 + RSI*0x4]
MOVSXD RSI,ECX
MOV R11D,dword ptr [R14 + RSI*0x4]
CMP R10D,R11D
JG 0x0010131b
MOVSXD RSI,EAX
CMP R10D,dword ptr [R12 + RSI*0x4]
JG 0x0010132f
ADD EDX,0x1
MOV ESI,R8D
MOV dword ptr [R9],R10D
JMP 0x0010133f
LAB_00101384:
ADD ECX,0x1
MOV R9D,ESI
LAB_0010138a:
MOV ESI,R8D
MOV dword ptr [RDI + R8*0x4 + -0x4],R9D
ADD R8,0x1
CMP EDX,EBX
JGE 0x001013b6
CMP ECX,EBP
JGE 0x001013b6
LAB_0010139e:
MOVSXD RSI,EDX
MOV R9D,dword ptr [R15 + RSI*0x4]
MOVSXD RSI,ECX
MOV ESI,dword ptr [R14 + RSI*0x4]
CMP R9D,ESI
JG 0x00101384
ADD EDX,0x1
JMP 0x0010138a
LAB_001013b6:
CMP EBX,EDX
JLE 0x001013fb
CMP R13D,EAX
JLE 0x001013fb
LEA R8D,[RSI + 0x1]
MOVSXD R8,R8D
JMP 0x001013e3
LAB_001013c8:
ADD EAX,0x1
MOV R9D,ESI
LAB_001013ce:
MOV ESI,R8D
MOV dword ptr [RDI + R8*0x4 + -0x4],R9D
ADD R8,0x1
CMP EDX,EBX
JGE 0x001013fb
CMP EAX,R13D
JGE 0x001013fb
LAB_001013e3:
MOVSXD RSI,EDX
MOV R9D,dword ptr [R15 + RSI*0x4]
MOVSXD RSI,EAX
MOV ESI,dword ptr [R12 + RSI*0x4]
CMP R9D,ESI
JG 0x001013c8
ADD EDX,0x1
JMP 0x001013ce
LAB_001013fb:
CMP EBP,ECX
JLE 0x00101440
CMP R13D,EAX
JLE 0x00101440
LEA R8D,[RSI + 0x1]
MOVSXD R8,R8D
JMP 0x00101428
LAB_0010140d:
ADD EAX,0x1
MOV R9D,ESI
LAB_00101413:
MOV ESI,R8D
MOV dword ptr [RDI + R8*0x4 + -0x4],R9D
ADD R8,0x1
CMP ECX,EBP
JGE 0x00101440
CMP EAX,R13D
JGE 0x00101440
LAB_00101428:
MOVSXD RSI,ECX
MOV R9D,dword ptr [R14 + RSI*0x4]
MOVSXD RSI,EAX
MOV ESI,dword ptr [R12 + RSI*0x4]
CMP R9D,ESI
JG 0x0010140d
ADD ECX,0x1
JMP 0x00101413
LAB_00101440:
CMP EBX,EDX
JLE 0x00101466
MOVSXD R8,EDX
MOVSXD R9,ESI
SUB R9,R8
LEA R10,[RDI + R9*0x4]
LAB_00101451:
MOV R9D,dword ptr [R15 + R8*0x4]
MOV dword ptr [R10 + R8*0x4],R9D
ADD R8,0x1
CMP EBX,R8D
JG 0x00101451
SUB EBX,EDX
ADD ESI,EBX
LAB_00101466:
CMP EBP,ECX
JLE 0x0010148b
MOVSXD RDX,ECX
MOVSXD R8,ESI
SUB R8,RDX
LEA R9,[RDI + R8*0x4]
LAB_00101477:
MOV R8D,dword ptr [R14 + RDX*0x4]
MOV dword ptr [R9 + RDX*0x4],R8D
ADD RDX,0x1
CMP EBP,EDX
JG 0x00101477
SUB EBP,ECX
ADD ESI,EBP
LAB_0010148b:
CMP R13D,EAX
JLE 0x001014ac
CDQE
MOVSXD RSI,ESI
SUB RSI,RAX
LEA RCX,[RDI + RSI*0x4]
LAB_0010149c:
MOV EDX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP R13D,EAX
JG 0x0010149c
LAB_001014ac:
MOV RAX,RDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
long lVar7;
int iVar8;
int *piVar9;
long lVar10;
qsort(param_1,(long)param_2,4,compare);
qsort(param_3,(long)param_4,4,compare);
qsort(param_5,(long)param_6,4,compare);
iVar6 = param_2 + param_4 + param_6;
*param_7 = iVar6;
piVar2 = (int *)malloc((long)iVar6 << 2);
if (piVar2 == (int *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
if ((param_4 < 1 || param_6 < 1) || (param_2 < 1)) {
iVar5 = 0;
iVar6 = 0;
iVar3 = 0;
iVar4 = 0;
}
else {
iVar6 = 0;
iVar3 = 0;
iVar4 = 0;
piVar9 = piVar2;
iVar8 = 1;
do {
iVar5 = iVar8;
iVar8 = *(int *)((long)param_1 + (long)iVar4 * 4);
iVar1 = *(int *)((long)param_3 + (long)iVar3 * 4);
if (iVar1 < iVar8) {
if (*(int *)((long)param_5 + (long)iVar6 * 4) < iVar1) goto LAB_0010132f;
iVar3 = iVar3 + 1;
*piVar9 = iVar1;
}
else if (*(int *)((long)param_5 + (long)iVar6 * 4) < iVar8) {
LAB_0010132f:
*piVar9 = *(int *)((long)param_5 + (long)iVar6 * 4);
iVar6 = iVar6 + 1;
}
else {
iVar4 = iVar4 + 1;
*piVar9 = iVar8;
}
piVar9 = piVar9 + 1;
} while ((iVar4 < param_2 && iVar3 < param_4) && (iVar8 = iVar5 + 1, iVar6 < param_6));
}
if ((iVar4 < param_2) && (iVar3 < param_4)) {
lVar7 = (long)(iVar5 + 1);
do {
iVar5 = *(int *)((long)param_1 + (long)iVar4 * 4);
iVar8 = *(int *)((long)param_3 + (long)iVar3 * 4);
if (iVar8 < iVar5) {
iVar3 = iVar3 + 1;
}
else {
iVar4 = iVar4 + 1;
iVar8 = iVar5;
}
iVar5 = (int)lVar7;
piVar2[lVar7 + -1] = iVar8;
lVar7 = lVar7 + 1;
} while ((iVar4 < param_2) && (iVar3 < param_4));
}
if ((iVar4 < param_2) && (iVar6 < param_6)) {
lVar7 = (long)(iVar5 + 1);
do {
iVar5 = *(int *)((long)param_1 + (long)iVar4 * 4);
iVar8 = *(int *)((long)param_5 + (long)iVar6 * 4);
if (iVar8 < iVar5) {
iVar6 = iVar6 + 1;
}
else {
iVar4 = iVar4 + 1;
iVar8 = iVar5;
}
iVar5 = (int)lVar7;
piVar2[lVar7 + -1] = iVar8;
lVar7 = lVar7 + 1;
} while ((iVar4 < param_2) && (iVar6 < param_6));
}
if ((iVar3 < param_4) && (iVar6 < param_6)) {
lVar7 = (long)(iVar5 + 1);
do {
iVar5 = *(int *)((long)param_3 + (long)iVar3 * 4);
iVar8 = *(int *)((long)param_5 + (long)iVar6 * 4);
if (iVar8 < iVar5) {
iVar6 = iVar6 + 1;
}
else {
iVar3 = iVar3 + 1;
iVar8 = iVar5;
}
iVar5 = (int)lVar7;
piVar2[lVar7 + -1] = iVar8;
lVar7 = lVar7 + 1;
} while ((iVar3 < param_4) && (iVar6 < param_6));
}
if (iVar4 < param_2) {
lVar7 = (long)iVar4;
lVar10 = iVar5 - lVar7;
do {
piVar2[lVar10 + lVar7] = *(int *)((long)param_1 + lVar7 * 4);
lVar7 = lVar7 + 1;
} while ((int)lVar7 < param_2);
iVar5 = iVar5 + (param_2 - iVar4);
}
if (iVar3 < param_4) {
lVar7 = (long)iVar3;
lVar10 = iVar5 - lVar7;
do {
piVar2[lVar10 + lVar7] = *(int *)((long)param_3 + lVar7 * 4);
lVar7 = lVar7 + 1;
} while ((int)lVar7 < param_4);
iVar5 = iVar5 + (param_4 - iVar3);
}
if (iVar6 < param_6) {
lVar7 = (long)iVar6;
lVar10 = iVar5 - lVar7;
do {
piVar2[lVar10 + lVar7] = *(int *)((long)param_5 + lVar7 * 4);
lVar7 = lVar7 + 1;
} while ((int)lVar7 < param_6);
}
return piVar2;
} |
4,326 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
*result_size = size1 + size2 + size3;
int *result = malloc(*result_size * sizeof(int));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
// Merge the sorted arrays
int i = 0, j = 0, k = 0, l = 0;
while (i < size1 && j < size2 && k < size3) {
if (num1[i] <= num2[j] && num1[i] <= num3[k]) {
result[l++] = num1[i++];
} else if (num2[j] <= num1[i] && num2[j] <= num3[k]) {
result[l++] = num2[j++];
} else {
result[l++] = num3[k++];
}
}
// Merge remaining elements from num1 and num2
while (i < size1 && j < size2) {
result[l++] = (num1[i] <= num2[j]) ? num1[i++] : num2[j++];
}
// Merge remaining elements from num1 and num3
while (i < size1 && k < size3) {
result[l++] = (num1[i] <= num3[k]) ? num1[i++] : num3[k++];
}
// Merge remaining elements from num2 and num3
while (j < size2 && k < size3) {
result[l++] = (num2[j] <= num3[k]) ? num2[j++] : num3[k++];
}
// Copy any remaining elements
while (i < size1) {
result[l++] = num1[i++];
}
while (j < size2) {
result[l++] = num2[j++];
}
while (k < size3) {
result[l++] = num3[k++];
}
return result;
}
| int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) / sizeof(num3_1[0]);
int expected1[] = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
int expected_size1 = sizeof(expected1) / sizeof(expected1[0]);
int result_size1;
int *result1 = func0(num1_1, size1_1, num2_1, size2_1, num3_1, size3_1, &result_size1);
assert(result_size1 == expected_size1);
for(int i = 0; i < expected_size1; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int num1_2[] = {1, 3, 5, 6, 8, 9};
int size1_2 = sizeof(num1_2) / sizeof(num1_2[0]);
int num2_2[] = {2, 5, 7, 11};
int size2_2 = sizeof(num2_2) / sizeof(num2_2[0]);
int num3_2[] = {1, 4, 7, 8, 12};
int size3_2 = sizeof(num3_2) / sizeof(num3_2[0]);
int expected2[] = {1, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9, 11, 12};
int expected_size2 = sizeof(expected2) / sizeof(expected2[0]);
int result_size2;
int *result2 = func0(num1_2, size1_2, num2_2, size2_2, num3_2, size3_2, &result_size2);
assert(result_size2 == expected_size2);
for(int i = 0; i < expected_size2; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int num1_3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size1_3 = sizeof(num1_3) / sizeof(num1_3[0]);
int num2_3[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2_3 = sizeof(num2_3) / sizeof(num2_3[0]);
int num3_3[] = {12, 74, 9, 50, 61, 41};
int size3_3 = sizeof(num3_3) / sizeof(num3_3[0]);
int expected3[] = {1, 2, 3, 4, 7, 8, 9, 9, 9, 10, 12, 14, 14, 18, 22, 25, 25, 35, 41, 50, 58, 61, 65, 74, 75, 85};
int expected_size3 = sizeof(expected3) / sizeof(expected3[0]);
int result_size3;
int *result3 = func0(num1_3, size1_3, num2_3, size2_3, num3_3, size3_3, &result_size3);
assert(result_size3 == expected_size3);
for(int i = 0; i < expected_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov %r9d,%r15d
push %r14
mov %r8,%r14
push %r13
mov %rdi,%r13
push %r12
mov %rdx,%r12
mov $0x4,%edx
push %rbp
mov %rsi,%rbp
push %rbx
mov %ecx,%ebx
lea -0x4e(%rip),%rcx
sub $0x18,%rsp
callq 10c0 <qsort@plt>
movslq %ebx,%rsi
mov $0x4,%edx
mov %r12,%rdi
lea -0x69(%rip),%rcx
callq 10c0 <qsort@plt>
mov %r14,%rdi
movslq %r15d,%rsi
mov $0x4,%edx
lea -0x80(%rip),%rcx
callq 10c0 <qsort@plt>
mov 0x50(%rsp),%rax
lea 0x0(%rbp,%rbx,1),%edi
add %r15d,%edi
mov %edi,(%rax)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
test %rax,%rax
je 1b63 <func0+0x313>
test %ebp,%ebp
setg %cl
test %ebx,%ebx
setg %dl
test %r15d,%r15d
mov %ecx,%r8d
setg %sil
mov %edx,%r9d
test %sil,%dl
je 1b50 <func0+0x300>
test %cl,%cl
je 1b50 <func0+0x300>
mov %ebx,0xc(%rsp)
mov $0x1,%r11d
xor %edi,%edi
xor %r10d,%r10d
xor %ecx,%ecx
jmp 195d <func0+0x10d>
nopl 0x0(%rax,%rax,1)
cmp %r8d,%esi
jg 1990 <func0+0x140>
mov %esi,-0x4(%rax,%r11,4)
add $0x1,%r10d
nopw %cs:0x0(%rax,%rax,1)
cmp %ebp,%ecx
setl %r8b
cmp 0xc(%rsp),%r10d
setl %r9b
mov %r8d,%edx
and %r9d,%edx
cmp %r15d,%edi
setl %sil
add $0x1,%r11
test %sil,%sil
je 19a0 <func0+0x150>
test %dl,%dl
je 1a08 <func0+0x1b8>
movslq %ecx,%rdx
movslq %r10d,%rsi
movslq %edi,%r8
mov %r11d,%ebx
mov 0x0(%r13,%rdx,4),%edx
mov (%r12,%rsi,4),%esi
mov (%r14,%r8,4),%r8d
cmp %esi,%edx
jg 1918 <func0+0xc8>
cmp %r8d,%edx
jg 1990 <func0+0x140>
mov %edx,-0x4(%rax,%r11,4)
add $0x1,%ecx
jmp 1930 <func0+0xe0>
nopl 0x0(%rax)
mov %r8d,-0x4(%rax,%r11,4)
add $0x1,%edi
jmp 1930 <func0+0xe0>
nopw 0x0(%rax,%rax,1)
mov %edx,%r11d
mov %ebx,%edx
mov 0xc(%rsp),%ebx
test %r11b,%r11b
je 1a0e <func0+0x1be>
add $0x1,%edx
movslq %edx,%r11
jmp 19e6 <func0+0x196>
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%ecx
cmp %ebp,%ecx
mov %r8d,-0x4(%rax,%r11,4)
mov %r11d,%edx
setl %r8b
cmp %ebx,%r10d
setl %r9b
add $0x1,%r11
test %r8b,%r8b
je 1a0e <func0+0x1be>
test %r9b,%r9b
je 1a0e <func0+0x1be>
movslq %ecx,%rdx
mov 0x0(%r13,%rdx,4),%r8d
movslq %r10d,%rdx
mov (%r12,%rdx,4),%edx
cmp %edx,%r8d
jle 19c0 <func0+0x170>
add $0x1,%r10d
mov %edx,%r8d
jmp 19c3 <func0+0x173>
nopl 0x0(%rax,%rax,1)
mov %ebx,%edx
mov 0xc(%rsp),%ebx
test %sil,%sil
je 1a60 <func0+0x210>
test %r8b,%r8b
je 1a60 <func0+0x210>
add $0x1,%edx
movslq %edx,%r8
jmp 1a3f <func0+0x1ef>
add $0x1,%ecx
cmp %r15d,%edi
mov %esi,-0x4(%rax,%r8,4)
mov %r8d,%edx
setl %sil
add $0x1,%r8
cmp %ebp,%ecx
jge 1a60 <func0+0x210>
test %sil,%sil
je 1a60 <func0+0x210>
movslq %ecx,%rdx
mov 0x0(%r13,%rdx,4),%esi
movslq %edi,%rdx
mov (%r14,%rdx,4),%edx
cmp %edx,%esi
jle 1a20 <func0+0x1d0>
add $0x1,%edi
mov %edx,%esi
jmp 1a23 <func0+0x1d3>
nopl 0x0(%rax)
test %r9b,%r9b
je 1aba <func0+0x26a>
test %sil,%sil
je 1aba <func0+0x26a>
add $0x1,%edx
movslq %edx,%rsi
jmp 1a91 <func0+0x241>
nopw 0x0(%rax,%rax,1)
add $0x1,%r10d
mov %r8d,-0x4(%rax,%rsi,4)
mov %esi,%edx
add $0x1,%rsi
cmp %ebx,%r10d
jge 1aba <func0+0x26a>
cmp %r15d,%edi
jge 1aba <func0+0x26a>
movslq %r10d,%rdx
mov (%r12,%rdx,4),%r8d
movslq %edi,%rdx
mov (%r14,%rdx,4),%edx
cmp %edx,%r8d
jle 1a78 <func0+0x228>
mov %edx,%r8d
add $0x1,%edi
mov %esi,%edx
mov %r8d,-0x4(%rax,%rsi,4)
add $0x1,%rsi
cmp %ebx,%r10d
jl 1a8c <func0+0x23c>
cmp %ecx,%ebp
jle 1ae5 <func0+0x295>
movslq %ecx,%rsi
movslq %edx,%r8
sub %rsi,%r8
lea (%rax,%r8,4),%r9
nopl 0x0(%rax,%rax,1)
mov 0x0(%r13,%rsi,4),%r8d
mov %r8d,(%r9,%rsi,4)
add $0x1,%rsi
cmp %esi,%ebp
jg 1ad0 <func0+0x280>
sub %ecx,%ebp
add %ebp,%edx
cmp %r10d,%ebx
jle 1b15 <func0+0x2c5>
movslq %r10d,%rcx
movslq %edx,%rsi
sub %rcx,%rsi
lea (%rax,%rsi,4),%r8
nopw 0x0(%rax,%rax,1)
mov (%r12,%rcx,4),%esi
mov %esi,(%r8,%rcx,4)
add $0x1,%rcx
cmp %ecx,%ebx
jg 1b00 <func0+0x2b0>
sub %r10d,%ebx
add %ebx,%edx
cmp %edi,%r15d
jle 1b40 <func0+0x2f0>
movslq %edi,%rdi
movslq %edx,%rdx
sub %rdi,%rdx
lea (%rax,%rdx,4),%rcx
nopw 0x0(%rax,%rax,1)
mov (%r14,%rdi,4),%edx
mov %edx,(%rcx,%rdi,4)
add $0x1,%rdi
cmp %edi,%r15d
jg 1b30 <func0+0x2e0>
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
and %ecx,%edx
xor %edi,%edi
xor %r10d,%r10d
xor %ecx,%ecx
mov %edx,%r11d
xor %edx,%edx
jmpq 19a9 <func0+0x159>
lea 0x49a(%rip),%rdi
callq 1100 <perror@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
movsxd rsi, esi
push r14
mov r14d, ecx
mov r15, rsi
push r13
push r12
lea r12, compare
push rbp
mov rcx, r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_48], rdx
mov edx, 4
mov dword ptr [rsp+58h+var_58], r9d
mov [rsp+58h+var_50], r8
mov [rsp+58h+var_40], rdi
call _qsort
mov rdi, [rsp+58h+var_48]
movsxd rsi, r14d
mov rcx, r12
mov edx, 4
call _qsort
mov rdi, [rsp+58h+var_50]
movsxd rsi, dword ptr [rsp+58h+var_58]
mov rcx, r12
mov edx, 4
call _qsort
mov r9d, dword ptr [rsp+58h+var_58]
mov rax, [rsp+58h+arg_0]
lea edi, [r15+r14]
add edi, r9d
mov [rax], edi
movsxd rdi, edi
shl rdi, 2
call _malloc
test rax, rax
jz loc_1BCB
test r15d, r15d
mov r9d, dword ptr [rsp+58h+var_58]
mov rcx, rax
mov r8, [rsp+58h+var_50]
setnle bl
test r14d, r14d
mov r10, [rsp+58h+var_48]
mov r11, [rsp+58h+var_40]
setnle dil
test r9d, r9d
mov edx, ebx
setnle al
mov esi, edi
test al, dil
jz loc_1BB8
test bl, bl
jz loc_1BB8
mov dword ptr [rsp+58h+var_58], r9d
mov edi, 1
xor ebp, ebp
xor r13d, r13d
xor r12d, r12d
jmp short loc_1993
loc_1958:
cmp esi, eax
jg short loc_19C0
add r13d, 1
mov eax, esi
nop word ptr [rax+rax+00h]
loc_1968:
cmp r12d, r15d
mov [rcx+rdi*4-4], eax
setl dl
cmp r13d, r14d
setl sil
mov ebx, edx
and ebx, esi
cmp ebp, dword ptr [rsp+58h+var_58]
setl al
add rdi, 1
test al, al
jz short loc_19C8
test bl, bl
jz loc_1A20
loc_1993:
movsxd rax, r12d
mov r9d, edi
mov edx, [r11+rax*4]
movsxd rax, r13d
mov esi, [r10+rax*4]
movsxd rax, ebp
mov eax, [r8+rax*4]
cmp edx, esi
jg short loc_1958
cmp edx, eax
jg short loc_19C0
add r12d, 1
mov eax, edx
jmp short loc_1968
loc_19C0:
add ebp, 1
jmp short loc_1968
loc_19C8:
mov edi, ebx
mov ebx, r9d
mov r9d, dword ptr [rsp+58h+var_58]
loc_19D1:
test dil, dil
jz short loc_1A27
add ebx, 1
movsxd rdi, ebx
jmp short loc_1A04
loc_19E0:
add r12d, 1
loc_19E4:
cmp r12d, r15d
mov [rcx+rdi*4-4], edx
mov ebx, edi
setl dl
cmp r13d, r14d
setl sil
add rdi, 1
test dl, dl
jz short loc_1A27
test sil, sil
jz short loc_1A27
loc_1A04:
movsxd rdx, r12d
movsxd rsi, r13d
mov edx, [r11+rdx*4]
mov esi, [r10+rsi*4]
cmp edx, esi
jle short loc_19E0
add r13d, 1
mov edx, esi
jmp short loc_19E4
loc_1A20:
mov ebx, r9d
mov r9d, dword ptr [rsp+58h+var_58]
loc_1A27:
test al, al
jz short loc_1A80
test dl, dl
jz short loc_1A80
add ebx, 1
movsxd rdx, ebx
jmp short loc_1A5D
loc_1A40:
add r12d, 1
loc_1A44:
cmp ebp, r9d
mov [rcx+rdx*4-4], eax
mov ebx, edx
setl al
add rdx, 1
cmp r12d, r15d
jge short loc_1A80
test al, al
jz short loc_1A80
loc_1A5D:
movsxd rax, r12d
movsxd rdi, ebp
mov eax, [r11+rax*4]
mov edi, [r8+rdi*4]
cmp eax, edi
jle short loc_1A40
add ebp, 1
mov eax, edi
jmp short loc_1A44
loc_1A80:
test sil, sil
jz short loc_1AD6
test al, al
jz short loc_1AD6
add ebx, 1
movsxd rax, ebx
jmp short loc_1AB0
loc_1A98:
add r13d, 1
mov [rcx+rax*4-4], edx
mov ebx, eax
add rax, 1
cmp r13d, r14d
jge short loc_1AD6
loc_1AAB:
cmp ebp, r9d
jge short loc_1AD6
loc_1AB0:
movsxd rdx, r13d
movsxd rsi, ebp
mov edx, [r10+rdx*4]
mov esi, [r8+rsi*4]
cmp edx, esi
jle short loc_1A98
mov edx, esi
mov ebx, eax
add ebp, 1
mov [rcx+rax*4-4], edx
add rax, 1
cmp r13d, r14d
jl short loc_1AAB
loc_1AD6:
cmp r15d, r12d
jle short loc_1B29
movsxd rax, ebx
mov dword ptr [rsp+58h+var_40], r9d
lea rdi, [rcx+rax*4]
lea eax, [r15-1]
mov [rsp+58h+var_48], r8
sub r15d, r12d
sub eax, r12d
mov [rsp+58h+var_50], r10
add ebx, r15d
lea rdx, ds:4[rax*4]
movsxd rax, r12d
mov [rsp+58h+var_58], rcx
lea rsi, [r11+rax*4]
call _memcpy
mov r9d, dword ptr [rsp+58h+var_40]
mov r8, [rsp+58h+var_48]
mov r10, [rsp+58h+var_50]
mov rcx, [rsp+58h+var_58]
loc_1B29:
cmp r14d, r13d
jle short loc_1B72
movsxd rax, ebx
mov dword ptr [rsp+58h+var_48], r9d
lea rdi, [rcx+rax*4]
lea eax, [r14-1]
mov [rsp+58h+var_50], r8
sub r14d, r13d
sub eax, r13d
mov [rsp+58h+var_58], rcx
add ebx, r14d
lea rdx, ds:4[rax*4]
movsxd rax, r13d
lea rsi, [r10+rax*4]
call _memcpy
mov r9d, dword ptr [rsp+58h+var_48]
mov r8, [rsp+58h+var_50]
mov rcx, [rsp+58h+var_58]
loc_1B72:
cmp r9d, ebp
jle short loc_1BA1
sub r9d, 1
movsxd rbx, ebx
mov [rsp+58h+var_58], rcx
sub r9d, ebp
movsxd rbp, ebp
lea rdi, [rcx+rbx*4]
lea rdx, ds:4[r9*4]
lea rsi, [r8+rbp*4]
call _memcpy
mov rcx, [rsp+58h+var_58]
loc_1BA1:
add rsp, 28h
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1BB8:
and ebx, edi
xor ebp, ebp
xor r13d, r13d
xor r12d, r12d
mov edi, ebx
xor ebx, ebx
jmp loc_19D1
loc_1BCB:
lea rdi, aFailedToAlloca; "Failed to allocate memory"
call _perror
mov edi, 1
call _exit | long long func0(long long a1, int a2, long long a3, int a4, long long a5, int a6, _DWORD *a7)
{
int v9; // edi
long long v10; // rax
int v11; // r9d
long long v12; // rcx
long long v13; // r8
long long v14; // r10
long long v15; // r11
bool v16; // dl
bool v17; // al
bool v18; // si
long long v19; // rdi
int v20; // ebp
int v21; // r13d
int v22; // r12d
int v23; // eax
int v24; // r9d
int v25; // edx
int v26; // esi
bool v27; // di
int v28; // ebx
long long v29; // rdi
int v30; // edx
int v31; // esi
long long v32; // rdx
int v33; // eax
int v34; // edi
long long v35; // rax
int v36; // edx
int v37; // esi
long long v38; // rdi
long long v39; // rdi
long long v42; // [rsp+0h] [rbp-58h]
long long v43; // [rsp+0h] [rbp-58h]
long long v44; // [rsp+0h] [rbp-58h]
long long v46; // [rsp+8h] [rbp-50h]
long long v47; // [rsp+8h] [rbp-50h]
long long v49; // [rsp+10h] [rbp-48h]
int v50; // [rsp+10h] [rbp-48h]
int v52; // [rsp+18h] [rbp-40h]
qsort(a1, a2, 4LL, compare);
qsort(a3, a4, 4LL, compare);
qsort(a5, a6, 4LL, compare);
v9 = a6 + a2 + a4;
*a7 = v9;
v10 = malloc(4LL * v9);
if ( !v10 )
{
perror("Failed to allocate memory");
exit(1LL);
}
v11 = a6;
v12 = v10;
v13 = a5;
v14 = a3;
v15 = a1;
v16 = a2 > 0;
v17 = a6 > 0;
v18 = a4 > 0;
if ( a4 > 0 && a6 > 0 && a2 > 0 )
{
v19 = 1LL;
v20 = 0;
v21 = 0;
v22 = 0;
while ( 1 )
{
v24 = v19;
v25 = *(_DWORD *)(a1 + 4LL * v22);
v26 = *(_DWORD *)(a3 + 4LL * v21);
v23 = *(_DWORD *)(a5 + 4LL * v20);
if ( v25 > v26 )
{
if ( v26 > v23 )
goto LABEL_12;
++v21;
v23 = v26;
}
else
{
if ( v25 > v23 )
{
LABEL_12:
++v20;
goto LABEL_7;
}
++v22;
v23 = v25;
}
LABEL_7:
*(_DWORD *)(v12 + 4 * v19 - 4) = v23;
v16 = v22 < a2;
v18 = v21 < a4;
v17 = v20 < a6;
++v19;
if ( v20 >= a6 )
{
v27 = v21 < a4 && v22 < a2;
v28 = v24;
v11 = a6;
goto LABEL_14;
}
if ( v21 >= a4 || v22 >= a2 )
{
v28 = v24;
v11 = a6;
goto LABEL_22;
}
}
}
v20 = 0;
v21 = 0;
v22 = 0;
v27 = a4 > 0 && a2 > 0;
v28 = 0;
LABEL_14:
if ( v27 )
{
v29 = v28 + 1;
do
{
v30 = *(_DWORD *)(a1 + 4LL * v22);
v31 = *(_DWORD *)(a3 + 4LL * v21);
if ( v30 <= v31 )
{
++v22;
}
else
{
++v21;
v30 = v31;
}
*(_DWORD *)(v12 + 4 * v29 - 4) = v30;
v28 = v29;
v16 = v22 < a2;
v18 = v21 < a4;
++v29;
}
while ( v22 < a2 && v21 < a4 );
}
LABEL_22:
if ( v17 && v16 )
{
v32 = v28 + 1;
do
{
v33 = *(_DWORD *)(a1 + 4LL * v22);
v34 = *(_DWORD *)(a5 + 4LL * v20);
if ( v33 <= v34 )
{
++v22;
}
else
{
++v20;
v33 = v34;
}
*(_DWORD *)(v12 + 4 * v32 - 4) = v33;
v28 = v32;
v17 = v20 < v11;
++v32;
}
while ( v22 < a2 && v20 < v11 );
}
if ( v18 && v17 )
{
v35 = v28 + 1;
do
{
v36 = *(_DWORD *)(a3 + 4LL * v21);
v37 = *(_DWORD *)(a5 + 4LL * v20);
if ( v36 <= v37 )
{
++v21;
*(_DWORD *)(v12 + 4 * v35 - 4) = v36;
v28 = v35++;
if ( v21 >= a4 )
break;
}
else
{
v28 = v35;
++v20;
*(_DWORD *)(v12 + 4 * v35++ - 4) = v37;
if ( v21 >= a4 )
break;
}
}
while ( v20 < v11 );
}
if ( a2 > v22 )
{
v52 = v11;
v38 = v12 + 4LL * v28;
v49 = a5;
v46 = v14;
v28 += a2 - v22;
v42 = v12;
memcpy(v38, v15 + 4LL * v22, 4LL * (unsigned int)(a2 - 1 - v22) + 4);
v11 = v52;
v13 = v49;
v14 = v46;
v12 = v42;
}
if ( a4 > v21 )
{
v50 = v11;
v39 = v12 + 4LL * v28;
v47 = v13;
v43 = v12;
v28 += a4 - v21;
memcpy(v39, v14 + 4LL * v21, 4LL * (unsigned int)(a4 - 1 - v21) + 4);
v11 = v50;
v13 = v47;
v12 = v43;
}
if ( v11 > v20 )
{
v44 = v12;
memcpy(v12 + 4LL * v28, v13 + 4LL * v20, 4LL * (unsigned int)(v11 - 1 - v20) + 4);
return v44;
}
return v12;
} | func0:
ENDBR64
PUSH R15
MOVSXD RSI,ESI
PUSH R14
MOV R14D,ECX
MOV R15,RSI
PUSH R13
PUSH R12
LEA R12,[0x101850]
PUSH RBP
MOV RCX,R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDX
MOV EDX,0x4
MOV dword ptr [RSP],R9D
MOV qword ptr [RSP + 0x8],R8
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001010d0
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RSI,R14D
MOV RCX,R12
MOV EDX,0x4
CALL 0x001010d0
MOV RDI,qword ptr [RSP + 0x8]
MOVSXD RSI,dword ptr [RSP]
MOV RCX,R12
MOV EDX,0x4
CALL 0x001010d0
MOV R9D,dword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x60]
LEA EDI,[R15 + R14*0x1]
ADD EDI,R9D
MOV dword ptr [RAX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101bcb
TEST R15D,R15D
MOV R9D,dword ptr [RSP]
MOV RCX,RAX
MOV R8,qword ptr [RSP + 0x8]
SETG BL
TEST R14D,R14D
MOV R10,qword ptr [RSP + 0x10]
MOV R11,qword ptr [RSP + 0x18]
SETG DIL
TEST R9D,R9D
MOV EDX,EBX
SETG AL
MOV ESI,EDI
TEST AL,DIL
JZ 0x00101bb8
TEST BL,BL
JZ 0x00101bb8
MOV dword ptr [RSP],R9D
MOV EDI,0x1
XOR EBP,EBP
XOR R13D,R13D
XOR R12D,R12D
JMP 0x00101993
LAB_00101958:
CMP ESI,EAX
JG 0x001019c0
ADD R13D,0x1
MOV EAX,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101968:
CMP R12D,R15D
MOV dword ptr [RCX + RDI*0x4 + -0x4],EAX
SETL DL
CMP R13D,R14D
SETL SIL
MOV EBX,EDX
AND EBX,ESI
CMP EBP,dword ptr [RSP]
SETL AL
ADD RDI,0x1
TEST AL,AL
JZ 0x001019c8
TEST BL,BL
JZ 0x00101a20
LAB_00101993:
MOVSXD RAX,R12D
MOV R9D,EDI
MOV EDX,dword ptr [R11 + RAX*0x4]
MOVSXD RAX,R13D
MOV ESI,dword ptr [R10 + RAX*0x4]
MOVSXD RAX,EBP
MOV EAX,dword ptr [R8 + RAX*0x4]
CMP EDX,ESI
JG 0x00101958
CMP EDX,EAX
JG 0x001019c0
ADD R12D,0x1
MOV EAX,EDX
JMP 0x00101968
LAB_001019c0:
ADD EBP,0x1
JMP 0x00101968
LAB_001019c8:
MOV EDI,EBX
MOV EBX,R9D
MOV R9D,dword ptr [RSP]
LAB_001019d1:
TEST DIL,DIL
JZ 0x00101a27
ADD EBX,0x1
MOVSXD RDI,EBX
JMP 0x00101a04
LAB_001019e0:
ADD R12D,0x1
LAB_001019e4:
CMP R12D,R15D
MOV dword ptr [RCX + RDI*0x4 + -0x4],EDX
MOV EBX,EDI
SETL DL
CMP R13D,R14D
SETL SIL
ADD RDI,0x1
TEST DL,DL
JZ 0x00101a27
TEST SIL,SIL
JZ 0x00101a27
LAB_00101a04:
MOVSXD RDX,R12D
MOVSXD RSI,R13D
MOV EDX,dword ptr [R11 + RDX*0x4]
MOV ESI,dword ptr [R10 + RSI*0x4]
CMP EDX,ESI
JLE 0x001019e0
ADD R13D,0x1
MOV EDX,ESI
JMP 0x001019e4
LAB_00101a20:
MOV EBX,R9D
MOV R9D,dword ptr [RSP]
LAB_00101a27:
TEST AL,AL
JZ 0x00101a80
TEST DL,DL
JZ 0x00101a80
ADD EBX,0x1
MOVSXD RDX,EBX
JMP 0x00101a5d
LAB_00101a40:
ADD R12D,0x1
LAB_00101a44:
CMP EBP,R9D
MOV dword ptr [RCX + RDX*0x4 + -0x4],EAX
MOV EBX,EDX
SETL AL
ADD RDX,0x1
CMP R12D,R15D
JGE 0x00101a80
TEST AL,AL
JZ 0x00101a80
LAB_00101a5d:
MOVSXD RAX,R12D
MOVSXD RDI,EBP
MOV EAX,dword ptr [R11 + RAX*0x4]
MOV EDI,dword ptr [R8 + RDI*0x4]
CMP EAX,EDI
JLE 0x00101a40
ADD EBP,0x1
MOV EAX,EDI
JMP 0x00101a44
LAB_00101a80:
TEST SIL,SIL
JZ 0x00101ad6
TEST AL,AL
JZ 0x00101ad6
ADD EBX,0x1
MOVSXD RAX,EBX
JMP 0x00101ab0
LAB_00101a98:
ADD R13D,0x1
MOV dword ptr [RCX + RAX*0x4 + -0x4],EDX
MOV EBX,EAX
ADD RAX,0x1
CMP R13D,R14D
JGE 0x00101ad6
LAB_00101aab:
CMP EBP,R9D
JGE 0x00101ad6
LAB_00101ab0:
MOVSXD RDX,R13D
MOVSXD RSI,EBP
MOV EDX,dword ptr [R10 + RDX*0x4]
MOV ESI,dword ptr [R8 + RSI*0x4]
CMP EDX,ESI
JLE 0x00101a98
MOV EDX,ESI
MOV EBX,EAX
ADD EBP,0x1
MOV dword ptr [RCX + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP R13D,R14D
JL 0x00101aab
LAB_00101ad6:
CMP R15D,R12D
JLE 0x00101b29
MOVSXD RAX,EBX
MOV dword ptr [RSP + 0x18],R9D
LEA RDI,[RCX + RAX*0x4]
LEA EAX,[R15 + -0x1]
MOV qword ptr [RSP + 0x10],R8
SUB R15D,R12D
SUB EAX,R12D
MOV qword ptr [RSP + 0x8],R10
ADD EBX,R15D
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,R12D
MOV qword ptr [RSP],RCX
LEA RSI,[R11 + RAX*0x4]
CALL 0x00101100
MOV R9D,dword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x10]
MOV R10,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
LAB_00101b29:
CMP R14D,R13D
JLE 0x00101b72
MOVSXD RAX,EBX
MOV dword ptr [RSP + 0x10],R9D
LEA RDI,[RCX + RAX*0x4]
LEA EAX,[R14 + -0x1]
MOV qword ptr [RSP + 0x8],R8
SUB R14D,R13D
SUB EAX,R13D
MOV qword ptr [RSP],RCX
ADD EBX,R14D
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,R13D
LEA RSI,[R10 + RAX*0x4]
CALL 0x00101100
MOV R9D,dword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
LAB_00101b72:
CMP R9D,EBP
JLE 0x00101ba1
SUB R9D,0x1
MOVSXD RBX,EBX
MOV qword ptr [RSP],RCX
SUB R9D,EBP
MOVSXD RBP,EBP
LEA RDI,[RCX + RBX*0x4]
LEA RDX,[0x4 + R9*0x4]
LEA RSI,[R8 + RBP*0x4]
CALL 0x00101100
MOV RCX,qword ptr [RSP]
LAB_00101ba1:
ADD RSP,0x28
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101bb8:
AND EBX,EDI
XOR EBP,EBP
XOR R13D,R13D
XOR R12D,R12D
MOV EDI,EBX
XOR EBX,EBX
JMP 0x001019d1
LAB_00101bcb:
LEA RDI,[0x102004]
CALL 0x00101120
MOV EDI,0x1
CALL 0x00101130 | void * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int iVar1;
int iVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
int iVar7;
void *pvVar8;
int iVar9;
int iVar10;
int iVar11;
long lVar12;
int iVar13;
qsort(param_1,(long)param_2,4,compare);
qsort(param_3,(long)param_4,4,compare);
qsort(param_5,(long)param_6,4,compare);
iVar11 = param_2 + param_4 + param_6;
*param_7 = iVar11;
pvVar8 = malloc((long)iVar11 << 2);
if (pvVar8 == (void *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
bVar3 = 0 < param_2;
bVar4 = 0 < param_4;
bVar5 = 0 < param_6;
if ((bVar5 && bVar4) && (bVar3)) {
lVar12 = 1;
iVar10 = 0;
iVar11 = 0;
iVar13 = 0;
do {
iVar9 = (int)lVar12;
iVar1 = *(int *)((long)param_1 + (long)iVar13 * 4);
iVar7 = *(int *)((long)param_3 + (long)iVar11 * 4);
iVar2 = *(int *)((long)param_5 + (long)iVar10 * 4);
if (iVar7 < iVar1) {
if (iVar2 < iVar7) goto LAB_001019c0;
iVar11 = iVar11 + 1;
}
else if (iVar2 < iVar1) {
LAB_001019c0:
iVar10 = iVar10 + 1;
iVar7 = iVar2;
}
else {
iVar13 = iVar13 + 1;
iVar7 = iVar1;
}
*(int *)((long)pvVar8 + lVar12 * 4 + -4) = iVar7;
bVar3 = iVar13 < param_2;
bVar4 = iVar11 < param_4;
bVar6 = bVar3 && bVar4;
bVar5 = iVar10 < param_6;
lVar12 = lVar12 + 1;
if (!bVar5) goto LAB_001019d1;
} while (bVar3 && bVar4);
}
else {
bVar6 = bVar3 && bVar4;
iVar10 = 0;
iVar11 = 0;
iVar13 = 0;
iVar9 = 0;
LAB_001019d1:
if (bVar6) {
lVar12 = (long)(iVar9 + 1);
do {
iVar9 = *(int *)((long)param_1 + (long)iVar13 * 4);
iVar1 = *(int *)((long)param_3 + (long)iVar11 * 4);
if (iVar1 < iVar9) {
iVar11 = iVar11 + 1;
iVar9 = iVar1;
}
else {
iVar13 = iVar13 + 1;
}
*(int *)((long)pvVar8 + lVar12 * 4 + -4) = iVar9;
iVar9 = (int)lVar12;
bVar3 = iVar13 < param_2;
bVar4 = iVar11 < param_4;
lVar12 = lVar12 + 1;
} while ((bVar3) && (bVar4));
}
}
if ((bVar5) && (bVar3)) {
lVar12 = (long)(iVar9 + 1);
do {
iVar9 = *(int *)((long)param_1 + (long)iVar13 * 4);
iVar1 = *(int *)((long)param_5 + (long)iVar10 * 4);
if (iVar1 < iVar9) {
iVar10 = iVar10 + 1;
iVar9 = iVar1;
}
else {
iVar13 = iVar13 + 1;
}
*(int *)((long)pvVar8 + lVar12 * 4 + -4) = iVar9;
iVar9 = (int)lVar12;
bVar5 = iVar10 < param_6;
lVar12 = lVar12 + 1;
} while ((iVar13 < param_2) && (bVar5));
}
if ((bVar4) && (bVar5)) {
lVar12 = (long)(iVar9 + 1);
do {
iVar1 = *(int *)((long)param_3 + (long)iVar11 * 4);
iVar7 = *(int *)((long)param_5 + (long)iVar10 * 4);
iVar9 = (int)lVar12;
if (iVar7 < iVar1) {
iVar10 = iVar10 + 1;
*(int *)((long)pvVar8 + lVar12 * 4 + -4) = iVar7;
}
else {
iVar11 = iVar11 + 1;
*(int *)((long)pvVar8 + lVar12 * 4 + -4) = iVar1;
}
} while ((iVar11 < param_4) && (lVar12 = lVar12 + 1, iVar10 < param_6));
}
if (iVar13 < param_2) {
lVar12 = (long)iVar9;
iVar9 = iVar9 + (param_2 - iVar13);
memcpy((void *)((long)pvVar8 + lVar12 * 4),(void *)((long)param_1 + (long)iVar13 * 4),
(ulong)(uint)((param_2 + -1) - iVar13) * 4 + 4);
}
if (iVar11 < param_4) {
lVar12 = (long)iVar9;
iVar9 = iVar9 + (param_4 - iVar11);
memcpy((void *)((long)pvVar8 + lVar12 * 4),(void *)((long)param_3 + (long)iVar11 * 4),
(ulong)(uint)((param_4 + -1) - iVar11) * 4 + 4);
}
if (iVar10 < param_6) {
memcpy((void *)((long)pvVar8 + (long)iVar9 * 4),(void *)((long)param_5 + (long)iVar10 * 4),
(ulong)(uint)((param_6 + -1) - iVar10) * 4 + 4);
}
return pvVar8;
} |
4,327 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
*result_size = size1 + size2 + size3;
int *result = malloc(*result_size * sizeof(int));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
// Merge the sorted arrays
int i = 0, j = 0, k = 0, l = 0;
while (i < size1 && j < size2 && k < size3) {
if (num1[i] <= num2[j] && num1[i] <= num3[k]) {
result[l++] = num1[i++];
} else if (num2[j] <= num1[i] && num2[j] <= num3[k]) {
result[l++] = num2[j++];
} else {
result[l++] = num3[k++];
}
}
// Merge remaining elements from num1 and num2
while (i < size1 && j < size2) {
result[l++] = (num1[i] <= num2[j]) ? num1[i++] : num2[j++];
}
// Merge remaining elements from num1 and num3
while (i < size1 && k < size3) {
result[l++] = (num1[i] <= num3[k]) ? num1[i++] : num3[k++];
}
// Merge remaining elements from num2 and num3
while (j < size2 && k < size3) {
result[l++] = (num2[j] <= num3[k]) ? num2[j++] : num3[k++];
}
// Copy any remaining elements
while (i < size1) {
result[l++] = num1[i++];
}
while (j < size2) {
result[l++] = num2[j++];
}
while (k < size3) {
result[l++] = num3[k++];
}
return result;
}
| int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) / sizeof(num3_1[0]);
int expected1[] = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
int expected_size1 = sizeof(expected1) / sizeof(expected1[0]);
int result_size1;
int *result1 = func0(num1_1, size1_1, num2_1, size2_1, num3_1, size3_1, &result_size1);
assert(result_size1 == expected_size1);
for(int i = 0; i < expected_size1; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int num1_2[] = {1, 3, 5, 6, 8, 9};
int size1_2 = sizeof(num1_2) / sizeof(num1_2[0]);
int num2_2[] = {2, 5, 7, 11};
int size2_2 = sizeof(num2_2) / sizeof(num2_2[0]);
int num3_2[] = {1, 4, 7, 8, 12};
int size3_2 = sizeof(num3_2) / sizeof(num3_2[0]);
int expected2[] = {1, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9, 11, 12};
int expected_size2 = sizeof(expected2) / sizeof(expected2[0]);
int result_size2;
int *result2 = func0(num1_2, size1_2, num2_2, size2_2, num3_2, size3_2, &result_size2);
assert(result_size2 == expected_size2);
for(int i = 0; i < expected_size2; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int num1_3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size1_3 = sizeof(num1_3) / sizeof(num1_3[0]);
int num2_3[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2_3 = sizeof(num2_3) / sizeof(num2_3[0]);
int num3_3[] = {12, 74, 9, 50, 61, 41};
int size3_3 = sizeof(num3_3) / sizeof(num3_3[0]);
int expected3[] = {1, 2, 3, 4, 7, 8, 9, 9, 9, 10, 12, 14, 14, 18, 22, 25, 25, 35, 41, 50, 58, 61, 65, 74, 75, 85};
int expected_size3 = sizeof(expected3) / sizeof(expected3[0]);
int result_size3;
int *result3 = func0(num1_3, size1_3, num2_3, size2_3, num3_3, size3_3, &result_size3);
assert(result_size3 == expected_size3);
for(int i = 0; i < expected_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov %rdi,%r15
push %r14
mov %rdx,%r14
mov $0x4,%edx
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %r9d,%ebp
push %rbx
mov %ecx,%ebx
sub $0x28,%rsp
mov %ecx,0x4(%rsp)
lea -0x53(%rip),%rcx
mov %r8,0x8(%rsp)
mov %r9d,0x10(%rsp)
callq 10d0 <qsort@plt>
movslq %ebx,%rsi
mov $0x4,%edx
mov %r14,%rdi
lea -0x74(%rip),%rcx
callq 10d0 <qsort@plt>
mov 0x8(%rsp),%r8
movslq %ebp,%rsi
lea -0x88(%rip),%rcx
mov $0x4,%edx
mov %r8,%rdi
callq 10d0 <qsort@plt>
mov 0x60(%rsp),%rax
lea 0x0(%r13,%rbx,1),%edi
add %ebp,%edi
mov %edi,(%rax)
movslq %edi,%rdi
shl $0x2,%rdi
callq 1110 <malloc@plt>
test %rax,%rax
je 1b33 <func0+0x3a3>
test %r13d,%r13d
mov %rax,%r12
mov 0x8(%rsp),%r8
setg %dl
test %ebx,%ebx
setg %r10b
test %ebp,%ebp
mov %edx,%edi
setg %al
mov %r10d,%esi
test %al,%r10b
je 18f0 <func0+0x160>
test %dl,%dl
je 18f0 <func0+0x160>
mov 0x10(%rsp),%r11d
mov $0x1,%edx
xor %ebp,%ebp
xor %r9d,%r9d
xor %ecx,%ecx
jmp 18ad <func0+0x11d>
nopw 0x0(%rax,%rax,1)
cmp %edi,%esi
jg 18e0 <func0+0x150>
mov %esi,-0x4(%r12,%rdx,4)
add $0x1,%r9d
nopl (%rax)
cmp %r13d,%ecx
setl %dil
cmp 0x4(%rsp),%r9d
setl %sil
mov %edi,%r10d
and %esi,%r10d
cmp %r11d,%ebp
setl %al
add $0x1,%rdx
test %al,%al
je 1900 <func0+0x170>
test %r10b,%r10b
je 1980 <func0+0x1f0>
movslq %ecx,%rax
movslq %r9d,%rsi
movslq %ebp,%rdi
mov %edx,%ebx
mov (%r15,%rax,4),%eax
mov (%r14,%rsi,4),%esi
mov (%r8,%rdi,4),%edi
cmp %esi,%eax
jg 1870 <func0+0xe0>
cmp %edi,%eax
jg 18e0 <func0+0x150>
mov %eax,-0x4(%r12,%rdx,4)
add $0x1,%ecx
jmp 1880 <func0+0xf0>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,-0x4(%r12,%rdx,4)
add $0x1,%ebp
jmp 1880 <func0+0xf0>
nopw 0x0(%rax,%rax,1)
and %edx,%r10d
xor %ebx,%ebx
xor %ebp,%ebp
xor %r9d,%r9d
xor %ecx,%ecx
nopl 0x0(%rax)
test %r10b,%r10b
je 1980 <func0+0x1f0>
add $0x1,%ebx
movslq %ecx,%r10
movslq %ebx,%rdx
xchg %ax,%ax
movslq %r9d,%r11
mov (%r15,%r10,4),%edi
mov (%r14,%r11,4),%esi
cmp %edi,%esi
jl 1956 <func0+0x1c6>
add $0x1,%ecx
mov %edi,-0x4(%r12,%rdx,4)
mov %edx,%ebx
cmp %ecx,%r13d
setg %dil
cmp %r9d,0x4(%rsp)
setg %sil
add $0x1,%rdx
test %sil,%sil
je 1980 <func0+0x1f0>
test %dil,%dil
je 1980 <func0+0x1f0>
movslq %ecx,%r10
mov (%r14,%r11,4),%esi
mov (%r15,%r10,4),%edi
cmp %edi,%esi
jge 191f <func0+0x18f>
add $0x1,%r9d
cmp %ecx,%r13d
mov %esi,-0x4(%r12,%rdx,4)
mov %edx,%ebx
setg %dil
cmp %r9d,0x4(%rsp)
setg %sil
add $0x1,%rdx
test %sil,%sil
je 1980 <func0+0x1f0>
test %dil,%dil
jne 1910 <func0+0x180>
test %al,%al
je 19f4 <func0+0x264>
test %dil,%dil
je 19f4 <func0+0x264>
add $0x1,%ebx
movslq %ecx,%r10
movslq %ebx,%rdx
nopw 0x0(%rax,%rax,1)
movslq %ebp,%rdi
mov (%r15,%r10,4),%r11d
mov (%r8,%rdi,4),%eax
cmp %eax,%r11d
jg 19d6 <func0+0x246>
add $0x1,%ecx
cmp %ebp,0x10(%rsp)
mov %r11d,-0x4(%r12,%rdx,4)
mov %edx,%ebx
setg %al
add $0x1,%rdx
cmp %ecx,%r13d
jle 19f4 <func0+0x264>
test %al,%al
je 19f4 <func0+0x264>
movslq %ecx,%r10
mov (%r8,%rdi,4),%eax
mov (%r15,%r10,4),%r11d
cmp %eax,%r11d
jle 19a8 <func0+0x218>
add $0x1,%ebp
cmp %ebp,0x10(%rsp)
mov %eax,-0x4(%r12,%rdx,4)
mov %edx,%ebx
setg %al
add $0x1,%rdx
cmp %ecx,%r13d
jle 19f4 <func0+0x264>
test %al,%al
jne 1998 <func0+0x208>
test %sil,%sil
je 1a65 <func0+0x2d5>
test %al,%al
je 1a65 <func0+0x2d5>
add $0x1,%ebx
movslq %r9d,%r11
movslq %ebx,%rax
nopw %cs:0x0(%rax,%rax,1)
movslq %ebp,%rdi
mov (%r14,%r11,4),%esi
mov (%r8,%rdi,4),%edx
cmp %edx,%esi
jg 1a4a <func0+0x2ba>
mov %esi,-0x4(%r12,%rax,4)
mov %eax,%ebx
add $0x1,%r9d
add $0x1,%rax
cmp %r9d,0x4(%rsp)
jle 1a65 <func0+0x2d5>
cmp %ebp,0x10(%rsp)
jle 1a65 <func0+0x2d5>
movslq %r9d,%r11
mov (%r8,%rdi,4),%edx
mov (%r14,%r11,4),%esi
cmp %edx,%esi
jle 1a1f <func0+0x28f>
mov %edx,-0x4(%r12,%rax,4)
mov %eax,%ebx
add $0x1,%ebp
add $0x1,%rax
cmp %r9d,0x4(%rsp)
jle 1a65 <func0+0x2d5>
cmp %ebp,0x10(%rsp)
jg 1a10 <func0+0x280>
cmp %ecx,%r13d
jle 1aad <func0+0x31d>
movslq %ebx,%rax
mov %r8,0x18(%rsp)
lea (%r12,%rax,4),%rdi
lea -0x1(%r13),%eax
mov %r9d,0x14(%rsp)
sub %ecx,%eax
mov %ecx,0x8(%rsp)
lea 0x4(,%rax,4),%rdx
movslq %ecx,%rax
lea (%r15,%rax,4),%rsi
callq 1100 <memcpy@plt>
mov 0x8(%rsp),%ecx
mov 0x18(%rsp),%r8
mov 0x14(%rsp),%r9d
sub %ecx,%r13d
add %r13d,%ebx
mov 0x4(%rsp),%r15d
cmp %r9d,%r15d
jle 1af5 <func0+0x365>
movslq %ebx,%rax
mov %r8,0x8(%rsp)
lea (%r12,%rax,4),%rdi
lea -0x1(%r15),%eax
mov %r9d,0x4(%rsp)
sub %r9d,%eax
lea 0x4(,%rax,4),%rdx
movslq %r9d,%rax
lea (%r14,%rax,4),%rsi
callq 1100 <memcpy@plt>
mov 0x4(%rsp),%r9d
mov %r15d,%ecx
mov 0x8(%rsp),%r8
sub %r9d,%ecx
add %ecx,%ebx
mov 0x10(%rsp),%eax
cmp %ebp,%eax
jle 1b21 <func0+0x391>
sub $0x1,%eax
movslq %ebx,%rbx
mov %eax,%r9d
lea (%r12,%rbx,4),%rdi
sub %ebp,%r9d
movslq %ebp,%rbp
lea 0x4(,%r9,4),%rdx
lea (%r8,%rbp,4),%rsi
callq 1100 <memcpy@plt>
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
lea 0x4ca(%rip),%rdi
callq 1120 <perror@plt>
mov $0x1,%edi
callq 1130 <exit@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
movsxd rsi, esi; nmemb
mov r15d, ecx
push r14
mov r14, rdx
push r13
push r12
push rbp
push rbx
lea rbx, compare
mov rcx, rbx; compar
sub rsp, 38h
mov [rsp+68h+var_60], rdx
mov edx, 4; size
mov dword ptr [rsp+68h+var_58], r9d
mov [rsp+68h+base], r8
mov dword ptr [rsp+68h+var_50], esi
mov [rsp+68h+var_40], rdi
call _qsort
movsxd rsi, r15d; nmemb
mov rcx, rbx; compar
mov edx, 4; size
mov rdi, r14; base
call _qsort
mov rdi, [rsp+68h+base]; base
movsxd rsi, dword ptr [rsp+68h+var_58]; nmemb
mov rcx, rbx; compar
mov edx, 4; size
call _qsort
mov r10d, dword ptr [rsp+68h+var_50]
mov r9d, dword ptr [rsp+68h+var_58]
mov rax, [rsp+68h+arg_0]
lea edi, [r10+r15]
add edi, r9d
mov [rax], edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
test rax, rax
jz func0_cold
mov r10d, dword ptr [rsp+68h+var_50]
mov r9d, dword ptr [rsp+68h+var_58]
mov r14, rax
mov r8, [rsp+68h+base]
mov r11, [rsp+68h+var_40]
test r10d, r10d
setnle sil
test r15d, r15d
setnle dil
test r9d, r9d
mov ecx, esi
setnle al
mov edx, edi
test dil, al
jz loc_1860
test sil, sil
jz loc_1860
mov ebx, 1
xor ebp, ebp
xor r13d, r13d
xor r12d, r12d
jmp short loc_182B
loc_17F0:
cmp eax, ecx
jl short loc_1858
add r13d, 1
mov eax, ecx
nop word ptr [rax+rax+00h]
loc_1800:
cmp r12d, r10d
mov [r14+rbx*4-4], eax
lea rdi, [rbx+1]
setl cl
cmp r13d, r15d
setl dl
mov esi, edx
and esi, ecx
cmp ebp, r9d
setl al
test al, al
jz short loc_1870
test sil, sil
jz short loc_1870
mov rbx, rdi
loc_182B:
movsxd rax, r12d
mov rdi, [rsp+68h+var_60]
mov edx, [r11+rax*4]
movsxd rax, r13d
mov ecx, [rdi+rax*4]
movsxd rax, ebp
mov eax, [r8+rax*4]
cmp ecx, edx
jl short loc_17F0
cmp eax, edx
jl short loc_1858
add r12d, 1
mov eax, edx
jmp short loc_1800
loc_1858:
add ebp, 1
jmp short loc_1800
loc_1860:
and esi, edi
xor ebx, ebx
xor ebp, ebp
xor r13d, r13d
xor r12d, r12d
nop dword ptr [rax+00h]
loc_1870:
test sil, sil
jz loc_1901
add ebx, 1
mov dword ptr [rsp+68h+var_58], ebp
movsxd rdi, r12d
mov rbp, [rsp+68h+var_60]
mov byte ptr [rsp+68h+var_50], al
movsxd rbx, ebx
movsxd rsi, r13d
jmp short loc_18BF
loc_1898:
add r12d, 1
mov [r14+rbx*4-4], edx
lea rax, [rbx+1]
cmp r10d, r12d
setnle cl
cmp r15d, r13d
setnle dl
test dl, dl
jz short loc_18F8
test cl, cl
jz short loc_18F8
movsxd rdi, r12d
loc_18BC:
mov rbx, rax
loc_18BF:
mov edx, [r11+rdi*4]
mov eax, [rbp+rsi*4+0]
cmp eax, edx
jge short loc_1898
add r13d, 1
cmp r10d, r12d
mov [r14+rbx*4-4], eax
lea rax, [rbx+1]
setnle cl
cmp r15d, r13d
setnle dl
test cl, cl
jz short loc_18F8
test dl, dl
jz short loc_18F8
movsxd rsi, r13d
jmp short loc_18BC
loc_18F8:
mov ebp, dword ptr [rsp+68h+var_58]
movzx eax, byte ptr [rsp+68h+var_50]
loc_1901:
test al, al
jz short loc_1970
test cl, cl
jz short loc_1970
add ebx, 1
movsxd rdi, r12d
movsxd rcx, ebp
movsxd rbx, ebx
jmp short loc_1942
loc_1920:
add r12d, 1
cmp ebp, r9d
mov [r14+rbx*4-4], esi
lea rsi, [rbx+1]
setl al
cmp r10d, r12d
jle short loc_1970
test al, al
jz short loc_1970
movsxd rdi, r12d
loc_193F:
mov rbx, rsi
loc_1942:
mov esi, [r11+rdi*4]
mov eax, [r8+rcx*4]
cmp eax, esi
jge short loc_1920
add ebp, 1
mov [r14+rbx*4-4], eax
lea rsi, [rbx+1]
cmp r9d, ebp
setnle al
cmp r10d, r12d
jle short loc_1970
test al, al
jz short loc_1970
movsxd rcx, ebp
jmp short loc_193F
loc_1970:
test dl, dl
jz short loc_19D8
test al, al
jz short loc_19D8
add ebx, 1
mov rdi, [rsp+68h+var_60]
movsxd rsi, r13d
movsxd rcx, ebp
movsxd rbx, ebx
jmp short loc_19AD
loc_1990:
add r13d, 1
mov [r14+rbx*4-4], edx
lea rax, [rbx+1]
cmp r15d, r13d
jle short loc_19D8
cmp r9d, ebp
jle short loc_19D8
movsxd rsi, r13d
loc_19AA:
mov rbx, rax
loc_19AD:
mov edx, [rdi+rsi*4]
mov eax, [r8+rcx*4]
cmp eax, edx
jge short loc_1990
mov [r14+rbx*4-4], eax
add ebp, 1
lea rax, [rbx+1]
cmp r15d, r13d
jle short loc_19D8
cmp r9d, ebp
jle short loc_19D8
movsxd rcx, ebp
jmp short loc_19AA
loc_19D8:
cmp r10d, r12d
jle short loc_1A23
movsxd rax, ebx
mov dword ptr [rsp+68h+base], r9d
lea rdi, [r14+rax*4]; dest
lea eax, [r10-1]
mov [rsp+68h+var_50], r8
sub eax, r12d
mov dword ptr [rsp+68h+var_58], r10d
lea rdx, ds:4[rax*4]; n
movsxd rax, r12d
lea rsi, [r11+rax*4]; src
call _memcpy
mov r10d, dword ptr [rsp+68h+var_58]
mov r9d, dword ptr [rsp+68h+base]
mov r8, [rsp+68h+var_50]
sub r10d, r12d
add ebx, r10d
loc_1A23:
cmp r15d, r13d
jle short loc_1A69
movsxd rax, ebx
mov rcx, [rsp+68h+var_60]
mov dword ptr [rsp+68h+var_50], r9d
lea rdi, [r14+rax*4]; dest
lea eax, [r15-1]
mov [rsp+68h+var_58], r8
sub r15d, r13d
sub eax, r13d
add ebx, r15d
lea rdx, ds:4[rax*4]; n
movsxd rax, r13d
lea rsi, [rcx+rax*4]; src
call _memcpy
mov r9d, dword ptr [rsp+68h+var_50]
mov r8, [rsp+68h+var_58]
loc_1A69:
cmp r9d, ebp
jle short loc_1A90
sub r9d, 1
movsxd rbx, ebx
sub r9d, ebp
movsxd rbp, ebp
lea rdi, [r14+rbx*4]; dest
lea rdx, ds:4[r9*4]; n
lea rsi, [r8+rbp*4]; src
call _memcpy
loc_1A90:
add rsp, 38h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _DWORD * func0(char *a1, int a2, char *a3, int a4, char *a5, int a6, _DWORD *a7)
{
int v9; // edi
_DWORD *v10; // rax
int v12; // r9d
_DWORD *v13; // r14
char *v14; // r8
bool v15; // cl
bool v16; // al
bool v17; // dl
long long i; // rbx
int v19; // ebp
int v20; // r13d
int v21; // r12d
int v22; // eax
bool v23; // si
int v24; // edx
int v25; // ecx
long long v26; // rdi
long long v27; // rsi
long long v28; // rax
int v29; // edx
int v30; // eax
long long v31; // rdi
long long v32; // rcx
long long v33; // rsi
int v34; // esi
int v35; // eax
long long v36; // rsi
long long v37; // rcx
long long v38; // rax
int v39; // edx
int v40; // eax
char *v41; // rdi
int v45; // [rsp+10h] [rbp-58h]
char *v46; // [rsp+10h] [rbp-58h]
bool v48; // [rsp+18h] [rbp-50h]
char *v49; // [rsp+18h] [rbp-50h]
int v50; // [rsp+18h] [rbp-50h]
int basea; // [rsp+20h] [rbp-48h]
qsort(a1, a2, 4uLL, compare);
qsort(a3, a4, 4uLL, compare);
qsort(a5, a6, 4uLL, compare);
v9 = a6 + a2 + a4;
*a7 = v9;
v10 = malloc(4LL * v9);
if ( !v10 )
func0_cold();
v12 = a6;
v13 = v10;
v14 = a5;
v15 = a2 > 0;
v16 = a6 > 0;
v17 = a4 > 0;
if ( a6 > 0 && a4 > 0 && a2 > 0 )
{
i = 1LL;
v19 = 0;
v20 = 0;
v21 = 0;
while ( 1 )
{
v24 = *(_DWORD *)&a1[4 * v21];
v25 = *(_DWORD *)&a3[4 * v20];
v22 = *(_DWORD *)&a5[4 * v19];
if ( v25 < v24 )
{
if ( v22 < v25 )
goto LABEL_13;
++v20;
v22 = v25;
}
else
{
if ( v22 < v24 )
{
LABEL_13:
++v19;
goto LABEL_7;
}
++v21;
v22 = v24;
}
LABEL_7:
v13[i - 1] = v22;
v15 = v21 < a2;
v17 = v20 < a4;
v23 = v21 < a2 && v20 < a4;
v16 = v19 < a6;
if ( v19 >= a6 || !v23 )
goto LABEL_15;
++i;
}
}
v23 = a4 > 0 && a2 > 0;
LODWORD(i) = 0;
v19 = 0;
v20 = 0;
v21 = 0;
LABEL_15:
if ( v23 )
{
v26 = v21;
v48 = v16;
i = (int)i + 1;
v27 = v20;
while ( 1 )
{
v29 = *(_DWORD *)&a1[4 * v26];
v30 = *(_DWORD *)&a3[4 * v27];
if ( v30 >= v29 )
{
++v21;
v13[i - 1] = v29;
v28 = i + 1;
v15 = a2 > v21;
v17 = a4 > v20;
if ( a4 <= v20 || a2 <= v21 )
{
LABEL_25:
v16 = v48;
break;
}
v26 = v21;
}
else
{
++v20;
v13[i - 1] = v30;
v28 = i + 1;
v15 = a2 > v21;
v17 = a4 > v20;
if ( a2 <= v21 || a4 <= v20 )
goto LABEL_25;
v27 = v20;
}
i = v28;
}
}
if ( v16 && v15 )
{
v31 = v21;
v32 = v19;
for ( i = (int)i + 1; ; i = v33 )
{
v34 = *(_DWORD *)&a1[4 * v31];
v35 = *(_DWORD *)&a5[4 * v32];
if ( v35 >= v34 )
{
++v21;
v13[i - 1] = v34;
v33 = i + 1;
v16 = v19 < a6;
if ( a2 <= v21 || v19 >= a6 )
break;
v31 = v21;
}
else
{
++v19;
v13[i - 1] = v35;
v33 = i + 1;
v16 = a6 > v19;
if ( a2 <= v21 || a6 <= v19 )
break;
v32 = v19;
}
}
}
if ( v17 && v16 )
{
v36 = v20;
v37 = v19;
for ( i = (int)i + 1; ; i = v38 )
{
v39 = *(_DWORD *)&a3[4 * v36];
v40 = *(_DWORD *)&a5[4 * v37];
if ( v40 >= v39 )
{
++v20;
v13[i - 1] = v39;
v38 = i + 1;
if ( a4 <= v20 || a6 <= v19 )
break;
v36 = v20;
}
else
{
v13[i - 1] = v40;
++v19;
v38 = i + 1;
if ( a4 <= v20 || a6 <= v19 )
break;
v37 = v19;
}
}
}
if ( a2 > v21 )
{
basea = a6;
v49 = v14;
v45 = a2;
memcpy(&v13[(int)i], &a1[4 * v21], 4LL * (unsigned int)(a2 - 1 - v21) + 4);
v12 = basea;
v14 = v49;
LODWORD(i) = v45 - v21 + i;
}
if ( a4 > v20 )
{
v50 = v12;
v41 = (char *)&v13[(int)i];
v46 = v14;
LODWORD(i) = a4 - v20 + i;
memcpy(v41, &a3[4 * v20], 4LL * (unsigned int)(a4 - 1 - v20) + 4);
v12 = v50;
v14 = v46;
}
if ( v12 > v19 )
memcpy(&v13[(int)i], &v14[4 * v19], 4LL * (unsigned int)(v12 - 1 - v19) + 4);
return v13;
} | func0:
ENDBR64
PUSH R15
MOVSXD RSI,ESI
MOV R15D,ECX
PUSH R14
MOV R14,RDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x1016e0]
MOV RCX,RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x8],RDX
MOV EDX,0x4
MOV dword ptr [RSP + 0x10],R9D
MOV qword ptr [RSP + 0x20],R8
MOV dword ptr [RSP + 0x18],ESI
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001010d0
MOVSXD RSI,R15D
MOV RCX,RBX
MOV EDX,0x4
MOV RDI,R14
CALL 0x001010d0
MOV RDI,qword ptr [RSP + 0x20]
MOVSXD RSI,dword ptr [RSP + 0x10]
MOV RCX,RBX
MOV EDX,0x4
CALL 0x001010d0
MOV R10D,dword ptr [RSP + 0x18]
MOV R9D,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x70]
LEA EDI,[R10 + R15*0x1]
ADD EDI,R9D
MOV dword ptr [RAX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101140
MOV R10D,dword ptr [RSP + 0x18]
MOV R9D,dword ptr [RSP + 0x10]
MOV R14,RAX
MOV R8,qword ptr [RSP + 0x20]
MOV R11,qword ptr [RSP + 0x28]
TEST R10D,R10D
SETG SIL
TEST R15D,R15D
SETG DIL
TEST R9D,R9D
MOV ECX,ESI
SETG AL
MOV EDX,EDI
TEST DIL,AL
JZ 0x00101860
TEST SIL,SIL
JZ 0x00101860
MOV EBX,0x1
XOR EBP,EBP
XOR R13D,R13D
XOR R12D,R12D
JMP 0x0010182b
LAB_001017f0:
CMP EAX,ECX
JL 0x00101858
ADD R13D,0x1
MOV EAX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101800:
CMP R12D,R10D
MOV dword ptr [R14 + RBX*0x4 + -0x4],EAX
LEA RDI,[RBX + 0x1]
SETL CL
CMP R13D,R15D
SETL DL
MOV ESI,EDX
AND ESI,ECX
CMP EBP,R9D
SETL AL
TEST AL,AL
JZ 0x00101870
TEST SIL,SIL
JZ 0x00101870
MOV RBX,RDI
LAB_0010182b:
MOVSXD RAX,R12D
MOV RDI,qword ptr [RSP + 0x8]
MOV EDX,dword ptr [R11 + RAX*0x4]
MOVSXD RAX,R13D
MOV ECX,dword ptr [RDI + RAX*0x4]
MOVSXD RAX,EBP
MOV EAX,dword ptr [R8 + RAX*0x4]
CMP ECX,EDX
JL 0x001017f0
CMP EAX,EDX
JL 0x00101858
ADD R12D,0x1
MOV EAX,EDX
JMP 0x00101800
LAB_00101858:
ADD EBP,0x1
JMP 0x00101800
LAB_00101860:
AND ESI,EDI
XOR EBX,EBX
XOR EBP,EBP
XOR R13D,R13D
XOR R12D,R12D
NOP dword ptr [RAX]
LAB_00101870:
TEST SIL,SIL
JZ 0x00101901
ADD EBX,0x1
MOV dword ptr [RSP + 0x10],EBP
MOVSXD RDI,R12D
MOV RBP,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x18],AL
MOVSXD RBX,EBX
MOVSXD RSI,R13D
JMP 0x001018bf
LAB_00101898:
ADD R12D,0x1
MOV dword ptr [R14 + RBX*0x4 + -0x4],EDX
LEA RAX,[RBX + 0x1]
CMP R10D,R12D
SETG CL
CMP R15D,R13D
SETG DL
TEST DL,DL
JZ 0x001018f8
TEST CL,CL
JZ 0x001018f8
MOVSXD RDI,R12D
LAB_001018bc:
MOV RBX,RAX
LAB_001018bf:
MOV EDX,dword ptr [R11 + RDI*0x4]
MOV EAX,dword ptr [RBP + RSI*0x4]
CMP EAX,EDX
JGE 0x00101898
ADD R13D,0x1
CMP R10D,R12D
MOV dword ptr [R14 + RBX*0x4 + -0x4],EAX
LEA RAX,[RBX + 0x1]
SETG CL
CMP R15D,R13D
SETG DL
TEST CL,CL
JZ 0x001018f8
TEST DL,DL
JZ 0x001018f8
MOVSXD RSI,R13D
JMP 0x001018bc
LAB_001018f8:
MOV EBP,dword ptr [RSP + 0x10]
MOVZX EAX,byte ptr [RSP + 0x18]
LAB_00101901:
TEST AL,AL
JZ 0x00101970
TEST CL,CL
JZ 0x00101970
ADD EBX,0x1
MOVSXD RDI,R12D
MOVSXD RCX,EBP
MOVSXD RBX,EBX
JMP 0x00101942
LAB_00101920:
ADD R12D,0x1
CMP EBP,R9D
MOV dword ptr [R14 + RBX*0x4 + -0x4],ESI
LEA RSI,[RBX + 0x1]
SETL AL
CMP R10D,R12D
JLE 0x00101970
TEST AL,AL
JZ 0x00101970
MOVSXD RDI,R12D
LAB_0010193f:
MOV RBX,RSI
LAB_00101942:
MOV ESI,dword ptr [R11 + RDI*0x4]
MOV EAX,dword ptr [R8 + RCX*0x4]
CMP EAX,ESI
JGE 0x00101920
ADD EBP,0x1
MOV dword ptr [R14 + RBX*0x4 + -0x4],EAX
LEA RSI,[RBX + 0x1]
CMP R9D,EBP
SETG AL
CMP R10D,R12D
JLE 0x00101970
TEST AL,AL
JZ 0x00101970
MOVSXD RCX,EBP
JMP 0x0010193f
LAB_00101970:
TEST DL,DL
JZ 0x001019d8
TEST AL,AL
JZ 0x001019d8
ADD EBX,0x1
MOV RDI,qword ptr [RSP + 0x8]
MOVSXD RSI,R13D
MOVSXD RCX,EBP
MOVSXD RBX,EBX
JMP 0x001019ad
LAB_00101990:
ADD R13D,0x1
MOV dword ptr [R14 + RBX*0x4 + -0x4],EDX
LEA RAX,[RBX + 0x1]
CMP R15D,R13D
JLE 0x001019d8
CMP R9D,EBP
JLE 0x001019d8
MOVSXD RSI,R13D
LAB_001019aa:
MOV RBX,RAX
LAB_001019ad:
MOV EDX,dword ptr [RDI + RSI*0x4]
MOV EAX,dword ptr [R8 + RCX*0x4]
CMP EAX,EDX
JGE 0x00101990
MOV dword ptr [R14 + RBX*0x4 + -0x4],EAX
ADD EBP,0x1
LEA RAX,[RBX + 0x1]
CMP R15D,R13D
JLE 0x001019d8
CMP R9D,EBP
JLE 0x001019d8
MOVSXD RCX,EBP
JMP 0x001019aa
LAB_001019d8:
CMP R10D,R12D
JLE 0x00101a23
MOVSXD RAX,EBX
MOV dword ptr [RSP + 0x20],R9D
LEA RDI,[R14 + RAX*0x4]
LEA EAX,[R10 + -0x1]
MOV qword ptr [RSP + 0x18],R8
SUB EAX,R12D
MOV dword ptr [RSP + 0x10],R10D
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,R12D
LEA RSI,[R11 + RAX*0x4]
CALL 0x00101100
MOV R10D,dword ptr [RSP + 0x10]
MOV R9D,dword ptr [RSP + 0x20]
MOV R8,qword ptr [RSP + 0x18]
SUB R10D,R12D
ADD EBX,R10D
LAB_00101a23:
CMP R15D,R13D
JLE 0x00101a69
MOVSXD RAX,EBX
MOV RCX,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x18],R9D
LEA RDI,[R14 + RAX*0x4]
LEA EAX,[R15 + -0x1]
MOV qword ptr [RSP + 0x10],R8
SUB R15D,R13D
SUB EAX,R13D
ADD EBX,R15D
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,R13D
LEA RSI,[RCX + RAX*0x4]
CALL 0x00101100
MOV R9D,dword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x10]
LAB_00101a69:
CMP R9D,EBP
JLE 0x00101a90
SUB R9D,0x1
MOVSXD RBX,EBX
SUB R9D,EBP
MOVSXD RBP,EBP
LEA RDI,[R14 + RBX*0x4]
LEA RDX,[0x4 + R9*0x4]
LEA RSI,[R8 + RBP*0x4]
CALL 0x00101100
LAB_00101a90:
ADD RSP,0x38
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int iVar1;
bool bVar2;
bool bVar3;
bool bVar4;
int iVar5;
void *pvVar6;
int iVar7;
long lVar8;
bool bVar9;
long lVar10;
int iVar11;
long lVar12;
int iVar13;
int iVar14;
qsort(param_1,(long)param_2,4,compare);
qsort(param_3,(long)param_4,4,compare);
qsort(param_5,(long)param_6,4,compare);
iVar11 = param_2 + param_4 + param_6;
*param_7 = iVar11;
pvVar6 = malloc((long)iVar11 << 2);
if (pvVar6 == (void *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
bVar2 = 0 < param_2;
bVar3 = 0 < param_4;
bVar4 = 0 < param_6;
if ((bVar3 && bVar4) && (bVar2)) {
iVar11 = 0;
iVar14 = 0;
iVar13 = 0;
lVar10 = 1;
do {
lVar8 = lVar10;
iVar7 = *(int *)((long)param_1 + (long)iVar13 * 4);
iVar5 = *(int *)((long)param_3 + (long)iVar14 * 4);
iVar1 = *(int *)((long)param_5 + (long)iVar11 * 4);
if (iVar5 < iVar7) {
if (iVar1 < iVar5) goto LAB_00101858;
iVar14 = iVar14 + 1;
}
else if (iVar1 < iVar7) {
LAB_00101858:
iVar11 = iVar11 + 1;
iVar5 = iVar1;
}
else {
iVar13 = iVar13 + 1;
iVar5 = iVar7;
}
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar5;
bVar2 = iVar13 < param_2;
bVar3 = iVar14 < param_4;
bVar9 = bVar3 && bVar2;
bVar4 = iVar11 < param_6;
} while ((bVar4) && (lVar10 = lVar8 + 1, bVar3 && bVar2));
}
else {
bVar9 = bVar2 && bVar3;
lVar8 = 0;
iVar11 = 0;
iVar14 = 0;
iVar13 = 0;
}
if (bVar9) {
lVar12 = (long)iVar13;
lVar8 = (long)((int)lVar8 + 1);
lVar10 = (long)iVar14;
do {
iVar7 = *(int *)((long)param_1 + lVar12 * 4);
iVar5 = *(int *)((long)param_3 + lVar10 * 4);
if (iVar5 < iVar7) {
iVar14 = iVar14 + 1;
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar5;
bVar2 = iVar13 < param_2;
bVar3 = iVar14 < param_4;
if ((param_2 <= iVar13) || (!bVar3)) break;
lVar10 = (long)iVar14;
}
else {
iVar13 = iVar13 + 1;
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar7;
bVar2 = iVar13 < param_2;
bVar3 = iVar14 < param_4;
if ((!bVar3) || (param_2 <= iVar13)) break;
lVar12 = (long)iVar13;
}
lVar8 = lVar8 + 1;
} while( true );
}
if ((bVar4) && (bVar2)) {
lVar12 = (long)iVar13;
lVar10 = (long)iVar11;
lVar8 = (long)((int)lVar8 + 1);
do {
iVar7 = *(int *)((long)param_1 + lVar12 * 4);
iVar5 = *(int *)((long)param_5 + lVar10 * 4);
if (iVar5 < iVar7) {
iVar11 = iVar11 + 1;
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar5;
bVar4 = iVar11 < param_6;
if ((param_2 <= iVar13) || (param_6 <= iVar11)) break;
lVar10 = (long)iVar11;
}
else {
iVar13 = iVar13 + 1;
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar7;
bVar4 = iVar11 < param_6;
if ((param_2 <= iVar13) || (!bVar4)) break;
lVar12 = (long)iVar13;
}
lVar8 = lVar8 + 1;
} while( true );
}
if ((bVar3) && (bVar4)) {
lVar12 = (long)iVar14;
lVar10 = (long)iVar11;
lVar8 = (long)((int)lVar8 + 1);
do {
iVar7 = *(int *)((long)param_3 + lVar12 * 4);
iVar5 = *(int *)((long)param_5 + lVar10 * 4);
if (iVar5 < iVar7) {
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar5;
iVar11 = iVar11 + 1;
if ((param_4 <= iVar14) || (param_6 <= iVar11)) break;
lVar10 = (long)iVar11;
}
else {
iVar14 = iVar14 + 1;
*(int *)((long)pvVar6 + lVar8 * 4 + -4) = iVar7;
if ((param_4 <= iVar14) || (param_6 <= iVar11)) break;
lVar12 = (long)iVar14;
}
lVar8 = lVar8 + 1;
} while( true );
}
iVar7 = (int)lVar8;
if (iVar13 < param_2) {
memcpy((void *)((long)pvVar6 + (long)iVar7 * 4),(void *)((long)param_1 + (long)iVar13 * 4),
(ulong)(uint)((param_2 + -1) - iVar13) * 4 + 4);
iVar7 = iVar7 + (param_2 - iVar13);
}
if (iVar14 < param_4) {
lVar10 = (long)iVar7;
iVar7 = iVar7 + (param_4 - iVar14);
memcpy((void *)((long)pvVar6 + lVar10 * 4),(void *)((long)param_3 + (long)iVar14 * 4),
(ulong)(uint)((param_4 + -1) - iVar14) * 4 + 4);
}
if (iVar11 < param_6) {
memcpy((void *)((long)pvVar6 + (long)iVar7 * 4),(void *)((long)param_5 + (long)iVar11 * 4),
(ulong)(uint)((param_6 + -1) - iVar11) * 4 + 4);
}
return pvVar6;
} |
4,328 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1184 <func0+0x3b>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x31,%al
jne 1180 <func0+0x37>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1168 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1184
loc_1168:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 31h ; '1'
jnz short loc_1180
add [rbp+var_8], 1
loc_1180:
add [rbp+var_4], 1
loc_1184:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1168
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == 49 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101184
LAB_00101168:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x31
JNZ 0x00101180
ADD dword ptr [RBP + -0x8],0x1
LAB_00101180:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101168
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == '1') {
local_10 = local_10 + 1;
}
}
return local_10;
} |
4,329 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1178 <func0+0x2f>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x1(%rdi,%rdx,1),%rsi
mov $0x0,%edx
cmpb $0x31,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x1,%rax
cmp %rsi,%rax
jne 1161 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1175 <func0+0x2c>
| func0:
endbr64
test esi, esi
jle short loc_1178
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx+1]
mov edx, 0
loc_1161:
cmp byte ptr [rax], 31h ; '1'
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1161
loc_1175:
mov eax, edx
retn
loc_1178:
mov edx, 0
jmp short loc_1175 | long long func0(_BYTE *a1, int a2)
{
_BYTE *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 += *v2++ == 49;
while ( v2 != (_BYTE *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x1 + 0x1]
MOV EDX,0x0
LAB_00101161:
CMP byte ptr [RAX],0x31
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101161
LAB_00101175:
MOV EAX,EDX
RET
LAB_00101178:
MOV EDX,0x0
JMP 0x00101175 | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 == '1');
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
}
return iVar2;
} |
4,330 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1280 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x1(%rdi,%rax,1),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
cmpb $0x31,(%rdi)
sete %dl
add $0x1,%rdi
add %edx,%eax
cmp %rcx,%rdi
jne 1268 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1280
lea eax, [rsi-1]
lea rcx, [rdi+rax+1]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1268:
xor edx, edx
cmp byte ptr [rdi], 31h ; '1'
setz dl
add rdi, 1
add eax, edx
cmp rdi, rcx
jnz short loc_1268
retn
loc_1280:
xor eax, eax
retn | long long func0(_BYTE *a1, int a2)
{
long long v2; // rcx
long long result; // rax
BOOL v4; // edx
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v4 = *a1++ == 49;
result = (unsigned int)(v4 + result);
}
while ( a1 != (_BYTE *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101280
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x1 + 0x1]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101268:
XOR EDX,EDX
CMP byte ptr [RDI],0x31
SETZ DL
ADD RDI,0x1
ADD EAX,EDX
CMP RDI,RCX
JNZ 0x00101268
RET
LAB_00101280:
XOR EAX,EAX
RET | int func0(char *param_1,int param_2)
{
char *pcVar1;
char cVar2;
int iVar3;
if (0 < param_2) {
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
cVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 + (uint)(cVar2 == '1');
} while (param_1 != pcVar1);
return iVar3;
}
return 0;
} |
4,331 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1388 <func0+0x248>
lea -0x1(%rsi),%eax
cmp $0xe,%eax
jbe 138b <func0+0x24b>
mov %esi,%edx
pxor %xmm1,%xmm1
pxor %xmm5,%xmm5
mov %rdi,%rax
shr $0x4,%edx
movdqa 0xea0(%rip),%xmm7
movdqa 0xea8(%rip),%xmm6
pxor %xmm4,%xmm4
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm5,%xmm3
add $0x10,%rax
pcmpeqb %xmm7,%xmm0
pand %xmm6,%xmm0
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
punpckhbw %xmm3,%xmm0
movdqa %xmm4,%xmm3
pcmpgtw %xmm2,%xmm3
movdqa %xmm2,%xmm8
punpcklwd %xmm3,%xmm8
punpckhwd %xmm3,%xmm2
movdqa %xmm0,%xmm3
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm4,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm3
punpckhwd %xmm2,%xmm0
paddd %xmm3,%xmm1
paddd %xmm0,%xmm1
cmp %rdx,%rax
jne 1188 <func0+0x48>
movdqa %xmm1,%xmm0
mov %esi,%edx
psrldq $0x8,%xmm0
and $0xfffffff0,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0xf,%sil
je 1394 <func0+0x254>
movslq %edx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %esi,%ecx
jge 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x3(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x4(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x5(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x6(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x7(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x8(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0x9(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0xa(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0xb(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0xc(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
lea 0xd(%rdx),%ecx
cmp %ecx,%esi
jle 138a <func0+0x24a>
movslq %ecx,%rcx
cmpb $0x31,(%rdi,%rcx,1)
sete %cl
add $0xe,%edx
movzbl %cl,%ecx
add %ecx,%eax
cmp %edx,%esi
jle 138a <func0+0x24a>
movslq %edx,%rdx
cmpb $0x31,(%rdi,%rdx,1)
sete %dl
movzbl %dl,%edx
add %edx,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
xor %edx,%edx
xor %eax,%eax
jmpq 1219 <func0+0xd9>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov rdx, rdi
mov ecx, esi
test esi, esi
jle loc_1360
lea eax, [rsi-1]
cmp eax, 0Eh
jbe loc_1363
shr esi, 4
pxor xmm1, xmm1
pxor xmm5, xmm5
mov rax, rdi
shl rsi, 4
movdqa xmm6, cs:xmmword_2010
pxor xmm4, xmm4
add rsi, rdi
xchg ax, ax
loc_1180:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm3, xmm5
add rax, 10h
pcmpeqb xmm0, xmm6
pcmpgtb xmm3, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm3
punpckhbw xmm0, xmm3
movdqa xmm3, xmm4
pcmpgtw xmm3, xmm2
movdqa xmm7, xmm2
punpcklwd xmm7, xmm3
punpckhwd xmm2, xmm3
movdqa xmm3, xmm0
psubd xmm1, xmm7
psubd xmm1, xmm2
movdqa xmm2, xmm4
pcmpgtw xmm2, xmm0
punpcklwd xmm3, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm3
psubd xmm1, xmm0
cmp rax, rsi
jnz short loc_1180
movdqa xmm0, xmm1
mov esi, ecx
psrldq xmm0, 8
and esi, 0FFFFFFF0h
paddd xmm0, xmm1
mov r8d, esi
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
cmp ecx, esi
jz locret_1373
loc_1218:
mov edi, ecx
sub edi, r8d
lea r9d, [rdi-1]
cmp r9d, 6
jbe loc_12B8
movq xmm2, qword ptr cs:xmmword_2010
movq xmm1, qword ptr [rdx+r8]
pcmpeqb xmm1, xmm2
pxor xmm2, xmm2
pcmpgtb xmm2, xmm1
movdqa xmm3, xmm1
punpcklbw xmm3, xmm2
punpcklbw xmm1, xmm2
pxor xmm2, xmm2
movdqa xmm4, xmm2
movdqa xmm5, xmm3
pshufd xmm1, xmm1, 4Eh ; 'N'
pcmpgtw xmm4, xmm3
pcmpgtw xmm2, xmm1
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
psubd xmm0, xmm5
pshufd xmm3, xmm3, 4Eh ; 'N'
psubd xmm0, xmm3
movdqa xmm3, xmm1
punpcklwd xmm1, xmm2
punpcklwd xmm3, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm3
psubd xmm0, xmm1
movd r8d, xmm0
pshufd xmm6, xmm0, 0E5h
movd eax, xmm6
add eax, r8d
mov r8d, edi
and r8d, 0FFFFFFF8h
add esi, r8d
and edi, 7
jz short locret_1327
loc_12B8:
movsxd rdi, esi
cmp byte ptr [rdx+rdi], 31h ; '1'
jz short loc_1330
loc_12C1:
lea edi, [rsi+1]
cmp ecx, edi
jle short locret_1327
movsxd rdi, edi
cmp byte ptr [rdx+rdi], 31h ; '1'
jz short loc_1338
loc_12D1:
lea edi, [rsi+2]
cmp ecx, edi
jle short locret_1327
movsxd rdi, edi
cmp byte ptr [rdx+rdi], 31h ; '1'
jz short loc_1340
loc_12E1:
lea edi, [rsi+3]
cmp ecx, edi
jle short locret_1327
movsxd rdi, edi
cmp byte ptr [rdx+rdi], 31h ; '1'
jz short loc_1348
lea edi, [rsi+4]
cmp ecx, edi
jle short locret_1327
loc_12F8:
movsxd rdi, edi
cmp byte ptr [rdx+rdi], 31h ; '1'
jnz short loc_1304
add eax, 1
loc_1304:
lea edi, [rsi+5]
cmp ecx, edi
jle short locret_1327
movsxd rdi, edi
cmp byte ptr [rdx+rdi], 31h ; '1'
jnz short loc_1317
add eax, 1
loc_1317:
add esi, 6
cmp ecx, esi
jle short locret_1327
movsxd rsi, esi
cmp byte ptr [rdx+rsi], 31h ; '1'
jz short loc_1358
locret_1327:
retn
loc_1330:
add eax, 1
jmp short loc_12C1
loc_1338:
add eax, 1
jmp short loc_12D1
loc_1340:
add eax, 1
jmp short loc_12E1
loc_1348:
lea edi, [rsi+4]
add eax, 1
cmp ecx, edi
jg short loc_12F8
retn
loc_1358:
add eax, 1
retn
loc_1360:
xor eax, eax
retn
loc_1363:
pxor xmm0, xmm0
xor r8d, r8d
xor esi, esi
xor eax, eax
jmp loc_1218
locret_1373:
retn | long long func0(const __m128i *a1, int a2)
{
__m128i v4; // xmm1
const __m128i *v5; // rax
__m128i si128; // xmm6
const __m128i *v7; // rsi
__m128i v8; // xmm0
__m128i v9; // xmm0
__m128i v10; // xmm3
__m128i v11; // xmm2
__m128i v12; // xmm0
__m128i v13; // xmm3
__m128i v14; // xmm1
__m128i v15; // xmm2
signed int v16; // esi
__m128i v17; // xmm0
long long v18; // r8
long long result; // rax
__m128i v20; // xmm0
int v21; // edi
__m128i v22; // xmm1
__m128i v23; // xmm3
__m128i v24; // xmm1
__m128i v25; // xmm2
__m128i v26; // xmm3
__m128i v27; // xmm0
int v28; // edi
int v29; // esi
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 0xE )
{
v20 = 0LL;
v18 = 0LL;
v16 = 0;
result = 0LL;
}
else
{
v4 = 0LL;
v5 = a1;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v7 = &a1[(unsigned int)a2 >> 4];
do
{
v8 = _mm_loadu_si128(v5++);
v9 = _mm_cmpeq_epi8(v8, si128);
v10 = _mm_cmpgt_epi8((__m128i)0LL, v9);
v11 = _mm_unpacklo_epi8(v9, v10);
v12 = _mm_unpackhi_epi8(v9, v10);
v13 = _mm_cmpgt_epi16((__m128i)0LL, v11);
v14 = _mm_sub_epi32(_mm_sub_epi32(v4, _mm_unpacklo_epi16(v11, v13)), _mm_unpackhi_epi16(v11, v13));
v15 = _mm_cmpgt_epi16((__m128i)0LL, v12);
v4 = _mm_sub_epi32(_mm_sub_epi32(v14, _mm_unpacklo_epi16(v12, v15)), _mm_unpackhi_epi16(v12, v15));
}
while ( v5 != v7 );
v16 = a2 & 0xFFFFFFF0;
v17 = _mm_add_epi32(_mm_srli_si128(v4, 8), v4);
v18 = a2 & 0xFFFFFFF0;
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v17, _mm_srli_si128(v17, 4)));
v20 = _mm_add_epi32(v4, _mm_srli_si128(v4, 8));
if ( a2 == (a2 & 0xFFFFFFF0) )
return result;
}
v21 = a2 - v18;
if ( (unsigned int)(a2 - v18 - 1) <= 6 )
goto LABEL_16;
v22 = _mm_cmpeq_epi8(
_mm_loadl_epi64((const __m128i *)((char *)a1 + v18)),
_mm_loadl_epi64((const __m128i *)&xmmword_2010));
v23 = _mm_unpacklo_epi8(v22, _mm_cmpgt_epi8((__m128i)0LL, v22));
v24 = _mm_shuffle_epi32(v23, 78);
v25 = _mm_cmpgt_epi16((__m128i)0LL, v24);
v26 = _mm_unpacklo_epi16(v23, _mm_cmpgt_epi16((__m128i)0LL, v23));
v27 = _mm_sub_epi32(
_mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(v20, v26), _mm_shuffle_epi32(v26, 78)),
_mm_unpacklo_epi16(v24, v25)),
_mm_shuffle_epi32(_mm_unpacklo_epi16(v24, v25), 78));
result = (unsigned int)(_mm_cvtsi128_si32(v27) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v27, 229)));
v16 += v21 & 0xFFFFFFF8;
if ( (v21 & 7) != 0 )
{
LABEL_16:
if ( a1->m128i_i8[v16] == 49 )
result = (unsigned int)(result + 1);
if ( a2 > v16 + 1 )
{
if ( a1->m128i_i8[v16 + 1] == 49 )
result = (unsigned int)(result + 1);
if ( a2 > v16 + 2 )
{
if ( a1->m128i_i8[v16 + 2] == 49 )
result = (unsigned int)(result + 1);
if ( a2 > v16 + 3 )
{
if ( a1->m128i_i8[v16 + 3] == 49 )
{
v28 = v16 + 4;
result = (unsigned int)(result + 1);
if ( a2 <= v16 + 4 )
return result;
}
else
{
v28 = v16 + 4;
if ( a2 <= v16 + 4 )
return result;
}
if ( a1->m128i_i8[v28] == 49 )
result = (unsigned int)(result + 1);
if ( a2 > v16 + 5 )
{
if ( a1->m128i_i8[v16 + 5] == 49 )
result = (unsigned int)(result + 1);
v29 = v16 + 6;
if ( a2 > v29 && a1->m128i_i8[v29] == 49 )
return (unsigned int)(result + 1);
}
}
}
}
}
return result;
} | func0:
ENDBR64
MOV RDX,RDI
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101360
LEA EAX,[RSI + -0x1]
CMP EAX,0xe
JBE 0x00101363
SHR ESI,0x4
PXOR XMM1,XMM1
PXOR XMM5,XMM5
MOV RAX,RDI
SHL RSI,0x4
MOVDQA XMM6,xmmword ptr [0x00102010]
PXOR XMM4,XMM4
ADD RSI,RDI
NOP
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM3,XMM5
ADD RAX,0x10
PCMPEQB XMM0,XMM6
PCMPGTB XMM3,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM3
PUNPCKHBW XMM0,XMM3
MOVDQA XMM3,XMM4
PCMPGTW XMM3,XMM2
MOVDQA XMM7,XMM2
PUNPCKLWD XMM7,XMM3
PUNPCKHWD XMM2,XMM3
MOVDQA XMM3,XMM0
PSUBD XMM1,XMM7
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM4
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM3,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
CMP RAX,RSI
JNZ 0x00101180
MOVDQA XMM0,XMM1
MOV ESI,ECX
PSRLDQ XMM0,0x8
AND ESI,0xfffffff0
PADDD XMM0,XMM1
MOV R8D,ESI
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
CMP ECX,ESI
JZ 0x00101373
LAB_00101218:
MOV EDI,ECX
SUB EDI,R8D
LEA R9D,[RDI + -0x1]
CMP R9D,0x6
JBE 0x001012b8
MOVQ XMM2,qword ptr [0x00102010]
MOVQ XMM1,qword ptr [RDX + R8*0x1]
PCMPEQB XMM1,XMM2
PXOR XMM2,XMM2
PCMPGTB XMM2,XMM1
MOVDQA XMM3,XMM1
PUNPCKLBW XMM3,XMM2
PUNPCKLBW XMM1,XMM2
PXOR XMM2,XMM2
MOVDQA XMM4,XMM2
MOVDQA XMM5,XMM3
PSHUFD XMM1,XMM1,0x4e
PCMPGTW XMM4,XMM3
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSUBD XMM0,XMM5
PSHUFD XMM3,XMM3,0x4e
PSUBD XMM0,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM1,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM3
PSUBD XMM0,XMM1
MOVD R8D,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EAX,XMM6
ADD EAX,R8D
MOV R8D,EDI
AND R8D,0xfffffff8
ADD ESI,R8D
AND EDI,0x7
JZ 0x00101327
LAB_001012b8:
MOVSXD RDI,ESI
CMP byte ptr [RDX + RDI*0x1],0x31
JZ 0x00101330
LAB_001012c1:
LEA EDI,[RSI + 0x1]
CMP ECX,EDI
JLE 0x00101327
MOVSXD RDI,EDI
CMP byte ptr [RDX + RDI*0x1],0x31
JZ 0x00101338
LAB_001012d1:
LEA EDI,[RSI + 0x2]
CMP ECX,EDI
JLE 0x00101327
MOVSXD RDI,EDI
CMP byte ptr [RDX + RDI*0x1],0x31
JZ 0x00101340
LAB_001012e1:
LEA EDI,[RSI + 0x3]
CMP ECX,EDI
JLE 0x00101327
MOVSXD RDI,EDI
CMP byte ptr [RDX + RDI*0x1],0x31
JZ 0x00101348
LEA EDI,[RSI + 0x4]
CMP ECX,EDI
JLE 0x00101327
LAB_001012f8:
MOVSXD RDI,EDI
CMP byte ptr [RDX + RDI*0x1],0x31
JNZ 0x00101304
ADD EAX,0x1
LAB_00101304:
LEA EDI,[RSI + 0x5]
CMP ECX,EDI
JLE 0x00101327
MOVSXD RDI,EDI
CMP byte ptr [RDX + RDI*0x1],0x31
JNZ 0x00101317
ADD EAX,0x1
LAB_00101317:
ADD ESI,0x6
CMP ECX,ESI
JLE 0x00101327
MOVSXD RSI,ESI
CMP byte ptr [RDX + RSI*0x1],0x31
JZ 0x00101358
LAB_00101327:
RET
LAB_00101330:
ADD EAX,0x1
JMP 0x001012c1
LAB_00101338:
ADD EAX,0x1
JMP 0x001012d1
LAB_00101340:
ADD EAX,0x1
JMP 0x001012e1
LAB_00101348:
LEA EDI,[RSI + 0x4]
ADD EAX,0x1
CMP ECX,EDI
JG 0x001012f8
RET
LAB_00101358:
ADD EAX,0x1
RET
LAB_00101360:
XOR EAX,EAX
RET
LAB_00101363:
PXOR XMM0,XMM0
XOR R8D,R8D
XOR ESI,ESI
XOR EAX,EAX
JMP 0x00101218
LAB_00101373:
RET | int func0(char *param_1,uint param_2)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
char *pcVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
int auVar24 [14];
int auVar25 [12];
unkbyte10 Var26;
int auVar27 [12];
int auVar28 [14];
int auVar29 [12];
int auVar30 [16];
int auVar31 [16];
int auVar32 [16];
int auVar33 [12];
unkbyte9 Var34;
int6 uVar35;
int4 uVar36;
int2 uVar37;
char *pcVar38;
uint uVar39;
uint uVar40;
ulong uVar41;
int4 uVar42;
int iVar43;
char cVar51;
short sVar52;
int auVar47 [12];
int iVar53;
int auVar56 [12];
short sVar70;
int iVar71;
int auVar54 [11];
int iVar75;
int iVar77;
int auVar59 [16];
int auVar66 [16];
int iVar78;
char cVar82;
char cVar83;
char cVar84;
char cVar85;
char cVar86;
char cVar87;
short sVar88;
short sVar89;
int auVar80 [16];
int auVar90 [16];
int auVar95 [16];
int auVar102 [16];
int auVar105 [16];
int auVar109 [16];
int auVar112 [16];
int6 uVar44;
int8 uVar45;
int auVar46 [12];
int auVar48 [14];
int auVar50 [16];
int auVar49 [16];
int auVar60 [16];
int auVar61 [16];
int auVar67 [16];
int auVar55 [12];
int auVar62 [16];
int auVar57 [13];
int auVar63 [16];
int auVar68 [16];
int auVar58 [14];
int auVar64 [16];
int auVar65 [16];
char cVar69;
char cVar72;
char cVar73;
byte bVar74;
long lVar76;
int auVar79 [12];
int auVar81 [16];
int auVar91 [16];
int auVar92 [16];
int auVar106 [16];
int auVar96 [16];
int auVar93 [16];
int auVar97 [16];
int auVar103 [16];
int auVar107 [16];
int auVar98 [16];
int auVar94 [16];
int auVar99 [16];
int auVar104 [16];
int auVar108 [16];
int auVar100 [16];
int auVar101 [16];
int auVar110 [16];
int auVar111 [16];
int auVar113 [16];
int auVar114 [16];
if ((int)param_2 < 1) {
return 0;
}
if (param_2 - 1 < 0xf) {
iVar53 = 0;
iVar71 = 0;
uVar41 = 0;
uVar39 = 0;
iVar43 = 0;
}
else {
iVar53 = 0;
iVar71 = 0;
iVar75 = 0;
iVar77 = 0;
pcVar38 = param_1;
do {
cVar51 = *pcVar38;
pcVar9 = pcVar38 + 1;
pcVar10 = pcVar38 + 2;
pcVar11 = pcVar38 + 3;
pcVar12 = pcVar38 + 4;
pcVar13 = pcVar38 + 5;
pcVar14 = pcVar38 + 6;
pcVar15 = pcVar38 + 7;
pcVar16 = pcVar38 + 8;
pcVar17 = pcVar38 + 9;
pcVar18 = pcVar38 + 10;
pcVar19 = pcVar38 + 0xb;
pcVar20 = pcVar38 + 0xc;
pcVar21 = pcVar38 + 0xd;
pcVar22 = pcVar38 + 0xe;
pcVar23 = pcVar38 + 0xf;
pcVar38 = pcVar38 + 0x10;
bVar1 = cVar51 == (char)DAT_00102010;
cVar51 = -(*pcVar15 == DAT_00102010._7_1_);
bVar5 = *pcVar16 == UNK_00102018;
bVar6 = *pcVar17 == UNK_00102019;
bVar7 = *pcVar18 == UNK_0010201a;
bVar8 = *pcVar19 == UNK_0010201b;
uVar37 = CONCAT11(-(*pcVar15 == DAT_00102010._7_1_),cVar51);
uVar36 = CONCAT31(CONCAT21(uVar37,-(*pcVar14 == DAT_00102010._6_1_)),
-(*pcVar14 == DAT_00102010._6_1_));
uVar35 = CONCAT51(CONCAT41(uVar36,-(*pcVar13 == DAT_00102010._5_1_)),
-(*pcVar13 == DAT_00102010._5_1_));
Var34 = CONCAT72(CONCAT61(uVar35,-(*pcVar12 == DAT_00102010._4_1_)),
CONCAT11(-(*pcVar12 == DAT_00102010._4_1_),cVar51));
lVar76 = (long)((unkuint9)Var34 >> 8);
Var26 = CONCAT91(CONCAT81(lVar76,-(*pcVar11 == DAT_00102010._3_1_)),
-(*pcVar11 == DAT_00102010._3_1_));
auVar25._2_10_ = Var26;
auVar25[1] = -(*pcVar10 == DAT_00102010._2_1_);
auVar25[0] = -(*pcVar10 == DAT_00102010._2_1_);
auVar24._2_12_ = auVar25;
auVar24[1] = -(*pcVar9 == DAT_00102010._1_1_);
auVar24[0] = -(*pcVar9 == DAT_00102010._1_1_);
auVar80._0_2_ = CONCAT11(-bVar1,-bVar1);
auVar80._2_14_ = auVar24;
uVar42 = CONCAT13(-bVar6,CONCAT12(-bVar6,CONCAT11(-bVar5,-bVar5)));
uVar44 = CONCAT15(-bVar7,CONCAT14(-bVar7,uVar42));
uVar45 = CONCAT17(-bVar8,CONCAT16(-bVar8,uVar44));
auVar46._0_10_ =
CONCAT19(-(*pcVar20 == UNK_0010201c),CONCAT18(-(*pcVar20 == UNK_0010201c),uVar45));
auVar46[10] = -(*pcVar21 == UNK_0010201d);
auVar46[0xb] = -(*pcVar21 == UNK_0010201d);
auVar48[0xc] = -(*pcVar22 == UNK_0010201e);
auVar48._0_12_ = auVar46;
auVar48[0xd] = -(*pcVar22 == UNK_0010201e);
auVar49[0xe] = -(*pcVar23 == UNK_0010201f);
auVar49._0_14_ = auVar48;
auVar49[0xf] = -(*pcVar23 == UNK_0010201f);
sVar52 = (short)Var26;
sVar70 = (short)((unkuint9)Var34 >> 8);
sVar88 = (short)uVar35;
sVar89 = (short)uVar36;
auVar114._0_12_ = auVar80._0_12_;
auVar114._12_2_ = sVar52;
auVar114._14_2_ = -(ushort)(sVar52 < 0);
auVar113._12_4_ = auVar114._12_4_;
auVar113._0_10_ = auVar80._0_10_;
auVar113._10_2_ = -(ushort)(auVar25._0_2_ < 0);
auVar112._10_6_ = auVar113._10_6_;
auVar112._0_8_ = auVar80._0_8_;
auVar112._8_2_ = auVar25._0_2_;
auVar27._4_8_ = auVar112._8_8_;
auVar27._2_2_ = -(ushort)(auVar24._0_2_ < 0);
auVar27._0_2_ = auVar24._0_2_;
iVar78 = CONCAT22(-(ushort)(sVar70 < 0),sVar70);
auVar79._0_8_ = CONCAT26(-(ushort)(sVar88 < 0),CONCAT24(sVar88,iVar78));
auVar79._8_2_ = sVar89;
auVar79._10_2_ = -(ushort)(sVar89 < 0);
auVar81._12_2_ = uVar37;
auVar81._0_12_ = auVar79;
auVar81._14_2_ = -(ushort)(lVar76 < 0);
sVar52 = (short)((unkuint10)auVar46._0_10_ >> 0x40);
auVar94._12_2_ = (short)((ulong)uVar45 >> 0x30);
auVar94._0_12_ = auVar46;
auVar94._14_2_ = -(ushort)bVar8;
auVar93._12_4_ = auVar94._12_4_;
auVar93._10_2_ = -(ushort)bVar7;
auVar93._0_10_ = auVar46._0_10_;
auVar92._10_6_ = auVar93._10_6_;
auVar92._8_2_ = (short)((uint6)uVar44 >> 0x20);
auVar92._0_8_ = uVar45;
auVar91._8_8_ = auVar92._8_8_;
auVar91._6_2_ = -(ushort)bVar6;
auVar91._0_6_ = uVar44;
auVar90._6_10_ = auVar91._6_10_;
auVar90._4_2_ = (short)((uint)uVar42 >> 0x10);
auVar90._0_4_ = uVar42;
iVar43 = CONCAT22(-(ushort)(sVar52 < 0),sVar52);
auVar47._0_8_ = CONCAT26(-(ushort)(auVar46._10_2_ < 0),CONCAT24(auVar46._10_2_,iVar43));
auVar47._8_2_ = auVar48._12_2_;
auVar47._10_2_ = -(ushort)(auVar48._12_2_ < 0);
auVar50._12_2_ = auVar49._14_2_;
auVar50._0_12_ = auVar47;
auVar50._14_2_ = -(ushort)(auVar49._14_2_ < 0);
iVar53 = (((iVar53 - CONCAT22(-(ushort)bVar1,auVar80._0_2_)) - iVar78) -
CONCAT22(-(ushort)bVar5,CONCAT11(-bVar5,-bVar5))) - iVar43;
iVar71 = (((iVar71 - auVar27._0_4_) - (int)((ulong)auVar79._0_8_ >> 0x20)) - auVar90._4_4_) -
(int)((ulong)auVar47._0_8_ >> 0x20);
iVar75 = (((iVar75 - auVar112._8_4_) - auVar79._8_4_) - auVar92._8_4_) - auVar47._8_4_;
iVar77 = (((iVar77 - auVar113._12_4_) - auVar81._12_4_) - auVar93._12_4_) - auVar50._12_4_;
} while (pcVar38 != param_1 + (ulong)(param_2 >> 4) * 0x10);
uVar39 = param_2 & 0xfffffff0;
uVar41 = (ulong)uVar39;
iVar43 = iVar75 + iVar53 + iVar77 + iVar71;
iVar53 = iVar53 + iVar75;
iVar71 = iVar71 + iVar77;
if (param_2 == uVar39) {
return iVar43;
}
}
uVar40 = param_2 - (int)uVar41;
if (6 < uVar40 - 1) {
uVar45 = *(int8 *)(param_1 + uVar41);
bVar1 = (char)uVar45 == (char)DAT_00102010;
auVar59[0] = -bVar1;
bVar5 = (char)((ulong)uVar45 >> 8) == DAT_00102010._1_1_;
cVar51 = -bVar5;
bVar6 = (char)((ulong)uVar45 >> 0x10) == DAT_00102010._2_1_;
bVar7 = (char)((ulong)uVar45 >> 0x18) == DAT_00102010._3_1_;
bVar8 = (char)((ulong)uVar45 >> 0x20) == DAT_00102010._4_1_;
cVar69 = -bVar8;
bVar2 = (char)((ulong)uVar45 >> 0x28) == DAT_00102010._5_1_;
cVar72 = -bVar2;
bVar3 = (char)((ulong)uVar45 >> 0x30) == DAT_00102010._6_1_;
cVar73 = -bVar3;
bVar4 = (char)((ulong)uVar45 >> 0x38) == DAT_00102010._7_1_;
bVar74 = -bVar4;
auVar60._0_9_ = CONCAT18(0xff,(ulong)bVar74 << 0x38);
auVar54._0_10_ = CONCAT19(0xff,auVar60._0_9_);
auVar54[10] = 0xff;
auVar55[0xb] = 0xff;
auVar55._0_11_ = auVar54;
auVar57[0xc] = 0xff;
auVar57._0_12_ = auVar55;
auVar58[0xd] = 0xff;
auVar58._0_13_ = auVar57;
cVar82 = -bVar5;
cVar83 = -bVar7;
cVar84 = -bVar8;
cVar85 = -bVar2;
cVar86 = -bVar3;
cVar87 = -bVar4;
auVar101[0xe] = bVar74;
auVar101._0_14_ = auVar58;
auVar101[0xf] = cVar87;
auVar100._14_2_ = auVar101._14_2_;
auVar100[0xd] = cVar86;
auVar100._0_13_ = auVar57;
auVar99._13_3_ = auVar100._13_3_;
auVar99[0xc] = cVar73;
auVar99._0_12_ = auVar55;
auVar98._12_4_ = auVar99._12_4_;
auVar98[0xb] = cVar85;
auVar98._0_11_ = auVar54;
auVar97._11_5_ = auVar98._11_5_;
auVar97[10] = cVar72;
auVar97._0_10_ = auVar54._0_10_;
auVar96._10_6_ = auVar97._10_6_;
auVar96[9] = cVar84;
auVar96._0_9_ = auVar60._0_9_;
Var26 = CONCAT91(CONCAT81((long)(CONCAT72(auVar96._9_7_,CONCAT11(cVar69,bVar74)) >> 8),cVar83),
-bVar7);
auVar29._2_10_ = Var26;
auVar29[1] = -bVar6;
auVar29[0] = -bVar6;
auVar28._2_12_ = auVar29;
auVar28[1] = cVar82;
auVar28[0] = cVar51;
auVar95._0_2_ = CONCAT11(-bVar1,auVar59[0]);
auVar95._2_14_ = auVar28;
auVar65[0xe] = bVar74;
auVar65._0_14_ = auVar58;
auVar65[0xf] = cVar87;
auVar64._14_2_ = auVar65._14_2_;
auVar64[0xd] = cVar86;
auVar64._0_13_ = auVar57;
auVar63._13_3_ = auVar64._13_3_;
auVar63[0xc] = cVar73;
auVar63._0_12_ = auVar55;
auVar62._12_4_ = auVar63._12_4_;
auVar62[0xb] = cVar85;
auVar62._0_11_ = auVar54;
auVar61._11_5_ = auVar62._11_5_;
auVar61[10] = cVar72;
auVar61._0_10_ = auVar54._0_10_;
auVar60._10_6_ = auVar61._10_6_;
auVar60[9] = cVar84;
Var34 = CONCAT72(auVar60._9_7_,CONCAT11(cVar69,bVar74));
lVar76 = (long)((unkuint9)Var34 >> 8);
auVar32._1_8_ = lVar76;
auVar32[0] = cVar83;
auVar32._9_7_ = 0;
auVar31._10_6_ = 0;
auVar31._0_10_ = SUB1610(auVar32 << 0x38,6);
auVar30._11_5_ = 0;
auVar30._0_11_ = SUB1611(auVar31 << 0x30,5);
auVar59._4_12_ = SUB1612(auVar30 << 0x28,4);
auVar59[3] = cVar82;
auVar59[2] = cVar51;
auVar59[1] = -bVar1;
iVar43 = (int)((unkuint9)Var34 >> 8);
auVar56._8_4_ = auVar59._0_4_;
auVar56._0_8_ = lVar76;
sVar88 = auVar29._0_2_;
sVar89 = (short)Var26;
sVar52 = (short)((unkuint9)Var34 >> 8);
sVar70 = auVar63._12_2_;
auVar111._0_12_ = auVar95._0_12_;
auVar111._12_2_ = sVar89;
auVar111._14_2_ = -(ushort)(sVar89 < 0);
auVar110._12_4_ = auVar111._12_4_;
auVar110._0_10_ = auVar95._0_10_;
auVar110._10_2_ = -(ushort)(sVar88 < 0);
auVar109._10_6_ = auVar110._10_6_;
auVar109._0_8_ = auVar95._0_8_;
auVar109._8_2_ = sVar88;
auVar33._4_8_ = auVar109._8_8_;
auVar33._2_2_ = -(ushort)(auVar28._0_2_ < 0);
auVar33._0_2_ = auVar28._0_2_;
auVar104._12_2_ = sVar89;
auVar104._0_12_ = auVar111._0_12_;
auVar104._14_2_ = -(ushort)(sVar89 < 0);
auVar103._12_4_ = auVar104._12_4_;
auVar103._10_2_ = -(ushort)(sVar88 < 0);
auVar103._0_10_ = auVar110._0_10_;
auVar102._10_6_ = auVar103._10_6_;
auVar102._8_2_ = sVar88;
auVar102._0_8_ = auVar109._0_8_;
auVar68._12_2_ = auVar64._14_2_;
auVar68._0_12_ = auVar56;
auVar68._14_2_ = -(ushort)(lVar76 < 0);
auVar67._12_4_ = auVar68._12_4_;
auVar67._0_10_ = auVar56._0_10_;
auVar67._10_2_ = -(ushort)(sVar70 < 0);
auVar66._10_6_ = auVar67._10_6_;
auVar66._8_2_ = sVar70;
auVar66._0_8_ = lVar76;
auVar108._12_2_ = auVar64._14_2_;
auVar108._0_12_ = auVar56;
auVar108._14_2_ = -(ushort)(lVar76 < 0);
auVar107._12_4_ = auVar108._12_4_;
auVar107._10_2_ = -(ushort)(sVar70 < 0);
auVar107._0_10_ = auVar67._0_10_;
auVar106._10_6_ = auVar107._10_6_;
auVar106._8_2_ = sVar70;
auVar106._0_8_ = lVar76;
auVar105._8_8_ = auVar106._8_8_;
auVar105._6_2_ = -(ushort)(iVar43 < 0);
auVar105._4_2_ = auVar61._10_2_;
auVar105._0_4_ = iVar43;
iVar43 = ((((iVar71 - auVar33._0_4_) - auVar103._12_4_) - auVar105._4_4_) - auVar67._12_4_) +
((((iVar53 - CONCAT22(-(ushort)bVar1,auVar95._0_2_)) - auVar102._8_4_) -
CONCAT22(-(ushort)(sVar52 < 0),sVar52)) - auVar66._8_4_);
uVar39 = uVar39 + (uVar40 & 0xfffffff8);
if ((uVar40 & 7) == 0) {
return iVar43;
}
}
if (param_1[(int)uVar39] == '1') {
iVar43 = iVar43 + 1;
}
if ((int)(uVar39 + 1) < (int)param_2) {
if (param_1[(int)(uVar39 + 1)] == '1') {
iVar43 = iVar43 + 1;
}
if ((int)(uVar39 + 2) < (int)param_2) {
if (param_1[(int)(uVar39 + 2)] == '1') {
iVar43 = iVar43 + 1;
}
if ((int)(uVar39 + 3) < (int)param_2) {
if (param_1[(int)(uVar39 + 3)] == '1') {
iVar43 = iVar43 + 1;
if ((int)param_2 <= (int)(uVar39 + 4)) {
return iVar43;
}
}
else if ((int)param_2 <= (int)(uVar39 + 4)) {
return iVar43;
}
if (param_1[(int)(uVar39 + 4)] == '1') {
iVar43 = iVar43 + 1;
}
if ((int)(uVar39 + 5) < (int)param_2) {
if (param_1[(int)(uVar39 + 5)] == '1') {
iVar43 = iVar43 + 1;
}
if (((int)(uVar39 + 6) < (int)param_2) && (param_1[(int)(uVar39 + 6)] == '1')) {
return iVar43 + 1;
}
}
}
}
}
return iVar43;
} |
4,332 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = test_list[i].first;
(*res_size)++;
strt_val = test_list[i].second;
}
if(strt_val < stop_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = stop_val;
(*res_size)++;
}
}
return res;
}
| int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first);
assert(result1[i].second == expected1[i].second);
}
free(result1);
// Test 2
pair test2[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size2;
pair* result2 = func0(test2, 3, 5, 60, &res_size2);
pair expected2[] = { {5, 7}, {2, 60}, {2, 15}, {19, 60}, {19, 38}, {50, 60} };
assert(res_size2 == 6);
for(int i = 0; i < 6; i++) {
assert(result2[i].first == expected2[i].first);
assert(result2[i].second == expected2[i].second);
}
free(result2);
// Test 3
pair test3[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size3;
pair* result3 = func0(test3, 3, 1, 52, &res_size3);
pair expected3[] = { {1, 7}, {2, 52}, {2, 15}, {19, 52}, {19, 38}, {50, 52} };
assert(res_size3 == 6);
for(int i = 0; i < 6; i++) {
assert(result3[i].first == expected3[i].first);
assert(result3[i].second == expected3[i].second);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %ecx,-0x24(%rbp)
mov %r8,-0x30(%rbp)
movq $0x0,-0x8(%rbp)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0xc(%rbp)
jmpq 1319 <func0+0x170>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jge 129f <func0+0xf6>
mov -0x30(%rbp),%rax
mov (%rax),%eax
add $0x1,%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <realloc@plt>
mov %rax,-0x8(%rbp)
mov -0x30(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x30(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,0x4(%rdx)
mov -0x30(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%eax
mov %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x24(%rbp),%eax
jge 1315 <func0+0x16c>
mov -0x30(%rbp),%rax
mov (%rax),%eax
add $0x1,%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <realloc@plt>
mov %rax,-0x8(%rbp)
mov -0x30(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
mov %eax,(%rdx)
mov -0x30(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x24(%rbp),%eax
mov %eax,0x4(%rdx)
mov -0x30(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11e4 <func0+0x3b>
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_20], edx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+ptr], 0
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov [rbp+var_C], 0
jmp loc_1319
loc_11E4:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jge loc_129F
mov rax, [rbp+var_30]
mov eax, [rax]
add eax, 1
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
mov rax, [rbp+var_30]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_20]
mov [rdx], eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov rax, [rbp+var_30]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rcx]
mov [rdx+4], eax
mov rax, [rbp+var_30]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_30]
mov [rax], edx
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax+4]
mov [rbp+var_20], eax
loc_129F:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jge short loc_1315
mov rax, [rbp+var_30]
mov eax, [rax]
add eax, 1
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
mov rax, [rbp+var_30]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_20]
mov [rdx], eax
mov rax, [rbp+var_30]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_24]
mov [rdx+4], eax
mov rax, [rbp+var_30]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_30]
mov [rax], edx
loc_1315:
add [rbp+var_C], 1
loc_1319:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_11E4
mov rax, [rbp+ptr]
leave
retn | void * func0(long long a1, int a2, int a3, int a4, int *a5)
{
int i; // [rsp+24h] [rbp-Ch]
void *ptr; // [rsp+28h] [rbp-8h]
ptr = 0LL;
*a5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( a3 < *(_DWORD *)(8LL * i + a1) )
{
ptr = realloc(ptr, 8LL * (*a5 + 1));
*((_DWORD *)ptr + 2 * *a5) = a3;
*((_DWORD *)ptr + 2 * (*a5)++ + 1) = *(_DWORD *)(8LL * i + a1);
a3 = *(_DWORD *)(8LL * i + a1 + 4);
}
if ( a3 < a4 )
{
ptr = realloc(ptr, 8LL * (*a5 + 1));
*((_DWORD *)ptr + 2 * *a5) = a3;
*((_DWORD *)ptr + 2 * (*a5)++ + 1) = a4;
}
}
return ptr;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101319
LAB_001011e4:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JGE 0x0010129f
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
ADD EAX,0x1
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX + 0x4],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x20],EAX
LAB_0010129f:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x00101315
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
ADD EAX,0x1
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RDX + 0x4],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
LAB_00101315:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101319:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011e4
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3,int param_4,int *param_5)
{
int local_28;
int local_14;
void *local_10;
local_10 = (void *)0x0;
*param_5 = 0;
local_28 = param_3;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (local_28 < *(int *)(param_1 + (long)local_14 * 8)) {
local_10 = realloc(local_10,(long)(*param_5 + 1) * 8);
*(int *)((long)*param_5 * 8 + (long)local_10) = local_28;
*(int4 *)((long)local_10 + (long)*param_5 * 8 + 4) =
*(int4 *)((long)local_14 * 8 + param_1);
*param_5 = *param_5 + 1;
local_28 = *(int *)(param_1 + (long)local_14 * 8 + 4);
}
if (local_28 < param_4) {
local_10 = realloc(local_10,(long)(*param_5 + 1) * 8);
*(int *)((long)*param_5 * 8 + (long)local_10) = local_28;
*(int *)((long)local_10 + (long)*param_5 * 8 + 4) = param_4;
*param_5 = *param_5 + 1;
}
}
return local_10;
} |
4,333 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = test_list[i].first;
(*res_size)++;
strt_val = test_list[i].second;
}
if(strt_val < stop_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = stop_val;
(*res_size)++;
}
}
return res;
}
| int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first);
assert(result1[i].second == expected1[i].second);
}
free(result1);
// Test 2
pair test2[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size2;
pair* result2 = func0(test2, 3, 5, 60, &res_size2);
pair expected2[] = { {5, 7}, {2, 60}, {2, 15}, {19, 60}, {19, 38}, {50, 60} };
assert(res_size2 == 6);
for(int i = 0; i < 6; i++) {
assert(result2[i].first == expected2[i].first);
assert(result2[i].second == expected2[i].second);
}
free(result2);
// Test 3
pair test3[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size3;
pair* result3 = func0(test3, 3, 1, 52, &res_size3);
pair expected3[] = { {1, 7}, {2, 52}, {2, 15}, {19, 52}, {19, 38}, {50, 52} };
assert(res_size3 == 6);
for(int i = 0; i < 6; i++) {
assert(result3[i].first == expected3[i].first);
assert(result3[i].second == expected3[i].second);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
movl $0x0,(%r8)
test %esi,%esi
jle 125d <func0+0xb4>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebp
mov %ecx,%r14d
mov %r8,%r12
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r15
mov $0x0,%edi
jmp 124e <func0+0xa5>
mov (%r12),%eax
lea 0x1(%rax),%esi
movslq %esi,%rsi
shl $0x3,%rsi
callq 10b0 <realloc@plt>
mov %rax,%rdi
mov (%r12),%eax
movslq %eax,%rdx
lea (%rdi,%rdx,8),%rdx
mov %ebp,(%rdx)
mov %r13d,0x4(%rdx)
add $0x1,%eax
mov %eax,(%r12)
mov 0x4(%rbx),%ebp
jmp 1256 <func0+0xad>
mov (%r12),%eax
lea 0x1(%rax),%esi
movslq %esi,%rsi
shl $0x3,%rsi
callq 10b0 <realloc@plt>
mov %rax,%rdi
mov (%r12),%eax
movslq %eax,%rdx
lea (%rdi,%rdx,8),%rdx
mov %ebp,(%rdx)
mov %r14d,0x4(%rdx)
add $0x1,%eax
mov %eax,(%r12)
add $0x8,%rbx
cmp %r15,%rbx
je 1266 <func0+0xbd>
mov (%rbx),%r13d
cmp %ebp,%r13d
jg 11e4 <func0+0x3b>
cmp %r14d,%ebp
jge 1245 <func0+0x9c>
jmp 1217 <func0+0x6e>
mov $0x0,%edi
mov %rdi,%rax
retq
mov %rdi,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
mov dword ptr [r8], 0
test esi, esi
jle loc_125D
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebp, edx
mov r14d, ecx
mov r12, r8
mov rbx, rdi
lea eax, [rsi-1]
lea r15, [rdi+rax*8+8]
mov edi, 0
jmp short loc_1220
loc_11E4:
mov eax, [r12]
lea esi, [rax+1]
movsxd rsi, esi
shl rsi, 3
call _realloc
mov rdi, rax
mov eax, [r12]
movsxd rdx, eax
lea rdx, [rdi+rdx*8]
mov [rdx], ebp
mov [rdx+4], r13d
add eax, 1
mov [r12], eax
mov ebp, [rbx+4]
jmp short loc_1228
loc_1217:
add rbx, 8
cmp rbx, r15
jz short loc_1266
loc_1220:
mov r13d, [rbx]
cmp r13d, ebp
jg short loc_11E4
loc_1228:
cmp ebp, r14d
jge short loc_1217
mov eax, [r12]
lea esi, [rax+1]
movsxd rsi, esi
shl rsi, 3
call _realloc
mov rdi, rax
mov eax, [r12]
movsxd rdx, eax
lea rdx, [rdi+rdx*8]
mov [rdx], ebp
mov [rdx+4], r14d
add eax, 1
mov [r12], eax
jmp short loc_1217
loc_125D:
mov edi, 0
mov rax, rdi
retn
loc_1266:
mov rax, rdi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int *a1, int a2, int a3, int a4, int *a5)
{
int *v8; // rbx
long long v9; // r15
long long v10; // rdi
int v11; // eax
_DWORD *v12; // rdx
int v13; // r13d
int v14; // eax
_DWORD *v15; // rdx
*a5 = 0;
if ( a2 <= 0 )
return 0LL;
v8 = a1;
v9 = (long long)&a1[2 * (a2 - 1) + 2];
v10 = 0LL;
do
{
v13 = *v8;
if ( *v8 > a3 )
{
v10 = realloc(v10, 8LL * (*a5 + 1));
v11 = *a5;
v12 = (_DWORD *)(v10 + 8LL * *a5);
*v12 = a3;
v12[1] = v13;
*a5 = v11 + 1;
a3 = v8[1];
}
if ( a3 < a4 )
{
v10 = realloc(v10, 8LL * (*a5 + 1));
v14 = *a5;
v15 = (_DWORD *)(v10 + 8LL * *a5);
*v15 = a3;
v15[1] = a4;
*a5 = v14 + 1;
}
v8 += 2;
}
while ( v8 != (int *)v9 );
return v10;
} | func0:
ENDBR64
MOV dword ptr [R8],0x0
TEST ESI,ESI
JLE 0x0010125d
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDX
MOV R14D,ECX
MOV R12,R8
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R15,[RDI + RAX*0x8 + 0x8]
MOV EDI,0x0
JMP 0x00101220
LAB_001011e4:
MOV EAX,dword ptr [R12]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010b0
MOV RDI,RAX
MOV EAX,dword ptr [R12]
MOVSXD RDX,EAX
LEA RDX,[RDI + RDX*0x8]
MOV dword ptr [RDX],EBP
MOV dword ptr [RDX + 0x4],R13D
ADD EAX,0x1
MOV dword ptr [R12],EAX
MOV EBP,dword ptr [RBX + 0x4]
JMP 0x00101228
LAB_00101217:
ADD RBX,0x8
CMP RBX,R15
JZ 0x00101266
LAB_00101220:
MOV R13D,dword ptr [RBX]
CMP R13D,EBP
JG 0x001011e4
LAB_00101228:
CMP EBP,R14D
JGE 0x00101217
MOV EAX,dword ptr [R12]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010b0
MOV RDI,RAX
MOV EAX,dword ptr [R12]
MOVSXD RDX,EAX
LEA RDX,[RDI + RDX*0x8]
MOV dword ptr [RDX],EBP
MOV dword ptr [RDX + 0x4],R14D
ADD EAX,0x1
MOV dword ptr [R12],EAX
JMP 0x00101217
LAB_0010125d:
MOV EDI,0x0
MOV RAX,RDI
RET
LAB_00101266:
MOV RAX,RDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
*param_5 = 0;
if (0 < param_2) {
piVar2 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
__ptr = (void *)0x0;
do {
iVar4 = *param_1;
if (param_3 < iVar4) {
__ptr = realloc(__ptr,(long)(*param_5 + 1) << 3);
iVar3 = *param_5;
piVar1 = (int *)((long)__ptr + (long)iVar3 * 8);
*piVar1 = param_3;
piVar1[1] = iVar4;
*param_5 = iVar3 + 1;
param_3 = param_1[1];
}
if (param_3 < param_4) {
__ptr = realloc(__ptr,(long)(*param_5 + 1) << 3);
iVar4 = *param_5;
piVar1 = (int *)((long)__ptr + (long)iVar4 * 8);
*piVar1 = param_3;
piVar1[1] = param_4;
*param_5 = iVar4 + 1;
}
param_1 = param_1 + 2;
} while (param_1 != piVar2);
return __ptr;
}
return (void *)0x0;
} |
4,334 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = test_list[i].first;
(*res_size)++;
strt_val = test_list[i].second;
}
if(strt_val < stop_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = stop_val;
(*res_size)++;
}
}
return res;
}
| int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first);
assert(result1[i].second == expected1[i].second);
}
free(result1);
// Test 2
pair test2[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size2;
pair* result2 = func0(test2, 3, 5, 60, &res_size2);
pair expected2[] = { {5, 7}, {2, 60}, {2, 15}, {19, 60}, {19, 38}, {50, 60} };
assert(res_size2 == 6);
for(int i = 0; i < 6; i++) {
assert(result2[i].first == expected2[i].first);
assert(result2[i].second == expected2[i].second);
}
free(result2);
// Test 3
pair test3[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size3;
pair* result3 = func0(test3, 3, 1, 52, &res_size3);
pair expected3[] = { {1, 7}, {2, 52}, {2, 15}, {19, 52}, {19, 38}, {50, 52} };
assert(res_size3 == 6);
for(int i = 0; i < 6; i++) {
assert(result3[i].first == expected3[i].first);
assert(result3[i].second == expected3[i].second);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
movl $0x0,(%r8)
test %esi,%esi
jle 16d0 <func0+0xd0>
push %r15
lea -0x1(%rsi),%eax
push %r14
mov %r8,%r14
push %r13
lea 0x8(%rdi,%rax,8),%r13
push %r12
mov %ecx,%r12d
push %rbp
mov %edx,%ebp
push %rbx
mov %rdi,%rbx
xor %edi,%edi
sub $0x8,%rsp
jmp 164e <func0+0x4e>
nopl 0x0(%rax,%rax,1)
cmp %r12d,%ebp
jl 1689 <func0+0x89>
add $0x8,%rbx
cmp %r13,%rbx
je 16bd <func0+0xbd>
mov (%rbx),%r15d
cmp %ebp,%r15d
jle 1640 <func0+0x40>
mov (%r14),%eax
lea 0x1(%rax),%esi
movslq %esi,%rsi
shl $0x3,%rsi
callq 10b0 <realloc@plt>
movslq (%r14),%rdx
mov %rax,%rdi
mov %rdx,%rax
lea (%rdi,%rdx,8),%rdx
add $0x1,%eax
mov %ebp,(%rdx)
mov %eax,(%r14)
mov 0x4(%rbx),%ebp
mov %r15d,0x4(%rdx)
cmp %r12d,%ebp
jge 1645 <func0+0x45>
mov (%r14),%eax
add $0x8,%rbx
lea 0x1(%rax),%esi
movslq %esi,%rsi
shl $0x3,%rsi
callq 10b0 <realloc@plt>
movslq (%r14),%rdx
mov %rax,%rdi
mov %rdx,%rax
lea (%rdi,%rdx,8),%rdx
add $0x1,%eax
mov %ebp,(%rdx)
mov %r12d,0x4(%rdx)
mov %eax,(%r14)
cmp %r13,%rbx
jne 164e <func0+0x4e>
add $0x8,%rsp
mov %rdi,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %edi,%edi
mov %rdi,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov dword ptr [r8], 0
test esi, esi
jle loc_16D0
push r15
lea eax, [rsi-1]
push r14
mov r14, r8
push r13
lea r13, [rdi+rax*8+8]
push r12
mov r12d, ecx
push rbp
mov ebp, edx
push rbx
mov rbx, rdi
xor edi, edi
sub rsp, 8
jmp short loc_164E
loc_1640:
cmp ebp, r12d
jl short loc_1689
loc_1645:
add rbx, 8
cmp rbx, r13
jz short loc_16BD
loc_164E:
mov r15d, [rbx]
cmp r15d, ebp
jle short loc_1640
mov eax, [r14]
lea esi, [rax+1]
movsxd rsi, esi
shl rsi, 3
call _realloc
movsxd rdx, dword ptr [r14]
mov rdi, rax
mov rax, rdx
lea rdx, [rdi+rdx*8]
add eax, 1
mov [rdx], ebp
mov [r14], eax
mov ebp, [rbx+4]
mov [rdx+4], r15d
cmp ebp, r12d
jge short loc_1645
loc_1689:
mov eax, [r14]
add rbx, 8
lea esi, [rax+1]
movsxd rsi, esi
shl rsi, 3
call _realloc
movsxd rdx, dword ptr [r14]
mov rdi, rax
mov rax, rdx
lea rdx, [rdi+rdx*8]
add eax, 1
mov [rdx], ebp
mov [rdx+4], r12d
mov [r14], eax
cmp rbx, r13
jnz short loc_164E
loc_16BD:
add rsp, 8
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16D0:
xor eax, eax
retn | long long func0(int *a1, int a2, int a3, int a4, int *a5)
{
long long v6; // r13
int *v9; // rbx
long long v10; // rdi
int v11; // r15d
_DWORD *v12; // rdx
int v13; // eax
_DWORD *v14; // rdx
int v15; // eax
*a5 = 0;
if ( a2 > 0 )
{
v6 = (long long)&a1[2 * (a2 - 1) + 2];
v9 = a1;
v10 = 0LL;
while ( 1 )
{
v11 = *v9;
if ( *v9 <= a3 )
{
if ( a3 >= a4 )
goto LABEL_4;
LABEL_7:
v9 += 2;
v10 = realloc(v10, 8LL * (*a5 + 1));
v14 = (_DWORD *)(v10 + 8LL * *a5);
v15 = *a5 + 1;
*v14 = a3;
v14[1] = a4;
*a5 = v15;
if ( v9 == (int *)v6 )
return v10;
}
else
{
v10 = realloc(v10, 8LL * (*a5 + 1));
v12 = (_DWORD *)(v10 + 8LL * *a5);
v13 = *a5 + 1;
*v12 = a3;
*a5 = v13;
a3 = v9[1];
v12[1] = v11;
if ( a3 < a4 )
goto LABEL_7;
LABEL_4:
v9 += 2;
if ( v9 == (int *)v6 )
return v10;
}
}
}
return 0LL;
} | func0:
ENDBR64
MOV dword ptr [R8],0x0
TEST ESI,ESI
JLE 0x001016d0
PUSH R15
LEA EAX,[RSI + -0x1]
PUSH R14
MOV R14,R8
PUSH R13
LEA R13,[RDI + RAX*0x8 + 0x8]
PUSH R12
MOV R12D,ECX
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RDI
XOR EDI,EDI
SUB RSP,0x8
JMP 0x0010164e
LAB_00101640:
CMP EBP,R12D
JL 0x00101689
LAB_00101645:
ADD RBX,0x8
CMP RBX,R13
JZ 0x001016bd
LAB_0010164e:
MOV R15D,dword ptr [RBX]
CMP R15D,EBP
JLE 0x00101640
MOV EAX,dword ptr [R14]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010b0
MOVSXD RDX,dword ptr [R14]
MOV RDI,RAX
MOV RAX,RDX
LEA RDX,[RDI + RDX*0x8]
ADD EAX,0x1
MOV dword ptr [RDX],EBP
MOV dword ptr [R14],EAX
MOV EBP,dword ptr [RBX + 0x4]
MOV dword ptr [RDX + 0x4],R15D
CMP EBP,R12D
JGE 0x00101645
LAB_00101689:
MOV EAX,dword ptr [R14]
ADD RBX,0x8
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010b0
MOVSXD RDX,dword ptr [R14]
MOV RDI,RAX
MOV RAX,RDX
LEA RDX,[RDI + RDX*0x8]
ADD EAX,0x1
MOV dword ptr [RDX],EBP
MOV dword ptr [RDX + 0x4],R12D
MOV dword ptr [R14],EAX
CMP RBX,R13
JNZ 0x0010164e
LAB_001016bd:
ADD RSP,0x8
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016d0:
XOR EAX,EAX
RET | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
*param_5 = 0;
if (param_2 < 1) {
return (void *)0x0;
}
piVar2 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
__ptr = (void *)0x0;
do {
while (iVar3 = *param_1, param_3 < iVar3) {
__ptr = realloc(__ptr,(long)(*param_5 + 1) << 3);
iVar4 = *param_5;
piVar1 = (int *)((long)__ptr + (long)iVar4 * 8);
*piVar1 = param_3;
*param_5 = iVar4 + 1;
param_3 = param_1[1];
piVar1[1] = iVar3;
if (param_4 <= param_3) goto LAB_00101645;
LAB_00101689:
param_1 = param_1 + 2;
__ptr = realloc(__ptr,(long)(*param_5 + 1) << 3);
iVar3 = *param_5;
piVar1 = (int *)((long)__ptr + (long)iVar3 * 8);
*piVar1 = param_3;
piVar1[1] = param_4;
*param_5 = iVar3 + 1;
if (param_1 == piVar2) {
return __ptr;
}
}
if (param_3 < param_4) goto LAB_00101689;
LAB_00101645:
param_1 = param_1 + 2;
if (param_1 == piVar2) {
return __ptr;
}
} while( true );
} |
4,335 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = test_list[i].first;
(*res_size)++;
strt_val = test_list[i].second;
}
if(strt_val < stop_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first = strt_val;
res[*res_size].second = stop_val;
(*res_size)++;
}
}
return res;
}
| int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first);
assert(result1[i].second == expected1[i].second);
}
free(result1);
// Test 2
pair test2[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size2;
pair* result2 = func0(test2, 3, 5, 60, &res_size2);
pair expected2[] = { {5, 7}, {2, 60}, {2, 15}, {19, 60}, {19, 38}, {50, 60} };
assert(res_size2 == 6);
for(int i = 0; i < 6; i++) {
assert(result2[i].first == expected2[i].first);
assert(result2[i].second == expected2[i].second);
}
free(result2);
// Test 3
pair test3[] = { {7, 2}, {15, 19}, {38, 50} };
int res_size3;
pair* result3 = func0(test3, 3, 1, 52, &res_size3);
pair expected3[] = { {1, 7}, {2, 52}, {2, 15}, {19, 52}, {19, 38}, {50, 52} };
assert(res_size3 == 6);
for(int i = 0; i < 6; i++) {
assert(result3[i].first == expected3[i].first);
assert(result3[i].second == expected3[i].second);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
movl $0x0,(%r8)
test %esi,%esi
jle 1770 <func0+0xd0>
push %r15
lea -0x1(%rsi),%eax
push %r14
mov %r8,%r14
push %r13
lea 0x8(%rdi,%rax,8),%r13
push %r12
mov %ecx,%r12d
push %rbp
mov %edx,%ebp
push %rbx
mov %rdi,%rbx
xor %edi,%edi
sub $0x8,%rsp
jmp 16ee <func0+0x4e>
nopl 0x0(%rax,%rax,1)
cmp %r12d,%ebp
jl 1729 <func0+0x89>
add $0x8,%rbx
cmp %r13,%rbx
je 175d <func0+0xbd>
mov (%rbx),%r15d
cmp %ebp,%r15d
jle 16e0 <func0+0x40>
mov (%r14),%eax
lea 0x1(%rax),%esi
movslq %esi,%rsi
shl $0x3,%rsi
callq 10b0 <realloc@plt>
movslq (%r14),%rdx
mov %rax,%rdi
mov %rdx,%rax
lea (%rdi,%rdx,8),%rdx
add $0x1,%eax
mov %ebp,(%rdx)
mov %eax,(%r14)
mov 0x4(%rbx),%ebp
mov %r15d,0x4(%rdx)
cmp %r12d,%ebp
jge 16e5 <func0+0x45>
mov (%r14),%eax
add $0x8,%rbx
lea 0x1(%rax),%esi
movslq %esi,%rsi
shl $0x3,%rsi
callq 10b0 <realloc@plt>
movslq (%r14),%rdx
mov %rax,%rdi
mov %rdx,%rax
lea (%rdi,%rdx,8),%rdx
add $0x1,%eax
mov %ebp,(%rdx)
mov %r12d,0x4(%rdx)
mov %eax,(%r14)
cmp %r13,%rbx
jne 16ee <func0+0x4e>
add $0x8,%rsp
mov %rdi,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %edi,%edi
mov %rdi,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov dword ptr [r8], 0
test esi, esi
jle loc_1600
push r15
movsxd rsi, esi
push r14
mov r14, r8
push r13
mov r13d, ecx
push r12
lea r12, [rdi+rsi*8]
push rbp
mov ebp, edx
push rbx
mov rbx, rdi
xor edi, edi; ptr
sub rsp, 8
jmp short loc_156E
loc_1560:
cmp ebp, r13d
jl short loc_15B1
loc_1565:
add rbx, 8
cmp rbx, r12
jz short loc_15E5
loc_156E:
mov r15d, [rbx]
cmp r15d, ebp
jle short loc_1560
mov eax, [r14]
lea esi, [rax+1]
movsxd rsi, esi
shl rsi, 3; size
call _realloc
movsxd rdx, dword ptr [r14]
movd xmm0, ebp
movd xmm1, r15d
mov rdi, rax; ptr
punpckldq xmm0, xmm1
mov rax, rdx
movq qword ptr [rdi+rdx*8], xmm0
add eax, 1
mov [r14], eax
mov ebp, [rbx+4]
cmp ebp, r13d
jge short loc_1565
loc_15B1:
mov eax, [r14]
add rbx, 8
lea esi, [rax+1]
movsxd rsi, esi
shl rsi, 3; size
call _realloc
movsxd rdx, dword ptr [r14]
mov rdi, rax
mov rax, rdx
lea rdx, [rdi+rdx*8]
add eax, 1
mov [rdx], ebp
mov [rdx+4], r13d
mov [r14], eax
cmp rbx, r12
jnz short loc_156E
loc_15E5:
add rsp, 8
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1600:
xor eax, eax
retn | char * func0(unsigned int *a1, int a2, signed int a3, signed int a4, int *a5)
{
unsigned int *v7; // r12
unsigned int *v9; // rbx
char *v10; // rdi
unsigned int v11; // r15d
int v12; // eax
signed int *v13; // rdx
int v14; // eax
*a5 = 0;
if ( a2 > 0 )
{
v7 = &a1[2 * a2];
v9 = a1;
v10 = 0LL;
while ( 1 )
{
v11 = *v9;
if ( (int)*v9 <= a3 )
{
if ( a3 >= a4 )
goto LABEL_4;
LABEL_7:
v9 += 2;
v10 = (char *)realloc(v10, 8LL * (*a5 + 1));
v13 = (signed int *)&v10[8 * *a5];
v14 = *a5 + 1;
*v13 = a3;
v13[1] = a4;
*a5 = v14;
if ( v9 == v7 )
return v10;
}
else
{
v10 = (char *)realloc(v10, 8LL * (*a5 + 1));
v12 = *a5;
*(_QWORD *)&v10[8 * *a5] = _mm_unpacklo_epi32(_mm_cvtsi32_si128(a3), _mm_cvtsi32_si128(v11)).m128i_u64[0];
*a5 = v12 + 1;
a3 = v9[1];
if ( a3 < a4 )
goto LABEL_7;
LABEL_4:
v9 += 2;
if ( v9 == v7 )
return v10;
}
}
}
return 0LL;
} | func0:
ENDBR64
MOV dword ptr [R8],0x0
TEST ESI,ESI
JLE 0x00101600
PUSH R15
MOVSXD RSI,ESI
PUSH R14
MOV R14,R8
PUSH R13
MOV R13D,ECX
PUSH R12
LEA R12,[RDI + RSI*0x8]
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RDI
XOR EDI,EDI
SUB RSP,0x8
JMP 0x0010156e
LAB_00101560:
CMP EBP,R13D
JL 0x001015b1
LAB_00101565:
ADD RBX,0x8
CMP RBX,R12
JZ 0x001015e5
LAB_0010156e:
MOV R15D,dword ptr [RBX]
CMP R15D,EBP
JLE 0x00101560
MOV EAX,dword ptr [R14]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010b0
MOVSXD RDX,dword ptr [R14]
MOVD XMM0,EBP
MOVD XMM1,R15D
MOV RDI,RAX
PUNPCKLDQ XMM0,XMM1
MOV RAX,RDX
MOVQ qword ptr [RDI + RDX*0x8],XMM0
ADD EAX,0x1
MOV dword ptr [R14],EAX
MOV EBP,dword ptr [RBX + 0x4]
CMP EBP,R13D
JGE 0x00101565
LAB_001015b1:
MOV EAX,dword ptr [R14]
ADD RBX,0x8
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010b0
MOVSXD RDX,dword ptr [R14]
MOV RDI,RAX
MOV RAX,RDX
LEA RDX,[RDI + RDX*0x8]
ADD EAX,0x1
MOV dword ptr [RDX],EBP
MOV dword ptr [RDX + 0x4],R13D
MOV dword ptr [R14],EAX
CMP RBX,R12
JNZ 0x0010156e
LAB_001015e5:
ADD RSP,0x8
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101600:
XOR EAX,EAX
RET | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
*param_5 = 0;
if (param_2 < 1) {
return (void *)0x0;
}
piVar1 = param_1 + (long)param_2 * 2;
__ptr = (void *)0x0;
do {
while (iVar3 = *param_1, param_3 < iVar3) {
__ptr = realloc(__ptr,(long)(*param_5 + 1) << 3);
iVar4 = *param_5;
*(ulong *)((long)__ptr + (long)iVar4 * 8) = CONCAT44(iVar3,param_3);
*param_5 = iVar4 + 1;
param_3 = param_1[1];
if (param_4 <= param_3) goto LAB_00101565;
LAB_001015b1:
param_1 = param_1 + 2;
__ptr = realloc(__ptr,(long)(*param_5 + 1) << 3);
iVar3 = *param_5;
piVar2 = (int *)((long)__ptr + (long)iVar3 * 8);
*piVar2 = param_3;
piVar2[1] = param_4;
*param_5 = iVar3 + 1;
if (param_1 == piVar1) {
return __ptr;
}
}
if (param_3 < param_4) goto LAB_001015b1;
LAB_00101565:
param_1 = param_1 + 2;
if (param_1 == piVar1) {
return __ptr;
}
} while( true );
} |
4,336 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize result with first list
int *temp = malloc(sizes[0] * sizeof(int));
int temp_size = 0;
for(int i = 0; i < sizes[0]; i++) {
if (i == 0 || nestedlist[0][i] != nestedlist[0][i-1]) {
temp[temp_size++] = nestedlist[0][i];
}
}
// Iterate through other lists and find intersection
for(int i = 1; i < num_lists; i++) {
int *new_temp = malloc(temp_size * sizeof(int));
int new_size = 0;
int j = 0, k = 0;
while(j < temp_size && k < sizes[i]) {
if(temp[j] < nestedlist[i][k]) {
j++;
}
else if(temp[j] > nestedlist[i][k]) {
k++;
}
else {
new_temp[new_size++] = temp[j];
j++;
k++;
}
}
free(temp);
temp = new_temp;
temp_size = new_size;
if(temp_size == 0) break;
}
*result_size = temp_size;
return temp;
}
| int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1, &result_size1);
qsort(result1, result_size1, sizeof(int), cmpfunc);
assert(result_size1 == 2 && result1[0] == 12 && result1[1] == 18);
free(result1);
// Second test case
int list2_1[] = {12, 5, 23, 25, 45};
int list2_2[] = {7, 11, 5, 23, 28};
int list2_3[] = {1, 5, 8, 18, 23, 16};
int *nested2[] = {list2_1, list2_2, list2_3};
int sizes2[] = {5, 5, 6};
int result_size2;
int *result2 = func0(nested2, 3, sizes2, &result_size2);
qsort(result2, result_size2, sizeof(int), cmpfunc);
assert(result_size2 == 2 && result2[0] == 5 && result2[1] == 23);
free(result2);
// Third test case
int list3_1[] = {2, 3, 4, 1};
int list3_2[] = {4, 5};
int list3_3[] = {6, 4, 8};
int list3_4[] = {4, 5};
int list3_5[] = {6, 8, 4};
int *nested3[] = {list3_1, list3_2, list3_3, list3_4, list3_5};
int sizes3[] = {4, 2, 3, 2, 3};
int result_size3;
int *result3 = func0(nested3, 5, sizes3, &result_size3);
qsort(result3, result_size3, sizeof(int), cmpfunc);
assert(result_size3 == 1 && result3[0] == 4);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %rcx,-0x50(%rbp)
cmpl $0x0,-0x3c(%rbp)
jne 1220 <func0+0x35>
mov -0x50(%rbp),%rax
movl $0x0,(%rax)
mov $0x0,%eax
jmpq 1489 <func0+0x29e>
movl $0x0,-0x2c(%rbp)
jmp 1271 <func0+0x86>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
movslq %eax,%rsi
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
lea -0x97(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1229 <func0+0x3e>
mov -0x48(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x28(%rbp)
movl $0x0,-0x24(%rbp)
jmp 1312 <func0+0x127>
cmpl $0x0,-0x24(%rbp)
je 12db <func0+0xf0>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
sub $0x4,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 130e <func0+0x123>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea (%rax,%rdx,1),%rcx
mov -0x28(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x28(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x24(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x24(%rbp)
jl 12a1 <func0+0xb6>
movl $0x1,-0x20(%rbp)
jmpq 146d <func0+0x282>
mov -0x28(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 1422 <func0+0x237>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 13a1 <func0+0x1b6>
addl $0x1,-0x18(%rbp)
jmpq 1422 <func0+0x237>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 13e7 <func0+0x1fc>
addl $0x1,-0x14(%rbp)
jmp 1422 <func0+0x237>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x18(%rbp),%eax
cmp -0x28(%rbp),%eax
jge 1449 <func0+0x25e>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x14(%rbp)
jl 1358 <func0+0x16d>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x8(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x28(%rbp)
cmpl $0x0,-0x28(%rbp)
je 147b <func0+0x290>
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1329 <func0+0x13e>
jmp 147c <func0+0x291>
mov -0x50(%rbp),%rax
mov -0x28(%rbp),%edx
mov %edx,(%rax)
mov -0x10(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_50], rcx
cmp [rbp+var_3C], 0
jnz short loc_1220
mov rax, [rbp+var_50]
mov dword ptr [rax], 0
mov eax, 0
jmp locret_148C
loc_1220:
mov [rbp+var_2C], 0
jmp short loc_1274
loc_1229:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
movsxd rsi, eax; nmemb
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
lea rdx, cmpfunc
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
add [rbp+var_2C], 1
loc_1274:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_3C]
jl short loc_1229
mov rax, [rbp+var_48]
mov eax, [rax]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_28], 0
mov [rbp+var_24], 0
jmp short loc_1315
loc_12A4:
cmp [rbp+var_24], 0
jz short loc_12DE
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_24]
movsxd rcx, ecx
shl rcx, 2
sub rcx, 4
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1311
loc_12DE:
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
shl rdx, 2
lea rcx, [rax+rdx]
mov eax, [rbp+var_28]
lea edx, [rax+1]
mov [rbp+var_28], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1311:
add [rbp+var_24], 1
loc_1315:
mov rax, [rbp+var_48]
mov eax, [rax]
cmp [rbp+var_24], eax
jl short loc_12A4
mov [rbp+var_20], 1
jmp loc_1470
loc_132C:
mov eax, [rbp+var_28]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_1425
loc_135B:
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_20]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_14]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_13A4
add [rbp+var_18], 1
jmp loc_1425
loc_13A4:
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_20]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_14]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_13EA
add [rbp+var_14], 1
jmp short loc_1425
loc_13EA:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
lea rcx, [rdx+rax]
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_18], 1
add [rbp+var_14], 1
loc_1425:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_28]
jge short loc_144C
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_14], eax
jl loc_135B
loc_144C:
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
mov [rbp+ptr], rax
mov eax, [rbp+var_1C]
mov [rbp+var_28], eax
cmp [rbp+var_28], 0
jz short loc_147E
add [rbp+var_20], 1
loc_1470:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_3C]
jl loc_132C
jmp short loc_147F
loc_147E:
nop
loc_147F:
mov rax, [rbp+var_50]
mov edx, [rbp+var_28]
mov [rax], edx
mov rax, [rbp+ptr]
locret_148C:
leave
retn | _DWORD * func0(_QWORD *a1, int a2, int *a3, _DWORD *a4)
{
int v5; // eax
int v6; // eax
int i; // [rsp+24h] [rbp-2Ch]
int v10; // [rsp+28h] [rbp-28h]
int j; // [rsp+2Ch] [rbp-24h]
int k; // [rsp+30h] [rbp-20h]
int v13; // [rsp+34h] [rbp-1Ch]
int v14; // [rsp+38h] [rbp-18h]
int v15; // [rsp+3Ch] [rbp-14h]
_DWORD *ptr; // [rsp+40h] [rbp-10h]
_DWORD *v17; // [rsp+48h] [rbp-8h]
if ( a2 )
{
for ( i = 0; i < a2; ++i )
qsort((void *)a1[i], a3[i], 4uLL, cmpfunc);
ptr = malloc(4LL * *a3);
v10 = 0;
for ( j = 0; j < *a3; ++j )
{
if ( !j || *(_DWORD *)(4LL * j + *a1) != *(_DWORD *)(4LL * j - 4 + *a1) )
{
v5 = v10++;
ptr[v5] = *(_DWORD *)(*a1 + 4LL * j);
}
}
for ( k = 1; k < a2; ++k )
{
v17 = malloc(4LL * v10);
v13 = 0;
v14 = 0;
v15 = 0;
while ( v14 < v10 && v15 < a3[k] )
{
if ( ptr[v14] >= *(_DWORD *)(4LL * v15 + a1[k]) )
{
if ( ptr[v14] <= *(_DWORD *)(4LL * v15 + a1[k]) )
{
v6 = v13++;
v17[v6] = ptr[v14++];
}
++v15;
}
else
{
++v14;
}
}
free(ptr);
ptr = v17;
v10 = v13;
if ( !v13 )
break;
}
*a4 = v10;
return ptr;
}
else
{
*a4 = 0;
return 0LL;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00101220
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x0
MOV EAX,0x0
JMP 0x0010148c
LAB_00101220:
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101274
LAB_00101229:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOVSXD RSI,EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010a0
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101274:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101229
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101315
LAB_001012a4:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001012de
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x24]
MOVSXD RCX,ECX
SHL RCX,0x2
SUB RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101311
LAB_001012de:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
SHL RDX,0x2
LEA RCX,[RAX + RDX*0x1]
MOV EAX,dword ptr [RBP + -0x28]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x28],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101311:
ADD dword ptr [RBP + -0x24],0x1
LAB_00101315:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x24],EAX
JL 0x001012a4
MOV dword ptr [RBP + -0x20],0x1
JMP 0x00101470
LAB_0010132c:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101425
LAB_0010135b:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001013a4
ADD dword ptr [RBP + -0x18],0x1
JMP 0x00101425
LAB_001013a4:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001013ea
ADD dword ptr [RBP + -0x14],0x1
JMP 0x00101425
LAB_001013ea:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],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
ADD dword ptr [RBP + -0x18],0x1
ADD dword ptr [RBP + -0x14],0x1
LAB_00101425:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x28]
JGE 0x0010144c
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x14],EAX
JL 0x0010135b
LAB_0010144c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x28],0x0
JZ 0x0010147e
ADD dword ptr [RBP + -0x20],0x1
LAB_00101470:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010132c
JMP 0x0010147f
LAB_0010147e:
NOP
LAB_0010147f:
MOV RAX,qword ptr [RBP + -0x50]
MOV EDX,dword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x10]
LAB_0010148c:
LEAVE
RET | void * func0(long *param_1,int param_2,int *param_3,int *param_4)
{
void *pvVar1;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
void *local_18;
if (param_2 == 0) {
*param_4 = 0;
local_18 = (void *)0x0;
}
else {
for (local_34 = 0; local_34 < param_2; local_34 = local_34 + 1) {
qsort((void *)param_1[local_34],(long)param_3[local_34],4,cmpfunc);
}
local_18 = malloc((long)*param_3 << 2);
local_30 = 0;
for (local_2c = 0; local_2c < *param_3; local_2c = local_2c + 1) {
if ((local_2c == 0) ||
(*(int *)(*param_1 + (long)local_2c * 4) != *(int *)(*param_1 + (long)local_2c * 4 + -4)))
{
*(int4 *)((long)local_30 * 4 + (long)local_18) =
*(int4 *)(*param_1 + (long)local_2c * 4);
local_30 = local_30 + 1;
}
}
for (local_28 = 1; local_28 < param_2; local_28 = local_28 + 1) {
pvVar1 = malloc((long)local_30 << 2);
local_24 = 0;
local_20 = 0;
local_1c = 0;
while ((local_20 < local_30 && (local_1c < param_3[local_28]))) {
if (*(int *)((long)local_18 + (long)local_20 * 4) <
*(int *)(param_1[local_28] + (long)local_1c * 4)) {
local_20 = local_20 + 1;
}
else if (*(int *)(param_1[local_28] + (long)local_1c * 4) <
*(int *)((long)local_18 + (long)local_20 * 4)) {
local_1c = local_1c + 1;
}
else {
*(int4 *)((long)local_24 * 4 + (long)pvVar1) =
*(int4 *)((long)local_20 * 4 + (long)local_18);
local_20 = local_20 + 1;
local_1c = local_1c + 1;
local_24 = local_24 + 1;
}
}
free(local_18);
local_30 = local_24;
local_18 = pvVar1;
if (local_24 == 0) break;
}
*param_4 = local_30;
}
return local_18;
} |
4,337 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize result with first list
int *temp = malloc(sizes[0] * sizeof(int));
int temp_size = 0;
for(int i = 0; i < sizes[0]; i++) {
if (i == 0 || nestedlist[0][i] != nestedlist[0][i-1]) {
temp[temp_size++] = nestedlist[0][i];
}
}
// Iterate through other lists and find intersection
for(int i = 1; i < num_lists; i++) {
int *new_temp = malloc(temp_size * sizeof(int));
int new_size = 0;
int j = 0, k = 0;
while(j < temp_size && k < sizes[i]) {
if(temp[j] < nestedlist[i][k]) {
j++;
}
else if(temp[j] > nestedlist[i][k]) {
k++;
}
else {
new_temp[new_size++] = temp[j];
j++;
k++;
}
}
free(temp);
temp = new_temp;
temp_size = new_size;
if(temp_size == 0) break;
}
*result_size = temp_size;
return temp;
}
| int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1, &result_size1);
qsort(result1, result_size1, sizeof(int), cmpfunc);
assert(result_size1 == 2 && result1[0] == 12 && result1[1] == 18);
free(result1);
// Second test case
int list2_1[] = {12, 5, 23, 25, 45};
int list2_2[] = {7, 11, 5, 23, 28};
int list2_3[] = {1, 5, 8, 18, 23, 16};
int *nested2[] = {list2_1, list2_2, list2_3};
int sizes2[] = {5, 5, 6};
int result_size2;
int *result2 = func0(nested2, 3, sizes2, &result_size2);
qsort(result2, result_size2, sizeof(int), cmpfunc);
assert(result_size2 == 2 && result2[0] == 5 && result2[1] == 23);
free(result2);
// Third test case
int list3_1[] = {2, 3, 4, 1};
int list3_2[] = {4, 5};
int list3_3[] = {6, 4, 8};
int list3_4[] = {4, 5};
int list3_5[] = {6, 8, 4};
int *nested3[] = {list3_1, list3_2, list3_3, list3_4, list3_5};
int sizes3[] = {4, 2, 3, 2, 3};
int result_size3;
int *result3 = func0(nested3, 5, sizes3, &result_size3);
qsort(result3, result_size3, sizeof(int), cmpfunc);
assert(result_size3 == 1 && result3[0] == 4);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rcx,(%rsp)
test %esi,%esi
jne 120e <func0+0x3c>
mov (%rsp),%rax
movl $0x0,(%rax)
mov $0x0,%r13d
mov %r13,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rdi,%rbp
mov %esi,%r13d
mov %rdx,%r12
lea -0x1(%rsi),%r15d
mov $0x0,%ebx
lea -0x5e(%rip),%r14
jle 124b <func0+0x79>
movslq (%r12,%rbx,4),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
mov %r14,%rcx
mov $0x4,%edx
callq 10a0 <qsort@plt>
mov %rbx,%rax
add $0x1,%rbx
cmp %r15,%rax
jne 1229 <func0+0x57>
movslq (%r12),%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r14
mov (%r12),%edi
test %edi,%edi
jle 12a3 <func0+0xd1>
mov $0x0,%edx
mov $0x0,%eax
mov $0x0,%ebx
jmp 1290 <func0+0xbe>
mov 0x0(%rbp),%rcx
mov (%rcx,%rdx,1),%esi
movslq %ebx,%rcx
mov %esi,(%r14,%rcx,4)
lea 0x1(%rbx),%ebx
add $0x1,%eax
add $0x4,%rdx
cmp %edi,%eax
je 12a8 <func0+0xd6>
test %eax,%eax
je 1274 <func0+0xa2>
mov 0x0(%rbp),%rcx
mov -0x4(%rcx,%rdx,1),%esi
cmp %esi,(%rcx,%rdx,1)
jne 1274 <func0+0xa2>
jmp 1285 <func0+0xb3>
mov $0x0,%ebx
cmp $0x1,%r13d
jle 135f <func0+0x18d>
lea 0x4(%r12),%r15
lea 0x8(%rbp),%r12
lea -0x2(%r13),%eax
lea 0x10(%rbp,%rax,8),%rax
mov %rax,0x8(%rsp)
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r13
test %ebx,%ebx
jle 1366 <func0+0x194>
mov (%r15),%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov $0x0,%ebp
jmp 12fd <func0+0x12b>
jle 131c <func0+0x14a>
add $0x1,%ecx
cmp %ebx,%edx
jge 132f <func0+0x15d>
cmp %ecx,%r8d
jle 132f <func0+0x15d>
movslq %edx,%rax
mov (%r14,%rax,4),%esi
movslq %ecx,%rax
mov (%r12),%rdi
mov (%rdi,%rax,4),%eax
cmp %eax,%esi
jge 12f4 <func0+0x122>
add $0x1,%edx
jmp 12f9 <func0+0x127>
movslq %ebp,%rax
mov %esi,0x0(%r13,%rax,4)
add $0x1,%edx
add $0x1,%ecx
lea 0x1(%rbp),%ebp
jmp 12f9 <func0+0x127>
mov %r14,%rdi
callq 1090 <free@plt>
test %ebp,%ebp
jne 1346 <func0+0x174>
mov (%rsp),%rax
mov %ebp,(%rax)
jmpq 11fc <func0+0x2a>
add $0x4,%r15
add $0x8,%r12
cmp 0x8(%rsp),%r12
je 133b <func0+0x169>
mov %ebp,%ebx
mov %r13,%r14
jmpq 12c9 <func0+0xf7>
mov %ebx,%ebp
mov %r14,%r13
jmp 133b <func0+0x169>
mov %r14,%rdi
callq 1090 <free@plt>
mov $0x0,%ebp
jmp 133b <func0+0x169>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov ebp, esi
mov [rsp+48h+var_48], rcx
mov r15d, 0
test esi, esi
jnz short loc_120C
loc_11F4:
mov rax, [rsp+48h+var_48]
mov [rax], ebp
mov rax, r15
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_120C:
mov r12, rdi
mov r14, rdx
jle short loc_1241
mov r15d, esi
mov ebx, 0
lea r13, cmpfunc
loc_1223:
movsxd rsi, dword ptr [r14+rbx*4]
mov rdi, [r12+rbx*8]
mov rcx, r13
mov edx, 4
call _qsort
add rbx, 1
cmp rbx, r15
jnz short loc_1223
loc_1241:
movsxd rdi, dword ptr [r14]
shl rdi, 2
call _malloc
mov r13, rax
mov edi, [r14]
test edi, edi
jle short loc_1298
mov edx, 0
mov eax, 0
mov ebx, 0
jmp short loc_1285
loc_1268:
mov rcx, [r12]
mov esi, [rcx+rdx]
movsxd rcx, ebx
mov [r13+rcx*4+0], esi
lea ebx, [rbx+1]
loc_127A:
add eax, 1
add rdx, 4
cmp eax, edi
jz short loc_129D
loc_1285:
test eax, eax
jz short loc_1268
mov rcx, [r12]
mov esi, [rcx+rdx-4]
cmp [rcx+rdx], esi
jnz short loc_1268
jmp short loc_127A
loc_1298:
mov ebx, 0
loc_129D:
cmp ebp, 1
jle loc_1353
lea rax, [r14+4]
mov [rsp+48h+var_40], rax
lea r14, [r12+8]
lea eax, [rbp-2]
lea r12, [r12+rax*8+10h]
loc_12BC:
movsxd rdi, ebx
shl rdi, 2
call _malloc
mov r15, rax
test ebx, ebx
jle loc_135D
mov rax, [rsp+48h+var_40]
mov r8d, [rax]
mov ecx, 0
mov edx, 0
mov ebp, 0
jmp short loc_12F5
loc_12EC:
jle short loc_1314
add ecx, 1
loc_12F1:
cmp edx, ebx
jge short loc_1326
loc_12F5:
cmp r8d, ecx
jle short loc_1326
movsxd rax, edx
mov esi, [r13+rax*4+0]
movsxd rax, ecx
mov rdi, [r14]
mov eax, [rdi+rax*4]
cmp esi, eax
jge short loc_12EC
add edx, 1
jmp short loc_12F1
loc_1314:
movsxd rax, ebp
mov [r15+rax*4], esi
add edx, 1
add ecx, 1
lea ebp, [rbp+1]
jmp short loc_12F1
loc_1326:
mov rdi, r13
call _free
test ebp, ebp
jz loc_11F4
add [rsp+48h+var_40], 4
add r14, 8
cmp r12, r14
jz loc_11F4
mov ebx, ebp
mov r13, r15
jmp loc_12BC
loc_1353:
mov ebp, ebx
mov r15, r13
jmp loc_11F4
loc_135D:
mov rdi, r13
call _free
mov ebp, 0
jmp loc_11F4 | long long func0(_QWORD *a1, int a2, int *a3, int *a4)
{
int v4; // ebp
long long v5; // r15
long long i; // rbx
long long v10; // r13
int v11; // edi
long long v12; // rdx
int v13; // eax
int v14; // ebx
_QWORD *v15; // r14
long long v16; // r12
int v17; // r8d
int v18; // ecx
int v19; // edx
int v20; // esi
int v21; // eax
int *v23; // [rsp+8h] [rbp-40h]
v4 = a2;
v5 = 0LL;
if ( a2 )
{
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
qsort(a1[i], a3[i], 4LL, cmpfunc);
}
v10 = malloc(4LL * *a3);
v11 = *a3;
if ( *a3 <= 0 )
{
v14 = 0;
}
else
{
v12 = 0LL;
v13 = 0;
v14 = 0;
do
{
if ( !v13 || *(_DWORD *)(*a1 + v12) != *(_DWORD *)(*a1 + v12 - 4) )
*(_DWORD *)(v10 + 4LL * v14++) = *(_DWORD *)(*a1 + v12);
++v13;
v12 += 4LL;
}
while ( v13 != v11 );
}
if ( a2 <= 1 )
{
v4 = v14;
v5 = v10;
}
else
{
v23 = a3 + 1;
v15 = a1 + 1;
v16 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
while ( 1 )
{
v5 = malloc(4LL * v14);
if ( v14 <= 0 )
break;
v17 = *v23;
v18 = 0;
v19 = 0;
v4 = 0;
do
{
if ( v17 <= v18 )
break;
v20 = *(_DWORD *)(v10 + 4LL * v19);
v21 = *(_DWORD *)(*v15 + 4LL * v18);
if ( v20 >= v21 )
{
if ( v20 <= v21 )
{
*(_DWORD *)(v5 + 4LL * v4) = v20;
++v19;
++v18;
++v4;
}
else
{
++v18;
}
}
else
{
++v19;
}
}
while ( v19 < v14 );
free(v10);
if ( !v4 )
goto LABEL_2;
++v23;
if ( (_QWORD *)v16 == ++v15 )
goto LABEL_2;
v14 = v4;
v10 = v5;
}
free(v10);
v4 = 0;
}
}
LABEL_2:
*a4 = v4;
return v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV EBP,ESI
MOV qword ptr [RSP],RCX
MOV R15D,0x0
TEST ESI,ESI
JNZ 0x0010120c
LAB_001011f4:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX],EBP
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010120c:
MOV R12,RDI
MOV R14,RDX
JLE 0x00101241
MOV R15D,ESI
MOV EBX,0x0
LEA R13,[0x1011c9]
LAB_00101223:
MOVSXD RSI,dword ptr [R14 + RBX*0x4]
MOV RDI,qword ptr [R12 + RBX*0x8]
MOV RCX,R13
MOV EDX,0x4
CALL 0x001010a0
ADD RBX,0x1
CMP RBX,R15
JNZ 0x00101223
LAB_00101241:
MOVSXD RDI,dword ptr [R14]
SHL RDI,0x2
CALL 0x001010d0
MOV R13,RAX
MOV EDI,dword ptr [R14]
TEST EDI,EDI
JLE 0x00101298
MOV EDX,0x0
MOV EAX,0x0
MOV EBX,0x0
JMP 0x00101285
LAB_00101268:
MOV RCX,qword ptr [R12]
MOV ESI,dword ptr [RCX + RDX*0x1]
MOVSXD RCX,EBX
MOV dword ptr [R13 + RCX*0x4],ESI
LEA EBX,[RBX + 0x1]
LAB_0010127a:
ADD EAX,0x1
ADD RDX,0x4
CMP EAX,EDI
JZ 0x0010129d
LAB_00101285:
TEST EAX,EAX
JZ 0x00101268
MOV RCX,qword ptr [R12]
MOV ESI,dword ptr [RCX + RDX*0x1 + -0x4]
CMP dword ptr [RCX + RDX*0x1],ESI
JNZ 0x00101268
JMP 0x0010127a
LAB_00101298:
MOV EBX,0x0
LAB_0010129d:
CMP EBP,0x1
JLE 0x00101353
LEA RAX,[R14 + 0x4]
MOV qword ptr [RSP + 0x8],RAX
LEA R14,[R12 + 0x8]
LEA EAX,[RBP + -0x2]
LEA R12,[R12 + RAX*0x8 + 0x10]
LAB_001012bc:
MOVSXD RDI,EBX
SHL RDI,0x2
CALL 0x001010d0
MOV R15,RAX
TEST EBX,EBX
JLE 0x0010135d
MOV RAX,qword ptr [RSP + 0x8]
MOV R8D,dword ptr [RAX]
MOV ECX,0x0
MOV EDX,0x0
MOV EBP,0x0
JMP 0x001012f5
LAB_001012ec:
JLE 0x00101314
ADD ECX,0x1
LAB_001012f1:
CMP EDX,EBX
JGE 0x00101326
LAB_001012f5:
CMP R8D,ECX
JLE 0x00101326
MOVSXD RAX,EDX
MOV ESI,dword ptr [R13 + RAX*0x4]
MOVSXD RAX,ECX
MOV RDI,qword ptr [R14]
MOV EAX,dword ptr [RDI + RAX*0x4]
CMP ESI,EAX
JGE 0x001012ec
ADD EDX,0x1
JMP 0x001012f1
LAB_00101314:
MOVSXD RAX,EBP
MOV dword ptr [R15 + RAX*0x4],ESI
ADD EDX,0x1
ADD ECX,0x1
LEA EBP,[RBP + 0x1]
JMP 0x001012f1
LAB_00101326:
MOV RDI,R13
CALL 0x00101090
TEST EBP,EBP
JZ 0x001011f4
ADD qword ptr [RSP + 0x8],0x4
ADD R14,0x8
CMP R12,R14
JZ 0x001011f4
MOV EBX,EBP
MOV R13,R15
JMP 0x001012bc
LAB_00101353:
MOV EBP,EBX
MOV R15,R13
JMP 0x001011f4
LAB_0010135d:
MOV RDI,R13
CALL 0x00101090
MOV EBP,0x0
JMP 0x001011f4 | void * func0(long *param_1,uint param_2,int *param_3,uint *param_4)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
void *__ptr;
long *plVar10;
void *pvVar11;
int *local_40;
pvVar11 = (void *)0x0;
uVar9 = param_2;
if (param_2 != 0) {
if (0 < (int)param_2) {
uVar8 = 0;
do {
qsort((void *)param_1[uVar8],(long)param_3[uVar8],4,cmpfunc);
uVar8 = uVar8 + 1;
} while (uVar8 != param_2);
}
pvVar11 = malloc((long)*param_3 << 2);
iVar1 = *param_3;
if (iVar1 < 1) {
uVar9 = 0;
}
else {
lVar6 = 0;
iVar4 = 0;
uVar9 = 0;
do {
if ((iVar4 == 0) || (*(int *)(*param_1 + lVar6) != *(int *)(*param_1 + -4 + lVar6))) {
*(int4 *)((long)pvVar11 + (long)(int)uVar9 * 4) = *(int4 *)(*param_1 + lVar6);
uVar9 = uVar9 + 1;
}
iVar4 = iVar4 + 1;
lVar6 = lVar6 + 4;
} while (iVar4 != iVar1);
}
if (1 < (int)param_2) {
local_40 = param_3 + 1;
plVar10 = param_1 + 1;
__ptr = pvVar11;
uVar7 = uVar9;
do {
pvVar11 = malloc((long)(int)uVar7 << 2);
if ((int)uVar7 < 1) {
free(__ptr);
uVar9 = 0;
break;
}
iVar1 = *local_40;
iVar4 = 0;
iVar5 = 0;
uVar9 = 0;
do {
if (iVar1 <= iVar4) break;
iVar2 = *(int *)((long)__ptr + (long)iVar5 * 4);
iVar3 = *(int *)(*plVar10 + (long)iVar4 * 4);
if (iVar2 < iVar3) {
iVar5 = iVar5 + 1;
}
else if (iVar3 < iVar2) {
iVar4 = iVar4 + 1;
}
else {
*(int *)((long)pvVar11 + (long)(int)uVar9 * 4) = iVar2;
iVar5 = iVar5 + 1;
iVar4 = iVar4 + 1;
uVar9 = uVar9 + 1;
}
} while (iVar5 < (int)uVar7);
free(__ptr);
if (uVar9 == 0) break;
local_40 = local_40 + 1;
plVar10 = plVar10 + 1;
__ptr = pvVar11;
uVar7 = uVar9;
} while (param_1 + (ulong)(param_2 - 2) + 2 != plVar10);
}
}
*param_4 = uVar9;
return pvVar11;
} |
4,338 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize result with first list
int *temp = malloc(sizes[0] * sizeof(int));
int temp_size = 0;
for(int i = 0; i < sizes[0]; i++) {
if (i == 0 || nestedlist[0][i] != nestedlist[0][i-1]) {
temp[temp_size++] = nestedlist[0][i];
}
}
// Iterate through other lists and find intersection
for(int i = 1; i < num_lists; i++) {
int *new_temp = malloc(temp_size * sizeof(int));
int new_size = 0;
int j = 0, k = 0;
while(j < temp_size && k < sizes[i]) {
if(temp[j] < nestedlist[i][k]) {
j++;
}
else if(temp[j] > nestedlist[i][k]) {
k++;
}
else {
new_temp[new_size++] = temp[j];
j++;
k++;
}
}
free(temp);
temp = new_temp;
temp_size = new_size;
if(temp_size == 0) break;
}
*result_size = temp_size;
return temp;
}
| int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1, &result_size1);
qsort(result1, result_size1, sizeof(int), cmpfunc);
assert(result_size1 == 2 && result1[0] == 12 && result1[1] == 18);
free(result1);
// Second test case
int list2_1[] = {12, 5, 23, 25, 45};
int list2_2[] = {7, 11, 5, 23, 28};
int list2_3[] = {1, 5, 8, 18, 23, 16};
int *nested2[] = {list2_1, list2_2, list2_3};
int sizes2[] = {5, 5, 6};
int result_size2;
int *result2 = func0(nested2, 3, sizes2, &result_size2);
qsort(result2, result_size2, sizeof(int), cmpfunc);
assert(result_size2 == 2 && result2[0] == 5 && result2[1] == 23);
free(result2);
// Third test case
int list3_1[] = {2, 3, 4, 1};
int list3_2[] = {4, 5};
int list3_3[] = {6, 4, 8};
int list3_4[] = {4, 5};
int list3_5[] = {6, 8, 4};
int *nested3[] = {list3_1, list3_2, list3_3, list3_4, list3_5};
int sizes3[] = {4, 2, 3, 2, 3};
int result_size3;
int *result3 = func0(nested3, 5, sizes3, &result_size3);
qsort(result3, result_size3, sizeof(int), cmpfunc);
assert(result_size3 == 1 && result3[0] == 4);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
je 17b0 <func0+0x10>
jmpq 1600 <func0.part.0>
nopl (%rax)
movl $0x0,(%rcx)
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0_part_0:
push r15
mov r15, rdi
push r14
movsxd r14, esi
push r13
lea r13, cmpfunc
push r12
xor r12d, r12d
push rbp
mov rbp, r14
push rbx
mov rbx, rdx
sub rsp, 18h
mov [rsp+48h+var_40], rcx
test r14d, r14d
jle short loc_164E
xchg ax, ax
loc_1630:
movsxd rsi, dword ptr [rbx+r12*4]
mov rdi, [r15+r12*8]
mov rcx, r13
mov edx, 4
add r12, 1
call _qsort
cmp r12, r14
jnz short loc_1630
loc_164E:
movsxd rdi, dword ptr [rbx]
shl rdi, 2
call _malloc
mov r9d, [rbx]
mov r12, rax
test r9d, r9d
jle loc_1763
mov rcx, [r15]
xor edx, edx
xor r13d, r13d
xor eax, eax
nop dword ptr [rax+rax+00h]
loc_1678:
test eax, eax
jz short loc_1685
mov edi, [rcx+rdx-4]
cmp [rcx+rdx], edi
jz short loc_1693
loc_1685:
mov edi, [rcx+rdx]
movsxd rsi, r13d
add r13d, 1
mov [r12+rsi*4], edi
loc_1693:
add eax, 1
add rdx, 4
cmp eax, r9d
jnz short loc_1678
cmp ebp, 1
jle loc_1749
lea eax, [rbp-2]
add rbx, 4
lea r14, [r15+8]
lea rax, [r15+rax*8+10h]
mov [rsp+48h+var_48], rax
nop dword ptr [rax+00h]
loc_16C0:
movsxd rdi, r13d
mov r15, r12
shl rdi, 2
call _malloc
mov r12, rax
test r13d, r13d
jz loc_1775
mov edi, [rbx]
xor ebp, ebp
xor ecx, ecx
xor edx, edx
jmp short loc_16F0
loc_16E8:
add edx, 1
loc_16EB:
cmp edx, r13d
jge short loc_1728
loc_16F0:
cmp edi, ecx
jle short loc_1728
movsxd rax, edx
mov r10, [r14]
mov esi, [r15+rax*4]
movsxd rax, ecx
mov eax, [r10+rax*4]
cmp esi, eax
jl short loc_16E8
add ecx, 1
cmp esi, eax
jg short loc_16EB
movsxd rax, ebp
add edx, 1
add ebp, 1
mov [r12+rax*4], esi
cmp edx, r13d
jl short loc_16F0
nop word ptr [rax+rax+00h]
loc_1728:
mov rdi, r15
mov r13d, ebp
call _free
test ebp, ebp
jz short loc_1749
add rbx, 4
add r14, 8
cmp r14, [rsp+48h+var_48]
jnz loc_16C0
loc_1749:
mov rax, [rsp+48h+var_40]
mov [rax], r13d
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1763:
cmp ebp, 1
jle short loc_1782
xor edi, edi
mov r15, r12
call _malloc
mov r12, rax
loc_1775:
mov rdi, r15
xor r13d, r13d
call _free
jmp short loc_1749
loc_1782:
xor r13d, r13d
jmp short loc_1749 | long long func0_part_0(long long *a1, int a2, int *a3, _DWORD *a4)
{
long long v5; // r14
long long v6; // r12
long long v9; // rsi
long long v10; // rdi
long long v11; // rax
int v12; // r9d
long long v13; // r12
long long v14; // rcx
long long v15; // rdx
int v16; // r13d
int v17; // eax
long long v18; // rsi
int *v19; // rbx
_QWORD *v20; // r14
long long v21; // r15
int v22; // edi
int v23; // ebp
int v24; // ecx
int v25; // edx
int v26; // esi
int v27; // eax
long long v28; // rax
long long v30; // [rsp+0h] [rbp-48h]
v5 = a2;
v6 = 0LL;
if ( a2 > 0 )
{
do
{
v9 = a3[v6];
v10 = a1[v6++];
qsort(v10, v9, 4LL, cmpfunc);
}
while ( v6 != v5 );
}
v11 = malloc(4LL * *a3);
v12 = *a3;
v13 = v11;
if ( *a3 <= 0 )
{
if ( a2 <= 1 )
{
v16 = 0;
goto LABEL_21;
}
v21 = v11;
v13 = malloc(0LL);
LABEL_24:
v16 = 0;
free(v21);
goto LABEL_21;
}
v14 = *a1;
v15 = 0LL;
v16 = 0;
v17 = 0;
do
{
if ( !v17 || *(_DWORD *)(v14 + v15) != *(_DWORD *)(v14 + v15 - 4) )
{
v18 = v16++;
*(_DWORD *)(v13 + 4 * v18) = *(_DWORD *)(v14 + v15);
}
++v17;
v15 += 4LL;
}
while ( v17 != v12 );
if ( a2 > 1 )
{
v19 = a3 + 1;
v20 = a1 + 1;
v30 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
while ( 1 )
{
v21 = v13;
v13 = malloc(4LL * v16);
if ( !v16 )
goto LABEL_24;
v22 = *v19;
v23 = 0;
v24 = 0;
v25 = 0;
while ( v22 > v24 )
{
v26 = *(_DWORD *)(v21 + 4LL * v25);
v27 = *(_DWORD *)(*v20 + 4LL * v24);
if ( v26 < v27 )
{
++v25;
LABEL_14:
if ( v25 >= v16 )
break;
}
else
{
++v24;
if ( v26 > v27 )
goto LABEL_14;
v28 = v23;
++v25;
++v23;
*(_DWORD *)(v13 + 4 * v28) = v26;
if ( v25 >= v16 )
break;
}
}
v16 = v23;
free(v21);
if ( v23 )
{
++v19;
if ( ++v20 != (_QWORD *)v30 )
continue;
}
break;
}
}
LABEL_21:
*a4 = v16;
return v13;
} | func0.part.0:
PUSH R15
MOV R15,RDI
PUSH R14
MOVSXD R14,ESI
PUSH R13
LEA R13,[0x1015f0]
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,R14
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
TEST R14D,R14D
JLE 0x0010164e
NOP
LAB_00101630:
MOVSXD RSI,dword ptr [RBX + R12*0x4]
MOV RDI,qword ptr [R15 + R12*0x8]
MOV RCX,R13
MOV EDX,0x4
ADD R12,0x1
CALL 0x001010a0
CMP R12,R14
JNZ 0x00101630
LAB_0010164e:
MOVSXD RDI,dword ptr [RBX]
SHL RDI,0x2
CALL 0x001010d0
MOV R9D,dword ptr [RBX]
MOV R12,RAX
TEST R9D,R9D
JLE 0x00101763
MOV RCX,qword ptr [R15]
XOR EDX,EDX
XOR R13D,R13D
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101678:
TEST EAX,EAX
JZ 0x00101685
MOV EDI,dword ptr [RCX + RDX*0x1 + -0x4]
CMP dword ptr [RCX + RDX*0x1],EDI
JZ 0x00101693
LAB_00101685:
MOV EDI,dword ptr [RCX + RDX*0x1]
MOVSXD RSI,R13D
ADD R13D,0x1
MOV dword ptr [R12 + RSI*0x4],EDI
LAB_00101693:
ADD EAX,0x1
ADD RDX,0x4
CMP EAX,R9D
JNZ 0x00101678
CMP EBP,0x1
JLE 0x00101749
LEA EAX,[RBP + -0x2]
ADD RBX,0x4
LEA R14,[R15 + 0x8]
LEA RAX,[R15 + RAX*0x8 + 0x10]
MOV qword ptr [RSP],RAX
NOP dword ptr [RAX]
LAB_001016c0:
MOVSXD RDI,R13D
MOV R15,R12
SHL RDI,0x2
CALL 0x001010d0
MOV R12,RAX
TEST R13D,R13D
JZ 0x00101775
MOV EDI,dword ptr [RBX]
XOR EBP,EBP
XOR ECX,ECX
XOR EDX,EDX
JMP 0x001016f0
LAB_001016e8:
ADD EDX,0x1
LAB_001016eb:
CMP EDX,R13D
JGE 0x00101728
LAB_001016f0:
CMP EDI,ECX
JLE 0x00101728
MOVSXD RAX,EDX
MOV R10,qword ptr [R14]
MOV ESI,dword ptr [R15 + RAX*0x4]
MOVSXD RAX,ECX
MOV EAX,dword ptr [R10 + RAX*0x4]
CMP ESI,EAX
JL 0x001016e8
ADD ECX,0x1
CMP ESI,EAX
JG 0x001016eb
MOVSXD RAX,EBP
ADD EDX,0x1
ADD EBP,0x1
MOV dword ptr [R12 + RAX*0x4],ESI
CMP EDX,R13D
JL 0x001016f0
NOP word ptr [RAX + RAX*0x1]
LAB_00101728:
MOV RDI,R15
MOV R13D,EBP
CALL 0x00101090
TEST EBP,EBP
JZ 0x00101749
ADD RBX,0x4
ADD R14,0x8
CMP R14,qword ptr [RSP]
JNZ 0x001016c0
LAB_00101749:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R13D
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101763:
CMP EBP,0x1
JLE 0x00101782
XOR EDI,EDI
MOV R15,R12
CALL 0x001010d0
MOV R12,RAX
LAB_00101775:
MOV RDI,R15
XOR R13D,R13D
CALL 0x00101090
JMP 0x00101749
LAB_00101782:
XOR R13D,R13D
JMP 0x00101749 | void * func0_part_0(long *param_1,int param_2,int *param_3,int *param_4)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
void *__ptr;
void *pvVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
int iVar12;
long *plVar13;
lVar11 = 0;
if (0 < param_2) {
do {
piVar1 = param_3 + lVar11;
plVar13 = param_1 + lVar11;
lVar11 = lVar11 + 1;
qsort((void *)*plVar13,(long)*piVar1,4,cmpfunc);
} while (lVar11 != param_2);
}
__ptr = malloc((long)*param_3 << 2);
iVar2 = *param_3;
if (iVar2 < 1) {
if (param_2 < 2) {
iVar12 = 0;
}
else {
pvVar6 = malloc(0);
LAB_00101775:
iVar12 = 0;
free(__ptr);
__ptr = pvVar6;
}
}
else {
lVar11 = *param_1;
lVar9 = 0;
iVar12 = 0;
iVar5 = 0;
do {
if ((iVar5 == 0) || (*(int *)(lVar11 + lVar9) != *(int *)(lVar11 + -4 + lVar9))) {
lVar10 = (long)iVar12;
iVar12 = iVar12 + 1;
*(int4 *)((long)__ptr + lVar10 * 4) = *(int4 *)(lVar11 + lVar9);
}
iVar5 = iVar5 + 1;
lVar9 = lVar9 + 4;
} while (iVar5 != iVar2);
if (1 < param_2) {
param_3 = param_3 + 1;
plVar13 = param_1 + 1;
do {
pvVar6 = malloc((long)iVar12 << 2);
if (iVar12 == 0) goto LAB_00101775;
iVar2 = *param_3;
iVar5 = 0;
iVar7 = 0;
iVar8 = 0;
do {
while( true ) {
if (iVar2 <= iVar7) goto LAB_00101728;
iVar3 = *(int *)((long)__ptr + (long)iVar8 * 4);
iVar4 = *(int *)(*plVar13 + (long)iVar7 * 4);
if (iVar4 <= iVar3) break;
iVar8 = iVar8 + 1;
LAB_001016eb:
if (iVar12 <= iVar8) goto LAB_00101728;
}
iVar7 = iVar7 + 1;
if (iVar4 < iVar3) goto LAB_001016eb;
lVar11 = (long)iVar5;
iVar8 = iVar8 + 1;
iVar5 = iVar5 + 1;
*(int *)((long)pvVar6 + lVar11 * 4) = iVar3;
} while (iVar8 < iVar12);
LAB_00101728:
iVar12 = iVar5;
free(__ptr);
__ptr = pvVar6;
if (iVar12 == 0) break;
param_3 = param_3 + 1;
plVar13 = plVar13 + 1;
} while (plVar13 != param_1 + (ulong)(param_2 - 2) + 2);
}
}
*param_4 = iVar12;
return __ptr;
} |
4,339 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize result with first list
int *temp = malloc(sizes[0] * sizeof(int));
int temp_size = 0;
for(int i = 0; i < sizes[0]; i++) {
if (i == 0 || nestedlist[0][i] != nestedlist[0][i-1]) {
temp[temp_size++] = nestedlist[0][i];
}
}
// Iterate through other lists and find intersection
for(int i = 1; i < num_lists; i++) {
int *new_temp = malloc(temp_size * sizeof(int));
int new_size = 0;
int j = 0, k = 0;
while(j < temp_size && k < sizes[i]) {
if(temp[j] < nestedlist[i][k]) {
j++;
}
else if(temp[j] > nestedlist[i][k]) {
k++;
}
else {
new_temp[new_size++] = temp[j];
j++;
k++;
}
}
free(temp);
temp = new_temp;
temp_size = new_size;
if(temp_size == 0) break;
}
*result_size = temp_size;
return temp;
}
| int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1, &result_size1);
qsort(result1, result_size1, sizeof(int), cmpfunc);
assert(result_size1 == 2 && result1[0] == 12 && result1[1] == 18);
free(result1);
// Second test case
int list2_1[] = {12, 5, 23, 25, 45};
int list2_2[] = {7, 11, 5, 23, 28};
int list2_3[] = {1, 5, 8, 18, 23, 16};
int *nested2[] = {list2_1, list2_2, list2_3};
int sizes2[] = {5, 5, 6};
int result_size2;
int *result2 = func0(nested2, 3, sizes2, &result_size2);
qsort(result2, result_size2, sizeof(int), cmpfunc);
assert(result_size2 == 2 && result2[0] == 5 && result2[1] == 23);
free(result2);
// Third test case
int list3_1[] = {2, 3, 4, 1};
int list3_2[] = {4, 5};
int list3_3[] = {6, 4, 8};
int list3_4[] = {4, 5};
int list3_5[] = {6, 8, 4};
int *nested3[] = {list3_1, list3_2, list3_3, list3_4, list3_5};
int sizes3[] = {4, 2, 3, 2, 3};
int result_size3;
int *result3 = func0(nested3, 5, sizes3, &result_size3);
qsort(result3, result_size3, sizeof(int), cmpfunc);
assert(result_size3 == 1 && result3[0] == 4);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
je 1740 <func0+0x10>
jmpq 1590 <func0.part.0>
nopl (%rax)
movl $0x0,(%rcx)
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdx
sub rsp, 18h
movsxd rax, dword ptr [rdx]
mov [rsp+48h+var_48], rdi
mov [rsp+48h+var_40], rcx
test esi, esi
jle loc_1750
mov r15, rdx
movsxd rdx, esi
lea r13, cmpfunc
mov r12, rdi
lea r14, [rbx+rdx*4]
nop dword ptr [rax+rax+00h]
loc_1600:
movsxd rsi, dword ptr [r15]; nmemb
mov rdi, [r12]; base
mov rcx, r13; compar
mov edx, 4; size
add r15, 4
add r12, 8
call _qsort
cmp r14, r15
jnz short loc_1600
movsxd rdi, dword ptr [rbx]
shl rdi, 2; size
call _malloc
mov edi, [rbx]
mov r12, rax
test edi, edi
jle loc_176F
loc_163A:
mov rax, [rsp+48h+var_48]
xor r13d, r13d
mov rdx, [rax]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_1650:
lea rcx, ds:0[rax*4]
test rax, rax
jz short loc_1666
mov esi, [rdx+rax*4-4]
cmp [rdx+rax*4], esi
jz short loc_1674
loc_1666:
mov esi, [rdx+rcx]
movsxd rcx, r13d
add r13d, 1
mov [r12+rcx*4], esi
loc_1674:
add rax, 1
cmp edi, eax
jg short loc_1650
loc_167C:
cmp ebp, 1
jle loc_1729
mov rdi, [rsp+48h+var_48]
lea eax, [rbp-2]
add rbx, 4
lea rax, [rdi+rax*8+10h]
lea r14, [rdi+8]
mov [rsp+48h+var_48], rax
nop dword ptr [rax]
loc_16A0:
movsxd rdi, r13d
mov r15, r12
shl rdi, 2; size
call _malloc
mov r12, rax
test r13d, r13d
jle loc_1743
mov edi, [rbx]
xor ebp, ebp
xor ecx, ecx
xor edx, edx
jmp short loc_16D0
loc_16C8:
add edx, 1
loc_16CB:
cmp edx, r13d
jge short loc_1708
loc_16D0:
cmp edi, ecx
jle short loc_1708
movsxd rax, edx
mov r10, [r14]
mov esi, [r15+rax*4]
movsxd rax, ecx
mov eax, [r10+rax*4]
cmp esi, eax
jl short loc_16C8
add ecx, 1
cmp esi, eax
jg short loc_16CB
movsxd rax, ebp
add edx, 1
add ebp, 1
mov [r12+rax*4], esi
cmp edx, r13d
jl short loc_16D0
nop word ptr [rax+rax+00h]
loc_1708:
mov rdi, r15; ptr
mov r13d, ebp
call _free
test ebp, ebp
jz short loc_1729
add rbx, 4
add r14, 8
cmp [rsp+48h+var_48], r14
jnz loc_16A0
loc_1729:
mov rax, [rsp+48h+var_40]
mov [rax], r13d
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1743:
mov rdi, r15; ptr
xor r13d, r13d
call _free
jmp short loc_1729
loc_1750:
lea rdi, ds:0[rax*4]; size
call _malloc
mov edi, [rbx]
mov r12, rax
test edi, edi
jg loc_163A
xor r13d, r13d
jmp short loc_1729
loc_176F:
xor r13d, r13d
jmp loc_167C | _DWORD * func0_part_0(_QWORD *a1, int a2, int *a3, int *a4)
{
int *v6; // r15
void **v7; // r12
int *v8; // r14
size_t v9; // rsi
void *v10; // rdi
_DWORD *v11; // rax
int v12; // edi
_DWORD *v13; // r12
int v14; // r13d
_DWORD *v15; // rdx
long long v16; // rax
long long v17; // rcx
int *v18; // rbx
_QWORD *v19; // r14
void *v20; // r15
int v21; // edi
int v22; // ebp
int v23; // ecx
int v24; // edx
int v25; // esi
int v26; // eax
long long v27; // rax
_DWORD *v29; // rax
long long v31; // [rsp+0h] [rbp-48h]
if ( a2 <= 0 )
{
v29 = malloc(4LL * *a3);
v12 = *a3;
v13 = v29;
if ( *a3 <= 0 )
{
v14 = 0;
goto LABEL_22;
}
goto LABEL_5;
}
v6 = a3;
v7 = (void **)a1;
v8 = &a3[a2];
do
{
v9 = *v6;
v10 = *v7;
++v6;
++v7;
qsort(v10, v9, 4uLL, cmpfunc);
}
while ( v8 != v6 );
v11 = malloc(4LL * *a3);
v12 = *a3;
v13 = v11;
if ( *a3 > 0 )
{
LABEL_5:
v14 = 0;
v15 = (_DWORD *)*a1;
v16 = 0LL;
do
{
if ( !v16 || v15[v16] != v15[v16 - 1] )
{
v17 = v14++;
v13[v17] = v15[v16];
}
++v16;
}
while ( v12 > (int)v16 );
goto LABEL_10;
}
v14 = 0;
LABEL_10:
if ( a2 <= 1 )
goto LABEL_22;
v18 = a3 + 1;
v19 = a1 + 1;
v31 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
do
{
v20 = v13;
v13 = malloc(4LL * v14);
if ( v14 <= 0 )
{
v14 = 0;
free(v20);
break;
}
v21 = *v18;
v22 = 0;
v23 = 0;
v24 = 0;
while ( v21 > v23 )
{
v25 = *((_DWORD *)v20 + v24);
v26 = *(_DWORD *)(*v19 + 4LL * v23);
if ( v25 < v26 )
{
++v24;
LABEL_15:
if ( v24 >= v14 )
break;
}
else
{
++v23;
if ( v25 > v26 )
goto LABEL_15;
v27 = v22;
++v24;
++v22;
v13[v27] = v25;
if ( v24 >= v14 )
break;
}
}
v14 = v22;
free(v20);
if ( !v22 )
break;
++v18;
++v19;
}
while ( (_QWORD *)v31 != v19 );
LABEL_22:
*a4 = v14;
return v13;
} | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOVSXD RAX,dword ptr [RDX]
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x8],RCX
TEST ESI,ESI
JLE 0x00101750
MOV R15,RDX
MOVSXD RDX,ESI
LEA R13,[0x1015b0]
MOV R12,RDI
LEA R14,[RBX + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101600:
MOVSXD RSI,dword ptr [R15]
MOV RDI,qword ptr [R12]
MOV RCX,R13
MOV EDX,0x4
ADD R15,0x4
ADD R12,0x8
CALL 0x001010a0
CMP R14,R15
JNZ 0x00101600
MOVSXD RDI,dword ptr [RBX]
SHL RDI,0x2
CALL 0x001010d0
MOV EDI,dword ptr [RBX]
MOV R12,RAX
TEST EDI,EDI
JLE 0x0010176f
LAB_0010163a:
MOV RAX,qword ptr [RSP]
XOR R13D,R13D
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101650:
LEA RCX,[RAX*0x4]
TEST RAX,RAX
JZ 0x00101666
MOV ESI,dword ptr [RDX + RAX*0x4 + -0x4]
CMP dword ptr [RDX + RAX*0x4],ESI
JZ 0x00101674
LAB_00101666:
MOV ESI,dword ptr [RDX + RCX*0x1]
MOVSXD RCX,R13D
ADD R13D,0x1
MOV dword ptr [R12 + RCX*0x4],ESI
LAB_00101674:
ADD RAX,0x1
CMP EDI,EAX
JG 0x00101650
LAB_0010167c:
CMP EBP,0x1
JLE 0x00101729
MOV RDI,qword ptr [RSP]
LEA EAX,[RBP + -0x2]
ADD RBX,0x4
LEA RAX,[RDI + RAX*0x8 + 0x10]
LEA R14,[RDI + 0x8]
MOV qword ptr [RSP],RAX
NOP dword ptr [RAX]
LAB_001016a0:
MOVSXD RDI,R13D
MOV R15,R12
SHL RDI,0x2
CALL 0x001010d0
MOV R12,RAX
TEST R13D,R13D
JLE 0x00101743
MOV EDI,dword ptr [RBX]
XOR EBP,EBP
XOR ECX,ECX
XOR EDX,EDX
JMP 0x001016d0
LAB_001016c8:
ADD EDX,0x1
LAB_001016cb:
CMP EDX,R13D
JGE 0x00101708
LAB_001016d0:
CMP EDI,ECX
JLE 0x00101708
MOVSXD RAX,EDX
MOV R10,qword ptr [R14]
MOV ESI,dword ptr [R15 + RAX*0x4]
MOVSXD RAX,ECX
MOV EAX,dword ptr [R10 + RAX*0x4]
CMP ESI,EAX
JL 0x001016c8
ADD ECX,0x1
CMP ESI,EAX
JG 0x001016cb
MOVSXD RAX,EBP
ADD EDX,0x1
ADD EBP,0x1
MOV dword ptr [R12 + RAX*0x4],ESI
CMP EDX,R13D
JL 0x001016d0
NOP word ptr [RAX + RAX*0x1]
LAB_00101708:
MOV RDI,R15
MOV R13D,EBP
CALL 0x00101090
TEST EBP,EBP
JZ 0x00101729
ADD RBX,0x4
ADD R14,0x8
CMP qword ptr [RSP],R14
JNZ 0x001016a0
LAB_00101729:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R13D
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101743:
MOV RDI,R15
XOR R13D,R13D
CALL 0x00101090
JMP 0x00101729
LAB_00101750:
LEA RDI,[RAX*0x4]
CALL 0x001010d0
MOV EDI,dword ptr [RBX]
MOV R12,RAX
TEST EDI,EDI
JG 0x0010163a
XOR R13D,R13D
JMP 0x00101729
LAB_0010176f:
XOR R13D,R13D
JMP 0x0010167c | void * func0_part_0(long *param_1,int param_2,int *param_3,int *param_4)
{
int iVar1;
int iVar2;
int iVar3;
void *pvVar4;
long lVar5;
long lVar6;
int iVar7;
long lVar8;
int iVar9;
int iVar10;
long *plVar11;
void *__ptr;
int iVar12;
int *piVar13;
if (param_2 < 1) {
pvVar4 = malloc((long)*param_3 * 4);
iVar10 = *param_3;
if (iVar10 < 1) {
iVar12 = 0;
goto LAB_00101729;
}
LAB_0010163a:
iVar12 = 0;
lVar6 = *param_1;
lVar5 = 0;
do {
if ((lVar5 == 0) || (*(int *)(lVar6 + lVar5 * 4) != *(int *)(lVar6 + -4 + lVar5 * 4))) {
lVar8 = (long)iVar12;
iVar12 = iVar12 + 1;
*(int4 *)((long)pvVar4 + lVar8 * 4) = *(int4 *)(lVar6 + lVar5 * 4);
}
lVar5 = lVar5 + 1;
} while ((int)lVar5 < iVar10);
}
else {
plVar11 = param_1;
piVar13 = param_3;
do {
iVar10 = *piVar13;
pvVar4 = (void *)*plVar11;
piVar13 = piVar13 + 1;
plVar11 = plVar11 + 1;
qsort(pvVar4,(long)iVar10,4,cmpfunc);
} while (param_3 + param_2 != piVar13);
pvVar4 = malloc((long)*param_3 << 2);
iVar10 = *param_3;
if (0 < iVar10) goto LAB_0010163a;
iVar12 = 0;
}
if (1 < param_2) {
param_3 = param_3 + 1;
plVar11 = param_1 + 1;
__ptr = pvVar4;
iVar10 = iVar12;
do {
pvVar4 = malloc((long)iVar10 << 2);
if (iVar10 < 1) {
iVar12 = 0;
free(__ptr);
break;
}
iVar1 = *param_3;
iVar12 = 0;
iVar7 = 0;
iVar9 = 0;
do {
while( true ) {
if (iVar1 <= iVar7) goto LAB_00101708;
iVar2 = *(int *)((long)__ptr + (long)iVar9 * 4);
iVar3 = *(int *)(*plVar11 + (long)iVar7 * 4);
if (iVar3 <= iVar2) break;
iVar9 = iVar9 + 1;
LAB_001016cb:
if (iVar10 <= iVar9) goto LAB_00101708;
}
iVar7 = iVar7 + 1;
if (iVar3 < iVar2) goto LAB_001016cb;
lVar6 = (long)iVar12;
iVar9 = iVar9 + 1;
iVar12 = iVar12 + 1;
*(int *)((long)pvVar4 + lVar6 * 4) = iVar2;
} while (iVar9 < iVar10);
LAB_00101708:
free(__ptr);
if (iVar12 == 0) break;
param_3 = param_3 + 1;
plVar11 = plVar11 + 1;
__ptr = pvVar4;
iVar10 = iVar12;
} while (param_1 + (ulong)(param_2 - 2) + 2 != plVar11);
}
LAB_00101729:
*param_4 = iVar12;
return pvVar4;
} |
4,340 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
add %eax,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
add eax, eax
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a1 + a2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
ADD EAX,EAX
POP RBP
RET | int func0(int param_1,int param_2)
{
return (param_2 + param_1) * 2;
} |
4,341 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
4,342 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
4,343 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
4,344 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} else {
if (text[0] == '+' || text[0] == '-') {
for (i = 1; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
} else {
for (i = 0; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
}
}
}
| int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x8(%rbp)
jmp 1193 <func0+0x2a>
addq $0x1,-0x18(%rbp)
subl $0x1,-0x8(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 118a <func0+0x21>
cmpl $0x0,-0x8(%rbp)
jg 11ae <func0+0x45>
mov $0xffffffff,%eax
jmpq 1258 <func0+0xef>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x2b,%al
je 11c4 <func0+0x5b>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x2d,%al
jne 120f <func0+0xa6>
movl $0x1,-0x4(%rbp)
jmp 1200 <func0+0x97>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jle 11f5 <func0+0x8c>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x39,%al
jle 11fc <func0+0x93>
mov $0x0,%eax
jmp 1258 <func0+0xef>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 11cd <func0+0x64>
mov $0x1,%eax
jmp 1258 <func0+0xef>
movl $0x0,-0x4(%rbp)
jmp 124b <func0+0xe2>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jle 1240 <func0+0xd7>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x39,%al
jle 1247 <func0+0xde>
mov $0x0,%eax
jmp 1258 <func0+0xef>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 1218 <func0+0xaf>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
jmp short loc_1193
loc_118A:
add [rbp+s], 1
sub [rbp+var_8], 1
loc_1193:
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_118A
cmp [rbp+var_8], 0
jg short loc_11AE
mov eax, 0FFFFFFFFh
jmp locret_1258
loc_11AE:
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
cmp al, 2Bh ; '+'
jz short loc_11C4
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
cmp al, 2Dh ; '-'
jnz short loc_120F
loc_11C4:
mov [rbp+var_4], 1
jmp short loc_1200
loc_11CD:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jle short loc_11F5
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 39h ; '9'
jle short loc_11FC
loc_11F5:
mov eax, 0
jmp short locret_1258
loc_11FC:
add [rbp+var_4], 1
loc_1200:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jl short loc_11CD
mov eax, 1
jmp short locret_1258
loc_120F:
mov [rbp+var_4], 0
jmp short loc_124B
loc_1218:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jle short loc_1240
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 39h ; '9'
jle short loc_1247
loc_1240:
mov eax, 0
jmp short locret_1258
loc_1247:
add [rbp+var_4], 1
loc_124B:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jl short loc_1218
mov eax, 1
locret_1258:
leave
retn | long long func0(const char *a1)
{
char *s; // [rsp+8h] [rbp-18h]
int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
int j; // [rsp+1Ch] [rbp-4h]
s = (char *)a1;
v3 = strlen(a1);
while ( *s == 32 )
{
++s;
--v3;
}
if ( v3 <= 0 )
return 0xFFFFFFFFLL;
if ( *s == 43 || *s == 45 )
{
for ( i = 1; i < v3; ++i )
{
if ( s[i] <= 47 || s[i] > 57 )
return 0LL;
}
return 1LL;
}
else
{
for ( j = 0; j < v3; ++j )
{
if ( s[j] <= 47 || s[j] > 57 )
return 0LL;
}
return 1LL;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101193
LAB_0010118a:
ADD qword ptr [RBP + -0x18],0x1
SUB dword ptr [RBP + -0x8],0x1
LAB_00101193:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x0010118a
CMP dword ptr [RBP + -0x8],0x0
JG 0x001011ae
MOV EAX,0xffffffff
JMP 0x00101258
LAB_001011ae:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2b
JZ 0x001011c4
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2d
JNZ 0x0010120f
LAB_001011c4:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101200
LAB_001011cd:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x001011f5
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x39
JLE 0x001011fc
LAB_001011f5:
MOV EAX,0x0
JMP 0x00101258
LAB_001011fc:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101200:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001011cd
MOV EAX,0x1
JMP 0x00101258
LAB_0010120f:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010124b
LAB_00101218:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x00101240
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x39
JLE 0x00101247
LAB_00101240:
MOV EAX,0x0
JMP 0x00101258
LAB_00101247:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010124b:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x00101218
MOV EAX,0x1
LAB_00101258:
LEAVE
RET | int8 func0(char *param_1)
{
size_t sVar1;
int8 uVar2;
char *local_20;
int local_10;
int local_c;
sVar1 = strlen(param_1);
local_10 = (int)sVar1;
for (local_20 = param_1; *local_20 == ' '; local_20 = local_20 + 1) {
local_10 = local_10 + -1;
}
if (local_10 < 1) {
uVar2 = 0xffffffff;
}
else if ((*local_20 == '+') || (*local_20 == '-')) {
for (local_c = 1; local_c < local_10; local_c = local_c + 1) {
if ((local_20[local_c] < '0') || ('9' < local_20[local_c])) {
return 0;
}
}
uVar2 = 1;
}
else {
for (local_c = 0; local_c < local_10; local_c = local_c + 1) {
if ((local_20[local_c] < '0') || ('9' < local_20[local_c])) {
return 0;
}
}
uVar2 = 1;
}
return uVar2;
} |
4,345 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} else {
if (text[0] == '+' || text[0] == '-') {
for (i = 1; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
} else {
for (i = 0; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
}
}
}
| int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
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),%rsi
mov %esi,%edx
movzbl (%r8),%ecx
cmp $0x20,%cl
jne 11c2 <func0+0x79>
mov %r8,%rax
add $0x1,%rax
mov %r8d,%edx
sub %eax,%edx
add %esi,%edx
movzbl (%rax),%ecx
cmp $0x20,%cl
je 1173 <func0+0x2a>
mov $0xffffffff,%esi
test %edx,%edx
jle 11f8 <func0+0xaf>
sub $0x2b,%ecx
test $0xfd,%cl
jne 11c7 <func0+0x7e>
cmp $0x1,%edx
jle 11ec <func0+0xa3>
lea 0x1(%rax),%rcx
lea -0x2(%rdx),%edx
lea 0x2(%rax,%rdx,1),%rdx
movzbl (%rcx),%eax
sub $0x30,%eax
cmp $0x9,%al
ja 11f3 <func0+0xaa>
add $0x1,%rcx
cmp %rdx,%rcx
jne 11a8 <func0+0x5f>
mov $0x1,%esi
jmp 11f8 <func0+0xaf>
mov %r8,%rax
jmp 1186 <func0+0x3d>
mov %rax,%rcx
lea -0x1(%rdx),%edx
lea 0x1(%rax,%rdx,1),%rdx
movzbl (%rcx),%eax
sub $0x30,%eax
cmp $0x9,%al
ja 11fb <func0+0xb2>
add $0x1,%rcx
cmp %rdx,%rcx
jne 11d2 <func0+0x89>
mov $0x1,%esi
jmp 11f8 <func0+0xaf>
mov $0x1,%esi
jmp 11f8 <func0+0xaf>
mov $0x0,%esi
mov %esi,%eax
retq
mov $0x0,%esi
jmp 11f8 <func0+0xaf>
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx esi, byte ptr [rbx]
cmp sil, 20h ; ' '
jnz short loc_11D2
mov rdx, rbx
loc_1182:
add rdx, 1
mov ecx, ebx
sub ecx, edx
add ecx, eax
movzx esi, byte ptr [rdx]
cmp sil, 20h ; ' '
jz short loc_1182
loc_1195:
mov eax, 0FFFFFFFFh
test ecx, ecx
jle short loc_120A
sub esi, 2Bh ; '+'
test sil, 0FDh
jnz short loc_11D9
cmp ecx, 1
jle short loc_11FE
lea rsi, [rdx+1]
lea eax, [rcx-2]
lea rdx, [rdx+rax+2]
loc_11B8:
movzx eax, byte ptr [rsi]
sub eax, 30h ; '0'
cmp al, 9
ja short loc_1205
add rsi, 1
cmp rsi, rdx
jnz short loc_11B8
mov eax, 1
jmp short loc_120A
loc_11D2:
mov ecx, eax
mov rdx, rbx
jmp short loc_1195
loc_11D9:
mov rsi, rdx
lea eax, [rcx-1]
lea rdx, [rdx+rax+1]
loc_11E4:
movzx eax, byte ptr [rsi]
sub eax, 30h ; '0'
cmp al, 9
ja short loc_120C
add rsi, 1
cmp rsi, rdx
jnz short loc_11E4
mov eax, 1
jmp short loc_120A
loc_11FE:
mov eax, 1
jmp short loc_120A
loc_1205:
mov eax, 0
loc_120A:
pop rbx
retn
loc_120C:
mov eax, 0
jmp short loc_120A | long long func0(_BYTE *a1)
{
int v1; // eax
char v2; // si
_BYTE *v3; // rdx
int v4; // ecx
long long result; // rax
_BYTE *v6; // rsi
long long v7; // rdx
_BYTE *v8; // rsi
long long v9; // rdx
v1 = strlen();
v2 = *a1;
if ( *a1 == 32 )
{
v3 = a1;
do
{
v4 = v1 + (_DWORD)a1 - (_DWORD)++v3;
v2 = *v3;
}
while ( *v3 == 32 );
}
else
{
v4 = v1;
v3 = a1;
}
result = 0xFFFFFFFFLL;
if ( v4 > 0 )
{
if ( ((v2 - 43) & 0xFD) != 0 )
{
v8 = v3;
v9 = (long long)&v3[v4 - 1 + 1];
while ( (unsigned __int8)(*v8 - 48) <= 9u )
{
if ( ++v8 == (_BYTE *)v9 )
return 1LL;
}
return 0LL;
}
else if ( v4 <= 1 )
{
return 1LL;
}
else
{
v6 = v3 + 1;
v7 = (long long)&v3[v4 - 2 + 2];
while ( (unsigned __int8)(*v6 - 48) <= 9u )
{
if ( ++v6 == (_BYTE *)v7 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX ESI,byte ptr [RBX]
CMP SIL,0x20
JNZ 0x001011d2
MOV RDX,RBX
LAB_00101182:
ADD RDX,0x1
MOV ECX,EBX
SUB ECX,EDX
ADD ECX,EAX
MOVZX ESI,byte ptr [RDX]
CMP SIL,0x20
JZ 0x00101182
LAB_00101195:
MOV EAX,0xffffffff
TEST ECX,ECX
JLE 0x0010120a
SUB ESI,0x2b
TEST SIL,0xfd
JNZ 0x001011d9
CMP ECX,0x1
JLE 0x001011fe
LEA RSI,[RDX + 0x1]
LEA EAX,[RCX + -0x2]
LEA RDX,[RDX + RAX*0x1 + 0x2]
LAB_001011b8:
MOVZX EAX,byte ptr [RSI]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101205
ADD RSI,0x1
CMP RSI,RDX
JNZ 0x001011b8
MOV EAX,0x1
JMP 0x0010120a
LAB_001011d2:
MOV ECX,EAX
MOV RDX,RBX
JMP 0x00101195
LAB_001011d9:
MOV RSI,RDX
LEA EAX,[RCX + -0x1]
LEA RDX,[RDX + RAX*0x1 + 0x1]
LAB_001011e4:
MOVZX EAX,byte ptr [RSI]
SUB EAX,0x30
CMP AL,0x9
JA 0x0010120c
ADD RSI,0x1
CMP RSI,RDX
JNZ 0x001011e4
MOV EAX,0x1
JMP 0x0010120a
LAB_001011fe:
MOV EAX,0x1
JMP 0x0010120a
LAB_00101205:
MOV EAX,0x0
LAB_0010120a:
POP RBX
RET
LAB_0010120c:
MOV EAX,0x0
JMP 0x0010120a | int8 func0(char *param_1)
{
char cVar1;
size_t sVar2;
int8 uVar3;
int iVar4;
char *pcVar5;
char *pcVar6;
sVar2 = strlen(param_1);
cVar1 = *param_1;
pcVar5 = param_1;
iVar4 = (int)sVar2;
while (cVar1 == ' ') {
pcVar5 = pcVar5 + 1;
iVar4 = ((int)param_1 - (int)pcVar5) + (int)sVar2;
cVar1 = *pcVar5;
}
uVar3 = 0xffffffff;
if (0 < iVar4) {
if ((cVar1 - 0x2bU & 0xfd) == 0) {
if (iVar4 < 2) {
uVar3 = 1;
}
else {
pcVar6 = pcVar5 + 1;
do {
if (9 < (byte)(*pcVar6 - 0x30U)) {
return 0;
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != pcVar5 + (ulong)(iVar4 - 2) + 2);
uVar3 = 1;
}
}
else {
pcVar6 = pcVar5 + (ulong)(iVar4 - 1) + 1;
do {
if (9 < (byte)(*pcVar5 - 0x30U)) {
return 0;
}
pcVar5 = pcVar5 + 1;
} while (pcVar5 != pcVar6);
uVar3 = 1;
}
}
return uVar3;
} |
4,346 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} else {
if (text[0] == '+' || text[0] == '-') {
for (i = 1; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
} else {
for (i = 0; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
}
}
}
| int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
movzbl (%rbx),%ecx
cmp $0x20,%cl
jne 12c0 <func0+0xb0>
mov %rax,%rsi
mov %rbx,%rdx
add $0x1,%rdx
mov %ebx,%eax
movzbl (%rdx),%ecx
sub %edx,%eax
add %esi,%eax
cmp $0x20,%cl
je 1230 <func0+0x20>
test %eax,%eax
jle 12b0 <func0+0xa0>
sub $0x2b,%ecx
and $0xfd,%ecx
jne 1280 <func0+0x70>
cmp $0x1,%eax
je 127d <func0+0x6d>
sub $0x2,%eax
lea 0x1(%rdx),%rcx
lea 0x2(%rdx,%rax,1),%rdx
jmp 1271 <func0+0x61>
nopl 0x0(%rax)
add $0x1,%rcx
cmp %rcx,%rdx
je 12a3 <func0+0x93>
movzbl (%rcx),%eax
sub $0x30,%eax
cmp $0x9,%al
jbe 1268 <func0+0x58>
xor %eax,%eax
pop %rbx
retq
sub $0x1,%eax
lea 0x1(%rdx,%rax,1),%rcx
nopl 0x0(%rax,%rax,1)
movzbl (%rdx),%eax
sub $0x30,%eax
cmp $0x9,%al
ja 127b <func0+0x6b>
add $0x1,%rdx
cmp %rcx,%rdx
jne 1290 <func0+0x80>
mov $0x1,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdx
jmpq 1242 <func0+0x32>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx ecx, byte ptr [rbx]
cmp cl, 20h ; ' '
jnz loc_12C0
mov rsi, rax
mov rdx, rbx
nop
loc_1230:
add rdx, 1
mov eax, ebx
movzx ecx, byte ptr [rdx]
sub eax, edx
add eax, esi
cmp cl, 20h ; ' '
jz short loc_1230
loc_1242:
test eax, eax
jle short loc_12B0
sub ecx, 2Bh ; '+'
and ecx, 0FDh
jnz short loc_1280
cmp eax, 1
jz short loc_127D
sub eax, 2
lea rcx, [rdx+1]
lea rdx, [rdx+rax+2]
jmp short loc_1271
loc_1268:
add rcx, 1
cmp rdx, rcx
jz short loc_12A3
loc_1271:
movzx eax, byte ptr [rcx]
sub eax, 30h ; '0'
cmp al, 9
jbe short loc_1268
loc_127B:
xor eax, eax
loc_127D:
pop rbx
retn
loc_1280:
sub eax, 1
lea rcx, [rdx+rax+1]
nop dword ptr [rax+rax+00000000h]
loc_1290:
movzx eax, byte ptr [rdx]
sub eax, 30h ; '0'
cmp al, 9
ja short loc_127B
add rdx, 1
cmp rdx, rcx
jnz short loc_1290
loc_12A3:
mov eax, 1
pop rbx
retn
loc_12B0:
mov eax, 0FFFFFFFFh
pop rbx
retn
loc_12C0:
mov rdx, rbx
jmp loc_1242 | long long func0(_BYTE *a1)
{
long long result; // rax
char v2; // cl
int v3; // esi
_BYTE *v4; // rdx
_BYTE *v5; // rcx
long long v6; // rdx
long long v7; // rcx
result = strlen();
v2 = *a1;
if ( *a1 == 32 )
{
v3 = result;
v4 = a1;
do
{
v2 = *++v4;
result = (unsigned int)(v3 + (_DWORD)a1 - (_DWORD)v4);
}
while ( *v4 == 32 );
}
else
{
v4 = a1;
}
if ( (int)result <= 0 )
return 0xFFFFFFFFLL;
if ( ((v2 - 43) & 0xFD) != 0 )
{
v7 = (long long)&v4[(unsigned int)(result - 1) + 1];
while ( (unsigned __int8)(*v4 - 48) <= 9u )
{
if ( ++v4 == (_BYTE *)v7 )
return 1LL;
}
}
else
{
if ( (_DWORD)result == 1 )
return result;
v5 = v4 + 1;
v6 = (long long)&v4[(unsigned int)(result - 2) + 2];
while ( (unsigned __int8)(*v5 - 48) <= 9u )
{
if ( (_BYTE *)v6 == ++v5 )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX ECX,byte ptr [RBX]
CMP CL,0x20
JNZ 0x001012c0
MOV RSI,RAX
MOV RDX,RBX
NOP
LAB_00101230:
ADD RDX,0x1
MOV EAX,EBX
MOVZX ECX,byte ptr [RDX]
SUB EAX,EDX
ADD EAX,ESI
CMP CL,0x20
JZ 0x00101230
LAB_00101242:
TEST EAX,EAX
JLE 0x001012b0
SUB ECX,0x2b
AND ECX,0xfd
JNZ 0x00101280
CMP EAX,0x1
JZ 0x0010127d
SUB EAX,0x2
LEA RCX,[RDX + 0x1]
LEA RDX,[RDX + RAX*0x1 + 0x2]
JMP 0x00101271
LAB_00101268:
ADD RCX,0x1
CMP RDX,RCX
JZ 0x001012a3
LAB_00101271:
MOVZX EAX,byte ptr [RCX]
SUB EAX,0x30
CMP AL,0x9
JBE 0x00101268
LAB_0010127b:
XOR EAX,EAX
LAB_0010127d:
POP RBX
RET
LAB_00101280:
SUB EAX,0x1
LEA RCX,[RDX + RAX*0x1 + 0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101290:
MOVZX EAX,byte ptr [RDX]
SUB EAX,0x30
CMP AL,0x9
JA 0x0010127b
ADD RDX,0x1
CMP RDX,RCX
JNZ 0x00101290
LAB_001012a3:
MOV EAX,0x1
POP RBX
RET
LAB_001012b0:
MOV EAX,0xffffffff
POP RBX
RET
LAB_001012c0:
MOV RDX,RBX
JMP 0x00101242 | size_t func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
char *pcVar5;
char *pcVar6;
sVar3 = strlen(param_1);
cVar1 = *param_1;
sVar4 = sVar3;
pcVar6 = param_1;
while (cVar1 == ' ') {
pcVar6 = pcVar6 + 1;
sVar4 = (size_t)(uint)(((int)param_1 - (int)pcVar6) + (int)sVar3);
cVar1 = *pcVar6;
}
iVar2 = (int)sVar4;
if (0 < iVar2) {
if ((cVar1 - 0x2bU & 0xfd) == 0) {
if (iVar2 == 1) {
return sVar4;
}
pcVar5 = pcVar6 + 1;
do {
if (9 < (byte)(*pcVar5 - 0x30U)) {
return 0;
}
pcVar5 = pcVar5 + 1;
} while (pcVar6 + (ulong)(iVar2 - 2) + 2 != pcVar5);
}
else {
pcVar5 = pcVar6 + (ulong)(iVar2 - 1) + 1;
do {
if (9 < (byte)(*pcVar6 - 0x30U)) {
return 0;
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != pcVar5);
}
return 1;
}
return 0xffffffff;
} |
4,347 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} else {
if (text[0] == '+' || text[0] == '-') {
for (i = 1; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
} else {
for (i = 0; i < len; i++) {
if (text[i] < '0' || text[i] > '9') {
return 0;
}
}
return 1;
}
}
}
| int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
movzbl (%rbx),%ecx
cmp $0x20,%cl
jne 12c0 <func0+0xb0>
mov %rax,%rsi
mov %rbx,%rdx
add $0x1,%rdx
mov %ebx,%eax
movzbl (%rdx),%ecx
sub %edx,%eax
add %esi,%eax
cmp $0x20,%cl
je 1230 <func0+0x20>
test %eax,%eax
jle 12b0 <func0+0xa0>
sub $0x2b,%ecx
and $0xfd,%ecx
jne 1280 <func0+0x70>
cmp $0x1,%eax
je 127d <func0+0x6d>
sub $0x2,%eax
lea 0x1(%rdx),%rcx
lea 0x2(%rdx,%rax,1),%rdx
jmp 1271 <func0+0x61>
nopl 0x0(%rax)
add $0x1,%rcx
cmp %rcx,%rdx
je 12a3 <func0+0x93>
movzbl (%rcx),%eax
sub $0x30,%eax
cmp $0x9,%al
jbe 1268 <func0+0x58>
xor %eax,%eax
pop %rbx
retq
sub $0x1,%eax
lea 0x1(%rdx,%rax,1),%rcx
nopl 0x0(%rax,%rax,1)
movzbl (%rdx),%eax
sub $0x30,%eax
cmp $0x9,%al
ja 127b <func0+0x6b>
add $0x1,%rdx
cmp %rdx,%rcx
jne 1290 <func0+0x80>
mov $0x1,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdx
jmpq 1242 <func0+0x32>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx ecx, byte ptr [rbx]
mov rdx, rbx
cmp cl, 20h ; ' '
jnz short loc_1241
nop dword ptr [rax+rax+00000000h]
loc_1230:
movzx ecx, byte ptr [rdx+1]
add rdx, 1
cmp cl, 20h ; ' '
jz short loc_1230
sub ebx, edx
add eax, ebx
loc_1241:
test eax, eax
jle short loc_12C0
sub ecx, 2Bh ; '+'
and ecx, 0FDh
jnz short loc_1280
cmp eax, 1
jz short loc_127D
sub eax, 2
lea rcx, [rdx+1]
lea rdx, [rdx+rax+2]
jmp short loc_1271
loc_1268:
add rcx, 1
cmp rdx, rcx
jz short loc_12B0
loc_1271:
movzx eax, byte ptr [rcx]
sub eax, 30h ; '0'
cmp al, 9
jbe short loc_1268
loc_127B:
xor eax, eax
loc_127D:
pop rbx
retn
loc_1280:
cdqe
add rax, rdx
jmp short loc_1299
loc_1290:
add rdx, 1
cmp rax, rdx
jz short loc_12B0
loc_1299:
movzx esi, byte ptr [rdx]
lea ecx, [rsi-30h]
cmp cl, 9
jbe short loc_1290
jmp short loc_127B
loc_12B0:
mov eax, 1
pop rbx
retn
loc_12C0:
mov eax, 0FFFFFFFFh
pop rbx
retn | size_t func0(const char *a1)
{
size_t result; // rax
char v2; // cl
const char *v3; // rdx
_BYTE *v4; // rcx
long long v5; // rdx
const char *v6; // rax
result = strlen(a1);
v2 = *a1;
v3 = a1;
if ( *a1 == 32 )
{
do
v2 = *++v3;
while ( v2 == 32 );
result = (unsigned int)((_DWORD)a1 - (_DWORD)v3 + result);
}
if ( (int)result <= 0 )
return 0xFFFFFFFFLL;
if ( ((v2 - 43) & 0xFD) != 0 )
{
v6 = &v3[(int)result];
while ( (unsigned __int8)(*v3 - 48) <= 9u )
{
if ( v6 == ++v3 )
return 1LL;
}
}
else
{
if ( (_DWORD)result == 1 )
return result;
v4 = v3 + 1;
v5 = (long long)&v3[(unsigned int)(result - 2) + 2];
while ( (unsigned __int8)(*v4 - 48) <= 9u )
{
if ( (_BYTE *)v5 == ++v4 )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX ECX,byte ptr [RBX]
MOV RDX,RBX
CMP CL,0x20
JNZ 0x00101241
NOP dword ptr [RAX + RAX*0x1]
LAB_00101230:
MOVZX ECX,byte ptr [RDX + 0x1]
ADD RDX,0x1
CMP CL,0x20
JZ 0x00101230
SUB EBX,EDX
ADD EAX,EBX
LAB_00101241:
TEST EAX,EAX
JLE 0x001012c0
SUB ECX,0x2b
AND ECX,0xfd
JNZ 0x00101280
CMP EAX,0x1
JZ 0x0010127d
SUB EAX,0x2
LEA RCX,[RDX + 0x1]
LEA RDX,[RDX + RAX*0x1 + 0x2]
JMP 0x00101271
LAB_00101268:
ADD RCX,0x1
CMP RDX,RCX
JZ 0x001012b0
LAB_00101271:
MOVZX EAX,byte ptr [RCX]
SUB EAX,0x30
CMP AL,0x9
JBE 0x00101268
LAB_0010127b:
XOR EAX,EAX
LAB_0010127d:
POP RBX
RET
LAB_00101280:
CDQE
ADD RAX,RDX
JMP 0x00101299
LAB_00101290:
ADD RDX,0x1
CMP RAX,RDX
JZ 0x001012b0
LAB_00101299:
MOVZX ESI,byte ptr [RDX]
LEA ECX,[RSI + -0x30]
CMP CL,0x9
JBE 0x00101290
JMP 0x0010127b
LAB_001012b0:
MOV EAX,0x1
POP RBX
RET
LAB_001012c0:
MOV EAX,0xffffffff
POP RBX
RET | size_t func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
char *pcVar5;
sVar3 = strlen(param_1);
cVar1 = *param_1;
pcVar5 = param_1;
if (cVar1 == ' ') {
do {
cVar1 = pcVar5[1];
pcVar5 = pcVar5 + 1;
} while (cVar1 == ' ');
sVar3 = (size_t)(uint)((int)sVar3 + ((int)param_1 - (int)pcVar5));
}
iVar2 = (int)sVar3;
if (0 < iVar2) {
if ((cVar1 - 0x2bU & 0xfd) == 0) {
if (iVar2 == 1) {
return sVar3;
}
pcVar4 = pcVar5 + 1;
do {
if (9 < (byte)(*pcVar4 - 0x30U)) {
return 0;
}
pcVar4 = pcVar4 + 1;
} while (pcVar5 + (ulong)(iVar2 - 2) + 2 != pcVar4);
}
else {
pcVar4 = pcVar5 + iVar2;
do {
if (9 < (byte)(*pcVar5 - 0x30U)) {
return 0;
}
pcVar5 = pcVar5 + 1;
} while (pcVar4 != pcVar5);
}
return 1;
}
return 0xffffffff;
} |
4,348 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
for(int k = 0; k < input[i].length; k++) {
if(counts[j].tuple.elements[k] != input[i].elements[k]) {
match = 0;
break;
}
}
if(match) {
counts[j].count++;
found = 1;
break;
}
}
}
if(!found) {
counts[unique].tuple = input[i];
counts[unique].count = 1;
unique++;
}
}
// Estimate the size needed for the string
int size = 2; // for [ and ]
for(int i = 0; i < unique; i++) {
size += 2; // for ( and )
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
size += strlen(num) + 2; // number and ", "
}
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
size += strlen(cnt) + 2; // count and ", "
}
if(unique > 0) size -= 2; // remove last ", "
size +=1; // for null terminator
char* result = malloc(size);
if(result == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}
strcpy(result, "[");
for(int i = 0; i < unique; i++) {
strcat(result, "(");
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
strcat(result, num);
if(j < counts[i].tuple.length -1) strcat(result, ", ");
}
strcat(result, ", ");
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
strcat(result, cnt);
strcat(result, ")");
if(i < unique -1) strcat(result, ", ");
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .elements = {2, 7, 0}, .length = 2 }
};
char* res1 = func0(test1, 6);
assert(strcmp(res1, "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]") == 0);
free(res1);
// Second test case
Tuple test2[] = {
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {7, 1, 0}, .length = 2 },
{ .elements = {4, 8, 0}, .length = 2 },
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {7, 1, 0}, .length = 2 }
};
char* res2 = func0(test2, 6);
assert(strcmp(res2, "[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]") == 0);
free(res2);
// Third test case
Tuple test3[] = {
{ .elements = {11, 13, 10}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 }
};
char* res3 = func0(test3, 6);
assert(strcmp(res3, "[(11, 13, 10, 1), (17, 21, 2), (4, 2, 3, 2), (9, 2, 1)]") == 0);
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x70,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rsi
mov %rsi,-0x18(%rbp)
xor %esi,%esi
mov %rsp,%rsi
mov %rsi,%r12
mov -0x7c(%rbp),%esi
movslq %esi,%rdi
sub $0x1,%rdi
mov %rdi,-0x40(%rbp)
movslq %esi,%rdi
mov %rdi,%rax
mov $0x0,%edx
imul $0xa0,%rdx,%r8
imul $0x0,%rax,%rdi
add %r8,%rdi
mov $0xa0,%r8d
mul %r8
add %rdx,%rdi
mov %rdi,%rdx
movslq %esi,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
movslq %esi,%rax
mov %rax,%rcx
mov $0x0,%ebx
imul $0xa0,%rbx,%rdx
imul $0x0,%rcx,%rax
lea (%rdx,%rax,1),%rdi
mov $0xa0,%eax
mul %rcx
lea (%rdi,%rdx,1),%rcx
mov %rcx,%rdx
movslq %esi,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 135f <func0+0xf6>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1348 <func0+0xdf>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1389 <func0+0x120>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x38(%rbp)
movl $0x0,-0x60(%rbp)
movl $0x0,-0x64(%rbp)
jmpq 154c <func0+0x2e3>
movl $0x0,-0x68(%rbp)
movl $0x0,-0x6c(%rbp)
jmpq 14d0 <func0+0x267>
mov -0x38(%rbp),%rcx
mov -0x6c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0xc,%rax
mov (%rax),%edx
mov -0x64(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov 0xc(%rax),%eax
cmp %eax,%edx
jne 14cc <func0+0x263>
movl $0x1,-0x5c(%rbp)
movl $0x0,-0x58(%rbp)
jmp 145d <func0+0x1f4>
mov -0x38(%rbp),%rcx
mov -0x58(%rbp),%eax
movslq %eax,%rsi
mov -0x6c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rsi,%rax
mov (%rcx,%rax,4),%edx
mov -0x64(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rcx
mov -0x78(%rbp),%rax
add %rax,%rcx
mov -0x58(%rbp),%eax
cltq
mov (%rcx,%rax,4),%eax
cmp %eax,%edx
je 1459 <func0+0x1f0>
movl $0x0,-0x5c(%rbp)
jmp 1478 <func0+0x20f>
addl $0x1,-0x58(%rbp)
mov -0x64(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov 0xc(%rax),%eax
cmp %eax,-0x58(%rbp)
jl 1411 <func0+0x1a8>
cmpl $0x0,-0x5c(%rbp)
je 14cc <func0+0x263>
mov -0x38(%rbp),%rcx
mov -0x6c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0x10,%rax
mov (%rax),%eax
lea 0x1(%rax),%ecx
mov -0x38(%rbp),%rsi
mov -0x6c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rsi,%rax
add $0x10,%rax
mov %ecx,(%rax)
movl $0x1,-0x68(%rbp)
jmp 14dc <func0+0x273>
addl $0x1,-0x6c(%rbp)
mov -0x6c(%rbp),%eax
cmp -0x60(%rbp),%eax
jl 13c2 <func0+0x159>
cmpl $0x0,-0x68(%rbp)
jne 1548 <func0+0x2df>
mov -0x64(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x78(%rbp),%rax
lea (%rdx,%rax,1),%rsi
mov -0x38(%rbp),%rcx
mov -0x60(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rax,%rcx
mov (%rsi),%rax
mov 0x8(%rsi),%rdx
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
mov -0x38(%rbp),%rcx
mov -0x60(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0x10,%rax
movl $0x1,(%rax)
addl $0x1,-0x60(%rbp)
addl $0x1,-0x64(%rbp)
mov -0x64(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 13af <func0+0x146>
movl $0x2,-0x54(%rbp)
movl $0x0,-0x50(%rbp)
jmpq 1649 <func0+0x3e0>
addl $0x2,-0x54(%rbp)
movl $0x0,-0x4c(%rbp)
jmp 15cd <func0+0x364>
mov -0x38(%rbp),%rcx
mov -0x4c(%rbp),%eax
movslq %eax,%rsi
mov -0x50(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rsi,%rax
mov (%rcx,%rax,4),%edx
lea -0x24(%rbp),%rax
lea 0xa65(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1150 <sprintf@plt>
lea -0x24(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,%edx
mov -0x54(%rbp),%eax
add %edx,%eax
add $0x2,%eax
mov %eax,-0x54(%rbp)
addl $0x1,-0x4c(%rbp)
mov -0x38(%rbp),%rcx
mov -0x50(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0xc,%rax
mov (%rax),%eax
cmp %eax,-0x4c(%rbp)
jl 1578 <func0+0x30f>
mov -0x38(%rbp),%rcx
mov -0x50(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0x10,%rax
mov (%rax),%edx
lea -0x24(%rbp),%rax
lea 0x9e9(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1150 <sprintf@plt>
lea -0x24(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,%edx
mov -0x54(%rbp),%eax
add %edx,%eax
add $0x2,%eax
mov %eax,-0x54(%rbp)
addl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x60(%rbp),%eax
jl 156b <func0+0x302>
cmpl $0x0,-0x60(%rbp)
jle 165f <func0+0x3f6>
subl $0x2,-0x54(%rbp)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cltq
mov %rax,%rdi
callq 1130 <malloc@plt>
mov %rax,-0x30(%rbp)
cmpq $0x0,-0x30(%rbp)
jne 16a5 <func0+0x43c>
mov 0x299e(%rip),%rax
mov %rax,%rcx
mov $0x19,%edx
mov $0x1,%esi
lea 0x975(%rip),%rdi
callq 1170 <fwrite@plt>
mov $0x1,%edi
callq 1160 <exit@plt>
mov -0x30(%rbp),%rax
movw $0x5b,(%rax)
movl $0x0,-0x48(%rbp)
jmpq 18b5 <func0+0x64c>
mov -0x30(%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 -0x30(%rbp),%rax
add %rdx,%rax
movw $0x28,(%rax)
movl $0x0,-0x44(%rbp)
jmpq 179e <func0+0x535>
mov -0x38(%rbp),%rcx
mov -0x44(%rbp),%eax
movslq %eax,%rsi
mov -0x48(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rsi,%rax
mov (%rcx,%rax,4),%edx
lea -0x24(%rbp),%rax
lea 0x8e9(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1150 <sprintf@plt>
lea -0x24(%rbp),%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1140 <strcat@plt>
mov -0x38(%rbp),%rcx
mov -0x48(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0xc,%rax
mov (%rax),%eax
sub $0x1,%eax
cmp %eax,-0x44(%rbp)
jge 179a <func0+0x531>
mov -0x30(%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 -0x30(%rbp),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
addl $0x1,-0x44(%rbp)
mov -0x38(%rbp),%rcx
mov -0x48(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0xc,%rax
mov (%rax),%eax
cmp %eax,-0x44(%rbp)
jl 16f4 <func0+0x48b>
mov -0x30(%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 -0x30(%rbp),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
mov -0x38(%rbp),%rcx
mov -0x48(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x2,%rax
add %rcx,%rax
add $0x10,%rax
mov (%rax),%edx
lea -0x24(%rbp),%rax
lea 0x7e2(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1150 <sprintf@plt>
lea -0x24(%rbp),%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1140 <strcat@plt>
mov -0x30(%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 -0x30(%rbp),%rax
add %rdx,%rax
movw $0x29,(%rax)
mov -0x60(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x48(%rbp)
jge 18b1 <func0+0x648>
mov -0x30(%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 -0x30(%rbp),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
addl $0x1,-0x48(%rbp)
mov -0x48(%rbp),%eax
cmp -0x60(%rbp),%eax
jl 16ba <func0+0x451>
mov -0x30(%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 -0x30(%rbp),%rax
add %rdx,%rax
movw $0x5d,(%rax)
mov -0x30(%rbp),%rax
mov %r12,%rsp
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
je 190a <func0+0x6a1>
callq 1100 <__stack_chk_fail@plt>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov ecx, [rbp+var_7C]
movsxd rax, ecx
sub rax, 1
mov [rbp+var_40], rax
movsxd rax, ecx
mov rsi, rax
mov edi, 0
mov rax, rsi
mov rdx, rdi
shld rdx, rax, 2
shl rax, 2
add rax, rsi
adc rdx, rdi
shld rdx, rax, 5
shl rax, 5
movsxd rdx, ecx
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
movsxd rax, ecx
mov rsi, rax
mov edi, 0
mov rax, rsi
mov rdx, rdi
shld rdx, rax, 2
shl rax, 2
add rax, rsi
adc rdx, rdi
shld rdx, rax, 5
shl rax, 5
movsxd rdx, ecx
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
mov rdx, rax
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_1344:
cmp rsp, rdx
jz short loc_135B
sub rsp, 1000h
or [rsp+1080h+var_88], 0
jmp short loc_1344
loc_135B:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1385
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1385:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_38], rax
mov [rbp+var_6C], 0
mov [rbp+var_68], 0
jmp loc_1548
loc_13AB:
mov [rbp+var_64], 0
mov [rbp+var_60], 0
jmp loc_14CC
loc_13BE:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_60]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 0Ch
mov edx, [rax]
mov eax, [rbp+var_68]
cdqe
shl rax, 4
mov rcx, rax
mov rax, [rbp+var_78]
add rax, rcx
mov eax, [rax+0Ch]
cmp edx, eax
jnz loc_14C8
mov [rbp+var_5C], 1
mov [rbp+var_58], 0
jmp short loc_1459
loc_140D:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_58]
movsxd rsi, eax
mov eax, [rbp+var_60]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rsi
mov edx, [rcx+rax*4]
mov eax, [rbp+var_68]
cdqe
shl rax, 4
mov rcx, rax
mov rax, [rbp+var_78]
add rcx, rax
mov eax, [rbp+var_58]
cdqe
mov eax, [rcx+rax*4]
cmp edx, eax
jz short loc_1455
mov [rbp+var_5C], 0
jmp short loc_1474
loc_1455:
add [rbp+var_58], 1
loc_1459:
mov eax, [rbp+var_68]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_78]
add rax, rdx
mov eax, [rax+0Ch]
cmp [rbp+var_58], eax
jl short loc_140D
loc_1474:
cmp [rbp+var_5C], 0
jz short loc_14C8
mov rcx, [rbp+var_38]
mov eax, [rbp+var_60]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 10h
mov eax, [rax]
lea ecx, [rax+1]
mov rsi, [rbp+var_38]
mov eax, [rbp+var_60]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rsi
add rax, 10h
mov [rax], ecx
mov [rbp+var_64], 1
jmp short loc_14D8
loc_14C8:
add [rbp+var_60], 1
loc_14CC:
mov eax, [rbp+var_60]
cmp eax, [rbp+var_6C]
jl loc_13BE
loc_14D8:
cmp [rbp+var_64], 0
jnz short loc_1544
mov eax, [rbp+var_68]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_78]
lea rsi, [rdx+rax]
mov rcx, [rbp+var_38]
mov eax, [rbp+var_6C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rcx, rax
mov rax, [rsi]
mov rdx, [rsi+8]
mov [rcx], rax
mov [rcx+8], rdx
mov rcx, [rbp+var_38]
mov eax, [rbp+var_6C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 10h
mov dword ptr [rax], 1
add [rbp+var_6C], 1
loc_1544:
add [rbp+var_68], 1
loc_1548:
mov eax, [rbp+var_68]
cmp eax, [rbp+var_7C]
jl loc_13AB
mov [rbp+var_54], 2
mov [rbp+var_50], 0
jmp loc_164B
loc_1567:
add [rbp+var_54], 2
mov [rbp+var_4C], 0
jmp short loc_15CC
loc_1574:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_4C]
movsxd rsi, eax
mov eax, [rbp+var_50]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rsi
mov edx, [rcx+rax*4]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_54]
add eax, edx
add eax, 2
mov [rbp+var_54], eax
add [rbp+var_4C], 1
loc_15CC:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_50]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 0Ch
mov eax, [rax]
cmp [rbp+var_4C], eax
jl short loc_1574
mov rcx, [rbp+var_38]
mov eax, [rbp+var_50]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 10h
mov edx, [rax]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_54]
add eax, edx
add eax, 2
mov [rbp+var_54], eax
add [rbp+var_50], 1
loc_164B:
mov eax, [rbp+var_50]
cmp eax, [rbp+var_6C]
jl loc_1567
cmp [rbp+var_6C], 0
jle short loc_1661
sub [rbp+var_54], 2
loc_1661:
add [rbp+var_54], 1
mov eax, [rbp+var_54]
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
cmp [rbp+dest], 0
jnz short loc_16AA
mov rax, cs:__bss_start
mov rcx, rax; s
mov edx, 19h; n
mov esi, 1; size
lea rax, aMemoryAllocati; "Memory allocation failed\n"
mov rdi, rax; ptr
call _fwrite
mov edi, 1; status
call _exit
loc_16AA:
mov rax, [rbp+dest]
mov word ptr [rax], 5Bh ; '['
mov [rbp+var_48], 0
jmp loc_1861
loc_16BF:
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 28h ; '('
mov [rbp+var_44], 0
jmp loc_1780
loc_16E6:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_44]
movsxd rsi, eax
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rsi
mov edx, [rcx+rax*4]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
mov rcx, [rbp+var_38]
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 0Ch
mov eax, [rax]
sub eax, 1
cmp [rbp+var_44], eax
jge short loc_177C
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
loc_177C:
add [rbp+var_44], 1
loc_1780:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 0Ch
mov eax, [rax]
cmp [rbp+var_44], eax
jl loc_16E6
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
mov rcx, [rbp+var_38]
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 2
add rax, rcx
add rax, 10h
mov edx, [rax]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 29h ; ')'
mov eax, [rbp+var_6C]
sub eax, 1
cmp [rbp+var_48], eax
jge short loc_185D
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
loc_185D:
add [rbp+var_48], 1
loc_1861:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_6C]
jl loc_16BF
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 5Dh ; ']'
mov rax, [rbp+dest]
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_18A3
call ___stack_chk_fail
loc_18A3:
mov rbx, [rbp+var_8]
leave
retn | char * func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_QWORD *v4; // rsi
_QWORD *v5; // rcx
long long v6; // rdx
int v7; // eax
int v8; // eax
size_t v9; // rax
size_t v10; // rax
size_t v11; // rax
size_t v12; // rax
size_t v13; // rax
size_t v14; // rax
_BYTE v16[4]; // [rsp+8h] [rbp-80h] BYREF
int v17; // [rsp+Ch] [rbp-7Ch]
long long v18; // [rsp+10h] [rbp-78h]
int v19; // [rsp+1Ch] [rbp-6Ch]
int i; // [rsp+20h] [rbp-68h]
int v21; // [rsp+24h] [rbp-64h]
int j; // [rsp+28h] [rbp-60h]
int v23; // [rsp+2Ch] [rbp-5Ch]
int k; // [rsp+30h] [rbp-58h]
int v25; // [rsp+34h] [rbp-54h]
int m; // [rsp+38h] [rbp-50h]
int n; // [rsp+3Ch] [rbp-4Ch]
int ii; // [rsp+40h] [rbp-48h]
int jj; // [rsp+44h] [rbp-44h]
long long v30; // [rsp+48h] [rbp-40h]
_BYTE *v31; // [rsp+50h] [rbp-38h]
char *dest; // [rsp+58h] [rbp-30h]
char s[12]; // [rsp+64h] [rbp-24h] BYREF
unsigned long long v34; // [rsp+70h] [rbp-18h]
v18 = a1;
v17 = a2;
v34 = __readfsqword(0x28u);
v30 = a2 - 1LL;
v2 = 16 * ((20LL * a2 + 15) / 0x10uLL);
while ( v16 != &v16[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v16[(v2 & 0xFFF) - 8] = *(_QWORD *)&v16[(v2 & 0xFFF) - 8];
v31 = v16;
v19 = 0;
for ( i = 0; i < v17; ++i )
{
v21 = 0;
for ( j = 0; j < v19; ++j )
{
if ( *(_DWORD *)&v31[20 * j + 12] == *(_DWORD *)(16LL * i + v18 + 12) )
{
v23 = 1;
for ( k = 0; k < *(_DWORD *)(16LL * i + v18 + 12); ++k )
{
if ( *(_DWORD *)&v31[20 * j + 4 * k] != *(_DWORD *)(v18 + 16LL * i + 4LL * k) )
{
v23 = 0;
break;
}
}
if ( v23 )
{
++*(_DWORD *)&v31[20 * j + 16];
v21 = 1;
break;
}
}
}
if ( !v21 )
{
v4 = (_QWORD *)(16LL * i + v18);
v5 = &v31[20 * v19];
v6 = v4[1];
*v5 = *v4;
v5[1] = v6;
*(_DWORD *)&v31[20 * v19++ + 16] = 1;
}
}
v25 = 2;
for ( m = 0; m < v19; ++m )
{
v25 += 2;
for ( n = 0; n < *(_DWORD *)&v31[20 * m + 12]; ++n )
{
sprintf(s, "%d", *(_DWORD *)&v31[20 * m + 4 * n]);
v7 = strlen(s);
v25 += v7 + 2;
}
sprintf(s, "%d", *(_DWORD *)&v31[20 * m + 16]);
v8 = strlen(s);
v25 += v8 + 2;
}
if ( v19 > 0 )
v25 -= 2;
dest = (char *)malloc(++v25);
if ( !dest )
{
fwrite("Memory allocation failed\n", 1uLL, 0x19uLL, _bss_start);
exit(1);
}
*(_WORD *)dest = 91;
for ( ii = 0; ii < v19; ++ii )
{
v9 = strlen(dest);
*(_WORD *)&dest[v9] = 40;
for ( jj = 0; jj < *(_DWORD *)&v31[20 * ii + 12]; ++jj )
{
sprintf(s, "%d", *(_DWORD *)&v31[20 * ii + 4 * jj]);
strcat(dest, s);
if ( jj < *(_DWORD *)&v31[20 * ii + 12] - 1 )
{
v10 = strlen(dest);
strcpy(&dest[v10], ", ");
}
}
v11 = strlen(dest);
strcpy(&dest[v11], ", ");
sprintf(s, "%d", *(_DWORD *)&v31[20 * ii + 16]);
strcat(dest, s);
v12 = strlen(dest);
*(_WORD *)&dest[v12] = 41;
if ( ii < v19 - 1 )
{
v13 = strlen(dest);
strcpy(&dest[v13], ", ");
}
}
v14 = strlen(dest);
*(_WORD *)&dest[v14] = 93;
return dest;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV ECX,dword ptr [RBP + -0x7c]
MOVSXD RAX,ECX
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOVSXD RAX,ECX
MOV RSI,RAX
MOV EDI,0x0
MOV RAX,RSI
MOV RDX,RDI
SHLD RDX,RAX,0x2
SHL RAX,0x2
ADD RAX,RSI
ADC RDX,RDI
SHLD RDX,RAX,0x5
SHL RAX,0x5
MOVSXD RDX,ECX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
MOVSXD RAX,ECX
MOV RSI,RAX
MOV EDI,0x0
MOV RAX,RSI
MOV RDX,RDI
SHLD RDX,RAX,0x2
SHL RAX,0x2
ADD RAX,RSI
ADC RDX,RDI
SHLD RDX,RAX,0x5
SHL RAX,0x5
MOVSXD RDX,ECX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_00101344:
CMP RSP,RDX
JZ 0x0010135b
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101344
LAB_0010135b:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101385
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101385:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x6c],0x0
MOV dword ptr [RBP + -0x68],0x0
JMP 0x00101548
LAB_001013ab:
MOV dword ptr [RBP + -0x64],0x0
MOV dword ptr [RBP + -0x60],0x0
JMP 0x001014cc
LAB_001013be:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x60]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0xc
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x68]
CDQE
SHL RAX,0x4
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0xc]
CMP EDX,EAX
JNZ 0x001014c8
MOV dword ptr [RBP + -0x5c],0x1
MOV dword ptr [RBP + -0x58],0x0
JMP 0x00101459
LAB_0010140d:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x58]
MOVSXD RSI,EAX
MOV EAX,dword ptr [RBP + -0x60]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RSI
MOV EDX,dword ptr [RCX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x68]
CDQE
SHL RAX,0x4
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RCX,RAX
MOV EAX,dword ptr [RBP + -0x58]
CDQE
MOV EAX,dword ptr [RCX + RAX*0x4]
CMP EDX,EAX
JZ 0x00101455
MOV dword ptr [RBP + -0x5c],0x0
JMP 0x00101474
LAB_00101455:
ADD dword ptr [RBP + -0x58],0x1
LAB_00101459:
MOV EAX,dword ptr [RBP + -0x68]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0xc]
CMP dword ptr [RBP + -0x58],EAX
JL 0x0010140d
LAB_00101474:
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x001014c8
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x60]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0x10
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + 0x1]
MOV RSI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x60]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RSI
ADD RAX,0x10
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x64],0x1
JMP 0x001014d8
LAB_001014c8:
ADD dword ptr [RBP + -0x60],0x1
LAB_001014cc:
MOV EAX,dword ptr [RBP + -0x60]
CMP EAX,dword ptr [RBP + -0x6c]
JL 0x001013be
LAB_001014d8:
CMP dword ptr [RBP + -0x64],0x0
JNZ 0x00101544
MOV EAX,dword ptr [RBP + -0x68]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x78]
LEA RSI,[RDX + RAX*0x1]
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RCX,RAX
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0x10
MOV dword ptr [RAX],0x1
ADD dword ptr [RBP + -0x6c],0x1
LAB_00101544:
ADD dword ptr [RBP + -0x68],0x1
LAB_00101548:
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,dword ptr [RBP + -0x7c]
JL 0x001013ab
MOV dword ptr [RBP + -0x54],0x2
MOV dword ptr [RBP + -0x50],0x0
JMP 0x0010164b
LAB_00101567:
ADD dword ptr [RBP + -0x54],0x2
MOV dword ptr [RBP + -0x4c],0x0
JMP 0x001015cc
LAB_00101574:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x4c]
MOVSXD RSI,EAX
MOV EAX,dword ptr [RBP + -0x50]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RSI
MOV EDX,dword ptr [RCX + RAX*0x4]
LEA RAX,[RBP + -0x24]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101150
LEA RAX,[RBP + -0x24]
MOV RDI,RAX
CALL 0x001010f0
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,EDX
ADD EAX,0x2
MOV dword ptr [RBP + -0x54],EAX
ADD dword ptr [RBP + -0x4c],0x1
LAB_001015cc:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x50]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0xc
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4c],EAX
JL 0x00101574
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x50]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0x10
MOV EDX,dword ptr [RAX]
LEA RAX,[RBP + -0x24]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101150
LEA RAX,[RBP + -0x24]
MOV RDI,RAX
CALL 0x001010f0
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,EDX
ADD EAX,0x2
MOV dword ptr [RBP + -0x54],EAX
ADD dword ptr [RBP + -0x50],0x1
LAB_0010164b:
MOV EAX,dword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x6c]
JL 0x00101567
CMP dword ptr [RBP + -0x6c],0x0
JLE 0x00101661
SUB dword ptr [RBP + -0x54],0x2
LAB_00101661:
ADD dword ptr [RBP + -0x54],0x1
MOV EAX,dword ptr [RBP + -0x54]
CDQE
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001016aa
MOV RAX,qword ptr [0x00104020]
MOV RCX,RAX
MOV EDX,0x19
MOV ESI,0x1
LEA RAX,[0x10200b]
MOV RDI,RAX
CALL 0x00101170
MOV EDI,0x1
CALL 0x00101160
LAB_001016aa:
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX],0x5b
MOV dword ptr [RBP + -0x48],0x0
JMP 0x00101861
LAB_001016bf:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV word ptr [RAX],0x28
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101780
LAB_001016e6:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RSI,EAX
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RSI
MOV EDX,dword ptr [RCX + RAX*0x4]
LEA RAX,[RBP + -0x24]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101150
LEA RDX,[RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101140
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0xc
MOV EAX,dword ptr [RAX]
SUB EAX,0x1
CMP dword ptr [RBP + -0x44],EAX
JGE 0x0010177c
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_0010177c:
ADD dword ptr [RBP + -0x44],0x1
LAB_00101780:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0xc
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x44],EAX
JL 0x001016e6
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,0x10
MOV EDX,dword ptr [RAX]
LEA RAX,[RBP + -0x24]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101150
LEA RDX,[RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101140
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV word ptr [RAX],0x29
MOV EAX,dword ptr [RBP + -0x6c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x48],EAX
JGE 0x0010185d
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_0010185d:
ADD dword ptr [RBP + -0x48],0x1
LAB_00101861:
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x6c]
JL 0x001016bf
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV word ptr [RAX],0x5d
MOV RAX,qword ptr [RBP + -0x30]
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001018a3
CALL 0x00101100
LAB_001018a3:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | char * func0(long param_1,int param_2)
{
int8 *puVar1;
uint uVar2;
int8 uVar3;
long lVar4;
ulong uVar5;
size_t sVar6;
char *pcVar7;
int *puVar8;
long in_FS_OFFSET;
int auStack_88 [4];
int local_84;
long local_80;
int local_74;
int local_70;
int local_6c;
int local_68;
int local_64;
int local_60;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
long local_48;
int *local_40;
char *local_38;
char local_2c [12];
long local_20;
local_80 = param_1;
local_84 = param_2;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = (long)param_2 + -1;
uVar5 = (((long)param_2 * 0x14 + 0xfU) / 0x10) * 0x10;
for (puVar8 = auStack_88; puVar8 != auStack_88 + -(uVar5 & 0xfffffffffffff000);
puVar8 = puVar8 + -0x1000) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
lVar4 = -(ulong)((uint)uVar5 & 0xfff);
if ((uVar5 & 0xfff) != 0) {
*(int8 *)(puVar8 + ((ulong)((uint)uVar5 & 0xfff) - 8) + lVar4) =
*(int8 *)(puVar8 + ((ulong)((uint)uVar5 & 0xfff) - 8) + lVar4);
}
local_74 = 0;
local_70 = 0;
do {
if (local_84 <= local_70) {
local_5c = 2;
local_40 = puVar8 + lVar4;
for (local_58 = 0; local_58 < local_74; local_58 = local_58 + 1) {
for (local_54 = 0; local_5c = local_5c + 2,
local_54 < *(int *)(local_40 + (long)local_58 * 0x14 + 0xc); local_54 = local_54 + 1) {
uVar2 = *(uint *)(local_40 + ((long)local_58 * 5 + (long)local_54) * 4);
*(int8 *)(puVar8 + lVar4 + -8) = 0x1015af;
sprintf(local_2c,"%d",(ulong)uVar2);
*(int8 *)(puVar8 + lVar4 + -8) = 0x1015bb;
sVar6 = strlen(local_2c);
local_5c = local_5c + (int)sVar6;
}
uVar2 = *(uint *)(local_40 + (long)local_58 * 0x14 + 0x10);
*(int8 *)(puVar8 + lVar4 + -8) = 0x10162e;
sprintf(local_2c,"%d",(ulong)uVar2);
*(int8 *)(puVar8 + lVar4 + -8) = 0x10163a;
sVar6 = strlen(local_2c);
local_5c = local_5c + (int)sVar6 + 2;
}
if (0 < local_74) {
local_5c = local_5c + -2;
}
local_5c = local_5c + 1;
sVar6 = (size_t)local_5c;
*(int8 *)(puVar8 + lVar4 + -8) = 0x101672;
local_38 = (char *)malloc(sVar6);
if (local_38 == (char *)0x0) {
*(int8 *)(puVar8 + lVar4 + -8) = 0x1016a0;
fwrite("Memory allocation failed\n",1,0x19,stderr);
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + lVar4 + -8) = 0x1016aa;
exit(1);
}
local_38[0] = '[';
local_38[1] = '\0';
for (local_50 = 0; pcVar7 = local_38, local_50 < local_74; local_50 = local_50 + 1) {
*(int8 *)(puVar8 + lVar4 + -8) = 0x1016cb;
sVar6 = strlen(pcVar7);
(local_38 + sVar6)[0] = '(';
(local_38 + sVar6)[1] = '\0';
for (local_4c = 0; pcVar7 = local_38,
local_4c < *(int *)(local_40 + (long)local_50 * 0x14 + 0xc); local_4c = local_4c + 1) {
uVar2 = *(uint *)(local_40 + ((long)local_50 * 5 + (long)local_4c) * 4);
*(int8 *)(puVar8 + lVar4 + -8) = 0x101721;
sprintf(local_2c,"%d",(ulong)uVar2);
pcVar7 = local_38;
*(int8 *)(puVar8 + lVar4 + -8) = 0x101734;
strcat(pcVar7,local_2c);
pcVar7 = local_38;
if (local_4c < *(int *)(local_40 + (long)local_50 * 0x14 + 0xc) + -1) {
*(int8 *)(puVar8 + lVar4 + -8) = 0x101769;
sVar6 = strlen(pcVar7);
pcVar7 = local_38 + sVar6;
pcVar7[0] = ',';
pcVar7[1] = ' ';
pcVar7[2] = '\0';
}
}
*(int8 *)(puVar8 + lVar4 + -8) = 0x1017b6;
sVar6 = strlen(pcVar7);
pcVar7 = local_38 + sVar6;
pcVar7[0] = ',';
pcVar7[1] = ' ';
pcVar7[2] = '\0';
uVar2 = *(uint *)(local_40 + (long)local_50 * 0x14 + 0x10);
*(int8 *)(puVar8 + lVar4 + -8) = 0x101805;
sprintf(local_2c,"%d",(ulong)uVar2);
pcVar7 = local_38;
*(int8 *)(puVar8 + lVar4 + -8) = 0x101818;
strcat(pcVar7,local_2c);
pcVar7 = local_38;
*(int8 *)(puVar8 + lVar4 + -8) = 0x101824;
sVar6 = strlen(pcVar7);
pcVar7 = local_38;
(local_38 + sVar6)[0] = ')';
(local_38 + sVar6)[1] = '\0';
if (local_50 < local_74 + -1) {
*(int8 *)(puVar8 + lVar4 + -8) = 0x10184a;
sVar6 = strlen(pcVar7);
pcVar7 = local_38 + sVar6;
pcVar7[0] = ',';
pcVar7[1] = ' ';
pcVar7[2] = '\0';
}
}
*(int8 *)(puVar8 + lVar4 + -8) = 0x101879;
sVar6 = strlen(pcVar7);
(local_38 + sVar6)[0] = ']';
(local_38 + sVar6)[1] = '\0';
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_38;
}
local_6c = 0;
for (local_68 = 0; local_68 < local_74; local_68 = local_68 + 1) {
if (*(int *)(puVar8 + (long)local_68 * 0x14 + lVar4 + 0xc) ==
*(int *)(local_80 + (long)local_70 * 0x10 + 0xc)) {
local_64 = 1;
for (local_60 = 0; local_60 < *(int *)(local_80 + (long)local_70 * 0x10 + 0xc);
local_60 = local_60 + 1) {
if (*(int *)(puVar8 + ((long)local_68 * 5 + (long)local_60) * 4 + lVar4) !=
*(int *)((long)local_70 * 0x10 + local_80 + (long)local_60 * 4)) {
local_64 = 0;
break;
}
}
if (local_64 != 0) {
*(int *)(puVar8 + (long)local_68 * 0x14 + lVar4 + 0x10) =
*(int *)(puVar8 + (long)local_68 * 0x14 + lVar4 + 0x10) + 1;
local_6c = 1;
break;
}
}
}
if (local_6c == 0) {
puVar1 = (int8 *)((long)local_70 * 0x10 + local_80);
uVar3 = puVar1[1];
*(int8 *)(puVar8 + (long)local_74 * 0x14 + lVar4) = *puVar1;
*(int8 *)((long)(puVar8 + (long)local_74 * 0x14 + lVar4) + 8) = uVar3;
*(int4 *)(puVar8 + (long)local_74 * 0x14 + lVar4 + 0x10) = 1;
local_74 = local_74 + 1;
}
local_70 = local_70 + 1;
} while( true );
} |
4,349 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
for(int k = 0; k < input[i].length; k++) {
if(counts[j].tuple.elements[k] != input[i].elements[k]) {
match = 0;
break;
}
}
if(match) {
counts[j].count++;
found = 1;
break;
}
}
}
if(!found) {
counts[unique].tuple = input[i];
counts[unique].count = 1;
unique++;
}
}
// Estimate the size needed for the string
int size = 2; // for [ and ]
for(int i = 0; i < unique; i++) {
size += 2; // for ( and )
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
size += strlen(num) + 2; // number and ", "
}
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
size += strlen(cnt) + 2; // count and ", "
}
if(unique > 0) size -= 2; // remove last ", "
size +=1; // for null terminator
char* result = malloc(size);
if(result == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}
strcpy(result, "[");
for(int i = 0; i < unique; i++) {
strcat(result, "(");
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
strcat(result, num);
if(j < counts[i].tuple.length -1) strcat(result, ", ");
}
strcat(result, ", ");
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
strcat(result, cnt);
strcat(result, ")");
if(i < unique -1) strcat(result, ", ");
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .elements = {2, 7, 0}, .length = 2 }
};
char* res1 = func0(test1, 6);
assert(strcmp(res1, "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]") == 0);
free(res1);
// Second test case
Tuple test2[] = {
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {7, 1, 0}, .length = 2 },
{ .elements = {4, 8, 0}, .length = 2 },
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {7, 1, 0}, .length = 2 }
};
char* res2 = func0(test2, 6);
assert(strcmp(res2, "[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]") == 0);
free(res2);
// Third test case
Tuple test3[] = {
{ .elements = {11, 13, 10}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 }
};
char* res3 = func0(test3, 6);
assert(strcmp(res3, "[(11, 13, 10, 1), (17, 21, 2), (4, 2, 3, 2), (9, 2, 1)]") == 0);
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea (%rax,%rax,4),%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 1289 <func0+0x60>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1272 <func0+0x49>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 129f <func0+0x76>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r10
mov %r10,%r11
test %esi,%esi
jle 15c4 <func0+0x39b>
mov %rdi,%r9
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%r12
mov $0x0,%ebx
jmp 133d <func0+0x114>
add $0x1,%ecx
add $0x14,%rdx
cmp %ebx,%ecx
je 130f <func0+0xe6>
mov %rdx,%rdi
cmp %esi,0xc(%rdx)
jne 12c3 <func0+0x9a>
test %esi,%esi
jle 12f1 <func0+0xc8>
mov $0x0,%eax
mov (%r8,%rax,4),%r15d
cmp %r15d,(%rdi,%rax,4)
jne 12c3 <func0+0x9a>
add $0x1,%rax
cmp %eax,%esi
jg 12df <func0+0xb6>
movslq %ecx,%rcx
lea 0x0(,%rcx,4),%rax
lea (%rax,%rcx,1),%rdx
mov 0x10(%r11,%rdx,4),%eax
add $0x1,%eax
mov %eax,0x10(%r11,%rdx,4)
jmp 1334 <func0+0x10b>
movslq %ebx,%rdx
lea 0x0(,%rdx,4),%rax
lea (%rax,%rdx,1),%rcx
movdqu (%r9),%xmm0
movups %xmm0,(%r11,%rcx,4)
movl $0x1,0x10(%r11,%rcx,4)
add $0x1,%ebx
add $0x10,%r9
cmp %r12,%r9
je 1355 <func0+0x12c>
test %ebx,%ebx
jle 130f <func0+0xe6>
mov %r9,%r8
mov 0xc(%r9),%esi
mov %r11,%rdx
mov $0x0,%ecx
jmpq 12ce <func0+0xa5>
test %ebx,%ebx
jle 15c4 <func0+0x39b>
mov %r10,-0x68(%rbp)
lea -0x1(%rbx),%eax
lea (%rax,%rax,4),%rax
lea 0x14(%r10,%rax,4),%rax
mov %rax,-0x70(%rbp)
mov $0x2,%r13d
lea -0x44(%rbp),%r14
mov %ebx,-0x74(%rbp)
mov %r13d,%r12d
mov %r10,%r13
jmp 13da <func0+0x1b1>
mov -0x58(%rbp),%rax
mov 0x10(%rax),%r8d
lea 0xc6f(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov %r14,%rdi
mov $0x0,%eax
callq 1130 <__sprintf_chk@plt>
mov $0x0,%eax
mov $0xffffffffffffffff,%rcx
mov %r14,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%r12,%rax,1),%eax
lea 0x2(%rax),%r12d
add $0x14,%r13
cmp -0x70(%rbp),%r13
je 15fd <func0+0x3d4>
add $0x2,%r12d
mov %r13,-0x58(%rbp)
mov 0xc(%r13),%r15d
test %r15d,%r15d
jle 1386 <func0+0x15d>
mov $0x0,%ebx
mov %r13,-0x60(%rbp)
mov 0x0(%r13,%rbx,4),%r8d
lea 0xc04(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov %r14,%rdi
mov $0x0,%eax
callq 1130 <__sprintf_chk@plt>
mov $0x0,%eax
mov $0xffffffffffffffff,%rcx
mov %r14,%rdi
repnz scas %es:(%rdi),%al
sub %ecx,%r12d
add $0x1,%rbx
cmp %ebx,%r15d
jg 13f4 <func0+0x1cb>
mov -0x60(%rbp),%r13
jmpq 1386 <func0+0x15d>
add $0x1,%rbx
cmp %ebx,%r14d
jle 149f <func0+0x276>
mov -0x58(%rbp),%rax
mov (%rax,%rbx,4),%r8d
lea 0xbaf(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov %r12,%rdi
mov %r15d,%eax
callq 1130 <__sprintf_chk@plt>
mov %r12,%rsi
mov %r13,%rdi
callq 1100 <strcat@plt>
lea -0x1(%r14),%eax
cmp %ebx,%eax
jle 143d <func0+0x214>
mov $0xffffffffffffffff,%rcx
mov %r13,%rdi
mov %r15d,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%r13,%rcx,1),%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
jmp 143d <func0+0x214>
mov $0xffffffffffffffff,%rcx
mov %r13,%rdi
mov %r15d,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%r13,%rcx,1),%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
mov -0x58(%rbp),%rax
mov 0x10(%rax),%r8d
lea 0xb36(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov %r12,%rdi
mov %r15d,%eax
callq 1130 <__sprintf_chk@plt>
mov %r12,%rsi
mov %r13,%rdi
callq 1100 <strcat@plt>
mov $0xffffffffffffffff,%rcx
mov %r13,%rdi
mov %r15d,%eax
repnz scas %es:(%rdi),%al
not %rcx
movw $0x29,-0x1(%r13,%rcx,1)
mov -0x60(%rbp),%ebx
cmp %ebx,-0x70(%rbp)
jg 155a <func0+0x331>
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
addq $0x14,-0x68(%rbp)
cmp %eax,-0x74(%rbp)
je 1580 <func0+0x357>
mov $0xffffffffffffffff,%rcx
mov %r13,%rdi
mov %r15d,%eax
repnz scas %es:(%rdi),%al
not %rcx
movw $0x28,-0x1(%r13,%rcx,1)
mov -0x68(%rbp),%rax
mov %rax,-0x58(%rbp)
mov 0xc(%rax),%r14d
test %r14d,%r14d
jle 149f <func0+0x276>
mov $0x0,%ebx
jmpq 1446 <func0+0x21d>
mov $0xffffffffffffffff,%rcx
mov %r13,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%r13,%rcx,1),%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
jmp 1510 <func0+0x2e7>
movw $0x5b,0x0(%r13)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r13,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
movw $0x5d,-0x1(%r13,%rax,1)
mov -0x38(%rbp),%rax
xor %fs:0x28,%rax
jne 1639 <func0+0x410>
mov %r13,%rax
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
mov $0x3,%edi
callq 10f0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
jne 1579 <func0+0x350>
mov 0x2a43(%rip),%rcx
mov $0x19,%edx
mov $0x1,%esi
lea 0xa19(%rip),%rdi
callq 1120 <fwrite@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
mov -0x74(%rbp),%ebx
add $0x1,%eax
movslq %eax,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r13
test %rax,%rax
je 15d6 <func0+0x3ad>
movw $0x5b,0x0(%r13)
movl $0x0,-0x60(%rbp)
mov $0x0,%r15d
lea -0x44(%rbp),%r12
lea -0x1(%rbx),%eax
mov %eax,-0x70(%rbp)
mov %ebx,-0x74(%rbp)
jmpq 1521 <func0+0x2f8>
callq 10d0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rdx, rdi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
lea rax, [rax+rax*4]
lea rax, ds:0Fh[rax*4]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rax
loc_12B2:
cmp rsp, rcx
jz short loc_12C9
sub rsp, 1000h
or [rsp+1080h+var_88], 0
jmp short loc_12B2
loc_12C9:
mov rax, rdi
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_12DF
or [rsp+rax+80h+var_88], 0
loc_12DF:
mov r10, rsp
test esi, esi
jle loc_159E
mov r9, rdx
lea eax, [rsi-1]
shl rax, 4
lea r11, [rdx+rax+10h]
mov ebx, 0
jmp short loc_137A
loc_1300:
add ecx, 1
add rdx, 14h
cmp ecx, ebx
jz short loc_134C
loc_130B:
mov rdi, rdx
cmp [rdx+0Ch], esi
jnz short loc_1300
test esi, esi
jle short loc_132E
mov eax, 0
loc_131C:
mov r15d, [r8+rax*4]
cmp [rdi+rax*4], r15d
jnz short loc_1300
add rax, 1
cmp esi, eax
jg short loc_131C
loc_132E:
movsxd rcx, ecx
lea rax, ds:0[rcx*4]
lea rdx, [rax+rcx]
mov eax, [r10+rdx*4+10h]
add eax, 1
mov [r10+rdx*4+10h], eax
jmp short loc_1371
loc_134C:
movsxd rdx, ebx
lea rax, ds:0[rdx*4]
lea rcx, [rax+rdx]
movdqu xmm0, xmmword ptr [r9]
movups xmmword ptr [r10+rcx*4], xmm0
mov dword ptr [r10+rcx*4+10h], 1
add ebx, 1
loc_1371:
add r9, 10h
cmp r9, r11
jz short loc_1392
loc_137A:
test ebx, ebx
jle short loc_134C
mov r8, r9
mov esi, [r9+0Ch]
mov rdx, r10
mov ecx, 0
jmp loc_130B
loc_1392:
test ebx, ebx
jle loc_159E
mov [rbp+var_60], r10
lea eax, [rbx-1]
lea rax, [rax+rax*4]
lea rax, [r10+rax*4+14h]
mov [rbp+var_70], rax
mov eax, 2
lea r14, [rbp+var_44]
mov [rbp+var_74], ebx
mov r13, r10
jmp short loc_1403
loc_13BF:
mov rax, [rbp+var_58]
mov r8d, [rax+10h]
lea rcx, unk_2004
mov edx, 0Ch
mov esi, 1
mov rdi, r14
mov eax, 0
call ___sprintf_chk
mov rdi, r14
call _strlen
add r12d, eax
lea eax, [r12+2]
add r13, 14h
cmp r13, [rbp+var_70]
jz loc_15D7
loc_1403:
lea r12d, [rax+2]
mov [rbp+var_58], r13
mov r15d, [r13+0Ch]
test r15d, r15d
jle short loc_13BF
mov ebx, 0
mov [rbp+var_68], r13
loc_141D:
mov r8d, [r13+rbx*4+0]
lea rcx, unk_2004
mov edx, 0Ch
mov esi, 1
mov rdi, r14
mov eax, 0
call ___sprintf_chk
mov rdi, r14
call _strlen
lea r12d, [r12+rax+2]
add rbx, 1
cmp r15d, ebx
jg short loc_141D
mov r13, [rbp+var_68]
jmp loc_13BF
loc_145F:
add rbx, 1
cmp r12d, ebx
jle short loc_14B4
loc_1468:
mov r8d, [r14+rbx*4]
lea rcx, unk_2004
mov edx, 0Ch
mov esi, 1
mov rdi, r15
mov eax, 0
call ___sprintf_chk
mov rsi, r15
mov rdi, r13
call _strcat
lea eax, [r12-1]
cmp eax, ebx
jle short loc_145F
mov rdi, r13
call _strlen
add rax, r13
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
jmp short loc_145F
loc_14B4:
mov rdi, r13
call _strlen
add rax, r13
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
mov r8d, [r14+10h]
lea rcx, unk_2004
mov edx, 0Ch
mov esi, 1
mov rdi, r15
mov eax, 0
call ___sprintf_chk
mov rsi, r15
mov rdi, r13
call _strcat
mov rdi, r13
call _strlen
mov word ptr [r13+rax+0], 29h ; ')'
mov ecx, dword ptr [rbp+var_58]
cmp dword ptr [rbp+var_68], ecx
jg short loc_154C
loc_150D:
add dword ptr [rbp+var_58], 1
mov eax, dword ptr [rbp+var_58]
add [rbp+var_60], 14h
cmp dword ptr [rbp+var_70], eax
jz short loc_1569
loc_151E:
mov rdi, r13
call _strlen
mov word ptr [r13+rax+0], 28h ; '('
mov rax, [rbp+var_60]
mov r14, rax
mov r12d, [rax+0Ch]
test r12d, r12d
jle loc_14B4
mov ebx, 0
jmp loc_1468
loc_154C:
mov rdi, r13
call _strlen
add rax, r13
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
jmp short loc_150D
loc_1562:
mov word ptr [r13+0], 5Bh ; '['
loc_1569:
mov rdi, r13
call _strlen
mov word ptr [r13+rax+0], 5Dh ; ']'
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_1611
mov rax, r13
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_159E:
mov edi, 3
call _malloc
mov r13, rax
test rax, rax
jnz short loc_1562
loc_15B0:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 19h
mov esi, 1
lea rdi, aMemoryAllocati; "Memory allocation failed\n"
call _fwrite
mov edi, 1
call _exit
loc_15D7:
mov r13d, r12d
mov ebx, [rbp+var_74]
add r13d, 1
movsxd rdi, r13d
call _malloc
mov r13, rax
test rax, rax
jz short loc_15B0
mov word ptr [r13+0], 5Bh ; '['
mov dword ptr [rbp+var_58], 0
lea r15, [rbp+var_44]
lea eax, [rbx-1]
mov dword ptr [rbp+var_68], eax
mov dword ptr [rbp+var_70], ebx
jmp loc_151E
loc_1611:
call ___stack_chk_fail | char * func0(const __m128i *a1, long long a2)
{
long long v2; // rdx
signed long long v3; // rax
void *v4; // rsp
const __m128i *v5; // r9
long long m128i_i64; // r11
int v7; // ebx
int i; // ecx
_DWORD *v9; // rdx
long long v10; // rax
long long v11; // rcx
int v12; // eax
char *v13; // r13
long long v14; // rdx
int v15; // r12d
int v16; // r12d
int v17; // r15d
long long v18; // rbx
long long v19; // rbx
_DWORD *v20; // r14
int v21; // r12d
char *v23; // rax
char *v24; // r13
int v25; // ebx
char *v26; // rax
_DWORD v28[3]; // [rsp+8h] [rbp-80h] BYREF
int v29; // [rsp+14h] [rbp-74h]
char *v30; // [rsp+18h] [rbp-70h] BYREF
char *v31; // [rsp+20h] [rbp-68h]
_DWORD *v32; // [rsp+28h] [rbp-60h]
char *v33; // [rsp+30h] [rbp-58h]
_BYTE v34[12]; // [rsp+44h] [rbp-44h] BYREF
unsigned long long v35; // [rsp+50h] [rbp-38h]
v2 = (long long)a1;
v35 = __readfsqword(0x28u);
while ( v28 != (_DWORD *)((char *)v28 - ((20LL * (int)a2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v3 = (20 * (_WORD)a2 + 15) & 0xFF0;
v4 = alloca(v3);
if ( ((20 * (_WORD)a2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v28[-2] + v3) = *(_QWORD *)((char *)&v28[-2] + v3);
if ( (int)a2 <= 0 )
goto LABEL_35;
v5 = a1;
m128i_i64 = (long long)a1[(unsigned int)(a2 - 1) + 1].m128i_i64;
v7 = 0;
do
{
if ( v7 > 0 )
{
a2 = v5->m128i_u32[3];
v9 = v28;
for ( i = 0; i != v7; ++i )
{
if ( v9[3] == (_DWORD)a2 )
{
if ( (int)a2 <= 0 )
{
LABEL_13:
v2 = 5LL * i;
++*((_DWORD *)&v30 + 5 * i);
goto LABEL_15;
}
v10 = 0LL;
while ( v9[v10] == v5->m128i_i32[v10] )
{
if ( (int)a2 <= (int)++v10 )
goto LABEL_13;
}
}
v9 += 5;
}
}
v2 = v7;
v11 = 5LL * v7;
*(__m128i *)&v28[v11] = _mm_loadu_si128(v5);
*((_DWORD *)&v30 + v11) = 1;
++v7;
LABEL_15:
++v5;
}
while ( v5 != (const __m128i *)m128i_i64 );
if ( v7 <= 0 )
{
LABEL_35:
v23 = (char *)malloc(3LL, a2, v2);
v24 = v23;
if ( v23 )
{
*(_WORD *)v23 = 91;
goto LABEL_34;
}
LABEL_36:
fwrite("Memory allocation failed\n", 1LL, 25LL, stderr);
exit(1LL);
}
v32 = v28;
v30 = (char *)&v30 + 20 * (unsigned int)(v7 - 1) + 4;
v12 = 2;
v29 = v7;
v13 = (char *)v28;
do
{
v16 = v12 + 2;
v33 = v13;
v17 = *((_DWORD *)v13 + 3);
if ( v17 > 0 )
{
v18 = 0LL;
v31 = v13;
do
{
__sprintf_chk(v34, 1LL, 12LL, &unk_2004, *(unsigned int *)&v13[4 * v18]);
v16 += strlen(v34) + 2;
++v18;
}
while ( v17 > (int)v18 );
v13 = v31;
}
__sprintf_chk(v34, 1LL, 12LL, &unk_2004, *((unsigned int *)v33 + 4));
v15 = strlen(v34) + v16;
v12 = v15 + 2;
v13 += 20;
}
while ( v13 != v30 );
v25 = v29;
v26 = (char *)malloc(v15 + 1, 1LL, v14);
v24 = v26;
if ( !v26 )
goto LABEL_36;
*(_WORD *)v26 = 91;
LODWORD(v33) = 0;
LODWORD(v31) = v25 - 1;
LODWORD(v30) = v25;
do
{
*(_WORD *)&v24[strlen(v24)] = 40;
v20 = v32;
v21 = v32[3];
if ( v21 > 0 )
{
v19 = 0LL;
do
{
__sprintf_chk(v34, 1LL, 12LL, &unk_2004, (unsigned int)v20[v19]);
strcat(v24, v34);
if ( v21 - 1 > (int)v19 )
strcpy(&v24[strlen(v24)], ", ");
++v19;
}
while ( v21 > (int)v19 );
}
strcpy(&v24[strlen(v24)], ", ");
__sprintf_chk(v34, 1LL, 12LL, &unk_2004, (unsigned int)v20[4]);
strcat(v24, v34);
*(_WORD *)&v24[strlen(v24)] = 41;
if ( (int)v31 > (int)v33 )
strcpy(&v24[strlen(v24)], ", ");
LODWORD(v33) = (_DWORD)v33 + 1;
v32 += 5;
}
while ( (_DWORD)v30 != (_DWORD)v33 );
LABEL_34:
*(_WORD *)&v24[strlen(v24)] = 93;
return v24;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RDX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[0xf + RAX*0x4]
MOV RDI,RAX
AND RDI,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001012b2:
CMP RSP,RCX
JZ 0x001012c9
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001012b2
LAB_001012c9:
MOV RAX,RDI
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001012df
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001012df:
MOV R10,RSP
TEST ESI,ESI
JLE 0x0010159e
MOV R9,RDX
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA R11,[RDX + RAX*0x1 + 0x10]
MOV EBX,0x0
JMP 0x0010137a
LAB_00101300:
ADD ECX,0x1
ADD RDX,0x14
CMP ECX,EBX
JZ 0x0010134c
LAB_0010130b:
MOV RDI,RDX
CMP dword ptr [RDX + 0xc],ESI
JNZ 0x00101300
TEST ESI,ESI
JLE 0x0010132e
MOV EAX,0x0
LAB_0010131c:
MOV R15D,dword ptr [R8 + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R15D
JNZ 0x00101300
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010131c
LAB_0010132e:
MOVSXD RCX,ECX
LEA RAX,[RCX*0x4]
LEA RDX,[RAX + RCX*0x1]
MOV EAX,dword ptr [R10 + RDX*0x4 + 0x10]
ADD EAX,0x1
MOV dword ptr [R10 + RDX*0x4 + 0x10],EAX
JMP 0x00101371
LAB_0010134c:
MOVSXD RDX,EBX
LEA RAX,[RDX*0x4]
LEA RCX,[RAX + RDX*0x1]
MOVDQU XMM0,xmmword ptr [R9]
MOVUPS xmmword ptr [R10 + RCX*0x4],XMM0
MOV dword ptr [R10 + RCX*0x4 + 0x10],0x1
ADD EBX,0x1
LAB_00101371:
ADD R9,0x10
CMP R9,R11
JZ 0x00101392
LAB_0010137a:
TEST EBX,EBX
JLE 0x0010134c
MOV R8,R9
MOV ESI,dword ptr [R9 + 0xc]
MOV RDX,R10
MOV ECX,0x0
JMP 0x0010130b
LAB_00101392:
TEST EBX,EBX
JLE 0x0010159e
MOV qword ptr [RBP + -0x60],R10
LEA EAX,[RBX + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[R10 + RAX*0x4 + 0x14]
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,0x2
LEA R14,[RBP + -0x44]
MOV dword ptr [RBP + -0x74],EBX
MOV R13,R10
JMP 0x00101403
LAB_001013bf:
MOV RAX,qword ptr [RBP + -0x58]
MOV R8D,dword ptr [RAX + 0x10]
LEA RCX,[0x102004]
MOV EDX,0xc
MOV ESI,0x1
MOV RDI,R14
MOV EAX,0x0
CALL 0x00101170
MOV RDI,R14
CALL 0x001010f0
ADD R12D,EAX
LEA EAX,[R12 + 0x2]
ADD R13,0x14
CMP R13,qword ptr [RBP + -0x70]
JZ 0x001015d7
LAB_00101403:
LEA R12D,[RAX + 0x2]
MOV qword ptr [RBP + -0x58],R13
MOV R15D,dword ptr [R13 + 0xc]
TEST R15D,R15D
JLE 0x001013bf
MOV EBX,0x0
MOV qword ptr [RBP + -0x68],R13
LAB_0010141d:
MOV R8D,dword ptr [R13 + RBX*0x4]
LEA RCX,[0x102004]
MOV EDX,0xc
MOV ESI,0x1
MOV RDI,R14
MOV EAX,0x0
CALL 0x00101170
MOV RDI,R14
CALL 0x001010f0
LEA R12D,[R12 + RAX*0x1 + 0x2]
ADD RBX,0x1
CMP R15D,EBX
JG 0x0010141d
MOV R13,qword ptr [RBP + -0x68]
JMP 0x001013bf
LAB_0010145f:
ADD RBX,0x1
CMP R12D,EBX
JLE 0x001014b4
LAB_00101468:
MOV R8D,dword ptr [R14 + RBX*0x4]
LEA RCX,[0x102004]
MOV EDX,0xc
MOV ESI,0x1
MOV RDI,R15
MOV EAX,0x0
CALL 0x00101170
MOV RSI,R15
MOV RDI,R13
CALL 0x00101140
LEA EAX,[R12 + -0x1]
CMP EAX,EBX
JLE 0x0010145f
MOV RDI,R13
CALL 0x001010f0
ADD RAX,R13
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
JMP 0x0010145f
LAB_001014b4:
MOV RDI,R13
CALL 0x001010f0
ADD RAX,R13
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
MOV R8D,dword ptr [R14 + 0x10]
LEA RCX,[0x102004]
MOV EDX,0xc
MOV ESI,0x1
MOV RDI,R15
MOV EAX,0x0
CALL 0x00101170
MOV RSI,R15
MOV RDI,R13
CALL 0x00101140
MOV RDI,R13
CALL 0x001010f0
MOV word ptr [R13 + RAX*0x1],0x29
MOV ECX,dword ptr [RBP + -0x58]
CMP dword ptr [RBP + -0x68],ECX
JG 0x0010154c
LAB_0010150d:
ADD dword ptr [RBP + -0x58],0x1
MOV EAX,dword ptr [RBP + -0x58]
ADD qword ptr [RBP + -0x60],0x14
CMP dword ptr [RBP + -0x70],EAX
JZ 0x00101569
LAB_0010151e:
MOV RDI,R13
CALL 0x001010f0
MOV word ptr [R13 + RAX*0x1],0x28
MOV RAX,qword ptr [RBP + -0x60]
MOV R14,RAX
MOV R12D,dword ptr [RAX + 0xc]
TEST R12D,R12D
JLE 0x001014b4
MOV EBX,0x0
JMP 0x00101468
LAB_0010154c:
MOV RDI,R13
CALL 0x001010f0
ADD RAX,R13
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
JMP 0x0010150d
LAB_00101562:
MOV word ptr [R13],0x5b
LAB_00101569:
MOV RDI,R13
CALL 0x001010f0
MOV word ptr [R13 + RAX*0x1],0x5d
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101611
MOV RAX,R13
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010159e:
MOV EDI,0x3
CALL 0x00101130
MOV R13,RAX
TEST RAX,RAX
JNZ 0x00101562
LAB_001015b0:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x19
MOV ESI,0x1
LEA RDI,[0x102007]
CALL 0x00101160
MOV EDI,0x1
CALL 0x00101150
LAB_001015d7:
MOV R13D,R12D
MOV EBX,dword ptr [RBP + -0x74]
ADD R13D,0x1
MOVSXD RDI,R13D
CALL 0x00101130
MOV R13,RAX
TEST RAX,RAX
JZ 0x001015b0
MOV word ptr [R13],0x5b
MOV dword ptr [RBP + -0x58],0x0
LEA R15,[RBP + -0x44]
LEA EAX,[RBX + -0x1]
MOV dword ptr [RBP + -0x68],EAX
MOV dword ptr [RBP + -0x70],EBX
JMP 0x0010151e
LAB_00101611:
CALL 0x00101100 | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
ulong uVar5;
long lVar6;
size_t sVar7;
char *pcVar8;
char *__s;
int1 *puVar9;
int iVar10;
int1 *puVar11;
int iVar12;
int iVar13;
int1 *puVar14;
long in_FS_OFFSET;
int1 auStack_88 [12];
int local_7c;
int1 *local_78;
int1 *local_70;
int1 *local_68;
int1 *local_60;
char local_4c [12];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)param_2 * 0x14 + 0xf;
for (puVar11 = auStack_88; puVar11 != auStack_88 + -(uVar5 & 0xfffffffffffff000);
puVar11 = puVar11 + -0x1000) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar3 = -uVar5;
puVar14 = puVar11 + lVar3;
if (uVar5 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
iVar10 = 0;
do {
if (0 < iVar10) {
iVar13 = *(int *)((long)param_1 + 0xc);
iVar12 = 0;
puVar9 = puVar11 + lVar3;
do {
if (*(int *)(puVar9 + 0xc) == iVar13) {
if (iVar13 < 1) {
LAB_0010132e:
*(int *)(puVar11 + (long)iVar12 * 0x14 + lVar3 + 0x10) =
*(int *)(puVar11 + (long)iVar12 * 0x14 + lVar3 + 0x10) + 1;
goto LAB_00101371;
}
lVar6 = 0;
while (*(int *)(puVar9 + lVar6 * 4) == *(int *)((long)param_1 + lVar6 * 4)) {
lVar6 = lVar6 + 1;
if (iVar13 <= (int)lVar6) goto LAB_0010132e;
}
}
iVar12 = iVar12 + 1;
puVar9 = puVar9 + 0x14;
} while (iVar12 != iVar10);
}
uVar4 = param_1[1];
*(int8 *)(puVar11 + (long)iVar10 * 0x14 + lVar3) = *param_1;
*(int8 *)((long)(puVar11 + (long)iVar10 * 0x14 + lVar3) + 8) = uVar4;
*(int4 *)(puVar11 + (long)iVar10 * 0x14 + lVar3 + 0x10) = 1;
iVar10 = iVar10 + 1;
LAB_00101371:
param_1 = param_1 + 2;
} while (param_1 != puVar1);
if (0 < iVar10) {
local_68 = puVar11 + lVar3;
local_78 = puVar11 + (ulong)(iVar10 - 1) * 0x14 + lVar3 + 0x14;
iVar13 = 2;
local_7c = iVar10;
do {
iVar13 = iVar13 + 2;
local_60 = puVar14;
iVar10 = *(int *)(puVar14 + 0xc);
puVar9 = puVar14;
if (0 < iVar10) {
lVar6 = 0;
local_70 = puVar14;
do {
uVar2 = *(int4 *)(puVar14 + lVar6 * 4);
*(int8 *)(puVar11 + lVar3 + -8) = 0x101440;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar2);
*(int8 *)(puVar11 + lVar3 + -8) = 0x101448;
sVar7 = strlen(local_4c);
iVar13 = iVar13 + 2 + (int)sVar7;
lVar6 = lVar6 + 1;
puVar9 = local_70;
} while ((int)lVar6 < iVar10);
}
uVar2 = *(int4 *)(local_60 + 0x10);
*(int8 *)(puVar11 + lVar3 + -8) = 0x1013e5;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar2);
*(int8 *)(puVar11 + lVar3 + -8) = 0x1013ed;
sVar7 = strlen(local_4c);
iVar10 = local_7c;
iVar12 = iVar13 + (int)sVar7;
iVar13 = iVar12 + 2;
puVar14 = puVar9 + 0x14;
} while (puVar14 != local_78);
*(int8 *)(puVar11 + lVar3 + -8) = 0x1015e9;
__s = (char *)malloc((long)(iVar12 + 1));
if (__s == (char *)0x0) goto LAB_001015b0;
__s[0] = '[';
__s[1] = '\0';
local_60 = (int1 *)((ulong)local_60 & 0xffffffff00000000);
local_70 = (int1 *)CONCAT44(local_70._4_4_,iVar10 + -1);
local_78 = (int1 *)CONCAT44(local_78._4_4_,iVar10);
do {
*(int8 *)(puVar11 + lVar3 + -8) = 0x101526;
sVar7 = strlen(__s);
puVar14 = local_68;
(__s + sVar7)[0] = '(';
(__s + sVar7)[1] = '\0';
iVar10 = *(int *)(local_68 + 0xc);
if (0 < iVar10) {
lVar6 = 0;
do {
uVar2 = *(int4 *)(puVar14 + lVar6 * 4);
*(int8 *)(puVar11 + lVar3 + -8) = 0x10148a;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar2);
*(int8 *)(puVar11 + lVar3 + -8) = 0x101495;
strcat(__s,local_4c);
if ((int)lVar6 < iVar10 + -1) {
*(int8 *)(puVar11 + lVar3 + -8) = 0x1014a6;
sVar7 = strlen(__s);
pcVar8 = __s + sVar7;
pcVar8[0] = ',';
pcVar8[1] = ' ';
pcVar8[2] = '\0';
}
lVar6 = lVar6 + 1;
} while ((int)lVar6 < iVar10);
}
*(int8 *)(puVar11 + lVar3 + -8) = 0x1014bc;
sVar7 = strlen(__s);
pcVar8 = __s + sVar7;
pcVar8[0] = ',';
pcVar8[1] = ' ';
pcVar8[2] = '\0';
uVar2 = *(int4 *)(puVar14 + 0x10);
*(int8 *)(puVar11 + lVar3 + -8) = 0x1014ea;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar2);
*(int8 *)(puVar11 + lVar3 + -8) = 0x1014f5;
strcat(__s,local_4c);
*(int8 *)(puVar11 + lVar3 + -8) = 0x1014fd;
sVar7 = strlen(__s);
(__s + sVar7)[0] = ')';
(__s + sVar7)[1] = '\0';
if ((int)local_60 < (int)local_70) {
*(int8 *)(puVar11 + lVar3 + -8) = 0x101554;
sVar7 = strlen(__s);
pcVar8 = __s + sVar7;
pcVar8[0] = ',';
pcVar8[1] = ' ';
pcVar8[2] = '\0';
}
iVar10 = (int)local_60 + 1;
local_60 = (int1 *)CONCAT44(local_60._4_4_,iVar10);
local_68 = local_68 + 0x14;
} while ((int)local_78 != iVar10);
goto LAB_00101569;
}
}
*(int8 *)(puVar11 + lVar3 + -8) = 0x1015a8;
__s = (char *)malloc(3);
if (__s == (char *)0x0) {
LAB_001015b0:
*(int8 *)(puVar11 + lVar3 + -8) = 0x1015cd;
fwrite("Memory allocation failed\n",1,0x19,stderr);
/* WARNING: Subroutine does not return */
*(int8 *)(puVar11 + lVar3 + -8) = 0x1015d7;
exit(1);
}
__s[0] = '[';
__s[1] = '\0';
LAB_00101569:
*(int8 *)(puVar11 + lVar3 + -8) = 0x101571;
sVar7 = strlen(__s);
(__s + sVar7)[0] = ']';
(__s + sVar7)[1] = '\0';
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar11 + lVar3 + -8) = main;
__stack_chk_fail();
}
return __s;
} |
4,350 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
for(int k = 0; k < input[i].length; k++) {
if(counts[j].tuple.elements[k] != input[i].elements[k]) {
match = 0;
break;
}
}
if(match) {
counts[j].count++;
found = 1;
break;
}
}
}
if(!found) {
counts[unique].tuple = input[i];
counts[unique].count = 1;
unique++;
}
}
// Estimate the size needed for the string
int size = 2; // for [ and ]
for(int i = 0; i < unique; i++) {
size += 2; // for ( and )
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
size += strlen(num) + 2; // number and ", "
}
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
size += strlen(cnt) + 2; // count and ", "
}
if(unique > 0) size -= 2; // remove last ", "
size +=1; // for null terminator
char* result = malloc(size);
if(result == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}
strcpy(result, "[");
for(int i = 0; i < unique; i++) {
strcat(result, "(");
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
strcat(result, num);
if(j < counts[i].tuple.length -1) strcat(result, ", ");
}
strcat(result, ", ");
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
strcat(result, cnt);
strcat(result, ")");
if(i < unique -1) strcat(result, ", ");
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .elements = {2, 7, 0}, .length = 2 }
};
char* res1 = func0(test1, 6);
assert(strcmp(res1, "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]") == 0);
free(res1);
// Second test case
Tuple test2[] = {
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {7, 1, 0}, .length = 2 },
{ .elements = {4, 8, 0}, .length = 2 },
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {7, 1, 0}, .length = 2 }
};
char* res2 = func0(test2, 6);
assert(strcmp(res2, "[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]") == 0);
free(res2);
// Third test case
Tuple test3[] = {
{ .elements = {11, 13, 10}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 }
};
char* res3 = func0(test3, 6);
assert(strcmp(res3, "[(11, 13, 10, 1), (17, 21, 2), (4, 2, 3, 2), (9, 2, 1)]") == 0);
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea (%rax,%rax,4),%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1563 <func0+0x63>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 154e <func0+0x4e>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 19f7 <func0+0x4f7>
mov %rsp,%r9
test %esi,%esi
jle 19be <func0+0x4be>
lea -0x1(%rsi),%eax
xor %ebx,%ebx
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%r8
xchg %ax,%ax
test %ebx,%ebx
je 1980 <func0+0x480>
mov 0xc(%rdi),%esi
mov %r9,%rdx
xor %ecx,%ecx
jmp 15b7 <func0+0xb7>
nopw 0x0(%rax,%rax,1)
add $0x1,%ecx
add $0x14,%rdx
cmp %ebx,%ecx
je 1980 <func0+0x480>
cmp %esi,0xc(%rdx)
jne 15a8 <func0+0xa8>
test %esi,%esi
jle 15da <func0+0xda>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%r11d
cmp %r11d,(%rdx,%rax,4)
jne 15a8 <func0+0xa8>
add $0x1,%rax
cmp %eax,%esi
jg 15c8 <func0+0xc8>
movslq %ecx,%rcx
lea (%rcx,%rcx,4),%rax
addl $0x1,0x10(%r9,%rax,4)
nopw 0x0(%rax,%rax,1)
add $0x10,%rdi
cmp %r8,%rdi
jne 1590 <func0+0x90>
lea -0x1(%rbx),%eax
lea -0x44(%rbp),%r14
mov %ebx,-0x58(%rbp)
mov $0x2,%r10d
mov %eax,-0x64(%rbp)
lea (%rax,%rax,4),%rax
mov %r9,%rbx
mov %r14,%r13
lea 0x14(%r9,%rax,4),%rax
mov %r9,-0x70(%rbp)
mov %rax,-0x60(%rbp)
nopl 0x0(%rax,%rax,1)
mov 0xc(%rbx),%r12d
lea 0x2(%r10),%r14d
mov %r14d,%r10d
test %r12d,%r12d
jle 16ab <func0+0x1ab>
xor %r15d,%r15d
nopl 0x0(%rax,%rax,1)
mov (%rbx,%r15,4),%r8d
mov $0xc,%edx
mov $0x1,%esi
xor %eax,%eax
lea 0x9ad(%rip),%rcx
mov %r13,%rdi
callq 1130 <__sprintf_chk@plt>
mov %r13,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 1662 <func0+0x162>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
sbb $0x3,%rdx
add $0x1,%r15
sub %r13,%rdx
lea 0x2(%r14,%rdx,1),%r10d
mov %r10d,%r14d
cmp %r15d,%r12d
jg 1640 <func0+0x140>
mov 0x10(%rbx),%r8d
mov $0xc,%edx
mov $0x1,%esi
xor %eax,%eax
lea 0x942(%rip),%rcx
mov %r13,%rdi
mov %r10d,-0x54(%rbp)
callq 1130 <__sprintf_chk@plt>
mov -0x54(%rbp),%r10d
mov %r13,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 16d5 <func0+0x1d5>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
sbb $0x3,%rdx
add $0x14,%rbx
sub %r13,%rdx
add %r10d,%edx
lea 0x2(%rdx),%r10d
cmp %rbx,-0x60(%rbp)
jne 1628 <func0+0x128>
mov %edx,%r15d
mov -0x58(%rbp),%ebx
mov %r13,%r14
add $0x1,%r15d
movslq %r15d,%rdi
callq 1100 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 19d0 <func0+0x4d0>
mov $0x5b,%edx
movl $0x0,-0x60(%rbp)
lea 0x8ae(%rip),%r15
mov %dx,(%r12)
mov %ebx,-0x68(%rbp)
mov -0x70(%rbp),%rbx
nopw 0x0(%rax,%rax,1)
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 176b <func0+0x26b>
mov %eax,%ecx
mov $0x28,%r10d
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
mov 0xc(%rbx),%eax
sbb $0x3,%rdx
xor %r13d,%r13d
lea -0x1(%rax),%esi
mov %r10w,(%rdx)
mov %eax,-0x58(%rbp)
mov %esi,-0x54(%rbp)
test %eax,%eax
jle 182c <func0+0x32c>
mov (%rbx,%r13,4),%r8d
mov %r14,%rdi
mov %r15,%rcx
mov $0xc,%edx
mov $0x1,%esi
xor %eax,%eax
callq 1130 <__sprintf_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 17db <func0+0x2db>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%esi
add %al,%sil
mov %r14,%rsi
sbb $0x3,%rdi
callq 10d0 <stpcpy@plt>
cmp %r13d,-0x54(%rbp)
jg 1968 <func0+0x468>
add $0x1,%r13
cmp %r13d,-0x58(%rbp)
jg 17bd <func0+0x2bd>
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 182f <func0+0x32f>
mov %eax,%ecx
mov $0x202c,%r9d
mov 0x10(%rbx),%r8d
mov %r14,%rdi
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %r15,%rcx
mov %eax,%esi
add %al,%sil
mov $0x1,%esi
sbb $0x3,%rdx
xor %eax,%eax
mov %r9w,(%rdx)
movb $0x0,0x2(%rdx)
mov $0xc,%edx
callq 1130 <__sprintf_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1890 <func0+0x390>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%esi
add %al,%sil
mov %r14,%rsi
sbb $0x3,%rdi
callq 10d0 <stpcpy@plt>
mov $0x29,%r8d
mov -0x60(%rbp),%esi
mov %rax,%rdx
mov %r8w,(%rax)
sub %r12,%rdx
cmp %esi,-0x64(%rbp)
jg 19a8 <func0+0x4a8>
addl $0x1,-0x60(%rbp)
add $0x14,%rbx
mov -0x60(%rbp),%eax
cmp %eax,-0x68(%rbp)
jne 1768 <func0+0x268>
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 1900 <func0+0x400>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov $0x5d,%ecx
mov %eax,%ebx
add %al,%bl
sbb $0x3,%rdx
mov %cx,(%rdx)
mov -0x38(%rbp),%rax
xor %fs:0x28,%rax
jne 1a11 <func0+0x511>
lea -0x28(%rbp),%rsp
mov %r12,%rax
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl 0x0(%rax)
mov $0x202c,%edi
movb $0x0,0x2(%rax)
mov %di,(%rax)
jmpq 1822 <func0+0x322>
nopl 0x0(%rax)
movslq %ebx,%rax
movdqu (%rdi),%xmm0
add $0x1,%ebx
lea (%rax,%rax,4),%rax
lea (%r9,%rax,4),%rax
movl $0x1,0x10(%rax)
movups %xmm0,(%rax)
jmpq 15f0 <func0+0xf0>
nopl 0x0(%rax)
lea 0x1(%r12,%rdx,1),%rax
mov $0x202c,%esi
mov %si,(%rax)
movb $0x0,0x2(%rax)
jmpq 18e9 <func0+0x3e9>
mov $0x3,%edi
callq 1100 <malloc@plt>
mov %rax,%r12
test %rax,%rax
jne 1a02 <func0+0x502>
mov 0x2649(%rip),%rcx
mov $0x19,%edx
mov $0x1,%esi
lea 0x61f(%rip),%rdi
callq 1120 <fwrite@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1575 <func0+0x75>
mov $0x5b,%eax
mov %ax,(%r12)
jmpq 18fd <func0+0x3fd>
callq 10e0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, [rax+rax*4]
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1590
loc_157B:
sub rsp, 1000h
or [rsp+1070h+var_78], 0
cmp rsp, rcx
jnz short loc_157B
loc_1590:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_18BA
loc_15A2:
mov r9, rsp
test esi, esi
jle loc_1881
lea eax, [rsi-1]
xor ebx, ebx
shl rax, 4
lea r8, [rdi+rax+10h]
nop dword ptr [rax+rax+00h]
loc_15C0:
test ebx, ebx
jz loc_1860
mov esi, [rdi+0Ch]
mov rdx, r9
xor ecx, ecx
jmp short loc_15E7
loc_15D8:
add ecx, 1
add rdx, 14h
cmp ecx, ebx
jz loc_1860
loc_15E7:
cmp [rdx+0Ch], esi
jnz short loc_15D8
test esi, esi
jle short loc_160A
xor eax, eax
nop word ptr [rax+rax+00h]
loc_15F8:
mov r10d, [rdi+rax*4]
cmp [rdx+rax*4], r10d
jnz short loc_15D8
add rax, 1
cmp esi, eax
jg short loc_15F8
loc_160A:
movsxd rcx, ecx
lea rax, [rcx+rcx*4]
add dword ptr [r9+rax*4+10h], 1
nop word ptr [rax+rax+00000000h]
loc_1620:
add rdi, 10h
cmp rdi, r8
jnz short loc_15C0
lea eax, [rbx-1]
mov [rbp+var_68], r9
mov r13, r9
mov r11d, 2
mov [rbp+var_58], eax
lea rax, [rax+rax*4]
lea r12, [rbp+var_44]
lea rax, [r9+rax*4+14h]
mov [rbp+var_6C], ebx
lea r15, unk_2004
mov [rbp+var_60], rax
nop word ptr [rax+rax+00000000h]
loc_1660:
mov eax, [r13+0Ch]
add r11d, 2
mov r14d, r11d
mov [rbp+var_54], eax
test eax, eax
jle short loc_16A9
xor ebx, ebx
loc_1674:
mov r8d, [r13+rbx*4+0]
mov rcx, r15
mov edx, 0Ch
mov rdi, r12
mov esi, 1
xor eax, eax
add rbx, 1
call ___sprintf_chk
mov rdi, r12
call _strlen
lea eax, [r14+rax+2]
mov r14d, eax
cmp [rbp+var_54], ebx
jg short loc_1674
loc_16A9:
mov r8d, [r13+10h]
mov rcx, r15
mov edx, 0Ch
mov rdi, r12
mov esi, 1
xor eax, eax
add r13, 14h
call ___sprintf_chk
mov rdi, r12
call _strlen
lea r10d, [r14+rax]
lea r11d, [r10+2]
cmp [rbp+var_60], r13
jnz short loc_1660
add r10d, 1
mov ebx, [rbp+var_6C]
movsxd rdi, r10d
call _malloc
mov r13, rax
test rax, rax
jz loc_1893
mov eax, 5Bh ; '['
mov [rbp+var_54], 0
mov [r13+0], ax
mov [rbp+var_6C], ebx
mov rbx, [rbp+var_68]
nop dword ptr [rax+00000000h]
loc_1718:
mov rdi, r13
xor r14d, r14d
call _strlen
mov r10d, 28h ; '('
mov [r13+rax+0], r10w
mov eax, [rbx+0Ch]
lea esi, [rax-1]
mov dword ptr [rbp+var_68], eax
mov dword ptr [rbp+var_60], esi
test eax, eax
jle short loc_1783
loc_173F:
mov r8d, [rbx+r14*4]
mov esi, 1
mov rcx, r15
mov rdi, r12
mov edx, 0Ch
xor eax, eax
call ___sprintf_chk
mov rdi, r13
call _strlen
mov rsi, r12
lea rdi, [r13+rax+0]
call _stpcpy
cmp dword ptr [rbp+var_60], r14d
jg loc_1848
loc_1779:
add r14, 1
cmp dword ptr [rbp+var_68], r14d
jg short loc_173F
loc_1783:
mov rdi, r13
call _strlen
mov rcx, r15
mov edx, 0Ch
mov rdi, r12
add rax, r13
mov r8d, 202Ch
mov esi, 1
mov [rax], r8w
mov r8d, [rbx+10h]
mov byte ptr [rax+2], 0
xor eax, eax
call ___sprintf_chk
mov rdi, r13
call _strlen
mov rsi, r12
lea rdi, [r13+rax+0]
call _stpcpy
mov r9d, 29h ; ')'
mov ecx, [rbp+var_54]
mov rdx, rax
mov [rax], r9w
sub rdx, r13
cmp [rbp+var_58], ecx
jle short loc_17F5
lea rax, [r13+rdx+1]
mov esi, 202Ch
mov [rax], si
mov byte ptr [rax+2], 0
loc_17F5:
add [rbp+var_54], 1
add rbx, 14h
mov eax, [rbp+var_54]
cmp [rbp+var_6C], eax
jnz loc_1718
loc_1809:
mov rdi, r13
call _strlen
mov ecx, 5Dh ; ']'
mov [r13+rax+0], cx
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_18D2
lea rsp, [rbp-28h]
mov rax, r13
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1848:
mov edi, 202Ch
mov byte ptr [rax+2], 0
mov [rax], di
jmp loc_1779
loc_1860:
movsxd rax, ebx
movdqu xmm0, xmmword ptr [rdi]
add ebx, 1
lea rax, [rax+rax*4]
lea rax, [r9+rax*4]
mov dword ptr [rax+10h], 1
movups xmmword ptr [rax], xmm0
jmp loc_1620
loc_1881:
mov edi, 3
call _malloc
mov r13, rax
test rax, rax
jnz short loc_18C5
loc_1893:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 19h
mov esi, 1
lea rdi, aMemoryAllocati; "Memory allocation failed\n"
call _fwrite
mov edi, 1
call _exit
loc_18BA:
or [rsp+rdx+1070h+var_1078], 0
jmp loc_15A2
loc_18C5:
mov edx, 5Bh ; '['
mov [rax], dx
jmp loc_1809
loc_18D2:
call ___stack_chk_fail | char * func0(const __m128i *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v5; // rdx
_DWORD *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
_DWORD *v10; // r9
int v11; // ebx
long long m128i_i64; // r8
int v13; // esi
_DWORD *v14; // rdx
int i; // ecx
long long v16; // rax
_DWORD *v17; // r13
int v18; // r11d
int v19; // r14d
long long v20; // rbx
long long v21; // r8
long long v22; // r8
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
int v26; // r10d
int v27; // ebx
char *v28; // r13
_DWORD *v29; // rbx
long long v30; // r14
long long v31; // r9
long long v32; // rax
char *v33; // rax
long long v34; // r9
long long v35; // rax
long long v36; // rax
int v37; // ecx
long long v39; // rax
__m128i v40; // xmm0
__m128i *v41; // rax
char *v42; // rax
_DWORD v44[1022]; // [rsp+8h] [rbp-1070h] BYREF
_BYTE v45[4]; // [rsp+1008h] [rbp-70h] BYREF
int v46; // [rsp+100Ch] [rbp-6Ch]
_DWORD *v47; // [rsp+1010h] [rbp-68h]
_DWORD *v48; // [rsp+1018h] [rbp-60h]
int v49; // [rsp+1020h] [rbp-58h]
int v50; // [rsp+1024h] [rbp-54h]
_BYTE v51[12]; // [rsp+1034h] [rbp-44h] BYREF
unsigned long long v52; // [rsp+1040h] [rbp-38h]
v52 = __readfsqword(0x28u);
v5 = 20LL * (int)a2 + 15;
v6 = &v45[-(v5 & 0xFFFFFFFFFFFFF000LL)];
v7 = v5 & 0xFFF0;
if ( v45 != (_BYTE *)v6 )
{
while ( v44 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v44[-2] + v8) = *(_QWORD *)((char *)&v44[-2] + v8);
v10 = v44;
if ( (int)a2 <= 0 )
{
v42 = (char *)malloc(3LL, a2, v8, v6, a5, v44);
v28 = v42;
if ( v42 )
{
*(_WORD *)v42 = 91;
goto LABEL_31;
}
LABEL_34:
fwrite("Memory allocation failed\n", 1LL, 25LL, stderr);
exit(1LL);
}
v11 = 0;
m128i_i64 = (long long)a1[(unsigned int)(a2 - 1) + 1].m128i_i64;
do
{
if ( v11 )
{
v13 = a1->m128i_i32[3];
v14 = v44;
for ( i = 0; i != v11; ++i )
{
if ( v14[3] == v13 )
{
if ( v13 <= 0 )
{
LABEL_15:
++v44[5 * i + 4];
goto LABEL_16;
}
v16 = 0LL;
while ( v14[v16] == a1->m128i_i32[v16] )
{
if ( v13 <= (int)++v16 )
goto LABEL_15;
}
}
v14 += 5;
}
}
v39 = v11;
v40 = _mm_loadu_si128(a1);
++v11;
v41 = (__m128i *)&v44[5 * v39];
v41[1].m128i_i32[0] = 1;
*v41 = v40;
LABEL_16:
++a1;
}
while ( a1 != (const __m128i *)m128i_i64 );
v47 = v44;
v17 = v44;
v18 = 2;
v49 = v11 - 1;
v46 = v11;
v48 = &v44[5 * (v11 - 1) + 5];
do
{
v19 = v18 + 2;
v50 = v17[3];
if ( v50 > 0 )
{
v20 = 0LL;
do
{
v21 = (unsigned int)v17[v20++];
__sprintf_chk(v51, 1LL, 12LL, &unk_2004, v21, v10);
v19 += strlen(v51) + 2;
}
while ( v50 > (int)v20 );
}
v22 = (unsigned int)v17[4];
v17 += 5;
__sprintf_chk(v51, 1LL, 12LL, &unk_2004, v22, v10);
v26 = v19 + strlen(v51);
v18 = v26 + 2;
}
while ( v48 != v17 );
v27 = v46;
v28 = (char *)malloc(v26 + 1, 1LL, v23, v24, v25, v10);
if ( !v28 )
goto LABEL_34;
v50 = 0;
*(_WORD *)v28 = 91;
v46 = v27;
v29 = v47;
do
{
v30 = 0LL;
*(_WORD *)&v28[strlen(v28)] = 40;
LODWORD(v47) = v29[3];
for ( LODWORD(v48) = (_DWORD)v47 - 1; (int)v47 > (int)v30; ++v30 )
{
__sprintf_chk(v51, 1LL, 12LL, &unk_2004, (unsigned int)v29[v30], v31);
v32 = strlen(v28);
v33 = (char *)stpcpy(&v28[v32], v51);
if ( (int)v48 > (int)v30 )
strcpy(v33, ", ");
}
strcpy(&v28[strlen(v28)], ", ");
__sprintf_chk(v51, 1LL, 12LL, &unk_2004, (unsigned int)v29[4], v34);
v35 = strlen(v28);
v36 = stpcpy(&v28[v35], v51);
v37 = v50;
*(_WORD *)v36 = 41;
if ( v49 > v37 )
strcpy((char *)(v36 + 1), ", ");
++v50;
v29 += 5;
}
while ( v46 != v50 );
LABEL_31:
*(_WORD *)&v28[strlen(v28)] = 93;
return v28;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101590
LAB_0010157b:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010157b
LAB_00101590:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001018ba
LAB_001015a2:
MOV R9,RSP
TEST ESI,ESI
JLE 0x00101881
LEA EAX,[RSI + -0x1]
XOR EBX,EBX
SHL RAX,0x4
LEA R8,[RDI + RAX*0x1 + 0x10]
NOP dword ptr [RAX + RAX*0x1]
LAB_001015c0:
TEST EBX,EBX
JZ 0x00101860
MOV ESI,dword ptr [RDI + 0xc]
MOV RDX,R9
XOR ECX,ECX
JMP 0x001015e7
LAB_001015d8:
ADD ECX,0x1
ADD RDX,0x14
CMP ECX,EBX
JZ 0x00101860
LAB_001015e7:
CMP dword ptr [RDX + 0xc],ESI
JNZ 0x001015d8
TEST ESI,ESI
JLE 0x0010160a
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001015f8:
MOV R10D,dword ptr [RDI + RAX*0x4]
CMP dword ptr [RDX + RAX*0x4],R10D
JNZ 0x001015d8
ADD RAX,0x1
CMP ESI,EAX
JG 0x001015f8
LAB_0010160a:
MOVSXD RCX,ECX
LEA RAX,[RCX + RCX*0x4]
ADD dword ptr [R9 + RAX*0x4 + 0x10],0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101620:
ADD RDI,0x10
CMP RDI,R8
JNZ 0x001015c0
LEA EAX,[RBX + -0x1]
MOV qword ptr [RBP + -0x68],R9
MOV R13,R9
MOV R11D,0x2
MOV dword ptr [RBP + -0x58],EAX
LEA RAX,[RAX + RAX*0x4]
LEA R12,[RBP + -0x44]
LEA RAX,[R9 + RAX*0x4 + 0x14]
MOV dword ptr [RBP + -0x6c],EBX
LEA R15,[0x102004]
MOV qword ptr [RBP + -0x60],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101660:
MOV EAX,dword ptr [R13 + 0xc]
ADD R11D,0x2
MOV R14D,R11D
MOV dword ptr [RBP + -0x54],EAX
TEST EAX,EAX
JLE 0x001016a9
XOR EBX,EBX
LAB_00101674:
MOV R8D,dword ptr [R13 + RBX*0x4]
MOV RCX,R15
MOV EDX,0xc
MOV RDI,R12
MOV ESI,0x1
XOR EAX,EAX
ADD RBX,0x1
CALL 0x00101170
MOV RDI,R12
CALL 0x00101100
LEA EAX,[R14 + RAX*0x1 + 0x2]
MOV R14D,EAX
CMP dword ptr [RBP + -0x54],EBX
JG 0x00101674
LAB_001016a9:
MOV R8D,dword ptr [R13 + 0x10]
MOV RCX,R15
MOV EDX,0xc
MOV RDI,R12
MOV ESI,0x1
XOR EAX,EAX
ADD R13,0x14
CALL 0x00101170
MOV RDI,R12
CALL 0x00101100
LEA R10D,[R14 + RAX*0x1]
LEA R11D,[R10 + 0x2]
CMP qword ptr [RBP + -0x60],R13
JNZ 0x00101660
ADD R10D,0x1
MOV EBX,dword ptr [RBP + -0x6c]
MOVSXD RDI,R10D
CALL 0x00101140
MOV R13,RAX
TEST RAX,RAX
JZ 0x00101893
MOV EAX,0x5b
MOV dword ptr [RBP + -0x54],0x0
MOV word ptr [R13],AX
MOV dword ptr [RBP + -0x6c],EBX
MOV RBX,qword ptr [RBP + -0x68]
NOP dword ptr [RAX]
LAB_00101718:
MOV RDI,R13
XOR R14D,R14D
CALL 0x00101100
MOV R10D,0x28
MOV word ptr [R13 + RAX*0x1],R10W
MOV EAX,dword ptr [RBX + 0xc]
LEA ESI,[RAX + -0x1]
MOV dword ptr [RBP + -0x68],EAX
MOV dword ptr [RBP + -0x60],ESI
TEST EAX,EAX
JLE 0x00101783
LAB_0010173f:
MOV R8D,dword ptr [RBX + R14*0x4]
MOV ESI,0x1
MOV RCX,R15
MOV RDI,R12
MOV EDX,0xc
XOR EAX,EAX
CALL 0x00101170
MOV RDI,R13
CALL 0x00101100
MOV RSI,R12
LEA RDI,[R13 + RAX*0x1]
CALL 0x001010f0
CMP dword ptr [RBP + -0x60],R14D
JG 0x00101848
LAB_00101779:
ADD R14,0x1
CMP dword ptr [RBP + -0x68],R14D
JG 0x0010173f
LAB_00101783:
MOV RDI,R13
CALL 0x00101100
MOV RCX,R15
MOV EDX,0xc
MOV RDI,R12
ADD RAX,R13
MOV R8D,0x202c
MOV ESI,0x1
MOV word ptr [RAX],R8W
MOV R8D,dword ptr [RBX + 0x10]
MOV byte ptr [RAX + 0x2],0x0
XOR EAX,EAX
CALL 0x00101170
MOV RDI,R13
CALL 0x00101100
MOV RSI,R12
LEA RDI,[R13 + RAX*0x1]
CALL 0x001010f0
MOV R9D,0x29
MOV ECX,dword ptr [RBP + -0x54]
MOV RDX,RAX
MOV word ptr [RAX],R9W
SUB RDX,R13
CMP dword ptr [RBP + -0x58],ECX
JLE 0x001017f5
LEA RAX,[R13 + RDX*0x1 + 0x1]
MOV ESI,0x202c
MOV word ptr [RAX],SI
MOV byte ptr [RAX + 0x2],0x0
LAB_001017f5:
ADD dword ptr [RBP + -0x54],0x1
ADD RBX,0x14
MOV EAX,dword ptr [RBP + -0x54]
CMP dword ptr [RBP + -0x6c],EAX
JNZ 0x00101718
LAB_00101809:
MOV RDI,R13
CALL 0x00101100
MOV ECX,0x5d
MOV word ptr [R13 + RAX*0x1],CX
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018d2
LEA RSP,[RBP + -0x28]
MOV RAX,R13
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101848:
MOV EDI,0x202c
MOV byte ptr [RAX + 0x2],0x0
MOV word ptr [RAX],DI
JMP 0x00101779
LAB_00101860:
MOVSXD RAX,EBX
MOVDQU XMM0,xmmword ptr [RDI]
ADD EBX,0x1
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[R9 + RAX*0x4]
MOV dword ptr [RAX + 0x10],0x1
MOVUPS xmmword ptr [RAX],XMM0
JMP 0x00101620
LAB_00101881:
MOV EDI,0x3
CALL 0x00101140
MOV R13,RAX
TEST RAX,RAX
JNZ 0x001018c5
LAB_00101893:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x19
MOV ESI,0x1
LEA RDI,[0x102007]
CALL 0x00101160
MOV EDI,0x1
CALL 0x00101150
LAB_001018ba:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001015a2
LAB_001018c5:
MOV EDX,0x5b
MOV word ptr [RAX],DX
JMP 0x00101809
LAB_001018d2:
CALL 0x00101110 | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int8 *puVar2;
int4 uVar3;
long lVar4;
int8 uVar5;
int8 uVar6;
long lVar7;
size_t sVar8;
char *__s;
char *pcVar9;
ulong uVar10;
int1 *puVar11;
int iVar12;
int1 *puVar13;
int iVar15;
int iVar16;
int1 *puVar17;
long in_FS_OFFSET;
int1 auStack_78 [4];
int local_74;
int1 *local_70;
int1 *local_68;
uint local_60;
int local_5c;
char local_4c [12];
long local_40;
int1 *puVar14;
puVar13 = auStack_78;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar10 = (long)param_2 * 0x14 + 0xf;
puVar14 = auStack_78;
puVar17 = auStack_78;
while (puVar14 != auStack_78 + -(uVar10 & 0xfffffffffffff000)) {
puVar13 = puVar17 + -0x1000;
*(int8 *)(puVar17 + -8) = *(int8 *)(puVar17 + -8);
puVar14 = puVar17 + -0x1000;
puVar17 = puVar17 + -0x1000;
}
uVar10 = (ulong)((uint)uVar10 & 0xff0);
lVar4 = -uVar10;
puVar17 = puVar13 + lVar4;
if (uVar10 != 0) {
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
}
if (param_2 < 1) {
*(int8 *)(puVar13 + lVar4 + -8) = 0x10188b;
__s = (char *)malloc(3);
if (__s == (char *)0x0) goto LAB_00101893;
__s[0] = '[';
__s[1] = '\0';
}
else {
iVar12 = 0;
puVar2 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
if (iVar12 != 0) {
iVar16 = *(int *)((long)param_1 + 0xc);
iVar15 = 0;
puVar11 = puVar13 + lVar4;
do {
if (*(int *)(puVar11 + 0xc) == iVar16) {
if (iVar16 < 1) {
LAB_0010160a:
*(int *)(puVar13 + (long)iVar15 * 0x14 + lVar4 + 0x10) =
*(int *)(puVar13 + (long)iVar15 * 0x14 + lVar4 + 0x10) + 1;
goto LAB_00101620;
}
lVar7 = 0;
while (*(int *)(puVar11 + lVar7 * 4) == *(int *)((long)param_1 + lVar7 * 4)) {
lVar7 = lVar7 + 1;
if (iVar16 <= (int)lVar7) goto LAB_0010160a;
}
}
iVar15 = iVar15 + 1;
puVar11 = puVar11 + 0x14;
} while (iVar15 != iVar12);
}
lVar7 = (long)iVar12;
uVar5 = *param_1;
uVar6 = param_1[1];
iVar12 = iVar12 + 1;
puVar1 = (int8 *)(puVar13 + lVar7 * 0x14 + lVar4);
*(int4 *)(puVar1 + 2) = 1;
*puVar1 = uVar5;
puVar1[1] = uVar6;
LAB_00101620:
param_1 = param_1 + 2;
} while (param_1 != puVar2);
local_60 = iVar12 - 1;
local_70 = puVar13 + lVar4;
iVar16 = 2;
local_68 = puVar13 + (ulong)local_60 * 0x14 + lVar4 + 0x14;
local_74 = iVar12;
do {
local_5c = *(int *)(puVar17 + 0xc);
iVar16 = iVar16 + 2;
if (0 < local_5c) {
lVar7 = 0;
do {
uVar3 = *(int4 *)(puVar17 + lVar7 * 4);
lVar7 = lVar7 + 1;
*(int8 *)(puVar13 + lVar4 + -8) = 0x101694;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar13 + lVar4 + -8) = 0x10169c;
sVar8 = strlen(local_4c);
iVar16 = iVar16 + 2 + (int)sVar8;
} while ((int)lVar7 < local_5c);
}
uVar3 = *(int4 *)(puVar17 + 0x10);
puVar17 = puVar17 + 0x14;
*(int8 *)(puVar13 + lVar4 + -8) = 0x1016c8;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar13 + lVar4 + -8) = 0x1016d0;
sVar8 = strlen(local_4c);
iVar12 = local_74;
iVar15 = iVar16 + (int)sVar8;
iVar16 = iVar15 + 2;
} while (local_68 != puVar17);
*(int8 *)(puVar13 + lVar4 + -8) = 0x1016ed;
__s = (char *)malloc((long)(iVar15 + 1));
if (__s == (char *)0x0) {
LAB_00101893:
*(int8 *)(puVar13 + lVar4 + -8) = 0x1018b0;
fwrite("Memory allocation failed\n",1,0x19,stderr);
/* WARNING: Subroutine does not return */
*(int8 *)(puVar13 + lVar4 + -8) = 0x1018ba;
exit(1);
}
local_5c = 0;
__s[0] = '[';
__s[1] = '\0';
puVar17 = local_70;
local_74 = iVar12;
do {
lVar7 = 0;
*(int8 *)(puVar13 + lVar4 + -8) = 0x101723;
sVar8 = strlen(__s);
(__s + sVar8)[0] = '(';
(__s + sVar8)[1] = '\0';
iVar12 = *(int *)(puVar17 + 0xc);
local_70 = (int1 *)CONCAT44(local_70._4_4_,iVar12);
local_68 = (int1 *)CONCAT44(local_68._4_4_,iVar12 + -1);
if (0 < iVar12) {
do {
uVar3 = *(int4 *)(puVar17 + lVar7 * 4);
*(int8 *)(puVar13 + lVar4 + -8) = 0x10175a;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar13 + lVar4 + -8) = 0x101762;
sVar8 = strlen(__s);
*(int8 *)(puVar13 + lVar4 + -8) = 0x10176f;
pcVar9 = stpcpy(__s + sVar8,local_4c);
if ((int)lVar7 < (int)local_68) {
pcVar9[2] = '\0';
pcVar9[0] = ',';
pcVar9[1] = ' ';
}
lVar7 = lVar7 + 1;
} while ((int)lVar7 < (int)local_70);
}
*(int8 *)(puVar13 + lVar4 + -8) = 0x10178b;
sVar8 = strlen(__s);
pcVar9 = __s + sVar8;
pcVar9[0] = ',';
pcVar9[1] = ' ';
uVar3 = *(int4 *)(puVar17 + 0x10);
pcVar9[2] = '\0';
*(int8 *)(puVar13 + lVar4 + -8) = 0x1017b7;
__sprintf_chk(local_4c,1,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar13 + lVar4 + -8) = 0x1017bf;
sVar8 = strlen(__s);
*(int8 *)(puVar13 + lVar4 + -8) = 0x1017cc;
pcVar9 = stpcpy(__s + sVar8,local_4c);
pcVar9[0] = ')';
pcVar9[1] = '\0';
if (local_5c < (int)local_60) {
pcVar9[1] = ',';
pcVar9[2] = ' ';
pcVar9[3] = '\0';
}
local_5c = local_5c + 1;
puVar17 = puVar17 + 0x14;
} while (local_74 != local_5c);
}
*(int8 *)(puVar13 + lVar4 + -8) = 0x101811;
sVar8 = strlen(__s);
(__s + sVar8)[0] = ']';
(__s + sVar8)[1] = '\0';
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar13 + lVar4 + -8) = 0x1018d7;
__stack_chk_fail();
}
return __s;
} |
4,351 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
for(int k = 0; k < input[i].length; k++) {
if(counts[j].tuple.elements[k] != input[i].elements[k]) {
match = 0;
break;
}
}
if(match) {
counts[j].count++;
found = 1;
break;
}
}
}
if(!found) {
counts[unique].tuple = input[i];
counts[unique].count = 1;
unique++;
}
}
// Estimate the size needed for the string
int size = 2; // for [ and ]
for(int i = 0; i < unique; i++) {
size += 2; // for ( and )
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
size += strlen(num) + 2; // number and ", "
}
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
size += strlen(cnt) + 2; // count and ", "
}
if(unique > 0) size -= 2; // remove last ", "
size +=1; // for null terminator
char* result = malloc(size);
if(result == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}
strcpy(result, "[");
for(int i = 0; i < unique; i++) {
strcat(result, "(");
for(int j = 0; j < counts[i].tuple.length; j++) {
char num[12];
sprintf(num, "%d", counts[i].tuple.elements[j]);
strcat(result, num);
if(j < counts[i].tuple.length -1) strcat(result, ", ");
}
strcat(result, ", ");
char cnt[12];
sprintf(cnt, "%d", counts[i].count);
strcat(result, cnt);
strcat(result, ")");
if(i < unique -1) strcat(result, ", ");
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .elements = {2, 7, 0}, .length = 2 }
};
char* res1 = func0(test1, 6);
assert(strcmp(res1, "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]") == 0);
free(res1);
// Second test case
Tuple test2[] = {
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {7, 1, 0}, .length = 2 },
{ .elements = {4, 8, 0}, .length = 2 },
{ .elements = {4, 2, 4}, .length = 3 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {7, 1, 0}, .length = 2 }
};
char* res2 = func0(test2, 6);
assert(strcmp(res2, "[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]") == 0);
free(res2);
// Third test case
Tuple test3[] = {
{ .elements = {11, 13, 10}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 },
{ .elements = {17, 21, 0}, .length = 2 },
{ .elements = {9, 2, 0}, .length = 2 },
{ .elements = {4, 2, 3}, .length = 3 }
};
char* res3 = func0(test3, 6);
assert(strcmp(res3, "[(11, 13, 10, 1), (17, 21, 2), (4, 2, 3, 2), (9, 2, 1)]") == 0);
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rdx
mov %rdx,%rax
lea (%rdx,%rdx,4),%rdx
lea 0xf(,%rdx,4),%rdx
mov %rsp,%rbp
push %r15
mov %rdx,%rcx
and $0xfffffffffffff000,%rdx
push %r14
and $0xfffffffffffffff0,%rcx
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
mov %rsp,%rsi
sub %rdx,%rsi
mov %rsi,%rdx
cmp %rdx,%rsp
je 14d7 <func0+0x67>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 14c2 <func0+0x52>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 19bf <func0+0x54f>
mov %rsp,%r8
test %eax,%eax
jle 1986 <func0+0x516>
sub $0x1,%eax
mov %rdi,%rsi
xor %r9d,%r9d
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%rdi
nopw %cs:0x0(%rax,%rax,1)
test %r9d,%r9d
je 1940 <func0+0x4d0>
mov 0xc(%rsi),%ecx
mov %r8,%rax
xor %edx,%edx
jmp 1538 <func0+0xc8>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
add $0x14,%rax
cmp %r9d,%edx
je 1940 <func0+0x4d0>
cmp %ecx,0xc(%rax)
jne 1528 <func0+0xb8>
test %ecx,%ecx
jle 1561 <func0+0xf1>
mov (%rsi),%ebx
cmp %ebx,(%rax)
jne 1528 <func0+0xb8>
cmp $0x1,%ecx
je 1561 <func0+0xf1>
mov 0x4(%rax),%ebx
cmp %ebx,0x4(%rsi)
jne 1528 <func0+0xb8>
cmp $0x2,%ecx
je 1561 <func0+0xf1>
mov 0x8(%rsi),%ebx
cmp %ebx,0x8(%rax)
jne 1528 <func0+0xb8>
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
addl $0x1,0x10(%r8,%rax,4)
xchg %ax,%ax
add $0x10,%rsi
cmp %rdi,%rsi
jne 1510 <func0+0xa0>
lea -0x1(%r9),%eax
lea -0x44(%rbp),%r13
mov %r9d,-0x70(%rbp)
mov $0x2,%r15d
mov %eax,-0x6c(%rbp)
lea (%rax,%rax,4),%rax
lea 0x14(%r8,%rax,4),%rax
mov %r8,-0x58(%rbp)
mov %rax,-0x68(%rbp)
mov %r13,%rax
mov %r8,%r13
mov %rax,%r12
nopl 0x0(%rax,%rax,1)
mov 0xc(%r13),%ebx
add $0x2,%r15d
mov %r15d,%r9d
test %ebx,%ebx
jle 1634 <func0+0x1c4>
xor %r14d,%r14d
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13,%r14,4),%r8d
mov $0xc,%edx
mov %r12,%rdi
xor %eax,%eax
lea 0xa26(%rip),%rcx
mov $0x1,%esi
callq 1150 <__sprintf_chk@plt>
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 15eb <func0+0x17b>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
sbb $0x3,%rdx
add $0x1,%r14
sub %r12,%rdx
lea 0x2(%r15,%rdx,1),%r9d
mov %r9d,%r15d
cmp %r14d,%ebx
jg 15c8 <func0+0x158>
mov 0x10(%r13),%r8d
mov $0xc,%edx
mov $0x1,%esi
xor %eax,%eax
lea 0x9b9(%rip),%rcx
mov %r12,%rdi
mov %r9d,-0x5c(%rbp)
callq 1150 <__sprintf_chk@plt>
mov -0x5c(%rbp),%r9d
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 165e <func0+0x1ee>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
sbb $0x3,%rdx
add $0x14,%r13
sub %r12,%rdx
add %edx,%r9d
lea 0x2(%r9),%r15d
cmp -0x68(%rbp),%r13
jne 15b0 <func0+0x140>
mov %r9d,%r14d
mov %r12,%r13
add $0x1,%r14d
movslq %r14d,%rdi
callq 1110 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1998 <func0+0x528>
mov $0x5b,%edx
movl $0x0,-0x68(%rbp)
lea 0x928(%rip),%r15
mov %dx,(%r12)
nopl 0x0(%rax)
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 16eb <func0+0x27b>
mov %eax,%ecx
mov $0x28,%r10d
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
mov -0x58(%rbp),%rax
sbb $0x3,%rdx
mov 0xc(%rax),%eax
mov %r10w,(%rdx)
mov %eax,-0x60(%rbp)
test %eax,%eax
jle 1803 <func0+0x393>
sub $0x1,%eax
mov %eax,-0x5c(%rbp)
test %eax,%eax
jle 1968 <func0+0x4f8>
mov -0x58(%rbp),%r14
xor %ebx,%ebx
mov (%r14),%r8d
mov %r13,%rdi
mov %r15,%rcx
mov $0xc,%edx
mov $0x1,%esi
xor %eax,%eax
callq 1150 <__sprintf_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 176d <func0+0x2fd>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%esi
add %al,%sil
mov %r13,%rsi
sbb $0x3,%rdi
add $0x1,%ebx
add $0x4,%r14
callq 10e0 <stpcpy@plt>
mov $0x202c,%edi
mov %di,(%rax)
movb $0x0,0x2(%rax)
cmp -0x5c(%rbp),%ebx
jl 1750 <func0+0x2e0>
cmp -0x60(%rbp),%ebx
jge 1803 <func0+0x393>
movslq %ebx,%rbx
mov %rbx,%r14
mov -0x60(%rbp),%ebx
mov -0x58(%rbp),%rax
mov %r15,%rcx
mov $0xc,%edx
mov %r13,%rdi
mov $0x1,%esi
mov (%rax,%r14,4),%r8d
xor %eax,%eax
add $0x1,%r14
callq 1150 <__sprintf_chk@plt>
mov %r13,%rsi
mov %r12,%rdi
callq 1120 <strcat@plt>
cmp %r14d,%ebx
jg 17d0 <func0+0x360>
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 1806 <func0+0x396>
mov %eax,%ecx
mov $0x202c,%r9d
mov %r13,%rdi
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %r15,%rcx
mov %eax,%esi
add %al,%sil
mov -0x58(%rbp),%rax
mov $0x1,%esi
sbb $0x3,%rdx
mov %r9w,(%rdx)
mov 0x10(%rax),%r8d
xor %eax,%eax
movb $0x0,0x2(%rdx)
mov $0xc,%edx
callq 1150 <__sprintf_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 186b <func0+0x3fb>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%esi
add %al,%sil
mov %r13,%rsi
sbb $0x3,%rdi
callq 10e0 <stpcpy@plt>
mov $0x29,%r8d
mov -0x6c(%rbp),%esi
mov %rax,%rdx
mov %r8w,(%rax)
sub %r12,%rdx
cmp %esi,-0x68(%rbp)
jl 1970 <func0+0x500>
addl $0x1,-0x68(%rbp)
mov -0x68(%rbp),%eax
addq $0x14,-0x58(%rbp)
cmp %eax,-0x70(%rbp)
jne 16e8 <func0+0x278>
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 18dc <func0+0x46c>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov $0x5d,%ecx
mov %eax,%ebx
add %al,%bl
sbb $0x3,%rdx
mov %cx,(%rdx)
mov -0x38(%rbp),%rax
xor %fs:0x28,%rax
jne 19d9 <func0+0x569>
lea -0x28(%rbp),%rsp
mov %r12,%rax
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl (%rax)
movslq %r9d,%rax
movdqu (%rsi),%xmm0
add $0x1,%r9d
lea (%rax,%rax,4),%rax
lea (%r8,%rax,4),%rax
movl $0x1,0x10(%rax)
movups %xmm0,(%rax)
jmpq 1570 <func0+0x100>
nopw 0x0(%rax,%rax,1)
xor %ebx,%ebx
jmpq 17c7 <func0+0x357>
lea 0x1(%r12,%rdx,1),%rax
mov $0x202c,%esi
mov %si,(%rax)
movb $0x0,0x2(%rax)
jmpq 18c4 <func0+0x454>
mov $0x3,%edi
callq 1110 <malloc@plt>
mov %rax,%r12
test %rax,%rax
jne 19ca <func0+0x55a>
mov 0x2681(%rip),%rcx
mov $0x19,%edx
mov $0x1,%esi
lea 0x657(%rip),%rdi
callq 1140 <fwrite@plt>
mov $0x1,%edi
callq 1130 <exit@plt>
orq $0x0,-0x8(%rsp,%rcx,1)
jmpq 14e9 <func0+0x79>
mov $0x5b,%eax
mov %ax,(%r12)
jmpq 18d9 <func0+0x469>
callq 10f0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov r8, rsp
lea rdx, [rax+rax*4]
lea rdx, ds:0Fh[rdx*4]
mov rcx, rdx
and rdx, 0FFFFFFFFFFFFF000h
sub r8, rdx
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, r8
jz short loc_1511
loc_14FC:
sub rsp, 1000h
or [rsp+1080h+var_88], 0
cmp rsp, r8
jnz short loc_14FC
loc_1511:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_18EA
loc_1523:
mov r8, rsp
test esi, esi
jle loc_18F5
shl rax, 4
mov rsi, rdi
xor ebx, ebx
lea rdi, [rdi+rax]
nop dword ptr [rax+rax+00h]
loc_1540:
test ebx, ebx
jle loc_1830
loc_1548:
mov ecx, [rsi+0Ch]
mov rax, r8
xor edx, edx
jmp short loc_1567
loc_1558:
add edx, 1
add rax, 14h
cmp ebx, edx
jz loc_1830
loc_1567:
cmp [rax+0Ch], ecx
jnz short loc_1558
test ecx, ecx
jle short loc_1596
mov r11d, [rsi]
cmp [rax], r11d
jnz short loc_1558
cmp ecx, 1
jz short loc_1596
mov r9d, [rax+4]
cmp [rsi+4], r9d
jnz short loc_1558
cmp ecx, 2
jz short loc_1596
mov r11d, [rsi+8]
cmp [rax+8], r11d
jnz short loc_1558
loc_1596:
movsxd rdx, edx
add rsi, 10h
lea rax, [rdx+rdx*4]
add dword ptr [r8+rax*4+10h], 1
cmp rsi, rdi
jnz short loc_1548
loc_15AC:
test ebx, ebx
jle loc_18F5
movsxd rax, ebx
mov [rbp+var_60], ebx
mov r13, r8
mov r9d, 2
lea rax, [rax+rax*4]
mov [rbp+var_58], 0
lea r15, [rbp+s]
mov [rbp+var_68], rax
mov [rbp+var_70], r8
nop dword ptr [rax+rax+00h]
loc_15E0:
movsxd rax, dword ptr [r13+0Ch]
lea r14d, [r9+2]
mov r10d, r14d
test eax, eax
jle short loc_1638
mov rsi, [rbp+var_58]
mov rbx, r13
add rax, rsi
mov rsi, [rbp+var_70]
lea r12, [rsi+rax*4]
loc_1601:
mov r8d, [rbx]
lea rcx, unk_2004
mov rdi, r15
xor eax, eax
mov edx, 0Ch
mov esi, 2
add rbx, 4
call ___sprintf_chk
mov rdi, r15; s
call _strlen
lea r10d, [r14+rax+2]
mov r14d, r10d
cmp rbx, r12
jnz short loc_1601
loc_1638:
mov r8d, [r13+10h]
mov esi, 2
mov edx, 0Ch
xor eax, eax
lea rcx, unk_2004
mov rdi, r15
mov [rbp+var_5C], r10d
add r13, 14h
call ___sprintf_chk
mov rdi, r15; s
call _strlen
mov r10d, [rbp+var_5C]
add [rbp+var_58], 5
mov rsi, [rbp+var_68]
add r10d, eax
mov rax, [rbp+var_58]
lea r9d, [r10+2]
cmp rax, rsi
jnz loc_15E0
mov r12d, r10d
mov r8, [rbp+var_70]
mov ebx, [rbp+var_60]
add r12d, 1
movsxd r12, r12d
mov [rbp+var_58], r8
mov rdi, r12; size
call _malloc
mov r8, [rbp+var_58]
test rax, rax
mov r13, rax
jz loc_1921
mov rcx, r12
mov edx, 2
mov rdi, rax
mov [rbp+var_58], r8
lea rsi, asc_202A; "["
call ___memcpy_chk
lea eax, [rbx-1]
mov r8, [rbp+var_58]
mov dword ptr [rbp+var_70], ebx
mov dword ptr [rbp+var_68], eax
mov dword ptr [rbp+var_58], 0
mov rbx, r8
nop word ptr [rax+rax+00000000h]
loc_16F0:
mov rdx, r12
lea rsi, asc_2023; "("
mov rdi, r13
call ___strcat_chk
mov eax, [rbx+0Ch]
test eax, eax
jle short loc_1751
lea edx, [rax-1]
xor r14d, r14d
test edx, edx
jg loc_1860
loc_1717:
mov [rbp+var_5C], eax
loc_171A:
mov r8d, [rbx+r14*4]
lea rcx, unk_2004
mov rdi, r15
xor eax, eax
mov edx, 0Ch
mov esi, 2
add r14, 1
call ___sprintf_chk
mov rdx, r12
mov rsi, r15
mov rdi, r13
call ___strcat_chk
cmp [rbp+var_5C], r14d
jg short loc_171A
loc_1751:
mov rdx, r12
lea rsi, asc_2025; ", "
mov rdi, r13
mov r14, r13
call ___strcat_chk
mov r8d, [rbx+10h]
mov edx, 0Ch
xor eax, eax
lea rcx, unk_2004
mov esi, 2
mov rdi, r15
call ___sprintf_chk
mov rdi, r13; s
call _strlen
mov rdx, r12
mov rsi, r15
lea rdi, [r13+rax+0]
call ___stpcpy_chk
lea rsi, asc_2028; ")"
mov edx, 2
sub r14, rax
mov rdi, rax
add r14, r12
mov rcx, r14
call ___memcpy_chk
mov esi, dword ptr [rbp+var_58]
mov rdi, rax
cmp dword ptr [rbp+var_68], esi
jle short loc_17DE
lea rcx, [r14-1]
add rdi, 1
mov edx, 3
lea rsi, asc_2025; ", "
call ___memcpy_chk
loc_17DE:
add dword ptr [rbp+var_58], 1
add rbx, 14h
mov eax, dword ptr [rbp+var_58]
cmp dword ptr [rbp+var_70], eax
jnz loc_16F0
loc_17F2:
mov rdx, r12
lea rsi, asc_2021; "]"
mov rdi, r13
call ___strcat_chk
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_191C
lea rsp, [rbp-28h]
mov rax, r13
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1830:
movsxd rax, ebx
movdqu xmm0, xmmword ptr [rsi]
add rsi, 10h
add ebx, 1
lea rax, [rax+rax*4]
lea rax, [r8+rax*4]
mov dword ptr [rax+10h], 1
movups xmmword ptr [rax], xmm0
cmp rsi, rdi
jnz loc_1540
jmp loc_15AC
loc_1860:
mov [rbp+var_5C], edx
mov r9, rbx
mov [rbp+var_60], eax
mov [rbp+var_78], rbx
mov ebx, r14d
mov r14, r9
loc_1873:
mov r8d, [r14]
lea rcx, unk_2004
mov rdi, r15
xor eax, eax
mov edx, 0Ch
mov esi, 2
add ebx, 1
add r14, 4
call ___sprintf_chk
mov rdi, r13; s
call _strlen
mov rdx, r12
mov rsi, r15
lea rdi, [r13+rax+0]
call ___stpcpy_chk
mov rcx, r13
mov edx, 3
lea rsi, asc_2025; ", "
sub rcx, rax
mov rdi, rax
add rcx, r12
call ___memcpy_chk
cmp [rbp+var_5C], ebx
jg short loc_1873
mov eax, [rbp+var_60]
movsxd r14, ebx
mov rbx, [rbp+var_78]
cmp r14d, eax
jl loc_1717
jmp loc_1751
loc_18EA:
or [rsp+rcx+1080h+var_1088], 0
jmp loc_1523
loc_18F5:
mov edi, 3; size
call _malloc
mov r13, rax
test rax, rax
jz short loc_1921
mov eax, 5Bh ; '['
mov r12d, 3
mov [r13+0], ax
jmp loc_17F2
loc_191C:
call ___stack_chk_fail
loc_1921:
mov rcx, cs:__bss_start; s
mov edx, 19h; n
mov esi, 1; size
lea rdi, aMemoryAllocati; "Memory allocation failed\n"
call _fwrite
mov edi, 1; status
call _exit | char * func0(const __m128i *a1, int a2)
{
long long v2; // rcx
long long *v3; // r8
__int16 v4; // cx
signed long long v5; // rcx
void *v6; // rsp
long long v7; // rax
const __m128i *v8; // rsi
int v9; // ebx
const __m128i *v10; // rdi
int v11; // ecx
_DWORD *v12; // rax
int v13; // edx
unsigned int *v14; // r13
int v15; // r9d
long long v16; // rax
int v17; // r14d
int v18; // r10d
unsigned int *v19; // rbx
unsigned int *v20; // r12
long long v21; // r8
long long v22; // r8
int v23; // eax
int v24; // ebx
size_t v25; // r12
char *v26; // rax
char *v27; // r13
unsigned int *v28; // r8
unsigned int *v29; // rbx
int v30; // eax
long long v31; // r14
long long v32; // r8
size_t v33; // rax
long long v34; // rax
char *v35; // r14
long long v36; // rax
long long v38; // rax
__m128i v39; // xmm0
__m128i *v40; // rax
unsigned int *v41; // r9
int v42; // ebx
unsigned int *v43; // r14
long long v44; // r8
size_t v45; // rax
long long v46; // rax
_DWORD v48[1022]; // [rsp+8h] [rbp-1080h] BYREF
long long v49; // [rsp+1008h] [rbp-80h] BYREF
unsigned int *v50; // [rsp+1010h] [rbp-78h]
unsigned int *v51; // [rsp+1018h] [rbp-70h]
long long v52; // [rsp+1020h] [rbp-68h]
int v53; // [rsp+1028h] [rbp-60h]
int v54; // [rsp+102Ch] [rbp-5Ch]
unsigned int *v55; // [rsp+1030h] [rbp-58h]
char s[12]; // [rsp+1044h] [rbp-44h] BYREF
unsigned long long v57; // [rsp+1050h] [rbp-38h]
v57 = __readfsqword(0x28u);
v2 = 20LL * a2 + 15;
v3 = (long long *)((char *)&v49 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( &v49 != v3 )
{
while ( v48 != (_DWORD *)v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(_QWORD *)((char *)&v48[-2] + v5) = *(_QWORD *)((char *)&v48[-2] + v5);
if ( a2 <= 0 )
goto LABEL_40;
v7 = a2;
v8 = a1;
v9 = 0;
v10 = &a1[v7];
while ( v9 <= 0 )
{
LABEL_34:
v38 = v9;
v39 = _mm_loadu_si128(v8++);
++v9;
v40 = (__m128i *)&v48[5 * v38];
v40[1].m128i_i32[0] = 1;
*v40 = v39;
if ( v8 == v10 )
goto LABEL_18;
}
do
{
v11 = v8->m128i_i32[3];
v12 = v48;
v13 = 0;
while ( v12[3] != v11
|| v11 > 0
&& (*v12 != v8->m128i_i32[0]
|| v11 != 1 && (v8->m128i_i32[1] != v12[1] || v11 != 2 && v12[2] != v8->m128i_i32[2])) )
{
++v13;
v12 += 5;
if ( v9 == v13 )
goto LABEL_34;
}
++v8;
++v48[5 * v13 + 4];
}
while ( v8 != v10 );
LABEL_18:
if ( v9 <= 0 )
{
LABEL_40:
v27 = (char *)malloc(3uLL);
if ( v27 )
{
v25 = 3LL;
*(_WORD *)v27 = 91;
goto LABEL_33;
}
LABEL_42:
fwrite("Memory allocation failed\n", 1uLL, 0x19uLL, _bss_start);
exit(1);
}
v53 = v9;
v14 = v48;
v15 = 2;
v55 = 0LL;
v52 = 5LL * v9;
v51 = v48;
do
{
v16 = (int)v14[3];
v17 = v15 + 2;
v18 = v15 + 2;
if ( (int)v16 > 0 )
{
v19 = v14;
v20 = &v51[(_QWORD)v55 + v16];
do
{
v21 = *v19++;
__sprintf_chk(s, 2LL, 12LL, &unk_2004, v21);
v18 = v17 + strlen(s) + 2;
v17 = v18;
}
while ( v19 != v20 );
}
v22 = v14[4];
v54 = v18;
v14 += 5;
__sprintf_chk(s, 2LL, 12LL, &unk_2004, v22);
v23 = strlen(s);
v55 = (unsigned int *)((char *)v55 + 5);
v15 = v23 + v54 + 2;
}
while ( v55 != (unsigned int *)v52 );
v24 = v53;
v25 = v23 + v54 + 1;
v55 = v51;
v26 = (char *)malloc(v25);
v27 = v26;
if ( !v26 )
goto LABEL_42;
__memcpy_chk(v26, "[", 2LL, v25);
v28 = v55;
LODWORD(v51) = v24;
LODWORD(v52) = v24 - 1;
LODWORD(v55) = 0;
v29 = v28;
do
{
__strcat_chk(v27, "(", v25);
v30 = v29[3];
if ( v30 > 0 )
{
v31 = 0LL;
if ( v30 - 1 <= 0 )
goto LABEL_28;
v54 = v30 - 1;
v41 = v29;
v53 = v30;
v50 = v29;
v42 = 0;
v43 = v41;
do
{
v44 = *v43;
++v42;
++v43;
__sprintf_chk(s, 2LL, 12LL, &unk_2004, v44);
v45 = strlen(v27);
v46 = __stpcpy_chk(&v27[v45], s, v25);
__memcpy_chk(v46, ", ", 3LL, &v27[v25 - v46]);
}
while ( v54 > v42 );
v30 = v53;
v31 = v42;
v29 = v50;
if ( (int)v31 < v53 )
{
LABEL_28:
v54 = v30;
do
{
v32 = v29[v31++];
__sprintf_chk(s, 2LL, 12LL, &unk_2004, v32);
__strcat_chk(v27, s, v25);
}
while ( v54 > (int)v31 );
}
}
__strcat_chk(v27, ", ", v25);
__sprintf_chk(s, 2LL, 12LL, &unk_2004, v29[4]);
v33 = strlen(v27);
v34 = __stpcpy_chk(&v27[v33], s, v25);
v35 = &v27[v25 - v34];
v36 = __memcpy_chk(v34, ")", 2LL, v35);
if ( (int)v52 > (int)v55 )
__memcpy_chk(v36 + 1, ", ", 3LL, v35 - 1);
LODWORD(v55) = (_DWORD)v55 + 1;
v29 += 5;
}
while ( (_DWORD)v51 != (_DWORD)v55 );
LABEL_33:
__strcat_chk(v27, "]", v25);
return v27;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV R8,RSP
LEA RDX,[RAX + RAX*0x4]
LEA RDX,[0xf + RDX*0x4]
MOV RCX,RDX
AND RDX,-0x1000
SUB R8,RDX
AND RCX,-0x10
CMP RSP,R8
JZ 0x00101511
LAB_001014fc:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,R8
JNZ 0x001014fc
LAB_00101511:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x001018ea
LAB_00101523:
MOV R8,RSP
TEST ESI,ESI
JLE 0x001018f5
SHL RAX,0x4
MOV RSI,RDI
XOR EBX,EBX
LEA RDI,[RDI + RAX*0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101540:
TEST EBX,EBX
JLE 0x00101830
LAB_00101548:
MOV ECX,dword ptr [RSI + 0xc]
MOV RAX,R8
XOR EDX,EDX
JMP 0x00101567
LAB_00101558:
ADD EDX,0x1
ADD RAX,0x14
CMP EBX,EDX
JZ 0x00101830
LAB_00101567:
CMP dword ptr [RAX + 0xc],ECX
JNZ 0x00101558
TEST ECX,ECX
JLE 0x00101596
MOV R11D,dword ptr [RSI]
CMP dword ptr [RAX],R11D
JNZ 0x00101558
CMP ECX,0x1
JZ 0x00101596
MOV R9D,dword ptr [RAX + 0x4]
CMP dword ptr [RSI + 0x4],R9D
JNZ 0x00101558
CMP ECX,0x2
JZ 0x00101596
MOV R11D,dword ptr [RSI + 0x8]
CMP dword ptr [RAX + 0x8],R11D
JNZ 0x00101558
LAB_00101596:
MOVSXD RDX,EDX
ADD RSI,0x10
LEA RAX,[RDX + RDX*0x4]
ADD dword ptr [R8 + RAX*0x4 + 0x10],0x1
CMP RSI,RDI
JNZ 0x00101548
LAB_001015ac:
TEST EBX,EBX
JLE 0x001018f5
MOVSXD RAX,EBX
MOV dword ptr [RBP + -0x60],EBX
MOV R13,R8
MOV R9D,0x2
LEA RAX,[RAX + RAX*0x4]
MOV qword ptr [RBP + -0x58],0x0
LEA R15,[RBP + -0x44]
MOV qword ptr [RBP + -0x68],RAX
MOV qword ptr [RBP + -0x70],R8
NOP dword ptr [RAX + RAX*0x1]
LAB_001015e0:
MOVSXD RAX,dword ptr [R13 + 0xc]
LEA R14D,[R9 + 0x2]
MOV R10D,R14D
TEST EAX,EAX
JLE 0x00101638
MOV RSI,qword ptr [RBP + -0x58]
MOV RBX,R13
ADD RAX,RSI
MOV RSI,qword ptr [RBP + -0x70]
LEA R12,[RSI + RAX*0x4]
LAB_00101601:
MOV R8D,dword ptr [RBX]
LEA RCX,[0x102004]
MOV RDI,R15
XOR EAX,EAX
MOV EDX,0xc
MOV ESI,0x2
ADD RBX,0x4
CALL 0x001011b0
MOV RDI,R15
CALL 0x00101120
LEA R10D,[R14 + RAX*0x1 + 0x2]
MOV R14D,R10D
CMP RBX,R12
JNZ 0x00101601
LAB_00101638:
MOV R8D,dword ptr [R13 + 0x10]
MOV ESI,0x2
MOV EDX,0xc
XOR EAX,EAX
LEA RCX,[0x102004]
MOV RDI,R15
MOV dword ptr [RBP + -0x5c],R10D
ADD R13,0x14
CALL 0x001011b0
MOV RDI,R15
CALL 0x00101120
MOV R10D,dword ptr [RBP + -0x5c]
ADD qword ptr [RBP + -0x58],0x5
MOV RSI,qword ptr [RBP + -0x68]
ADD R10D,EAX
MOV RAX,qword ptr [RBP + -0x58]
LEA R9D,[R10 + 0x2]
CMP RAX,RSI
JNZ 0x001015e0
MOV R12D,R10D
MOV R8,qword ptr [RBP + -0x70]
MOV EBX,dword ptr [RBP + -0x60]
ADD R12D,0x1
MOVSXD R12,R12D
MOV qword ptr [RBP + -0x58],R8
MOV RDI,R12
CALL 0x00101180
MOV R8,qword ptr [RBP + -0x58]
TEST RAX,RAX
MOV R13,RAX
JZ 0x00101921
MOV RCX,R12
MOV EDX,0x2
MOV RDI,RAX
MOV qword ptr [RBP + -0x58],R8
LEA RSI,[0x10202a]
CALL 0x00101160
LEA EAX,[RBX + -0x1]
MOV R8,qword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x70],EBX
MOV dword ptr [RBP + -0x68],EAX
MOV dword ptr [RBP + -0x58],0x0
MOV RBX,R8
NOP word ptr [RAX + RAX*0x1]
LAB_001016f0:
MOV RDX,R12
LEA RSI,[0x102023]
MOV RDI,R13
CALL 0x00101100
MOV EAX,dword ptr [RBX + 0xc]
TEST EAX,EAX
JLE 0x00101751
LEA EDX,[RAX + -0x1]
XOR R14D,R14D
TEST EDX,EDX
JG 0x00101860
LAB_00101717:
MOV dword ptr [RBP + -0x5c],EAX
LAB_0010171a:
MOV R8D,dword ptr [RBX + R14*0x4]
LEA RCX,[0x102004]
MOV RDI,R15
XOR EAX,EAX
MOV EDX,0xc
MOV ESI,0x2
ADD R14,0x1
CALL 0x001011b0
MOV RDX,R12
MOV RSI,R15
MOV RDI,R13
CALL 0x00101100
CMP dword ptr [RBP + -0x5c],R14D
JG 0x0010171a
LAB_00101751:
MOV RDX,R12
LEA RSI,[0x102025]
MOV RDI,R13
MOV R14,R13
CALL 0x00101100
MOV R8D,dword ptr [RBX + 0x10]
MOV EDX,0xc
XOR EAX,EAX
LEA RCX,[0x102004]
MOV ESI,0x2
MOV RDI,R15
CALL 0x001011b0
MOV RDI,R13
CALL 0x00101120
MOV RDX,R12
MOV RSI,R15
LEA RDI,[R13 + RAX*0x1]
CALL 0x00101170
LEA RSI,[0x102028]
MOV EDX,0x2
SUB R14,RAX
MOV RDI,RAX
ADD R14,R12
MOV RCX,R14
CALL 0x00101160
MOV ESI,dword ptr [RBP + -0x58]
MOV RDI,RAX
CMP dword ptr [RBP + -0x68],ESI
JLE 0x001017de
LEA RCX,[R14 + -0x1]
ADD RDI,0x1
MOV EDX,0x3
LEA RSI,[0x102025]
CALL 0x00101160
LAB_001017de:
ADD dword ptr [RBP + -0x58],0x1
ADD RBX,0x14
MOV EAX,dword ptr [RBP + -0x58]
CMP dword ptr [RBP + -0x70],EAX
JNZ 0x001016f0
LAB_001017f2:
MOV RDX,R12
LEA RSI,[0x102021]
MOV RDI,R13
CALL 0x00101100
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010191c
LEA RSP,[RBP + -0x28]
MOV RAX,R13
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101830:
MOVSXD RAX,EBX
MOVDQU XMM0,xmmword ptr [RSI]
ADD RSI,0x10
ADD EBX,0x1
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[R8 + RAX*0x4]
MOV dword ptr [RAX + 0x10],0x1
MOVUPS xmmword ptr [RAX],XMM0
CMP RSI,RDI
JNZ 0x00101540
JMP 0x001015ac
LAB_00101860:
MOV dword ptr [RBP + -0x5c],EDX
MOV R9,RBX
MOV dword ptr [RBP + -0x60],EAX
MOV qword ptr [RBP + -0x78],RBX
MOV EBX,R14D
MOV R14,R9
LAB_00101873:
MOV R8D,dword ptr [R14]
LEA RCX,[0x102004]
MOV RDI,R15
XOR EAX,EAX
MOV EDX,0xc
MOV ESI,0x2
ADD EBX,0x1
ADD R14,0x4
CALL 0x001011b0
MOV RDI,R13
CALL 0x00101120
MOV RDX,R12
MOV RSI,R15
LEA RDI,[R13 + RAX*0x1]
CALL 0x00101170
MOV RCX,R13
MOV EDX,0x3
LEA RSI,[0x102025]
SUB RCX,RAX
MOV RDI,RAX
ADD RCX,R12
CALL 0x00101160
CMP dword ptr [RBP + -0x5c],EBX
JG 0x00101873
MOV EAX,dword ptr [RBP + -0x60]
MOVSXD R14,EBX
MOV RBX,qword ptr [RBP + -0x78]
CMP R14D,EAX
JL 0x00101717
JMP 0x00101751
LAB_001018ea:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x00101523
LAB_001018f5:
MOV EDI,0x3
CALL 0x00101180
MOV R13,RAX
TEST RAX,RAX
JZ 0x00101921
MOV EAX,0x5b
MOV R12D,0x3
MOV word ptr [R13],AX
JMP 0x001017f2
LAB_0010191c:
CALL 0x00101130
LAB_00101921:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x19
MOV ESI,0x1
LEA RDI,[0x102007]
CALL 0x001011a0
MOV EDI,0x1
CALL 0x00101190 | char * func0(int *param_1,int param_2)
{
int *piVar1;
int8 *puVar2;
int4 uVar3;
long lVar4;
int8 uVar5;
int8 uVar6;
int *puVar7;
int4 *puVar8;
int *piVar9;
size_t sVar10;
char *__s;
size_t sVar11;
long lVar12;
long lVar13;
int iVar14;
uint uVar15;
int4 *puVar16;
int4 *puVar17;
int *puVar18;
int iVar20;
int iVar21;
ulong uVar22;
long in_FS_OFFSET;
int auStack_88 [8];
int4 *local_80;
int4 *local_78;
long local_70;
int local_68;
int local_64;
int4 *local_60;
char local_4c [12];
long local_40;
int *puVar19;
puVar18 = auStack_88;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar22 = (long)param_2 * 0x14 + 0xf;
puVar19 = auStack_88;
puVar7 = auStack_88;
while (puVar19 != auStack_88 + -(uVar22 & 0xfffffffffffff000)) {
puVar18 = puVar7 + -0x1000;
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
puVar19 = puVar7 + -0x1000;
puVar7 = puVar7 + -0x1000;
}
uVar22 = (ulong)((uint)uVar22 & 0xff0);
lVar4 = -uVar22;
puVar17 = (int4 *)(puVar18 + lVar4);
if (uVar22 != 0) {
*(int8 *)(puVar18 + -8) = *(int8 *)(puVar18 + -8);
}
if (0 < param_2) {
iVar14 = 0;
piVar1 = param_1 + (long)param_2 * 4;
do {
if (0 < iVar14) {
do {
iVar21 = param_1[3];
iVar20 = 0;
piVar9 = (int *)(puVar18 + lVar4);
while ((piVar9[3] != iVar21 ||
((0 < iVar21 &&
((*piVar9 != *param_1 ||
((iVar21 != 1 &&
((param_1[1] != piVar9[1] || ((iVar21 != 2 && (piVar9[2] != param_1[2]))))))))))
))) {
iVar20 = iVar20 + 1;
piVar9 = piVar9 + 5;
if (iVar14 == iVar20) goto LAB_00101830;
}
param_1 = param_1 + 4;
*(int *)(puVar18 + (long)iVar20 * 0x14 + lVar4 + 0x10) =
*(int *)(puVar18 + (long)iVar20 * 0x14 + lVar4 + 0x10) + 1;
} while (param_1 != piVar1);
break;
}
LAB_00101830:
lVar12 = (long)iVar14;
uVar5 = *(int8 *)param_1;
uVar6 = *(int8 *)(param_1 + 2);
param_1 = param_1 + 4;
iVar14 = iVar14 + 1;
puVar2 = (int8 *)(puVar18 + lVar12 * 0x14 + lVar4);
*(int4 *)(puVar2 + 2) = 1;
*puVar2 = uVar5;
puVar2[1] = uVar6;
} while (param_1 != piVar1);
if (0 < iVar14) {
iVar21 = 2;
local_70 = (long)iVar14 * 5;
local_60 = (int4 *)0x0;
local_78 = (int4 *)(puVar18 + lVar4);
local_68 = iVar14;
do {
iVar21 = iVar21 + 2;
if (0 < (int)puVar17[3]) {
puVar8 = local_78 + (long)(int)puVar17[3] + (long)local_60;
puVar16 = puVar17;
do {
uVar3 = *puVar16;
puVar16 = puVar16 + 1;
*(int8 *)(puVar18 + lVar4 + -8) = 0x101623;
__sprintf_chk(local_4c,2,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar18 + lVar4 + -8) = 0x10162b;
sVar10 = strlen(local_4c);
iVar21 = iVar21 + 2 + (int)sVar10;
} while (puVar16 != puVar8);
}
uVar3 = puVar17[4];
puVar17 = puVar17 + 5;
*(int8 *)(puVar18 + lVar4 + -8) = 0x10165f;
local_64 = iVar21;
__sprintf_chk(local_4c,2,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar18 + lVar4 + -8) = 0x101667;
sVar10 = strlen(local_4c);
iVar14 = local_68;
local_60 = (int4 *)((long)local_60 + 5);
iVar20 = local_64 + (int)sVar10;
iVar21 = iVar20 + 2;
} while (local_60 != (int4 *)local_70);
sVar10 = (size_t)(iVar20 + 1);
local_60 = local_78;
*(int8 *)(puVar18 + lVar4 + -8) = 0x1016a5;
__s = (char *)malloc(sVar10);
if (__s == (char *)0x0) goto LAB_00101921;
*(int8 *)(puVar18 + lVar4 + -8) = 0x1016d0;
__memcpy_chk(__s,&DAT_0010202a,2,sVar10);
puVar17 = local_60;
local_78 = (int4 *)CONCAT44(local_78._4_4_,iVar14);
local_70 = CONCAT44(local_70._4_4_,iVar14 + -1);
local_60 = (int4 *)((ulong)local_60 & 0xffffffff00000000);
do {
*(int8 *)(puVar18 + lVar4 + -8) = 0x101702;
__strcat_chk(__s,&DAT_00102023,sVar10);
iVar14 = puVar17[3];
if (0 < iVar14) {
local_64 = iVar14 + -1;
uVar22 = 0;
puVar8 = puVar17;
if (0 < local_64) {
do {
local_68 = iVar14;
local_80 = puVar8;
uVar3 = *puVar17;
uVar15 = (int)uVar22 + 1;
uVar22 = (ulong)uVar15;
puVar17 = puVar17 + 1;
*(int8 *)(puVar18 + lVar4 + -8) = 0x101898;
__sprintf_chk(local_4c,2,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar18 + lVar4 + -8) = 0x1018a0;
sVar11 = strlen(__s);
*(int8 *)(puVar18 + lVar4 + -8) = 0x1018b0;
lVar12 = __stpcpy_chk(__s + sVar11,local_4c,sVar10);
*(int8 *)(puVar18 + lVar4 + -8) = 0x1018cd;
__memcpy_chk(lVar12,&DAT_00102025,3,__s + (sVar10 - lVar12));
puVar8 = local_80;
iVar14 = local_68;
} while ((int)uVar15 < local_64);
uVar22 = (ulong)(int)uVar15;
puVar17 = local_80;
iVar14 = local_68;
if (local_68 <= (int)uVar15) goto LAB_00101751;
}
do {
local_64 = iVar14;
uVar3 = puVar17[uVar22];
uVar22 = uVar22 + 1;
*(int8 *)(puVar18 + lVar4 + -8) = 0x10173d;
__sprintf_chk(local_4c,2,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar18 + lVar4 + -8) = 0x10174b;
__strcat_chk(__s,local_4c,sVar10);
iVar14 = local_64;
} while ((int)uVar22 < local_64);
}
LAB_00101751:
*(int8 *)(puVar18 + lVar4 + -8) = 0x101766;
__strcat_chk(__s,&DAT_00102025,sVar10);
uVar3 = puVar17[4];
*(int8 *)(puVar18 + lVar4 + -8) = 0x101785;
__sprintf_chk(local_4c,2,0xc,&DAT_00102004,uVar3);
*(int8 *)(puVar18 + lVar4 + -8) = 0x10178d;
sVar11 = strlen(__s);
*(int8 *)(puVar18 + lVar4 + -8) = 0x10179d;
lVar12 = __stpcpy_chk(__s + sVar11,local_4c,sVar10);
*(int8 *)(puVar18 + lVar4 + -8) = 0x1017ba;
lVar13 = __memcpy_chk(lVar12,&DAT_00102028,2,__s + (sVar10 - lVar12));
if ((int)local_60 < (int)local_70) {
*(int8 *)(puVar18 + lVar4 + -8) = 0x1017de;
__memcpy_chk(lVar13 + 1,&DAT_00102025,3,__s + (sVar10 - lVar12) + -1);
}
iVar14 = (int)local_60 + 1;
local_60 = (int4 *)CONCAT44(local_60._4_4_,iVar14);
puVar17 = puVar17 + 5;
} while ((int)local_78 != iVar14);
goto LAB_001017f2;
}
}
*(int8 *)(puVar18 + lVar4 + -8) = 0x1018ff;
__s = (char *)malloc(3);
if (__s == (char *)0x0) {
LAB_00101921:
*(int8 *)(puVar18 + lVar4 + -8) = 0x10193e;
fwrite("Memory allocation failed\n",1,0x19,stderr);
/* WARNING: Subroutine does not return */
*(code **)(puVar18 + lVar4 + -8) = _fini;
exit(1);
}
sVar10 = 3;
__s[0] = '[';
__s[1] = '\0';
LAB_001017f2:
*(int8 *)(puVar18 + lVar4 + -8) = 0x101804;
__strcat_chk(__s,&DAT_00102021,sVar10);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return __s;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar18 + lVar4 + -8) = 0x101921;
__stack_chk_fail();
} |
4,352 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a9 <func0+0x40>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov (%rax),%eax
test %eax,%eax
je 11a5 <func0+0x3c>
mov $0x0,%eax
jmp 11b6 <func0+0x4d>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11A9
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov eax, [rax]
test eax, eax
jz short loc_11A5
mov eax, 0
jmp short loc_11B6
loc_11A5:
add [rbp+var_4], 1
loc_11A9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 1
loc_11B6:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( **(_DWORD **)(8LL * i + a1) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a9
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x001011a5
MOV EAX,0x0
JMP 0x001011b6
LAB_001011a5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x1
LAB_001011b6:
POP RBP
RET | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (**(int **)(param_1 + (long)local_c * 8) != 0) break;
local_c = local_c + 1;
}
return 0;
} |
4,353 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1193 <func0+0x2a>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x8(%rdi,%rdx,8),%rcx
mov (%rax),%rdx
cmpl $0x0,(%rdx)
jne 1199 <func0+0x30>
add $0x8,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1193
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*8+8]
loc_117C:
mov rdx, [rax]
cmp dword ptr [rdx], 0
jnz short loc_1199
add rax, 8
cmp rax, rcx
jnz short loc_117C
mov eax, 1
retn
loc_1193:
mov eax, 1
retn
loc_1199:
mov eax, 0
retn | long long func0(_DWORD **a1, int a2)
{
_DWORD **v2; // rax
if ( a2 <= 0 )
return 1LL;
v2 = a1;
while ( !**v2 )
{
if ( ++v2 == &a1[(unsigned int)(a2 - 1) + 1] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101193
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x8 + 0x8]
LAB_0010117c:
MOV RDX,qword ptr [RAX]
CMP dword ptr [RDX],0x0
JNZ 0x00101199
ADD RAX,0x8
CMP RAX,RCX
JNZ 0x0010117c
MOV EAX,0x1
RET
LAB_00101193:
MOV EAX,0x1
RET
LAB_00101199:
MOV EAX,0x0
RET | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
if (param_2 < 1) {
return 1;
}
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*(int *)*param_1 != 0) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return 1;
} |
4,354 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdx
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x8,%rdi
cmp %rdx,%rdi
je 1170 <func0+0x30>
mov (%rdi),%rax
mov (%rax),%eax
test %eax,%eax
je 1158 <func0+0x18>
xor %eax,%eax
retq
nopl (%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rdx, [rdi+rax*8+8]
jmp short loc_1161
loc_1158:
add rdi, 8
cmp rdi, rdx
jz short loc_1170
loc_1161:
mov rax, [rdi]
mov eax, [rax]
test eax, eax
jz short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn | long long func0(_DWORD **a1, int a2)
{
long long v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
while ( !**a1 )
{
if ( ++a1 == (_DWORD **)v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x8 + 0x8]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x8
CMP RDI,RDX
JZ 0x00101170
LAB_00101161:
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*(int *)*param_1 != 0) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 1;
} |
4,355 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdx
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x8,%rdi
cmp %rdx,%rdi
je 1170 <func0+0x30>
mov (%rdi),%rax
mov (%rax),%eax
test %eax,%eax
je 1158 <func0+0x18>
xor %eax,%eax
retq
nopl (%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rdx, [rdi+rsi*8]
jmp short loc_1161
loc_1158:
add rdi, 8
cmp rdi, rdx
jz short loc_1170
loc_1161:
mov rax, [rdi]
mov eax, [rax]
test eax, eax
jz short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn | long long func0(_DWORD **a1, int a2)
{
_DWORD **v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = &a1[a2];
while ( !**a1 )
{
if ( ++a1 == v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x8]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x8
CMP RDI,RDX
JZ 0x00101170
LAB_00101161:
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
if (*(int *)*param_1 != 0) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 1;
} |
4,356 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
assert(func0(nums3, size3) == 567);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b5 <func0+0x4c>
mov -0x8(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %ecx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11B5
loc_1188:
mov edx, [rbp+var_8]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add eax, ecx
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_11B5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 = 10 * v3 + *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b5
LAB_00101188:
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD EAX,ECX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) + local_10 * 10;
}
return local_10;
} |
4,357 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
assert(func0(nums3, size3) == 567);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%edx
lea (%rdx,%rdx,4),%ecx
mov (%rax),%edx
lea (%rdx,%rcx,2),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1192 <func0+0x29>
| func0:
endbr64
test esi, esi
jle short loc_1195
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
lea ecx, [rdx+rdx*4]
mov edx, [rax]
lea edx, [rdx+rcx*2]
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1192:
mov eax, edx
retn
loc_1195:
mov edx, 0
jmp short loc_1192 | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 = *v2++ + 10 * v4;
while ( v2 != (_DWORD *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101195
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
LEA ECX,[RDX + RDX*0x4]
MOV EDX,dword ptr [RAX]
LEA EDX,[RDX + RCX*0x2]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101192:
MOV EAX,EDX
RET
LAB_00101195:
MOV EDX,0x0
JMP 0x00101192 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = *param_1 + iVar2 * 10;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
4,358 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
assert(func0(nums3, size3) == 567);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rcx,%rdi
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rdi, rcx
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long v2; // rcx
long long result; // rax
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( a1 != (int *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RDI,RCX
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (param_1 != piVar1);
return iVar3;
}
return 0;
} |
4,359 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
assert(func0(nums3, size3) == 567);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rdi,%rcx
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
xor eax, eax
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rcx, rdi
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rcx
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
LODWORD(result) = 0;
v3 = &a1[a2];
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RCX,RDI
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (piVar1 != param_1);
return iVar3;
}
return 0;
} |
4,360 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, second);
strcat(res, temp);
if (i < size - 2) {
strcat(res, ", ");
}
}
strcat(res, "]");
return res;
}
| int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == 0);
assert(strcmp(func0(list2, 8), "[(4.00, 4.00), (2.00, 27.00), (4.12, 9.00), (7.00, 11.00)]") == 0);
assert(strcmp(func0(list3, 8), "[(6.00, 78.00), (5.00, 26.45), (1.33, 4.00), (82.00, 13.00)]") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movw $0x5b,0x2e23(%rip)
movl $0x0,-0x84(%rbp)
jmpq 131e <func0+0x135>
mov -0x84(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x98(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10a0 <atof@plt>
movq %xmm0,%rax
mov %rax,-0x80(%rbp)
mov -0x84(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x98(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10a0 <atof@plt>
movq %xmm0,%rax
mov %rax,-0x78(%rbp)
movsd -0x78(%rbp),%xmm0
mov -0x80(%rbp),%rdx
lea -0x70(%rbp),%rax
movapd %xmm0,%xmm1
movq %rdx,%xmm0
lea 0xd5f(%rip),%rdx
mov $0x64,%esi
mov %rax,%rdi
mov $0x2,%eax
callq 10c0 <snprintf@plt>
lea -0x70(%rbp),%rax
mov %rax,%rsi
lea 0x2d77(%rip),%rdi
callq 10f0 <strcat@plt>
mov -0x9c(%rbp),%eax
sub $0x2,%eax
cmp %eax,-0x84(%rbp)
jge 1317 <func0+0x12e>
lea 0x2d5a(%rip),%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
lea 0x2d35(%rip),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
addl $0x2,-0x84(%rbp)
mov -0x84(%rbp),%eax
cmp -0x9c(%rbp),%eax
jl 122c <func0+0x43>
lea 0x2d09(%rip),%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
lea 0x2ce4(%rip),%rax
add %rdx,%rax
movw $0x5d,(%rax)
lea 0x2cd5(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 137f <func0+0x196>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_98], rdi
mov [rbp+var_9C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
mov [rbp+var_84], 0
jmp loc_132E
loc_124C:
mov eax, [rbp+var_84]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_98]
add rax, rdx
mov rax, [rax]
mov rdi, rax; nptr
call _atof
movq rax, xmm0
mov [rbp+var_80], rax
mov eax, [rbp+var_84]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_98]
add rax, rdx
mov rax, [rax]
mov rdi, rax; nptr
call _atof
movq rax, xmm0
mov [rbp+var_78], rax
movsd xmm0, [rbp+var_78]
mov rdx, [rbp+var_80]
lea rax, [rbp+s]
movapd xmm1, xmm0
movq xmm0, rdx
lea rdx, format; "(%.2f, %.2f)"
mov esi, 64h ; 'd'; maxlen
mov rdi, rax; s
mov eax, 2
call _snprintf
lea rax, [rbp+s]
mov rsi, rax; src
lea rax, res_1
mov rdi, rax; dest
call _strcat
mov eax, [rbp+var_9C]
sub eax, 2
cmp [rbp+var_84], eax
jge short loc_1327
lea rax, res_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, res_1
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
loc_1327:
add [rbp+var_84], 2
loc_132E:
mov eax, [rbp+var_84]
cmp eax, [rbp+var_9C]
jl loc_124C
lea rax, res_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, res_1
add rax, rdx
mov word ptr [rax], 5Dh ; ']'
lea rax, res_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_137C
call ___stack_chk_fail
locret_137C:
leave
retn | char * func0(long long a1, int a2)
{
double v2; // xmm1_8
int i; // [rsp+1Ch] [rbp-84h]
double v5; // [rsp+20h] [rbp-80h]
char s[104]; // [rsp+30h] [rbp-70h] BYREF
unsigned long long v7; // [rsp+98h] [rbp-8h]
v7 = __readfsqword(0x28u);
strcpy(res_1, "[");
for ( i = 0; i < a2; i += 2 )
{
v5 = atof(*(const char **)(8LL * i + a1));
v2 = atof(*(const char **)(8 * (i + 1LL) + a1));
snprintf(s, 0x64uLL, "(%.2f, %.2f)", v5, v2);
strcat(res_1, s);
if ( i < a2 - 2 )
strcpy(&res_1[strlen(res_1)], ", ");
}
*(_WORD *)&res_1[strlen(res_1)] = 93;
return res_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x98],RDI
MOV dword ptr [RBP + -0x9c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV word ptr [0x00104040],0x5b
MOV dword ptr [RBP + -0x84],0x0
JMP 0x0010132e
LAB_0010124c:
MOV EAX,dword ptr [RBP + -0x84]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x84]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x78],RAX
MOVSD XMM0,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x80]
LEA RAX,[RBP + -0x70]
MOVAPD XMM1,XMM0
MOVQ XMM0,RDX
LEA RDX,[0x102008]
MOV ESI,0x64
MOV RDI,RAX
MOV EAX,0x2
CALL 0x001010e0
LEA RAX,[RBP + -0x70]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101110
MOV EAX,dword ptr [RBP + -0x9c]
SUB EAX,0x2
CMP dword ptr [RBP + -0x84],EAX
JGE 0x00101327
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_00101327:
ADD dword ptr [RBP + -0x84],0x2
LAB_0010132e:
MOV EAX,dword ptr [RBP + -0x84]
CMP EAX,dword ptr [RBP + -0x9c]
JL 0x0010124c
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x5d
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010137c
CALL 0x001010d0
LAB_0010137c:
LEAVE
RET | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
long in_FS_OFFSET;
double dVar2;
double dVar3;
int local_8c;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
for (local_8c = 0; local_8c < param_2; local_8c = local_8c + 2) {
dVar2 = atof(*(char **)(param_1 + (long)local_8c * 8));
dVar3 = atof(*(char **)(param_1 + ((long)local_8c + 1) * 8));
snprintf(local_78,100,"(%.2f, %.2f)",dVar2,dVar3);
strcat(res_1,local_78);
if (local_8c < param_2 + -2) {
sVar1 = strlen(res_1);
*(int2 *)(res_1 + sVar1) = 0x202c;
res_1[sVar1 + 2] = 0;
}
}
sVar1 = strlen(res_1);
*(int2 *)(res_1 + sVar1) = 0x5d;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
4,361 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, second);
strcat(res, temp);
if (i < size - 2) {
strcat(res, ", ");
}
}
strcat(res, "]");
return res;
}
| int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == 0);
assert(strcmp(func0(list2, 8), "[(4.00, 4.00), (2.00, 27.00), (4.12, 9.00), (7.00, 11.00)]") == 0);
assert(strcmp(func0(list3, 8), "[(6.00, 78.00), (5.00, 26.45), (1.33, 4.00), (82.00, 13.00)]") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
add $0xffffffffffffff80,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
movw $0x5b,0x2e4e(%rip)
test %esi,%esi
jle 12ab <func0+0xe2>
mov %rdi,%rbp
mov %esi,%r13d
lea -0x1(%rsi),%eax
shr %eax
mov %eax,%eax
lea 0x2(%rax,%rax,1),%r14
mov $0x0,%ebx
lea 0x10(%rsp),%r12
jmp 1239 <func0+0x70>
mov $0x3e8,%edx
lea 0xded(%rip),%rsi
lea 0x2e15(%rip),%rdi
callq 1090 <__strcat_chk@plt>
add $0x2,%rbx
cmp %r14,%rbx
je 12ab <func0+0xe2>
mov 0x0(%rbp,%rbx,8),%rdi
mov $0x0,%esi
callq 10b0 <strtod@plt>
movsd %xmm0,0x8(%rsp)
mov 0x8(%rbp,%rbx,8),%rdi
mov $0x0,%esi
callq 10b0 <strtod@plt>
movapd %xmm0,%xmm1
movsd 0x8(%rsp),%xmm0
lea 0xd96(%rip),%r8
mov $0x64,%ecx
mov $0x1,%edx
mov $0x64,%esi
mov %r12,%rdi
mov $0x2,%eax
callq 10a0 <__snprintf_chk@plt>
mov $0x3e8,%edx
mov %r12,%rsi
lea 0x2da7(%rip),%rdi
callq 1090 <__strcat_chk@plt>
lea -0x2(%r13),%eax
cmp %ebx,%eax
jle 1230 <func0+0x67>
jmpq 1218 <func0+0x4f>
mov $0x3e8,%edx
lea 0xd5d(%rip),%rsi
lea 0x2d82(%rip),%rdi
callq 1090 <__strcat_chk@plt>
mov 0x78(%rsp),%rax
xor %fs:0x28,%rax
jne 12e7 <func0+0x11e>
lea 0x2d66(%rip),%rax
sub $0xffffffffffffff80,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 10c0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
test esi, esi
jle loc_12CD
mov rbp, rdi
lea eax, [rsi-1]
shr eax, 1
lea r15d, [rax+1]
add r15, r15
mov ebx, 0
lea r12, [rsp+0B8h+var_A8]
lea r14, res_1
lea r13d, [rsi-2]
jmp short loc_124E
loc_1245:
add rbx, 2
cmp rbx, r15
jz short loc_12CD
loc_124E:
mov rdi, [rbp+rbx*8+0]
mov esi, 0
call _strtod
movsd [rsp+0B8h+var_B0], xmm0
mov rdi, [rbp+rbx*8+8]
mov esi, 0
call _strtod
movapd xmm1, xmm0
movsd xmm0, [rsp+0B8h+var_B0]
lea r8, a2f2f; "(%.2f, %.2f)"
mov ecx, 64h ; 'd'
mov edx, 1
mov esi, 64h ; 'd'
mov rdi, r12
mov eax, 2
call ___snprintf_chk
mov edx, 3E8h
mov rsi, r12
mov rdi, r14
call ___strcat_chk
cmp r13d, ebx
jle short loc_1245
mov edx, 3E8h
lea rsi, asc_2011; ", "
mov rdi, r14
call ___strcat_chk
jmp loc_1245
loc_12CD:
mov edx, 3E8h
lea rsi, asc_2014; "]"
lea rbx, res_1
mov rdi, rbx
call ___strcat_chk
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_130D
mov rax, rbx
add rsp, 88h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_130D:
call ___stack_chk_fail | __int16 * func0(long long a1, int a2)
{
long long v2; // rbx
double v3; // xmm1_8
double v5; // [rsp+8h] [rbp-B0h]
_BYTE v6[104]; // [rsp+10h] [rbp-A8h] BYREF
unsigned long long v7; // [rsp+78h] [rbp-40h]
v7 = __readfsqword(0x28u);
res_1 = 91;
if ( a2 > 0 )
{
v2 = 0LL;
do
{
v5 = strtod(*(_QWORD *)(a1 + 8 * v2), 0LL);
v3 = strtod(*(_QWORD *)(a1 + 8 * v2 + 8), 0LL);
__snprintf_chk(v6, 100LL, 1LL, 100LL, "(%.2f, %.2f)", v5, v3);
__strcat_chk(&res_1, v6, 1000LL);
if ( a2 - 2 > (int)v2 )
__strcat_chk(&res_1, ", ", 1000LL);
v2 += 2LL;
}
while ( v2 != 2LL * (((unsigned int)(a2 - 1) >> 1) + 1) );
}
__strcat_chk(&res_1, "]", 1000LL);
return &res_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV word ptr [0x00104040],0x5b
TEST ESI,ESI
JLE 0x001012cd
MOV RBP,RDI
LEA EAX,[RSI + -0x1]
SHR EAX,0x1
LEA R15D,[RAX + 0x1]
ADD R15,R15
MOV EBX,0x0
LEA R12,[RSP + 0x10]
LEA R14,[0x104040]
LEA R13D,[RSI + -0x2]
JMP 0x0010124e
LAB_00101245:
ADD RBX,0x2
CMP RBX,R15
JZ 0x001012cd
LAB_0010124e:
MOV RDI,qword ptr [RBP + RBX*0x8]
MOV ESI,0x0
CALL 0x001010c0
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RDI,qword ptr [RBP + RBX*0x8 + 0x8]
MOV ESI,0x0
CALL 0x001010c0
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA R8,[0x102004]
MOV ECX,0x64
MOV EDX,0x1
MOV ESI,0x64
MOV RDI,R12
MOV EAX,0x2
CALL 0x001010b0
MOV EDX,0x3e8
MOV RSI,R12
MOV RDI,R14
CALL 0x001010a0
CMP R13D,EBX
JLE 0x00101245
MOV EDX,0x3e8
LEA RSI,[0x102011]
MOV RDI,R14
CALL 0x001010a0
JMP 0x00101245
LAB_001012cd:
MOV EDX,0x3e8
LEA RSI,[0x102014]
LEA RBX,[0x104040]
MOV RDI,RBX
CALL 0x001010a0
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010130d
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010130d:
CALL 0x001010d0 | int1 * func0(long param_1,int param_2)
{
long lVar1;
long in_FS_OFFSET;
double dVar2;
double dVar3;
int1 local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
if (0 < param_2) {
lVar1 = 0;
do {
dVar2 = strtod(*(char **)(param_1 + lVar1 * 8),(char **)0x0);
dVar3 = strtod(*(char **)(param_1 + 8 + lVar1 * 8),(char **)0x0);
__snprintf_chk(dVar2,dVar3,local_a8,100,1,100,"(%.2f, %.2f)");
__strcat_chk(res_1,local_a8,1000);
if ((int)lVar1 < param_2 + -2) {
__strcat_chk(res_1,&DAT_00102011,1000);
}
lVar1 = lVar1 + 2;
} while (lVar1 != (ulong)((param_2 - 1U >> 1) + 1) * 2);
}
__strcat_chk(res_1,&DAT_00102014,1000);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return res_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,362 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, second);
strcat(res, temp);
if (i < size - 2) {
strcat(res, ", ");
}
}
strcat(res, "]");
return res;
}
| int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == 0);
assert(strcmp(func0(list2, 8), "[(4.00, 4.00), (2.00, 27.00), (4.12, 9.00), (7.00, 11.00)]") == 0);
assert(strcmp(func0(list3, 8), "[(6.00, 78.00), (5.00, 26.45), (1.33, 4.00), (82.00, 13.00)]") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov $0x5b,%eax
mov %ax,0x2bcf(%rip)
test %esi,%esi
jle 1574 <func0+0x134>
lea -0x2(%rsi),%r14d
sub $0x1,%esi
mov %rdi,%rbx
xor %r15d,%r15d
shr %esi
lea 0x2bb1(%rip),%r12
lea 0x10(%rsp),%rbp
lea 0x2(%rsi,%rsi,1),%rax
mov %r12,%r13
mov %rax,0x8(%rsp)
nopl 0x0(%rax)
mov (%rbx,%r15,8),%rdi
xor %esi,%esi
callq 10d0 <strtod@plt>
mov 0x8(%rbx,%r15,8),%rdi
xor %esi,%esi
movsd %xmm0,(%rsp)
callq 10d0 <strtod@plt>
movsd (%rsp),%xmm2
mov %rbp,%rdi
lea 0xb33(%rip),%r8
movapd %xmm0,%xmm1
mov $0x64,%ecx
mov $0x1,%edx
mov $0x64,%esi
movapd %xmm2,%xmm0
mov $0x2,%eax
callq 10c0 <__snprintf_chk@plt>
lea 0x2b45(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 14fb <func0+0xbb>
mov %eax,%edx
mov %rbp,%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdi
sub %r12,%rdi
add %r13,%rdi
callq 1110 <__stpcpy_chk@plt>
mov %rax,%rdi
cmp %r15d,%r14d
jle 1565 <func0+0x125>
lea 0x2ed7(%rip),%rcx
mov $0x3,%edx
lea 0xab6(%rip),%rsi
sub %rax,%rcx
callq 1100 <__memcpy_chk@plt>
add $0x2,%r15
cmp 0x8(%rsp),%r15
jne 14a8 <func0+0x68>
mov $0x3e8,%edx
lea 0xa84(%rip),%rsi
lea 0x2ab9(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x78(%rsp),%rax
xor %fs:0x28,%rax
jne 15b5 <func0+0x175>
add $0x88,%rsp
lea 0x2a96(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10e0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov eax, 5Bh ; '['
mov cs:res_1, ax
test esi, esi
jle loc_15A0
lea r14d, [rsi-2]
sub esi, 1
mov rbx, rdi
xor r15d, r15d
shr esi, 1
lea r12, res_1
lea rbp, [rsp+0B8h+var_A8]
lea r13d, [rsi+1]
add r13, r13
nop dword ptr [rax+rax+00h]
loc_14D0:
mov rdi, [rbx+r15*8]
xor esi, esi
call _strtod
mov rdi, [rbx+r15*8+8]
xor esi, esi
movsd [rsp+0B8h+var_B0], xmm0
call _strtod
movsd xmm2, [rsp+0B8h+var_B0]
mov ecx, 64h ; 'd'
mov rdi, rbp
movapd xmm1, xmm0
mov edx, 1
mov esi, 64h ; 'd'
mov eax, 2
movapd xmm0, xmm2
lea r8, a2f2f; "(%.2f, %.2f)"
call ___snprintf_chk
mov rdi, r12
call _strlen
mov edx, 3E8h
mov rsi, rbp
lea rdi, [r12+rax]
call ___stpcpy_chk
mov rdi, rax
cmp r14d, r15d
jle short loc_155A
lea rcx, _end
mov edx, 3
lea rsi, asc_2013; ", "
sub rcx, rax
call ___memcpy_chk
loc_155A:
add r15, 2
cmp r15, r13
jnz loc_14D0
loc_1567:
mov edx, 3E8h
lea rsi, unk_2004
mov rdi, r12
call ___strcat_chk
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_15A9
add rsp, 88h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15A0:
lea r12, res_1
jmp short loc_1567
loc_15A9:
call ___stack_chk_fail | __int16 * func0(long long a1, int a2)
{
long long v2; // r15
double v3; // xmm1_8
long long v4; // rax
long long v5; // rax
double v7; // [rsp+8h] [rbp-B0h]
_BYTE v8[104]; // [rsp+10h] [rbp-A8h] BYREF
unsigned long long v9; // [rsp+78h] [rbp-40h]
v9 = __readfsqword(0x28u);
res_1[0] = 91;
if ( a2 > 0 )
{
v2 = 0LL;
do
{
v7 = strtod(*(_QWORD *)(a1 + 8 * v2), 0LL);
v3 = strtod(*(_QWORD *)(a1 + 8 * v2 + 8), 0LL);
__snprintf_chk(v8, 100LL, 1LL, 100LL, "(%.2f, %.2f)", v7, v3);
v4 = strlen(res_1);
v5 = __stpcpy_chk((char *)res_1 + v4, v8, 1000LL);
if ( a2 - 2 > (int)v2 )
__memcpy_chk(v5, ", ", 3LL, (char *)&end - v5);
v2 += 2LL;
}
while ( v2 != 2LL * (((unsigned int)(a2 - 1) >> 1) + 1) );
}
__strcat_chk(res_1, &unk_2004, 1000LL);
return res_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV EAX,0x5b
MOV word ptr [0x00104040],AX
TEST ESI,ESI
JLE 0x001015a0
LEA R14D,[RSI + -0x2]
SUB ESI,0x1
MOV RBX,RDI
XOR R15D,R15D
SHR ESI,0x1
LEA R12,[0x104040]
LEA RBP,[RSP + 0x10]
LEA R13D,[RSI + 0x1]
ADD R13,R13
NOP dword ptr [RAX + RAX*0x1]
LAB_001014d0:
MOV RDI,qword ptr [RBX + R15*0x8]
XOR ESI,ESI
CALL 0x001010f0
MOV RDI,qword ptr [RBX + R15*0x8 + 0x8]
XOR ESI,ESI
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x001010f0
MOVSD XMM2,qword ptr [RSP + 0x8]
MOV ECX,0x64
MOV RDI,RBP
MOVAPD XMM1,XMM0
MOV EDX,0x1
MOV ESI,0x64
MOV EAX,0x2
MOVAPD XMM0,XMM2
LEA R8,[0x102006]
CALL 0x001010e0
MOV RDI,R12
CALL 0x00101100
MOV EDX,0x3e8
MOV RSI,RBP
LEA RDI,[R12 + RAX*0x1]
CALL 0x00101150
MOV RDI,RAX
CMP R14D,R15D
JLE 0x0010155a
LEA RCX,[0x104428]
MOV EDX,0x3
LEA RSI,[0x102013]
SUB RCX,RAX
CALL 0x00101140
LAB_0010155a:
ADD R15,0x2
CMP R15,R13
JNZ 0x001014d0
LAB_00101567:
MOV EDX,0x3e8
LEA RSI,[0x102004]
MOV RDI,R12
CALL 0x001010d0
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001015a9
ADD RSP,0x88
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015a0:
LEA R12,[0x104040]
JMP 0x00101567
LAB_001015a9:
CALL 0x00101110 | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
double dVar4;
double dVar5;
int1 local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
if (0 < param_2) {
lVar3 = 0;
do {
dVar4 = strtod(*(char **)(param_1 + lVar3 * 8),(char **)0x0);
dVar5 = strtod(*(char **)(param_1 + 8 + lVar3 * 8),(char **)0x0);
__snprintf_chk(dVar4,dVar5,local_a8,100,1,100,"(%.2f, %.2f)");
sVar1 = strlen(res_1);
lVar2 = __stpcpy_chk(res_1 + sVar1,local_a8,1000);
if ((int)lVar3 < param_2 + -2) {
__memcpy_chk(lVar2,&DAT_00102013,3,(long)&_end - lVar2);
}
lVar3 = lVar3 + 2;
} while (lVar3 != (ulong)((param_2 - 1U >> 1) + 1) * 2);
}
__strcat_chk(res_1,&DAT_00102004,1000);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
4,363 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, second);
strcat(res, temp);
if (i < size - 2) {
strcat(res, ", ");
}
}
strcat(res, "]");
return res;
}
| int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == 0);
assert(strcmp(func0(list2, 8), "[(4.00, 4.00), (2.00, 27.00), (4.12, 9.00), (7.00, 11.00)]") == 0);
assert(strcmp(func0(list3, 8), "[(6.00, 78.00), (5.00, 26.45), (1.33, 4.00), (82.00, 13.00)]") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov $0x5b,%eax
mov %ax,0x2b8f(%rip)
test %esi,%esi
jle 1620 <func0+0x1a0>
lea -0x2(%rsi),%r15d
mov %rdi,%r13
mov %esi,%r14d
test %r15d,%r15d
jle 1668 <func0+0x1e8>
mov %rdi,%rbp
xor %ebx,%ebx
lea 0x10(%rsp),%r12
nopw %cs:0x0(%rax,%rax,1)
mov 0x0(%rbp),%rdi
xor %esi,%esi
callq 10d0 <strtod@plt>
mov 0x8(%rbp),%rdi
xor %esi,%esi
movsd %xmm0,0x8(%rsp)
callq 10d0 <strtod@plt>
movsd 0x8(%rsp),%xmm2
mov %r12,%rdi
lea 0xafa(%rip),%r8
movapd %xmm0,%xmm1
mov $0x64,%ecx
mov $0x1,%edx
mov $0x64,%esi
movapd %xmm2,%xmm0
mov $0x2,%eax
callq 10c0 <__snprintf_chk@plt>
lea 0x2b0c(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1534 <func0+0xb4>
mov %eax,%edx
mov %r12,%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdi
add $0x2,%ebx
add $0x10,%rbp
callq 1110 <__stpcpy_chk@plt>
lea 0x2ea5(%rip),%rcx
mov $0x3,%edx
lea 0xa84(%rip),%rsi
mov %rax,%rdi
sub %rax,%rcx
callq 1100 <__memcpy_chk@plt>
cmp %r15d,%ebx
jl 14e0 <func0+0x60>
cmp %ebx,%r14d
jle 1620 <func0+0x1a0>
movslq %ebx,%rbx
lea 0xa54(%rip),%rbp
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13,%rbx,8),%rdi
xor %esi,%esi
callq 10d0 <strtod@plt>
mov 0x8(%r13,%rbx,8),%rdi
xor %esi,%esi
add $0x2,%rbx
movsd %xmm0,0x8(%rsp)
callq 10d0 <strtod@plt>
mov %rbp,%r8
mov $0x64,%ecx
mov %r12,%rdi
movsd 0x8(%rsp),%xmm2
movapd %xmm0,%xmm1
mov $0x1,%edx
mov $0x64,%esi
mov $0x2,%eax
movapd %xmm2,%xmm0
callq 10c0 <__snprintf_chk@plt>
mov $0x3e8,%edx
mov %r12,%rsi
lea 0x2a2a(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
cmp %ebx,%r14d
jg 15b8 <func0+0x138>
mov $0x3e8,%edx
lea 0x9d8(%rip),%rsi
lea 0x2a0d(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x78(%rsp),%rax
xor %fs:0x28,%rax
jne 1674 <func0+0x1f4>
add $0x88,%rsp
lea 0x29ea(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
xor %ebx,%ebx
lea 0x10(%rsp),%r12
jmpq 15a8 <func0+0x128>
callq 10e0 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
mov eax, 5Bh ; '['
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rdx, fs:28h
mov [rsp+0B8h+var_40], rdx
xor edx, edx
mov cs:res_1, ax
test esi, esi
jle loc_1678
lea edx, [rsi-2]
mov r12, rdi
mov r14d, esi
test edx, edx
jg loc_15B0
xor r13d, r13d
lea rbp, res_1
lea rbx, [rsp+0B8h+var_A8]
loc_1509:
lea r15, a2f2f; "(%.2f, %.2f)"
loc_1510:
mov rdi, [r12+r13*8]; nptr
xor esi, esi; endptr
call _strtod
mov rdi, [r12+r13*8+8]; nptr
xor esi, esi; endptr
add r13, 2
movsd [rsp+0B8h+var_B8], xmm0
call _strtod
mov r8, r15
mov ecx, 64h ; 'd'
mov rdi, rbx
movapd xmm1, xmm0
movsd xmm0, [rsp+0B8h+var_B8]
mov edx, 2
mov esi, 64h ; 'd'
mov eax, 2
call ___snprintf_chk
mov edx, 3E8h
mov rsi, rbx
mov rdi, rbp
call ___strcat_chk
cmp r14d, r13d
jg short loc_1510
loc_156D:
mov edx, 3E8h
lea rsi, unk_2004
mov rdi, rbp
call ___strcat_chk
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz loc_1684
add rsp, 88h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B0:
mov [rsp+0B8h+var_B0], rdi
xor r13d, r13d
lea rbx, [rsp+0B8h+var_A8]
mov r15d, edx
mov r12d, r13d
lea rbp, res_1
mov r13, rdi
loc_15CD:
mov rdi, [r13+0]; nptr
xor esi, esi; endptr
add r12d, 2
add r13, 10h
call _strtod
mov rdi, [r13-8]; nptr
xor esi, esi; endptr
movsd [rsp+0B8h+var_B8], xmm0
call _strtod
lea r8, a2f2f; "(%.2f, %.2f)"
mov ecx, 64h ; 'd'
mov rdi, rbx
movapd xmm1, xmm0
movsd xmm0, [rsp+0B8h+var_B8]
mov edx, 2
mov esi, 64h ; 'd'
mov eax, 2
call ___snprintf_chk
mov rdi, rbp; s
call _strlen
mov edx, 3E8h
mov rsi, rbx
lea rdi, [rbp+rax+0]
call ___stpcpy_chk
lea rcx, _end
mov edx, 3
lea rsi, asc_2013; ", "
mov rdi, rax
sub rcx, rax
call ___memcpy_chk
cmp r12d, r15d
jl loc_15CD
movsxd r13, r12d
mov r12, [rsp+0B8h+var_B0]
cmp r14d, r13d
jg loc_1509
jmp loc_156D
loc_1678:
lea rbp, res_1
jmp loc_156D
loc_1684:
call ___stack_chk_fail | char * func0(const char **a1, int a2)
{
const char **v2; // r12
long long v3; // r13
double v4; // xmm0_8
const char *v5; // rdi
double v6; // xmm1_8
int v8; // r12d
const char **v9; // r13
const char *v10; // rdi
double v11; // xmm1_8
size_t v12; // rax
long long v13; // rax
double v14; // [rsp+0h] [rbp-B8h]
double v15; // [rsp+0h] [rbp-B8h]
_BYTE v17[104]; // [rsp+10h] [rbp-A8h] BYREF
unsigned long long v18; // [rsp+78h] [rbp-40h]
v18 = __readfsqword(0x28u);
strcpy(res_1, "[");
if ( a2 > 0 )
{
v2 = a1;
if ( a2 - 2 <= 0 )
{
v3 = 0LL;
do
{
LABEL_4:
v4 = strtod(v2[v3], 0LL);
v5 = v2[v3 + 1];
v3 += 2LL;
v14 = v4;
v6 = strtod(v5, 0LL);
__snprintf_chk(v17, 100LL, 2LL, 100LL, "(%.2f, %.2f)", v14, v6);
__strcat_chk(res_1, v17, 1000LL);
}
while ( a2 > (int)v3 );
goto LABEL_5;
}
v8 = 0;
v9 = a1;
do
{
v10 = *v9;
v8 += 2;
v9 += 2;
v15 = strtod(v10, 0LL);
v11 = strtod(*(v9 - 1), 0LL);
__snprintf_chk(v17, 100LL, 2LL, 100LL, "(%.2f, %.2f)", v15, v11);
v12 = strlen(res_1);
v13 = __stpcpy_chk(&res_1[v12], v17, 1000LL);
__memcpy_chk(v13, ", ", 3LL, (char *)&end - v13);
}
while ( v8 < a2 - 2 );
v3 = v8;
v2 = a1;
if ( a2 > (int)v3 )
goto LABEL_4;
}
LABEL_5:
__strcat_chk(res_1, &unk_2004, 1000LL);
return res_1;
} | func0:
ENDBR64
PUSH R15
MOV EAX,0x5b
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RDX
XOR EDX,EDX
MOV word ptr [0x00104040],AX
TEST ESI,ESI
JLE 0x00101678
LEA EDX,[RSI + -0x2]
MOV R12,RDI
MOV R14D,ESI
TEST EDX,EDX
JG 0x001015b0
XOR R13D,R13D
LEA RBP,[0x104040]
LEA RBX,[RSP + 0x10]
LAB_00101509:
LEA R15,[0x102006]
LAB_00101510:
MOV RDI,qword ptr [R12 + R13*0x8]
XOR ESI,ESI
CALL 0x001010f0
MOV RDI,qword ptr [R12 + R13*0x8 + 0x8]
XOR ESI,ESI
ADD R13,0x2
MOVSD qword ptr [RSP],XMM0
CALL 0x001010f0
MOV R8,R15
MOV ECX,0x64
MOV RDI,RBX
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RSP]
MOV EDX,0x2
MOV ESI,0x64
MOV EAX,0x2
CALL 0x001010e0
MOV EDX,0x3e8
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
CMP R14D,R13D
JG 0x00101510
LAB_0010156d:
MOV EDX,0x3e8
LEA RSI,[0x102004]
MOV RDI,RBP
CALL 0x001010d0
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101684
ADD RSP,0x88
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b0:
MOV qword ptr [RSP + 0x8],RDI
XOR R13D,R13D
LEA RBX,[RSP + 0x10]
MOV R15D,EDX
MOV R12D,R13D
LEA RBP,[0x104040]
MOV R13,RDI
LAB_001015cd:
MOV RDI,qword ptr [R13]
XOR ESI,ESI
ADD R12D,0x2
ADD R13,0x10
CALL 0x001010f0
MOV RDI,qword ptr [R13 + -0x8]
XOR ESI,ESI
MOVSD qword ptr [RSP],XMM0
CALL 0x001010f0
LEA R8,[0x102006]
MOV ECX,0x64
MOV RDI,RBX
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RSP]
MOV EDX,0x2
MOV ESI,0x64
MOV EAX,0x2
CALL 0x001010e0
MOV RDI,RBP
CALL 0x00101100
MOV EDX,0x3e8
MOV RSI,RBX
LEA RDI,[RBP + RAX*0x1]
CALL 0x00101150
LEA RCX,[0x104428]
MOV EDX,0x3
LEA RSI,[0x102013]
MOV RDI,RAX
SUB RCX,RAX
CALL 0x00101140
CMP R12D,R15D
JL 0x001015cd
MOVSXD R13,R12D
MOV R12,qword ptr [RSP + 0x8]
CMP R14D,R13D
JG 0x00101509
JMP 0x0010156d
LAB_00101678:
LEA RBP,[0x104040]
JMP 0x0010156d
LAB_00101684:
CALL 0x00101110 | int1 * func0(int8 *param_1,int param_2)
{
long lVar1;
size_t sVar2;
int iVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
double dVar6;
double dVar7;
int local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
if (0 < param_2) {
if (param_2 + -2 < 1) {
lVar4 = 0;
}
else {
iVar3 = 0;
puVar5 = param_1;
do {
iVar3 = iVar3 + 2;
dVar6 = strtod((char *)*puVar5,(char **)0x0);
dVar7 = strtod((char *)puVar5[1],(char **)0x0);
__snprintf_chk(dVar6,dVar7,local_a8,100,2,100,"(%.2f, %.2f)");
sVar2 = strlen(res_1);
lVar4 = __stpcpy_chk(res_1 + sVar2,local_a8,1000);
__memcpy_chk(lVar4,&DAT_00102013,3,(long)&_end - lVar4);
puVar5 = puVar5 + 2;
} while (iVar3 < param_2 + -2);
lVar4 = (long)iVar3;
if (param_2 <= iVar3) goto LAB_0010156d;
}
do {
dVar6 = strtod((char *)param_1[lVar4],(char **)0x0);
lVar1 = lVar4 + 1;
lVar4 = lVar4 + 2;
dVar7 = strtod((char *)param_1[lVar1],(char **)0x0);
__snprintf_chk(dVar6,dVar7,local_a8,100,2,100,"(%.2f, %.2f)");
__strcat_chk(res_1,local_a8,1000);
} while ((int)lVar4 < param_2);
}
LAB_0010156d:
__strcat_chk(res_1,&DAT_00102004,1000);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
4,364 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((count + 1) * sizeof(char*));
if (!list) {
return NULL;
}
// Duplicate the input string to use with strtok
char* str = strdup(string);
if (!str) {
free(list);
return NULL;
}
// Split the string by spaces
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
list[index++] = strdup(token);
token = strtok(NULL, " ");
}
list[index] = NULL;
free(str);
return list;
}
| int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Second test case
char** result2 = func0("lists tuples strings");
assert(strcmp(result2[0], "lists") == 0);
assert(strcmp(result2[1], "tuples") == 0);
assert(strcmp(result2[2], "strings") == 0);
assert(result2[3] == NULL);
// Free memory
free(result2[0]);
free(result2[1]);
free(result2[2]);
free(result2);
// Third test case
char** result3 = func0("write a program");
assert(strcmp(result3[0], "write") == 0);
assert(strcmp(result3[1], "a") == 0);
assert(strcmp(result3[2], "program") == 0);
assert(result3[3] == NULL);
// Free memory
free(result3[0]);
free(result3[1]);
free(result3[2]);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
movl $0x1,-0x38(%rbp)
mov -0x48(%rbp),%rax
mov %rax,-0x30(%rbp)
jmp 121f <func0+0x36>
mov -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 121a <func0+0x31>
addl $0x1,-0x38(%rbp)
addq $0x1,-0x30(%rbp)
mov -0x30(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 120b <func0+0x22>
mov -0x38(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x20(%rbp)
cmpq $0x0,-0x20(%rbp)
jne 1253 <func0+0x6a>
mov $0x0,%eax
jmpq 1311 <func0+0x128>
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 1280 <func0+0x97>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov $0x0,%eax
jmpq 1311 <func0+0x128>
movl $0x0,-0x34(%rbp)
mov -0x18(%rbp),%rax
lea 0xd76(%rip),%rsi
mov %rax,%rdi
callq 10e0 <strtok@plt>
mov %rax,-0x28(%rbp)
jmp 12df <func0+0xf6>
mov -0x34(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x34(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,(%rbx)
lea 0xd37(%rip),%rsi
mov $0x0,%edi
callq 10e0 <strtok@plt>
mov %rax,-0x28(%rbp)
cmpq $0x0,-0x28(%rbp)
jne 12a0 <func0+0xb7>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movq $0x0,(%rax)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x20(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+s], rdi
mov [rbp+var_38], 1
mov rax, [rbp+s]
mov [rbp+var_30], rax
jmp short loc_121F
loc_120B:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_121A
add [rbp+var_38], 1
loc_121A:
add [rbp+var_30], 1
loc_121F:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_120B
mov eax, [rbp+var_38]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
cmp [rbp+ptr], 0
jnz short loc_1253
mov eax, 0
jmp loc_1317
loc_1253:
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_1280
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, 0
jmp loc_1317
loc_1280:
mov [rbp+var_34], 0
mov rax, [rbp+var_18]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_28], rax
jmp short loc_12E5
loc_12A3:
mov eax, [rbp+var_34]
lea edx, [rax+1]
mov [rbp+var_34], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
lea rbx, [rdx+rax]
mov rax, [rbp+var_28]
mov rdi, rax; s
call _strdup
mov [rbx], rax
lea rax, delim; " "
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+var_28], rax
loc_12E5:
cmp [rbp+var_28], 0
jnz short loc_12A3
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov qword ptr [rax], 0
mov rax, [rbp+var_18]
mov rdi, rax; ptr
call _free
mov rax, [rbp+ptr]
loc_1317:
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(const char *a1)
{
int v2; // eax
int v3; // [rsp+18h] [rbp-38h]
int v4; // [rsp+1Ch] [rbp-34h]
const char *i; // [rsp+20h] [rbp-30h]
const char *j; // [rsp+28h] [rbp-28h]
_QWORD *ptr; // [rsp+30h] [rbp-20h]
char *v8; // [rsp+38h] [rbp-18h]
v3 = 1;
for ( i = a1; *i; ++i )
{
if ( *i == 32 )
++v3;
}
ptr = malloc(8LL * (v3 + 1));
if ( !ptr )
return 0LL;
v8 = strdup(a1);
if ( v8 )
{
v4 = 0;
for ( j = strtok(v8, " "); j; j = strtok(0LL, " ") )
{
v2 = v4++;
ptr[v2] = strdup(j);
}
ptr[v4] = 0LL;
free(v8);
return ptr;
}
else
{
free(ptr);
return 0LL;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x38],0x1
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0010121f
LAB_0010120b:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x0010121a
ADD dword ptr [RBP + -0x38],0x1
LAB_0010121a:
ADD qword ptr [RBP + -0x30],0x1
LAB_0010121f:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010120b
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00101253
MOV EAX,0x0
JMP 0x00101317
LAB_00101253:
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00101280
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,0x0
JMP 0x00101317
LAB_00101280:
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001012e5
LAB_001012a3:
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x34],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBX],RAX
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x001010e0
MOV qword ptr [RBP + -0x28],RAX
LAB_001012e5:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001012a3
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x20]
LAB_00101317:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(char *param_1)
{
void *__ptr;
char *__s;
char *pcVar1;
int local_40;
int local_3c;
char *local_38;
char *local_30;
local_40 = 1;
for (local_38 = param_1; *local_38 != '\0'; local_38 = local_38 + 1) {
if (*local_38 == ' ') {
local_40 = local_40 + 1;
}
}
__ptr = malloc((long)(local_40 + 1) << 3);
if (__ptr == (void *)0x0) {
__ptr = (void *)0x0;
}
else {
__s = strdup(param_1);
if (__s == (char *)0x0) {
free(__ptr);
__ptr = (void *)0x0;
}
else {
local_3c = 0;
local_30 = strtok(__s," ");
while (local_30 != (char *)0x0) {
pcVar1 = strdup(local_30);
*(char **)((long)local_3c * 8 + (long)__ptr) = pcVar1;
local_30 = strtok((char *)0x0," ");
local_3c = local_3c + 1;
}
*(int8 *)((long)__ptr + (long)local_3c * 8) = 0;
free(__s);
}
}
return __ptr;
} |
4,365 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((count + 1) * sizeof(char*));
if (!list) {
return NULL;
}
// Duplicate the input string to use with strtok
char* str = strdup(string);
if (!str) {
free(list);
return NULL;
}
// Split the string by spaces
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
list[index++] = strdup(token);
token = strtok(NULL, " ");
}
list[index] = NULL;
free(str);
return list;
}
| int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Second test case
char** result2 = func0("lists tuples strings");
assert(strcmp(result2[0], "lists") == 0);
assert(strcmp(result2[1], "tuples") == 0);
assert(strcmp(result2[2], "strings") == 0);
assert(result2[3] == NULL);
// Free memory
free(result2[0]);
free(result2[1]);
free(result2[2]);
free(result2);
// Third test case
char** result3 = func0("write a program");
assert(strcmp(result3[0], "write") == 0);
assert(strcmp(result3[1], "a") == 0);
assert(strcmp(result3[2], "program") == 0);
assert(result3[3] == NULL);
// Free memory
free(result3[0]);
free(result3[1]);
free(result3[2]);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movzbl (%rdi),%eax
test %al,%al
je 1290 <func0+0xc7>
mov %rdi,%rdx
mov $0x1,%ecx
cmp $0x20,%al
sete %al
movzbl %al,%eax
add %eax,%ecx
add $0x1,%rdx
movzbl (%rdx),%eax
test %al,%al
jne 11eb <func0+0x22>
lea 0x1(%rcx),%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbp
test %rax,%rax
je 1284 <func0+0xbb>
mov %rbx,%rdi
callq 10d0 <strdup@plt>
mov %rax,%r14
test %rax,%rax
je 129a <func0+0xd1>
lea 0xdd6(%rip),%rsi
mov %rax,%rdi
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 12a7 <func0+0xde>
mov $0x1,%ebx
lea 0xdba(%rip),%r13
mov %ebx,%r12d
callq 10d0 <strdup@plt>
mov %rax,-0x8(%rbp,%rbx,8)
mov %r13,%rsi
mov $0x0,%edi
callq 10c0 <strtok@plt>
mov %rax,%rdi
add $0x1,%rbx
test %rax,%rax
jne 124a <func0+0x81>
movslq %r12d,%r12
movq $0x0,0x0(%rbp,%r12,8)
mov %r14,%rdi
callq 1090 <free@plt>
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x1,%ecx
jmpq 1200 <func0+0x37>
mov %rbp,%rdi
callq 1090 <free@plt>
mov %r14,%rbp
jmp 1284 <func0+0xbb>
mov $0x0,%r12d
jmp 1270 <func0+0xa7>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
movzx eax, byte ptr [rdi]
test al, al
jz loc_12B0
mov rdx, rdi
mov ecx, 1
loc_120B:
cmp al, 20h ; ' '
setz al
movzx eax, al
add ecx, eax
add rdx, 1
movzx eax, byte ptr [rdx]
test al, al
jnz short loc_120B
loc_1220:
lea edi, [rcx+1]
movsxd rdi, edi
shl rdi, 3
call _malloc
mov rbp, rax
test rax, rax
jz short loc_12A4
mov rdi, rbx
call _strdup
mov r14, rax
test rax, rax
jz short loc_12BA
lea rsi, unk_2004
mov rdi, rax
call _strtok
mov rdi, rax
test rax, rax
jz short loc_12C7
mov ebx, 1
lea r13, unk_2004
loc_126A:
mov r12d, ebx
call _strdup
mov [rbp+rbx*8-8], rax
mov rsi, r13
mov edi, 0
call _strtok
mov rdi, rax
add rbx, 1
test rax, rax
jnz short loc_126A
loc_1290:
movsxd r12, r12d
mov qword ptr [rbp+r12*8+0], 0
mov rdi, r14
call _free
loc_12A4:
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12B0:
mov ecx, 1
jmp loc_1220
loc_12BA:
mov rdi, rbp
call _free
mov rbp, r14
jmp short loc_12A4
loc_12C7:
mov r12d, 0
jmp short loc_1290 | long long func0(_BYTE *a1)
{
char v1; // al
_BYTE *v2; // rdx
int v3; // ecx
long long v4; // rbp
long long v5; // rax
long long v6; // r14
long long v7; // rdi
long long v8; // rbx
int v9; // r12d
v1 = *a1;
if ( *a1 )
{
v2 = a1;
v3 = 1;
do
{
v3 += v1 == 32;
v1 = *++v2;
}
while ( *v2 );
}
else
{
v3 = 1;
}
v4 = malloc(8LL * (v3 + 1));
if ( v4 )
{
v5 = strdup(a1);
v6 = v5;
if ( v5 )
{
v7 = strtok(v5, &unk_2004);
if ( v7 )
{
v8 = 1LL;
do
{
v9 = v8;
*(_QWORD *)(v4 + 8 * v8 - 8) = strdup(v7);
v7 = strtok(0LL, &unk_2004);
++v8;
}
while ( v7 );
}
else
{
v9 = 0;
}
*(_QWORD *)(v4 + 8LL * v9) = 0LL;
free(v6);
}
else
{
free(v4);
return 0LL;
}
}
return v4;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001012b0
MOV RDX,RDI
MOV ECX,0x1
LAB_0010120b:
CMP AL,0x20
SETZ AL
MOVZX EAX,AL
ADD ECX,EAX
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x0010120b
LAB_00101220:
LEA EDI,[RCX + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x001010d0
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001012a4
MOV RDI,RBX
CALL 0x001010f0
MOV R14,RAX
TEST RAX,RAX
JZ 0x001012ba
LEA RSI,[0x102004]
MOV RDI,RAX
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001012c7
MOV EBX,0x1
LEA R13,[0x102004]
LAB_0010126a:
MOV R12D,EBX
CALL 0x001010f0
MOV qword ptr [RBP + RBX*0x8 + -0x8],RAX
MOV RSI,R13
MOV EDI,0x0
CALL 0x001010e0
MOV RDI,RAX
ADD RBX,0x1
TEST RAX,RAX
JNZ 0x0010126a
LAB_00101290:
MOVSXD R12,R12D
MOV qword ptr [RBP + R12*0x8],0x0
MOV RDI,R14
CALL 0x001010a0
LAB_001012a4:
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012b0:
MOV ECX,0x1
JMP 0x00101220
LAB_001012ba:
MOV RDI,RBP
CALL 0x001010a0
MOV RBP,R14
JMP 0x001012a4
LAB_001012c7:
MOV R12D,0x0
JMP 0x00101290 | void * func0(char *param_1)
{
char cVar1;
void *__ptr;
char *pcVar2;
int iVar3;
char *pcVar4;
long lVar5;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar3 = 1;
}
else {
iVar3 = 1;
pcVar4 = param_1;
do {
iVar3 = iVar3 + (uint)(cVar1 == ' ');
pcVar4 = pcVar4 + 1;
cVar1 = *pcVar4;
} while (cVar1 != '\0');
}
__ptr = malloc((long)(iVar3 + 1) << 3);
if (__ptr != (void *)0x0) {
pcVar4 = strdup(param_1);
if (pcVar4 == (char *)0x0) {
free(__ptr);
__ptr = (void *)0x0;
}
else {
pcVar2 = strtok(pcVar4," ");
if (pcVar2 == (char *)0x0) {
iVar3 = 0;
}
else {
lVar5 = 1;
do {
iVar3 = (int)lVar5;
pcVar2 = strdup(pcVar2);
*(char **)((long)__ptr + lVar5 * 8 + -8) = pcVar2;
pcVar2 = strtok((char *)0x0," ");
lVar5 = lVar5 + 1;
} while (pcVar2 != (char *)0x0);
}
*(int8 *)((long)__ptr + (long)iVar3 * 8) = 0;
free(pcVar4);
}
}
return __ptr;
} |
4,366 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((count + 1) * sizeof(char*));
if (!list) {
return NULL;
}
// Duplicate the input string to use with strtok
char* str = strdup(string);
if (!str) {
free(list);
return NULL;
}
// Split the string by spaces
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
list[index++] = strdup(token);
token = strtok(NULL, " ");
}
list[index] = NULL;
free(str);
return list;
}
| int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Second test case
char** result2 = func0("lists tuples strings");
assert(strcmp(result2[0], "lists") == 0);
assert(strcmp(result2[1], "tuples") == 0);
assert(strcmp(result2[2], "strings") == 0);
assert(result2[3] == NULL);
// Free memory
free(result2[0]);
free(result2[1]);
free(result2[2]);
free(result2);
// Third test case
char** result3 = func0("write a program");
assert(strcmp(result3[0], "write") == 0);
assert(strcmp(result3[1], "a") == 0);
assert(strcmp(result3[2], "program") == 0);
assert(result3[3] == NULL);
// Free memory
free(result3[0]);
free(result3[1]);
free(result3[2]);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
movzbl (%rdi),%eax
test %al,%al
je 15a8 <func0+0xd8>
mov %rdi,%rdx
mov $0x1,%ecx
nopw 0x0(%rax,%rax,1)
lea 0x1(%rcx),%edi
cmp $0x20,%al
jne 1506 <func0+0x36>
lea 0x2(%rcx),%eax
mov %edi,%ecx
mov %eax,%edi
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 14f8 <func0+0x28>
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1596 <func0+0xc6>
mov %rbp,%rdi
callq 10d0 <strdup@plt>
mov %rax,%r14
test %rax,%rax
je 15bd <func0+0xed>
mov %rax,%rdi
lea 0xac0(%rip),%rsi
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 15b8 <func0+0xe8>
mov $0x1,%ebx
lea 0xaa7(%rip),%r13
nopl (%rax)
callq 10d0 <strdup@plt>
xor %edi,%edi
mov %r13,%rsi
movslq %ebx,%rbp
mov %rax,-0x8(%r12,%rbx,8)
add $0x1,%rbx
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
jne 1560 <func0+0x90>
lea (%r12,%rbp,8),%rax
movq $0x0,(%rax)
mov %r14,%rdi
callq 1090 <free@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
mov $0x10,%edi
jmpq 1519 <func0+0x49>
nopw 0x0(%rax,%rax,1)
mov %r12,%rax
jmp 1587 <func0+0xb7>
mov %r12,%rdi
xor %r12d,%r12d
callq 1090 <free@plt>
jmp 1596 <func0+0xc6>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
movzx eax, byte ptr [rdi]
test al, al
jz loc_1598
mov rdx, rdi
mov ecx, 1
nop word ptr [rax+rax+00h]
loc_14E8:
cmp al, 20h ; ' '
setz al
add rdx, 1
movzx eax, al
add ecx, eax
movzx eax, byte ptr [rdx]
test al, al
jnz short loc_14E8
lea edi, [rcx+1]
movsxd rdi, edi
shl rdi, 3
loc_1507:
call _malloc
mov r12, rax
test rax, rax
jz short loc_1586
mov rdi, rbp
call _strdup
mov r14, rax
test rax, rax
jz loc_15AD
lea r13, unk_2004
mov rdi, rax
mov rsi, r13
call _strtok
mov rdi, rax
test rax, rax
jz short loc_15A8
mov ebx, 1
nop word ptr [rax+rax+00000000h]
loc_1550:
call _strdup
xor edi, edi
mov rsi, r13
movsxd rbp, ebx
mov [r12+rbx*8-8], rax
add rbx, 1
call _strtok
mov rdi, rax
test rax, rax
jnz short loc_1550
lea rax, [r12+rbp*8]
loc_1577:
mov qword ptr [rax], 0
mov rdi, r14
call _free
loc_1586:
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
pop r14
retn
loc_1598:
mov edi, 10h
jmp loc_1507
loc_15A8:
mov rax, r12
jmp short loc_1577
loc_15AD:
mov rdi, r12
xor r12d, r12d
call _free
jmp short loc_1586 | long long func0(char *a1)
{
char v2; // al
char *v3; // rdx
int v4; // ecx
long long v5; // rdi
long long v6; // r12
long long v7; // rax
long long v8; // r14
long long v9; // rdi
long long v10; // rbx
long long v11; // rbp
_QWORD *v12; // rax
long long v14; // rdi
v2 = *a1;
if ( *a1 )
{
v3 = a1;
v4 = 1;
do
{
++v3;
v4 += v2 == 32;
v2 = *v3;
}
while ( *v3 );
v5 = 8LL * (v4 + 1);
}
else
{
v5 = 16LL;
}
v6 = malloc(v5);
if ( v6 )
{
v7 = strdup(a1);
v8 = v7;
if ( v7 )
{
v9 = strtok(v7, &unk_2004);
if ( v9 )
{
v10 = 1LL;
do
{
v11 = (int)v10;
*(_QWORD *)(v6 + 8 * v10++ - 8) = strdup(v9);
v9 = strtok(0LL, &unk_2004);
}
while ( v9 );
v12 = (_QWORD *)(v6 + 8 * v11);
}
else
{
v12 = (_QWORD *)v6;
}
*v12 = 0LL;
free(v8);
}
else
{
v14 = v6;
v6 = 0LL;
free(v14);
}
}
return v6;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101598
MOV RDX,RDI
MOV ECX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001014e8:
CMP AL,0x20
SETZ AL
ADD RDX,0x1
MOVZX EAX,AL
ADD ECX,EAX
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x001014e8
LEA EDI,[RCX + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
LAB_00101507:
CALL 0x001010d0
MOV R12,RAX
TEST RAX,RAX
JZ 0x00101586
MOV RDI,RBP
CALL 0x001010f0
MOV R14,RAX
TEST RAX,RAX
JZ 0x001015ad
LEA R13,[0x102004]
MOV RDI,RAX
MOV RSI,R13
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001015a8
MOV EBX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101550:
CALL 0x001010f0
XOR EDI,EDI
MOV RSI,R13
MOVSXD RBP,EBX
MOV qword ptr [R12 + RBX*0x8 + -0x8],RAX
ADD RBX,0x1
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JNZ 0x00101550
LEA RAX,[R12 + RBP*0x8]
LAB_00101577:
MOV qword ptr [RAX],0x0
MOV RDI,R14
CALL 0x001010a0
LAB_00101586:
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101598:
MOV EDI,0x10
JMP 0x00101507
LAB_001015a8:
MOV RAX,R12
JMP 0x00101577
LAB_001015ad:
MOV RDI,R12
XOR R12D,R12D
CALL 0x001010a0
JMP 0x00101586 | int8 * func0(char *param_1)
{
char cVar1;
int8 *puVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
long lVar6;
size_t __size;
int8 *puVar7;
cVar1 = *param_1;
if (cVar1 == '\0') {
__size = 0x10;
}
else {
iVar4 = 1;
pcVar5 = param_1;
do {
pcVar5 = pcVar5 + 1;
iVar4 = iVar4 + (uint)(cVar1 == ' ');
cVar1 = *pcVar5;
} while (cVar1 != '\0');
__size = (long)(iVar4 + 1) << 3;
}
puVar2 = (int8 *)malloc(__size);
puVar7 = puVar2;
if (puVar2 != (int8 *)0x0) {
pcVar5 = strdup(param_1);
if (pcVar5 == (char *)0x0) {
puVar7 = (int8 *)0x0;
free(puVar2);
}
else {
pcVar3 = strtok(pcVar5," ");
if (pcVar3 != (char *)0x0) {
lVar6 = 1;
do {
pcVar3 = strdup(pcVar3);
iVar4 = (int)lVar6;
puVar2[lVar6 + -1] = pcVar3;
lVar6 = lVar6 + 1;
pcVar3 = strtok((char *)0x0," ");
} while (pcVar3 != (char *)0x0);
puVar2 = puVar2 + iVar4;
}
*puVar2 = 0;
free(pcVar5);
}
}
return puVar7;
} |
4,367 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((count + 1) * sizeof(char*));
if (!list) {
return NULL;
}
// Duplicate the input string to use with strtok
char* str = strdup(string);
if (!str) {
free(list);
return NULL;
}
// Split the string by spaces
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
list[index++] = strdup(token);
token = strtok(NULL, " ");
}
list[index] = NULL;
free(str);
return list;
}
| int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Second test case
char** result2 = func0("lists tuples strings");
assert(strcmp(result2[0], "lists") == 0);
assert(strcmp(result2[1], "tuples") == 0);
assert(strcmp(result2[2], "strings") == 0);
assert(result2[3] == NULL);
// Free memory
free(result2[0]);
free(result2[1]);
free(result2[2]);
free(result2);
// Third test case
char** result3 = func0("write a program");
assert(strcmp(result3[0], "write") == 0);
assert(strcmp(result3[1], "a") == 0);
assert(strcmp(result3[2], "program") == 0);
assert(result3[3] == NULL);
// Free memory
free(result3[0]);
free(result3[1]);
free(result3[2]);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
movzbl (%rdi),%eax
test %al,%al
je 15a8 <func0+0xd8>
mov %rdi,%rdx
mov $0x1,%ecx
nopw 0x0(%rax,%rax,1)
lea 0x1(%rcx),%edi
cmp $0x20,%al
jne 1506 <func0+0x36>
lea 0x2(%rcx),%eax
mov %edi,%ecx
mov %eax,%edi
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 14f8 <func0+0x28>
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1596 <func0+0xc6>
mov %rbp,%rdi
callq 10d0 <strdup@plt>
mov %rax,%r14
test %rax,%rax
je 15bd <func0+0xed>
mov %rax,%rdi
lea 0xac0(%rip),%rsi
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 15b8 <func0+0xe8>
mov $0x1,%ebx
lea 0xaa7(%rip),%r13
nopl (%rax)
callq 10d0 <strdup@plt>
xor %edi,%edi
mov %r13,%rsi
movslq %ebx,%rbp
mov %rax,-0x8(%r12,%rbx,8)
add $0x1,%rbx
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
jne 1560 <func0+0x90>
lea (%r12,%rbp,8),%rax
movq $0x0,(%rax)
mov %r14,%rdi
callq 1090 <free@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
mov $0x10,%edi
jmpq 1519 <func0+0x49>
nopw 0x0(%rax,%rax,1)
mov %r12,%rax
jmp 1587 <func0+0xb7>
mov %r12,%rdi
xor %r12d,%r12d
callq 1090 <free@plt>
jmp 1596 <func0+0xc6>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
movzx eax, byte ptr [rdi]
test al, al
jz loc_15A0
mov rdx, rdi
mov ecx, 1
nop dword ptr [rax+00h]
loc_14E8:
cmp al, 20h ; ' '
setz al
add rdx, 1
movzx eax, al
add ecx, eax
movzx eax, byte ptr [rdx]
test al, al
jnz short loc_14E8
lea edi, [rcx+1]
movsxd rdi, edi
shl rdi, 3; size
loc_1507:
call _malloc
mov rbx, rax
test rax, rax
jz loc_15BD
mov rdi, rbp; s
call _strdup
mov r12, rax
test rax, rax
jz loc_15B5
lea rbp, delim; " "
mov rdi, rax; s
mov rsi, rbp; delim
call _strtok
mov rdi, rax; s
test rax, rax
jz short loc_15B0
mov r13d, 1
nop dword ptr [rax+00h]
loc_1550:
call _strdup
xor edi, edi; s
mov rsi, rbp; delim
mov [rbx+r13*8-8], rax
call _strtok
mov rdi, rax
mov rax, r13
add r13, 1
test rdi, rdi
jnz short loc_1550
cdqe
lea rax, [rbx+rax*8]
loc_1579:
mov qword ptr [rax], 0
mov rdi, r12; ptr
call _free
loc_1588:
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_15A0:
mov edi, 10h
jmp loc_1507
loc_15B0:
mov rax, rbx
jmp short loc_1579
loc_15B5:
mov rdi, rbx; ptr
call _free
loc_15BD:
xor ebx, ebx
jmp short loc_1588 | char * func0(char *s)
{
char v2; // al
char *v3; // rdx
int v4; // ecx
size_t v5; // rdi
char *v6; // rbx
char *v7; // rax
char *v8; // r12
char *v9; // rdi
long long v10; // r13
int v11; // eax
char *v12; // rax
v2 = *s;
if ( *s )
{
v3 = s;
v4 = 1;
do
{
++v3;
v4 += v2 == 32;
v2 = *v3;
}
while ( *v3 );
v5 = 8LL * (v4 + 1);
}
else
{
v5 = 16LL;
}
v6 = (char *)malloc(v5);
if ( !v6 )
return 0LL;
v7 = strdup(s);
v8 = v7;
if ( !v7 )
{
free(v6);
return 0LL;
}
v9 = strtok(v7, " ");
if ( v9 )
{
v10 = 1LL;
do
{
*(_QWORD *)&v6[8 * v10 - 8] = strdup(v9);
v9 = strtok(0LL, " ");
v11 = v10++;
}
while ( v9 );
v12 = &v6[8 * v11];
}
else
{
v12 = v6;
}
*(_QWORD *)v12 = 0LL;
free(v8);
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001015a0
MOV RDX,RDI
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_001014e8:
CMP AL,0x20
SETZ AL
ADD RDX,0x1
MOVZX EAX,AL
ADD ECX,EAX
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x001014e8
LEA EDI,[RCX + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
LAB_00101507:
CALL 0x001010d0
MOV RBX,RAX
TEST RAX,RAX
JZ 0x001015bd
MOV RDI,RBP
CALL 0x001010f0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001015b5
LEA RBP,[0x102004]
MOV RDI,RAX
MOV RSI,RBP
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001015b0
MOV R13D,0x1
NOP dword ptr [RAX]
LAB_00101550:
CALL 0x001010f0
XOR EDI,EDI
MOV RSI,RBP
MOV qword ptr [RBX + R13*0x8 + -0x8],RAX
CALL 0x001010e0
MOV RDI,RAX
MOV RAX,R13
ADD R13,0x1
TEST RDI,RDI
JNZ 0x00101550
CDQE
LEA RAX,[RBX + RAX*0x8]
LAB_00101579:
MOV qword ptr [RAX],0x0
MOV RDI,R12
CALL 0x001010a0
LAB_00101588:
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001015a0:
MOV EDI,0x10
JMP 0x00101507
LAB_001015b0:
MOV RAX,RBX
JMP 0x00101579
LAB_001015b5:
MOV RDI,RBX
CALL 0x001010a0
LAB_001015bd:
XOR EBX,EBX
JMP 0x00101588 | int8 * func0(char *param_1)
{
long lVar1;
char cVar2;
int8 *__ptr;
char *pcVar3;
int8 *puVar4;
int iVar5;
char *pcVar6;
size_t __size;
long lVar7;
cVar2 = *param_1;
if (cVar2 == '\0') {
__size = 0x10;
}
else {
iVar5 = 1;
pcVar6 = param_1;
do {
pcVar6 = pcVar6 + 1;
iVar5 = iVar5 + (uint)(cVar2 == ' ');
cVar2 = *pcVar6;
} while (cVar2 != '\0');
__size = (long)(iVar5 + 1) << 3;
}
__ptr = (int8 *)malloc(__size);
if (__ptr != (int8 *)0x0) {
pcVar6 = strdup(param_1);
if (pcVar6 != (char *)0x0) {
pcVar3 = strtok(pcVar6," ");
puVar4 = __ptr;
if (pcVar3 != (char *)0x0) {
lVar1 = 1;
do {
lVar7 = lVar1;
pcVar3 = strdup(pcVar3);
__ptr[lVar7 + -1] = pcVar3;
pcVar3 = strtok((char *)0x0," ");
lVar1 = lVar7 + 1;
} while (pcVar3 != (char *)0x0);
puVar4 = __ptr + (int)lVar7;
}
*puVar4 = 0;
free(pcVar6);
return __ptr;
}
free(__ptr);
}
return (int8 *)0x0;
} |
4,368 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
xor %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
xor [rbp+var_8], eax
add [rbp+var_4], 1
loc_11A5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 ^= *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
XOR dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | uint func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 ^ *(uint *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
4,369 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
xor (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
xor edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0
jmp short loc_118C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 ^= *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
XOR EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0x0
JMP 0x0010118c | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (param_2 < 1) {
uVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = uVar2 ^ *param_1;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return uVar2;
} |
4,370 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1268 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1258 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12E8
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_12D8:
xor eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_12D8
retn
loc_12E8:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = *a1++ ^ (unsigned int)result;
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012e8
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d8:
XOR EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x001012d8
RET
LAB_001012e8:
XOR EAX,EAX
RET | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = uVar2 ^ *param_1;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return uVar2;
}
return 0;
} |
4,371 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11e0 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
pxor %xmm2,%xmm0
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
pxor %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
pxor %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 11e8 <func0+0xa8>
movslq %edx,%rcx
xor (%rdi,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
xor (%rdi,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add $0x3,%edx
xor (%rdi,%rcx,4),%eax
cmp %edx,%esi
jle 11e2 <func0+0xa2>
movslq %edx,%rdx
xor (%rdi,%rdx,4),%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11aa <func0+0x6a>
| func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
pxor xmm0, xmm2
cmp rax, rdx
jnz short loc_1170
movdqa xmm1, xmm0
mov edx, esi
psrldq xmm1, 8
and edx, 0FFFFFFFCh
pxor xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
pxor xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short locret_11E0
loc_11AA:
movsxd rdi, edx
lea r8, ds:0[rdi*4]
xor eax, [rcx+rdi*4]
lea edi, [rdx+1]
cmp esi, edi
jle short locret_11DA
add edx, 2
xor eax, [rcx+r8+4]
cmp esi, edx
jle short locret_11DA
xor eax, [rcx+r8+8]
retn
loc_11D8:
xor eax, eax
locret_11DA:
retn
locret_11E0:
retn
loc_11E1:
xor edx, edx
xor eax, eax
jmp short loc_11AA | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = _mm_loadu_si128(v2++);
v3 = _mm_xor_si128(v3, v4);
}
while ( v2 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_xor_si128(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_xor_si128(v6, _mm_srli_si128(v6, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v8 = v5;
result = a1->m128i_i32[v8] ^ (unsigned int)result;
if ( a2 > v5 + 1 )
{
result = a1->m128i_i32[v8 + 1] ^ (unsigned int)result;
if ( a2 > v5 + 2 )
return a1->m128i_i32[v8 + 2] ^ (unsigned int)result;
}
return result;
} | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PXOR XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PXOR XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PXOR XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x001011e0
LAB_001011aa:
MOVSXD RDI,EDX
LEA R8,[RDI*0x4]
XOR EAX,dword ptr [RCX + RDI*0x4]
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JLE 0x001011da
ADD EDX,0x2
XOR EAX,dword ptr [RCX + R8*0x1 + 0x4]
CMP ESI,EDX
JLE 0x001011da
XOR EAX,dword ptr [RCX + R8*0x1 + 0x8]
RET
LAB_001011d8:
XOR EAX,EAX
LAB_001011da:
RET
LAB_001011e0:
RET
LAB_001011e1:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011aa | uint func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
if ((int)param_2 < 1) {
uVar4 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
uVar4 = 0;
}
else {
uVar4 = 0;
uVar7 = 0;
uVar8 = 0;
uVar9 = 0;
puVar5 = param_1;
do {
uVar6 = *puVar5;
puVar1 = puVar5 + 1;
puVar2 = puVar5 + 2;
puVar3 = puVar5 + 3;
puVar5 = puVar5 + 4;
uVar4 = uVar4 ^ uVar6;
uVar7 = uVar7 ^ *puVar1;
uVar8 = uVar8 ^ *puVar2;
uVar9 = uVar9 ^ *puVar3;
} while (puVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
uVar4 = uVar4 ^ uVar8 ^ uVar7 ^ uVar9;
if ((param_2 & 3) == 0) {
return uVar4;
}
}
uVar4 = uVar4 ^ param_1[(int)uVar6];
if ((int)(uVar6 + 1) < (int)param_2) {
uVar4 = uVar4 ^ param_1[(long)(int)uVar6 + 1];
if ((int)(uVar6 + 2) < (int)param_2) {
return uVar4 ^ param_1[(long)(int)uVar6 + 2];
}
}
}
return uVar4;
} |
4,372 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
imul %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0x4(%rbp)
sub %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 11d3 <func0+0x6a>
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D4
loc_1188:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax+4]
imul eax, edx
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_C]
jle short loc_11D0
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
loc_11D0:
add [rbp+var_8], 1
loc_11D4:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v2 = *(_DWORD *)(8LL * i + a1) * *(_DWORD *)(8LL * i + a1 + 4);
if ( v2 <= 0 )
v2 = -v2;
if ( v2 > v4 )
v4 = v2;
}
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d4
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
IMUL EAX,EDX
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x001011d0
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011d0:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d4:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = *(int *)(param_1 + (long)local_10 * 8 + 4) * *(int *)(param_1 + (long)local_10 * 8);
if (iVar1 < 1) {
iVar1 = -iVar1;
}
if (local_14 < iVar1) {
local_14 = iVar1;
}
}
return local_14;
} |
4,373 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a1 <func0+0x38>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdi
mov $0x0,%ecx
mov (%rdx),%eax
imul 0x4(%rdx),%eax
mov %eax,%esi
sar $0x1f,%esi
xor %esi,%eax
sub %esi,%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x8,%rdx
cmp %rdi,%rdx
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 119e <func0+0x35>
| func0:
endbr64
test esi, esi
jle short loc_119F
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*8+8]
mov esi, 0
loc_1181:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp esi, eax
cmovl esi, eax
add rdx, 8
cmp rdx, rdi
jnz short loc_1181
loc_119C:
mov eax, esi
retn
loc_119F:
mov esi, 0
jmp short loc_119C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
long long v3; // rdi
int v4; // esi
int v5; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[2 * (a2 - 1) + 2];
v4 = 0;
do
{
v5 = v2[1] * *v2;
if ( v5 <= 0 )
v5 = -(v2[1] * *v2);
if ( v4 < v5 )
v4 = v5;
v2 += 2;
}
while ( v2 != (_DWORD *)v3 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119f
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x8 + 0x8]
MOV ESI,0x0
LAB_00101181:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x8
CMP RDX,RDI
JNZ 0x00101181
LAB_0010119c:
MOV EAX,ESI
RET
LAB_0010119f:
MOV ESI,0x0
JMP 0x0010119c | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
iVar3 = 0;
do {
iVar2 = *param_1 * param_1[1];
if (iVar2 < 1) {
iVar2 = -iVar2;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
}
return iVar3;
} |
4,374 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x8,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1310
lea eax, [rsi-1]
xor r8d, r8d
lea rcx, [rdi+rax*8+8]
nop dword ptr [rax+rax+00h]
loc_12E8:
mov eax, [rdi]
imul eax, [rdi+4]
mov edx, eax
neg edx
cmovns eax, edx
cmp r8d, eax
cmovl r8d, eax
add rdi, 8
cmp rdi, rcx
jnz short loc_12E8
mov eax, r8d
retn
loc_1310:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
long long v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[2 * (a2 - 1) + 2];
do
{
v4 = a1[1] * *a1;
if ( v4 <= 0 )
v4 = -(a1[1] * *a1);
if ( v2 < v4 )
v2 = v4;
a1 += 2;
}
while ( a1 != (_DWORD *)v3 );
return (unsigned int)v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101310
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RCX,[RDI + RAX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e8:
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x8
CMP RDI,RCX
JNZ 0x001012e8
MOV EAX,R8D
RET
LAB_00101310:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
iVar2 = *param_1 * param_1[1];
if (iVar2 < 1) {
iVar2 = -iVar2;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
return iVar3;
}
return 0;
} |
4,375 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1440 <func0+0x150>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1449 <func0+0x159>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm3,%xmm3
shr $0x2,%edx
shl $0x5,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
movdqu 0x10(%rax),%xmm4
add $0x20,%rax
movdqa %xmm2,%xmm1
shufps $0xdd,%xmm4,%xmm2
shufps $0x88,%xmm4,%xmm1
movdqa %xmm1,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm2,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrad $0x1f,%xmm1
pxor %xmm1,%xmm0
psubd %xmm1,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
movdqa %xmm1,%xmm3
por %xmm0,%xmm3
cmp %rdx,%rax
jne 1320 <func0+0x30>
movdqa %xmm3,%xmm0
mov %esi,%ecx
psrldq $0x8,%xmm0
and $0xfffffffc,%ecx
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 1448 <func0+0x158>
movslq %ecx,%r8
mov (%rdi,%r8,8),%edx
imul 0x4(%rdi,%r8,8),%edx
mov %edx,%r8d
sar $0x1f,%r8d
xor %r8d,%edx
sub %r8d,%edx
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rcx),%edx
cmp %edx,%esi
jle 1442 <func0+0x152>
movslq %edx,%r8
mov (%rdi,%r8,8),%edx
imul 0x4(%rdi,%r8,8),%edx
mov %edx,%r8d
sar $0x1f,%r8d
xor %r8d,%edx
sub %r8d,%edx
cmp %edx,%eax
cmovl %edx,%eax
add $0x2,%ecx
cmp %ecx,%esi
jle 1442 <func0+0x152>
movslq %ecx,%rcx
mov 0x4(%rdi,%rcx,8),%edx
imul (%rdi,%rcx,8),%edx
mov %edx,%ecx
sar $0x1f,%ecx
xor %ecx,%edx
sub %ecx,%edx
cmp %edx,%eax
cmovl %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 13d4 <func0+0xe4>
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_13B0
lea eax, [rsi-1]
cmp eax, 2
jbe loc_13B9
mov edx, esi
mov rax, rdi
pxor xmm3, xmm3
shr edx, 2
shl rdx, 5
add rdx, rdi
nop dword ptr [rax]
loc_1290:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm4, xmmword ptr [rax+10h]
add rax, 20h ; ' '
movdqa xmm1, xmm2
shufps xmm2, xmm4, 0DDh
shufps xmm1, xmm4, 88h
movdqa xmm0, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm2
psrlq xmm2, 20h ; ' '
pmuludq xmm1, xmm2
pshufd xmm0, xmm0, 8
pshufd xmm1, xmm1, 8
punpckldq xmm0, xmm1
movdqa xmm1, xmm0
psrad xmm1, 1Fh
pxor xmm0, xmm1
psubd xmm0, xmm1
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm3
pand xmm0, xmm1
pandn xmm1, xmm3
movdqa xmm3, xmm1
por xmm3, xmm0
cmp rax, rdx
jnz short loc_1290
movdqa xmm1, xmm3
mov esi, ecx
psrldq xmm1, 8
and esi, 0FFFFFFFCh
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm3
pand xmm1, xmm0
pandn xmm0, xmm3
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
test cl, 3
jz short locret_13B8
loc_1343:
movsxd r8, esi
shl r8, 3
lea r9, [rdi+r8]
mov edx, [r9]
imul edx, [r9+4]
mov r9d, edx
neg r9d
cmovns edx, r9d
cmp eax, edx
cmovl eax, edx
lea edx, [rsi+1]
cmp ecx, edx
jle short locret_13B2
lea r9, [rdi+r8+8]
mov edx, [r9]
imul edx, [r9+4]
mov r9d, edx
neg r9d
cmovns edx, r9d
cmp eax, edx
cmovl eax, edx
add esi, 2
cmp ecx, esi
jle short locret_13B2
lea rcx, [rdi+r8+10h]
mov edx, [rcx+4]
imul edx, [rcx]
mov ecx, edx
neg ecx
cmovns edx, ecx
cmp eax, edx
cmovl eax, edx
retn
loc_13B0:
xor eax, eax
locret_13B2:
retn
locret_13B8:
retn
loc_13B9:
xor esi, esi
xor eax, eax
jmp short loc_1343 | long long func0(const __m128i *a1, int a2)
{
const __m128i *v3; // rax
__m128i v4; // xmm3
__m128 v5; // xmm2
__m128 v6; // xmm4
__m128 v7; // xmm1
__m128i v8; // xmm2
__m128i v9; // xmm0
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm1
signed int v15; // esi
__m128i v16; // xmm0
__m128i v17; // xmm0
__m128i v18; // xmm2
__m128i v19; // xmm1
long long result; // rax
long long v21; // r8
int v22; // edx
int v23; // edx
int v24; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v15 = 0;
result = 0LL;
}
else
{
v3 = a1;
v4 = 0LL;
do
{
v5 = (__m128)_mm_loadu_si128(v3);
v6 = (__m128)_mm_loadu_si128(v3 + 1);
v3 += 2;
v7 = v5;
v8 = (__m128i)_mm_shuffle_ps(v5, v6, 221);
v9 = (__m128i)_mm_shuffle_ps(v7, v6, 136);
v10 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v9, v8), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v9, 0x20u), _mm_srli_epi64(v8, 0x20u)), 8));
v11 = _mm_srai_epi32(v10, 0x1Fu);
v12 = _mm_sub_epi32(_mm_xor_si128(v10, v11), v11);
v13 = _mm_cmpgt_epi32(v12, v4);
v4 = _mm_or_si128(_mm_andnot_si128(v13, v4), _mm_and_si128(v12, v13));
}
while ( v3 != &a1[2 * ((unsigned int)a2 >> 2)] );
v14 = _mm_srli_si128(v4, 8);
v15 = a2 & 0xFFFFFFFC;
v16 = _mm_cmpgt_epi32(v14, v4);
v17 = _mm_or_si128(_mm_andnot_si128(v16, v4), _mm_and_si128(v14, v16));
v18 = _mm_srli_si128(v17, 4);
v19 = _mm_cmpgt_epi32(v18, v17);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v19, v17), _mm_and_si128(v18, v19)));
if ( (a2 & 3) == 0 )
return result;
}
v21 = 2LL * v15;
v22 = a1->m128i_i32[v21 + 1] * a1->m128i_i32[v21];
if ( v22 <= 0 )
v22 = -(a1->m128i_i32[2 * v15 + 1] * a1->m128i_i32[2 * v15]);
if ( (int)result < v22 )
result = (unsigned int)v22;
if ( a2 > v15 + 1 )
{
v23 = a1->m128i_i32[v21 + 3] * a1->m128i_i32[v21 + 2];
if ( v23 <= 0 )
v23 = -(a1->m128i_i32[v21 + 3] * a1->m128i_i32[v21 + 2]);
if ( (int)result < v23 )
result = (unsigned int)v23;
if ( a2 > v15 + 2 )
{
v24 = a1[1].m128i_i32[v21] * a1[1].m128i_i32[v21 + 1];
if ( v24 <= 0 )
v24 = -(a1[1].m128i_i32[v21] * a1[1].m128i_i32[v21 + 1]);
if ( (int)result < v24 )
return (unsigned int)v24;
}
}
return result;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x001013b0
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001013b9
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM3,XMM3
SHR EDX,0x2
SHL RDX,0x5
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101290:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM4,xmmword ptr [RAX + 0x10]
ADD RAX,0x20
MOVDQA XMM1,XMM2
SHUFPS XMM2,XMM4,0xdd
SHUFPS XMM1,XMM4,0x88
MOVDQA XMM0,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM2
PSRLQ XMM2,0x20
PMULUDQ XMM1,XMM2
PSHUFD XMM0,XMM0,0x8
PSHUFD XMM1,XMM1,0x8
PUNPCKLDQ XMM0,XMM1
MOVDQA XMM1,XMM0
PSRAD XMM1,0x1f
PXOR XMM0,XMM1
PSUBD XMM0,XMM1
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM3
PAND XMM0,XMM1
PANDN XMM1,XMM3
MOVDQA XMM3,XMM1
POR XMM3,XMM0
CMP RAX,RDX
JNZ 0x00101290
MOVDQA XMM1,XMM3
MOV ESI,ECX
PSRLDQ XMM1,0x8
AND ESI,0xfffffffc
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM3
PAND XMM1,XMM0
PANDN XMM0,XMM3
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
TEST CL,0x3
JZ 0x001013b8
LAB_00101343:
MOVSXD R8,ESI
SHL R8,0x3
LEA R9,[RDI + R8*0x1]
MOV EDX,dword ptr [R9]
IMUL EDX,dword ptr [R9 + 0x4]
MOV R9D,EDX
NEG R9D
CMOVNS EDX,R9D
CMP EAX,EDX
CMOVL EAX,EDX
LEA EDX,[RSI + 0x1]
CMP ECX,EDX
JLE 0x001013b2
LEA R9,[RDI + R8*0x1 + 0x8]
MOV EDX,dword ptr [R9]
IMUL EDX,dword ptr [R9 + 0x4]
MOV R9D,EDX
NEG R9D
CMOVNS EDX,R9D
CMP EAX,EDX
CMOVL EAX,EDX
ADD ESI,0x2
CMP ECX,ESI
JLE 0x001013b2
LEA RCX,[RDI + R8*0x1 + 0x10]
MOV EDX,dword ptr [RCX + 0x4]
IMUL EDX,dword ptr [RCX]
MOV ECX,EDX
NEG ECX
CMOVNS EDX,ECX
CMP EAX,EDX
CMOVL EAX,EDX
RET
LAB_001013b0:
XOR EAX,EAX
LAB_001013b2:
RET
LAB_001013b8:
RET
LAB_001013b9:
XOR ESI,ESI
XOR EAX,EAX
JMP 0x00101343 | uint func0(int *param_1,uint param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint *puVar6;
int *piVar7;
int *piVar8;
uint uVar9;
int *piVar10;
uint uVar11;
long lVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
int auVar16 [16];
uint uVar21;
uint uVar22;
int auVar23 [16];
uint uVar24;
if ((int)param_2 < 1) {
uVar9 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar14 = 0;
uVar9 = 0;
}
else {
uVar9 = 0;
uVar11 = 0;
uVar15 = 0;
uVar24 = 0;
piVar10 = param_1;
do {
iVar2 = *piVar10;
piVar3 = piVar10 + 1;
piVar4 = piVar10 + 2;
piVar5 = piVar10 + 3;
piVar1 = piVar10 + 4;
puVar6 = (uint *)(piVar10 + 5);
piVar7 = piVar10 + 6;
piVar8 = piVar10 + 7;
piVar10 = piVar10 + 8;
auVar23._4_4_ = *piVar5;
auVar23._0_4_ = *piVar3;
auVar23._8_4_ = *puVar6;
auVar23._12_4_ = *piVar8;
auVar16._4_4_ = *piVar4;
auVar16._0_4_ = iVar2;
auVar16._8_4_ = *piVar1;
auVar16._12_4_ = *piVar7;
uVar14 = iVar2 * *piVar3;
uVar20 = *piVar4 * *piVar5;
uVar18 = (uint)((auVar16._8_8_ & 0xffffffff) * (ulong)*puVar6);
uVar22 = (uint)((auVar16._8_8_ >> 0x20) * (auVar23._8_8_ >> 0x20));
uVar13 = (int)uVar14 >> 0x1f;
uVar17 = (int)uVar20 >> 0x1f;
uVar19 = (int)uVar18 >> 0x1f;
uVar21 = (int)uVar22 >> 0x1f;
uVar13 = (uVar14 ^ uVar13) - uVar13;
uVar17 = (uVar20 ^ uVar17) - uVar17;
uVar19 = (uVar18 ^ uVar19) - uVar19;
uVar21 = (uVar22 ^ uVar21) - uVar21;
uVar14 = -(uint)((int)uVar9 < (int)uVar13);
uVar18 = -(uint)((int)uVar11 < (int)uVar17);
uVar20 = -(uint)((int)uVar15 < (int)uVar19);
uVar22 = -(uint)((int)uVar24 < (int)uVar21);
uVar9 = ~uVar14 & uVar9 | uVar13 & uVar14;
uVar11 = ~uVar18 & uVar11 | uVar17 & uVar18;
uVar15 = ~uVar20 & uVar15 | uVar19 & uVar20;
uVar24 = ~uVar22 & uVar24 | uVar21 & uVar22;
} while (piVar10 != param_1 + (ulong)(param_2 >> 2) * 8);
uVar14 = param_2 & 0xfffffffc;
uVar9 = ~-(uint)((int)uVar9 < (int)uVar15) & uVar9 |
uVar15 & -(uint)((int)uVar9 < (int)uVar15);
uVar11 = ~-(uint)((int)uVar11 < (int)uVar24) & uVar11 |
uVar24 & -(uint)((int)uVar11 < (int)uVar24);
uVar15 = -(uint)((int)uVar9 < (int)uVar11);
uVar9 = ~uVar15 & uVar9 | uVar11 & uVar15;
if ((param_2 & 3) == 0) {
return uVar9;
}
}
lVar12 = (long)(int)uVar14;
uVar11 = param_1[lVar12 * 2] * (param_1 + lVar12 * 2)[1];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar9 < (int)uVar11) {
uVar9 = uVar11;
}
if ((int)(uVar14 + 1) < (int)param_2) {
uVar11 = param_1[lVar12 * 2 + 2] * (param_1 + lVar12 * 2 + 2)[1];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar9 < (int)uVar11) {
uVar9 = uVar11;
}
if ((int)(uVar14 + 2) < (int)param_2) {
uVar14 = (param_1 + lVar12 * 2 + 4)[1] * param_1[lVar12 * 2 + 4];
if ((int)uVar14 < 1) {
uVar14 = -uVar14;
}
if ((int)uVar9 < (int)uVar14) {
uVar9 = uVar14;
}
return uVar9;
}
}
}
return uVar9;
} |
4,376 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
mov %ecx,-0x14(%rbp)
cmpl $0x3,-0x14(%rbp)
jne 1195 <func0+0x2c>
cmpl $0x0,-0x10(%rbp)
jne 1195 <func0+0x2c>
mov $0x1,%eax
jmp 1210 <func0+0xa7>
cmpl $0x3,-0x14(%rbp)
je 11a7 <func0+0x3e>
cmpl $0x0,-0xc(%rbp)
je 11a7 <func0+0x3e>
cmpl $0x0,-0x10(%rbp)
jns 11ae <func0+0x45>
mov $0x0,%eax
jmp 1210 <func0+0xa7>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%ecx
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x10(%rbp),%edx
sub %eax,%edx
mov -0xc(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1169 <func0>
test %al,%al
jne 1201 <func0+0x98>
mov -0xc(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x14(%rbp),%ecx
mov -0x10(%rbp),%edx
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1169 <func0>
test %al,%al
je 1208 <func0+0x9f>
mov $0x1,%eax
jmp 120d <func0+0xa4>
mov $0x0,%eax
and $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
cmp [rbp+var_14], 3
jnz short loc_1195
cmp [rbp+var_10], 0
jnz short loc_1195
mov eax, 1
jmp short locret_1210
loc_1195:
cmp [rbp+var_14], 3
jz short loc_11A7
cmp [rbp+var_C], 0
jz short loc_11A7
cmp [rbp+var_10], 0
jns short loc_11AE
loc_11A7:
mov eax, 0
jmp short locret_1210
loc_11AE:
mov eax, [rbp+var_14]
lea ecx, [rax+1]
mov eax, [rbp+var_C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_8]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_10]
sub edx, eax
mov eax, [rbp+var_C]
lea esi, [rax-1]
mov rax, [rbp+var_8]
mov rdi, rax
call func0
test al, al
jnz short loc_1201
mov eax, [rbp+var_C]
lea esi, [rax-1]
mov ecx, [rbp+var_14]
mov edx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rdi, rax
call func0
test al, al
jz short loc_1208
loc_1201:
mov eax, 1
jmp short loc_120D
loc_1208:
mov eax, 0
loc_120D:
and eax, 1
locret_1210:
leave
retn | long long func0(long long a1, int a2, int a3, unsigned int a4)
{
if ( a4 == 3 && !a3 )
return 1LL;
if ( a4 == 3 || !a2 || a3 < 0 )
return 0LL;
return (unsigned __int8)func0(a1, (unsigned int)(a2 - 1), (unsigned int)(a3 - *(_DWORD *)(4LL * a2 - 4 + a1)), a4 + 1)
|| (unsigned __int8)func0(a1, (unsigned int)(a2 - 1), (unsigned int)a3, a4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
CMP dword ptr [RBP + -0x14],0x3
JNZ 0x00101195
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x00101195
MOV EAX,0x1
JMP 0x00101210
LAB_00101195:
CMP dword ptr [RBP + -0x14],0x3
JZ 0x001011a7
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011a7
CMP dword ptr [RBP + -0x10],0x0
JNS 0x001011ae
LAB_001011a7:
MOV EAX,0x0
JMP 0x00101210
LAB_001011ae:
MOV EAX,dword ptr [RBP + -0x14]
LEA ECX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
SUB EDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
LEA ESI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101169
TEST AL,AL
JNZ 0x00101201
MOV EAX,dword ptr [RBP + -0xc]
LEA ESI,[RAX + -0x1]
MOV ECX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101169
TEST AL,AL
JZ 0x00101208
LAB_00101201:
MOV EAX,0x1
JMP 0x0010120d
LAB_00101208:
MOV EAX,0x0
LAB_0010120d:
AND EAX,0x1
LAB_00101210:
LEAVE
RET | int4 func0(long param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int4 uVar2;
if ((param_4 == 3) && (param_3 == 0)) {
uVar2 = 1;
}
else if (((param_4 == 3) || (param_2 == 0)) || (param_3 < 0)) {
uVar2 = 0;
}
else {
cVar1 = func0(param_1,param_2 + -1,param_3 - *(int *)(param_1 + (long)param_2 * 4 + -4),
param_4 + 1);
if ((cVar1 == '\0') && (cVar1 = func0(param_1,param_2 + -1,param_3,param_4), cVar1 == '\0')) {
uVar2 = 0;
}
else {
uVar2 = 1;
}
}
return uVar2;
} |
4,377 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
cmp $0x3,%ecx
sete %dl
test %ebx,%ebx
sete %al
and %dl,%al
jne 11cb <func0+0x62>
mov %rdi,%r12
mov %ecx,%ebp
test %esi,%esi
sete %dil
mov %ebx,%ecx
shr $0x1f,%ecx
or %cl,%dil
jne 11cb <func0+0x62>
test %dl,%dl
jne 11cb <func0+0x62>
lea -0x1(%rsi),%r13d
lea 0x1(%rbp),%ecx
movslq %esi,%rsi
mov %ebx,%edx
sub -0x4(%r12,%rsi,4),%edx
mov %r13d,%esi
mov %r12,%rdi
callq 1169 <func0>
mov %eax,%edx
mov $0x1,%eax
test %dl,%dl
je 11d6 <func0+0x6d>
and $0x1,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %ebp,%ecx
mov %ebx,%edx
mov %r13d,%esi
mov %r12,%rdi
callq 1169 <func0>
movzbl %al,%eax
jmp 11c8 <func0+0x5f>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edx
cmp ecx, 3
setz dl
test ebx, ebx
setz al
and al, dl
jnz short loc_11CA
mov r12, rdi
mov ebp, ecx
test esi, esi
setz cl
mov edi, ebx
shr edi, 1Fh
or cl, dil
jnz short loc_11CA
test dl, dl
jnz short loc_11CA
lea r13d, [rsi-1]
lea ecx, [rbp+1]
movsxd rsi, esi
mov edx, ebx
sub edx, [r12+rsi*4-4]
mov esi, r13d
mov rdi, r12
call func0
mov edx, eax
mov eax, 1
test dl, dl
jz short loc_11D5
loc_11C7:
and eax, 1
loc_11CA:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11D5:
mov ecx, ebp
mov edx, ebx
mov esi, r13d
mov rdi, r12
call func0
movzx eax, al
jmp short loc_11C7 | bool func0(long long a1, int a2, int a3, unsigned int a4)
{
bool result; // al
char v7; // dl
char v8; // al
result = a4 == 3 && a3 == 0;
if ( !result && a3 >= 0 && a2 != 0 && a4 != 3 )
{
v7 = func0(a1, (unsigned int)(a2 - 1), (unsigned int)(a3 - *(_DWORD *)(a1 + 4LL * a2 - 4)), a4 + 1);
v8 = 1;
if ( !v7 )
v8 = func0(a1, (unsigned int)(a2 - 1), (unsigned int)a3, a4);
return v8 & 1;
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDX
CMP ECX,0x3
SETZ DL
TEST EBX,EBX
SETZ AL
AND AL,DL
JNZ 0x001011ca
MOV R12,RDI
MOV EBP,ECX
TEST ESI,ESI
SETZ CL
MOV EDI,EBX
SHR EDI,0x1f
OR CL,DIL
JNZ 0x001011ca
TEST DL,DL
JNZ 0x001011ca
LEA R13D,[RSI + -0x1]
LEA ECX,[RBP + 0x1]
MOVSXD RSI,ESI
MOV EDX,EBX
SUB EDX,dword ptr [R12 + RSI*0x4 + -0x4]
MOV ESI,R13D
MOV RDI,R12
CALL 0x00101169
MOV EDX,EAX
MOV EAX,0x1
TEST DL,DL
JZ 0x001011d5
LAB_001011c7:
AND EAX,0x1
LAB_001011ca:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011d5:
MOV ECX,EBP
MOV EDX,EBX
MOV ESI,R13D
MOV RDI,R12
CALL 0x00101169
MOVZX EAX,AL
JMP 0x001011c7 | bool func0(long param_1,int param_2,int param_3,int param_4)
{
bool bVar1;
char cVar2;
byte bVar3;
bool bVar4;
bVar4 = param_4 == 3;
bVar1 = param_3 == 0 && bVar4;
if (((param_3 != 0 || !bVar4) && (param_2 != 0 && -1 < param_3)) && (!bVar4)) {
cVar2 = func0(param_1,param_2 + -1,param_3 - *(int *)(param_1 + -4 + (long)param_2 * 4),
param_4 + 1);
bVar3 = 1;
if (cVar2 == '\0') {
bVar3 = func0(param_1,param_2 + -1,param_3,param_4);
}
bVar1 = (bool)(bVar3 & 1);
}
return bVar1;
} |
4,378 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x3,%ecx
sete %r8b
test %edx,%edx
sete %al
and %r8b,%al
jne 1320 <func0+0x30>
test %esi,%esi
mov %edx,%r9d
sete %r10b
shr $0x1f,%r9d
or %r9b,%r10b
jne 1320 <func0+0x30>
test %r8b,%r8b
jne 1320 <func0+0x30>
jmp 1330 <func0.part.0>
xchg %ax,%ax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0_part_0:
push r15
lea r15d, [rcx+1]
push r14
mov r14d, edx
push r13
shr r14d, 1Fh
mov r13d, ecx
push r12
mov r12, rdi
push rbp
mov ebp, esi
push rbx
mov ebx, edx
sub rsp, 18h
loc_1313:
movsxd rax, ebp
cmp r15d, 3
mov r9d, ebx
setz dl
sub r9d, [r12+rax*4-4]
setz al
and al, dl
jnz short loc_135C
sub ebp, 1
setz r8b
or dl, r8b
jnz short loc_1370
test r9d, r9d
js short loc_1370
mov ecx, r15d
mov edx, r9d
mov esi, ebp
mov rdi, r12
mov [rsp+48h+var_39], r8b
call func0_part_0
movzx r8d, [rsp+48h+var_39]
test al, al
jz short loc_1370
loc_135C:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1370:
cmp r13d, 3
setz dl
test ebx, ebx
setz al
and al, dl
jnz short loc_135C
test r14b, r14b
jnz short loc_135C
or dl, r8b
jz short loc_1313
jmp short loc_135C | char func0_part_0(long long a1, unsigned int a2, unsigned int a3, int a4)
{
unsigned int v4; // r15d
unsigned int v5; // r14d
int v9; // r9d
char result; // al
bool v11; // r8
v4 = a4 + 1;
v5 = a3 >> 31;
do
{
v9 = a3 - *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
result = v4 == 3 && a3 == *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
if ( result )
break;
v11 = --a2 == 0;
if ( a2 != 0 && v4 != 3 && v9 >= 0 )
{
result = func0_part_0(a1, a2, (unsigned int)v9, v4);
v11 = a2 == 0;
if ( result )
break;
}
result = a4 == 3 && a3 == 0;
if ( result )
break;
}
while ( !(_BYTE)v5 && !v11 && a4 != 3 );
return result;
} | func0.part.0:
PUSH R15
LEA R15D,[RCX + 0x1]
PUSH R14
MOV R14D,EDX
PUSH R13
SHR R14D,0x1f
MOV R13D,ECX
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
LAB_00101313:
MOVSXD RAX,EBP
CMP R15D,0x3
MOV R9D,EBX
SETZ DL
SUB R9D,dword ptr [R12 + RAX*0x4 + -0x4]
SETZ AL
AND AL,DL
JNZ 0x0010135c
SUB EBP,0x1
SETZ R8B
OR DL,R8B
JNZ 0x00101370
TEST R9D,R9D
JS 0x00101370
MOV ECX,R15D
MOV EDX,R9D
MOV ESI,EBP
MOV RDI,R12
MOV byte ptr [RSP + 0xf],R8B
CALL 0x001012f0
MOVZX R8D,byte ptr [RSP + 0xf]
TEST AL,AL
JZ 0x00101370
LAB_0010135c:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101370:
CMP R13D,0x3
SETZ DL
TEST EBX,EBX
SETZ AL
AND AL,DL
JNZ 0x0010135c
TEST R14B,R14B
JNZ 0x0010135c
OR DL,R8B
JZ 0x00101313
JMP 0x0010135c | void func0_part_0(long param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int iVar2;
int iVar3;
iVar3 = param_4 + 1;
while( true ) {
iVar2 = param_3 - *(int *)(param_1 + -4 + (long)param_2 * 4);
if (iVar2 == 0 && iVar3 == 3) {
return;
}
param_2 = param_2 + -1;
if (((iVar3 != 3 && param_2 != 0) && (-1 < iVar2)) &&
(cVar1 = func0_part_0(param_1,param_2,iVar2,iVar3), cVar1 != '\0')) {
return;
}
if (param_3 == 0 && param_4 == 3) {
return;
}
if (param_3 < 0) break;
if (param_4 == 3 || param_2 == 0) {
return;
}
}
return;
} |
4,379 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%r10d
cmp $0x3,%ecx
sete %dl
test %r10d,%r10d
sete %al
and %dl,%al
jne 13d8 <func0+0x88>
push %r12
mov %ecx,%r11d
mov %r10d,%ecx
push %rbp
mov %rdi,%rbp
sub $0x8,%rsp
test %esi,%esi
sete %dil
shr $0x1f,%ecx
or %cl,%dil
jne 13ca <func0+0x7a>
test %dl,%dl
jne 13ca <func0+0x7a>
movslq %esi,%rax
cmp $0x2,%r11d
lea 0x1(%r11),%ecx
mov %r10d,%r8d
sete %dl
sub -0x4(%rbp,%rax,4),%r8d
sete %al
and %dl,%al
jne 13ca <func0+0x7a>
lea -0x1(%rsi),%r12d
cmp $0x1,%esi
je 13e0 <func0+0x90>
test %dl,%dl
jne 13e0 <func0+0x90>
test %r8d,%r8d
js 13e5 <func0+0x95>
mov %r8d,%edx
mov %r12d,%esi
mov %rbp,%rdi
callq 12a0 <func0.part.0>
test %al,%al
je 13e5 <func0+0x95>
add $0x8,%rsp
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
retq
nopl 0x0(%rax)
test %r12d,%r12d
je 13ca <func0+0x7a>
add $0x8,%rsp
mov %r12d,%esi
mov %rbp,%rdi
mov %r11d,%ecx
pop %rbp
mov %r10d,%edx
pop %r12
jmpq 12a0 <func0.part.0>
nopl (%rax)
| func0_part_0:
push r15
push r14
lea r14d, [rcx+1]
push r13
mov r13d, ecx
push r12
mov r12, rdi
push rbp
mov ebp, edx
push rbx
mov ebx, esi
sub rsp, 8
loc_12BC:
movsxd rax, ebx
cmp r14d, 3
mov esi, ebp
setz dl
sub esi, [r12+rax*4-4]
setz al
and al, dl
jnz short loc_12F7
sub ebx, 1
setz r15b
test esi, esi
js short loc_1310
or dl, r15b
jnz short loc_1310
mov edx, esi
mov ecx, r14d
mov esi, ebx
mov rdi, r12
call func0_part_0
test al, al
jz short loc_1310
loc_12F7:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1310:
cmp r13d, 3
setz dl
test ebp, ebp
setz al
and al, dl
jnz short loc_12F7
test ebp, ebp
js short loc_12F7
or dl, r15b
jz short loc_12BC
jmp short loc_12F7 | char func0_part_0(long long a1, unsigned int a2, int a3, int a4)
{
unsigned int v4; // r14d
int v8; // esi
char result; // al
bool v10; // r15
v4 = a4 + 1;
do
{
v8 = a3 - *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
result = v4 == 3 && a3 == *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
if ( result )
break;
v10 = --a2 == 0;
if ( v8 >= 0 && !v10 && v4 != 3 )
{
result = func0_part_0(a1, a2, (unsigned int)v8, v4);
if ( result )
break;
}
result = a4 == 3 && a3 == 0;
if ( result )
break;
}
while ( a3 >= 0 && !v10 && a4 != 3 );
return result;
} | func0.part.0:
PUSH R15
PUSH R14
LEA R14D,[RCX + 0x1]
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV EBX,ESI
SUB RSP,0x8
LAB_001012bc:
MOVSXD RAX,EBX
CMP R14D,0x3
MOV ESI,EBP
SETZ DL
SUB ESI,dword ptr [R12 + RAX*0x4 + -0x4]
SETZ AL
AND AL,DL
JNZ 0x001012f7
SUB EBX,0x1
SETZ R15B
TEST ESI,ESI
JS 0x00101310
OR DL,R15B
JNZ 0x00101310
MOV EDX,ESI
MOV ECX,R14D
MOV ESI,EBX
MOV RDI,R12
CALL 0x001012a0
TEST AL,AL
JZ 0x00101310
LAB_001012f7:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101310:
CMP R13D,0x3
SETZ DL
TEST EBP,EBP
SETZ AL
AND AL,DL
JNZ 0x001012f7
TEST EBP,EBP
JS 0x001012f7
OR DL,R15B
JZ 0x001012bc
JMP 0x001012f7 | void func0_part_0(long param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int iVar2;
int iVar3;
iVar3 = param_4 + 1;
while( true ) {
iVar2 = param_3 - *(int *)(param_1 + -4 + (long)param_2 * 4);
if (iVar2 == 0 && iVar3 == 3) {
return;
}
param_2 = param_2 + -1;
if (((-1 < iVar2) && (iVar3 != 3 && param_2 != 0)) &&
(cVar1 = func0_part_0(param_1,param_2,iVar2,iVar3), cVar1 != '\0')) {
return;
}
if (param_3 == 0 && param_4 == 3) {
return;
}
if (param_3 < 0) break;
if (param_4 == 3 || param_2 == 0) {
return;
}
}
return;
} |
4,380 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == 0) {
result[resultIndex++] = j;
}
j += i;
}
}
}
for (int i = 0; i < resultIndex - 1; i++) {
for (int j = 0; j < resultIndex - i - 1; j++) {
if (result[j] > result[j + 1]) {
int temp = result[j];
result[j] = result[j + 1];
result[j + 1] = temp;
}
}
}
return result[n - 1];
}
| int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 1199 <func0+0x10>
sub $0xe00,%rsp
mov %edi,-0x5df4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x5dd0(%rbp),%rax
mov $0x2ee0,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 1090 <memset@plt>
movl $0x0,-0x5de8(%rbp)
movl $0x2,-0x5de4(%rbp)
jmpq 12a4 <func0+0x11b>
mov -0x5de4(%rbp),%eax
cltq
mov -0x5dd0(%rbp,%rax,4),%eax
test %eax,%eax
jne 129d <func0+0x114>
mov -0x5de4(%rbp),%eax
cltq
movl $0x1,-0x5dd0(%rbp,%rax,4)
mov -0x5de4(%rbp),%eax
add %eax,%eax
mov %eax,-0x5de0(%rbp)
jmp 1291 <func0+0x108>
mov -0x5de0(%rbp),%eax
cltq
mov -0x5dd0(%rbp,%rax,4),%eax
lea -0x1(%rax),%edx
mov -0x5de0(%rbp),%eax
cltq
mov %edx,-0x5dd0(%rbp,%rax,4)
mov -0x5de0(%rbp),%eax
cltq
mov -0x5dd0(%rbp,%rax,4),%eax
cmp $0xfffffffd,%eax
jne 1285 <func0+0xfc>
mov -0x5de8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x5de8(%rbp)
cltq
mov -0x5de0(%rbp),%edx
mov %edx,-0x2ef0(%rbp,%rax,4)
mov -0x5de4(%rbp),%eax
add %eax,-0x5de0(%rbp)
cmpl $0xbb7,-0x5de0(%rbp)
jle 1232 <func0+0xa9>
addl $0x1,-0x5de4(%rbp)
cmpl $0xbb7,-0x5de4(%rbp)
jle 11f8 <func0+0x6f>
movl $0x0,-0x5ddc(%rbp)
jmpq 136b <func0+0x1e2>
movl $0x0,-0x5dd8(%rbp)
jmp 1349 <func0+0x1c0>
mov -0x5dd8(%rbp),%eax
cltq
mov -0x2ef0(%rbp,%rax,4),%edx
mov -0x5dd8(%rbp),%eax
add $0x1,%eax
cltq
mov -0x2ef0(%rbp,%rax,4),%eax
cmp %eax,%edx
jle 1342 <func0+0x1b9>
mov -0x5dd8(%rbp),%eax
cltq
mov -0x2ef0(%rbp,%rax,4),%eax
mov %eax,-0x5dd4(%rbp)
mov -0x5dd8(%rbp),%eax
add $0x1,%eax
cltq
mov -0x2ef0(%rbp,%rax,4),%edx
mov -0x5dd8(%rbp),%eax
cltq
mov %edx,-0x2ef0(%rbp,%rax,4)
mov -0x5dd8(%rbp),%eax
add $0x1,%eax
cltq
mov -0x5dd4(%rbp),%edx
mov %edx,-0x2ef0(%rbp,%rax,4)
addl $0x1,-0x5dd8(%rbp)
mov -0x5de8(%rbp),%eax
sub -0x5ddc(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x5dd8(%rbp)
jl 12cf <func0+0x146>
addl $0x1,-0x5ddc(%rbp)
mov -0x5de8(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x5ddc(%rbp)
jl 12c3 <func0+0x13a>
mov -0x5df4(%rbp),%eax
sub $0x1,%eax
cltq
mov -0x2ef0(%rbp,%rax,4),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 13a6 <func0+0x21d>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
lea r11, [rsp+var_5000]
loc_1199:
sub rsp, 1000h
or [rsp+1000h+var_1000], 0
cmp rsp, r11
jnz short loc_1199
sub rsp, 0E00h
mov [rbp+var_5DF4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+s]
mov edx, 2EE0h; n
mov esi, 0; c
mov rdi, rax; s
call _memset
mov [rbp+var_5DE8], 0
mov [rbp+var_5DE4], 2
jmp loc_12A4
loc_11F8:
mov eax, [rbp+var_5DE4]
cdqe
mov eax, [rbp+rax*4+s]
test eax, eax
jnz loc_129D
mov eax, [rbp+var_5DE4]
cdqe
mov [rbp+rax*4+s], 1
mov eax, [rbp+var_5DE4]
add eax, eax
mov [rbp+var_5DE0], eax
jmp short loc_1291
loc_1232:
mov eax, [rbp+var_5DE0]
cdqe
mov eax, [rbp+rax*4+s]
lea edx, [rax-1]
mov eax, [rbp+var_5DE0]
cdqe
mov [rbp+rax*4+s], edx
mov eax, [rbp+var_5DE0]
cdqe
mov eax, [rbp+rax*4+s]
cmp eax, 0FFFFFFFDh
jnz short loc_1285
mov eax, [rbp+var_5DE8]
lea edx, [rax+1]
mov [rbp+var_5DE8], edx
cdqe
mov edx, [rbp+var_5DE0]
mov [rbp+rax*4+var_2EF0], edx
loc_1285:
mov eax, [rbp+var_5DE4]
add [rbp+var_5DE0], eax
loc_1291:
cmp [rbp+var_5DE0], 0BB7h
jle short loc_1232
loc_129D:
add [rbp+var_5DE4], 1
loc_12A4:
cmp [rbp+var_5DE4], 0BB7h
jle loc_11F8
mov [rbp+var_5DDC], 0
jmp loc_136B
loc_12C3:
mov [rbp+var_5DD8], 0
jmp short loc_1349
loc_12CF:
mov eax, [rbp+var_5DD8]
cdqe
mov edx, [rbp+rax*4+var_2EF0]
mov eax, [rbp+var_5DD8]
add eax, 1
cdqe
mov eax, [rbp+rax*4+var_2EF0]
cmp edx, eax
jle short loc_1342
mov eax, [rbp+var_5DD8]
cdqe
mov eax, [rbp+rax*4+var_2EF0]
mov [rbp+var_5DD4], eax
mov eax, [rbp+var_5DD8]
add eax, 1
cdqe
mov edx, [rbp+rax*4+var_2EF0]
mov eax, [rbp+var_5DD8]
cdqe
mov [rbp+rax*4+var_2EF0], edx
mov eax, [rbp+var_5DD8]
add eax, 1
cdqe
mov edx, [rbp+var_5DD4]
mov [rbp+rax*4+var_2EF0], edx
loc_1342:
add [rbp+var_5DD8], 1
loc_1349:
mov eax, [rbp+var_5DE8]
sub eax, [rbp+var_5DDC]
sub eax, 1
cmp [rbp+var_5DD8], eax
jl loc_12CF
add [rbp+var_5DDC], 1
loc_136B:
mov eax, [rbp+var_5DE8]
sub eax, 1
cmp [rbp+var_5DDC], eax
jl loc_12C3
mov eax, [rbp+var_5DF4]
sub eax, 1
cdqe
mov eax, [rbp+rax*4+var_2EF0]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13A6
call ___stack_chk_fail
locret_13A6:
leave
retn | // bad sp value at call has been detected, the output may be wrong!
long long func0(int a1)
{
int v1; // eax
int v3; // [rsp+Ch] [rbp-5DE8h]
int i; // [rsp+10h] [rbp-5DE4h]
int j; // [rsp+14h] [rbp-5DE0h]
int k; // [rsp+18h] [rbp-5DDCh]
int m; // [rsp+1Ch] [rbp-5DD8h]
int v8; // [rsp+20h] [rbp-5DD4h]
_DWORD s[884]; // [rsp+24h] [rbp-5DD0h] BYREF
_BYTE v10[16384]; // [rsp+DF4h] [rbp-5000h] BYREF
_QWORD v11[512]; // [rsp+4DF4h] [rbp-1000h] BYREF
while ( v11 != (_QWORD *)v10 )
;
v11[511] = __readfsqword(0x28u);
memset(s, 0, 0x2EE0uLL);
v3 = 0;
for ( i = 2; i <= 2999; ++i )
{
if ( !s[i] )
{
s[i] = 1;
for ( j = 2 * i; j <= 2999; j += i )
{
if ( --s[j] == -3 )
{
v1 = v3++;
*(_DWORD *)&v10[4 * v1 + 8464] = j;
}
}
}
}
for ( k = 0; k < v3 - 1; ++k )
{
for ( m = 0; m < v3 - k - 1; ++m )
{
if ( *(_DWORD *)&v10[4 * m + 8464] > *(_DWORD *)&v10[4 * m + 8468] )
{
v8 = *(_DWORD *)&v10[4 * m + 8464];
*(_DWORD *)&v10[4 * m + 8464] = *(_DWORD *)&v10[4 * m + 8468];
*(_DWORD *)&v10[4 * m + 8468] = v8;
}
}
}
return *(unsigned int *)&v10[4 * a1 + 8460];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
LEA R11,[RSP + -0x5000]
LAB_00101199:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x00101199
SUB RSP,0xe00
MOV dword ptr [RBP + -0x5df4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x5dd0]
MOV EDX,0x2ee0
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0x5de8],0x0
MOV dword ptr [RBP + -0x5de4],0x2
JMP 0x001012a4
LAB_001011f8:
MOV EAX,dword ptr [RBP + -0x5de4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x5dd0]
TEST EAX,EAX
JNZ 0x0010129d
MOV EAX,dword ptr [RBP + -0x5de4]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x5dd0],0x1
MOV EAX,dword ptr [RBP + -0x5de4]
ADD EAX,EAX
MOV dword ptr [RBP + -0x5de0],EAX
JMP 0x00101291
LAB_00101232:
MOV EAX,dword ptr [RBP + -0x5de0]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x5dd0]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x5de0]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x5dd0],EDX
MOV EAX,dword ptr [RBP + -0x5de0]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x5dd0]
CMP EAX,-0x3
JNZ 0x00101285
MOV EAX,dword ptr [RBP + -0x5de8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x5de8],EDX
CDQE
MOV EDX,dword ptr [RBP + -0x5de0]
MOV dword ptr [RBP + RAX*0x4 + -0x2ef0],EDX
LAB_00101285:
MOV EAX,dword ptr [RBP + -0x5de4]
ADD dword ptr [RBP + -0x5de0],EAX
LAB_00101291:
CMP dword ptr [RBP + -0x5de0],0xbb7
JLE 0x00101232
LAB_0010129d:
ADD dword ptr [RBP + -0x5de4],0x1
LAB_001012a4:
CMP dword ptr [RBP + -0x5de4],0xbb7
JLE 0x001011f8
MOV dword ptr [RBP + -0x5ddc],0x0
JMP 0x0010136b
LAB_001012c3:
MOV dword ptr [RBP + -0x5dd8],0x0
JMP 0x00101349
LAB_001012cf:
MOV EAX,dword ptr [RBP + -0x5dd8]
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x2ef0]
MOV EAX,dword ptr [RBP + -0x5dd8]
ADD EAX,0x1
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x2ef0]
CMP EDX,EAX
JLE 0x00101342
MOV EAX,dword ptr [RBP + -0x5dd8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x2ef0]
MOV dword ptr [RBP + -0x5dd4],EAX
MOV EAX,dword ptr [RBP + -0x5dd8]
ADD EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x2ef0]
MOV EAX,dword ptr [RBP + -0x5dd8]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x2ef0],EDX
MOV EAX,dword ptr [RBP + -0x5dd8]
ADD EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + -0x5dd4]
MOV dword ptr [RBP + RAX*0x4 + -0x2ef0],EDX
LAB_00101342:
ADD dword ptr [RBP + -0x5dd8],0x1
LAB_00101349:
MOV EAX,dword ptr [RBP + -0x5de8]
SUB EAX,dword ptr [RBP + -0x5ddc]
SUB EAX,0x1
CMP dword ptr [RBP + -0x5dd8],EAX
JL 0x001012cf
ADD dword ptr [RBP + -0x5ddc],0x1
LAB_0010136b:
MOV EAX,dword ptr [RBP + -0x5de8]
SUB EAX,0x1
CMP dword ptr [RBP + -0x5ddc],EAX
JL 0x001012c3
MOV EAX,dword ptr [RBP + -0x5df4]
SUB EAX,0x1
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x2ef0]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013a6
CALL 0x00101070
LAB_001013a6:
LEAVE
RET | int func0(int param_1)
{
int iVar1;
int *puVar2;
int *puVar3;
long in_FS_OFFSET;
int local_5df0;
int local_5dec;
int local_5de8;
int local_5de4;
int local_5de0;
int local_5dd8 [884];
int local_5008 [8464];
int aiStack_2ef8 [3002];
long local_10;
puVar2 = &stack0xfffffffffffffff8;
do {
puVar3 = puVar2;
*(int8 *)(puVar3 + -0x1000) = *(int8 *)(puVar3 + -0x1000);
puVar2 = puVar3 + -0x1000;
} while (puVar3 + -0x1000 != local_5008);
local_10 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(puVar3 + -0x1e08) = 0x1011df;
memset(local_5dd8,0,12000);
local_5df0 = 0;
for (local_5dec = 2; local_5dec < 3000; local_5dec = local_5dec + 1) {
if (local_5dd8[local_5dec] == 0) {
local_5dd8[local_5dec] = 1;
for (local_5de8 = local_5dec * 2; local_5de8 < 3000; local_5de8 = local_5de8 + local_5dec) {
local_5dd8[local_5de8] = local_5dd8[local_5de8] + -1;
if (local_5dd8[local_5de8] == -3) {
aiStack_2ef8[local_5df0] = local_5de8;
local_5df0 = local_5df0 + 1;
}
}
}
}
for (local_5de4 = 0; local_5de4 < local_5df0 + -1; local_5de4 = local_5de4 + 1) {
for (local_5de0 = 0; local_5de0 < (local_5df0 - local_5de4) + -1; local_5de0 = local_5de0 + 1) {
if (aiStack_2ef8[local_5de0 + 1] < aiStack_2ef8[local_5de0]) {
iVar1 = aiStack_2ef8[local_5de0];
aiStack_2ef8[local_5de0] = aiStack_2ef8[local_5de0 + 1];
aiStack_2ef8[local_5de0 + 1] = iVar1;
}
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar3 + -0x1e08) = 0x1013a6;
__stack_chk_fail();
}
return aiStack_2ef8[param_1 + -1];
} |
4,381 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == 0) {
result[resultIndex++] = j;
}
j += i;
}
}
}
for (int i = 0; i < resultIndex - 1; i++) {
for (int j = 0; j < resultIndex - i - 1; j++) {
if (result[j] > result[j + 1]) {
int temp = result[j];
result[j] = result[j + 1];
result[j + 1] = temp;
}
}
}
return result[n - 1];
}
| int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 1196 <func0+0xd>
sub $0xdd0,%rsp
mov %edi,%ebx
mov %fs:0x28,%rax
mov %rax,0x5dc8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x2ee0,%edx
mov $0x0,%esi
callq 1090 <memset@plt>
mov $0x2,%ecx
mov $0x0,%edi
mov %rsp,%rsi
jmp 1218 <func0+0x8f>
add %rcx,%rax
cmp $0xbb7,%eax
jg 120b <func0+0x82>
mov (%rsi,%rax,4),%edx
sub $0x1,%edx
mov %edx,(%rsi,%rax,4)
cmp $0xfffffffd,%edx
jne 11e4 <func0+0x5b>
movslq %edi,%rdx
mov %eax,0x2ee0(%rsp,%rdx,4)
lea 0x1(%rdi),%edi
jmp 11e4 <func0+0x5b>
add $0x1,%rcx
cmp $0xbb8,%rcx
je 1235 <func0+0xac>
cmpl $0x0,(%rsi,%rcx,4)
jne 120b <func0+0x82>
movl $0x1,(%rsi,%rcx,4)
lea (%rcx,%rcx,1),%eax
cmp $0xbb7,%eax
jg 120b <func0+0x82>
lea (%rcx,%rcx,1),%rax
jmp 11ee <func0+0x65>
sub $0x1,%edi
test %edi,%edi
jle 1279 <func0+0xf0>
lea 0x2ee4(%rsp),%r8
jmp 1264 <func0+0xdb>
add $0x4,%rax
cmp %rax,%rsi
je 125f <func0+0xd6>
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 1246 <func0+0xbd>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
jmp 1246 <func0+0xbd>
sub $0x1,%edi
je 1279 <func0+0xf0>
test %edi,%edi
jle 125f <func0+0xd6>
lea 0x2ee0(%rsp),%rax
lea -0x1(%rdi),%edx
lea (%r8,%rdx,4),%rsi
jmp 124f <func0+0xc6>
lea -0x1(%rbx),%eax
cltq
mov 0x2ee0(%rsp,%rax,4),%eax
mov 0x5dc8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 12a1 <func0+0x118>
add $0x5dd0,%rsp
pop %rbx
retq
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
lea r11, [rsp+8+var_5008]
loc_1196:
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
cmp rsp, r11
jnz short loc_1196
sub rsp, 0DD0h
mov ebx, edi
mov rax, fs:28h
mov [rsp+1DD8h+arg_3FE8], rax
xor eax, eax
mov rdi, rsp
mov edx, 2EE0h
mov esi, 0
call _memset
mov r8d, 4
mov ecx, 2
mov edi, 0
mov rsi, rsp
jmp short loc_1222
loc_11EA:
add rax, rcx
cmp eax, 0BB7h
jg short loc_1211
loc_11F4:
mov edx, [rsi+rax*4]
sub edx, 1
mov [rsi+rax*4], edx
cmp edx, 0FFFFFFFDh
jnz short loc_11EA
movsxd rdx, edi
mov [rsp+rdx*4+1DD8h+arg_1100], eax
lea edi, [rdi+1]
jmp short loc_11EA
loc_1211:
add rcx, 1
add r8, 2
cmp rcx, 0BB8h
jz short loc_123D
loc_1222:
cmp dword ptr [rsi+rcx*4], 0
jnz short loc_1211
mov dword ptr [rsi+rcx*4], 1
cmp r8d, 0BB7h
jg short loc_1211
mov rax, r8
jmp short loc_11F4
loc_123D:
sub edi, 1
test edi, edi
jle short loc_1281
lea r8, [rsp+1DD8h+arg_1104]
jmp short loc_126C
loc_124E:
add rax, 4
cmp rsi, rax
jz short loc_1267
loc_1257:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_124E
mov [rax], ecx
mov [rax+4], edx
jmp short loc_124E
loc_1267:
sub edi, 1
jz short loc_1281
loc_126C:
test edi, edi
jle short loc_1267
lea rax, [rsp+1DD8h+arg_1100]
lea edx, [rdi-1]
lea rsi, [r8+rdx*4]
jmp short loc_1257
loc_1281:
lea eax, [rbx-1]
cdqe
mov eax, [rsp+rax*4+1DD8h+arg_1100]
mov rdx, [rsp+1DD8h+arg_3FE8]
sub rdx, fs:28h
jnz short loc_12A9
add rsp, 5DD0h
pop rbx
retn
loc_12A9:
call ___stack_chk_fail | // positive sp value has been detected, the output may be wrong!
long long func0(int a1)
{
long long v2; // r8
long long v3; // rcx
int v4; // edi
long long v5; // rax
int v6; // edx
int v7; // edi
_QWORD *v8; // rax
int v9; // edx
int v10; // ecx
_DWORD v12[884]; // [rsp-DD0h] [rbp-5DD8h] BYREF
char v13; // [rsp+0h] [rbp-5008h] BYREF
long long v14; // [rsp+1000h] [rbp-4008h] BYREF
_QWORD v15[1503]; // [rsp+2110h] [rbp-2EF8h] BYREF
while ( &v13 != (char *)(&v14 - 2560) )
;
v15[1501] = __readfsqword(0x28u);
((void ( *)(_DWORD *, _QWORD, long long))memset)(v12, 0LL, 12000LL);
v2 = 4LL;
v3 = 2LL;
v4 = 0;
do
{
if ( !v12[v3] )
{
v12[v3] = 1;
if ( (int)v2 <= 2999 )
{
v5 = v2;
do
{
v6 = v12[v5] - 1;
v12[v5] = v6;
if ( v6 == -3 )
*((_DWORD *)v15 + v4++) = v5;
v5 += v3;
}
while ( (int)v5 <= 2999 );
}
}
++v3;
v2 += 2LL;
}
while ( v3 != 3000 );
v7 = v4 - 1;
if ( v7 > 0 )
{
do
{
if ( v7 > 0 )
{
v8 = v15;
do
{
v9 = *(_DWORD *)v8;
v10 = *((_DWORD *)v8 + 1);
if ( *(_DWORD *)v8 > v10 )
{
*(_DWORD *)v8 = v10;
*((_DWORD *)v8 + 1) = v9;
}
v8 = (_QWORD *)((char *)v8 + 4);
}
while ( (_QWORD *)((char *)v15 + 4 * (unsigned int)(v7 - 1) + 4) != v8 );
}
--v7;
}
while ( v7 );
}
return *((unsigned int *)v15 + a1 - 1);
} | func0:
ENDBR64
PUSH RBX
LEA R11,[RSP + -0x5000]
LAB_00101196:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x00101196
SUB RSP,0xdd0
MOV EBX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x5dc8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x2ee0
MOV ESI,0x0
CALL 0x00101090
MOV R8D,0x4
MOV ECX,0x2
MOV EDI,0x0
MOV RSI,RSP
JMP 0x00101222
LAB_001011ea:
ADD RAX,RCX
CMP EAX,0xbb7
JG 0x00101211
LAB_001011f4:
MOV EDX,dword ptr [RSI + RAX*0x4]
SUB EDX,0x1
MOV dword ptr [RSI + RAX*0x4],EDX
CMP EDX,-0x3
JNZ 0x001011ea
MOVSXD RDX,EDI
MOV dword ptr [RSP + RDX*0x4 + 0x2ee0],EAX
LEA EDI,[RDI + 0x1]
JMP 0x001011ea
LAB_00101211:
ADD RCX,0x1
ADD R8,0x2
CMP RCX,0xbb8
JZ 0x0010123d
LAB_00101222:
CMP dword ptr [RSI + RCX*0x4],0x0
JNZ 0x00101211
MOV dword ptr [RSI + RCX*0x4],0x1
CMP R8D,0xbb7
JG 0x00101211
MOV RAX,R8
JMP 0x001011f4
LAB_0010123d:
SUB EDI,0x1
TEST EDI,EDI
JLE 0x00101281
LEA R8,[RSP + 0x2ee4]
JMP 0x0010126c
LAB_0010124e:
ADD RAX,0x4
CMP RSI,RAX
JZ 0x00101267
LAB_00101257:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x0010124e
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
JMP 0x0010124e
LAB_00101267:
SUB EDI,0x1
JZ 0x00101281
LAB_0010126c:
TEST EDI,EDI
JLE 0x00101267
LEA RAX,[RSP + 0x2ee0]
LEA EDX,[RDI + -0x1]
LEA RSI,[R8 + RDX*0x4]
JMP 0x00101257
LAB_00101281:
LEA EAX,[RBX + -0x1]
CDQE
MOV EAX,dword ptr [RSP + RAX*0x4 + 0x2ee0]
MOV RDX,qword ptr [RSP + 0x5dc8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012a9
ADD RSP,0x5dd0
POP RBX
RET
LAB_001012a9:
CALL 0x00101070 | int4 func0(int param_1)
{
int1 *puVar1;
int iVar2;
long lVar3;
int *piVar4;
long lVar5;
int1 *puVar6;
int iVar7;
long lVar8;
long in_FS_OFFSET;
int aiStack_5dd0 [882];
int1 local_5008 [20480];
puVar1 = &stack0xfffffffffffffff8;
do {
puVar6 = puVar1;
*(int8 *)(puVar6 + -0x1000) = *(int8 *)(puVar6 + -0x1000);
puVar1 = puVar6 + -0x1000;
} while (puVar6 + -0x1000 != local_5008);
*(int8 *)(puVar6 + 0x3ff8) = *(int8 *)(in_FS_OFFSET + 0x28);
*(int8 *)(puVar6 + -0x1dd8) = 0x1011d5;
memset(puVar6 + -0x1dd0,0,12000);
lVar8 = 4;
lVar5 = 2;
iVar7 = 0;
do {
if (*(int *)(puVar6 + lVar5 * 4 + -0x1dd0) == 0) {
*(int4 *)(puVar6 + lVar5 * 4 + -0x1dd0) = 1;
iVar2 = (int)lVar8;
lVar3 = lVar8;
while (iVar2 < 3000) {
iVar2 = *(int *)(puVar6 + lVar3 * 4 + -0x1dd0);
*(int *)(puVar6 + lVar3 * 4 + -0x1dd0) = iVar2 + -1;
if (iVar2 + -1 == -3) {
*(int *)(puVar6 + (long)iVar7 * 4 + 0x1110) = (int)lVar3;
iVar7 = iVar7 + 1;
}
lVar3 = lVar3 + lVar5;
iVar2 = (int)lVar3;
}
}
lVar5 = lVar5 + 1;
lVar8 = lVar8 + 2;
} while (lVar5 != 3000);
iVar7 = iVar7 + -1;
if (0 < iVar7) {
do {
if (0 < iVar7) {
piVar4 = (int *)(puVar6 + 0x1110);
do {
iVar2 = *piVar4;
if (piVar4[1] < iVar2) {
*piVar4 = piVar4[1];
piVar4[1] = iVar2;
}
piVar4 = piVar4 + 1;
} while ((int *)(puVar6 + (ulong)(iVar7 - 1) * 4 + 0x1114) != piVar4);
}
iVar7 = iVar7 + -1;
} while (iVar7 != 0);
}
if (*(long *)(puVar6 + 0x3ff8) != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + -0x1dd8) = main;
__stack_chk_fail();
}
return *(int4 *)(puVar6 + (long)(param_1 + -1) * 4 + 0x1110);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.