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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,182 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void print_array(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) printf(", ");
}
printf("]\n");
}
int arrays_equal(int a[], int b[], int sizeA, int sizeB) {
if (sizeA != sizeB) return 0;
for (int i = 0; i < sizeA; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
| int* func0(int nums[], int size, int *returnSize) {
int *result = (int*)malloc(size * sizeof(int));
int k = 0;
for (int i = 0; i < size; i++) {
int count = 0;
for (int j = 0; j < size; j++) {
if (nums[i] == nums[j]) {
count++;
}
}
if (count == 1) {
result[k++] = nums[i];
}
}
*returnSize = k;
return result;
}
| int main() {
int sz;
int testArr1[] = {1, 2, 3, 2, 3, 4, 5};
int expected1[] = {1, 4, 5};
int* result1 = func0(testArr1, 7, &sz);
assert(arrays_equal(result1, expected1, sz, 3));
int testArr2[] = {1, 2, 3, 2, 4, 5};
int expected2[] = {1, 3, 4, 5};
int* result2 = func0(testArr2, 6, &sz);
assert(arrays_equal(result2, expected2, sz, 4));
int testArr3[] = {1, 2, 3, 4, 5};
int expected3[] = {1, 2, 3, 4, 5};
int* result3 = func0(testArr3, 5, &sz);
assert(arrays_equal(result3, expected3, sz, 5));
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 1100 <malloc@plt>
test %ebp,%ebp
jle 15b6 <func0+0x76>
lea -0x1(%rbp),%edx
mov %rbx,%r10
xor %r11d,%r11d
lea 0x4(%rbx,%rdx,4),%r9
mov (%r10),%r8d
mov %rbx,%rcx
xor %esi,%esi
nopl 0x0(%rax,%rax,1)
xor %edi,%edi
cmp (%rcx),%r8d
sete %dil
add $0x4,%rcx
add %edi,%esi
cmp %r9,%rcx
jne 1580 <func0+0x40>
cmp $0x1,%esi
jne 15a4 <func0+0x64>
movslq %r11d,%rcx
add $0x1,%r11d
mov %r8d,(%rax,%rcx,4)
add $0x4,%r10
cmp %r9,%r10
jne 1570 <func0+0x30>
pop %rbx
pop %rbp
mov %r11d,(%r12)
pop %r12
retq
xor %r11d,%r11d
pop %rbx
pop %rbp
mov %r11d,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_15B4
lea edx, [rbp-1]
mov r9, rbx
xor r10d, r10d
lea r8, [rbx+rdx*4+4]
nop
loc_1570:
mov edi, [r9]
mov rdx, rbx
xor ecx, ecx
nop dword ptr [rax+rax+00000000h]
loc_1580:
xor esi, esi
cmp edi, [rdx]
setz sil
add rdx, 4
add ecx, esi
cmp rdx, r8
jnz short loc_1580
cmp ecx, 1
jnz short loc_15A2
movsxd rdx, r10d
add r10d, 1
mov [rax+rdx*4], edi
loc_15A2:
add r9, 4
cmp r9, r8
jnz short loc_1570
pop rbx
pop rbp
mov [r12], r10d
pop r12
retn
loc_15B4:
xor r10d, r10d
pop rbx
pop rbp
mov [r12], r10d
pop r12
retn | long long func0(int *a1, int a2, _DWORD *a3)
{
long long result; // rax
int *v6; // r9
int v7; // r10d
long long v8; // r8
int v9; // edi
int *v10; // rdx
int v11; // ecx
int v12; // esi
long long v13; // rdx
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
v8 = (long long)&a1[a2 - 1 + 1];
do
{
v9 = *v6;
v10 = a1;
v11 = 0;
do
{
v12 = v9 == *v10++;
v11 += v12;
}
while ( v10 != (int *)v8 );
if ( v11 == 1 )
{
v13 = v7++;
*(_DWORD *)(result + 4 * v13) = v9;
}
++v6;
}
while ( v6 != (int *)v8 );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
CALL 0x00101100
TEST EBP,EBP
JLE 0x001015b4
LEA EDX,[RBP + -0x1]
MOV R9,RBX
XOR R10D,R10D
LEA R8,[RBX + RDX*0x4 + 0x4]
NOP
LAB_00101570:
MOV EDI,dword ptr [R9]
MOV RDX,RBX
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101580:
XOR ESI,ESI
CMP EDI,dword ptr [RDX]
SETZ SIL
ADD RDX,0x4
ADD ECX,ESI
CMP RDX,R8
JNZ 0x00101580
CMP ECX,0x1
JNZ 0x001015a2
MOVSXD RDX,R10D
ADD R10D,0x1
MOV dword ptr [RAX + RDX*0x4],EDI
LAB_001015a2:
ADD R9,0x4
CMP R9,R8
JNZ 0x00101570
POP RBX
POP RBP
MOV dword ptr [R12],R10D
POP R12
RET
LAB_001015b4:
XOR R10D,R10D
POP RBX
POP RBP
MOV dword ptr [R12],R10D
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
int iVar3;
int *piVar4;
long lVar5;
int *piVar6;
int iVar7;
pvVar2 = malloc((long)param_2 << 2);
if (0 < param_2) {
iVar7 = 0;
piVar6 = param_1;
do {
iVar3 = 0;
piVar4 = param_1;
do {
iVar1 = *piVar4;
piVar4 = piVar4 + 1;
iVar3 = iVar3 + (uint)(*piVar6 == iVar1);
} while (piVar4 != param_1 + (ulong)(param_2 - 1) + 1);
if (iVar3 == 1) {
lVar5 = (long)iVar7;
iVar7 = iVar7 + 1;
*(int *)((long)pvVar2 + lVar5 * 4) = *piVar6;
}
piVar6 = piVar6 + 1;
} while (piVar6 != param_1 + (ulong)(param_2 - 1) + 1);
*param_3 = iVar7;
return;
}
*param_3 = 0;
return;
} |
6,183 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void print_array(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) printf(", ");
}
printf("]\n");
}
int arrays_equal(int a[], int b[], int sizeA, int sizeB) {
if (sizeA != sizeB) return 0;
for (int i = 0; i < sizeA; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
| int* func0(int nums[], int size, int *returnSize) {
int *result = (int*)malloc(size * sizeof(int));
int k = 0;
for (int i = 0; i < size; i++) {
int count = 0;
for (int j = 0; j < size; j++) {
if (nums[i] == nums[j]) {
count++;
}
}
if (count == 1) {
result[k++] = nums[i];
}
}
*returnSize = k;
return result;
}
| int main() {
int sz;
int testArr1[] = {1, 2, 3, 2, 3, 4, 5};
int expected1[] = {1, 4, 5};
int* result1 = func0(testArr1, 7, &sz);
assert(arrays_equal(result1, expected1, sz, 3));
int testArr2[] = {1, 2, 3, 2, 4, 5};
int expected2[] = {1, 3, 4, 5};
int* result2 = func0(testArr2, 6, &sz);
assert(arrays_equal(result2, expected2, sz, 4));
int testArr3[] = {1, 2, 3, 4, 5};
int expected3[] = {1, 2, 3, 4, 5};
int* result3 = func0(testArr3, 5, &sz);
assert(arrays_equal(result3, expected3, sz, 5));
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 1100 <malloc@plt>
mov %rax,%r13
test %ebp,%ebp
jle 16ca <func0+0x14a>
mov %ebp,%edi
lea -0x1(%rbp),%edx
mov %ebp,%esi
mov %rbx,%r10
shr $0x2,%edi
mov %rdx,%rax
and $0xfffffffc,%esi
xor %r11d,%r11d
shl $0x4,%rdi
lea 0x4(%rbx,%rdx,4),%rdx
add %rbx,%rdi
nopl 0x0(%rax)
mov (%r10),%r9d
cmp $0x3,%eax
jbe 16c0 <func0+0x140>
movd %r9d,%xmm3
mov %rbx,%rcx
pxor %xmm1,%xmm1
pshufd $0x0,%xmm3,%xmm2
nopl (%rax)
movdqu (%rcx),%xmm0
add $0x10,%rcx
pcmpeqd %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rcx,%rdi
jne 15f8 <func0+0x78>
movdqa %xmm1,%xmm0
mov %esi,%r8d
psrldq $0x8,%xmm0
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%ecx
cmp %ebp,%esi
je 1688 <func0+0x108>
movslq %r8d,%r15
cmp (%rbx,%r15,4),%r9d
lea 0x0(,%r15,4),%r14
sete %r15b
movzbl %r15b,%r15d
add %r15d,%ecx
lea 0x1(%r8),%r15d
cmp %ebp,%r15d
jge 1688 <func0+0x108>
cmp 0x4(%rbx,%r14,1),%r9d
jne 165f <func0+0xdf>
add $0x1,%ecx
lea 0x2(%r8),%r15d
cmp %ebp,%r15d
jge 1688 <func0+0x108>
cmp 0x8(%rbx,%r14,1),%r9d
jne 1672 <func0+0xf2>
add $0x1,%ecx
add $0x3,%r8d
cmp %r8d,%ebp
jle 1688 <func0+0x108>
cmp 0xc(%rbx,%r14,1),%r9d
jne 1688 <func0+0x108>
add $0x1,%ecx
nopl (%rax)
cmp $0x1,%ecx
jne 1699 <func0+0x119>
movslq %r11d,%rcx
add $0x1,%r11d
mov %r9d,0x0(%r13,%rcx,4)
add $0x4,%r10
cmp %rdx,%r10
jne 15d8 <func0+0x58>
mov %r11d,(%r12)
add $0x8,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
xor %r8d,%r8d
xor %ecx,%ecx
jmpq 1632 <func0+0xb2>
xor %r11d,%r11d
jmp 16a6 <func0+0x126>
| func0:
endbr64
push r15
movsxd r9, esi
push r14
lea r14, ds:0[r9*4]
push r13
push r12
mov r12, rdx
push rbp
mov rbp, r9
push rbx
mov rbx, rdi
mov rdi, r14; size
sub rsp, 8
call _malloc
mov r13, rax
test ebp, ebp
jle loc_1686
mov edx, ebp
mov r8d, ebp
lea r9, [r14+rbx]
mov rdi, rbx
shr edx, 2
lea r11d, [rbp-1]
and r8d, 0FFFFFFFCh
xor r10d, r10d
shl rdx, 4
add rdx, rbx
nop word ptr [rax+rax+00h]
loc_15B0:
mov esi, [rdi]
cmp r11d, 2
jbe loc_1680
movd xmm3, esi
mov rax, rbx
pxor xmm1, xmm1
pshufd xmm2, xmm3, 0
nop dword ptr [rax+00h]
loc_15D0:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rdx, rax
jnz short loc_15D0
movdqa xmm0, xmm1
mov ecx, r8d
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
cmp ebp, r8d
jz short loc_1643
loc_160B:
movsxd r15, ecx
lea r14, ds:0[r15*4]
cmp esi, [rbx+r15*4]
jnz short loc_161F
add eax, 1
loc_161F:
lea r15d, [rcx+1]
cmp ebp, r15d
jle short loc_1643
cmp esi, [rbx+r14+4]
jnz short loc_1632
add eax, 1
loc_1632:
add ecx, 2
cmp ebp, ecx
jle short loc_1643
cmp esi, [rbx+r14+8]
jnz short loc_1643
add eax, 1
loc_1643:
cmp eax, 1
jnz short loc_1654
movsxd rax, r10d
add r10d, 1
mov [r13+rax*4+0], esi
loc_1654:
add rdi, 4
cmp r9, rdi
jnz loc_15B0
loc_1661:
mov [r12], r10d
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1680:
xor ecx, ecx
xor eax, eax
jmp short loc_160B
loc_1686:
xor r10d, r10d
jmp short loc_1661 | _DWORD * func0(unsigned int *a1, int a2, _DWORD *a3)
{
const __m128i *v5; // rbx
_DWORD *v6; // r13
unsigned int *v7; // r9
int v8; // r10d
unsigned int v9; // esi
const __m128i *v10; // rax
__m128i v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm0
int v14; // ecx
__m128i v15; // xmm1
int v16; // eax
long long v17; // r14
long long v18; // rax
v5 = (const __m128i *)a1;
v6 = malloc(4LL * a2);
if ( a2 > 0 )
{
v7 = &a1[a2];
v8 = 0;
while ( 1 )
{
v9 = *a1;
if ( (unsigned int)(a2 - 1) <= 2 )
break;
v10 = v5;
v11 = 0LL;
v12 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v9), 0);
do
{
v13 = _mm_loadu_si128(v10++);
v11 = _mm_sub_epi32(v11, _mm_cmpeq_epi32(v13, v12));
}
while ( &v5[(unsigned int)a2 >> 2] != v10 );
v14 = a2 & 0x7FFFFFFC;
v15 = _mm_add_epi32(v11, _mm_srli_si128(v11, 8));
v16 = _mm_cvtsi128_si32(_mm_add_epi32(v15, _mm_srli_si128(v15, 4)));
if ( a2 != (a2 & 0xFFFFFFFC) )
goto LABEL_7;
LABEL_15:
if ( v16 == 1 )
{
v18 = v8++;
v6[v18] = v9;
}
if ( v7 == ++a1 )
goto LABEL_18;
}
v14 = 0;
v16 = 0;
LABEL_7:
v17 = v14;
if ( v9 == v5->m128i_i32[v17] )
++v16;
if ( a2 > v14 + 1 )
{
if ( v9 == v5->m128i_i32[v17 + 1] )
++v16;
if ( a2 > v14 + 2 && v9 == v5->m128i_i32[v17 + 2] )
++v16;
}
goto LABEL_15;
}
v8 = 0;
LABEL_18:
*a3 = v8;
return v6;
} | func0:
ENDBR64
PUSH R15
MOVSXD R9,ESI
PUSH R14
LEA R14,[R9*0x4]
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,R9
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x8
CALL 0x00101100
MOV R13,RAX
TEST EBP,EBP
JLE 0x00101686
MOV EDX,EBP
MOV R8D,EBP
LEA R9,[R14 + RBX*0x1]
MOV RDI,RBX
SHR EDX,0x2
LEA R11D,[RBP + -0x1]
AND R8D,0xfffffffc
XOR R10D,R10D
SHL RDX,0x4
ADD RDX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_001015b0:
MOV ESI,dword ptr [RDI]
CMP R11D,0x2
JBE 0x00101680
MOVD XMM3,ESI
MOV RAX,RBX
PXOR XMM1,XMM1
PSHUFD XMM2,XMM3,0x0
NOP dword ptr [RAX]
LAB_001015d0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RDX,RAX
JNZ 0x001015d0
MOVDQA XMM0,XMM1
MOV ECX,R8D
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
CMP EBP,R8D
JZ 0x00101643
LAB_0010160b:
MOVSXD R15,ECX
LEA R14,[R15*0x4]
CMP ESI,dword ptr [RBX + R15*0x4]
JNZ 0x0010161f
ADD EAX,0x1
LAB_0010161f:
LEA R15D,[RCX + 0x1]
CMP EBP,R15D
JLE 0x00101643
CMP ESI,dword ptr [RBX + R14*0x1 + 0x4]
JNZ 0x00101632
ADD EAX,0x1
LAB_00101632:
ADD ECX,0x2
CMP EBP,ECX
JLE 0x00101643
CMP ESI,dword ptr [RBX + R14*0x1 + 0x8]
JNZ 0x00101643
ADD EAX,0x1
LAB_00101643:
CMP EAX,0x1
JNZ 0x00101654
MOVSXD RAX,R10D
ADD R10D,0x1
MOV dword ptr [R13 + RAX*0x4],ESI
LAB_00101654:
ADD RDI,0x4
CMP R9,RDI
JNZ 0x001015b0
LAB_00101661:
MOV dword ptr [R12],R10D
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101680:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x0010160b
LAB_00101686:
XOR R10D,R10D
JMP 0x00101661 | void * func0(int *param_1,uint param_2,int *param_3)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
void *pvVar6;
int *piVar7;
long lVar8;
uint uVar9;
int *piVar10;
ulong uVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
uVar11 = (ulong)(int)param_2;
pvVar6 = malloc(uVar11 * 4);
if ((int)param_2 < 1) {
iVar12 = 0;
}
else {
iVar12 = 0;
piVar10 = param_1;
do {
iVar1 = *piVar10;
if (param_2 - 1 < 3) {
uVar9 = 0;
iVar13 = 0;
LAB_0010160b:
if (iVar1 == param_1[(int)uVar9]) {
iVar13 = iVar13 + 1;
}
if ((int)(uVar9 + 1) < (int)param_2) {
if (iVar1 == param_1[(long)(int)uVar9 + 1]) {
iVar13 = iVar13 + 1;
}
if (((int)(uVar9 + 2) < (int)param_2) && (iVar1 == param_1[(long)(int)uVar9 + 2])) {
iVar13 = iVar13 + 1;
}
}
}
else {
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
iVar16 = 0;
piVar7 = param_1;
do {
iVar2 = *piVar7;
piVar3 = piVar7 + 1;
piVar4 = piVar7 + 2;
piVar5 = piVar7 + 3;
piVar7 = piVar7 + 4;
iVar13 = iVar13 + (uint)(iVar2 == iVar1);
iVar14 = iVar14 + (uint)(*piVar3 == iVar1);
iVar15 = iVar15 + (uint)(*piVar4 == iVar1);
iVar16 = iVar16 + (uint)(*piVar5 == iVar1);
} while (param_1 + (uVar11 >> 2 & 0x3fffffff) * 4 != piVar7);
iVar13 = iVar13 + iVar15 + iVar14 + iVar16;
uVar9 = param_2 & 0xfffffffc;
if (param_2 != (param_2 & 0xfffffffc)) goto LAB_0010160b;
}
if (iVar13 == 1) {
lVar8 = (long)iVar12;
iVar12 = iVar12 + 1;
*(int *)((long)pvVar6 + lVar8 * 4) = iVar1;
}
piVar10 = piVar10 + 1;
} while (param_1 + uVar11 != piVar10);
}
*param_3 = iVar12;
return pvVar6;
} |
6,184 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1c0,%rsp
mov %rdi,-0x1b8(%rbp)
mov %esi,-0x1bc(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x1,-0x1a8(%rbp)
lea -0x1a0(%rbp),%rdx
mov $0x0,%eax
mov $0x32,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
mov %rdi,%rdx
mov %eax,(%rdx)
add $0x4,%rdx
movl $0x0,-0x1a4(%rbp)
jmpq 1251 <func0+0xe8>
mov -0x1a4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x1b8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
test %eax,%eax
jne 124a <func0+0xe1>
mov -0x1a4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x1b8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x1a8(%rbp),%edx
imul %edx,%eax
mov %eax,-0x1a8(%rbp)
mov -0x1a4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x1b8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
movl $0x1,-0x1a0(%rbp,%rax,4)
addl $0x1,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1bc(%rbp),%eax
jl 11cd <func0+0x64>
mov -0x1a8(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 127d <func0+0x114>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_1B8], rdi
mov [rbp+var_1BC], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1A8], 1
lea rdx, [rbp+var_1A0]
mov eax, 0
mov ecx, 32h ; '2'
mov rdi, rdx
rep stosq
mov rdx, rdi
mov [rdx], eax
add rdx, 4
mov [rbp+var_1A4], 0
jmp loc_1251
loc_11CD:
mov eax, [rbp+var_1A4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_1B8]
add rax, rdx
mov eax, [rax]
cdqe
mov eax, [rbp+rax*4+var_1A0]
test eax, eax
jnz short loc_124A
mov eax, [rbp+var_1A4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_1B8]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_1A8]
imul eax, edx
mov [rbp+var_1A8], eax
mov eax, [rbp+var_1A4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_1B8]
add rax, rdx
mov eax, [rax]
cdqe
mov [rbp+rax*4+var_1A0], 1
loc_124A:
add [rbp+var_1A4], 1
loc_1251:
mov eax, [rbp+var_1A4]
cmp eax, [rbp+var_1BC]
jl loc_11CD
mov eax, [rbp+var_1A8]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_127D
call ___stack_chk_fail
locret_127D:
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-1A8h]
int i; // [rsp+1Ch] [rbp-1A4h]
_DWORD v5[102]; // [rsp+20h] [rbp-1A0h] BYREF
unsigned long long v6; // [rsp+1B8h] [rbp-8h]
v6 = __readfsqword(0x28u);
v3 = 1;
memset(v5, 0, 404);
for ( i = 0; i < a2; ++i )
{
if ( !v5[*(int *)(4LL * i + a1)] )
{
v3 *= *(_DWORD *)(4LL * i + a1);
v5[*(int *)(4LL * i + a1)] = 1;
}
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV qword ptr [RBP + -0x1b8],RDI
MOV dword ptr [RBP + -0x1bc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1a8],0x1
LEA RDX,[RBP + -0x1a0]
MOV EAX,0x0
MOV ECX,0x32
MOV RDI,RDX
STOSQ.REP RDI
MOV RDX,RDI
MOV dword ptr [RDX],EAX
ADD RDX,0x4
MOV dword ptr [RBP + -0x1a4],0x0
JMP 0x00101251
LAB_001011cd:
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x1b8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
TEST EAX,EAX
JNZ 0x0010124a
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x1b8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x1a8]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x1a8],EAX
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x1b8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1a0],0x1
LAB_0010124a:
ADD dword ptr [RBP + -0x1a4],0x1
LAB_00101251:
MOV EAX,dword ptr [RBP + -0x1a4]
CMP EAX,dword ptr [RBP + -0x1bc]
JL 0x001011cd
MOV EAX,dword ptr [RBP + -0x1a8]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010127d
CALL 0x00101060
LAB_0010127d:
LEAVE
RET | int func0(long param_1,int param_2)
{
long lVar1;
int *piVar2;
long in_FS_OFFSET;
int local_1b0;
int local_1ac;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1b0 = 1;
piVar2 = local_1a8;
for (lVar1 = 0x32; lVar1 != 0; lVar1 = lVar1 + -1) {
piVar2[0] = 0;
piVar2[1] = 0;
piVar2 = piVar2 + 2;
}
*piVar2 = 0;
for (local_1ac = 0; local_1ac < param_2; local_1ac = local_1ac + 1) {
if (local_1a8[*(int *)(param_1 + (long)local_1ac * 4)] == 0) {
local_1b0 = *(int *)(param_1 + (long)local_1ac * 4) * local_1b0;
local_1a8[*(int *)(param_1 + (long)local_1ac * 4)] = 1;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1b0;
} |
6,185 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x32,%ecx
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %esi,%esi
jle 11d1 <func0+0x68>
mov %rdx,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdx,%rcx,4),%rdi
mov $0x1,%esi
jmp 11ba <func0+0x51>
add $0x4,%rax
cmp %rdi,%rax
je 11d6 <func0+0x6d>
mov (%rax),%edx
movslq %edx,%rcx
cmpl $0x0,(%rsp,%rcx,4)
jne 11b1 <func0+0x48>
imul %edx,%esi
movl $0x1,(%rsp,%rcx,4)
jmp 11b1 <func0+0x48>
mov $0x1,%esi
mov 0x198(%rsp),%rax
xor %fs:0x28,%rax
jne 11f3 <func0+0x8a>
mov %esi,%eax
add $0x1a8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
sub rsp, 1A8h
mov rdx, rdi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 32h ; '2'
rep stosq
mov dword ptr [rdi], 0
test esi, esi
jle short loc_11D1
mov rax, rdx
lea ecx, [rsi-1]
lea rdi, [rdx+rcx*4+4]
mov esi, 1
jmp short loc_11BA
loc_11B1:
add rax, 4
cmp rax, rdi
jz short loc_11D6
loc_11BA:
mov edx, [rax]
movsxd rcx, edx
cmp [rsp+rcx*4+1A8h+var_1A8], 0
jnz short loc_11B1
imul esi, edx
mov [rsp+rcx*4+1A8h+var_1A8], 1
jmp short loc_11B1
loc_11D1:
mov esi, 1
loc_11D6:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_11F3
mov eax, esi
add rsp, 1A8h
retn
loc_11F3:
call ___stack_chk_fail | long long func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rdi
unsigned int v4; // esi
int v5; // edx
_DWORD v7[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v8; // [rsp+198h] [rbp-10h]
v8 = __readfsqword(0x28u);
memset(v7, 0, 404);
if ( a2 <= 0 )
{
return 1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 1;
do
{
v5 = *v2;
if ( !v7[*v2] )
{
v4 *= v5;
v7[v5] = 1;
}
++v2;
}
while ( v2 != (int *)v3 );
}
return v4;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV RDX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x32
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST ESI,ESI
JLE 0x001011d1
MOV RAX,RDX
LEA ECX,[RSI + -0x1]
LEA RDI,[RDX + RCX*0x4 + 0x4]
MOV ESI,0x1
JMP 0x001011ba
LAB_001011b1:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011d6
LAB_001011ba:
MOV EDX,dword ptr [RAX]
MOVSXD RCX,EDX
CMP dword ptr [RSP + RCX*0x4],0x0
JNZ 0x001011b1
IMUL ESI,EDX
MOV dword ptr [RSP + RCX*0x4],0x1
JMP 0x001011b1
LAB_001011d1:
MOV ESI,0x1
LAB_001011d6:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001011f3
MOV EAX,ESI
ADD RSP,0x1a8
RET
LAB_001011f3:
CALL 0x00101060 | int func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
int iVar3;
int *piVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_1a8;
for (lVar2 = 0x32; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (int *)((long)piVar4 + 8);
}
*piVar4 = 0;
if (param_2 < 1) {
iVar3 = 1;
}
else {
piVar4 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 1;
do {
iVar1 = *param_1;
if (local_1a8[iVar1] == 0) {
iVar3 = iVar3 * iVar1;
local_1a8[iVar1] = 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar4);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,186 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %rdi,%rdx
mov $0x32,%ecx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %esi,%esi
jle 1430 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdx,%rdi
mov $0x1,%r8d
lea 0x4(%rdx,%rax,4),%rcx
nopw 0x0(%rax,%rax,1)
movslq (%rdi),%rax
mov (%rsp,%rax,4),%esi
test %esi,%esi
jne 1405 <func0+0x65>
imul %eax,%r8d
movl $0x1,(%rsp,%rax,4)
add $0x4,%rdi
cmp %rcx,%rdi
jne 13f0 <func0+0x50>
mov 0x198(%rsp),%rax
xor %fs:0x28,%rax
jne 1438 <func0+0x98>
mov %r8d,%eax
add $0x1a8,%rsp
retq
nopl 0x0(%rax)
mov $0x1,%r8d
jmp 140e <func0+0x6e>
callq 1060 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
sub rsp, 1A8h
mov rdx, rdi
mov ecx, 32h ; '2'
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test esi, esi
jle short loc_1360
lea eax, [rsi-1]
mov rdi, rdx
mov r8d, 1
lea rcx, [rdx+rax*4+4]
nop word ptr [rax+rax+00000000h]
loc_1320:
movsxd rax, dword ptr [rdi]
mov esi, [rsp+rax*4+1A8h+var_1A8]
test esi, esi
jnz short loc_1335
imul r8d, eax
mov [rsp+rax*4+1A8h+var_1A8], 1
loc_1335:
add rdi, 4
cmp rdi, rcx
jnz short loc_1320
loc_133E:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_1368
mov eax, r8d
add rsp, 1A8h
retn
loc_1360:
mov r8d, 1
jmp short loc_133E
loc_1368:
call ___stack_chk_fail | long long func0(int *a1, int a2)
{
int *v2; // rdx
unsigned int v3; // r8d
long long v4; // rax
_DWORD v6[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v7; // [rsp+198h] [rbp-10h]
v2 = a1;
v7 = __readfsqword(0x28u);
memset(v6, 0, 404);
if ( a2 <= 0 )
{
return 1;
}
else
{
v3 = 1;
do
{
v4 = *a1;
if ( !v6[v4] )
{
v3 *= (_DWORD)v4;
v6[v4] = 1;
}
++a1;
}
while ( a1 != &v2[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV RDX,RDI
MOV ECX,0x32
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST ESI,ESI
JLE 0x00101360
LEA EAX,[RSI + -0x1]
MOV RDI,RDX
MOV R8D,0x1
LEA RCX,[RDX + RAX*0x4 + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101320:
MOVSXD RAX,dword ptr [RDI]
MOV ESI,dword ptr [RSP + RAX*0x4]
TEST ESI,ESI
JNZ 0x00101335
IMUL R8D,EAX
MOV dword ptr [RSP + RAX*0x4],0x1
LAB_00101335:
ADD RDI,0x4
CMP RDI,RCX
JNZ 0x00101320
LAB_0010133e:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101368
MOV EAX,R8D
ADD RSP,0x1a8
RET
LAB_00101360:
MOV R8D,0x1
JMP 0x0010133e
LAB_00101368:
CALL 0x00101060 | int func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
int *piVar3;
int iVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_1a8;
for (lVar2 = 0x32; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (int *)((long)piVar3 + 8);
}
*piVar3 = 0;
if (param_2 < 1) {
iVar4 = 1;
}
else {
iVar4 = 1;
piVar3 = param_1 + (ulong)(param_2 - 1) + 1;
do {
iVar1 = *param_1;
if (local_1a8[iVar1] == 0) {
iVar4 = iVar4 * iVar1;
local_1a8[iVar1] = 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar3);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,187 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %rdi,%rdx
mov $0x32,%ecx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %esi,%esi
jle 14a0 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdx,%rdi
mov $0x1,%r8d
lea 0x4(%rdx,%rax,4),%rcx
nopw 0x0(%rax,%rax,1)
movslq (%rdi),%rax
mov (%rsp,%rax,4),%esi
test %esi,%esi
jne 1475 <func0+0x65>
imul %eax,%r8d
movl $0x1,(%rsp,%rax,4)
add $0x4,%rdi
cmp %rcx,%rdi
jne 1460 <func0+0x50>
mov 0x198(%rsp),%rax
xor %fs:0x28,%rax
jne 14a8 <func0+0x98>
mov %r8d,%eax
add $0x1a8,%rsp
retq
nopl 0x0(%rax)
mov $0x1,%r8d
jmp 147e <func0+0x6e>
callq 1060 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
sub rsp, 1A8h
mov rdx, rdi
mov ecx, 32h ; '2'
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test esi, esi
jle short loc_11E8
movsxd rsi, esi
mov rdi, rdx
mov ecx, 1
lea rsi, [rdx+rsi*4]
nop dword ptr [rax]
loc_11A8:
movsxd rax, dword ptr [rdi]
mov r8d, [rsp+rax*4+1A8h+var_1A8]
test r8d, r8d
jnz short loc_11BE
imul ecx, eax
mov [rsp+rax*4+1A8h+var_1A8], 1
loc_11BE:
add rdi, 4
cmp rdi, rsi
jnz short loc_11A8
loc_11C7:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_11EF
mov eax, ecx
add rsp, 1A8h
retn
loc_11E8:
mov ecx, 1
jmp short loc_11C7
loc_11EF:
call ___stack_chk_fail | long long func0(int *a1, int a2)
{
unsigned int v2; // ecx
int *v3; // rsi
long long v4; // rax
_DWORD v6[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v7; // [rsp+198h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 404);
if ( a2 <= 0 )
{
return 1;
}
else
{
v2 = 1;
v3 = &a1[a2];
do
{
v4 = *a1;
if ( !v6[v4] )
{
v2 *= (_DWORD)v4;
v6[v4] = 1;
}
++a1;
}
while ( a1 != v3 );
}
return v2;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV RDX,RDI
MOV ECX,0x32
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST ESI,ESI
JLE 0x001011e8
MOVSXD RSI,ESI
MOV RDI,RDX
MOV ECX,0x1
LEA RSI,[RDX + RSI*0x4]
NOP dword ptr [RAX]
LAB_001011a8:
MOVSXD RAX,dword ptr [RDI]
MOV R8D,dword ptr [RSP + RAX*0x4]
TEST R8D,R8D
JNZ 0x001011be
IMUL ECX,EAX
MOV dword ptr [RSP + RAX*0x4],0x1
LAB_001011be:
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x001011a8
LAB_001011c7:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001011ef
MOV EAX,ECX
ADD RSP,0x1a8
RET
LAB_001011e8:
MOV ECX,0x1
JMP 0x001011c7
LAB_001011ef:
CALL 0x00101050 | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_1a8;
for (lVar3 = 0x32; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (int *)((long)piVar4 + 8);
}
*piVar4 = 0;
if (param_2 < 1) {
iVar2 = 1;
}
else {
iVar2 = 1;
piVar4 = param_1 + param_2;
do {
iVar1 = *param_1;
if (local_1a8[iVar1] == 0) {
iVar2 = iVar2 * iVar1;
local_1a8[iVar1] = 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar4);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,188 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf38(%rip),%xmm0
mulsd %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd -0x18(%rbp),%xmm1
movsd -0x18(%rbp),%xmm2
movsd 0xf1e(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd -0x20(%rbp),%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm1
movapd xmm1, xmm0
mulsd xmm1, [rbp+var_18]
movsd xmm2, [rbp+var_18]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm2
mulsd xmm0, [rbp+var_20]
addsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1, double a2)
{
return 6.283 * a1 * a2 + 6.283 * a1 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM1
MOVAPD XMM1,XMM0
MULSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM2,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM2
MULSD XMM0,qword ptr [RBP + -0x20]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1,double param_2)
{
return DAT_00102080 * param_1 * param_2 + DAT_00102080 * param_1 * param_1;
} |
6,189 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm2
mulsd 0xecf(%rip),%xmm2
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
retq
| func0:
endbr64
movapd xmm2, xmm0
mulsd xmm2, cs:qword_2008
mulsd xmm0, xmm2
mulsd xmm2, xmm1
addsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * (a1 * 6.283) + a1 * 6.283 * a2;
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MULSD XMM2,qword ptr [0x00102008]
MULSD XMM0,XMM2
MULSD XMM2,XMM1
ADDSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * param_1 * _DAT_00102008 + param_1 * _DAT_00102008 * param_2;
} |
6,190 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O2 | c | func0:
endbr64
movsd 0xebc(%rip),%xmm2
mulsd %xmm0,%xmm2
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movsd xmm2, cs:qword_2008
mulsd xmm2, xmm0
mulsd xmm0, xmm2
mulsd xmm2, xmm1
addsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * (6.283 * a1) + 6.283 * a1 * a2;
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102008]
MULSD XMM2,XMM0
MULSD XMM0,XMM2
MULSD XMM2,XMM1
ADDSD XMM0,XMM2
RET | double func0(double param_1,double param_2)
{
return param_1 * DAT_00102008 * param_1 + DAT_00102008 * param_1 * param_2;
} |
6,191 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O3 | c | func0:
endbr64
movsd 0xebc(%rip),%xmm2
mulsd %xmm0,%xmm2
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movsd xmm2, cs:qword_2008
mulsd xmm2, xmm0
mulsd xmm0, xmm2
mulsd xmm2, xmm1
addsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * (6.283 * a1) + 6.283 * a1 * a2;
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102008]
MULSD XMM2,XMM0
MULSD XMM0,XMM2
MULSD XMM2,XMM1
ADDSD XMM0,XMM2
RET | double func0(double param_1,double param_2)
{
return param_1 * DAT_00102008 * param_1 + DAT_00102008 * param_1 * param_2;
} |
6,192 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1189 <func0+0x40>
mov -0x4(%rbp),%eax
cltd
idivl -0x14(%rbp)
mov %edx,%eax
test %eax,%eax
je 117d <func0+0x34>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x18(%rbp),%eax
je 1193 <func0+0x4a>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 116c <func0+0x23>
jmp 1194 <func0+0x4b>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp short loc_1189
loc_116C:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_14]
mov eax, edx
test eax, eax
jz short loc_117D
add [rbp+var_8], 1
loc_117D:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_18]
jz short loc_1193
add [rbp+var_4], 1
loc_1189:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jle short loc_116C
jmp short loc_1194
loc_1193:
nop
loc_1194:
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2, signed int a3, signed int a4)
{
int v5; // [rsp+18h] [rbp-8h]
v5 = 0;
while ( a3 <= a4 )
{
if ( a3 % a1 )
++v5;
if ( v5 == a2 )
break;
++a3;
}
return (unsigned int)a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101189
LAB_0010116c:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x14]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x0010117d
ADD dword ptr [RBP + -0x8],0x1
LAB_0010117d:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x18]
JZ 0x00101193
ADD dword ptr [RBP + -0x4],0x1
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x0010116c
JMP 0x00101194
LAB_00101193:
NOP
LAB_00101194:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int local_10;
int local_c;
local_10 = 0;
local_c = param_3;
while( true ) {
if (param_4 < local_c) {
return local_c;
}
if (local_c % param_1 != 0) {
local_10 = local_10 + 1;
}
if (local_10 == param_2) break;
local_c = local_c + 1;
}
return local_c;
} |
6,193 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O1 | c | func0:
endbr64
mov %edx,%r8d
cmp %ecx,%edx
jg 1179 <func0+0x30>
mov $0x0,%r9d
mov %r8d,%eax
cltd
idiv %edi
cmp $0x1,%edx
sbb $0xffffffff,%r9d
cmp %esi,%r9d
je 117c <func0+0x33>
add $0x1,%r8d
cmp %r8d,%ecx
jge 115a <func0+0x11>
mov %r8d,%eax
retq
mov %edx,%eax
retq
mov %r8d,%eax
retq
| func0:
endbr64
mov r8d, edx
cmp edx, ecx
jg short loc_1179
mov r9d, 0
loc_115A:
mov eax, r8d
cdq
idiv edi
cmp edx, 1
sbb r9d, 0FFFFFFFFh
cmp r9d, esi
jz short loc_117C
add r8d, 1
cmp ecx, r8d
jge short loc_115A
mov eax, r8d
retn
loc_1179:
mov eax, edx
retn
loc_117C:
mov eax, r8d
retn | long long func0(int a1, int a2, unsigned int a3, int a4)
{
unsigned int v4; // r8d
int v5; // r9d
v4 = a3;
if ( (int)a3 > a4 )
return a3;
v5 = 0;
while ( 1 )
{
v5 -= ((int)v4 % a1 == 0) - 1;
if ( v5 == a2 )
break;
if ( a4 < (int)++v4 )
return v4;
}
return v4;
} | func0:
ENDBR64
MOV R8D,EDX
CMP EDX,ECX
JG 0x00101179
MOV R9D,0x0
LAB_0010115a:
MOV EAX,R8D
CDQ
IDIV EDI
CMP EDX,0x1
SBB R9D,-0x1
CMP R9D,ESI
JZ 0x0010117c
ADD R8D,0x1
CMP ECX,R8D
JGE 0x0010115a
MOV EAX,R8D
RET
LAB_00101179:
MOV EAX,EDX
RET
LAB_0010117c:
MOV EAX,R8D
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
if (param_4 < param_3) {
return param_3;
}
iVar1 = 0;
do {
iVar1 = (iVar1 + 1) - (uint)(param_3 % param_1 == 0);
if (iVar1 == param_2) {
return param_3;
}
param_3 = param_3 + 1;
} while (param_3 <= param_4);
return param_3;
} |
6,194 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O2 | c | func0:
endbr64
mov %edx,%r8d
cmp %ecx,%edx
jg 127b <func0+0x2b>
xor %r9d,%r9d
jmp 1269 <func0+0x19>
add $0x1,%r8d
cmp %r8d,%ecx
jl 127b <func0+0x2b>
mov %r8d,%eax
cltd
idiv %edi
cmp $0x1,%edx
sbb $0xffffffff,%r9d
cmp %esi,%r9d
jne 1260 <func0+0x10>
mov %r8d,%eax
retq
| func0:
endbr64
mov r8d, edx
cmp edx, ecx
jg short loc_127B
xor r9d, r9d
jmp short loc_1269
loc_1260:
add r8d, 1
cmp ecx, r8d
jl short loc_127B
loc_1269:
mov eax, r8d
cdq
idiv edi
cmp edx, 1
sbb r9d, 0FFFFFFFFh
cmp r9d, esi
jnz short loc_1260
loc_127B:
mov eax, r8d
retn | long long func0(int a1, int a2, signed int a3, signed int a4)
{
signed int v4; // r8d
int v5; // r9d
v4 = a3;
if ( a3 <= a4 )
{
v5 = 0;
do
{
v5 -= (v4 % a1 == 0) - 1;
if ( v5 == a2 )
break;
++v4;
}
while ( a4 >= v4 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
MOV R8D,EDX
CMP EDX,ECX
JG 0x0010127b
XOR R9D,R9D
JMP 0x00101269
LAB_00101260:
ADD R8D,0x1
CMP ECX,R8D
JL 0x0010127b
LAB_00101269:
MOV EAX,R8D
CDQ
IDIV EDI
CMP EDX,0x1
SBB R9D,-0x1
CMP R9D,ESI
JNZ 0x00101260
LAB_0010127b:
MOV EAX,R8D
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
if (param_3 <= param_4) {
iVar1 = 0;
do {
iVar1 = (iVar1 + 1) - (uint)(param_3 % param_1 == 0);
if (iVar1 == param_2) {
return param_3;
}
param_3 = param_3 + 1;
} while (param_3 <= param_4);
}
return param_3;
} |
6,195 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%r8d
cmp %ecx,%edx
jg 116b <func0+0x2b>
xor %r9d,%r9d
jmp 1159 <func0+0x19>
add $0x1,%r8d
cmp %r8d,%ecx
jl 116b <func0+0x2b>
mov %r8d,%eax
cltd
idiv %edi
cmp $0x1,%edx
sbb $0xffffffff,%r9d
cmp %esi,%r9d
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
| func0:
endbr64
mov r8d, edx
cmp edx, ecx
jg short loc_116B
xor r9d, r9d
jmp short loc_1159
loc_1150:
add r8d, 1
cmp ecx, r8d
jl short loc_116B
loc_1159:
mov eax, r8d
cdq
idiv edi
cmp edx, 1
sbb r9d, 0FFFFFFFFh
cmp r9d, esi
jnz short loc_1150
loc_116B:
mov eax, r8d
retn | long long func0(int a1, int a2, signed int a3, signed int a4)
{
signed int v4; // r8d
int v5; // r9d
v4 = a3;
if ( a3 <= a4 )
{
v5 = 0;
do
{
v5 -= (v4 % a1 == 0) - 1;
if ( v5 == a2 )
break;
++v4;
}
while ( a4 >= v4 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
MOV R8D,EDX
CMP EDX,ECX
JG 0x0010116b
XOR R9D,R9D
JMP 0x00101159
LAB_00101150:
ADD R8D,0x1
CMP ECX,R8D
JL 0x0010116b
LAB_00101159:
MOV EAX,R8D
CDQ
IDIV EDI
CMP EDX,0x1
SBB R9D,-0x1
CMP R9D,ESI
JNZ 0x00101150
LAB_0010116b:
MOV EAX,R8D
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
if (param_3 <= param_4) {
iVar1 = 0;
do {
iVar1 = (iVar1 + 1) - (uint)(param_3 % param_1 == 0);
if (iVar1 == param_2) {
return param_3;
}
param_3 = param_3 + 1;
} while (param_3 <= param_4);
}
return param_3;
} |
6,196 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
return false;
}
| int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11e9 <func0+0x80>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11d6 <func0+0x6d>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x28(%rbp),%eax
jne 11e9 <func0+0x80>
mov $0x1,%eax
jmp 11fe <func0+0x95>
mov -0x8(%rbp),%eax
sub -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x24(%rbp),%eax
jge 11f9 <func0+0x90>
mov -0x4(%rbp),%eax
cmp -0x28(%rbp),%eax
jl 118f <func0+0x26>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_28], ecx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11E9
loc_118F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11D6
add [rbp+var_8], 1
add [rbp+var_4], 1
mov eax, [rbp+var_4]
cmp eax, [rbp+var_28]
jnz short loc_11E9
mov eax, 1
jmp short loc_11FE
loc_11D6:
mov eax, [rbp+var_8]
sub eax, [rbp+var_4]
add eax, 1
mov [rbp+var_8], eax
mov [rbp+var_4], 0
loc_11E9:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_24]
jge short loc_11F9
mov eax, [rbp+var_4]
cmp eax, [rbp+var_28]
jl short loc_118F
loc_11F9:
mov eax, 0
loc_11FE:
pop rbp
retn | long long func0(long long a1, long long a2, int a3, int a4)
{
int v5; // [rsp+20h] [rbp-8h]
int v6; // [rsp+24h] [rbp-4h]
v5 = 0;
v6 = 0;
while ( v5 < a3 && v6 < a4 )
{
if ( *(_DWORD *)(4LL * v5 + a1) == *(_DWORD *)(4LL * v6 + a2) )
{
++v5;
if ( ++v6 == a4 )
return 1LL;
}
else
{
v5 = v5 - v6 + 1;
v6 = 0;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x28],ECX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e9
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011d6
ADD dword ptr [RBP + -0x8],0x1
ADD dword ptr [RBP + -0x4],0x1
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x28]
JNZ 0x001011e9
MOV EAX,0x1
JMP 0x001011fe
LAB_001011d6:
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
LAB_001011e9:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x001011f9
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x28]
JL 0x0010118f
LAB_001011f9:
MOV EAX,0x0
LAB_001011fe:
POP RBP
RET | int8 func0(long param_1,long param_2,int param_3,int param_4)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while ((local_10 < param_3 && (local_c < param_4))) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_2 + (long)local_c * 4)) {
local_10 = local_10 + 1;
local_c = local_c + 1;
if (local_c == param_4) {
return 1;
}
}
else {
local_10 = (local_10 - local_c) + 1;
local_c = 0;
}
}
return 0;
} |
6,197 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
return false;
}
| int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
setg %al
test %ecx,%ecx
setg %r11b
and %al,%r11b
je 11cc <func0+0x63>
mov $0x0,%r9d
mov $0x0,%r8d
jmp 11aa <func0+0x41>
sub %r9d,%r8d
add $0x1,%r8d
mov $0x0,%r9d
cmp %edx,%r8d
setl %al
cmp %ecx,%r9d
setl %r10b
and %r10b,%al
je 11cb <func0+0x62>
movslq %r8d,%rax
movslq %r9d,%r10
mov (%rsi,%r10,4),%r10d
cmp %r10d,(%rdi,%rax,4)
jne 118b <func0+0x22>
add $0x1,%r8d
add $0x1,%r9d
cmp %r9d,%ecx
jne 1198 <func0+0x2f>
mov %r11d,%eax
retq
retq
mov %r11d,%eax
retq
| func0:
endbr64
mov r9, rdi
mov r10, rsi
mov r8d, edx
mov edi, ecx
test edx, edx
setnle al
test ecx, ecx
setnle dl
and al, dl
mov r11d, eax
jz short locret_11CF
mov ecx, 0
mov edx, 0
jmp short loc_11B0
loc_1195:
sub edx, ecx
add edx, 1
mov ecx, 0
loc_119F:
cmp edx, r8d
setl al
cmp ecx, edi
setl sil
and al, sil
jz short locret_11CE
loc_11B0:
movsxd rax, edx
movsxd rsi, ecx
mov esi, [r10+rsi*4]
cmp [r9+rax*4], esi
jnz short loc_1195
add edx, 1
add ecx, 1
cmp edi, ecx
jnz short loc_119F
mov eax, r11d
retn
locret_11CE:
retn
locret_11CF:
retn | bool func0(long long a1, long long a2, int a3, int a4)
{
bool result; // al
bool v8; // r11
int v9; // ecx
int v10; // edx
result = a4 > 0 && a3 > 0;
v8 = result;
if ( result )
{
v9 = 0;
v10 = 0;
do
{
if ( *(_DWORD *)(a1 + 4LL * v10) == *(_DWORD *)(a2 + 4LL * v9) )
{
++v10;
if ( a4 == ++v9 )
return v8;
}
else
{
v10 = v10 - v9 + 1;
v9 = 0;
}
result = v9 < a4 && v10 < a3;
}
while ( result );
}
return result;
} | func0:
ENDBR64
MOV R9,RDI
MOV R10,RSI
MOV R8D,EDX
MOV EDI,ECX
TEST EDX,EDX
SETG AL
TEST ECX,ECX
SETG DL
AND AL,DL
MOV R11D,EAX
JZ 0x001011cf
MOV ECX,0x0
MOV EDX,0x0
JMP 0x001011b0
LAB_00101195:
SUB EDX,ECX
ADD EDX,0x1
MOV ECX,0x0
LAB_0010119f:
CMP EDX,R8D
SETL AL
CMP ECX,EDI
SETL SIL
AND AL,SIL
JZ 0x001011ce
LAB_001011b0:
MOVSXD RAX,EDX
MOVSXD RSI,ECX
MOV ESI,dword ptr [R10 + RSI*0x4]
CMP dword ptr [R9 + RAX*0x4],ESI
JNZ 0x00101195
ADD EDX,0x1
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010119f
MOV EAX,R11D
RET
LAB_001011ce:
RET
LAB_001011cf:
RET | bool func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
int iVar2;
int iVar3;
bVar1 = 0 < param_3 && 0 < param_4;
if (0 >= param_3 || 0 >= param_4) {
return bVar1;
}
iVar2 = 0;
iVar3 = 0;
do {
if (*(int *)(param_1 + (long)iVar3 * 4) == *(int *)(param_2 + (long)iVar2 * 4)) {
iVar2 = iVar2 + 1;
if (param_4 == iVar2) {
return bVar1;
}
}
else {
iVar3 = iVar3 - iVar2;
iVar2 = 0;
}
iVar3 = iVar3 + 1;
} while (iVar3 < param_3 && iVar2 < param_4);
return iVar3 < param_3 && iVar2 < param_4;
} |
6,198 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
return false;
}
| int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
setg %r11b
test %edx,%edx
setg %al
and %al,%r11b
je 13ac <func0+0x6c>
xor %r9d,%r9d
xor %r8d,%r8d
jmp 1378 <func0+0x38>
nopl 0x0(%rax)
sub %r9d,%r8d
xor %r9d,%r9d
mov %r11d,%r10d
add $0x1,%r8d
cmp %edx,%r8d
setl %al
and %r10b,%al
je 13a4 <func0+0x64>
movslq %r9d,%r10
movslq %r8d,%rax
mov (%rsi,%r10,4),%r10d
cmp %r10d,(%rdi,%rax,4)
jne 1360 <func0+0x20>
add $0x1,%r9d
add $0x1,%r8d
cmp %r9d,%ecx
je 13a8 <func0+0x68>
setg %r10b
cmp %edx,%r8d
setl %al
and %r10b,%al
jne 1378 <func0+0x38>
retq
nopl (%rax)
mov %r11d,%eax
retq
xor %eax,%eax
retq
| func0:
endbr64
test ecx, ecx
mov r8, rdi
mov r9, rsi
mov edi, edx
setnle r10b
test edx, edx
mov r11d, ecx
setnle al
and r10b, al
jz short loc_1344
xor ecx, ecx
xor edx, edx
jmp short loc_130C
loc_12F8:
sub edx, ecx
xor ecx, ecx
mov esi, r10d
add edx, 1
cmp edx, edi
setl al
and al, sil
jz short locret_1335
loc_130C:
movsxd rsi, ecx
movsxd rax, edx
mov esi, [r9+rsi*4]
cmp [r8+rax*4], esi
jnz short loc_12F8
add ecx, 1
add edx, 1
cmp r11d, ecx
jz short loc_1340
setnle sil
cmp edx, edi
setl al
and al, sil
jnz short loc_130C
locret_1335:
retn
loc_1340:
mov eax, r10d
retn
loc_1344:
xor eax, eax
retn | bool func0(long long a1, long long a2, int a3, int a4)
{
bool v7; // r10
int v8; // ecx
int v9; // edx
int v10; // edx
bool result; // al
v7 = a3 > 0 && a4 > 0;
if ( !v7 )
return 0;
v8 = 0;
v9 = 0;
while ( 1 )
{
while ( *(_DWORD *)(a1 + 4LL * v9) != *(_DWORD *)(a2 + 4LL * v8) )
{
v10 = v9 - v8;
v8 = 0;
v9 = v10 + 1;
result = v7 && v9 < a3;
if ( !result )
return result;
}
++v8;
++v9;
if ( a4 == v8 )
break;
result = a4 > v8 && v9 < a3;
if ( !result )
return result;
}
return v7;
} | func0:
ENDBR64
TEST ECX,ECX
MOV R8,RDI
MOV R9,RSI
MOV EDI,EDX
SETG R10B
TEST EDX,EDX
MOV R11D,ECX
SETG AL
AND R10B,AL
JZ 0x00101344
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0010130c
LAB_001012f8:
SUB EDX,ECX
XOR ECX,ECX
MOV ESI,R10D
ADD EDX,0x1
CMP EDX,EDI
SETL AL
AND AL,SIL
JZ 0x00101335
LAB_0010130c:
MOVSXD RSI,ECX
MOVSXD RAX,EDX
MOV ESI,dword ptr [R9 + RSI*0x4]
CMP dword ptr [R8 + RAX*0x4],ESI
JNZ 0x001012f8
ADD ECX,0x1
ADD EDX,0x1
CMP R11D,ECX
JZ 0x00101340
SETG SIL
CMP EDX,EDI
SETL AL
AND AL,SIL
JNZ 0x0010130c
LAB_00101335:
RET
LAB_00101340:
MOV EAX,R10D
RET
LAB_00101344:
XOR EAX,EAX
RET | ulong func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
bool bVar2;
bool bVar3;
uint uVar4;
bool bVar5;
int iVar6;
int iVar7;
int4 in_R10D;
bVar2 = 0 < param_4;
bVar3 = 0 < param_3;
if (!bVar2 || !bVar3) {
return 0;
}
iVar6 = 0;
iVar7 = 0;
do {
while (uVar4 = (uint)iVar7 >> 8,
*(int *)(param_1 + (long)iVar7 * 4) == *(int *)(param_2 + (long)iVar6 * 4)) {
iVar6 = iVar6 + 1;
iVar7 = iVar7 + 1;
if (param_4 == iVar6) {
return (ulong)CONCAT31((int3)((uint)in_R10D >> 8),bVar2 && bVar3);
}
bVar1 = param_4 != iVar6;
bVar5 = iVar7 < param_3 && (bVar1 && iVar6 <= param_4);
if (iVar7 >= param_3 || (!bVar1 || iVar6 > param_4)) goto LAB_00101335;
}
iVar7 = iVar7 - iVar6;
iVar6 = 0;
iVar7 = iVar7 + 1;
bVar5 = iVar7 < param_3 && (bVar2 && bVar3);
} while (iVar7 < param_3 && (bVar2 && bVar3));
LAB_00101335:
return CONCAT71((int7)(int3)uVar4,bVar5);
} |
6,199 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
return false;
}
| int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
setg %r11b
test %edx,%edx
setg %al
and %al,%r11b
je 13ac <func0+0x6c>
xor %r9d,%r9d
xor %r8d,%r8d
jmp 1378 <func0+0x38>
nopl 0x0(%rax)
sub %r9d,%r8d
xor %r9d,%r9d
mov %r11d,%r10d
add $0x1,%r8d
cmp %edx,%r8d
setl %al
and %r10b,%al
je 13a4 <func0+0x64>
movslq %r9d,%r10
movslq %r8d,%rax
mov (%rsi,%r10,4),%r10d
cmp %r10d,(%rdi,%rax,4)
jne 1360 <func0+0x20>
add $0x1,%r9d
add $0x1,%r8d
cmp %r9d,%ecx
je 13a8 <func0+0x68>
setg %r10b
cmp %edx,%r8d
setl %al
and %r10b,%al
jne 1378 <func0+0x38>
retq
nopl (%rax)
mov %r11d,%eax
retq
xor %eax,%eax
retq
| func0:
endbr64
test edx, edx
mov r8, rdi
mov r9, rsi
mov edi, edx
setnle r10b
test ecx, ecx
mov r11d, ecx
setnle al
and r10b, al
jz short loc_1394
xor ecx, ecx
xor edx, edx
jmp short loc_135C
loc_1348:
sub edx, ecx
xor ecx, ecx
mov esi, r10d
add edx, 1
cmp edx, edi
setl al
and al, sil
jz short locret_1385
loc_135C:
movsxd rsi, ecx
movsxd rax, edx
mov esi, [r9+rsi*4]
cmp [r8+rax*4], esi
jnz short loc_1348
add ecx, 1
add edx, 1
cmp r11d, ecx
jz short loc_1390
setnle sil
cmp edx, edi
setl al
and al, sil
jnz short loc_135C
locret_1385:
retn
loc_1390:
mov eax, r10d
retn
loc_1394:
xor eax, eax
retn | bool func0(long long a1, long long a2, int a3, int a4)
{
bool v7; // r10
int v8; // ecx
int v9; // edx
int v10; // edx
bool result; // al
v7 = a4 > 0 && a3 > 0;
if ( !v7 )
return 0;
v8 = 0;
v9 = 0;
while ( 1 )
{
while ( *(_DWORD *)(a1 + 4LL * v9) != *(_DWORD *)(a2 + 4LL * v8) )
{
v10 = v9 - v8;
v8 = 0;
v9 = v10 + 1;
result = v7 && v9 < a3;
if ( !result )
return result;
}
++v8;
++v9;
if ( a4 == v8 )
break;
result = a4 > v8 && v9 < a3;
if ( !result )
return result;
}
return v7;
} | func0:
ENDBR64
TEST EDX,EDX
MOV R8,RDI
MOV R9,RSI
MOV EDI,EDX
SETG R10B
TEST ECX,ECX
MOV R11D,ECX
SETG AL
AND R10B,AL
JZ 0x00101394
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0010135c
LAB_00101348:
SUB EDX,ECX
XOR ECX,ECX
MOV ESI,R10D
ADD EDX,0x1
CMP EDX,EDI
SETL AL
AND AL,SIL
JZ 0x00101385
LAB_0010135c:
MOVSXD RSI,ECX
MOVSXD RAX,EDX
MOV ESI,dword ptr [R9 + RSI*0x4]
CMP dword ptr [R8 + RAX*0x4],ESI
JNZ 0x00101348
ADD ECX,0x1
ADD EDX,0x1
CMP R11D,ECX
JZ 0x00101390
SETG SIL
CMP EDX,EDI
SETL AL
AND AL,SIL
JNZ 0x0010135c
LAB_00101385:
RET
LAB_00101390:
MOV EAX,R10D
RET
LAB_00101394:
XOR EAX,EAX
RET | ulong func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
bool bVar2;
bool bVar3;
uint uVar4;
bool bVar5;
int iVar6;
int iVar7;
int4 in_R10D;
bVar2 = 0 < param_3;
bVar3 = 0 < param_4;
if (!bVar2 || !bVar3) {
return 0;
}
iVar6 = 0;
iVar7 = 0;
do {
while (uVar4 = (uint)iVar7 >> 8,
*(int *)(param_1 + (long)iVar7 * 4) == *(int *)(param_2 + (long)iVar6 * 4)) {
iVar6 = iVar6 + 1;
iVar7 = iVar7 + 1;
if (param_4 == iVar6) {
return (ulong)CONCAT31((int3)((uint)in_R10D >> 8),bVar2 && bVar3);
}
bVar1 = param_4 != iVar6;
bVar5 = iVar7 < param_3 && (bVar1 && iVar6 <= param_4);
if (iVar7 >= param_3 || (!bVar1 || iVar6 > param_4)) goto LAB_00101385;
}
iVar7 = iVar7 - iVar6;
iVar6 = 0;
iVar7 = iVar7 + 1;
bVar5 = iVar7 < param_3 && (bVar2 && bVar3);
} while (iVar7 < param_3 && (bVar2 && bVar3));
LAB_00101385:
return CONCAT71((int7)(int3)uVar4,bVar5);
} |
6,200 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 1161 <func0+0x18>
mov $0x1,%eax
jmp 118b <func0+0x42>
cmpl $0x2,-0x4(%rbp)
jg 116c <func0+0x23>
mov -0x4(%rbp),%eax
jmp 118b <func0+0x42>
cmpl $0x3,-0x4(%rbp)
jne 1179 <func0+0x30>
mov $0x6,%eax
jmp 118b <func0+0x42>
cmpl $0x4,-0x4(%rbp)
jne 1186 <func0+0x3d>
mov $0x4,%eax
jmp 118b <func0+0x42>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jnz short loc_1161
mov eax, 1
jmp short loc_118B
loc_1161:
cmp [rbp+var_4], 2
jg short loc_116C
mov eax, [rbp+var_4]
jmp short loc_118B
loc_116C:
cmp [rbp+var_4], 3
jnz short loc_1179
mov eax, 6
jmp short loc_118B
loc_1179:
cmp [rbp+var_4], 4
jnz short loc_1186
mov eax, 4
jmp short loc_118B
loc_1186:
mov eax, 0
loc_118B:
pop rbp
retn | long long func0(int a1)
{
if ( !a1 )
return 1LL;
if ( a1 <= 2 )
return (unsigned int)a1;
if ( a1 == 3 )
return 6LL;
if ( a1 == 4 )
return 4LL;
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x00101161
MOV EAX,0x1
JMP 0x0010118b
LAB_00101161:
CMP dword ptr [RBP + -0x4],0x2
JG 0x0010116c
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x0010118b
LAB_0010116c:
CMP dword ptr [RBP + -0x4],0x3
JNZ 0x00101179
MOV EAX,0x6
JMP 0x0010118b
LAB_00101179:
CMP dword ptr [RBP + -0x4],0x4
JNZ 0x00101186
MOV EAX,0x4
JMP 0x0010118b
LAB_00101186:
MOV EAX,0x0
LAB_0010118b:
POP RBP
RET | int func0(int param_1)
{
if (param_1 == 0) {
param_1 = 1;
}
else if (2 < param_1) {
if (param_1 == 3) {
param_1 = 6;
}
else if (param_1 == 4) {
param_1 = 4;
}
else {
param_1 = 0;
}
}
return param_1;
} |
6,201 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 1153 <func0+0x2a>
mov %edi,%eax
cmp $0x2,%edi
jle 1153 <func0+0x2a>
cmp $0x3,%edi
je 114e <func0+0x25>
cmp $0x4,%edi
mov $0x0,%eax
cmove %edi,%eax
retq
mov $0x6,%eax
retq
| func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_1154
mov eax, edi
cmp edi, 2
jle short locret_1154
cmp edi, 3
jz short loc_114F
cmp edi, 4
setz al
movzx eax, al
shl eax, 2
retn
loc_114F:
mov eax, 6
locret_1154:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( a1 > 2 )
{
if ( a1 == 3 )
return 6LL;
else
return 4 * (unsigned int)(a1 == 4);
}
}
return result;
} | ||
6,202 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 1175 <func0+0x35>
mov %edi,%eax
cmp $0x2,%edi
jle 1175 <func0+0x35>
cmp $0x3,%edi
je 1170 <func0+0x30>
cmp $0x4,%edi
sete %al
movzbl %al,%eax
shl $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x6,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_1175
mov eax, edi
cmp edi, 2
jle short locret_1175
cmp edi, 3
jz short loc_1170
cmp edi, 4
setz al
movzx eax, al
shl eax, 2
retn
loc_1170:
mov eax, 6
locret_1175:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( a1 > 2 )
{
if ( a1 == 3 )
return 6LL;
else
return 4 * (unsigned int)(a1 == 4);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x00101175
MOV EAX,EDI
CMP EDI,0x2
JLE 0x00101175
CMP EDI,0x3
JZ 0x00101170
CMP EDI,0x4
SETZ AL
MOVZX EAX,AL
SHL EAX,0x2
RET
LAB_00101170:
MOV EAX,0x6
LAB_00101175:
RET | ulong func0(uint param_1)
{
ulong uVar1;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = (ulong)param_1, 2 < (int)param_1)) {
if (param_1 != 3) {
return (ulong)(param_1 == 4) << 2;
}
uVar1 = 6;
}
return uVar1;
} |
6,203 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 1175 <func0+0x35>
mov %edi,%eax
cmp $0x2,%edi
jle 1175 <func0+0x35>
cmp $0x3,%edi
je 1170 <func0+0x30>
cmp $0x4,%edi
sete %al
movzbl %al,%eax
shl $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x6,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_1175
mov eax, edi
cmp edi, 2
jle short locret_1175
cmp edi, 3
jz short loc_1170
cmp edi, 4
setz al
movzx eax, al
shl eax, 2
retn
loc_1170:
mov eax, 6
locret_1175:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( a1 > 2 )
{
if ( a1 == 3 )
return 6LL;
else
return 4 * (unsigned int)(a1 == 4);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x00101175
MOV EAX,EDI
CMP EDI,0x2
JLE 0x00101175
CMP EDI,0x3
JZ 0x00101170
CMP EDI,0x4
SETZ AL
MOVZX EAX,AL
SHL EAX,0x2
RET
LAB_00101170:
MOV EAX,0x6
LAB_00101175:
RET | ulong func0(uint param_1)
{
ulong uVar1;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = (ulong)param_1, 2 < (int)param_1)) {
if (param_1 != 3) {
return (ulong)(param_1 == 4) << 2;
}
uVar1 = 6;
}
return uVar1;
} |
6,204 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700};
for (int i = 0; i < size1 * 3; i++) assert(result1[i] == expected1[i]);
int size2 = 2;
int list4[] = {10, 20};
int list5[] = {15, 2};
int list6[] = {5, 10};
int result2[6];
func0(list4, list5, list6, result2, size2);
int expected2[] = {10, 15, 5, 20, 2, 10};
for (int i = 0; i < size2 * 3; i++) assert(result2[i] == expected2[i]);
int size3 = 2;
int list7[] = {11, 44};
int list8[] = {10, 15};
int list9[] = {20, 5};
int result3[6];
func0(list7, list8, list9, result3, size3);
int expected3[] = {11, 10, 20, 44, 15, 5};
for (int i = 0; i < size3 * 3; i++) assert(result3[i] == expected3[i]);
printf("All tests passed successfully!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8d,-0x34(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1255 <func0+0xcc>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 11b8 <func0+0x2f>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_34], r8d
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_1255
loc_11B8:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_4], 1
loc_1255:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_34]
jl loc_11B8
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
int v5; // eax
long long result; // rax
int v7; // [rsp+2Ch] [rbp-8h]
unsigned int i; // [rsp+30h] [rbp-4h]
v7 = 0;
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a5 )
break;
*(_DWORD *)(a4 + 4LL * v7) = *(_DWORD *)(4LL * (int)i + a1);
*(_DWORD *)(a4 + 4LL * (v7 + 1)) = *(_DWORD *)(4LL * (int)i + a2);
v5 = v7 + 2;
v7 += 3;
*(_DWORD *)(a4 + 4LL * v5) = *(_DWORD *)(4LL * (int)i + a3);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x34],R8D
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101255
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
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
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101255:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x001011b8
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_5; local_c = local_c + 1) {
*(int4 *)((long)local_10 * 4 + param_4) = *(int4 *)((long)local_c * 4 + param_1);
iVar1 = local_10 + 2;
*(int4 *)((long)(local_10 + 1) * 4 + param_4) =
*(int4 *)((long)local_c * 4 + param_2);
local_10 = local_10 + 3;
*(int4 *)((long)iVar1 * 4 + param_4) = *(int4 *)((long)local_c * 4 + param_3);
}
return;
} |
6,205 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700};
for (int i = 0; i < size1 * 3; i++) assert(result1[i] == expected1[i]);
int size2 = 2;
int list4[] = {10, 20};
int list5[] = {15, 2};
int list6[] = {5, 10};
int result2[6];
func0(list4, list5, list6, result2, size2);
int expected2[] = {10, 15, 5, 20, 2, 10};
for (int i = 0; i < size2 * 3; i++) assert(result2[i] == expected2[i]);
int size3 = 2;
int list7[] = {11, 44};
int list8[] = {10, 15};
int list9[] = {20, 5};
int result3[6];
func0(list7, list8, list9, result3, size3);
int expected3[] = {11, 10, 20, 44, 15, 5};
for (int i = 0; i < size3 * 3; i++) assert(result3[i] == expected3[i]);
printf("All tests passed successfully!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %r8d,%r8d
jle 11c2 <func0+0x39>
lea -0x1(%r8),%r9d
mov $0x0,%eax
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rcx)
mov (%rsi,%rax,4),%r8d
mov %r8d,0x4(%rcx)
mov (%rdx,%rax,4),%r8d
mov %r8d,0x8(%rcx)
mov %rax,%r8
add $0x1,%rax
add $0xc,%rcx
cmp %r9,%r8
jne 119b <func0+0x12>
retq
| func0:
endbr64
mov r9, rsi
test r8d, r8d
jle short locret_11BC
mov r8d, r8d
mov eax, 0
loc_119D:
mov esi, [rdi+rax*4]
mov [rcx], esi
mov esi, [r9+rax*4]
mov [rcx+4], esi
mov esi, [rdx+rax*4]
mov [rcx+8], esi
add rax, 1
add rcx, 0Ch
cmp rax, r8
jnz short loc_119D
locret_11BC:
retn | void func0(long long a1, long long a2, long long a3, _DWORD *a4, int a5)
{
long long v5; // rax
if ( a5 > 0 )
{
v5 = 0LL;
do
{
*a4 = *(_DWORD *)(a1 + 4 * v5);
a4[1] = *(_DWORD *)(a2 + 4 * v5);
a4[2] = *(_DWORD *)(a3 + 4 * v5++);
a4 += 3;
}
while ( v5 != a5 );
}
} | func0:
ENDBR64
MOV R9,RSI
TEST R8D,R8D
JLE 0x001011bc
MOV R8D,R8D
MOV EAX,0x0
LAB_0010119d:
MOV ESI,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX],ESI
MOV ESI,dword ptr [R9 + RAX*0x4]
MOV dword ptr [RCX + 0x4],ESI
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RCX + 0x8],ESI
ADD RAX,0x1
ADD RCX,0xc
CMP RAX,R8
JNZ 0x0010119d
LAB_001011bc:
RET | void func0(long param_1,long param_2,long param_3,int4 *param_4,uint param_5)
{
ulong uVar1;
if (0 < (int)param_5) {
uVar1 = 0;
do {
*param_4 = *(int4 *)(param_1 + uVar1 * 4);
param_4[1] = *(int4 *)(param_2 + uVar1 * 4);
param_4[2] = *(int4 *)(param_3 + uVar1 * 4);
uVar1 = uVar1 + 1;
param_4 = param_4 + 3;
} while (uVar1 != param_5);
}
return;
} |
6,206 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700};
for (int i = 0; i < size1 * 3; i++) assert(result1[i] == expected1[i]);
int size2 = 2;
int list4[] = {10, 20};
int list5[] = {15, 2};
int list6[] = {5, 10};
int result2[6];
func0(list4, list5, list6, result2, size2);
int expected2[] = {10, 15, 5, 20, 2, 10};
for (int i = 0; i < size2 * 3; i++) assert(result2[i] == expected2[i]);
int size3 = 2;
int list7[] = {11, 44};
int list8[] = {10, 15};
int list9[] = {20, 5};
int result3[6];
func0(list7, list8, list9, result3, size3);
int expected3[] = {11, 10, 20, 44, 15, 5};
for (int i = 0; i < size3 * 3; i++) assert(result3[i] == expected3[i]);
printf("All tests passed successfully!\n");
return 0;
}
| O2 | c | func0:
endbr64
test %r8d,%r8d
jle 1588 <func0+0x38>
lea -0x1(%r8),%r9d
xor %eax,%eax
mov (%rdi,%rax,4),%r8d
add $0xc,%rcx
mov %r8d,-0xc(%rcx)
mov (%rsi,%rax,4),%r8d
mov %r8d,-0x8(%rcx)
mov (%rdx,%rax,4),%r8d
mov %r8d,-0x4(%rcx)
mov %rax,%r8
add $0x1,%rax
cmp %r8,%r9
jne 1560 <func0+0x10>
retq
nopl 0x0(%rax)
| func0:
endbr64
mov r9, rsi
test r8d, r8d
jle short locret_1588
movsxd r8, r8d
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1568:
mov esi, [rdi+rax*4]
add rcx, 0Ch
mov [rcx-0Ch], esi
mov esi, [r9+rax*4]
mov [rcx-8], esi
mov esi, [rdx+rax*4]
add rax, 1
mov [rcx-4], esi
cmp r8, rax
jnz short loc_1568
locret_1588:
retn | void func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v6; // rax
int v7; // esi
if ( a5 > 0 )
{
v6 = 0LL;
do
{
a4 += 12LL;
*(_DWORD *)(a4 - 12) = *(_DWORD *)(a1 + 4 * v6);
*(_DWORD *)(a4 - 8) = *(_DWORD *)(a2 + 4 * v6);
v7 = *(_DWORD *)(a3 + 4 * v6++);
*(_DWORD *)(a4 - 4) = v7;
}
while ( a5 != v6 );
}
} | func0:
ENDBR64
MOV R9,RSI
TEST R8D,R8D
JLE 0x00101588
MOVSXD R8,R8D
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101568:
MOV ESI,dword ptr [RDI + RAX*0x4]
ADD RCX,0xc
MOV dword ptr [RCX + -0xc],ESI
MOV ESI,dword ptr [R9 + RAX*0x4]
MOV dword ptr [RCX + -0x8],ESI
MOV ESI,dword ptr [RDX + RAX*0x4]
ADD RAX,0x1
MOV dword ptr [RCX + -0x4],ESI
CMP R8,RAX
JNZ 0x00101568
LAB_00101588:
RET | void func0(long param_1,long param_2,long param_3,int4 *param_4,int param_5)
{
long lVar1;
long lVar2;
if (0 < param_5) {
lVar2 = 0;
do {
*param_4 = *(int4 *)(param_1 + lVar2 * 4);
param_4[1] = *(int4 *)(param_2 + lVar2 * 4);
lVar1 = lVar2 * 4;
lVar2 = lVar2 + 1;
param_4[2] = *(int4 *)(param_3 + lVar1);
param_4 = param_4 + 3;
} while (param_5 != lVar2);
}
return;
} |
6,207 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700};
for (int i = 0; i < size1 * 3; i++) assert(result1[i] == expected1[i]);
int size2 = 2;
int list4[] = {10, 20};
int list5[] = {15, 2};
int list6[] = {5, 10};
int result2[6];
func0(list4, list5, list6, result2, size2);
int expected2[] = {10, 15, 5, 20, 2, 10};
for (int i = 0; i < size2 * 3; i++) assert(result2[i] == expected2[i]);
int size3 = 2;
int list7[] = {11, 44};
int list8[] = {10, 15};
int list9[] = {20, 5};
int result3[6];
func0(list7, list8, list9, result3, size3);
int expected3[] = {11, 10, 20, 44, 15, 5};
for (int i = 0; i < size3 * 3; i++) assert(result3[i] == expected3[i]);
printf("All tests passed successfully!\n");
return 0;
}
| O3 | c | func0:
endbr64
test %r8d,%r8d
jle 14f8 <func0+0x38>
lea -0x1(%r8),%r9d
xor %eax,%eax
mov (%rdi,%rax,4),%r8d
add $0xc,%rcx
mov %r8d,-0xc(%rcx)
mov (%rsi,%rax,4),%r8d
mov %r8d,-0x8(%rcx)
mov (%rdx,%rax,4),%r8d
mov %r8d,-0x4(%rcx)
mov %rax,%r8
add $0x1,%rax
cmp %r9,%r8
jne 14d0 <func0+0x10>
retq
nopl 0x0(%rax)
| func0:
endbr64
test r8d, r8d
jle locret_1640
mov r9, rdx
lea edx, [r8-1]
push r14
mov rax, rcx
push rbp
movsxd rcx, r8d
push rbx
cmp edx, 2
jbe loc_1608
lea rdx, ds:0[rcx*4]
lea r10, [rcx+rcx*2]
lea rbx, [rax+r10*4]
lea r10, [rdi+rdx]
cmp rax, r10
setnb r11b
cmp rdi, rbx
setnb r10b
or r11d, r10d
lea r10, [rsi+rdx]
cmp rax, r10
setnb r10b
cmp rsi, rbx
setnb bpl
or r10d, ebp
test r11b, r10b
jz loc_1608
add rdx, r9
cmp rax, rdx
setnb dl
cmp r9, rbx
setnb r10b
or dl, r10b
jz loc_1608
mov r10d, r8d
mov rcx, rax
xor edx, edx
shr r10d, 2
shl r10, 4
nop dword ptr [rax+rax+00h]
loc_14F8:
movdqu xmm1, xmmword ptr [rdi+rdx]
movdqu xmm3, xmmword ptr [rsi+rdx]
add rcx, 30h ; '0'
movdqu xmm0, xmmword ptr [r9+rdx]
add rdx, 10h
movdqa xmm2, xmm1
punpckldq xmm2, xmm3
movdqa xmm4, xmm0
pshufd xmm2, xmm2, 84h
shufps xmm4, xmm2, 0F0h
shufps xmm2, xmm4, 84h
movups xmmword ptr [rcx-30h], xmm2
movdqa xmm2, xmm3
movdqa xmm4, xmm0
shufps xmm2, xmm1, 89h
shufps xmm3, xmm1, 0Fh
pshufd xmm2, xmm2, 78h ; 'x'
shufps xmm1, xmm3, 8Ch
shufps xmm0, xmm1, 9Eh
pshufd xmm0, xmm0, 78h ; 'x'
shufps xmm4, xmm2, 5
movups xmmword ptr [rcx-10h], xmm0
shufps xmm4, xmm2, 0E2h
movups xmmword ptr [rcx-20h], xmm4
cmp rdx, r10
jnz short loc_14F8
mov edx, r8d
and edx, 0FFFFFFFCh
lea ecx, [rdx+rdx*2]
cmp r8d, edx
jz loc_15FC
mov ebx, edx
movsxd r11, ecx
add ecx, 1
mov r14d, [rdi+rbx*4]
movsxd rcx, ecx
lea rbp, ds:0[r11*4]
lea r10, ds:0[rbx*4]
mov [rax+r11*4], r14d
mov r14d, [rsi+rbx*4]
lea r11, ds:0[rcx*4]
mov [rax+rcx*4], r14d
mov ecx, [r9+rbx*4]
mov [rax+r11+4], ecx
lea ecx, [rdx+1]
cmp r8d, ecx
jle short loc_15FC
mov ecx, [rdi+r10+4]
add edx, 2
mov [rax+rbp+0Ch], ecx
mov ecx, [rsi+r10+4]
mov [rax+r11+0Ch], ecx
mov ecx, [r9+r10+4]
mov [rax+r11+10h], ecx
cmp r8d, edx
jle short loc_15FC
mov edx, [rdi+r10+8]
mov [rax+rbp+18h], edx
mov edx, [rsi+r10+8]
mov [rax+r11+18h], edx
mov edx, [r9+r10+8]
mov [rax+r11+1Ch], edx
loc_15FC:
pop rbx
pop rbp
pop r14
retn
loc_1608:
shl rcx, 2
xor edx, edx
xchg ax, ax
loc_1610:
mov r8d, [rdi+rdx]
add rax, 0Ch
mov [rax-0Ch], r8d
mov r8d, [rsi+rdx]
mov [rax-8], r8d
mov r8d, [r9+rdx]
add rdx, 4
mov [rax-4], r8d
cmp rcx, rdx
jnz short loc_1610
pop rbx
pop rbp
pop r14
retn
locret_1640:
retn | void func0(unsigned long long a1, unsigned long long a2, unsigned long long a3, unsigned long long a4, int a5)
{
unsigned long long v6; // rax
unsigned long long v7; // rbx
long long v8; // rdx
__m128 v9; // xmm1
__m128 v10; // xmm3
__m128 v11; // xmm0
__m128 v12; // xmm2
__m128 v13; // xmm2
unsigned int v14; // edx
signed int v15; // ecx
long long v16; // rbp
long long v17; // r10
long long v18; // r11
long long v19; // rcx
long long v20; // rdx
int v21; // r8d
if ( a5 > 0 )
{
v6 = a4;
if ( (unsigned int)(a5 - 1) > 2
&& (v7 = a4 + 12LL * a5, (a2 >= v7 || a4 >= a2 + 4LL * a5) && (a1 >= v7 || a4 >= a1 + 4LL * a5))
&& (a3 >= v7 || a4 >= a3 + 4LL * a5) )
{
v8 = 0LL;
do
{
v9 = (__m128)_mm_loadu_si128((const __m128i *)(a1 + v8));
v10 = (__m128)_mm_loadu_si128((const __m128i *)(a2 + v8));
a4 += 48LL;
v11 = (__m128)_mm_loadu_si128((const __m128i *)(a3 + v8));
v8 += 16LL;
v12 = (__m128)_mm_shuffle_epi32(_mm_unpacklo_epi32((__m128i)v9, (__m128i)v10), 132);
*(__m128 *)(a4 - 48) = _mm_shuffle_ps(v12, _mm_shuffle_ps(v11, v12, 240), 132);
v13 = (__m128)_mm_shuffle_epi32((__m128i)_mm_shuffle_ps(v10, v9, 137), 120);
*(__m128i *)(a4 - 16) = _mm_shuffle_epi32(
(__m128i)_mm_shuffle_ps(
v11,
_mm_shuffle_ps(v9, _mm_shuffle_ps(v10, v9, 15), 140),
158),
120);
*(__m128 *)(a4 - 32) = _mm_shuffle_ps(_mm_shuffle_ps(v11, v13, 5), v13, 226);
}
while ( v8 != 16LL * ((unsigned int)a5 >> 2) );
v14 = a5 & 0x7FFFFFFC;
v15 = 3 * (a5 & 0xFFFFFFFC);
if ( a5 != (a5 & 0xFFFFFFFC) )
{
v16 = 4LL * v15;
v17 = 4LL * v14;
*(_DWORD *)(v6 + v16) = *(_DWORD *)(a1 + v17);
v18 = 4LL * (v15 + 1);
*(_DWORD *)(v6 + v18) = *(_DWORD *)(a2 + v17);
*(_DWORD *)(v6 + v18 + 4) = *(_DWORD *)(a3 + v17);
if ( a5 > (int)(v14 + 1) )
{
*(_DWORD *)(v6 + v16 + 12) = *(_DWORD *)(a1 + v17 + 4);
*(_DWORD *)(v6 + v18 + 12) = *(_DWORD *)(a2 + v17 + 4);
*(_DWORD *)(v6 + v18 + 16) = *(_DWORD *)(a3 + v17 + 4);
if ( a5 > (int)(v14 + 2) )
{
*(_DWORD *)(v6 + v16 + 24) = *(_DWORD *)(a1 + v17 + 8);
*(_DWORD *)(v6 + v18 + 24) = *(_DWORD *)(a2 + v17 + 8);
*(_DWORD *)(v6 + v18 + 28) = *(_DWORD *)(a3 + v17 + 8);
}
}
}
}
else
{
v19 = 4LL * a5;
v20 = 0LL;
do
{
v6 += 12LL;
*(_DWORD *)(v6 - 12) = *(_DWORD *)(a1 + v20);
*(_DWORD *)(v6 - 8) = *(_DWORD *)(a2 + v20);
v21 = *(_DWORD *)(a3 + v20);
v20 += 4LL;
*(_DWORD *)(v6 - 4) = v21;
}
while ( v19 != v20 );
}
}
} | func0:
ENDBR64
TEST R8D,R8D
JLE 0x00101640
MOV R9,RDX
LEA EDX,[R8 + -0x1]
PUSH R14
MOV RAX,RCX
PUSH RBP
MOVSXD RCX,R8D
PUSH RBX
CMP EDX,0x2
JBE 0x00101608
LEA RDX,[RCX*0x4]
LEA R10,[RCX + RCX*0x2]
LEA RBX,[RAX + R10*0x4]
LEA R10,[RDI + RDX*0x1]
CMP RAX,R10
SETNC R11B
CMP RDI,RBX
SETNC R10B
OR R11D,R10D
LEA R10,[RSI + RDX*0x1]
CMP RAX,R10
SETNC R10B
CMP RSI,RBX
SETNC BPL
OR R10D,EBP
TEST R11B,R10B
JZ 0x00101608
ADD RDX,R9
CMP RAX,RDX
SETNC DL
CMP R9,RBX
SETNC R10B
OR DL,R10B
JZ 0x00101608
MOV R10D,R8D
MOV RCX,RAX
XOR EDX,EDX
SHR R10D,0x2
SHL R10,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_001014f8:
MOVDQU XMM1,xmmword ptr [RDI + RDX*0x1]
MOVDQU XMM3,xmmword ptr [RSI + RDX*0x1]
ADD RCX,0x30
MOVDQU XMM0,xmmword ptr [R9 + RDX*0x1]
ADD RDX,0x10
MOVDQA XMM2,XMM1
PUNPCKLDQ XMM2,XMM3
MOVDQA XMM4,XMM0
PSHUFD XMM2,XMM2,0x84
SHUFPS XMM4,XMM2,0xf0
SHUFPS XMM2,XMM4,0x84
MOVUPS xmmword ptr [RCX + -0x30],XMM2
MOVDQA XMM2,XMM3
MOVDQA XMM4,XMM0
SHUFPS XMM2,XMM1,0x89
SHUFPS XMM3,XMM1,0xf
PSHUFD XMM2,XMM2,0x78
SHUFPS XMM1,XMM3,0x8c
SHUFPS XMM0,XMM1,0x9e
PSHUFD XMM0,XMM0,0x78
SHUFPS XMM4,XMM2,0x5
MOVUPS xmmword ptr [RCX + -0x10],XMM0
SHUFPS XMM4,XMM2,0xe2
MOVUPS xmmword ptr [RCX + -0x20],XMM4
CMP RDX,R10
JNZ 0x001014f8
MOV EDX,R8D
AND EDX,0xfffffffc
LEA ECX,[RDX + RDX*0x2]
CMP R8D,EDX
JZ 0x001015fc
MOV EBX,EDX
MOVSXD R11,ECX
ADD ECX,0x1
MOV R14D,dword ptr [RDI + RBX*0x4]
MOVSXD RCX,ECX
LEA RBP,[R11*0x4]
LEA R10,[RBX*0x4]
MOV dword ptr [RAX + R11*0x4],R14D
MOV R14D,dword ptr [RSI + RBX*0x4]
LEA R11,[RCX*0x4]
MOV dword ptr [RAX + RCX*0x4],R14D
MOV ECX,dword ptr [R9 + RBX*0x4]
MOV dword ptr [RAX + R11*0x1 + 0x4],ECX
LEA ECX,[RDX + 0x1]
CMP R8D,ECX
JLE 0x001015fc
MOV ECX,dword ptr [RDI + R10*0x1 + 0x4]
ADD EDX,0x2
MOV dword ptr [RAX + RBP*0x1 + 0xc],ECX
MOV ECX,dword ptr [RSI + R10*0x1 + 0x4]
MOV dword ptr [RAX + R11*0x1 + 0xc],ECX
MOV ECX,dword ptr [R9 + R10*0x1 + 0x4]
MOV dword ptr [RAX + R11*0x1 + 0x10],ECX
CMP R8D,EDX
JLE 0x001015fc
MOV EDX,dword ptr [RDI + R10*0x1 + 0x8]
MOV dword ptr [RAX + RBP*0x1 + 0x18],EDX
MOV EDX,dword ptr [RSI + R10*0x1 + 0x8]
MOV dword ptr [RAX + R11*0x1 + 0x18],EDX
MOV EDX,dword ptr [R9 + R10*0x1 + 0x8]
MOV dword ptr [RAX + R11*0x1 + 0x1c],EDX
LAB_001015fc:
POP RBX
POP RBP
POP R14
RET
LAB_00101608:
SHL RCX,0x2
XOR EDX,EDX
NOP
LAB_00101610:
MOV R8D,dword ptr [RDI + RDX*0x1]
ADD RAX,0xc
MOV dword ptr [RAX + -0xc],R8D
MOV R8D,dword ptr [RSI + RDX*0x1]
MOV dword ptr [RAX + -0x8],R8D
MOV R8D,dword ptr [R9 + RDX*0x1]
ADD RDX,0x4
MOV dword ptr [RAX + -0x4],R8D
CMP RCX,RDX
JNZ 0x00101610
POP RBX
POP RBP
POP R14
RET
LAB_00101640:
RET | void func0(int4 *param_1,int4 *param_2,int4 *param_3,int4 *param_4,
uint param_5)
{
int4 *puVar1;
int4 *puVar2;
int iVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int4 uVar12;
int4 uVar13;
int4 uVar14;
long lVar15;
int4 *puVar16;
uint uVar17;
long lVar18;
if ((int)param_5 < 1) {
return;
}
lVar15 = (long)(int)param_5;
if (2 < param_5 - 1) {
puVar16 = param_4 + lVar15 * 3;
if (((param_1 + lVar15 <= param_4 || puVar16 <= param_1) &&
(param_2 + lVar15 <= param_4 || puVar16 <= param_2)) &&
(param_3 + lVar15 <= param_4 || puVar16 <= param_3)) {
lVar15 = 0;
puVar16 = param_4;
do {
puVar1 = (int4 *)((long)param_1 + lVar15);
uVar4 = puVar1[1];
uVar5 = puVar1[2];
uVar6 = puVar1[3];
puVar2 = (int4 *)((long)param_2 + lVar15);
uVar7 = *puVar2;
uVar8 = puVar2[1];
uVar9 = puVar2[2];
uVar10 = puVar2[3];
puVar2 = (int4 *)((long)param_3 + lVar15);
uVar11 = *puVar2;
uVar12 = puVar2[1];
uVar13 = puVar2[2];
uVar14 = puVar2[3];
lVar15 = lVar15 + 0x10;
*puVar16 = *puVar1;
puVar16[1] = uVar7;
puVar16[2] = uVar11;
puVar16[3] = uVar4;
puVar16[8] = uVar13;
puVar16[9] = uVar6;
puVar16[10] = uVar10;
puVar16[0xb] = uVar14;
puVar16[4] = uVar8;
puVar16[5] = uVar12;
puVar16[6] = uVar5;
puVar16[7] = uVar9;
puVar16 = puVar16 + 0xc;
} while (lVar15 != (ulong)(param_5 >> 2) << 4);
uVar17 = param_5 & 0xfffffffc;
iVar3 = uVar17 * 3;
if (param_5 != uVar17) {
lVar15 = (long)(iVar3 + 1);
param_4[iVar3] = param_1[uVar17];
param_4[lVar15] = param_2[uVar17];
param_4[lVar15 + 1] = param_3[uVar17];
if ((int)(uVar17 + 1) < (int)param_5) {
param_4[(long)iVar3 + 3] = param_1[(ulong)uVar17 + 1];
param_4[lVar15 + 3] = param_2[(ulong)uVar17 + 1];
param_4[lVar15 + 4] = param_3[(ulong)uVar17 + 1];
if ((int)(uVar17 + 2) < (int)param_5) {
param_4[(long)iVar3 + 6] = param_1[(ulong)uVar17 + 2];
param_4[lVar15 + 6] = param_2[(ulong)uVar17 + 2];
param_4[lVar15 + 7] = param_3[(ulong)uVar17 + 2];
}
}
}
return;
}
}
lVar18 = 0;
do {
*param_4 = *(int4 *)((long)param_1 + lVar18);
param_4[1] = *(int4 *)((long)param_2 + lVar18);
puVar16 = (int4 *)((long)param_3 + lVar18);
lVar18 = lVar18 + 4;
param_4[2] = *puVar16;
param_4 = param_4 + 3;
} while (lVar15 * 4 != lVar18);
return;
} |
6,208 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (arr[i] == val)
return 1;
}
return 0;
}
// Function to find symmetric difference
| tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
if (!contains(a, a_len, b[i])) {
temp[count++] = b[i];
}
}
// Sort the result for consistent ordering
for (size_t i = 0; i < count - 1; i++) {
for (size_t j = i + 1; j < count; j++) {
if (temp[i] > temp[j]) {
int swap = temp[i];
temp[i] = temp[j];
temp[j] = swap;
}
}
}
tuple result;
result.data = temp;
result.size = count;
return result;
}
| int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.data);
// Test 2
int test2_a[] = {1, 2, 3, 4};
int test2_b[] = {7, 2, 3, 9};
int expected2[] = {1, 4, 7, 9};
tuple res2 = func0(test2_a, 4, test2_b, 4);
assert(res2.size == 4);
for (int i = 0; i < 4; i++) {
assert(res2.data[i] == expected2[i]);
}
free(res2.data);
// Test 3
int test3_a[] = {21, 11, 25, 26};
int test3_b[] = {26, 34, 21, 36};
int expected3[] = {11, 25, 34, 36};
tuple res3 = func0(test3_a, 4, test3_b, 4);
assert(res3.size == 4);
for (int i = 0; i < 4; i++) {
assert(res3.data[i] == expected3[i]);
}
free(res3.data);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %rdx,-0x68(%rbp)
mov %rcx,-0x70(%rbp)
mov -0x60(%rbp),%rdx
mov -0x70(%rbp),%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
jmp 12aa <func0+0xad>
mov -0x38(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x70(%rbp),%rcx
mov -0x68(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 11a9 <contains>
test %eax,%eax
jne 12a5 <func0+0xa8>
mov -0x38(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x58(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x40(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x40(%rbp)
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addq $0x1,-0x38(%rbp)
mov -0x38(%rbp),%rax
cmp -0x60(%rbp),%rax
jb 1246 <func0+0x49>
movq $0x0,-0x30(%rbp)
jmp 1322 <func0+0x125>
mov -0x30(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x60(%rbp),%rcx
mov -0x58(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 11a9 <contains>
test %eax,%eax
jne 131d <func0+0x120>
mov -0x30(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x40(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x40(%rbp)
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addq $0x1,-0x30(%rbp)
mov -0x30(%rbp),%rax
cmp -0x70(%rbp),%rax
jb 12be <func0+0xc1>
movq $0x0,-0x28(%rbp)
jmpq 13ea <func0+0x1ed>
mov -0x28(%rbp),%rax
add $0x1,%rax
mov %rax,-0x20(%rbp)
jmpq 13d7 <func0+0x1da>
mov -0x28(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 13d2 <func0+0x1d5>
mov -0x28(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x44(%rbp)
mov -0x20(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x20(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x44(%rbp),%eax
mov %eax,(%rdx)
addq $0x1,-0x20(%rbp)
mov -0x20(%rbp),%rax
cmp -0x40(%rbp),%rax
jb 134a <func0+0x14d>
addq $0x1,-0x28(%rbp)
mov -0x40(%rbp),%rax
sub $0x1,%rax
cmp %rax,-0x28(%rbp)
jb 1339 <func0+0x13c>
mov -0x18(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x40(%rbp),%rax
mov %rax,-0x8(%rbp)
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_70], rcx
mov rdx, [rbp+var_60]
mov rax, [rbp+var_70]
add rax, rdx
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_40], 0
mov [rbp+var_38], 0
jmp short loc_12AA
loc_1246:
mov rax, [rbp+var_38]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov edx, [rax]
mov rcx, [rbp+var_70]
mov rax, [rbp+var_68]
mov rsi, rcx
mov rdi, rax
call contains
test eax, eax
jnz short loc_12A5
mov rax, [rbp+var_38]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
lea rcx, [rdx+rax]
mov rax, [rbp+var_40]
lea rdx, [rax+1]
mov [rbp+var_40], rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_12A5:
add [rbp+var_38], 1
loc_12AA:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_60]
jb short loc_1246
mov [rbp+var_30], 0
jmp short loc_1322
loc_12BE:
mov rax, [rbp+var_30]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_68]
add rax, rdx
mov edx, [rax]
mov rcx, [rbp+var_60]
mov rax, [rbp+var_58]
mov rsi, rcx
mov rdi, rax
call contains
test eax, eax
jnz short loc_131D
mov rax, [rbp+var_30]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_68]
lea rcx, [rdx+rax]
mov rax, [rbp+var_40]
lea rdx, [rax+1]
mov [rbp+var_40], rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_131D:
add [rbp+var_30], 1
loc_1322:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_70]
jb short loc_12BE
mov [rbp+var_28], 0
jmp loc_13EA
loc_1339:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_20], rax
jmp loc_13D7
loc_134A:
mov rax, [rbp+var_28]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_20]
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_13D2
mov rax, [rbp+var_28]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_44], eax
mov rax, [rbp+var_20]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rbp+var_28]
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov rax, [rbp+var_20]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_44]
mov [rdx], eax
loc_13D2:
add [rbp+var_20], 1
loc_13D7:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
jb loc_134A
add [rbp+var_28], 1
loc_13EA:
mov rax, [rbp+var_40]
sub rax, 1
cmp [rbp+var_28], rax
jb loc_1339
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, unsigned long long a2, long long a3, unsigned long long a4)
{
unsigned long long v4; // rax
unsigned long long v5; // rax
int v9; // [rsp+2Ch] [rbp-44h]
unsigned long long v10; // [rsp+30h] [rbp-40h]
unsigned long long i; // [rsp+38h] [rbp-38h]
unsigned long long j; // [rsp+40h] [rbp-30h]
unsigned long long k; // [rsp+48h] [rbp-28h]
unsigned long long m; // [rsp+50h] [rbp-20h]
_DWORD *v15; // [rsp+58h] [rbp-18h]
v15 = malloc(4 * (a2 + a4));
v10 = 0LL;
for ( i = 0LL; i < a2; ++i )
{
if ( !(unsigned int)contains(a3, a4, *(unsigned int *)(4 * i + a1)) )
{
v4 = v10++;
v15[v4] = *(_DWORD *)(4 * i + a1);
}
}
for ( j = 0LL; j < a4; ++j )
{
if ( !(unsigned int)contains(a1, a2, *(unsigned int *)(4 * j + a3)) )
{
v5 = v10++;
v15[v5] = *(_DWORD *)(4 * j + a3);
}
}
for ( k = 0LL; k < v10 - 1; ++k )
{
for ( m = k + 1; m < v10; ++m )
{
if ( v15[k] > v15[m] )
{
v9 = v15[k];
v15[k] = v15[m];
v15[m] = v9;
}
}
}
return v15;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV qword ptr [RBP + -0x70],RCX
MOV RDX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,RDX
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
JMP 0x001012aa
LAB_00101246:
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001011a9
TEST EAX,EAX
JNZ 0x001012a5
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x40]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x40],RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_001012a5:
ADD qword ptr [RBP + -0x38],0x1
LAB_001012aa:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x60]
JC 0x00101246
MOV qword ptr [RBP + -0x30],0x0
JMP 0x00101322
LAB_001012be:
MOV RAX,qword ptr [RBP + -0x30]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001011a9
TEST EAX,EAX
JNZ 0x0010131d
MOV RAX,qword ptr [RBP + -0x30]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x68]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x40]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x40],RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010131d:
ADD qword ptr [RBP + -0x30],0x1
LAB_00101322:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x70]
JC 0x001012be
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001013ea
LAB_00101339:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001013d7
LAB_0010134a:
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001013d2
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RBP + -0x28]
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RDX],EAX
LAB_001013d2:
ADD qword ptr [RBP + -0x20],0x1
LAB_001013d7:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JC 0x0010134a
ADD qword ptr [RBP + -0x28],0x1
LAB_001013ea:
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,0x1
CMP qword ptr [RBP + -0x28],RAX
JC 0x00101339
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(long param_1,ulong param_2,long param_3,ulong param_4)
{
int4 uVar1;
int auVar2 [16];
int iVar3;
void *pvVar4;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
pvVar4 = malloc((param_4 + param_2) * 4);
local_48 = 0;
for (local_40 = 0; local_40 < param_2; local_40 = local_40 + 1) {
iVar3 = contains(param_3,param_4,*(int4 *)(param_1 + local_40 * 4));
if (iVar3 == 0) {
*(int4 *)(local_48 * 4 + (long)pvVar4) = *(int4 *)(local_40 * 4 + param_1);
local_48 = local_48 + 1;
}
}
for (local_38 = 0; local_38 < param_4; local_38 = local_38 + 1) {
iVar3 = contains(param_1,param_2,*(int4 *)(param_3 + local_38 * 4));
if (iVar3 == 0) {
*(int4 *)(local_48 * 4 + (long)pvVar4) = *(int4 *)(local_38 * 4 + param_3);
local_48 = local_48 + 1;
}
}
for (local_30 = 0; local_28 = local_30, local_30 < local_48 - 1; local_30 = local_30 + 1) {
while (local_28 = local_28 + 1, local_28 < local_48) {
if (*(int *)((long)pvVar4 + local_28 * 4) < *(int *)((long)pvVar4 + local_30 * 4)) {
uVar1 = *(int4 *)((long)pvVar4 + local_30 * 4);
*(int4 *)((long)pvVar4 + local_30 * 4) = *(int4 *)((long)pvVar4 + local_28 * 4);
*(int4 *)(local_28 * 4 + (long)pvVar4) = uVar1;
}
}
}
auVar2._8_8_ = local_48;
auVar2._0_8_ = pvVar4;
return auVar2;
} |
6,209 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (arr[i] == val)
return 1;
}
return 0;
}
// Function to find symmetric difference
| tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
if (!contains(a, a_len, b[i])) {
temp[count++] = b[i];
}
}
// Sort the result for consistent ordering
for (size_t i = 0; i < count - 1; i++) {
for (size_t j = i + 1; j < count; j++) {
if (temp[i] > temp[j]) {
int swap = temp[i];
temp[i] = temp[j];
temp[j] = swap;
}
}
}
tuple result;
result.data = temp;
result.size = count;
return result;
}
| int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.data);
// Test 2
int test2_a[] = {1, 2, 3, 4};
int test2_b[] = {7, 2, 3, 9};
int expected2[] = {1, 4, 7, 9};
tuple res2 = func0(test2_a, 4, test2_b, 4);
assert(res2.size == 4);
for (int i = 0; i < 4; i++) {
assert(res2.data[i] == expected2[i]);
}
free(res2.data);
// Test 3
int test3_a[] = {21, 11, 25, 26};
int test3_b[] = {26, 34, 21, 36};
int expected3[] = {11, 25, 34, 36};
tuple res3 = func0(test3_a, 4, test3_b, 4);
assert(res3.size == 4);
for (int i = 0; i < 4; i++) {
assert(res3.data[i] == expected3[i]);
}
free(res3.data);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r15
mov %rdi,0x10(%rsp)
mov %rsi,%rbx
mov %rsi,0x8(%rsp)
mov %rdx,%r13
mov %rcx,%r12
lea (%rsi,%rcx,1),%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %rbx,%rbx
je 12f3 <func0+0x11c>
mov %r15,%rbp
lea (%r15,%rbx,4),%rax
mov %rax,0x18(%rsp)
mov $0x0,%ebx
jmp 1236 <func0+0x5f>
add $0x4,%rbp
cmp 0x18(%rsp),%rbp
je 1256 <func0+0x7f>
mov 0x0(%rbp),%r15d
mov %r15d,%edx
mov %r12,%rsi
mov %r13,%rdi
callq 11a9 <contains>
test %eax,%eax
jne 122b <func0+0x54>
mov %r15d,(%r14,%rbx,4)
lea 0x1(%rbx),%rbx
jmp 122b <func0+0x54>
test %r12,%r12
je 1290 <func0+0xb9>
mov $0x0,%ebp
jmp 126b <func0+0x94>
add $0x1,%rbp
cmp %rbp,%r12
jbe 1290 <func0+0xb9>
mov 0x0(%r13,%rbp,4),%r15d
mov %r15d,%edx
mov 0x8(%rsp),%rsi
mov 0x10(%rsp),%rdi
callq 11a9 <contains>
test %eax,%eax
jne 1262 <func0+0x8b>
mov %r15d,(%r14,%rbx,4)
lea 0x1(%rbx),%rbx
jmp 1262 <func0+0x8b>
mov %rbx,%r9
sub $0x1,%r9
je 12d9 <func0+0x102>
lea 0x4(%r14),%rsi
lea (%r14,%rbx,4),%rdi
mov $0x0,%r8d
jmp 12cb <func0+0xf4>
add $0x4,%rax
cmp %rax,%rdi
je 12c2 <func0+0xeb>
mov -0x4(%rsi),%edx
mov (%rax),%ecx
cmp %ecx,%edx
jle 12a9 <func0+0xd2>
mov %ecx,-0x4(%rsi)
mov %edx,(%rax)
jmp 12a9 <func0+0xd2>
add $0x4,%rsi
cmp %r9,%r8
jae 12de <func0+0x107>
add $0x1,%r8
cmp %r8,%rbx
jbe 12c2 <func0+0xeb>
mov %rsi,%rax
jmp 12b2 <func0+0xdb>
mov $0x1,%ebx
mov %r14,%rax
mov %rbx,%rdx
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov 0x8(%rsp),%rbx
test %r12,%r12
jne 125b <func0+0x84>
mov %r12,%rbx
mov $0xffffffffffffffff,%r9
jmp 1299 <func0+0xc2>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r15, rdi
mov [rsp+58h+var_48], rdi
mov rbx, rsi
mov [rsp+58h+var_50], rsi
mov r13, rdx
mov r12, rcx
lea rdi, [rsi+rcx]
shl rdi, 2
call _malloc
mov r14, rax
test rbx, rbx
jz loc_12F3
mov rbp, r15
lea rax, [r15+rbx*4]
mov [rsp+58h+var_40], rax
mov ebx, 0
jmp short loc_1236
loc_122B:
add rbp, 4
cmp rbp, [rsp+58h+var_40]
jz short loc_1256
loc_1236:
mov r15d, [rbp+0]
mov edx, r15d
mov rsi, r12
mov rdi, r13
call contains
test eax, eax
jnz short loc_122B
mov [r14+rbx*4], r15d
lea rbx, [rbx+1]
jmp short loc_122B
loc_1256:
test r12, r12
jz short loc_1290
loc_125B:
mov ebp, 0
jmp short loc_126B
loc_1262:
add rbp, 1
cmp r12, rbp
jbe short loc_1290
loc_126B:
mov r15d, [r13+rbp*4+0]
mov edx, r15d
mov rsi, [rsp+58h+var_50]
mov rdi, [rsp+58h+var_48]
call contains
test eax, eax
jnz short loc_1262
mov [r14+rbx*4], r15d
lea rbx, [rbx+1]
jmp short loc_1262
loc_1290:
mov r9, rbx
sub r9, 1
jz short loc_12D9
loc_1299:
lea rsi, [r14+4]
lea rdi, [r14+rbx*4]
mov r8d, 0
jmp short loc_12CB
loc_12A9:
add rax, 4
cmp rdi, rax
jz short loc_12C2
loc_12B2:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_12A9
mov [rsi-4], ecx
mov [rax], edx
jmp short loc_12A9
loc_12C2:
add rsi, 4
cmp r8, r9
jnb short loc_12DE
loc_12CB:
add r8, 1
cmp rbx, r8
jbe short loc_12C2
mov rax, rsi
jmp short loc_12B2
loc_12D9:
mov ebx, 1
loc_12DE:
mov rax, r14
mov rdx, rbx
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12F3:
mov rbx, [rsp+58h+var_50]
test r12, r12
jnz loc_125B
mov rbx, r12
mov r9, 0FFFFFFFFFFFFFFFFh
jmp short loc_1299 | long long func0(unsigned int *a1, long long a2, long long a3, unsigned long long a4)
{
long long v6; // r14
unsigned int *v7; // rbp
unsigned long long v8; // rbx
unsigned int v9; // r15d
unsigned long long v10; // rbp
unsigned int v11; // r15d
unsigned long long v12; // r9
_DWORD *v13; // rsi
unsigned long long v14; // r8
_DWORD *v15; // rax
int v16; // edx
v6 = malloc(4 * (a2 + a4));
if ( a2 )
{
v7 = a1;
v8 = 0LL;
do
{
v9 = *v7;
if ( !(unsigned int)contains(a3, a4, *v7) )
*(_DWORD *)(v6 + 4 * v8++) = v9;
++v7;
}
while ( v7 != &a1[a2] );
if ( !a4 )
{
LABEL_11:
v12 = v8 - 1;
if ( v8 == 1 )
return v6;
goto LABEL_12;
}
LABEL_7:
v10 = 0LL;
do
{
v11 = *(_DWORD *)(a3 + 4 * v10);
if ( !(unsigned int)contains(a1, a2, v11) )
*(_DWORD *)(v6 + 4 * v8++) = v11;
++v10;
}
while ( a4 > v10 );
goto LABEL_11;
}
v8 = 0LL;
if ( a4 )
goto LABEL_7;
v8 = 0LL;
v12 = -1LL;
LABEL_12:
v13 = (_DWORD *)(v6 + 4);
v14 = 0LL;
do
{
if ( v8 > ++v14 )
{
v15 = v13;
do
{
v16 = *(v13 - 1);
if ( v16 > *v15 )
{
*(v13 - 1) = *v15;
*v15 = v16;
}
++v15;
}
while ( (_DWORD *)(v6 + 4 * v8) != v15 );
}
++v13;
}
while ( v14 < v12 );
return v6;
} | ||
6,210 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (arr[i] == val)
return 1;
}
return 0;
}
// Function to find symmetric difference
| tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
if (!contains(a, a_len, b[i])) {
temp[count++] = b[i];
}
}
// Sort the result for consistent ordering
for (size_t i = 0; i < count - 1; i++) {
for (size_t j = i + 1; j < count; j++) {
if (temp[i] > temp[j]) {
int swap = temp[i];
temp[i] = temp[j];
temp[j] = swap;
}
}
}
tuple result;
result.data = temp;
result.size = count;
return result;
}
| int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.data);
// Test 2
int test2_a[] = {1, 2, 3, 4};
int test2_b[] = {7, 2, 3, 9};
int expected2[] = {1, 4, 7, 9};
tuple res2 = func0(test2_a, 4, test2_b, 4);
assert(res2.size == 4);
for (int i = 0; i < 4; i++) {
assert(res2.data[i] == expected2[i]);
}
free(res2.data);
// Test 3
int test3_a[] = {21, 11, 25, 26};
int test3_b[] = {26, 34, 21, 36};
int expected3[] = {11, 25, 34, 36};
tuple res3 = func0(test3_a, 4, test3_b, 4);
assert(res3.size == 4);
for (int i = 0; i < 4; i++) {
assert(res3.data[i] == expected3[i]);
}
free(res3.data);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
lea (%rsi,%rcx,1),%rdi
push %rbp
shl $0x2,%rdi
mov %rcx,%rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %r13,%r13
je 160a <func0+0x14a>
mov %r12,%rcx
lea (%r12,%r13,4),%rsi
xor %r9d,%r9d
nopw 0x0(%rax,%rax,1)
mov (%rcx),%edx
test %rbp,%rbp
je 15d0 <func0+0x110>
xor %edi,%edi
jmp 151d <func0+0x5d>
add $0x1,%rdi
cmp %rdi,%rbp
je 15d0 <func0+0x110>
cmp (%rbx,%rdi,4),%edx
jne 1510 <func0+0x50>
add $0x4,%rcx
cmp %rsi,%rcx
jne 1500 <func0+0x40>
test %rbp,%rbp
je 156c <func0+0xac>
lea (%rbx,%rbp,4),%rsi
nopl 0x0(%rax)
mov (%rbx),%ecx
test %r13,%r13
je 15f0 <func0+0x130>
xor %edx,%edx
jmp 155d <func0+0x9d>
nopw 0x0(%rax,%rax,1)
add $0x1,%rdx
cmp %rdx,%r13
je 15f0 <func0+0x130>
cmp (%r12,%rdx,4),%ecx
jne 1550 <func0+0x90>
add $0x4,%rbx
cmp %rsi,%rbx
jne 1538 <func0+0x78>
mov %r9,%r11
sub $0x1,%r11
je 1622 <func0+0x162>
lea 0x4(%rax),%rdi
lea (%rax,%r9,4),%r8
xor %r10d,%r10d
nopl 0x0(%rax)
add $0x1,%r10
cmp %r10,%r9
jbe 15af <func0+0xef>
mov %rdi,%rdx
nopl 0x0(%rax)
mov -0x4(%rdi),%ecx
mov (%rdx),%esi
cmp %esi,%ecx
jle 15a6 <func0+0xe6>
mov %esi,-0x4(%rdi)
mov %ecx,(%rdx)
add $0x4,%rdx
cmp %rdx,%r8
jne 1598 <func0+0xd8>
add $0x4,%rdi
cmp %r10,%r11
jne 1588 <func0+0xc8>
add $0x8,%rsp
mov %r9,%rdx
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x4,%rcx
mov %edx,(%rax,%r9,4)
add $0x1,%r9
cmp %rsi,%rcx
jne 1500 <func0+0x40>
jmpq 152b <func0+0x6b>
nopw 0x0(%rax,%rax,1)
add $0x4,%rbx
mov %ecx,(%rax,%r9,4)
add $0x1,%r9
cmp %rsi,%rbx
jne 1538 <func0+0x78>
jmpq 156c <func0+0xac>
xor %r9d,%r9d
mov $0xffffffffffffffff,%r11
test %rbp,%rbp
jne 1530 <func0+0x70>
jmpq 1579 <func0+0xb9>
add $0x8,%rsp
mov $0x1,%r9d
pop %rbx
mov %r9,%rdx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov r13, rsi
push r12
mov r12, rdi
lea rdi, [rsi+rcx]
push rbp
shl rdi, 2
mov rbp, rcx
push rbx
mov rbx, rdx
sub rsp, 8
call _malloc
mov r9, rax
test r13, r13
jz loc_160A
mov rcx, r12
lea rsi, [r12+r13*4]
xor r8d, r8d
nop dword ptr [rax]
loc_1500:
mov edx, [rcx]
test rbp, rbp
jz loc_15D0
xor eax, eax
jmp short loc_151D
loc_1510:
add rax, 1
cmp rbp, rax
jz loc_15D0
loc_151D:
cmp edx, [rbx+rax*4]
jnz short loc_1510
add rcx, 4
cmp rcx, rsi
jnz short loc_1500
loc_152B:
test rbp, rbp
jz short loc_156C
loc_1530:
lea rcx, [rbx+rbp*4]
nop dword ptr [rax+00h]
loc_1538:
mov edx, [rbx]
test r13, r13
jz loc_15F0
xor eax, eax
jmp short loc_155D
loc_1550:
add rax, 1
cmp r13, rax
jz loc_15F0
loc_155D:
cmp edx, [r12+rax*4]
jnz short loc_1550
add rbx, 4
cmp rbx, rcx
jnz short loc_1538
loc_156C:
mov r11, r8
sub r11, 1
jz loc_1622
loc_1579:
lea rsi, [r9+4]
lea rdi, [r9+r8*4]
xor r10d, r10d
nop dword ptr [rax+00h]
loc_1588:
add r10, 1
cmp r10, r8
jnb short loc_15AF
mov rax, rsi
nop dword ptr [rax+00h]
loc_1598:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_15A6
mov [rsi-4], ecx
mov [rax], edx
loc_15A6:
add rax, 4
cmp rdi, rax
jnz short loc_1598
loc_15AF:
add rsi, 4
cmp r10, r11
jnz short loc_1588
loc_15B8:
add rsp, 8
mov rax, r9
mov rdx, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_15D0:
add rcx, 4
mov [r9+r8*4], edx
add r8, 1
cmp rcx, rsi
jnz loc_1500
jmp loc_152B
loc_15F0:
add rbx, 4
mov [r9+r8*4], edx
add r8, 1
cmp rbx, rcx
jnz loc_1538
jmp loc_156C
loc_160A:
xor r8d, r8d
mov r11, 0FFFFFFFFFFFFFFFFh
test rbp, rbp
jnz loc_1530
jmp loc_1579
loc_1622:
mov r8d, 1
jmp short loc_15B8 | long long func0(int *a1, long long a2, int *a3, long long a4)
{
long long v7; // r9
int *v8; // rcx
int *v9; // rsi
unsigned long long v10; // r8
int v11; // edx
long long v12; // rax
int *v13; // rcx
int v14; // edx
long long v15; // rax
long long v16; // r11
_DWORD *v17; // rsi
long long v18; // r10
_DWORD *v19; // rax
int v20; // edx
v7 = malloc(4 * (a2 + a4));
if ( a2 )
{
v8 = a1;
v9 = &a1[a2];
v10 = 0LL;
do
{
while ( 1 )
{
v11 = *v8;
if ( a4 )
break;
LABEL_24:
++v8;
*(_DWORD *)(v7 + 4 * v10++) = v11;
if ( v8 == v9 )
goto LABEL_8;
}
v12 = 0LL;
while ( v11 != a3[v12] )
{
if ( a4 == ++v12 )
goto LABEL_24;
}
++v8;
}
while ( v8 != v9 );
LABEL_8:
if ( !a4 )
{
LABEL_15:
v16 = v10 - 1;
if ( v10 == 1 )
return v7;
goto LABEL_16;
}
LABEL_9:
v13 = &a3[a4];
do
{
while ( 1 )
{
v14 = *a3;
if ( a2 )
break;
LABEL_26:
++a3;
*(_DWORD *)(v7 + 4 * v10++) = v14;
if ( a3 == v13 )
goto LABEL_15;
}
v15 = 0LL;
while ( v14 != a1[v15] )
{
if ( a2 == ++v15 )
goto LABEL_26;
}
++a3;
}
while ( a3 != v13 );
goto LABEL_15;
}
v10 = 0LL;
v16 = -1LL;
if ( a4 )
goto LABEL_9;
LABEL_16:
v17 = (_DWORD *)(v7 + 4);
v18 = 0LL;
do
{
if ( ++v18 < v10 )
{
v19 = v17;
do
{
v20 = *(v17 - 1);
if ( v20 > *v19 )
{
*(v17 - 1) = *v19;
*v19 = v20;
}
++v19;
}
while ( (_DWORD *)(v7 + 4 * v10) != v19 );
}
++v17;
}
while ( v18 != v16 );
return v7;
} | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
LEA RDI,[RSI + RCX*0x1]
PUSH RBP
SHL RDI,0x2
MOV RBP,RCX
PUSH RBX
MOV RBX,RDX
SUB RSP,0x8
CALL 0x001010b0
MOV R9,RAX
TEST R13,R13
JZ 0x0010160a
MOV RCX,R12
LEA RSI,[R12 + R13*0x4]
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101500:
MOV EDX,dword ptr [RCX]
TEST RBP,RBP
JZ 0x001015d0
XOR EAX,EAX
JMP 0x0010151d
LAB_00101510:
ADD RAX,0x1
CMP RBP,RAX
JZ 0x001015d0
LAB_0010151d:
CMP EDX,dword ptr [RBX + RAX*0x4]
JNZ 0x00101510
ADD RCX,0x4
CMP RCX,RSI
JNZ 0x00101500
LAB_0010152b:
TEST RBP,RBP
JZ 0x0010156c
LAB_00101530:
LEA RCX,[RBX + RBP*0x4]
NOP dword ptr [RAX]
LAB_00101538:
MOV EDX,dword ptr [RBX]
TEST R13,R13
JZ 0x001015f0
XOR EAX,EAX
JMP 0x0010155d
LAB_00101550:
ADD RAX,0x1
CMP R13,RAX
JZ 0x001015f0
LAB_0010155d:
CMP EDX,dword ptr [R12 + RAX*0x4]
JNZ 0x00101550
ADD RBX,0x4
CMP RBX,RCX
JNZ 0x00101538
LAB_0010156c:
MOV R11,R8
SUB R11,0x1
JZ 0x00101622
LAB_00101579:
LEA RSI,[R9 + 0x4]
LEA RDI,[R9 + R8*0x4]
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_00101588:
ADD R10,0x1
CMP R10,R8
JNC 0x001015af
MOV RAX,RSI
NOP dword ptr [RAX]
LAB_00101598:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x001015a6
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_001015a6:
ADD RAX,0x4
CMP RDI,RAX
JNZ 0x00101598
LAB_001015af:
ADD RSI,0x4
CMP R10,R11
JNZ 0x00101588
LAB_001015b8:
ADD RSP,0x8
MOV RAX,R9
MOV RDX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001015d0:
ADD RCX,0x4
MOV dword ptr [R9 + R8*0x4],EDX
ADD R8,0x1
CMP RCX,RSI
JNZ 0x00101500
JMP 0x0010152b
LAB_001015f0:
ADD RBX,0x4
MOV dword ptr [R9 + R8*0x4],EDX
ADD R8,0x1
CMP RBX,RCX
JNZ 0x00101538
JMP 0x0010156c
LAB_0010160a:
XOR R8D,R8D
MOV R11,-0x1
TEST RBP,RBP
JNZ 0x00101530
JMP 0x00101579
LAB_00101622:
MOV R8D,0x1
JMP 0x001015b8 | int1 [16] func0(int *param_1,long param_2,int *param_3,long param_4)
{
int iVar1;
long lVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int1 auVar8 [16];
auVar8._0_8_ = (int *)malloc((param_2 + param_4) * 4);
if (param_2 == 0) {
uVar5 = 0;
uVar7 = 0xffffffffffffffff;
if (param_4 != 0) goto LAB_00101530;
}
else {
uVar5 = 0;
piVar4 = param_1;
do {
if (param_4 != 0) {
lVar2 = 0;
do {
if (*piVar4 == param_3[lVar2]) goto joined_r0x00101529;
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
}
auVar8._0_8_[uVar5] = *piVar4;
uVar5 = uVar5 + 1;
joined_r0x00101529:
piVar4 = piVar4 + 1;
} while (piVar4 != param_1 + param_2);
if (param_4 != 0) {
LAB_00101530:
piVar4 = param_3 + param_4;
do {
if (param_2 != 0) {
lVar2 = 0;
do {
if (*param_3 == param_1[lVar2]) goto joined_r0x0010156a;
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
}
auVar8._0_8_[uVar5] = *param_3;
uVar5 = uVar5 + 1;
joined_r0x0010156a:
param_3 = param_3 + 1;
} while (param_3 != piVar4);
}
uVar7 = uVar5 - 1;
if (uVar7 == 0) {
uVar5 = 1;
goto LAB_001015b8;
}
}
uVar6 = 0;
piVar4 = auVar8._0_8_;
do {
uVar6 = uVar6 + 1;
piVar3 = piVar4 + 1;
if (uVar6 < uVar5) {
do {
iVar1 = *piVar4;
if (*piVar3 < iVar1) {
*piVar4 = *piVar3;
*piVar3 = iVar1;
}
piVar3 = piVar3 + 1;
} while (auVar8._0_8_ + uVar5 != piVar3);
}
piVar4 = piVar4 + 1;
} while (uVar6 != uVar7);
LAB_001015b8:
auVar8._8_8_ = uVar5;
return auVar8;
} |
6,211 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (arr[i] == val)
return 1;
}
return 0;
}
// Function to find symmetric difference
| tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
if (!contains(a, a_len, b[i])) {
temp[count++] = b[i];
}
}
// Sort the result for consistent ordering
for (size_t i = 0; i < count - 1; i++) {
for (size_t j = i + 1; j < count; j++) {
if (temp[i] > temp[j]) {
int swap = temp[i];
temp[i] = temp[j];
temp[j] = swap;
}
}
}
tuple result;
result.data = temp;
result.size = count;
return result;
}
| int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.data);
// Test 2
int test2_a[] = {1, 2, 3, 4};
int test2_b[] = {7, 2, 3, 9};
int expected2[] = {1, 4, 7, 9};
tuple res2 = func0(test2_a, 4, test2_b, 4);
assert(res2.size == 4);
for (int i = 0; i < 4; i++) {
assert(res2.data[i] == expected2[i]);
}
free(res2.data);
// Test 3
int test3_a[] = {21, 11, 25, 26};
int test3_b[] = {26, 34, 21, 36};
int expected3[] = {11, 25, 34, 36};
tuple res3 = func0(test3_a, 4, test3_b, 4);
assert(res3.size == 4);
for (int i = 0; i < 4; i++) {
assert(res3.data[i] == expected3[i]);
}
free(res3.data);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
lea (%rsi,%rcx,1),%rdi
push %rbp
shl $0x2,%rdi
mov %rcx,%rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %r13,%r13
je 155a <func0+0x14a>
mov %r12,%rcx
lea (%r12,%r13,4),%rsi
xor %r9d,%r9d
nopw 0x0(%rax,%rax,1)
mov (%rcx),%edx
test %rbp,%rbp
je 1520 <func0+0x110>
xor %edi,%edi
jmp 146d <func0+0x5d>
add $0x1,%rdi
cmp %rdi,%rbp
je 1520 <func0+0x110>
cmp (%rbx,%rdi,4),%edx
jne 1460 <func0+0x50>
add $0x4,%rcx
cmp %rsi,%rcx
jne 1450 <func0+0x40>
test %rbp,%rbp
je 14bc <func0+0xac>
lea (%rbx,%rbp,4),%rsi
nopl 0x0(%rax)
mov (%rbx),%ecx
test %r13,%r13
je 1540 <func0+0x130>
xor %edx,%edx
jmp 14ad <func0+0x9d>
nopw 0x0(%rax,%rax,1)
add $0x1,%rdx
cmp %rdx,%r13
je 1540 <func0+0x130>
cmp (%r12,%rdx,4),%ecx
jne 14a0 <func0+0x90>
add $0x4,%rbx
cmp %rbx,%rsi
jne 1488 <func0+0x78>
mov %r9,%r11
sub $0x1,%r11
je 1572 <func0+0x162>
lea 0x4(%rax),%rdi
lea (%rax,%r9,4),%r8
xor %r10d,%r10d
nopl 0x0(%rax)
add $0x1,%r10
cmp %r10,%r9
jbe 14ff <func0+0xef>
mov %rdi,%rdx
nopl 0x0(%rax)
mov -0x4(%rdi),%ecx
mov (%rdx),%esi
cmp %esi,%ecx
jle 14f6 <func0+0xe6>
mov %esi,-0x4(%rdi)
mov %ecx,(%rdx)
add $0x4,%rdx
cmp %rdx,%r8
jne 14e8 <func0+0xd8>
add $0x4,%rdi
cmp %r10,%r11
jne 14d8 <func0+0xc8>
add $0x8,%rsp
mov %r9,%rdx
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x4,%rcx
mov %edx,(%rax,%r9,4)
add $0x1,%r9
cmp %rsi,%rcx
jne 1450 <func0+0x40>
jmpq 147b <func0+0x6b>
nopw 0x0(%rax,%rax,1)
add $0x4,%rbx
mov %ecx,(%rax,%r9,4)
add $0x1,%r9
cmp %rbx,%rsi
jne 1488 <func0+0x78>
jmpq 14bc <func0+0xac>
xor %r9d,%r9d
mov $0xffffffffffffffff,%r11
test %rbp,%rbp
jne 1480 <func0+0x70>
jmpq 14c9 <func0+0xb9>
add $0x8,%rsp
mov $0x1,%r9d
pop %rbx
mov %r9,%rdx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov r13, rdi
lea rdi, [rsi+rcx]
push r12
shl rdi, 2; size
mov r12, rsi
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
sub rsp, 8
call _malloc
mov r9, rax
test r12, r12
jz loc_1541
mov rcx, r13
lea rdi, [r13+r12*4+0]
xor esi, esi
nop dword ptr [rax]
loc_1450:
mov edx, [rcx]
test rbx, rbx
jz short loc_1480
loc_1457:
xor eax, eax
jmp short loc_1469
loc_1460:
add rax, 1
cmp rbx, rax
jz short loc_1480
loc_1469:
cmp edx, [rbp+rax*4+0]
jnz short loc_1460
add rcx, 4
cmp rcx, rdi
jz short loc_1496
mov edx, [rcx]
jmp short loc_1457
loc_1480:
add rcx, 4
mov [r9+rsi*4], edx
lea r8, [rsi+1]
cmp rcx, rdi
jz short loc_1499
mov rsi, r8
jmp short loc_1450
loc_1496:
mov r8, rsi
loc_1499:
test rbx, rbx
jz short loc_14E1
loc_149E:
xor ecx, ecx
loc_14A0:
mov edx, [rbp+rcx*4+0]
mov rsi, r8
test r12, r12
jz short loc_14D0
loc_14AC:
xor eax, eax
jmp short loc_14B9
loc_14B0:
add rax, 1
cmp r12, rax
jz short loc_14D0
loc_14B9:
cmp edx, [r13+rax*4+0]
jnz short loc_14B0
add rcx, 1
cmp rcx, rbx
jnb short loc_14E1
mov edx, [rbp+rcx*4+0]
jmp short loc_14AC
loc_14D0:
add rcx, 1
mov [r9+rsi*4], edx
add r8, 1
cmp rcx, rbx
jb short loc_14A0
loc_14E1:
cmp r8, 1
jz short loc_1530
lea r11, [r8-1]
loc_14EB:
lea rsi, [r9+4]
lea rdi, [r9+r8*4]
xor r10d, r10d
nop word ptr [rax+rax+00000000h]
loc_1500:
add r10, 1
mov rax, rsi
cmp r10, r8
jnb short loc_1527
nop dword ptr [rax+00h]
loc_1510:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_151E
mov [rsi-4], ecx
mov [rax], edx
loc_151E:
add rax, 4
cmp rdi, rax
jnz short loc_1510
loc_1527:
add rsi, 4
cmp r10, r11
jb short loc_1500
loc_1530:
add rsp, 8
mov rax, r9
mov rdx, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1541:
xor r8d, r8d
mov r11, 0FFFFFFFFFFFFFFFFh
test rbx, rbx
jnz loc_149E
jmp short loc_14EB | _DWORD * func0(int *a1, long long a2, long long a3, unsigned long long a4)
{
_DWORD *v8; // r9
int *v9; // rcx
int *v10; // rdi
unsigned long long i; // rsi
int v12; // edx
long long v13; // rax
unsigned long long v14; // r8
unsigned long long v15; // rcx
int v16; // edx
long long v17; // rax
unsigned long long v18; // r11
_DWORD *v19; // rsi
unsigned long long v20; // r10
_DWORD *v21; // rax
int v22; // edx
v8 = malloc(4 * (a2 + a4));
if ( a2 )
{
v9 = a1;
v10 = &a1[a2];
for ( i = 0LL; ; ++i )
{
v12 = *v9;
if ( a4 )
break;
LABEL_9:
++v9;
v8[i] = v12;
v14 = i + 1;
if ( v9 == v10 )
goto LABEL_12;
}
while ( 1 )
{
v13 = 0LL;
while ( v12 != *(_DWORD *)(a3 + 4 * v13) )
{
if ( a4 == ++v13 )
goto LABEL_9;
}
if ( ++v9 == v10 )
break;
v12 = *v9;
}
v14 = i;
LABEL_12:
if ( !a4 )
goto LABEL_21;
}
else
{
v14 = 0LL;
v18 = -1LL;
if ( !a4 )
goto LABEL_23;
}
v15 = 0LL;
while ( 1 )
{
v16 = *(_DWORD *)(a3 + 4 * v15);
if ( a2 )
break;
LABEL_20:
++v15;
v8[v14++] = v16;
if ( v15 >= a4 )
goto LABEL_21;
}
while ( 1 )
{
v17 = 0LL;
while ( v16 != a1[v17] )
{
if ( a2 == ++v17 )
goto LABEL_20;
}
if ( ++v15 >= a4 )
break;
v16 = *(_DWORD *)(a3 + 4 * v15);
}
LABEL_21:
if ( v14 == 1 )
return v8;
v18 = v14 - 1;
LABEL_23:
v19 = v8 + 1;
v20 = 0LL;
do
{
++v20;
v21 = v19;
if ( v20 < v14 )
{
do
{
v22 = *(v19 - 1);
if ( v22 > *v21 )
{
*(v19 - 1) = *v21;
*v21 = v22;
}
++v21;
}
while ( &v8[v14] != v21 );
}
++v19;
}
while ( v20 < v18 );
return v8;
} | func0:
ENDBR64
PUSH R13
MOV R13,RDI
LEA RDI,[RSI + RCX*0x1]
PUSH R12
SHL RDI,0x2
MOV R12,RSI
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
SUB RSP,0x8
CALL 0x001010b0
MOV R9,RAX
TEST R12,R12
JZ 0x00101541
MOV RCX,R13
LEA RDI,[R13 + R12*0x4]
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101450:
MOV EDX,dword ptr [RCX]
TEST RBX,RBX
JZ 0x00101480
LAB_00101457:
XOR EAX,EAX
JMP 0x00101469
LAB_00101460:
ADD RAX,0x1
CMP RBX,RAX
JZ 0x00101480
LAB_00101469:
CMP EDX,dword ptr [RBP + RAX*0x4]
JNZ 0x00101460
ADD RCX,0x4
CMP RCX,RDI
JZ 0x00101496
MOV EDX,dword ptr [RCX]
JMP 0x00101457
LAB_00101480:
ADD RCX,0x4
MOV dword ptr [R9 + RSI*0x4],EDX
LEA R8,[RSI + 0x1]
CMP RCX,RDI
JZ 0x00101499
MOV RSI,R8
JMP 0x00101450
LAB_00101496:
MOV R8,RSI
LAB_00101499:
TEST RBX,RBX
JZ 0x001014e1
LAB_0010149e:
XOR ECX,ECX
LAB_001014a0:
MOV EDX,dword ptr [RBP + RCX*0x4]
MOV RSI,R8
TEST R12,R12
JZ 0x001014d0
LAB_001014ac:
XOR EAX,EAX
JMP 0x001014b9
LAB_001014b0:
ADD RAX,0x1
CMP R12,RAX
JZ 0x001014d0
LAB_001014b9:
CMP EDX,dword ptr [R13 + RAX*0x4]
JNZ 0x001014b0
ADD RCX,0x1
CMP RCX,RBX
JNC 0x001014e1
MOV EDX,dword ptr [RBP + RCX*0x4]
JMP 0x001014ac
LAB_001014d0:
ADD RCX,0x1
MOV dword ptr [R9 + RSI*0x4],EDX
ADD R8,0x1
CMP RCX,RBX
JC 0x001014a0
LAB_001014e1:
CMP R8,0x1
JZ 0x00101530
LEA R11,[R8 + -0x1]
LAB_001014eb:
LEA RSI,[R9 + 0x4]
LEA RDI,[R9 + R8*0x4]
XOR R10D,R10D
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101500:
ADD R10,0x1
MOV RAX,RSI
CMP R10,R8
JNC 0x00101527
NOP dword ptr [RAX]
LAB_00101510:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x0010151e
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_0010151e:
ADD RAX,0x4
CMP RDI,RAX
JNZ 0x00101510
LAB_00101527:
ADD RSI,0x4
CMP R10,R11
JC 0x00101500
LAB_00101530:
ADD RSP,0x8
MOV RAX,R9
MOV RDX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101541:
XOR R8D,R8D
MOV R11,-0x1
TEST RBX,RBX
JNZ 0x0010149e
JMP 0x001014eb | int [16] func0(int *param_1,long param_2,long param_3,ulong param_4)
{
long lVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
int auVar8 [16];
auVar8._0_8_ = (int *)malloc((param_2 + param_4) * 4);
if (param_2 == 0) {
uVar6 = 0;
uVar4 = 0xffffffffffffffff;
if (param_4 != 0) goto LAB_0010149e;
}
else {
uVar6 = 0;
piVar3 = param_1;
do {
iVar5 = *piVar3;
if (param_4 != 0) {
while( true ) {
uVar4 = 0;
while (iVar5 != *(int *)(param_3 + uVar4 * 4)) {
uVar4 = uVar4 + 1;
if (param_4 == uVar4) goto LAB_00101480;
}
piVar3 = piVar3 + 1;
if (piVar3 == param_1 + param_2) break;
iVar5 = *piVar3;
}
break;
}
LAB_00101480:
piVar3 = piVar3 + 1;
auVar8._0_8_[uVar6] = iVar5;
uVar6 = uVar6 + 1;
} while (piVar3 != param_1 + param_2);
if (param_4 != 0) {
LAB_0010149e:
uVar4 = 0;
do {
iVar5 = *(int *)(param_3 + uVar4 * 4);
if (param_2 != 0) {
while( true ) {
lVar1 = 0;
while (iVar5 != param_1[lVar1]) {
lVar1 = lVar1 + 1;
if (param_2 == lVar1) goto LAB_001014d0;
}
uVar4 = uVar4 + 1;
if (param_4 <= uVar4) break;
iVar5 = *(int *)(param_3 + uVar4 * 4);
}
break;
}
LAB_001014d0:
uVar4 = uVar4 + 1;
auVar8._0_8_[uVar6] = iVar5;
uVar6 = uVar6 + 1;
} while (uVar4 < param_4);
}
if (uVar6 == 1) goto LAB_00101530;
uVar4 = uVar6 - 1;
}
uVar7 = 0;
piVar3 = auVar8._0_8_;
do {
uVar7 = uVar7 + 1;
piVar2 = piVar3 + 1;
if (uVar7 < uVar6) {
do {
iVar5 = *piVar3;
if (*piVar2 < iVar5) {
*piVar3 = *piVar2;
*piVar2 = iVar5;
}
piVar2 = piVar2 + 1;
} while (auVar8._0_8_ + uVar6 != piVar2);
}
piVar3 = piVar3 + 1;
} while (uVar7 < uVar4);
LAB_00101530:
auVar8._8_8_ = uVar6;
return auVar8;
} |
6,212 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an integer element
Element make_int(int value) {
Element e;
e.is_tuple = 0;
e.data.value = value;
return e;
}
// Function to create a tuple element
Element make_tuple(Element* elements, int size);
// Function to create a tuple
Tuple* create_tuple(Element* elements, int size) {
Tuple* t = malloc(sizeof(Tuple));
t->elements = malloc(sizeof(Element) * size);
for(int i = 0; i < size; i++) {
t->elements[i] = elements[i];
}
t->size = size;
return t;
}
// Function to create a tuple element
Element make_tuple_element(Element* elements, int size) {
Element e;
e.is_tuple = 1;
e.data.tuple = create_tuple(elements, size);
return e;
}
// Function to check if a number is even
int is_even(int x) {
return x % 2 == 0;
}
// Recursive function to extract even elements
Tuple* even_ele(Tuple* test_tuple, int (*even_fnc)(int)) {
Tuple* res = create_tuple(NULL, 0);
for(int i = 0; i < test_tuple->size; i++) {
Element ele = test_tuple->elements[i];
if(ele.is_tuple) {
Tuple* filtered = even_ele(ele.data.tuple, even_fnc);
if(filtered->size > 0) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_tuple_element(filtered->elements, filtered->size);
res->size++;
}
}
else if(even_fnc(ele.data.value)) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_int(ele.data.value);
res->size++;
}
}
return res;
}
// Function to extract even elements
Tuple* extract_even(Tuple* test_tuple) {
return even_ele(test_tuple, is_even);
}
// Function to compare two tuples
| int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) return 0;
}
else {
if(ea.data.value != eb.data.value) return 0;
}
}
return 1;
}
// Main Function with Assert Statements
| int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_element(sub_elements1, 3), make_int(6), make_int(8) };
Tuple* input1 = create_tuple(input_elements1, 5);
// Construct expected tuple: (4, (6, (2, 4)), 6, 8)
Element expected_sub_sub_elements1[] = { make_int(2), make_int(4) };
Element expected_sub_elements1[] = { make_int(6), make_tuple_element(expected_sub_sub_elements1, 2) };
Element expected_elements1[] = { make_int(4), make_tuple_element(expected_sub_elements1, 2), make_int(6), make_int(8) };
Tuple* expected1 = create_tuple(expected_elements1, 4);
// Assert first test case
Tuple* result1 = extract_even(input1);
assert(func0(result1, expected1));
// Construct second input tuple: (5, 6, (8, 7, (4, 8)), 7, 9)
Element sub_sub_elements2[] = { make_int(4), make_int(8) };
Element sub_elements2[] = { make_int(8), make_int(7), make_tuple_element(sub_sub_elements2, 2) };
Element input_elements2[] = { make_int(5), make_int(6), make_tuple_element(sub_elements2, 3), make_int(7), make_int(9) };
Tuple* input2 = create_tuple(input_elements2, 5);
// Construct expected tuple: (6, (8, (4, 8)))
Element expected_sub_elements2[] = { make_int(8), make_tuple_element(sub_sub_elements2, 2) };
Element expected_elements2[] = { make_int(6), make_tuple_element(expected_sub_elements2, 2) };
Tuple* expected2 = create_tuple(expected_elements2, 2);
// Assert second test case
Tuple* result2 = extract_even(input2);
assert(func0(result2, expected2));
// Construct third input tuple: (5, 6, (9, 8, (4, 6)), 8, 10)
Element sub_sub_elements3[] = { make_int(4), make_int(6) };
Element sub_elements3[] = { make_int(9), make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element input_elements3[] = { make_int(5), make_int(6), make_tuple_element(sub_elements3, 3), make_int(8), make_int(10) };
Tuple* input3 = create_tuple(input_elements3, 5);
// Construct expected tuple: (6, (8, (4, 6)), 8, 10)
Element expected_sub_elements3[] = { make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element expected_elements3[] = { make_int(6), make_tuple_element(expected_sub_elements3, 2), make_int(8), make_int(10) };
Tuple* expected3 = create_tuple(expected_elements3, 4);
// Assert third test case
Tuple* result3 = extract_even(input3);
assert(func0(result3, expected3));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x40(%rbp),%rax
mov 0x8(%rax),%eax
cmp %eax,%edx
je 14be <func0+0x30>
mov $0x0,%eax
jmpq 1570 <func0+0xe2>
movl $0x0,-0x24(%rbp)
jmpq 155b <func0+0xcd>
mov -0x38(%rbp),%rax
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
mov 0x8(%rax),%rdx
mov (%rax),%rax
mov %rax,-0x20(%rbp)
mov %rdx,-0x18(%rbp)
mov -0x40(%rbp),%rax
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
mov 0x8(%rax),%rdx
mov (%rax),%rax
mov %rax,-0x10(%rbp)
mov %rdx,-0x8(%rbp)
mov -0x20(%rbp),%edx
mov -0x10(%rbp),%eax
cmp %eax,%edx
je 1521 <func0+0x93>
mov $0x0,%eax
jmp 1570 <func0+0xe2>
mov -0x20(%rbp),%eax
test %eax,%eax
je 1546 <func0+0xb8>
mov -0x8(%rbp),%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 148e <func0>
test %eax,%eax
jne 1557 <func0+0xc9>
mov $0x0,%eax
jmp 1570 <func0+0xe2>
mov -0x18(%rbp),%edx
mov -0x8(%rbp),%eax
cmp %eax,%edx
je 1557 <func0+0xc9>
mov $0x0,%eax
jmp 1570 <func0+0xe2>
addl $0x1,-0x24(%rbp)
mov -0x38(%rbp),%rax
mov 0x8(%rax),%eax
cmp %eax,-0x24(%rbp)
jl 14ca <func0+0x3c>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+var_38]
mov edx, [rax+8]
mov rax, [rbp+var_40]
mov eax, [rax+8]
cmp edx, eax
jz short loc_14D4
mov eax, 0
jmp locret_1586
loc_14D4:
mov [rbp+var_24], 0
jmp loc_1571
loc_14E0:
mov rax, [rbp+var_38]
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov rdx, [rax+8]
mov rax, [rax]
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
mov rax, [rbp+var_40]
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov rdx, [rax+8]
mov rax, [rax]
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
mov edx, dword ptr [rbp+var_20]
mov eax, dword ptr [rbp+var_10]
cmp edx, eax
jz short loc_1537
mov eax, 0
jmp short locret_1586
loc_1537:
mov eax, dword ptr [rbp+var_20]
test eax, eax
jz short loc_155C
mov rdx, [rbp+var_8]
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call func0
test eax, eax
jnz short loc_156D
mov eax, 0
jmp short locret_1586
loc_155C:
mov edx, dword ptr [rbp+var_18]
mov eax, dword ptr [rbp+var_8]
cmp edx, eax
jz short loc_156D
mov eax, 0
jmp short locret_1586
loc_156D:
add [rbp+var_24], 1
loc_1571:
mov rax, [rbp+var_38]
mov eax, [rax+8]
cmp [rbp+var_24], eax
jl loc_14E0
mov eax, 1
locret_1586:
leave
retn | long long func0(long long a1, long long a2)
{
long long *v3; // rax
_QWORD *v4; // rax
int i; // [rsp+1Ch] [rbp-24h]
long long v6; // [rsp+20h] [rbp-20h]
long long v7; // [rsp+28h] [rbp-18h]
long long v8; // [rsp+38h] [rbp-8h]
if ( *(_DWORD *)(a1 + 8) != *(_DWORD *)(a2 + 8) )
return 0LL;
for ( i = 0; i < *(_DWORD *)(a1 + 8); ++i )
{
v3 = (long long *)(16LL * i + *(_QWORD *)a1);
v6 = *v3;
v7 = v3[1];
v4 = (_QWORD *)(16LL * i + *(_QWORD *)a2);
v8 = v4[1];
if ( (_DWORD)v6 != (unsigned int)*v4 )
return 0LL;
if ( (_DWORD)v6 )
{
if ( !(unsigned int)func0(v7, v8) )
return 0LL;
}
else if ( (_DWORD)v7 != (_DWORD)v8 )
{
return 0LL;
}
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x8]
CMP EDX,EAX
JZ 0x001014d4
MOV EAX,0x0
JMP 0x00101586
LAB_001014d4:
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101571
LAB_001014e0:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
MOV EDX,dword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x10]
CMP EDX,EAX
JZ 0x00101537
MOV EAX,0x0
JMP 0x00101586
LAB_00101537:
MOV EAX,dword ptr [RBP + -0x20]
TEST EAX,EAX
JZ 0x0010155c
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001014a4
TEST EAX,EAX
JNZ 0x0010156d
MOV EAX,0x0
JMP 0x00101586
LAB_0010155c:
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x8]
CMP EDX,EAX
JZ 0x0010156d
MOV EAX,0x0
JMP 0x00101586
LAB_0010156d:
ADD dword ptr [RBP + -0x24],0x1
LAB_00101571:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x8]
CMP dword ptr [RBP + -0x24],EAX
JL 0x001014e0
MOV EAX,0x1
LAB_00101586:
LEAVE
RET | int8 func0(long *param_1,long *param_2)
{
int8 uVar1;
int iVar2;
int8 uVar3;
int8 *puVar4;
int8 *puVar5;
int local_2c;
int local_28;
int local_20;
int local_18;
int local_10;
if (*(int *)(param_1 + 1) == *(int *)(param_2 + 1)) {
for (local_2c = 0; local_2c < *(int *)(param_1 + 1); local_2c = local_2c + 1) {
puVar4 = (int8 *)(*param_1 + (long)local_2c * 0x10);
uVar3 = puVar4[1];
puVar5 = (int8 *)(*param_2 + (long)local_2c * 0x10);
uVar1 = puVar5[1];
local_28 = (int)*puVar4;
local_18 = (int)*puVar5;
if (local_28 != local_18) {
return 0;
}
if (local_28 == 0) {
local_20 = (int)uVar3;
local_10 = (int)uVar1;
if (local_20 != local_10) {
return 0;
}
}
else {
iVar2 = func0(uVar3,uVar1);
if (iVar2 == 0) {
return 0;
}
}
}
uVar3 = 1;
}
else {
uVar3 = 0;
}
return uVar3;
} |
6,213 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an integer element
Element make_int(int value) {
Element e;
e.is_tuple = 0;
e.data.value = value;
return e;
}
// Function to create a tuple element
Element make_tuple(Element* elements, int size);
// Function to create a tuple
Tuple* create_tuple(Element* elements, int size) {
Tuple* t = malloc(sizeof(Tuple));
t->elements = malloc(sizeof(Element) * size);
for(int i = 0; i < size; i++) {
t->elements[i] = elements[i];
}
t->size = size;
return t;
}
// Function to create a tuple element
Element make_tuple_element(Element* elements, int size) {
Element e;
e.is_tuple = 1;
e.data.tuple = create_tuple(elements, size);
return e;
}
// Function to check if a number is even
int is_even(int x) {
return x % 2 == 0;
}
// Recursive function to extract even elements
Tuple* even_ele(Tuple* test_tuple, int (*even_fnc)(int)) {
Tuple* res = create_tuple(NULL, 0);
for(int i = 0; i < test_tuple->size; i++) {
Element ele = test_tuple->elements[i];
if(ele.is_tuple) {
Tuple* filtered = even_ele(ele.data.tuple, even_fnc);
if(filtered->size > 0) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_tuple_element(filtered->elements, filtered->size);
res->size++;
}
}
else if(even_fnc(ele.data.value)) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_int(ele.data.value);
res->size++;
}
}
return res;
}
// Function to extract even elements
Tuple* extract_even(Tuple* test_tuple) {
return even_ele(test_tuple, is_even);
}
// Function to compare two tuples
| int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) return 0;
}
else {
if(ea.data.value != eb.data.value) return 0;
}
}
return 1;
}
// Main Function with Assert Statements
| int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_element(sub_elements1, 3), make_int(6), make_int(8) };
Tuple* input1 = create_tuple(input_elements1, 5);
// Construct expected tuple: (4, (6, (2, 4)), 6, 8)
Element expected_sub_sub_elements1[] = { make_int(2), make_int(4) };
Element expected_sub_elements1[] = { make_int(6), make_tuple_element(expected_sub_sub_elements1, 2) };
Element expected_elements1[] = { make_int(4), make_tuple_element(expected_sub_elements1, 2), make_int(6), make_int(8) };
Tuple* expected1 = create_tuple(expected_elements1, 4);
// Assert first test case
Tuple* result1 = extract_even(input1);
assert(func0(result1, expected1));
// Construct second input tuple: (5, 6, (8, 7, (4, 8)), 7, 9)
Element sub_sub_elements2[] = { make_int(4), make_int(8) };
Element sub_elements2[] = { make_int(8), make_int(7), make_tuple_element(sub_sub_elements2, 2) };
Element input_elements2[] = { make_int(5), make_int(6), make_tuple_element(sub_elements2, 3), make_int(7), make_int(9) };
Tuple* input2 = create_tuple(input_elements2, 5);
// Construct expected tuple: (6, (8, (4, 8)))
Element expected_sub_elements2[] = { make_int(8), make_tuple_element(sub_sub_elements2, 2) };
Element expected_elements2[] = { make_int(6), make_tuple_element(expected_sub_elements2, 2) };
Tuple* expected2 = create_tuple(expected_elements2, 2);
// Assert second test case
Tuple* result2 = extract_even(input2);
assert(func0(result2, expected2));
// Construct third input tuple: (5, 6, (9, 8, (4, 6)), 8, 10)
Element sub_sub_elements3[] = { make_int(4), make_int(6) };
Element sub_elements3[] = { make_int(9), make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element input_elements3[] = { make_int(5), make_int(6), make_tuple_element(sub_elements3, 3), make_int(8), make_int(10) };
Tuple* input3 = create_tuple(input_elements3, 5);
// Construct expected tuple: (6, (8, (4, 6)), 8, 10)
Element expected_sub_elements3[] = { make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element expected_elements3[] = { make_int(6), make_tuple_element(expected_sub_elements3, 2), make_int(8), make_int(10) };
Tuple* expected3 = create_tuple(expected_elements3, 4);
// Assert third test case
Tuple* result3 = extract_even(input3);
assert(func0(result3, expected3));
return 0;
}
| O1 | c | func0:
endbr64
mov 0x8(%rdi),%eax
mov $0x0,%edx
cmp 0x8(%rsi),%eax
jne 13f1 <func0+0x8e>
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r12
test %eax,%eax
jle 13ea <func0+0x87>
lea -0x1(%rax),%r13d
add $0x1,%r13
shl $0x4,%r13
mov $0x0,%ebx
jmp 13ad <func0+0x4a>
callq 1363 <func0>
test %eax,%eax
je 13d1 <func0+0x6e>
add $0x10,%rbx
cmp %r13,%rbx
je 13e3 <func0+0x80>
mov %rbx,%rax
add 0x0(%rbp),%rax
mov 0x8(%rax),%rdi
mov (%rax),%edx
mov %rbx,%rax
add (%r12),%rax
mov 0x8(%rax),%rsi
cmp (%rax),%edx
jne 13d1 <func0+0x6e>
test %edx,%edx
jne 139b <func0+0x38>
cmp %esi,%edi
je 13a4 <func0+0x41>
mov $0x0,%edx
mov %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x1,%edx
jmp 13d6 <func0+0x73>
mov $0x1,%edx
jmp 13d6 <func0+0x73>
mov %edx,%eax
retq
| func0:
endbr64
mov eax, [rdi+8]
mov edx, 0
cmp eax, [rsi+8]
jnz short loc_13E6
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12, rsi
test eax, eax
jle short loc_13DF
lea r13d, [rax-1]
add r13, 1
shl r13, 4
mov ebx, 0
jmp short loc_13A2
loc_1390:
call func0
test eax, eax
jz short loc_13C6
loc_1399:
add rbx, 10h
cmp rbx, r13
jz short loc_13D8
loc_13A2:
mov rax, rbx
add rax, [rbp+0]
mov rdi, [rax+8]
mov edx, [rax]
mov rax, rbx
add rax, [r12]
mov rsi, [rax+8]
cmp edx, [rax]
jnz short loc_13C6
test edx, edx
jnz short loc_1390
cmp edi, esi
jz short loc_1399
loc_13C6:
mov edx, 0
loc_13CB:
mov eax, edx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13D8:
mov edx, 1
jmp short loc_13CB
loc_13DF:
mov edx, 1
jmp short loc_13CB
loc_13E6:
mov eax, edx
retn | long long func0(long long a1, long long a2)
{
int v2; // eax
long long v4; // r13
long long v5; // rbx
int *v6; // rax
long long v7; // rdi
int v8; // edx
long long v9; // rax
v2 = *(_DWORD *)(a1 + 8);
if ( v2 != *(_DWORD *)(a2 + 8) )
return 0LL;
if ( v2 <= 0 )
{
return 1;
}
else
{
v4 = 16 * ((unsigned int)(v2 - 1) + 1LL);
v5 = 0LL;
do
{
v6 = (int *)(*(_QWORD *)a1 + v5);
v7 = *((_QWORD *)v6 + 1);
v8 = *v6;
v9 = *(_QWORD *)a2 + v5;
if ( v8 != *(_DWORD *)v9 )
return 0;
if ( v8 )
{
if ( !(unsigned int)func0() )
return 0;
}
else if ( (_DWORD)v7 != (unsigned int)*(_QWORD *)(v9 + 8) )
{
return 0;
}
v5 += 16LL;
}
while ( v5 != v4 );
return 1;
}
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x8]
MOV EDX,0x0
CMP EAX,dword ptr [RSI + 0x8]
JNZ 0x001013e6
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12,RSI
TEST EAX,EAX
JLE 0x001013df
LEA R13D,[RAX + -0x1]
ADD R13,0x1
SHL R13,0x4
MOV EBX,0x0
JMP 0x001013a2
LAB_00101390:
CALL 0x00101358
TEST EAX,EAX
JZ 0x001013c6
LAB_00101399:
ADD RBX,0x10
CMP RBX,R13
JZ 0x001013d8
LAB_001013a2:
MOV RAX,RBX
ADD RAX,qword ptr [RBP]
MOV RDI,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
MOV RAX,RBX
ADD RAX,qword ptr [R12]
MOV RSI,qword ptr [RAX + 0x8]
CMP EDX,dword ptr [RAX]
JNZ 0x001013c6
TEST EDX,EDX
JNZ 0x00101390
CMP EDI,ESI
JZ 0x00101399
LAB_001013c6:
MOV EDX,0x0
LAB_001013cb:
MOV EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013d8:
MOV EDX,0x1
JMP 0x001013cb
LAB_001013df:
MOV EDX,0x1
JMP 0x001013cb
LAB_001013e6:
MOV EAX,EDX
RET | int8 func0(long *param_1,long *param_2)
{
int iVar1;
int iVar2;
long lVar3;
iVar1 = (int)param_1[1];
if (iVar1 != (int)param_2[1]) {
return 0;
}
if (0 < iVar1) {
lVar3 = 0;
do {
iVar2 = *(int *)(lVar3 + *param_1);
if (iVar2 != *(int *)(lVar3 + *param_2)) {
return 0;
}
if (iVar2 == 0) {
if ((int)*(int8 *)((int *)(lVar3 + *param_1) + 2) !=
(int)*(int8 *)((int *)(lVar3 + *param_2) + 2)) {
return 0;
}
}
else {
iVar2 = func0();
if (iVar2 == 0) {
return 0;
}
}
lVar3 = lVar3 + 0x10;
} while (lVar3 != ((ulong)(iVar1 - 1) + 1) * 0x10);
}
return 1;
} |
6,214 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an integer element
Element make_int(int value) {
Element e;
e.is_tuple = 0;
e.data.value = value;
return e;
}
// Function to create a tuple element
Element make_tuple(Element* elements, int size);
// Function to create a tuple
Tuple* create_tuple(Element* elements, int size) {
Tuple* t = malloc(sizeof(Tuple));
t->elements = malloc(sizeof(Element) * size);
for(int i = 0; i < size; i++) {
t->elements[i] = elements[i];
}
t->size = size;
return t;
}
// Function to create a tuple element
Element make_tuple_element(Element* elements, int size) {
Element e;
e.is_tuple = 1;
e.data.tuple = create_tuple(elements, size);
return e;
}
// Function to check if a number is even
int is_even(int x) {
return x % 2 == 0;
}
// Recursive function to extract even elements
Tuple* even_ele(Tuple* test_tuple, int (*even_fnc)(int)) {
Tuple* res = create_tuple(NULL, 0);
for(int i = 0; i < test_tuple->size; i++) {
Element ele = test_tuple->elements[i];
if(ele.is_tuple) {
Tuple* filtered = even_ele(ele.data.tuple, even_fnc);
if(filtered->size > 0) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_tuple_element(filtered->elements, filtered->size);
res->size++;
}
}
else if(even_fnc(ele.data.value)) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_int(ele.data.value);
res->size++;
}
}
return res;
}
// Function to extract even elements
Tuple* extract_even(Tuple* test_tuple) {
return even_ele(test_tuple, is_even);
}
// Function to compare two tuples
| int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) return 0;
}
else {
if(ea.data.value != eb.data.value) return 0;
}
}
return 1;
}
// Main Function with Assert Statements
| int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_element(sub_elements1, 3), make_int(6), make_int(8) };
Tuple* input1 = create_tuple(input_elements1, 5);
// Construct expected tuple: (4, (6, (2, 4)), 6, 8)
Element expected_sub_sub_elements1[] = { make_int(2), make_int(4) };
Element expected_sub_elements1[] = { make_int(6), make_tuple_element(expected_sub_sub_elements1, 2) };
Element expected_elements1[] = { make_int(4), make_tuple_element(expected_sub_elements1, 2), make_int(6), make_int(8) };
Tuple* expected1 = create_tuple(expected_elements1, 4);
// Assert first test case
Tuple* result1 = extract_even(input1);
assert(func0(result1, expected1));
// Construct second input tuple: (5, 6, (8, 7, (4, 8)), 7, 9)
Element sub_sub_elements2[] = { make_int(4), make_int(8) };
Element sub_elements2[] = { make_int(8), make_int(7), make_tuple_element(sub_sub_elements2, 2) };
Element input_elements2[] = { make_int(5), make_int(6), make_tuple_element(sub_elements2, 3), make_int(7), make_int(9) };
Tuple* input2 = create_tuple(input_elements2, 5);
// Construct expected tuple: (6, (8, (4, 8)))
Element expected_sub_elements2[] = { make_int(8), make_tuple_element(sub_sub_elements2, 2) };
Element expected_elements2[] = { make_int(6), make_tuple_element(expected_sub_elements2, 2) };
Tuple* expected2 = create_tuple(expected_elements2, 2);
// Assert second test case
Tuple* result2 = extract_even(input2);
assert(func0(result2, expected2));
// Construct third input tuple: (5, 6, (9, 8, (4, 6)), 8, 10)
Element sub_sub_elements3[] = { make_int(4), make_int(6) };
Element sub_elements3[] = { make_int(9), make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element input_elements3[] = { make_int(5), make_int(6), make_tuple_element(sub_elements3, 3), make_int(8), make_int(10) };
Tuple* input3 = create_tuple(input_elements3, 5);
// Construct expected tuple: (6, (8, (4, 6)), 8, 10)
Element expected_sub_elements3[] = { make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element expected_elements3[] = { make_int(6), make_tuple_element(expected_sub_elements3, 2), make_int(8), make_int(10) };
Tuple* expected3 = create_tuple(expected_elements3, 4);
// Assert third test case
Tuple* result3 = extract_even(input3);
assert(func0(result3, expected3));
return 0;
}
| O2 | c | func0:
endbr64
mov 0x8(%rsi),%eax
cmp %eax,0x8(%rdi)
jne 19d0 <func0+0x10>
jmp 19e0 <func0.part.0>
xchg %ax,%ax
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0_part_0_isra_0:
test esi, esi
jle short loc_189B
lea eax, [rsi-1]
push r12
shl rax, 4
push rbp
lea r12, [rdi+rax+10h]
push rbx
mov rbx, rdi
mov rbp, [rdx]
jmp short loc_1851
loc_1840:
cmp ecx, edx
jnz short loc_186C
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jz short loc_1891
loc_1851:
mov rcx, [rbx+8]
mov eax, [rbx]
mov rdx, [rbp+8]
cmp eax, [rbp+0]
jnz short loc_186C
test eax, eax
jz short loc_1840
mov esi, [rcx+8]
cmp esi, [rdx+8]
jz short loc_1878
loc_186C:
pop rbx
xor eax, eax
pop rbp
pop r12
retn
loc_1878:
mov rdi, [rcx]
call func0_part_0_isra_0
test eax, eax
jz short loc_186C
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jnz short loc_1851
loc_1891:
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_189B:
mov eax, 1
retn | long long func0_part_0_isra_0(long long a1, int a2, long long *a3)
{
long long v3; // r12
long long v4; // rbx
long long v5; // rbp
long long v6; // rcx
long long v7; // rdx
if ( a2 <= 0 )
return 1LL;
v3 = a1 + 16LL * (unsigned int)(a2 - 1) + 16;
v4 = a1;
v5 = *a3;
do
{
while ( 1 )
{
v6 = *(_QWORD *)(v4 + 8);
v7 = *(_QWORD *)(v5 + 8);
if ( *(_DWORD *)v4 != *(_DWORD *)v5 )
return 0LL;
if ( !*(_DWORD *)v4 )
break;
if ( *(_DWORD *)(v6 + 8) != *(_DWORD *)(v7 + 8) || !(unsigned int)func0_part_0_isra_0(*(_QWORD *)v6) )
return 0LL;
v4 += 16LL;
v5 += 16LL;
if ( v4 == v3 )
return 1LL;
}
if ( (_DWORD)v6 != (_DWORD)v7 )
return 0LL;
v4 += 16LL;
v5 += 16LL;
}
while ( v4 != v3 );
return 1LL;
} | func0.part.0.isra.0:
TEST ESI,ESI
JLE 0x0010189b
LEA EAX,[RSI + -0x1]
PUSH R12
SHL RAX,0x4
PUSH RBP
LEA R12,[RDI + RAX*0x1 + 0x10]
PUSH RBX
MOV RBX,RDI
MOV RBP,qword ptr [RDX]
JMP 0x00101851
LAB_00101840:
CMP ECX,EDX
JNZ 0x0010186c
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JZ 0x00101891
LAB_00101851:
MOV RCX,qword ptr [RBX + 0x8]
MOV EAX,dword ptr [RBX]
MOV RDX,qword ptr [RBP + 0x8]
CMP EAX,dword ptr [RBP]
JNZ 0x0010186c
TEST EAX,EAX
JZ 0x00101840
MOV ESI,dword ptr [RCX + 0x8]
CMP ESI,dword ptr [RDX + 0x8]
JZ 0x00101878
LAB_0010186c:
POP RBX
XOR EAX,EAX
POP RBP
POP R12
RET
LAB_00101878:
MOV RDI,qword ptr [RCX]
CALL 0x00101820
TEST EAX,EAX
JZ 0x0010186c
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JNZ 0x00101851
LAB_00101891:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_0010189b:
MOV EAX,0x1
RET | int8 func0_part_0_isra_0(int *param_1,int param_2,int8 *param_3)
{
int *piVar1;
int8 *puVar2;
int iVar3;
int *piVar4;
if (param_2 < 1) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
piVar4 = (int *)*param_3;
do {
puVar2 = *(int8 **)(param_1 + 2);
if (*param_1 != *piVar4) {
return 0;
}
if (*param_1 == 0) {
if ((int)puVar2 != (int)*(long *)(piVar4 + 2)) {
return 0;
}
}
else {
if (*(int *)(puVar2 + 1) != *(int *)(*(long *)(piVar4 + 2) + 8)) {
return 0;
}
iVar3 = func0_part_0_isra_0(*puVar2);
if (iVar3 == 0) {
return 0;
}
}
piVar4 = piVar4 + 4;
param_1 = param_1 + 4;
if (param_1 == piVar1) {
return 1;
}
} while( true );
} |
6,215 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an integer element
Element make_int(int value) {
Element e;
e.is_tuple = 0;
e.data.value = value;
return e;
}
// Function to create a tuple element
Element make_tuple(Element* elements, int size);
// Function to create a tuple
Tuple* create_tuple(Element* elements, int size) {
Tuple* t = malloc(sizeof(Tuple));
t->elements = malloc(sizeof(Element) * size);
for(int i = 0; i < size; i++) {
t->elements[i] = elements[i];
}
t->size = size;
return t;
}
// Function to create a tuple element
Element make_tuple_element(Element* elements, int size) {
Element e;
e.is_tuple = 1;
e.data.tuple = create_tuple(elements, size);
return e;
}
// Function to check if a number is even
int is_even(int x) {
return x % 2 == 0;
}
// Recursive function to extract even elements
Tuple* even_ele(Tuple* test_tuple, int (*even_fnc)(int)) {
Tuple* res = create_tuple(NULL, 0);
for(int i = 0; i < test_tuple->size; i++) {
Element ele = test_tuple->elements[i];
if(ele.is_tuple) {
Tuple* filtered = even_ele(ele.data.tuple, even_fnc);
if(filtered->size > 0) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_tuple_element(filtered->elements, filtered->size);
res->size++;
}
}
else if(even_fnc(ele.data.value)) {
res->elements = realloc(res->elements, sizeof(Element) * (res->size + 1));
res->elements[res->size] = make_int(ele.data.value);
res->size++;
}
}
return res;
}
// Function to extract even elements
Tuple* extract_even(Tuple* test_tuple) {
return even_ele(test_tuple, is_even);
}
// Function to compare two tuples
| int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) return 0;
}
else {
if(ea.data.value != eb.data.value) return 0;
}
}
return 1;
}
// Main Function with Assert Statements
| int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_element(sub_elements1, 3), make_int(6), make_int(8) };
Tuple* input1 = create_tuple(input_elements1, 5);
// Construct expected tuple: (4, (6, (2, 4)), 6, 8)
Element expected_sub_sub_elements1[] = { make_int(2), make_int(4) };
Element expected_sub_elements1[] = { make_int(6), make_tuple_element(expected_sub_sub_elements1, 2) };
Element expected_elements1[] = { make_int(4), make_tuple_element(expected_sub_elements1, 2), make_int(6), make_int(8) };
Tuple* expected1 = create_tuple(expected_elements1, 4);
// Assert first test case
Tuple* result1 = extract_even(input1);
assert(func0(result1, expected1));
// Construct second input tuple: (5, 6, (8, 7, (4, 8)), 7, 9)
Element sub_sub_elements2[] = { make_int(4), make_int(8) };
Element sub_elements2[] = { make_int(8), make_int(7), make_tuple_element(sub_sub_elements2, 2) };
Element input_elements2[] = { make_int(5), make_int(6), make_tuple_element(sub_elements2, 3), make_int(7), make_int(9) };
Tuple* input2 = create_tuple(input_elements2, 5);
// Construct expected tuple: (6, (8, (4, 8)))
Element expected_sub_elements2[] = { make_int(8), make_tuple_element(sub_sub_elements2, 2) };
Element expected_elements2[] = { make_int(6), make_tuple_element(expected_sub_elements2, 2) };
Tuple* expected2 = create_tuple(expected_elements2, 2);
// Assert second test case
Tuple* result2 = extract_even(input2);
assert(func0(result2, expected2));
// Construct third input tuple: (5, 6, (9, 8, (4, 6)), 8, 10)
Element sub_sub_elements3[] = { make_int(4), make_int(6) };
Element sub_elements3[] = { make_int(9), make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element input_elements3[] = { make_int(5), make_int(6), make_tuple_element(sub_elements3, 3), make_int(8), make_int(10) };
Tuple* input3 = create_tuple(input_elements3, 5);
// Construct expected tuple: (6, (8, (4, 6)), 8, 10)
Element expected_sub_elements3[] = { make_int(8), make_tuple_element(sub_sub_elements3, 2) };
Element expected_elements3[] = { make_int(6), make_tuple_element(expected_sub_elements3, 2), make_int(8), make_int(10) };
Tuple* expected3 = create_tuple(expected_elements3, 4);
// Assert third test case
Tuple* result3 = extract_even(input3);
assert(func0(result3, expected3));
return 0;
}
| O3 | c | func0:
endbr64
mov 0x8(%rdi),%eax
xor %r8d,%r8d
cmp 0x8(%rsi),%eax
je 1c88 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
test %eax,%eax
jle 1d30 <func0+0xc0>
mov (%rdi),%rdx
sub $0x1,%eax
mov (%rsi),%rcx
shl $0x4,%rax
lea 0x10(%rdx,%rax,1),%r8
jmp 1cb9 <func0+0x49>
nopl 0x0(%rax)
cmp %esi,%edi
jne 1cd3 <func0+0x63>
add $0x10,%rdx
add $0x10,%rcx
cmp %r8,%rdx
je 1d30 <func0+0xc0>
mov 0x8(%rdx),%rdi
mov (%rdx),%eax
mov 0x8(%rcx),%rsi
cmp (%rcx),%eax
jne 1cd3 <func0+0x63>
test %eax,%eax
je 1ca8 <func0+0x38>
mov 0x8(%rsi),%eax
cmp %eax,0x8(%rdi)
je 1ce0 <func0+0x70>
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
sub $0x8,%rsp
callq 1800 <func0.part.0>
test %eax,%eax
je 1d20 <func0+0xb0>
add $0x10,%rdx
add $0x10,%rcx
cmp %r8,%rdx
je 1d40 <func0+0xd0>
mov 0x8(%rdx),%rdi
mov (%rdx),%eax
mov 0x8(%rcx),%rsi
cmp (%rcx),%eax
jne 1d20 <func0+0xb0>
test %eax,%eax
jne 1d18 <func0+0xa8>
cmp %esi,%edi
je 1ced <func0+0x7d>
jmp 1d20 <func0+0xb0>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsi),%eax
cmp %eax,0x8(%rdi)
je 1ce4 <func0+0x74>
xor %r8d,%r8d
mov %r8d,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%r8d
jmpq 1c7f <func0+0xf>
nopl 0x0(%rax,%rax,1)
mov $0x1,%r8d
jmp 1d23 <func0+0xb3>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rax, dword ptr [rdi+8]
cmp eax, [rsi+8]
jz short loc_1BA0
xor eax, eax
retn
loc_1BA0:
test eax, eax
jle loc_20A0
push r15
shl rax, 4
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rbp, [rdi]
mov r12, [rsi]
lea r14, [rax+rbp]
mov rbx, r12
mov r13, r14
jmp short loc_1BE9
loc_1BD0:
cmp ecx, edx
jnz loc_1F88
loc_1BD8:
add rbp, 10h
add rbx, 10h
cmp rbp, r13
jz loc_1FA0
loc_1BE9:
mov rcx, [rbp+8]
mov eax, [rbp+0]
mov rdx, [rbx+8]
cmp eax, [rbx]
jnz loc_1F88
test eax, eax
jz short loc_1BD0
movsxd rax, dword ptr [rcx+8]
cmp eax, [rdx+8]
jnz loc_1F88
test eax, eax
jle short loc_1BD8
mov r12, [rcx]
shl rax, 4
mov r14, [rdx]
mov rsi, rbp
lea rdx, [rax+r12]
mov rax, rbx
mov rbx, rdx
jmp short loc_1C49
loc_1C30:
cmp edi, ecx
jnz loc_1F88
loc_1C38:
add r12, 10h
add r14, 10h
cmp r12, rbx
jz loc_1FB0
loc_1C49:
mov rdi, [r12+8]
mov edx, [r12]
mov rcx, [r14+8]
cmp edx, [r14]
jnz loc_1F88
test edx, edx
jz short loc_1C30
movsxd r8, dword ptr [rdi+8]
cmp r8d, [rcx+8]
jnz loc_1F88
test r8d, r8d
jle short loc_1C38
mov rbp, [rdi]
mov rdx, [rcx]
shl r8, 4
mov rdi, r13
mov [rsp+0E8h+var_D8], rbx
mov r9, rsi
lea rcx, [r8+rbp]
mov [rsp+0E8h+var_E0], r14
mov r8, rax
mov rbx, rdx
mov r13, rcx
mov rax, r12
mov rcx, rdi
jmp short loc_1CC2
loc_1CA8:
cmp r11d, r10d
jnz loc_1F88
loc_1CB1:
add rbp, 10h
add rbx, 10h
cmp rbp, r13
jz loc_1FC0
loc_1CC2:
mov r11, [rbp+8]
mov edx, [rbp+0]
mov r10, [rbx+8]
cmp edx, [rbx]
jnz loc_1F88
test edx, edx
jz short loc_1CA8
movsxd rdx, dword ptr [r11+8]
cmp edx, [r10+8]
jnz loc_1F88
test edx, edx
jle short loc_1CB1
mov r12, [r11]
shl rdx, 4
mov [rsp+0E8h+var_C8], rbx
mov r15, rax
mov [rsp+0E8h+var_D0], rbp
mov r14, [r10]
mov rax, rcx
add rdx, r12
mov rbx, rdx
jmp short loc_1D29
loc_1D10:
cmp ebp, edx
jnz loc_1F88
loc_1D18:
add r12, 10h
add r14, 10h
cmp r12, rbx
jz loc_1FE0
loc_1D29:
mov rbp, [r12+8]
mov esi, [r12]
mov rdx, [r14+8]
cmp esi, [r14]
jnz loc_1F88
test esi, esi
jz short loc_1D10
movsxd rsi, dword ptr [rbp+8]
cmp esi, [rdx+8]
jnz loc_1F88
test esi, esi
jle short loc_1D18
mov rbp, [rbp+0]
mov rdx, [rdx]
shl rsi, 4
mov [rsp+0E8h+var_C0], r12
mov rcx, r13
mov r11, r9
mov [rsp+0E8h+var_B8], r14
mov r10, r8
add rsi, rbp
mov [rsp+0E8h+var_B0], rbx
mov r12, rdx
mov r9, rax
mov r13, rsi
jmp short loc_1DA1
loc_1D88:
cmp ebx, edx
jnz loc_1F88
loc_1D90:
add rbp, 10h
add r12, 10h
cmp rbp, r13
jz loc_1FF8
loc_1DA1:
mov rbx, [rbp+8]
mov eax, [rbp+0]
mov rdx, [r12+8]
cmp eax, [r12]
jnz loc_1F88
test eax, eax
jz short loc_1D88
movsxd rax, dword ptr [rbx+8]
cmp eax, [rdx+8]
jnz loc_1F88
test eax, eax
jle short loc_1D90
mov rbx, [rbx]
shl rax, 4
mov [rsp+0E8h+var_A0], r12
mov r8, rcx
mov [rsp+0E8h+var_A8], rbp
mov r14, [rdx]
add rax, rbx
mov [rsp+0E8h+var_98], r13
mov [rsp+0E8h+var_90], r15
mov r12, rax
jmp short loc_1E11
loc_1DF8:
cmp ebp, edi
jnz loc_1F88
loc_1E00:
add rbx, 10h
add r14, 10h
cmp rbx, r12
jz loc_2020
loc_1E11:
mov rbp, [rbx+8]
mov ecx, [rbx]
mov rdi, [r14+8]
cmp ecx, [r14]
jnz loc_1F88
test ecx, ecx
jz short loc_1DF8
movsxd rcx, dword ptr [rbp+8]
cmp ecx, [rdi+8]
jnz loc_1F88
test ecx, ecx
jle short loc_1E00
mov rbp, [rbp+0]
mov r15, [rdi]
shl rcx, 4
mov [rsp+0E8h+var_80], rbx
mov [rsp+0E8h+var_88], r14
add rcx, rbp
mov rbx, r15
mov [rsp+0E8h+var_78], r12
mov r15, rcx
jmp short loc_1E7A
loc_1E60:
cmp r14d, r12d
jnz loc_1F88
loc_1E69:
add rbp, 10h
add rbx, 10h
cmp r15, rbp
jz loc_2040
loc_1E7A:
mov r14, [rbp+8]
mov edx, [rbp+0]
mov r12, [rbx+8]
cmp edx, [rbx]
jnz loc_1F88
test edx, edx
jz short loc_1E60
movsxd rdx, dword ptr [r14+8]
cmp edx, [r12+8]
jnz loc_1F88
test edx, edx
jle short loc_1E69
mov r14, [r14]
mov r12, [r12]
shl rdx, 4
mov [rsp+0E8h+var_70], r15
mov [rsp+0E8h+var_68], rbx
add rdx, r14
mov [rsp+0E8h+var_60], rbp
mov rbx, r12
mov [rsp+0E8h+var_58], r8
mov r15, rdx
jmp short loc_1EF9
loc_1EE0:
cmp ebp, esi
jnz loc_1F88
loc_1EE8:
add r14, 10h
add rbx, 10h
cmp r15, r14
jz loc_2058
loc_1EF9:
mov rbp, [r14+8]
mov r12d, [r14]
mov rsi, [rbx+8]
cmp r12d, [rbx]
jnz short loc_1F88
test r12d, r12d
jz short loc_1EE0
movsxd r13, dword ptr [rbp+8]
cmp r13d, [rsi+8]
jnz short loc_1F88
test r13d, r13d
jle short loc_1EE8
mov r12, [rbp+0]
shl r13, 4
mov [rsp+0E8h+var_50], rbx
mov [rsp+0E8h+var_48], r11
mov rbp, [rsi]
add r13, r12
mov rbx, r12
mov [rsp+0E8h+var_40], r10
mov r12, r13
mov r13, r9
jmp short loc_1F65
loc_1F50:
cmp edi, esi
jnz short loc_1F88
loc_1F54:
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jz loc_2080
loc_1F65:
mov rdi, [rbx+8]
mov eax, [rbx]
mov rsi, [rbp+8]
cmp eax, [rbp+0]
jnz short loc_1F88
test eax, eax
jz short loc_1F50
call func0
test eax, eax
jnz short loc_1F54
nop dword ptr [rax+00000000h]
loc_1F88:
xor eax, eax
loc_1F8A:
add rsp, 0B8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1FA0:
mov eax, 1
jmp short loc_1F8A
loc_1FB0:
mov rbp, rsi
mov rbx, rax
jmp loc_1BD8
loc_1FC0:
mov r12, rax
mov r14, [rsp+0E8h+var_E0]
mov rbx, [rsp+0E8h+var_D8]
mov rsi, r9
mov rax, r8
mov r13, rcx
jmp loc_1C38
loc_1FE0:
mov rcx, rax
mov rbp, [rsp+0E8h+var_D0]
mov rbx, [rsp+0E8h+var_C8]
mov rax, r15
jmp loc_1CB1
loc_1FF8:
mov rax, r9
mov r12, [rsp+0E8h+var_C0]
mov r14, [rsp+0E8h+var_B8]
mov r13, rcx
mov rbx, [rsp+0E8h+var_B0]
mov r8, r10
mov r9, r11
jmp loc_1D18
loc_2020:
mov rbp, [rsp+0E8h+var_A8]
mov r12, [rsp+0E8h+var_A0]
mov rcx, r8
mov r13, [rsp+0E8h+var_98]
mov r15, [rsp+0E8h+var_90]
jmp loc_1D90
loc_2040:
mov r14, [rsp+0E8h+var_88]
mov rbx, [rsp+0E8h+var_80]
mov r12, [rsp+0E8h+var_78]
jmp loc_1E00
loc_2058:
mov r15, [rsp+0E8h+var_70]
mov rbx, [rsp+0E8h+var_68]
mov rbp, [rsp+0E8h+var_60]
mov r8, [rsp+0E8h+var_58]
jmp loc_1E69
loc_2080:
mov rbx, [rsp+0E8h+var_50]
mov r11, [rsp+0E8h+var_48]
mov r9, r13
mov r10, [rsp+0E8h+var_40]
jmp loc_1EE8
loc_20A0:
mov eax, 1
retn | long long func0(long long *a1, long long *a2)
{
long long v2; // rax
long long v4; // rbp
long long v5; // rbx
long long v6; // r13
long long *v7; // rcx
long long *v8; // rdx
long long v9; // rax
long long v10; // r12
long long v11; // r14
long long v12; // rsi
long long v13; // rdx
long long v14; // rax
long long v15; // rbx
long long *v16; // rdi
long long *v17; // rcx
long long v18; // r8
long long v19; // rbp
long long v20; // rdx
long long v21; // rdi
long long v22; // r9
long long v23; // rcx
long long v24; // r8
long long v25; // rbx
long long v26; // r13
long long v27; // rax
long long v28; // rcx
long long *v29; // r11
long long *v30; // r10
long long v31; // rdx
long long v32; // r12
long long v33; // r15
long long v34; // r14
long long v35; // rax
long long v36; // rbx
long long *v37; // rbp
long long *v38; // rdx
long long v39; // rsi
long long v40; // rbp
long long v41; // rcx
long long v42; // r11
long long v43; // r10
long long v44; // r12
long long v45; // r9
long long v46; // r13
long long *v47; // rbx
long long *v48; // rdx
long long v49; // rax
long long v50; // rbx
long long v51; // r8
long long v52; // r14
long long v53; // r12
long long *v54; // rbp
long long *v55; // rdi
long long v56; // rcx
long long v57; // rbp
long long v58; // rbx
long long v59; // r15
long long *v60; // r14
long long *v61; // r12
long long v62; // rdx
long long v63; // r14
long long v64; // rbx
long long v65; // r15
long long *v66; // rbp
long long *v67; // rsi
long long v68; // r13
long long v69; // r12
long long v70; // rbp
long long v71; // rbx
long long v72; // r12
long long v73; // r13
long long v74; // rdi
long long v75; // rsi
long long v76; // [rsp+0h] [rbp-E0h]
long long v77; // [rsp+8h] [rbp-D8h]
long long v78; // [rsp+10h] [rbp-D0h]
long long v79; // [rsp+18h] [rbp-C8h]
long long v80; // [rsp+20h] [rbp-C0h]
long long v81; // [rsp+28h] [rbp-B8h]
long long v82; // [rsp+30h] [rbp-B0h]
long long v83; // [rsp+38h] [rbp-A8h]
long long v84; // [rsp+40h] [rbp-A0h]
long long v85; // [rsp+48h] [rbp-98h]
long long v86; // [rsp+50h] [rbp-90h]
long long v87; // [rsp+58h] [rbp-88h]
long long v88; // [rsp+60h] [rbp-80h]
long long v89; // [rsp+68h] [rbp-78h]
long long v90; // [rsp+70h] [rbp-70h]
long long v91; // [rsp+78h] [rbp-68h]
long long v92; // [rsp+80h] [rbp-60h]
long long v93; // [rsp+88h] [rbp-58h]
long long v94; // [rsp+90h] [rbp-50h]
long long v95; // [rsp+98h] [rbp-48h]
long long v96; // [rsp+A0h] [rbp-40h]
v2 = *((int *)a1 + 2);
if ( (_DWORD)v2 != *((_DWORD *)a2 + 2) )
return 0LL;
if ( (int)v2 <= 0 )
return 1LL;
v4 = *a1;
v5 = *a2;
v6 = 16 * v2 + *a1;
do
{
v7 = *(long long **)(v4 + 8);
v8 = *(long long **)(v5 + 8);
if ( *(_DWORD *)v4 != *(_DWORD *)v5 )
return 0LL;
if ( *(_DWORD *)v4 )
{
v9 = *((int *)v7 + 2);
if ( (_DWORD)v9 != *((_DWORD *)v8 + 2) )
return 0LL;
if ( (int)v9 > 0 )
{
v10 = *v7;
v11 = *v8;
v12 = v4;
v13 = 16 * v9 + *v7;
v14 = v5;
v15 = v13;
while ( 1 )
{
v16 = *(long long **)(v10 + 8);
v17 = *(long long **)(v11 + 8);
if ( *(_DWORD *)v10 != *(_DWORD *)v11 )
return 0LL;
if ( *(_DWORD *)v10 )
{
v18 = *((int *)v16 + 2);
if ( (_DWORD)v18 != *((_DWORD *)v17 + 2) )
return 0LL;
if ( (int)v18 > 0 )
{
v19 = *v16;
v20 = *v17;
v21 = v6;
v77 = v15;
v22 = v12;
v23 = 16 * v18 + v19;
v76 = v11;
v24 = v14;
v25 = v20;
v26 = v23;
v27 = v10;
v28 = v21;
while ( 1 )
{
v29 = *(long long **)(v19 + 8);
v30 = *(long long **)(v25 + 8);
if ( *(_DWORD *)v19 != *(_DWORD *)v25 )
return 0LL;
if ( *(_DWORD *)v19 )
{
v31 = *((int *)v29 + 2);
if ( (_DWORD)v31 != *((_DWORD *)v30 + 2) )
return 0LL;
if ( (int)v31 > 0 )
{
v32 = *v29;
v79 = v25;
v33 = v27;
v78 = v19;
v34 = *v30;
v35 = v28;
v36 = *v29 + 16 * v31;
while ( 1 )
{
v37 = *(long long **)(v32 + 8);
v38 = *(long long **)(v34 + 8);
if ( *(_DWORD *)v32 != *(_DWORD *)v34 )
return 0LL;
if ( *(_DWORD *)v32 )
{
v39 = *((int *)v37 + 2);
if ( (_DWORD)v39 != *((_DWORD *)v38 + 2) )
return 0LL;
if ( (int)v39 > 0 )
{
v40 = *v37;
v80 = v32;
v41 = v26;
v42 = v22;
v81 = v34;
v43 = v24;
v82 = v36;
v44 = *v38;
v45 = v35;
v46 = v40 + 16 * v39;
while ( 1 )
{
v47 = *(long long **)(v40 + 8);
v48 = *(long long **)(v44 + 8);
if ( *(_DWORD *)v40 != *(_DWORD *)v44 )
return 0LL;
if ( *(_DWORD *)v40 )
{
v49 = *((int *)v47 + 2);
if ( (_DWORD)v49 != *((_DWORD *)v48 + 2) )
return 0LL;
if ( (int)v49 > 0 )
{
v50 = *v47;
v84 = v44;
v51 = v41;
v83 = v40;
v52 = *v48;
v85 = v46;
v86 = v33;
v53 = v50 + 16 * v49;
while ( 1 )
{
v54 = *(long long **)(v50 + 8);
v55 = *(long long **)(v52 + 8);
if ( *(_DWORD *)v50 != *(_DWORD *)v52 )
return 0LL;
if ( *(_DWORD *)v50 )
{
v56 = *((int *)v54 + 2);
if ( (_DWORD)v56 != *((_DWORD *)v55 + 2) )
return 0LL;
if ( (int)v56 > 0 )
{
v57 = *v54;
v88 = v50;
v87 = v52;
v58 = *v55;
v89 = v53;
v59 = v57 + 16 * v56;
while ( 1 )
{
v60 = *(long long **)(v57 + 8);
v61 = *(long long **)(v58 + 8);
if ( *(_DWORD *)v57 != *(_DWORD *)v58 )
return 0LL;
if ( *(_DWORD *)v57 )
{
v62 = *((int *)v60 + 2);
if ( (_DWORD)v62 != *((_DWORD *)v61 + 2) )
return 0LL;
if ( (int)v62 > 0 )
{
v63 = *v60;
v90 = v59;
v91 = v58;
v92 = v57;
v64 = *v61;
v93 = v51;
v65 = v63 + 16 * v62;
while ( 1 )
{
v66 = *(long long **)(v63 + 8);
v67 = *(long long **)(v64 + 8);
if ( *(_DWORD *)v63 != *(_DWORD *)v64 )
return 0LL;
if ( *(_DWORD *)v63 )
{
v68 = *((int *)v66 + 2);
if ( (_DWORD)v68 != *((_DWORD *)v67 + 2) )
return 0LL;
if ( (int)v68 > 0 )
{
v69 = *v66;
v94 = v64;
v95 = v42;
v70 = *v67;
v71 = v69;
v96 = v43;
v72 = v69 + 16 * v68;
v73 = v45;
while ( 1 )
{
v74 = *(_QWORD *)(v71 + 8);
v75 = *(_QWORD *)(v70 + 8);
if ( *(_DWORD *)v71 != *(_DWORD *)v70 )
return 0LL;
if ( *(_DWORD *)v71 )
{
if ( !(unsigned int)func0(v74, v75) )
return 0LL;
}
else if ( (_DWORD)v74 != (_DWORD)v75 )
{
return 0LL;
}
v71 += 16LL;
v70 += 16LL;
if ( v71 == v72 )
{
v64 = v94;
v42 = v95;
v45 = v73;
v43 = v96;
break;
}
}
}
}
else if ( (_DWORD)v66 != (_DWORD)v67 )
{
return 0LL;
}
v63 += 16LL;
v64 += 16LL;
if ( v65 == v63 )
{
v59 = v90;
v58 = v91;
v57 = v92;
v51 = v93;
break;
}
}
}
}
else if ( (_DWORD)v60 != (_DWORD)v61 )
{
return 0LL;
}
v57 += 16LL;
v58 += 16LL;
if ( v59 == v57 )
{
v52 = v87;
v50 = v88;
v53 = v89;
break;
}
}
}
}
else if ( (_DWORD)v54 != (_DWORD)v55 )
{
return 0LL;
}
v50 += 16LL;
v52 += 16LL;
if ( v50 == v53 )
{
v40 = v83;
v44 = v84;
v41 = v51;
v46 = v85;
v33 = v86;
break;
}
}
}
}
else if ( (_DWORD)v47 != (_DWORD)v48 )
{
return 0LL;
}
v40 += 16LL;
v44 += 16LL;
if ( v40 == v46 )
{
v35 = v45;
v32 = v80;
v34 = v81;
v26 = v41;
v36 = v82;
v24 = v43;
v22 = v42;
break;
}
}
}
}
else if ( (_DWORD)v37 != (_DWORD)v38 )
{
return 0LL;
}
v32 += 16LL;
v34 += 16LL;
if ( v32 == v36 )
{
v28 = v35;
v19 = v78;
v25 = v79;
v27 = v33;
break;
}
}
}
}
else if ( (_DWORD)v29 != (_DWORD)v30 )
{
return 0LL;
}
v19 += 16LL;
v25 += 16LL;
if ( v19 == v26 )
{
v10 = v27;
v11 = v76;
v15 = v77;
v12 = v22;
v14 = v24;
v6 = v28;
break;
}
}
}
}
else if ( (_DWORD)v16 != (_DWORD)v17 )
{
return 0LL;
}
v10 += 16LL;
v11 += 16LL;
if ( v10 == v15 )
{
v4 = v12;
v5 = v14;
break;
}
}
}
}
else if ( (_DWORD)v7 != (_DWORD)v8 )
{
return 0LL;
}
v4 += 16LL;
v5 += 16LL;
}
while ( v4 != v6 );
return 1LL;
} | func0:
ENDBR64
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP EAX,dword ptr [RSI + 0x8]
JZ 0x00101ba0
XOR EAX,EAX
RET
LAB_00101ba0:
TEST EAX,EAX
JLE 0x001020a0
PUSH R15
SHL RAX,0x4
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RBP,qword ptr [RDI]
MOV R12,qword ptr [RSI]
LEA R14,[RAX + RBP*0x1]
MOV RBX,R12
MOV R13,R14
JMP 0x00101be9
LAB_00101bd0:
CMP ECX,EDX
JNZ 0x00101f88
LAB_00101bd8:
ADD RBP,0x10
ADD RBX,0x10
CMP RBP,R13
JZ 0x00101fa0
LAB_00101be9:
MOV RCX,qword ptr [RBP + 0x8]
MOV EAX,dword ptr [RBP]
MOV RDX,qword ptr [RBX + 0x8]
CMP EAX,dword ptr [RBX]
JNZ 0x00101f88
TEST EAX,EAX
JZ 0x00101bd0
MOVSXD RAX,dword ptr [RCX + 0x8]
CMP EAX,dword ptr [RDX + 0x8]
JNZ 0x00101f88
TEST EAX,EAX
JLE 0x00101bd8
MOV R12,qword ptr [RCX]
SHL RAX,0x4
MOV R14,qword ptr [RDX]
MOV RSI,RBP
LEA RDX,[RAX + R12*0x1]
MOV RAX,RBX
MOV RBX,RDX
JMP 0x00101c49
LAB_00101c30:
CMP EDI,ECX
JNZ 0x00101f88
LAB_00101c38:
ADD R12,0x10
ADD R14,0x10
CMP R12,RBX
JZ 0x00101fb0
LAB_00101c49:
MOV RDI,qword ptr [R12 + 0x8]
MOV EDX,dword ptr [R12]
MOV RCX,qword ptr [R14 + 0x8]
CMP EDX,dword ptr [R14]
JNZ 0x00101f88
TEST EDX,EDX
JZ 0x00101c30
MOVSXD R8,dword ptr [RDI + 0x8]
CMP R8D,dword ptr [RCX + 0x8]
JNZ 0x00101f88
TEST R8D,R8D
JLE 0x00101c38
MOV RBP,qword ptr [RDI]
MOV RDX,qword ptr [RCX]
SHL R8,0x4
MOV RDI,R13
MOV qword ptr [RSP + 0x10],RBX
MOV R9,RSI
LEA RCX,[R8 + RBP*0x1]
MOV qword ptr [RSP + 0x8],R14
MOV R8,RAX
MOV RBX,RDX
MOV R13,RCX
MOV RAX,R12
MOV RCX,RDI
JMP 0x00101cc2
LAB_00101ca8:
CMP R11D,R10D
JNZ 0x00101f88
LAB_00101cb1:
ADD RBP,0x10
ADD RBX,0x10
CMP RBP,R13
JZ 0x00101fc0
LAB_00101cc2:
MOV R11,qword ptr [RBP + 0x8]
MOV EDX,dword ptr [RBP]
MOV R10,qword ptr [RBX + 0x8]
CMP EDX,dword ptr [RBX]
JNZ 0x00101f88
TEST EDX,EDX
JZ 0x00101ca8
MOVSXD RDX,dword ptr [R11 + 0x8]
CMP EDX,dword ptr [R10 + 0x8]
JNZ 0x00101f88
TEST EDX,EDX
JLE 0x00101cb1
MOV R12,qword ptr [R11]
SHL RDX,0x4
MOV qword ptr [RSP + 0x20],RBX
MOV R15,RAX
MOV qword ptr [RSP + 0x18],RBP
MOV R14,qword ptr [R10]
MOV RAX,RCX
ADD RDX,R12
MOV RBX,RDX
JMP 0x00101d29
LAB_00101d10:
CMP EBP,EDX
JNZ 0x00101f88
LAB_00101d18:
ADD R12,0x10
ADD R14,0x10
CMP R12,RBX
JZ 0x00101fe0
LAB_00101d29:
MOV RBP,qword ptr [R12 + 0x8]
MOV ESI,dword ptr [R12]
MOV RDX,qword ptr [R14 + 0x8]
CMP ESI,dword ptr [R14]
JNZ 0x00101f88
TEST ESI,ESI
JZ 0x00101d10
MOVSXD RSI,dword ptr [RBP + 0x8]
CMP ESI,dword ptr [RDX + 0x8]
JNZ 0x00101f88
TEST ESI,ESI
JLE 0x00101d18
MOV RBP,qword ptr [RBP]
MOV RDX,qword ptr [RDX]
SHL RSI,0x4
MOV qword ptr [RSP + 0x28],R12
MOV RCX,R13
MOV R11,R9
MOV qword ptr [RSP + 0x30],R14
MOV R10,R8
ADD RSI,RBP
MOV qword ptr [RSP + 0x38],RBX
MOV R12,RDX
MOV R9,RAX
MOV R13,RSI
JMP 0x00101da1
LAB_00101d88:
CMP EBX,EDX
JNZ 0x00101f88
LAB_00101d90:
ADD RBP,0x10
ADD R12,0x10
CMP RBP,R13
JZ 0x00101ff8
LAB_00101da1:
MOV RBX,qword ptr [RBP + 0x8]
MOV EAX,dword ptr [RBP]
MOV RDX,qword ptr [R12 + 0x8]
CMP EAX,dword ptr [R12]
JNZ 0x00101f88
TEST EAX,EAX
JZ 0x00101d88
MOVSXD RAX,dword ptr [RBX + 0x8]
CMP EAX,dword ptr [RDX + 0x8]
JNZ 0x00101f88
TEST EAX,EAX
JLE 0x00101d90
MOV RBX,qword ptr [RBX]
SHL RAX,0x4
MOV qword ptr [RSP + 0x48],R12
MOV R8,RCX
MOV qword ptr [RSP + 0x40],RBP
MOV R14,qword ptr [RDX]
ADD RAX,RBX
MOV qword ptr [RSP + 0x50],R13
MOV qword ptr [RSP + 0x58],R15
MOV R12,RAX
JMP 0x00101e11
LAB_00101df8:
CMP EBP,EDI
JNZ 0x00101f88
LAB_00101e00:
ADD RBX,0x10
ADD R14,0x10
CMP RBX,R12
JZ 0x00102020
LAB_00101e11:
MOV RBP,qword ptr [RBX + 0x8]
MOV ECX,dword ptr [RBX]
MOV RDI,qword ptr [R14 + 0x8]
CMP ECX,dword ptr [R14]
JNZ 0x00101f88
TEST ECX,ECX
JZ 0x00101df8
MOVSXD RCX,dword ptr [RBP + 0x8]
CMP ECX,dword ptr [RDI + 0x8]
JNZ 0x00101f88
TEST ECX,ECX
JLE 0x00101e00
MOV RBP,qword ptr [RBP]
MOV R15,qword ptr [RDI]
SHL RCX,0x4
MOV qword ptr [RSP + 0x68],RBX
MOV qword ptr [RSP + 0x60],R14
ADD RCX,RBP
MOV RBX,R15
MOV qword ptr [RSP + 0x70],R12
MOV R15,RCX
JMP 0x00101e7a
LAB_00101e60:
CMP R14D,R12D
JNZ 0x00101f88
LAB_00101e69:
ADD RBP,0x10
ADD RBX,0x10
CMP R15,RBP
JZ 0x00102040
LAB_00101e7a:
MOV R14,qword ptr [RBP + 0x8]
MOV EDX,dword ptr [RBP]
MOV R12,qword ptr [RBX + 0x8]
CMP EDX,dword ptr [RBX]
JNZ 0x00101f88
TEST EDX,EDX
JZ 0x00101e60
MOVSXD RDX,dword ptr [R14 + 0x8]
CMP EDX,dword ptr [R12 + 0x8]
JNZ 0x00101f88
TEST EDX,EDX
JLE 0x00101e69
MOV R14,qword ptr [R14]
MOV R12,qword ptr [R12]
SHL RDX,0x4
MOV qword ptr [RSP + 0x78],R15
MOV qword ptr [RSP + 0x80],RBX
ADD RDX,R14
MOV qword ptr [RSP + 0x88],RBP
MOV RBX,R12
MOV qword ptr [RSP + 0x90],R8
MOV R15,RDX
JMP 0x00101ef9
LAB_00101ee0:
CMP EBP,ESI
JNZ 0x00101f88
LAB_00101ee8:
ADD R14,0x10
ADD RBX,0x10
CMP R15,R14
JZ 0x00102058
LAB_00101ef9:
MOV RBP,qword ptr [R14 + 0x8]
MOV R12D,dword ptr [R14]
MOV RSI,qword ptr [RBX + 0x8]
CMP R12D,dword ptr [RBX]
JNZ 0x00101f88
TEST R12D,R12D
JZ 0x00101ee0
MOVSXD R13,dword ptr [RBP + 0x8]
CMP R13D,dword ptr [RSI + 0x8]
JNZ 0x00101f88
TEST R13D,R13D
JLE 0x00101ee8
MOV R12,qword ptr [RBP]
SHL R13,0x4
MOV qword ptr [RSP + 0x98],RBX
MOV qword ptr [RSP + 0xa0],R11
MOV RBP,qword ptr [RSI]
ADD R13,R12
MOV RBX,R12
MOV qword ptr [RSP + 0xa8],R10
MOV R12,R13
MOV R13,R9
JMP 0x00101f65
LAB_00101f50:
CMP EDI,ESI
JNZ 0x00101f88
LAB_00101f54:
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JZ 0x00102080
LAB_00101f65:
MOV RDI,qword ptr [RBX + 0x8]
MOV EAX,dword ptr [RBX]
MOV RSI,qword ptr [RBP + 0x8]
CMP EAX,dword ptr [RBP]
JNZ 0x00101f88
TEST EAX,EAX
JZ 0x00101f50
CALL 0x00101b90
TEST EAX,EAX
JNZ 0x00101f54
NOP dword ptr [RAX]
LAB_00101f88:
XOR EAX,EAX
LAB_00101f8a:
ADD RSP,0xb8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101fa0:
MOV EAX,0x1
JMP 0x00101f8a
LAB_00101fb0:
MOV RBP,RSI
MOV RBX,RAX
JMP 0x00101bd8
LAB_00101fc0:
MOV R12,RAX
MOV R14,qword ptr [RSP + 0x8]
MOV RBX,qword ptr [RSP + 0x10]
MOV RSI,R9
MOV RAX,R8
MOV R13,RCX
JMP 0x00101c38
LAB_00101fe0:
MOV RCX,RAX
MOV RBP,qword ptr [RSP + 0x18]
MOV RBX,qword ptr [RSP + 0x20]
MOV RAX,R15
JMP 0x00101cb1
LAB_00101ff8:
MOV RAX,R9
MOV R12,qword ptr [RSP + 0x28]
MOV R14,qword ptr [RSP + 0x30]
MOV R13,RCX
MOV RBX,qword ptr [RSP + 0x38]
MOV R8,R10
MOV R9,R11
JMP 0x00101d18
LAB_00102020:
MOV RBP,qword ptr [RSP + 0x40]
MOV R12,qword ptr [RSP + 0x48]
MOV RCX,R8
MOV R13,qword ptr [RSP + 0x50]
MOV R15,qword ptr [RSP + 0x58]
JMP 0x00101d90
LAB_00102040:
MOV R14,qword ptr [RSP + 0x60]
MOV RBX,qword ptr [RSP + 0x68]
MOV R12,qword ptr [RSP + 0x70]
JMP 0x00101e00
LAB_00102058:
MOV R15,qword ptr [RSP + 0x78]
MOV RBX,qword ptr [RSP + 0x80]
MOV RBP,qword ptr [RSP + 0x88]
MOV R8,qword ptr [RSP + 0x90]
JMP 0x00101e69
LAB_00102080:
MOV RBX,qword ptr [RSP + 0x98]
MOV R11,qword ptr [RSP + 0xa0]
MOV R9,R13
MOV R10,qword ptr [RSP + 0xa8]
JMP 0x00101ee8
LAB_001020a0:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int8 *param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 *puVar4;
int8 *puVar5;
int iVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int *piVar10;
int *piVar11;
int *piVar12;
int *piVar13;
int *piVar14;
int *piVar15;
int *piVar16;
int *piVar17;
int *piVar18;
int *piVar19;
int *piVar20;
int *piVar21;
int *piVar22;
int *piVar23;
int *piVar24;
int *piVar25;
int *piVar26;
int *piVar27;
int *piVar28;
int *piVar29;
int *piVar30;
iVar6 = *(int *)(param_1 + 1);
if (iVar6 != *(int *)(param_2 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar17 = (int *)*param_1;
piVar11 = (int *)*param_2;
piVar1 = piVar17 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar17 + 2);
puVar5 = *(int8 **)(piVar11 + 2);
if (*piVar17 != *piVar11) {
return 0;
}
if (*piVar17 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar23 = (int *)*puVar4;
piVar27 = (int *)*puVar5;
piVar2 = piVar23 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar23 + 2);
puVar5 = *(int8 **)(piVar27 + 2);
if (*piVar23 != *piVar27) {
return 0;
}
if (*piVar23 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar18 = (int *)*puVar4;
piVar12 = (int *)*puVar5;
piVar3 = piVar18 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar18 + 2);
puVar5 = *(int8 **)(piVar12 + 2);
if (*piVar18 != *piVar12) {
return 0;
}
if (*piVar18 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar24 = (int *)*puVar4;
piVar28 = (int *)*puVar5;
piVar9 = piVar24 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar24 + 2);
puVar5 = *(int8 **)(piVar28 + 2);
if (*piVar24 != *piVar28) {
return 0;
}
if (*piVar24 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar19 = (int *)*puVar4;
piVar25 = (int *)*puVar5;
piVar22 = piVar19 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar19 + 2);
puVar5 = *(int8 **)(piVar25 + 2);
if (*piVar19 != *piVar25) {
return 0;
}
if (*piVar19 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar13 = (int *)*puVar4;
piVar29 = (int *)*puVar5;
piVar7 = piVar13 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar13 + 2);
puVar5 = *(int8 **)(piVar29 + 2);
if (*piVar13 != *piVar29) {
return 0;
}
if (*piVar13 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar20 = (int *)*puVar4;
piVar14 = (int *)*puVar5;
piVar8 = piVar20 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar20 + 2);
puVar5 = *(int8 **)(piVar14 + 2);
if (*piVar20 != *piVar14) {
return 0;
}
if (*piVar20 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar30 = (int *)*puVar4;
piVar15 = (int *)*puVar5;
piVar10 = piVar30 + (long)iVar6 * 4;
do {
puVar4 = *(int8 **)(piVar30 + 2);
puVar5 = *(int8 **)(piVar15 + 2);
if (*piVar30 != *piVar15) {
return 0;
}
if (*piVar30 == 0) {
if ((int)puVar4 != (int)puVar5) {
return 0;
}
}
else {
iVar6 = *(int *)(puVar4 + 1);
if (iVar6 != *(int *)(puVar5 + 1)) {
return 0;
}
if (0 < iVar6) {
piVar16 = (int *)*puVar4;
piVar21 = (int *)*puVar5;
piVar26 = piVar16 + (long)iVar6 * 4;
do {
if (*piVar16 != *piVar21) {
return 0;
}
if (*piVar16 == 0) {
if ((int)*(int8 *)(piVar16 + 2) !=
(int)*(int8 *)(piVar21 + 2)) {
return 0;
}
}
else {
iVar6 = func0();
if (iVar6 == 0) {
return 0;
}
}
piVar16 = piVar16 + 4;
piVar21 = piVar21 + 4;
} while (piVar16 != piVar26);
}
}
piVar30 = piVar30 + 4;
piVar15 = piVar15 + 4;
} while (piVar10 != piVar30);
}
}
piVar20 = piVar20 + 4;
piVar14 = piVar14 + 4;
} while (piVar8 != piVar20);
}
}
piVar13 = piVar13 + 4;
piVar29 = piVar29 + 4;
} while (piVar13 != piVar7);
}
}
piVar19 = piVar19 + 4;
piVar25 = piVar25 + 4;
} while (piVar19 != piVar22);
}
}
piVar24 = piVar24 + 4;
piVar28 = piVar28 + 4;
} while (piVar24 != piVar9);
}
}
piVar18 = piVar18 + 4;
piVar12 = piVar12 + 4;
} while (piVar18 != piVar3);
}
}
piVar23 = piVar23 + 4;
piVar27 = piVar27 + 4;
} while (piVar23 != piVar2);
}
}
piVar17 = piVar17 + 4;
piVar11 = piVar11 + 4;
} while (piVar17 != piVar1);
return 1;
}
return 1;
} |
6,216 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
imul -0x8(%rbp),%eax
add %eax,%eax
cvtsi2sd %eax,%xmm2
movsd %xmm2,-0x10(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm0
movsd 0xee6(%rip),%xmm1
callq 1060 <pow@plt>
addsd -0x10(%rbp),%xmm0
cvttsd2si %xmm0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
imul eax, [rbp+var_8]
add eax, eax
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movsd [rbp+var_10], xmm2
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_4]
movq rax, xmm3
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
addsd xmm0, [rbp+var_10]
cvttsd2si eax, xmm0
leave
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)(pow((double)a1, 2.0) + (double)(2 * a2 * a1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVSD qword ptr [RBP + -0x10],XMM2
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x4]
MOVQ RAX,XMM3
MOVSD XMM0,qword ptr [0x00102060]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
ADDSD XMM0,qword ptr [RBP + -0x10]
CVTTSD2SI EAX,XMM0
LEAVE
RET | int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)param_1,DAT_00102060);
return (int)(dVar1 + (double)(param_1 * param_2 * 2));
} |
6,217 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O1 | c | func0:
endbr64
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
imul %esi,%edi
add %edi,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd %xmm1,%xmm1
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
| func0:
endbr64
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
imul edi, esi
add edi, edi
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm0, xmm0
addsd xmm0, xmm1
cvttsd2si eax, xmm0
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)((double)a1 * (double)a1 + (double)(2 * a2 * a1));
} | func0:
ENDBR64
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
IMUL EDI,ESI
ADD EDI,EDI
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
RET | int func0(int param_1,int param_2)
{
return (int)((double)param_1 * (double)param_1 + (double)(param_1 * param_2 * 2));
} |
6,218 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm1
imul %esi,%edi
mulsd %xmm1,%xmm1
add %edi,%edi
cvtsi2sd %edi,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, edi
imul edi, esi
mulsd xmm0, xmm0
add edi, edi
cvtsi2sd xmm1, edi
addsd xmm1, xmm0
cvttsd2si eax, xmm1
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)((double)(2 * a2 * a1) + (double)a1 * (double)a1);
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDI
IMUL EDI,ESI
MULSD XMM0,XMM0
ADD EDI,EDI
CVTSI2SD XMM1,EDI
ADDSD XMM1,XMM0
CVTTSD2SI EAX,XMM1
RET | int func0(int param_1,int param_2)
{
return (int)((double)(param_1 * param_2 * 2) + (double)param_1 * (double)param_1);
} |
6,219 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm1
imul %esi,%edi
mulsd %xmm1,%xmm1
add %edi,%edi
cvtsi2sd %edi,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, edi
imul edi, esi
mulsd xmm0, xmm0
add edi, edi
cvtsi2sd xmm1, edi
addsd xmm1, xmm0
cvttsd2si eax, xmm1
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)((double)(2 * a2 * a1) + (double)a1 * (double)a1);
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDI
IMUL EDI,ESI
MULSD XMM0,XMM0
ADD EDI,EDI
CVTSI2SD XMM1,EDI
ADDSD XMM1,XMM0
CVTTSD2SI EAX,XMM1
RET | int func0(int param_1,int param_2)
{
return (int)((double)(param_1 * param_2 * 2) + (double)param_1 * (double)param_1);
} |
6,220 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
je 1161 <func0+0x18>
mov $0x0,%eax
jmp 1166 <func0+0x1d>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jz short loc_1161
mov eax, 0
jmp short loc_1166
loc_1161:
mov eax, 1
loc_1166:
pop rbp
retn | _BOOL8 func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JZ 0x00101161
MOV EAX,0x0
JMP 0x00101166
LAB_00101161:
MOV EAX,0x1
LAB_00101166:
POP RBP
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,221 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
sete %al
retq
| func0:
endbr64
test edi, edi
setz al
retn | bool func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
TEST EDI,EDI
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,222 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
setz al
retn | bool func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
TEST EDI,EDI
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,223 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
setz al
retn | bool func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
TEST EDI,EDI
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,224 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %edi,-0x24(%rbp)
cmpl $0x1,-0x24(%rbp)
jg 1166 <func0+0x1d>
mov $0x1,%eax
jmp 11a7 <func0+0x5e>
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 119c <func0+0x53>
mov -0x14(%rbp),%eax
mov %eax,%edi
callq 1149 <func0>
mov %eax,%ebx
mov -0x24(%rbp),%eax
sub -0x14(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1149 <func0>
imul %ebx,%eax
add %eax,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1176 <func0+0x2d>
mov -0x18(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_24], edi
cmp [rbp+var_24], 1
jg short loc_1166
mov eax, 1
jmp short loc_11A7
loc_1166:
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_119C
loc_1176:
mov eax, [rbp+var_14]
mov edi, eax
call func0
mov ebx, eax
mov eax, [rbp+var_24]
sub eax, [rbp+var_14]
sub eax, 1
mov edi, eax
call func0
imul eax, ebx
add [rbp+var_18], eax
add [rbp+var_14], 1
loc_119C:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jl short loc_1176
mov eax, [rbp+var_18]
loc_11A7:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
int v2; // ebx
unsigned int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
if ( a1 <= 1 )
return 1LL;
v3 = 0;
for ( i = 0; i < a1; ++i )
{
v2 = func0((unsigned int)i);
v3 += v2 * func0((unsigned int)(a1 - i - 1));
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RBP + -0x24],EDI
CMP dword ptr [RBP + -0x24],0x1
JG 0x00101166
MOV EAX,0x1
JMP 0x001011a7
LAB_00101166:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010119c
LAB_00101176:
MOV EAX,dword ptr [RBP + -0x14]
MOV EDI,EAX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101149
IMUL EAX,EBX
ADD dword ptr [RBP + -0x18],EAX
ADD dword ptr [RBP + -0x14],0x1
LAB_0010119c:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101176
MOV EAX,dword ptr [RBP + -0x18]
LAB_001011a7:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int4 local_20;
int4 local_1c;
if (param_1 < 2) {
local_20 = 1;
}
else {
local_20 = 0;
for (local_1c = 0; local_1c < param_1; local_1c = local_1c + 1) {
iVar1 = func0(local_1c);
iVar2 = func0((param_1 - local_1c) + -1);
local_20 = local_20 + iVar2 * iVar1;
}
}
return local_20;
} |
6,225 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov $0x1,%r12d
cmp $0x1,%edi
jle 118f <func0+0x46>
lea -0x1(%rdi),%ebp
mov $0x0,%r12d
mov %ebp,%r13d
mov %r13d,%edi
sub %ebp,%edi
callq 1149 <func0>
mov %eax,%ebx
mov %ebp,%edi
callq 1149 <func0>
imul %eax,%ebx
add %ebx,%r12d
sub $0x1,%ebp
cmp $0xffffffff,%ebp
jne 116e <func0+0x25>
mov %r12d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12d, 1
cmp edi, 1
jle short loc_118F
lea ebp, [rdi-1]
mov r12d, 0
mov r13d, ebp
loc_116E:
mov edi, r13d
sub edi, ebp
call func0
mov ebx, eax
mov edi, ebp
call func0
imul ebx, eax
add r12d, ebx
sub ebp, 1
cmp ebp, 0FFFFFFFFh
jnz short loc_116E
loc_118F:
mov eax, r12d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(int a1)
{
unsigned int v1; // r12d
unsigned int v2; // ebp
int v3; // ebx
v1 = 1;
if ( a1 > 1 )
{
v2 = a1 - 1;
v1 = 0;
do
{
v3 = func0(a1 - 1 - v2);
v1 += func0(v2--) * v3;
}
while ( v2 != -1 );
}
return v1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,0x1
CMP EDI,0x1
JLE 0x0010118f
LEA EBP,[RDI + -0x1]
MOV R12D,0x0
MOV R13D,EBP
LAB_0010116e:
MOV EDI,R13D
SUB EDI,EBP
CALL 0x00101149
MOV EBX,EAX
MOV EDI,EBP
CALL 0x00101149
IMUL EBX,EAX
ADD R12D,EBX
SUB EBP,0x1
CMP EBP,-0x1
JNZ 0x0010116e
LAB_0010118f:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 1;
if (1 < param_1) {
iVar4 = 0;
iVar3 = param_1 + -1;
do {
iVar1 = func0((param_1 + -1) - iVar3);
iVar2 = func0(iVar3);
iVar4 = iVar4 + iVar1 * iVar2;
iVar3 = iVar3 + -1;
} while (iVar3 != -1);
}
return iVar4;
} |
6,226 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%edi
jle 1200 <func0+0x10>
jmp 1210 <func0.part.0>
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov [rsp+88h+var_58], edi
mov [rsp+88h+var_5C], 0
test edi, edi
jle loc_24A2
mov eax, edi
mov [rsp+88h+var_6C], 0
sub eax, 1
mov [rsp+88h+var_70], 1
mov [rsp+88h+var_60], eax
loc_122B:
mov eax, [rsp+88h+var_60]
cmp eax, 1
jle loc_1B4F
sub eax, 1
mov [rsp+88h+var_68], 0
mov [rsp+88h+var_7C], eax
mov eax, [rsp+88h+var_7C]
mov [rsp+88h+var_78], 0
mov [rsp+88h+var_74], 1
cmp eax, 1
jle loc_1B29
loc_1264:
sub eax, 1
xor esi, esi
xor edx, edx
mov r15d, 1
mov [rsp+88h+var_64], eax
mov ecx, eax
loc_1277:
cmp ecx, 1
jle loc_146A
lea r8d, [rcx-1]
xor r9d, r9d
xor r11d, r11d
xor r14d, r14d
mov r13d, r8d
mov ebx, 1
cmp r13d, 1
jle loc_1456
loc_129F:
sub r13d, 1
xor ebp, ebp
xor r12d, r12d
mov r10d, 1
mov r8d, r13d
cmp r8d, 1
jle loc_1370
loc_12BB:
mov edi, r8d
mov [rsp+88h+var_3C], r10d
add r12d, 1
mov [rsp+88h+var_40], r9d
mov [rsp+88h+var_44], ecx
mov [rsp+88h+var_48], esi
mov [rsp+88h+var_4C], edx
mov [rsp+88h+var_50], r11d
mov [rsp+88h+var_54], r8d
call func0_part_0
mov r10d, [rsp+88h+var_3C]
mov r8d, [rsp+88h+var_54]
mov r11d, [rsp+88h+var_50]
mov edx, [rsp+88h+var_4C]
imul eax, r10d
mov esi, [rsp+88h+var_48]
mov ecx, [rsp+88h+var_44]
mov r9d, [rsp+88h+var_40]
add ebp, eax
nop dword ptr [rax]
loc_1310:
cmp r12d, 1
jz loc_2547
mov edi, r12d
mov [rsp+88h+var_40], r9d
mov [rsp+88h+var_44], ecx
mov [rsp+88h+var_48], esi
mov [rsp+88h+var_4C], r8d
mov [rsp+88h+var_50], edx
mov [rsp+88h+var_54], r11d
call func0_part_0
mov r11d, [rsp+88h+var_54]
mov edx, [rsp+88h+var_50]
mov r8d, [rsp+88h+var_4C]
mov esi, [rsp+88h+var_48]
mov r10d, eax
mov ecx, [rsp+88h+var_44]
mov r9d, [rsp+88h+var_40]
loc_135B:
sub r8d, 1
cmp r8d, 1
jg loc_12BB
nop dword ptr [rax+00000000h]
loc_1370:
add ebp, r10d
add r12d, 1
test r8d, r8d
jnz short loc_1310
imul ebp, ebx
add r14d, 1
add r11d, ebp
loc_1386:
cmp r14d, 1
jz loc_253D
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_139A:
mov edi, r9d
sub edi, ebp
cmp edi, 1
jle short loc_13E0
loc_13A4:
mov [rsp+88h+var_44], r9d
mov [rsp+88h+var_48], ecx
mov [rsp+88h+var_4C], esi
mov [rsp+88h+var_50], edx
mov [rsp+88h+var_54], r11d
call func0_part_0
mov r9d, [rsp+88h+var_44]
mov ecx, [rsp+88h+var_48]
imul r12d, eax
mov esi, [rsp+88h+var_4C]
mov edx, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_54]
nop dword ptr [rax+00000000h]
loc_13E0:
add ebp, 1
add ebx, r12d
cmp r14d, ebp
jz short loc_1448
loc_13EB:
cmp ebp, 1
jle loc_1690
mov edi, ebp
mov [rsp+88h+var_44], r9d
mov [rsp+88h+var_48], ecx
mov [rsp+88h+var_4C], esi
mov [rsp+88h+var_50], edx
mov [rsp+88h+var_54], r11d
call func0_part_0
mov r9d, [rsp+88h+var_44]
mov r11d, [rsp+88h+var_54]
mov edx, [rsp+88h+var_50]
mov esi, [rsp+88h+var_4C]
mov r12d, eax
mov edi, r9d
mov ecx, [rsp+88h+var_48]
sub edi, ebp
cmp edi, 1
jg loc_13A4
add ebp, 1
add ebx, r12d
cmp r14d, ebp
jnz short loc_13EB
nop dword ptr [rax+rax+00h]
loc_1448:
add r9d, 1
cmp r13d, 1
jg loc_129F
loc_1456:
add r11d, ebx
add r14d, 1
test r13d, r13d
jnz loc_2529
imul r15d, r11d
loc_146A:
add esi, r15d
lea r11d, [rdx+1]
cmp [rsp+88h+var_7C], r11d
jz loc_16B0
cmp r11d, 1
jle loc_1670
mov r9d, edx
xor r8d, r8d
xor r15d, r15d
xor r14d, r14d
mov ebx, 1
loc_1497:
cmp r9d, 1
jle loc_157F
lea r13d, [r9-1]
xor r12d, r12d
xor ebp, ebp
mov r10d, 1
cmp r13d, 1
jle loc_1570
loc_14BA:
mov edi, r13d
mov [rsp+88h+var_3C], ecx
add ebp, 1
mov [rsp+88h+var_40], r11d
mov [rsp+88h+var_44], esi
mov [rsp+88h+var_48], r10d
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], r8d
mov [rsp+88h+var_54], edx
call func0_part_0
mov r10d, [rsp+88h+var_48]
mov edx, [rsp+88h+var_54]
mov r8d, [rsp+88h+var_50]
mov r9d, [rsp+88h+var_4C]
imul eax, r10d
mov esi, [rsp+88h+var_44]
mov r11d, [rsp+88h+var_40]
mov ecx, [rsp+88h+var_3C]
add r12d, eax
nop dword ptr [rax+00h]
loc_1510:
cmp ebp, 1
jz loc_2532
mov edi, ebp
mov [rsp+88h+var_40], ecx
mov [rsp+88h+var_44], r11d
mov [rsp+88h+var_48], esi
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], r8d
mov [rsp+88h+var_54], edx
call func0_part_0
mov edx, [rsp+88h+var_54]
mov r8d, [rsp+88h+var_50]
mov r9d, [rsp+88h+var_4C]
mov esi, [rsp+88h+var_48]
mov r10d, eax
mov r11d, [rsp+88h+var_44]
mov ecx, [rsp+88h+var_40]
loc_1559:
sub r13d, 1
cmp r13d, 1
jg loc_14BA
nop word ptr [rax+rax+00000000h]
loc_1570:
add r12d, r10d
add ebp, 1
test r13d, r13d
jnz short loc_1510
imul ebx, r12d
loc_157F:
add r15d, ebx
lea r13d, [r14+1]
cmp edx, r14d
jz loc_1680
cmp r13d, 1
jle loc_1658
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_15A3:
mov edi, r8d
sub edi, ebp
cmp edi, 1
jle short loc_15F0
mov [rsp+88h+var_40], ecx
mov [rsp+88h+var_44], r11d
mov [rsp+88h+var_48], esi
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], r8d
mov [rsp+88h+var_54], edx
call func0_part_0
mov ecx, [rsp+88h+var_40]
mov r11d, [rsp+88h+var_44]
imul r12d, eax
mov esi, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_4C]
mov r8d, [rsp+88h+var_50]
mov edx, [rsp+88h+var_54]
nop dword ptr [rax+00h]
loc_15F0:
add ebx, r12d
lea edi, [rbp+1]
cmp ebp, r14d
jz short loc_1660
cmp edi, 1
jle loc_16A0
mov [rsp+88h+var_3C], ecx
mov [rsp+88h+var_40], r11d
mov [rsp+88h+var_44], esi
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], r8d
mov [rsp+88h+var_50], edx
mov [rsp+88h+var_54], edi
call func0_part_0
mov edi, [rsp+88h+var_54]
mov edx, [rsp+88h+var_50]
mov r8d, [rsp+88h+var_4C]
mov r9d, [rsp+88h+var_48]
mov r12d, eax
mov esi, [rsp+88h+var_44]
mov r11d, [rsp+88h+var_40]
mov ebp, edi
mov ecx, [rsp+88h+var_3C]
jmp loc_15A3
loc_1658:
mov ebx, 1
nop dword ptr [rax]
loc_1660:
add r8d, 1
sub r9d, 1
mov r14d, r13d
jmp loc_1497
loc_1670:
mov r15d, 1
nop word ptr [rax+rax+00000000h]
loc_1680:
sub ecx, 1
mov edx, r11d
jmp loc_1277
loc_1690:
mov r12d, 1
jmp loc_139A
loc_16A0:
mov r12d, 1
mov ebp, edi
jmp loc_15A3
loc_16B0:
imul esi, [rsp+88h+var_74]
add [rsp+88h+var_78], 1
add [rsp+88h+var_68], esi
loc_16BE:
mov eax, [rsp+88h+var_78]
cmp eax, 1
jz loc_251C
lea ecx, [rax-1]
xor esi, esi
xor edx, edx
mov r15d, 1
loc_16D8:
cmp ecx, 1
jle loc_18CA
lea r8d, [rcx-1]
xor r9d, r9d
xor r11d, r11d
xor r14d, r14d
mov r13d, r8d
mov ebx, 1
cmp r13d, 1
jbe loc_18B6
loc_1700:
sub r13d, 1
xor r12d, r12d
xor ebp, ebp
mov r10d, 1
mov r8d, r13d
cmp r8d, 1
jbe loc_17D0
loc_171C:
mov edi, r8d
mov [rsp+88h+var_44], edx
add r12d, 1
mov [rsp+88h+var_48], esi
mov [rsp+88h+var_4C], r10d
mov [rsp+88h+var_50], ecx
mov [rsp+88h+var_54], r11d
mov [rsp+88h+var_74], r9d
mov [rsp+88h+var_7C], r8d
call func0_part_0
mov r10d, [rsp+88h+var_4C]
mov r8d, [rsp+88h+var_7C]
mov r9d, [rsp+88h+var_74]
mov r11d, [rsp+88h+var_54]
imul eax, r10d
mov ecx, [rsp+88h+var_50]
mov esi, [rsp+88h+var_48]
mov edx, [rsp+88h+var_44]
add ebp, eax
xchg ax, ax
loc_1770:
cmp r12d, 1
jz loc_2511
mov edi, r12d
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], esi
mov [rsp+88h+var_50], r8d
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_74], r11d
mov [rsp+88h+var_7C], r9d
call func0_part_0
mov r9d, [rsp+88h+var_7C]
mov r11d, [rsp+88h+var_74]
mov ecx, [rsp+88h+var_54]
mov r8d, [rsp+88h+var_50]
mov r10d, eax
mov esi, [rsp+88h+var_4C]
mov edx, [rsp+88h+var_48]
loc_17BB:
sub r8d, 1
cmp r8d, 1
ja loc_171C
nop dword ptr [rax+00000000h]
loc_17D0:
add ebp, r10d
add r12d, 1
test r8d, r8d
jnz short loc_1770
imul ebp, ebx
add r14d, 1
add r11d, ebp
loc_17E6:
cmp r14d, 1
jz loc_2507
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_17FA:
mov edi, r9d
sub edi, ebp
cmp edi, 1
jle short loc_1840
loc_1804:
mov [rsp+88h+var_4C], edx
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_74], r11d
mov [rsp+88h+var_7C], r9d
call func0_part_0
mov edx, [rsp+88h+var_4C]
mov esi, [rsp+88h+var_50]
imul r12d, eax
mov ecx, [rsp+88h+var_54]
mov r11d, [rsp+88h+var_74]
mov r9d, [rsp+88h+var_7C]
nop dword ptr [rax+00000000h]
loc_1840:
add ebp, 1
add ebx, r12d
cmp r14d, ebp
jz short loc_18A8
loc_184B:
cmp ebp, 1
jle loc_1AF0
mov edi, ebp
mov [rsp+88h+var_4C], edx
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_74], r11d
mov [rsp+88h+var_7C], r9d
call func0_part_0
mov r9d, [rsp+88h+var_7C]
mov r11d, [rsp+88h+var_74]
mov ecx, [rsp+88h+var_54]
mov esi, [rsp+88h+var_50]
mov r12d, eax
mov edi, r9d
mov edx, [rsp+88h+var_4C]
sub edi, ebp
cmp edi, 1
jg loc_1804
add ebp, 1
add ebx, r12d
cmp r14d, ebp
jnz short loc_184B
nop dword ptr [rax+rax+00h]
loc_18A8:
add r9d, 1
cmp r13d, 1
ja loc_1700
loc_18B6:
add r11d, ebx
add r14d, 1
test r13d, r13d
jnz loc_24F3
imul r15d, r11d
loc_18CA:
add esi, r15d
lea r11d, [rdx+1]
cmp [rsp+88h+var_78], r11d
jz loc_1B10
cmp r11d, 1
jle loc_1AD0
mov r9d, edx
xor r8d, r8d
xor r15d, r15d
xor r14d, r14d
mov ebx, 1
loc_18F7:
cmp r9d, 1
jle loc_19DF
lea r13d, [r9-1]
xor r12d, r12d
xor ebp, ebp
mov r10d, 1
cmp r13d, 1
jle loc_19D0
loc_191A:
mov edi, r13d
mov [rsp+88h+var_44], edx
add ebp, 1
mov [rsp+88h+var_48], r10d
mov [rsp+88h+var_4C], r11d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], r8d
mov [rsp+88h+var_74], r9d
mov [rsp+88h+var_7C], ecx
call func0_part_0
mov r10d, [rsp+88h+var_48]
mov ecx, [rsp+88h+var_7C]
mov r9d, [rsp+88h+var_74]
mov r8d, [rsp+88h+var_54]
imul eax, r10d
mov esi, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_4C]
mov edx, [rsp+88h+var_44]
add r12d, eax
nop dword ptr [rax+00h]
loc_1970:
cmp ebp, 1
jz loc_24FC
mov edi, ebp
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], r11d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], r8d
mov [rsp+88h+var_74], r9d
mov [rsp+88h+var_7C], ecx
call func0_part_0
mov ecx, [rsp+88h+var_7C]
mov r9d, [rsp+88h+var_74]
mov r8d, [rsp+88h+var_54]
mov esi, [rsp+88h+var_50]
mov r10d, eax
mov r11d, [rsp+88h+var_4C]
mov edx, [rsp+88h+var_48]
loc_19B9:
sub r13d, 1
cmp r13d, 1
jg loc_191A
nop word ptr [rax+rax+00000000h]
loc_19D0:
add r12d, r10d
add ebp, 1
test r13d, r13d
jnz short loc_1970
imul ebx, r12d
loc_19DF:
add r15d, ebx
lea r13d, [r14+1]
cmp edx, r14d
jz loc_1AE0
cmp r13d, 1
jle loc_1AB8
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_1A03:
mov edi, r8d
sub edi, ebp
cmp edi, 1
jle short loc_1A50
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], r11d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], r8d
mov [rsp+88h+var_74], r9d
mov [rsp+88h+var_7C], ecx
call func0_part_0
mov edx, [rsp+88h+var_48]
mov r11d, [rsp+88h+var_4C]
imul r12d, eax
mov esi, [rsp+88h+var_50]
mov r8d, [rsp+88h+var_54]
mov r9d, [rsp+88h+var_74]
mov ecx, [rsp+88h+var_7C]
nop dword ptr [rax+00h]
loc_1A50:
add ebx, r12d
lea edi, [rbp+1]
cmp r14d, ebp
jz short loc_1AC0
cmp edi, 1
jle loc_1B00
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r11d
mov [rsp+88h+var_4C], esi
mov [rsp+88h+var_50], r8d
mov [rsp+88h+var_54], r9d
mov [rsp+88h+var_74], ecx
mov [rsp+88h+var_7C], edi
call func0_part_0
mov edi, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_74]
mov r9d, [rsp+88h+var_54]
mov r8d, [rsp+88h+var_50]
mov r12d, eax
mov esi, [rsp+88h+var_4C]
mov r11d, [rsp+88h+var_48]
mov ebp, edi
mov edx, [rsp+88h+var_44]
jmp loc_1A03
loc_1AB8:
mov ebx, 1
nop dword ptr [rax]
loc_1AC0:
add r8d, 1
sub r9d, 1
mov r14d, r13d
jmp loc_18F7
loc_1AD0:
mov r15d, 1
nop word ptr [rax+rax+00000000h]
loc_1AE0:
sub ecx, 1
mov edx, r11d
jmp loc_16D8
loc_1AF0:
mov r12d, 1
jmp loc_17FA
loc_1B00:
mov r12d, 1
mov ebp, edi
jmp loc_1A03
loc_1B10:
mov [rsp+88h+var_74], esi
loc_1B14:
mov eax, [rsp+88h+var_64]
mov [rsp+88h+var_7C], eax
mov eax, [rsp+88h+var_7C]
cmp eax, 1
jg loc_1264
loc_1B29:
mov eax, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_74]
add [rsp+88h+var_78], 1
add [rsp+88h+var_68], ecx
test eax, eax
jnz loc_2552
mov eax, [rsp+88h+var_70]
imul eax, [rsp+88h+var_68]
mov [rsp+88h+var_70], eax
loc_1B4F:
mov eax, [rsp+88h+var_6C]
mov ecx, [rsp+88h+var_70]
add [rsp+88h+var_5C], ecx
add eax, 1
mov [rsp+88h+var_68], eax
cmp [rsp+88h+var_58], eax
jz loc_24A2
cmp [rsp+88h+var_68], 1
jle loc_2481
mov eax, [rsp+88h+var_6C]
mov [rsp+88h+var_70], 0
mov [rsp+88h+var_7C], 0
mov [rsp+88h+var_78], eax
mov [rsp+88h+var_74], 1
loc_1B97:
mov eax, [rsp+88h+var_78]
cmp eax, 1
jle loc_1FD9
lea ecx, [rax-1]
xor esi, esi
xor edx, edx
mov r15d, 1
loc_1BB1:
cmp ecx, 1
jle loc_1DAA
lea r8d, [rcx-1]
xor r9d, r9d
xor r11d, r11d
xor r14d, r14d
mov r13d, r8d
mov ebx, 1
cmp r13d, 1
jle loc_1D96
loc_1BD9:
sub r13d, 1
xor r12d, r12d
xor ebp, ebp
mov r10d, 1
mov r8d, r13d
cmp r8d, 1
jle loc_1CB0
loc_1BF5:
mov edi, r8d
mov [rsp+88h+var_40], edx
add r12d, 1
mov [rsp+88h+var_44], r9d
mov [rsp+88h+var_48], esi
mov [rsp+88h+var_4C], ecx
mov [rsp+88h+var_50], r11d
mov [rsp+88h+var_54], r10d
mov [rsp+88h+var_64], r8d
call func0_part_0
mov r10d, [rsp+88h+var_54]
mov r8d, [rsp+88h+var_64]
mov r11d, [rsp+88h+var_50]
mov ecx, [rsp+88h+var_4C]
imul eax, r10d
mov esi, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_44]
mov edx, [rsp+88h+var_40]
add ebp, eax
nop word ptr [rax+rax+00000000h]
loc_1C50:
cmp r12d, 1
jz loc_24DF
mov edi, r12d
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], esi
mov [rsp+88h+var_50], r8d
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_64], r11d
call func0_part_0
mov r11d, [rsp+88h+var_64]
mov ecx, [rsp+88h+var_54]
mov r8d, [rsp+88h+var_50]
mov esi, [rsp+88h+var_4C]
mov r10d, eax
mov r9d, [rsp+88h+var_48]
mov edx, [rsp+88h+var_44]
loc_1C9B:
sub r8d, 1
cmp r8d, 1
jg loc_1BF5
nop dword ptr [rax+00000000h]
loc_1CB0:
add ebp, r10d
add r12d, 1
test r8d, r8d
jnz short loc_1C50
imul ebp, ebx
add r14d, 1
add r11d, ebp
loc_1CC6:
cmp r14d, 1
jz loc_24D5
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_1CDA:
mov edi, r9d
sub edi, ebp
cmp edi, 1
jle short loc_1D20
loc_1CE4:
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_64], r11d
call func0_part_0
mov edx, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_4C]
imul r12d, eax
mov esi, [rsp+88h+var_50]
mov ecx, [rsp+88h+var_54]
mov r11d, [rsp+88h+var_64]
nop dword ptr [rax+00000000h]
loc_1D20:
add ebp, 1
add ebx, r12d
cmp r14d, ebp
jz short loc_1D88
loc_1D2B:
cmp ebp, 1
jle loc_2458
mov edi, ebp
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_64], r11d
call func0_part_0
mov r9d, [rsp+88h+var_4C]
mov r11d, [rsp+88h+var_64]
mov ecx, [rsp+88h+var_54]
mov esi, [rsp+88h+var_50]
mov r12d, eax
mov edi, r9d
mov edx, [rsp+88h+var_48]
sub edi, ebp
cmp edi, 1
jg loc_1CE4
add ebp, 1
add ebx, r12d
cmp r14d, ebp
jnz short loc_1D2B
nop dword ptr [rax+rax+00h]
loc_1D88:
add r9d, 1
cmp r13d, 1
jg loc_1BD9
loc_1D96:
add r11d, ebx
add r14d, 1
test r13d, r13d
jnz loc_24EA
imul r15d, r11d
loc_1DAA:
add esi, r15d
lea r11d, [rdx+1]
cmp [rsp+88h+var_78], r11d
jz loc_1FD0
cmp r11d, 1
jle loc_1FB0
mov r9d, edx
xor r8d, r8d
xor r15d, r15d
xor r14d, r14d
mov ebx, 1
loc_1DD7:
cmp r9d, 1
jle loc_1EBF
lea r13d, [r9-1]
xor r12d, r12d
xor ebp, ebp
mov r10d, 1
cmp r13d, 1
jle loc_1EB0
loc_1DFA:
mov edi, r13d
mov [rsp+88h+var_40], edx
add ebp, 1
mov [rsp+88h+var_44], r8d
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], r11d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_64], r10d
call func0_part_0
mov r10d, [rsp+88h+var_64]
mov ecx, [rsp+88h+var_54]
mov esi, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_4C]
imul eax, r10d
mov r9d, [rsp+88h+var_48]
mov r8d, [rsp+88h+var_44]
mov edx, [rsp+88h+var_40]
add r12d, eax
nop dword ptr [rax+00h]
loc_1E50:
cmp ebp, 1
jz loc_24CA
mov edi, ebp
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r8d
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], r11d
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_64], ecx
call func0_part_0
mov ecx, [rsp+88h+var_64]
mov esi, [rsp+88h+var_54]
mov r11d, [rsp+88h+var_50]
mov r9d, [rsp+88h+var_4C]
mov r10d, eax
mov r8d, [rsp+88h+var_48]
mov edx, [rsp+88h+var_44]
loc_1E99:
sub r13d, 1
cmp r13d, 1
jg loc_1DFA
nop word ptr [rax+rax+00000000h]
loc_1EB0:
add r12d, r10d
add ebp, 1
test r13d, r13d
jnz short loc_1E50
imul ebx, r12d
loc_1EBF:
add r15d, ebx
lea r13d, [r14+1]
cmp edx, r14d
jz loc_1FC0
cmp r13d, 1
jle loc_1F98
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_1EE3:
mov edi, r8d
sub edi, ebp
cmp edi, 1
jle short loc_1F30
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r8d
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], r11d
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_64], ecx
call func0_part_0
mov edx, [rsp+88h+var_44]
mov r8d, [rsp+88h+var_48]
imul r12d, eax
mov r9d, [rsp+88h+var_4C]
mov r11d, [rsp+88h+var_50]
mov esi, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_64]
nop dword ptr [rax+00h]
loc_1F30:
add ebx, r12d
lea edi, [rbp+1]
cmp ebp, r14d
jz short loc_1FA0
cmp edi, 1
jle loc_2448
mov [rsp+88h+var_40], edx
mov [rsp+88h+var_44], r8d
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], r11d
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_64], edi
call func0_part_0
mov edi, [rsp+88h+var_64]
mov ecx, [rsp+88h+var_54]
mov esi, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_4C]
mov r12d, eax
mov r9d, [rsp+88h+var_48]
mov r8d, [rsp+88h+var_44]
mov ebp, edi
mov edx, [rsp+88h+var_40]
jmp loc_1EE3
loc_1F98:
mov ebx, 1
nop dword ptr [rax]
loc_1FA0:
add r8d, 1
sub r9d, 1
mov r14d, r13d
jmp loc_1DD7
loc_1FB0:
mov r15d, 1
nop word ptr [rax+rax+00000000h]
loc_1FC0:
sub ecx, 1
mov edx, r11d
jmp loc_1BB1
loc_1FD0:
imul esi, [rsp+88h+var_74]
mov [rsp+88h+var_74], esi
loc_1FD9:
mov eax, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_74]
add [rsp+88h+var_70], ecx
lea r11d, [rax+1]
cmp eax, [rsp+88h+var_6C]
jz loc_2490
cmp r11d, 1
jle loc_24B5
mov [rsp+88h+var_74], r11d
mov r15d, 1
xor r13d, r13d
xor edx, edx
mov ecx, [rsp+88h+var_7C]
mov esi, r15d
loc_2014:
cmp ecx, 1
jle loc_220A
lea r8d, [rcx-1]
xor r9d, r9d
xor r15d, r15d
xor r11d, r11d
mov r14d, r8d
mov ebx, 1
cmp r14d, 1
jle loc_21F6
loc_203C:
sub r14d, 1
xor ebp, ebp
xor r12d, r12d
mov r10d, 1
mov r8d, r14d
cmp r8d, 1
jle loc_2110
loc_2058:
mov edi, r8d
mov [rsp+88h+var_40], edx
add r12d, 1
mov [rsp+88h+var_44], r9d
mov [rsp+88h+var_48], ecx
mov [rsp+88h+var_4C], r10d
mov [rsp+88h+var_50], r11d
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_64], r8d
call func0_part_0
mov r10d, [rsp+88h+var_4C]
mov r8d, [rsp+88h+var_64]
mov esi, [rsp+88h+var_54]
mov r11d, [rsp+88h+var_50]
imul eax, r10d
mov ecx, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_44]
mov edx, [rsp+88h+var_40]
add ebp, eax
nop word ptr [rax+rax+00h]
loc_20B0:
cmp r12d, 1
jz loc_24BF
mov edi, r12d
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], r8d
mov [rsp+88h+var_50], ecx
mov [rsp+88h+var_54], r11d
mov [rsp+88h+var_64], esi
call func0_part_0
mov esi, [rsp+88h+var_64]
mov r11d, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_50]
mov r8d, [rsp+88h+var_4C]
mov r10d, eax
mov r9d, [rsp+88h+var_48]
mov edx, [rsp+88h+var_44]
loc_20FB:
sub r8d, 1
cmp r8d, 1
jg loc_2058
nop dword ptr [rax+00000000h]
loc_2110:
add ebp, r10d
add r12d, 1
test r8d, r8d
jnz short loc_20B0
imul ebp, ebx
add r15d, 1
add r11d, ebp
loc_2126:
cmp r15d, 1
jz loc_2576
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_213A:
mov edi, r9d
sub edi, ebp
cmp edi, 1
jle short loc_2180
loc_2144:
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], ecx
mov [rsp+88h+var_54], r11d
mov [rsp+88h+var_64], esi
call func0_part_0
mov edx, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_4C]
imul r12d, eax
mov ecx, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_54]
mov esi, [rsp+88h+var_64]
nop dword ptr [rax+00000000h]
loc_2180:
add ebp, 1
add ebx, r12d
cmp r15d, ebp
jz short loc_21E8
loc_218B:
cmp ebp, 1
jle loc_2428
mov edi, ebp
mov [rsp+88h+var_48], edx
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], ecx
mov [rsp+88h+var_54], r11d
mov [rsp+88h+var_64], esi
call func0_part_0
mov r9d, [rsp+88h+var_4C]
mov esi, [rsp+88h+var_64]
mov r11d, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_50]
mov r12d, eax
mov edi, r9d
mov edx, [rsp+88h+var_48]
sub edi, ebp
cmp edi, 1
jg loc_2144
add ebp, 1
add ebx, r12d
cmp r15d, ebp
jnz short loc_218B
nop dword ptr [rax+rax+00h]
loc_21E8:
add r9d, 1
cmp r14d, 1
jg loc_203C
loc_21F6:
add r11d, ebx
add r15d, 1
test r14d, r14d
jnz loc_2562
imul esi, r11d
loc_220A:
add r13d, esi
lea r11d, [rdx+1]
cmp [rsp+88h+var_7C], edx
jz loc_2468
cmp r11d, 1
jle loc_2410
mov r9d, edx
xor r8d, r8d
xor esi, esi
xor r15d, r15d
mov ebx, 1
loc_2235:
cmp r9d, 1
jle loc_231F
lea r14d, [r9-1]
xor r12d, r12d
xor ebp, ebp
mov r10d, 1
cmp r14d, 1
jle loc_2310
loc_2258:
mov edi, r14d
mov [rsp+88h+var_40], edx
add ebp, 1
mov [rsp+88h+var_44], r8d
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], ecx
mov [rsp+88h+var_50], r10d
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_64], r11d
call func0_part_0
mov r10d, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_64]
mov esi, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_4C]
imul eax, r10d
mov r9d, [rsp+88h+var_48]
mov r8d, [rsp+88h+var_44]
mov edx, [rsp+88h+var_40]
add r12d, eax
nop word ptr [rax+rax+00h]
loc_22B0:
cmp ebp, 1
jz loc_256B
mov edi, ebp
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r8d
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], ecx
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_64], r11d
call func0_part_0
mov r11d, [rsp+88h+var_64]
mov esi, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_50]
mov r9d, [rsp+88h+var_4C]
mov r10d, eax
mov r8d, [rsp+88h+var_48]
mov edx, [rsp+88h+var_44]
loc_22F9:
sub r14d, 1
cmp r14d, 1
jg loc_2258
nop word ptr [rax+rax+00000000h]
loc_2310:
add r12d, r10d
add ebp, 1
test r14d, r14d
jnz short loc_22B0
imul ebx, r12d
loc_231F:
add esi, ebx
lea r14d, [r15+1]
cmp r15d, edx
jz loc_2418
cmp r14d, 1
jle loc_23F8
xor ebx, ebx
xor ebp, ebp
mov r12d, 1
loc_2342:
mov edi, r8d
sub edi, ebp
cmp edi, 1
jle short loc_2390
mov [rsp+88h+var_44], edx
mov [rsp+88h+var_48], r8d
mov [rsp+88h+var_4C], r9d
mov [rsp+88h+var_50], ecx
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_64], r11d
call func0_part_0
mov edx, [rsp+88h+var_44]
mov r8d, [rsp+88h+var_48]
imul r12d, eax
mov r9d, [rsp+88h+var_4C]
mov ecx, [rsp+88h+var_50]
mov esi, [rsp+88h+var_54]
mov r11d, [rsp+88h+var_64]
nop dword ptr [rax+rax+00h]
loc_2390:
add ebx, r12d
lea edi, [rbp+1]
cmp ebp, r15d
jz short loc_2400
cmp edi, 1
jle loc_2438
mov [rsp+88h+var_40], edx
mov [rsp+88h+var_44], r8d
mov [rsp+88h+var_48], r9d
mov [rsp+88h+var_4C], ecx
mov [rsp+88h+var_50], esi
mov [rsp+88h+var_54], r11d
mov [rsp+88h+var_64], edi
call func0_part_0
mov edi, [rsp+88h+var_64]
mov r11d, [rsp+88h+var_54]
mov esi, [rsp+88h+var_50]
mov ecx, [rsp+88h+var_4C]
mov r12d, eax
mov r9d, [rsp+88h+var_48]
mov r8d, [rsp+88h+var_44]
mov ebp, edi
mov edx, [rsp+88h+var_40]
jmp loc_2342
loc_23F8:
mov ebx, 1
nop dword ptr [rax]
loc_2400:
add r8d, 1
sub r9d, 1
mov r15d, r14d
jmp loc_2235
loc_2410:
mov esi, 1
nop dword ptr [rax]
loc_2418:
sub ecx, 1
mov edx, r11d
jmp loc_2014
loc_2428:
mov r12d, 1
jmp loc_213A
loc_2438:
mov r12d, 1
mov ebp, edi
jmp loc_2342
loc_2448:
mov r12d, 1
mov ebp, edi
jmp loc_1EE3
loc_2458:
mov r12d, 1
jmp loc_1CDA
loc_2468:
mov r11d, [rsp+88h+var_74]
mov [rsp+88h+var_74], r13d
loc_2472:
sub [rsp+88h+var_78], 1
mov [rsp+88h+var_7C], r11d
jmp loc_1B97
loc_2481:
mov [rsp+88h+var_70], 1
nop dword ptr [rax+00000000h]
loc_2490:
mov eax, [rsp+88h+var_68]
sub [rsp+88h+var_60], 1
mov [rsp+88h+var_6C], eax
jmp loc_122B
loc_24A2:
mov eax, [rsp+88h+var_5C]
add rsp, 58h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_24B5:
mov [rsp+88h+var_74], 1
jmp short loc_2472
loc_24BF:
mov r10d, 1
jmp loc_20FB
loc_24CA:
mov r10d, 1
jmp loc_1E99
loc_24D5:
mov ebx, 1
jmp loc_1D88
loc_24DF:
mov r10d, 1
jmp loc_1C9B
loc_24EA:
sub r13d, 1
jmp loc_1CC6
loc_24F3:
sub r13d, 1
jmp loc_17E6
loc_24FC:
mov r10d, 1
jmp loc_19B9
loc_2507:
mov ebx, 1
jmp loc_18A8
loc_2511:
mov r10d, 1
jmp loc_17BB
loc_251C:
mov [rsp+88h+var_74], 1
jmp loc_1B14
loc_2529:
sub r13d, 1
jmp loc_1386
loc_2532:
mov r10d, 1
jmp loc_1559
loc_253D:
mov ebx, 1
jmp loc_1448
loc_2547:
mov r10d, 1
jmp loc_135B
loc_2552:
mov eax, [rsp+88h+var_7C]
sub eax, 1
mov [rsp+88h+var_64], eax
jmp loc_16BE
loc_2562:
sub r14d, 1
jmp loc_2126
loc_256B:
mov r10d, 1
jmp loc_22F9
loc_2576:
mov ebx, 1
jmp loc_21E8 | long long func0_part_0(int a1)
{
int v1; // eax
int v2; // esi
int v3; // edx
int v4; // r15d
int j; // ecx
int v6; // r9d
int v7; // r11d
int v8; // r14d
int v9; // r13d
int v10; // ebx
int v11; // ebp
unsigned int v12; // r12d
int v13; // r10d
unsigned int v14; // r8d
int v15; // eax
int v16; // eax
int v17; // ebp
int k; // r12d
long long v19; // rdi
int v20; // eax
int v21; // eax
int v22; // r11d
int v23; // r9d
int v24; // r8d
int v25; // r14d
int v26; // ebx
unsigned int v27; // r13d
int v28; // r12d
unsigned int v29; // ebp
int v30; // r10d
int v31; // eax
int v32; // eax
int v33; // ebp
int v34; // r12d
long long v35; // rdi
int v36; // eax
long long v37; // rdi
int v38; // eax
int v39; // ecx
int v40; // esi
int v41; // edx
int v42; // r15d
int v43; // r9d
int v44; // r11d
int v45; // r14d
unsigned int v46; // r13d
int v47; // ebx
unsigned int v48; // r12d
int v49; // ebp
int v50; // r10d
unsigned int v51; // r8d
int v52; // eax
int v53; // eax
int v54; // ebp
int m; // r12d
long long v56; // rdi
int v57; // eax
int v58; // eax
int v59; // r11d
int v60; // r9d
int v61; // r8d
int v62; // r14d
int v63; // ebx
unsigned int v64; // r13d
int v65; // r12d
unsigned int v66; // ebp
int v67; // r10d
int v68; // eax
int v69; // eax
int v70; // ebp
int v71; // r12d
long long v72; // rdi
int v73; // eax
long long v74; // rdi
int v75; // eax
int v76; // ecx
int v77; // esi
int v78; // edx
int v79; // r15d
int v80; // r9d
int v81; // r11d
int v82; // r14d
int v83; // r13d
int v84; // ebx
unsigned int v85; // r12d
int v86; // ebp
int v87; // r10d
unsigned int v88; // r8d
int v89; // eax
int v90; // eax
int v91; // ebp
int n; // r12d
long long v93; // rdi
int v94; // eax
int v95; // eax
int v96; // r11d
int v97; // r9d
int v98; // r8d
int v99; // r14d
int v100; // ebx
unsigned int v101; // r13d
int v102; // r12d
unsigned int v103; // ebp
int v104; // r10d
int v105; // eax
int v106; // eax
int v107; // ebp
int v108; // r12d
long long v109; // rdi
int v110; // eax
long long v111; // rdi
int v112; // eax
int v113; // r11d
int v114; // r13d
int v115; // edx
int v116; // ecx
int v117; // esi
int v118; // r9d
int v119; // r15d
int v120; // r11d
int v121; // r14d
int v122; // ebx
int v123; // ebp
unsigned int v124; // r12d
int v125; // r10d
unsigned int v126; // r8d
int v127; // eax
int v128; // eax
int v129; // ebp
int ii; // r12d
long long v131; // rdi
int v132; // eax
int v133; // eax
int v134; // r11d
int v135; // r9d
int v136; // r8d
int v137; // r15d
int v138; // ebx
unsigned int v139; // r14d
int v140; // r12d
unsigned int v141; // ebp
int v142; // r10d
int v143; // eax
int v144; // eax
int v145; // ebp
int v146; // r12d
long long v147; // rdi
int v148; // eax
long long v149; // rdi
int v150; // eax
int v152; // [rsp+Ch] [rbp-7Ch]
unsigned int v153; // [rsp+Ch] [rbp-7Ch]
int v154; // [rsp+Ch] [rbp-7Ch]
int v155; // [rsp+Ch] [rbp-7Ch]
int v156; // [rsp+Ch] [rbp-7Ch]
int v157; // [rsp+Ch] [rbp-7Ch]
int v158; // [rsp+Ch] [rbp-7Ch]
int v159; // [rsp+Ch] [rbp-7Ch]
int v160; // [rsp+Ch] [rbp-7Ch]
int v161; // [rsp+10h] [rbp-78h]
int v162; // [rsp+10h] [rbp-78h]
int v163; // [rsp+14h] [rbp-74h]
int v164; // [rsp+14h] [rbp-74h]
int v165; // [rsp+14h] [rbp-74h]
int v166; // [rsp+14h] [rbp-74h]
int v167; // [rsp+14h] [rbp-74h]
int v168; // [rsp+14h] [rbp-74h]
int v169; // [rsp+14h] [rbp-74h]
int v170; // [rsp+14h] [rbp-74h]
int v171; // [rsp+14h] [rbp-74h]
int v172; // [rsp+14h] [rbp-74h]
int v173; // [rsp+18h] [rbp-70h]
int v174; // [rsp+1Ch] [rbp-6Ch]
int v175; // [rsp+20h] [rbp-68h]
int v176; // [rsp+24h] [rbp-64h]
unsigned int v177; // [rsp+24h] [rbp-64h]
int v178; // [rsp+24h] [rbp-64h]
int v179; // [rsp+24h] [rbp-64h]
int v180; // [rsp+24h] [rbp-64h]
int v181; // [rsp+24h] [rbp-64h]
int v182; // [rsp+24h] [rbp-64h]
int v183; // [rsp+24h] [rbp-64h]
unsigned int v184; // [rsp+24h] [rbp-64h]
int v185; // [rsp+24h] [rbp-64h]
int v186; // [rsp+24h] [rbp-64h]
int v187; // [rsp+24h] [rbp-64h]
int i; // [rsp+28h] [rbp-60h]
unsigned int v189; // [rsp+2Ch] [rbp-5Ch]
unsigned int v191; // [rsp+34h] [rbp-54h]
int v192; // [rsp+34h] [rbp-54h]
int v193; // [rsp+34h] [rbp-54h]
int v194; // [rsp+34h] [rbp-54h]
int v195; // [rsp+34h] [rbp-54h]
int v196; // [rsp+34h] [rbp-54h]
int v197; // [rsp+34h] [rbp-54h]
int v198; // [rsp+34h] [rbp-54h]
int v199; // [rsp+34h] [rbp-54h]
int v200; // [rsp+34h] [rbp-54h]
int v201; // [rsp+34h] [rbp-54h]
int v202; // [rsp+34h] [rbp-54h]
int v203; // [rsp+34h] [rbp-54h]
int v204; // [rsp+34h] [rbp-54h]
int v205; // [rsp+34h] [rbp-54h]
int v206; // [rsp+34h] [rbp-54h]
int v207; // [rsp+34h] [rbp-54h]
int v208; // [rsp+34h] [rbp-54h]
int v209; // [rsp+34h] [rbp-54h]
int v210; // [rsp+34h] [rbp-54h]
int v211; // [rsp+34h] [rbp-54h]
int v212; // [rsp+34h] [rbp-54h]
int v213; // [rsp+34h] [rbp-54h]
int v214; // [rsp+34h] [rbp-54h]
int v215; // [rsp+34h] [rbp-54h]
int v216; // [rsp+38h] [rbp-50h]
int v217; // [rsp+38h] [rbp-50h]
int v218; // [rsp+38h] [rbp-50h]
int v219; // [rsp+38h] [rbp-50h]
int v220; // [rsp+38h] [rbp-50h]
int v221; // [rsp+38h] [rbp-50h]
int v222; // [rsp+38h] [rbp-50h]
int v223; // [rsp+38h] [rbp-50h]
int v224; // [rsp+38h] [rbp-50h]
unsigned int v225; // [rsp+38h] [rbp-50h]
int v226; // [rsp+38h] [rbp-50h]
int v227; // [rsp+38h] [rbp-50h]
unsigned int v228; // [rsp+38h] [rbp-50h]
int v229; // [rsp+38h] [rbp-50h]
int v230; // [rsp+38h] [rbp-50h]
int v231; // [rsp+38h] [rbp-50h]
int v232; // [rsp+38h] [rbp-50h]
int v233; // [rsp+38h] [rbp-50h]
int v234; // [rsp+38h] [rbp-50h]
int v235; // [rsp+38h] [rbp-50h]
int v236; // [rsp+38h] [rbp-50h]
int v237; // [rsp+38h] [rbp-50h]
int v238; // [rsp+3Ch] [rbp-4Ch]
unsigned int v239; // [rsp+3Ch] [rbp-4Ch]
int v240; // [rsp+3Ch] [rbp-4Ch]
int v241; // [rsp+3Ch] [rbp-4Ch]
int v242; // [rsp+3Ch] [rbp-4Ch]
int v243; // [rsp+3Ch] [rbp-4Ch]
int v244; // [rsp+3Ch] [rbp-4Ch]
int v245; // [rsp+3Ch] [rbp-4Ch]
int v246; // [rsp+3Ch] [rbp-4Ch]
int v247; // [rsp+3Ch] [rbp-4Ch]
int v248; // [rsp+3Ch] [rbp-4Ch]
int v249; // [rsp+3Ch] [rbp-4Ch]
int v250; // [rsp+3Ch] [rbp-4Ch]
int v251; // [rsp+3Ch] [rbp-4Ch]
int v252; // [rsp+3Ch] [rbp-4Ch]
int v253; // [rsp+3Ch] [rbp-4Ch]
int v254; // [rsp+3Ch] [rbp-4Ch]
int v255; // [rsp+3Ch] [rbp-4Ch]
int v256; // [rsp+3Ch] [rbp-4Ch]
int v257; // [rsp+3Ch] [rbp-4Ch]
unsigned int v258; // [rsp+3Ch] [rbp-4Ch]
int v259; // [rsp+3Ch] [rbp-4Ch]
int v260; // [rsp+3Ch] [rbp-4Ch]
int v261; // [rsp+3Ch] [rbp-4Ch]
int v262; // [rsp+3Ch] [rbp-4Ch]
int v263; // [rsp+3Ch] [rbp-4Ch]
int v264; // [rsp+3Ch] [rbp-4Ch]
int v265; // [rsp+40h] [rbp-48h]
int v266; // [rsp+40h] [rbp-48h]
int v267; // [rsp+40h] [rbp-48h]
int v268; // [rsp+40h] [rbp-48h]
int v269; // [rsp+40h] [rbp-48h]
int v270; // [rsp+40h] [rbp-48h]
int v271; // [rsp+40h] [rbp-48h]
int v272; // [rsp+40h] [rbp-48h]
int v273; // [rsp+40h] [rbp-48h]
int v274; // [rsp+40h] [rbp-48h]
int v275; // [rsp+40h] [rbp-48h]
int v276; // [rsp+40h] [rbp-48h]
int v277; // [rsp+40h] [rbp-48h]
int v278; // [rsp+40h] [rbp-48h]
int v279; // [rsp+40h] [rbp-48h]
int v280; // [rsp+40h] [rbp-48h]
int v281; // [rsp+40h] [rbp-48h]
int v282; // [rsp+40h] [rbp-48h]
int v283; // [rsp+40h] [rbp-48h]
int v284; // [rsp+40h] [rbp-48h]
int v285; // [rsp+40h] [rbp-48h]
int v286; // [rsp+40h] [rbp-48h]
int v287; // [rsp+40h] [rbp-48h]
int v288; // [rsp+40h] [rbp-48h]
int v289; // [rsp+44h] [rbp-44h]
int v290; // [rsp+44h] [rbp-44h]
int v291; // [rsp+44h] [rbp-44h]
int v292; // [rsp+44h] [rbp-44h]
int v293; // [rsp+44h] [rbp-44h]
int v294; // [rsp+44h] [rbp-44h]
int v295; // [rsp+44h] [rbp-44h]
int v296; // [rsp+44h] [rbp-44h]
int v297; // [rsp+44h] [rbp-44h]
int v298; // [rsp+44h] [rbp-44h]
int v299; // [rsp+44h] [rbp-44h]
int v300; // [rsp+44h] [rbp-44h]
int v301; // [rsp+44h] [rbp-44h]
int v302; // [rsp+44h] [rbp-44h]
int v303; // [rsp+44h] [rbp-44h]
int v304; // [rsp+44h] [rbp-44h]
int v305; // [rsp+44h] [rbp-44h]
int v306; // [rsp+44h] [rbp-44h]
int v307; // [rsp+44h] [rbp-44h]
int v308; // [rsp+44h] [rbp-44h]
int v309; // [rsp+44h] [rbp-44h]
int v310; // [rsp+48h] [rbp-40h]
int v311; // [rsp+48h] [rbp-40h]
int v312; // [rsp+48h] [rbp-40h]
int v313; // [rsp+48h] [rbp-40h]
int v314; // [rsp+48h] [rbp-40h]
int v315; // [rsp+48h] [rbp-40h]
int v316; // [rsp+48h] [rbp-40h]
int v317; // [rsp+48h] [rbp-40h]
int v318; // [rsp+48h] [rbp-40h]
int v319; // [rsp+48h] [rbp-40h]
int v320; // [rsp+48h] [rbp-40h]
int v321; // [rsp+48h] [rbp-40h]
int v322; // [rsp+4Ch] [rbp-3Ch]
int v323; // [rsp+4Ch] [rbp-3Ch]
int v324; // [rsp+4Ch] [rbp-3Ch]
v189 = 0;
if ( a1 > 0 )
{
v174 = 0;
v173 = 1;
for ( i = a1 - 1; ; --i )
{
if ( i > 1 )
{
v175 = 0;
v152 = i - 1;
v1 = i - 1;
v161 = 0;
v163 = 1;
if ( i - 1 > 1 )
{
LABEL_5:
v2 = 0;
v3 = 0;
v4 = 1;
v176 = v1 - 1;
for ( j = v1 - 1; ; --j )
{
if ( j > 1 )
{
v6 = 0;
v7 = 0;
v8 = 0;
v9 = j - 1;
v10 = 1;
if ( j - 1 > 1 )
{
LABEL_8:
--v9;
v11 = 0;
v12 = 0;
v13 = 1;
v14 = v9;
if ( v9 <= 1 )
goto LABEL_13;
while ( 1 )
{
v322 = v13;
++v12;
v310 = v6;
v289 = j;
v238 = v3;
v216 = v7;
v191 = v14;
v15 = func0_part_0(v14);
v14 = v191;
v7 = v216;
v3 = v238;
j = v289;
v6 = v310;
v11 += v322 * v15;
while ( 1 )
{
if ( v12 == 1 )
{
v13 = 1;
}
else
{
v311 = v6;
v290 = j;
v239 = v14;
v217 = v3;
v192 = v7;
v16 = func0_part_0(v12);
v7 = v192;
v3 = v217;
v14 = v239;
v13 = v16;
j = v290;
v6 = v311;
}
if ( (int)--v14 > 1 )
break;
LABEL_13:
v11 += v13;
++v12;
if ( !v14 )
{
++v8;
v7 += v10 * v11;
goto LABEL_15;
}
}
}
}
while ( 1 )
{
v7 += v10;
++v8;
if ( !v9 )
break;
--v9;
LABEL_15:
if ( v8 == 1 )
{
v10 = 1;
}
else
{
v10 = 0;
v17 = 0;
for ( k = 1; ; k = 1 )
{
v19 = (unsigned int)(v6 - v17);
if ( (int)v19 > 1 )
{
LABEL_18:
v291 = v6;
v265 = j;
v218 = v3;
v193 = v7;
v20 = func0_part_0(v19);
v6 = v291;
j = v265;
k *= v20;
v3 = v218;
v7 = v193;
}
++v17;
v10 += k;
if ( v8 == v17 )
break;
while ( v17 > 1 )
{
v292 = v6;
v266 = j;
v219 = v3;
v194 = v7;
v21 = func0_part_0((unsigned int)v17);
v6 = v292;
v7 = v194;
v3 = v219;
k = v21;
j = v266;
v19 = (unsigned int)(v292 - v17);
if ( (int)v19 > 1 )
goto LABEL_18;
++v17;
v10 += v21;
if ( v8 == v17 )
goto LABEL_23;
}
}
}
LABEL_23:
++v6;
if ( v9 > 1 )
goto LABEL_8;
}
v4 *= v7;
}
v2 += v4;
v22 = v3 + 1;
if ( v152 == v3 + 1 )
{
++v161;
v175 += v163 * v2;
goto LABEL_52;
}
if ( v22 <= 1 )
{
v4 = 1;
}
else
{
v23 = v3;
v24 = 0;
v4 = 0;
v25 = 0;
v26 = 1;
while ( 1 )
{
if ( v23 > 1 )
{
v27 = v23 - 1;
v28 = 0;
v29 = 0;
v30 = 1;
if ( v23 - 1 > 1 )
{
LABEL_31:
v323 = j;
++v29;
v312 = v22;
v267 = v30;
v240 = v23;
v220 = v24;
v195 = v3;
v31 = func0_part_0(v27);
v3 = v195;
v24 = v220;
v23 = v240;
v22 = v312;
j = v323;
v28 += v267 * v31;
goto LABEL_32;
}
while ( 1 )
{
v28 += v30;
++v29;
if ( !v27 )
break;
LABEL_32:
if ( v29 == 1 )
{
v30 = 1;
}
else
{
v313 = j;
v293 = v22;
v241 = v23;
v221 = v24;
v196 = v3;
v32 = func0_part_0(v29);
v3 = v196;
v24 = v221;
v23 = v241;
v30 = v32;
v22 = v293;
j = v313;
}
if ( (int)--v27 > 1 )
goto LABEL_31;
}
v26 *= v28;
}
v4 += v26;
if ( v3 == v25 )
break;
if ( v25 + 1 <= 1 )
{
v26 = 1;
}
else
{
v26 = 0;
v33 = 0;
v34 = 1;
while ( 1 )
{
v35 = (unsigned int)(v24 - v33);
if ( (int)v35 > 1 )
{
v314 = j;
v294 = v22;
v242 = v23;
v222 = v24;
v197 = v3;
v36 = func0_part_0(v35);
j = v314;
v22 = v294;
v34 *= v36;
v23 = v242;
v24 = v222;
v3 = v197;
}
v26 += v34;
v37 = (unsigned int)(v33 + 1);
if ( v33 == v25 )
break;
if ( (int)v37 <= 1 )
{
v34 = 1;
++v33;
}
else
{
v324 = j;
v315 = v22;
v268 = v23;
v243 = v24;
v223 = v3;
v38 = func0_part_0(v37);
v3 = v223;
v24 = v243;
v23 = v268;
v34 = v38;
v22 = v315;
++v33;
j = v324;
}
}
}
++v24;
--v23;
++v25;
}
}
v3 = v22;
}
}
while ( 1 )
{
++v161;
v175 += v163;
if ( !v152 )
break;
v176 = v152 - 1;
LABEL_52:
if ( v161 == 1 )
{
v163 = 1;
}
else
{
v39 = v161 - 1;
v40 = 0;
v41 = 0;
v42 = 1;
while ( 1 )
{
if ( v39 > 1 )
{
v43 = 0;
v44 = 0;
v45 = 0;
v46 = v39 - 1;
v47 = 1;
if ( (unsigned int)(v39 - 1) > 1 )
{
LABEL_56:
--v46;
v48 = 0;
v49 = 0;
v50 = 1;
v51 = v46;
if ( v46 <= 1 )
goto LABEL_61;
while ( 1 )
{
v295 = v41;
++v48;
v244 = v50;
v224 = v39;
v198 = v44;
v164 = v43;
v153 = v51;
v52 = func0_part_0(v51);
v51 = v153;
v43 = v164;
v44 = v198;
v39 = v224;
v41 = v295;
v49 += v244 * v52;
while ( 1 )
{
if ( v48 == 1 )
{
v50 = 1;
}
else
{
v269 = v41;
v225 = v51;
v199 = v39;
v165 = v44;
v154 = v43;
v53 = func0_part_0(v48);
v43 = v154;
v44 = v165;
v39 = v199;
v51 = v225;
v50 = v53;
v41 = v269;
}
if ( --v51 > 1 )
break;
LABEL_61:
v49 += v50;
++v48;
if ( !v51 )
{
++v45;
v44 += v47 * v49;
goto LABEL_63;
}
}
}
}
while ( 1 )
{
v44 += v47;
++v45;
if ( !v46 )
break;
--v46;
LABEL_63:
if ( v45 == 1 )
{
v47 = 1;
}
else
{
v47 = 0;
v54 = 0;
for ( m = 1; ; m = 1 )
{
v56 = (unsigned int)(v43 - v54);
if ( (int)v56 > 1 )
{
LABEL_66:
v245 = v41;
v200 = v39;
v166 = v44;
v155 = v43;
v57 = func0_part_0(v56);
v41 = v245;
m *= v57;
v39 = v200;
v44 = v166;
v43 = v155;
}
++v54;
v47 += m;
if ( v45 == v54 )
break;
while ( v54 > 1 )
{
v246 = v41;
v201 = v39;
v167 = v44;
v156 = v43;
v58 = func0_part_0((unsigned int)v54);
v43 = v156;
v44 = v167;
v39 = v201;
m = v58;
v41 = v246;
v56 = (unsigned int)(v156 - v54);
if ( (int)v56 > 1 )
goto LABEL_66;
++v54;
v47 += v58;
if ( v45 == v54 )
goto LABEL_71;
}
}
}
LABEL_71:
++v43;
if ( v46 > 1 )
goto LABEL_56;
}
v42 *= v44;
}
v40 += v42;
v59 = v41 + 1;
if ( v161 == v41 + 1 )
break;
if ( v59 <= 1 )
{
v42 = 1;
}
else
{
v60 = v41;
v61 = 0;
v42 = 0;
v62 = 0;
v63 = 1;
while ( 1 )
{
if ( v60 > 1 )
{
v64 = v60 - 1;
v65 = 0;
v66 = 0;
v67 = 1;
if ( v60 - 1 > 1 )
{
LABEL_79:
v296 = v41;
++v66;
v270 = v67;
v247 = v59;
v202 = v61;
v168 = v60;
v157 = v39;
v68 = func0_part_0(v64);
v39 = v157;
v60 = v168;
v61 = v202;
v59 = v247;
v41 = v296;
v65 += v270 * v68;
goto LABEL_80;
}
while ( 1 )
{
v65 += v67;
++v66;
if ( !v64 )
break;
LABEL_80:
if ( v66 == 1 )
{
v67 = 1;
}
else
{
v271 = v41;
v248 = v59;
v203 = v61;
v169 = v60;
v158 = v39;
v69 = func0_part_0(v66);
v39 = v158;
v60 = v169;
v61 = v203;
v67 = v69;
v59 = v248;
v41 = v271;
}
if ( (int)--v64 > 1 )
goto LABEL_79;
}
v63 *= v65;
}
v42 += v63;
if ( v41 == v62 )
break;
if ( v62 + 1 <= 1 )
{
v63 = 1;
}
else
{
v63 = 0;
v70 = 0;
v71 = 1;
while ( 1 )
{
v72 = (unsigned int)(v61 - v70);
if ( (int)v72 > 1 )
{
v272 = v41;
v249 = v59;
v204 = v61;
v170 = v60;
v159 = v39;
v73 = func0_part_0(v72);
v41 = v272;
v59 = v249;
v71 *= v73;
v61 = v204;
v60 = v170;
v39 = v159;
}
v63 += v71;
v74 = (unsigned int)(v70 + 1);
if ( v62 == v70 )
break;
if ( (int)v74 <= 1 )
{
v71 = 1;
++v70;
}
else
{
v297 = v41;
v273 = v59;
v226 = v61;
v205 = v60;
v171 = v39;
v75 = func0_part_0(v74);
v39 = v171;
v60 = v205;
v61 = v226;
v71 = v75;
v59 = v273;
++v70;
v41 = v297;
}
}
}
++v61;
--v60;
++v62;
}
}
--v39;
v41 = v59;
}
v163 = v40;
}
v152 = v176;
v1 = v176;
if ( v176 > 1 )
goto LABEL_5;
}
v173 *= v175;
}
v189 += v173;
if ( a1 == v174 + 1 )
break;
if ( v174 + 1 <= 1 )
{
v173 = 1;
}
else
{
v173 = 0;
v160 = 0;
v162 = v174;
v172 = 1;
while ( 1 )
{
if ( v162 > 1 )
{
v76 = v162 - 1;
v77 = 0;
v78 = 0;
v79 = 1;
while ( 1 )
{
if ( v76 > 1 )
{
v80 = 0;
v81 = 0;
v82 = 0;
v83 = v76 - 1;
v84 = 1;
if ( v76 - 1 > 1 )
{
LABEL_110:
--v83;
v85 = 0;
v86 = 0;
v87 = 1;
v88 = v83;
if ( v83 <= 1 )
goto LABEL_115;
while ( 1 )
{
v316 = v78;
++v85;
v298 = v80;
v250 = v76;
v227 = v81;
v206 = v87;
v177 = v88;
v89 = func0_part_0(v88);
v88 = v177;
v81 = v227;
v76 = v250;
v80 = v298;
v78 = v316;
v86 += v206 * v89;
while ( 1 )
{
if ( v85 == 1 )
{
v87 = 1;
}
else
{
v299 = v78;
v274 = v80;
v228 = v88;
v207 = v76;
v178 = v81;
v90 = func0_part_0(v85);
v81 = v178;
v76 = v207;
v88 = v228;
v87 = v90;
v80 = v274;
v78 = v299;
}
if ( (int)--v88 > 1 )
break;
LABEL_115:
v86 += v87;
++v85;
if ( !v88 )
{
++v82;
v81 += v84 * v86;
goto LABEL_117;
}
}
}
}
while ( 1 )
{
v81 += v84;
++v82;
if ( !v83 )
break;
--v83;
LABEL_117:
if ( v82 == 1 )
{
v84 = 1;
}
else
{
v84 = 0;
v91 = 0;
for ( n = 1; ; n = 1 )
{
v93 = (unsigned int)(v80 - v91);
if ( (int)v93 > 1 )
{
LABEL_120:
v275 = v78;
v251 = v80;
v208 = v76;
v179 = v81;
v94 = func0_part_0(v93);
v78 = v275;
v80 = v251;
n *= v94;
v76 = v208;
v81 = v179;
}
++v91;
v84 += n;
if ( v82 == v91 )
break;
while ( v91 > 1 )
{
v276 = v78;
v252 = v80;
v209 = v76;
v180 = v81;
v95 = func0_part_0((unsigned int)v91);
v80 = v252;
v81 = v180;
v76 = v209;
n = v95;
v78 = v276;
v93 = (unsigned int)(v252 - v91);
if ( (int)v93 > 1 )
goto LABEL_120;
++v91;
v84 += v95;
if ( v82 == v91 )
goto LABEL_125;
}
}
}
LABEL_125:
++v80;
if ( v83 > 1 )
goto LABEL_110;
}
v79 *= v81;
}
v77 += v79;
v96 = v78 + 1;
if ( v162 == v78 + 1 )
break;
if ( v96 <= 1 )
{
v79 = 1;
}
else
{
v97 = v78;
v98 = 0;
v79 = 0;
v99 = 0;
v100 = 1;
while ( 1 )
{
if ( v97 > 1 )
{
v101 = v97 - 1;
v102 = 0;
v103 = 0;
v104 = 1;
if ( v97 - 1 > 1 )
{
LABEL_133:
v317 = v78;
++v103;
v300 = v98;
v277 = v97;
v253 = v96;
v210 = v76;
v181 = v104;
v105 = func0_part_0(v101);
v76 = v210;
v96 = v253;
v97 = v277;
v98 = v300;
v78 = v317;
v102 += v181 * v105;
goto LABEL_134;
}
while ( 1 )
{
v102 += v104;
++v103;
if ( !v101 )
break;
LABEL_134:
if ( v103 == 1 )
{
v104 = 1;
}
else
{
v301 = v78;
v278 = v98;
v254 = v97;
v229 = v96;
v182 = v76;
v106 = func0_part_0(v103);
v76 = v182;
v96 = v229;
v97 = v254;
v104 = v106;
v98 = v278;
v78 = v301;
}
if ( (int)--v101 > 1 )
goto LABEL_133;
}
v100 *= v102;
}
v79 += v100;
if ( v78 == v99 )
break;
if ( v99 + 1 <= 1 )
{
v100 = 1;
}
else
{
v100 = 0;
v107 = 0;
v108 = 1;
while ( 1 )
{
v109 = (unsigned int)(v98 - v107);
if ( (int)v109 > 1 )
{
v302 = v78;
v279 = v98;
v255 = v97;
v230 = v96;
v183 = v76;
v110 = func0_part_0(v109);
v78 = v302;
v98 = v279;
v108 *= v110;
v97 = v255;
v96 = v230;
v76 = v183;
}
v100 += v108;
v111 = (unsigned int)(v107 + 1);
if ( v107 == v99 )
break;
if ( (int)v111 <= 1 )
{
v108 = 1;
++v107;
}
else
{
v318 = v78;
v303 = v98;
v280 = v97;
v256 = v96;
v211 = v76;
v112 = func0_part_0(v111);
v76 = v211;
v96 = v256;
v108 = v112;
v97 = v280;
v98 = v303;
++v107;
v78 = v318;
}
}
}
++v98;
--v97;
++v99;
}
}
--v76;
v78 = v96;
}
v172 *= v77;
}
v173 += v172;
v113 = v160 + 1;
if ( v160 == v174 )
break;
if ( v113 <= 1 )
{
v172 = 1;
}
else
{
v114 = 0;
v115 = 0;
v116 = v160;
v117 = 1;
while ( 1 )
{
if ( v116 > 1 )
{
v118 = 0;
v119 = 0;
v120 = 0;
v121 = v116 - 1;
v122 = 1;
if ( v116 - 1 > 1 )
{
LABEL_157:
--v121;
v123 = 0;
v124 = 0;
v125 = 1;
v126 = v121;
if ( v121 <= 1 )
goto LABEL_162;
while ( 1 )
{
v319 = v115;
++v124;
v304 = v118;
v281 = v116;
v257 = v125;
v231 = v120;
v184 = v126;
v127 = func0_part_0(v126);
v126 = v184;
v120 = v231;
v116 = v281;
v118 = v304;
v115 = v319;
v123 += v257 * v127;
while ( 1 )
{
if ( v124 == 1 )
{
v125 = 1;
}
else
{
v305 = v115;
v282 = v118;
v258 = v126;
v232 = v116;
v212 = v120;
v128 = func0_part_0(v124);
v120 = v212;
v116 = v232;
v126 = v258;
v125 = v128;
v118 = v282;
v115 = v305;
}
if ( (int)--v126 > 1 )
break;
LABEL_162:
v123 += v125;
++v124;
if ( !v126 )
{
++v119;
v120 += v122 * v123;
goto LABEL_164;
}
}
}
}
while ( 1 )
{
v120 += v122;
++v119;
if ( !v121 )
break;
--v121;
LABEL_164:
if ( v119 == 1 )
{
v122 = 1;
}
else
{
v122 = 0;
v129 = 0;
for ( ii = 1; ; ii = 1 )
{
v131 = (unsigned int)(v118 - v129);
if ( (int)v131 > 1 )
{
LABEL_167:
v283 = v115;
v259 = v118;
v233 = v116;
v213 = v120;
v132 = func0_part_0(v131);
v115 = v283;
v118 = v259;
ii *= v132;
v116 = v233;
v120 = v213;
}
++v129;
v122 += ii;
if ( v119 == v129 )
break;
while ( v129 > 1 )
{
v284 = v115;
v260 = v118;
v234 = v116;
v214 = v120;
v133 = func0_part_0((unsigned int)v129);
v118 = v260;
v120 = v214;
v116 = v234;
ii = v133;
v115 = v284;
v131 = (unsigned int)(v260 - v129);
if ( (int)v131 > 1 )
goto LABEL_167;
++v129;
v122 += v133;
if ( v119 == v129 )
goto LABEL_172;
}
}
}
LABEL_172:
++v118;
if ( v121 > 1 )
goto LABEL_157;
}
v117 *= v120;
}
v114 += v117;
v134 = v115 + 1;
if ( v160 == v115 )
break;
if ( v134 <= 1 )
{
v117 = 1;
}
else
{
v135 = v115;
v136 = 0;
v117 = 0;
v137 = 0;
v138 = 1;
while ( 1 )
{
if ( v135 > 1 )
{
v139 = v135 - 1;
v140 = 0;
v141 = 0;
v142 = 1;
if ( v135 - 1 > 1 )
{
LABEL_180:
v320 = v115;
++v141;
v306 = v136;
v285 = v135;
v261 = v116;
v235 = v142;
v185 = v134;
v143 = func0_part_0(v139);
v134 = v185;
v116 = v261;
v135 = v285;
v136 = v306;
v115 = v320;
v140 += v235 * v143;
goto LABEL_181;
}
while ( 1 )
{
v140 += v142;
++v141;
if ( !v139 )
break;
LABEL_181:
if ( v141 == 1 )
{
v142 = 1;
}
else
{
v307 = v115;
v286 = v136;
v262 = v135;
v236 = v116;
v186 = v134;
v144 = func0_part_0(v141);
v134 = v186;
v116 = v236;
v135 = v262;
v142 = v144;
v136 = v286;
v115 = v307;
}
if ( (int)--v139 > 1 )
goto LABEL_180;
}
v138 *= v140;
}
v117 += v138;
if ( v137 == v115 )
break;
if ( v137 + 1 <= 1 )
{
v138 = 1;
}
else
{
v138 = 0;
v145 = 0;
v146 = 1;
while ( 1 )
{
v147 = (unsigned int)(v136 - v145);
if ( (int)v147 > 1 )
{
v308 = v115;
v287 = v136;
v263 = v135;
v237 = v116;
v187 = v134;
v148 = func0_part_0(v147);
v115 = v308;
v136 = v287;
v146 *= v148;
v135 = v263;
v116 = v237;
v134 = v187;
}
v138 += v146;
v149 = (unsigned int)(v145 + 1);
if ( v145 == v137 )
break;
if ( (int)v149 <= 1 )
{
v146 = 1;
++v145;
}
else
{
v321 = v115;
v309 = v136;
v288 = v135;
v264 = v116;
v215 = v134;
v150 = func0_part_0(v149);
v134 = v215;
v116 = v264;
v146 = v150;
v135 = v288;
v136 = v309;
++v145;
v115 = v321;
}
}
}
++v136;
--v135;
++v137;
}
}
--v116;
v115 = v134;
}
v113 = v160 + 1;
v172 = v114;
}
--v162;
v160 = v113;
}
}
++v174;
}
}
return v189;
} | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RSP + 0x30],EDI
MOV dword ptr [RSP + 0x2c],0x0
TEST EDI,EDI
JLE 0x001024a2
MOV EAX,EDI
MOV dword ptr [RSP + 0x1c],0x0
SUB EAX,0x1
MOV dword ptr [RSP + 0x18],0x1
MOV dword ptr [RSP + 0x28],EAX
LAB_0010122b:
MOV EAX,dword ptr [RSP + 0x28]
CMP EAX,0x1
JLE 0x00101b4f
SUB EAX,0x1
MOV dword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0xc],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x10],0x0
MOV dword ptr [RSP + 0x14],0x1
CMP EAX,0x1
JLE 0x00101b29
LAB_00101264:
SUB EAX,0x1
XOR ESI,ESI
XOR EDX,EDX
MOV R15D,0x1
MOV dword ptr [RSP + 0x24],EAX
MOV ECX,EAX
LAB_00101277:
CMP ECX,0x1
JLE 0x0010146a
LEA R8D,[RCX + -0x1]
XOR R9D,R9D
XOR R11D,R11D
XOR R14D,R14D
MOV R13D,R8D
MOV EBX,0x1
CMP R13D,0x1
JLE 0x00101456
LAB_0010129f:
SUB R13D,0x1
XOR EBP,EBP
XOR R12D,R12D
MOV R10D,0x1
MOV R8D,R13D
CMP R8D,0x1
JLE 0x00101370
LAB_001012bb:
MOV EDI,R8D
MOV dword ptr [RSP + 0x4c],R10D
ADD R12D,0x1
MOV dword ptr [RSP + 0x48],R9D
MOV dword ptr [RSP + 0x44],ECX
MOV dword ptr [RSP + 0x40],ESI
MOV dword ptr [RSP + 0x3c],EDX
MOV dword ptr [RSP + 0x38],R11D
MOV dword ptr [RSP + 0x34],R8D
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x4c]
MOV R8D,dword ptr [RSP + 0x34]
MOV R11D,dword ptr [RSP + 0x38]
MOV EDX,dword ptr [RSP + 0x3c]
IMUL EAX,R10D
MOV ESI,dword ptr [RSP + 0x40]
MOV ECX,dword ptr [RSP + 0x44]
MOV R9D,dword ptr [RSP + 0x48]
ADD EBP,EAX
NOP dword ptr [RAX]
LAB_00101310:
CMP R12D,0x1
JZ 0x00102547
MOV EDI,R12D
MOV dword ptr [RSP + 0x48],R9D
MOV dword ptr [RSP + 0x44],ECX
MOV dword ptr [RSP + 0x40],ESI
MOV dword ptr [RSP + 0x3c],R8D
MOV dword ptr [RSP + 0x38],EDX
MOV dword ptr [RSP + 0x34],R11D
CALL 0x001011f0
MOV R11D,dword ptr [RSP + 0x34]
MOV EDX,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x3c]
MOV ESI,dword ptr [RSP + 0x40]
MOV R10D,EAX
MOV ECX,dword ptr [RSP + 0x44]
MOV R9D,dword ptr [RSP + 0x48]
LAB_0010135b:
SUB R8D,0x1
CMP R8D,0x1
JG 0x001012bb
NOP dword ptr [RAX]
LAB_00101370:
ADD EBP,R10D
ADD R12D,0x1
TEST R8D,R8D
JNZ 0x00101310
IMUL EBP,EBX
ADD R14D,0x1
ADD R11D,EBP
LAB_00101386:
CMP R14D,0x1
JZ 0x0010253d
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_0010139a:
MOV EDI,R9D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x001013e0
LAB_001013a4:
MOV dword ptr [RSP + 0x44],R9D
MOV dword ptr [RSP + 0x40],ECX
MOV dword ptr [RSP + 0x3c],ESI
MOV dword ptr [RSP + 0x38],EDX
MOV dword ptr [RSP + 0x34],R11D
CALL 0x001011f0
MOV R9D,dword ptr [RSP + 0x44]
MOV ECX,dword ptr [RSP + 0x40]
IMUL R12D,EAX
MOV ESI,dword ptr [RSP + 0x3c]
MOV EDX,dword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x34]
NOP dword ptr [RAX]
LAB_001013e0:
ADD EBP,0x1
ADD EBX,R12D
CMP R14D,EBP
JZ 0x00101448
LAB_001013eb:
CMP EBP,0x1
JLE 0x00101690
MOV EDI,EBP
MOV dword ptr [RSP + 0x44],R9D
MOV dword ptr [RSP + 0x40],ECX
MOV dword ptr [RSP + 0x3c],ESI
MOV dword ptr [RSP + 0x38],EDX
MOV dword ptr [RSP + 0x34],R11D
CALL 0x001011f0
MOV R9D,dword ptr [RSP + 0x44]
MOV R11D,dword ptr [RSP + 0x34]
MOV EDX,dword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x3c]
MOV R12D,EAX
MOV EDI,R9D
MOV ECX,dword ptr [RSP + 0x40]
SUB EDI,EBP
CMP EDI,0x1
JG 0x001013a4
ADD EBP,0x1
ADD EBX,R12D
CMP R14D,EBP
JNZ 0x001013eb
NOP dword ptr [RAX + RAX*0x1]
LAB_00101448:
ADD R9D,0x1
CMP R13D,0x1
JG 0x0010129f
LAB_00101456:
ADD R11D,EBX
ADD R14D,0x1
TEST R13D,R13D
JNZ 0x00102529
IMUL R15D,R11D
LAB_0010146a:
ADD ESI,R15D
LEA R11D,[RDX + 0x1]
CMP dword ptr [RSP + 0xc],R11D
JZ 0x001016b0
CMP R11D,0x1
JLE 0x00101670
MOV R9D,EDX
XOR R8D,R8D
XOR R15D,R15D
XOR R14D,R14D
MOV EBX,0x1
LAB_00101497:
CMP R9D,0x1
JLE 0x0010157f
LEA R13D,[R9 + -0x1]
XOR R12D,R12D
XOR EBP,EBP
MOV R10D,0x1
CMP R13D,0x1
JLE 0x00101570
LAB_001014ba:
MOV EDI,R13D
MOV dword ptr [RSP + 0x4c],ECX
ADD EBP,0x1
MOV dword ptr [RSP + 0x48],R11D
MOV dword ptr [RSP + 0x44],ESI
MOV dword ptr [RSP + 0x40],R10D
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],R8D
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x34]
MOV R8D,dword ptr [RSP + 0x38]
MOV R9D,dword ptr [RSP + 0x3c]
IMUL EAX,R10D
MOV ESI,dword ptr [RSP + 0x44]
MOV R11D,dword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0x4c]
ADD R12D,EAX
NOP dword ptr [RAX]
LAB_00101510:
CMP EBP,0x1
JZ 0x00102532
MOV EDI,EBP
MOV dword ptr [RSP + 0x48],ECX
MOV dword ptr [RSP + 0x44],R11D
MOV dword ptr [RSP + 0x40],ESI
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],R8D
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x34]
MOV R8D,dword ptr [RSP + 0x38]
MOV R9D,dword ptr [RSP + 0x3c]
MOV ESI,dword ptr [RSP + 0x40]
MOV R10D,EAX
MOV R11D,dword ptr [RSP + 0x44]
MOV ECX,dword ptr [RSP + 0x48]
LAB_00101559:
SUB R13D,0x1
CMP R13D,0x1
JG 0x001014ba
NOP word ptr [RAX + RAX*0x1]
LAB_00101570:
ADD R12D,R10D
ADD EBP,0x1
TEST R13D,R13D
JNZ 0x00101510
IMUL EBX,R12D
LAB_0010157f:
ADD R15D,EBX
LEA R13D,[R14 + 0x1]
CMP EDX,R14D
JZ 0x00101680
CMP R13D,0x1
JLE 0x00101658
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_001015a3:
MOV EDI,R8D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x001015f0
MOV dword ptr [RSP + 0x48],ECX
MOV dword ptr [RSP + 0x44],R11D
MOV dword ptr [RSP + 0x40],ESI
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],R8D
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x48]
MOV R11D,dword ptr [RSP + 0x44]
IMUL R12D,EAX
MOV ESI,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x3c]
MOV R8D,dword ptr [RSP + 0x38]
MOV EDX,dword ptr [RSP + 0x34]
NOP dword ptr [RAX]
LAB_001015f0:
ADD EBX,R12D
LEA EDI,[RBP + 0x1]
CMP EBP,R14D
JZ 0x00101660
CMP EDI,0x1
JLE 0x001016a0
MOV dword ptr [RSP + 0x4c],ECX
MOV dword ptr [RSP + 0x48],R11D
MOV dword ptr [RSP + 0x44],ESI
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],R8D
MOV dword ptr [RSP + 0x38],EDX
MOV dword ptr [RSP + 0x34],EDI
CALL 0x001011f0
MOV EDI,dword ptr [RSP + 0x34]
MOV EDX,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x3c]
MOV R9D,dword ptr [RSP + 0x40]
MOV R12D,EAX
MOV ESI,dword ptr [RSP + 0x44]
MOV R11D,dword ptr [RSP + 0x48]
MOV EBP,EDI
MOV ECX,dword ptr [RSP + 0x4c]
JMP 0x001015a3
LAB_00101658:
MOV EBX,0x1
NOP dword ptr [RAX]
LAB_00101660:
ADD R8D,0x1
SUB R9D,0x1
MOV R14D,R13D
JMP 0x00101497
LAB_00101670:
MOV R15D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101680:
SUB ECX,0x1
MOV EDX,R11D
JMP 0x00101277
LAB_00101690:
MOV R12D,0x1
JMP 0x0010139a
LAB_001016a0:
MOV R12D,0x1
MOV EBP,EDI
JMP 0x001015a3
LAB_001016b0:
IMUL ESI,dword ptr [RSP + 0x14]
ADD dword ptr [RSP + 0x10],0x1
ADD dword ptr [RSP + 0x20],ESI
LAB_001016be:
MOV EAX,dword ptr [RSP + 0x10]
CMP EAX,0x1
JZ 0x0010251c
LEA ECX,[RAX + -0x1]
XOR ESI,ESI
XOR EDX,EDX
MOV R15D,0x1
LAB_001016d8:
CMP ECX,0x1
JLE 0x001018ca
LEA R8D,[RCX + -0x1]
XOR R9D,R9D
XOR R11D,R11D
XOR R14D,R14D
MOV R13D,R8D
MOV EBX,0x1
CMP R13D,0x1
JBE 0x001018b6
LAB_00101700:
SUB R13D,0x1
XOR R12D,R12D
XOR EBP,EBP
MOV R10D,0x1
MOV R8D,R13D
CMP R8D,0x1
JBE 0x001017d0
LAB_0010171c:
MOV EDI,R8D
MOV dword ptr [RSP + 0x44],EDX
ADD R12D,0x1
MOV dword ptr [RSP + 0x40],ESI
MOV dword ptr [RSP + 0x3c],R10D
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],R11D
MOV dword ptr [RSP + 0x14],R9D
MOV dword ptr [RSP + 0xc],R8D
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x3c]
MOV R8D,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x14]
MOV R11D,dword ptr [RSP + 0x34]
IMUL EAX,R10D
MOV ECX,dword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x44]
ADD EBP,EAX
NOP
LAB_00101770:
CMP R12D,0x1
JZ 0x00102511
MOV EDI,R12D
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],ESI
MOV dword ptr [RSP + 0x38],R8D
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x14],R11D
MOV dword ptr [RSP + 0xc],R9D
CALL 0x001011f0
MOV R9D,dword ptr [RSP + 0xc]
MOV R11D,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x34]
MOV R8D,dword ptr [RSP + 0x38]
MOV R10D,EAX
MOV ESI,dword ptr [RSP + 0x3c]
MOV EDX,dword ptr [RSP + 0x40]
LAB_001017bb:
SUB R8D,0x1
CMP R8D,0x1
JA 0x0010171c
NOP dword ptr [RAX]
LAB_001017d0:
ADD EBP,R10D
ADD R12D,0x1
TEST R8D,R8D
JNZ 0x00101770
IMUL EBP,EBX
ADD R14D,0x1
ADD R11D,EBP
LAB_001017e6:
CMP R14D,0x1
JZ 0x00102507
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_001017fa:
MOV EDI,R9D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x00101840
LAB_00101804:
MOV dword ptr [RSP + 0x3c],EDX
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x14],R11D
MOV dword ptr [RSP + 0xc],R9D
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x3c]
MOV ESI,dword ptr [RSP + 0x38]
IMUL R12D,EAX
MOV ECX,dword ptr [RSP + 0x34]
MOV R11D,dword ptr [RSP + 0x14]
MOV R9D,dword ptr [RSP + 0xc]
NOP dword ptr [RAX]
LAB_00101840:
ADD EBP,0x1
ADD EBX,R12D
CMP R14D,EBP
JZ 0x001018a8
LAB_0010184b:
CMP EBP,0x1
JLE 0x00101af0
MOV EDI,EBP
MOV dword ptr [RSP + 0x3c],EDX
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x14],R11D
MOV dword ptr [RSP + 0xc],R9D
CALL 0x001011f0
MOV R9D,dword ptr [RSP + 0xc]
MOV R11D,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x38]
MOV R12D,EAX
MOV EDI,R9D
MOV EDX,dword ptr [RSP + 0x3c]
SUB EDI,EBP
CMP EDI,0x1
JG 0x00101804
ADD EBP,0x1
ADD EBX,R12D
CMP R14D,EBP
JNZ 0x0010184b
NOP dword ptr [RAX + RAX*0x1]
LAB_001018a8:
ADD R9D,0x1
CMP R13D,0x1
JA 0x00101700
LAB_001018b6:
ADD R11D,EBX
ADD R14D,0x1
TEST R13D,R13D
JNZ 0x001024f3
IMUL R15D,R11D
LAB_001018ca:
ADD ESI,R15D
LEA R11D,[RDX + 0x1]
CMP dword ptr [RSP + 0x10],R11D
JZ 0x00101b10
CMP R11D,0x1
JLE 0x00101ad0
MOV R9D,EDX
XOR R8D,R8D
XOR R15D,R15D
XOR R14D,R14D
MOV EBX,0x1
LAB_001018f7:
CMP R9D,0x1
JLE 0x001019df
LEA R13D,[R9 + -0x1]
XOR R12D,R12D
XOR EBP,EBP
MOV R10D,0x1
CMP R13D,0x1
JLE 0x001019d0
LAB_0010191a:
MOV EDI,R13D
MOV dword ptr [RSP + 0x44],EDX
ADD EBP,0x1
MOV dword ptr [RSP + 0x40],R10D
MOV dword ptr [RSP + 0x3c],R11D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],R8D
MOV dword ptr [RSP + 0x14],R9D
MOV dword ptr [RSP + 0xc],ECX
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x40]
MOV ECX,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x14]
MOV R8D,dword ptr [RSP + 0x34]
IMUL EAX,R10D
MOV ESI,dword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x3c]
MOV EDX,dword ptr [RSP + 0x44]
ADD R12D,EAX
NOP dword ptr [RAX]
LAB_00101970:
CMP EBP,0x1
JZ 0x001024fc
MOV EDI,EBP
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],R11D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],R8D
MOV dword ptr [RSP + 0x14],R9D
MOV dword ptr [RSP + 0xc],ECX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x14]
MOV R8D,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x38]
MOV R10D,EAX
MOV R11D,dword ptr [RSP + 0x3c]
MOV EDX,dword ptr [RSP + 0x40]
LAB_001019b9:
SUB R13D,0x1
CMP R13D,0x1
JG 0x0010191a
NOP word ptr [RAX + RAX*0x1]
LAB_001019d0:
ADD R12D,R10D
ADD EBP,0x1
TEST R13D,R13D
JNZ 0x00101970
IMUL EBX,R12D
LAB_001019df:
ADD R15D,EBX
LEA R13D,[R14 + 0x1]
CMP EDX,R14D
JZ 0x00101ae0
CMP R13D,0x1
JLE 0x00101ab8
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_00101a03:
MOV EDI,R8D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x00101a50
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],R11D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],R8D
MOV dword ptr [RSP + 0x14],R9D
MOV dword ptr [RSP + 0xc],ECX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x40]
MOV R11D,dword ptr [RSP + 0x3c]
IMUL R12D,EAX
MOV ESI,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x34]
MOV R9D,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0xc]
NOP dword ptr [RAX]
LAB_00101a50:
ADD EBX,R12D
LEA EDI,[RBP + 0x1]
CMP R14D,EBP
JZ 0x00101ac0
CMP EDI,0x1
JLE 0x00101b00
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R11D
MOV dword ptr [RSP + 0x3c],ESI
MOV dword ptr [RSP + 0x38],R8D
MOV dword ptr [RSP + 0x34],R9D
MOV dword ptr [RSP + 0x14],ECX
MOV dword ptr [RSP + 0xc],EDI
CALL 0x001011f0
MOV EDI,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x14]
MOV R9D,dword ptr [RSP + 0x34]
MOV R8D,dword ptr [RSP + 0x38]
MOV R12D,EAX
MOV ESI,dword ptr [RSP + 0x3c]
MOV R11D,dword ptr [RSP + 0x40]
MOV EBP,EDI
MOV EDX,dword ptr [RSP + 0x44]
JMP 0x00101a03
LAB_00101ab8:
MOV EBX,0x1
NOP dword ptr [RAX]
LAB_00101ac0:
ADD R8D,0x1
SUB R9D,0x1
MOV R14D,R13D
JMP 0x001018f7
LAB_00101ad0:
MOV R15D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101ae0:
SUB ECX,0x1
MOV EDX,R11D
JMP 0x001016d8
LAB_00101af0:
MOV R12D,0x1
JMP 0x001017fa
LAB_00101b00:
MOV R12D,0x1
MOV EBP,EDI
JMP 0x00101a03
LAB_00101b10:
MOV dword ptr [RSP + 0x14],ESI
LAB_00101b14:
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0xc],EAX
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,0x1
JG 0x00101264
LAB_00101b29:
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x14]
ADD dword ptr [RSP + 0x10],0x1
ADD dword ptr [RSP + 0x20],ECX
TEST EAX,EAX
JNZ 0x00102552
MOV EAX,dword ptr [RSP + 0x18]
IMUL EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x18],EAX
LAB_00101b4f:
MOV EAX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x18]
ADD dword ptr [RSP + 0x2c],ECX
ADD EAX,0x1
MOV dword ptr [RSP + 0x20],EAX
CMP dword ptr [RSP + 0x30],EAX
JZ 0x001024a2
CMP dword ptr [RSP + 0x20],0x1
JLE 0x00102481
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0xc],0x0
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP + 0x14],0x1
LAB_00101b97:
MOV EAX,dword ptr [RSP + 0x10]
CMP EAX,0x1
JLE 0x00101fd9
LEA ECX,[RAX + -0x1]
XOR ESI,ESI
XOR EDX,EDX
MOV R15D,0x1
LAB_00101bb1:
CMP ECX,0x1
JLE 0x00101daa
LEA R8D,[RCX + -0x1]
XOR R9D,R9D
XOR R11D,R11D
XOR R14D,R14D
MOV R13D,R8D
MOV EBX,0x1
CMP R13D,0x1
JLE 0x00101d96
LAB_00101bd9:
SUB R13D,0x1
XOR R12D,R12D
XOR EBP,EBP
MOV R10D,0x1
MOV R8D,R13D
CMP R8D,0x1
JLE 0x00101cb0
LAB_00101bf5:
MOV EDI,R8D
MOV dword ptr [RSP + 0x48],EDX
ADD R12D,0x1
MOV dword ptr [RSP + 0x44],R9D
MOV dword ptr [RSP + 0x40],ESI
MOV dword ptr [RSP + 0x3c],ECX
MOV dword ptr [RSP + 0x38],R11D
MOV dword ptr [RSP + 0x34],R10D
MOV dword ptr [RSP + 0x24],R8D
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x34]
MOV R8D,dword ptr [RSP + 0x24]
MOV R11D,dword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x3c]
IMUL EAX,R10D
MOV ESI,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x44]
MOV EDX,dword ptr [RSP + 0x48]
ADD EBP,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101c50:
CMP R12D,0x1
JZ 0x001024df
MOV EDI,R12D
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],ESI
MOV dword ptr [RSP + 0x38],R8D
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x24],R11D
CALL 0x001011f0
MOV R11D,dword ptr [RSP + 0x24]
MOV ECX,dword ptr [RSP + 0x34]
MOV R8D,dword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x3c]
MOV R10D,EAX
MOV R9D,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x44]
LAB_00101c9b:
SUB R8D,0x1
CMP R8D,0x1
JG 0x00101bf5
NOP dword ptr [RAX]
LAB_00101cb0:
ADD EBP,R10D
ADD R12D,0x1
TEST R8D,R8D
JNZ 0x00101c50
IMUL EBP,EBX
ADD R14D,0x1
ADD R11D,EBP
LAB_00101cc6:
CMP R14D,0x1
JZ 0x001024d5
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_00101cda:
MOV EDI,R9D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x00101d20
LAB_00101ce4:
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x24],R11D
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x3c]
IMUL R12D,EAX
MOV ESI,dword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x34]
MOV R11D,dword ptr [RSP + 0x24]
NOP dword ptr [RAX]
LAB_00101d20:
ADD EBP,0x1
ADD EBX,R12D
CMP R14D,EBP
JZ 0x00101d88
LAB_00101d2b:
CMP EBP,0x1
JLE 0x00102458
MOV EDI,EBP
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x24],R11D
CALL 0x001011f0
MOV R9D,dword ptr [RSP + 0x3c]
MOV R11D,dword ptr [RSP + 0x24]
MOV ECX,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x38]
MOV R12D,EAX
MOV EDI,R9D
MOV EDX,dword ptr [RSP + 0x40]
SUB EDI,EBP
CMP EDI,0x1
JG 0x00101ce4
ADD EBP,0x1
ADD EBX,R12D
CMP R14D,EBP
JNZ 0x00101d2b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101d88:
ADD R9D,0x1
CMP R13D,0x1
JG 0x00101bd9
LAB_00101d96:
ADD R11D,EBX
ADD R14D,0x1
TEST R13D,R13D
JNZ 0x001024ea
IMUL R15D,R11D
LAB_00101daa:
ADD ESI,R15D
LEA R11D,[RDX + 0x1]
CMP dword ptr [RSP + 0x10],R11D
JZ 0x00101fd0
CMP R11D,0x1
JLE 0x00101fb0
MOV R9D,EDX
XOR R8D,R8D
XOR R15D,R15D
XOR R14D,R14D
MOV EBX,0x1
LAB_00101dd7:
CMP R9D,0x1
JLE 0x00101ebf
LEA R13D,[R9 + -0x1]
XOR R12D,R12D
XOR EBP,EBP
MOV R10D,0x1
CMP R13D,0x1
JLE 0x00101eb0
LAB_00101dfa:
MOV EDI,R13D
MOV dword ptr [RSP + 0x48],EDX
ADD EBP,0x1
MOV dword ptr [RSP + 0x44],R8D
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],R11D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x24],R10D
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x24]
MOV ECX,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x3c]
IMUL EAX,R10D
MOV R9D,dword ptr [RSP + 0x40]
MOV R8D,dword ptr [RSP + 0x44]
MOV EDX,dword ptr [RSP + 0x48]
ADD R12D,EAX
NOP dword ptr [RAX]
LAB_00101e50:
CMP EBP,0x1
JZ 0x001024ca
MOV EDI,EBP
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R8D
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],R11D
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x24],ECX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x24]
MOV ESI,dword ptr [RSP + 0x34]
MOV R11D,dword ptr [RSP + 0x38]
MOV R9D,dword ptr [RSP + 0x3c]
MOV R10D,EAX
MOV R8D,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x44]
LAB_00101e99:
SUB R13D,0x1
CMP R13D,0x1
JG 0x00101dfa
NOP word ptr [RAX + RAX*0x1]
LAB_00101eb0:
ADD R12D,R10D
ADD EBP,0x1
TEST R13D,R13D
JNZ 0x00101e50
IMUL EBX,R12D
LAB_00101ebf:
ADD R15D,EBX
LEA R13D,[R14 + 0x1]
CMP EDX,R14D
JZ 0x00101fc0
CMP R13D,0x1
JLE 0x00101f98
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_00101ee3:
MOV EDI,R8D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x00101f30
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R8D
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],R11D
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x24],ECX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x44]
MOV R8D,dword ptr [RSP + 0x40]
IMUL R12D,EAX
MOV R9D,dword ptr [RSP + 0x3c]
MOV R11D,dword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x24]
NOP dword ptr [RAX]
LAB_00101f30:
ADD EBX,R12D
LEA EDI,[RBP + 0x1]
CMP EBP,R14D
JZ 0x00101fa0
CMP EDI,0x1
JLE 0x00102448
MOV dword ptr [RSP + 0x48],EDX
MOV dword ptr [RSP + 0x44],R8D
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],R11D
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x24],EDI
CALL 0x001011f0
MOV EDI,dword ptr [RSP + 0x24]
MOV ECX,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x3c]
MOV R12D,EAX
MOV R9D,dword ptr [RSP + 0x40]
MOV R8D,dword ptr [RSP + 0x44]
MOV EBP,EDI
MOV EDX,dword ptr [RSP + 0x48]
JMP 0x00101ee3
LAB_00101f98:
MOV EBX,0x1
NOP dword ptr [RAX]
LAB_00101fa0:
ADD R8D,0x1
SUB R9D,0x1
MOV R14D,R13D
JMP 0x00101dd7
LAB_00101fb0:
MOV R15D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101fc0:
SUB ECX,0x1
MOV EDX,R11D
JMP 0x00101bb1
LAB_00101fd0:
IMUL ESI,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x14],ESI
LAB_00101fd9:
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x14]
ADD dword ptr [RSP + 0x18],ECX
LEA R11D,[RAX + 0x1]
CMP EAX,dword ptr [RSP + 0x1c]
JZ 0x00102490
CMP R11D,0x1
JLE 0x001024b5
MOV dword ptr [RSP + 0x14],R11D
MOV R15D,0x1
XOR R13D,R13D
XOR EDX,EDX
MOV ECX,dword ptr [RSP + 0xc]
MOV ESI,R15D
LAB_00102014:
CMP ECX,0x1
JLE 0x0010220a
LEA R8D,[RCX + -0x1]
XOR R9D,R9D
XOR R15D,R15D
XOR R11D,R11D
MOV R14D,R8D
MOV EBX,0x1
CMP R14D,0x1
JLE 0x001021f6
LAB_0010203c:
SUB R14D,0x1
XOR EBP,EBP
XOR R12D,R12D
MOV R10D,0x1
MOV R8D,R14D
CMP R8D,0x1
JLE 0x00102110
LAB_00102058:
MOV EDI,R8D
MOV dword ptr [RSP + 0x48],EDX
ADD R12D,0x1
MOV dword ptr [RSP + 0x44],R9D
MOV dword ptr [RSP + 0x40],ECX
MOV dword ptr [RSP + 0x3c],R10D
MOV dword ptr [RSP + 0x38],R11D
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x24],R8D
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x3c]
MOV R8D,dword ptr [RSP + 0x24]
MOV ESI,dword ptr [RSP + 0x34]
MOV R11D,dword ptr [RSP + 0x38]
IMUL EAX,R10D
MOV ECX,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x44]
MOV EDX,dword ptr [RSP + 0x48]
ADD EBP,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001020b0:
CMP R12D,0x1
JZ 0x001024bf
MOV EDI,R12D
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],R8D
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],R11D
MOV dword ptr [RSP + 0x24],ESI
CALL 0x001011f0
MOV ESI,dword ptr [RSP + 0x24]
MOV R11D,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x3c]
MOV R10D,EAX
MOV R9D,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x44]
LAB_001020fb:
SUB R8D,0x1
CMP R8D,0x1
JG 0x00102058
NOP dword ptr [RAX]
LAB_00102110:
ADD EBP,R10D
ADD R12D,0x1
TEST R8D,R8D
JNZ 0x001020b0
IMUL EBP,EBX
ADD R15D,0x1
ADD R11D,EBP
LAB_00102126:
CMP R15D,0x1
JZ 0x00102576
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_0010213a:
MOV EDI,R9D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x00102180
LAB_00102144:
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],R11D
MOV dword ptr [RSP + 0x24],ESI
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x3c]
IMUL R12D,EAX
MOV ECX,dword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x24]
NOP dword ptr [RAX]
LAB_00102180:
ADD EBP,0x1
ADD EBX,R12D
CMP R15D,EBP
JZ 0x001021e8
LAB_0010218b:
CMP EBP,0x1
JLE 0x00102428
MOV EDI,EBP
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],R11D
MOV dword ptr [RSP + 0x24],ESI
CALL 0x001011f0
MOV R9D,dword ptr [RSP + 0x3c]
MOV ESI,dword ptr [RSP + 0x24]
MOV R11D,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x38]
MOV R12D,EAX
MOV EDI,R9D
MOV EDX,dword ptr [RSP + 0x40]
SUB EDI,EBP
CMP EDI,0x1
JG 0x00102144
ADD EBP,0x1
ADD EBX,R12D
CMP R15D,EBP
JNZ 0x0010218b
NOP dword ptr [RAX + RAX*0x1]
LAB_001021e8:
ADD R9D,0x1
CMP R14D,0x1
JG 0x0010203c
LAB_001021f6:
ADD R11D,EBX
ADD R15D,0x1
TEST R14D,R14D
JNZ 0x00102562
IMUL ESI,R11D
LAB_0010220a:
ADD R13D,ESI
LEA R11D,[RDX + 0x1]
CMP dword ptr [RSP + 0xc],EDX
JZ 0x00102468
CMP R11D,0x1
JLE 0x00102410
MOV R9D,EDX
XOR R8D,R8D
XOR ESI,ESI
XOR R15D,R15D
MOV EBX,0x1
LAB_00102235:
CMP R9D,0x1
JLE 0x0010231f
LEA R14D,[R9 + -0x1]
XOR R12D,R12D
XOR EBP,EBP
MOV R10D,0x1
CMP R14D,0x1
JLE 0x00102310
LAB_00102258:
MOV EDI,R14D
MOV dword ptr [RSP + 0x48],EDX
ADD EBP,0x1
MOV dword ptr [RSP + 0x44],R8D
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],ECX
MOV dword ptr [RSP + 0x38],R10D
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x24],R11D
CALL 0x001011f0
MOV R10D,dword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x24]
MOV ESI,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x3c]
IMUL EAX,R10D
MOV R9D,dword ptr [RSP + 0x40]
MOV R8D,dword ptr [RSP + 0x44]
MOV EDX,dword ptr [RSP + 0x48]
ADD R12D,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001022b0:
CMP EBP,0x1
JZ 0x0010256b
MOV EDI,EBP
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R8D
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x24],R11D
CALL 0x001011f0
MOV R11D,dword ptr [RSP + 0x24]
MOV ESI,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x38]
MOV R9D,dword ptr [RSP + 0x3c]
MOV R10D,EAX
MOV R8D,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x44]
LAB_001022f9:
SUB R14D,0x1
CMP R14D,0x1
JG 0x00102258
NOP word ptr [RAX + RAX*0x1]
LAB_00102310:
ADD R12D,R10D
ADD EBP,0x1
TEST R14D,R14D
JNZ 0x001022b0
IMUL EBX,R12D
LAB_0010231f:
ADD ESI,EBX
LEA R14D,[R15 + 0x1]
CMP R15D,EDX
JZ 0x00102418
CMP R14D,0x1
JLE 0x001023f8
XOR EBX,EBX
XOR EBP,EBP
MOV R12D,0x1
LAB_00102342:
MOV EDI,R8D
SUB EDI,EBP
CMP EDI,0x1
JLE 0x00102390
MOV dword ptr [RSP + 0x44],EDX
MOV dword ptr [RSP + 0x40],R8D
MOV dword ptr [RSP + 0x3c],R9D
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x24],R11D
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x44]
MOV R8D,dword ptr [RSP + 0x40]
IMUL R12D,EAX
MOV R9D,dword ptr [RSP + 0x3c]
MOV ECX,dword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x34]
MOV R11D,dword ptr [RSP + 0x24]
NOP dword ptr [RAX + RAX*0x1]
LAB_00102390:
ADD EBX,R12D
LEA EDI,[RBP + 0x1]
CMP EBP,R15D
JZ 0x00102400
CMP EDI,0x1
JLE 0x00102438
MOV dword ptr [RSP + 0x48],EDX
MOV dword ptr [RSP + 0x44],R8D
MOV dword ptr [RSP + 0x40],R9D
MOV dword ptr [RSP + 0x3c],ECX
MOV dword ptr [RSP + 0x38],ESI
MOV dword ptr [RSP + 0x34],R11D
MOV dword ptr [RSP + 0x24],EDI
CALL 0x001011f0
MOV EDI,dword ptr [RSP + 0x24]
MOV R11D,dword ptr [RSP + 0x34]
MOV ESI,dword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x3c]
MOV R12D,EAX
MOV R9D,dword ptr [RSP + 0x40]
MOV R8D,dword ptr [RSP + 0x44]
MOV EBP,EDI
MOV EDX,dword ptr [RSP + 0x48]
JMP 0x00102342
LAB_001023f8:
MOV EBX,0x1
NOP dword ptr [RAX]
LAB_00102400:
ADD R8D,0x1
SUB R9D,0x1
MOV R15D,R14D
JMP 0x00102235
LAB_00102410:
MOV ESI,0x1
NOP dword ptr [RAX]
LAB_00102418:
SUB ECX,0x1
MOV EDX,R11D
JMP 0x00102014
LAB_00102428:
MOV R12D,0x1
JMP 0x0010213a
LAB_00102438:
MOV R12D,0x1
MOV EBP,EDI
JMP 0x00102342
LAB_00102448:
MOV R12D,0x1
MOV EBP,EDI
JMP 0x00101ee3
LAB_00102458:
MOV R12D,0x1
JMP 0x00101cda
LAB_00102468:
MOV R11D,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x14],R13D
LAB_00102472:
SUB dword ptr [RSP + 0x10],0x1
MOV dword ptr [RSP + 0xc],R11D
JMP 0x00101b97
LAB_00102481:
MOV dword ptr [RSP + 0x18],0x1
NOP dword ptr [RAX]
LAB_00102490:
MOV EAX,dword ptr [RSP + 0x20]
SUB dword ptr [RSP + 0x28],0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0010122b
LAB_001024a2:
MOV EAX,dword ptr [RSP + 0x2c]
ADD RSP,0x58
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001024b5:
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00102472
LAB_001024bf:
MOV R10D,0x1
JMP 0x001020fb
LAB_001024ca:
MOV R10D,0x1
JMP 0x00101e99
LAB_001024d5:
MOV EBX,0x1
JMP 0x00101d88
LAB_001024df:
MOV R10D,0x1
JMP 0x00101c9b
LAB_001024ea:
SUB R13D,0x1
JMP 0x00101cc6
LAB_001024f3:
SUB R13D,0x1
JMP 0x001017e6
LAB_001024fc:
MOV R10D,0x1
JMP 0x001019b9
LAB_00102507:
MOV EBX,0x1
JMP 0x001018a8
LAB_00102511:
MOV R10D,0x1
JMP 0x001017bb
LAB_0010251c:
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00101b14
LAB_00102529:
SUB R13D,0x1
JMP 0x00101386
LAB_00102532:
MOV R10D,0x1
JMP 0x00101559
LAB_0010253d:
MOV EBX,0x1
JMP 0x00101448
LAB_00102547:
MOV R10D,0x1
JMP 0x0010135b
LAB_00102552:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x001016be
LAB_00102562:
SUB R14D,0x1
JMP 0x00102126
LAB_0010256b:
MOV R10D,0x1
JMP 0x001022f9
LAB_00102576:
MOV EBX,0x1
JMP 0x001021e8 | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
uint uVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int local_7c;
int local_78;
int local_74;
int local_70;
int local_6c;
int local_68;
int local_64;
int local_60;
int local_5c;
local_5c = 0;
if (param_1 < 1) {
return 0;
}
local_6c = 0;
local_60 = param_1 + -1;
local_70 = 1;
do {
if (1 < local_60) {
local_7c = local_60 + -1;
local_68 = 0;
local_78 = 0;
local_74 = 1;
if (local_7c < 2) goto LAB_00101b29;
LAB_00101264:
local_64 = local_7c + -1;
iVar5 = 0;
iVar18 = 1;
iVar2 = local_64;
iVar13 = 0;
do {
if (1 < iVar2) {
iVar6 = iVar2 + -1;
iVar10 = 0;
iVar12 = 0;
iVar7 = 0;
iVar3 = 1;
iVar11 = 0;
if (iVar6 < 2) goto LAB_00101456;
LAB_0010129f:
iVar6 = iVar6 + -1;
iVar4 = 0;
iVar14 = 0;
iVar1 = 1;
iVar7 = iVar6;
iVar15 = 0;
if (iVar6 < 2) goto LAB_00101370;
do {
iVar14 = func0_part_0(iVar7);
iVar4 = iVar4 + iVar14 * iVar1;
iVar14 = iVar15;
while( true ) {
iVar14 = iVar14 + 1;
if (iVar14 == 1) {
iVar1 = 1;
}
else {
iVar1 = func0_part_0(iVar14);
}
iVar7 = iVar7 + -1;
iVar15 = iVar14;
if (1 < iVar7) break;
LAB_00101370:
iVar4 = iVar4 + iVar1;
if (iVar7 == 0) {
iVar12 = iVar12 + iVar4 * iVar3;
iVar7 = iVar11;
goto LAB_00101386;
}
}
} while( true );
}
LAB_0010146a:
iVar5 = iVar5 + iVar18;
iVar3 = iVar13 + 1;
if (local_7c == iVar3) goto LAB_001016b0;
if (1 < iVar3) {
iVar10 = 0;
iVar18 = 0;
iVar6 = 1;
iVar11 = iVar13;
iVar7 = 0;
do {
if (1 < iVar11) {
iVar16 = iVar11 + -1;
iVar4 = 0;
iVar14 = 0;
iVar1 = 1;
iVar12 = 0;
iVar15 = 0;
if (iVar16 < 2) goto LAB_00101570;
do {
iVar14 = func0_part_0(iVar16);
iVar4 = iVar15 + iVar14 * iVar1;
iVar14 = iVar12;
while( true ) {
iVar14 = iVar14 + 1;
if (iVar14 == 1) {
iVar1 = 1;
}
else {
iVar1 = func0_part_0(iVar14);
}
iVar16 = iVar16 + -1;
iVar12 = iVar14;
iVar15 = iVar4;
if (1 < iVar16) break;
LAB_00101570:
iVar4 = iVar4 + iVar1;
if (iVar16 == 0) {
iVar6 = iVar6 * iVar4;
goto LAB_0010157f;
}
}
} while( true );
}
LAB_0010157f:
iVar18 = iVar18 + iVar6;
if (iVar13 == iVar7) goto LAB_00101680;
if (iVar7 + 1 < 2) {
iVar6 = 1;
}
else {
iVar6 = 0;
iVar15 = 1;
iVar12 = 0;
while( true ) {
if (1 < iVar10 - iVar12) {
iVar14 = func0_part_0();
iVar15 = iVar15 * iVar14;
}
iVar6 = iVar6 + iVar15;
iVar15 = iVar12 + 1;
if (iVar12 == iVar7) break;
iVar12 = iVar15;
if (iVar15 < 2) {
iVar15 = 1;
}
else {
iVar15 = func0_part_0();
}
}
}
iVar10 = iVar10 + 1;
iVar11 = iVar11 + -1;
iVar7 = iVar7 + 1;
} while( true );
}
iVar18 = 1;
LAB_00101680:
iVar2 = iVar2 + -1;
iVar13 = iVar3;
} while( true );
}
LAB_00101b4f:
local_5c = local_5c + local_70;
iVar2 = local_6c + 1;
if (param_1 == iVar2) {
return local_5c;
}
if (1 < iVar2) {
local_70 = 0;
local_7c = 0;
local_78 = local_6c;
local_74 = 1;
do {
if (1 < local_78) {
iVar18 = 0;
iVar3 = 1;
iVar13 = local_78;
iVar5 = 0;
LAB_00101bb1:
do {
iVar7 = iVar5;
iVar11 = iVar13 + -1;
if (1 < iVar11) {
iVar13 = iVar13 + -2;
iVar12 = 0;
iVar15 = 0;
iVar10 = 0;
iVar5 = 1;
iVar6 = 0;
if (iVar13 < 2) goto LAB_00101d96;
LAB_00101bd9:
iVar13 = iVar13 + -1;
iVar1 = 0;
iVar16 = 0;
iVar4 = 1;
iVar10 = iVar13;
iVar14 = 0;
if (iVar13 < 2) goto LAB_00101cb0;
do {
iVar1 = func0_part_0(iVar10);
iVar16 = iVar16 + iVar1 * iVar4;
iVar1 = iVar14;
while( true ) {
iVar1 = iVar1 + 1;
if (iVar1 == 1) {
iVar4 = 1;
}
else {
iVar4 = func0_part_0(iVar1);
}
iVar10 = iVar10 + -1;
iVar14 = iVar1;
if (1 < iVar10) break;
LAB_00101cb0:
iVar16 = iVar16 + iVar4;
if (iVar10 == 0) {
iVar15 = iVar15 + iVar16 * iVar5;
iVar10 = iVar6;
goto LAB_00101cc6;
}
}
} while( true );
}
LAB_00101daa:
iVar18 = iVar18 + iVar3;
iVar5 = iVar7 + 1;
if (local_78 == iVar5) {
local_74 = iVar18 * local_74;
break;
}
iVar13 = iVar11;
if (1 < iVar5) {
iVar12 = 0;
iVar3 = 0;
iVar10 = 1;
iVar11 = iVar7;
iVar6 = 0;
do {
if (1 < iVar11) {
iVar17 = iVar11 + -1;
iVar16 = 0;
iVar1 = 0;
iVar4 = 1;
iVar15 = 0;
iVar14 = 0;
if (iVar17 < 2) goto LAB_00101eb0;
do {
iVar1 = func0_part_0(iVar17);
iVar16 = iVar14 + iVar1 * iVar4;
iVar1 = iVar15;
while( true ) {
iVar1 = iVar1 + 1;
if (iVar1 == 1) {
iVar4 = 1;
}
else {
iVar4 = func0_part_0(iVar1);
}
iVar17 = iVar17 + -1;
iVar15 = iVar1;
iVar14 = iVar16;
if (1 < iVar17) break;
LAB_00101eb0:
iVar16 = iVar16 + iVar4;
if (iVar17 == 0) {
iVar10 = iVar10 * iVar16;
goto LAB_00101ebf;
}
}
} while( true );
}
LAB_00101ebf:
iVar3 = iVar3 + iVar10;
if (iVar7 == iVar6) goto LAB_00101bb1;
if (iVar6 + 1 < 2) {
iVar10 = 1;
}
else {
iVar10 = 0;
iVar14 = 1;
iVar15 = 0;
while( true ) {
if (1 < iVar12 - iVar15) {
iVar1 = func0_part_0();
iVar14 = iVar14 * iVar1;
}
iVar10 = iVar10 + iVar14;
iVar14 = iVar15 + 1;
if (iVar15 == iVar6) break;
iVar15 = iVar14;
if (iVar14 < 2) {
iVar14 = 1;
}
else {
iVar14 = func0_part_0();
}
}
}
iVar12 = iVar12 + 1;
iVar11 = iVar11 + -1;
iVar6 = iVar6 + 1;
} while( true );
}
iVar3 = 1;
} while( true );
}
local_70 = local_70 + local_74;
if (local_7c == local_6c) goto LAB_00102490;
if (1 < local_7c + 1) {
local_74 = 0;
iVar18 = 1;
iVar13 = local_7c;
iVar5 = 0;
do {
if (1 < iVar13) {
iVar11 = iVar13 + -1;
iVar7 = 0;
iVar10 = 0;
iVar6 = 0;
iVar3 = 1;
if (iVar11 < 2) goto LAB_001021f6;
LAB_0010203c:
iVar11 = iVar11 + -1;
iVar4 = 0;
iVar14 = 0;
iVar1 = 1;
iVar12 = iVar11;
iVar15 = 0;
if (iVar11 < 2) goto LAB_00102110;
do {
iVar14 = func0_part_0(iVar12);
iVar4 = iVar4 + iVar14 * iVar1;
iVar14 = iVar15;
while( true ) {
iVar14 = iVar14 + 1;
if (iVar14 == 1) {
iVar1 = 1;
}
else {
iVar1 = func0_part_0(iVar14);
}
iVar12 = iVar12 + -1;
iVar15 = iVar14;
if (1 < iVar12) break;
LAB_00102110:
iVar4 = iVar4 + iVar1;
if (iVar12 == 0) {
iVar6 = iVar6 + iVar4 * iVar3;
goto LAB_00102126;
}
}
} while( true );
}
LAB_0010220a:
local_74 = local_74 + iVar18;
if (local_7c == iVar5) goto LAB_00102472;
if (1 < iVar5 + 1) {
iVar6 = 0;
iVar18 = 0;
iVar7 = 1;
iVar3 = 0;
iVar11 = iVar5;
do {
if (1 < iVar11) {
iVar4 = iVar11 + -1;
iVar1 = 0;
iVar15 = 0;
iVar14 = 1;
iVar10 = 0;
iVar12 = 0;
if (iVar4 < 2) goto LAB_00102310;
do {
iVar15 = func0_part_0(iVar4);
iVar1 = iVar12 + iVar15 * iVar14;
iVar15 = iVar10;
while( true ) {
iVar15 = iVar15 + 1;
if (iVar15 == 1) {
iVar14 = 1;
}
else {
iVar14 = func0_part_0(iVar15);
}
iVar4 = iVar4 + -1;
iVar10 = iVar15;
iVar12 = iVar1;
if (1 < iVar4) break;
LAB_00102310:
iVar1 = iVar1 + iVar14;
if (iVar4 == 0) {
iVar7 = iVar7 * iVar1;
goto LAB_0010231f;
}
}
} while( true );
}
LAB_0010231f:
iVar18 = iVar18 + iVar7;
if (iVar3 == iVar5) goto LAB_00102418;
if (iVar3 + 1 < 2) {
iVar7 = 1;
}
else {
iVar7 = 0;
iVar12 = 1;
iVar10 = 0;
while( true ) {
if (1 < iVar6 - iVar10) {
iVar15 = func0_part_0();
iVar12 = iVar12 * iVar15;
}
iVar7 = iVar7 + iVar12;
iVar12 = iVar10 + 1;
if (iVar10 == iVar3) break;
iVar10 = iVar12;
if (iVar12 < 2) {
iVar12 = 1;
}
else {
iVar12 = func0_part_0();
}
}
}
iVar6 = iVar6 + 1;
iVar11 = iVar11 + -1;
iVar3 = iVar3 + 1;
} while( true );
}
iVar18 = 1;
LAB_00102418:
iVar13 = iVar13 + -1;
iVar5 = iVar5 + 1;
} while( true );
}
local_74 = 1;
LAB_00102472:
local_78 = local_78 + -1;
local_7c = local_7c + 1;
} while( true );
}
local_70 = 1;
LAB_00102490:
local_60 = local_60 + -1;
local_6c = iVar2;
} while( true );
LAB_00101386:
iVar7 = iVar7 + 1;
if (iVar7 != 1) {
iVar3 = 0;
iVar11 = 0;
LAB_0010139a:
iVar15 = 1;
if (iVar10 - iVar11 < 2) goto LAB_001013e0;
do {
iVar14 = func0_part_0();
iVar15 = iVar15 * iVar14;
LAB_001013e0:
iVar3 = iVar3 + iVar15;
while( true ) {
iVar11 = iVar11 + 1;
if (iVar7 == iVar11) goto LAB_00101448;
if (iVar11 < 2) goto LAB_0010139a;
iVar15 = func0_part_0(iVar11);
if (1 < iVar10 - iVar11) break;
iVar3 = iVar3 + iVar15;
}
} while( true );
}
iVar3 = 1;
LAB_00101448:
iVar10 = iVar10 + 1;
iVar11 = iVar7;
if (1 < iVar6) goto LAB_0010129f;
LAB_00101456:
iVar12 = iVar12 + iVar3;
if (iVar6 == 0) {
iVar18 = iVar18 * iVar12;
goto LAB_0010146a;
}
iVar6 = iVar6 + -1;
goto LAB_00101386;
LAB_001016b0:
local_68 = local_68 + iVar5 * local_74;
do {
local_78 = local_78 + 1;
if (local_78 != 1) {
local_74 = 0;
iVar5 = 1;
iVar2 = local_78;
iVar13 = 0;
LAB_001016d8:
do {
iVar3 = iVar13;
iVar18 = iVar2 + -1;
if (1 < iVar18) {
uVar8 = iVar2 - 2;
iVar7 = 0;
iVar6 = 0;
iVar11 = 0;
iVar2 = 1;
iVar13 = 0;
if (uVar8 < 2) goto LAB_001018b6;
LAB_00101700:
uVar8 = uVar8 - 1;
iVar10 = 0;
iVar15 = 0;
iVar12 = 1;
uVar9 = uVar8;
iVar11 = 0;
if (uVar8 < 2) goto LAB_001017d0;
do {
iVar10 = func0_part_0(uVar9);
iVar15 = iVar15 + iVar10 * iVar12;
iVar10 = iVar11;
while( true ) {
iVar10 = iVar10 + 1;
if (iVar10 == 1) {
iVar12 = 1;
}
else {
iVar12 = func0_part_0(iVar10);
}
uVar9 = uVar9 - 1;
iVar11 = iVar10;
if (1 < uVar9) break;
LAB_001017d0:
iVar15 = iVar15 + iVar12;
if (uVar9 == 0) {
iVar6 = iVar6 + iVar15 * iVar2;
iVar11 = iVar13;
goto LAB_001017e6;
}
}
} while( true );
}
LAB_001018ca:
local_74 = local_74 + iVar5;
iVar13 = iVar3 + 1;
if (local_78 == iVar13) goto LAB_00101b14;
iVar2 = iVar18;
if (1 < iVar13) {
iVar6 = 0;
iVar5 = 0;
iVar7 = 1;
iVar18 = iVar3;
iVar11 = 0;
do {
if (1 < iVar18) {
iVar4 = iVar18 + -1;
iVar1 = 0;
iVar15 = 0;
iVar14 = 1;
iVar10 = 0;
iVar12 = 0;
if (iVar4 < 2) goto LAB_001019d0;
do {
iVar15 = func0_part_0(iVar4);
iVar1 = iVar12 + iVar15 * iVar14;
iVar15 = iVar10;
while( true ) {
iVar15 = iVar15 + 1;
if (iVar15 == 1) {
iVar14 = 1;
}
else {
iVar14 = func0_part_0(iVar15);
}
iVar4 = iVar4 + -1;
iVar10 = iVar15;
iVar12 = iVar1;
if (1 < iVar4) break;
LAB_001019d0:
iVar1 = iVar1 + iVar14;
if (iVar4 == 0) {
iVar7 = iVar7 * iVar1;
goto LAB_001019df;
}
}
} while( true );
}
LAB_001019df:
iVar5 = iVar5 + iVar7;
if (iVar3 == iVar11) goto LAB_001016d8;
if (iVar11 + 1 < 2) {
iVar7 = 1;
}
else {
iVar7 = 0;
iVar12 = 1;
iVar10 = 0;
while( true ) {
if (1 < iVar6 - iVar10) {
iVar15 = func0_part_0();
iVar12 = iVar12 * iVar15;
}
iVar7 = iVar7 + iVar12;
iVar12 = iVar10 + 1;
if (iVar11 == iVar10) break;
iVar10 = iVar12;
if (iVar12 < 2) {
iVar12 = 1;
}
else {
iVar12 = func0_part_0();
}
}
}
iVar6 = iVar6 + 1;
iVar18 = iVar18 + -1;
iVar11 = iVar11 + 1;
} while( true );
}
iVar5 = 1;
} while( true );
}
local_74 = 1;
LAB_00101b14:
local_7c = local_64;
if (1 < local_64) goto LAB_00101264;
LAB_00101b29:
local_68 = local_68 + local_74;
if (local_7c == 0) {
local_70 = local_70 * local_68;
goto LAB_00101b4f;
}
local_64 = local_7c + -1;
} while( true );
LAB_001017e6:
iVar11 = iVar11 + 1;
if (iVar11 != 1) {
iVar2 = 0;
iVar13 = 0;
LAB_001017fa:
iVar10 = 1;
if (iVar7 - iVar13 < 2) goto LAB_00101840;
do {
iVar12 = func0_part_0();
iVar10 = iVar10 * iVar12;
LAB_00101840:
iVar2 = iVar2 + iVar10;
while( true ) {
iVar13 = iVar13 + 1;
if (iVar11 == iVar13) goto LAB_001018a8;
if (iVar13 < 2) goto LAB_001017fa;
iVar10 = func0_part_0(iVar13);
if (1 < iVar7 - iVar13) break;
iVar2 = iVar2 + iVar10;
}
} while( true );
}
iVar2 = 1;
LAB_001018a8:
iVar7 = iVar7 + 1;
iVar13 = iVar11;
if (1 < uVar8) goto LAB_00101700;
LAB_001018b6:
iVar6 = iVar6 + iVar2;
if (uVar8 == 0) {
iVar5 = iVar5 * iVar6;
goto LAB_001018ca;
}
uVar8 = uVar8 - 1;
goto LAB_001017e6;
LAB_00101cc6:
iVar10 = iVar10 + 1;
if (iVar10 != 1) {
iVar5 = 0;
iVar6 = 0;
LAB_00101cda:
iVar14 = 1;
if (iVar12 - iVar6 < 2) goto LAB_00101d20;
do {
iVar1 = func0_part_0();
iVar14 = iVar14 * iVar1;
LAB_00101d20:
iVar5 = iVar5 + iVar14;
while( true ) {
iVar6 = iVar6 + 1;
if (iVar10 == iVar6) goto LAB_00101d88;
if (iVar6 < 2) goto LAB_00101cda;
iVar14 = func0_part_0(iVar6);
if (1 < iVar12 - iVar6) break;
iVar5 = iVar5 + iVar14;
}
} while( true );
}
iVar5 = 1;
LAB_00101d88:
iVar12 = iVar12 + 1;
iVar6 = iVar10;
if (1 < iVar13) goto LAB_00101bd9;
LAB_00101d96:
iVar15 = iVar15 + iVar5;
if (iVar13 == 0) {
iVar3 = iVar3 * iVar15;
goto LAB_00101daa;
}
iVar13 = iVar13 + -1;
goto LAB_00101cc6;
LAB_00102126:
iVar10 = iVar10 + 1;
if (iVar10 != 1) {
iVar3 = 0;
iVar12 = 0;
LAB_0010213a:
iVar15 = 1;
if (iVar7 - iVar12 < 2) goto LAB_00102180;
do {
iVar14 = func0_part_0();
iVar15 = iVar15 * iVar14;
LAB_00102180:
iVar3 = iVar3 + iVar15;
while( true ) {
iVar12 = iVar12 + 1;
if (iVar10 == iVar12) goto LAB_001021e8;
if (iVar12 < 2) goto LAB_0010213a;
iVar15 = func0_part_0(iVar12);
if (1 < iVar7 - iVar12) break;
iVar3 = iVar3 + iVar15;
}
} while( true );
}
iVar3 = 1;
LAB_001021e8:
iVar7 = iVar7 + 1;
if (1 < iVar11) goto LAB_0010203c;
LAB_001021f6:
iVar6 = iVar6 + iVar3;
if (iVar11 == 0) {
iVar18 = iVar18 * iVar6;
goto LAB_0010220a;
}
iVar11 = iVar11 + -1;
goto LAB_00102126;
} |
6,227 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%edi
jle 12c0 <func0+0x60>
lea -0x1(%rdi),%edx
sub $0x8,%rsp
mov %edi,%esi
xor %r8d,%r8d
mov $0x1,%ecx
cmp $0x1,%edx
jbe 12a4 <func0+0x44>
mov %edx,%edi
callq 11f0 <func0.part.0>
imul %eax,%ecx
mov %esi,%edi
sub %edx,%edi
add %ecx,%r8d
cmp $0x1,%edi
jle 12ca <func0+0x6a>
callq 11f0 <func0.part.0>
mov %eax,%ecx
sub $0x1,%edx
cmp $0x1,%edx
ja 127f <func0+0x1f>
mov %esi,%edi
add %ecx,%r8d
sub %edx,%edi
test %edx,%edx
jne 1290 <func0+0x30>
mov %r8d,%eax
add $0x8,%rsp
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%r8d
mov %r8d,%eax
retq
mov $0x1,%ecx
jmp 129c <func0+0x3c>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
xor ebp, ebp
push rbx
sub rsp, 48h
test edi, edi
jle loc_2571
xor r12d, r12d
mov [rsp+78h+var_58], 1
lea ebx, [rdi-1]
mov [rsp+78h+var_4C], r12d
mov [rsp+78h+var_48], ebp
loc_121F:
cmp ebx, 1
jle loc_2542
loc_1228:
sub ebx, 1
mov [rsp+78h+var_5C], 0
mov [rsp+78h+var_54], 0
mov r12d, ebx
mov [rsp+78h+var_68], 1
mov [rsp+78h+var_44], ebx
loc_124A:
cmp r12d, 1
jle loc_1B27
loc_1254:
sub r12d, 1
xor r14d, r14d
mov [rsp+78h+var_6C], 0
mov [rsp+78h+var_74], 1
mov ebp, r12d
mov [rsp+78h+var_64], r14d
mov [rsp+78h+var_50], r12d
loc_1278:
cmp ebp, 1
jle loc_162D
loc_1281:
lea eax, [rbp-1]
sub ebp, 2
xor r12d, r12d
mov ebx, 1
mov [rsp+78h+var_60], eax
mov r14d, eax
mov r15d, ebp
mov [rsp+78h+var_70], 0
loc_12A1:
cmp r14d, 1
jle loc_1420
mov edi, r15d
cmp r15d, 1
jle loc_1350
mov edx, r15d
xor ecx, ecx
lea ebp, [r15-1]
xor r13d, r13d
loc_12C4:
mov [rsp+78h+var_3C], ecx
mov [rsp+78h+var_40], edx
call func0_part_0
mov ecx, [rsp+78h+var_3C]
mov edi, 1
mov edx, [rsp+78h+var_40]
add r13d, eax
test r15d, r15d
cmovle edi, r15d
lea eax, [rcx+1]
cmp edi, eax
jge loc_2683
nop dword ptr [rax+rax+00h]
loc_12F8:
cmp r14d, eax
jle short loc_136D
nop dword ptr [rax]
loc_1300:
mov edx, r14d
sub r14d, 1
sub edx, eax
lea r15d, [rdx-1]
loc_130D:
mov edi, r14d
sub edi, r15d
call func0_part_0
cmp r15d, 1
jle short loc_1340
mov edi, r15d
mov [rsp+78h+var_40], eax
sub r15d, 1
call func0_part_0
mov edx, [rsp+78h+var_40]
imul edx, eax
add r13d, edx
jmp short loc_130D
loc_1340:
add r13d, eax
test r15d, r15d
jz short loc_1371
xor r15d, r15d
jmp short loc_130D
loc_1350:
test r15d, r15d
jg loc_1678
mov eax, 1
mov r13d, 1
lea ebp, [r15-1]
cmp r14d, eax
jg short loc_1300
loc_136D:
sub r14d, 1
loc_1371:
mov esi, r13d
add r12d, 1
mov r15d, ebp
imul esi, ebx
add [rsp+78h+var_70], esi
loc_1382:
cmp r12d, 1
jz loc_26DD
lea r13d, [r12-1]
mov edi, r13d
cmp r13d, 1
jz loc_1B58
mov ebp, r13d
xor ebx, ebx
xor edx, edx
loc_13A5:
mov [rsp+78h+var_40], edx
call func0_part_0
mov edx, [rsp+78h+var_40]
add ebx, eax
test edx, edx
jz loc_266B
nop dword ptr [rax+00h]
loc_13C0:
lea ebp, [r12-3]
cmp r12d, 2
jz loc_12A1
loc_13CF:
mov edi, r13d
sub edi, ebp
call func0_part_0
cmp ebp, 1
jle short loc_1408
loc_13DE:
mov edi, ebp
mov [rsp+78h+var_40], eax
sub ebp, 1
call func0_part_0
mov edx, [rsp+78h+var_40]
mov edi, r13d
sub edi, ebp
imul edx, eax
add ebx, edx
call func0_part_0
cmp ebp, 1
jg short loc_13DE
nop dword ptr [rax+00h]
loc_1408:
add ebx, eax
test ebp, ebp
jz loc_12A1
xor ebp, ebp
jmp short loc_13CF
loc_1420:
add [rsp+78h+var_70], ebx
test r14d, r14d
jz short loc_1440
add r12d, 1
sub r15d, 1
xor r14d, r14d
jmp loc_1382
loc_1440:
mov r13d, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
add [rsp+78h+var_6C], 1
mov ebp, [rsp+78h+var_60]
imul r13d, eax
add [rsp+78h+var_64], r13d
loc_145B:
cmp [rsp+78h+var_6C], 1
jz loc_26A2
mov eax, [rsp+78h+var_6C]
mov [rsp+78h+var_70], ebp
xor r13d, r13d
mov ebx, 1
mov [rsp+78h+var_74], 0
lea r12d, [rax-2]
lea r14d, [rax-1]
mov ebp, r12d
loc_1489:
cmp r14d, 1
jle loc_1600
mov edi, ebp
cmp ebp, 1
jle loc_1540
mov r8d, ebp
xor r15d, r15d
lea r12d, [rbp-1]
xor edx, edx
loc_14AA:
mov [rsp+78h+var_40], edx
mov [rsp+78h+var_60], r8d
call func0_part_0
mov edx, [rsp+78h+var_40]
mov r8d, [rsp+78h+var_60]
add r15d, eax
test ebp, ebp
lea eax, [rdx+1]
mov edx, 1
cmovle edx, ebp
cmp edx, eax
jge loc_2662
nop dword ptr [rax+00000000h]
loc_14E0:
cmp r14d, eax
jle short loc_155C
nop dword ptr [rax]
loc_14E8:
mov edx, r14d
sub r14d, 1
sub edx, eax
lea ebp, [rdx-1]
loc_14F4:
mov edi, r14d
sub edi, ebp
call func0_part_0
cmp ebp, 1
jle short loc_1530
loc_1503:
mov edi, ebp
mov [rsp+78h+var_60], eax
sub ebp, 1
call func0_part_0
mov edx, [rsp+78h+var_60]
mov edi, r14d
sub edi, ebp
imul edx, eax
add r15d, edx
call func0_part_0
cmp ebp, 1
jg short loc_1503
nop word ptr [rax+rax+00h]
loc_1530:
add r15d, eax
test ebp, ebp
jz short loc_1560
xor ebp, ebp
jmp short loc_14F4
loc_1540:
test ebp, ebp
jg loc_1648
mov eax, 1
mov r15d, 1
lea r12d, [rbp-1]
cmp r14d, eax
jg short loc_14E8
loc_155C:
sub r14d, 1
loc_1560:
mov esi, ebx
add r13d, 1
mov ebp, r12d
imul esi, r15d
add [rsp+78h+var_74], esi
loc_1571:
cmp r13d, 1
jz loc_268B
lea r12d, [r13-1]
mov edi, r12d
cmp r12d, 1
jz loc_1B78
mov edx, r12d
xor r15d, r15d
xor ebx, ebx
loc_1594:
mov [rsp+78h+var_60], edx
call func0_part_0
mov edx, [rsp+78h+var_60]
add ebx, eax
test r15d, r15d
jz loc_2649
nop dword ptr [rax+00h]
loc_15B0:
lea r15d, [r13-3]
cmp r13d, 2
jz loc_1489
loc_15BE:
mov edi, r12d
sub edi, r15d
call func0_part_0
cmp r15d, 1
jle short loc_15F0
mov edi, r15d
mov [rsp+78h+var_60], eax
sub r15d, 1
call func0_part_0
mov edx, [rsp+78h+var_60]
imul eax, edx
add ebx, eax
jmp short loc_15BE
loc_15F0:
add ebx, eax
test r15d, r15d
jz loc_1489
xor r15d, r15d
jmp short loc_15BE
loc_1600:
add [rsp+78h+var_74], ebx
test r14d, r14d
jz short loc_1620
add r13d, 1
sub ebp, 1
xor r14d, r14d
jmp loc_1571
loc_1620:
mov ebp, [rsp+78h+var_70]
cmp ebp, 1
jg loc_1281
loc_162D:
mov ecx, [rsp+78h+var_74]
add [rsp+78h+var_64], ecx
test ebp, ebp
jz short loc_16A8
add [rsp+78h+var_6C], 1
xor ebp, ebp
jmp loc_145B
loc_1648:
lea r12d, [rbp-1]
mov r15d, 1
mov r8d, r12d
loc_1655:
mov edi, r8d
mov edx, 1
cmp r8d, 1
jg loc_14AA
add r15d, 1
mov eax, 2
jmp loc_14E0
loc_1678:
lea ebp, [r15-1]
mov r13d, 1
mov edx, ebp
loc_1684:
mov edi, edx
mov ecx, 1
cmp edx, 1
jg loc_12C4
add r13d, 1
mov eax, 2
jmp loc_12F8
loc_16A8:
mov r14d, [rsp+78h+var_64]
mov eax, [rsp+78h+var_68]
add [rsp+78h+var_5C], 1
mov r12d, [rsp+78h+var_50]
imul eax, r14d
add [rsp+78h+var_54], eax
loc_16C3:
cmp [rsp+78h+var_5C], 1
jz loc_26D0
mov eax, [rsp+78h+var_5C]
mov [rsp+78h+var_68], 0
mov [rsp+78h+var_6C], 0
mov [rsp+78h+var_74], 1
sub eax, 1
mov [rsp+78h+var_60], r12d
mov ebp, eax
loc_16F4:
cmp ebp, 1
jle loc_1A9D
loc_16FD:
lea eax, [rbp-1]
sub ebp, 2
xor r12d, r12d
mov ebx, 1
mov [rsp+78h+var_64], eax
mov r14d, ebp
mov r15d, eax
mov [rsp+78h+var_70], 0
loc_171D:
cmp r15d, 1
jle loc_1890
mov edi, r14d
cmp r14d, 1
jle loc_17C8
mov edx, r14d
xor r13d, r13d
lea ebp, [r14-1]
xor ecx, ecx
loc_1740:
mov [rsp+78h+var_40], ecx
mov [rsp+78h+var_50], edx
call func0_part_0
mov ecx, [rsp+78h+var_40]
mov edi, 1
mov edx, [rsp+78h+var_50]
add r13d, eax
test r14d, r14d
cmovle edi, r14d
lea eax, [rcx+1]
cmp eax, edi
jle loc_2641
nop
loc_1770:
cmp r15d, eax
jle short loc_17E5
nop dword ptr [rax]
loc_1778:
mov edx, r15d
sub r15d, 1
sub edx, eax
lea r14d, [rdx-1]
loc_1785:
mov edi, r15d
sub edi, r14d
call func0_part_0
cmp r14d, 1
jle short loc_17B8
mov edi, r14d
mov [rsp+78h+var_50], eax
sub r14d, 1
call func0_part_0
mov edx, [rsp+78h+var_50]
imul edx, eax
add r13d, edx
jmp short loc_1785
loc_17B8:
add r13d, eax
test r14d, r14d
jz short loc_17E9
xor r14d, r14d
jmp short loc_1785
loc_17C8:
test r14d, r14d
jg loc_1AB8
mov eax, 1
mov r13d, 1
lea ebp, [r14-1]
cmp r15d, eax
jg short loc_1778
loc_17E5:
sub r15d, 1
loc_17E9:
mov esi, ebx
add r12d, 1
mov r14d, ebp
imul esi, r13d
add [rsp+78h+var_70], esi
loc_17FA:
cmp r12d, 1
jz loc_26C6
lea r13d, [r12-1]
mov edi, r13d
cmp r13d, 1
jz loc_1B48
mov ebp, r13d
xor ebx, ebx
xor edx, edx
loc_181D:
mov [rsp+78h+var_50], edx
call func0_part_0
mov edx, [rsp+78h+var_50]
add ebx, eax
test edx, edx
jz loc_2629
nop dword ptr [rax+00h]
loc_1838:
lea ebp, [r12-3]
cmp r12d, 2
jz loc_171D
loc_1847:
mov edi, r13d
sub edi, ebp
call func0_part_0
cmp ebp, 1
jle short loc_1880
loc_1856:
mov edi, ebp
mov [rsp+78h+var_50], eax
sub ebp, 1
call func0_part_0
mov edx, [rsp+78h+var_50]
mov edi, r13d
sub edi, ebp
imul edx, eax
add ebx, edx
call func0_part_0
cmp ebp, 1
jg short loc_1856
nop dword ptr [rax+00h]
loc_1880:
add ebx, eax
test ebp, ebp
jz loc_171D
xor ebp, ebp
jmp short loc_1847
loc_1890:
add [rsp+78h+var_70], ebx
test r15d, r15d
jz short loc_18B0
add r12d, 1
sub r14d, 1
xor r15d, r15d
jmp loc_17FA
loc_18B0:
mov r13d, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
add [rsp+78h+var_6C], 1
mov ebp, [rsp+78h+var_64]
imul r13d, eax
add [rsp+78h+var_68], r13d
loc_18CB:
cmp [rsp+78h+var_6C], 1
jz loc_26B9
mov eax, [rsp+78h+var_6C]
mov [rsp+78h+var_70], ebp
xor r13d, r13d
mov ebx, 1
mov [rsp+78h+var_74], 0
lea r12d, [rax-2]
lea r14d, [rax-1]
mov ebp, r12d
loc_18F9:
cmp r14d, 1
jle loc_1A70
mov edi, ebp
cmp ebp, 1
jle loc_19B0
mov r8d, ebp
xor r15d, r15d
lea r12d, [rbp-1]
xor edx, edx
loc_191A:
mov [rsp+78h+var_50], edx
mov [rsp+78h+var_64], r8d
call func0_part_0
mov edx, [rsp+78h+var_50]
mov r8d, [rsp+78h+var_64]
add r15d, eax
test ebp, ebp
lea eax, [rdx+1]
mov edx, 1
cmovle edx, ebp
cmp edx, eax
jge loc_2620
nop dword ptr [rax+00000000h]
loc_1950:
cmp r14d, eax
jle short loc_19CC
nop dword ptr [rax]
loc_1958:
mov edx, r14d
sub r14d, 1
sub edx, eax
lea ebp, [rdx-1]
loc_1964:
mov edi, r14d
sub edi, ebp
call func0_part_0
cmp ebp, 1
jle short loc_19A0
loc_1973:
mov edi, ebp
mov [rsp+78h+var_64], eax
sub ebp, 1
call func0_part_0
mov edx, [rsp+78h+var_64]
mov edi, r14d
sub edi, ebp
imul edx, eax
add r15d, edx
call func0_part_0
cmp ebp, 1
jg short loc_1973
nop word ptr [rax+rax+00h]
loc_19A0:
add r15d, eax
test ebp, ebp
jz short loc_19D0
xor ebp, ebp
jmp short loc_1964
loc_19B0:
test ebp, ebp
jg loc_1AE8
mov eax, 1
mov r15d, 1
lea r12d, [rbp-1]
cmp r14d, eax
jg short loc_1958
loc_19CC:
sub r14d, 1
loc_19D0:
mov esi, ebx
add r13d, 1
mov ebp, r12d
imul esi, r15d
add [rsp+78h+var_74], esi
loc_19E1:
cmp r13d, 1
jz loc_26AF
lea r12d, [r13-1]
mov edi, r12d
cmp r12d, 1
jz loc_1B68
mov edx, r12d
xor ebx, ebx
xor r15d, r15d
loc_1A04:
mov [rsp+78h+var_64], edx
call func0_part_0
mov edx, [rsp+78h+var_64]
add ebx, eax
test r15d, r15d
jz loc_2607
nop dword ptr [rax+00h]
loc_1A20:
lea r15d, [r13-3]
cmp r13d, 2
jz loc_18F9
loc_1A2E:
mov edi, r12d
sub edi, r15d
call func0_part_0
cmp r15d, 1
jle short loc_1A60
mov edi, r15d
mov [rsp+78h+var_64], eax
sub r15d, 1
call func0_part_0
mov edx, [rsp+78h+var_64]
imul eax, edx
add ebx, eax
jmp short loc_1A2E
loc_1A60:
add ebx, eax
test r15d, r15d
jz loc_18F9
xor r15d, r15d
jmp short loc_1A2E
loc_1A70:
add [rsp+78h+var_74], ebx
test r14d, r14d
jz short loc_1A90
add r13d, 1
sub ebp, 1
xor r14d, r14d
jmp loc_19E1
loc_1A90:
mov ebp, [rsp+78h+var_70]
cmp ebp, 1
jg loc_16FD
loc_1A9D:
mov ecx, [rsp+78h+var_74]
add [rsp+78h+var_68], ecx
test ebp, ebp
jz short loc_1B18
add [rsp+78h+var_6C], 1
xor ebp, ebp
jmp loc_18CB
loc_1AB8:
lea ebp, [r14-1]
mov r13d, 1
mov edx, ebp
loc_1AC4:
mov edi, edx
mov ecx, 1
cmp edx, 1
jg loc_1740
add r13d, 1
mov eax, 2
jmp loc_1770
loc_1AE8:
lea r12d, [rbp-1]
mov r15d, 1
mov r8d, r12d
loc_1AF5:
mov edi, r8d
mov edx, 1
cmp r8d, 1
jg loc_191A
add r15d, 1
mov eax, 2
jmp loc_1950
loc_1B18:
mov r12d, [rsp+78h+var_60]
cmp r12d, 1
jg loc_1254
loc_1B27:
mov ecx, [rsp+78h+var_68]
add [rsp+78h+var_54], ecx
test r12d, r12d
jz short loc_1B85
add [rsp+78h+var_5C], 1
xor r12d, r12d
jmp loc_16C3
loc_1B48:
mov ebx, 1
loc_1B4D:
add ebx, 1
jmp loc_1838
loc_1B58:
mov ebx, 1
loc_1B5D:
add ebx, 1
jmp loc_13C0
loc_1B68:
mov ebx, 1
loc_1B6D:
add ebx, 1
jmp loc_1A20
loc_1B78:
mov ebx, 1
loc_1B7D:
add ebx, 1
jmp loc_15B0
loc_1B85:
mov eax, [rsp+78h+var_58]
mov ecx, [rsp+78h+var_54]
add [rsp+78h+var_4C], 1
mov ebx, [rsp+78h+var_44]
imul eax, ecx
add [rsp+78h+var_48], eax
cmp [rsp+78h+var_4C], 1
jz loc_2560
loc_1BA8:
mov eax, [rsp+78h+var_4C]
xor r15d, r15d
mov [rsp+78h+var_50], ebx
mov [rsp+78h+var_58], 0
mov [rsp+78h+var_68], 1
lea r14d, [rax-1]
mov [rsp+78h+var_5C], r15d
mov ebp, r14d
loc_1BCF:
cmp ebp, 1
jle loc_24DD
loc_1BD8:
lea r12d, [rbp-1]
mov [rsp+78h+var_70], 0
mov ebp, 1
mov [rsp+78h+var_6C], 0
mov r15d, r12d
mov [rsp+78h+var_54], r12d
loc_1BF9:
cmp r15d, 1
jle loc_1FCF
loc_1C03:
lea eax, [r15-1]
lea r12d, [r15-2]
mov [rsp+78h+var_60], ebp
xor r13d, r13d
mov [rsp+78h+var_64], eax
mov ebx, 1
mov r15d, r12d
mov ebp, eax
mov [rsp+78h+var_74], 0
loc_1C28:
cmp ebp, 1
jle loc_1DA0
mov edi, r15d
cmp r15d, 1
jle loc_1CE0
mov edx, r15d
xor r14d, r14d
lea r12d, [r15-1]
xor ecx, ecx
loc_1C4A:
mov [rsp+78h+var_40], ecx
mov [rsp+78h+var_44], edx
call func0_part_0
mov ecx, [rsp+78h+var_40]
mov edi, 1
mov edx, [rsp+78h+var_44]
add r14d, eax
test r15d, r15d
cmovle edi, r15d
lea eax, [rcx+1]
cmp eax, edi
jle loc_25FF
nop dword ptr [rax+00000000h]
loc_1C80:
cmp ebp, eax
jle short loc_1CFC
nop dword ptr [rax+00h]
loc_1C88:
mov edx, ebp
sub ebp, 1
sub edx, eax
lea r15d, [rdx-1]
loc_1C93:
mov edi, ebp
sub edi, r15d
call func0_part_0
cmp r15d, 1
jle short loc_1CD0
loc_1CA3:
mov edi, r15d
mov [rsp+78h+var_44], eax
sub r15d, 1
call func0_part_0
mov edx, [rsp+78h+var_44]
mov edi, ebp
sub edi, r15d
imul edx, eax
add r14d, edx
call func0_part_0
cmp r15d, 1
jg short loc_1CA3
nop dword ptr [rax]
loc_1CD0:
add r14d, eax
test r15d, r15d
jz short loc_1CFF
xor r15d, r15d
jmp short loc_1C93
loc_1CE0:
test r15d, r15d
jg loc_2020
mov eax, 1
mov r14d, 1
lea r12d, [r15-1]
cmp ebp, eax
jg short loc_1C88
loc_1CFC:
sub ebp, 1
loc_1CFF:
mov esi, ebx
add r13d, 1
mov r15d, r12d
imul esi, r14d
add [rsp+78h+var_74], esi
loc_1D10:
cmp r13d, 1
jz loc_26E7
lea r14d, [r13-1]
mov edi, r14d
cmp r14d, 1
jz loc_2508
mov r12d, r14d
xor ebx, ebx
xor edx, edx
loc_1D32:
mov [rsp+78h+var_44], edx
call func0_part_0
mov edx, [rsp+78h+var_44]
add ebx, eax
test edx, edx
jz loc_25E4
nop dword ptr [rax+00000000h]
loc_1D50:
lea r12d, [r13-3]
cmp r13d, 2
jz loc_1C28
loc_1D5E:
mov edi, r14d
sub edi, r12d
call func0_part_0
cmp r12d, 1
jle short loc_1D90
mov edi, r12d
mov [rsp+78h+var_44], eax
sub r12d, 1
call func0_part_0
mov edx, [rsp+78h+var_44]
imul eax, edx
add ebx, eax
jmp short loc_1D5E
loc_1D90:
add ebx, eax
test r12d, r12d
jz loc_1C28
xor r12d, r12d
jmp short loc_1D5E
loc_1DA0:
add [rsp+78h+var_74], ebx
test ebp, ebp
jz short loc_1DC0
add r13d, 1
sub r15d, 1
xor ebp, ebp
jmp loc_1D10
loc_1DC0:
mov ebp, [rsp+78h+var_60]
mov r14d, [rsp+78h+var_74]
add [rsp+78h+var_70], 1
mov r15d, [rsp+78h+var_64]
imul r14d, ebp
add [rsp+78h+var_6C], r14d
loc_1DDC:
cmp [rsp+78h+var_70], 1
jz loc_26FB
mov eax, [rsp+78h+var_70]
mov [rsp+78h+var_64], r15d
xor r13d, r13d
xor ebp, ebp
mov ebx, 1
lea r12d, [rax-1]
lea esi, [rax-2]
mov ecx, r12d
mov r15d, esi
loc_1E07:
cmp ecx, 1
jle loc_1F90
mov edi, r15d
cmp r15d, 1
jle loc_1EB8
lea eax, [r15-1]
mov edx, r15d
xor r14d, r14d
xor r12d, r12d
mov [rsp+78h+var_74], eax
loc_1E2E:
mov [rsp+78h+var_44], ecx
mov [rsp+78h+var_60], edx
call func0_part_0
mov edi, 1
mov edx, [rsp+78h+var_60]
mov ecx, [rsp+78h+var_44]
add r14d, eax
test r15d, r15d
lea eax, [r12+1]
cmovle edi, r15d
cmp edi, eax
jge loc_25DC
nop
loc_1E60:
cmp ecx, eax
jle short loc_1ED8
nop dword ptr [rax+00h]
loc_1E68:
mov edx, ecx
lea r12d, [rcx-1]
sub edx, eax
lea r15d, [rdx-1]
loc_1E74:
mov edi, r12d
sub edi, r15d
call func0_part_0
cmp r15d, 1
jle short loc_1EA8
mov edi, r15d
mov [rsp+78h+var_60], eax
sub r15d, 1
call func0_part_0
mov edx, [rsp+78h+var_60]
imul edx, eax
add r14d, edx
jmp short loc_1E74
loc_1EA8:
add r14d, eax
test r15d, r15d
jz short loc_1EDC
xor r15d, r15d
jmp short loc_1E74
loc_1EB8:
test r15d, r15d
jg loc_1FE8
lea esi, [r15-1]
mov eax, 1
mov r14d, 1
mov [rsp+78h+var_74], esi
cmp ecx, eax
jg short loc_1E68
loc_1ED8:
lea r12d, [rcx-1]
loc_1EDC:
imul ebx, r14d
mov r15d, [rsp+78h+var_74]
add r13d, 1
mov ecx, r12d
add ebp, ebx
loc_1EEE:
cmp r13d, 1
jz loc_26F1
lea r12d, [r13-1]
mov edi, r12d
cmp r12d, 1
jz loc_2528
mov r14d, r12d
xor edx, edx
xor ebx, ebx
loc_1F10:
mov [rsp+78h+var_60], edx
mov [rsp+78h+var_74], ecx
call func0_part_0
mov edx, [rsp+78h+var_60]
mov ecx, [rsp+78h+var_74]
add ebx, eax
test edx, edx
jz loc_25C1
nop
loc_1F30:
lea r14d, [r13-3]
cmp r13d, 2
jz loc_1E07
mov [rsp+78h+var_74], ebp
mov ebp, ebx
mov ebx, r14d
mov r14d, ecx
loc_1F4A:
mov edi, r12d
sub edi, ebx
call func0_part_0
cmp ebx, 1
jle short loc_1F80
loc_1F59:
mov edi, ebx
mov [rsp+78h+var_60], eax
sub ebx, 1
call func0_part_0
mov edx, [rsp+78h+var_60]
mov edi, r12d
sub edi, ebx
imul edx, eax
add ebp, edx
call func0_part_0
cmp ebx, 1
jg short loc_1F59
nop
loc_1F80:
add ebp, eax
test ebx, ebx
jz short loc_1FA8
xor ebx, ebx
jmp short loc_1F4A
loc_1F90:
add ebp, ebx
test ecx, ecx
jz short loc_1FC0
add r13d, 1
sub r15d, 1
xor ecx, ecx
jmp loc_1EEE
loc_1FA8:
mov ebx, ebp
mov ecx, r14d
mov ebp, [rsp+78h+var_74]
jmp loc_1E07
loc_1FC0:
mov r15d, [rsp+78h+var_64]
cmp r15d, 1
jg loc_1C03
loc_1FCF:
add [rsp+78h+var_6C], ebp
test r15d, r15d
jz short loc_2050
add [rsp+78h+var_70], 1
xor r15d, r15d
jmp loc_1DDC
loc_1FE8:
lea eax, [r15-1]
mov r14d, 1
mov [rsp+78h+var_74], eax
mov edx, eax
loc_1FF8:
mov edi, edx
mov r12d, 1
cmp edx, 1
jg loc_1E2E
add r14d, 1
mov eax, 2
jmp loc_1E60
loc_2020:
lea r12d, [r15-1]
mov r14d, 1
mov edx, r12d
loc_202D:
mov edi, edx
mov ecx, 1
cmp edx, 1
jg loc_1C4A
add r14d, 1
mov eax, 2
jmp loc_1C80
loc_2050:
mov eax, [rsp+78h+var_68]
mov ecx, [rsp+78h+var_6C]
add [rsp+78h+var_5C], 1
mov r12d, [rsp+78h+var_54]
imul eax, ecx
add [rsp+78h+var_58], eax
mov ebp, r12d
loc_206C:
cmp [rsp+78h+var_5C], 1
jz loc_2695
mov eax, [rsp+78h+var_5C]
mov [rsp+78h+var_68], 0
mov [rsp+78h+var_6C], 0
mov [rsp+78h+var_74], 1
lea r12d, [rax-1]
mov [rsp+78h+var_60], ebp
loc_209B:
cmp r12d, 1
jle loc_244F
loc_20A5:
lea r15d, [r12-1]
lea ebp, [r12-2]
xor r13d, r13d
mov ebx, 1
mov [rsp+78h+var_70], 0
mov r12d, ebp
mov [rsp+78h+var_64], r15d
loc_20C7:
cmp r15d, 1
jle loc_2240
mov edi, r12d
cmp r12d, 1
jle loc_2178
mov edx, r12d
xor ecx, ecx
lea ebp, [r12-1]
xor r14d, r14d
loc_20EB:
mov [rsp+78h+var_44], ecx
mov [rsp+78h+var_54], edx
call func0_part_0
mov ecx, [rsp+78h+var_44]
mov edi, 1
mov edx, [rsp+78h+var_54]
add r14d, eax
test r12d, r12d
cmovle edi, r12d
lea eax, [rcx+1]
cmp edi, eax
jge loc_25B9
nop word ptr [rax+rax+00h]
loc_2120:
cmp r15d, eax
jle short loc_2196
nop dword ptr [rax]
loc_2128:
mov edx, r15d
sub r15d, 1
sub edx, eax
lea r12d, [rdx-1]
loc_2135:
mov edi, r15d
sub edi, r12d
call func0_part_0
cmp r12d, 1
jle short loc_2168
mov edi, r12d
mov [rsp+78h+var_54], eax
sub r12d, 1
call func0_part_0
mov edx, [rsp+78h+var_54]
imul edx, eax
add r14d, edx
jmp short loc_2135
loc_2168:
add r14d, eax
test r12d, r12d
jz short loc_219A
xor r12d, r12d
jmp short loc_2135
loc_2178:
test r12d, r12d
jg loc_2470
mov eax, 1
mov r14d, 1
lea ebp, [r12-1]
cmp r15d, eax
jg short loc_2128
loc_2196:
sub r15d, 1
loc_219A:
mov esi, ebx
add r13d, 1
mov r12d, ebp
imul esi, r14d
add [rsp+78h+var_70], esi
loc_21AB:
cmp r13d, 1
jz loc_271C
lea r14d, [r13-1]
mov edi, r14d
cmp r14d, 1
jz loc_24F8
mov ebp, r14d
xor ebx, ebx
xor edx, edx
loc_21CD:
mov [rsp+78h+var_54], edx
call func0_part_0
mov edx, [rsp+78h+var_54]
add ebx, eax
test edx, edx
jz loc_25A1
nop dword ptr [rax+00h]
loc_21E8:
lea ebp, [r13-3]
cmp r13d, 2
jz loc_20C7
loc_21F6:
mov edi, r14d
sub edi, ebp
call func0_part_0
cmp ebp, 1
jle short loc_2230
loc_2205:
mov edi, ebp
mov [rsp+78h+var_54], eax
sub ebp, 1
call func0_part_0
mov edx, [rsp+78h+var_54]
mov edi, r14d
sub edi, ebp
imul edx, eax
add ebx, edx
call func0_part_0
cmp ebp, 1
jg short loc_2205
nop dword ptr [rax+rax+00h]
loc_2230:
add ebx, eax
test ebp, ebp
jz loc_20C7
xor ebp, ebp
jmp short loc_21F6
loc_2240:
add [rsp+78h+var_70], ebx
test r15d, r15d
jz short loc_2260
add r13d, 1
sub r12d, 1
xor r15d, r15d
jmp loc_21AB
loc_2260:
mov r14d, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
add [rsp+78h+var_6C], 1
mov r15d, [rsp+78h+var_64]
imul r14d, eax
add [rsp+78h+var_68], r14d
mov r12d, r15d
loc_227F:
cmp [rsp+78h+var_6C], 1
jz loc_270F
mov eax, [rsp+78h+var_6C]
mov [rsp+78h+var_70], r12d
xor r13d, r13d
mov ebx, 1
mov [rsp+78h+var_74], 0
lea ebp, [rax-1]
lea r15d, [rax-2]
mov r14d, r15d
mov r12d, ebp
loc_22B0:
cmp r12d, 1
jle loc_2420
mov edi, r14d
cmp r14d, 1
jle loc_2358
mov edx, r14d
xor ebp, ebp
lea r15d, [r14-1]
xor ecx, ecx
loc_22D2:
mov [rsp+78h+var_54], ecx
mov [rsp+78h+var_64], edx
call func0_part_0
mov ecx, [rsp+78h+var_54]
mov edi, 1
mov edx, [rsp+78h+var_64]
add ebp, eax
test r14d, r14d
cmovle edi, r14d
lea eax, [rcx+1]
cmp edi, eax
jge loc_2599
loc_2300:
cmp r12d, eax
jle short loc_2374
nop dword ptr [rax]
loc_2308:
mov edx, r12d
sub r12d, 1
sub edx, eax
lea r14d, [rdx-1]
loc_2315:
mov edi, r12d
sub edi, r14d
call func0_part_0
cmp r14d, 1
jle short loc_2348
mov edi, r14d
mov [rsp+78h+var_64], eax
sub r14d, 1
call func0_part_0
mov edx, [rsp+78h+var_64]
imul edx, eax
add ebp, edx
jmp short loc_2315
loc_2348:
add ebp, eax
test r14d, r14d
jz short loc_2378
xor r14d, r14d
jmp short loc_2315
loc_2358:
test r14d, r14d
jg loc_24A0
mov eax, 1
mov ebp, 1
lea r15d, [r14-1]
cmp r12d, eax
jg short loc_2308
loc_2374:
sub r12d, 1
loc_2378:
mov esi, ebx
add r13d, 1
mov r14d, r15d
imul esi, ebp
add [rsp+78h+var_74], esi
loc_2388:
cmp r13d, 1
jz loc_2705
lea ebp, [r13-1]
mov edi, ebp
cmp ebp, 1
jz loc_2518
mov r15d, ebp
xor edx, edx
xor ebx, ebx
loc_23A8:
mov [rsp+78h+var_64], edx
call func0_part_0
mov edx, [rsp+78h+var_64]
add ebx, eax
test edx, edx
jz loc_2582
nop
loc_23C0:
lea r15d, [r13-3]
cmp r13d, 2
jz loc_22B0
loc_23CE:
mov edi, ebp
sub edi, r15d
call func0_part_0
cmp r15d, 1
jle short loc_2410
loc_23DE:
mov edi, r15d
mov [rsp+78h+var_64], eax
sub r15d, 1
call func0_part_0
mov edx, [rsp+78h+var_64]
mov edi, ebp
sub edi, r15d
imul edx, eax
add ebx, edx
call func0_part_0
cmp r15d, 1
jg short loc_23DE
nop word ptr [rax+rax+00000000h]
loc_2410:
add ebx, eax
test r15d, r15d
jz loc_22B0
xor r15d, r15d
jmp short loc_23CE
loc_2420:
add [rsp+78h+var_74], ebx
test r12d, r12d
jz short loc_2440
add r13d, 1
sub r14d, 1
xor r12d, r12d
jmp loc_2388
loc_2440:
mov r12d, [rsp+78h+var_70]
cmp r12d, 1
jg loc_20A5
loc_244F:
mov ecx, [rsp+78h+var_74]
add [rsp+78h+var_68], ecx
test r12d, r12d
jz short loc_24D0
add [rsp+78h+var_6C], 1
xor r12d, r12d
jmp loc_227F
loc_2470:
lea ebp, [r12-1]
mov r14d, 1
mov edx, ebp
loc_247D:
mov edi, edx
mov ecx, 1
cmp edx, 1
jg loc_20EB
add r14d, 1
mov eax, 2
jmp loc_2120
loc_24A0:
lea r15d, [r14-1]
mov ebp, 1
mov edx, r15d
loc_24AC:
mov edi, edx
mov ecx, 1
cmp edx, 1
jg loc_22D2
add ebp, 1
mov eax, 2
jmp loc_2300
loc_24D0:
mov ebp, [rsp+78h+var_60]
cmp ebp, 1
jg loc_1BD8
loc_24DD:
mov ecx, [rsp+78h+var_68]
add [rsp+78h+var_58], ecx
test ebp, ebp
jz short loc_2535
add [rsp+78h+var_5C], 1
xor ebp, ebp
jmp loc_206C
loc_24F8:
mov ebx, 1
loc_24FD:
add ebx, 1
jmp loc_21E8
loc_2508:
mov ebx, 1
loc_250D:
add ebx, 1
jmp loc_1D50
loc_2518:
mov ebx, 1
loc_251D:
add ebx, 1
jmp loc_23C0
loc_2528:
mov ebx, 1
loc_252D:
add ebx, 1
jmp loc_1F30
loc_2535:
mov ebx, [rsp+78h+var_50]
cmp ebx, 1
jg loc_1228
loc_2542:
mov ecx, [rsp+78h+var_58]
add [rsp+78h+var_48], ecx
test ebx, ebx
jz short loc_256D
add [rsp+78h+var_4C], 1
xor ebx, ebx
cmp [rsp+78h+var_4C], 1
jnz loc_1BA8
loc_2560:
mov [rsp+78h+var_58], 1
jmp loc_121F
loc_256D:
mov ebp, [rsp+78h+var_48]
loc_2571:
add rsp, 48h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_2582:
sub r15d, 1
cmp r15d, 1
jbe short loc_251D
mov edi, r15d
mov edx, 1
jmp loc_23A8
loc_2599:
sub edx, 1
jmp loc_24AC
loc_25A1:
sub ebp, 1
cmp ebp, 1
jbe loc_24FD
mov edi, ebp
mov edx, 1
jmp loc_21CD
loc_25B9:
sub edx, 1
jmp loc_247D
loc_25C1:
sub r14d, 1
cmp r14d, 1
jbe loc_252D
mov edi, r14d
mov edx, 1
jmp loc_1F10
loc_25DC:
sub edx, 1
jmp loc_1FF8
loc_25E4:
sub r12d, 1
cmp r12d, 1
jbe loc_250D
mov edi, r12d
mov edx, 1
jmp loc_1D32
loc_25FF:
sub edx, 1
jmp loc_202D
loc_2607:
sub edx, 1
cmp edx, 1
jbe loc_1B6D
mov edi, edx
mov r15d, 1
jmp loc_1A04
loc_2620:
sub r8d, 1
jmp loc_1AF5
loc_2629:
sub ebp, 1
cmp ebp, 1
jbe loc_1B4D
mov edi, ebp
mov edx, 1
jmp loc_181D
loc_2641:
sub edx, 1
jmp loc_1AC4
loc_2649:
sub edx, 1
cmp edx, 1
jbe loc_1B7D
mov edi, edx
mov r15d, 1
jmp loc_1594
loc_2662:
sub r8d, 1
jmp loc_1655
loc_266B:
sub ebp, 1
cmp ebp, 1
jbe loc_1B5D
mov edi, ebp
mov edx, 1
jmp loc_13A5
loc_2683:
sub edx, 1
jmp loc_1684
loc_268B:
mov ebx, 1
jmp loc_1489
loc_2695:
mov [rsp+78h+var_68], 1
jmp loc_1BCF
loc_26A2:
mov [rsp+78h+var_74], 1
jmp loc_1278
loc_26AF:
mov ebx, 1
jmp loc_18F9
loc_26B9:
mov [rsp+78h+var_74], 1
jmp loc_16F4
loc_26C6:
mov ebx, 1
jmp loc_171D
loc_26D0:
mov [rsp+78h+var_68], 1
jmp loc_124A
loc_26DD:
mov ebx, 1
jmp loc_12A1
loc_26E7:
mov ebx, 1
jmp loc_1C28
loc_26F1:
mov ebx, 1
jmp loc_1E07
loc_26FB:
mov ebp, 1
jmp loc_1BF9
loc_2705:
mov ebx, 1
jmp loc_22B0
loc_270F:
mov [rsp+78h+var_74], 1
jmp loc_209B
loc_271C:
mov ebx, 1
jmp loc_20C7 | long long func0_part_0(int a1)
{
unsigned int v1; // ebp
int v2; // ebx
int v3; // r12d
int v4; // ebp
int v5; // r12d
int v6; // ebx
int v7; // r14d
int v8; // r15d
long long v9; // rdi
int j; // edx
int v11; // ecx
int v12; // ebp
int v13; // r13d
int v14; // eax
int v15; // edx
int i; // r15d
int v17; // eax
long long v18; // rdi
int v19; // r13d
long long v20; // rdi
unsigned int v21; // ebp
int k; // edx
int v23; // ebp
int m; // eax
long long v25; // rdi
int v26; // r13d
int v27; // ebx
int v28; // r14d
int v29; // ebp
long long v30; // rdi
int n; // r8d
int v32; // r15d
int v33; // r12d
int v34; // edx
int v35; // eax
int v36; // edx
int ii; // ebp
int jj; // eax
long long v39; // rdi
long long v40; // rdi
unsigned int v41; // edx
int v42; // r15d
int v43; // r15d
int v44; // eax
long long v45; // rdi
int v46; // ebp
int v47; // r12d
int v48; // ebx
int v49; // r14d
int v50; // r15d
long long v51; // rdi
int kk; // edx
int v53; // r13d
int v54; // ebp
int v55; // ecx
int v56; // eax
int v57; // edx
int mm; // r14d
int v59; // eax
long long v60; // rdi
int v61; // r13d
long long v62; // rdi
unsigned int v63; // ebp
int nn; // edx
int v65; // ebp
int i1; // eax
long long v67; // rdi
int v68; // r13d
int v69; // ebx
int v70; // r14d
int v71; // ebp
long long v72; // rdi
int i2; // r8d
int v74; // r15d
int v75; // r12d
int v76; // edx
int v77; // eax
int v78; // edx
int i3; // ebp
int i4; // eax
long long v81; // rdi
long long v82; // rdi
unsigned int v83; // edx
int i5; // r15d
int v85; // r15d
int v86; // eax
long long v87; // rdi
int v88; // ebp
int v89; // r12d
int v90; // ebp
int v91; // r15d
int v92; // r13d
int v93; // ebx
int v94; // r15d
int v95; // ebp
long long v96; // rdi
int i6; // edx
int v98; // r14d
int v99; // r12d
int v100; // ecx
int v101; // eax
int v102; // edx
int i7; // r15d
int i8; // eax
long long v105; // rdi
long long v106; // rdi
unsigned int v107; // r12d
int i9; // edx
int v109; // r12d
int v110; // eax
long long v111; // rdi
int v112; // r13d
int v113; // ebx
int v114; // ecx
int v115; // r15d
long long v116; // rdi
int i10; // edx
int v118; // r14d
int v119; // r12d
int v120; // eax
int v121; // eax
int v122; // r12d
int i11; // r15d
int v124; // eax
long long v125; // rdi
int v126; // r12d
long long v127; // rdi
unsigned int v128; // r14d
int v129; // edx
int v130; // eax
int v131; // ebp
int v132; // ebx
int v133; // r14d
int i12; // eax
long long v135; // rdi
int v136; // r12d
int v137; // r15d
int v138; // r13d
int v139; // ebx
int v140; // r12d
long long v141; // rdi
int i13; // edx
int v143; // ecx
int v144; // ebp
int v145; // r14d
int v146; // eax
int v147; // edx
int i14; // r12d
int v149; // eax
long long v150; // rdi
int v151; // r14d
long long v152; // rdi
unsigned int v153; // ebp
int i15; // edx
int v155; // ebp
int i16; // eax
long long v157; // rdi
int v158; // r13d
int v159; // ebx
int v160; // r14d
int v161; // r12d
long long v162; // rdi
int i17; // edx
int v164; // ebp
int v165; // r15d
int v166; // ecx
int v167; // eax
int v168; // edx
int i18; // r14d
int v170; // eax
long long v171; // rdi
int v172; // ebp
long long v173; // rdi
unsigned int v174; // r15d
int v175; // edx
int v176; // r15d
int i19; // eax
long long v178; // rdi
int v180; // [rsp+4h] [rbp-74h]
int v181; // [rsp+4h] [rbp-74h]
int v182; // [rsp+4h] [rbp-74h]
int v183; // [rsp+4h] [rbp-74h]
int v184; // [rsp+4h] [rbp-74h]
int v185; // [rsp+4h] [rbp-74h]
int v186; // [rsp+4h] [rbp-74h]
int v187; // [rsp+8h] [rbp-70h]
int v188; // [rsp+8h] [rbp-70h]
int v189; // [rsp+8h] [rbp-70h]
int v190; // [rsp+8h] [rbp-70h]
int v191; // [rsp+8h] [rbp-70h]
int v192; // [rsp+8h] [rbp-70h]
int v193; // [rsp+8h] [rbp-70h]
int v194; // [rsp+Ch] [rbp-6Ch]
int v195; // [rsp+Ch] [rbp-6Ch]
int v196; // [rsp+Ch] [rbp-6Ch]
int v197; // [rsp+Ch] [rbp-6Ch]
int v198; // [rsp+10h] [rbp-68h]
int v199; // [rsp+10h] [rbp-68h]
int v200; // [rsp+14h] [rbp-64h]
int v201; // [rsp+14h] [rbp-64h]
int v202; // [rsp+14h] [rbp-64h]
unsigned int v203; // [rsp+14h] [rbp-64h]
int v204; // [rsp+14h] [rbp-64h]
int v205; // [rsp+14h] [rbp-64h]
int v206; // [rsp+14h] [rbp-64h]
int v207; // [rsp+14h] [rbp-64h]
int v208; // [rsp+14h] [rbp-64h]
int v209; // [rsp+18h] [rbp-60h]
int v210; // [rsp+18h] [rbp-60h]
unsigned int v211; // [rsp+18h] [rbp-60h]
int v212; // [rsp+18h] [rbp-60h]
int v213; // [rsp+18h] [rbp-60h]
int v214; // [rsp+18h] [rbp-60h]
int v215; // [rsp+18h] [rbp-60h]
int v216; // [rsp+18h] [rbp-60h]
int v217; // [rsp+1Ch] [rbp-5Ch]
int v218; // [rsp+1Ch] [rbp-5Ch]
int v219; // [rsp+20h] [rbp-58h]
int v220; // [rsp+24h] [rbp-54h]
int v221; // [rsp+24h] [rbp-54h]
int v222; // [rsp+24h] [rbp-54h]
int v223; // [rsp+24h] [rbp-54h]
int v224; // [rsp+24h] [rbp-54h]
int v225; // [rsp+28h] [rbp-50h]
int v226; // [rsp+28h] [rbp-50h]
int v227; // [rsp+28h] [rbp-50h]
int v228; // [rsp+28h] [rbp-50h]
int v229; // [rsp+28h] [rbp-50h]
int v230; // [rsp+2Ch] [rbp-4Ch]
unsigned int v231; // [rsp+30h] [rbp-48h]
int v232; // [rsp+34h] [rbp-44h]
int v233; // [rsp+34h] [rbp-44h]
int v234; // [rsp+34h] [rbp-44h]
int v235; // [rsp+34h] [rbp-44h]
int v236; // [rsp+34h] [rbp-44h]
int v237; // [rsp+38h] [rbp-40h]
int v238; // [rsp+38h] [rbp-40h]
int v239; // [rsp+38h] [rbp-40h]
int v240; // [rsp+38h] [rbp-40h]
int v241; // [rsp+38h] [rbp-40h]
int v242; // [rsp+3Ch] [rbp-3Ch]
v1 = 0;
if ( a1 <= 0 )
return v1;
v219 = 1;
v2 = a1 - 1;
v230 = 0;
v231 = 0;
LABEL_3:
if ( v2 <= 1 )
goto LABEL_298;
do
{
v217 = 0;
v220 = 0;
v3 = v2 - 1;
v198 = 1;
v232 = v2 - 1;
LABEL_5:
if ( v3 <= 1 )
goto LABEL_139;
do
{
v194 = 0;
v180 = 1;
v4 = v3 - 1;
v200 = 0;
v225 = v3 - 1;
LABEL_7:
if ( v4 <= 1 )
goto LABEL_63;
do
{
v5 = 0;
v6 = 1;
v209 = v4 - 1;
v7 = v4 - 1;
v8 = v4 - 2;
v187 = 0;
while ( v7 > 1 )
{
v9 = (unsigned int)v8;
if ( v8 > 1 )
{
j = v8;
v11 = 0;
v12 = v8 - 1;
v13 = 0;
goto LABEL_12;
}
if ( v8 <= 0 )
{
v14 = 1;
v13 = 1;
v12 = v8 - 1;
LABEL_14:
v15 = v7--;
for ( i = v15 - v14 - 1; ; i = 0 )
{
while ( 1 )
{
v17 = func0_part_0((unsigned int)(v7 - i));
if ( i <= 1 )
break;
v18 = (unsigned int)i--;
v13 += func0_part_0(v18) * v17;
}
v13 += v17;
if ( !i )
break;
}
goto LABEL_22;
}
v12 = v8 - 1;
v13 = 1;
for ( j = v8 - 1; ; j = v237 - 1 )
{
v9 = (unsigned int)j;
v11 = 1;
if ( j <= 1 )
break;
LABEL_12:
v242 = v11;
v237 = j;
v13 += func0_part_0(v9);
v14 = v242 + 1;
if ( v242 + 1 > 1 )
goto LABEL_13;
}
++v13;
v14 = 2;
LABEL_13:
if ( v7 > v14 )
goto LABEL_14;
--v7;
LABEL_22:
++v5;
v8 = v12;
v187 += v6 * v13;
LABEL_23:
if ( v5 == 1 )
{
v6 = 1;
}
else
{
v19 = v5 - 1;
v20 = (unsigned int)(v5 - 1);
if ( v5 == 2 )
{
v6 = 1;
LABEL_144:
++v6;
}
else
{
v21 = v5 - 1;
v6 = 0;
for ( k = 0; ; k = 1 )
{
v238 = k;
v6 += func0_part_0(v20);
if ( v238 )
break;
if ( --v21 <= 1 )
goto LABEL_144;
v20 = v21;
}
}
v23 = v5 - 3;
if ( v5 != 2 )
{
while ( 1 )
{
for ( m = func0_part_0((unsigned int)(v19 - v23)); v23 > 1; m = func0_part_0((unsigned int)(v19 - v23)) )
{
v25 = (unsigned int)v23--;
v6 += func0_part_0(v25) * m;
}
v6 += m;
if ( !v23 )
break;
v23 = 0;
}
}
}
}
v187 += v6;
if ( v7 )
{
++v5;
--v8;
v7 = 0;
goto LABEL_23;
}
++v194;
v4 = v209;
v200 += v187 * v180;
LABEL_35:
if ( v194 == 1 )
{
v180 = 1;
goto LABEL_7;
}
v188 = v4;
v26 = 0;
v27 = 1;
v180 = 0;
v28 = v194 - 1;
v29 = v194 - 2;
while ( 2 )
{
if ( v28 > 1 )
{
v30 = (unsigned int)v29;
if ( v29 > 1 )
{
n = v29;
v32 = 0;
v33 = v29 - 1;
v34 = 0;
goto LABEL_40;
}
if ( v29 <= 0 )
{
v35 = 1;
v32 = 1;
v33 = v29 - 1;
goto LABEL_42;
}
v33 = v29 - 1;
v32 = 1;
for ( n = v29 - 1; ; n = v210 - 1 )
{
v30 = (unsigned int)n;
v34 = 1;
if ( n <= 1 )
break;
LABEL_40:
v239 = v34;
v210 = n;
v32 += func0_part_0(v30);
v35 = v239 + 1;
if ( v239 + 1 > 1 )
goto LABEL_41;
}
++v32;
v35 = 2;
LABEL_41:
if ( v28 <= v35 )
{
--v28;
}
else
{
LABEL_42:
v36 = v28--;
for ( ii = v36 - v35 - 1; ; ii = 0 )
{
for ( jj = func0_part_0((unsigned int)(v28 - ii)); ii > 1; jj = func0_part_0((unsigned int)(v28 - ii)) )
{
v39 = (unsigned int)ii--;
v32 += func0_part_0(v39) * jj;
}
v32 += jj;
if ( !ii )
break;
}
}
++v26;
v29 = v33;
v180 += v32 * v27;
LABEL_51:
if ( v26 == 1 )
{
v27 = 1;
}
else
{
v40 = (unsigned int)(v26 - 1);
if ( v26 == 2 )
{
v27 = 1;
LABEL_148:
++v27;
}
else
{
v41 = v26 - 1;
v42 = 0;
v27 = 0;
while ( 1 )
{
v211 = v41;
v27 += func0_part_0(v40);
if ( v42 )
break;
v41 = v211 - 1;
if ( v211 - 1 <= 1 )
goto LABEL_148;
v40 = v41;
v42 = 1;
}
}
v43 = v26 - 3;
if ( v26 != 2 )
{
while ( 1 )
{
while ( 1 )
{
v44 = func0_part_0((unsigned int)(v26 - 1 - v43));
if ( v43 <= 1 )
break;
v45 = (unsigned int)v43--;
v27 += v44 * func0_part_0(v45);
}
v27 += v44;
if ( !v43 )
break;
v43 = 0;
}
}
}
continue;
}
break;
}
v180 += v27;
if ( v28 )
{
++v26;
--v29;
v28 = 0;
goto LABEL_51;
}
v4 = v188;
}
while ( v188 > 1 );
LABEL_63:
v200 += v180;
if ( v4 )
{
++v194;
v4 = 0;
goto LABEL_35;
}
++v217;
v3 = v225;
v220 += v200 * v198;
LABEL_72:
if ( v217 == 1 )
{
v198 = 1;
goto LABEL_5;
}
v198 = 0;
v195 = 0;
v181 = 1;
v212 = v3;
v46 = v217 - 1;
while ( 2 )
{
if ( v46 <= 1 )
goto LABEL_130;
LABEL_75:
v47 = 0;
v48 = 1;
v201 = v46 - 1;
v49 = v46 - 2;
v50 = v46 - 1;
v189 = 0;
while ( 2 )
{
if ( v50 > 1 )
{
v51 = (unsigned int)v49;
if ( v49 > 1 )
{
kk = v49;
v53 = 0;
v54 = v49 - 1;
v55 = 0;
goto LABEL_79;
}
if ( v49 <= 0 )
{
v56 = 1;
v53 = 1;
v54 = v49 - 1;
goto LABEL_81;
}
v54 = v49 - 1;
v53 = 1;
for ( kk = v49 - 1; ; kk = v226 - 1 )
{
v51 = (unsigned int)kk;
v55 = 1;
if ( kk <= 1 )
break;
LABEL_79:
v240 = v55;
v226 = kk;
v53 += func0_part_0(v51);
v56 = v240 + 1;
if ( v240 + 1 > 1 )
goto LABEL_80;
}
++v53;
v56 = 2;
LABEL_80:
if ( v50 <= v56 )
{
--v50;
}
else
{
LABEL_81:
v57 = v50--;
for ( mm = v57 - v56 - 1; ; mm = 0 )
{
while ( 1 )
{
v59 = func0_part_0((unsigned int)(v50 - mm));
if ( mm <= 1 )
break;
v60 = (unsigned int)mm--;
v53 += func0_part_0(v60) * v59;
}
v53 += v59;
if ( !mm )
break;
}
}
++v47;
v49 = v54;
v189 += v53 * v48;
LABEL_90:
if ( v47 == 1 )
{
v48 = 1;
}
else
{
v61 = v47 - 1;
v62 = (unsigned int)(v47 - 1);
if ( v47 == 2 )
{
v48 = 1;
LABEL_142:
++v48;
}
else
{
v63 = v47 - 1;
v48 = 0;
for ( nn = 0; ; nn = 1 )
{
v227 = nn;
v48 += func0_part_0(v62);
if ( v227 )
break;
if ( --v63 <= 1 )
goto LABEL_142;
v62 = v63;
}
}
v65 = v47 - 3;
if ( v47 != 2 )
{
while ( 1 )
{
for ( i1 = func0_part_0((unsigned int)(v61 - v65)); v65 > 1; i1 = func0_part_0((unsigned int)(v61 - v65)) )
{
v67 = (unsigned int)v65--;
v48 += func0_part_0(v67) * i1;
}
v48 += i1;
if ( !v65 )
break;
v65 = 0;
}
}
}
continue;
}
break;
}
v189 += v48;
if ( v50 )
{
++v47;
--v49;
v50 = 0;
goto LABEL_90;
}
++v195;
v46 = v201;
v198 += v189 * v181;
LABEL_102:
if ( v195 == 1 )
{
v181 = 1;
continue;
}
break;
}
v190 = v46;
v68 = 0;
v69 = 1;
v181 = 0;
v70 = v195 - 1;
v71 = v195 - 2;
while ( 2 )
{
if ( v70 > 1 )
{
v72 = (unsigned int)v71;
if ( v71 > 1 )
{
i2 = v71;
v74 = 0;
v75 = v71 - 1;
v76 = 0;
goto LABEL_107;
}
if ( v71 <= 0 )
{
v77 = 1;
v74 = 1;
v75 = v71 - 1;
goto LABEL_109;
}
v75 = v71 - 1;
v74 = 1;
for ( i2 = v71 - 1; ; i2 = v202 - 1 )
{
v72 = (unsigned int)i2;
v76 = 1;
if ( i2 <= 1 )
break;
LABEL_107:
v228 = v76;
v202 = i2;
v74 += func0_part_0(v72);
v77 = v228 + 1;
if ( v228 + 1 > 1 )
goto LABEL_108;
}
++v74;
v77 = 2;
LABEL_108:
if ( v70 <= v77 )
{
--v70;
}
else
{
LABEL_109:
v78 = v70--;
for ( i3 = v78 - v77 - 1; ; i3 = 0 )
{
for ( i4 = func0_part_0((unsigned int)(v70 - i3)); i3 > 1; i4 = func0_part_0((unsigned int)(v70 - i3)) )
{
v81 = (unsigned int)i3--;
v74 += func0_part_0(v81) * i4;
}
v74 += i4;
if ( !i3 )
break;
}
}
++v68;
v71 = v75;
v181 += v74 * v69;
LABEL_118:
if ( v68 == 1 )
{
v69 = 1;
}
else
{
v82 = (unsigned int)(v68 - 1);
if ( v68 == 2 )
{
v69 = 1;
LABEL_146:
++v69;
}
else
{
v83 = v68 - 1;
v69 = 0;
for ( i5 = 0; ; i5 = 1 )
{
v203 = v83;
v69 += func0_part_0(v82);
if ( i5 )
break;
v83 = v203 - 1;
if ( v203 - 1 <= 1 )
goto LABEL_146;
v82 = v83;
}
}
v85 = v68 - 3;
if ( v68 != 2 )
{
while ( 1 )
{
while ( 1 )
{
v86 = func0_part_0((unsigned int)(v68 - 1 - v85));
if ( v85 <= 1 )
break;
v87 = (unsigned int)v85--;
v69 += v86 * func0_part_0(v87);
}
v69 += v86;
if ( !v85 )
break;
v85 = 0;
}
}
}
continue;
}
break;
}
v181 += v69;
if ( v70 )
{
++v68;
--v71;
v70 = 0;
goto LABEL_118;
}
v46 = v190;
if ( v190 > 1 )
goto LABEL_75;
LABEL_130:
v198 += v181;
if ( v46 )
{
++v195;
v46 = 0;
goto LABEL_102;
}
v3 = v212;
}
while ( v212 > 1 );
LABEL_139:
v220 += v198;
if ( v3 )
{
++v217;
v3 = 0;
goto LABEL_72;
}
++v230;
v2 = v232;
v231 += v220 * v219;
if ( v230 == 1 )
{
LABEL_300:
v219 = 1;
goto LABEL_3;
}
LABEL_150:
v229 = v2;
v219 = 0;
v199 = 1;
v218 = 0;
v88 = v230 - 1;
while ( 2 )
{
if ( v88 <= 1 )
goto LABEL_287;
LABEL_152:
v89 = v88 - 1;
v191 = 0;
v90 = 1;
v196 = 0;
v91 = v89;
v221 = v89;
while ( 2 )
{
if ( v91 <= 1 )
goto LABEL_211;
LABEL_154:
v213 = v90;
v92 = 0;
v204 = v91 - 1;
v93 = 1;
v94 = v91 - 2;
v95 = v204;
v182 = 0;
while ( 2 )
{
if ( v95 > 1 )
{
v96 = (unsigned int)v94;
if ( v94 > 1 )
{
i6 = v94;
v98 = 0;
v99 = v94 - 1;
v100 = 0;
goto LABEL_158;
}
if ( v94 <= 0 )
{
v101 = 1;
v98 = 1;
v99 = v94 - 1;
goto LABEL_160;
}
v99 = v94 - 1;
v98 = 1;
for ( i6 = v94 - 1; ; i6 = v233 - 1 )
{
v96 = (unsigned int)i6;
v100 = 1;
if ( i6 <= 1 )
break;
LABEL_158:
v241 = v100;
v233 = i6;
v98 += func0_part_0(v96);
v101 = v241 + 1;
if ( v241 + 1 > 1 )
goto LABEL_159;
}
++v98;
v101 = 2;
LABEL_159:
if ( v95 <= v101 )
{
--v95;
}
else
{
LABEL_160:
v102 = v95--;
for ( i7 = v102 - v101 - 1; ; i7 = 0 )
{
for ( i8 = func0_part_0((unsigned int)(v95 - i7)); i7 > 1; i8 = func0_part_0((unsigned int)(v95 - i7)) )
{
v105 = (unsigned int)i7--;
v98 += func0_part_0(v105) * i8;
}
v98 += i8;
if ( !i7 )
break;
}
}
++v92;
v94 = v99;
v182 += v98 * v93;
LABEL_169:
if ( v92 == 1 )
{
v93 = 1;
}
else
{
v106 = (unsigned int)(v92 - 1);
if ( v92 == 2 )
{
v93 = 1;
LABEL_292:
++v93;
}
else
{
v107 = v92 - 1;
v93 = 0;
for ( i9 = 0; ; i9 = 1 )
{
v234 = i9;
v93 += func0_part_0(v106);
if ( v234 )
break;
if ( --v107 <= 1 )
goto LABEL_292;
v106 = v107;
}
}
v109 = v92 - 3;
if ( v92 != 2 )
{
while ( 1 )
{
while ( 1 )
{
v110 = func0_part_0((unsigned int)(v92 - 1 - v109));
if ( v109 <= 1 )
break;
v111 = (unsigned int)v109--;
v93 += v110 * func0_part_0(v111);
}
v93 += v110;
if ( !v109 )
break;
v109 = 0;
}
}
}
continue;
}
break;
}
v182 += v93;
if ( v95 )
{
++v92;
--v94;
v95 = 0;
goto LABEL_169;
}
++v191;
v91 = v204;
v196 += v213 * v182;
LABEL_181:
if ( v191 == 1 )
{
v90 = 1;
continue;
}
break;
}
v205 = v91;
v112 = 0;
v90 = 0;
v113 = 1;
v114 = v191 - 1;
v115 = v191 - 2;
while ( 2 )
{
if ( v114 > 1 )
{
v116 = (unsigned int)v115;
if ( v115 > 1 )
{
i10 = v115;
v118 = 0;
v119 = 0;
v183 = v115 - 1;
goto LABEL_186;
}
if ( v115 <= 0 )
{
v121 = 1;
v118 = 1;
v183 = v115 - 1;
goto LABEL_188;
}
v118 = 1;
v183 = v115 - 1;
for ( i10 = v115 - 1; ; i10 = v214 - 1 )
{
v116 = (unsigned int)i10;
v119 = 1;
if ( i10 <= 1 )
break;
LABEL_186:
v235 = v114;
v214 = i10;
v120 = func0_part_0(v116);
v114 = v235;
v118 += v120;
v121 = v119 + 1;
if ( v119 + 1 > 1 )
goto LABEL_187;
}
++v118;
v121 = 2;
LABEL_187:
if ( v114 <= v121 )
{
v122 = v114 - 1;
}
else
{
LABEL_188:
v122 = v114 - 1;
for ( i11 = v114 - v121 - 1; ; i11 = 0 )
{
while ( 1 )
{
v124 = func0_part_0((unsigned int)(v122 - i11));
if ( i11 <= 1 )
break;
v125 = (unsigned int)i11--;
v118 += func0_part_0(v125) * v124;
}
v118 += v124;
if ( !i11 )
break;
}
}
v115 = v183;
++v112;
v114 = v122;
v90 += v118 * v113;
LABEL_197:
if ( v112 == 1 )
{
v113 = 1;
}
else
{
v126 = v112 - 1;
v127 = (unsigned int)(v112 - 1);
if ( v112 == 2 )
{
v113 = 1;
LABEL_296:
++v113;
}
else
{
v128 = v112 - 1;
v129 = 0;
v113 = 0;
while ( 1 )
{
v215 = v129;
v184 = v114;
v130 = func0_part_0(v127);
v114 = v184;
v113 += v130;
if ( v215 )
break;
if ( --v128 <= 1 )
goto LABEL_296;
v127 = v128;
v129 = 1;
}
}
if ( v112 != 2 )
{
v185 = v90;
v131 = v113;
v132 = v112 - 3;
v133 = v114;
while ( 1 )
{
for ( i12 = func0_part_0((unsigned int)(v126 - v132));
v132 > 1;
i12 = func0_part_0((unsigned int)(v126 - v132)) )
{
v135 = (unsigned int)v132--;
v131 += func0_part_0(v135) * i12;
}
v131 += i12;
if ( !v132 )
break;
v132 = 0;
}
v113 = v131;
v114 = v133;
v90 = v185;
}
}
continue;
}
break;
}
v90 += v113;
if ( v114 )
{
++v112;
--v115;
v114 = 0;
goto LABEL_197;
}
v91 = v205;
if ( v205 > 1 )
goto LABEL_154;
LABEL_211:
v196 += v90;
if ( v91 )
{
++v191;
v91 = 0;
goto LABEL_181;
}
++v218;
v219 += v196 * v199;
v88 = v221;
LABEL_220:
if ( v218 == 1 )
{
v199 = 1;
continue;
}
break;
}
v199 = 0;
v197 = 0;
v186 = 1;
v136 = v218 - 1;
v216 = v88;
while ( 2 )
{
if ( v136 <= 1 )
goto LABEL_278;
LABEL_223:
v137 = v136 - 1;
v138 = 0;
v139 = 1;
v192 = 0;
v140 = v136 - 2;
v206 = v137;
while ( 2 )
{
if ( v137 > 1 )
{
v141 = (unsigned int)v140;
if ( v140 > 1 )
{
i13 = v140;
v143 = 0;
v144 = v140 - 1;
v145 = 0;
goto LABEL_227;
}
if ( v140 <= 0 )
{
v146 = 1;
v145 = 1;
v144 = v140 - 1;
goto LABEL_229;
}
v144 = v140 - 1;
v145 = 1;
for ( i13 = v140 - 1; ; i13 = v222 - 1 )
{
v141 = (unsigned int)i13;
v143 = 1;
if ( i13 <= 1 )
break;
LABEL_227:
v236 = v143;
v222 = i13;
v145 += func0_part_0(v141);
v146 = v236 + 1;
if ( v236 + 1 > 1 )
goto LABEL_228;
}
++v145;
v146 = 2;
LABEL_228:
if ( v137 <= v146 )
{
--v137;
}
else
{
LABEL_229:
v147 = v137--;
for ( i14 = v147 - v146 - 1; ; i14 = 0 )
{
while ( 1 )
{
v149 = func0_part_0((unsigned int)(v137 - i14));
if ( i14 <= 1 )
break;
v150 = (unsigned int)i14--;
v145 += func0_part_0(v150) * v149;
}
v145 += v149;
if ( !i14 )
break;
}
}
++v138;
v140 = v144;
v192 += v145 * v139;
LABEL_238:
if ( v138 == 1 )
{
v139 = 1;
}
else
{
v151 = v138 - 1;
v152 = (unsigned int)(v138 - 1);
if ( v138 == 2 )
{
v139 = 1;
LABEL_290:
++v139;
}
else
{
v153 = v138 - 1;
v139 = 0;
for ( i15 = 0; ; i15 = 1 )
{
v223 = i15;
v139 += func0_part_0(v152);
if ( v223 )
break;
if ( --v153 <= 1 )
goto LABEL_290;
v152 = v153;
}
}
v155 = v138 - 3;
if ( v138 != 2 )
{
while ( 1 )
{
for ( i16 = func0_part_0((unsigned int)(v151 - v155));
v155 > 1;
i16 = func0_part_0((unsigned int)(v151 - v155)) )
{
v157 = (unsigned int)v155--;
v139 += func0_part_0(v157) * i16;
}
v139 += i16;
if ( !v155 )
break;
v155 = 0;
}
}
}
continue;
}
break;
}
v192 += v139;
if ( v137 )
{
++v138;
--v140;
v137 = 0;
goto LABEL_238;
}
++v197;
v199 += v192 * v186;
v136 = v206;
LABEL_250:
if ( v197 == 1 )
{
v186 = 1;
continue;
}
break;
}
v193 = v136;
v158 = 0;
v159 = 1;
v186 = 0;
v160 = v197 - 2;
v161 = v197 - 1;
while ( 2 )
{
if ( v161 > 1 )
{
v162 = (unsigned int)v160;
if ( v160 > 1 )
{
i17 = v160;
v164 = 0;
v165 = v160 - 1;
v166 = 0;
goto LABEL_255;
}
if ( v160 <= 0 )
{
v167 = 1;
v164 = 1;
v165 = v160 - 1;
goto LABEL_257;
}
v165 = v160 - 1;
v164 = 1;
for ( i17 = v160 - 1; ; i17 = v207 - 1 )
{
v162 = (unsigned int)i17;
v166 = 1;
if ( i17 <= 1 )
break;
LABEL_255:
v224 = v166;
v207 = i17;
v164 += func0_part_0(v162);
v167 = v224 + 1;
if ( v224 + 1 > 1 )
goto LABEL_256;
}
++v164;
v167 = 2;
LABEL_256:
if ( v161 <= v167 )
{
--v161;
}
else
{
LABEL_257:
v168 = v161--;
for ( i18 = v168 - v167 - 1; ; i18 = 0 )
{
while ( 1 )
{
v170 = func0_part_0((unsigned int)(v161 - i18));
if ( i18 <= 1 )
break;
v171 = (unsigned int)i18--;
v164 += func0_part_0(v171) * v170;
}
v164 += v170;
if ( !i18 )
break;
}
}
++v158;
v160 = v165;
v186 += v164 * v159;
LABEL_266:
if ( v158 == 1 )
{
v159 = 1;
}
else
{
v172 = v158 - 1;
v173 = (unsigned int)(v158 - 1);
if ( v158 == 2 )
{
v159 = 1;
LABEL_294:
++v159;
}
else
{
v174 = v158 - 1;
v175 = 0;
v159 = 0;
while ( 1 )
{
v208 = v175;
v159 += func0_part_0(v173);
if ( v208 )
break;
if ( --v174 <= 1 )
goto LABEL_294;
v173 = v174;
v175 = 1;
}
}
v176 = v158 - 3;
if ( v158 != 2 )
{
while ( 1 )
{
for ( i19 = func0_part_0((unsigned int)(v172 - v176));
v176 > 1;
i19 = func0_part_0((unsigned int)(v172 - v176)) )
{
v178 = (unsigned int)v176--;
v159 += func0_part_0(v178) * i19;
}
v159 += i19;
if ( !v176 )
break;
v176 = 0;
}
}
}
continue;
}
break;
}
v186 += v159;
if ( v161 )
{
++v158;
--v160;
v161 = 0;
goto LABEL_266;
}
v136 = v193;
if ( v193 > 1 )
goto LABEL_223;
LABEL_278:
v199 += v186;
if ( v136 )
{
++v197;
v136 = 0;
goto LABEL_250;
}
v88 = v216;
if ( v216 > 1 )
goto LABEL_152;
LABEL_287:
v219 += v199;
if ( v88 )
{
++v218;
v88 = 0;
goto LABEL_220;
}
v2 = v229;
}
while ( v229 > 1 );
LABEL_298:
v231 += v219;
if ( v2 )
{
++v230;
v2 = 0;
if ( v230 != 1 )
goto LABEL_150;
goto LABEL_300;
}
return v231;
} | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
XOR EBP,EBP
PUSH RBX
SUB RSP,0x48
TEST EDI,EDI
JLE 0x00102571
XOR R12D,R12D
MOV dword ptr [RSP + 0x20],0x1
LEA EBX,[RDI + -0x1]
MOV dword ptr [RSP + 0x2c],R12D
MOV dword ptr [RSP + 0x30],EBP
LAB_0010121f:
CMP EBX,0x1
JLE 0x00102542
LAB_00101228:
SUB EBX,0x1
MOV dword ptr [RSP + 0x1c],0x0
MOV dword ptr [RSP + 0x24],0x0
MOV R12D,EBX
MOV dword ptr [RSP + 0x10],0x1
MOV dword ptr [RSP + 0x34],EBX
LAB_0010124a:
CMP R12D,0x1
JLE 0x00101b27
LAB_00101254:
SUB R12D,0x1
XOR R14D,R14D
MOV dword ptr [RSP + 0xc],0x0
MOV dword ptr [RSP + 0x4],0x1
MOV EBP,R12D
MOV dword ptr [RSP + 0x14],R14D
MOV dword ptr [RSP + 0x28],R12D
LAB_00101278:
CMP EBP,0x1
JLE 0x0010162d
LAB_00101281:
LEA EAX,[RBP + -0x1]
SUB EBP,0x2
XOR R12D,R12D
MOV EBX,0x1
MOV dword ptr [RSP + 0x18],EAX
MOV R14D,EAX
MOV R15D,EBP
MOV dword ptr [RSP + 0x8],0x0
LAB_001012a1:
CMP R14D,0x1
JLE 0x00101420
MOV EDI,R15D
CMP R15D,0x1
JLE 0x00101350
MOV EDX,R15D
XOR ECX,ECX
LEA EBP,[R15 + -0x1]
XOR R13D,R13D
LAB_001012c4:
MOV dword ptr [RSP + 0x3c],ECX
MOV dword ptr [RSP + 0x38],EDX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x3c]
MOV EDI,0x1
MOV EDX,dword ptr [RSP + 0x38]
ADD R13D,EAX
TEST R15D,R15D
CMOVLE EDI,R15D
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JGE 0x00102683
NOP dword ptr [RAX + RAX*0x1]
LAB_001012f8:
CMP R14D,EAX
JLE 0x0010136d
NOP dword ptr [RAX]
LAB_00101300:
MOV EDX,R14D
SUB R14D,0x1
SUB EDX,EAX
LEA R15D,[RDX + -0x1]
LAB_0010130d:
MOV EDI,R14D
SUB EDI,R15D
CALL 0x001011f0
CMP R15D,0x1
JLE 0x00101340
MOV EDI,R15D
MOV dword ptr [RSP + 0x38],EAX
SUB R15D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x38]
IMUL EDX,EAX
ADD R13D,EDX
JMP 0x0010130d
LAB_00101340:
ADD R13D,EAX
TEST R15D,R15D
JZ 0x00101371
XOR R15D,R15D
JMP 0x0010130d
LAB_00101350:
TEST R15D,R15D
JG 0x00101678
MOV EAX,0x1
MOV R13D,0x1
LEA EBP,[R15 + -0x1]
CMP R14D,EAX
JG 0x00101300
LAB_0010136d:
SUB R14D,0x1
LAB_00101371:
MOV ESI,R13D
ADD R12D,0x1
MOV R15D,EBP
IMUL ESI,EBX
ADD dword ptr [RSP + 0x8],ESI
LAB_00101382:
CMP R12D,0x1
JZ 0x001026dd
LEA R13D,[R12 + -0x1]
MOV EDI,R13D
CMP R13D,0x1
JZ 0x00101b58
MOV EBP,R13D
XOR EBX,EBX
XOR EDX,EDX
LAB_001013a5:
MOV dword ptr [RSP + 0x38],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x38]
ADD EBX,EAX
TEST EDX,EDX
JZ 0x0010266b
NOP dword ptr [RAX]
LAB_001013c0:
LEA EBP,[R12 + -0x3]
CMP R12D,0x2
JZ 0x001012a1
LAB_001013cf:
MOV EDI,R13D
SUB EDI,EBP
CALL 0x001011f0
CMP EBP,0x1
JLE 0x00101408
LAB_001013de:
MOV EDI,EBP
MOV dword ptr [RSP + 0x38],EAX
SUB EBP,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x38]
MOV EDI,R13D
SUB EDI,EBP
IMUL EDX,EAX
ADD EBX,EDX
CALL 0x001011f0
CMP EBP,0x1
JG 0x001013de
NOP dword ptr [RAX]
LAB_00101408:
ADD EBX,EAX
TEST EBP,EBP
JZ 0x001012a1
XOR EBP,EBP
JMP 0x001013cf
LAB_00101420:
ADD dword ptr [RSP + 0x8],EBX
TEST R14D,R14D
JZ 0x00101440
ADD R12D,0x1
SUB R15D,0x1
XOR R14D,R14D
JMP 0x00101382
LAB_00101440:
MOV R13D,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
ADD dword ptr [RSP + 0xc],0x1
MOV EBP,dword ptr [RSP + 0x18]
IMUL R13D,EAX
ADD dword ptr [RSP + 0x14],R13D
LAB_0010145b:
CMP dword ptr [RSP + 0xc],0x1
JZ 0x001026a2
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x8],EBP
XOR R13D,R13D
MOV EBX,0x1
MOV dword ptr [RSP + 0x4],0x0
LEA R12D,[RAX + -0x2]
LEA R14D,[RAX + -0x1]
MOV EBP,R12D
LAB_00101489:
CMP R14D,0x1
JLE 0x00101600
MOV EDI,EBP
CMP EBP,0x1
JLE 0x00101540
MOV R8D,EBP
XOR R15D,R15D
LEA R12D,[RBP + -0x1]
XOR EDX,EDX
LAB_001014aa:
MOV dword ptr [RSP + 0x38],EDX
MOV dword ptr [RSP + 0x18],R8D
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x18]
ADD R15D,EAX
TEST EBP,EBP
LEA EAX,[RDX + 0x1]
MOV EDX,0x1
CMOVLE EDX,EBP
CMP EDX,EAX
JGE 0x00102662
NOP dword ptr [RAX]
LAB_001014e0:
CMP R14D,EAX
JLE 0x0010155c
NOP dword ptr [RAX]
LAB_001014e8:
MOV EDX,R14D
SUB R14D,0x1
SUB EDX,EAX
LEA EBP,[RDX + -0x1]
LAB_001014f4:
MOV EDI,R14D
SUB EDI,EBP
CALL 0x001011f0
CMP EBP,0x1
JLE 0x00101530
LAB_00101503:
MOV EDI,EBP
MOV dword ptr [RSP + 0x18],EAX
SUB EBP,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x18]
MOV EDI,R14D
SUB EDI,EBP
IMUL EDX,EAX
ADD R15D,EDX
CALL 0x001011f0
CMP EBP,0x1
JG 0x00101503
NOP word ptr [RAX + RAX*0x1]
LAB_00101530:
ADD R15D,EAX
TEST EBP,EBP
JZ 0x00101560
XOR EBP,EBP
JMP 0x001014f4
LAB_00101540:
TEST EBP,EBP
JG 0x00101648
MOV EAX,0x1
MOV R15D,0x1
LEA R12D,[RBP + -0x1]
CMP R14D,EAX
JG 0x001014e8
LAB_0010155c:
SUB R14D,0x1
LAB_00101560:
MOV ESI,EBX
ADD R13D,0x1
MOV EBP,R12D
IMUL ESI,R15D
ADD dword ptr [RSP + 0x4],ESI
LAB_00101571:
CMP R13D,0x1
JZ 0x0010268b
LEA R12D,[R13 + -0x1]
MOV EDI,R12D
CMP R12D,0x1
JZ 0x00101b78
MOV EDX,R12D
XOR R15D,R15D
XOR EBX,EBX
LAB_00101594:
MOV dword ptr [RSP + 0x18],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x18]
ADD EBX,EAX
TEST R15D,R15D
JZ 0x00102649
NOP dword ptr [RAX]
LAB_001015b0:
LEA R15D,[R13 + -0x3]
CMP R13D,0x2
JZ 0x00101489
LAB_001015be:
MOV EDI,R12D
SUB EDI,R15D
CALL 0x001011f0
CMP R15D,0x1
JLE 0x001015f0
MOV EDI,R15D
MOV dword ptr [RSP + 0x18],EAX
SUB R15D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x18]
IMUL EAX,EDX
ADD EBX,EAX
JMP 0x001015be
LAB_001015f0:
ADD EBX,EAX
TEST R15D,R15D
JZ 0x00101489
XOR R15D,R15D
JMP 0x001015be
LAB_00101600:
ADD dword ptr [RSP + 0x4],EBX
TEST R14D,R14D
JZ 0x00101620
ADD R13D,0x1
SUB EBP,0x1
XOR R14D,R14D
JMP 0x00101571
LAB_00101620:
MOV EBP,dword ptr [RSP + 0x8]
CMP EBP,0x1
JG 0x00101281
LAB_0010162d:
MOV ECX,dword ptr [RSP + 0x4]
ADD dword ptr [RSP + 0x14],ECX
TEST EBP,EBP
JZ 0x001016a8
ADD dword ptr [RSP + 0xc],0x1
XOR EBP,EBP
JMP 0x0010145b
LAB_00101648:
LEA R12D,[RBP + -0x1]
MOV R15D,0x1
MOV R8D,R12D
LAB_00101655:
MOV EDI,R8D
MOV EDX,0x1
CMP R8D,0x1
JG 0x001014aa
ADD R15D,0x1
MOV EAX,0x2
JMP 0x001014e0
LAB_00101678:
LEA EBP,[R15 + -0x1]
MOV R13D,0x1
MOV EDX,EBP
LAB_00101684:
MOV EDI,EDX
MOV ECX,0x1
CMP EDX,0x1
JG 0x001012c4
ADD R13D,0x1
MOV EAX,0x2
JMP 0x001012f8
LAB_001016a8:
MOV R14D,dword ptr [RSP + 0x14]
MOV EAX,dword ptr [RSP + 0x10]
ADD dword ptr [RSP + 0x1c],0x1
MOV R12D,dword ptr [RSP + 0x28]
IMUL EAX,R14D
ADD dword ptr [RSP + 0x24],EAX
LAB_001016c3:
CMP dword ptr [RSP + 0x1c],0x1
JZ 0x001026d0
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x10],0x0
MOV dword ptr [RSP + 0xc],0x0
MOV dword ptr [RSP + 0x4],0x1
SUB EAX,0x1
MOV dword ptr [RSP + 0x18],R12D
MOV EBP,EAX
LAB_001016f4:
CMP EBP,0x1
JLE 0x00101a9d
LAB_001016fd:
LEA EAX,[RBP + -0x1]
SUB EBP,0x2
XOR R12D,R12D
MOV EBX,0x1
MOV dword ptr [RSP + 0x14],EAX
MOV R14D,EBP
MOV R15D,EAX
MOV dword ptr [RSP + 0x8],0x0
LAB_0010171d:
CMP R15D,0x1
JLE 0x00101890
MOV EDI,R14D
CMP R14D,0x1
JLE 0x001017c8
MOV EDX,R14D
XOR R13D,R13D
LEA EBP,[R14 + -0x1]
XOR ECX,ECX
LAB_00101740:
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x28],EDX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x38]
MOV EDI,0x1
MOV EDX,dword ptr [RSP + 0x28]
ADD R13D,EAX
TEST R14D,R14D
CMOVLE EDI,R14D
LEA EAX,[RCX + 0x1]
CMP EAX,EDI
JLE 0x00102641
NOP
LAB_00101770:
CMP R15D,EAX
JLE 0x001017e5
NOP dword ptr [RAX]
LAB_00101778:
MOV EDX,R15D
SUB R15D,0x1
SUB EDX,EAX
LEA R14D,[RDX + -0x1]
LAB_00101785:
MOV EDI,R15D
SUB EDI,R14D
CALL 0x001011f0
CMP R14D,0x1
JLE 0x001017b8
MOV EDI,R14D
MOV dword ptr [RSP + 0x28],EAX
SUB R14D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x28]
IMUL EDX,EAX
ADD R13D,EDX
JMP 0x00101785
LAB_001017b8:
ADD R13D,EAX
TEST R14D,R14D
JZ 0x001017e9
XOR R14D,R14D
JMP 0x00101785
LAB_001017c8:
TEST R14D,R14D
JG 0x00101ab8
MOV EAX,0x1
MOV R13D,0x1
LEA EBP,[R14 + -0x1]
CMP R15D,EAX
JG 0x00101778
LAB_001017e5:
SUB R15D,0x1
LAB_001017e9:
MOV ESI,EBX
ADD R12D,0x1
MOV R14D,EBP
IMUL ESI,R13D
ADD dword ptr [RSP + 0x8],ESI
LAB_001017fa:
CMP R12D,0x1
JZ 0x001026c6
LEA R13D,[R12 + -0x1]
MOV EDI,R13D
CMP R13D,0x1
JZ 0x00101b48
MOV EBP,R13D
XOR EBX,EBX
XOR EDX,EDX
LAB_0010181d:
MOV dword ptr [RSP + 0x28],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x28]
ADD EBX,EAX
TEST EDX,EDX
JZ 0x00102629
NOP dword ptr [RAX]
LAB_00101838:
LEA EBP,[R12 + -0x3]
CMP R12D,0x2
JZ 0x0010171d
LAB_00101847:
MOV EDI,R13D
SUB EDI,EBP
CALL 0x001011f0
CMP EBP,0x1
JLE 0x00101880
LAB_00101856:
MOV EDI,EBP
MOV dword ptr [RSP + 0x28],EAX
SUB EBP,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x28]
MOV EDI,R13D
SUB EDI,EBP
IMUL EDX,EAX
ADD EBX,EDX
CALL 0x001011f0
CMP EBP,0x1
JG 0x00101856
NOP dword ptr [RAX]
LAB_00101880:
ADD EBX,EAX
TEST EBP,EBP
JZ 0x0010171d
XOR EBP,EBP
JMP 0x00101847
LAB_00101890:
ADD dword ptr [RSP + 0x8],EBX
TEST R15D,R15D
JZ 0x001018b0
ADD R12D,0x1
SUB R14D,0x1
XOR R15D,R15D
JMP 0x001017fa
LAB_001018b0:
MOV R13D,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
ADD dword ptr [RSP + 0xc],0x1
MOV EBP,dword ptr [RSP + 0x14]
IMUL R13D,EAX
ADD dword ptr [RSP + 0x10],R13D
LAB_001018cb:
CMP dword ptr [RSP + 0xc],0x1
JZ 0x001026b9
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x8],EBP
XOR R13D,R13D
MOV EBX,0x1
MOV dword ptr [RSP + 0x4],0x0
LEA R12D,[RAX + -0x2]
LEA R14D,[RAX + -0x1]
MOV EBP,R12D
LAB_001018f9:
CMP R14D,0x1
JLE 0x00101a70
MOV EDI,EBP
CMP EBP,0x1
JLE 0x001019b0
MOV R8D,EBP
XOR R15D,R15D
LEA R12D,[RBP + -0x1]
XOR EDX,EDX
LAB_0010191a:
MOV dword ptr [RSP + 0x28],EDX
MOV dword ptr [RSP + 0x14],R8D
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x28]
MOV R8D,dword ptr [RSP + 0x14]
ADD R15D,EAX
TEST EBP,EBP
LEA EAX,[RDX + 0x1]
MOV EDX,0x1
CMOVLE EDX,EBP
CMP EDX,EAX
JGE 0x00102620
NOP dword ptr [RAX]
LAB_00101950:
CMP R14D,EAX
JLE 0x001019cc
NOP dword ptr [RAX]
LAB_00101958:
MOV EDX,R14D
SUB R14D,0x1
SUB EDX,EAX
LEA EBP,[RDX + -0x1]
LAB_00101964:
MOV EDI,R14D
SUB EDI,EBP
CALL 0x001011f0
CMP EBP,0x1
JLE 0x001019a0
LAB_00101973:
MOV EDI,EBP
MOV dword ptr [RSP + 0x14],EAX
SUB EBP,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x14]
MOV EDI,R14D
SUB EDI,EBP
IMUL EDX,EAX
ADD R15D,EDX
CALL 0x001011f0
CMP EBP,0x1
JG 0x00101973
NOP word ptr [RAX + RAX*0x1]
LAB_001019a0:
ADD R15D,EAX
TEST EBP,EBP
JZ 0x001019d0
XOR EBP,EBP
JMP 0x00101964
LAB_001019b0:
TEST EBP,EBP
JG 0x00101ae8
MOV EAX,0x1
MOV R15D,0x1
LEA R12D,[RBP + -0x1]
CMP R14D,EAX
JG 0x00101958
LAB_001019cc:
SUB R14D,0x1
LAB_001019d0:
MOV ESI,EBX
ADD R13D,0x1
MOV EBP,R12D
IMUL ESI,R15D
ADD dword ptr [RSP + 0x4],ESI
LAB_001019e1:
CMP R13D,0x1
JZ 0x001026af
LEA R12D,[R13 + -0x1]
MOV EDI,R12D
CMP R12D,0x1
JZ 0x00101b68
MOV EDX,R12D
XOR EBX,EBX
XOR R15D,R15D
LAB_00101a04:
MOV dword ptr [RSP + 0x14],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x14]
ADD EBX,EAX
TEST R15D,R15D
JZ 0x00102607
NOP dword ptr [RAX]
LAB_00101a20:
LEA R15D,[R13 + -0x3]
CMP R13D,0x2
JZ 0x001018f9
LAB_00101a2e:
MOV EDI,R12D
SUB EDI,R15D
CALL 0x001011f0
CMP R15D,0x1
JLE 0x00101a60
MOV EDI,R15D
MOV dword ptr [RSP + 0x14],EAX
SUB R15D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x14]
IMUL EAX,EDX
ADD EBX,EAX
JMP 0x00101a2e
LAB_00101a60:
ADD EBX,EAX
TEST R15D,R15D
JZ 0x001018f9
XOR R15D,R15D
JMP 0x00101a2e
LAB_00101a70:
ADD dword ptr [RSP + 0x4],EBX
TEST R14D,R14D
JZ 0x00101a90
ADD R13D,0x1
SUB EBP,0x1
XOR R14D,R14D
JMP 0x001019e1
LAB_00101a90:
MOV EBP,dword ptr [RSP + 0x8]
CMP EBP,0x1
JG 0x001016fd
LAB_00101a9d:
MOV ECX,dword ptr [RSP + 0x4]
ADD dword ptr [RSP + 0x10],ECX
TEST EBP,EBP
JZ 0x00101b18
ADD dword ptr [RSP + 0xc],0x1
XOR EBP,EBP
JMP 0x001018cb
LAB_00101ab8:
LEA EBP,[R14 + -0x1]
MOV R13D,0x1
MOV EDX,EBP
LAB_00101ac4:
MOV EDI,EDX
MOV ECX,0x1
CMP EDX,0x1
JG 0x00101740
ADD R13D,0x1
MOV EAX,0x2
JMP 0x00101770
LAB_00101ae8:
LEA R12D,[RBP + -0x1]
MOV R15D,0x1
MOV R8D,R12D
LAB_00101af5:
MOV EDI,R8D
MOV EDX,0x1
CMP R8D,0x1
JG 0x0010191a
ADD R15D,0x1
MOV EAX,0x2
JMP 0x00101950
LAB_00101b18:
MOV R12D,dword ptr [RSP + 0x18]
CMP R12D,0x1
JG 0x00101254
LAB_00101b27:
MOV ECX,dword ptr [RSP + 0x10]
ADD dword ptr [RSP + 0x24],ECX
TEST R12D,R12D
JZ 0x00101b85
ADD dword ptr [RSP + 0x1c],0x1
XOR R12D,R12D
JMP 0x001016c3
LAB_00101b48:
MOV EBX,0x1
LAB_00101b4d:
ADD EBX,0x1
JMP 0x00101838
LAB_00101b58:
MOV EBX,0x1
LAB_00101b5d:
ADD EBX,0x1
JMP 0x001013c0
LAB_00101b68:
MOV EBX,0x1
LAB_00101b6d:
ADD EBX,0x1
JMP 0x00101a20
LAB_00101b78:
MOV EBX,0x1
LAB_00101b7d:
ADD EBX,0x1
JMP 0x001015b0
LAB_00101b85:
MOV EAX,dword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x24]
ADD dword ptr [RSP + 0x2c],0x1
MOV EBX,dword ptr [RSP + 0x34]
IMUL EAX,ECX
ADD dword ptr [RSP + 0x30],EAX
CMP dword ptr [RSP + 0x2c],0x1
JZ 0x00102560
LAB_00101ba8:
MOV EAX,dword ptr [RSP + 0x2c]
XOR R15D,R15D
MOV dword ptr [RSP + 0x28],EBX
MOV dword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x10],0x1
LEA R14D,[RAX + -0x1]
MOV dword ptr [RSP + 0x1c],R15D
MOV EBP,R14D
LAB_00101bcf:
CMP EBP,0x1
JLE 0x001024dd
LAB_00101bd8:
LEA R12D,[RBP + -0x1]
MOV dword ptr [RSP + 0x8],0x0
MOV EBP,0x1
MOV dword ptr [RSP + 0xc],0x0
MOV R15D,R12D
MOV dword ptr [RSP + 0x24],R12D
LAB_00101bf9:
CMP R15D,0x1
JLE 0x00101fcf
LAB_00101c03:
LEA EAX,[R15 + -0x1]
LEA R12D,[R15 + -0x2]
MOV dword ptr [RSP + 0x18],EBP
XOR R13D,R13D
MOV dword ptr [RSP + 0x14],EAX
MOV EBX,0x1
MOV R15D,R12D
MOV EBP,EAX
MOV dword ptr [RSP + 0x4],0x0
LAB_00101c28:
CMP EBP,0x1
JLE 0x00101da0
MOV EDI,R15D
CMP R15D,0x1
JLE 0x00101ce0
MOV EDX,R15D
XOR R14D,R14D
LEA R12D,[R15 + -0x1]
XOR ECX,ECX
LAB_00101c4a:
MOV dword ptr [RSP + 0x38],ECX
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x38]
MOV EDI,0x1
MOV EDX,dword ptr [RSP + 0x34]
ADD R14D,EAX
TEST R15D,R15D
CMOVLE EDI,R15D
LEA EAX,[RCX + 0x1]
CMP EAX,EDI
JLE 0x001025ff
NOP dword ptr [RAX]
LAB_00101c80:
CMP EBP,EAX
JLE 0x00101cfc
NOP dword ptr [RAX]
LAB_00101c88:
MOV EDX,EBP
SUB EBP,0x1
SUB EDX,EAX
LEA R15D,[RDX + -0x1]
LAB_00101c93:
MOV EDI,EBP
SUB EDI,R15D
CALL 0x001011f0
CMP R15D,0x1
JLE 0x00101cd0
LAB_00101ca3:
MOV EDI,R15D
MOV dword ptr [RSP + 0x34],EAX
SUB R15D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x34]
MOV EDI,EBP
SUB EDI,R15D
IMUL EDX,EAX
ADD R14D,EDX
CALL 0x001011f0
CMP R15D,0x1
JG 0x00101ca3
NOP dword ptr [RAX]
LAB_00101cd0:
ADD R14D,EAX
TEST R15D,R15D
JZ 0x00101cff
XOR R15D,R15D
JMP 0x00101c93
LAB_00101ce0:
TEST R15D,R15D
JG 0x00102020
MOV EAX,0x1
MOV R14D,0x1
LEA R12D,[R15 + -0x1]
CMP EBP,EAX
JG 0x00101c88
LAB_00101cfc:
SUB EBP,0x1
LAB_00101cff:
MOV ESI,EBX
ADD R13D,0x1
MOV R15D,R12D
IMUL ESI,R14D
ADD dword ptr [RSP + 0x4],ESI
LAB_00101d10:
CMP R13D,0x1
JZ 0x001026e7
LEA R14D,[R13 + -0x1]
MOV EDI,R14D
CMP R14D,0x1
JZ 0x00102508
MOV R12D,R14D
XOR EBX,EBX
XOR EDX,EDX
LAB_00101d32:
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x34]
ADD EBX,EAX
TEST EDX,EDX
JZ 0x001025e4
NOP dword ptr [RAX]
LAB_00101d50:
LEA R12D,[R13 + -0x3]
CMP R13D,0x2
JZ 0x00101c28
LAB_00101d5e:
MOV EDI,R14D
SUB EDI,R12D
CALL 0x001011f0
CMP R12D,0x1
JLE 0x00101d90
MOV EDI,R12D
MOV dword ptr [RSP + 0x34],EAX
SUB R12D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x34]
IMUL EAX,EDX
ADD EBX,EAX
JMP 0x00101d5e
LAB_00101d90:
ADD EBX,EAX
TEST R12D,R12D
JZ 0x00101c28
XOR R12D,R12D
JMP 0x00101d5e
LAB_00101da0:
ADD dword ptr [RSP + 0x4],EBX
TEST EBP,EBP
JZ 0x00101dc0
ADD R13D,0x1
SUB R15D,0x1
XOR EBP,EBP
JMP 0x00101d10
LAB_00101dc0:
MOV EBP,dword ptr [RSP + 0x18]
MOV R14D,dword ptr [RSP + 0x4]
ADD dword ptr [RSP + 0x8],0x1
MOV R15D,dword ptr [RSP + 0x14]
IMUL R14D,EBP
ADD dword ptr [RSP + 0xc],R14D
LAB_00101ddc:
CMP dword ptr [RSP + 0x8],0x1
JZ 0x001026fb
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x14],R15D
XOR R13D,R13D
XOR EBP,EBP
MOV EBX,0x1
LEA R12D,[RAX + -0x1]
LEA ESI,[RAX + -0x2]
MOV ECX,R12D
MOV R15D,ESI
LAB_00101e07:
CMP ECX,0x1
JLE 0x00101f90
MOV EDI,R15D
CMP R15D,0x1
JLE 0x00101eb8
LEA EAX,[R15 + -0x1]
MOV EDX,R15D
XOR R14D,R14D
XOR R12D,R12D
MOV dword ptr [RSP + 0x4],EAX
LAB_00101e2e:
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x18],EDX
CALL 0x001011f0
MOV EDI,0x1
MOV EDX,dword ptr [RSP + 0x18]
MOV ECX,dword ptr [RSP + 0x34]
ADD R14D,EAX
TEST R15D,R15D
LEA EAX,[R12 + 0x1]
CMOVLE EDI,R15D
CMP EDI,EAX
JGE 0x001025dc
NOP
LAB_00101e60:
CMP ECX,EAX
JLE 0x00101ed8
NOP dword ptr [RAX]
LAB_00101e68:
MOV EDX,ECX
LEA R12D,[RCX + -0x1]
SUB EDX,EAX
LEA R15D,[RDX + -0x1]
LAB_00101e74:
MOV EDI,R12D
SUB EDI,R15D
CALL 0x001011f0
CMP R15D,0x1
JLE 0x00101ea8
MOV EDI,R15D
MOV dword ptr [RSP + 0x18],EAX
SUB R15D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x18]
IMUL EDX,EAX
ADD R14D,EDX
JMP 0x00101e74
LAB_00101ea8:
ADD R14D,EAX
TEST R15D,R15D
JZ 0x00101edc
XOR R15D,R15D
JMP 0x00101e74
LAB_00101eb8:
TEST R15D,R15D
JG 0x00101fe8
LEA ESI,[R15 + -0x1]
MOV EAX,0x1
MOV R14D,0x1
MOV dword ptr [RSP + 0x4],ESI
CMP ECX,EAX
JG 0x00101e68
LAB_00101ed8:
LEA R12D,[RCX + -0x1]
LAB_00101edc:
IMUL EBX,R14D
MOV R15D,dword ptr [RSP + 0x4]
ADD R13D,0x1
MOV ECX,R12D
ADD EBP,EBX
LAB_00101eee:
CMP R13D,0x1
JZ 0x001026f1
LEA R12D,[R13 + -0x1]
MOV EDI,R12D
CMP R12D,0x1
JZ 0x00102528
MOV R14D,R12D
XOR EDX,EDX
XOR EBX,EBX
LAB_00101f10:
MOV dword ptr [RSP + 0x18],EDX
MOV dword ptr [RSP + 0x4],ECX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x18]
MOV ECX,dword ptr [RSP + 0x4]
ADD EBX,EAX
TEST EDX,EDX
JZ 0x001025c1
NOP
LAB_00101f30:
LEA R14D,[R13 + -0x3]
CMP R13D,0x2
JZ 0x00101e07
MOV dword ptr [RSP + 0x4],EBP
MOV EBP,EBX
MOV EBX,R14D
MOV R14D,ECX
LAB_00101f4a:
MOV EDI,R12D
SUB EDI,EBX
CALL 0x001011f0
CMP EBX,0x1
JLE 0x00101f80
LAB_00101f59:
MOV EDI,EBX
MOV dword ptr [RSP + 0x18],EAX
SUB EBX,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x18]
MOV EDI,R12D
SUB EDI,EBX
IMUL EDX,EAX
ADD EBP,EDX
CALL 0x001011f0
CMP EBX,0x1
JG 0x00101f59
NOP
LAB_00101f80:
ADD EBP,EAX
TEST EBX,EBX
JZ 0x00101fa8
XOR EBX,EBX
JMP 0x00101f4a
LAB_00101f90:
ADD EBP,EBX
TEST ECX,ECX
JZ 0x00101fc0
ADD R13D,0x1
SUB R15D,0x1
XOR ECX,ECX
JMP 0x00101eee
LAB_00101fa8:
MOV EBX,EBP
MOV ECX,R14D
MOV EBP,dword ptr [RSP + 0x4]
JMP 0x00101e07
LAB_00101fc0:
MOV R15D,dword ptr [RSP + 0x14]
CMP R15D,0x1
JG 0x00101c03
LAB_00101fcf:
ADD dword ptr [RSP + 0xc],EBP
TEST R15D,R15D
JZ 0x00102050
ADD dword ptr [RSP + 0x8],0x1
XOR R15D,R15D
JMP 0x00101ddc
LAB_00101fe8:
LEA EAX,[R15 + -0x1]
MOV R14D,0x1
MOV dword ptr [RSP + 0x4],EAX
MOV EDX,EAX
LAB_00101ff8:
MOV EDI,EDX
MOV R12D,0x1
CMP EDX,0x1
JG 0x00101e2e
ADD R14D,0x1
MOV EAX,0x2
JMP 0x00101e60
LAB_00102020:
LEA R12D,[R15 + -0x1]
MOV R14D,0x1
MOV EDX,R12D
LAB_0010202d:
MOV EDI,EDX
MOV ECX,0x1
CMP EDX,0x1
JG 0x00101c4a
ADD R14D,0x1
MOV EAX,0x2
JMP 0x00101c80
LAB_00102050:
MOV EAX,dword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
ADD dword ptr [RSP + 0x1c],0x1
MOV R12D,dword ptr [RSP + 0x24]
IMUL EAX,ECX
ADD dword ptr [RSP + 0x20],EAX
MOV EBP,R12D
LAB_0010206c:
CMP dword ptr [RSP + 0x1c],0x1
JZ 0x00102695
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x10],0x0
MOV dword ptr [RSP + 0xc],0x0
MOV dword ptr [RSP + 0x4],0x1
LEA R12D,[RAX + -0x1]
MOV dword ptr [RSP + 0x18],EBP
LAB_0010209b:
CMP R12D,0x1
JLE 0x0010244f
LAB_001020a5:
LEA R15D,[R12 + -0x1]
LEA EBP,[R12 + -0x2]
XOR R13D,R13D
MOV EBX,0x1
MOV dword ptr [RSP + 0x8],0x0
MOV R12D,EBP
MOV dword ptr [RSP + 0x14],R15D
LAB_001020c7:
CMP R15D,0x1
JLE 0x00102240
MOV EDI,R12D
CMP R12D,0x1
JLE 0x00102178
MOV EDX,R12D
XOR ECX,ECX
LEA EBP,[R12 + -0x1]
XOR R14D,R14D
LAB_001020eb:
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x24],EDX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x34]
MOV EDI,0x1
MOV EDX,dword ptr [RSP + 0x24]
ADD R14D,EAX
TEST R12D,R12D
CMOVLE EDI,R12D
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JGE 0x001025b9
NOP word ptr [RAX + RAX*0x1]
LAB_00102120:
CMP R15D,EAX
JLE 0x00102196
NOP dword ptr [RAX]
LAB_00102128:
MOV EDX,R15D
SUB R15D,0x1
SUB EDX,EAX
LEA R12D,[RDX + -0x1]
LAB_00102135:
MOV EDI,R15D
SUB EDI,R12D
CALL 0x001011f0
CMP R12D,0x1
JLE 0x00102168
MOV EDI,R12D
MOV dword ptr [RSP + 0x24],EAX
SUB R12D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x24]
IMUL EDX,EAX
ADD R14D,EDX
JMP 0x00102135
LAB_00102168:
ADD R14D,EAX
TEST R12D,R12D
JZ 0x0010219a
XOR R12D,R12D
JMP 0x00102135
LAB_00102178:
TEST R12D,R12D
JG 0x00102470
MOV EAX,0x1
MOV R14D,0x1
LEA EBP,[R12 + -0x1]
CMP R15D,EAX
JG 0x00102128
LAB_00102196:
SUB R15D,0x1
LAB_0010219a:
MOV ESI,EBX
ADD R13D,0x1
MOV R12D,EBP
IMUL ESI,R14D
ADD dword ptr [RSP + 0x8],ESI
LAB_001021ab:
CMP R13D,0x1
JZ 0x0010271c
LEA R14D,[R13 + -0x1]
MOV EDI,R14D
CMP R14D,0x1
JZ 0x001024f8
MOV EBP,R14D
XOR EBX,EBX
XOR EDX,EDX
LAB_001021cd:
MOV dword ptr [RSP + 0x24],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x24]
ADD EBX,EAX
TEST EDX,EDX
JZ 0x001025a1
NOP dword ptr [RAX]
LAB_001021e8:
LEA EBP,[R13 + -0x3]
CMP R13D,0x2
JZ 0x001020c7
LAB_001021f6:
MOV EDI,R14D
SUB EDI,EBP
CALL 0x001011f0
CMP EBP,0x1
JLE 0x00102230
LAB_00102205:
MOV EDI,EBP
MOV dword ptr [RSP + 0x24],EAX
SUB EBP,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x24]
MOV EDI,R14D
SUB EDI,EBP
IMUL EDX,EAX
ADD EBX,EDX
CALL 0x001011f0
CMP EBP,0x1
JG 0x00102205
NOP dword ptr [RAX + RAX*0x1]
LAB_00102230:
ADD EBX,EAX
TEST EBP,EBP
JZ 0x001020c7
XOR EBP,EBP
JMP 0x001021f6
LAB_00102240:
ADD dword ptr [RSP + 0x8],EBX
TEST R15D,R15D
JZ 0x00102260
ADD R13D,0x1
SUB R12D,0x1
XOR R15D,R15D
JMP 0x001021ab
LAB_00102260:
MOV R14D,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
ADD dword ptr [RSP + 0xc],0x1
MOV R15D,dword ptr [RSP + 0x14]
IMUL R14D,EAX
ADD dword ptr [RSP + 0x10],R14D
MOV R12D,R15D
LAB_0010227f:
CMP dword ptr [RSP + 0xc],0x1
JZ 0x0010270f
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x8],R12D
XOR R13D,R13D
MOV EBX,0x1
MOV dword ptr [RSP + 0x4],0x0
LEA EBP,[RAX + -0x1]
LEA R15D,[RAX + -0x2]
MOV R14D,R15D
MOV R12D,EBP
LAB_001022b0:
CMP R12D,0x1
JLE 0x00102420
MOV EDI,R14D
CMP R14D,0x1
JLE 0x00102358
MOV EDX,R14D
XOR EBP,EBP
LEA R15D,[R14 + -0x1]
XOR ECX,ECX
LAB_001022d2:
MOV dword ptr [RSP + 0x24],ECX
MOV dword ptr [RSP + 0x14],EDX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x24]
MOV EDI,0x1
MOV EDX,dword ptr [RSP + 0x14]
ADD EBP,EAX
TEST R14D,R14D
CMOVLE EDI,R14D
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JGE 0x00102599
LAB_00102300:
CMP R12D,EAX
JLE 0x00102374
NOP dword ptr [RAX]
LAB_00102308:
MOV EDX,R12D
SUB R12D,0x1
SUB EDX,EAX
LEA R14D,[RDX + -0x1]
LAB_00102315:
MOV EDI,R12D
SUB EDI,R14D
CALL 0x001011f0
CMP R14D,0x1
JLE 0x00102348
MOV EDI,R14D
MOV dword ptr [RSP + 0x14],EAX
SUB R14D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x14]
IMUL EDX,EAX
ADD EBP,EDX
JMP 0x00102315
LAB_00102348:
ADD EBP,EAX
TEST R14D,R14D
JZ 0x00102378
XOR R14D,R14D
JMP 0x00102315
LAB_00102358:
TEST R14D,R14D
JG 0x001024a0
MOV EAX,0x1
MOV EBP,0x1
LEA R15D,[R14 + -0x1]
CMP R12D,EAX
JG 0x00102308
LAB_00102374:
SUB R12D,0x1
LAB_00102378:
MOV ESI,EBX
ADD R13D,0x1
MOV R14D,R15D
IMUL ESI,EBP
ADD dword ptr [RSP + 0x4],ESI
LAB_00102388:
CMP R13D,0x1
JZ 0x00102705
LEA EBP,[R13 + -0x1]
MOV EDI,EBP
CMP EBP,0x1
JZ 0x00102518
MOV R15D,EBP
XOR EDX,EDX
XOR EBX,EBX
LAB_001023a8:
MOV dword ptr [RSP + 0x14],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x14]
ADD EBX,EAX
TEST EDX,EDX
JZ 0x00102582
NOP
LAB_001023c0:
LEA R15D,[R13 + -0x3]
CMP R13D,0x2
JZ 0x001022b0
LAB_001023ce:
MOV EDI,EBP
SUB EDI,R15D
CALL 0x001011f0
CMP R15D,0x1
JLE 0x00102410
LAB_001023de:
MOV EDI,R15D
MOV dword ptr [RSP + 0x14],EAX
SUB R15D,0x1
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x14]
MOV EDI,EBP
SUB EDI,R15D
IMUL EDX,EAX
ADD EBX,EDX
CALL 0x001011f0
CMP R15D,0x1
JG 0x001023de
NOP word ptr [RAX + RAX*0x1]
LAB_00102410:
ADD EBX,EAX
TEST R15D,R15D
JZ 0x001022b0
XOR R15D,R15D
JMP 0x001023ce
LAB_00102420:
ADD dword ptr [RSP + 0x4],EBX
TEST R12D,R12D
JZ 0x00102440
ADD R13D,0x1
SUB R14D,0x1
XOR R12D,R12D
JMP 0x00102388
LAB_00102440:
MOV R12D,dword ptr [RSP + 0x8]
CMP R12D,0x1
JG 0x001020a5
LAB_0010244f:
MOV ECX,dword ptr [RSP + 0x4]
ADD dword ptr [RSP + 0x10],ECX
TEST R12D,R12D
JZ 0x001024d0
ADD dword ptr [RSP + 0xc],0x1
XOR R12D,R12D
JMP 0x0010227f
LAB_00102470:
LEA EBP,[R12 + -0x1]
MOV R14D,0x1
MOV EDX,EBP
LAB_0010247d:
MOV EDI,EDX
MOV ECX,0x1
CMP EDX,0x1
JG 0x001020eb
ADD R14D,0x1
MOV EAX,0x2
JMP 0x00102120
LAB_001024a0:
LEA R15D,[R14 + -0x1]
MOV EBP,0x1
MOV EDX,R15D
LAB_001024ac:
MOV EDI,EDX
MOV ECX,0x1
CMP EDX,0x1
JG 0x001022d2
ADD EBP,0x1
MOV EAX,0x2
JMP 0x00102300
LAB_001024d0:
MOV EBP,dword ptr [RSP + 0x18]
CMP EBP,0x1
JG 0x00101bd8
LAB_001024dd:
MOV ECX,dword ptr [RSP + 0x10]
ADD dword ptr [RSP + 0x20],ECX
TEST EBP,EBP
JZ 0x00102535
ADD dword ptr [RSP + 0x1c],0x1
XOR EBP,EBP
JMP 0x0010206c
LAB_001024f8:
MOV EBX,0x1
LAB_001024fd:
ADD EBX,0x1
JMP 0x001021e8
LAB_00102508:
MOV EBX,0x1
LAB_0010250d:
ADD EBX,0x1
JMP 0x00101d50
LAB_00102518:
MOV EBX,0x1
LAB_0010251d:
ADD EBX,0x1
JMP 0x001023c0
LAB_00102528:
MOV EBX,0x1
LAB_0010252d:
ADD EBX,0x1
JMP 0x00101f30
LAB_00102535:
MOV EBX,dword ptr [RSP + 0x28]
CMP EBX,0x1
JG 0x00101228
LAB_00102542:
MOV ECX,dword ptr [RSP + 0x20]
ADD dword ptr [RSP + 0x30],ECX
TEST EBX,EBX
JZ 0x0010256d
ADD dword ptr [RSP + 0x2c],0x1
XOR EBX,EBX
CMP dword ptr [RSP + 0x2c],0x1
JNZ 0x00101ba8
LAB_00102560:
MOV dword ptr [RSP + 0x20],0x1
JMP 0x0010121f
LAB_0010256d:
MOV EBP,dword ptr [RSP + 0x30]
LAB_00102571:
ADD RSP,0x48
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00102582:
SUB R15D,0x1
CMP R15D,0x1
JBE 0x0010251d
MOV EDI,R15D
MOV EDX,0x1
JMP 0x001023a8
LAB_00102599:
SUB EDX,0x1
JMP 0x001024ac
LAB_001025a1:
SUB EBP,0x1
CMP EBP,0x1
JBE 0x001024fd
MOV EDI,EBP
MOV EDX,0x1
JMP 0x001021cd
LAB_001025b9:
SUB EDX,0x1
JMP 0x0010247d
LAB_001025c1:
SUB R14D,0x1
CMP R14D,0x1
JBE 0x0010252d
MOV EDI,R14D
MOV EDX,0x1
JMP 0x00101f10
LAB_001025dc:
SUB EDX,0x1
JMP 0x00101ff8
LAB_001025e4:
SUB R12D,0x1
CMP R12D,0x1
JBE 0x0010250d
MOV EDI,R12D
MOV EDX,0x1
JMP 0x00101d32
LAB_001025ff:
SUB EDX,0x1
JMP 0x0010202d
LAB_00102607:
SUB EDX,0x1
CMP EDX,0x1
JBE 0x00101b6d
MOV EDI,EDX
MOV R15D,0x1
JMP 0x00101a04
LAB_00102620:
SUB R8D,0x1
JMP 0x00101af5
LAB_00102629:
SUB EBP,0x1
CMP EBP,0x1
JBE 0x00101b4d
MOV EDI,EBP
MOV EDX,0x1
JMP 0x0010181d
LAB_00102641:
SUB EDX,0x1
JMP 0x00101ac4
LAB_00102649:
SUB EDX,0x1
CMP EDX,0x1
JBE 0x00101b7d
MOV EDI,EDX
MOV R15D,0x1
JMP 0x00101594
LAB_00102662:
SUB R8D,0x1
JMP 0x00101655
LAB_0010266b:
SUB EBP,0x1
CMP EBP,0x1
JBE 0x00101b5d
MOV EDI,EBP
MOV EDX,0x1
JMP 0x001013a5
LAB_00102683:
SUB EDX,0x1
JMP 0x00101684
LAB_0010268b:
MOV EBX,0x1
JMP 0x00101489
LAB_00102695:
MOV dword ptr [RSP + 0x10],0x1
JMP 0x00101bcf
LAB_001026a2:
MOV dword ptr [RSP + 0x4],0x1
JMP 0x00101278
LAB_001026af:
MOV EBX,0x1
JMP 0x001018f9
LAB_001026b9:
MOV dword ptr [RSP + 0x4],0x1
JMP 0x001016f4
LAB_001026c6:
MOV EBX,0x1
JMP 0x0010171d
LAB_001026d0:
MOV dword ptr [RSP + 0x10],0x1
JMP 0x0010124a
LAB_001026dd:
MOV EBX,0x1
JMP 0x001012a1
LAB_001026e7:
MOV EBX,0x1
JMP 0x00101c28
LAB_001026f1:
MOV EBX,0x1
JMP 0x00101e07
LAB_001026fb:
MOV EBP,0x1
JMP 0x00101bf9
LAB_00102705:
MOV EBX,0x1
JMP 0x001022b0
LAB_0010270f:
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0010209b
LAB_0010271c:
MOV EBX,0x1
JMP 0x001020c7 | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
uint uVar8;
int iVar9;
uint uVar10;
uint uVar11;
int iVar12;
int iVar13;
int iVar14;
bool bVar15;
int local_74;
int local_70;
int local_6c;
int local_68;
int local_64;
int local_5c;
int local_58;
int local_54;
int local_4c;
int local_48;
if (param_1 < 1) {
return 0;
}
param_1 = param_1 + -1;
local_4c = 0;
local_48 = 0;
do {
local_58 = 1;
iVar12 = local_4c;
joined_r0x00101222:
if (1 < param_1) {
param_1 = param_1 + -1;
local_5c = 0;
local_54 = 0;
iVar9 = param_1;
do {
local_68 = 1;
iVar7 = local_5c;
joined_r0x0010124e:
if (1 < iVar9) {
iVar9 = iVar9 + -1;
local_6c = 0;
local_64 = 0;
iVar6 = iVar9;
LAB_00101278:
local_74 = 1;
if (iVar6 < 2) goto LAB_0010162d;
LAB_00101281:
iVar5 = iVar6 + -2;
iVar3 = 1;
local_70 = 0;
uVar10 = 0;
iVar4 = iVar6 + -1;
LAB_001012a1:
uVar11 = uVar10;
if (iVar4 < 2) {
local_70 = local_70 + iVar3;
if (iVar4 == 0) goto LAB_00101440;
iVar4 = 0;
}
else {
iVar14 = iVar5;
if (iVar5 < 2) {
if (0 < iVar5) {
iVar13 = 1;
goto LAB_00101684;
}
iVar2 = 1;
iVar13 = 1;
if (1 < iVar4) goto LAB_00101300;
}
else {
iVar2 = 0;
iVar13 = 0;
do {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar1;
iVar1 = 1;
if (iVar5 < 1) {
iVar1 = iVar5;
}
iVar2 = iVar2 + 1;
if (iVar1 < iVar2) goto LAB_001012f8;
LAB_00101684:
iVar14 = iVar14 + -1;
iVar2 = 1;
} while (1 < iVar14);
iVar13 = iVar13 + 1;
iVar2 = 2;
LAB_001012f8:
if (iVar2 < iVar4) {
LAB_00101300:
iVar14 = (iVar4 - iVar2) + -1;
while( true ) {
for (; iVar2 = func0_part_0((iVar4 + -1) - iVar14), 1 < iVar14;
iVar14 = iVar14 + -1) {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar2 * iVar1;
}
iVar13 = iVar13 + iVar2;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
iVar4 = iVar4 + -1;
local_70 = local_70 + iVar13 * iVar3;
}
iVar5 = iVar5 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar3 = 1;
}
else {
if (uVar11 == 1) {
iVar3 = 1;
LAB_00101b5d:
iVar3 = iVar3 + 1;
}
else {
iVar3 = 0;
bVar15 = false;
uVar8 = uVar11;
while( true ) {
iVar14 = func0_part_0(uVar8);
iVar3 = iVar3 + iVar14;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_00101b5d;
bVar15 = true;
}
}
iVar14 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
iVar13 = func0_part_0(uVar11 - iVar14);
while (1 < iVar14) {
iVar2 = func0_part_0(iVar14);
iVar3 = iVar3 + iVar13 * iVar2;
iVar13 = func0_part_0(uVar11 - (iVar14 + -1));
iVar14 = iVar14 + -1;
}
iVar3 = iVar3 + iVar13;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
goto LAB_001012a1;
}
local_54 = local_54 + local_68;
if (iVar9 == 0) {
local_48 = local_48 + local_58 * local_54;
goto joined_r0x00101ba2;
}
iVar9 = 0;
LAB_001016c3:
local_5c = iVar7 + 1;
if (local_5c != 1) {
local_68 = 0;
local_6c = 0;
LAB_001016f4:
local_74 = 1;
if (iVar7 < 2) goto LAB_00101a9d;
LAB_001016fd:
iVar6 = iVar7 + -2;
iVar5 = 1;
local_70 = 0;
uVar10 = 0;
iVar3 = iVar7 + -1;
LAB_0010171d:
uVar11 = uVar10;
if (iVar3 < 2) {
local_70 = local_70 + iVar5;
if (iVar3 == 0) goto LAB_001018b0;
iVar3 = 0;
}
else {
iVar4 = iVar6;
if (iVar6 < 2) {
if (0 < iVar6) {
iVar14 = 1;
goto LAB_00101ac4;
}
iVar13 = 1;
iVar14 = 1;
if (1 < iVar3) goto LAB_00101778;
}
else {
iVar14 = 0;
iVar13 = 0;
do {
iVar2 = func0_part_0(iVar4);
iVar14 = iVar14 + iVar2;
iVar2 = 1;
if (iVar6 < 1) {
iVar2 = iVar6;
}
iVar13 = iVar13 + 1;
if (iVar2 < iVar13) goto LAB_00101770;
LAB_00101ac4:
iVar4 = iVar4 + -1;
iVar13 = 1;
} while (1 < iVar4);
iVar14 = iVar14 + 1;
iVar13 = 2;
LAB_00101770:
if (iVar13 < iVar3) {
LAB_00101778:
iVar4 = (iVar3 - iVar13) + -1;
while( true ) {
for (; iVar13 = func0_part_0((iVar3 + -1) - iVar4), 1 < iVar4; iVar4 = iVar4 + -1)
{
iVar2 = func0_part_0(iVar4);
iVar14 = iVar14 + iVar13 * iVar2;
}
iVar14 = iVar14 + iVar13;
if (iVar4 == 0) break;
iVar4 = 0;
}
}
}
iVar3 = iVar3 + -1;
local_70 = local_70 + iVar5 * iVar14;
}
iVar6 = iVar6 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar5 = 1;
}
else {
if (uVar11 == 1) {
iVar5 = 1;
LAB_00101b4d:
iVar5 = iVar5 + 1;
}
else {
iVar5 = 0;
bVar15 = false;
uVar8 = uVar11;
while( true ) {
iVar4 = func0_part_0(uVar8);
iVar5 = iVar5 + iVar4;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_00101b4d;
bVar15 = true;
}
}
iVar4 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
iVar14 = func0_part_0(uVar11 - iVar4);
while (1 < iVar4) {
iVar13 = func0_part_0(iVar4);
iVar5 = iVar5 + iVar14 * iVar13;
iVar14 = func0_part_0(uVar11 - (iVar4 + -1));
iVar4 = iVar4 + -1;
}
iVar5 = iVar5 + iVar14;
if (iVar4 == 0) break;
iVar4 = 0;
}
}
}
goto LAB_0010171d;
}
} while( true );
}
local_48 = local_48 + local_58;
if (param_1 == 0) {
return local_48;
}
param_1 = 0;
joined_r0x00101ba2:
if (iVar12 != 0) {
local_4c = iVar12 + 1;
local_58 = 0;
local_5c = 0;
do {
local_68 = 1;
iVar9 = local_5c;
joined_r0x00101bd2:
if (1 < iVar12) {
iVar12 = iVar12 + -1;
local_70 = 0;
local_6c = 0;
iVar7 = iVar12;
LAB_00101bf9:
iVar6 = 1;
if (iVar7 < 2) goto LAB_00101fcf;
LAB_00101c03:
iVar4 = iVar7 + -2;
iVar3 = 1;
local_74 = 0;
iVar5 = iVar7 + -1;
uVar10 = 0;
LAB_00101c28:
uVar11 = uVar10;
if (iVar5 < 2) {
local_74 = local_74 + iVar3;
if (iVar5 == 0) goto LAB_00101dc0;
iVar5 = 0;
}
else {
iVar14 = iVar4;
if (iVar4 < 2) {
if (0 < iVar4) {
iVar13 = 1;
goto LAB_0010202d;
}
iVar2 = 1;
iVar13 = 1;
if (1 < iVar5) goto LAB_00101c88;
}
else {
iVar13 = 0;
iVar2 = 0;
do {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar1;
iVar1 = 1;
if (iVar4 < 1) {
iVar1 = iVar4;
}
iVar2 = iVar2 + 1;
if (iVar1 < iVar2) goto LAB_00101c80;
LAB_0010202d:
iVar14 = iVar14 + -1;
iVar2 = 1;
} while (1 < iVar14);
iVar13 = iVar13 + 1;
iVar2 = 2;
LAB_00101c80:
if (iVar2 < iVar5) {
LAB_00101c88:
iVar14 = (iVar5 - iVar2) + -1;
while( true ) {
iVar2 = func0_part_0((iVar5 + -1) - iVar14);
while (1 < iVar14) {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar2 * iVar1;
iVar2 = func0_part_0((iVar5 + -1) - (iVar14 + -1));
iVar14 = iVar14 + -1;
}
iVar13 = iVar13 + iVar2;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
iVar5 = iVar5 + -1;
local_74 = local_74 + iVar3 * iVar13;
}
iVar4 = iVar4 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar3 = 1;
}
else {
if (uVar11 == 1) {
iVar3 = 1;
LAB_0010250d:
iVar3 = iVar3 + 1;
}
else {
iVar3 = 0;
bVar15 = false;
uVar8 = uVar11;
while( true ) {
iVar14 = func0_part_0(uVar8);
iVar3 = iVar3 + iVar14;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_0010250d;
bVar15 = true;
}
}
iVar14 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
for (; iVar13 = func0_part_0(uVar11 - iVar14), 1 < iVar14; iVar14 = iVar14 + -1) {
iVar2 = func0_part_0(iVar14);
iVar3 = iVar3 + iVar2 * iVar13;
}
iVar3 = iVar3 + iVar13;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
goto LAB_00101c28;
}
local_58 = local_58 + local_68;
bVar15 = iVar12 == 0;
iVar12 = local_4c;
if (bVar15) goto joined_r0x00101222;
iVar12 = 0;
LAB_0010206c:
local_5c = iVar9 + 1;
if (local_5c != 1) {
local_68 = 0;
local_6c = 0;
LAB_0010209b:
local_74 = 1;
if (iVar9 < 2) goto LAB_0010244f;
LAB_001020a5:
iVar5 = iVar9 + -2;
iVar7 = 1;
local_70 = 0;
iVar6 = iVar9 + -1;
uVar10 = 0;
LAB_001020c7:
uVar11 = uVar10;
if (iVar6 < 2) {
local_70 = local_70 + iVar7;
if (iVar6 == 0) goto LAB_00102260;
iVar6 = 0;
}
else {
iVar3 = iVar5;
if (iVar5 < 2) {
if (0 < iVar5) {
iVar4 = 1;
goto LAB_0010247d;
}
iVar14 = 1;
iVar4 = 1;
if (1 < iVar6) goto LAB_00102128;
}
else {
iVar14 = 0;
iVar4 = 0;
do {
iVar13 = func0_part_0(iVar3);
iVar4 = iVar4 + iVar13;
iVar13 = 1;
if (iVar5 < 1) {
iVar13 = iVar5;
}
iVar14 = iVar14 + 1;
if (iVar13 < iVar14) goto LAB_00102120;
LAB_0010247d:
iVar3 = iVar3 + -1;
iVar14 = 1;
} while (1 < iVar3);
iVar4 = iVar4 + 1;
iVar14 = 2;
LAB_00102120:
if (iVar14 < iVar6) {
LAB_00102128:
iVar3 = (iVar6 - iVar14) + -1;
while( true ) {
for (; iVar14 = func0_part_0((iVar6 + -1) - iVar3), 1 < iVar3; iVar3 = iVar3 + -1)
{
iVar13 = func0_part_0(iVar3);
iVar4 = iVar4 + iVar14 * iVar13;
}
iVar4 = iVar4 + iVar14;
if (iVar3 == 0) break;
iVar3 = 0;
}
}
}
iVar6 = iVar6 + -1;
local_70 = local_70 + iVar7 * iVar4;
}
iVar5 = iVar5 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar7 = 1;
}
else {
if (uVar11 == 1) {
iVar7 = 1;
LAB_001024fd:
iVar7 = iVar7 + 1;
}
else {
iVar7 = 0;
bVar15 = false;
uVar8 = uVar11;
while( true ) {
iVar3 = func0_part_0(uVar8);
iVar7 = iVar7 + iVar3;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_001024fd;
bVar15 = true;
}
}
iVar3 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
iVar4 = func0_part_0(uVar11 - iVar3);
while (1 < iVar3) {
iVar14 = func0_part_0(iVar3);
iVar7 = iVar7 + iVar4 * iVar14;
iVar4 = func0_part_0(uVar11 - (iVar3 + -1));
iVar3 = iVar3 + -1;
}
iVar7 = iVar7 + iVar4;
if (iVar3 == 0) break;
iVar3 = 0;
}
}
}
goto LAB_001020c7;
}
} while( true );
}
local_4c = 1;
} while( true );
LAB_00101440:
local_64 = local_64 + local_74 * local_70;
iVar6 = iVar6 + -1;
iVar5 = local_6c;
LAB_0010145b:
local_6c = iVar5 + 1;
if (local_6c != 1) {
iVar4 = 1;
local_74 = 0;
iVar3 = iVar5 + -1;
uVar10 = 0;
LAB_00101489:
uVar11 = uVar10;
if (iVar5 < 2) {
local_74 = local_74 + iVar4;
if (iVar5 == 0) goto LAB_00101620;
iVar5 = 0;
}
else {
iVar14 = iVar3;
if (iVar3 < 2) {
if (0 < iVar3) {
iVar13 = 1;
goto LAB_00101655;
}
iVar13 = 1;
iVar2 = 1;
if (1 < iVar5) goto LAB_001014e8;
}
else {
iVar13 = 0;
iVar2 = 0;
do {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar1;
iVar2 = iVar2 + 1;
iVar1 = 1;
if (iVar3 < 1) {
iVar1 = iVar3;
}
if (iVar1 < iVar2) goto LAB_001014e0;
LAB_00101655:
iVar14 = iVar14 + -1;
iVar2 = 1;
} while (1 < iVar14);
iVar13 = iVar13 + 1;
iVar2 = 2;
LAB_001014e0:
if (iVar2 < iVar5) {
LAB_001014e8:
iVar14 = (iVar5 - iVar2) + -1;
while( true ) {
iVar2 = func0_part_0((iVar5 + -1) - iVar14);
while (1 < iVar14) {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar2 * iVar1;
iVar2 = func0_part_0((iVar5 + -1) - (iVar14 + -1));
iVar14 = iVar14 + -1;
}
iVar13 = iVar13 + iVar2;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
iVar5 = iVar5 + -1;
local_74 = local_74 + iVar4 * iVar13;
}
iVar3 = iVar3 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar4 = 1;
}
else {
if (uVar11 == 1) {
iVar4 = 1;
LAB_00101b7d:
iVar4 = iVar4 + 1;
}
else {
bVar15 = false;
iVar4 = 0;
uVar8 = uVar11;
while( true ) {
iVar14 = func0_part_0(uVar8);
iVar4 = iVar4 + iVar14;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_00101b7d;
bVar15 = true;
}
}
iVar14 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
for (; iVar13 = func0_part_0(uVar11 - iVar14), 1 < iVar14; iVar14 = iVar14 + -1) {
iVar2 = func0_part_0(iVar14);
iVar4 = iVar4 + iVar2 * iVar13;
}
iVar4 = iVar4 + iVar13;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
goto LAB_00101489;
}
goto LAB_00101278;
LAB_00101620:
if (1 < iVar6) goto LAB_00101281;
LAB_0010162d:
local_64 = local_64 + local_74;
if (iVar6 == 0) {
local_54 = local_54 + local_68 * local_64;
goto LAB_001016c3;
}
iVar6 = 0;
iVar5 = local_6c;
goto LAB_0010145b;
LAB_001018b0:
local_68 = local_68 + local_74 * local_70;
iVar7 = iVar7 + -1;
iVar6 = local_6c;
LAB_001018cb:
local_6c = iVar6 + 1;
if (local_6c != 1) {
iVar3 = 1;
local_74 = 0;
iVar5 = iVar6 + -1;
uVar10 = 0;
LAB_001018f9:
uVar11 = uVar10;
if (iVar6 < 2) {
local_74 = local_74 + iVar3;
if (iVar6 == 0) goto LAB_00101a90;
iVar6 = 0;
}
else {
iVar4 = iVar5;
if (iVar5 < 2) {
if (0 < iVar5) {
iVar14 = 1;
goto LAB_00101af5;
}
iVar14 = 1;
iVar13 = 1;
if (1 < iVar6) goto LAB_00101958;
}
else {
iVar14 = 0;
iVar13 = 0;
do {
iVar2 = func0_part_0(iVar4);
iVar14 = iVar14 + iVar2;
iVar13 = iVar13 + 1;
iVar2 = 1;
if (iVar5 < 1) {
iVar2 = iVar5;
}
if (iVar2 < iVar13) goto LAB_00101950;
LAB_00101af5:
iVar4 = iVar4 + -1;
iVar13 = 1;
} while (1 < iVar4);
iVar14 = iVar14 + 1;
iVar13 = 2;
LAB_00101950:
if (iVar13 < iVar6) {
LAB_00101958:
iVar4 = (iVar6 - iVar13) + -1;
while( true ) {
iVar13 = func0_part_0((iVar6 + -1) - iVar4);
while (1 < iVar4) {
iVar2 = func0_part_0(iVar4);
iVar14 = iVar14 + iVar13 * iVar2;
iVar13 = func0_part_0((iVar6 + -1) - (iVar4 + -1));
iVar4 = iVar4 + -1;
}
iVar14 = iVar14 + iVar13;
if (iVar4 == 0) break;
iVar4 = 0;
}
}
}
iVar6 = iVar6 + -1;
local_74 = local_74 + iVar3 * iVar14;
}
iVar5 = iVar5 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar3 = 1;
}
else {
if (uVar11 == 1) {
iVar3 = 1;
LAB_00101b6d:
iVar3 = iVar3 + 1;
}
else {
iVar3 = 0;
bVar15 = false;
uVar8 = uVar11;
while( true ) {
iVar4 = func0_part_0(uVar8);
iVar3 = iVar3 + iVar4;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_00101b6d;
bVar15 = true;
}
}
iVar4 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
for (; iVar14 = func0_part_0(uVar11 - iVar4), 1 < iVar4; iVar4 = iVar4 + -1) {
iVar13 = func0_part_0(iVar4);
iVar3 = iVar3 + iVar13 * iVar14;
}
iVar3 = iVar3 + iVar14;
if (iVar4 == 0) break;
iVar4 = 0;
}
}
}
goto LAB_001018f9;
}
goto LAB_001016f4;
LAB_00101a90:
if (1 < iVar7) goto LAB_001016fd;
LAB_00101a9d:
local_68 = local_68 + local_74;
bVar15 = iVar7 == 0;
iVar7 = local_5c;
if (bVar15) goto joined_r0x0010124e;
iVar7 = 0;
iVar6 = local_6c;
goto LAB_001018cb;
LAB_00101dc0:
local_6c = local_6c + local_74 * iVar6;
iVar7 = iVar7 + -1;
iVar5 = local_70;
LAB_00101ddc:
local_70 = iVar5 + 1;
if (local_70 != 1) {
iVar6 = 0;
iVar4 = 1;
iVar3 = iVar5 + -1;
uVar10 = 0;
LAB_00101e07:
uVar11 = uVar10;
if (iVar5 < 2) {
iVar6 = iVar6 + iVar4;
if (iVar5 == 0) goto LAB_00101fc0;
iVar5 = 0;
}
else {
iVar14 = iVar3;
if (iVar3 < 2) {
if (0 < iVar3) {
iVar13 = 1;
goto LAB_00101ff8;
}
iVar2 = 1;
iVar13 = 1;
if (1 < iVar5) goto LAB_00101e68;
}
else {
iVar13 = 0;
iVar2 = 0;
do {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar1;
iVar2 = iVar2 + 1;
iVar1 = 1;
if (iVar3 < 1) {
iVar1 = iVar3;
}
if (iVar1 < iVar2) goto LAB_00101e60;
LAB_00101ff8:
iVar14 = iVar14 + -1;
iVar2 = 1;
} while (1 < iVar14);
iVar13 = iVar13 + 1;
iVar2 = 2;
LAB_00101e60:
if (iVar2 < iVar5) {
LAB_00101e68:
iVar14 = (iVar5 - iVar2) + -1;
while( true ) {
for (; iVar2 = func0_part_0((iVar5 + -1) - iVar14), 1 < iVar14; iVar14 = iVar14 + -1) {
iVar1 = func0_part_0(iVar14);
iVar13 = iVar13 + iVar2 * iVar1;
}
iVar13 = iVar13 + iVar2;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
iVar5 = iVar5 + -1;
iVar6 = iVar6 + iVar4 * iVar13;
}
iVar3 = iVar3 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar4 = 1;
}
else {
if (uVar11 == 1) {
iVar4 = 1;
LAB_0010252d:
iVar4 = iVar4 + 1;
}
else {
bVar15 = false;
iVar4 = 0;
uVar8 = uVar11;
while( true ) {
iVar14 = func0_part_0(uVar8);
iVar4 = iVar4 + iVar14;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_0010252d;
bVar15 = true;
}
}
iVar14 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
iVar13 = func0_part_0(uVar11 - iVar14);
while (1 < iVar14) {
iVar2 = func0_part_0(iVar14);
iVar4 = iVar4 + iVar13 * iVar2;
iVar13 = func0_part_0(uVar11 - (iVar14 + -1));
iVar14 = iVar14 + -1;
}
iVar4 = iVar4 + iVar13;
if (iVar14 == 0) break;
iVar14 = 0;
}
}
}
goto LAB_00101e07;
}
goto LAB_00101bf9;
LAB_00101fc0:
if (1 < iVar7) goto LAB_00101c03;
LAB_00101fcf:
local_6c = local_6c + iVar6;
if (iVar7 == 0) {
local_58 = local_58 + local_68 * local_6c;
goto LAB_0010206c;
}
iVar7 = 0;
iVar5 = local_70;
goto LAB_00101ddc;
LAB_00102260:
local_68 = local_68 + local_74 * local_70;
iVar9 = iVar9 + -1;
iVar7 = local_6c;
LAB_0010227f:
local_6c = iVar7 + 1;
if (local_6c != 1) {
iVar5 = 1;
local_74 = 0;
iVar6 = iVar7 + -1;
uVar10 = 0;
LAB_001022b0:
uVar11 = uVar10;
if (iVar7 < 2) {
local_74 = local_74 + iVar5;
if (iVar7 == 0) goto LAB_00102440;
iVar7 = 0;
}
else {
iVar3 = iVar6;
if (iVar6 < 2) {
if (0 < iVar6) {
iVar4 = 1;
goto LAB_001024ac;
}
iVar14 = 1;
iVar4 = 1;
if (1 < iVar7) goto LAB_00102308;
}
else {
iVar4 = 0;
iVar14 = 0;
do {
iVar13 = func0_part_0(iVar3);
iVar4 = iVar4 + iVar13;
iVar13 = 1;
if (iVar6 < 1) {
iVar13 = iVar6;
}
iVar14 = iVar14 + 1;
if (iVar13 < iVar14) goto LAB_00102300;
LAB_001024ac:
iVar3 = iVar3 + -1;
iVar14 = 1;
} while (1 < iVar3);
iVar4 = iVar4 + 1;
iVar14 = 2;
LAB_00102300:
if (iVar14 < iVar7) {
LAB_00102308:
iVar3 = (iVar7 - iVar14) + -1;
while( true ) {
for (; iVar14 = func0_part_0((iVar7 + -1) - iVar3), 1 < iVar3; iVar3 = iVar3 + -1) {
iVar13 = func0_part_0(iVar3);
iVar4 = iVar4 + iVar14 * iVar13;
}
iVar4 = iVar4 + iVar14;
if (iVar3 == 0) break;
iVar3 = 0;
}
}
}
iVar7 = iVar7 + -1;
local_74 = local_74 + iVar5 * iVar4;
}
iVar6 = iVar6 + -1;
uVar10 = uVar11 + 1;
if (uVar10 == 1) {
iVar5 = 1;
}
else {
if (uVar11 == 1) {
iVar5 = 1;
LAB_0010251d:
iVar5 = iVar5 + 1;
}
else {
bVar15 = false;
iVar5 = 0;
uVar8 = uVar11;
while( true ) {
iVar3 = func0_part_0(uVar8);
iVar5 = iVar5 + iVar3;
if (bVar15) break;
uVar8 = uVar8 - 1;
if (uVar8 < 2) goto LAB_0010251d;
bVar15 = true;
}
}
iVar3 = uVar11 - 2;
if (uVar10 != 2) {
while( true ) {
iVar4 = func0_part_0(uVar11 - iVar3);
while (1 < iVar3) {
iVar14 = func0_part_0(iVar3);
iVar5 = iVar5 + iVar4 * iVar14;
iVar4 = func0_part_0(uVar11 - (iVar3 + -1));
iVar3 = iVar3 + -1;
}
iVar5 = iVar5 + iVar4;
if (iVar3 == 0) break;
iVar3 = 0;
}
}
}
goto LAB_001022b0;
}
goto LAB_0010209b;
LAB_00102440:
if (1 < iVar9) goto LAB_001020a5;
LAB_0010244f:
local_68 = local_68 + local_74;
bVar15 = iVar9 == 0;
iVar9 = local_5c;
if (bVar15) goto joined_r0x00101bd2;
iVar9 = 0;
iVar7 = local_6c;
goto LAB_0010227f;
} |
6,228 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NULL;
}
// Execute regular expression
if (regexec(®ex, text, 1, match, 0) == 0) {
int start = match[0].rm_so;
int end = match[0].rm_eo;
// Extract the actual word
char word[100]; // Ensure it's large enough to hold the word
strncpy(word, text + start, end - start);
word[end - start] = '\0';
// Create the resulting message
snprintf(result, sizeof(result), "%d-%d: %s", start, end, word);
// Free compiled regular expression
regfree(®ex);
return result;
}
regfree(®ex);
return NULL;
}
| int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xe0,%rsp
mov %rdi,-0xd8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0xc0(%rbp),%rax
mov $0x1,%edx
lea 0xd87(%rip),%rsi
mov %rax,%rdi
callq 1130 <regcomp@plt>
test %eax,%eax
je 12a3 <func0+0x5a>
lea 0xd7a(%rip),%rdi
callq 10e0 <puts@plt>
mov $0x0,%eax
jmpq 138a <func0+0x141>
lea -0x78(%rbp),%rdx
mov -0xd8(%rbp),%rsi
lea -0xc0(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 1150 <regexec@plt>
test %eax,%eax
jne 1376 <func0+0x12d>
mov -0x78(%rbp),%eax
mov %eax,-0xc8(%rbp)
mov -0x74(%rbp),%eax
mov %eax,-0xc4(%rbp)
mov -0xc4(%rbp),%eax
sub -0xc8(%rbp),%eax
movslq %eax,%rdx
mov -0xc8(%rbp),%eax
movslq %eax,%rcx
mov -0xd8(%rbp),%rax
add %rax,%rcx
lea -0x70(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <strncpy@plt>
mov -0xc4(%rbp),%eax
sub -0xc8(%rbp),%eax
cltq
movb $0x0,-0x70(%rbp,%rax,1)
lea -0x70(%rbp),%rcx
mov -0xc4(%rbp),%edx
mov -0xc8(%rbp),%eax
mov %rcx,%r9
mov %edx,%r8d
mov %eax,%ecx
lea 0xcde(%rip),%rdx
mov $0x64,%esi
lea 0x2cec(%rip),%rdi
mov $0x0,%eax
callq 1110 <snprintf@plt>
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 10f0 <regfree@plt>
lea 0x2ccc(%rip),%rax
jmp 138a <func0+0x141>
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 10f0 <regfree@plt>
mov $0x0,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 139e <func0+0x155>
callq 1100 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+preg]
mov edx, 1; cflags
lea rcx, pattern; "\\w+ly"
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
test eax, eax
jz short loc_12A9
lea rax, s; "Could not compile regex"
mov rdi, rax; s
call _puts
mov eax, 0
jmp loc_1396
loc_12A9:
lea rdx, [rbp+pmatch]
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 1; nmatch
mov rdi, rax; preg
call _regexec
test eax, eax
jnz loc_1382
mov eax, [rbp+pmatch.rm_so]
mov [rbp+var_C8], eax
mov eax, [rbp+pmatch.rm_eo]
mov [rbp+var_C4], eax
mov eax, [rbp+var_C4]
sub eax, [rbp+var_C8]
movsxd rdx, eax; n
mov eax, [rbp+var_C8]
movsxd rcx, eax
mov rax, [rbp+string]
add rcx, rax
lea rax, [rbp+dest]
mov rsi, rcx; src
mov rdi, rax; dest
call _strncpy
mov eax, [rbp+var_C4]
sub eax, [rbp+var_C8]
cdqe
mov [rbp+rax+dest], 0
lea rcx, [rbp+dest]
mov edx, [rbp+var_C4]
mov eax, [rbp+var_C8]
mov r9, rcx
mov r8d, edx
mov ecx, eax
lea rax, format; "%d-%d: %s"
mov rdx, rax; format
mov esi, 64h ; 'd'; maxlen
lea rax, result_1
mov rdi, rax; s
mov eax, 0
call _snprintf
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
lea rax, result_1
jmp short loc_1396
loc_1382:
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
mov eax, 0
loc_1396:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13AA
call ___stack_chk_fail
locret_13AA:
leave
retn | char * func0(const char *a1)
{
regmatch_t v2; // [rsp+18h] [rbp-C8h]
regex_t preg; // [rsp+20h] [rbp-C0h] BYREF
regmatch_t pmatch; // [rsp+68h] [rbp-78h] BYREF
char dest[104]; // [rsp+70h] [rbp-70h] BYREF
unsigned long long v6; // [rsp+D8h] [rbp-8h]
v6 = __readfsqword(0x28u);
if ( regcomp(&preg, "\\w+ly", 1) )
{
puts("Could not compile regex");
return 0LL;
}
else if ( regexec(&preg, a1, 1uLL, &pmatch, 0) )
{
regfree(&preg);
return 0LL;
}
else
{
v2 = pmatch;
strncpy(dest, &a1[pmatch.rm_so], pmatch.rm_eo - pmatch.rm_so);
dest[v2.rm_eo - v2.rm_so] = 0;
snprintf(result_1, 0x64uLL, "%d-%d: %s", v2.rm_so, v2.rm_eo, dest);
regfree(&preg);
return result_1;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0xd8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xc0]
MOV EDX,0x1
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101130
TEST EAX,EAX
JZ 0x001012a9
LEA RAX,[0x10200e]
MOV RDI,RAX
CALL 0x001010e0
MOV EAX,0x0
JMP 0x00101396
LAB_001012a9:
LEA RDX,[RBP + -0x78]
MOV RSI,qword ptr [RBP + -0xd8]
LEA RAX,[RBP + -0xc0]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00101150
TEST EAX,EAX
JNZ 0x00101382
MOV EAX,dword ptr [RBP + -0x78]
MOV dword ptr [RBP + -0xc8],EAX
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0xc4],EAX
MOV EAX,dword ptr [RBP + -0xc4]
SUB EAX,dword ptr [RBP + -0xc8]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0xc8]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0xd8]
ADD RCX,RAX
LEA RAX,[RBP + -0x70]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV EAX,dword ptr [RBP + -0xc4]
SUB EAX,dword ptr [RBP + -0xc8]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],0x0
LEA RCX,[RBP + -0x70]
MOV EDX,dword ptr [RBP + -0xc4]
MOV EAX,dword ptr [RBP + -0xc8]
MOV R9,RCX
MOV R8D,EDX
MOV ECX,EAX
LEA RAX,[0x102026]
MOV RDX,RAX
MOV ESI,0x64
LEA RAX,[0x104040]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101110
LEA RAX,[RBP + -0xc0]
MOV RDI,RAX
CALL 0x001010f0
LEA RAX,[0x104040]
JMP 0x00101396
LAB_00101382:
LEA RAX,[RBP + -0xc0]
MOV RDI,RAX
CALL 0x001010f0
MOV EAX,0x0
LAB_00101396:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013aa
CALL 0x00101100
LAB_001013aa:
LEAVE
RET | int1 * func0(char *param_1)
{
int iVar1;
int1 *puVar2;
long in_FS_OFFSET;
regex_t local_c8;
regmatch_t local_80;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_c8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_c8,param_1,1,&local_80,0);
if (iVar1 == 0) {
strncpy(local_78,param_1 + local_80.rm_so,(long)(local_80.rm_eo - local_80.rm_so));
local_78[local_80.rm_eo - local_80.rm_so] = '\0';
snprintf(result_1,100,"%d-%d: %s",(ulong)(uint)local_80.rm_so,(ulong)(uint)local_80.rm_eo,
local_78);
regfree(&local_c8);
puVar2 = result_1;
}
else {
regfree(&local_c8);
puVar2 = (int1 *)0x0;
}
}
else {
puts("Could not compile regex");
puVar2 = (int1 *)0x0;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar2;
} |
6,229 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NULL;
}
// Execute regular expression
if (regexec(®ex, text, 1, match, 0) == 0) {
int start = match[0].rm_so;
int end = match[0].rm_eo;
// Extract the actual word
char word[100]; // Ensure it's large enough to hold the word
strncpy(word, text + start, end - start);
word[end - start] = '\0';
// Create the resulting message
snprintf(result, sizeof(result), "%d-%d: %s", start, end, word);
// Free compiled regular expression
regfree(®ex);
return result;
}
regfree(®ex);
return NULL;
}
| int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0xc8,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xda5(%rip),%rsi
callq 1110 <regcomp@plt>
test %eax,%eax
jne 1325 <func0+0xfc>
lea 0x48(%rsp),%rcx
mov %rsp,%rdi
mov $0x0,%r8d
mov $0x1,%edx
mov %rbx,%rsi
callq 1120 <regexec@plt>
test %eax,%eax
jne 1338 <func0+0x10f>
mov 0x48(%rsp),%r12d
mov 0x4c(%rsp),%r13d
mov %r13d,%ebp
sub %r12d,%ebp
movslq %ebp,%rbp
movslq %r12d,%rsi
add %rbx,%rsi
lea 0x50(%rsp),%rbx
mov $0x64,%ecx
mov %rbp,%rdx
mov %rbx,%rdi
callq 1130 <__strncpy_chk@plt>
movb $0x0,0x50(%rsp,%rbp,1)
push %rbx
push %r13
mov %r12d,%r9d
lea 0xd53(%rip),%r8
mov $0x64,%ecx
mov $0x1,%edx
mov $0x64,%esi
lea 0x2d5b(%rip),%rdi
mov $0x0,%eax
callq 10c0 <__snprintf_chk@plt>
lea 0x10(%rsp),%rdi
callq 10e0 <regfree@plt>
add $0x10,%rsp
lea 0x2d3c(%rip),%rax
mov 0xb8(%rsp),%rdx
xor %fs:0x28,%rdx
jne 1347 <func0+0x11e>
add $0xc8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
lea 0xcde(%rip),%rdi
callq 10d0 <puts@plt>
mov $0x0,%eax
jmp 1304 <func0+0xdb>
mov %rsp,%rdi
callq 10e0 <regfree@plt>
mov $0x0,%eax
jmp 1304 <func0+0xdb>
callq 10f0 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+0E8h+var_30], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aWLy; "\\w+ly"
call _regcomp
test eax, eax
jnz loc_1345
lea rcx, [rsp+0E8h+var_A0]
mov rdi, rsp
mov r8d, 0
mov edx, 1
mov rsi, rbx
call _regexec
test eax, eax
jnz loc_1358
mov r12d, [rsp+0E8h+var_A0]
mov r13d, [rsp+0E8h+var_9C]
mov ebp, r13d
sub ebp, r12d
movsxd rbp, ebp
movsxd rax, r12d
lea rsi, [rbx+rax]
lea rbx, [rsp+0E8h+var_98]
mov ecx, 64h ; 'd'
mov rdx, rbp
mov rdi, rbx
call ___strncpy_chk
mov [rsp+rbp+0E8h+var_98], 0
push rbx
push r13
mov r9d, r12d
lea r8, aDDS; "%d-%d: %s"
mov ecx, 64h ; 'd'
mov edx, 1
mov esi, 64h ; 'd'
lea rbx, result_1
mov rdi, rbx
mov eax, 0
call ___snprintf_chk
lea rdi, [rsp+0F8h+var_E8]
call _regfree
add rsp, 10h
mov rax, rbx
loc_1324:
mov rdx, [rsp+0E8h+var_30]
sub rdx, fs:28h
jnz short loc_1367
add rsp, 0C8h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1345:
lea rdi, aCouldNotCompil; "Could not compile regex"
call _puts
mov eax, 0
jmp short loc_1324
loc_1358:
mov rdi, rsp
call _regfree
mov eax, 0
jmp short loc_1324
loc_1367:
call ___stack_chk_fail | void * func0(long long a1)
{
int v1; // r12d
int v2; // r13d
long long v3; // rbp
_BYTE v5[72]; // [rsp+0h] [rbp-E8h] BYREF
int v6; // [rsp+48h] [rbp-A0h] BYREF
int v7; // [rsp+4Ch] [rbp-9Ch]
char v8[104]; // [rsp+50h] [rbp-98h] BYREF
unsigned long long v9; // [rsp+B8h] [rbp-30h]
v9 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v5, "\\w+ly", 1LL) )
{
puts("Could not compile regex");
return 0LL;
}
else if ( (unsigned int)regexec(v5, a1, 1LL, &v6, 0LL) )
{
regfree(v5);
return 0LL;
}
else
{
v1 = v6;
v2 = v7;
v3 = v7 - v6;
__strncpy_chk(v8, a1 + v6, v3, 100LL);
v8[v3] = 0;
__snprintf_chk(&result_1, 100LL, 1LL, 100LL, "%d-%d: %s", v1, v2, v8);
regfree(v5);
return &result_1;
}
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
CALL 0x00101120
TEST EAX,EAX
JNZ 0x00101345
LEA RCX,[RSP + 0x48]
MOV RDI,RSP
MOV R8D,0x0
MOV EDX,0x1
MOV RSI,RBX
CALL 0x00101140
TEST EAX,EAX
JNZ 0x00101358
MOV R12D,dword ptr [RSP + 0x48]
MOV R13D,dword ptr [RSP + 0x4c]
MOV EBP,R13D
SUB EBP,R12D
MOVSXD RBP,EBP
MOVSXD RAX,R12D
LEA RSI,[RBX + RAX*0x1]
LEA RBX,[RSP + 0x50]
MOV ECX,0x64
MOV RDX,RBP
MOV RDI,RBX
CALL 0x00101150
MOV byte ptr [RSP + RBP*0x1 + 0x50],0x0
PUSH RBX
PUSH R13
MOV R9D,R12D
LEA R8,[0x102022]
MOV ECX,0x64
MOV EDX,0x1
MOV ESI,0x64
LEA RBX,[0x104040]
MOV RDI,RBX
MOV EAX,0x0
CALL 0x001010d0
LEA RDI,[RSP + 0x10]
CALL 0x001010f0
ADD RSP,0x10
MOV RAX,RBX
LAB_00101324:
MOV RDX,qword ptr [RSP + 0xb8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101367
ADD RSP,0xc8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101345:
LEA RDI,[0x10200a]
CALL 0x001010e0
MOV EAX,0x0
JMP 0x00101324
LAB_00101358:
MOV RDI,RSP
CALL 0x001010f0
MOV EAX,0x0
JMP 0x00101324
LAB_00101367:
CALL 0x00101100 | int1 * func0(char *param_1)
{
int iVar1;
int1 *puVar2;
long in_FS_OFFSET;
regex_t local_e8;
regmatch_t local_a0;
int1 local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_e8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_e8,param_1,1,&local_a0,0);
if (iVar1 == 0) {
__strncpy_chk(local_98,param_1 + local_a0.rm_so,(long)(local_a0.rm_eo - local_a0.rm_so),100);
local_98[local_a0.rm_eo - local_a0.rm_so] = 0;
__snprintf_chk(result_1,100,1,100,"%d-%d: %s",local_a0.rm_so,local_a0.rm_eo,local_98);
regfree(&local_e8);
puVar2 = result_1;
}
else {
regfree(&local_e8);
puVar2 = (int1 *)0x0;
}
}
else {
puts("Could not compile regex");
puVar2 = (int1 *)0x0;
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,230 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NULL;
}
// Execute regular expression
if (regexec(®ex, text, 1, match, 0) == 0) {
int start = match[0].rm_so;
int end = match[0].rm_eo;
// Extract the actual word
char word[100]; // Ensure it's large enough to hold the word
strncpy(word, text + start, end - start);
word[end - start] = '\0';
// Create the resulting message
snprintf(result, sizeof(result), "%d-%d: %s", start, end, word);
// Free compiled regular expression
regfree(®ex);
return result;
}
regfree(®ex);
return NULL;
}
| int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
mov $0x1,%edx
lea 0xce2(%rip),%rsi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0xc0,%rsp
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 1110 <regcomp@plt>
test %eax,%eax
jne 1420 <func0+0x110>
xor %r8d,%r8d
lea 0x48(%rsp),%rcx
mov $0x1,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 1120 <regexec@plt>
test %eax,%eax
jne 1410 <func0+0x100>
mov 0x4c(%rsp),%r14d
movslq 0x48(%rsp),%rsi
lea 0x50(%rsp),%rdi
mov $0x64,%ecx
mov %r14d,%r12d
mov %rsi,%r13
sub %esi,%r12d
add %rbx,%rsi
movslq %r12d,%r12
mov %r12,%rdx
callq 1130 <__strncpy_chk@plt>
movb $0x0,0x50(%rsp,%r12,1)
mov %r13d,%r9d
mov $0x1,%edx
push %rax
lea 0xc69(%rip),%r8
xor %eax,%eax
mov $0x64,%ecx
push %r14
mov $0x64,%esi
lea 0x2c72(%rip),%rdi
callq 10c0 <__snprintf_chk@plt>
mov %rbp,%rdi
callq 10e0 <regfree@plt>
pop %rax
lea 0x2c5d(%rip),%rax
pop %rdx
mov 0xb8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 1430 <func0+0x120>
add $0xc0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 10e0 <regfree@plt>
xor %eax,%eax
jmp 13e4 <func0+0xd4>
nopl 0x0(%rax)
lea 0xbe3(%rip),%rdi
callq 10d0 <puts@plt>
xor %eax,%eax
jmp 13e4 <func0+0xd4>
callq 10f0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov edx, 1
lea rsi, aWLy; "\\w+ly"
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C0h
mov rax, fs:28h
mov [rsp+var_sB8], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
test eax, eax
jnz loc_1430
xor r8d, r8d
lea rcx, [rsp+var_s48]
mov edx, 1
mov rsi, rbx
mov rdi, rbp
call _regexec
test eax, eax
jnz loc_1420
mov r14d, [rsp+var_s4C]
movsxd rax, [rsp+var_s48]
lea rdi, [rsp+var_s50]
mov ecx, 64h ; 'd'
mov r12d, r14d
lea rsi, [rbx+rax]
mov r13, rax
sub r12d, eax
lea rbx, result_1
movsxd r12, r12d
mov rdx, r12
call ___strncpy_chk
mov edx, 1
mov r9d, r13d
mov rdi, rbx
mov [rsp+r12+var_s50], 0
mov ecx, 64h ; 'd'
mov esi, 64h ; 'd'
lea r8, aDDS; "%d-%d: %s"
push rax
xor eax, eax
push r14
call ___snprintf_chk
mov rdi, rbp
call _regfree
pop rax
mov rax, rbx
pop rdx
loc_13F4:
mov rdx, [rsp+var_sB8]
sub rdx, fs:28h
jnz short loc_1440
add rsp, 0C0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1420:
mov rdi, rbp
call _regfree
xor eax, eax
jmp short loc_13F4
loc_1430:
lea rdi, aCouldNotCompil; "Could not compile regex"
call _puts
xor eax, eax
jmp short loc_13F4
loc_1440:
call ___stack_chk_fail | void * func0(long long a1)
{
int v1; // r14d
int v2; // r13d
long long v3; // r12
const char *v4; // rax
_BYTE _0[72]; // [rsp+0h] [rbp+0h] BYREF
int vars48; // [rsp+48h] [rbp+48h] BYREF
int vars4C; // [rsp+4Ch] [rbp+4Ch]
_BYTE vars50[104]; // [rsp+50h] [rbp+50h] BYREF
unsigned long long varsB8; // [rsp+B8h] [rbp+B8h]
varsB8 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(_0, "\\w+ly", 1LL) )
{
puts("Could not compile regex");
return 0LL;
}
else if ( (unsigned int)regexec(_0, a1, 1LL, &vars48, 0LL) )
{
regfree(_0);
return 0LL;
}
else
{
v1 = vars4C;
v2 = vars48;
v3 = vars4C - vars48;
v4 = (const char *)__strncpy_chk(vars50, a1 + vars48, v3, 100LL);
vars50[v3] = 0;
__snprintf_chk(&result_1, 100LL, 1LL, 100LL, "%d-%d: %s", v2, v1, v4);
regfree(_0);
return &result_1;
}
} | func0:
ENDBR64
PUSH R14
MOV EDX,0x1
LEA RSI,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x00101120
TEST EAX,EAX
JNZ 0x00101430
XOR R8D,R8D
LEA RCX,[RSP + 0x48]
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101140
TEST EAX,EAX
JNZ 0x00101420
MOV R14D,dword ptr [RSP + 0x4c]
MOVSXD RAX,dword ptr [RSP + 0x48]
LEA RDI,[RSP + 0x50]
MOV ECX,0x64
MOV R12D,R14D
LEA RSI,[RBX + RAX*0x1]
MOV R13,RAX
SUB R12D,EAX
LEA RBX,[0x104040]
MOVSXD R12,R12D
MOV RDX,R12
CALL 0x00101150
MOV EDX,0x1
MOV R9D,R13D
MOV RDI,RBX
MOV byte ptr [RSP + R12*0x1 + 0x50],0x0
MOV ECX,0x64
MOV ESI,0x64
LEA R8,[0x102022]
PUSH RAX
XOR EAX,EAX
PUSH R14
CALL 0x001010d0
MOV RDI,RBP
CALL 0x001010f0
POP RAX
MOV RAX,RBX
POP RDX
LAB_001013f4:
MOV RDX,qword ptr [RSP + 0xb8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101440
ADD RSP,0xc0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101420:
MOV RDI,RBP
CALL 0x001010f0
XOR EAX,EAX
JMP 0x001013f4
LAB_00101430:
LEA RDI,[0x10200a]
CALL 0x001010e0
XOR EAX,EAX
JMP 0x001013f4
LAB_00101440:
CALL 0x00101100 | int1 * func0(char *param_1)
{
int iVar1;
int8 uVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_e8;
regmatch_t local_a0;
int1 local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_e8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_e8,param_1,1,&local_a0,0);
if (iVar1 == 0) {
uVar2 = __strncpy_chk(local_98,param_1 + local_a0.rm_so,
(long)(local_a0.rm_eo - local_a0.rm_so),100);
local_98[local_a0.rm_eo - local_a0.rm_so] = 0;
__snprintf_chk(result_1,100,1,100,"%d-%d: %s",local_a0.rm_so,local_a0.rm_eo,uVar2);
regfree(&rStack_e8);
puVar3 = result_1;
}
else {
regfree(&rStack_e8);
puVar3 = (int1 *)0x0;
}
}
else {
puts("Could not compile regex");
puVar3 = (int1 *)0x0;
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,231 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NULL;
}
// Execute regular expression
if (regexec(®ex, text, 1, match, 0) == 0) {
int start = match[0].rm_so;
int end = match[0].rm_eo;
// Extract the actual word
char word[100]; // Ensure it's large enough to hold the word
strncpy(word, text + start, end - start);
word[end - start] = '\0';
// Create the resulting message
snprintf(result, sizeof(result), "%d-%d: %s", start, end, word);
// Free compiled regular expression
regfree(®ex);
return result;
}
regfree(®ex);
return NULL;
}
| int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
mov $0x1,%edx
lea 0xce2(%rip),%rsi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0xc0,%rsp
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 1110 <regcomp@plt>
test %eax,%eax
jne 1420 <func0+0x110>
xor %r8d,%r8d
lea 0x48(%rsp),%rcx
mov $0x1,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 1120 <regexec@plt>
test %eax,%eax
jne 1410 <func0+0x100>
mov 0x4c(%rsp),%r14d
movslq 0x48(%rsp),%rsi
lea 0x50(%rsp),%rdi
mov $0x64,%ecx
mov %r14d,%r12d
mov %rsi,%r13
sub %esi,%r12d
add %rbx,%rsi
movslq %r12d,%r12
mov %r12,%rdx
callq 1130 <__strncpy_chk@plt>
movb $0x0,0x50(%rsp,%r12,1)
mov %r13d,%r9d
mov $0x1,%edx
push %rax
lea 0xc69(%rip),%r8
xor %eax,%eax
mov $0x64,%ecx
push %r14
mov $0x64,%esi
lea 0x2c72(%rip),%rdi
callq 10c0 <__snprintf_chk@plt>
mov %rbp,%rdi
callq 10e0 <regfree@plt>
pop %rax
lea 0x2c5d(%rip),%rax
pop %rdx
mov 0xb8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 1430 <func0+0x120>
add $0xc0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 10e0 <regfree@plt>
xor %eax,%eax
jmp 13e4 <func0+0xd4>
nopl 0x0(%rax)
lea 0xbe3(%rip),%rdi
callq 10d0 <puts@plt>
xor %eax,%eax
jmp 13e4 <func0+0xd4>
callq 10f0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov edx, 1; cflags
lea rsi, pattern; "\\w+ly"
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C0h
mov rax, fs:28h
mov [rsp+var_sB8], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz loc_1430
xor r8d, r8d; eflags
lea rcx, [rsp+pmatch]; pmatch
mov edx, 1; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
test eax, eax
jnz loc_1420
mov r14d, [rsp+pmatch.rm_eo]
movsxd rax, [rsp+pmatch.rm_so]
lea rdi, [rsp+var_s50]
mov ecx, 64h ; 'd'
mov r12d, r14d
lea rsi, [rbx+rax]
mov r13, rax
sub r12d, eax
lea rbx, result_1
movsxd r12, r12d
mov rdx, r12
call ___strncpy_chk
mov edx, 2
mov r9d, r13d
mov rdi, rbx
mov [rsp+r12+var_s50], 0
mov ecx, 64h ; 'd'
mov esi, 64h ; 'd'
lea r8, aDDS; "%d-%d: %s"
push rax
xor eax, eax
push r14
call ___snprintf_chk
mov rdi, rbp; preg
call _regfree
pop rax
mov rax, rbx
pop rdx
loc_13F4:
mov rdx, [rsp+var_sB8]
sub rdx, fs:28h
jnz short loc_1440
add rsp, 0C0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1420:
mov rdi, rbp; preg
call _regfree
xor eax, eax
jmp short loc_13F4
loc_1430:
lea rdi, s; "Could not compile regex"
call _puts
xor eax, eax
jmp short loc_13F4
loc_1440:
call ___stack_chk_fail | void * func0(char *string)
{
regoff_t rm_eo; // r14d
regoff_t rm_so; // r13d
long long v3; // r12
const char *v4; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
regmatch_t pmatch; // [rsp+48h] [rbp+48h] BYREF
_BYTE vars50[104]; // [rsp+50h] [rbp+50h] BYREF
unsigned long long varsB8; // [rsp+B8h] [rbp+B8h]
varsB8 = __readfsqword(0x28u);
if ( regcomp(&_0, "\\w+ly", 1) )
{
puts("Could not compile regex");
return 0LL;
}
else if ( regexec(&_0, string, 1uLL, &pmatch, 0) )
{
regfree(&_0);
return 0LL;
}
else
{
rm_eo = pmatch.rm_eo;
rm_so = pmatch.rm_so;
v3 = pmatch.rm_eo - pmatch.rm_so;
v4 = (const char *)__strncpy_chk(vars50, &string[pmatch.rm_so], v3, 100LL);
vars50[v3] = 0;
__snprintf_chk(&result_1, 100LL, 2LL, 100LL, "%d-%d: %s", rm_so, rm_eo, v4);
regfree(&_0);
return &result_1;
}
} | func0:
ENDBR64
PUSH R14
MOV EDX,0x1
LEA RSI,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x00101120
TEST EAX,EAX
JNZ 0x00101430
XOR R8D,R8D
LEA RCX,[RSP + 0x48]
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101140
TEST EAX,EAX
JNZ 0x00101420
MOV R14D,dword ptr [RSP + 0x4c]
MOVSXD RAX,dword ptr [RSP + 0x48]
LEA RDI,[RSP + 0x50]
MOV ECX,0x64
MOV R12D,R14D
LEA RSI,[RBX + RAX*0x1]
MOV R13,RAX
SUB R12D,EAX
LEA RBX,[0x104040]
MOVSXD R12,R12D
MOV RDX,R12
CALL 0x00101150
MOV EDX,0x2
MOV R9D,R13D
MOV RDI,RBX
MOV byte ptr [RSP + R12*0x1 + 0x50],0x0
MOV ECX,0x64
MOV ESI,0x64
LEA R8,[0x102022]
PUSH RAX
XOR EAX,EAX
PUSH R14
CALL 0x001010d0
MOV RDI,RBP
CALL 0x001010f0
POP RAX
MOV RAX,RBX
POP RDX
LAB_001013f4:
MOV RDX,qword ptr [RSP + 0xb8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101440
ADD RSP,0xc0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101420:
MOV RDI,RBP
CALL 0x001010f0
XOR EAX,EAX
JMP 0x001013f4
LAB_00101430:
LEA RDI,[0x10200a]
CALL 0x001010e0
XOR EAX,EAX
JMP 0x001013f4
LAB_00101440:
CALL 0x00101100 | int1 * func0(char *param_1)
{
int iVar1;
int8 uVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_e8;
regmatch_t local_a0;
int local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_e8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_e8,param_1,1,&local_a0,0);
if (iVar1 == 0) {
uVar2 = __strncpy_chk(local_98,param_1 + local_a0.rm_so,
(long)(local_a0.rm_eo - local_a0.rm_so),100);
local_98[local_a0.rm_eo - local_a0.rm_so] = 0;
__snprintf_chk(result_1,100,2,100,"%d-%d: %s",local_a0.rm_so,local_a0.rm_eo,uVar2);
regfree(&rStack_e8);
puVar3 = result_1;
}
else {
regfree(&rStack_e8);
puVar3 = (int1 *)0x0;
}
}
else {
puts("Could not compile regex");
puVar3 = (int1 *)0x0;
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,232 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->price < itemA->price) {
return -1;
} else {
return 0;
}
}
| Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}, {.name = "Item-4", .price = 22.75}};
Item *result;
result = func0(items1, 2, 1);
assert(result[0].price == 555.22);
result = func0(items2, 3, 2);
assert(result[0].price == 555.22 && result[1].price == 101.1);
result = func0(items3, 4, 1);
assert(result[0].price == 555.22);
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x8c(%rip),%rcx
mov $0x20,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x20(%rbp),%eax
cltq
shl $0x5,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 12ca <func0+0x9c>
mov -0xc(%rbp),%eax
cltq
shl $0x5,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rsi
mov -0xc(%rbp),%eax
cltq
shl $0x5,%rax
mov %rax,%rdx
mov -0x8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov (%rsi),%rax
mov 0x8(%rsi),%rdx
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
mov 0x10(%rsi),%rax
mov 0x18(%rsi),%rdx
mov %rax,0x10(%rcx)
mov %rdx,0x18(%rcx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 1280 <func0+0x52>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 20h ; ' '; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_20]
cdqe
shl rax, 5
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_12CD
loc_1283:
mov eax, [rbp+var_C]
cdqe
shl rax, 5
mov rdx, rax
mov rax, [rbp+base]
lea rsi, [rdx+rax]
mov eax, [rbp+var_C]
cdqe
shl rax, 5
mov rdx, rax
mov rax, [rbp+var_8]
lea rcx, [rdx+rax]
mov rax, [rsi]
mov rdx, [rsi+8]
mov [rcx], rax
mov [rcx+8], rdx
mov rax, [rsi+10h]
mov rdx, [rsi+18h]
mov [rcx+10h], rax
mov [rcx+18h], rdx
add [rbp+var_C], 1
loc_12CD:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_20]
jl short loc_1283
mov rax, [rbp+var_8]
leave
retn | char * func0(char *a1, int a2, int a3)
{
char *v3; // rsi
char *v4; // rcx
long long v5; // rdx
long long v6; // rdx
int i; // [rsp+14h] [rbp-Ch]
char *v10; // [rsp+18h] [rbp-8h]
qsort(a1, a2, 0x20uLL, compare);
v10 = (char *)malloc(32LL * a3);
for ( i = 0; i < a3; ++i )
{
v3 = &a1[32 * i];
v4 = &v10[32 * i];
v5 = *((_QWORD *)v3 + 1);
*(_QWORD *)v4 = *(_QWORD *)v3;
*((_QWORD *)v4 + 1) = v5;
v6 = *((_QWORD *)v3 + 3);
*((_QWORD *)v4 + 2) = *((_QWORD *)v3 + 2);
*((_QWORD *)v4 + 3) = v6;
}
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x20
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x5
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012cd
LAB_00101283:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x5
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RSI,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x5
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
MOV RAX,qword ptr [RSI + 0x10]
MOV RDX,qword ptr [RSI + 0x18]
MOV qword ptr [RCX + 0x10],RAX
MOV qword ptr [RCX + 0x18],RDX
ADD dword ptr [RBP + -0xc],0x1
LAB_001012cd:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101283
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(void *param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
void *pvVar4;
int local_14;
qsort(param_1,(long)param_2,0x20,compare);
pvVar4 = malloc((long)param_3 << 5);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
puVar1 = (int8 *)((long)local_14 * 0x20 + (long)param_1);
puVar2 = (int8 *)((long)local_14 * 0x20 + (long)pvVar4);
uVar3 = puVar1[1];
*puVar2 = *puVar1;
puVar2[1] = uVar3;
uVar3 = puVar1[3];
puVar2[2] = puVar1[2];
puVar2[3] = uVar3;
}
return pvVar4;
} |
6,233 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->price < itemA->price) {
return -1;
} else {
return 0;
}
}
| Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}, {.name = "Item-4", .price = 22.75}};
Item *result;
result = func0(items1, 2, 1);
assert(result[0].price == 555.22);
result = func0(items2, 3, 2);
assert(result[0].price == 555.22 && result[1].price == 101.1);
result = func0(items3, 4, 1);
assert(result[0].price == 555.22);
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %edx,%ebp
movslq %esi,%rsi
lea -0x3f(%rip),%rcx
mov $0x20,%edx
callq 10a0 <qsort@plt>
movslq %ebp,%rdi
shl $0x5,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 124f <func0+0x60>
lea -0x1(%rbp),%ecx
add $0x1,%rcx
shl $0x5,%rcx
mov $0x0,%edx
movdqu (%rbx,%rdx,1),%xmm0
movups %xmm0,(%rax,%rdx,1)
movdqu 0x10(%rbx,%rdx,1),%xmm1
movups %xmm1,0x10(%rax,%rdx,1)
add $0x20,%rdx
cmp %rcx,%rdx
jne 1232 <func0+0x43>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, edx
movsxd rsi, esi
lea rcx, compare
mov edx, 20h ; ' '
call _qsort
movsxd rdi, ebp
shl rdi, 5
call _malloc
test ebp, ebp
jle short loc_124A
mov ecx, ebp
shl rcx, 5
mov edx, 0
loc_122D:
movdqu xmm0, xmmword ptr [rbx+rdx]
movups xmmword ptr [rax+rdx], xmm0
movdqu xmm1, xmmword ptr [rbx+rdx+10h]
movups xmmword ptr [rax+rdx+10h], xmm1
add rdx, 20h ; ' '
cmp rdx, rcx
jnz short loc_122D
loc_124A:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
long long v5; // rdx
qsort(a1, a2, 32LL, compare);
result = malloc(32LL * a3);
if ( a3 > 0 )
{
v5 = 0LL;
do
{
*(__m128i *)(result + v5) = _mm_loadu_si128((const __m128i *)(a1 + v5));
*(__m128i *)(result + v5 + 16) = _mm_loadu_si128((const __m128i *)(a1 + v5 + 16));
v5 += 32LL;
}
while ( v5 != 32LL * (unsigned int)a3 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,EDX
MOVSXD RSI,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x20
CALL 0x001010a0
MOVSXD RDI,EBP
SHL RDI,0x5
CALL 0x001010d0
TEST EBP,EBP
JLE 0x0010124a
MOV ECX,EBP
SHL RCX,0x5
MOV EDX,0x0
LAB_0010122d:
MOVDQU XMM0,xmmword ptr [RBX + RDX*0x1]
MOVUPS xmmword ptr [RAX + RDX*0x1],XMM0
MOVDQU XMM1,xmmword ptr [RBX + RDX*0x1 + 0x10]
MOVUPS xmmword ptr [RAX + RDX*0x1 + 0x10],XMM1
ADD RDX,0x20
CMP RDX,RCX
JNZ 0x0010122d
LAB_0010124a:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(void *param_1,int param_2,uint param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
void *pvVar4;
long lVar5;
qsort(param_1,(long)param_2,0x20,compare);
pvVar4 = malloc((long)(int)param_3 << 5);
if (0 < (int)param_3) {
lVar5 = 0;
do {
uVar3 = ((int8 *)((long)param_1 + lVar5))[1];
*(int8 *)((long)pvVar4 + lVar5) = *(int8 *)((long)param_1 + lVar5);
((int8 *)((long)pvVar4 + lVar5))[1] = uVar3;
puVar1 = (int8 *)((long)param_1 + lVar5 + 0x10);
uVar3 = puVar1[1];
puVar2 = (int8 *)((long)pvVar4 + lVar5 + 0x10);
*puVar2 = *puVar1;
puVar2[1] = uVar3;
lVar5 = lVar5 + 0x20;
} while (lVar5 != (ulong)param_3 << 5);
}
return;
} |
6,234 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->price < itemA->price) {
return -1;
} else {
return 0;
}
}
| Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}, {.name = "Item-4", .price = 22.75}};
Item *result;
result = func0(items1, 2, 1);
assert(result[0].price == 555.22);
result = func0(items2, 3, 2);
assert(result[0].price == 555.22 && result[1].price == 101.1);
result = func0(items3, 4, 1);
assert(result[0].price == 555.22);
free(result);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
mov %edx,%ebp
lea -0x41(%rip),%rcx
push %rbx
mov $0x20,%edx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10a0 <qsort@plt>
movslq %ebp,%rdi
shl $0x5,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 14fd <func0+0x5d>
lea -0x1(%rbp),%ecx
xor %edx,%edx
add $0x1,%rcx
shl $0x5,%rcx
movdqu (%rbx,%rdx,1),%xmm0
movdqu 0x10(%rbx,%rdx,1),%xmm1
movups %xmm0,(%rax,%rdx,1)
movups %xmm1,0x10(%rax,%rdx,1)
add $0x20,%rdx
cmp %rcx,%rdx
jne 14e0 <func0+0x40>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r12
movsxd r12, edx
movsxd rsi, esi
lea rcx, compare
push rbp
mov edx, 20h ; ' '
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 5
call _qsort
mov rdi, r12
call _malloc
mov r8, rax
test ebx, ebx
jle short loc_1509
mov rdx, r12
mov rsi, rbp
mov rdi, rax
call _memcpy
mov r8, rax
loc_1509:
pop rbx
mov rax, r8
pop rbp
pop r12
retn | long long func0(long long a1, int a2, int a3)
{
long long v4; // r12
long long v5; // rax
long long v6; // rcx
long long v7; // r8
v4 = 32LL * a3;
qsort(a1, a2, 32LL, compare);
v5 = malloc(v4);
v7 = v5;
if ( a3 > 0 )
return memcpy(v5, a1, v4, v6, v5);
return v7;
} | func0:
ENDBR64
PUSH R12
MOVSXD R12,EDX
MOVSXD RSI,ESI
LEA RCX,[0x101490]
PUSH RBP
MOV EDX,0x20
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x5
CALL 0x001010b0
MOV RDI,R12
CALL 0x001010f0
MOV R8,RAX
TEST EBX,EBX
JLE 0x00101509
MOV RDX,R12
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010e0
MOV R8,RAX
LAB_00101509:
POP RBX
MOV RAX,R8
POP RBP
POP R12
RET | void * func0(void *param_1,int param_2,int param_3)
{
void *__dest;
qsort(param_1,(long)param_2,0x20,compare);
__dest = malloc((long)param_3 << 5);
if (0 < param_3) {
__dest = memcpy(__dest,param_1,(long)param_3 << 5);
}
return __dest;
} |
6,235 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->price < itemA->price) {
return -1;
} else {
return 0;
}
}
| Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}, {.name = "Item-4", .price = 22.75}};
Item *result;
result = func0(items1, 2, 1);
assert(result[0].price == 555.22);
result = func0(items2, 3, 2);
assert(result[0].price == 555.22 && result[1].price == 101.1);
result = func0(items3, 4, 1);
assert(result[0].price == 555.22);
free(result);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
lea -0x3f(%rip),%rcx
mov %rdi,%rbp
push %rbx
mov %edx,%ebx
mov $0x20,%edx
sub $0x8,%rsp
callq 10b0 <qsort@plt>
movslq %ebx,%rdi
shl $0x5,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 150f <func0+0x4f>
lea -0x1(%rbx),%edx
mov %rbp,%rsi
mov %rax,%rdi
add $0x1,%rdx
shl $0x5,%rdx
callq 10e0 <memcpy@plt>
mov %rax,%r8
add $0x8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbp
lea rcx, compare; compar
movsxd rsi, esi; nmemb
mov rbp, rdi
push rbx
mov ebx, edx
mov edx, 20h ; ' '; size
sub rsp, 8
call _qsort
movsxd rdi, ebx
shl rdi, 5; size
call _malloc
mov rcx, rax
test ebx, ebx
jle short loc_150A
mov edx, ebx
mov rsi, rbp; src
mov rdi, rax; dest
shl rdx, 5; n
call _memcpy
mov rcx, rax
loc_150A:
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
retn | void * func0(void *src, int a2, int a3)
{
void *v4; // rax
void *v5; // rcx
qsort(src, a2, 0x20uLL, compare);
v4 = malloc(32LL * a3);
v5 = v4;
if ( a3 > 0 )
return memcpy(v4, src, 32LL * (unsigned int)a3);
return v5;
} | func0:
ENDBR64
PUSH RBP
LEA RCX,[0x101490]
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
MOV EBX,EDX
MOV EDX,0x20
SUB RSP,0x8
CALL 0x001010b0
MOVSXD RDI,EBX
SHL RDI,0x5
CALL 0x001010f0
MOV RCX,RAX
TEST EBX,EBX
JLE 0x0010150a
MOV EDX,EBX
MOV RSI,RBP
MOV RDI,RAX
SHL RDX,0x5
CALL 0x001010e0
MOV RCX,RAX
LAB_0010150a:
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
RET | void * func0(void *param_1,int param_2,uint param_3)
{
void *__dest;
qsort(param_1,(long)param_2,0x20,compare);
__dest = malloc((long)(int)param_3 << 5);
if (0 < (int)param_3) {
__dest = memcpy(__dest,param_1,(ulong)param_3 << 5);
}
return __dest;
} |
6,236 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2] == 4 && result[3] == 1);
func0((int[]){0, 1, 2, 3, 4, 5, 6, 7}, 8, 3, result);
assert(result[0] == 3 && result[1] == 4 && result[2] == 5 && result[3] == 6 && result[4] == 7 && result[5] == 0 && result[6] == 1 && result[7] == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x30(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x18(%rbp)
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 120f <func0+0xa6>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f8 <func0+0x8f>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1239 <func0+0xd0>
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,-0x10(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 127c <func0+0x113>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x10(%rbp),%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1255 <func0+0xec>
movl $0x0,-0x20(%rbp)
mov -0x30(%rbp),%eax
mov %eax,-0x1c(%rbp)
jmp 12ca <func0+0x161>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x20(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x20(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1293 <func0+0x12a>
movl $0x0,-0x1c(%rbp)
jmp 1309 <func0+0x1a0>
mov -0x20(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x20(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,(%rcx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 12db <func0+0x172>
mov %rsi,%rsp
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 1329 <func0+0x1c0>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_30]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
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_11DD:
cmp rsp, rdx
jz short loc_11F4
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11DD
loc_11F4:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_121E
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_121E:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_20], 0
jmp short loc_1261
loc_123A:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_20], 1
loc_1261:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_30]
jl short loc_123A
mov [rbp+var_1C], 0
mov eax, [rbp+var_30]
mov [rbp+var_20], eax
jmp short loc_12AF
loc_1278:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
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_38]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_20], 1
loc_12AF:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jl short loc_1278
mov [rbp+var_20], 0
jmp short loc_12EE
loc_12C0:
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_38]
lea rcx, [rdx+rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rcx], eax
add [rbp+var_20], 1
loc_12EE:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_30]
jl short loc_12C0
mov rsp, rsi
nop
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_130E
call ___stack_chk_fail
locret_130E:
leave
retn | unsigned long long func0(long long a1, int a2, int a3, long long a4)
{
unsigned long long v4; // rax
void *v5; // rsp
int v6; // eax
int v7; // eax
_BYTE v9[8]; // [rsp+8h] [rbp-40h] BYREF
long long v10; // [rsp+10h] [rbp-38h]
int v11; // [rsp+18h] [rbp-30h]
int v12; // [rsp+1Ch] [rbp-2Ch]
long long v13; // [rsp+20h] [rbp-28h]
int i; // [rsp+28h] [rbp-20h]
int v15; // [rsp+2Ch] [rbp-1Ch]
long long v16; // [rsp+30h] [rbp-18h]
_BYTE *v17; // [rsp+38h] [rbp-10h]
unsigned long long v18; // [rsp+40h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v18 = __readfsqword(0x28u);
v16 = a3 - 1LL;
v4 = 16 * ((4LL * a3 + 15) / 0x10uLL);
while ( v9 != &v9[-(v4 & 0xFFFFFFFFFFFFF000LL)] )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)&v9[(v4 & 0xFFF) - 8] = *(_QWORD *)&v9[(v4 & 0xFFF) - 8];
v17 = v9;
for ( i = 0; i < v11; ++i )
*(_DWORD *)&v17[4 * i] = *(_DWORD *)(4LL * i + v13);
v15 = 0;
for ( i = v11; i < v12; ++i )
{
v6 = v15++;
*(_DWORD *)(v10 + 4LL * v6) = *(_DWORD *)(4LL * i + v13);
}
for ( i = 0; i < v11; ++i )
{
v7 = v15++;
*(_DWORD *)(4LL * v7 + v10) = *(_DWORD *)&v17[4 * i];
}
return v18 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
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_001011dd:
CMP RSP,RDX
JZ 0x001011f4
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011dd
LAB_001011f4:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010121e
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010121e:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101261
LAB_0010123a:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x20],0x1
LAB_00101261:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x0010123a
MOV dword ptr [RBP + -0x1c],0x0
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001012af
LAB_00101278:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
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 + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x20],0x1
LAB_001012af:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101278
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001012ee
LAB_001012c0:
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 + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RCX],EAX
ADD dword ptr [RBP + -0x20],0x1
LAB_001012ee:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001012c0
MOV RSP,RSI
NOP
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010130e
CALL 0x00101060
LAB_0010130e:
LEAVE
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int local_38;
int local_34;
long local_30;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_30 = param_1;
local_34 = param_2;
local_38 = param_3;
local_40 = param_4;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)param_3 + -1;
uVar2 = (((long)param_3 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_28 = 0; local_28 < local_38; local_28 = local_28 + 1) {
*(int4 *)(puVar3 + (long)local_28 * 4 + lVar1) =
*(int4 *)(local_30 + (long)local_28 * 4);
}
local_24 = 0;
for (local_28 = local_38; local_28 < local_34; local_28 = local_28 + 1) {
*(int4 *)((long)local_24 * 4 + local_40) = *(int4 *)((long)local_28 * 4 + local_30);
local_24 = local_24 + 1;
}
for (local_28 = 0; local_28 < local_38; local_28 = local_28 + 1) {
*(int4 *)((long)local_24 * 4 + local_40) =
*(int4 *)(puVar3 + (long)local_28 * 4 + lVar1);
local_24 = local_24 + 1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
} |
6,237 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2] == 4 && result[3] == 1);
func0((int[]){0, 1, 2, 3, 4, 5, 6, 7}, 8, 3, result);
assert(result[0] == 3 && result[1] == 4 && result[2] == 5 && result[3] == 6 && result[4] == 7 && result[5] == 0 && result[6] == 1 && result[7] == 2);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edx,%rax
lea 0xf(,%rax,4),%r8
mov %r8,%r9
and $0xfffffffffffffff0,%r9
and $0xfffffffffffff000,%r8
mov %rsp,%r11
sub %r8,%r11
mov %r11,%r8
cmp %r8,%rsp
je 11bd <func0+0x54>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a6 <func0+0x3d>
mov %r9,%r8
and $0xfff,%r8d
sub %r8,%rsp
test %r8,%r8
je 11d5 <func0+0x6c>
orq $0x0,-0x8(%rsp,%r8,1)
mov %rsp,%r9
test %edx,%edx
jle 1260 <func0+0xf7>
lea -0x1(%rdx),%r11d
mov $0x0,%r8d
mov (%rdi,%r8,4),%r10d
mov %r10d,(%r9,%r8,4)
mov %r8,%r10
add $0x1,%r8
cmp %r11,%r10
jne 11ea <func0+0x81>
cmp %esi,%edx
jge 1259 <func0+0xf0>
mov %rax,%r8
neg %r8
lea (%rcx,%r8,4),%r10
mov (%rdi,%rax,4),%r8d
mov %r8d,(%r10,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 120c <func0+0xa3>
mov %esi,%eax
sub %edx,%eax
cmp %esi,%edx
mov $0x1,%esi
cmovge %esi,%eax
test %edx,%edx
jle 1248 <func0+0xdf>
cltq
lea (%rcx,%rax,4),%rsi
mov $0x0,%eax
mov (%r9,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
add $0x1,%rax
cmp %eax,%edx
jg 1239 <func0+0xd0>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 1266 <func0+0xfd>
leaveq
retq
mov $0x0,%eax
jmp 122e <func0+0xc5>
cmp %esi,%edx
jl 1202 <func0+0x99>
jmp 1248 <func0+0xdf>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r9d, esi
mov esi, edx
mov r11, rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edx
lea rdx, ds:0Fh[rax*4]
mov r8, rdx
and r8, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rdx
loc_11AB:
cmp rsp, rcx
jz short loc_11C2
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11AB
loc_11C2:
mov rdx, r8
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jz short loc_11D9
or [rsp+rdx+10h+var_18], 0
loc_11D9:
mov rcx, rsp
test esi, esi
jle short loc_125D
mov r10d, esi
mov edx, 0
loc_11E8:
mov r8d, [rdi+rdx*4]
mov [rcx+rdx*4], r8d
add rdx, 1
cmp rdx, r10
jnz short loc_11E8
cmp esi, r9d
jge short loc_1256
loc_11FE:
mov rdx, rax
neg rdx
lea r8, [r11+rdx*4]
loc_1208:
mov edx, [rdi+rax*4]
mov [r8+rax*4], edx
add rax, 1
cmp r9d, eax
jg short loc_1208
mov eax, r9d
sub eax, esi
cmp esi, r9d
mov edx, 1
cmovge eax, edx
test esi, esi
jle short loc_1245
loc_122C:
cdqe
lea rdi, [r11+rax*4]
mov eax, 0
loc_1237:
mov edx, [rcx+rax*4]
mov [rdi+rax*4], edx
add rax, 1
cmp esi, eax
jg short loc_1237
loc_1245:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_1264
leave
retn
loc_1256:
mov eax, 0
jmp short loc_122C
loc_125D:
cmp esi, r9d
jl short loc_11FE
jmp short loc_1245
loc_1264:
call ___stack_chk_fail | unsigned long long func0(long long a1, int a2, int a3, long long a4)
{
long long v6; // rax
long long v7; // rdx
__int16 v8; // r8
signed long long v9; // rdx
void *v10; // rsp
long long v11; // rdx
long long v12; // r8
int v13; // eax
long long v14; // rdi
long long v15; // rax
_DWORD v18[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v19; // [rsp+10h] [rbp-8h]
v19 = __readfsqword(0x28u);
v6 = a3;
v7 = 4LL * a3 + 15;
v8 = v7 & 0xFFF0;
while ( v18 != (_DWORD *)((char *)v18 - (v7 & 0xFFFFFFFFFFFFF000LL)) )
;
v9 = v7 & 0xFF0;
v10 = alloca(v9);
if ( (v8 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v18[-2] + v9) = *(_QWORD *)((char *)&v18[-2] + v9);
if ( a3 <= 0 )
{
if ( a3 >= a2 )
return v19 - __readfsqword(0x28u);
}
else
{
v11 = 0LL;
do
{
v18[v11] = *(_DWORD *)(a1 + 4 * v11);
++v11;
}
while ( v11 != a3 );
if ( a3 >= a2 )
{
v13 = 0;
LABEL_14:
v14 = a4 + 4LL * v13;
v15 = 0LL;
do
{
*(_DWORD *)(v14 + 4 * v15) = v18[v15];
++v15;
}
while ( a3 > (int)v15 );
return v19 - __readfsqword(0x28u);
}
}
v12 = a4 - 4 * v6;
do
{
*(_DWORD *)(v12 + 4 * v6) = *(_DWORD *)(a1 + 4 * v6);
++v6;
}
while ( a2 > (int)v6 );
v13 = a2 - a3;
if ( a3 >= a2 )
v13 = 1;
if ( a3 > 0 )
goto LABEL_14;
return v19 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9D,ESI
MOV ESI,EDX
MOV R11,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
LEA RDX,[0xf + RAX*0x4]
MOV R8,RDX
AND R8,-0x10
AND RDX,-0x1000
MOV RCX,RSP
SUB RCX,RDX
LAB_001011ab:
CMP RSP,RCX
JZ 0x001011c2
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ab
LAB_001011c2:
MOV RDX,R8
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JZ 0x001011d9
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
LAB_001011d9:
MOV RCX,RSP
TEST ESI,ESI
JLE 0x0010125d
MOV R10D,ESI
MOV EDX,0x0
LAB_001011e8:
MOV R8D,dword ptr [RDI + RDX*0x4]
MOV dword ptr [RCX + RDX*0x4],R8D
ADD RDX,0x1
CMP RDX,R10
JNZ 0x001011e8
CMP ESI,R9D
JGE 0x00101256
LAB_001011fe:
MOV RDX,RAX
NEG RDX
LEA R8,[R11 + RDX*0x4]
LAB_00101208:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],EDX
ADD RAX,0x1
CMP R9D,EAX
JG 0x00101208
MOV EAX,R9D
SUB EAX,ESI
CMP ESI,R9D
MOV EDX,0x1
CMOVGE EAX,EDX
TEST ESI,ESI
JLE 0x00101245
LAB_0010122c:
CDQE
LEA RDI,[R11 + RAX*0x4]
MOV EAX,0x0
LAB_00101237:
MOV EDX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101237
LAB_00101245:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101264
LEAVE
RET
LAB_00101256:
MOV EAX,0x0
JMP 0x0010122c
LAB_0010125d:
CMP ESI,R9D
JL 0x001011fe
JMP 0x00101245
LAB_00101264:
CALL 0x00101060 | void func0(long param_1,int param_2,uint param_3,long param_4)
{
long lVar1;
long lVar2;
int iVar3;
long lVar4;
ulong uVar5;
int1 *puVar6;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = (long)(int)param_3;
uVar5 = lVar4 * 4 + 0xf;
for (puVar6 = auStack_18; puVar6 != auStack_18 + -(uVar5 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar2 = -uVar5;
if (uVar5 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if ((int)param_3 < 1) {
if (param_2 <= (int)param_3) goto LAB_00101245;
LAB_001011fe:
lVar1 = lVar4 * -4;
do {
*(int4 *)(param_4 + lVar1 + lVar4 * 4) = *(int4 *)(param_1 + lVar4 * 4);
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_2);
iVar3 = param_2 - param_3;
if (param_2 <= (int)param_3) {
iVar3 = 1;
}
if ((int)param_3 < 1) goto LAB_00101245;
}
else {
uVar5 = 0;
do {
*(int4 *)(puVar6 + uVar5 * 4 + lVar2) = *(int4 *)(param_1 + uVar5 * 4);
uVar5 = uVar5 + 1;
} while (uVar5 != param_3);
if ((int)param_3 < param_2) goto LAB_001011fe;
iVar3 = 0;
}
lVar4 = 0;
do {
*(int4 *)(param_4 + (long)iVar3 * 4 + lVar4 * 4) =
*(int4 *)(puVar6 + lVar4 * 4 + lVar2);
lVar4 = lVar4 + 1;
} while ((int)lVar4 < (int)param_3);
LAB_00101245:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar2 + -8) = main;
__stack_chk_fail();
}
return;
} |
6,238 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2] == 4 && result[3] == 1);
func0((int[]){0, 1, 2, 3, 4, 5, 6, 7}, 8, 3, result);
assert(result[0] == 3 && result[1] == 4 && result[2] == 5 && result[3] == 6 && result[4] == 7 && result[5] == 0 && result[6] == 1 && result[7] == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edx,%rax
mov %rsp,%r11
lea 0xf(,%rax,4),%r8
mov %r8,%r9
and $0xfffffffffffff000,%r8
sub %r8,%r11
and $0xfffffffffffffff0,%r9
mov %r11,%r8
cmp %r8,%rsp
je 13d7 <func0+0x57>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %r8,%rsp
jne 13c2 <func0+0x42>
and $0xfff,%r9d
sub %r9,%rsp
test %r9,%r9
jne 1480 <func0+0x100>
mov %rsp,%r9
test %edx,%edx
jle 148b <func0+0x10b>
lea -0x1(%rdx),%r11d
xor %r8d,%r8d
nopl 0x0(%rax)
mov (%rdi,%r8,4),%r10d
mov %r10d,(%r9,%r8,4)
mov %r8,%r10
add $0x1,%r8
cmp %r10,%r11
jne 1400 <func0+0x80>
cmp %esi,%edx
jge 1498 <func0+0x118>
mov %rax,%r8
neg %r8
lea (%rcx,%r8,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%r8d
mov %r8d,(%r10,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 1430 <func0+0xb0>
mov %esi,%eax
sub %edx,%eax
cmp %esi,%edx
mov $0x1,%esi
cmovge %esi,%eax
test %edx,%edx
jle 146f <func0+0xef>
cltq
lea (%rcx,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%r9,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
add $0x1,%rax
cmp %eax,%edx
jg 1460 <func0+0xe0>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 149c <func0+0x11c>
leaveq
retq
orq $0x0,-0x8(%rsp,%r9,1)
jmpq 13ea <func0+0x6a>
cmp %esi,%edx
jl 141c <func0+0x9c>
jmp 146f <func0+0xef>
nopl 0x0(%rax)
xor %eax,%eax
jmp 1452 <func0+0xd2>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd rdx, edx
mov rbp, rsp
push r15
mov r15, rcx
lea rcx, ds:0[rdx*4]
push r14
mov r14, rdx
push r13
mov r13, rdi
push r12
mov r12d, esi
push rbx
mov rbx, rdx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rcx+0Fh]
mov rdi, rsp
mov rsi, rax
and rax, 0FFFFFFFFFFFFF000h
sub rdi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdi
jz short loc_140F
loc_13FA:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rdi
jnz short loc_13FA
loc_140F:
and esi, 0FFFh
sub rsp, rsi
test rsi, rsi
jnz loc_14D0
loc_1421:
mov r8, rsp
test r14d, r14d
jle loc_14DB
shl rdx, 2
mov rdi, r8
mov rsi, r13
mov [rbp+var_48], rcx
call _memcpy
cmp r14d, r12d
mov rcx, [rbp+var_48]
mov r8, rax
jge loc_14F0
loc_1450:
mov rdx, r15
sub rdx, rcx
nop word ptr [rax+rax+00000000h]
loc_1460:
mov eax, [r13+rbx*4+0]
mov [rdx+rbx*4], eax
add rbx, 1
cmp r12d, ebx
jg short loc_1460
mov eax, r12d
mov edx, 1
sub eax, r14d
cmp r14d, r12d
cmovge eax, edx
test r14d, r14d
jle short loc_14AD
loc_1487:
cdqe
test r14d, r14d
mov rsi, r8
lea rdi, [r15+rax*4]
lea eax, [r14-1]
lea rdx, ds:4[rax*4]
mov eax, 4
cmovle rdx, rax
call _memcpy
loc_14AD:
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz short loc_14F4
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_14D0:
or [rsp+rsi+1050h+var_1058], 0
jmp loc_1421
loc_14DB:
cmp r14d, r12d
jl loc_1450
jmp short loc_14AD
loc_14F0:
xor eax, eax
jmp short loc_1487
loc_14F4:
call ___stack_chk_fail | unsigned long long func0(long long a1, int a2, int a3, long long a4)
{
long long v5; // rcx
long long v9; // rbx
long long *v10; // rdi
signed long long v11; // rsi
void *v12; // rsp
_BYTE *v13; // r8
long long v14; // rax
int v15; // eax
_BYTE v18[4088]; // [rsp+8h] [rbp-1050h] BYREF
long long v19; // [rsp+1008h] [rbp-50h] BYREF
long long v20; // [rsp+1010h] [rbp-48h]
unsigned long long v21; // [rsp+1020h] [rbp-38h]
v5 = 4LL * a3;
v9 = a3;
v21 = __readfsqword(0x28u);
v10 = (long long *)((char *)&v19 - ((v5 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( &v19 != v10 )
{
while ( v18 != (_BYTE *)v10 )
;
}
v11 = ((_WORD)v5 + 15) & 0xFF0;
v12 = alloca(v11);
if ( (((_WORD)v5 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v18[v11 - 8] = *(_QWORD *)&v18[v11 - 8];
v13 = v18;
if ( a3 <= 0 )
{
if ( a3 >= a2 )
return v21 - __readfsqword(0x28u);
}
else
{
v20 = 4LL * a3;
v14 = memcpy(v18, a1, v20);
v5 = v20;
v13 = (_BYTE *)v14;
if ( a3 >= a2 )
{
v15 = 0;
LABEL_11:
memcpy(a4 + 4LL * v15, v13, 4LL * (unsigned int)(a3 - 1) + 4);
return v21 - __readfsqword(0x28u);
}
}
do
{
*(_DWORD *)(a4 - v5 + 4 * v9) = *(_DWORD *)(a1 + 4 * v9);
++v9;
}
while ( a2 > (int)v9 );
v15 = a2 - a3;
if ( a3 >= a2 )
v15 = 1;
if ( a3 > 0 )
goto LABEL_11;
return v21 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOVSXD RDX,EDX
MOV RBP,RSP
PUSH R15
MOV R15,RCX
LEA RCX,[RDX*0x4]
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV RBX,RDX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RCX + 0xf]
MOV RDI,RSP
MOV RSI,RAX
AND RAX,-0x1000
SUB RDI,RAX
AND RSI,-0x10
CMP RSP,RDI
JZ 0x0010140f
LAB_001013fa:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDI
JNZ 0x001013fa
LAB_0010140f:
AND ESI,0xfff
SUB RSP,RSI
TEST RSI,RSI
JNZ 0x001014d0
LAB_00101421:
MOV R8,RSP
TEST R14D,R14D
JLE 0x001014db
SHL RDX,0x2
MOV RDI,R8
MOV RSI,R13
MOV qword ptr [RBP + -0x48],RCX
CALL 0x00101090
CMP R14D,R12D
MOV RCX,qword ptr [RBP + -0x48]
MOV R8,RAX
JGE 0x001014f0
LAB_00101450:
MOV RDX,R15
SUB RDX,RCX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101460:
MOV EAX,dword ptr [R13 + RBX*0x4]
MOV dword ptr [RDX + RBX*0x4],EAX
ADD RBX,0x1
CMP R12D,EBX
JG 0x00101460
MOV EAX,R12D
MOV EDX,0x1
SUB EAX,R14D
CMP R14D,R12D
CMOVGE EAX,EDX
TEST R14D,R14D
JLE 0x001014ad
LAB_00101487:
CDQE
TEST R14D,R14D
MOV RSI,R8
LEA RDI,[R15 + RAX*0x4]
LEA EAX,[R14 + -0x1]
LEA RDX,[0x4 + RAX*0x4]
MOV EAX,0x4
CMOVLE RDX,RAX
CALL 0x00101090
LAB_001014ad:
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014f4
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001014d0:
OR qword ptr [RSP + RSI*0x1 + -0x8],0x0
JMP 0x00101421
LAB_001014db:
CMP R14D,R12D
JL 0x00101450
JMP 0x001014ad
LAB_001014f0:
XOR EAX,EAX
JMP 0x00101487
LAB_001014f4:
CALL 0x00101070 | void func0(void *param_1,int param_2,int param_3,long param_4)
{
long lVar1;
int iVar2;
int1 *puVar3;
long lVar4;
long lVar5;
size_t __n;
int1 *puVar6;
ulong uVar8;
long in_FS_OFFSET;
int1 auStack_58 [8];
long local_50;
long local_40;
int1 *puVar7;
lVar5 = (long)param_3;
lVar4 = lVar5 * 4;
puVar6 = auStack_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar7 = auStack_58;
puVar3 = auStack_58;
while (puVar7 != auStack_58 + -(lVar4 + 0xfU & 0xfffffffffffff000)) {
puVar6 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar7 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar8 = (ulong)((uint)(lVar4 + 0xfU) & 0xff0);
lVar1 = -uVar8;
puVar3 = puVar6 + lVar1;
if (uVar8 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (param_3 < 1) {
if (param_2 <= param_3) goto LAB_001014ad;
LAB_00101450:
do {
*(int4 *)((param_4 - lVar4) + lVar5 * 4) = *(int4 *)((long)param_1 + lVar5 * 4);
lVar5 = lVar5 + 1;
} while ((int)lVar5 < param_2);
iVar2 = param_2 - param_3;
if (param_2 <= param_3) {
iVar2 = 1;
}
if (param_3 < 1) goto LAB_001014ad;
}
else {
*(int8 *)(puVar6 + lVar1 + -8) = 0x101440;
local_50 = lVar4;
puVar3 = (int1 *)memcpy(puVar6 + lVar1,param_1,lVar5 << 2);
lVar4 = local_50;
if (param_3 < param_2) goto LAB_00101450;
iVar2 = 0;
}
__n = (ulong)(param_3 - 1) * 4 + 4;
if (param_3 < 1) {
__n = 4;
}
*(int8 *)(puVar6 + lVar1 + -8) = 0x1014ad;
memcpy((void *)(param_4 + (long)iVar2 * 4),puVar3,__n);
LAB_001014ad:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x1014f9;
__stack_chk_fail();
} |
6,239 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2] == 4 && result[3] == 1);
func0((int[]){0, 1, 2, 3, 4, 5, 6, 7}, 8, 3, result);
assert(result[0] == 3 && result[1] == 4 && result[2] == 5 && result[3] == 6 && result[4] == 7 && result[5] == 0 && result[6] == 1 && result[7] == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %rdi,%r15
push %r14
movslq %edx,%r14
push %r13
lea 0x0(,%r14,4),%r9
mov %esi,%r13d
push %r12
mov %rcx,%r12
push %rbx
mov %r14,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0xf(%r9),%rax
mov %rsp,%rdi
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 13cf <func0+0x6f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 13ba <func0+0x5a>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1530 <func0+0x1d0>
mov %rsp,%r8
test %ebx,%ebx
jle 1566 <func0+0x206>
lea -0x1(%rbx),%eax
mov %r8,%rdi
mov %r15,%rsi
mov %r9,-0x50(%rbp)
lea 0x4(,%rax,4),%rdx
mov %eax,-0x44(%rbp)
callq 1090 <memcpy@plt>
cmp %r13d,%ebx
mov -0x44(%rbp),%ecx
mov -0x50(%rbp),%r9
mov %rax,%r8
jge 1578 <func0+0x218>
lea 0x10(%r15,%r9,1),%rax
lea (%r15,%r9,1),%rcx
cmp %rax,%r12
lea 0x10(%r12),%rax
setae %dl
cmp %rax,%rcx
setae %al
or %al,%dl
je 1540 <func0+0x1e0>
lea -0x1(%r13),%eax
sub %ebx,%eax
cmp $0x3,%eax
jbe 1540 <func0+0x1e0>
mov %r13d,%esi
mov $0x1,%eax
sub %ebx,%esi
cmp %r13d,%ebx
cmovge %eax,%esi
xor %eax,%eax
mov %esi,%edx
shr $0x2,%edx
shl $0x4,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rcx,%rax,1),%xmm0
movups %xmm0,(%r12,%rax,1)
add $0x10,%rax
cmp %rdx,%rax
jne 1470 <func0+0x110>
mov %esi,%edx
and $0xfffffffc,%edx
lea (%rbx,%rdx,1),%eax
cmp %edx,%esi
je 14d1 <func0+0x171>
movslq %eax,%rsi
lea 0x1(%rdx),%ecx
movslq %edx,%rdx
mov (%r15,%rsi,4),%esi
mov %esi,(%r12,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%r13d
jle 14d1 <func0+0x171>
movslq %edx,%rdx
movslq %ecx,%rcx
add $0x2,%eax
mov (%r15,%rdx,4),%edx
lea 0x0(,%rcx,4),%rsi
mov %edx,(%r12,%rcx,4)
cmp %eax,%r13d
jle 14d1 <func0+0x171>
cltq
mov (%r15,%rax,4),%eax
mov %eax,0x4(%r12,%rsi,1)
mov %r13d,%eax
mov $0x1,%edx
sub %ebx,%eax
cmp %r13d,%ebx
cmovge %edx,%eax
test %ebx,%ebx
jle 1509 <func0+0x1a9>
lea -0x1(%rbx),%ecx
cltq
lea 0x4(,%rcx,4),%rdx
test %ebx,%ebx
mov %r8,%rsi
lea (%r12,%rax,4),%rdi
mov $0x4,%eax
cmovle %rax,%rdx
callq 1090 <memcpy@plt>
mov -0x38(%rbp),%rax
xor %fs:0x28,%rax
jne 157f <func0+0x21f>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 13e1 <func0+0x81>
nopl 0x0(%rax,%rax,1)
mov %r14,%rax
neg %rax
lea (%r12,%rax,4),%rdx
nopw 0x0(%rax,%rax,1)
mov (%r15,%r14,4),%eax
mov %eax,(%rdx,%r14,4)
add $0x1,%r14
cmp %r14d,%r13d
jg 1550 <func0+0x1f0>
jmpq 14d1 <func0+0x171>
cmp %r13d,%ebx
jl 141c <func0+0xbc>
jmp 1509 <func0+0x1a9>
nopl 0x0(%rax)
xor %eax,%eax
jmpq 14e8 <func0+0x188>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15, rcx
push r14
push r13
mov r13, rdi
push r12
mov r12d, esi
push rbx
movsxd rbx, edx
lea r8, ds:0[rbx*4]
mov r14, rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [r8+0Fh]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_13CC
loc_13B7:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rcx
jnz short loc_13B7
loc_13CC:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1540
loc_13DE:
mov rcx, rsp
test r14d, r14d
jle loc_154B
mov r9d, r14d
mov rdi, rcx; dest
mov rsi, r13; src
mov [rbp+var_50], r8
lea rdx, ds:0[r9*4]; n
mov [rbp+var_48], r9
call _memcpy
xor edx, edx
cmp r14d, r12d
mov r9, [rbp+var_48]
mov r8, [rbp+var_50]
mov rcx, rax
jge short loc_1474
loc_141A:
cmp r14d, r12d
mov edx, r12d
setl dil
sub edx, r14d
lea eax, [rdx-1]
cmp eax, 2
jbe short loc_1445
test dil, dil
jz short loc_1445
lea rsi, [r13+r8+4]
mov rax, r15
sub rax, rsi
cmp rax, 8
ja short loc_14B0
loc_1445:
mov rsi, r15
sub rsi, r8
nop dword ptr [rax+rax+00h]
loc_1450:
mov eax, [r13+rbx*4+0]
mov [rsi+rbx*4], eax
add rbx, 1
cmp r12d, ebx
jg short loc_1450
loc_1461:
test dil, dil
mov eax, 1
cmovz edx, eax
test r14d, r14d
jle short loc_148B
mov r9d, r14d
loc_1474:
movsxd rdx, edx
mov rsi, rcx; src
lea rdi, [r15+rdx*4]; dest
lea rdx, ds:0[r9*4]; n
call _memcpy
loc_148B:
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_1559
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_14B0:
mov esi, edx
add r8, r13
xor eax, eax
shr esi, 2
shl rsi, 4
xchg ax, ax
loc_14C0:
movdqu xmm0, xmmword ptr [r8+rax]
movups xmmword ptr [r15+rax], xmm0
add rax, 10h
cmp rax, rsi
jnz short loc_14C0
mov eax, edx
and eax, 0FFFFFFFCh
lea esi, [r14+rax]
test dl, 3
jz loc_1461
movsxd r9, esi
cdqe
mov r9d, [r13+r9*4+0]
lea r8, ds:0[rax*4]
mov [r15+rax*4], r9d
lea eax, [rsi+1]
cmp r12d, eax
jle loc_1461
cdqe
add esi, 2
lea r9, ds:0[rax*4]
mov eax, [r13+rax*4+0]
mov [r15+r8+4], eax
cmp r12d, esi
jle loc_1461
mov eax, [r13+r9+4]
mov [r15+r8+8], eax
jmp loc_1461
loc_1540:
or [rsp+rdx+1050h+var_1058], 0
jmp loc_13DE
loc_154B:
cmp r14d, r12d
jl loc_141A
jmp loc_148B
loc_1559:
call ___stack_chk_fail | unsigned long long func0(char *src, int a2, int a3, long long a4)
{
long long v6; // rbx
long long v7; // r8
long long *v9; // rcx
signed long long v10; // rdx
void *v11; // rsp
_BYTE *v12; // rcx
_BYTE *v13; // rax
int v14; // edx
long long v15; // r9
char *v17; // r8
long long v18; // rax
unsigned int v19; // esi
long long v20; // r8
long long v21; // r9
_BYTE v23[4088]; // [rsp+8h] [rbp-1050h] BYREF
long long v24; // [rsp+1008h] [rbp-50h] BYREF
long long v25; // [rsp+1010h] [rbp-48h]
unsigned long long v26; // [rsp+1020h] [rbp-38h]
v6 = a3;
v7 = 4LL * a3;
v26 = __readfsqword(0x28u);
v9 = (long long *)((char *)&v24 - ((v7 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( &v24 != v9 )
{
while ( v23 != (_BYTE *)v9 )
;
}
v10 = ((_WORD)v7 + 15) & 0xFF0;
v11 = alloca(v10);
if ( (((_WORD)v7 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v23[v10 - 8] = *(_QWORD *)&v23[v10 - 8];
v12 = v23;
if ( a3 <= 0 )
{
if ( a3 >= a2 )
return v26 - __readfsqword(0x28u);
}
else
{
v24 = v7;
v25 = (unsigned int)a3;
v13 = memcpy(v23, src, 4LL * (unsigned int)a3);
v14 = 0;
v15 = v25;
v7 = v24;
v12 = v13;
if ( a3 >= a2 )
{
LABEL_15:
memcpy((void *)(a4 + 4LL * v14), v12, 4 * v15);
return v26 - __readfsqword(0x28u);
}
}
v14 = a2 - a3;
if ( (unsigned int)(a2 - a3 - 1) > 2 && a3 < a2 && (unsigned long long)(a4 - (_QWORD)&src[v7 + 4]) > 8 )
{
v17 = &src[v7];
v18 = 0LL;
do
{
*(__m128i *)(a4 + v18) = _mm_loadu_si128((const __m128i *)&v17[v18]);
v18 += 16LL;
}
while ( v18 != 16LL * ((unsigned int)v14 >> 2) );
v19 = a3 + (v14 & 0xFFFFFFFC);
if ( (v14 & 3) != 0 )
{
v20 = 4LL * (int)(v14 & 0xFFFFFFFC);
*(_DWORD *)(a4 + v20) = *(_DWORD *)&src[4 * v19];
if ( a2 > (int)(v19 + 1) )
{
v21 = 4LL * (int)(v19 + 1);
*(_DWORD *)(a4 + v20 + 4) = *(_DWORD *)&src[v21];
if ( a2 > (int)(v19 + 2) )
*(_DWORD *)(a4 + v20 + 8) = *(_DWORD *)&src[v21 + 4];
}
}
}
else
{
do
{
*(_DWORD *)(a4 - v7 + 4 * v6) = *(_DWORD *)&src[4 * v6];
++v6;
}
while ( a2 > (int)v6 );
}
if ( a3 >= a2 )
v14 = 1;
if ( a3 > 0 )
{
v15 = (unsigned int)a3;
goto LABEL_15;
}
return v26 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15,RCX
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12D,ESI
PUSH RBX
MOVSXD RBX,EDX
LEA R8,[RBX*0x4]
MOV R14,RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[R8 + 0xf]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001013cc
LAB_001013b7:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001013b7
LAB_001013cc:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101540
LAB_001013de:
MOV RCX,RSP
TEST R14D,R14D
JLE 0x0010154b
MOV R9D,R14D
MOV RDI,RCX
MOV RSI,R13
MOV qword ptr [RBP + -0x50],R8
LEA RDX,[R9*0x4]
MOV qword ptr [RBP + -0x48],R9
CALL 0x00101090
XOR EDX,EDX
CMP R14D,R12D
MOV R9,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x50]
MOV RCX,RAX
JGE 0x00101474
LAB_0010141a:
CMP R14D,R12D
MOV EDX,R12D
SETL DIL
SUB EDX,R14D
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101445
TEST DIL,DIL
JZ 0x00101445
LEA RSI,[R13 + R8*0x1 + 0x4]
MOV RAX,R15
SUB RAX,RSI
CMP RAX,0x8
JA 0x001014b0
LAB_00101445:
MOV RSI,R15
SUB RSI,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_00101450:
MOV EAX,dword ptr [R13 + RBX*0x4]
MOV dword ptr [RSI + RBX*0x4],EAX
ADD RBX,0x1
CMP R12D,EBX
JG 0x00101450
LAB_00101461:
TEST DIL,DIL
MOV EAX,0x1
CMOVZ EDX,EAX
TEST R14D,R14D
JLE 0x0010148b
MOV R9D,R14D
LAB_00101474:
MOVSXD RDX,EDX
MOV RSI,RCX
LEA RDI,[R15 + RDX*0x4]
LEA RDX,[R9*0x4]
CALL 0x00101090
LAB_0010148b:
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101559
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001014b0:
MOV ESI,EDX
ADD R8,R13
XOR EAX,EAX
SHR ESI,0x2
SHL RSI,0x4
NOP
LAB_001014c0:
MOVDQU XMM0,xmmword ptr [R8 + RAX*0x1]
MOVUPS xmmword ptr [R15 + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RSI
JNZ 0x001014c0
MOV EAX,EDX
AND EAX,0xfffffffc
LEA ESI,[R14 + RAX*0x1]
TEST DL,0x3
JZ 0x00101461
MOVSXD R9,ESI
CDQE
MOV R9D,dword ptr [R13 + R9*0x4]
LEA R8,[RAX*0x4]
MOV dword ptr [R15 + RAX*0x4],R9D
LEA EAX,[RSI + 0x1]
CMP R12D,EAX
JLE 0x00101461
CDQE
ADD ESI,0x2
LEA R9,[RAX*0x4]
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV dword ptr [R15 + R8*0x1 + 0x4],EAX
CMP R12D,ESI
JLE 0x00101461
MOV EAX,dword ptr [R13 + R9*0x1 + 0x4]
MOV dword ptr [R15 + R8*0x1 + 0x8],EAX
JMP 0x00101461
LAB_00101540:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001013de
LAB_0010154b:
CMP R14D,R12D
JL 0x0010141a
JMP 0x0010148b
LAB_00101559:
CALL 0x00101070 | void func0(void *param_1,int param_2,uint param_3,long param_4)
{
int iVar1;
int8 *puVar2;
long lVar3;
int8 uVar4;
long *plVar5;
uint uVar6;
int *__src;
uint uVar7;
ulong uVar8;
long lVar9;
long *plVar10;
int iVar12;
long lVar13;
long in_FS_OFFSET;
long local_58;
ulong local_50;
long local_40;
long *plVar11;
lVar9 = (long)(int)param_3;
lVar13 = lVar9 * 4;
plVar10 = &local_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
plVar11 = &local_58;
plVar5 = &local_58;
while (plVar11 != (long *)((long)&local_58 - (lVar13 + 0xfU & 0xfffffffffffff000))) {
plVar10 = (long *)((long)plVar5 + -0x1000);
*(int8 *)((long)plVar5 + -8) = *(int8 *)((long)plVar5 + -8);
plVar11 = (long *)((long)plVar5 + -0x1000);
plVar5 = (long *)((long)plVar5 + -0x1000);
}
uVar8 = (ulong)((uint)(lVar13 + 0xfU) & 0xff0);
lVar3 = -uVar8;
__src = (int *)((long)plVar10 + lVar3);
if (uVar8 != 0) {
*(int8 *)((long)plVar10 + -8) = *(int8 *)((long)plVar10 + -8);
}
if ((int)param_3 < 1) {
if (param_2 <= (int)param_3) goto LAB_0010148b;
LAB_0010141a:
uVar7 = param_2 - param_3;
if (((uVar7 - 1 < 3) || (param_2 <= (int)param_3)) ||
((ulong)(param_4 - ((long)param_1 + lVar13 + 4)) < 9)) {
do {
*(int4 *)((param_4 - lVar13) + lVar9 * 4) = *(int4 *)((long)param_1 + lVar9 * 4)
;
lVar9 = lVar9 + 1;
} while ((int)lVar9 < param_2);
}
else {
lVar9 = 0;
do {
puVar2 = (int8 *)((long)param_1 + lVar9 + lVar13);
uVar4 = puVar2[1];
*(int8 *)(param_4 + lVar9) = *puVar2;
((int8 *)(param_4 + lVar9))[1] = uVar4;
lVar9 = lVar9 + 0x10;
} while (lVar9 != (ulong)(uVar7 >> 2) << 4);
uVar6 = uVar7 & 0xfffffffc;
iVar12 = param_3 + uVar6;
if ((uVar7 & 3) != 0) {
lVar13 = (long)(int)uVar6 * 4;
*(int4 *)(param_4 + (long)(int)uVar6 * 4) =
*(int4 *)((long)param_1 + (long)iVar12 * 4);
iVar1 = iVar12 + 1;
if (iVar1 < param_2) {
*(int4 *)(param_4 + 4 + lVar13) = *(int4 *)((long)param_1 + (long)iVar1 * 4);
if (iVar12 + 2 < param_2) {
*(int4 *)(param_4 + 8 + lVar13) =
*(int4 *)((long)param_1 + (long)iVar1 * 4 + 4);
}
}
}
}
if (param_2 <= (int)param_3) {
uVar7 = 1;
}
if ((int)param_3 < 1) goto LAB_0010148b;
uVar8 = (ulong)param_3;
}
else {
local_50 = (ulong)param_3;
*(int8 *)((long)plVar10 + lVar3 + -8) = 0x101408;
local_58 = lVar13;
__src = (int *)memcpy((int *)((long)plVar10 + lVar3),param_1,local_50 * 4);
uVar7 = 0;
lVar13 = local_58;
uVar8 = local_50;
if ((int)param_3 < param_2) goto LAB_0010141a;
}
*(int8 *)((long)plVar10 + lVar3 + -8) = 0x10148b;
memcpy((void *)(param_4 + (long)(int)uVar7 * 4),__src,uVar8 * 4);
LAB_0010148b:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)plVar10 + lVar3 + -8) = 0x10155e;
__stack_chk_fail();
} |
6,240 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (int[]){2, 4, 5, 6, 2, 3, 4, 4, 7}, sizeof(result2)) == 0);
int result3[3];
int list3[3] = {58, 44, 56};
func0(list3, 3, result3);
assert(memcmp(result3, (int[]){58, 44, 56}, sizeof(result3)) == 0);
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)
movl $0x0,-0x4(%rbp)
jmp 11f6 <func0+0x4d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11c5 <func0+0x1c>
mov -0x28(%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_4], 0
jmp short loc_11F6
loc_11C5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4], 1
loc_11F6:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11C5
mov rax, [rbp+var_28]
pop rbp
retn | long long func0(long long a1, int a2, long long a3)
{
int i; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2; ++i )
*(_DWORD *)(4LL * i + a3) = *(_DWORD *)(4LL * i + a1);
return a3;
} | 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 + -0x4],0x0
JMP 0x001011f6
LAB_001011c5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011f6:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011c5
MOV RAX,qword ptr [RBP + -0x28]
POP RBP
RET | long func0(long param_1,int param_2,long param_3)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int4 *)(param_3 + (long)local_c * 4) = *(int4 *)(param_1 + (long)local_c * 4);
}
return param_3;
} |
6,241 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (int[]){2, 4, 5, 6, 2, 3, 4, 4, 7}, sizeof(result2)) == 0);
int result3[3];
int list3[3] = {58, 44, 56};
func0(list3, 3, result3);
assert(memcmp(result3, (int[]){58, 44, 56}, sizeof(result3)) == 0);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 11ce <func0+0x25>
lea -0x1(%rsi),%edx
mov $0x0,%ecx
mov (%rdi,%rcx,4),%esi
mov %esi,(%rax,%rcx,4)
mov %rcx,%rsi
add $0x1,%rcx
cmp %rdx,%rsi
jne 11bc <func0+0x13>
retq
| func0:
endbr64
mov rax, rdx
test esi, esi
jle short locret_11CC
mov esi, esi
mov ecx, 0
loc_11BB:
mov r8d, [rdi+rcx*4]
mov [rax+rcx*4], r8d
add rcx, 1
cmp rcx, rsi
jnz short loc_11BB
locret_11CC:
retn | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
long long i; // rcx
result = a3;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RDX
TEST ESI,ESI
JLE 0x001011cc
MOV ESI,ESI
MOV ECX,0x0
LAB_001011bb:
MOV R8D,dword ptr [RDI + RCX*0x4]
MOV dword ptr [RAX + RCX*0x4],R8D
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001011bb
LAB_001011cc:
RET | void func0(long param_1,uint param_2,long param_3)
{
ulong uVar1;
if (0 < (int)param_2) {
uVar1 = 0;
do {
*(int4 *)(param_3 + uVar1 * 4) = *(int4 *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return;
} |
6,242 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (int[]){2, 4, 5, 6, 2, 3, 4, 4, 7}, sizeof(result2)) == 0);
int result3[3];
int list3[3] = {58, 44, 56};
func0(list3, 3, result3);
assert(memcmp(result3, (int[]){58, 44, 56}, sizeof(result3)) == 0);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 12c2 <func0+0x22>
lea -0x1(%rsi),%edx
xor %ecx,%ecx
mov (%rdi,%rcx,4),%esi
mov %esi,(%rax,%rcx,4)
mov %rcx,%rsi
add $0x1,%rcx
cmp %rdx,%rsi
jne 12b0 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov rax, rdx
test esi, esi
jle short locret_1401
movsxd rsi, esi
xor ecx, ecx
loc_13F0:
mov r8d, [rdi+rcx*4]
mov [rax+rcx*4], r8d
add rcx, 1
cmp rcx, rsi
jnz short loc_13F0
locret_1401:
retn | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
long long i; // rcx
result = a3;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RDX
TEST ESI,ESI
JLE 0x00101401
MOVSXD RSI,ESI
XOR ECX,ECX
LAB_001013f0:
MOV R8D,dword ptr [RDI + RCX*0x4]
MOV dword ptr [RAX + RCX*0x4],R8D
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001013f0
LAB_00101401:
RET | void func0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
*(int4 *)(param_3 + lVar1 * 4) = *(int4 *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return;
} |
6,243 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (int[]){2, 4, 5, 6, 2, 3, 4, 4, 7}, sizeof(result2)) == 0);
int result3[3];
int list3[3] = {58, 44, 56};
func0(list3, 3, result3);
assert(memcmp(result3, (int[]){58, 44, 56}, sizeof(result3)) == 0);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 13ea <func0+0x9a>
lea 0xf(%rax),%rcx
lea -0x1(%rsi),%edx
sub %rdi,%rcx
cmp $0x1e,%rcx
jbe 13d0 <func0+0x80>
cmp $0x3,%edx
jbe 13d0 <func0+0x80>
mov %esi,%edx
xor %ecx,%ecx
shr $0x2,%edx
shl $0x4,%rdx
movdqu (%rdi,%rcx,1),%xmm0
movups %xmm0,(%rax,%rcx,1)
add $0x10,%rcx
cmp %rdx,%rcx
jne 1380 <func0+0x30>
mov %esi,%edx
and $0xfffffffc,%edx
test $0x3,%sil
je 13ea <func0+0x9a>
mov %edx,%ecx
mov (%rdi,%rcx,4),%r8d
mov %r8d,(%rax,%rcx,4)
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 13ea <func0+0x9a>
movslq %ecx,%rcx
add $0x2,%edx
mov (%rdi,%rcx,4),%r8d
mov %r8d,(%rax,%rcx,4)
cmp %edx,%esi
jle 13ea <func0+0x9a>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
retq
nopw 0x0(%rax,%rax,1)
mov %edx,%ecx
xor %edx,%edx
nopl 0x0(%rax)
mov (%rdi,%rdx,4),%esi
mov %esi,(%rax,%rdx,4)
mov %rdx,%rsi
add $0x1,%rdx
cmp %rcx,%rsi
jne 13d8 <func0+0x88>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rax, esi
mov rsi, rdx
test eax, eax
jle short loc_135F
lea edx, [rax-1]
cmp edx, 2
jbe short loc_1346
lea rcx, [rdi+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
ja short loc_1368
loc_1346:
lea rdx, ds:0[rax*4]
xor eax, eax
loc_1350:
mov ecx, [rdi+rax]
mov [rsi+rax], ecx
add rax, 4
cmp rdx, rax
jnz short loc_1350
loc_135F:
mov rax, rsi
retn
loc_1368:
mov ecx, eax
xor edx, edx
shr ecx, 2
shl rcx, 4
nop dword ptr [rax+rax+00h]
loc_1378:
movdqu xmm0, xmmword ptr [rdi+rdx]
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
cmp rdx, rcx
jnz short loc_1378
mov edx, eax
and edx, 0FFFFFFFCh
test al, 3
jz short loc_135F
mov r8d, edx
mov r9d, [rdi+r8*4]
lea rcx, ds:0[r8*4]
mov [rsi+r8*4], r9d
lea r8d, [rdx+1]
cmp eax, r8d
jle short loc_135F
mov r8d, [rdi+rcx+4]
add edx, 2
mov [rsi+rcx+4], r8d
cmp eax, edx
jle short loc_135F
mov eax, [rdi+rcx+8]
mov [rsi+rcx+8], eax
mov rax, rsi
retn | long long func0(long long a1, int a2, long long a3)
{
long long v3; // rax
long long v5; // rdx
long long v6; // rax
long long v8; // rdx
unsigned int v9; // edx
long long v10; // rcx
v3 = a2;
if ( (int)v3 <= 0 )
return a3;
if ( (unsigned int)(v3 - 1) <= 2 || (unsigned long long)(a3 - (a1 + 4)) <= 8 )
{
v5 = 4 * v3;
v6 = 0LL;
do
{
*(_DWORD *)(a3 + v6) = *(_DWORD *)(a1 + v6);
v6 += 4LL;
}
while ( v5 != v6 );
return a3;
}
v8 = 0LL;
do
{
*(__m128i *)(a3 + v8) = _mm_loadu_si128((const __m128i *)(a1 + v8));
v8 += 16LL;
}
while ( v8 != 16LL * ((unsigned int)v3 >> 2) );
v9 = v3 & 0x7FFFFFFC;
if ( (v3 & 3) == 0 )
return a3;
v10 = 4LL * v9;
*(_DWORD *)(a3 + v10) = *(_DWORD *)(a1 + v10);
if ( (int)v3 <= (int)(v9 + 1) )
return a3;
*(_DWORD *)(a3 + v10 + 4) = *(_DWORD *)(a1 + v10 + 4);
if ( (int)v3 <= (int)(v9 + 2) )
return a3;
*(_DWORD *)(a3 + v10 + 8) = *(_DWORD *)(a1 + v10 + 8);
return a3;
} | func0:
ENDBR64
MOVSXD RAX,ESI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x0010135f
LEA EDX,[RAX + -0x1]
CMP EDX,0x2
JBE 0x00101346
LEA RCX,[RDI + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JA 0x00101368
LAB_00101346:
LEA RDX,[RAX*0x4]
XOR EAX,EAX
LAB_00101350:
MOV ECX,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RSI + RAX*0x1],ECX
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x00101350
LAB_0010135f:
MOV RAX,RSI
RET
LAB_00101368:
MOV ECX,EAX
XOR EDX,EDX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101378:
MOVDQU XMM0,xmmword ptr [RDI + RDX*0x1]
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
CMP RDX,RCX
JNZ 0x00101378
MOV EDX,EAX
AND EDX,0xfffffffc
TEST AL,0x3
JZ 0x0010135f
MOV R8D,EDX
MOV R9D,dword ptr [RDI + R8*0x4]
LEA RCX,[R8*0x4]
MOV dword ptr [RSI + R8*0x4],R9D
LEA R8D,[RDX + 0x1]
CMP EAX,R8D
JLE 0x0010135f
MOV R8D,dword ptr [RDI + RCX*0x1 + 0x4]
ADD EDX,0x2
MOV dword ptr [RSI + RCX*0x1 + 0x4],R8D
CMP EAX,EDX
JLE 0x0010135f
MOV EAX,dword ptr [RDI + RCX*0x1 + 0x8]
MOV dword ptr [RSI + RCX*0x1 + 0x8],EAX
MOV RAX,RSI
RET | long func0(long param_1,uint param_2,long param_3)
{
int8 uVar1;
long lVar2;
uint uVar3;
ulong uVar4;
if (0 < (int)param_2) {
if ((param_2 - 1 < 3) || ((ulong)(param_3 - (param_1 + 4)) < 9)) {
lVar2 = 0;
do {
*(int4 *)(param_3 + lVar2) = *(int4 *)(param_1 + lVar2);
lVar2 = lVar2 + 4;
} while ((long)(int)param_2 * 4 - lVar2 != 0);
}
else {
lVar2 = 0;
do {
uVar1 = ((int8 *)(param_1 + lVar2))[1];
*(int8 *)(param_3 + lVar2) = *(int8 *)(param_1 + lVar2);
((int8 *)(param_3 + lVar2))[1] = uVar1;
lVar2 = lVar2 + 0x10;
} while (lVar2 != (ulong)(param_2 >> 2) << 4);
uVar3 = param_2 & 0xfffffffc;
if (((long)(int)param_2 & 3U) != 0) {
uVar4 = (ulong)uVar3;
lVar2 = uVar4 * 4;
*(int4 *)(param_3 + uVar4 * 4) = *(int4 *)(param_1 + uVar4 * 4);
if (((int)(uVar3 + 1) < (int)param_2) &&
(*(int4 *)(param_3 + 4 + lVar2) = *(int4 *)(param_1 + 4 + lVar2),
(int)(uVar3 + 2) < (int)param_2)) {
*(int4 *)(param_3 + 8 + lVar2) = *(int4 *)(param_1 + 8 + lVar2);
return param_3;
}
}
}
}
return param_3;
} |
6,244 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
}
| int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x80000000,-0xc(%rbp)
movl $0x7fffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11fb <func0+0x92>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jge 11c3 <func0+0x5a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jle 11f7 <func0+0x8e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118f <func0+0x26>
mov -0xc(%rbp),%eax
sub -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_C], 80000000h
mov [rbp+var_8], 7FFFFFFFh
mov [rbp+var_4], 0
jmp short loc_11FB
loc_118F:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jge short loc_11C3
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_11C3:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_8], eax
jle short loc_11F7
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
loc_11F7:
add [rbp+var_4], 1
loc_11FB:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118F
mov eax, [rbp+var_C]
sub eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
signed int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0x80000000;
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( v3 < *(_DWORD *)(4LL * i + a1) )
v3 = *(_DWORD *)(4LL * i + a1);
if ( v4 > *(_DWORD *)(4LL * i + a1) )
v4 = *(_DWORD *)(4LL * i + a1);
}
return (unsigned int)(v3 - 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],0x80000000
MOV dword ptr [RBP + -0x8],0x7fffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011fb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JGE 0x001011c3
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011c3:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x8],EAX
JLE 0x001011f7
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011f7:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011fb:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118f
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = -0x80000000;
local_10 = 0x7fffffff;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_14 < *(int *)(param_1 + (long)local_c * 4)) {
local_14 = *(int *)(param_1 + (long)local_c * 4);
}
if (*(int *)(param_1 + (long)local_c * 4) < local_10) {
local_10 = *(int *)(param_1 + (long)local_c * 4);
}
}
return local_14 - local_10;
} |
6,245 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
}
| int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 119e <func0+0x35>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x7fffffff,%esi
mov $0x80000000,%eax
mov (%rcx),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %edx,%esi
cmovg %edx,%esi
add $0x4,%rcx
cmp %rdi,%rcx
jne 1186 <func0+0x1d>
sub %esi,%eax
retq
mov $0x7fffffff,%esi
mov $0x80000000,%eax
jmp 119b <func0+0x32>
| func0:
endbr64
test esi, esi
jle short loc_119E
mov rcx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
mov esi, 7FFFFFFFh
mov eax, 80000000h
loc_1186:
mov edx, [rcx]
cmp eax, edx
cmovl eax, edx
cmp esi, edx
cmovg esi, edx
add rcx, 4
cmp rcx, rdi
jnz short loc_1186
loc_119B:
sub eax, esi
retn
loc_119E:
mov esi, 7FFFFFFFh
mov eax, 80000000h
jmp short loc_119B | long long func0(signed int *a1, int a2)
{
signed int *v2; // rcx
long long v3; // rdi
int v4; // esi
signed int v5; // eax
if ( a2 <= 0 )
{
v4 = 0x7FFFFFFF;
v5 = 0x80000000;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x7FFFFFFF;
v5 = 0x80000000;
do
{
if ( v5 < *v2 )
v5 = *v2;
if ( v4 > *v2 )
v4 = *v2;
++v2;
}
while ( v2 != (signed int *)v3 );
}
return (unsigned int)(v5 - v4);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119e
MOV RCX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
MOV ESI,0x7fffffff
MOV EAX,0x80000000
LAB_00101186:
MOV EDX,dword ptr [RCX]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ESI,EDX
CMOVG ESI,EDX
ADD RCX,0x4
CMP RCX,RDI
JNZ 0x00101186
LAB_0010119b:
SUB EAX,ESI
RET
LAB_0010119e:
MOV ESI,0x7fffffff
MOV EAX,0x80000000
JMP 0x0010119b | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0x7fffffff;
iVar3 = -0x80000000;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0x7fffffff;
iVar3 = -0x80000000;
do {
iVar2 = *param_1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
if (iVar2 < iVar4) {
iVar4 = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar3 - iVar4;
} |
6,246 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
}
| int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
mov $0x7fffffff,%ecx
lea 0x4(%rdi,%rax,4),%rsi
mov $0x80000000,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %edx,%ecx
cmovg %edx,%ecx
add $0x4,%rdi
cmp %rsi,%rdi
jne 1160 <func0+0x20>
sub %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1180
lea eax, [rsi-1]
mov ecx, 7FFFFFFFh
lea rsi, [rdi+rax*4+4]
mov eax, 80000000h
nop word ptr [rax+rax+00h]
loc_1160:
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
cmp ecx, edx
cmovg ecx, edx
add rdi, 4
cmp rdi, rsi
jnz short loc_1160
sub eax, ecx
retn
loc_1180:
mov eax, 1
retn | long long func0(signed int *a1, int a2)
{
int v2; // ecx
long long v3; // rsi
signed int v4; // eax
if ( a2 <= 0 )
return 1LL;
v2 = 0x7FFFFFFF;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x80000000;
do
{
if ( v4 < *a1 )
v4 = *a1;
if ( v2 > *a1 )
v2 = *a1;
++a1;
}
while ( a1 != (signed int *)v3 );
return (unsigned int)(v4 - v2);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
LEA EAX,[RSI + -0x1]
MOV ECX,0x7fffffff
LEA RSI,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x80000000
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ECX,EDX
CMOVG ECX,EDX
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101160
SUB EAX,ECX
RET
LAB_00101180:
MOV EAX,0x1
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
iVar4 = 0x7fffffff;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = -0x80000000;
do {
iVar2 = *param_1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
if (iVar2 < iVar4) {
iVar4 = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar3 - iVar4;
}
return 1;
} |
6,247 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
}
| int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1298 <func0+0x158>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 129e <func0+0x15e>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm4
movdqa 0xeb6(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm1,%xmm3
movdqa %xmm4,%xmm2
add $0x10,%rax
pcmpgtd %xmm0,%xmm3
pcmpgtd %xmm0,%xmm2
pand %xmm3,%xmm1
pandn %xmm0,%xmm3
pand %xmm2,%xmm0
pandn %xmm4,%xmm2
por %xmm3,%xmm1
movdqa %xmm2,%xmm4
por %xmm0,%xmm4
cmp %rdx,%rax
jne 1180 <func0+0x40>
movdqa %xmm4,%xmm3
mov %esi,%ecx
psrldq $0x8,%xmm3
and $0xfffffffc,%ecx
movdqa %xmm3,%xmm0
pcmpgtd %xmm4,%xmm0
pand %xmm0,%xmm4
pandn %xmm3,%xmm0
movdqa %xmm4,%xmm2
por %xmm0,%xmm2
movdqa %xmm2,%xmm3
psrldq $0x4,%xmm3
movdqa %xmm3,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm2
pandn %xmm3,%xmm0
por %xmm2,%xmm0
movdqa %xmm1,%xmm2
psrldq $0x8,%xmm2
movd %xmm0,%edx
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
movdqa %xmm0,%xmm1
por %xmm2,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 1292 <func0+0x152>
movslq %ecx,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%eax
cmovl %r8d,%eax
cmp %r8d,%edx
cmovg %r8d,%edx
lea 0x1(%rcx),%r8d
cmp %r8d,%esi
jle 1292 <func0+0x152>
movslq %r8d,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%eax
cmovl %r8d,%eax
cmp %r8d,%edx
cmovg %r8d,%edx
add $0x2,%ecx
cmp %ecx,%esi
jle 1292 <func0+0x152>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
cmp %ecx,%edx
cmovg %ecx,%edx
sub %edx,%eax
retq
nopl (%rax)
mov $0x1,%eax
retq
xor %ecx,%ecx
mov $0x7fffffff,%edx
mov $0x80000000,%eax
jmp 1248 <func0+0x108>
nopl 0x0(%rax)
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1298
lea eax, [rsi-1]
cmp eax, 2
jbe loc_129E
mov edx, esi
movdqa xmm3, cs:xmmword_2010
movdqa xmm1, cs:xmmword_2020
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm2, xmm1
add rax, 10h
pcmpgtd xmm2, xmm0
pand xmm1, xmm2
pandn xmm2, xmm0
por xmm1, xmm2
movdqa xmm2, xmm3
pcmpgtd xmm2, xmm0
pand xmm0, xmm2
pandn xmm2, xmm3
movdqa xmm3, xmm2
por xmm3, xmm0
cmp rdx, rax
jnz short loc_1180
movdqa xmm0, xmm3
mov esi, ecx
psrldq xmm0, 8
and esi, 0FFFFFFFCh
movdqa xmm2, xmm0
pcmpgtd xmm2, xmm3
pand xmm3, xmm2
pandn xmm2, xmm0
por xmm2, xmm3
movdqa xmm3, xmm2
psrldq xmm3, 4
movdqa xmm0, xmm3
pcmpgtd xmm0, xmm2
pand xmm2, xmm0
pandn xmm0, xmm3
por xmm0, xmm2
movdqa xmm2, xmm1
psrldq xmm2, 8
movd edx, xmm0
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
movdqa xmm1, xmm0
por xmm1, xmm2
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
test cl, 3
jz short loc_1292
loc_1243:
movsxd r8, esi
lea r9, ds:0[r8*4]
mov r8d, [rdi+r8*4]
cmp eax, r8d
cmovl eax, r8d
cmp edx, r8d
cmovg edx, r8d
lea r8d, [rsi+1]
cmp ecx, r8d
jle short loc_1292
mov r8d, [rdi+r9+4]
cmp eax, r8d
cmovl eax, r8d
cmp edx, r8d
cmovg edx, r8d
add esi, 2
cmp ecx, esi
jle short loc_1292
mov ecx, [rdi+r9+8]
cmp eax, ecx
cmovl eax, ecx
cmp edx, ecx
cmovg edx, ecx
loc_1292:
sub eax, edx
retn
loc_1298:
mov eax, 1
retn
loc_129E:
xor esi, esi
mov edx, 7FFFFFFFh
mov eax, 80000000h
jmp short loc_1243 | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm3
__m128i v4; // xmm1
const __m128i *v5; // rax
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm2
__m128i v9; // xmm0
signed int v10; // esi
__m128i v11; // xmm2
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; // xmm0
__m128i v15; // xmm0
__m128i v16; // xmm2
int v17; // edx
__m128i v18; // xmm0
__m128i v19; // xmm1
__m128i v20; // xmm2
__m128i v21; // xmm0
int v22; // eax
long long v23; // r9
int v24; // r8d
int v25; // r8d
int v26; // ecx
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v10 = 0;
v17 = 0x7FFFFFFF;
v22 = 0x80000000;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = _mm_load_si128((const __m128i *)&xmmword_2020);
v5 = a1;
do
{
v6 = _mm_loadu_si128(v5++);
v7 = _mm_cmpgt_epi32(v4, v6);
v4 = _mm_or_si128(_mm_and_si128(v4, v7), _mm_andnot_si128(v7, v6));
v8 = _mm_cmpgt_epi32(si128, v6);
si128 = _mm_or_si128(_mm_andnot_si128(v8, si128), _mm_and_si128(v6, v8));
}
while ( &a1[(unsigned int)a2 >> 2] != v5 );
v9 = _mm_srli_si128(si128, 8);
v10 = a2 & 0xFFFFFFFC;
v11 = _mm_cmpgt_epi32(v9, si128);
v12 = _mm_or_si128(_mm_andnot_si128(v11, v9), _mm_and_si128(si128, v11));
v13 = _mm_srli_si128(v12, 4);
v14 = _mm_cmpgt_epi32(v13, v12);
v15 = _mm_or_si128(_mm_andnot_si128(v14, v13), _mm_and_si128(v12, v14));
v16 = _mm_srli_si128(v4, 8);
v17 = _mm_cvtsi128_si32(v15);
v18 = _mm_cmpgt_epi32(v16, v4);
v19 = _mm_or_si128(_mm_andnot_si128(v18, v4), _mm_and_si128(v16, v18));
v20 = _mm_srli_si128(v19, 4);
v21 = _mm_cmpgt_epi32(v20, v19);
v22 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v21, v19), _mm_and_si128(v20, v21)));
if ( (a2 & 3) == 0 )
return (unsigned int)(v22 - v17);
}
v23 = v10;
v24 = a1->m128i_i32[v23];
if ( v22 < v24 )
v22 = a1->m128i_i32[v10];
if ( v17 > v24 )
v17 = a1->m128i_i32[v10];
if ( a2 > v10 + 1 )
{
v25 = a1->m128i_i32[v23 + 1];
if ( v22 < v25 )
v22 = a1->m128i_i32[v23 + 1];
if ( v17 > v25 )
v17 = a1->m128i_i32[v23 + 1];
if ( a2 > v10 + 2 )
{
v26 = a1->m128i_i32[v23 + 2];
if ( v22 < v26 )
v22 = a1->m128i_i32[v23 + 2];
if ( v17 > v26 )
v17 = a1->m128i_i32[v23 + 2];
}
}
return (unsigned int)(v22 - v17);
}
return 1LL;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101298
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x0010129e
MOV EDX,ESI
MOVDQA XMM3,xmmword ptr [0x00102010]
MOVDQA XMM1,xmmword ptr [0x00102020]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM2,XMM1
ADD RAX,0x10
PCMPGTD XMM2,XMM0
PAND XMM1,XMM2
PANDN XMM2,XMM0
POR XMM1,XMM2
MOVDQA XMM2,XMM3
PCMPGTD XMM2,XMM0
PAND XMM0,XMM2
PANDN XMM2,XMM3
MOVDQA XMM3,XMM2
POR XMM3,XMM0
CMP RDX,RAX
JNZ 0x00101180
MOVDQA XMM0,XMM3
MOV ESI,ECX
PSRLDQ XMM0,0x8
AND ESI,0xfffffffc
MOVDQA XMM2,XMM0
PCMPGTD XMM2,XMM3
PAND XMM3,XMM2
PANDN XMM2,XMM0
POR XMM2,XMM3
MOVDQA XMM3,XMM2
PSRLDQ XMM3,0x4
MOVDQA XMM0,XMM3
PCMPGTD XMM0,XMM2
PAND XMM2,XMM0
PANDN XMM0,XMM3
POR XMM0,XMM2
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x8
MOVD EDX,XMM0
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
MOVDQA XMM1,XMM0
POR XMM1,XMM2
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x00101292
LAB_00101243:
MOVSXD R8,ESI
LEA R9,[R8*0x4]
MOV R8D,dword ptr [RDI + R8*0x4]
CMP EAX,R8D
CMOVL EAX,R8D
CMP EDX,R8D
CMOVG EDX,R8D
LEA R8D,[RSI + 0x1]
CMP ECX,R8D
JLE 0x00101292
MOV R8D,dword ptr [RDI + R9*0x1 + 0x4]
CMP EAX,R8D
CMOVL EAX,R8D
CMP EDX,R8D
CMOVG EDX,R8D
ADD ESI,0x2
CMP ECX,ESI
JLE 0x00101292
MOV ECX,dword ptr [RDI + R9*0x1 + 0x8]
CMP EAX,ECX
CMOVL EAX,ECX
CMP EDX,ECX
CMOVG EDX,ECX
LAB_00101292:
SUB EAX,EDX
RET
LAB_00101298:
MOV EAX,0x1
RET
LAB_0010129e:
XOR ESI,ESI
MOV EDX,0x7fffffff
MOV EAX,0x80000000
JMP 0x00101243 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
if ((int)param_2 < 1) {
return 1;
}
if (param_2 - 1 < 3) {
uVar5 = 0;
uVar6 = 0x7fffffff;
uVar7 = 0x80000000;
}
else {
puVar4 = param_1;
uVar6 = _DAT_00102010;
uVar7 = _UNK_00102014;
uVar12 = _UNK_00102018;
uVar13 = _UNK_0010201c;
uVar8 = _DAT_00102020;
uVar9 = _UNK_00102024;
uVar10 = _UNK_00102028;
uVar11 = _UNK_0010202c;
do {
uVar5 = *puVar4;
uVar1 = puVar4[1];
uVar2 = puVar4[2];
uVar3 = puVar4[3];
puVar4 = puVar4 + 4;
uVar8 = uVar8 & -(uint)((int)uVar5 < (int)uVar8) | ~-(uint)((int)uVar5 < (int)uVar8) & uVar5;
uVar9 = uVar9 & -(uint)((int)uVar1 < (int)uVar9) | ~-(uint)((int)uVar1 < (int)uVar9) & uVar1;
uVar10 = uVar10 & -(uint)((int)uVar2 < (int)uVar10) |
~-(uint)((int)uVar2 < (int)uVar10) & uVar2;
uVar11 = uVar11 & -(uint)((int)uVar3 < (int)uVar11) |
~-(uint)((int)uVar3 < (int)uVar11) & uVar3;
uVar6 = ~-(uint)((int)uVar5 < (int)uVar6) & uVar6 | uVar5 & -(uint)((int)uVar5 < (int)uVar6);
uVar7 = ~-(uint)((int)uVar1 < (int)uVar7) & uVar7 | uVar1 & -(uint)((int)uVar1 < (int)uVar7);
uVar12 = ~-(uint)((int)uVar2 < (int)uVar12) & uVar12 |
uVar2 & -(uint)((int)uVar2 < (int)uVar12);
uVar13 = ~-(uint)((int)uVar3 < (int)uVar13) & uVar13 |
uVar3 & -(uint)((int)uVar3 < (int)uVar13);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != puVar4);
uVar5 = param_2 & 0xfffffffc;
uVar12 = ~-(uint)((int)uVar6 < (int)uVar12) & uVar12 | uVar6 & -(uint)((int)uVar6 < (int)uVar12)
;
uVar7 = ~-(uint)((int)uVar7 < (int)uVar13) & uVar13 | uVar7 & -(uint)((int)uVar7 < (int)uVar13);
uVar6 = -(uint)((int)uVar12 < (int)uVar7);
uVar6 = ~uVar6 & uVar7 | uVar12 & uVar6;
uVar12 = ~-(uint)((int)uVar8 < (int)uVar10) & uVar8 | uVar10 & -(uint)((int)uVar8 < (int)uVar10)
;
uVar13 = ~-(uint)((int)uVar9 < (int)uVar11) & uVar9 | uVar11 & -(uint)((int)uVar9 < (int)uVar11)
;
uVar7 = -(uint)((int)uVar12 < (int)uVar13);
uVar7 = ~uVar7 & uVar12 | uVar13 & uVar7;
if ((param_2 & 3) == 0) goto LAB_00101292;
}
uVar12 = param_1[(int)uVar5];
if ((int)uVar7 < (int)uVar12) {
uVar7 = uVar12;
}
if ((int)uVar12 < (int)uVar6) {
uVar6 = uVar12;
}
if ((int)(uVar5 + 1) < (int)param_2) {
uVar12 = param_1[(long)(int)uVar5 + 1];
if ((int)uVar7 < (int)uVar12) {
uVar7 = uVar12;
}
if ((int)uVar12 < (int)uVar6) {
uVar6 = uVar12;
}
if ((int)(uVar5 + 2) < (int)param_2) {
uVar5 = param_1[(long)(int)uVar5 + 2];
if ((int)uVar7 < (int)uVar5) {
uVar7 = uVar5;
}
if ((int)uVar5 < (int)uVar6) {
uVar6 = uVar5;
}
}
}
LAB_00101292:
return uVar7 - uVar6;
} |
6,248 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
}
}
*size = idx;
return lists;
}
| int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
}
free(result);
result = func0(50, 100, &size);
int expected_2[] = {64, 81, 100};
int expected_2_size = sizeof(expected_2) / sizeof(expected_2[0]);
assert(size == expected_2_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_2[i]);
}
free(result);
result = func0(100, 200, &size);
int expected_3[] = {100, 121, 144, 169, 196};
int expected_3_size = sizeof(expected_3) / sizeof(expected_3[0]);
assert(size == expected_3_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_3[i]);
}
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov %rdx,-0x30(%rbp)
mov -0x28(%rbp),%eax
sub -0x24(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x24(%rbp),%eax
mov %eax,-0x10(%rbp)
jmp 1231 <func0+0x88>
movl $0x1,-0xc(%rbp)
jmp 1222 <func0+0x79>
mov -0xc(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x10(%rbp)
jne 121e <func0+0x75>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
mov %eax,(%rdx)
jmp 122d <func0+0x84>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x10(%rbp)
jge 11f2 <func0+0x49>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x28(%rbp),%eax
jle 11e9 <func0+0x40>
mov -0x30(%rbp),%rax
mov -0x14(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov [rbp+var_30], rdx
mov eax, [rbp+var_28]
sub eax, [rbp+var_24]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov eax, [rbp+var_24]
mov [rbp+var_10], eax
jmp short loc_1231
loc_11E9:
mov [rbp+var_C], 1
jmp short loc_1222
loc_11F2:
mov eax, [rbp+var_C]
imul eax, eax
cmp [rbp+var_10], eax
jnz short loc_121E
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_8]
add rdx, rax
mov eax, [rbp+var_10]
mov [rdx], eax
jmp short loc_122D
loc_121E:
add [rbp+var_C], 1
loc_1222:
mov eax, [rbp+var_C]
imul eax, eax
cmp [rbp+var_10], eax
jge short loc_11F2
loc_122D:
add [rbp+var_10], 1
loc_1231:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_28]
jle short loc_11E9
mov rax, [rbp+var_30]
mov edx, [rbp+var_14]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(int a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v9 = malloc(4LL * (a2 - a1 + 1));
v6 = 0;
for ( i = a1; i <= a2; ++i )
{
for ( j = 1; i >= j * j; ++j )
{
if ( i == j * j )
{
v3 = v6++;
v9[v3] = i;
break;
}
}
}
*a3 = v6;
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV qword ptr [RBP + -0x30],RDX
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00101231
LAB_001011e9:
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101222
LAB_001011f2:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x10],EAX
JNZ 0x0010121e
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 + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RDX],EAX
JMP 0x0010122d
LAB_0010121e:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101222:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x10],EAX
JGE 0x001011f2
LAB_0010122d:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101231:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x28]
JLE 0x001011e9
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)((param_2 - param_1) + 1) << 2);
local_1c = 0;
local_18 = param_1;
do {
if (param_2 < local_18) {
*param_3 = local_1c;
return pvVar1;
}
for (local_14 = 1; local_14 * local_14 <= local_18; local_14 = local_14 + 1) {
if (local_18 == local_14 * local_14) {
*(int *)((long)local_1c * 4 + (long)pvVar1) = local_18;
local_1c = local_1c + 1;
break;
}
}
local_18 = local_18 + 1;
} while( true );
} |
6,249 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
}
}
*size = idx;
return lists;
}
| int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
}
free(result);
result = func0(50, 100, &size);
int expected_2[] = {64, 81, 100};
int expected_2_size = sizeof(expected_2) / sizeof(expected_2[0]);
assert(size == expected_2_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_2[i]);
}
free(result);
result = func0(100, 200, &size);
int expected_3[] = {100, 121, 144, 169, 196};
int expected_3_size = sizeof(expected_3) / sizeof(expected_3[0]);
assert(size == expected_3_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_3[i]);
}
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %esi,%r12d
mov %rdx,%rbp
mov %esi,%edi
sub %ebx,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %ebx,%r12d
jl 120b <func0+0x62>
lea 0x1(%r12),%edi
mov $0x0,%esi
jmp 11ed <func0+0x44>
movslq %esi,%rdx
mov %ebx,(%rax,%rdx,4)
lea 0x1(%rsi),%esi
add $0x1,%ebx
cmp %ebx,%edi
je 1210 <func0+0x67>
test %ebx,%ebx
jle 11e6 <func0+0x3d>
cmp $0x1,%ebx
je 11dd <func0+0x34>
mov $0x1,%edx
add $0x1,%edx
mov %edx,%ecx
imul %edx,%ecx
cmp %ebx,%ecx
jg 11e6 <func0+0x3d>
jne 11fb <func0+0x52>
jmp 11dd <func0+0x34>
mov $0x0,%esi
mov %esi,0x0(%rbp)
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov ebx, edi
mov r12d, esi
mov rbp, rdx
mov edi, esi
sub edi, ebx
add edi, 1
movsxd rdi, edi
shl rdi, 2
call _malloc
cmp r12d, ebx
jl short loc_120B
lea edi, [r12+1]
mov esi, 0
jmp short loc_11ED
loc_11DD:
movsxd rdx, esi
mov [rax+rdx*4], ebx
lea esi, [rsi+1]
loc_11E6:
add ebx, 1
cmp edi, ebx
jz short loc_1210
loc_11ED:
test ebx, ebx
jle short loc_11E6
cmp ebx, 1
jz short loc_11DD
mov edx, 1
loc_11FB:
add edx, 1
mov ecx, edx
imul ecx, edx
cmp ecx, ebx
jg short loc_11E6
jnz short loc_11FB
jmp short loc_11DD
loc_120B:
mov esi, 0
loc_1210:
mov [rbp+0], esi
pop rbx
pop rbp
pop r12
retn | long long func0(int a1, int a2, _DWORD *a3)
{
int v3; // ebx
long long result; // rax
int v7; // esi
int v8; // edx
v3 = a1;
result = malloc(4LL * (a2 - a1 + 1));
if ( a2 < a1 )
{
v7 = 0;
}
else
{
v7 = 0;
do
{
if ( v3 > 0 )
{
if ( v3 == 1 )
{
LABEL_3:
*(_DWORD *)(result + 4LL * v7++) = v3;
}
else
{
v8 = 1;
while ( 1 )
{
++v8;
if ( v8 * v8 > v3 )
break;
if ( v8 * v8 == v3 )
goto LABEL_3;
}
}
}
++v3;
}
while ( a2 + 1 != v3 );
}
*a3 = v7;
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV R12D,ESI
MOV RBP,RDX
MOV EDI,ESI
SUB EDI,EBX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
CMP R12D,EBX
JL 0x0010120b
LEA EDI,[R12 + 0x1]
MOV ESI,0x0
JMP 0x001011ed
LAB_001011dd:
MOVSXD RDX,ESI
MOV dword ptr [RAX + RDX*0x4],EBX
LEA ESI,[RSI + 0x1]
LAB_001011e6:
ADD EBX,0x1
CMP EDI,EBX
JZ 0x00101210
LAB_001011ed:
TEST EBX,EBX
JLE 0x001011e6
CMP EBX,0x1
JZ 0x001011dd
MOV EDX,0x1
LAB_001011fb:
ADD EDX,0x1
MOV ECX,EDX
IMUL ECX,EDX
CMP ECX,EBX
JG 0x001011e6
JNZ 0x001011fb
JMP 0x001011dd
LAB_0010120b:
MOV ESI,0x0
LAB_00101210:
MOV dword ptr [RBP],ESI
POP RBX
POP RBP
POP R12
RET | void func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int iVar2;
int iVar3;
pvVar1 = malloc((long)((param_2 - param_1) + 1) << 2);
if (param_2 < param_1) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
if (0 < param_1) {
if (param_1 != 1) {
iVar2 = 1;
do {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) goto LAB_001011e6;
} while (iVar2 * iVar2 != param_1);
}
*(int *)((long)pvVar1 + (long)iVar3 * 4) = param_1;
iVar3 = iVar3 + 1;
}
LAB_001011e6:
param_1 = param_1 + 1;
} while (param_2 + 1 != param_1);
}
*param_3 = iVar3;
return;
} |
6,250 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
}
}
*size = idx;
return lists;
}
| int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
}
free(result);
result = func0(50, 100, &size);
int expected_2[] = {64, 81, 100};
int expected_2_size = sizeof(expected_2) / sizeof(expected_2[0]);
assert(size == expected_2_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_2[i]);
}
free(result);
result = func0(100, 200, &size);
int expected_3[] = {100, 121, 144, 169, 196};
int expected_3_size = sizeof(expected_3) / sizeof(expected_3[0]);
assert(size == expected_3_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_3[i]);
}
free(result);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov %edi,%ebx
mov %esi,%edi
sub %ebx,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %ebx,%ebp
jl 1433 <func0+0x73>
lea 0x1(%rbp),%edi
xor %r8d,%r8d
nopl 0x0(%rax)
test %ebx,%ebx
jle 140e <func0+0x4e>
cmp $0x1,%ebx
je 1420 <func0+0x60>
mov $0x1,%ecx
jmp 1402 <func0+0x42>
je 1420 <func0+0x60>
add $0x1,%ecx
mov %ecx,%esi
imul %ecx,%esi
cmp %ebx,%esi
jle 1400 <func0+0x40>
add $0x1,%ebx
cmp %ebx,%edi
jne 13f0 <func0+0x30>
pop %rbx
pop %rbp
mov %r8d,(%r12)
pop %r12
retq
xchg %ax,%ax
movslq %r8d,%rdx
add $0x1,%r8d
mov %ebx,(%rax,%rdx,4)
add $0x1,%ebx
cmp %ebx,%edi
jne 13f0 <func0+0x30>
jmp 1415 <func0+0x55>
xor %r8d,%r8d
pop %rbx
pop %rbp
mov %r8d,(%r12)
pop %r12
retq
| func0:
endbr64
push r12
mov r12, rdx
push rbp
mov ebp, esi
push rbx
mov ebx, edi
mov edi, esi
sub edi, ebx
add edi, 1
movsxd rdi, edi
shl rdi, 2
call _malloc
cmp ebp, ebx
jl short loc_1432
lea esi, [rbp+1]
xor edi, edi
nop dword ptr [rax+rax+00h]
loc_13F0:
test ebx, ebx
jle short loc_140E
cmp ebx, 1
jz short loc_1420
mov edx, 1
jmp short loc_1402
loc_1400:
jz short loc_1420
loc_1402:
add edx, 1
mov ecx, edx
imul ecx, edx
cmp ecx, ebx
jle short loc_1400
loc_140E:
add ebx, 1
cmp esi, ebx
jnz short loc_13F0
loc_1415:
pop rbx
pop rbp
mov [r12], edi
pop r12
retn
loc_1420:
movsxd rdx, edi
add edi, 1
mov [rax+rdx*4], ebx
add ebx, 1
cmp esi, ebx
jnz short loc_13F0
jmp short loc_1415
loc_1432:
xor edi, edi
pop rbx
pop rbp
mov [r12], edi
pop r12
retn | long long func0(int a1, int a2, _DWORD *a3)
{
int v4; // ebx
long long result; // rax
int v6; // esi
int v7; // edi
int v8; // edx
long long v9; // rdx
v4 = a1;
result = malloc(4LL * (a2 - a1 + 1));
if ( a2 >= a1 )
{
v6 = a2 + 1;
v7 = 0;
while ( 1 )
{
while ( v4 <= 0 )
{
LABEL_8:
if ( v6 == ++v4 )
goto LABEL_9;
}
if ( v4 != 1 )
{
v8 = 1;
do
{
++v8;
if ( v8 * v8 > v4 )
goto LABEL_8;
}
while ( v8 * v8 != v4 );
}
v9 = v7++;
*(_DWORD *)(result + 4 * v9) = v4++;
if ( v6 == v4 )
{
LABEL_9:
*a3 = v7;
return result;
}
}
}
*a3 = 0;
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDI
MOV EDI,ESI
SUB EDI,EBX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
CMP EBP,EBX
JL 0x00101432
LEA ESI,[RBP + 0x1]
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013f0:
TEST EBX,EBX
JLE 0x0010140e
CMP EBX,0x1
JZ 0x00101420
MOV EDX,0x1
JMP 0x00101402
LAB_00101400:
JZ 0x00101420
LAB_00101402:
ADD EDX,0x1
MOV ECX,EDX
IMUL ECX,EDX
CMP ECX,EBX
JLE 0x00101400
LAB_0010140e:
ADD EBX,0x1
CMP ESI,EBX
JNZ 0x001013f0
LAB_00101415:
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET
LAB_00101420:
MOVSXD RDX,EDI
ADD EDI,0x1
MOV dword ptr [RAX + RDX*0x4],EBX
ADD EBX,0x1
CMP ESI,EBX
JNZ 0x001013f0
JMP 0x00101415
LAB_00101432:
XOR EDI,EDI
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET | void func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int iVar2;
long lVar3;
int iVar4;
pvVar1 = malloc((long)((param_2 - param_1) + 1) << 2);
if (param_2 < param_1) {
*param_3 = 0;
return;
}
iVar4 = 0;
do {
while (0 < param_1) {
if (param_1 != 1) {
iVar2 = 1;
do {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) goto LAB_0010140e;
} while (iVar2 * iVar2 != param_1);
}
lVar3 = (long)iVar4;
iVar4 = iVar4 + 1;
*(int *)((long)pvVar1 + lVar3 * 4) = param_1;
param_1 = param_1 + 1;
if (param_2 + 1 == param_1) goto LAB_00101415;
}
LAB_0010140e:
param_1 = param_1 + 1;
} while (param_2 + 1 != param_1);
LAB_00101415:
*param_3 = iVar4;
return;
} |
6,251 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
}
}
*size = idx;
return lists;
}
| int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
}
free(result);
result = func0(50, 100, &size);
int expected_2[] = {64, 81, 100};
int expected_2_size = sizeof(expected_2) / sizeof(expected_2[0]);
assert(size == expected_2_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_2[i]);
}
free(result);
result = func0(100, 200, &size);
int expected_3[] = {100, 121, 144, 169, 196};
int expected_3_size = sizeof(expected_3) / sizeof(expected_3[0]);
assert(size == expected_3_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_3[i]);
}
free(result);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov %edi,%ebx
mov %esi,%edi
sub %ebx,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %ebx,%ebp
jl 14e4 <func0+0x124>
test %ebx,%ebx
jle 1428 <func0+0x68>
xor %esi,%esi
mov $0x1,%ecx
cmp $0x1,%ebx
jne 1406 <func0+0x46>
jmpq 14f0 <func0+0x130>
je 14f0 <func0+0x130>
add $0x1,%ecx
mov %ecx,%edi
imul %ecx,%edi
cmp %edi,%ebx
jge 1400 <func0+0x40>
add $0x1,%ebx
cmp %ebx,%ebp
jge 13f0 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw 0x0(%rax,%rax,1)
test %ebp,%ebp
mov $0x1,%ecx
mov $0x0,%esi
cmovle %ebp,%esi
mov %ecx,%edx
sub %ebx,%edx
add %esi,%edx
cmp %esi,%ebx
cmovg %ecx,%edx
mov %esi,%ecx
sub %ebx,%ecx
cmp $0x7,%ecx
jbe 14a7 <func0+0xe7>
cmp %esi,%ebx
jg 14a7 <func0+0xe7>
movd %ebx,%xmm4
mov %edx,%edi
movdqa 0xca3(%rip),%xmm3
xor %ecx,%ecx
pshufd $0x0,%xmm4,%xmm1
movdqa 0xca4(%rip),%xmm2
paddd 0xc7c(%rip),%xmm1
shr $0x2,%edi
nopw 0x0(%rax,%rax,1)
movdqa %xmm1,%xmm0
add $0x1,%ecx
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
cmp %edi,%ecx
jne 1480 <func0+0xc0>
mov %edx,%edi
pshufd $0xff,%xmm0,%xmm0
and $0xfffffffc,%edi
movd %xmm0,%ecx
add %edi,%ebx
cmp %edi,%edx
je 150d <func0+0x14d>
lea 0x1(%rbx),%edx
cmp %esi,%edx
jg 1509 <func0+0x149>
lea 0x2(%rbx),%edx
cmp %edx,%esi
jl 1509 <func0+0x149>
lea 0x3(%rbx),%edx
cmp %edx,%esi
jl 1509 <func0+0x149>
lea 0x4(%rbx),%edx
cmp %edx,%esi
jl 1509 <func0+0x149>
lea 0x5(%rbx),%edx
cmp %edx,%esi
jl 1509 <func0+0x149>
lea 0x6(%rbx),%edx
cmp %edx,%esi
jl 1509 <func0+0x149>
lea 0x7(%rbx),%edx
add $0x8,%ebx
cmp %edx,%esi
cmovl %edx,%ebx
cmp %ebx,%ebp
jge 13ee <func0+0x2e>
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
movslq %esi,%rdx
add $0x1,%esi
mov %ebx,(%rax,%rdx,4)
add $0x1,%ebx
cmp %ebx,%ebp
jge 13f0 <func0+0x30>
jmpq 1419 <func0+0x59>
mov %edx,%ebx
jmp 14dc <func0+0x11c>
mov %ecx,%ebx
jmp 14dc <func0+0x11c>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12, rdx
push rbp
mov ebp, esi
push rbx
mov ebx, edi
mov edi, esi
sub edi, ebx
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax
cmp ebp, ebx
jl loc_1470
mov eax, ebx
test ebx, ebx
jg short loc_1439
xor edx, edx
test ebp, ebp
mov ecx, 1
cmovle edx, ebp
mov eax, edx
sub eax, ebx
cmp ebx, edx
lea esi, [rax+1]
cmovg esi, ecx
jg short loc_1423
cmp eax, 2
jbe short loc_1423
movd xmm3, ebx
mov ecx, esi
movdqa xmm2, cs:xmmword_20E0
xor eax, eax
pshufd xmm0, xmm3, 0
paddd xmm0, cs:xmmword_20D0
shr ecx, 2
nop word ptr [rax+rax+00h]
loc_1408:
add eax, 1
movdqa xmm1, xmm0
paddd xmm0, xmm2
cmp eax, ecx
jnz short loc_1408
mov eax, esi
and eax, 0FFFFFFFCh
add ebx, eax
and esi, 3
jz short loc_147E
loc_1423:
lea eax, [rbx+1]
cmp edx, eax
jl short loc_1435
lea eax, [rbx+2]
add ebx, 3
cmp edx, eax
cmovge eax, ebx
loc_1435:
cmp ebp, eax
jl short loc_1470
loc_1439:
xor esi, esi
loc_143B:
mov edx, 1
cmp eax, 1
jnz short loc_1452
jmp short loc_1491
loc_1450:
jz short loc_1491
loc_1452:
add edx, 1
mov ecx, edx
imul ecx, edx
cmp ecx, eax
jle short loc_1450
add eax, 1
cmp ebp, eax
jge short loc_143B
jmp short loc_1472
loc_1470:
xor esi, esi
loc_1472:
mov [r12], esi
mov rax, rdi
pop rbx
pop rbp
pop r12
retn
loc_147E:
paddd xmm1, cs:xmmword_20C0
pshufd xmm0, xmm1, 0FFh
movd eax, xmm0
jmp short loc_1435
loc_1491:
movsxd rdx, esi
add esi, 1
mov [rdi+rdx*4], eax
add eax, 1
cmp ebp, eax
jge short loc_143B
jmp short loc_1472 | _DWORD * func0(signed int a1, int a2, _DWORD *a3)
{
signed int v5; // ebx
_DWORD *v6; // rdi
int v7; // eax
signed int v8; // edx
unsigned int v9; // esi
__m128i si128; // xmm2
int v11; // eax
__m128i v12; // xmm0
__m128i v13; // xmm1
int v14; // ebx
int v15; // esi
int v16; // edx
long long v18; // rdx
v5 = a1;
v6 = malloc(4LL * (a2 - a1 + 1));
if ( a2 < v5 )
goto LABEL_21;
v7 = v5;
if ( v5 > 0 )
goto LABEL_14;
v8 = 0;
if ( a2 <= 0 )
v8 = a2;
v9 = v8 - v5 + 1;
if ( v5 > v8 )
goto LABEL_10;
if ( (unsigned int)(v8 - v5) <= 2 )
goto LABEL_10;
si128 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v11 = 0;
v12 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(v5), 0), (__m128i)xmmword_20D0);
do
{
++v11;
v13 = v12;
v12 = _mm_add_epi32(v12, si128);
}
while ( v11 != v9 >> 2 );
v5 += v9 & 0xFFFFFFFC;
if ( (v9 & 3) != 0 )
{
LABEL_10:
v7 = v5 + 1;
if ( v8 >= v5 + 1 )
{
v7 = v5 + 2;
v14 = v5 + 3;
if ( v8 >= v7 )
v7 = v14;
}
}
else
{
v7 = _mm_cvtsi128_si32(_mm_shuffle_epi32(_mm_add_epi32(v13, (__m128i)xmmword_20C0), 255));
}
if ( a2 < v7 )
{
LABEL_21:
v15 = 0;
}
else
{
LABEL_14:
v15 = 0;
do
{
while ( 1 )
{
v16 = 1;
if ( v7 != 1 )
break;
LABEL_24:
v18 = v15++;
v6[v18] = v7++;
if ( a2 < v7 )
goto LABEL_22;
}
while ( 1 )
{
++v16;
if ( v16 * v16 > v7 )
break;
if ( v16 * v16 == v7 )
goto LABEL_24;
}
++v7;
}
while ( a2 >= v7 );
}
LABEL_22:
*a3 = v15;
return v6;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDI
MOV EDI,ESI
SUB EDI,EBX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
CMP EBP,EBX
JL 0x00101470
MOV EAX,EBX
TEST EBX,EBX
JG 0x00101439
XOR EDX,EDX
TEST EBP,EBP
MOV ECX,0x1
CMOVLE EDX,EBP
MOV EAX,EDX
SUB EAX,EBX
CMP EBX,EDX
LEA ESI,[RAX + 0x1]
CMOVG ESI,ECX
JG 0x00101423
CMP EAX,0x2
JBE 0x00101423
MOVD XMM3,EBX
MOV ECX,ESI
MOVDQA XMM2,xmmword ptr [0x001020e0]
XOR EAX,EAX
PSHUFD XMM0,XMM3,0x0
PADDD XMM0,xmmword ptr [0x001020d0]
SHR ECX,0x2
NOP word ptr [RAX + RAX*0x1]
LAB_00101408:
ADD EAX,0x1
MOVDQA XMM1,XMM0
PADDD XMM0,XMM2
CMP EAX,ECX
JNZ 0x00101408
MOV EAX,ESI
AND EAX,0xfffffffc
ADD EBX,EAX
AND ESI,0x3
JZ 0x0010147e
LAB_00101423:
LEA EAX,[RBX + 0x1]
CMP EDX,EAX
JL 0x00101435
LEA EAX,[RBX + 0x2]
ADD EBX,0x3
CMP EDX,EAX
CMOVGE EAX,EBX
LAB_00101435:
CMP EBP,EAX
JL 0x00101470
LAB_00101439:
XOR ESI,ESI
LAB_0010143b:
MOV EDX,0x1
CMP EAX,0x1
JNZ 0x00101452
JMP 0x00101491
LAB_00101450:
JZ 0x00101491
LAB_00101452:
ADD EDX,0x1
MOV ECX,EDX
IMUL ECX,EDX
CMP ECX,EAX
JLE 0x00101450
ADD EAX,0x1
CMP EBP,EAX
JGE 0x0010143b
JMP 0x00101472
LAB_00101470:
XOR ESI,ESI
LAB_00101472:
MOV dword ptr [R12],ESI
MOV RAX,RDI
POP RBX
POP RBP
POP R12
RET
LAB_0010147e:
PADDD XMM1,xmmword ptr [0x001020c0]
PSHUFD XMM0,XMM1,0xff
MOVD EAX,XMM0
JMP 0x00101435
LAB_00101491:
MOVSXD RDX,ESI
ADD ESI,0x1
MOV dword ptr [RDI + RDX*0x4],EAX
ADD EAX,0x1
CMP EBP,EAX
JGE 0x0010143b
JMP 0x00101472 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(int param_1,int param_2,int *param_3)
{
uint uVar1;
uint uVar2;
void *pvVar3;
int iVar4;
long lVar5;
int iVar6;
int iVar7;
pvVar3 = malloc((long)((param_2 - param_1) + 1) << 2);
if (param_2 < param_1) {
LAB_00101470:
iVar6 = 0;
}
else {
if (param_1 < 1) {
iVar6 = 0;
if (param_2 < 1) {
iVar6 = param_2;
}
uVar1 = (iVar6 - param_1) + 1;
if ((iVar6 < param_1) || ((uint)(iVar6 - param_1) < 3)) {
LAB_00101423:
iVar4 = param_1 + 1;
if (param_1 + 1 <= iVar6) {
iVar4 = param_1 + 2;
if (param_1 + 2 <= iVar6) {
iVar4 = param_1 + 3;
}
}
}
else {
uVar2 = 0;
iVar4 = param_1 + _UNK_001020dc;
do {
iVar7 = iVar4;
uVar2 = uVar2 + 1;
iVar4 = iVar7 + _UNK_001020ec;
} while (uVar2 != uVar1 >> 2);
param_1 = param_1 + (uVar1 & 0xfffffffc);
if ((uVar1 & 3) != 0) goto LAB_00101423;
iVar4 = iVar7 + _UNK_001020cc;
}
param_1 = iVar4;
if (param_2 < param_1) goto LAB_00101470;
}
iVar6 = 0;
LAB_0010143b:
do {
iVar4 = 1;
if (param_1 != 1) {
do {
iVar4 = iVar4 + 1;
if (param_1 < iVar4 * iVar4) {
param_1 = param_1 + 1;
if (param_2 < param_1) goto LAB_00101472;
goto LAB_0010143b;
}
} while (iVar4 * iVar4 != param_1);
}
lVar5 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int *)((long)pvVar3 + lVar5 * 4) = param_1;
param_1 = param_1 + 1;
} while (param_1 <= param_2);
}
LAB_00101472:
*param_3 = iVar6;
return pvVar3;
} |
6,252 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.0516502125483738);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(15, 17);
assert(pr.r == 22.67156809750927);
assert(pr.theta == 0.8478169733934057);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
movsd %xmm0,-0x60(%rbp)
movsd %xmm1,-0x68(%rbp)
movsd -0x68(%rbp),%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd -0x60(%rbp),%xmm1
movsd %xmm1,-0x40(%rbp)
movsd %xmm0,-0x38(%rbp)
mov -0x40(%rbp),%rax
movsd -0x38(%rbp),%xmm1
movq %rax,%xmm0
callq 10b0 <cabs@plt>
movq %xmm0,%rax
mov %rax,-0x50(%rbp)
movsd -0x40(%rbp),%xmm0
mov -0x38(%rbp),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 10a0 <atan2@plt>
movq %xmm0,%rax
mov %rax,-0x48(%rbp)
movsd 0xde5(%rip),%xmm0
movsd %xmm0,-0x30(%rbp)
movsd 0xde0(%rip),%xmm0
movsd %xmm0,-0x28(%rbp)
movsd -0x50(%rbp),%xmm0
movsd %xmm0,-0x20(%rbp)
movsd -0x48(%rbp),%xmm0
movsd %xmm0,-0x18(%rbp)
movsd -0x30(%rbp),%xmm0
movsd %xmm0,-0x10(%rbp)
movsd -0x28(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
mov -0x58(%rbp),%rcx
mov -0x20(%rbp),%rax
mov -0x18(%rbp),%rdx
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
mov %rax,0x10(%rcx)
mov %rdx,0x18(%rcx)
mov -0x58(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_68], rdi
movsd [rbp+var_70], xmm0
movsd [rbp+var_78], xmm1
movsd xmm0, [rbp+var_78]
movsd [rbp+y], xmm0
movsd xmm1, [rbp+y]
pxor xmm0, xmm0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_70]
addsd xmm0, xmm1
movsd [rbp+x], xmm0
movsd xmm0, [rbp+y]
movsd xmm1, [rbp+x]
movsd [rbp+var_40], xmm1
movsd [rbp+var_38], xmm0
mov rax, [rbp+var_40]
movsd xmm1, [rbp+var_38]
movq xmm0, rax
call _cabs
movq rax, xmm0
mov [rbp+var_50], rax
movsd xmm0, [rbp+x]
mov rax, [rbp+y]
movapd xmm1, xmm0; x
movq xmm0, rax; y
call _atan2
movq rax, xmm0
mov [rbp+var_48], rax
movsd xmm0, cs:qword_2120
movsd [rbp+var_30], xmm0
movsd xmm0, cs:qword_2128
movsd [rbp+var_28], xmm0
movsd xmm0, [rbp+var_50]
movsd [rbp+var_20], xmm0
movsd xmm0, [rbp+var_48]
movsd [rbp+var_18], xmm0
movsd xmm0, cs:qword_2120
movsd [rbp+var_10], xmm0
movsd xmm0, cs:qword_2128
movsd [rbp+var_8], xmm0
mov rcx, [rbp+var_68]
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
mov [rcx], rax
mov [rcx+8], rdx
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
mov [rcx+10h], rax
mov [rcx+18h], rdx
mov rax, [rbp+var_68]
leave
retn | double * func0(double *a1, double a2, double a3)
{
double x; // [rsp+20h] [rbp-60h]
double v5; // [rsp+60h] [rbp-20h]
double v6; // [rsp+68h] [rbp-18h]
x = 0.0 * a3 + a2;
v5 = cabs(x, a3);
v6 = atan2(a3, x);
*a1 = v5;
a1[1] = v6;
a1[2] = -2.0;
a1[3] = 2.449293598294706e-16;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x68],RDI
MOVSD qword ptr [RBP + -0x70],XMM0
MOVSD qword ptr [RBP + -0x78],XMM1
MOVSD XMM0,qword ptr [RBP + -0x78]
MOVSD qword ptr [RBP + -0x58],XMM0
MOVSD XMM1,qword ptr [RBP + -0x58]
PXOR XMM0,XMM0
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x70]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x60],XMM0
MOVSD XMM0,qword ptr [RBP + -0x58]
MOVSD XMM1,qword ptr [RBP + -0x60]
MOVSD qword ptr [RBP + -0x40],XMM1
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [RBP + -0x40]
MOVSD XMM1,qword ptr [RBP + -0x38]
MOVQ XMM0,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x50],RAX
MOVSD XMM0,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x58]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x001010a0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x48],RAX
MOVSD XMM0,qword ptr [0x00102120]
MOVSD qword ptr [RBP + -0x30],XMM0
MOVSD XMM0,qword ptr [0x00102128]
MOVSD qword ptr [RBP + -0x28],XMM0
MOVSD XMM0,qword ptr [RBP + -0x50]
MOVSD qword ptr [RBP + -0x20],XMM0
MOVSD XMM0,qword ptr [RBP + -0x48]
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM0,qword ptr [0x00102120]
MOVSD qword ptr [RBP + -0x10],XMM0
MOVSD XMM0,qword ptr [0x00102128]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX + 0x10],RAX
MOV qword ptr [RCX + 0x18],RDX
MOV RAX,qword ptr [RBP + -0x68]
LEAVE
RET | double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
param_1 = param_2 * 0.0 + param_1;
dVar3 = cabs(param_1);
dVar4 = atan2(param_2,param_1);
dVar2 = DAT_00102128;
dVar1 = DAT_00102120;
*param_3 = dVar3;
param_3[1] = dVar4;
param_3[2] = dVar1;
param_3[3] = dVar2;
return param_3;
} |
6,253 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.0516502125483738);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(15, 17);
assert(pr.r == 22.67156809750927);
assert(pr.theta == 0.8478169733934057);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
movapd %xmm1,%xmm2
mulsd 0xf7e(%rip),%xmm1
addsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
movapd %xmm1,%xmm0
movsd %xmm2,0x8(%rsp)
movapd %xmm2,%xmm1
callq 10b0 <cabs@plt>
movq %xmm0,%rbp
movsd (%rsp),%xmm1
movsd 0x8(%rsp),%xmm0
callq 10a0 <atan2@plt>
mov %rbp,(%rbx)
movsd %xmm0,0x8(%rbx)
movsd 0xe05(%rip),%xmm0
movsd %xmm0,0x10(%rbx)
movsd 0xe00(%rip),%xmm0
movsd %xmm0,0x18(%rbx)
mov %rbx,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push r14
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
movapd xmm2, xmm0
movq rbp, xmm1
movapd xmm0, xmm1
mulsd xmm0, cs:qword_2118
addsd xmm0, xmm2
movq r14, xmm0
call _cabs
movq r12, xmm0
movq xmm1, r14
movq xmm0, rbp
call _atan2
mov [rbx], r12
movsd qword ptr [rbx+8], xmm0
movsd xmm0, cs:qword_2008
movsd qword ptr [rbx+10h], xmm0
movsd xmm0, cs:qword_2010
movsd qword ptr [rbx+18h], xmm0
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r14
retn | long long func0(long long a1, double a2, double a3)
{
double v3; // r14
double v4; // r12
double v5; // xmm0_8
v3 = a3 * 0.0 + a2;
v4 = cabs();
v5 = atan2(a3, v3);
*(double *)a1 = v4;
*(double *)(a1 + 8) = v5;
*(_QWORD *)(a1 + 16) = 0xC000000000000000LL;
*(_QWORD *)(a1 + 24) = 0x3CB1A62633145C07LL;
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOVAPD XMM2,XMM0
MOVQ RBP,XMM1
MOVAPD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102118]
ADDSD XMM0,XMM2
MOVQ R14,XMM0
CALL 0x001010b0
MOVQ R12,XMM0
MOVQ XMM1,R14
MOVQ XMM0,RBP
CALL 0x001010a0
MOV qword ptr [RBX],R12
MOVSD qword ptr [RBX + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102008]
MOVSD qword ptr [RBX + 0x10],XMM0
MOVSD XMM0,qword ptr [0x00102010]
MOVSD qword ptr [RBX + 0x18],XMM0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R14
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
param_1 = param_2 * _DAT_00102118 + param_1;
dVar1 = cabs(param_1);
dVar2 = atan2(param_2,param_1);
*param_3 = dVar1;
param_3[1] = dVar2;
param_3[2] = DAT_00102008;
param_3[3] = _DAT_00102010;
return param_3;
} |
6,254 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.0516502125483738);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(15, 17);
assert(pr.r == 22.67156809750927);
assert(pr.theta == 0.8478169733934057);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm3,%xmm3
push %r12
mov %rdi,%r12
mulsd %xmm1,%xmm3
sub $0x20,%rsp
movsd %xmm1,0x10(%rsp)
addsd %xmm0,%xmm3
movapd %xmm3,%xmm0
movsd %xmm3,0x18(%rsp)
callq 1070 <cabs@plt>
movsd 0x18(%rsp),%xmm3
movsd 0x10(%rsp),%xmm2
movsd %xmm0,0x8(%rsp)
movapd %xmm3,%xmm1
movapd %xmm2,%xmm0
callq 1060 <atan2@plt>
movsd 0x8(%rsp),%xmm4
mov %r12,%rax
movsd %xmm0,0x8(%r12)
movsd 0xe23(%rip),%xmm0
movsd %xmm4,(%r12)
movsd %xmm0,0x10(%r12)
movsd 0xe16(%rip),%xmm0
movsd %xmm0,0x18(%r12)
add $0x20,%rsp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm3, xmm3
push r12
mov r12, rdi
mulsd xmm3, xmm1
sub rsp, 20h
movsd [rsp+28h+var_18], xmm1
addsd xmm3, xmm0
movapd xmm0, xmm3
movsd [rsp+28h+var_10], xmm3
call _cabs
movsd xmm3, [rsp+28h+var_10]
movsd xmm2, [rsp+28h+var_18]
movsd [rsp+28h+var_20], xmm0
movapd xmm1, xmm3
movapd xmm0, xmm2
call _atan2
movsd xmm4, [rsp+28h+var_20]
mov rax, r12
movsd qword ptr [r12+8], xmm0
movsd xmm0, cs:qword_2008
movsd qword ptr [r12], xmm4
movsd qword ptr [r12+10h], xmm0
movsd xmm0, cs:qword_2010
movsd qword ptr [r12+18h], xmm0
add rsp, 20h
pop r12
retn | long long func0(long long a1, double a2, double a3)
{
double v3; // xmm0_8
long long result; // rax
double v5; // [rsp+0h] [rbp-20h]
double v6; // [rsp+10h] [rbp-10h]
v6 = 0.0 * a3 + a2;
v5 = cabs(v6);
v3 = atan2(a3, v6);
result = a1;
*(double *)(a1 + 8) = v3;
*(double *)a1 = v5;
*(_QWORD *)(a1 + 16) = 0xC000000000000000LL;
*(_QWORD *)(a1 + 24) = 0x3CB1A62633145C07LL;
return result;
} | func0:
ENDBR64
PXOR XMM3,XMM3
PUSH R12
MOV R12,RDI
MULSD XMM3,XMM1
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x10],XMM1
ADDSD XMM3,XMM0
MOVAPD XMM0,XMM3
MOVSD qword ptr [RSP + 0x18],XMM3
CALL 0x001010b0
MOVSD XMM3,qword ptr [RSP + 0x18]
MOVSD XMM2,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM1,XMM3
MOVAPD XMM0,XMM2
CALL 0x001010a0
MOVSD XMM4,qword ptr [RSP + 0x8]
MOV RAX,R12
MOVSD qword ptr [R12 + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102008]
MOVSD qword ptr [R12],XMM4
MOVSD qword ptr [R12 + 0x10],XMM0
MOVSD XMM0,qword ptr [0x00102010]
MOVSD qword ptr [R12 + 0x18],XMM0
ADD RSP,0x20
POP R12
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
param_1 = param_2 * 0.0 + param_1;
dVar1 = cabs(param_1);
dVar2 = atan2(param_2,param_1);
param_3[1] = dVar2;
dVar2 = DAT_00102008;
*param_3 = dVar1;
param_3[2] = dVar2;
param_3[3] = _DAT_00102010;
return param_3;
} |
6,255 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.0516502125483738);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(15, 17);
assert(pr.r == 22.67156809750927);
assert(pr.theta == 0.8478169733934057);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm4,%xmm4
push %r12
mov %rdi,%r12
mulsd %xmm1,%xmm4
sub $0x20,%rsp
movsd %xmm1,0x10(%rsp)
addsd %xmm0,%xmm4
movapd %xmm4,%xmm0
movsd %xmm4,0x18(%rsp)
callq 1070 <cabs@plt>
movsd 0x18(%rsp),%xmm4
movsd 0x10(%rsp),%xmm3
movsd %xmm0,0x8(%rsp)
movapd %xmm4,%xmm1
movapd %xmm3,%xmm0
callq 1060 <atan2@plt>
movsd 0x8(%rsp),%xmm2
mov %r12,%rax
unpcklpd %xmm0,%xmm2
movsd 0xe26(%rip),%xmm0
movups %xmm2,(%r12)
movsd %xmm0,0x10(%r12)
movsd 0xe1a(%rip),%xmm0
movsd %xmm0,0x18(%r12)
add $0x20,%rsp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
pxor xmm2, xmm2
push rbx
mov rbx, rdi
mulsd xmm2, xmm1
sub rsp, 20h
movsd [rsp+28h+y], xmm1
addsd xmm2, xmm0
movapd xmm0, xmm2
movsd [rsp+28h+x], xmm2
call _cabs
movsd xmm2, [rsp+28h+x]
movsd xmm4, [rsp+28h+y]
movsd [rsp+28h+var_20], xmm0
movapd xmm1, xmm2; x
movapd xmm0, xmm4; y
call _atan2
movsd xmm3, [rsp+28h+var_20]
mov rax, rbx
movapd xmm1, xmm0
movapd xmm0, xmm3
unpcklpd xmm0, xmm1
movups xmmword ptr [rbx], xmm0
movapd xmm0, cs:xmmword_2010
movups xmmword ptr [rbx+10h], xmm0
add rsp, 20h
pop rbx
retn | long long func0(long long a1, double a2, double a3)
{
__m128d v3; // xmm0
long long result; // rax
double v5; // [rsp+0h] [rbp-20h]
double x; // [rsp+10h] [rbp-10h]
x = 0.0 * a3 + a2;
v5 = cabs(x);
v3 = (__m128d)*(unsigned long long *)&a3;
v3.m128d_f64[0] = atan2(a3, x);
result = a1;
*(__m128d *)a1 = _mm_unpacklo_pd((__m128d)*(unsigned long long *)&v5, v3);
*(_OWORD *)(a1 + 16) = xmmword_2010;
return result;
} | func0:
ENDBR64
PXOR XMM2,XMM2
PUSH RBX
MOV RBX,RDI
MULSD XMM2,XMM1
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x10],XMM1
ADDSD XMM2,XMM0
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x18],XMM2
CALL 0x00101070
MOVSD XMM2,qword ptr [RSP + 0x18]
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM1,XMM2
MOVAPD XMM0,XMM4
CALL 0x00101060
MOVSD XMM3,qword ptr [RSP + 0x8]
MOV RAX,RBX
MOVAPD XMM1,XMM0
MOVAPD XMM0,XMM3
UNPCKLPD XMM0,XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOVAPD XMM0,xmmword ptr [0x00102010]
MOVUPS xmmword ptr [RBX + 0x10],XMM0
ADD RSP,0x20
POP RBX
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
param_1 = param_2 * 0.0 + param_1;
dVar1 = cabs(param_1);
dVar2 = atan2(param_2,param_1);
*param_3 = dVar1;
param_3[1] = dVar2;
dVar1 = _UNK_00102018;
param_3[2] = _DAT_00102010;
param_3[3] = dVar1;
return param_3;
} |
6,256 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] == 56 && result1[4] == 12);
assert(result2[0] == 3 && result2[1] == 2 && result2[2] == 1);
assert(result3[0] == 6 && result3[1] == 5 && result3[2] == 4);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_18]
mov [rax], edx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
mov rax, [rbp+var_18]
pop rbp
retn | int * func0(int *a1, int a2)
{
int v3; // [rsp+18h] [rbp-4h]
v3 = *a1;
*a1 = a1[a2 - 1];
a1[a2 - 1] = v3;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,257 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] == 56 && result1[4] == 12);
assert(result2[0] == 3 && result2[1] == 2 && result2[2] == 1);
assert(result3[0] == 6 && result3[1] == 5 && result3[2] == 4);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
mov (%rdi),%ecx
movslq %esi,%rsi
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
| func0:
endbr64
mov rax, rdi
mov ecx, [rdi]
movsxd rsi, esi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *result; // rax
int v3; // ecx
_DWORD *v4; // rdx
result = a1;
v3 = *a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v3;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV ECX,dword ptr [RDI]
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,258 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] == 56 && result1[4] == 12);
assert(result2[0] == 3 && result2[1] == 2 && result2[2] == 1);
assert(result3[0] == 6 && result3[1] == 5 && result3[2] == 4);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi),%ecx
mov %rdi,%rax
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
mov ecx, [rdi]
mov rax, rdi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // ecx
_DWORD *result; // rax
_DWORD *v4; // rdx
v2 = *a1;
result = a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v2;
return result;
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV ECX,dword ptr [RDI]
MOV RAX,RDI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,259 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] == 56 && result1[4] == 12);
assert(result2[0] == 3 && result2[1] == 2 && result2[2] == 1);
assert(result3[0] == 6 && result3[1] == 5 && result3[2] == 4);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi),%ecx
mov %rdi,%rax
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
mov ecx, [rdi]
mov rax, rdi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // ecx
_DWORD *result; // rax
_DWORD *v4; // rdx
v2 = *a1;
result = a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v2;
return result;
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV ECX,dword ptr [RDI]
MOV RAX,RDI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,260 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k];
}
| int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x44(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x2c(%rbp)
shll -0x44(%rbp)
mov -0x2c(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1213 <func0+0xaa>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11fc <func0+0x93>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 123d <func0+0xd4>
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,-0x20(%rbp)
movl $0x0,-0x30(%rbp)
jmp 126e <func0+0x105>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x30(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x30(%rbp),%eax
jge 1259 <func0+0xf0>
mov -0x20(%rbp),%rax
movl $0x1,(%rax)
movl $0x1,-0x34(%rbp)
jmp 12d2 <func0+0x169>
mov -0x34(%rbp),%eax
cmp %eax,-0x2c(%rbp)
cmovle -0x2c(%rbp),%eax
mov %eax,-0x38(%rbp)
jmp 12c8 <func0+0x15f>
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x38(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %eax,%ecx
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
subl $0x1,-0x38(%rbp)
cmpl $0x0,-0x38(%rbp)
jg 1298 <func0+0x12f>
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 1289 <func0+0x120>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 12fe <func0+0x195>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
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 rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
sub eax, 1
mov [rbp+var_1C], eax
shl [rbp+var_34], 1
mov eax, [rbp+var_1C]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
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_11E1:
cmp rsp, rdx
jz short loc_11F8
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11E1
loc_11F8:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1222
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1222:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_28], 0
jmp short loc_1253
loc_123E:
mov rax, [rbp+var_10]
mov edx, [rbp+var_28]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 0
add [rbp+var_28], 1
loc_1253:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_28]
jge short loc_123E
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov [rbp+var_24], 1
jmp short loc_12B8
loc_126E:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_24]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_20], eax
jmp short loc_12AE
loc_127E:
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_20]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add ecx, eax
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov [rax+rdx*4], ecx
sub [rbp+var_20], 1
loc_12AE:
cmp [rbp+var_20], 0
jg short loc_127E
add [rbp+var_24], 1
loc_12B8:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_34]
jle short loc_126E
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12E4
call ___stack_chk_fail
locret_12E4:
leave
retn | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
int v3; // eax
_BYTE v5[12]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+14h] [rbp-34h]
int i; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
int k; // [rsp+28h] [rbp-20h]
int v10; // [rsp+2Ch] [rbp-1Ch]
long long v11; // [rsp+30h] [rbp-18h]
_DWORD *v12; // [rsp+38h] [rbp-10h]
unsigned long long v13; // [rsp+40h] [rbp-8h]
v13 = __readfsqword(0x28u);
v10 = a1 - 1;
v6 = 2 * a1;
v11 = a1 - 1LL;
v1 = 16 * ((4LL * a1 + 15) / 0x10uLL);
while ( v5 != &v5[-(v1 & 0xFFFFFFFFFFFFF000LL)] )
;
v2 = alloca(v1 & 0xFFF);
if ( (v1 & 0xFFF) != 0 )
*(_QWORD *)&v5[(v1 & 0xFFF) - 8] = *(_QWORD *)&v5[(v1 & 0xFFF) - 8];
v12 = v5;
for ( i = 0; v10 >= i; ++i )
v12[i] = 0;
*v12 = 1;
for ( j = 1; j <= v6; ++j )
{
v3 = j;
if ( v10 <= j )
v3 = v10;
for ( k = v3; k > 0; --k )
v12[k] += v12[k - 1];
}
return (unsigned int)v12[v10];
} | 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 RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
SHL dword ptr [RBP + -0x34],0x1
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
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_001011e1:
CMP RSP,RDX
JZ 0x001011f8
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e1
LAB_001011f8:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101222
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101222:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101253
LAB_0010123e:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x0
ADD dword ptr [RBP + -0x28],0x1
LAB_00101253:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x28]
JGE 0x0010123e
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001012b8
LAB_0010126e:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x24]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001012ae
LAB_0010127e:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x20]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
SUB dword ptr [RBP + -0x20],0x1
LAB_001012ae:
CMP dword ptr [RBP + -0x20],0x0
JG 0x0010127e
ADD dword ptr [RBP + -0x24],0x1
LAB_001012b8:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x0010126e
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012e4
CALL 0x00101060
LAB_001012e4:
LEAVE
RET | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [12];
int local_3c;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_24 = param_1 + -1;
local_3c = param_1 << 1;
local_20 = (long)param_1 + -1;
uVar2 = (((long)param_1 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_30 = 0; local_30 <= local_24; local_30 = local_30 + 1) {
*(int4 *)(puVar3 + (long)local_30 * 4 + lVar1) = 0;
}
*(int4 *)(puVar3 + lVar1) = 1;
for (local_2c = 1; local_2c <= local_3c; local_2c = local_2c + 1) {
local_28 = local_2c;
if (local_24 <= local_2c) {
local_28 = local_24;
}
for (; 0 < local_28; local_28 = local_28 + -1) {
*(int *)(puVar3 + (long)local_28 * 4 + lVar1) =
*(int *)(puVar3 + (long)local_28 * 4 + lVar1) +
*(int *)(puVar3 + (long)(local_28 + -1) * 4 + lVar1);
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar3 + (long)local_24 * 4 + lVar1);
}
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,261 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k];
}
| int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x1(%rdi),%r8d
lea (%rdi,%rdi,1),%ecx
movslq %edi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 11c3 <func0+0x5a>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ac <func0+0x43>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d9 <func0+0x70>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r10
mov %r10,%rsi
shr $0x2,%rsi
and $0xfffffffffffffffc,%r10
mov %r10,%r9
test %r8d,%r8d
js 120b <func0+0xa2>
mov %r10,%rax
lea -0x1(%rdi),%edx
lea 0x4(%r10,%rdx,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 11fc <func0+0x93>
movl $0x1,0x0(,%rsi,4)
test %ecx,%ecx
jle 1264 <func0+0xfb>
lea 0x1(%rcx),%edi
mov $0x1,%esi
lea -0x4(%r9),%r11
jmp 122f <func0+0xc6>
add $0x1,%esi
cmp %edi,%esi
je 1264 <func0+0xfb>
cmp %esi,%r8d
mov %esi,%edx
cmovle %r8d,%edx
test %edx,%edx
jle 1228 <func0+0xbf>
movslq %edx,%rcx
shl $0x2,%rcx
lea (%r9,%rcx,1),%rax
add %r11,%rcx
lea -0x1(%rdx),%edx
shl $0x2,%rdx
sub %rdx,%rcx
mov -0x4(%rax),%edx
add %edx,(%rax)
sub $0x4,%rax
cmp %rcx,%rax
jne 1254 <func0+0xeb>
jmp 1228 <func0+0xbf>
movslq %r8d,%r8
mov (%r10,%r8,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 127c <func0+0x113>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov edx, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea edi, [rdi-1]
lea r9d, [rdx+rdx]
movsxd rax, edx
lea rax, ds:0Fh[rax*4]
mov rsi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rax
loc_11AB:
cmp rsp, rcx
jz short loc_11C2
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11AB
loc_11C2:
mov rax, rsi
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D8
or [rsp+rax+10h+var_18], 0
loc_11D8:
lea r8, [rsp+10h+var_D]
mov rcx, r8
shr rcx, 2
and r8, 0FFFFFFFFFFFFFFFCh
test edi, edi
js short loc_1206
mov rax, r8
lea edx, [rdx-1]
lea rdx, [r8+rdx*4+4]
loc_11F7:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_11F7
loc_1206:
mov ds:dword_0[rcx*4], 1
test r9d, r9d
jle short loc_125C
add r9d, 1
mov esi, 1
lea r10, [r8-4]
loc_1223:
cmp edi, esi
mov edx, esi
cmovle edx, edi
test edx, edx
jle short loc_1254
movsxd rcx, edx
shl rcx, 2
lea rax, [r8+rcx]
add rcx, r10
lea edx, [rdx-1]
shl rdx, 2
sub rcx, rdx
loc_1246:
mov edx, [rax-4]
add [rax], edx
sub rax, 4
cmp rax, rcx
jnz short loc_1246
loc_1254:
add esi, 1
cmp esi, r9d
jnz short loc_1223
loc_125C:
movsxd rdi, edi
mov eax, [r8+rdi*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1274
leave
retn
loc_1274:
call ___stack_chk_fail | long long func0(int a1)
{
int v2; // edi
int v3; // r9d
signed long long v4; // rax
void *v5; // rsp
_DWORD *v6; // rax
_DWORD *v7; // rdx
int v8; // r9d
int v9; // esi
int v10; // edx
long long v11; // rcx
_DWORD *v12; // rax
_DWORD *v13; // rcx
_DWORD v16[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v17; // [rsp+10h] [rbp-8h]
v17 = __readfsqword(0x28u);
v2 = a1 - 1;
v3 = 2 * a1;
while ( v16 != (_DWORD *)((char *)v16 - ((4LL * a1 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = (4 * (_WORD)a1 + 15) & 0xFF0;
v5 = alloca(v4);
if ( ((4 * (_WORD)a1 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v16[-2] + v4) = *(_QWORD *)((char *)&v16[-2] + v4);
if ( v2 >= 0 )
{
v6 = v16;
v7 = &v16[a1 - 1 + 1];
do
*v6++ = 0;
while ( v6 != v7 );
}
v16[0] = 1;
if ( v3 > 0 )
{
v8 = v3 + 1;
v9 = 1;
do
{
v10 = v9;
if ( v2 <= v9 )
v10 = v2;
if ( v10 > 0 )
{
v11 = v10;
v12 = &v16[v11];
v13 = &v16[v11 - 1 - (unsigned int)(v10 - 1)];
do
{
*v12 += *(v12 - 1);
--v12;
}
while ( v12 != v13 );
}
++v9;
}
while ( v9 != v8 );
}
return (unsigned int)v16[v2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EDI,[RDI + -0x1]
LEA R9D,[RDX + RDX*0x1]
MOVSXD RAX,EDX
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
AND RSI,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001011ab:
CMP RSP,RCX
JZ 0x001011c2
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ab
LAB_001011c2:
MOV RAX,RSI
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d8
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d8:
LEA R8,[RSP + 0x3]
MOV RCX,R8
SHR RCX,0x2
AND R8,-0x4
TEST EDI,EDI
JS 0x00101206
MOV RAX,R8
LEA EDX,[RDX + -0x1]
LEA RDX,[R8 + RDX*0x4 + 0x4]
LAB_001011f7:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011f7
LAB_00101206:
MOV dword ptr [RCX*0x4],0x1
TEST R9D,R9D
JLE 0x0010125c
ADD R9D,0x1
MOV ESI,0x1
LEA R10,[R8 + -0x4]
LAB_00101223:
CMP EDI,ESI
MOV EDX,ESI
CMOVLE EDX,EDI
TEST EDX,EDX
JLE 0x00101254
MOVSXD RCX,EDX
SHL RCX,0x2
LEA RAX,[R8 + RCX*0x1]
ADD RCX,R10
LEA EDX,[RDX + -0x1]
SHL RDX,0x2
SUB RCX,RDX
LAB_00101246:
MOV EDX,dword ptr [RAX + -0x4]
ADD dword ptr [RAX],EDX
SUB RAX,0x4
CMP RAX,RCX
JNZ 0x00101246
LAB_00101254:
ADD ESI,0x1
CMP ESI,R9D
JNZ 0x00101223
LAB_0010125c:
MOVSXD RDI,EDI
MOV EAX,dword ptr [R8 + RDI*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101274
LEAVE
RET
LAB_00101274:
CALL 0x00101060 | int4 func0(int param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
int4 *puVar4;
int *piVar5;
int iVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = param_1 + -1;
uVar3 = (long)param_1 * 4 + 0xf;
for (puVar7 = auStack_18; puVar7 != auStack_18 + -(uVar3 & 0xfffffffffffff000);
puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar2 = -uVar3;
puVar4 = (int4 *)(puVar7 + lVar2);
if (uVar3 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < iVar1) {
do {
*puVar4 = 0;
puVar4 = puVar4 + 1;
} while (puVar4 != (int4 *)(puVar7 + (ulong)(param_1 - 1) * 4 + lVar2 + 4));
}
*(int4 *)(puVar7 + lVar2) = 1;
if (0 < param_1 * 2) {
iVar8 = 1;
do {
iVar6 = iVar8;
if (iVar1 <= iVar8) {
iVar6 = iVar1;
}
if (0 < iVar6) {
piVar5 = (int *)(puVar7 + (long)iVar6 * 4 + lVar2);
do {
*piVar5 = *piVar5 + piVar5[-1];
piVar5 = piVar5 + -1;
} while (piVar5 != (int *)(puVar7 + (ulong)(iVar6 - 1) * -4 + (long)iVar6 * 4 + lVar2 + -4))
;
}
iVar8 = iVar8 + 1;
} while (iVar8 != param_1 * 2 + 1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar7 + (long)iVar1 * 4 + lVar2);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar2 + -8) = main;
__stack_chk_fail();
} |
6,262 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k];
}
| int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
lea -0x1(%rdi),%r8d
lea (%rdi,%rdi,1),%r9d
movslq %edi,%rdi
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xf(,%rdi,4),%rax
mov %rsp,%rdi
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 126e <func0+0x5e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1259 <func0+0x49>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1326 <func0+0x116>
lea 0x3(%rsp),%rdi
mov %rdi,%rcx
and $0xfffffffffffffffc,%rdi
shr $0x2,%rcx
test %r8d,%r8d
js 12af <func0+0x9f>
mov %r8d,%edx
mov %rdi,%rax
lea 0x4(%rdi,%rdx,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 12a0 <func0+0x90>
movl $0x1,0x0(,%rcx,4)
test %r9d,%r9d
jle 130e <func0+0xfe>
add $0x1,%r9d
mov $0x1,%esi
lea -0x4(%rdi),%r10
nopl 0x0(%rax)
cmp %esi,%r8d
mov %esi,%edx
cmovle %r8d,%edx
test %edx,%edx
jle 1306 <func0+0xf6>
movslq %edx,%rcx
sub $0x1,%edx
shl $0x2,%rcx
shl $0x2,%rdx
lea (%rdi,%rcx,1),%rax
add %r10,%rcx
sub %rdx,%rcx
nopl (%rax)
mov -0x4(%rax),%edx
add %edx,(%rax)
sub $0x4,%rax
cmp %rcx,%rax
jne 12f8 <func0+0xe8>
add $0x1,%esi
cmp %r9d,%esi
jne 12d0 <func0+0xc0>
movslq %r8d,%r8
mov (%rdi,%r8,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 1331 <func0+0x121>
leaveq
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1280 <func0+0x70>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
lea r12d, [rdi+rdi]
push rbx
lea ebx, [rdi-1]
movsxd rdi, edi
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea rax, ds:0Fh[rdi*4]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_128F
loc_127A:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_127A
loc_128F:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_134E
loc_12A1:
lea rdi, [rsp+1030h+var_102D]
mov r13, rdi
and rdi, 0FFFFFFFFFFFFFFFCh
shr r13, 2
test ebx, ebx
js short loc_12C9
mov eax, ebx
xor esi, esi
lea rdx, ds:4[rax*4]
call _memset
mov rdi, rax
loc_12C9:
mov ds:dword_0[r13*4], 1
test r12d, r12d
jle short loc_132E
lea r8d, [r12+1]
mov esi, 1
lea r9, [rdi-4]
nop dword ptr [rax+rax+00000000h]
loc_12F0:
cmp ebx, esi
mov edx, esi
cmovle edx, ebx
test edx, edx
jle short loc_1326
movsxd rcx, edx
sub edx, 1
shl rcx, 2
shl rdx, 2
lea rax, [rdi+rcx]
add rcx, r9
sub rcx, rdx
nop dword ptr [rax+rax+00h]
loc_1318:
mov edx, [rax-4]
add [rax], edx
sub rax, 4
cmp rax, rcx
jnz short loc_1318
loc_1326:
add esi, 1
cmp esi, r8d
jnz short loc_12F0
loc_132E:
movsxd rbx, ebx
mov eax, [rdi+rbx*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_1359
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_134E:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_12A1
loc_1359:
call ___stack_chk_fail | long long func0(int a1)
{
int v1; // r12d
int v2; // ebx
long long v3; // rdx
_DWORD *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
_DWORD *v8; // rdi
int v9; // esi
int v10; // edx
long long v11; // rcx
_DWORD *v12; // rax
long long v13; // rcx
_DWORD v16[1022]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v17[6]; // [rsp+1008h] [rbp-30h] BYREF
v1 = 2 * a1;
v2 = a1 - 1;
v17[1] = __readfsqword(0x28u);
v3 = 4LL * a1 + 15;
v4 = (_DWORD *)((char *)v17 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( v17 != (_QWORD *)v4 )
{
while ( v16 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(_QWORD *)((char *)&v16[-2] + v6) = *(_QWORD *)((char *)&v16[-2] + v6);
v8 = v16;
if ( v2 >= 0 )
v8 = (_DWORD *)memset(v16, 0LL, 4LL * (unsigned int)v2 + 4);
v16[0] = 1;
if ( v1 > 0 )
{
v9 = 1;
do
{
v10 = v9;
if ( v2 <= v9 )
v10 = v2;
if ( v10 > 0 )
{
v11 = v10;
v12 = &v8[v11];
v13 = (long long)&v8[v11 - 1 - (unsigned int)(v10 - 1)];
do
{
*v12 += *(v12 - 1);
--v12;
}
while ( v12 != (_DWORD *)v13 );
}
++v9;
}
while ( v9 != v1 + 1 );
}
return (unsigned int)v8[v2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
LEA R12D,[RDI + RDI*0x1]
PUSH RBX
LEA EBX,[RDI + -0x1]
MOVSXD RDI,EDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[0xf + RDI*0x4]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010128f
LAB_0010127a:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010127a
LAB_0010128f:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010134e
LAB_001012a1:
LEA RDI,[RSP + 0x3]
MOV R13,RDI
AND RDI,-0x4
SHR R13,0x2
TEST EBX,EBX
JS 0x001012c9
MOV EAX,EBX
XOR ESI,ESI
LEA RDX,[0x4 + RAX*0x4]
CALL 0x00101090
MOV RDI,RAX
LAB_001012c9:
MOV dword ptr [R13*0x4],0x1
TEST R12D,R12D
JLE 0x0010132e
LEA R8D,[R12 + 0x1]
MOV ESI,0x1
LEA R9,[RDI + -0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012f0:
CMP EBX,ESI
MOV EDX,ESI
CMOVLE EDX,EBX
TEST EDX,EDX
JLE 0x00101326
MOVSXD RCX,EDX
SUB EDX,0x1
SHL RCX,0x2
SHL RDX,0x2
LEA RAX,[RDI + RCX*0x1]
ADD RCX,R9
SUB RCX,RDX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101318:
MOV EDX,dword ptr [RAX + -0x4]
ADD dword ptr [RAX],EDX
SUB RAX,0x4
CMP RAX,RCX
JNZ 0x00101318
LAB_00101326:
ADD ESI,0x1
CMP ESI,R8D
JNZ 0x001012f0
LAB_0010132e:
MOVSXD RBX,EBX
MOV EAX,dword ptr [RDI + RBX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101359
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_0010134e:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012a1
LAB_00101359:
CALL 0x00101070 | int4 func0(int param_1)
{
uint uVar1;
long lVar2;
int1 *puVar3;
int *piVar4;
uint uVar5;
ulong uVar6;
int1 *puVar7;
uint uVar9;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar8;
uVar1 = param_1 - 1;
puVar7 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)param_1 * 4 + 0xf;
puVar8 = auStack_38;
puVar3 = auStack_38;
while (puVar8 != auStack_38 + -(uVar6 & 0xfffffffffffff000)) {
puVar7 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar8 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar2 = -uVar6;
puVar3 = puVar7 + lVar2;
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < (int)uVar1) {
*(int8 *)(puVar7 + lVar2 + -8) = 0x1012c6;
puVar3 = (int1 *)memset(puVar7 + lVar2,0,(ulong)uVar1 * 4 + 4);
}
*(int4 *)(puVar7 + lVar2) = 1;
if (0 < param_1 * 2) {
uVar9 = 1;
do {
uVar5 = uVar9;
if ((int)uVar1 <= (int)uVar9) {
uVar5 = uVar1;
}
if (0 < (int)uVar5) {
piVar4 = (int *)(puVar3 + (long)(int)uVar5 * 4);
do {
*piVar4 = *piVar4 + piVar4[-1];
piVar4 = piVar4 + -1;
} while (piVar4 != (int *)(puVar3 + (ulong)(uVar5 - 1) * -4 + (long)(int)uVar5 * 4 + -4));
}
uVar9 = uVar9 + 1;
} while (uVar9 != param_1 * 2 + 1U);
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar2 + -8) = 0x10135e;
__stack_chk_fail();
}
return *(int4 *)(puVar3 + (long)(int)uVar1 * 4);
} |
6,263 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k];
}
| int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
lea (%rdi,%rdi,1),%r12d
push %rbx
lea -0x1(%rdi),%ebx
movslq %edi,%rdi
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea 0xf(,%rdi,4),%rax
mov %rsp,%rdi
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 1292 <func0+0x62>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 127d <func0+0x4d>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13b8 <func0+0x188>
lea 0x3(%rsp),%r9
mov %r9,%r13
and $0xfffffffffffffffc,%r9
shr $0x2,%r13
test %ebx,%ebx
js 12cf <func0+0x9f>
mov %ebx,%eax
mov %r9,%rdi
xor %esi,%esi
lea 0x4(,%rax,4),%rdx
callq 1090 <memset@plt>
mov %rax,%r9
movl $0x1,0x0(,%r13,4)
test %r12d,%r12d
jle 1397 <func0+0x167>
lea 0x1(%r12),%r10d
mov $0x1,%r8d
cmp %r8d,%ebx
mov %r8d,%esi
cmovle %ebx,%esi
test %esi,%esi
jle 138a <func0+0x15a>
mov %esi,%r11d
cmp $0x3,%esi
jle 1366 <func0+0x136>
mov %esi,%edx
movslq %esi,%rax
shr $0x2,%edx
shl $0x2,%rax
neg %rdx
lea -0xc(%r9,%rax,1),%rcx
lea -0x10(%r9,%rax,1),%rdi
xor %eax,%eax
shl $0x4,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rcx,%rax,1),%xmm2
movdqu (%rdi,%rax,1),%xmm3
pshufd $0x1b,%xmm2,%xmm0
pshufd $0x1b,%xmm3,%xmm1
paddd %xmm1,%xmm0
pshufd $0x1b,%xmm0,%xmm0
movups %xmm0,(%rcx,%rax,1)
sub $0x10,%rax
cmp %rdx,%rax
jne 1330 <func0+0x100>
mov %esi,%eax
and $0xfffffffc,%eax
sub %eax,%esi
cmp %eax,%r11d
je 138a <func0+0x15a>
movslq %esi,%rax
lea (%r9,%rax,4),%rax
mov -0x4(%rax),%edx
add %edx,(%rax)
cmp $0x1,%esi
je 138a <func0+0x15a>
mov -0x8(%rax),%ecx
add %ecx,%edx
mov %edx,-0x4(%rax)
cmp $0x2,%esi
je 138a <func0+0x15a>
add -0xc(%rax),%ecx
mov %ecx,-0x8(%rax)
add $0x1,%r8d
cmp %r10d,%r8d
jne 12f0 <func0+0xc0>
movslq %ebx,%rbx
mov (%r9,%rbx,4),%eax
mov -0x28(%rbp),%rbx
xor %fs:0x28,%rbx
jne 13c3 <func0+0x193>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12a4 <func0+0x74>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
mov r12d, edi
push rbx
lea ebx, [rdi-1]
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, edi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_128E
loc_1279:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_1279
loc_128E:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13C7
loc_12A0:
lea rdi, [rsp+1030h+var_102D]
mov r13, rdi
and rdi, 0FFFFFFFFFFFFFFFCh; s
shr r13, 2
test ebx, ebx
js loc_13D2
mov edx, r12d
xor esi, esi; c
shl rdx, 2; n
call _memset
lea r8d, [r12+r12+1]
mov esi, 1
mov ds:dword_0[r13*4], 1
mov rdi, rax
nop
loc_12E0:
cmp ebx, esi
mov edx, esi
cmovle edx, ebx
test edx, edx
jz loc_1395
cmp edx, 3
jle loc_13C1
mov ecx, edx
movsxd rax, edx
shr ecx, 2
shl rax, 2
neg rcx
lea r9, [rdi+rax-0Ch]
lea r10, [rdi+rax-10h]
xor eax, eax
shl rcx, 4
nop word ptr [rax+rax+00000000h]
loc_1320:
movdqu xmm0, xmmword ptr [r9+rax]
movdqu xmm2, xmmword ptr [r10+rax]
paddd xmm0, xmm2
movups xmmword ptr [r9+rax], xmm0
sub rax, 10h
cmp rcx, rax
jnz short loc_1320
mov ecx, edx
and ecx, 0FFFFFFFCh
test dl, 3
jz short loc_1395
mov eax, edx
sub eax, ecx
loc_134C:
mov r9d, edx
sub r9d, ecx
cmp r9d, 1
jz short loc_138A
movsxd rdx, edx
sub rdx, rcx
lea rcx, ds:0[rdx*4]
lea rdx, [rdi+rcx-4]
movq xmm0, qword ptr [rdi+rcx-8]
movq xmm1, qword ptr [rdx]
paddd xmm0, xmm1
movq qword ptr [rdx], xmm0
test r9b, 1
jz short loc_1395
and r9d, 0FFFFFFFEh
sub eax, r9d
loc_138A:
cdqe
lea rax, [rdi+rax*4]
mov edx, [rax-4]
add [rax], edx
loc_1395:
add esi, 1
cmp esi, r8d
jnz loc_12E0
loc_13A1:
movsxd rbx, ebx
mov eax, [rdi+rbx*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_13E0
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_13C1:
mov eax, edx
xor ecx, ecx
jmp short loc_134C
loc_13C7:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_12A0
loc_13D2:
mov ds:dword_0[r13*4], 1
jmp short loc_13A1
loc_13E0:
call ___stack_chk_fail | long long func0(unsigned int a1)
{
int v2; // ebx
long long v3; // rdx
_DWORD *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
_DWORD *v8; // rdi
_DWORD *v9; // rax
int v10; // esi
int v11; // edx
long long v12; // rax
long long v13; // r9
long long v14; // r10
long long v15; // rax
long long v16; // rcx
int v17; // eax
int v18; // r9d
_DWORD v21[1022]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v22[6]; // [rsp+1008h] [rbp-30h] BYREF
v2 = a1 - 1;
v22[1] = __readfsqword(0x28u);
v3 = 4LL * (int)a1 + 15;
v4 = (_DWORD *)((char *)v22 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( v22 != (_QWORD *)v4 )
{
while ( v21 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(_QWORD *)((char *)&v21[-2] + v6) = *(_QWORD *)((char *)&v21[-2] + v6);
v8 = v21;
if ( v2 >= 0 )
{
v9 = memset(v21, 0, 4LL * a1);
v10 = 1;
v21[0] = 1;
v8 = v9;
while ( 1 )
{
v11 = v10;
if ( v2 <= v10 )
v11 = v2;
if ( !v11 )
goto LABEL_19;
if ( v11 <= 3 )
{
v17 = v11;
v16 = 0LL;
}
else
{
v12 = v11;
v13 = (long long)&v8[v12 - 3];
v14 = (long long)&v8[v12 - 4];
v15 = 0LL;
do
{
*(__m128i *)(v13 + v15) = _mm_add_epi32(
_mm_loadu_si128((const __m128i *)(v13 + v15)),
_mm_loadu_si128((const __m128i *)(v14 + v15)));
v15 -= 16LL;
}
while ( -16LL * ((unsigned int)v11 >> 2) != v15 );
v16 = v11 & 0xFFFFFFFC;
if ( (v11 & 3) == 0 )
goto LABEL_19;
v17 = v11 - v16;
}
v18 = v11 - v16;
if ( v11 - (_DWORD)v16 == 1 )
goto LABEL_18;
*(_QWORD *)&v8[v11 - v16 - 1] = _mm_add_epi32(
_mm_loadl_epi64((const __m128i *)&v8[v11 - v16 - 2]),
_mm_loadl_epi64((const __m128i *)&v8[v11 - v16 - 1])).m128i_u64[0];
if ( (v18 & 1) != 0 )
break;
LABEL_19:
if ( ++v10 == 2 * a1 + 1 )
return (unsigned int)v8[v2];
}
v17 -= v18 & 0xFFFFFFFE;
LABEL_18:
v8[v17] += v8[v17 - 1];
goto LABEL_19;
}
v21[0] = 1;
return (unsigned int)v8[v2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBX
LEA EBX,[RDI + -0x1]
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010128e
LAB_00101279:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101279
LAB_0010128e:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013c7
LAB_001012a0:
LEA RDI,[RSP + 0x3]
MOV R13,RDI
AND RDI,-0x4
SHR R13,0x2
TEST EBX,EBX
JS 0x001013d2
MOV EDX,R12D
XOR ESI,ESI
SHL RDX,0x2
CALL 0x00101090
LEA R8D,[R12 + R12*0x1 + 0x1]
MOV ESI,0x1
MOV dword ptr [R13*0x4],0x1
MOV RDI,RAX
NOP
LAB_001012e0:
CMP EBX,ESI
MOV EDX,ESI
CMOVLE EDX,EBX
TEST EDX,EDX
JZ 0x00101395
CMP EDX,0x3
JLE 0x001013c1
MOV ECX,EDX
MOVSXD RAX,EDX
SHR ECX,0x2
SHL RAX,0x2
NEG RCX
LEA R9,[RDI + RAX*0x1 + -0xc]
LEA R10,[RDI + RAX*0x1 + -0x10]
XOR EAX,EAX
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101320:
MOVDQU XMM0,xmmword ptr [R9 + RAX*0x1]
MOVDQU XMM2,xmmword ptr [R10 + RAX*0x1]
PADDD XMM0,XMM2
MOVUPS xmmword ptr [R9 + RAX*0x1],XMM0
SUB RAX,0x10
CMP RCX,RAX
JNZ 0x00101320
MOV ECX,EDX
AND ECX,0xfffffffc
TEST DL,0x3
JZ 0x00101395
MOV EAX,EDX
SUB EAX,ECX
LAB_0010134c:
MOV R9D,EDX
SUB R9D,ECX
CMP R9D,0x1
JZ 0x0010138a
MOVSXD RDX,EDX
SUB RDX,RCX
LEA RCX,[RDX*0x4]
LEA RDX,[RDI + RCX*0x1 + -0x4]
MOVQ XMM0,qword ptr [RDI + RCX*0x1 + -0x8]
MOVQ XMM1,qword ptr [RDX]
PADDD XMM0,XMM1
MOVQ qword ptr [RDX],XMM0
TEST R9B,0x1
JZ 0x00101395
AND R9D,0xfffffffe
SUB EAX,R9D
LAB_0010138a:
CDQE
LEA RAX,[RDI + RAX*0x4]
MOV EDX,dword ptr [RAX + -0x4]
ADD dword ptr [RAX],EDX
LAB_00101395:
ADD ESI,0x1
CMP ESI,R8D
JNZ 0x001012e0
LAB_001013a1:
MOVSXD RBX,EBX
MOV EAX,dword ptr [RDI + RBX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013e0
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_001013c1:
MOV EAX,EDX
XOR ECX,ECX
JMP 0x0010134c
LAB_001013c7:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012a0
LAB_001013d2:
MOV dword ptr [R13*0x4],0x1
JMP 0x001013a1
LAB_001013e0:
CALL 0x00101070 | int4 func0(uint param_1)
{
uint uVar1;
int *piVar2;
int *piVar3;
int *piVar4;
long lVar5;
int8 uVar6;
long lVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
uint uVar14;
int *puVar15;
long lVar16;
ulong uVar17;
uint uVar18;
int *puVar19;
uint uVar21;
uint uVar22;
long in_FS_OFFSET;
int auStack_38 [8];
long local_30;
int *puVar20;
uVar1 = param_1 - 1;
puVar19 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar17 = (long)(int)param_1 * 4 + 0xf;
puVar20 = auStack_38;
puVar15 = auStack_38;
while (puVar20 != auStack_38 + -(uVar17 & 0xfffffffffffff000)) {
puVar19 = puVar15 + -0x1000;
*(int8 *)(puVar15 + -8) = *(int8 *)(puVar15 + -8);
puVar20 = puVar15 + -0x1000;
puVar15 = puVar15 + -0x1000;
}
uVar17 = (ulong)((uint)uVar17 & 0xff0);
lVar7 = -uVar17;
puVar15 = puVar19 + lVar7;
if (uVar17 != 0) {
*(int8 *)(puVar19 + -8) = *(int8 *)(puVar19 + -8);
}
if ((int)uVar1 < 0) {
*(int4 *)(((ulong)(puVar19 + lVar7 + 3) >> 2) * 4) = 1;
}
else {
*(int8 *)(puVar19 + lVar7 + -8) = 0x1012c6;
puVar15 = (int *)memset(puVar19 + lVar7,0,(ulong)param_1 << 2);
uVar21 = 1;
*(int4 *)(((ulong)(puVar19 + lVar7 + 3) >> 2) * 4) = 1;
do {
uVar18 = uVar21;
if ((int)uVar1 <= (int)uVar21) {
uVar18 = uVar1;
}
if (uVar18 != 0) {
if ((int)uVar18 < 4) {
uVar17 = 0;
uVar14 = uVar18;
}
else {
lVar5 = (long)(int)uVar18 * 4 + -0xc;
lVar16 = 0;
do {
piVar2 = (int *)(puVar15 + lVar16 + lVar5);
iVar8 = piVar2[1];
iVar9 = piVar2[2];
iVar10 = piVar2[3];
piVar3 = (int *)(puVar15 + lVar16 + (long)(int)uVar18 * 4 + -0x10);
iVar11 = piVar3[1];
iVar12 = piVar3[2];
iVar13 = piVar3[3];
piVar4 = (int *)(puVar15 + lVar16 + lVar5);
*piVar4 = *piVar2 + *piVar3;
piVar4[1] = iVar8 + iVar11;
piVar4[2] = iVar9 + iVar12;
piVar4[3] = iVar10 + iVar13;
lVar16 = lVar16 + -0x10;
} while ((ulong)(uVar18 >> 2) * -0x10 != lVar16);
uVar17 = (ulong)(uVar18 & 0xfffffffc);
if ((uVar18 & 3) == 0) goto LAB_00101395;
uVar14 = uVar18 - (uVar18 & 0xfffffffc);
}
uVar22 = uVar18 - (int)uVar17;
if (uVar22 != 1) {
lVar5 = ((long)(int)uVar18 - uVar17) * 4;
uVar6 = *(int8 *)(puVar15 + lVar5 + -4);
*(ulong *)(puVar15 + lVar5 + -4) =
CONCAT44((int)((ulong)*(int8 *)(puVar15 + lVar5 + -8) >> 0x20) +
(int)((ulong)uVar6 >> 0x20),
(int)*(int8 *)(puVar15 + lVar5 + -8) + (int)uVar6);
if ((uVar22 & 1) == 0) goto LAB_00101395;
uVar14 = uVar14 - (uVar22 & 0xfffffffe);
}
piVar2 = (int *)(puVar15 + (long)(int)uVar14 * 4);
*piVar2 = *piVar2 + piVar2[-1];
}
LAB_00101395:
uVar21 = uVar21 + 1;
} while (uVar21 != param_1 * 2 + 1);
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar19 + lVar7 + -8) = 0x1013e5;
__stack_chk_fail();
}
return *(int4 *)(puVar15 + (long)(int)uVar1 * 4);
} |
6,264 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current_location, 1, matches, 0) == 0) {
size_t len = strlen(current_location);
size_t start = matches[0].rm_so;
size_t end = matches[0].rm_eo;
memmove(current_location + start + 1, current_location + end, len - end + 1);
current_location += start + 1;
}
regfree(®ex);
return result;
}
| int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(test3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
mov %rdi,-0x98(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x2b302e5c,-0xd(%rbp)
movb $0x0,-0x9(%rbp)
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 1120 <strlen@plt>
add $0x1,%rax
mov %rax,%rdi
callq 1170 <malloc@plt>
mov %rax,-0x80(%rbp)
lea -0xd(%rbp),%rcx
lea -0x60(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 1150 <regcomp@plt>
mov -0x98(%rbp),%rdx
mov -0x80(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1100 <strcpy@plt>
mov -0x80(%rbp),%rax
mov %rax,-0x88(%rbp)
jmp 137e <func0+0xf5>
mov -0x88(%rbp),%rax
mov %rax,%rdi
callq 1120 <strlen@plt>
mov %rax,-0x78(%rbp)
mov -0x18(%rbp),%eax
cltq
mov %rax,-0x70(%rbp)
mov -0x14(%rbp),%eax
cltq
mov %rax,-0x68(%rbp)
mov -0x78(%rbp),%rax
sub -0x68(%rbp),%rax
lea 0x1(%rax),%rdx
mov -0x88(%rbp),%rcx
mov -0x68(%rbp),%rax
add %rax,%rcx
mov -0x70(%rbp),%rax
lea 0x1(%rax),%rsi
mov -0x88(%rbp),%rax
add %rsi,%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1190 <memmove@plt>
mov -0x70(%rbp),%rax
add $0x1,%rax
add %rax,-0x88(%rbp)
lea -0x18(%rbp),%rdx
mov -0x88(%rbp),%rsi
lea -0x60(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 1180 <regexec@plt>
test %eax,%eax
je 1313 <func0+0x8a>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 1110 <regfree@plt>
mov -0x80(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 13cf <func0+0x146>
callq 1130 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov dword ptr [rbp+pattern], 2B302E5Ch
mov [rbp+var_9], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
lea rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+dest]
mov [rbp+string], rax
jmp short loc_137E
loc_1313:
mov rax, [rbp+string]
mov rdi, rax; s
call _strlen
mov [rbp+var_78], rax
mov eax, [rbp+pmatch.rm_so]
cdqe
mov [rbp+var_70], rax
mov eax, [rbp+pmatch.rm_eo]
cdqe
mov [rbp+var_68], rax
mov rax, [rbp+var_78]
sub rax, [rbp+var_68]
lea rdx, [rax+1]; n
mov rcx, [rbp+string]
mov rax, [rbp+var_68]
add rcx, rax
mov rax, [rbp+var_70]
lea rsi, [rax+1]
mov rax, [rbp+string]
add rax, rsi
mov rsi, rcx; src
mov rdi, rax; dest
call _memmove
mov rax, [rbp+var_70]
add rax, 1
add [rbp+string], rax
loc_137E:
lea rdx, [rbp+pmatch]
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 1; nmatch
mov rdi, rax; preg
call _regexec
test eax, eax
jz loc_1313
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
mov rax, [rbp+dest]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13CF
call ___stack_chk_fail
locret_13CF:
leave
retn | char * func0(const char *a1)
{
size_t v1; // rax
int i; // eax
char *string; // [rsp+18h] [rbp-88h]
char *dest; // [rsp+20h] [rbp-80h]
size_t v6; // [rsp+28h] [rbp-78h]
long long rm_so; // [rsp+30h] [rbp-70h]
regex_t preg; // [rsp+40h] [rbp-60h] BYREF
regmatch_t pmatch; // [rsp+88h] [rbp-18h] BYREF
char pattern[5]; // [rsp+93h] [rbp-Dh] BYREF
unsigned long long v11; // [rsp+98h] [rbp-8h]
v11 = __readfsqword(0x28u);
strcpy(pattern, "\\.0+");
v1 = strlen(a1);
dest = (char *)malloc(v1 + 1);
regcomp(&preg, pattern, 1);
strcpy(dest, a1);
string = dest;
for ( i = regexec(&preg, dest, 1uLL, &pmatch, 0); !i; i = regexec(&preg, string, 1uLL, &pmatch, 0) )
{
v6 = strlen(string);
rm_so = pmatch.rm_so;
memmove(&string[pmatch.rm_so + 1], &string[pmatch.rm_eo], v6 - pmatch.rm_eo + 1);
string += rm_so + 1;
}
regfree(&preg);
return dest;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xd],0x2b302e5c
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x98]
MOV RDI,RAX
CALL 0x00101120
ADD RAX,0x1
MOV RDI,RAX
CALL 0x00101170
MOV qword ptr [RBP + -0x80],RAX
LEA RCX,[RBP + -0xd]
LEA RAX,[RBP + -0x60]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101150
MOV RDX,qword ptr [RBP + -0x98]
MOV RAX,qword ptr [RBP + -0x80]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101100
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0010137e
LAB_00101313:
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x78],RAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x78]
SUB RAX,qword ptr [RBP + -0x68]
LEA RDX,[RAX + 0x1]
MOV RCX,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x68]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x70]
LEA RSI,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,RSI
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101190
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x1
ADD qword ptr [RBP + -0x88],RAX
LAB_0010137e:
LEA RDX,[RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x88]
LEA RAX,[RBP + -0x60]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00101180
TEST EAX,EAX
JZ 0x00101313
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00101110
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013cf
CALL 0x00101130
LAB_001013cf:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *__dest;
long lVar3;
long in_FS_OFFSET;
char *local_90;
regex_t local_68;
regmatch_t local_20;
char local_15 [5];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_15,"\\.0+",5);
sVar2 = strlen(param_1);
__dest = (char *)malloc(sVar2 + 1);
regcomp(&local_68,local_15,1);
strcpy(__dest,param_1);
local_90 = __dest;
while( true ) {
iVar1 = regexec(&local_68,local_90,1,&local_20,0);
if (iVar1 != 0) break;
sVar2 = strlen(local_90);
lVar3 = (long)local_20.rm_so;
memmove(local_90 + lVar3 + 1,local_90 + local_20.rm_eo,(sVar2 - (long)local_20.rm_eo) + 1);
local_90 = local_90 + lVar3 + 1;
}
regfree(&local_68);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __dest;
} |
6,265 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current_location, 1, matches, 0) == 0) {
size_t len = strlen(current_location);
size_t start = matches[0].rm_so;
size_t end = matches[0].rm_eo;
memmove(current_location + start + 1, current_location + end, len - end + 1);
current_location += start + 1;
}
regfree(®ex);
return result;
}
| int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(test3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x2b302e5c,0x53(%rsp)
movb $0x0,0x57(%rsp)
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
callq 1130 <malloc@plt>
mov %rax,%r12
lea 0x53(%rsp),%rsi
mov %rsp,%rdi
mov $0x1,%edx
callq 1120 <regcomp@plt>
mov %rbx,%rsi
mov %r12,%rdi
callq 10e0 <strcpy@plt>
mov %r12,%rbx
lea 0x48(%rsp),%rbp
mov %rsp,%rdi
mov $0x0,%r8d
mov %rbp,%rcx
mov $0x1,%edx
mov %rbx,%rsi
callq 1140 <regexec@plt>
test %eax,%eax
jne 1305 <func0+0xbc>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
movslq 0x4c(%rsp),%rax
lea (%rbx,%rax,1),%rsi
movslq 0x48(%rsp),%rdx
lea 0x1(%rbx,%rdx,1),%rbx
mov %rcx,%rdx
sub %rax,%rdx
mov %rbx,%rdi
callq 1150 <memmove@plt>
jmp 12b1 <func0+0x68>
mov %rsp,%rdi
callq 10f0 <regfree@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1329 <func0+0xe0>
mov %r12,%rax
add $0x60,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 1100 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 60h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+78h+var_20], rax
xor eax, eax
mov [rsp+78h+var_25], 2B302E5Ch
mov [rsp+78h+var_21], 0
call _strlen
lea rdi, [rax+1]
call _malloc
mov r12, rax
lea rsi, [rsp+78h+var_25]
mov rdi, rsp
mov edx, 1
call _regcomp
mov rsi, rbx
mov rdi, r12
call _strcpy
mov rbx, r12
lea rbp, [rsp+78h+var_30]
jmp short loc_1317
loc_12ED:
mov rdi, rbx
call _strlen
movsxd rdx, [rsp+78h+var_2C]
lea rsi, [rbx+rdx]
movsxd rcx, [rsp+78h+var_30]
lea rbx, [rbx+rcx+1]
sub rax, rdx
lea rdx, [rax+1]
mov rdi, rbx
call _memmove
loc_1317:
mov rdi, rsp
mov r8d, 0
mov rcx, rbp
mov edx, 1
mov rsi, rbx
call _regexec
test eax, eax
jz short loc_12ED
mov rdi, rsp
call _regfree
mov rax, [rsp+78h+var_20]
sub rax, fs:28h
jnz short loc_1358
mov rax, r12
add rsp, 60h
pop rbx
pop rbp
pop r12
retn
loc_1358:
call ___stack_chk_fail | long long func0(long long a1)
{
long long v1; // rax
long long v2; // r12
long long i; // rbx
long long v4; // rax
long long v5; // rsi
_BYTE v7[72]; // [rsp+0h] [rbp-78h] BYREF
int v8; // [rsp+48h] [rbp-30h] BYREF
int v9; // [rsp+4Ch] [rbp-2Ch]
char v10[5]; // [rsp+53h] [rbp-25h] BYREF
unsigned long long v11; // [rsp+58h] [rbp-20h]
v11 = __readfsqword(0x28u);
strcpy(v10, "\\.0+");
v1 = ((long long (*)(void))strlen)();
v2 = malloc(v1 + 1);
regcomp(v7, v10, 1LL);
strcpy(v2, a1);
for ( i = v2; !(unsigned int)regexec(v7, i, 1LL, &v8, 0LL); memmove(i, v5, v4 - v9 + 1) )
{
v4 = strlen(i);
v5 = i + v9;
i += v8 + 1LL;
}
regfree(v7);
return v2;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x53],0x2b302e5c
MOV byte ptr [RSP + 0x57],0x0
CALL 0x00101120
LEA RDI,[RAX + 0x1]
CALL 0x00101170
MOV R12,RAX
LEA RSI,[RSP + 0x53]
MOV RDI,RSP
MOV EDX,0x1
CALL 0x00101150
MOV RSI,RBX
MOV RDI,R12
CALL 0x00101100
MOV RBX,R12
LEA RBP,[RSP + 0x48]
JMP 0x00101317
LAB_001012ed:
MOV RDI,RBX
CALL 0x00101120
MOVSXD RDX,dword ptr [RSP + 0x4c]
LEA RSI,[RBX + RDX*0x1]
MOVSXD RCX,dword ptr [RSP + 0x48]
LEA RBX,[RBX + RCX*0x1 + 0x1]
SUB RAX,RDX
LEA RDX,[RAX + 0x1]
MOV RDI,RBX
CALL 0x00101190
LAB_00101317:
MOV RDI,RSP
MOV R8D,0x0
MOV RCX,RBP
MOV EDX,0x1
MOV RSI,RBX
CALL 0x00101180
TEST EAX,EAX
JZ 0x001012ed
MOV RDI,RSP
CALL 0x00101110
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101358
MOV RAX,R12
ADD RSP,0x60
POP RBX
POP RBP
POP R12
RET
LAB_00101358:
CALL 0x00101130 | char * func0(char *param_1)
{
char *__src;
int iVar1;
size_t sVar2;
char *__dest;
char *__string;
long in_FS_OFFSET;
regex_t rStack_78;
regmatch_t local_30;
char local_25 [5];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_25,"\\.0+",5);
sVar2 = strlen(param_1);
__dest = (char *)malloc(sVar2 + 1);
regcomp(&rStack_78,local_25,1);
strcpy(__dest,param_1);
__string = __dest;
while( true ) {
iVar1 = regexec(&rStack_78,__string,1,&local_30,0);
if (iVar1 != 0) break;
sVar2 = strlen(__string);
__src = __string + local_30.rm_eo;
__string = __string + (long)local_30.rm_so + 1;
memmove(__string,__src,(sVar2 - (long)local_30.rm_eo) + 1);
}
regfree(&rStack_78);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,266 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current_location, 1, matches, 0) == 0) {
size_t len = strlen(current_location);
size_t start = matches[0].rm_so;
size_t end = matches[0].rm_eo;
memmove(current_location + start + 1, current_location + end, len - end + 1);
current_location += start + 1;
}
regfree(®ex);
return result;
}
| int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(test3);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x2b302e5c,0x53(%rsp)
mov %rsp,%rbp
movb $0x0,0x57(%rsp)
callq 1110 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1150 <malloc@plt>
lea 0x53(%rsp),%rsi
mov $0x1,%edx
mov %rbp,%rdi
mov %rax,%r13
callq 1140 <regcomp@plt>
mov %r12,%rsi
mov %r13,%rdi
mov %r13,%rbx
callq 10f0 <strcpy@plt>
lea 0x48(%rsp),%r12
jmp 140a <func0+0x9a>
nopl 0x0(%rax)
mov %rbx,%rdi
callq 1110 <strlen@plt>
movslq 0x4c(%rsp),%rdx
movslq 0x48(%rsp),%rcx
lea (%rbx,%rdx,1),%rsi
sub %rdx,%rax
lea 0x1(%rbx,%rcx,1),%rbx
lea 0x1(%rax),%rdx
mov %rbx,%rdi
callq 1170 <memmove@plt>
xor %r8d,%r8d
mov %r12,%rcx
mov $0x1,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 1160 <regexec@plt>
test %eax,%eax
je 13e0 <func0+0x70>
mov %rbp,%rdi
callq 1100 <regfree@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 144a <func0+0xda>
add $0x68,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1120 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+var_s58], rax
xor eax, eax
mov [rsp+var_s53], 2B302E5Ch
mov rbp, rsp
mov [rsp+var_s57], 0
call _strlen
lea rdi, [rax+1]
call _malloc
lea rsi, [rsp+var_s53]
mov edx, 1
mov rdi, rbp
mov r13, rax
call _regcomp
mov rsi, r12
mov rdi, r13
mov rbx, r13
call _strcpy
lea r12, [rsp+var_s48]
jmp short loc_141A
loc_13F0:
mov rdi, rbx
call _strlen
movsxd rdx, [rsp+var_s4C]
movsxd rcx, [rsp+var_s48]
lea rsi, [rbx+rdx]
sub rax, rdx
lea rbx, [rbx+rcx+1]
lea rdx, [rax+1]
mov rdi, rbx
call _memmove
loc_141A:
xor r8d, r8d
mov rcx, r12
mov edx, 1
mov rsi, rbx
mov rdi, rbp
call _regexec
test eax, eax
jz short loc_13F0
mov rdi, rbp
call _regfree
mov rax, [rsp+var_s58]
sub rax, fs:28h
jnz short loc_145A
add rsp, 68h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
retn
loc_145A:
call ___stack_chk_fail | long long func0(long long a1)
{
long long v1; // rax
long long v2; // r13
long long v3; // rbx
long long v4; // rax
long long v5; // rsi
_BYTE _0[72]; // [rsp+0h] [rbp+0h] BYREF
int vars48; // [rsp+48h] [rbp+48h] BYREF
int vars4C; // [rsp+4Ch] [rbp+4Ch]
char vars53[5]; // [rsp+53h] [rbp+53h] BYREF
unsigned long long vars58; // [rsp+58h] [rbp+58h]
vars58 = __readfsqword(0x28u);
strcpy(vars53, "\\.0+");
v1 = ((long long (*)(void))strlen)();
v2 = malloc(v1 + 1);
regcomp(_0, vars53, 1LL);
v3 = v2;
strcpy(v2, a1);
while ( !(unsigned int)regexec(_0, v3, 1LL, &vars48, 0LL) )
{
v4 = strlen(v3);
v5 = v3 + vars4C;
v3 += vars48 + 1LL;
memmove(v3, v5, v4 - vars4C + 1);
}
regfree(_0);
return v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x53],0x2b302e5c
MOV RBP,RSP
MOV byte ptr [RSP + 0x57],0x0
CALL 0x00101120
LEA RDI,[RAX + 0x1]
CALL 0x00101170
LEA RSI,[RSP + 0x53]
MOV EDX,0x1
MOV RDI,RBP
MOV R13,RAX
CALL 0x00101150
MOV RSI,R12
MOV RDI,R13
MOV RBX,R13
CALL 0x00101100
LEA R12,[RSP + 0x48]
JMP 0x0010141a
LAB_001013f0:
MOV RDI,RBX
CALL 0x00101120
MOVSXD RDX,dword ptr [RSP + 0x4c]
MOVSXD RCX,dword ptr [RSP + 0x48]
LEA RSI,[RBX + RDX*0x1]
SUB RAX,RDX
LEA RBX,[RBX + RCX*0x1 + 0x1]
LEA RDX,[RAX + 0x1]
MOV RDI,RBX
CALL 0x00101190
LAB_0010141a:
XOR R8D,R8D
MOV RCX,R12
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101180
TEST EAX,EAX
JZ 0x001013f0
MOV RDI,RBP
CALL 0x00101110
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010145a
ADD RSP,0x68
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010145a:
CALL 0x00101130 | char * func0(char *param_1)
{
char *__src;
int iVar1;
size_t sVar2;
char *__dest;
char *__string;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_40;
char local_35 [5];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_35,"\\.0+",5);
sVar2 = strlen(param_1);
__dest = (char *)malloc(sVar2 + 1);
regcomp(&rStack_88,local_35,1);
strcpy(__dest,param_1);
__string = __dest;
while( true ) {
iVar1 = regexec(&rStack_88,__string,1,&local_40,0);
if (iVar1 != 0) break;
sVar2 = strlen(__string);
__src = __string + local_40.rm_eo;
__string = __string + (long)local_40.rm_so + 1;
memmove(__string,__src,(sVar2 - (long)local_40.rm_eo) + 1);
}
regfree(&rStack_88);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,267 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current_location, 1, matches, 0) == 0) {
size_t len = strlen(current_location);
size_t start = matches[0].rm_so;
size_t end = matches[0].rm_eo;
memmove(current_location + start + 1, current_location + end, len - end + 1);
current_location += start + 1;
}
regfree(®ex);
return result;
}
| int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(test3);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x2b302e5c,0x53(%rsp)
mov %rsp,%rbp
movb $0x0,0x57(%rsp)
callq 1110 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1150 <malloc@plt>
lea 0x53(%rsp),%rsi
mov $0x1,%edx
mov %rbp,%rdi
mov %rax,%r13
callq 1140 <regcomp@plt>
mov %r12,%rsi
mov %r13,%rdi
mov %r13,%rbx
callq 10f0 <strcpy@plt>
lea 0x48(%rsp),%r12
jmp 140a <func0+0x9a>
nopl 0x0(%rax)
mov %rbx,%rdi
callq 1110 <strlen@plt>
movslq 0x4c(%rsp),%rdx
movslq 0x48(%rsp),%rcx
lea (%rbx,%rdx,1),%rsi
sub %rdx,%rax
lea 0x1(%rbx,%rcx,1),%rbx
lea 0x1(%rax),%rdx
mov %rbx,%rdi
callq 1170 <memmove@plt>
xor %r8d,%r8d
mov %r12,%rcx
mov $0x1,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 1160 <regexec@plt>
test %eax,%eax
je 13e0 <func0+0x70>
mov %rbp,%rdi
callq 1100 <regfree@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 144a <func0+0xda>
add $0x68,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1120 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov [rsp+98h+var_41], 0
mov r13, rsp
lea r14, [rsp+98h+pmatch]
mov dword ptr [rsp+98h+pattern], 2B302E5Ch
call _strlen
lea r12, [rax+1]
mov rdi, r12; size
call _malloc
lea rsi, [rsp+98h+pattern]; pattern
mov edx, 1; cflags
mov rdi, r13; preg
mov r15, rax
call _regcomp
mov rsi, rbx
mov rdx, r12
mov rdi, r15
call ___strcpy_chk
mov rbx, r12
mov rbp, r15
jmp short loc_1457
loc_1400:
mov rdi, rbp; s
call _strlen
mov rdi, rbx
movsxd r8, [rsp+98h+pmatch.rm_eo]
mov rcx, rax
movsxd rax, [rsp+98h+pmatch.rm_so]
lea rsi, [rbp+r8+0]
add rax, 1
cmp r12, rbx
cmovnb rdi, r12
lea r9, [rax+rdi]
mov rdx, r9
sub rdx, rbx
cmp rdx, rdi
cmovb rdx, rdi
add rbp, rax
sub rbx, r9
mov rax, rcx
sub rax, r8
mov rdi, rbp
add rbx, rdx
lea rdx, [rax+1]
mov rcx, rbx
call ___memmove_chk
loc_1457:
xor r8d, r8d; eflags
mov rcx, r14; pmatch
mov edx, 1; nmatch
mov rsi, rbp; string
mov rdi, r13; preg
call _regexec
test eax, eax
jz short loc_1400
mov rdi, r13; preg
call _regfree
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_149B
add rsp, 68h
mov rax, r15
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_149B:
call ___stack_chk_fail | const char * func0(const char *a1)
{
size_t v1; // r12
const char *v2; // r15
size_t v3; // rbx
const char *i; // rbp
size_t v5; // rdi
size_t v6; // rcx
const char *v7; // rsi
long long v8; // rax
size_t v9; // rdx
regex_t v11; // [rsp+0h] [rbp-98h] BYREF
regmatch_t pmatch; // [rsp+48h] [rbp-50h] BYREF
char pattern[5]; // [rsp+53h] [rbp-45h] BYREF
unsigned long long v14; // [rsp+58h] [rbp-40h]
v14 = __readfsqword(0x28u);
strcpy(pattern, "\\.0+");
v1 = strlen(a1) + 1;
v2 = (const char *)malloc(v1);
regcomp(&v11, pattern, 1);
__strcpy_chk(v2, a1, v1);
v3 = v1;
for ( i = v2; !regexec(&v11, i, 1uLL, &pmatch, 0); __memmove_chk(i, v7, v6 - pmatch.rm_eo + 1, v3) )
{
v5 = v3;
v6 = strlen(i);
v7 = &i[pmatch.rm_eo];
v8 = pmatch.rm_so + 1LL;
if ( v1 >= v3 )
v5 = v1;
v9 = v8 + v5 - v3;
if ( v9 < v5 )
v9 = v5;
i += v8;
v3 = v9 + v3 - (v8 + v5);
}
regfree(&v11);
return v2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x57],0x0
MOV R13,RSP
LEA R14,[RSP + 0x48]
MOV dword ptr [RSP + 0x53],0x2b302e5c
CALL 0x00101110
LEA R12,[RAX + 0x1]
MOV RDI,R12
CALL 0x00101170
LEA RSI,[RSP + 0x53]
MOV EDX,0x1
MOV RDI,R13
MOV R15,RAX
CALL 0x00101140
MOV RSI,RBX
MOV RDX,R12
MOV RDI,R15
CALL 0x00101190
MOV RBX,R12
MOV RBP,R15
JMP 0x00101457
LAB_00101400:
MOV RDI,RBP
CALL 0x00101110
MOV RDI,RBX
MOVSXD R8,dword ptr [RSP + 0x4c]
MOV RCX,RAX
MOVSXD RAX,dword ptr [RSP + 0x48]
LEA RSI,[RBP + R8*0x1]
ADD RAX,0x1
CMP R12,RBX
CMOVNC RDI,R12
LEA R9,[RAX + RDI*0x1]
MOV RDX,R9
SUB RDX,RBX
CMP RDX,RDI
CMOVC RDX,RDI
ADD RBP,RAX
SUB RBX,R9
MOV RAX,RCX
SUB RAX,R8
MOV RDI,RBP
ADD RBX,RDX
LEA RDX,[RAX + 0x1]
MOV RCX,RBX
CALL 0x00101160
LAB_00101457:
XOR R8D,R8D
MOV RCX,R14
MOV EDX,0x1
MOV RSI,RBP
MOV RDI,R13
CALL 0x00101180
TEST EAX,EAX
JZ 0x00101400
MOV RDI,R13
CALL 0x00101100
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010149b
ADD RSP,0x68
MOV RAX,R15
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010149b:
CALL 0x00101120 | char * func0(char *param_1)
{
long lVar1;
char *pcVar2;
int iVar3;
size_t sVar4;
char *pcVar5;
size_t sVar6;
ulong uVar7;
size_t sVar8;
char *__string;
ulong uVar9;
long in_FS_OFFSET;
regex_t rStack_98;
regmatch_t local_50;
char local_45 [5];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_45,"\\.0+",5);
sVar4 = strlen(param_1);
sVar4 = sVar4 + 1;
pcVar5 = (char *)malloc(sVar4);
regcomp(&rStack_98,local_45,1);
__strcpy_chk(pcVar5,param_1,sVar4);
sVar8 = sVar4;
__string = pcVar5;
while( true ) {
iVar3 = regexec(&rStack_98,__string,1,&local_50,0);
if (iVar3 != 0) break;
sVar6 = strlen(__string);
pcVar2 = __string + local_50.rm_eo;
uVar9 = sVar8;
if (sVar8 <= sVar4) {
uVar9 = sVar4;
}
lVar1 = (long)local_50.rm_so + 1 + uVar9;
uVar7 = lVar1 - sVar8;
if (uVar7 < uVar9) {
uVar7 = uVar9;
}
__string = __string + (long)local_50.rm_so + 1;
sVar8 = (sVar8 - lVar1) + uVar7;
__memmove_chk(__string,pcVar2,(sVar6 - (long)local_50.rm_eo) + 1,sVar8);
}
regfree(&rStack_98);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,268 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
return (first_even - first_odd);
}
| int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0xffffffff,-0x10(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11c7 <func0+0x5e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
jmp 11d3 <func0+0x6a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118f <func0+0x26>
movl $0x0,-0x4(%rbp)
jmp 1218 <func0+0xaf>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
je 1214 <func0+0xab>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
jmp 1220 <func0+0xb7>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11dc <func0+0x73>
mov -0x10(%rbp),%eax
sub -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_10], 0FFFFFFFFh
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0
jmp short loc_11CB
loc_118F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11C7
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_10], eax
jmp short loc_11D3
loc_11C7:
add [rbp+var_8], 1
loc_11CB:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_118F
loc_11D3:
mov [rbp+var_4], 0
jmp short loc_1218
loc_11DC:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jz short loc_1214
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
jmp short loc_1220
loc_1214:
add [rbp+var_4], 1
loc_1218:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11DC
loc_1220:
mov eax, [rbp+var_10]
sub eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+Ch] [rbp-10h]
int v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = -1;
v4 = -1;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
{
v3 = *(_DWORD *)(4LL * i + a1);
break;
}
}
for ( j = 0; j < a2; ++j )
{
if ( (*(_DWORD *)(4LL * j + a1) & 1) != 0 )
{
v4 = *(_DWORD *)(4LL * j + a1);
return (unsigned int)(v3 - v4);
}
}
return (unsigned int)(v3 - v4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0xffffffff
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011cb
LAB_0010118f:
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]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011c7
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 + -0x10],EAX
JMP 0x001011d3
LAB_001011c7:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011cb:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118f
LAB_001011d3:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101218
LAB_001011dc:
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]
AND EAX,0x1
TEST EAX,EAX
JZ 0x00101214
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101220
LAB_00101214:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101218:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011dc
LAB_00101220:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_18 = -1;
local_14 = -1;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1) == 0) {
local_18 = *(int *)(param_1 + (long)local_10 * 4);
break;
}
}
local_c = 0;
do {
if (param_2 <= local_c) {
LAB_00101220:
return local_18 - local_14;
}
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) != 0) {
local_14 = *(int *)(param_1 + (long)local_c * 4);
goto LAB_00101220;
}
local_c = local_c + 1;
} while( true );
} |
6,269 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
return (first_even - first_odd);
}
| int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a8 <func0+0x3f>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
mov (%rdi),%eax
test $0x1,%al
je 1190 <func0+0x27>
add $0x4,%rdi
cmp %rsi,%rdi
jne 117c <func0+0x13>
mov $0xffffffff,%eax
mov (%rdx),%ecx
test $0x1,%cl
jne 11a5 <func0+0x3c>
add $0x4,%rdx
cmp %rsi,%rdx
jne 1190 <func0+0x27>
mov $0xffffffff,%ecx
sub %ecx,%eax
retq
mov $0xffffffff,%eax
mov $0xffffffff,%ecx
jmp 11a5 <func0+0x3c>
| func0:
endbr64
test esi, esi
jle short loc_11A8
mov rdx, rdi
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
loc_117C:
mov eax, [rdi]
test al, 1
jz short loc_1190
add rdi, 4
cmp rdi, rsi
jnz short loc_117C
mov eax, 0FFFFFFFFh
loc_1190:
mov ecx, [rdx]
test cl, 1
jnz short loc_11A5
add rdx, 4
cmp rdx, rsi
jnz short loc_1190
mov ecx, 0FFFFFFFFh
loc_11A5:
sub eax, ecx
retn
loc_11A8:
mov eax, 0FFFFFFFFh
mov ecx, 0FFFFFFFFh
jmp short loc_11A5 | long long func0(int *a1, int a2)
{
int *v2; // rdx
long long v3; // rsi
int v4; // eax
int v5; // ecx
if ( a2 <= 0 )
{
v4 = -1;
v5 = -1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
do
{
v4 = *a1;
if ( (*a1 & 1) == 0 )
goto LABEL_6;
++a1;
}
while ( a1 != (int *)v3 );
v4 = -1;
LABEL_6:
while ( 1 )
{
v5 = *v2;
if ( (*v2 & 1) != 0 )
break;
if ( ++v2 == (int *)v3 )
{
v5 = -1;
return (unsigned int)(v4 - v5);
}
}
}
return (unsigned int)(v4 - v5);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a8
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
LAB_0010117c:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 0x00101190
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x0010117c
MOV EAX,0xffffffff
LAB_00101190:
MOV ECX,dword ptr [RDX]
TEST CL,0x1
JNZ 0x001011a5
ADD RDX,0x4
CMP RDX,RSI
JNZ 0x00101190
MOV ECX,0xffffffff
LAB_001011a5:
SUB EAX,ECX
RET
LAB_001011a8:
MOV EAX,0xffffffff
MOV ECX,0xffffffff
JMP 0x001011a5 | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
if (param_2 < 1) {
uVar2 = 0xffffffff;
uVar3 = 0xffffffff;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar4 = param_1;
do {
uVar2 = *puVar4;
if ((uVar2 & 1) == 0) goto LAB_00101190;
puVar4 = puVar4 + 1;
} while (puVar4 != puVar1);
uVar2 = 0xffffffff;
LAB_00101190:
do {
uVar3 = *param_1;
if ((uVar3 & 1) != 0) goto LAB_001011a5;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
uVar3 = 0xffffffff;
}
LAB_001011a5:
return uVar2 - uVar3;
} |
6,270 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
return (first_even - first_odd);
}
| int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1344 <func0+0x54>
lea -0x1(%rsi),%eax
mov %rdi,%rdx
lea 0x4(%rdi,%rax,4),%rcx
jmp 1311 <func0+0x21>
nopl (%rax)
add $0x4,%rdx
cmp %rcx,%rdx
je 1338 <func0+0x48>
mov (%rdx),%eax
test $0x1,%al
jne 1308 <func0+0x18>
jmp 1329 <func0+0x39>
nopl 0x0(%rax)
add $0x4,%rdi
cmp %rcx,%rdi
je 1340 <func0+0x50>
mov (%rdi),%edx
test $0x1,%dl
je 1320 <func0+0x30>
sub %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
jmp 1329 <func0+0x39>
add $0x1,%eax
retq
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1344
lea eax, [rsi-1]
mov rdx, rdi
lea rcx, [rdi+rax*4+4]
jmp short loc_1311
loc_1308:
add rdx, 4
cmp rdx, rcx
jz short loc_1338
loc_1311:
mov eax, [rdx]
test al, 1
jnz short loc_1308
jmp short loc_1329
loc_1320:
add rdi, 4
cmp rdi, rcx
jz short loc_1340
loc_1329:
mov edx, [rdi]
test dl, 1
jz short loc_1320
sub eax, edx
retn
loc_1338:
mov eax, 0FFFFFFFFh
jmp short loc_1329
loc_1340:
add eax, 1
retn
loc_1344:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
int *v2; // rdx
long long v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
v4 = *v2;
if ( (*v2 & 1) == 0 )
break;
if ( ++v2 == (int *)v3 )
{
v4 = -1;
goto LABEL_7;
}
}
do
{
LABEL_7:
if ( (*a1 & 1) != 0 )
return (unsigned int)(v4 - *a1);
++a1;
}
while ( a1 != (int *)v3 );
return (unsigned int)(v4 + 1);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101344
LEA EAX,[RSI + -0x1]
MOV RDX,RDI
LEA RCX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101311
LAB_00101308:
ADD RDX,0x4
CMP RDX,RCX
JZ 0x00101338
LAB_00101311:
MOV EAX,dword ptr [RDX]
TEST AL,0x1
JNZ 0x00101308
JMP 0x00101329
LAB_00101320:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x00101340
LAB_00101329:
MOV EDX,dword ptr [RDI]
TEST DL,0x1
JZ 0x00101320
SUB EAX,EDX
RET
LAB_00101338:
MOV EAX,0xffffffff
JMP 0x00101329
LAB_00101340:
ADD EAX,0x1
RET
LAB_00101344:
XOR EAX,EAX
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
if (param_2 < 1) {
return 0;
}
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar3 = param_1;
do {
uVar2 = *puVar3;
if ((uVar2 & 1) == 0) goto LAB_00101329;
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
uVar2 = 0xffffffff;
LAB_00101329:
do {
if ((*param_1 & 1) != 0) {
return uVar2 - *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return uVar2 + 1;
} |
6,271 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
return (first_even - first_odd);
}
| int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 12f4 <func0+0x54>
lea -0x1(%rsi),%eax
mov %rdi,%rdx
lea 0x4(%rdi,%rax,4),%rcx
jmp 12c1 <func0+0x21>
nopl (%rax)
add $0x4,%rdx
cmp %rcx,%rdx
je 12e8 <func0+0x48>
mov (%rdx),%eax
test $0x1,%al
jne 12b8 <func0+0x18>
jmp 12d9 <func0+0x39>
nopl 0x0(%rax)
add $0x4,%rdi
cmp %rcx,%rdi
je 12f0 <func0+0x50>
mov (%rdi),%edx
test $0x1,%dl
je 12d0 <func0+0x30>
sub %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
jmp 12d9 <func0+0x39>
add $0x1,%eax
retq
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12E4
movsxd rsi, esi
mov rdx, rdi
lea rcx, [rdi+rsi*4]
jmp short loc_12B1
loc_12A8:
add rdx, 4
cmp rdx, rcx
jz short loc_12D8
loc_12B1:
mov eax, [rdx]
test al, 1
jnz short loc_12A8
jmp short loc_12C9
loc_12C0:
add rdi, 4
cmp rdi, rcx
jz short loc_12E0
loc_12C9:
mov edx, [rdi]
test dl, 1
jz short loc_12C0
sub eax, edx
retn
loc_12D8:
mov eax, 0FFFFFFFFh
jmp short loc_12C9
loc_12E0:
add eax, 1
retn
loc_12E4:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
int *v2; // rdx
int *v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = &a1[a2];
while ( 1 )
{
v4 = *v2;
if ( (*v2 & 1) == 0 )
break;
if ( ++v2 == v3 )
{
v4 = -1;
goto LABEL_7;
}
}
do
{
LABEL_7:
if ( (*a1 & 1) != 0 )
return (unsigned int)(v4 - *a1);
++a1;
}
while ( a1 != v3 );
return (unsigned int)(v4 + 1);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012e4
MOVSXD RSI,ESI
MOV RDX,RDI
LEA RCX,[RDI + RSI*0x4]
JMP 0x001012b1
LAB_001012a8:
ADD RDX,0x4
CMP RDX,RCX
JZ 0x001012d8
LAB_001012b1:
MOV EAX,dword ptr [RDX]
TEST AL,0x1
JNZ 0x001012a8
JMP 0x001012c9
LAB_001012c0:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x001012e0
LAB_001012c9:
MOV EDX,dword ptr [RDI]
TEST DL,0x1
JZ 0x001012c0
SUB EAX,EDX
RET
LAB_001012d8:
MOV EAX,0xffffffff
JMP 0x001012c9
LAB_001012e0:
ADD EAX,0x1
RET
LAB_001012e4:
XOR EAX,EAX
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
if (param_2 < 1) {
return 0;
}
puVar1 = param_1 + param_2;
puVar3 = param_1;
do {
uVar2 = *puVar3;
if ((uVar2 & 1) == 0) goto LAB_001012c9;
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
uVar2 = 0xffffffff;
LAB_001012c9:
do {
if ((*param_1 & 1) != 0) {
return uVar2 - *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return uVar2 + 1;
} |
6,272 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represent "Not Possible"
}
}
| int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
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)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11c8 <func0+0x5f>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x8(%rbp),%eax
movslq %eax,%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 11c4 <func0+0x5b>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 119c <func0+0x33>
mov -0xc(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 11e8 <func0+0x7f>
mov -0xc(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
jmp 11ed <func0+0x84>
mov $0xffffffff,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11C8
loc_119C:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_8]
movsxd rcx, eax
mov rax, [rbp+var_20]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_11C4
add [rbp+var_C], 1
loc_11C4:
add [rbp+var_8], 1
loc_11C8:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_119C
mov eax, [rbp+var_C]
and eax, 1
test eax, eax
jnz short loc_11E8
mov eax, [rbp+var_C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
jmp short locret_11ED
loc_11E8:
mov eax, 0FFFFFFFFh
locret_11ED:
leave
retn | long long func0(const char *a1, long long a2)
{
int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( a1[i] != *(_BYTE *)(i + a2) )
++v3;
}
if ( (v3 & 1) != 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(v3 / 2);
} | 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 RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011c8
LAB_0010119c:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x001011c4
ADD dword ptr [RBP + -0xc],0x1
LAB_001011c4:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c8:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x0010119c
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011e8
MOV EAX,dword ptr [RBP + -0xc]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
JMP 0x001011ed
LAB_001011e8:
MOV EAX,0xffffffff
LAB_001011ed:
LEAVE
RET | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
uint local_14;
int local_10;
local_14 = 0;
sVar2 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar2; local_10 = local_10 + 1) {
if (param_1[local_10] != *(char *)(param_2 + local_10)) {
local_14 = local_14 + 1;
}
}
if ((local_14 & 1) == 0) {
iVar1 = (int)local_14 / 2;
}
else {
iVar1 = -1;
}
return iVar1;
} |
6,273 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represent "Not Possible"
}
}
| int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11a3 <func0+0x5a>
lea -0x1(%rcx),%edi
mov $0x0,%eax
mov $0x0,%edx
jmp 117b <func0+0x32>
mov %rcx,%rax
movzbl (%rsi,%rax,1),%ecx
cmp %cl,(%r8,%rax,1)
setne %cl
movzbl %cl,%ecx
add %ecx,%edx
lea 0x1(%rax),%rcx
cmp %rdi,%rax
jne 1178 <func0+0x2f>
test $0x1,%dl
jne 11aa <func0+0x61>
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
retq
mov $0x0,%edx
jmp 1199 <func0+0x50>
mov $0xffffffff,%eax
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, rsi
call _strlen
test eax, eax
jle short loc_11C3
lea esi, [rax-1]
mov eax, 0
mov edx, 0
jmp short loc_1194
loc_1191:
mov rax, rcx
loc_1194:
movzx edi, byte ptr [rbp+rax+0]
cmp [rbx+rax], dil
setnz cl
movzx ecx, cl
add edx, ecx
lea rcx, [rax+1]
cmp rax, rsi
jnz short loc_1191
test dl, 1
jnz short loc_11CA
loc_11B3:
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
loc_11BC:
add rsp, 8
pop rbx
pop rbp
retn
loc_11C3:
mov edx, 0
jmp short loc_11B3
loc_11CA:
mov eax, 0FFFFFFFFh
jmp short loc_11BC | long long func0(long long a1, long long a2)
{
int v3; // eax
long long v4; // rsi
long long v5; // rax
int v6; // edx
v3 = strlen();
if ( v3 <= 0 )
{
v6 = 0;
return (unsigned int)(v6 / 2);
}
v4 = (unsigned int)(v3 - 1);
v5 = 0LL;
v6 = 0;
while ( 1 )
{
v6 += *(_BYTE *)(a1 + v5) != *(_BYTE *)(a2 + v5);
if ( v5 == v4 )
break;
++v5;
}
if ( (v6 & 1) == 0 )
return (unsigned int)(v6 / 2);
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,RSI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011c3
LEA ESI,[RAX + -0x1]
MOV EAX,0x0
MOV EDX,0x0
JMP 0x00101194
LAB_00101191:
MOV RAX,RCX
LAB_00101194:
MOVZX EDI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],DIL
SETNZ CL
MOVZX ECX,CL
ADD EDX,ECX
LEA RCX,[RAX + 0x1]
CMP RAX,RSI
JNZ 0x00101191
TEST DL,0x1
JNZ 0x001011ca
LAB_001011b3:
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
LAB_001011bc:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011c3:
MOV EDX,0x0
JMP 0x001011b3
LAB_001011ca:
MOV EAX,0xffffffff
JMP 0x001011bc | int func0(char *param_1,long param_2)
{
size_t sVar1;
ulong uVar2;
uint uVar3;
bool bVar4;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
uVar3 = 0;
}
else {
uVar3 = 0;
uVar2 = 0;
do {
uVar3 = uVar3 + (param_1[uVar2] != *(char *)(param_2 + uVar2));
bVar4 = uVar2 != (int)sVar1 - 1;
uVar2 = uVar2 + 1;
} while (bVar4);
if ((uVar3 & 1) != 0) {
return -1;
}
}
return (int)uVar3 / 2;
} |
6,274 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represent "Not Possible"
}
}
| int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 1290 <func0+0x60>
lea -0x1(%rax),%esi
xor %edx,%edx
xor %eax,%eax
jmp 125b <func0+0x2b>
nopw 0x0(%rax,%rax,1)
mov %rcx,%rax
xor %ecx,%ecx
movzbl 0x0(%rbp,%rax,1),%edi
cmp %dil,(%rbx,%rax,1)
setne %cl
add %ecx,%edx
lea 0x1(%rax),%rcx
cmp %rax,%rsi
jne 1258 <func0+0x28>
mov %edx,%eax
sar %eax
and $0x1,%edx
mov $0xffffffff,%edx
cmovne %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1280
lea esi, [rax-1]
xor edx, edx
xor eax, eax
jmp short loc_124B
loc_1248:
mov rax, rcx
loc_124B:
xor ecx, ecx
movzx edi, byte ptr [rbp+rax+0]
cmp [rbx+rax], dil
setnz cl
add edx, ecx
lea rcx, [rax+1]
cmp rsi, rax
jnz short loc_1248
mov eax, edx
sar eax, 1
and edx, 1
mov edx, 0FFFFFFFFh
cmovnz eax, edx
add rsp, 8
pop rbx
pop rbp
retn
loc_1280:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn | long long func0(long long a1, long long a2)
{
int v3; // eax
long long v4; // rsi
int v5; // edx
long long i; // rax
long long result; // rax
v3 = strlen();
if ( v3 <= 0 )
return 0LL;
v4 = (unsigned int)(v3 - 1);
v5 = 0;
for ( i = 0LL; ; ++i )
{
v5 += *(_BYTE *)(a1 + i) != *(_BYTE *)(a2 + i);
if ( v4 == i )
break;
}
result = (unsigned int)(v5 >> 1);
if ( (v5 & 1) != 0 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101280
LEA ESI,[RAX + -0x1]
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010124b
LAB_00101248:
MOV RAX,RCX
LAB_0010124b:
XOR ECX,ECX
MOVZX EDI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],DIL
SETNZ CL
ADD EDX,ECX
LEA RCX,[RAX + 0x1]
CMP RSI,RAX
JNZ 0x00101248
MOV EAX,EDX
SAR EAX,0x1
AND EDX,0x1
MOV EDX,0xffffffff
CMOVNZ EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101280:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
uint uVar4;
bool bVar5;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
return 0;
}
uVar4 = 0;
uVar3 = 0;
do {
uVar4 = uVar4 + (param_1[uVar3] != *(char *)(param_2 + uVar3));
bVar5 = (int)sVar2 - 1 != uVar3;
uVar3 = uVar3 + 1;
} while (bVar5);
iVar1 = (int)uVar4 >> 1;
if ((uVar4 & 1) != 0) {
iVar1 = -1;
}
return iVar1;
} |
6,275 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represent "Not Possible"
}
}
| int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 1500 <func0+0x2d0>
lea -0x1(%rax),%edx
cmp $0xe,%edx
jbe 1509 <func0+0x2d9>
mov %eax,%ecx
movdqa 0xe4d(%rip),%xmm6
xor %edx,%edx
pxor %xmm1,%xmm1
shr $0x4,%ecx
pxor %xmm5,%xmm5
pxor %xmm4,%xmm4
shl $0x4,%rcx
nopl 0x0(%rax,%rax,1)
movdqu 0x0(%rbp,%rdx,1),%xmm7
movdqu (%rbx,%rdx,1),%xmm0
movdqa %xmm5,%xmm3
add $0x10,%rdx
pcmpeqb %xmm7,%xmm0
pandn %xmm6,%xmm0
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
punpckhbw %xmm3,%xmm0
movdqa %xmm4,%xmm3
pcmpgtw %xmm2,%xmm3
movdqa %xmm2,%xmm7
punpcklwd %xmm3,%xmm7
punpckhwd %xmm3,%xmm2
movdqa %xmm0,%xmm3
paddd %xmm7,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm4,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm3
punpckhwd %xmm2,%xmm0
paddd %xmm3,%xmm1
paddd %xmm0,%xmm1
cmp %rcx,%rdx
jne 1280 <func0+0x50>
movdqa %xmm1,%xmm0
mov %eax,%ecx
psrldq $0x8,%xmm0
and $0xfffffff0,%ecx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%edx
test $0xf,%al
je 14e4 <func0+0x2b4>
movslq %ecx,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x1(%rcx),%esi
cmp %eax,%esi
jge 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl (%rbx,%rsi,1),%edi
cmp %dil,0x0(%rbp,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x2(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x3(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x4(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x5(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x6(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x7(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x8(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0x9(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0xa(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0xb(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0xc(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
movzbl %sil,%esi
add %esi,%edx
lea 0xd(%rcx),%esi
cmp %esi,%eax
jle 14e4 <func0+0x2b4>
movslq %esi,%rsi
movzbl 0x0(%rbp,%rsi,1),%edi
cmp %dil,(%rbx,%rsi,1)
setne %sil
add $0xe,%ecx
movzbl %sil,%esi
add %esi,%edx
cmp %ecx,%eax
jle 14e4 <func0+0x2b4>
movslq %ecx,%rcx
movzbl 0x0(%rbp,%rcx,1),%eax
cmp %al,(%rbx,%rcx,1)
setne %al
movzbl %al,%eax
add %eax,%edx
mov %edx,%eax
sar %eax
and $0x1,%edx
mov $0xffffffff,%edx
cmovne %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
xor %ecx,%ecx
xor %edx,%edx
jmpq 1313 <func0+0xe3>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle loc_1460
mov rdx, rax
lea eax, [rax-1]
cmp eax, 0Eh
jbe loc_1469
mov ecx, edx
pxor xmm1, xmm1
pxor xmm5, xmm5
xor eax, eax
shr ecx, 4
pxor xmm4, xmm4
shl rcx, 4
nop dword ptr [rax+rax+00h]
loc_1268:
movdqu xmm0, xmmword ptr [rbx+rax]
movdqu xmm7, xmmword ptr [rbp+rax+0]
movdqa xmm3, xmm5
add rax, 10h
pcmpeqb xmm0, xmm7
pcmpeqb xmm0, xmm5
pcmpgtb xmm3, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm3
punpckhbw xmm0, xmm3
movdqa xmm3, xmm4
pcmpgtw xmm3, xmm2
movdqa xmm6, xmm2
punpcklwd xmm6, xmm3
punpckhwd xmm2, xmm3
movdqa xmm3, xmm0
psubd xmm1, xmm6
psubd xmm1, xmm2
movdqa xmm2, xmm4
pcmpgtw xmm2, xmm0
punpcklwd xmm3, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm3
psubd xmm1, xmm0
cmp rax, rcx
jnz short loc_1268
movdqa xmm0, xmm1
mov eax, edx
psrldq xmm0, 8
and eax, 0FFFFFFF0h
paddd xmm0, xmm1
mov ecx, eax
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd edi, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm1, xmm0
test dl, 0Fh
jz loc_1449
loc_130B:
mov esi, edx
sub esi, eax
lea r8d, [rsi-1]
cmp r8d, 6
jbe loc_13AA
movq xmm2, qword ptr [rbp+rax+0]
movq xmm0, qword ptr [rbx+rax]
pcmpeqb xmm0, xmm2
pxor xmm2, xmm2
pcmpeqb xmm0, xmm2
pcmpgtb xmm2, xmm0
movdqa xmm3, xmm0
punpcklbw xmm3, xmm2
punpcklbw xmm0, xmm2
pxor xmm2, xmm2
movdqa xmm4, xmm2
movdqa xmm5, xmm3
pshufd xmm0, xmm0, 4Eh ; 'N'
pcmpgtw xmm4, xmm3
pcmpgtw xmm2, xmm0
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
psubd xmm1, xmm5
pshufd xmm3, xmm3, 4Eh ; 'N'
psubd xmm1, xmm3
movdqa xmm3, xmm0
punpcklwd xmm0, xmm2
punpcklwd xmm3, xmm2
pshufd xmm0, xmm0, 4Eh ; 'N'
psubd xmm1, xmm3
psubd xmm1, xmm0
movd edi, xmm1
pshufd xmm7, xmm1, 0E5h
movd eax, xmm7
add edi, eax
mov eax, esi
and eax, 0FFFFFFF8h
add ecx, eax
and esi, 7
jz loc_1449
loc_13AA:
movsxd rax, ecx
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jz short loc_13BB
add edi, 1
loc_13BB:
lea eax, [rcx+1]
cmp edx, eax
jle loc_1449
cdqe
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jz short loc_13D6
add edi, 1
loc_13D6:
lea eax, [rcx+2]
cmp edx, eax
jle short loc_1449
cdqe
movzx esi, byte ptr [rbx+rax]
cmp [rbp+rax+0], sil
jz short loc_13ED
add edi, 1
loc_13ED:
lea eax, [rcx+3]
cmp edx, eax
jle short loc_1449
cdqe
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jz short loc_1404
add edi, 1
loc_1404:
lea eax, [rcx+4]
cmp edx, eax
jle short loc_1449
cdqe
movzx esi, byte ptr [rbx+rax]
cmp [rbp+rax+0], sil
jz short loc_141B
add edi, 1
loc_141B:
lea eax, [rcx+5]
cmp edx, eax
jle short loc_1449
cdqe
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jz short loc_1432
add edi, 1
loc_1432:
add ecx, 6
cmp edx, ecx
jle short loc_1449
movsxd rcx, ecx
movzx eax, byte ptr [rbp+rcx+0]
cmp [rbx+rcx], al
jz short loc_1449
add edi, 1
loc_1449:
test dil, 1
jnz short loc_1478
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
loc_1458:
add rsp, 8
pop rbx
pop rbp
retn
loc_1460:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_1469:
pxor xmm1, xmm1
xor eax, eax
xor ecx, ecx
xor edi, edi
jmp loc_130B
loc_1478:
mov eax, 0FFFFFFFFh
jmp short loc_1458 | long long func0(const char *a1, long long a2)
{
int v4; // eax
int v5; // edx
__m128i v6; // xmm1
long long v7; // rax
__m128i v8; // xmm0
__m128i v9; // xmm7
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; // xmm3
__m128i v15; // xmm1
__m128i v16; // xmm2
long long v17; // rax
__m128i v18; // xmm0
signed int v19; // ecx
int v20; // edi
__m128i v21; // xmm1
int v22; // esi
__m128i v23; // xmm0
__m128i v24; // xmm3
__m128i v25; // xmm0
__m128i v26; // xmm2
__m128i v27; // xmm3
__m128i v28; // xmm1
int v29; // ecx
v4 = strlen(a1);
if ( v4 <= 0 )
return 0LL;
v5 = v4;
if ( (unsigned int)(v4 - 1) <= 0xE )
{
v21 = 0LL;
v17 = 0LL;
v19 = 0;
v20 = 0;
goto LABEL_6;
}
v6 = 0LL;
v7 = 0LL;
do
{
v8 = _mm_loadu_si128((const __m128i *)&a1[v7]);
v9 = _mm_loadu_si128((const __m128i *)(a2 + v7));
v7 += 16LL;
v10 = _mm_cmpeq_epi8(_mm_cmpeq_epi8(v8, v9), (__m128i)0LL);
v11 = _mm_cmpgt_epi8((__m128i)0LL, v10);
v12 = _mm_unpacklo_epi8(v10, v11);
v13 = _mm_unpackhi_epi8(v10, v11);
v14 = _mm_cmpgt_epi16((__m128i)0LL, v12);
v15 = _mm_sub_epi32(_mm_sub_epi32(v6, _mm_unpacklo_epi16(v12, v14)), _mm_unpackhi_epi16(v12, v14));
v16 = _mm_cmpgt_epi16((__m128i)0LL, v13);
v6 = _mm_sub_epi32(_mm_sub_epi32(v15, _mm_unpacklo_epi16(v13, v16)), _mm_unpackhi_epi16(v13, v16));
}
while ( v7 != 16LL * ((unsigned int)v5 >> 4) );
v17 = v5 & 0xFFFFFFF0;
v18 = _mm_add_epi32(_mm_srli_si128(v6, 8), v6);
v19 = v5 & 0xFFFFFFF0;
v20 = _mm_cvtsi128_si32(_mm_add_epi32(v18, _mm_srli_si128(v18, 4)));
v21 = v18;
if ( (v5 & 0xF) != 0 )
{
LABEL_6:
v22 = v5 - v17;
if ( (unsigned int)(v5 - v17 - 1) <= 6 )
goto LABEL_8;
v23 = _mm_cmpeq_epi8(
_mm_cmpeq_epi8(_mm_loadl_epi64((const __m128i *)&a1[v17]), _mm_loadl_epi64((const __m128i *)(a2 + v17))),
(__m128i)0LL);
v24 = _mm_unpacklo_epi8(v23, _mm_cmpgt_epi8((__m128i)0LL, v23));
v25 = _mm_shuffle_epi32(v24, 78);
v26 = _mm_cmpgt_epi16((__m128i)0LL, v25);
v27 = _mm_unpacklo_epi16(v24, _mm_cmpgt_epi16((__m128i)0LL, v24));
v28 = _mm_sub_epi32(
_mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(v21, v27), _mm_shuffle_epi32(v27, 78)),
_mm_unpacklo_epi16(v25, v26)),
_mm_shuffle_epi32(_mm_unpacklo_epi16(v25, v26), 78));
v20 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v28, 229)) + _mm_cvtsi128_si32(v28);
v19 += v22 & 0xFFFFFFF8;
if ( (v22 & 7) != 0 )
{
LABEL_8:
if ( a1[v19] != *(_BYTE *)(a2 + v19) )
++v20;
if ( v5 > v19 + 1 )
{
if ( a1[v19 + 1] != *(_BYTE *)(a2 + v19 + 1) )
++v20;
if ( v5 > v19 + 2 )
{
if ( *(_BYTE *)(a2 + v19 + 2) != a1[v19 + 2] )
++v20;
if ( v5 > v19 + 3 )
{
if ( a1[v19 + 3] != *(_BYTE *)(a2 + v19 + 3) )
++v20;
if ( v5 > v19 + 4 )
{
if ( *(_BYTE *)(a2 + v19 + 4) != a1[v19 + 4] )
++v20;
if ( v5 > v19 + 5 )
{
if ( a1[v19 + 5] != *(_BYTE *)(a2 + v19 + 5) )
++v20;
v29 = v19 + 6;
if ( v5 > v29 && a1[v29] != *(_BYTE *)(a2 + v29) )
++v20;
}
}
}
}
}
}
}
if ( (v20 & 1) != 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(v20 / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101460
MOV RDX,RAX
LEA EAX,[RAX + -0x1]
CMP EAX,0xe
JBE 0x00101469
MOV ECX,EDX
PXOR XMM1,XMM1
PXOR XMM5,XMM5
XOR EAX,EAX
SHR ECX,0x4
PXOR XMM4,XMM4
SHL RCX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101268:
MOVDQU XMM0,xmmword ptr [RBX + RAX*0x1]
MOVDQU XMM7,xmmword ptr [RBP + RAX*0x1]
MOVDQA XMM3,XMM5
ADD RAX,0x10
PCMPEQB XMM0,XMM7
PCMPEQB XMM0,XMM5
PCMPGTB XMM3,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM3
PUNPCKHBW XMM0,XMM3
MOVDQA XMM3,XMM4
PCMPGTW XMM3,XMM2
MOVDQA XMM6,XMM2
PUNPCKLWD XMM6,XMM3
PUNPCKHWD XMM2,XMM3
MOVDQA XMM3,XMM0
PSUBD XMM1,XMM6
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM4
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM3,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
CMP RAX,RCX
JNZ 0x00101268
MOVDQA XMM0,XMM1
MOV EAX,EDX
PSRLDQ XMM0,0x8
AND EAX,0xfffffff0
PADDD XMM0,XMM1
MOV ECX,EAX
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EDI,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM1,XMM0
TEST DL,0xf
JZ 0x00101449
LAB_0010130b:
MOV ESI,EDX
SUB ESI,EAX
LEA R8D,[RSI + -0x1]
CMP R8D,0x6
JBE 0x001013aa
MOVQ XMM2,qword ptr [RBP + RAX*0x1]
MOVQ XMM0,qword ptr [RBX + RAX*0x1]
PCMPEQB XMM0,XMM2
PXOR XMM2,XMM2
PCMPEQB XMM0,XMM2
PCMPGTB XMM2,XMM0
MOVDQA XMM3,XMM0
PUNPCKLBW XMM3,XMM2
PUNPCKLBW XMM0,XMM2
PXOR XMM2,XMM2
MOVDQA XMM4,XMM2
MOVDQA XMM5,XMM3
PSHUFD XMM0,XMM0,0x4e
PCMPGTW XMM4,XMM3
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSUBD XMM1,XMM5
PSHUFD XMM3,XMM3,0x4e
PSUBD XMM1,XMM3
MOVDQA XMM3,XMM0
PUNPCKLWD XMM0,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM0,XMM0,0x4e
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
MOVD EDI,XMM1
PSHUFD XMM7,XMM1,0xe5
MOVD EAX,XMM7
ADD EDI,EAX
MOV EAX,ESI
AND EAX,0xfffffff8
ADD ECX,EAX
AND ESI,0x7
JZ 0x00101449
LAB_001013aa:
MOVSXD RAX,ECX
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JZ 0x001013bb
ADD EDI,0x1
LAB_001013bb:
LEA EAX,[RCX + 0x1]
CMP EDX,EAX
JLE 0x00101449
CDQE
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JZ 0x001013d6
ADD EDI,0x1
LAB_001013d6:
LEA EAX,[RCX + 0x2]
CMP EDX,EAX
JLE 0x00101449
CDQE
MOVZX ESI,byte ptr [RBX + RAX*0x1]
CMP byte ptr [RBP + RAX*0x1],SIL
JZ 0x001013ed
ADD EDI,0x1
LAB_001013ed:
LEA EAX,[RCX + 0x3]
CMP EDX,EAX
JLE 0x00101449
CDQE
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JZ 0x00101404
ADD EDI,0x1
LAB_00101404:
LEA EAX,[RCX + 0x4]
CMP EDX,EAX
JLE 0x00101449
CDQE
MOVZX ESI,byte ptr [RBX + RAX*0x1]
CMP byte ptr [RBP + RAX*0x1],SIL
JZ 0x0010141b
ADD EDI,0x1
LAB_0010141b:
LEA EAX,[RCX + 0x5]
CMP EDX,EAX
JLE 0x00101449
CDQE
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JZ 0x00101432
ADD EDI,0x1
LAB_00101432:
ADD ECX,0x6
CMP EDX,ECX
JLE 0x00101449
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RBP + RCX*0x1]
CMP byte ptr [RBX + RCX*0x1],AL
JZ 0x00101449
ADD EDI,0x1
LAB_00101449:
TEST DIL,0x1
JNZ 0x00101478
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
LAB_00101458:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101460:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET
LAB_00101469:
PXOR XMM1,XMM1
XOR EAX,EAX
XOR ECX,ECX
XOR EDI,EDI
JMP 0x0010130b
LAB_00101478:
MOV EAX,0xffffffff
JMP 0x00101458 | int func0(char *param_1,long param_2)
{
char *pcVar1;
char *pcVar2;
int8 uVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
int auVar12 [14];
int auVar13 [12];
unkbyte10 Var14;
int auVar15 [12];
int auVar16 [14];
int auVar17 [12];
int auVar18 [16];
int auVar19 [16];
int auVar20 [16];
int auVar21 [12];
unkbyte9 Var22;
int6 uVar23;
int4 uVar24;
int2 uVar25;
uint uVar26;
uint uVar27;
size_t sVar28;
long lVar29;
uint uVar30;
short sVar31;
int4 uVar32;
int iVar33;
uint uVar34;
int auVar39 [12];
char cVar53;
short sVar54;
char cVar55;
char cVar56;
char cVar57;
byte bVar58;
int auVar43 [16];
int auVar50 [16];
int iVar59;
int iVar60;
int iVar61;
int iVar62;
int iVar63;
char cVar67;
char cVar68;
char cVar69;
char cVar70;
char cVar71;
char cVar72;
short sVar74;
short sVar75;
int auVar65 [16];
int auVar76 [16];
int auVar81 [16];
int auVar88 [16];
int auVar91 [16];
int auVar95 [16];
int auVar98 [16];
int6 uVar35;
int8 uVar36;
int auVar38 [12];
int auVar44 [16];
int auVar37 [12];
int auVar45 [16];
int auVar51 [16];
int auVar46 [16];
int auVar40 [14];
int auVar42 [16];
int auVar47 [16];
int auVar52 [16];
int auVar48 [16];
int auVar41 [16];
int auVar49 [16];
int auVar64 [12];
int auVar66 [16];
long lVar73;
int auVar77 [16];
int auVar78 [16];
int auVar92 [16];
int auVar82 [16];
int auVar79 [16];
int auVar83 [16];
int auVar89 [16];
int auVar93 [16];
int auVar84 [16];
int auVar80 [16];
int auVar85 [16];
int auVar90 [16];
int auVar94 [16];
int auVar86 [16];
int auVar87 [16];
int auVar96 [16];
int auVar97 [16];
int auVar99 [16];
int auVar100 [16];
sVar28 = strlen(param_1);
uVar26 = (uint)sVar28;
if ((int)uVar26 < 1) {
return 0;
}
if (uVar26 - 1 < 0xf) {
iVar61 = 0;
iVar62 = 0;
uVar27 = 0;
uVar34 = 0;
}
else {
iVar59 = 0;
iVar60 = 0;
iVar61 = 0;
iVar62 = 0;
lVar29 = 0;
do {
pcVar1 = param_1 + lVar29;
pcVar2 = (char *)(param_2 + lVar29);
lVar29 = lVar29 + 0x10;
bVar4 = *pcVar1 != *pcVar2;
bVar8 = pcVar1[8] != pcVar2[8];
bVar9 = pcVar1[9] != pcVar2[9];
bVar10 = pcVar1[10] != pcVar2[10];
bVar11 = pcVar1[0xb] != pcVar2[0xb];
cVar57 = -(pcVar1[7] != pcVar2[7]);
uVar25 = CONCAT11(-(pcVar1[7] != pcVar2[7]),cVar57);
uVar24 = CONCAT31(CONCAT21(uVar25,-(pcVar1[6] != pcVar2[6])),-(pcVar1[6] != pcVar2[6]));
uVar23 = CONCAT51(CONCAT41(uVar24,-(pcVar1[5] != pcVar2[5])),-(pcVar1[5] != pcVar2[5]));
Var22 = CONCAT72(CONCAT61(uVar23,-(pcVar1[4] != pcVar2[4])),
CONCAT11(-(pcVar1[4] != pcVar2[4]),cVar57));
lVar73 = (long)((unkuint9)Var22 >> 8);
Var14 = CONCAT91(CONCAT81(lVar73,-(pcVar1[3] != pcVar2[3])),-(pcVar1[3] != pcVar2[3]));
auVar13._2_10_ = Var14;
auVar13[1] = -(pcVar1[2] != pcVar2[2]);
auVar13[0] = -(pcVar1[2] != pcVar2[2]);
auVar12._2_12_ = auVar13;
auVar12[1] = -(pcVar1[1] != pcVar2[1]);
auVar12[0] = -(pcVar1[1] != pcVar2[1]);
auVar65._0_2_ = CONCAT11(-bVar4,-bVar4);
auVar65._2_14_ = auVar12;
uVar32 = CONCAT13(-bVar9,CONCAT12(-bVar9,CONCAT11(-bVar8,-bVar8)));
uVar35 = CONCAT15(-bVar10,CONCAT14(-bVar10,uVar32));
uVar36 = CONCAT17(-bVar11,CONCAT16(-bVar11,uVar35));
auVar37._0_10_ =
CONCAT19(-(pcVar1[0xc] != pcVar2[0xc]),CONCAT18(-(pcVar1[0xc] != pcVar2[0xc]),uVar36));
auVar37[10] = -(pcVar1[0xd] != pcVar2[0xd]);
auVar37[0xb] = -(pcVar1[0xd] != pcVar2[0xd]);
auVar40[0xc] = -(pcVar1[0xe] != pcVar2[0xe]);
auVar40._0_12_ = auVar37;
auVar40[0xd] = -(pcVar1[0xe] != pcVar2[0xe]);
auVar41[0xe] = -(pcVar1[0xf] != pcVar2[0xf]);
auVar41._0_14_ = auVar40;
auVar41[0xf] = -(pcVar1[0xf] != pcVar2[0xf]);
sVar31 = (short)Var14;
sVar54 = (short)((unkuint9)Var22 >> 8);
sVar74 = (short)uVar23;
sVar75 = (short)uVar24;
auVar100._0_12_ = auVar65._0_12_;
auVar100._12_2_ = sVar31;
auVar100._14_2_ = -(ushort)(sVar31 < 0);
auVar99._12_4_ = auVar100._12_4_;
auVar99._0_10_ = auVar65._0_10_;
auVar99._10_2_ = -(ushort)(auVar13._0_2_ < 0);
auVar98._10_6_ = auVar99._10_6_;
auVar98._0_8_ = auVar65._0_8_;
auVar98._8_2_ = auVar13._0_2_;
auVar15._4_8_ = auVar98._8_8_;
auVar15._2_2_ = -(ushort)(auVar12._0_2_ < 0);
auVar15._0_2_ = auVar12._0_2_;
iVar63 = CONCAT22(-(ushort)(sVar54 < 0),sVar54);
auVar64._0_8_ = CONCAT26(-(ushort)(sVar74 < 0),CONCAT24(sVar74,iVar63));
auVar64._8_2_ = sVar75;
auVar64._10_2_ = -(ushort)(sVar75 < 0);
auVar66._12_2_ = uVar25;
auVar66._0_12_ = auVar64;
auVar66._14_2_ = -(ushort)(lVar73 < 0);
sVar31 = (short)((unkuint10)auVar37._0_10_ >> 0x40);
auVar80._12_2_ = (short)((ulong)uVar36 >> 0x30);
auVar80._0_12_ = auVar37;
auVar80._14_2_ = -(ushort)bVar11;
auVar79._12_4_ = auVar80._12_4_;
auVar79._10_2_ = -(ushort)bVar10;
auVar79._0_10_ = auVar37._0_10_;
auVar78._10_6_ = auVar79._10_6_;
auVar78._8_2_ = (short)((uint6)uVar35 >> 0x20);
auVar78._0_8_ = uVar36;
auVar77._8_8_ = auVar78._8_8_;
auVar77._6_2_ = -(ushort)bVar9;
auVar77._0_6_ = uVar35;
auVar76._6_10_ = auVar77._6_10_;
auVar76._4_2_ = (short)((uint)uVar32 >> 0x10);
auVar76._0_4_ = uVar32;
iVar33 = CONCAT22(-(ushort)(sVar31 < 0),sVar31);
auVar38._0_8_ = CONCAT26(-(ushort)(auVar37._10_2_ < 0),CONCAT24(auVar37._10_2_,iVar33));
auVar38._8_2_ = auVar40._12_2_;
auVar38._10_2_ = -(ushort)(auVar40._12_2_ < 0);
auVar42._12_2_ = auVar41._14_2_;
auVar42._0_12_ = auVar38;
auVar42._14_2_ = -(ushort)(auVar41._14_2_ < 0);
iVar59 = (((iVar59 - CONCAT22(-(ushort)bVar4,auVar65._0_2_)) - iVar63) -
CONCAT22(-(ushort)bVar8,CONCAT11(-bVar8,-bVar8))) - iVar33;
iVar60 = (((iVar60 - auVar15._0_4_) - (int)((ulong)auVar64._0_8_ >> 0x20)) - auVar76._4_4_) -
(int)((ulong)auVar38._0_8_ >> 0x20);
iVar61 = (((iVar61 - auVar98._8_4_) - auVar64._8_4_) - auVar78._8_4_) - auVar38._8_4_;
iVar62 = (((iVar62 - auVar99._12_4_) - auVar66._12_4_) - auVar79._12_4_) - auVar42._12_4_;
} while (lVar29 != (sVar28 >> 4 & 0xfffffff) << 4);
uVar27 = uVar26 & 0xfffffff0;
uVar34 = iVar61 + iVar59 + iVar62 + iVar60;
iVar61 = iVar61 + iVar59;
iVar62 = iVar62 + iVar60;
if ((sVar28 & 0xf) == 0) goto LAB_00101449;
}
uVar30 = uVar26 - uVar27;
if (6 < uVar30 - 1) {
uVar36 = *(int8 *)(param_2 + (ulong)uVar27);
uVar3 = *(int8 *)(param_1 + uVar27);
bVar4 = (char)uVar3 != (char)uVar36;
bVar8 = (char)((ulong)uVar3 >> 8) != (char)((ulong)uVar36 >> 8);
bVar9 = (char)((ulong)uVar3 >> 0x10) != (char)((ulong)uVar36 >> 0x10);
bVar10 = (char)((ulong)uVar3 >> 0x18) != (char)((ulong)uVar36 >> 0x18);
bVar11 = (char)((ulong)uVar3 >> 0x20) != (char)((ulong)uVar36 >> 0x20);
bVar5 = (char)((ulong)uVar3 >> 0x28) != (char)((ulong)uVar36 >> 0x28);
bVar6 = (char)((ulong)uVar3 >> 0x30) != (char)((ulong)uVar36 >> 0x30);
bVar7 = (char)((ulong)uVar3 >> 0x38) != (char)((ulong)uVar36 >> 0x38);
auVar43[0] = -bVar4;
cVar57 = -bVar8;
cVar53 = -bVar11;
cVar55 = -bVar5;
cVar56 = -bVar6;
bVar58 = -bVar7;
auVar44._0_9_ = (unkuint9)bVar58 << 0x38;
auVar45._0_10_ = (unkuint10)bVar58 << 0x38;
auVar46._0_11_ = ZEXT111(bVar58) << 0x38;
auVar47._0_12_ = ZEXT112(bVar58) << 0x38;
auVar48._0_13_ = ZEXT113(bVar58) << 0x38;
auVar49._0_14_ = ZEXT114(bVar58) << 0x38;
cVar67 = -bVar8;
cVar68 = -bVar10;
cVar69 = -bVar11;
cVar70 = -bVar5;
cVar71 = -bVar6;
cVar72 = -bVar7;
auVar87[0xe] = bVar58;
auVar87._0_14_ = auVar49._0_14_;
auVar87[0xf] = cVar72;
auVar86._14_2_ = auVar87._14_2_;
auVar86[0xd] = cVar71;
auVar86._0_13_ = auVar48._0_13_;
auVar85._13_3_ = auVar86._13_3_;
auVar85[0xc] = cVar56;
auVar85._0_12_ = auVar47._0_12_;
auVar84._12_4_ = auVar85._12_4_;
auVar84[0xb] = cVar70;
auVar84._0_11_ = auVar46._0_11_;
auVar83._11_5_ = auVar84._11_5_;
auVar83[10] = cVar55;
auVar83._0_10_ = auVar45._0_10_;
auVar82._10_6_ = auVar83._10_6_;
auVar82[9] = cVar69;
auVar82._0_9_ = auVar44._0_9_;
Var14 = CONCAT91(CONCAT81((long)(CONCAT72(auVar82._9_7_,CONCAT11(cVar53,bVar58)) >> 8),cVar68),
-bVar10);
auVar17._2_10_ = Var14;
auVar17[1] = -bVar9;
auVar17[0] = -bVar9;
auVar16._2_12_ = auVar17;
auVar16[1] = cVar67;
auVar16[0] = cVar57;
auVar81._0_2_ = CONCAT11(-bVar4,auVar43[0]);
auVar81._2_14_ = auVar16;
auVar49[0xe] = bVar58;
auVar49[0xf] = cVar72;
auVar48._14_2_ = auVar49._14_2_;
auVar48[0xd] = cVar71;
auVar47._13_3_ = auVar48._13_3_;
auVar47[0xc] = cVar56;
auVar46._12_4_ = auVar47._12_4_;
auVar46[0xb] = cVar70;
auVar45._11_5_ = auVar46._11_5_;
auVar45[10] = cVar55;
auVar44._10_6_ = auVar45._10_6_;
auVar44[9] = cVar69;
Var22 = CONCAT72(auVar44._9_7_,CONCAT11(cVar53,bVar58));
lVar29 = (long)((unkuint9)Var22 >> 8);
auVar20._1_8_ = lVar29;
auVar20[0] = cVar68;
auVar20._9_7_ = 0;
auVar19._10_6_ = 0;
auVar19._0_10_ = SUB1610(auVar20 << 0x38,6);
auVar18._11_5_ = 0;
auVar18._0_11_ = SUB1611(auVar19 << 0x30,5);
auVar43._4_12_ = SUB1612(auVar18 << 0x28,4);
auVar43[3] = cVar67;
auVar43[2] = cVar57;
auVar43[1] = -bVar4;
iVar59 = (int)((unkuint9)Var22 >> 8);
auVar39._8_4_ = auVar43._0_4_;
auVar39._0_8_ = lVar29;
sVar74 = auVar17._0_2_;
sVar75 = (short)Var14;
sVar31 = (short)((unkuint9)Var22 >> 8);
sVar54 = auVar47._12_2_;
auVar97._0_12_ = auVar81._0_12_;
auVar97._12_2_ = sVar75;
auVar97._14_2_ = -(ushort)(sVar75 < 0);
auVar96._12_4_ = auVar97._12_4_;
auVar96._0_10_ = auVar81._0_10_;
auVar96._10_2_ = -(ushort)(sVar74 < 0);
auVar95._10_6_ = auVar96._10_6_;
auVar95._0_8_ = auVar81._0_8_;
auVar95._8_2_ = sVar74;
auVar21._4_8_ = auVar95._8_8_;
auVar21._2_2_ = -(ushort)(auVar16._0_2_ < 0);
auVar21._0_2_ = auVar16._0_2_;
auVar90._12_2_ = sVar75;
auVar90._0_12_ = auVar97._0_12_;
auVar90._14_2_ = -(ushort)(sVar75 < 0);
auVar89._12_4_ = auVar90._12_4_;
auVar89._10_2_ = -(ushort)(sVar74 < 0);
auVar89._0_10_ = auVar96._0_10_;
auVar88._10_6_ = auVar89._10_6_;
auVar88._8_2_ = sVar74;
auVar88._0_8_ = auVar95._0_8_;
auVar52._12_2_ = auVar48._14_2_;
auVar52._0_12_ = auVar39;
auVar52._14_2_ = -(ushort)(lVar29 < 0);
auVar51._12_4_ = auVar52._12_4_;
auVar51._0_10_ = auVar39._0_10_;
auVar51._10_2_ = -(ushort)(sVar54 < 0);
auVar50._10_6_ = auVar51._10_6_;
auVar50._8_2_ = sVar54;
auVar50._0_8_ = lVar29;
auVar94._12_2_ = auVar48._14_2_;
auVar94._0_12_ = auVar39;
auVar94._14_2_ = -(ushort)(lVar29 < 0);
auVar93._12_4_ = auVar94._12_4_;
auVar93._10_2_ = -(ushort)(sVar54 < 0);
auVar93._0_10_ = auVar51._0_10_;
auVar92._10_6_ = auVar93._10_6_;
auVar92._8_2_ = sVar54;
auVar92._0_8_ = lVar29;
auVar91._8_8_ = auVar92._8_8_;
auVar91._6_2_ = -(ushort)(iVar59 < 0);
auVar91._4_2_ = auVar45._10_2_;
auVar91._0_4_ = iVar59;
uVar34 = ((((iVar61 - CONCAT22(-(ushort)bVar4,auVar81._0_2_)) - auVar88._8_4_) -
CONCAT22(-(ushort)(sVar31 < 0),sVar31)) - auVar50._8_4_) +
((((iVar62 - auVar21._0_4_) - auVar89._12_4_) - auVar91._4_4_) - auVar51._12_4_);
uVar27 = uVar27 + (uVar30 & 0xfffffff8);
if ((uVar30 & 7) == 0) goto LAB_00101449;
}
if (param_1[(int)uVar27] != *(char *)(param_2 + (int)uVar27)) {
uVar34 = uVar34 + 1;
}
iVar61 = uVar27 + 1;
if (iVar61 < (int)uVar26) {
if (param_1[iVar61] != *(char *)(param_2 + iVar61)) {
uVar34 = uVar34 + 1;
}
iVar61 = uVar27 + 2;
if (iVar61 < (int)uVar26) {
if (*(char *)(param_2 + iVar61) != param_1[iVar61]) {
uVar34 = uVar34 + 1;
}
iVar61 = uVar27 + 3;
if (iVar61 < (int)uVar26) {
if (param_1[iVar61] != *(char *)(param_2 + iVar61)) {
uVar34 = uVar34 + 1;
}
iVar61 = uVar27 + 4;
if (iVar61 < (int)uVar26) {
if (*(char *)(param_2 + iVar61) != param_1[iVar61]) {
uVar34 = uVar34 + 1;
}
iVar61 = uVar27 + 5;
if (iVar61 < (int)uVar26) {
if (param_1[iVar61] != *(char *)(param_2 + iVar61)) {
uVar34 = uVar34 + 1;
}
iVar61 = uVar27 + 6;
if ((iVar61 < (int)uVar26) && (param_1[iVar61] != *(char *)(param_2 + iVar61))) {
uVar34 = uVar34 + 1;
}
}
}
}
}
}
LAB_00101449:
if ((uVar34 & 1) == 0) {
iVar61 = (int)uVar34 / 2;
}
else {
iVar61 = -1;
}
return iVar61;
} |
6,276 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(tuple1) / sizeof(tuple1[0]); // Number of elements in tuple1
size_t tuple2_size = sizeof(tuple2) / sizeof(tuple2[0]); // Number of elements in tuple2
// Assert the sizes are correct
assert(func0(tuple1, tuple1_size) == sizeof(tuple1));
assert(func0(tuple2, tuple2_size) == sizeof(tuple2));
printf("Assertions passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movq $0x0,-0x10(%rbp)
movq $0x0,-0x8(%rbp)
jmp 11b5 <func0+0x2c>
addq $0x8,-0x10(%rbp)
addq $0x1,-0x8(%rbp)
mov -0x8(%rbp),%rax
cmp -0x20(%rbp),%rax
jb 11ab <func0+0x22>
mov -0x10(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_11B5
loc_11AB:
add [rbp+var_10], 8
add [rbp+var_8], 1
loc_11B5:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jb short loc_11AB
mov rax, [rbp+var_10]
pop rbp
retn | long long func0(long long a1, unsigned long long a2)
{
long long v3; // [rsp+10h] [rbp-10h]
unsigned long long i; // [rsp+18h] [rbp-8h]
v3 = 0LL;
for ( i = 0LL; i < a2; ++i )
v3 += 8LL;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001011b5
LAB_001011ab:
ADD qword ptr [RBP + -0x10],0x8
ADD qword ptr [RBP + -0x8],0x1
LAB_001011b5:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001011ab
MOV RAX,qword ptr [RBP + -0x10]
POP RBP
RET | long func0(int8 param_1,ulong param_2)
{
int8 local_18;
int8 local_10;
local_18 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
local_18 = local_18 + 8;
}
return local_18;
} |
6,277 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(tuple1) / sizeof(tuple1[0]); // Number of elements in tuple1
size_t tuple2_size = sizeof(tuple2) / sizeof(tuple2[0]); // Number of elements in tuple2
// Assert the sizes are correct
assert(func0(tuple1, tuple1_size) == sizeof(tuple1));
assert(func0(tuple2, tuple2_size) == sizeof(tuple2));
printf("Assertions passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %rsi,%rsi
je 1165 <func0+0x1c>
mov $0x0,%eax
add $0x1,%rax
cmp %rax,%rsi
jne 1157 <func0+0xe>
shl $0x3,%rax
retq
mov %rsi,%rax
retq
| func0:
endbr64
test rsi, rsi
jz short loc_1169
mov edx, 0
loc_1157:
add rdx, 1
cmp rsi, rdx
jnz short loc_1157
lea rax, ds:0[rdx*8]
retn
loc_1169:
mov rax, rsi
retn | long long func0(long long a1, long long a2)
{
long long i; // rdx
if ( !a2 )
return 0LL;
for ( i = 0LL; i != a2; ++i )
;
return 8 * i;
} | func0:
ENDBR64
TEST RSI,RSI
JZ 0x00101169
MOV EDX,0x0
LAB_00101157:
ADD RDX,0x1
CMP RSI,RDX
JNZ 0x00101157
LEA RAX,[RDX*0x8]
RET
LAB_00101169:
MOV RAX,RSI
RET | long func0(int8 param_1,long param_2)
{
long lVar1;
if (param_2 != 0) {
lVar1 = 0;
do {
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
return lVar1 * 8;
}
return 0;
} |
6,278 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(tuple1) / sizeof(tuple1[0]); // Number of elements in tuple1
size_t tuple2_size = sizeof(tuple2) / sizeof(tuple2[0]); // Number of elements in tuple2
// Assert the sizes are correct
assert(func0(tuple1, tuple1_size) == sizeof(tuple1));
assert(func0(tuple2, tuple2_size) == sizeof(tuple2));
printf("Assertions passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
lea 0x0(,%rsi,8),%rax
retq
nopl (%rax)
| func0:
endbr64
lea rax, ds:0[rsi*8]
retn | long long func0(long long a1, long long a2)
{
return 8 * a2;
} | func0:
ENDBR64
LEA RAX,[RSI*0x8]
RET | long func0(int8 param_1,long param_2)
{
return param_2 * 8;
} |
6,279 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(tuple1) / sizeof(tuple1[0]); // Number of elements in tuple1
size_t tuple2_size = sizeof(tuple2) / sizeof(tuple2[0]); // Number of elements in tuple2
// Assert the sizes are correct
assert(func0(tuple1, tuple1_size) == sizeof(tuple1));
assert(func0(tuple2, tuple2_size) == sizeof(tuple2));
printf("Assertions passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
lea 0x0(,%rsi,8),%rax
retq
nopl (%rax)
| func0:
endbr64
lea rax, ds:0[rsi*8]
retn | long long func0(long long a1, long long a2)
{
return 8 * a2;
} | func0:
ENDBR64
LEA RAX,[RSI*0x8]
RET | long func0(int8 param_1,long param_2)
{
return param_2 * 8;
} |
6,280 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr1[], int arr2[], int m, int n, int k) {
int sorted1[m + n];
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
d++;
i++;
}
while (j < n) {
sorted1[d] = arr2[j];
d++;
j++;
}
return sorted1[k - 1];
}
| int main() {
int arr1_1[] = {2, 3, 6, 7, 9};
int arr2_1[] = {1, 4, 8, 10};
int arr1_2[] = {100, 112, 256, 349, 770};
int arr2_2[] = {72, 86, 113, 119, 265, 445, 892};
int arr1_3[] = {3, 4, 7, 8, 10};
int arr2_3[] = {2, 5, 9, 11};
assert(func0(arr1_1, arr2_1, 5, 4, 5) == 6);
assert(func0(arr1_2, arr2_2, 5, 7, 7) == 256);
assert(func0(arr1_3, arr2_3, 5, 4, 6) == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %edx,-0x54(%rbp)
mov %ecx,-0x58(%rbp)
mov %r8d,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x54(%rbp),%edx
mov -0x58(%rbp),%eax
add %edx,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 121c <func0+0xb3>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1205 <func0+0x9c>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1246 <func0+0xdd>
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,-0x20(%rbp)
movl $0x0,-0x30(%rbp)
movl $0x0,-0x34(%rbp)
movl $0x0,-0x2c(%rbp)
jmpq 12f7 <func0+0x18e>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x50(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 12cc <func0+0x163>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x30(%rbp)
jmp 12f3 <func0+0x18a>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x50(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x34(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x30(%rbp),%eax
cmp -0x54(%rbp),%eax
jge 1338 <func0+0x1cf>
mov -0x34(%rbp),%eax
cmp -0x58(%rbp),%eax
jl 1273 <func0+0x10a>
jmp 1338 <func0+0x1cf>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x54(%rbp),%eax
jl 130d <func0+0x1a4>
jmp 136d <func0+0x204>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x50(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x58(%rbp),%eax
jl 1342 <func0+0x1d9>
mov -0x5c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rsi
xor %fs:0x28,%rsi
je 139c <func0+0x233>
callq 1060 <__stack_chk_fail@plt>
lea -0x10(%rbp),%rsp
pop %r12
pop %r13
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+var_48], ecx
mov [rbp+var_4C], r8d
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov edx, [rbp+var_44]
mov eax, [rbp+var_48]
add eax, edx
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
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_11E6:
cmp rsp, rdx
jz short loc_11FD
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11E6
loc_11FD:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1227
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1227:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp loc_12D8
loc_1254:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_20]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_12AD
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_24], 1
jmp short loc_12D4
loc_12AD:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_20], 1
loc_12D4:
add [rbp+var_1C], 1
loc_12D8:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_44]
jge short loc_1319
mov eax, [rbp+var_20]
cmp eax, [rbp+var_48]
jl loc_1254
jmp short loc_1319
loc_12EE:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_1C], 1
add [rbp+var_24], 1
loc_1319:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_44]
jl short loc_12EE
jmp short loc_134E
loc_1323:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_1C], 1
add [rbp+var_20], 1
loc_134E:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_48]
jl short loc_1323
mov eax, [rbp+var_4C]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_137D
call ___stack_chk_fail
locret_137D:
leave
retn | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
unsigned long long v5; // rax
void *v6; // rsp
_BYTE v8[4]; // [rsp+8h] [rbp-50h] BYREF
int v9; // [rsp+Ch] [rbp-4Ch]
int v10; // [rsp+10h] [rbp-48h]
int v11; // [rsp+14h] [rbp-44h]
long long v12; // [rsp+18h] [rbp-40h]
long long v13; // [rsp+20h] [rbp-38h]
int v14; // [rsp+34h] [rbp-24h]
int v15; // [rsp+38h] [rbp-20h]
int v16; // [rsp+3Ch] [rbp-1Ch]
long long v17; // [rsp+40h] [rbp-18h]
_BYTE *v18; // [rsp+48h] [rbp-10h]
unsigned long long v19; // [rsp+50h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v19 = __readfsqword(0x28u);
v17 = a3 + a4 - 1LL;
v5 = 16 * ((4LL * (a3 + a4) + 15) / 0x10uLL);
while ( v8 != &v8[-(v5 & 0xFFFFFFFFFFFFF000LL)] )
;
v6 = alloca(v5 & 0xFFF);
if ( (v5 & 0xFFF) != 0 )
*(_QWORD *)&v8[(v5 & 0xFFF) - 8] = *(_QWORD *)&v8[(v5 & 0xFFF) - 8];
v18 = v8;
v14 = 0;
v15 = 0;
v16 = 0;
while ( v14 < v11 && v15 < v10 )
{
if ( *(_DWORD *)(4LL * v14 + v13) >= *(_DWORD *)(4LL * v15 + v12) )
*(_DWORD *)&v18[4 * v16] = *(_DWORD *)(4LL * v15++ + v12);
else
*(_DWORD *)&v18[4 * v16] = *(_DWORD *)(4LL * v14++ + v13);
++v16;
}
while ( v14 < v11 )
*(_DWORD *)&v18[4 * v16++] = *(_DWORD *)(4LL * v14++ + v13);
while ( v15 < v10 )
*(_DWORD *)&v18[4 * v16++] = *(_DWORD *)(4LL * v15++ + v12);
return *(unsigned int *)&v18[4 * v9 - 4];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV dword ptr [RBP + -0x48],ECX
MOV dword ptr [RBP + -0x4c],R8D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EDX,dword ptr [RBP + -0x44]
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,EDX
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
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_001011e6:
CMP RSP,RDX
JZ 0x001011fd
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e6
LAB_001011fd:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101227
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101227:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001012d8
LAB_00101254:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001012ad
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x24],0x1
JMP 0x001012d4
LAB_001012ad:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x20],0x1
LAB_001012d4:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012d8:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x00101319
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x48]
JL 0x00101254
JMP 0x00101319
LAB_001012ee:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x1c],0x1
ADD dword ptr [RBP + -0x24],0x1
LAB_00101319:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x001012ee
JMP 0x0010134e
LAB_00101323:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x1c],0x1
ADD dword ptr [RBP + -0x20],0x1
LAB_0010134e:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x48]
JL 0x00101323
MOV EAX,dword ptr [RBP + -0x4c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010137d
CALL 0x00101060
LAB_0010137d:
LEAVE
RET | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_58 [4];
int local_54;
int local_50;
int local_4c;
long local_48;
long local_40;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = param_1;
local_48 = param_2;
local_4c = param_3;
local_50 = param_4;
local_54 = param_5;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_4 + param_3) + -1;
uVar2 = (((long)(param_4 + param_3) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_58; puVar3 != auStack_58 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
local_2c = 0;
local_28 = 0;
local_24 = 0;
while ((local_2c < local_4c && (local_28 < local_50))) {
if (*(int *)(local_40 + (long)local_2c * 4) < *(int *)(local_48 + (long)local_28 * 4)) {
*(int4 *)(puVar3 + (long)local_24 * 4 + lVar1) =
*(int4 *)(local_40 + (long)local_2c * 4);
local_2c = local_2c + 1;
}
else {
*(int4 *)(puVar3 + (long)local_24 * 4 + lVar1) =
*(int4 *)(local_48 + (long)local_28 * 4);
local_28 = local_28 + 1;
}
local_24 = local_24 + 1;
}
for (; local_2c < local_4c; local_2c = local_2c + 1) {
*(int4 *)(puVar3 + (long)local_24 * 4 + lVar1) =
*(int4 *)(local_40 + (long)local_2c * 4);
local_24 = local_24 + 1;
}
for (; local_28 < local_50; local_28 = local_28 + 1) {
*(int4 *)(puVar3 + (long)local_24 * 4 + lVar1) =
*(int4 *)(local_48 + (long)local_28 * 4);
local_24 = local_24 + 1;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar3 + (long)(local_54 + -1) * 4 + lVar1);
}
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,281 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr1[], int arr2[], int m, int n, int k) {
int sorted1[m + n];
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
d++;
i++;
}
while (j < n) {
sorted1[d] = arr2[j];
d++;
j++;
}
return sorted1[k - 1];
}
| int main() {
int arr1_1[] = {2, 3, 6, 7, 9};
int arr2_1[] = {1, 4, 8, 10};
int arr1_2[] = {100, 112, 256, 349, 770};
int arr2_2[] = {72, 86, 113, 119, 265, 445, 892};
int arr1_3[] = {3, 4, 7, 8, 10};
int arr2_3[] = {2, 5, 9, 11};
assert(func0(arr1_1, arr2_1, 5, 4, 5) == 6);
assert(func0(arr1_2, arr2_2, 5, 7, 7) == 256);
assert(func0(arr1_3, arr2_3, 5, 4, 6) == 8);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea (%rdx,%rcx,1),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r9
and $0xfffffffffffffff0,%r9
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11c3 <func0+0x5a>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ac <func0+0x43>
mov %r9,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d9 <func0+0x70>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r12
mov %r12,%r13
test %edx,%edx
jle 122d <func0+0xc4>
test %ecx,%ecx
jle 122d <func0+0xc4>
mov $0x1,%r9d
mov $0x0,%r11d
mov $0x0,%eax
jmp 1215 <func0+0xac>
add $0x1,%eax
mov %ebx,%r10d
mov %r10d,-0x4(%r13,%r9,4)
mov %r9d,%ebx
add $0x1,%r9
cmp %edx,%r11d
jge 123d <func0+0xd4>
cmp %ecx,%eax
jge 123d <func0+0xd4>
movslq %r11d,%r10
mov (%rdi,%r10,4),%r10d
movslq %eax,%rbx
mov (%rsi,%rbx,4),%ebx
cmp %ebx,%r10d
jge 11fa <func0+0x91>
add $0x1,%r11d
jmp 1200 <func0+0x97>
mov $0x0,%ebx
mov $0x0,%r11d
mov $0x0,%eax
cmp %r11d,%edx
jle 1268 <func0+0xff>
movslq %r11d,%r9
movslq %ebx,%r10
sub %r9,%r10
lea (%r12,%r10,4),%r13
mov (%rdi,%r9,4),%r10d
mov %r10d,0x0(%r13,%r9,4)
add $0x1,%r9
cmp %r9d,%edx
jg 124f <func0+0xe6>
add %ebx,%edx
sub %r11d,%edx
mov %edx,%ebx
cmp %eax,%ecx
jle 1286 <func0+0x11d>
cltq
movslq %ebx,%rdx
sub %rax,%rdx
lea (%r12,%rdx,4),%rdi
mov (%rsi,%rax,4),%edx
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%ecx
jg 1278 <func0+0x10f>
sub $0x1,%r8d
movslq %r8d,%r8
mov (%r12,%r8,4),%eax
mov -0x28(%rbp),%rsi
xor %fs:0x28,%rsi
jne 12ab <func0+0x142>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r11, rsi
mov edi, edx
mov r9d, ecx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [rdx+rcx]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11B4:
cmp rsp, rdx
jz short loc_11CB
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11B4
loc_11CB:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11E1
or [rsp+rax+30h+var_38], 0
loc_11E1:
mov r12, rsp
test edi, edi
jle short loc_1230
test r9d, r9d
jle short loc_1230
mov edx, 1
mov eax, 0
mov esi, 0
jmp short loc_1219
loc_11FE:
add eax, 1
mov ecx, r10d
loc_1204:
mov [r12+rdx*4-4], ecx
mov r10d, edx
add rdx, 1
cmp esi, edi
jge short loc_1240
cmp eax, r9d
jge short loc_1240
loc_1219:
movsxd rcx, esi
mov ecx, [rbx+rcx*4]
movsxd r10, eax
mov r10d, [r11+r10*4]
cmp ecx, r10d
jge short loc_11FE
add esi, 1
jmp short loc_1204
loc_1230:
mov r10d, 0
mov eax, 0
mov esi, 0
loc_1240:
cmp edi, esi
jle short loc_1269
movsxd rdx, esi
movsxd rcx, r10d
sub rcx, rdx
lea r13, [r12+rcx*4]
loc_1251:
mov ecx, [rbx+rdx*4]
mov [r13+rdx*4+0], ecx
add rdx, 1
cmp edi, edx
jg short loc_1251
add edi, r10d
sub edi, esi
mov r10d, edi
loc_1269:
cmp r9d, eax
jle short loc_128A
cdqe
movsxd r10, r10d
sub r10, rax
lea rcx, [r12+r10*4]
loc_127A:
mov edx, [r11+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp r9d, eax
jg short loc_127A
loc_128A:
sub r8d, 1
movsxd r8, r8d
mov eax, [r12+r8*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_12AF
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_12AF:
call ___stack_chk_fail | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
long long v9; // rax
__int16 v10; // cx
signed long long v11; // rax
void *v12; // rsp
long long v13; // rdx
long long v14; // rax
int v15; // esi
int v16; // ecx
int v17; // r10d
int v18; // r10d
long long v19; // rdx
long long v20; // r10
_DWORD v23[2]; // [rsp+8h] [rbp-30h] BYREF
unsigned long long v24; // [rsp+10h] [rbp-28h]
v24 = __readfsqword(0x28u);
v9 = 4LL * (a3 + a4) + 15;
v10 = (4 * (a3 + a4) + 15) & 0xFFF0;
while ( v23 != (_DWORD *)((char *)v23 - (v9 & 0xFFFFFFFFFFFFF000LL)) )
;
v11 = v10 & 0xFFF;
v12 = alloca(v11);
if ( (v10 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v23[-2] + v11) = *(_QWORD *)((char *)&v23[-2] + v11);
if ( a3 <= 0 || a4 <= 0 )
{
v17 = 0;
LODWORD(v14) = 0;
v15 = 0;
}
else
{
v13 = 1LL;
LODWORD(v14) = 0;
v15 = 0;
do
{
v16 = *(_DWORD *)(a1 + 4LL * v15);
v18 = *(_DWORD *)(a2 + 4LL * (int)v14);
if ( v16 >= v18 )
{
LODWORD(v14) = v14 + 1;
v16 = v18;
}
else
{
++v15;
}
v23[v13 - 1] = v16;
v17 = v13++;
}
while ( v15 < a3 && (int)v14 < a4 );
}
if ( a3 > v15 )
{
v19 = v15;
do
{
v23[v17 - (long long)v15 + v19] = *(_DWORD *)(a1 + 4 * v19);
++v19;
}
while ( a3 > (int)v19 );
v17 = v17 + a3 - v15;
}
if ( a4 > (int)v14 )
{
v14 = (int)v14;
v20 = v17 - (long long)(int)v14;
do
{
v23[v20 + v14] = *(_DWORD *)(a2 + 4 * v14);
++v14;
}
while ( a4 > (int)v14 );
}
return (unsigned int)v23[a5 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R11,RSI
MOV EDI,EDX
MOV R9D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[RDX + RCX*0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011b4:
CMP RSP,RDX
JZ 0x001011cb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011b4
LAB_001011cb:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011e1
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011e1:
MOV R12,RSP
TEST EDI,EDI
JLE 0x00101230
TEST R9D,R9D
JLE 0x00101230
MOV EDX,0x1
MOV EAX,0x0
MOV ESI,0x0
JMP 0x00101219
LAB_001011fe:
ADD EAX,0x1
MOV ECX,R10D
LAB_00101204:
MOV dword ptr [R12 + RDX*0x4 + -0x4],ECX
MOV R10D,EDX
ADD RDX,0x1
CMP ESI,EDI
JGE 0x00101240
CMP EAX,R9D
JGE 0x00101240
LAB_00101219:
MOVSXD RCX,ESI
MOV ECX,dword ptr [RBX + RCX*0x4]
MOVSXD R10,EAX
MOV R10D,dword ptr [R11 + R10*0x4]
CMP ECX,R10D
JGE 0x001011fe
ADD ESI,0x1
JMP 0x00101204
LAB_00101230:
MOV R10D,0x0
MOV EAX,0x0
MOV ESI,0x0
LAB_00101240:
CMP EDI,ESI
JLE 0x00101269
MOVSXD RDX,ESI
MOVSXD RCX,R10D
SUB RCX,RDX
LEA R13,[R12 + RCX*0x4]
LAB_00101251:
MOV ECX,dword ptr [RBX + RDX*0x4]
MOV dword ptr [R13 + RDX*0x4],ECX
ADD RDX,0x1
CMP EDI,EDX
JG 0x00101251
ADD EDI,R10D
SUB EDI,ESI
MOV R10D,EDI
LAB_00101269:
CMP R9D,EAX
JLE 0x0010128a
CDQE
MOVSXD R10,R10D
SUB R10,RAX
LEA RCX,[R12 + R10*0x4]
LAB_0010127a:
MOV EDX,dword ptr [R11 + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP R9D,EAX
JG 0x0010127a
LAB_0010128a:
SUB R8D,0x1
MOVSXD R8,R8D
MOV EAX,dword ptr [R12 + R8*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012af
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_001012af:
CALL 0x00101060 | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
int iVar1;
long lVar2;
int iVar3;
ulong uVar4;
long lVar5;
long lVar6;
int1 *puVar7;
int iVar8;
int iVar9;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(param_3 + param_4) * 4 + 0xf;
for (puVar7 = auStack_38; puVar7 != auStack_38 + -(uVar4 & 0xfffffffffffff000);
puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar2 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if ((param_3 < 1) || (param_4 < 1)) {
iVar9 = 0;
iVar3 = 0;
iVar8 = 0;
}
else {
lVar5 = 1;
iVar3 = 0;
iVar8 = 0;
do {
iVar1 = *(int *)(param_1 + (long)iVar8 * 4);
iVar9 = *(int *)(param_2 + (long)iVar3 * 4);
if (iVar1 < iVar9) {
iVar8 = iVar8 + 1;
iVar9 = iVar1;
}
else {
iVar3 = iVar3 + 1;
}
*(int *)(puVar7 + lVar5 * 4 + lVar2 + -4) = iVar9;
iVar9 = (int)lVar5;
lVar5 = lVar5 + 1;
} while ((iVar8 < param_3) && (iVar3 < param_4));
}
if (iVar8 < param_3) {
lVar6 = (long)iVar8;
lVar5 = iVar9 - lVar6;
do {
*(int4 *)(puVar7 + lVar6 * 4 + lVar5 * 4 + lVar2) = *(int4 *)(param_1 + lVar6 * 4)
;
lVar6 = lVar6 + 1;
} while ((int)lVar6 < param_3);
iVar9 = (param_3 + iVar9) - iVar8;
}
if (iVar3 < param_4) {
lVar5 = (long)iVar3;
lVar6 = iVar9 - lVar5;
do {
*(int4 *)(puVar7 + lVar5 * 4 + lVar6 * 4 + lVar2) = *(int4 *)(param_2 + lVar5 * 4)
;
lVar5 = lVar5 + 1;
} while ((int)lVar5 < param_4);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar7 + (long)(param_5 + -1) * 4 + lVar2);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar2 + -8) = main;
__stack_chk_fail();
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.