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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,582 | func0 | #include <assert.h>
// Function to find max product pairs in an array
| void func0(int arr[], int arr_len, int *x, int *y) {
if (arr_len < 2) {
*x = 0;
*y = 0;
return;
}
*x = arr[0];
*y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > (*x) * (*y)) {
*x = arr[i];
*y = arr[j];
}
}
}
}
| int main() {
int x, y;
// Test Case 1
int arr1[] = {1, 2, 3, 4, 7, 0, 8, 4};
func0(arr1, 8, &x, &y);
assert(x == 7 && y == 8);
// Test Case 2
int arr2[] = {0, -1, -2, -4, 5, 0, -6};
func0(arr2, 7, &x, &y);
assert(x == -4 && y == -6);
// Test Case 3
int arr3[] = {1, 3, 5, 6, 8, 9};
func0(arr3, 6, &x, &y);
assert(x == 8 && y == 9);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 13d0 <func0+0x20>
mov (%rdi),%eax
mov %eax,(%rdx)
mov 0x4(%rdi),%eax
mov %eax,(%rcx)
jmpq 1340 <func0.part.0>
nopw 0x0(%rax,%rax,1)
movl $0x0,(%rdx)
movl $0x0,(%rcx)
retq
nopl (%rax)
| func0_part_0:
test esi, esi
jle short locret_13CF
push r12
mov r11d, 1
mov r8, rdx
mov r9, rcx
push rbp
lea r10, [rdi+4]
lea r12d, [rsi-1]
push rbx
mov ebx, esi
lea rbp, [rdi+8]
cmp r11, rbx
jz short loc_13CA
nop word ptr [rax+rax+00000000h]
loc_1380:
mov eax, r12d
sub eax, r11d
lea rax, [r11+rax-1]
lea rdi, [rbp+rax*4+0]
mov rax, r10
nop dword ptr [rax+rax+00h]
loc_1398:
mov ecx, [r10-4]
mov esi, [rax]
mov edx, [r8]
imul edx, [r9]
imul esi, ecx
cmp esi, edx
jle short loc_13B4
mov [r8], ecx
mov edx, [rax]
mov [r9], edx
loc_13B4:
add rax, 4
cmp rax, rdi
jnz short loc_1398
add r11, 1
add r10, 4
cmp r11, rbx
jnz short loc_1380
loc_13CA:
pop rbx
pop rbp
pop r12
retn
locret_13CF:
retn | void func0_part_0(long long a1, int a2, _DWORD *a3, _DWORD *a4)
{
long long v4; // r11
_DWORD *i; // r10
_DWORD *v7; // rax
int v8; // ecx
if ( a2 > 0 )
{
v4 = 1LL;
for ( i = (_DWORD *)(a1 + 4); v4 != a2; ++i )
{
v7 = i;
do
{
v8 = *(i - 1);
if ( v8 * *v7 > *a4 * *a3 )
{
*a3 = v8;
*a4 = *v7;
}
++v7;
}
while ( v7 != (_DWORD *)(a1 + 8 + 4 * (v4 + (unsigned int)(a2 - 1 - v4) - 1)) );
++v4;
}
}
} | func0.part.0:
TEST ESI,ESI
JLE 0x001013cf
PUSH R12
MOV R11D,0x1
MOV R8,RDX
MOV R9,RCX
PUSH RBP
LEA R10,[RDI + 0x4]
LEA R12D,[RSI + -0x1]
PUSH RBX
MOV EBX,ESI
LEA RBP,[RDI + 0x8]
CMP R11,RBX
JZ 0x001013ca
NOP word ptr [RAX + RAX*0x1]
LAB_00101380:
MOV EAX,R12D
SUB EAX,R11D
LEA RAX,[R11 + RAX*0x1 + -0x1]
LEA RDI,[RBP + RAX*0x4]
MOV RAX,R10
NOP dword ptr [RAX + RAX*0x1]
LAB_00101398:
MOV ECX,dword ptr [R10 + -0x4]
MOV ESI,dword ptr [RAX]
MOV EDX,dword ptr [R8]
IMUL EDX,dword ptr [R9]
IMUL ESI,ECX
CMP ESI,EDX
JLE 0x001013b4
MOV dword ptr [R8],ECX
MOV EDX,dword ptr [RAX]
MOV dword ptr [R9],EDX
LAB_001013b4:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101398
ADD R11,0x1
ADD R10,0x4
CMP R11,RBX
JNZ 0x00101380
LAB_001013ca:
POP RBX
POP RBP
POP R12
RET
LAB_001013cf:
RET | void func0_part_0(long param_1,uint param_2,int *param_3,int *param_4)
{
int *piVar1;
int *piVar2;
ulong uVar3;
if ((int)param_2 < 1) {
return;
}
uVar3 = 1;
piVar2 = (int *)(param_1 + 4);
if ((ulong)param_2 != 1) {
do {
piVar1 = piVar2;
do {
if (*param_3 * *param_4 < *piVar1 * piVar2[-1]) {
*param_3 = piVar2[-1];
*param_4 = *piVar1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)(param_1 + 8 +
((uVar3 - 1) + (ulong)((param_2 - 1) - (int)uVar3)) * 4));
uVar3 = uVar3 + 1;
piVar2 = piVar2 + 1;
} while (uVar3 != param_2);
}
return;
} |
7,583 | func0 | #include <assert.h>
// Function to find max product pairs in an array
| void func0(int arr[], int arr_len, int *x, int *y) {
if (arr_len < 2) {
*x = 0;
*y = 0;
return;
}
*x = arr[0];
*y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > (*x) * (*y)) {
*x = arr[i];
*y = arr[j];
}
}
}
}
| int main() {
int x, y;
// Test Case 1
int arr1[] = {1, 2, 3, 4, 7, 0, 8, 4};
func0(arr1, 8, &x, &y);
assert(x == 7 && y == 8);
// Test Case 2
int arr2[] = {0, -1, -2, -4, 5, 0, -6};
func0(arr2, 7, &x, &y);
assert(x == -4 && y == -6);
// Test Case 3
int arr3[] = {1, 3, 5, 6, 8, 9};
func0(arr3, 6, &x, &y);
assert(x == 8 && y == 9);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %esi,%ebx
mov %rdx,%rsi
cmp $0x1,%ebx
jle 13f0 <func0+0x70>
mov (%rdi),%eax
mov $0x1,%r12d
mov %eax,(%rdx)
mov 0x4(%rdi),%r10d
mov $0x1,%eax
mov %r10d,(%rcx)
xor %ecx,%ecx
nopl (%rax)
movslq %eax,%r8
mov (%rdi,%rcx,4),%r9d
mov (%rsi),%r11d
lea (%rdi,%r8,4),%r8
mov (%r8),%edx
imul %r10d,%r11d
imul %r9d,%edx
cmp %r11d,%edx
jle 13d8 <func0+0x58>
mov %r9d,(%rsi)
mov (%r8),%r10d
mov %r10d,0x0(%rbp)
add $0x1,%eax
cmp %eax,%ebx
jg 13b0 <func0+0x30>
lea 0x1(%r12),%eax
cmp %eax,%ebx
jle 13fc <func0+0x7c>
movslq %r12d,%rcx
mov %eax,%r12d
jmp 13b0 <func0+0x30>
movl $0x0,(%rdx)
movl $0x0,(%rcx)
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0_part_0:
test esi, esi
jle short locret_1361
push r12
mov r10, rdi
mov r11, rdi
mov r12d, esi
push rbp
mov ebp, 1
push rbx
mov ebx, esi
cmp esi, 1
jz short loc_135C
nop dword ptr [rax]
loc_1320:
mov edi, [rcx]
mov rax, rbp
nop dword ptr [rax]
loc_1328:
mov esi, [r11]
mov r9d, [r10+rax*4]
mov r8d, [rdx]
imul r9d, esi
imul r8d, edi
cmp r9d, r8d
jle short loc_1347
mov [rdx], esi
mov edi, [r10+rax*4]
mov [rcx], edi
loc_1347:
add rax, 1
cmp ebx, eax
jg short loc_1328
add rbp, 1
add r11, 4
cmp r12, rbp
jnz short loc_1320
loc_135C:
pop rbx
pop rbp
pop r12
retn
locret_1361:
retn | void func0_part_0(_DWORD *a1, int a2, _DWORD *a3, int *a4)
{
_DWORD *v5; // r11
long long v6; // rbp
int v7; // edi
long long v8; // rax
if ( a2 > 0 )
{
v5 = a1;
v6 = 1LL;
if ( a2 != 1 )
{
do
{
v7 = *a4;
v8 = v6;
do
{
if ( *v5 * a1[v8] > v7 * *a3 )
{
*a3 = *v5;
v7 = a1[v8];
*a4 = v7;
}
++v8;
}
while ( a2 > (int)v8 );
++v6;
++v5;
}
while ( a2 != v6 );
}
}
} | func0.part.0:
TEST ESI,ESI
JLE 0x00101361
PUSH R12
MOV R10,RDI
MOV R11,RDI
MOV R12D,ESI
PUSH RBP
MOV EBP,0x1
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JZ 0x0010135c
NOP dword ptr [RAX]
LAB_00101320:
MOV EDI,dword ptr [RCX]
MOV RAX,RBP
NOP dword ptr [RAX]
LAB_00101328:
MOV ESI,dword ptr [R11]
MOV R9D,dword ptr [R10 + RAX*0x4]
MOV R8D,dword ptr [RDX]
IMUL R9D,ESI
IMUL R8D,EDI
CMP R9D,R8D
JLE 0x00101347
MOV dword ptr [RDX],ESI
MOV EDI,dword ptr [R10 + RAX*0x4]
MOV dword ptr [RCX],EDI
LAB_00101347:
ADD RAX,0x1
CMP EBX,EAX
JG 0x00101328
ADD RBP,0x1
ADD R11,0x4
CMP R12,RBP
JNZ 0x00101320
LAB_0010135c:
POP RBX
POP RBP
POP R12
RET
LAB_00101361:
RET | void func0_part_0(int *param_1,uint param_2,int *param_3,int *param_4)
{
ulong uVar1;
ulong uVar2;
int iVar3;
int *piVar4;
if (0 < (int)param_2) {
uVar2 = 1;
piVar4 = param_1;
if (param_2 != 1) {
do {
iVar3 = *param_4;
uVar1 = uVar2;
do {
if (*param_3 * iVar3 < param_1[uVar1] * *piVar4) {
*param_3 = *piVar4;
iVar3 = param_1[uVar1];
*param_4 = iVar3;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
uVar2 = uVar2 + 1;
piVar4 = piVar4 + 1;
} while (param_2 != uVar2);
}
return;
}
return;
} |
7,584 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : right);
}
| int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
cmpl $0x0,-0x24(%rbp)
jne 1171 <func0+0x28>
mov -0x28(%rbp),%eax
jmpq 1213 <func0+0xca>
cmpl $0x0,-0x28(%rbp)
jne 117f <func0+0x36>
mov -0x24(%rbp),%eax
jmpq 1213 <func0+0xca>
mov -0x24(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x28(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 11ca <func0+0x81>
mov -0x28(%rbp),%eax
lea -0x1(%rax),%ecx
mov -0x24(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rsi
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1149 <func0>
add $0x1,%eax
jmp 1213 <func0+0xca>
mov -0x24(%rbp),%eax
lea -0x1(%rax),%edi
mov -0x28(%rbp),%edx
mov -0x20(%rbp),%rsi
mov -0x18(%rbp),%rax
mov %edx,%ecx
mov %edi,%edx
mov %rax,%rdi
callq 1149 <func0>
mov %eax,-0x8(%rbp)
mov -0x28(%rbp),%eax
lea -0x1(%rax),%ecx
mov -0x24(%rbp),%edx
mov -0x20(%rbp),%rsi
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1149 <func0>
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp %eax,-0x4(%rbp)
cmovle -0x4(%rbp),%eax
add $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_28], ecx
cmp [rbp+var_24], 0
jnz short loc_1171
mov eax, [rbp+var_28]
jmp locret_1214
loc_1171:
cmp [rbp+var_28], 0
jnz short loc_117F
mov eax, [rbp+var_24]
jmp locret_1214
loc_117F:
mov eax, [rbp+var_24]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+var_18]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_28]
cdqe
lea rcx, [rax-1]
mov rax, [rbp+var_20]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_11CA
mov eax, [rbp+var_28]
lea ecx, [rax-1]
mov eax, [rbp+var_24]
lea edx, [rax-1]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_18]
mov rdi, rax
call func0
add eax, 1
jmp short locret_1214
loc_11CA:
mov eax, [rbp+var_24]
lea edi, [rax-1]
mov edx, [rbp+var_28]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_18]
mov ecx, edx
mov edx, edi
mov rdi, rax
call func0
mov [rbp+var_8], eax
mov eax, [rbp+var_28]
lea ecx, [rax-1]
mov edx, [rbp+var_24]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_18]
mov rdi, rax
call func0
mov [rbp+var_4], eax
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
cmp edx, eax
cmovle eax, edx
add eax, 1
locret_1214:
leave
retn | long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
int v5; // edx
int v6; // eax
int v9; // [rsp+28h] [rbp-8h]
if ( !a3 )
return a4;
if ( !a4 )
return a3;
if ( *(_BYTE *)((int)a3 - 1LL + a1) == *(_BYTE *)((int)a4 - 1LL + a2) )
return (unsigned int)func0(a1, a2, a3 - 1, a4 - 1) + 1;
v9 = func0(a1, a2, a3 - 1, a4);
v5 = func0(a1, a2, a3, a4 - 1);
v6 = v9;
if ( v5 <= v9 )
v6 = v5;
return (unsigned int)(v6 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x28],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00101171
MOV EAX,dword ptr [RBP + -0x28]
JMP 0x00101214
LAB_00101171:
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x0010117f
MOV EAX,dword ptr [RBP + -0x24]
JMP 0x00101214
LAB_0010117f:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RCX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001011ca
MOV EAX,dword ptr [RBP + -0x28]
LEA ECX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + -0x1]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101149
ADD EAX,0x1
JMP 0x00101214
LAB_001011ca:
MOV EAX,dword ptr [RBP + -0x24]
LEA EDI,[RAX + -0x1]
MOV EDX,dword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,EDX
MOV EDX,EDI
MOV RDI,RAX
CALL 0x00101149
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x28]
LEA ECX,[RAX + -0x1]
MOV EDX,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101149
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
CMP EDX,EAX
CMOVLE EAX,EDX
ADD EAX,0x1
LAB_00101214:
LEAVE
RET | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
iVar1 = param_4;
if ((param_3 != 0) && (iVar1 = param_3, param_4 != 0)) {
if (*(char *)(param_1 + (long)param_3 + -1) == *(char *)(param_2 + (long)param_4 + -1)) {
iVar1 = func0(param_1,param_2,param_3 + -1,param_4 + -1);
iVar1 = iVar1 + 1;
}
else {
iVar1 = func0(param_1,param_2,param_3 + -1,param_4);
iVar2 = func0(param_1,param_2,param_3,param_4 + -1);
if (iVar2 <= iVar1) {
iVar1 = iVar2;
}
iVar1 = iVar1 + 1;
}
}
return iVar1;
} |
7,585 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : right);
}
| int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O1 | c | func0:
endbr64
mov %ecx,%eax
test %edx,%edx
je 11c1 <func0+0x78>
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r13
mov %rsi,%r14
mov %edx,%ebp
mov %ecx,%ebx
mov %edx,%eax
test %ecx,%ecx
je 11a5 <func0+0x5c>
movslq %edx,%rax
movslq %ecx,%rdx
movzbl -0x1(%rsi,%rdx,1),%esi
cmp %sil,-0x1(%rdi,%rax,1)
je 11ae <func0+0x65>
lea -0x1(%rbp),%edx
mov %r14,%rsi
callq 1149 <func0>
mov %eax,%r12d
lea -0x1(%rbx),%ecx
mov %ebp,%edx
mov %r14,%rsi
mov %r13,%rdi
callq 1149 <func0>
cmp %eax,%r12d
cmovle %r12d,%eax
add $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
lea -0x1(%rcx),%ecx
lea -0x1(%rbp),%edx
mov %r14,%rsi
callq 1149 <func0>
add $0x1,%eax
jmp 11a5 <func0+0x5c>
retq
| func0:
endbr64
mov eax, ecx
test edx, edx
jz short locret_11C1
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
mov r14, rsi
mov ebp, edx
mov ebx, ecx
mov eax, edx
test ecx, ecx
jz short loc_11A5
movsxd rax, edx
movsxd rdx, ecx
movzx esi, byte ptr [rsi+rdx-1]
cmp [rdi+rax-1], sil
jz short loc_11AE
lea edx, [rbp-1]
mov rsi, r14
call func0
mov r12d, eax
lea ecx, [rbx-1]
mov edx, ebp
mov rsi, r14
mov rdi, r13
call func0
cmp r12d, eax
cmovle eax, r12d
add eax, 1
loc_11A5:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_11AE:
lea ecx, [rcx-1]
lea edx, [rbp-1]
mov rsi, r14
call func0
add eax, 1
jmp short loc_11A5
locret_11C1:
retn | long long func0(long long a1, long long a2, unsigned int a3, long long a4)
{
long long result; // rax
int v6; // ebx
int v7; // r12d
int v8; // eax
result = (unsigned int)a4;
if ( a3 )
{
v6 = a4;
result = a3;
if ( (_DWORD)a4 )
{
if ( *(_BYTE *)(a1 + (int)a3 - 1) == *(_BYTE *)(a2 + (int)a4 - 1) )
{
return (unsigned int)func0(a1, a2, a3 - 1, (unsigned int)(a4 - 1)) + 1;
}
else
{
v7 = func0(a1, a2, a3 - 1, a4);
v8 = func0(a1, a2, a3, (unsigned int)(v6 - 1));
if ( v7 <= v8 )
v8 = v7;
return (unsigned int)(v8 + 1);
}
}
}
return result;
} | func0:
ENDBR64
MOV EAX,ECX
TEST EDX,EDX
JZ 0x001011c1
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
MOV R14,RSI
MOV EBP,EDX
MOV EBX,ECX
MOV EAX,EDX
TEST ECX,ECX
JZ 0x001011a5
MOVSXD RAX,EDX
MOVSXD RDX,ECX
MOVZX ESI,byte ptr [RSI + RDX*0x1 + -0x1]
CMP byte ptr [RDI + RAX*0x1 + -0x1],SIL
JZ 0x001011ae
LEA EDX,[RBP + -0x1]
MOV RSI,R14
CALL 0x00101149
MOV R12D,EAX
LEA ECX,[RBX + -0x1]
MOV EDX,EBP
MOV RSI,R14
MOV RDI,R13
CALL 0x00101149
CMP R12D,EAX
CMOVLE EAX,R12D
ADD EAX,0x1
LAB_001011a5:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001011ae:
LEA ECX,[RCX + -0x1]
LEA EDX,[RBP + -0x1]
MOV RSI,R14
CALL 0x00101149
ADD EAX,0x1
JMP 0x001011a5
LAB_001011c1:
RET | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
if (param_3 != 0) {
if (param_4 != 0) {
if (*(char *)(param_1 + -1 + (long)param_3) == *(char *)(param_2 + -1 + (long)param_4)) {
param_3 = func0(param_1,param_2,param_3 + -1,param_4 + -1);
param_3 = param_3 + 1;
}
else {
iVar1 = func0(param_1,param_2,param_3 + -1);
param_3 = func0(param_1,param_2,param_3,param_4 + -1);
if (iVar1 <= param_3) {
param_3 = iVar1;
}
param_3 = param_3 + 1;
}
}
return param_3;
}
return param_4;
} |
7,586 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : right);
}
| int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
je 12fa <func0+0xca>
test %ecx,%ecx
je 12fd <func0+0xcd>
push %r15
movslq %ecx,%rcx
movslq %edx,%rax
push %r14
sub %rcx,%rax
push %r13
add %rdi,%rax
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
jmp 127f <func0+0x4f>
nopl 0x0(%rax,%rax,1)
add $0x1,%ebx
test %edx,%edx
je 12d0 <func0+0xa0>
sub $0x1,%rcx
test %ecx,%ecx
je 12e8 <func0+0xb8>
mov %edx,%r14d
movzbl -0x1(%rbp,%rcx,1),%esi
lea -0x1(%rcx),%r13d
sub $0x1,%edx
cmp %sil,-0x1(%rcx,%rax,1)
je 1270 <func0+0x40>
mov %rbp,%rsi
mov %r12,%rdi
callq 1230 <func0>
mov %r13d,%ecx
mov %r14d,%edx
mov %rbp,%rsi
mov %r12,%rdi
mov %eax,%r15d
callq 1230 <func0>
cmp %eax,%r15d
cmovg %eax,%r15d
add $0x8,%rsp
lea 0x1(%rbx,%r15,1),%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
add $0x8,%rsp
lea 0x0(%r13,%rbx,1),%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
add $0x8,%rsp
lea (%rbx,%rdx,1),%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %ecx,%eax
retq
mov %edx,%eax
retq
| func0:
endbr64
test edx, edx
jz loc_12FA
test ecx, ecx
jz loc_12FD
push r15
movsxd rcx, ecx
movsxd rax, edx
push r14
sub rax, rcx
push r13
add rax, rdi
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_127F
loc_1270:
add ebx, 1
test edx, edx
jz short loc_12D0
sub rcx, 1
test ecx, ecx
jz short loc_12E8
loc_127F:
mov r14d, edx
movzx esi, byte ptr [rbp+rcx-1]
lea r13d, [rcx-1]
sub edx, 1
cmp [rcx+rax-1], sil
jz short loc_1270
mov rsi, rbp
mov rdi, r12
call func0
mov ecx, r13d
mov edx, r14d
mov rsi, rbp
mov rdi, r12
mov r15d, eax
call func0
cmp r15d, eax
cmovg r15d, eax
add rsp, 8
lea eax, [rbx+r15+1]
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12D0:
add rsp, 8
lea eax, [r13+rbx+0]
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12E8:
add rsp, 8
lea eax, [rbx+rdx]
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12FA:
mov eax, ecx
retn
loc_12FD:
mov eax, edx
retn | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
int v5; // ebx
unsigned int v6; // r14d
int v7; // r15d
int v8; // eax
if ( !(_DWORD)a3 )
return (unsigned int)a4;
if ( !(_DWORD)a4 )
return (unsigned int)a3;
a4 = (int)a4;
v4 = a1 + (int)a3 - (long long)(int)a4;
v5 = 0;
while ( 1 )
{
v6 = a3;
a3 = (unsigned int)(a3 - 1);
if ( *(_BYTE *)(a4 + v4 - 1) != *(_BYTE *)(a2 + a4 - 1) )
break;
++v5;
if ( !(_DWORD)a3 )
return (unsigned int)(a4 - 1 + v5);
if ( !(_DWORD)--a4 )
return (unsigned int)(v5 + a3);
}
v7 = func0(a1, a2, a3);
v8 = func0(a1, a2, v6);
if ( v7 > v8 )
v7 = v8;
return (unsigned int)(v5 + v7 + 1);
} | func0:
ENDBR64
TEST EDX,EDX
JZ 0x001012fa
TEST ECX,ECX
JZ 0x001012fd
PUSH R15
MOVSXD RCX,ECX
MOVSXD RAX,EDX
PUSH R14
SUB RAX,RCX
PUSH R13
ADD RAX,RDI
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x0010127f
LAB_00101270:
ADD EBX,0x1
TEST EDX,EDX
JZ 0x001012d0
SUB RCX,0x1
TEST ECX,ECX
JZ 0x001012e8
LAB_0010127f:
MOV R14D,EDX
MOVZX ESI,byte ptr [RBP + RCX*0x1 + -0x1]
LEA R13D,[RCX + -0x1]
SUB EDX,0x1
CMP byte ptr [RCX + RAX*0x1 + -0x1],SIL
JZ 0x00101270
MOV RSI,RBP
MOV RDI,R12
CALL 0x00101230
MOV ECX,R13D
MOV EDX,R14D
MOV RSI,RBP
MOV RDI,R12
MOV R15D,EAX
CALL 0x00101230
CMP R15D,EAX
CMOVG R15D,EAX
ADD RSP,0x8
LEA EAX,[RBX + R15*0x1 + 0x1]
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012d0:
ADD RSP,0x8
LEA EAX,[R13 + RBX*0x1]
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012e8:
ADD RSP,0x8
LEA EAX,[RBX + RDX*0x1]
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012fa:
MOV EAX,ECX
RET
LAB_001012fd:
MOV EAX,EDX
RET | int func0(long param_1,long param_2,int param_3,int param_4)
{
long lVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_3 == 0) {
return param_4;
}
if (param_4 != 0) {
lVar2 = (long)param_4;
lVar1 = param_3 - lVar2;
iVar4 = 0;
while( true ) {
iVar5 = (int)lVar2 + -1;
iVar3 = param_3 + -1;
if (*(char *)(lVar2 + -1 + lVar1 + param_1) != *(char *)(param_2 + -1 + lVar2)) {
iVar3 = func0(param_1,param_2);
iVar5 = func0(param_1,param_2,param_3,iVar5);
if (iVar5 < iVar3) {
iVar3 = iVar5;
}
return iVar4 + 1 + iVar3;
}
iVar4 = iVar4 + 1;
if (iVar3 == 0) break;
lVar2 = lVar2 + -1;
param_3 = iVar3;
if ((int)lVar2 == 0) {
return iVar4 + iVar3;
}
}
return iVar5 + iVar4;
}
return param_3;
} |
7,587 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : right);
}
| int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
je 12fa <func0+0xca>
test %ecx,%ecx
je 12fd <func0+0xcd>
push %r15
movslq %ecx,%rcx
movslq %edx,%rax
push %r14
sub %rcx,%rax
push %r13
add %rdi,%rax
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
jmp 127f <func0+0x4f>
nopl 0x0(%rax,%rax,1)
add $0x1,%ebx
test %edx,%edx
je 12d0 <func0+0xa0>
sub $0x1,%rcx
test %ecx,%ecx
je 12e8 <func0+0xb8>
mov %edx,%r14d
movzbl -0x1(%rbp,%rcx,1),%esi
lea -0x1(%rcx),%r13d
sub $0x1,%edx
cmp %sil,-0x1(%rcx,%rax,1)
je 1270 <func0+0x40>
mov %rbp,%rsi
mov %r12,%rdi
callq 1230 <func0>
mov %r13d,%ecx
mov %r14d,%edx
mov %rbp,%rsi
mov %r12,%rdi
mov %eax,%r15d
callq 1230 <func0>
cmp %eax,%r15d
cmovg %eax,%r15d
add $0x8,%rsp
lea 0x1(%rbx,%r15,1),%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
add $0x8,%rsp
lea 0x0(%r13,%rbx,1),%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
add $0x8,%rsp
lea (%rbx,%rdx,1),%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %ecx,%eax
retq
mov %edx,%eax
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
movsxd rbx, ecx
sub rsp, 38h
test edx, edx
jz loc_16D5
mov ebp, edx
test ebx, ebx
jz loc_16D9
movsxd rdx, edx
xor r13d, r13d
sub rdx, rbx
add rdx, rdi
jmp short loc_12E0
loc_12C8:
add r13d, 1
test ebp, ebp
jz loc_1680
sub rbx, 1
test ebx, ebx
jz loc_1698
loc_12E0:
movzx r12d, byte ptr [rdx+rbx-1]
movzx eax, byte ptr [rsi+rbx-1]
movsxd r15, ebp
lea r14d, [rbx-1]
sub ebp, 1
cmp r12b, al
jz short loc_12C8
mov r9d, ebx
cmp r15d, 1
jz loc_14CF
movsxd rcx, ebx
movsxd r9, ebp
lea edx, [r15-2]
xor r8d, r8d
sub rcx, r9
movsxd rdx, edx
add rcx, rsi
jmp short loc_1340
loc_1320:
add r8d, 1
test edx, edx
jz loc_14CC
sub rdx, 1
test r9d, r9d
jz loc_16C0
movzx eax, byte ptr [rcx+rdx]
mov ebx, r9d
loc_1340:
lea r9d, [rbx-1]
mov r10d, edx
cmp [rdi+rdx], al
jz short loc_1320
lea eax, [rdx+1]
mov dword ptr [rsp+68h+var_68], eax
test edx, edx
jz loc_1404
movsxd rcx, ebx
movsxd rax, edx
mov [rsp+68h+var_60], rdi
xor ebx, ebx
sub rax, rcx
add rax, rdi
jmp short loc_1387
loc_1370:
add ebx, 1
test edx, edx
jz loc_16F7
sub rcx, 1
test ecx, ecx
jz loc_170B
loc_1387:
mov r11d, edx
movzx edi, byte ptr [rsi+rcx-1]
lea r10d, [rcx-1]
sub edx, 1
cmp [rcx+rax-1], dil
jz short loc_1370
mov rdi, [rsp+68h+var_60]
mov [rsp+68h+var_3C], r8d
mov [rsp+68h+var_40], r9d
mov [rsp+68h+var_44], r10d
mov [rsp+68h+var_48], r11d
mov [rsp+68h+var_50], rsi
mov [rsp+68h+var_58], rdi
call func0
mov rsi, [rsp+68h+var_50]
mov rdi, [rsp+68h+var_58]
mov ecx, [rsp+68h+var_44]
mov edx, [rsp+68h+var_48]
mov dword ptr [rsp+68h+var_60], eax
call func0
mov edi, dword ptr [rsp+68h+var_60]
mov rsi, [rsp+68h+var_50]
mov r9d, [rsp+68h+var_40]
mov r8d, [rsp+68h+var_3C]
cmp edi, eax
cmovle eax, edi
mov rdi, [rsp+68h+var_58]
lea r10d, [rax+1]
loc_1401:
add ebx, r10d
loc_1404:
mov eax, dword ptr [rsp+68h+var_68]
test r9d, r9d
jz loc_14C3
movsxd rax, dword ptr [rsp+68h+var_68]
movsxd rcx, r9d
mov [rsp+68h+var_68], rdi
xor r9d, r9d
mov rdx, rax
sub rax, rcx
add rax, rdi
jmp short loc_1448
loc_1430:
add r9d, 1
test edx, edx
jz loc_16DD
sub rcx, 1
test ecx, ecx
jz loc_171F
loc_1448:
mov r11d, edx
movzx edi, byte ptr [rsi+rcx-1]
lea r10d, [rcx-1]
sub edx, 1
cmp [rcx+rax-1], dil
jz short loc_1430
mov rdi, [rsp+68h+var_68]
mov [rsp+68h+var_40], r8d
mov [rsp+68h+var_44], r9d
mov [rsp+68h+var_48], r11d
mov dword ptr [rsp+68h+var_50], r10d
mov [rsp+68h+var_58], rsi
mov [rsp+68h+var_60], rdi
call func0
mov rsi, [rsp+68h+var_58]
mov rdi, [rsp+68h+var_60]
mov ecx, dword ptr [rsp+68h+var_50]
mov edx, [rsp+68h+var_48]
mov dword ptr [rsp+68h+var_68], eax
call func0
mov edi, dword ptr [rsp+68h+var_68]
mov r9d, [rsp+68h+var_44]
mov r8d, [rsp+68h+var_40]
mov rsi, [rsp+68h+var_58]
cmp edi, eax
cmovle eax, edi
mov rdi, [rsp+68h+var_60]
lea eax, [r9+rax+1]
mov dword ptr [rsp+68h+var_68], eax
loc_14C3:
cmp ebx, eax
cmovg ebx, eax
lea r9d, [rbx+1]
loc_14CC:
add r9d, r8d
loc_14CF:
test r14d, r14d
jz loc_1663
movsxd rax, r14d
movsxd rbp, ebp
xor ebx, ebx
sub rax, r15
add rax, rsi
jmp short loc_1511
loc_14F0:
sub r14d, 1
add ebx, 1
test ebp, ebp
jz loc_16B0
sub rbp, 1
test r14d, r14d
jz loc_16D0
movzx r12d, byte ptr [rdi+rbp]
loc_1511:
mov r15d, ebp
cmp [rax+rbp], r12b
jz short loc_14F0
lea r12d, [rbp+1]
lea ecx, [r14-1]
mov r15d, r14d
test ebp, ebp
jz loc_15C7
movsxd rax, ebp
movsxd rcx, r14d
xor r15d, r15d
mov rdx, rax
sub rax, rcx
add rax, rdi
jmp short loc_155C
loc_1548:
add r15d, 1
test edx, edx
jz short loc_15C0
sub rcx, 1
test ecx, ecx
jz loc_1718
loc_155C:
mov r8d, edx
movzx r11d, byte ptr [rsi+rcx-1]
lea ebp, [rcx-1]
sub edx, 1
cmp [rcx+rax-1], r11b
jz short loc_1548
mov [rsp+68h+var_48], r9d
mov dword ptr [rsp+68h+var_50], r8d
mov [rsp+68h+var_60], rsi
mov [rsp+68h+var_68], rdi
call func0
mov rsi, [rsp+68h+var_60]
mov rdi, [rsp+68h+var_68]
mov ecx, ebp
mov edx, dword ptr [rsp+68h+var_50]
mov dword ptr [rsp+68h+var_58], eax
call func0
mov r10d, dword ptr [rsp+68h+var_58]
mov rdi, [rsp+68h+var_68]
mov rsi, [rsp+68h+var_60]
mov r9d, [rsp+68h+var_48]
cmp r10d, eax
cmovg r10d, eax
lea ebp, [r10+1]
loc_15C0:
add r15d, ebp
lea ecx, [r14-1]
loc_15C7:
test ecx, ecx
jz loc_1657
movsxd rax, r12d
movsxd rcx, ecx
xor ebp, ebp
mov rdx, rax
sub rax, rcx
add rax, rdi
jmp short loc_15FF
loc_15E8:
add ebp, 1
test edx, edx
jz loc_16ED
sub rcx, 1
test ecx, ecx
jz loc_1701
loc_15FF:
mov r12d, edx
movzx r11d, byte ptr [rsi+rcx-1]
lea r14d, [rcx-1]
sub edx, 1
cmp [rcx+rax-1], r11b
jz short loc_15E8
mov dword ptr [rsp+68h+var_50], r9d
mov [rsp+68h+var_58], rsi
mov [rsp+68h+var_60], rdi
call func0
mov rsi, [rsp+68h+var_58]
mov edx, r12d
mov ecx, r14d
mov rdi, [rsp+68h+var_60]
mov dword ptr [rsp+68h+var_68], eax
call func0
mov r8d, dword ptr [rsp+68h+var_68]
mov r9d, dword ptr [rsp+68h+var_50]
cmp r8d, eax
cmovg r8d, eax
lea r12d, [rbp+r8+1]
loc_1657:
cmp r15d, r12d
cmovg r15d, r12d
lea r15d, [rbx+r15+1]
loc_1663:
cmp r9d, r15d
cmovg r9d, r15d
add rsp, 38h
pop rbx
pop rbp
lea eax, [r13+r9+1]
pop r12
pop r13
pop r14
pop r15
retn
loc_1680:
lea eax, [r13+r14+0]
loc_1685:
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1698:
add rsp, 38h
lea eax, [r13+rbp+0]
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16B0:
lea r15d, [r14+rbx]
jmp short loc_1663
loc_16C0:
mov r9d, r10d
jmp loc_14CC
loc_16D0:
add r15d, ebx
jmp short loc_1663
loc_16D5:
mov eax, ebx
jmp short loc_1685
loc_16D9:
mov eax, edx
jmp short loc_1685
loc_16DD:
lea eax, [r9+r10]
mov rdi, [rsp+68h+var_68]
mov dword ptr [rsp+68h+var_68], eax
jmp loc_14C3
loc_16ED:
lea r12d, [rbp+r14+0]
jmp loc_1657
loc_16F7:
mov rdi, [rsp+68h+var_60]
jmp loc_1401
loc_1701:
lea r12d, [rbp+rdx+0]
jmp loc_1657
loc_170B:
mov rdi, [rsp+68h+var_60]
mov r10d, edx
jmp loc_1401
loc_1718:
mov ebp, edx
jmp loc_15C0
loc_171F:
lea eax, [r9+rdx]
mov rdi, [rsp+68h+var_68]
mov dword ptr [rsp+68h+var_68], eax
jmp loc_14C3 | long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
long long v4; // rbx
long long v5; // rbp
int v6; // r13d
long long v7; // rdx
char v8; // r12
char v9; // al
long long v10; // r15
int v11; // r14d
int v12; // r9d
int v13; // r8d
long long v14; // rdx
long long v15; // rcx
int v16; // r9d
int v17; // r10d
long long v18; // rcx
int v19; // ebx
long long v20; // rax
unsigned int v21; // r11d
int v22; // r10d
int v23; // eax
int v24; // eax
long long v25; // rcx
int v26; // r9d
long long v27; // rdx
long long v28; // rax
unsigned int v29; // r11d
int v30; // eax
int v31; // ebx
long long v32; // rax
int v33; // r15d
int v34; // r12d
long long v35; // rcx
int v36; // r15d
long long v37; // rcx
int v38; // r15d
long long v39; // rdx
long long v40; // rax
unsigned int v41; // r8d
int v42; // ebp
int v43; // eax
int v44; // r10d
int v45; // ebp
long long v46; // rdx
long long v47; // rax
unsigned int v48; // r12d
int v49; // eax
int v50; // r8d
int v52; // [rsp+0h] [rbp-68h]
int v53; // [rsp+0h] [rbp-68h]
int v54; // [rsp+0h] [rbp-68h]
int v55; // [rsp+8h] [rbp-60h]
int v56; // [rsp+10h] [rbp-58h]
unsigned int v57; // [rsp+18h] [rbp-50h]
int v58; // [rsp+18h] [rbp-50h]
unsigned int v59; // [rsp+20h] [rbp-48h]
unsigned int v60; // [rsp+20h] [rbp-48h]
int v61; // [rsp+20h] [rbp-48h]
int v62; // [rsp+24h] [rbp-44h]
int v63; // [rsp+28h] [rbp-40h]
int v64; // [rsp+28h] [rbp-40h]
int v65; // [rsp+2Ch] [rbp-3Ch]
v4 = (int)a4;
if ( !a3 )
return a4;
LODWORD(v5) = a3;
if ( !a4 )
return a3;
v6 = 0;
v7 = a1 + (int)a3 - (long long)(int)a4;
while ( 1 )
{
v8 = *(_BYTE *)(v7 + v4 - 1);
v9 = *(_BYTE *)(a2 + v4 - 1);
v10 = (int)v5;
v11 = v4 - 1;
LODWORD(v5) = v5 - 1;
if ( v8 != v9 )
break;
++v6;
if ( !(_DWORD)v5 )
return (unsigned int)(v6 + v11);
if ( !(_DWORD)--v4 )
return (unsigned int)(v6 + v5);
}
v12 = v4;
if ( (_DWORD)v10 != 1 )
{
v13 = 0;
v14 = (int)v10 - 2;
v15 = a2 + (int)v4 - (long long)(int)v5;
while ( 1 )
{
v16 = v4 - 1;
v17 = v14;
if ( *(_BYTE *)(a1 + v14) != v9 )
break;
++v13;
if ( !(_DWORD)v14 )
goto LABEL_33;
--v14;
if ( (_DWORD)v4 == 1 )
{
v16 = v17;
goto LABEL_33;
}
v9 = *(_BYTE *)(v15 + v14);
LODWORD(v4) = v4 - 1;
}
v52 = v14 + 1;
if ( (_DWORD)v14 )
{
v18 = (int)v4;
v19 = 0;
v20 = a1 + (int)v14 - v18;
while ( 1 )
{
v21 = v14;
v22 = v18 - 1;
v14 = (unsigned int)(v14 - 1);
if ( *(_BYTE *)(v18 + v20 - 1) != *(_BYTE *)(a2 + v18 - 1) )
break;
++v19;
if ( !(_DWORD)v14 )
goto LABEL_21;
if ( !(_DWORD)--v18 )
{
v22 = v14;
goto LABEL_21;
}
}
v65 = v13;
v63 = v16;
v59 = v21;
v55 = func0(a1, a2, v14);
v23 = func0(a1, a2, v59);
v16 = v63;
v13 = v65;
if ( v55 <= v23 )
v23 = v55;
v22 = v23 + 1;
LABEL_21:
LODWORD(v4) = v22 + v19;
}
v24 = v52;
if ( v16 )
{
v25 = v16;
v26 = 0;
LODWORD(v27) = v52;
v28 = a1 + v52 - v25;
while ( 1 )
{
v29 = v27;
v27 = (unsigned int)(v27 - 1);
if ( *(_BYTE *)(v25 + v28 - 1) != *(_BYTE *)(a2 + v25 - 1) )
break;
++v26;
if ( !(_DWORD)v27 )
{
v24 = v26 + v25 - 1;
goto LABEL_30;
}
if ( !(_DWORD)--v25 )
{
v24 = v26 + v27;
goto LABEL_30;
}
}
v64 = v13;
v62 = v26;
v60 = v29;
v53 = func0(a1, a2, v27);
v30 = func0(a1, a2, v60);
v13 = v64;
if ( v53 <= v30 )
v30 = v53;
v24 = v62 + v30 + 1;
}
LABEL_30:
if ( (int)v4 > v24 )
LODWORD(v4) = v24;
v16 = v4 + 1;
LABEL_33:
v12 = v13 + v16;
}
if ( v11 )
{
v5 = (int)v5;
v31 = 0;
v32 = a2 + v11 - v10;
while ( 1 )
{
v33 = v5;
if ( *(_BYTE *)(v32 + v5) != v8 )
break;
--v11;
++v31;
if ( !(_DWORD)v5 )
{
LODWORD(v10) = v11 + v31;
goto LABEL_60;
}
--v5;
if ( !v11 )
{
LODWORD(v10) = v31 + v33;
goto LABEL_60;
}
v8 = *(_BYTE *)(a1 + v5);
}
v34 = v5 + 1;
LODWORD(v35) = v11 - 1;
v36 = v11;
if ( (_DWORD)v5 )
{
v37 = v11;
v38 = 0;
LODWORD(v39) = v5;
v40 = a1 + (int)v5 - (long long)v11;
while ( 1 )
{
v41 = v39;
v42 = v37 - 1;
v39 = (unsigned int)(v39 - 1);
if ( *(_BYTE *)(v37 + v40 - 1) != *(_BYTE *)(a2 + v37 - 1) )
break;
++v38;
if ( !(_DWORD)v39 )
goto LABEL_48;
if ( !(_DWORD)--v37 )
{
v42 = v39;
goto LABEL_48;
}
}
v61 = v12;
v57 = v41;
v56 = func0(a1, a2, v39);
v43 = func0(a1, a2, v57);
v44 = v56;
v12 = v61;
if ( v56 > v43 )
v44 = v43;
v42 = v44 + 1;
LABEL_48:
v36 = v42 + v38;
LODWORD(v35) = v11 - 1;
}
if ( (_DWORD)v35 )
{
v35 = (int)v35;
v45 = 0;
LODWORD(v46) = v34;
v47 = a1 + v34 - (long long)(int)v35;
while ( 1 )
{
v48 = v46;
v46 = (unsigned int)(v46 - 1);
if ( *(_BYTE *)(v35 + v47 - 1) != *(_BYTE *)(a2 + v35 - 1) )
break;
++v45;
if ( !(_DWORD)v46 )
{
v34 = v45 + v35 - 1;
goto LABEL_57;
}
if ( !(_DWORD)--v35 )
{
v34 = v45 + v46;
goto LABEL_57;
}
}
v58 = v12;
v54 = func0(a1, a2, v46);
v49 = func0(a1, a2, v48);
v50 = v54;
v12 = v58;
if ( v54 > v49 )
v50 = v49;
v34 = v45 + v50 + 1;
}
LABEL_57:
if ( v36 > v34 )
v36 = v34;
LODWORD(v10) = v31 + v36 + 1;
}
LABEL_60:
if ( v12 > (int)v10 )
v12 = v10;
return (unsigned int)(v6 + v12 + 1);
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSXD RBX,ECX
SUB RSP,0x38
TEST EDX,EDX
JZ 0x001016d5
MOV EBP,EDX
TEST EBX,EBX
JZ 0x001016d9
MOVSXD RDX,EDX
XOR R13D,R13D
SUB RDX,RBX
ADD RDX,RDI
JMP 0x001012e0
LAB_001012c8:
ADD R13D,0x1
TEST EBP,EBP
JZ 0x00101680
SUB RBX,0x1
TEST EBX,EBX
JZ 0x00101698
LAB_001012e0:
MOVZX R12D,byte ptr [RDX + RBX*0x1 + -0x1]
MOVZX EAX,byte ptr [RSI + RBX*0x1 + -0x1]
MOVSXD R15,EBP
LEA R14D,[RBX + -0x1]
SUB EBP,0x1
CMP R12B,AL
JZ 0x001012c8
MOV R9D,EBX
CMP R15D,0x1
JZ 0x001014cf
MOVSXD RCX,EBX
MOVSXD R9,EBP
LEA EDX,[R15 + -0x2]
XOR R8D,R8D
SUB RCX,R9
MOVSXD RDX,EDX
ADD RCX,RSI
JMP 0x00101340
LAB_00101320:
ADD R8D,0x1
TEST EDX,EDX
JZ 0x001014cc
SUB RDX,0x1
TEST R9D,R9D
JZ 0x001016c0
MOVZX EAX,byte ptr [RCX + RDX*0x1]
MOV EBX,R9D
LAB_00101340:
LEA R9D,[RBX + -0x1]
MOV R10D,EDX
CMP byte ptr [RDI + RDX*0x1],AL
JZ 0x00101320
LEA EAX,[RDX + 0x1]
MOV dword ptr [RSP],EAX
TEST EDX,EDX
JZ 0x00101404
MOVSXD RCX,EBX
MOVSXD RAX,EDX
MOV qword ptr [RSP + 0x8],RDI
XOR EBX,EBX
SUB RAX,RCX
ADD RAX,RDI
JMP 0x00101387
LAB_00101370:
ADD EBX,0x1
TEST EDX,EDX
JZ 0x001016f7
SUB RCX,0x1
TEST ECX,ECX
JZ 0x0010170b
LAB_00101387:
MOV R11D,EDX
MOVZX EDI,byte ptr [RSI + RCX*0x1 + -0x1]
LEA R10D,[RCX + -0x1]
SUB EDX,0x1
CMP byte ptr [RCX + RAX*0x1 + -0x1],DIL
JZ 0x00101370
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x2c],R8D
MOV dword ptr [RSP + 0x28],R9D
MOV dword ptr [RSP + 0x24],R10D
MOV dword ptr [RSP + 0x20],R11D
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00101290
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0x24]
MOV EDX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x8],EAX
CALL 0x00101290
MOV EDI,dword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x18]
MOV R9D,dword ptr [RSP + 0x28]
MOV R8D,dword ptr [RSP + 0x2c]
CMP EDI,EAX
CMOVLE EAX,EDI
MOV RDI,qword ptr [RSP + 0x10]
LEA R10D,[RAX + 0x1]
LAB_00101401:
ADD EBX,R10D
LAB_00101404:
MOV EAX,dword ptr [RSP]
TEST R9D,R9D
JZ 0x001014c3
MOVSXD RAX,dword ptr [RSP]
MOVSXD RCX,R9D
MOV qword ptr [RSP],RDI
XOR R9D,R9D
MOV RDX,RAX
SUB RAX,RCX
ADD RAX,RDI
JMP 0x00101448
LAB_00101430:
ADD R9D,0x1
TEST EDX,EDX
JZ 0x001016dd
SUB RCX,0x1
TEST ECX,ECX
JZ 0x0010171f
LAB_00101448:
MOV R11D,EDX
MOVZX EDI,byte ptr [RSI + RCX*0x1 + -0x1]
LEA R10D,[RCX + -0x1]
SUB EDX,0x1
CMP byte ptr [RCX + RAX*0x1 + -0x1],DIL
JZ 0x00101430
MOV RDI,qword ptr [RSP]
MOV dword ptr [RSP + 0x28],R8D
MOV dword ptr [RSP + 0x24],R9D
MOV dword ptr [RSP + 0x20],R11D
MOV dword ptr [RSP + 0x18],R10D
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00101290
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP],EAX
CALL 0x00101290
MOV EDI,dword ptr [RSP]
MOV R9D,dword ptr [RSP + 0x24]
MOV R8D,dword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x10]
CMP EDI,EAX
CMOVLE EAX,EDI
MOV RDI,qword ptr [RSP + 0x8]
LEA EAX,[R9 + RAX*0x1 + 0x1]
MOV dword ptr [RSP],EAX
LAB_001014c3:
CMP EBX,EAX
CMOVG EBX,EAX
LEA R9D,[RBX + 0x1]
LAB_001014cc:
ADD R9D,R8D
LAB_001014cf:
TEST R14D,R14D
JZ 0x00101663
MOVSXD RAX,R14D
MOVSXD RBP,EBP
XOR EBX,EBX
SUB RAX,R15
ADD RAX,RSI
JMP 0x00101511
LAB_001014f0:
SUB R14D,0x1
ADD EBX,0x1
TEST EBP,EBP
JZ 0x001016b0
SUB RBP,0x1
TEST R14D,R14D
JZ 0x001016d0
MOVZX R12D,byte ptr [RDI + RBP*0x1]
LAB_00101511:
MOV R15D,EBP
CMP byte ptr [RAX + RBP*0x1],R12B
JZ 0x001014f0
LEA R12D,[RBP + 0x1]
LEA ECX,[R14 + -0x1]
MOV R15D,R14D
TEST EBP,EBP
JZ 0x001015c7
MOVSXD RAX,EBP
MOVSXD RCX,R14D
XOR R15D,R15D
MOV RDX,RAX
SUB RAX,RCX
ADD RAX,RDI
JMP 0x0010155c
LAB_00101548:
ADD R15D,0x1
TEST EDX,EDX
JZ 0x001015c0
SUB RCX,0x1
TEST ECX,ECX
JZ 0x00101718
LAB_0010155c:
MOV R8D,EDX
MOVZX R11D,byte ptr [RSI + RCX*0x1 + -0x1]
LEA EBP,[RCX + -0x1]
SUB EDX,0x1
CMP byte ptr [RCX + RAX*0x1 + -0x1],R11B
JZ 0x00101548
MOV dword ptr [RSP + 0x20],R9D
MOV dword ptr [RSP + 0x18],R8D
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDI
CALL 0x00101290
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP]
MOV ECX,EBP
MOV EDX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x10],EAX
CALL 0x00101290
MOV R10D,dword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
MOV R9D,dword ptr [RSP + 0x20]
CMP R10D,EAX
CMOVG R10D,EAX
LEA EBP,[R10 + 0x1]
LAB_001015c0:
ADD R15D,EBP
LEA ECX,[R14 + -0x1]
LAB_001015c7:
TEST ECX,ECX
JZ 0x00101657
MOVSXD RAX,R12D
MOVSXD RCX,ECX
XOR EBP,EBP
MOV RDX,RAX
SUB RAX,RCX
ADD RAX,RDI
JMP 0x001015ff
LAB_001015e8:
ADD EBP,0x1
TEST EDX,EDX
JZ 0x001016ed
SUB RCX,0x1
TEST ECX,ECX
JZ 0x00101701
LAB_001015ff:
MOV R12D,EDX
MOVZX R11D,byte ptr [RSI + RCX*0x1 + -0x1]
LEA R14D,[RCX + -0x1]
SUB EDX,0x1
CMP byte ptr [RCX + RAX*0x1 + -0x1],R11B
JZ 0x001015e8
MOV dword ptr [RSP + 0x18],R9D
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00101290
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,R12D
MOV ECX,R14D
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RSP],EAX
CALL 0x00101290
MOV R8D,dword ptr [RSP]
MOV R9D,dword ptr [RSP + 0x18]
CMP R8D,EAX
CMOVG R8D,EAX
LEA R12D,[RBP + R8*0x1 + 0x1]
LAB_00101657:
CMP R15D,R12D
CMOVG R15D,R12D
LEA R15D,[RBX + R15*0x1 + 0x1]
LAB_00101663:
CMP R9D,R15D
CMOVG R9D,R15D
ADD RSP,0x38
POP RBX
POP RBP
LEA EAX,[R13 + R9*0x1 + 0x1]
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101680:
LEA EAX,[R13 + R14*0x1]
LAB_00101685:
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101698:
ADD RSP,0x38
LEA EAX,[R13 + RBP*0x1]
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016b0:
LEA R15D,[R14 + RBX*0x1]
JMP 0x00101663
LAB_001016c0:
MOV R9D,R10D
JMP 0x001014cc
LAB_001016d0:
ADD R15D,EBX
JMP 0x00101663
LAB_001016d5:
MOV EAX,EBX
JMP 0x00101685
LAB_001016d9:
MOV EAX,EDX
JMP 0x00101685
LAB_001016dd:
LEA EAX,[R9 + R10*0x1]
MOV RDI,qword ptr [RSP]
MOV dword ptr [RSP],EAX
JMP 0x001014c3
LAB_001016ed:
LEA R12D,[RBP + R14*0x1]
JMP 0x00101657
LAB_001016f7:
MOV RDI,qword ptr [RSP + 0x8]
JMP 0x00101401
LAB_00101701:
LEA R12D,[RBP + RDX*0x1]
JMP 0x00101657
LAB_0010170b:
MOV RDI,qword ptr [RSP + 0x8]
MOV R10D,EDX
JMP 0x00101401
LAB_00101718:
MOV EBP,EDX
JMP 0x001015c0
LAB_0010171f:
LEA EAX,[R9 + RDX*0x1]
MOV RDI,qword ptr [RSP]
MOV dword ptr [RSP],EAX
JMP 0x001014c3 | int func0(long param_1,long param_2,int param_3,int param_4)
{
char cVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
uint uVar7;
long lVar8;
ulong uVar9;
int iVar10;
ulong uVar11;
int iVar12;
uint uVar13;
uint uVar14;
char cVar15;
int iVar16;
int iVar17;
uVar11 = (ulong)param_4;
iVar16 = param_4;
if ((param_3 == 0) || (iVar16 = param_3, param_4 == 0)) {
return iVar16;
}
iVar16 = 0;
lVar8 = (long)param_3 - uVar11;
while( true ) {
cVar15 = *(char *)(lVar8 + param_1 + -1 + uVar11);
cVar1 = *(char *)(param_2 + -1 + uVar11);
iVar2 = (int)uVar11;
iVar17 = iVar2 + -1;
iVar12 = param_3 + -1;
if (cVar15 != cVar1) break;
iVar16 = iVar16 + 1;
if (iVar12 == 0) {
return iVar16 + iVar17;
}
uVar11 = uVar11 - 1;
param_3 = iVar12;
if ((int)uVar11 == 0) {
return iVar16 + iVar12;
}
}
if (param_3 != 1) {
iVar5 = 0;
uVar9 = (ulong)(param_3 + -2);
while( true ) {
iVar10 = (int)uVar11;
uVar13 = iVar10 - 1;
uVar11 = (ulong)uVar13;
uVar14 = (uint)uVar9;
if (*(char *)(param_1 + uVar9) != cVar1) break;
iVar5 = iVar5 + 1;
uVar7 = uVar13;
if ((uVar14 == 0) || (uVar9 = uVar9 - 1, uVar7 = uVar14, uVar13 == 0)) goto LAB_001014cc;
cVar1 = *(char *)(((long)iVar2 - (long)iVar12) + param_2 + uVar9);
}
iVar2 = uVar14 + 1;
if (uVar14 != 0) {
lVar6 = (long)iVar10;
iVar10 = 0;
lVar8 = (int)uVar14 - lVar6;
while( true ) {
uVar14 = (int)lVar6 - 1;
uVar7 = (int)uVar9 - 1;
if (*(char *)(lVar6 + -1 + lVar8 + param_1) != *(char *)(param_2 + -1 + lVar6)) break;
iVar10 = iVar10 + 1;
if ((uVar7 == 0) ||
(lVar6 = lVar6 + -1, uVar9 = (ulong)uVar7, uVar14 = uVar7, (int)lVar6 == 0))
goto LAB_00101401;
}
iVar3 = func0();
iVar4 = func0(param_1,param_2,uVar9 & 0xffffffff,uVar14);
if (iVar3 <= iVar4) {
iVar4 = iVar3;
}
uVar14 = iVar4 + 1;
LAB_00101401:
iVar10 = iVar10 + uVar14;
}
if (uVar13 != 0) {
lVar6 = (long)(int)uVar13;
iVar4 = 0;
lVar8 = iVar2 - lVar6;
uVar11 = (long)iVar2;
do {
iVar2 = (int)lVar6 + -1;
uVar14 = (int)uVar11 - 1;
if (*(char *)(lVar6 + -1 + lVar8 + param_1) != *(char *)(param_2 + -1 + lVar6)) {
iVar3 = func0();
iVar2 = func0(param_1,param_2,uVar11 & 0xffffffff,iVar2);
if (iVar3 <= iVar2) {
iVar2 = iVar3;
}
iVar2 = iVar4 + 1 + iVar2;
goto LAB_001014c3;
}
iVar4 = iVar4 + 1;
if (uVar14 == 0) {
iVar2 = iVar4 + iVar2;
goto LAB_001014c3;
}
lVar6 = lVar6 + -1;
uVar11 = (ulong)uVar14;
} while ((int)lVar6 != 0);
iVar2 = iVar4 + uVar14;
}
LAB_001014c3:
if (iVar2 < iVar10) {
iVar10 = iVar2;
}
uVar7 = iVar10 + 1;
LAB_001014cc:
iVar2 = uVar7 + iVar5;
}
if (iVar17 != 0) {
lVar8 = (long)iVar17;
lVar6 = (long)iVar12;
iVar12 = 0;
while (iVar5 = (int)lVar6, *(char *)((lVar8 - param_3) + param_2 + lVar6) == cVar15) {
iVar17 = iVar17 + -1;
iVar12 = iVar12 + 1;
if (iVar5 == 0) {
param_3 = iVar17 + iVar12;
goto LAB_00101663;
}
lVar6 = lVar6 + -1;
if (iVar17 == 0) {
param_3 = iVar5 + iVar12;
goto LAB_00101663;
}
cVar15 = *(char *)(param_1 + lVar6);
}
iVar10 = iVar5 + 1;
param_3 = iVar17;
if (iVar5 != 0) {
lVar6 = (long)iVar17;
param_3 = 0;
lVar8 = iVar5 - lVar6;
uVar11 = (long)iVar5;
while( true ) {
uVar14 = (int)lVar6 - 1;
uVar13 = (int)uVar11 - 1;
if (*(char *)(lVar6 + -1 + lVar8 + param_1) != *(char *)(param_2 + -1 + lVar6)) break;
param_3 = param_3 + 1;
if ((uVar13 == 0) ||
(lVar6 = lVar6 + -1, uVar11 = (ulong)uVar13, uVar14 = uVar13, (int)lVar6 == 0))
goto LAB_001015c0;
}
iVar5 = func0();
iVar4 = func0(param_1,param_2,uVar11 & 0xffffffff,uVar14);
if (iVar4 < iVar5) {
iVar5 = iVar4;
}
uVar14 = iVar5 + 1;
LAB_001015c0:
param_3 = param_3 + uVar14;
}
if (iVar17 + -1 != 0) {
uVar11 = (ulong)iVar10;
lVar6 = (long)(iVar17 + -1);
iVar17 = 0;
lVar8 = uVar11 - lVar6;
do {
uVar9 = uVar11 & 0xffffffff;
iVar5 = (int)lVar6 + -1;
uVar14 = (int)uVar11 - 1;
uVar11 = (ulong)uVar14;
if (*(char *)(lVar6 + -1 + lVar8 + param_1) != *(char *)(param_2 + -1 + lVar6)) {
iVar10 = func0();
iVar5 = func0(param_1,param_2,uVar9,iVar5);
if (iVar5 < iVar10) {
iVar10 = iVar5;
}
iVar10 = iVar17 + 1 + iVar10;
goto LAB_00101657;
}
iVar17 = iVar17 + 1;
if (uVar14 == 0) {
iVar10 = iVar17 + iVar5;
goto LAB_00101657;
}
lVar6 = lVar6 + -1;
} while ((int)lVar6 != 0);
iVar10 = iVar17 + uVar14;
}
LAB_00101657:
if (iVar10 < param_3) {
param_3 = iVar10;
}
param_3 = iVar12 + 1 + param_3;
}
LAB_00101663:
if (param_3 < iVar2) {
iVar2 = param_3;
}
return iVar16 + 1 + iVar2;
} |
7,588 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jle 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jle short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 <= (int)a2 )
return a2;
else
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
param_2 = param_1;
}
return param_2;
} |
7,589 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
7,590 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
7,591 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
7,592 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ab <func0+0x42>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x8(%rbp),%edx
imul %edx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_11AB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_8]
imul eax, edx
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_11AB:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 1;
for ( i = 0; i < a2; ++i )
v3 *= *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ab
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ab:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) * local_10;
}
return local_10;
} |
7,593 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x27>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x1,%edx
imul (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x1,%edx
jmp 118d <func0+0x24>
| func0:
endbr64
test esi, esi
jle short loc_1190
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 1
loc_1181:
imul edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118D:
mov eax, edx
retn
loc_1190:
mov edx, 1
jmp short loc_118D | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 1;
}
else
{
v2 = a1;
v3 = 1;
do
v3 *= *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x1
LAB_00101181:
IMUL EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118d:
MOV EAX,EDX
RET
LAB_00101190:
MOV EDX,0x1
JMP 0x0010118d | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 1;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 1;
do {
iVar2 = iVar2 * *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,594 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
mov $0x1,%eax
nopl (%rax)
imul (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl (%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1258
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
mov eax, 1
nop dword ptr [rax]
loc_1248:
imul eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1248
retn
loc_1258:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 1LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 1;
do
result = (unsigned int)(*a1++ * result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101248:
IMUL EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101248
RET
LAB_00101258:
MOV EAX,0x1
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 1;
do {
iVar2 = iVar2 * *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 1;
} |
7,595 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1208 <func0+0xc8>
lea -0x1(%rsi),%eax
cmp $0x1c,%eax
jbe 1212 <func0+0xd2>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm2
movdqu (%rax),%xmm0
add $0x10,%rax
pmuludq %xmm1,%xmm2
psrlq $0x20,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm1,%xmm0
pshufd $0x8,%xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm1,%xmm2
movdqa %xmm1,%xmm0
mov %esi,%eax
psrldq $0x8,%xmm2
psrlq $0x20,%xmm1
and $0xfffffffc,%eax
pmuludq %xmm2,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
pmuludq %xmm1,%xmm0
movd %xmm0,%r8d
test $0x3,%sil
je 11fd <func0+0xbd>
cltq
nopl (%rax)
imul (%rdi,%rax,4),%r8d
add $0x1,%rax
cmp %eax,%esi
jg 11f0 <func0+0xb0>
mov %r8d,%eax
retq
nopl 0x0(%rax)
mov $0x1,%r8d
mov %r8d,%eax
retq
xor %eax,%eax
mov $0x1,%r8d
jmp 11eb <func0+0xab>
nopl 0x0(%rax)
| func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_1238
lea eax, [rsi-1]
cmp eax, 1Ah
jbe loc_1240
mov edx, esi
movdqa xmm1, cs:xmmword_2010
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1178:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pmuludq xmm2, xmm1
psrlq xmm0, 20h ; ' '
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm1
pshufd xmm1, xmm2, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
cmp rax, rdx
jnz short loc_1178
movdqa xmm0, xmm1
mov eax, esi
psrldq xmm0, 8
and eax, 0FFFFFFFCh
movdqa xmm2, xmm0
psrlq xmm0, 20h ; ' '
pmuludq xmm2, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm1
pshufd xmm1, xmm2, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
pmuludq xmm0, xmm1
movd edx, xmm0
test sil, 3
jz short loc_1231
loc_11F2:
cdqe
mov rdi, rax
imul edx, [rcx+rax*4]
add rax, 1
not rdi
add edi, esi
and edi, 1
cmp esi, eax
jle short loc_1231
test edi, edi
jz short loc_1220
imul edx, [rcx+rax*4]
add rax, 1
cmp esi, eax
jle short loc_1231
nop dword ptr [rax+rax+00h]
loc_1220:
imul edx, [rcx+rax*4]
imul edx, [rcx+rax*4+4]
add rax, 2
cmp esi, eax
jg short loc_1220
loc_1231:
mov eax, edx
retn
loc_1238:
mov edx, 1
mov eax, edx
retn
loc_1240:
xor eax, eax
mov edx, 1
jmp short loc_11F2 | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm1
const __m128i *v4; // rax
__m128i v5; // xmm2
int v6; // eax
__m128i v7; // xmm2
__m128i v8; // xmm1
unsigned int v9; // edx
char v10; // di
long long v11; // rax
int v12; // edi
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 0x1A )
{
v6 = 0;
v9 = 1;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = a1;
do
{
v5 = _mm_loadu_si128(v4++);
si128 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v5, si128), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v5, 0x20u), _mm_srli_epi64(si128, 0x20u)), 8));
}
while ( v4 != &a1[(unsigned int)a2 >> 2] );
v6 = a2 & 0x7FFFFFFC;
v7 = _mm_srli_si128(si128, 8);
v8 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v7, si128), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v7, 0x20u), _mm_srli_epi64(si128, 0x20u)), 8));
v9 = _mm_cvtsi128_si32(_mm_mul_epu32(_mm_srli_si128(v8, 4), v8));
if ( (a2 & 3) == 0 )
return v9;
}
v10 = v6;
v9 *= a1->m128i_i32[v6];
v11 = v6 + 1LL;
v12 = ((_BYTE)a2 + ~v10) & 1;
if ( a2 > (int)v11 )
{
if ( !v12 || (v9 *= a1->m128i_i32[v11], ++v11, a2 > (int)v11) )
{
do
{
v9 *= a1->m128i_i32[v11 + 1] * a1->m128i_i32[v11];
v11 += 2LL;
}
while ( a2 > (int)v11 );
}
}
return v9;
}
return 1LL;
} | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x00101238
LEA EAX,[RSI + -0x1]
CMP EAX,0x1a
JBE 0x00101240
MOV EDX,ESI
MOVDQA XMM1,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PMULUDQ XMM2,XMM1
PSRLQ XMM0,0x20
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM1
PSHUFD XMM1,XMM2,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
CMP RAX,RDX
JNZ 0x00101178
MOVDQA XMM0,XMM1
MOV EAX,ESI
PSRLDQ XMM0,0x8
AND EAX,0xfffffffc
MOVDQA XMM2,XMM0
PSRLQ XMM0,0x20
PMULUDQ XMM2,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM1
PSHUFD XMM1,XMM2,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PMULUDQ XMM0,XMM1
MOVD EDX,XMM0
TEST SIL,0x3
JZ 0x00101231
LAB_001011f2:
CDQE
MOV RDI,RAX
IMUL EDX,dword ptr [RCX + RAX*0x4]
ADD RAX,0x1
NOT RDI
ADD EDI,ESI
AND EDI,0x1
CMP ESI,EAX
JLE 0x00101231
TEST EDI,EDI
JZ 0x00101220
IMUL EDX,dword ptr [RCX + RAX*0x4]
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101231
NOP dword ptr [RAX + RAX*0x1]
LAB_00101220:
IMUL EDX,dword ptr [RCX + RAX*0x4]
IMUL EDX,dword ptr [RCX + RAX*0x4 + 0x4]
ADD RAX,0x2
CMP ESI,EAX
JG 0x00101220
LAB_00101231:
MOV EAX,EDX
RET
LAB_00101238:
MOV EDX,0x1
MOV EAX,EDX
RET
LAB_00101240:
XOR EAX,EAX
MOV EDX,0x1
JMP 0x001011f2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong func0(ulong *param_1,uint param_2)
{
ulong *puVar1;
ulong *puVar2;
uint uVar3;
ulong *puVar4;
long lVar5;
long lVar6;
int iVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
int auVar11 [16];
int4 uVar13;
ulong uVar14;
int4 uVar15;
ulong uVar12;
if ((int)param_2 < 1) {
return 1;
}
if (param_2 - 1 < 0x1b) {
uVar3 = 0;
iVar7 = 1;
}
else {
puVar4 = param_1;
uVar10 = _DAT_00102010;
uVar12 = _UNK_00102018;
do {
uVar14 = *puVar4;
puVar2 = puVar4 + 1;
uVar9 = *puVar4;
puVar1 = puVar4 + 1;
puVar4 = puVar4 + 2;
uVar14 = (uVar14 & 0xffffffff) * (uVar10 & 0xffffffff);
uVar9 = (uVar9 >> 0x20) * (uVar10 >> 0x20);
uVar13 = (int4)uVar14;
uVar15 = (int4)((*puVar2 & 0xffffffff) * (uVar12 & 0xffffffff));
auVar11._4_4_ = uVar15;
auVar11._0_4_ = uVar13;
auVar11._8_4_ = uVar15;
auVar11._12_4_ = (int)((*puVar1 >> 0x20) * (uVar12 >> 0x20));
uVar12 = auVar11._8_8_;
uVar10 = CONCAT44((int)uVar9,uVar13);
} while (puVar4 != param_1 + (ulong)(param_2 >> 2) * 2);
uVar3 = param_2 & 0xfffffffc;
uVar10 = ((uVar12 >> 0x20) * (uVar9 & 0xffffffff) & 0xffffffff) *
((uVar12 & 0xffffffff) * (uVar14 & 0xffffffff) & 0xffffffff);
iVar7 = (int)uVar10;
if ((param_2 & 3) == 0) {
return uVar10 & 0xffffffff;
}
}
lVar5 = (long)(int)uVar3;
uVar8 = iVar7 * *(int *)((long)param_1 + lVar5 * 4);
uVar10 = (ulong)uVar8;
lVar6 = lVar5 + 1;
if ((int)lVar6 < (int)param_2) {
if ((~uVar3 + param_2 & 1) != 0) {
uVar10 = (ulong)(uVar8 * *(int *)((long)param_1 + lVar6 * 4));
lVar6 = lVar5 + 2;
if ((int)param_2 <= (int)lVar6) {
return uVar10;
}
}
do {
uVar10 = (ulong)(uint)((int)uVar10 * *(int *)((long)param_1 + lVar6 * 4) *
*(int *)((long)param_1 + lVar6 * 4 + 4));
lVar6 = lVar6 + 2;
} while ((int)lVar6 < (int)param_2);
}
return uVar10;
} |
7,596 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 11eb <func0+0x28>
cmpl $0x0,-0x18(%rbp)
jne 11eb <func0+0x28>
mov $0x1,%eax
jmp 125f <func0+0x9c>
cmpl $0x1,-0x14(%rbp)
jne 11fe <func0+0x3b>
cmpl $0x0,-0x18(%rbp)
jne 11fe <func0+0x3b>
mov $0x0,%eax
jmp 125f <func0+0x9c>
cmpl $0x0,-0x18(%rbp)
jne 1239 <func0+0x76>
mov -0x14(%rbp),%eax
lea -0x1(%rax),%r12d
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov $0x0,%esi
mov %eax,%edi
callq 11c3 <func0>
mov %eax,%ebx
mov -0x14(%rbp),%eax
sub $0x2,%eax
mov $0x0,%esi
mov %eax,%edi
callq 11c3 <func0>
add %ebx,%eax
imul %r12d,%eax
jmp 125f <func0+0x9c>
mov -0x18(%rbp),%edx
mov -0x14(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1169 <binomial_coeffi>
mov %eax,%ebx
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
mov $0x0,%esi
mov %eax,%edi
callq 11c3 <func0>
imul %ebx,%eax
add $0x10,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 10h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
cmp [rbp+var_14], 0
jnz short loc_11EA
cmp [rbp+var_18], 0
jnz short loc_11EA
mov eax, 1
jmp short loc_125E
loc_11EA:
cmp [rbp+var_14], 1
jnz short loc_11FD
cmp [rbp+var_18], 0
jnz short loc_11FD
mov eax, 0
jmp short loc_125E
loc_11FD:
cmp [rbp+var_18], 0
jnz short loc_1238
mov eax, [rbp+var_14]
lea r12d, [rax-1]
mov eax, [rbp+var_14]
sub eax, 1
mov esi, 0
mov edi, eax
call func0
mov ebx, eax
mov eax, [rbp+var_14]
sub eax, 2
mov esi, 0
mov edi, eax
call func0
add eax, ebx
imul eax, r12d
jmp short loc_125E
loc_1238:
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
mov esi, edx
mov edi, eax
call binomial_coeffi
mov ebx, eax
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
mov esi, 0
mov edi, eax
call func0
imul eax, ebx
loc_125E:
add rsp, 10h
pop rbx
pop r12
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
int v3; // ebx
int v4; // ebx
if ( !a1 && !a2 )
return 1LL;
if ( a1 == 1 && !a2 )
return 0LL;
if ( a2 )
{
v4 = binomial_coeffi(a1, a2);
return v4 * (unsigned int)func0(a1 - a2, 0LL);
}
else
{
v3 = func0(a1 - 1, 0LL);
return (a1 - 1) * (v3 + (unsigned int)func0(a1 - 2, 0LL));
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001011ea
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001011ea
MOV EAX,0x1
JMP 0x0010125e
LAB_001011ea:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x001011fd
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001011fd
MOV EAX,0x0
JMP 0x0010125e
LAB_001011fd:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00101238
MOV EAX,dword ptr [RBP + -0x14]
LEA R12D,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV ESI,0x0
MOV EDI,EAX
CALL 0x001011c2
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
MOV ESI,0x0
MOV EDI,EAX
CALL 0x001011c2
ADD EAX,EBX
IMUL EAX,R12D
JMP 0x0010125e
LAB_00101238:
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
MOV ESI,0x0
MOV EDI,EAX
CALL 0x001011c2
IMUL EAX,EBX
LAB_0010125e:
ADD RSP,0x10
POP RBX
POP R12
POP RBP
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if ((param_1 == 0) && (param_2 == 0)) {
iVar2 = 1;
}
else if ((param_1 == 1) && (param_2 == 0)) {
iVar2 = 0;
}
else if (param_2 == 0) {
iVar1 = func0(param_1 + -1,0);
iVar2 = func0(param_1 + -2,0);
iVar2 = (iVar2 + iVar1) * (param_1 + -1);
}
else {
iVar1 = binomial_coeffi(param_1,param_2);
iVar2 = func0(param_1 - param_2,0);
iVar2 = iVar2 * iVar1;
}
return iVar2;
} |
7,597 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
mov %edi,%edx
or %esi,%edx
je 121b <func0+0x74>
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %esi,%ebp
cmp $0x1,%edi
jne 11cc <func0+0x25>
mov $0x0,%eax
test %esi,%esi
je 11ee <func0+0x47>
test %ebp,%ebp
je 11f3 <func0+0x4c>
mov %ebp,%esi
mov %ebx,%edi
callq 1169 <binomial_coeffi>
mov %eax,%r12d
sub %ebp,%ebx
mov %ebx,%edi
mov $0x0,%esi
callq 11a7 <func0>
imul %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
lea -0x1(%rbx),%r12d
mov $0x0,%esi
mov %r12d,%edi
callq 11a7 <func0>
mov %eax,%ebp
lea -0x2(%rbx),%edi
mov $0x0,%esi
callq 11a7 <func0>
add %ebp,%eax
imul %r12d,%eax
jmp 11ee <func0+0x47>
retq
| func0:
endbr64
mov eax, 1
mov edx, edi
or edx, esi
jz short locret_121B
push r12
push rbp
push rbx
mov ebx, edi
mov ebp, esi
cmp edi, 1
jnz short loc_11CC
mov eax, 0
test esi, esi
jz short loc_11EE
loc_11CC:
test ebp, ebp
jz short loc_11F3
mov esi, ebp
mov edi, ebx
call binomial_coeffi
mov r12d, eax
sub ebx, ebp
mov edi, ebx
mov esi, 0
call func0
imul eax, r12d
loc_11EE:
pop rbx
pop rbp
pop r12
retn
loc_11F3:
lea r12d, [rbx-1]
mov esi, 0
mov edi, r12d
call func0
mov ebp, eax
lea edi, [rbx-2]
mov esi, 0
call func0
add eax, ebp
imul eax, r12d
jmp short loc_11EE
locret_121B:
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
int v4; // ebp
result = 1LL;
if ( a2 | a1 )
{
if ( a1 != 1 || (result = 0LL, a2) )
{
if ( a2 )
{
v3 = binomial_coeffi(a1, a2);
return v3 * (unsigned int)func0(a1 - a2, 0LL);
}
else
{
v4 = func0(a1 - 1, 0LL);
return (a1 - 1) * (v4 + (unsigned int)func0(a1 - 2, 0LL));
}
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
MOV EDX,EDI
OR EDX,ESI
JZ 0x0010121b
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV EBP,ESI
CMP EDI,0x1
JNZ 0x001011cc
MOV EAX,0x0
TEST ESI,ESI
JZ 0x001011ee
LAB_001011cc:
TEST EBP,EBP
JZ 0x001011f3
MOV ESI,EBP
MOV EDI,EBX
CALL 0x00101169
MOV R12D,EAX
SUB EBX,EBP
MOV EDI,EBX
MOV ESI,0x0
CALL 0x001011a7
IMUL EAX,R12D
LAB_001011ee:
POP RBX
POP RBP
POP R12
RET
LAB_001011f3:
LEA R12D,[RBX + -0x1]
MOV ESI,0x0
MOV EDI,R12D
CALL 0x001011a7
MOV EBP,EAX
LEA EDI,[RBX + -0x2]
MOV ESI,0x0
CALL 0x001011a7
ADD EAX,EBP
IMUL EAX,R12D
JMP 0x001011ee
LAB_0010121b:
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 != 0 || param_2 != 0) {
if ((param_1 != 1) || (iVar2 = 0, param_2 != 0)) {
if (param_2 == 0) {
iVar2 = func0(param_1 + -1,0);
iVar1 = func0(param_1 + -2,0);
iVar2 = (iVar1 + iVar2) * (param_1 + -1);
}
else {
iVar1 = binomial_coeffi(param_1,param_2);
iVar2 = func0(param_1 - param_2,0);
iVar2 = iVar2 * iVar1;
}
}
return iVar2;
}
return 1;
} |
7,598 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %edi,%eax
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
or %esi,%eax
je 1320 <func0+0x80>
mov %edi,%ebx
mov %esi,%edx
cmp $0x1,%edi
jne 1310 <func0+0x70>
test %esi,%esi
je 1338 <func0+0x98>
mov %ebx,%edi
mov %edx,%esi
xor %r12d,%r12d
callq 1230 <binomial_coeffi>
sub %edx,%ebx
mov %eax,%ebp
test %ebx,%ebx
je 12fd <func0+0x5d>
cmp $0x1,%ebx
je 1300 <func0+0x60>
lea -0x1(%rbx),%r13d
xor %esi,%esi
sub $0x2,%ebx
mov %r13d,%edi
callq 12a0 <func0>
imul %r13d,%eax
imul %ebp,%eax
imul %r13d,%ebp
add %eax,%r12d
test %ebx,%ebx
jne 12d5 <func0+0x35>
add %ebp,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xchg %ax,%ax
test %esi,%esi
jne 12c1 <func0+0x21>
xor %r12d,%r12d
mov $0x1,%ebp
jmp 12da <func0+0x3a>
xchg %ax,%ax
add $0x8,%rsp
mov $0x1,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
xor %r12d,%r12d
jmp 1300 <func0+0x60>
nopl (%rax)
| func0:
endbr64
push r15
mov eax, edi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
or eax, esi
jz loc_1670
test esi, esi
mov ebp, edi
mov r14d, esi
setz cl
mov eax, ecx
cmp edi, 1
jnz short loc_15D5
test cl, cl
jnz loc_1660
loc_15D5:
mov [rsp+48h+var_3C], 0
mov r13d, 1
test r14d, r14d
jz short loc_1623
cmp ebp, r14d
jz short loc_1617
lea r15d, [r14-1]
mov ebx, ebp
xor r12d, r12d
test al, al
jnz short loc_1617
loc_15FA:
sub ebx, 1
mov esi, r15d
mov edi, ebx
call binomial_coeffi
add r12d, eax
cmp ebx, r14d
jnz short loc_15FA
add r12d, 1
imul r13d, r12d
loc_1617:
sub ebp, r14d
test ebp, ebp
jz short loc_1645
loc_161E:
cmp ebp, 1
jz short loc_164A
loc_1623:
lea ebx, [rbp-1]
xor esi, esi
sub ebp, 2
mov edi, ebx
call func0
imul eax, ebx
imul eax, r13d
add [rsp+48h+var_3C], eax
imul r13d, ebx
test ebp, ebp
jnz short loc_161E
loc_1645:
add [rsp+48h+var_3C], r13d
loc_164A:
mov eax, [rsp+48h+var_3C]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1660:
mov [rsp+48h+var_3C], 0
jmp short loc_164A
loc_1670:
mov [rsp+48h+var_3C], 1
jmp short loc_164A | long long func0(int a1, int a2)
{
int v2; // ebp
int v3; // r13d
int v4; // ebx
int v5; // r12d
unsigned int v6; // ebx
unsigned int v8; // [rsp+Ch] [rbp-3Ch]
if ( a2 | a1 )
{
v2 = a1;
if ( a1 == 1 && !a2 )
{
return 0;
}
else
{
v8 = 0;
v3 = 1;
if ( !a2 )
goto LABEL_11;
if ( a1 != a2 )
{
v4 = a1;
v5 = 0;
do
v5 += binomial_coeffi((unsigned int)--v4, (unsigned int)(a2 - 1));
while ( v4 != a2 );
v3 = v5 + 1;
}
v2 = a1 - a2;
if ( a1 == a2 )
{
LABEL_12:
v8 += v3;
}
else
{
while ( v2 != 1 )
{
LABEL_11:
v6 = v2 - 1;
v2 -= 2;
v8 += v3 * v6 * func0(v6, 0LL);
v3 *= v6;
if ( !v2 )
goto LABEL_12;
}
}
}
}
else
{
return 1;
}
return v8;
} | func0:
ENDBR64
PUSH R15
MOV EAX,EDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
OR EAX,ESI
JZ 0x00101670
TEST ESI,ESI
MOV EBP,EDI
MOV R14D,ESI
SETZ CL
MOV EAX,ECX
CMP EDI,0x1
JNZ 0x001015d5
TEST CL,CL
JNZ 0x00101660
LAB_001015d5:
MOV dword ptr [RSP + 0xc],0x0
MOV R13D,0x1
TEST R14D,R14D
JZ 0x00101623
CMP EBP,R14D
JZ 0x00101617
LEA R15D,[R14 + -0x1]
MOV EBX,EBP
XOR R12D,R12D
TEST AL,AL
JNZ 0x00101617
LAB_001015fa:
SUB EBX,0x1
MOV ESI,R15D
MOV EDI,EBX
CALL 0x00101230
ADD R12D,EAX
CMP EBX,R14D
JNZ 0x001015fa
ADD R12D,0x1
IMUL R13D,R12D
LAB_00101617:
SUB EBP,R14D
TEST EBP,EBP
JZ 0x00101645
LAB_0010161e:
CMP EBP,0x1
JZ 0x0010164a
LAB_00101623:
LEA EBX,[RBP + -0x1]
XOR ESI,ESI
SUB EBP,0x2
MOV EDI,EBX
CALL 0x001015a0
IMUL EAX,EBX
IMUL EAX,R13D
ADD dword ptr [RSP + 0xc],EAX
IMUL R13D,EBX
TEST EBP,EBP
JNZ 0x0010161e
LAB_00101645:
ADD dword ptr [RSP + 0xc],R13D
LAB_0010164a:
MOV EAX,dword ptr [RSP + 0xc]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101660:
MOV dword ptr [RSP + 0xc],0x0
JMP 0x0010164a
LAB_00101670:
MOV dword ptr [RSP + 0xc],0x1
JMP 0x0010164a | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int local_3c;
if (param_1 == 0 && param_2 == 0) {
local_3c = 1;
}
else if ((param_1 != 1) || (param_2 != 0)) {
local_3c = 0;
iVar1 = 1;
if (param_2 == 0) goto LAB_00101623;
if (param_1 != param_2) {
iVar3 = 0;
iVar2 = param_1;
if (param_2 != 0) {
do {
iVar2 = iVar2 + -1;
iVar1 = binomial_coeffi(iVar2,param_2 + -1);
iVar3 = iVar3 + iVar1;
} while (iVar2 != param_2);
iVar1 = iVar3 + 1;
}
}
for (param_1 = param_1 - param_2; param_1 != 0; param_1 = param_1 + -2) {
if (param_1 == 1) {
return local_3c;
}
LAB_00101623:
iVar3 = param_1 + -1;
iVar2 = func0(iVar3,0);
local_3c = local_3c + iVar2 * iVar3 * iVar1;
iVar1 = iVar1 * iVar3;
}
local_3c = local_3c + iVar1;
}
else {
local_3c = 0;
}
return local_3c;
} |
7,599 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %edi,%eax
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
or %esi,%eax
je 1350 <func0+0xb0>
test %esi,%esi
mov %edi,%ebx
mov %esi,%ecx
sete %dl
mov %edx,%eax
cmp $0x1,%edi
jne 12cc <func0+0x2c>
test %dl,%dl
jne 1348 <func0+0xa8>
mov $0x1,%ebp
xor %r12d,%r12d
test %ecx,%ecx
je 1310 <func0+0x70>
cmp %ecx,%ebx
je 1305 <func0+0x65>
lea -0x1(%rcx),%r9d
mov %ebx,%edx
xor %r8d,%r8d
test %al,%al
jne 1305 <func0+0x65>
sub $0x1,%edx
mov %r9d,%esi
mov %edx,%edi
callq 1230 <binomial_coeffi>
add %eax,%r8d
cmp %ecx,%edx
jne 12e9 <func0+0x49>
add $0x1,%r8d
imul %r8d,%ebp
sub %ecx,%ebx
test %ebx,%ebx
je 1333 <func0+0x93>
cmp $0x1,%ebx
je 1336 <func0+0x96>
lea -0x1(%rbx),%r13d
xor %esi,%esi
sub $0x2,%ebx
mov %r13d,%edi
callq 12a0 <func0>
imul %r13d,%eax
imul %ebp,%eax
imul %r13d,%ebp
add %eax,%r12d
test %ebx,%ebx
jne 130b <func0+0x6b>
add %ebp,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
xor %r12d,%r12d
jmp 1336 <func0+0x96>
nopl (%rax)
add $0x8,%rsp
mov $0x1,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
push r14
or eax, esi
push r13
push r12
push rbp
push rbx
jz loc_16B8
mov r12d, edi
mov r13d, esi
cmp edi, 1
jnz short loc_1698
test esi, esi
jz loc_16D0
loc_1629:
cmp r12d, r13d
jz short loc_16A8
lea r14d, [r13-1]
mov ebx, r12d
xor ebp, ebp
loc_1637:
sub ebx, 1
mov esi, r14d
mov edi, ebx
call binomial_coeffi
add ebp, eax
cmp r13d, ebx
jnz short loc_1637
sub r12d, r13d
add ebp, 1
xor ebx, ebx
test r12d, r12d
jz short loc_1688
loc_1658:
cmp r12d, 1
jz short loc_168A
loc_165E:
lea r13d, [r12-1]
xor esi, esi
sub r12d, 2
mov edi, r13d
call func0
imul eax, r13d
imul eax, ebp
imul ebp, r13d
add ebx, eax
test r12d, r12d
jnz short loc_1658
nop dword ptr [rax+rax+00h]
loc_1688:
add ebx, ebp
loc_168A:
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1698:
test esi, esi
jnz short loc_1629
xor ebx, ebx
mov ebp, 1
jmp short loc_165E
loc_16A8:
xor ebx, ebx
mov ebp, 1
jmp short loc_1688
loc_16B8:
mov ebx, 1
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_16D0:
xor ebx, ebx
jmp short loc_168A | long long func0(int a1, int a2)
{
int v2; // r12d
int v3; // ebx
int v4; // ebp
int v5; // ebp
unsigned int v6; // ebx
unsigned int v7; // r13d
int v8; // eax
if ( a2 | a1 )
{
v2 = a1;
if ( a1 == 1 )
{
if ( !a2 )
return 0;
}
else if ( !a2 )
{
v6 = 0;
v5 = 1;
goto LABEL_9;
}
if ( a1 == a2 )
{
v6 = 0;
v5 = 1;
}
else
{
v3 = a1;
v4 = 0;
do
v4 += binomial_coeffi((unsigned int)--v3, (unsigned int)(a2 - 1));
while ( a2 != v3 );
v2 = a1 - a2;
v5 = v4 + 1;
v6 = 0;
if ( a1 != a2 )
{
while ( v2 != 1 )
{
LABEL_9:
v7 = v2 - 1;
v2 -= 2;
v8 = v5 * v7 * func0(v7, 0LL);
v5 *= v7;
v6 += v8;
if ( !v2 )
goto LABEL_10;
}
return v6;
}
}
LABEL_10:
v6 += v5;
return v6;
}
return 1LL;
} | func0:
ENDBR64
MOV EAX,EDI
PUSH R14
OR EAX,ESI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
JZ 0x001016b8
MOV R12D,EDI
MOV R13D,ESI
CMP EDI,0x1
JNZ 0x00101698
TEST ESI,ESI
JZ 0x001016d0
LAB_00101629:
CMP R12D,R13D
JZ 0x001016a8
LEA R14D,[R13 + -0x1]
MOV EBX,R12D
XOR EBP,EBP
LAB_00101637:
SUB EBX,0x1
MOV ESI,R14D
MOV EDI,EBX
CALL 0x00101230
ADD EBP,EAX
CMP R13D,EBX
JNZ 0x00101637
SUB R12D,R13D
ADD EBP,0x1
XOR EBX,EBX
TEST R12D,R12D
JZ 0x00101688
LAB_00101658:
CMP R12D,0x1
JZ 0x0010168a
LAB_0010165e:
LEA R13D,[R12 + -0x1]
XOR ESI,ESI
SUB R12D,0x2
MOV EDI,R13D
CALL 0x00101600
IMUL EAX,R13D
IMUL EAX,EBP
IMUL EBP,R13D
ADD EBX,EAX
TEST R12D,R12D
JNZ 0x00101658
NOP dword ptr [RAX + RAX*0x1]
LAB_00101688:
ADD EBX,EBP
LAB_0010168a:
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101698:
TEST ESI,ESI
JNZ 0x00101629
XOR EBX,EBX
MOV EBP,0x1
JMP 0x0010165e
LAB_001016a8:
XOR EBX,EBX
MOV EBP,0x1
JMP 0x00101688
LAB_001016b8:
MOV EBX,0x1
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001016d0:
XOR EBX,EBX
JMP 0x0010168a | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 == 0 && param_2 == 0) {
return 1;
}
if (param_1 == 1) {
if (param_2 == 0) {
return 0;
}
}
else if (param_2 == 0) {
iVar2 = 0;
iVar3 = 1;
goto LAB_0010165e;
}
if (param_1 == param_2) {
iVar2 = 0;
iVar3 = 1;
}
else {
iVar3 = 0;
iVar2 = param_1;
do {
iVar2 = iVar2 + -1;
iVar1 = binomial_coeffi(iVar2,param_2 + -1);
iVar3 = iVar3 + iVar1;
} while (param_2 != iVar2);
iVar3 = iVar3 + 1;
iVar2 = 0;
for (param_1 = param_1 - param_2; param_1 != 0; param_1 = param_1 + -2) {
if (param_1 == 1) {
return iVar2;
}
LAB_0010165e:
iVar4 = param_1 + -1;
iVar1 = func0(iVar4,0);
iVar1 = iVar1 * iVar4 * iVar3;
iVar3 = iVar3 * iVar4;
iVar2 = iVar2 + iVar1;
}
}
return iVar2 + iVar3;
} |
7,600 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
// Function to find the maximum height of the binary tree
| int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
}
}
}
| int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->right->left = newNode(5);
root1->right->right = newNode(6);
root1->right->right->right = newNode(7);
root1->right->right->right->right = newNode(8);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(6);
root2->left->left->right = newNode(7);
// Testing the max_height function
assert(func0(root) == 3);
assert(func0(root1) == 5);
assert(func0(root2) == 4);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 11eb <func0+0x1e>
mov $0x0,%eax
jmp 1227 <func0+0x5a>
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov %rax,%rdi
callq 11cd <func0>
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov 0x10(%rax),%rax
mov %rax,%rdi
callq 11cd <func0>
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jle 1221 <func0+0x54>
mov -0x8(%rbp),%eax
add $0x1,%eax
jmp 1227 <func0+0x5a>
mov -0x4(%rbp),%eax
add $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
cmp [rbp+var_18], 0
jnz short loc_11EB
mov eax, 0
jmp short locret_1227
loc_11EB:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdi, rax
call func0
mov [rbp+var_8], eax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rdi, rax
call func0
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jle short loc_1221
mov eax, [rbp+var_8]
add eax, 1
jmp short locret_1227
loc_1221:
mov eax, [rbp+var_4]
add eax, 1
locret_1227:
leave
retn | long long func0(long long a1)
{
int v2; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
if ( !a1 )
return 0LL;
v2 = func0(*(_QWORD *)(a1 + 8));
v3 = func0(*(_QWORD *)(a1 + 16));
if ( v2 <= v3 )
return (unsigned int)(v3 + 1);
else
return (unsigned int)(v2 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001011eb
MOV EAX,0x0
JMP 0x00101227
LAB_001011eb:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,RAX
CALL 0x001011cd
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,RAX
CALL 0x001011cd
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JLE 0x00101221
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
JMP 0x00101227
LAB_00101221:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
LAB_00101227:
LEAVE
RET | int func0(long param_1)
{
int iVar1;
int iVar2;
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = func0(*(int8 *)(param_1 + 8));
iVar2 = func0(*(int8 *)(param_1 + 0x10));
if (iVar2 < iVar1) {
iVar1 = iVar1 + 1;
}
else {
iVar1 = iVar2 + 1;
}
}
return iVar1;
} |
7,601 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
// Function to find the maximum height of the binary tree
| int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
}
}
}
| int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->right->left = newNode(5);
root1->right->right = newNode(6);
root1->right->right->right = newNode(7);
root1->right->right->right->right = newNode(8);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(6);
root2->left->left->right = newNode(7);
// Testing the max_height function
assert(func0(root) == 3);
assert(func0(root1) == 5);
assert(func0(root2) == 4);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
test %rdi,%rdi
je 11ed <func0+0x3f>
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov 0x8(%rdi),%rdi
callq 11ae <func0>
mov %eax,%ebp
mov 0x10(%rbx),%rdi
callq 11ae <func0>
mov %eax,%edx
lea 0x1(%rbp),%ecx
lea 0x1(%rax),%eax
cmp %edx,%ebp
cmovg %ecx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
retq
| func0:
endbr64
mov eax, 0
test rdi, rdi
jz short locret_11ED
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rdi, [rdi+8]
call func0
mov ebp, eax
mov rdi, [rbx+10h]
call func0
lea ecx, [rbp+1]
lea edx, [rax+1]
cmp ebp, eax
mov eax, ecx
cmovle eax, edx
add rsp, 8
pop rbx
pop rbp
retn
locret_11ED:
retn | long long func0(long long a1)
{
long long result; // rax
int v2; // ebp
int v3; // eax
unsigned int v4; // edx
bool v5; // cc
result = 0LL;
if ( a1 )
{
v2 = func0(*(_QWORD *)(a1 + 8));
v3 = func0(*(_QWORD *)(a1 + 16));
v4 = v3 + 1;
v5 = v2 <= v3;
result = (unsigned int)(v2 + 1);
if ( v5 )
return v4;
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
TEST RDI,RDI
JZ 0x001011ed
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x001011ae
MOV EBP,EAX
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x001011ae
LEA ECX,[RBP + 0x1]
LEA EDX,[RAX + 0x1]
CMP EBP,EAX
MOV EAX,ECX
CMOVLE EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011ed:
RET | int func0(long param_1)
{
int iVar1;
int iVar2;
if (param_1 != 0) {
iVar1 = func0(*(int8 *)(param_1 + 8));
iVar2 = func0(*(int8 *)(param_1 + 0x10));
if (iVar1 <= iVar2) {
iVar1 = iVar2;
}
return iVar1 + 1;
}
return 0;
} |
7,602 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
// Function to find the maximum height of the binary tree
| int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
}
}
}
| int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->right->left = newNode(5);
root1->right->right = newNode(6);
root1->right->right->right = newNode(7);
root1->right->right->right->right = newNode(8);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(6);
root2->left->left->right = newNode(7);
// Testing the max_height function
assert(func0(root) == 3);
assert(func0(root1) == 5);
assert(func0(root2) == 4);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %rdi,%rdi
je 14e0 <func0+0x10>
jmp 14f0 <func0.part.0>
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov rbp, [rdi+8]
test rbp, rbp
jz loc_1A38
mov r12, [rbp+8]
test r12, r12
jz loc_19D8
mov r13, [r12+8]
test r13, r13
jz loc_1B40
mov r14, [r13+8]
test r14, r14
jz loc_1C00
mov rdi, [r14+8]
test rdi, rdi
jz loc_1AC0
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_148B
loc_1486:
call func0_part_0
loc_148B:
lea edx, [r15+1]
lea r14d, [rax+1]
cmp eax, r15d
cmovl r14d, edx
loc_149A:
mov r15, [r13+10h]
xor eax, eax
test r15, r15
jz short loc_14D9
loc_14A5:
mov rdi, [r15+8]
test rdi, rdi
jz loc_1D60
call func0_part_0
mov rdi, [r15+10h]
mov r13d, eax
xor eax, eax
test rdi, rdi
jz short loc_14CA
loc_14C5:
call func0_part_0
loc_14CA:
lea ecx, [r13+1]
lea edx, [rax+1]
cmp eax, r13d
mov eax, ecx
cmovge eax, edx
loc_14D9:
lea edx, [r14+1]
lea r13d, [rax+1]
cmp eax, r14d
cmovl r13d, edx
loc_14E8:
mov r14, [r12+10h]
xor eax, eax
test r14, r14
jz loc_1586
mov r12, [r14+8]
test r12, r12
jz loc_1B64
loc_1505:
mov rdi, [r12+8]
test rdi, rdi
jz loc_1C40
call func0_part_0
mov rdi, [r12+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_152C
loc_1527:
call func0_part_0
loc_152C:
lea edx, [r15+1]
lea r12d, [rax+1]
cmp eax, r15d
cmovl r12d, edx
loc_153B:
mov r14, [r14+10h]
xor edx, edx
test r14, r14
jz short loc_1578
loc_1546:
mov rdi, [r14+8]
test rdi, rdi
jz loc_1D40
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_156B
loc_1566:
call func0_part_0
loc_156B:
lea ecx, [r15+1]
lea edx, [rax+1]
cmp eax, r15d
cmovl edx, ecx
loc_1578:
lea ecx, [r12+1]
lea eax, [rdx+1]
cmp edx, r12d
cmovl eax, ecx
loc_1586:
lea edx, [r13+1]
lea r12d, [rax+1]
cmp eax, r13d
cmovl r12d, edx
loc_1595:
mov r13, [rbp+10h]
xor eax, eax
test r13, r13
jz loc_16E2
mov rbp, [r13+8]
test rbp, rbp
jz loc_19FA
loc_15B1:
mov r14, [rbp+8]
test r14, r14
jz loc_1C20
mov rdi, [r14+8]
test rdi, rdi
jz loc_1AE0
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_15E3
loc_15DE:
call func0_part_0
loc_15E3:
lea edx, [r15+1]
lea r14d, [rax+1]
cmp eax, r15d
cmovl r14d, edx
loc_15F2:
mov r15, [rbp+10h]
xor eax, eax
test r15, r15
jz short loc_162E
loc_15FD:
mov rdi, [r15+8]
test rdi, rdi
jz loc_1D20
call func0_part_0
mov rdi, [r15+10h]
mov ebp, eax
xor eax, eax
test rdi, rdi
jz short loc_1621
loc_161C:
call func0_part_0
loc_1621:
lea ecx, [rbp+1]
lea edx, [rax+1]
cmp eax, ebp
mov eax, ecx
cmovge eax, edx
loc_162E:
lea edx, [r14+1]
lea ebp, [rax+1]
cmp eax, r14d
cmovl ebp, edx
loc_163B:
mov r13, [r13+10h]
xor edx, edx
test r13, r13
jz loc_16D7
mov r14, [r13+8]
test r14, r14
jz loc_1A1B
loc_1657:
mov rdi, [r14+8]
test rdi, rdi
jz loc_1CE0
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_167C
loc_1677:
call func0_part_0
loc_167C:
lea edx, [r15+1]
lea r14d, [rax+1]
cmp eax, r15d
cmovl r14d, edx
loc_168B:
mov r13, [r13+10h]
xor eax, eax
test r13, r13
jz short loc_16CA
loc_1696:
mov rdi, [r13+8]
test rdi, rdi
jz loc_1D00
call func0_part_0
mov rdi, [r13+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_16BB
loc_16B6:
call func0_part_0
loc_16BB:
lea ecx, [r15+1]
lea edx, [rax+1]
cmp eax, r15d
mov eax, ecx
cmovge eax, edx
loc_16CA:
lea ecx, [r14+1]
lea edx, [rax+1]
cmp eax, r14d
cmovl edx, ecx
loc_16D7:
lea ecx, [rbp+1]
lea eax, [rdx+1]
cmp edx, ebp
cmovl eax, ecx
loc_16E2:
lea edx, [r12+1]
lea ebp, [rax+1]
cmp eax, r12d
cmovl ebp, edx
loc_16F0:
mov rbx, [rbx+10h]
xor edx, edx
test rbx, rbx
jz loc_19B8
mov r12, [rbx+8]
test r12, r12
jz loc_1A59
loc_170C:
mov r13, [r12+8]
test r13, r13
jz loc_1B80
mov r14, [r13+8]
test r14, r14
jz loc_1BC0
mov rdi, [r14+8]
test rdi, rdi
jz loc_1B00
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_174C
loc_1747:
call func0_part_0
loc_174C:
lea edx, [r15+1]
lea r14d, [rax+1]
cmp eax, r15d
cmovl r14d, edx
loc_175B:
mov r15, [r13+10h]
xor eax, eax
test r15, r15
jz short loc_179A
loc_1766:
mov rdi, [r15+8]
test rdi, rdi
jz loc_1CC0
call func0_part_0
mov rdi, [r15+10h]
mov r13d, eax
xor eax, eax
test rdi, rdi
jz short loc_178B
loc_1786:
call func0_part_0
loc_178B:
lea ecx, [r13+1]
lea edx, [rax+1]
cmp eax, r13d
mov eax, ecx
cmovge eax, edx
loc_179A:
lea edx, [r14+1]
lea r13d, [rax+1]
cmp eax, r14d
cmovl r13d, edx
loc_17A9:
mov r14, [r12+10h]
xor eax, eax
test r14, r14
jz loc_1847
mov r12, [r14+8]
test r12, r12
jz loc_1BA4
loc_17C6:
mov rdi, [r12+8]
test rdi, rdi
jz loc_1DA0
call func0_part_0
mov rdi, [r12+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_17ED
loc_17E8:
call func0_part_0
loc_17ED:
lea edx, [r15+1]
lea r12d, [rax+1]
cmp eax, r15d
cmovl r12d, edx
loc_17FC:
mov r14, [r14+10h]
xor edx, edx
test r14, r14
jz short loc_1839
loc_1807:
mov rdi, [r14+8]
test rdi, rdi
jz loc_1D80
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_182C
loc_1827:
call func0_part_0
loc_182C:
lea ecx, [r15+1]
lea edx, [rax+1]
cmp eax, r15d
cmovl edx, ecx
loc_1839:
lea ecx, [r12+1]
lea eax, [rdx+1]
cmp edx, r12d
cmovl eax, ecx
loc_1847:
lea edx, [r13+1]
lea r12d, [rax+1]
cmp eax, r13d
cmovl r12d, edx
loc_1856:
mov rbx, [rbx+10h]
xor eax, eax
test rbx, rbx
jz loc_19AA
mov r13, [rbx+8]
test r13, r13
jz loc_1A7B
loc_1872:
mov r14, [r13+8]
test r14, r14
jz loc_1BE0
mov rdi, [r14+8]
test rdi, rdi
jz loc_1B20
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_18A4
loc_189F:
call func0_part_0
loc_18A4:
lea edx, [r15+1]
lea r14d, [rax+1]
cmp eax, r15d
cmovl r14d, edx
loc_18B3:
mov r15, [r13+10h]
xor eax, eax
test r15, r15
jz short loc_18F2
loc_18BE:
mov rdi, [r15+8]
test rdi, rdi
jz loc_1CA0
call func0_part_0
mov rdi, [r15+10h]
mov r13d, eax
xor eax, eax
test rdi, rdi
jz short loc_18E3
loc_18DE:
call func0_part_0
loc_18E3:
lea ecx, [r13+1]
lea edx, [rax+1]
cmp eax, r13d
mov eax, ecx
cmovge eax, edx
loc_18F2:
lea edx, [r14+1]
lea r13d, [rax+1]
cmp eax, r14d
cmovl r13d, edx
loc_1901:
mov rbx, [rbx+10h]
xor edx, edx
test rbx, rbx
jz loc_199D
mov r14, [rbx+8]
test r14, r14
jz loc_1A9D
loc_191D:
mov rdi, [r14+8]
test rdi, rdi
jz loc_1C60
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_1942
loc_193D:
call func0_part_0
loc_1942:
lea edx, [r15+1]
lea r14d, [rax+1]
cmp eax, r15d
cmovl r14d, edx
loc_1951:
mov rbx, [rbx+10h]
xor eax, eax
test rbx, rbx
jz short loc_1990
loc_195C:
mov rdi, [rbx+8]
test rdi, rdi
jz loc_1C80
call func0_part_0
mov rdi, [rbx+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_1981
loc_197C:
call func0_part_0
loc_1981:
lea ecx, [r15+1]
lea edx, [rax+1]
cmp eax, r15d
mov eax, ecx
cmovge eax, edx
loc_1990:
lea ecx, [r14+1]
lea edx, [rax+1]
cmp eax, r14d
cmovl edx, ecx
loc_199D:
lea ecx, [r13+1]
lea eax, [rdx+1]
cmp edx, r13d
cmovl eax, ecx
loc_19AA:
lea ecx, [r12+1]
lea edx, [rax+1]
cmp eax, r12d
cmovl edx, ecx
loc_19B8:
lea ecx, [rbp+1]
lea eax, [rdx+1]
cmp edx, ebp
cmovl eax, ecx
loc_19C3:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_19D8:
mov r13, [rbp+10h]
xor r12d, r12d
mov ebp, 1
test r13, r13
jz loc_16F0
mov rbp, [r13+8]
test rbp, rbp
jnz loc_15B1
loc_19FA:
mov r13, [r13+10h]
mov eax, 1
xor ebp, ebp
test r13, r13
jz loc_16E2
mov r14, [r13+8]
test r14, r14
jnz loc_1657
loc_1A1B:
mov r13, [r13+10h]
mov edx, 1
xor r14d, r14d
test r13, r13
jnz loc_1696
jmp loc_16D7
loc_1A38:
mov rbx, [rdi+10h]
mov eax, 1
xor ebp, ebp
test rbx, rbx
jz loc_19C3
mov r12, [rbx+8]
test r12, r12
jnz loc_170C
loc_1A59:
mov rbx, [rbx+10h]
mov edx, 1
xor r12d, r12d
test rbx, rbx
jz loc_19B8
mov r13, [rbx+8]
test r13, r13
jnz loc_1872
loc_1A7B:
mov rbx, [rbx+10h]
mov eax, 1
xor r13d, r13d
test rbx, rbx
jz loc_19AA
mov r14, [rbx+8]
test r14, r14
jnz loc_191D
loc_1A9D:
mov rbx, [rbx+10h]
mov edx, 1
xor r14d, r14d
test rbx, rbx
jnz loc_195C
jmp loc_199D
loc_1AC0:
mov rdi, [r14+10h]
xor r15d, r15d
mov r14d, 1
test rdi, rdi
jnz loc_1486
jmp loc_149A
loc_1AE0:
mov rdi, [r14+10h]
xor r15d, r15d
mov r14d, 1
test rdi, rdi
jnz loc_15DE
jmp loc_15F2
loc_1B00:
mov rdi, [r14+10h]
xor r15d, r15d
mov r14d, 1
test rdi, rdi
jnz loc_1747
jmp loc_175B
loc_1B20:
mov rdi, [r14+10h]
xor r15d, r15d
mov r14d, 1
test rdi, rdi
jnz loc_189F
jmp loc_18B3
loc_1B40:
mov r14, [r12+10h]
xor r13d, r13d
mov r12d, 1
test r14, r14
jz loc_1595
mov r12, [r14+8]
test r12, r12
jnz loc_1505
loc_1B64:
mov r14, [r14+10h]
mov eax, 1
xor r12d, r12d
test r14, r14
jnz loc_1546
jmp loc_1586
loc_1B80:
mov r14, [r12+10h]
xor r13d, r13d
mov r12d, 1
test r14, r14
jz loc_1856
mov r12, [r14+8]
test r12, r12
jnz loc_17C6
loc_1BA4:
mov r14, [r14+10h]
mov eax, 1
xor r12d, r12d
test r14, r14
jnz loc_1807
jmp loc_1847
loc_1BC0:
mov r15, [r13+10h]
xor r14d, r14d
mov r13d, 1
test r15, r15
jnz loc_1766
jmp loc_17A9
loc_1BE0:
mov r15, [r13+10h]
xor r14d, r14d
mov r13d, 1
test r15, r15
jnz loc_18BE
jmp loc_1901
loc_1C00:
mov r15, [r13+10h]
xor r14d, r14d
mov r13d, 1
test r15, r15
jnz loc_14A5
jmp loc_14E8
loc_1C20:
mov r15, [rbp+10h]
xor r14d, r14d
mov ebp, 1
test r15, r15
jnz loc_15FD
jmp loc_163B
loc_1C40:
mov rdi, [r12+10h]
xor r15d, r15d
mov r12d, 1
test rdi, rdi
jnz loc_1527
jmp loc_153B
loc_1C60:
mov rdi, [r14+10h]
xor r15d, r15d
mov r14d, 1
test rdi, rdi
jnz loc_193D
jmp loc_1951
loc_1C80:
mov rdi, [rbx+10h]
mov eax, 1
xor r15d, r15d
test rdi, rdi
jnz loc_197C
jmp loc_1990
loc_1CA0:
mov rdi, [r15+10h]
mov eax, 1
xor r13d, r13d
test rdi, rdi
jnz loc_18DE
jmp loc_18F2
loc_1CC0:
mov rdi, [r15+10h]
mov eax, 1
xor r13d, r13d
test rdi, rdi
jnz loc_1786
jmp loc_179A
loc_1CE0:
mov rdi, [r14+10h]
xor r15d, r15d
mov r14d, 1
test rdi, rdi
jnz loc_1677
jmp loc_168B
loc_1D00:
mov rdi, [r13+10h]
mov eax, 1
xor r15d, r15d
test rdi, rdi
jnz loc_16B6
jmp loc_16CA
loc_1D20:
mov rdi, [r15+10h]
mov eax, 1
xor ebp, ebp
test rdi, rdi
jnz loc_161C
jmp loc_162E
loc_1D40:
mov rdi, [r14+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1566
jmp loc_1578
loc_1D60:
mov rdi, [r15+10h]
mov eax, 1
xor r13d, r13d
test rdi, rdi
jnz loc_14C5
jmp loc_14D9
loc_1D80:
mov rdi, [r14+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1827
jmp loc_1839
loc_1DA0:
mov rdi, [r12+10h]
xor r15d, r15d
mov r12d, 1
test rdi, rdi
jnz loc_17E8
jmp loc_17FC | long long func0_part_0(long long a1, long long a2, long long a3)
{
long long v4; // rbp
long long v5; // r12
long long v6; // r13
long long v7; // r14
int v8; // r15d
int v9; // eax
int v10; // r14d
long long v11; // r15
int v12; // eax
int v13; // r13d
int v14; // eax
int v15; // edx
bool v16; // cc
int v17; // r13d
long long v18; // r14
int v19; // eax
long long v20; // r12
int v21; // r15d
int v22; // eax
int v23; // r12d
long long v24; // r14
long long v25; // rdi
int v26; // eax
long long v27; // rdi
int v28; // r15d
int v29; // eax
int v30; // r12d
long long v31; // r13
int v32; // eax
long long v33; // rbp
long long v34; // r14
long long v35; // rdi
int v36; // eax
long long v37; // rdi
int v38; // r15d
int v39; // eax
int v40; // r14d
long long v41; // r15
int v42; // eax
long long v43; // rdi
int v44; // eax
long long v45; // rdi
int v46; // ebp
int v47; // eax
int v48; // edx
int v49; // ebp
long long v50; // r13
long long v51; // r14
long long v52; // rdi
int v53; // eax
long long v54; // rdi
int v55; // r15d
int v56; // eax
int v57; // r14d
long long v58; // r13
int v59; // eax
long long v60; // rdi
int v61; // eax
long long v62; // rdi
int v63; // r15d
int v64; // eax
int v65; // edx
int v66; // ebp
long long v67; // rbx
long long v68; // r12
long long v69; // r13
long long v70; // r14
long long v71; // rdi
int v72; // eax
long long v73; // rdi
int v74; // r15d
int v75; // eax
int v76; // r14d
long long v77; // r15
int v78; // eax
long long v79; // rdi
int v80; // eax
long long v81; // rdi
int v82; // r13d
int v83; // eax
int v84; // edx
int v85; // r13d
long long v86; // r14
int v87; // eax
long long v88; // r12
long long v89; // rdi
int v90; // eax
long long v91; // rdi
int v92; // r15d
int v93; // eax
int v94; // r12d
long long v95; // r14
long long v96; // rdi
int v97; // eax
long long v98; // rdi
int v99; // r15d
int v100; // eax
int v101; // r12d
long long v102; // rbx
int v103; // eax
long long v104; // r13
long long v105; // r14
long long v106; // rdi
int v107; // eax
long long v108; // rdi
int v109; // r15d
int v110; // eax
int v111; // r14d
long long v112; // r15
int v113; // eax
long long v114; // rdi
int v115; // eax
long long v116; // rdi
int v117; // r13d
int v118; // eax
int v119; // edx
int v120; // r13d
long long v121; // rbx
long long v122; // r14
long long v123; // rdi
int v124; // eax
long long v125; // rdi
int v126; // r15d
int v127; // eax
int v128; // r14d
long long v129; // rbx
int v130; // eax
long long v131; // rdi
int v132; // eax
long long v133; // rdi
int v134; // r15d
int v135; // eax
int v136; // edx
long long result; // rax
long long v138; // rdi
long long v139; // rdi
v4 = *(_QWORD *)(a1 + 8);
if ( !v4 )
{
v67 = *(_QWORD *)(a1 + 16);
result = 1LL;
v66 = 0;
if ( !v67 )
return result;
v68 = *(_QWORD *)(v67 + 8);
if ( v68 )
{
LABEL_72:
v69 = *(_QWORD *)(v68 + 8);
if ( !v69 )
{
v86 = *(_QWORD *)(v68 + 16);
v85 = 0;
v101 = 1;
if ( !v86 )
{
LABEL_104:
v102 = *(_QWORD *)(v67 + 16);
v103 = 0;
if ( !v102 )
goto LABEL_137;
v104 = *(_QWORD *)(v102 + 8);
if ( v104 )
goto LABEL_106;
LABEL_152:
v121 = *(_QWORD *)(v102 + 16);
v103 = 1;
v120 = 0;
if ( v121 )
{
v122 = *(_QWORD *)(v121 + 8);
if ( v122 )
{
LABEL_122:
v123 = *(_QWORD *)(v122 + 8);
if ( v123 )
{
v124 = func0_part_0(v123, a2, a3);
v125 = *(_QWORD *)(v122 + 16);
v126 = v124;
v127 = 0;
if ( !v125 )
goto LABEL_125;
}
else
{
v125 = *(_QWORD *)(v122 + 16);
v126 = 0;
v128 = 1;
if ( !v125 )
goto LABEL_127;
}
v127 = func0_part_0(v125, a2, a3);
LABEL_125:
a3 = (unsigned int)(v126 + 1);
v128 = v127 + 1;
if ( v127 < v126 )
v128 = v126 + 1;
LABEL_127:
v129 = *(_QWORD *)(v121 + 16);
v130 = 0;
if ( !v129 )
goto LABEL_133;
goto LABEL_128;
}
goto LABEL_154;
}
LABEL_137:
LODWORD(a3) = v103 + 1;
if ( v103 < v101 )
LODWORD(a3) = v101 + 1;
goto LABEL_139;
}
v88 = *(_QWORD *)(v86 + 8);
if ( v88 )
{
LABEL_89:
v89 = *(_QWORD *)(v88 + 8);
if ( v89 )
{
v90 = func0_part_0(v89, a2, a3);
v91 = *(_QWORD *)(v88 + 16);
v92 = v90;
v93 = 0;
if ( !v91 )
goto LABEL_92;
}
else
{
v91 = *(_QWORD *)(v88 + 16);
v92 = 0;
v94 = 1;
if ( !v91 )
goto LABEL_94;
}
v93 = func0_part_0(v91, a2, a3);
LABEL_92:
v94 = v93 + 1;
if ( v93 < v92 )
v94 = v92 + 1;
LABEL_94:
v95 = *(_QWORD *)(v86 + 16);
a3 = 0LL;
if ( !v95 )
goto LABEL_100;
goto LABEL_95;
}
goto LABEL_170;
}
v70 = *(_QWORD *)(v69 + 8);
if ( !v70 )
{
v77 = *(_QWORD *)(v69 + 16);
v76 = 0;
v85 = 1;
if ( !v77 )
{
LABEL_87:
v86 = *(_QWORD *)(v68 + 16);
v87 = 0;
if ( !v86 )
goto LABEL_102;
v88 = *(_QWORD *)(v86 + 8);
if ( v88 )
goto LABEL_89;
LABEL_170:
v95 = *(_QWORD *)(v86 + 16);
v87 = 1;
v94 = 0;
if ( v95 )
{
LABEL_95:
v96 = *(_QWORD *)(v95 + 8);
if ( v96 )
{
v97 = func0_part_0(v96, a2, a3);
v98 = *(_QWORD *)(v95 + 16);
v99 = v97;
v100 = 0;
if ( !v98 )
goto LABEL_98;
goto LABEL_97;
}
v98 = *(_QWORD *)(v95 + 16);
a3 = 1LL;
v99 = 0;
if ( v98 )
{
LABEL_97:
v100 = func0_part_0(v98, a2, a3);
LABEL_98:
LODWORD(a3) = v100 + 1;
if ( v100 < v99 )
LODWORD(a3) = v99 + 1;
}
LABEL_100:
v87 = a3 + 1;
if ( (int)a3 < v94 )
v87 = v94 + 1;
}
LABEL_102:
a3 = (unsigned int)(v85 + 1);
v101 = v87 + 1;
if ( v87 < v85 )
v101 = v85 + 1;
goto LABEL_104;
}
LABEL_80:
v79 = *(_QWORD *)(v77 + 8);
if ( v79 )
{
v80 = func0_part_0(v79, a2, a3);
v81 = *(_QWORD *)(v77 + 16);
v82 = v80;
v83 = 0;
if ( !v81 )
goto LABEL_83;
goto LABEL_82;
}
v81 = *(_QWORD *)(v77 + 16);
v78 = 1;
v82 = 0;
if ( v81 )
{
LABEL_82:
v83 = func0_part_0(v81, a2, a3);
LABEL_83:
v84 = v83 + 1;
v16 = v83 < v82;
v78 = v82 + 1;
if ( !v16 )
v78 = v84;
}
LABEL_85:
a3 = (unsigned int)(v76 + 1);
v85 = v78 + 1;
if ( v78 < v76 )
v85 = v76 + 1;
goto LABEL_87;
}
v71 = *(_QWORD *)(v70 + 8);
if ( v71 )
{
v72 = func0_part_0(v71, a2, a3);
v73 = *(_QWORD *)(v70 + 16);
v74 = v72;
v75 = 0;
if ( !v73 )
goto LABEL_77;
}
else
{
v73 = *(_QWORD *)(v70 + 16);
v74 = 0;
v76 = 1;
if ( !v73 )
goto LABEL_79;
}
v75 = func0_part_0(v73, a2, a3);
LABEL_77:
a3 = (unsigned int)(v74 + 1);
v76 = v75 + 1;
if ( v75 < v74 )
v76 = v74 + 1;
LABEL_79:
v77 = *(_QWORD *)(v69 + 16);
v78 = 0;
if ( !v77 )
goto LABEL_85;
goto LABEL_80;
}
goto LABEL_150;
}
v5 = *(_QWORD *)(v4 + 8);
if ( v5 )
{
v6 = *(_QWORD *)(v5 + 8);
if ( !v6 )
{
v18 = *(_QWORD *)(v5 + 16);
v17 = 0;
v30 = 1;
if ( !v18 )
{
LABEL_35:
v31 = *(_QWORD *)(v4 + 16);
v32 = 0;
if ( !v31 )
goto LABEL_68;
v33 = *(_QWORD *)(v31 + 8);
if ( v33 )
goto LABEL_37;
LABEL_144:
v50 = *(_QWORD *)(v31 + 16);
v32 = 1;
v49 = 0;
if ( v50 )
{
v51 = *(_QWORD *)(v50 + 8);
if ( v51 )
{
LABEL_53:
v52 = *(_QWORD *)(v51 + 8);
if ( v52 )
{
v53 = func0_part_0(v52, a2, a3);
v54 = *(_QWORD *)(v51 + 16);
v55 = v53;
v56 = 0;
if ( !v54 )
goto LABEL_56;
}
else
{
v54 = *(_QWORD *)(v51 + 16);
v55 = 0;
v57 = 1;
if ( !v54 )
goto LABEL_58;
}
v56 = func0_part_0(v54, a2, a3);
LABEL_56:
a3 = (unsigned int)(v55 + 1);
v57 = v56 + 1;
if ( v56 < v55 )
v57 = v55 + 1;
LABEL_58:
v58 = *(_QWORD *)(v50 + 16);
v59 = 0;
if ( !v58 )
goto LABEL_64;
goto LABEL_59;
}
goto LABEL_146;
}
LABEL_68:
v66 = v32 + 1;
if ( v32 < v30 )
v66 = v30 + 1;
goto LABEL_70;
}
v20 = *(_QWORD *)(v18 + 8);
if ( v20 )
{
LABEL_20:
if ( *(_QWORD *)(v20 + 8) )
{
v21 = ((long long (*)(void))func0_part_0)();
v22 = 0;
if ( !*(_QWORD *)(v20 + 16) )
goto LABEL_23;
}
else
{
v139 = *(_QWORD *)(v20 + 16);
v21 = 0;
v23 = 1;
if ( !v139 )
goto LABEL_25;
}
v22 = ((long long (*)(void))func0_part_0)();
LABEL_23:
v23 = v22 + 1;
if ( v22 < v21 )
v23 = v21 + 1;
LABEL_25:
v24 = *(_QWORD *)(v18 + 16);
a3 = 0LL;
if ( !v24 )
goto LABEL_31;
goto LABEL_26;
}
goto LABEL_166;
}
v7 = *(_QWORD *)(v6 + 8);
if ( !v7 )
{
v11 = *(_QWORD *)(v6 + 16);
v10 = 0;
v17 = 1;
if ( !v11 )
{
LABEL_18:
v18 = *(_QWORD *)(v5 + 16);
v19 = 0;
if ( !v18 )
goto LABEL_33;
v20 = *(_QWORD *)(v18 + 8);
if ( v20 )
goto LABEL_20;
LABEL_166:
v24 = *(_QWORD *)(v18 + 16);
v19 = 1;
v23 = 0;
if ( v24 )
{
LABEL_26:
v25 = *(_QWORD *)(v24 + 8);
if ( v25 )
{
v26 = func0_part_0(v25, a2, a3);
v27 = *(_QWORD *)(v24 + 16);
v28 = v26;
v29 = 0;
if ( !v27 )
goto LABEL_29;
goto LABEL_28;
}
v27 = *(_QWORD *)(v24 + 16);
a3 = 1LL;
v28 = 0;
if ( v27 )
{
LABEL_28:
v29 = func0_part_0(v27, a2, a3);
LABEL_29:
LODWORD(a3) = v29 + 1;
if ( v29 < v28 )
LODWORD(a3) = v28 + 1;
}
LABEL_31:
v19 = a3 + 1;
if ( (int)a3 < v23 )
v19 = v23 + 1;
}
LABEL_33:
a3 = (unsigned int)(v17 + 1);
v30 = v19 + 1;
if ( v19 < v17 )
v30 = v17 + 1;
goto LABEL_35;
}
LABEL_11:
if ( *(_QWORD *)(v11 + 8) )
{
v13 = ((long long (*)(void))func0_part_0)();
v14 = 0;
if ( !*(_QWORD *)(v11 + 16) )
goto LABEL_14;
goto LABEL_13;
}
v12 = 1;
v13 = 0;
if ( *(_QWORD *)(v11 + 16) )
{
LABEL_13:
v14 = ((long long (*)(void))func0_part_0)();
LABEL_14:
v15 = v14 + 1;
v16 = v14 < v13;
v12 = v13 + 1;
if ( !v16 )
v12 = v15;
}
LABEL_16:
a3 = (unsigned int)(v10 + 1);
v17 = v12 + 1;
if ( v12 < v10 )
v17 = v10 + 1;
goto LABEL_18;
}
if ( *(_QWORD *)(v7 + 8) )
{
v8 = ((long long (*)(void))func0_part_0)();
v9 = 0;
if ( !*(_QWORD *)(v7 + 16) )
goto LABEL_8;
}
else
{
v138 = *(_QWORD *)(v7 + 16);
v8 = 0;
v10 = 1;
if ( !v138 )
goto LABEL_10;
}
v9 = ((long long (*)(void))func0_part_0)();
LABEL_8:
v10 = v9 + 1;
if ( v9 < v8 )
v10 = v8 + 1;
LABEL_10:
v11 = *(_QWORD *)(v6 + 16);
v12 = 0;
if ( !v11 )
goto LABEL_16;
goto LABEL_11;
}
v31 = *(_QWORD *)(v4 + 16);
v30 = 0;
v66 = 1;
if ( v31 )
{
v33 = *(_QWORD *)(v31 + 8);
if ( v33 )
{
LABEL_37:
v34 = *(_QWORD *)(v33 + 8);
if ( !v34 )
{
v41 = *(_QWORD *)(v33 + 16);
v40 = 0;
v49 = 1;
if ( !v41 )
{
LABEL_51:
v50 = *(_QWORD *)(v31 + 16);
a3 = 0LL;
if ( !v50 )
goto LABEL_66;
v51 = *(_QWORD *)(v50 + 8);
if ( v51 )
goto LABEL_53;
LABEL_146:
v58 = *(_QWORD *)(v50 + 16);
a3 = 1LL;
v57 = 0;
if ( v58 )
{
LABEL_59:
v60 = *(_QWORD *)(v58 + 8);
if ( v60 )
{
v61 = func0_part_0(v60, a2, a3);
v62 = *(_QWORD *)(v58 + 16);
v63 = v61;
v64 = 0;
if ( !v62 )
goto LABEL_62;
goto LABEL_61;
}
v62 = *(_QWORD *)(v58 + 16);
v59 = 1;
v63 = 0;
if ( v62 )
{
LABEL_61:
v64 = func0_part_0(v62, a2, a3);
LABEL_62:
v65 = v64 + 1;
v16 = v64 < v63;
v59 = v63 + 1;
if ( !v16 )
v59 = v65;
}
LABEL_64:
LODWORD(a3) = v59 + 1;
if ( v59 < v57 )
LODWORD(a3) = v57 + 1;
}
LABEL_66:
v32 = a3 + 1;
if ( (int)a3 < v49 )
v32 = v49 + 1;
goto LABEL_68;
}
LABEL_44:
v43 = *(_QWORD *)(v41 + 8);
if ( v43 )
{
v44 = func0_part_0(v43, a2, a3);
v45 = *(_QWORD *)(v41 + 16);
v46 = v44;
v47 = 0;
if ( !v45 )
goto LABEL_47;
goto LABEL_46;
}
v45 = *(_QWORD *)(v41 + 16);
v42 = 1;
v46 = 0;
if ( v45 )
{
LABEL_46:
v47 = func0_part_0(v45, a2, a3);
LABEL_47:
v48 = v47 + 1;
v16 = v47 < v46;
v42 = v46 + 1;
if ( !v16 )
v42 = v48;
}
LABEL_49:
v49 = v42 + 1;
if ( v42 < v40 )
v49 = v40 + 1;
goto LABEL_51;
}
v35 = *(_QWORD *)(v34 + 8);
if ( v35 )
{
v36 = func0_part_0(v35, a2, a3);
v37 = *(_QWORD *)(v34 + 16);
v38 = v36;
v39 = 0;
if ( !v37 )
goto LABEL_41;
}
else
{
v37 = *(_QWORD *)(v34 + 16);
v38 = 0;
v40 = 1;
if ( !v37 )
goto LABEL_43;
}
v39 = func0_part_0(v37, a2, a3);
LABEL_41:
a3 = (unsigned int)(v38 + 1);
v40 = v39 + 1;
if ( v39 < v38 )
v40 = v38 + 1;
LABEL_43:
v41 = *(_QWORD *)(v33 + 16);
v42 = 0;
if ( !v41 )
goto LABEL_49;
goto LABEL_44;
}
goto LABEL_144;
}
LABEL_70:
v67 = *(_QWORD *)(a1 + 16);
a3 = 0LL;
if ( !v67 )
goto LABEL_139;
v68 = *(_QWORD *)(v67 + 8);
if ( v68 )
goto LABEL_72;
LABEL_150:
v102 = *(_QWORD *)(v67 + 16);
a3 = 1LL;
v101 = 0;
if ( v102 )
{
v104 = *(_QWORD *)(v102 + 8);
if ( v104 )
{
LABEL_106:
v105 = *(_QWORD *)(v104 + 8);
if ( !v105 )
{
v112 = *(_QWORD *)(v104 + 16);
v111 = 0;
v120 = 1;
if ( !v112 )
{
LABEL_120:
v121 = *(_QWORD *)(v102 + 16);
a3 = 0LL;
if ( !v121 )
goto LABEL_135;
v122 = *(_QWORD *)(v121 + 8);
if ( v122 )
goto LABEL_122;
LABEL_154:
v129 = *(_QWORD *)(v121 + 16);
a3 = 1LL;
v128 = 0;
if ( v129 )
{
LABEL_128:
v131 = *(_QWORD *)(v129 + 8);
if ( v131 )
{
v132 = func0_part_0(v131, a2, a3);
v133 = *(_QWORD *)(v129 + 16);
v134 = v132;
v135 = 0;
if ( !v133 )
goto LABEL_131;
goto LABEL_130;
}
v133 = *(_QWORD *)(v129 + 16);
v130 = 1;
v134 = 0;
if ( v133 )
{
LABEL_130:
v135 = func0_part_0(v133, a2, a3);
LABEL_131:
v136 = v135 + 1;
v16 = v135 < v134;
v130 = v134 + 1;
if ( !v16 )
v130 = v136;
}
LABEL_133:
LODWORD(a3) = v130 + 1;
if ( v130 < v128 )
LODWORD(a3) = v128 + 1;
}
LABEL_135:
v103 = a3 + 1;
if ( (int)a3 < v120 )
v103 = v120 + 1;
goto LABEL_137;
}
LABEL_113:
v114 = *(_QWORD *)(v112 + 8);
if ( v114 )
{
v115 = func0_part_0(v114, a2, a3);
v116 = *(_QWORD *)(v112 + 16);
v117 = v115;
v118 = 0;
if ( !v116 )
goto LABEL_116;
goto LABEL_115;
}
v116 = *(_QWORD *)(v112 + 16);
v113 = 1;
v117 = 0;
if ( v116 )
{
LABEL_115:
v118 = func0_part_0(v116, a2, a3);
LABEL_116:
v119 = v118 + 1;
v16 = v118 < v117;
v113 = v117 + 1;
if ( !v16 )
v113 = v119;
}
LABEL_118:
v120 = v113 + 1;
if ( v113 < v111 )
v120 = v111 + 1;
goto LABEL_120;
}
v106 = *(_QWORD *)(v105 + 8);
if ( v106 )
{
v107 = func0_part_0(v106, a2, a3);
v108 = *(_QWORD *)(v105 + 16);
v109 = v107;
v110 = 0;
if ( !v108 )
goto LABEL_110;
}
else
{
v108 = *(_QWORD *)(v105 + 16);
v109 = 0;
v111 = 1;
if ( !v108 )
goto LABEL_112;
}
v110 = func0_part_0(v108, a2, a3);
LABEL_110:
a3 = (unsigned int)(v109 + 1);
v111 = v110 + 1;
if ( v110 < v109 )
v111 = v109 + 1;
LABEL_112:
v112 = *(_QWORD *)(v104 + 16);
v113 = 0;
if ( !v112 )
goto LABEL_118;
goto LABEL_113;
}
goto LABEL_152;
}
LABEL_139:
result = (unsigned int)(a3 + 1);
if ( (int)a3 < v66 )
return (unsigned int)(v66 + 1);
return result;
} | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RBP,qword ptr [RDI + 0x8]
TEST RBP,RBP
JZ 0x00101a38
MOV R12,qword ptr [RBP + 0x8]
TEST R12,R12
JZ 0x001019d8
MOV R13,qword ptr [R12 + 0x8]
TEST R13,R13
JZ 0x00101b40
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101c00
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101ac0
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010148b
LAB_00101486:
CALL 0x00101420
LAB_0010148b:
LEA EDX,[R15 + 0x1]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R14D,EDX
LAB_0010149a:
MOV R15,qword ptr [R13 + 0x10]
XOR EAX,EAX
TEST R15,R15
JZ 0x001014d9
LAB_001014a5:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x00101d60
CALL 0x00101420
MOV RDI,qword ptr [R15 + 0x10]
MOV R13D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001014ca
LAB_001014c5:
CALL 0x00101420
LAB_001014ca:
LEA ECX,[R13 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R13D
MOV EAX,ECX
CMOVGE EAX,EDX
LAB_001014d9:
LEA EDX,[R14 + 0x1]
LEA R13D,[RAX + 0x1]
CMP EAX,R14D
CMOVL R13D,EDX
LAB_001014e8:
MOV R14,qword ptr [R12 + 0x10]
XOR EAX,EAX
TEST R14,R14
JZ 0x00101586
MOV R12,qword ptr [R14 + 0x8]
TEST R12,R12
JZ 0x00101b64
LAB_00101505:
MOV RDI,qword ptr [R12 + 0x8]
TEST RDI,RDI
JZ 0x00101c40
CALL 0x00101420
MOV RDI,qword ptr [R12 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010152c
LAB_00101527:
CALL 0x00101420
LAB_0010152c:
LEA EDX,[R15 + 0x1]
LEA R12D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R12D,EDX
LAB_0010153b:
MOV R14,qword ptr [R14 + 0x10]
XOR EDX,EDX
TEST R14,R14
JZ 0x00101578
LAB_00101546:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101d40
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010156b
LAB_00101566:
CALL 0x00101420
LAB_0010156b:
LEA ECX,[R15 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R15D
CMOVL EDX,ECX
LAB_00101578:
LEA ECX,[R12 + 0x1]
LEA EAX,[RDX + 0x1]
CMP EDX,R12D
CMOVL EAX,ECX
LAB_00101586:
LEA EDX,[R13 + 0x1]
LEA R12D,[RAX + 0x1]
CMP EAX,R13D
CMOVL R12D,EDX
LAB_00101595:
MOV R13,qword ptr [RBP + 0x10]
XOR EAX,EAX
TEST R13,R13
JZ 0x001016e2
MOV RBP,qword ptr [R13 + 0x8]
TEST RBP,RBP
JZ 0x001019fa
LAB_001015b1:
MOV R14,qword ptr [RBP + 0x8]
TEST R14,R14
JZ 0x00101c20
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101ae0
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001015e3
LAB_001015de:
CALL 0x00101420
LAB_001015e3:
LEA EDX,[R15 + 0x1]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R14D,EDX
LAB_001015f2:
MOV R15,qword ptr [RBP + 0x10]
XOR EAX,EAX
TEST R15,R15
JZ 0x0010162e
LAB_001015fd:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x00101d20
CALL 0x00101420
MOV RDI,qword ptr [R15 + 0x10]
MOV EBP,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101621
LAB_0010161c:
CALL 0x00101420
LAB_00101621:
LEA ECX,[RBP + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,EBP
MOV EAX,ECX
CMOVGE EAX,EDX
LAB_0010162e:
LEA EDX,[R14 + 0x1]
LEA EBP,[RAX + 0x1]
CMP EAX,R14D
CMOVL EBP,EDX
LAB_0010163b:
MOV R13,qword ptr [R13 + 0x10]
XOR EDX,EDX
TEST R13,R13
JZ 0x001016d7
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101a1b
LAB_00101657:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101ce0
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010167c
LAB_00101677:
CALL 0x00101420
LAB_0010167c:
LEA EDX,[R15 + 0x1]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R14D,EDX
LAB_0010168b:
MOV R13,qword ptr [R13 + 0x10]
XOR EAX,EAX
TEST R13,R13
JZ 0x001016ca
LAB_00101696:
MOV RDI,qword ptr [R13 + 0x8]
TEST RDI,RDI
JZ 0x00101d00
CALL 0x00101420
MOV RDI,qword ptr [R13 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001016bb
LAB_001016b6:
CALL 0x00101420
LAB_001016bb:
LEA ECX,[R15 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R15D
MOV EAX,ECX
CMOVGE EAX,EDX
LAB_001016ca:
LEA ECX,[R14 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R14D
CMOVL EDX,ECX
LAB_001016d7:
LEA ECX,[RBP + 0x1]
LEA EAX,[RDX + 0x1]
CMP EDX,EBP
CMOVL EAX,ECX
LAB_001016e2:
LEA EDX,[R12 + 0x1]
LEA EBP,[RAX + 0x1]
CMP EAX,R12D
CMOVL EBP,EDX
LAB_001016f0:
MOV RBX,qword ptr [RBX + 0x10]
XOR EDX,EDX
TEST RBX,RBX
JZ 0x001019b8
MOV R12,qword ptr [RBX + 0x8]
TEST R12,R12
JZ 0x00101a59
LAB_0010170c:
MOV R13,qword ptr [R12 + 0x8]
TEST R13,R13
JZ 0x00101b80
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101bc0
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101b00
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010174c
LAB_00101747:
CALL 0x00101420
LAB_0010174c:
LEA EDX,[R15 + 0x1]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R14D,EDX
LAB_0010175b:
MOV R15,qword ptr [R13 + 0x10]
XOR EAX,EAX
TEST R15,R15
JZ 0x0010179a
LAB_00101766:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x00101cc0
CALL 0x00101420
MOV RDI,qword ptr [R15 + 0x10]
MOV R13D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010178b
LAB_00101786:
CALL 0x00101420
LAB_0010178b:
LEA ECX,[R13 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R13D
MOV EAX,ECX
CMOVGE EAX,EDX
LAB_0010179a:
LEA EDX,[R14 + 0x1]
LEA R13D,[RAX + 0x1]
CMP EAX,R14D
CMOVL R13D,EDX
LAB_001017a9:
MOV R14,qword ptr [R12 + 0x10]
XOR EAX,EAX
TEST R14,R14
JZ 0x00101847
MOV R12,qword ptr [R14 + 0x8]
TEST R12,R12
JZ 0x00101ba4
LAB_001017c6:
MOV RDI,qword ptr [R12 + 0x8]
TEST RDI,RDI
JZ 0x00101da0
CALL 0x00101420
MOV RDI,qword ptr [R12 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001017ed
LAB_001017e8:
CALL 0x00101420
LAB_001017ed:
LEA EDX,[R15 + 0x1]
LEA R12D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R12D,EDX
LAB_001017fc:
MOV R14,qword ptr [R14 + 0x10]
XOR EDX,EDX
TEST R14,R14
JZ 0x00101839
LAB_00101807:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101d80
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010182c
LAB_00101827:
CALL 0x00101420
LAB_0010182c:
LEA ECX,[R15 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R15D
CMOVL EDX,ECX
LAB_00101839:
LEA ECX,[R12 + 0x1]
LEA EAX,[RDX + 0x1]
CMP EDX,R12D
CMOVL EAX,ECX
LAB_00101847:
LEA EDX,[R13 + 0x1]
LEA R12D,[RAX + 0x1]
CMP EAX,R13D
CMOVL R12D,EDX
LAB_00101856:
MOV RBX,qword ptr [RBX + 0x10]
XOR EAX,EAX
TEST RBX,RBX
JZ 0x001019aa
MOV R13,qword ptr [RBX + 0x8]
TEST R13,R13
JZ 0x00101a7b
LAB_00101872:
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101be0
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101b20
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001018a4
LAB_0010189f:
CALL 0x00101420
LAB_001018a4:
LEA EDX,[R15 + 0x1]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R14D,EDX
LAB_001018b3:
MOV R15,qword ptr [R13 + 0x10]
XOR EAX,EAX
TEST R15,R15
JZ 0x001018f2
LAB_001018be:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x00101ca0
CALL 0x00101420
MOV RDI,qword ptr [R15 + 0x10]
MOV R13D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001018e3
LAB_001018de:
CALL 0x00101420
LAB_001018e3:
LEA ECX,[R13 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R13D
MOV EAX,ECX
CMOVGE EAX,EDX
LAB_001018f2:
LEA EDX,[R14 + 0x1]
LEA R13D,[RAX + 0x1]
CMP EAX,R14D
CMOVL R13D,EDX
LAB_00101901:
MOV RBX,qword ptr [RBX + 0x10]
XOR EDX,EDX
TEST RBX,RBX
JZ 0x0010199d
MOV R14,qword ptr [RBX + 0x8]
TEST R14,R14
JZ 0x00101a9d
LAB_0010191d:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101c60
CALL 0x00101420
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101942
LAB_0010193d:
CALL 0x00101420
LAB_00101942:
LEA EDX,[R15 + 0x1]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
CMOVL R14D,EDX
LAB_00101951:
MOV RBX,qword ptr [RBX + 0x10]
XOR EAX,EAX
TEST RBX,RBX
JZ 0x00101990
LAB_0010195c:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x00101c80
CALL 0x00101420
MOV RDI,qword ptr [RBX + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101981
LAB_0010197c:
CALL 0x00101420
LAB_00101981:
LEA ECX,[R15 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R15D
MOV EAX,ECX
CMOVGE EAX,EDX
LAB_00101990:
LEA ECX,[R14 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R14D
CMOVL EDX,ECX
LAB_0010199d:
LEA ECX,[R13 + 0x1]
LEA EAX,[RDX + 0x1]
CMP EDX,R13D
CMOVL EAX,ECX
LAB_001019aa:
LEA ECX,[R12 + 0x1]
LEA EDX,[RAX + 0x1]
CMP EAX,R12D
CMOVL EDX,ECX
LAB_001019b8:
LEA ECX,[RBP + 0x1]
LEA EAX,[RDX + 0x1]
CMP EDX,EBP
CMOVL EAX,ECX
LAB_001019c3:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001019d8:
MOV R13,qword ptr [RBP + 0x10]
XOR R12D,R12D
MOV EBP,0x1
TEST R13,R13
JZ 0x001016f0
MOV RBP,qword ptr [R13 + 0x8]
TEST RBP,RBP
JNZ 0x001015b1
LAB_001019fa:
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x1
XOR EBP,EBP
TEST R13,R13
JZ 0x001016e2
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JNZ 0x00101657
LAB_00101a1b:
MOV R13,qword ptr [R13 + 0x10]
MOV EDX,0x1
XOR R14D,R14D
TEST R13,R13
JNZ 0x00101696
JMP 0x001016d7
LAB_00101a38:
MOV RBX,qword ptr [RDI + 0x10]
MOV EAX,0x1
XOR EBP,EBP
TEST RBX,RBX
JZ 0x001019c3
MOV R12,qword ptr [RBX + 0x8]
TEST R12,R12
JNZ 0x0010170c
LAB_00101a59:
MOV RBX,qword ptr [RBX + 0x10]
MOV EDX,0x1
XOR R12D,R12D
TEST RBX,RBX
JZ 0x001019b8
MOV R13,qword ptr [RBX + 0x8]
TEST R13,R13
JNZ 0x00101872
LAB_00101a7b:
MOV RBX,qword ptr [RBX + 0x10]
MOV EAX,0x1
XOR R13D,R13D
TEST RBX,RBX
JZ 0x001019aa
MOV R14,qword ptr [RBX + 0x8]
TEST R14,R14
JNZ 0x0010191d
LAB_00101a9d:
MOV RBX,qword ptr [RBX + 0x10]
MOV EDX,0x1
XOR R14D,R14D
TEST RBX,RBX
JNZ 0x0010195c
JMP 0x0010199d
LAB_00101ac0:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
MOV R14D,0x1
TEST RDI,RDI
JNZ 0x00101486
JMP 0x0010149a
LAB_00101ae0:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
MOV R14D,0x1
TEST RDI,RDI
JNZ 0x001015de
JMP 0x001015f2
LAB_00101b00:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
MOV R14D,0x1
TEST RDI,RDI
JNZ 0x00101747
JMP 0x0010175b
LAB_00101b20:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
MOV R14D,0x1
TEST RDI,RDI
JNZ 0x0010189f
JMP 0x001018b3
LAB_00101b40:
MOV R14,qword ptr [R12 + 0x10]
XOR R13D,R13D
MOV R12D,0x1
TEST R14,R14
JZ 0x00101595
MOV R12,qword ptr [R14 + 0x8]
TEST R12,R12
JNZ 0x00101505
LAB_00101b64:
MOV R14,qword ptr [R14 + 0x10]
MOV EAX,0x1
XOR R12D,R12D
TEST R14,R14
JNZ 0x00101546
JMP 0x00101586
LAB_00101b80:
MOV R14,qword ptr [R12 + 0x10]
XOR R13D,R13D
MOV R12D,0x1
TEST R14,R14
JZ 0x00101856
MOV R12,qword ptr [R14 + 0x8]
TEST R12,R12
JNZ 0x001017c6
LAB_00101ba4:
MOV R14,qword ptr [R14 + 0x10]
MOV EAX,0x1
XOR R12D,R12D
TEST R14,R14
JNZ 0x00101807
JMP 0x00101847
LAB_00101bc0:
MOV R15,qword ptr [R13 + 0x10]
XOR R14D,R14D
MOV R13D,0x1
TEST R15,R15
JNZ 0x00101766
JMP 0x001017a9
LAB_00101be0:
MOV R15,qword ptr [R13 + 0x10]
XOR R14D,R14D
MOV R13D,0x1
TEST R15,R15
JNZ 0x001018be
JMP 0x00101901
LAB_00101c00:
MOV R15,qword ptr [R13 + 0x10]
XOR R14D,R14D
MOV R13D,0x1
TEST R15,R15
JNZ 0x001014a5
JMP 0x001014e8
LAB_00101c20:
MOV R15,qword ptr [RBP + 0x10]
XOR R14D,R14D
MOV EBP,0x1
TEST R15,R15
JNZ 0x001015fd
JMP 0x0010163b
LAB_00101c40:
MOV RDI,qword ptr [R12 + 0x10]
XOR R15D,R15D
MOV R12D,0x1
TEST RDI,RDI
JNZ 0x00101527
JMP 0x0010153b
LAB_00101c60:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
MOV R14D,0x1
TEST RDI,RDI
JNZ 0x0010193d
JMP 0x00101951
LAB_00101c80:
MOV RDI,qword ptr [RBX + 0x10]
MOV EAX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x0010197c
JMP 0x00101990
LAB_00101ca0:
MOV RDI,qword ptr [R15 + 0x10]
MOV EAX,0x1
XOR R13D,R13D
TEST RDI,RDI
JNZ 0x001018de
JMP 0x001018f2
LAB_00101cc0:
MOV RDI,qword ptr [R15 + 0x10]
MOV EAX,0x1
XOR R13D,R13D
TEST RDI,RDI
JNZ 0x00101786
JMP 0x0010179a
LAB_00101ce0:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
MOV R14D,0x1
TEST RDI,RDI
JNZ 0x00101677
JMP 0x0010168b
LAB_00101d00:
MOV RDI,qword ptr [R13 + 0x10]
MOV EAX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x001016b6
JMP 0x001016ca
LAB_00101d20:
MOV RDI,qword ptr [R15 + 0x10]
MOV EAX,0x1
XOR EBP,EBP
TEST RDI,RDI
JNZ 0x0010161c
JMP 0x0010162e
LAB_00101d40:
MOV RDI,qword ptr [R14 + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101566
JMP 0x00101578
LAB_00101d60:
MOV RDI,qword ptr [R15 + 0x10]
MOV EAX,0x1
XOR R13D,R13D
TEST RDI,RDI
JNZ 0x001014c5
JMP 0x001014d9
LAB_00101d80:
MOV RDI,qword ptr [R14 + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101827
JMP 0x00101839
LAB_00101da0:
MOV RDI,qword ptr [R12 + 0x10]
XOR R15D,R15D
MOV R12D,0x1
TEST RDI,RDI
JNZ 0x001017e8
JMP 0x001017fc | int func0_part_0(long param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
lVar9 = *(long *)(param_1 + 8);
if (lVar9 == 0) {
lVar9 = *(long *)(param_1 + 0x10);
iVar2 = 0;
if (lVar9 == 0) {
return 1;
}
lVar10 = *(long *)(lVar9 + 8);
if (lVar10 == 0) goto LAB_00101a59;
LAB_0010170c:
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar7 = 0;
iVar3 = 1;
if (lVar10 != 0) {
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 == 0) goto LAB_00101ba4;
LAB_001017c6:
if (*(long *)(lVar11 + 8) == 0) {
iVar4 = 0;
iVar3 = 1;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_001017e8;
}
else {
iVar4 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_001017e8:
iVar5 = func0_part_0();
}
iVar3 = iVar5 + 1;
if (iVar5 < iVar4) {
iVar3 = iVar4 + 1;
}
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 0;
if (lVar10 != 0) {
LAB_00101807:
if (*(long *)(lVar10 + 8) == 0) {
iVar5 = 1;
iVar4 = 0;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_00101827;
}
else {
iVar4 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_00101827:
iVar6 = func0_part_0();
}
iVar5 = iVar6 + 1;
if (iVar6 < iVar4) {
iVar5 = iVar4 + 1;
}
}
}
iVar4 = iVar5 + 1;
if (iVar5 < iVar3) {
iVar4 = iVar3 + 1;
}
goto LAB_00101847;
}
}
else {
lVar1 = *(long *)(lVar11 + 8);
if (lVar1 == 0) {
lVar11 = *(long *)(lVar11 + 0x10);
iVar3 = 0;
iVar7 = 1;
if (lVar11 != 0) goto LAB_00101766;
}
else {
if (*(long *)(lVar1 + 8) == 0) {
iVar7 = 0;
iVar3 = 1;
if (*(long *)(lVar1 + 0x10) != 0) goto LAB_00101747;
}
else {
iVar7 = func0_part_0();
iVar4 = 0;
if (*(long *)(lVar1 + 0x10) != 0) {
LAB_00101747:
iVar4 = func0_part_0();
}
iVar3 = iVar4 + 1;
if (iVar4 < iVar7) {
iVar3 = iVar7 + 1;
}
}
lVar11 = *(long *)(lVar11 + 0x10);
iVar4 = 0;
if (lVar11 != 0) {
LAB_00101766:
if (*(long *)(lVar11 + 8) == 0) {
iVar4 = 1;
iVar7 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_00101786;
}
else {
iVar7 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_00101786:
iVar5 = func0_part_0();
}
iVar4 = iVar7 + 1;
if (iVar7 <= iVar5) {
iVar4 = iVar5 + 1;
}
}
}
iVar7 = iVar4 + 1;
if (iVar4 < iVar3) {
iVar7 = iVar3 + 1;
}
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 0;
if (lVar10 != 0) {
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 != 0) goto LAB_001017c6;
LAB_00101ba4:
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 1;
iVar3 = 0;
if (lVar10 != 0) goto LAB_00101807;
}
LAB_00101847:
iVar3 = iVar4 + 1;
if (iVar4 < iVar7) {
iVar3 = iVar7 + 1;
}
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 0;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
goto joined_r0x0010186c;
}
}
else {
lVar10 = *(long *)(lVar9 + 8);
if (lVar10 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar7 = 0;
iVar2 = 1;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
if (lVar10 == 0) goto LAB_001019fa;
LAB_001015b1:
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 0;
iVar2 = 1;
if (lVar10 != 0) goto LAB_001015fd;
}
else {
if (*(long *)(lVar11 + 8) == 0) {
iVar2 = 0;
iVar3 = 1;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_001015de;
}
else {
iVar2 = func0_part_0();
iVar4 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_001015de:
iVar4 = func0_part_0();
}
iVar3 = iVar4 + 1;
if (iVar4 < iVar2) {
iVar3 = iVar2 + 1;
}
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 0;
if (lVar10 != 0) {
LAB_001015fd:
if (*(long *)(lVar10 + 8) == 0) {
iVar4 = 1;
iVar2 = 0;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_0010161c;
}
else {
iVar2 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_0010161c:
iVar5 = func0_part_0();
}
iVar4 = iVar2 + 1;
if (iVar2 <= iVar5) {
iVar4 = iVar5 + 1;
}
}
}
iVar2 = iVar4 + 1;
if (iVar4 < iVar3) {
iVar2 = iVar3 + 1;
}
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 0;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
joined_r0x00101a15:
if (lVar10 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 1;
iVar3 = 0;
if (lVar9 != 0) goto LAB_00101696;
}
else {
if (*(long *)(lVar10 + 8) == 0) {
iVar4 = 0;
iVar3 = 1;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_00101677;
}
else {
iVar4 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_00101677:
iVar5 = func0_part_0();
}
iVar3 = iVar5 + 1;
if (iVar5 < iVar4) {
iVar3 = iVar4 + 1;
}
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar5 = 0;
if (lVar9 != 0) {
LAB_00101696:
if (*(long *)(lVar9 + 8) == 0) {
iVar5 = 1;
iVar4 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_001016b6;
}
else {
iVar4 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
LAB_001016b6:
iVar6 = func0_part_0();
}
iVar5 = iVar4 + 1;
if (iVar4 <= iVar6) {
iVar5 = iVar6 + 1;
}
}
}
iVar4 = iVar5 + 1;
if (iVar5 < iVar3) {
iVar4 = iVar3 + 1;
}
}
}
iVar3 = iVar4 + 1;
if (iVar4 < iVar2) {
iVar3 = iVar2 + 1;
}
goto LAB_001016e2;
}
}
else {
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar2 = 0;
iVar7 = 1;
if (lVar10 != 0) {
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 == 0) goto LAB_00101b64;
LAB_00101505:
if (*(long *)(lVar11 + 8) == 0) {
iVar3 = 0;
iVar7 = 1;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_00101527;
}
else {
iVar3 = func0_part_0();
iVar4 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_00101527:
iVar4 = func0_part_0();
}
iVar7 = iVar4 + 1;
if (iVar4 < iVar3) {
iVar7 = iVar3 + 1;
}
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 0;
if (lVar10 != 0) {
LAB_00101546:
if (*(long *)(lVar10 + 8) == 0) {
iVar4 = 1;
iVar3 = 0;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_00101566;
}
else {
iVar3 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_00101566:
iVar5 = func0_part_0();
}
iVar4 = iVar5 + 1;
if (iVar5 < iVar3) {
iVar4 = iVar3 + 1;
}
}
}
iVar3 = iVar4 + 1;
if (iVar4 < iVar7) {
iVar3 = iVar7 + 1;
}
goto LAB_00101586;
}
}
else {
lVar1 = *(long *)(lVar11 + 8);
if (lVar1 == 0) {
lVar11 = *(long *)(lVar11 + 0x10);
iVar7 = 0;
iVar2 = 1;
if (lVar11 != 0) goto LAB_001014a5;
}
else {
if (*(long *)(lVar1 + 8) == 0) {
iVar2 = 0;
iVar7 = 1;
if (*(long *)(lVar1 + 0x10) != 0) goto LAB_00101486;
}
else {
iVar2 = func0_part_0();
iVar3 = 0;
if (*(long *)(lVar1 + 0x10) != 0) {
LAB_00101486:
iVar3 = func0_part_0();
}
iVar7 = iVar3 + 1;
if (iVar3 < iVar2) {
iVar7 = iVar2 + 1;
}
}
lVar11 = *(long *)(lVar11 + 0x10);
iVar3 = 0;
if (lVar11 != 0) {
LAB_001014a5:
if (*(long *)(lVar11 + 8) == 0) {
iVar3 = 1;
iVar2 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_001014c5;
}
else {
iVar2 = func0_part_0();
iVar4 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_001014c5:
iVar4 = func0_part_0();
}
iVar3 = iVar2 + 1;
if (iVar2 <= iVar4) {
iVar3 = iVar4 + 1;
}
}
}
iVar2 = iVar3 + 1;
if (iVar3 < iVar7) {
iVar2 = iVar7 + 1;
}
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 0;
if (lVar10 != 0) {
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 != 0) goto LAB_00101505;
LAB_00101b64:
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 1;
iVar7 = 0;
if (lVar10 != 0) goto LAB_00101546;
}
LAB_00101586:
iVar7 = iVar3 + 1;
if (iVar3 < iVar2) {
iVar7 = iVar2 + 1;
}
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
if (lVar10 != 0) goto LAB_001015b1;
LAB_001019fa:
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 1;
iVar2 = 0;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
goto joined_r0x00101a15;
}
}
LAB_001016e2:
iVar2 = iVar3 + 1;
if (iVar3 < iVar7) {
iVar2 = iVar7 + 1;
}
}
lVar9 = *(long *)(param_1 + 0x10);
iVar7 = 0;
if (lVar9 == 0) goto LAB_001019b8;
lVar10 = *(long *)(lVar9 + 8);
if (lVar10 != 0) goto LAB_0010170c;
LAB_00101a59:
lVar9 = *(long *)(lVar9 + 0x10);
iVar7 = 1;
iVar3 = 0;
if (lVar9 == 0) goto LAB_001019b8;
lVar10 = *(long *)(lVar9 + 8);
joined_r0x0010186c:
if (lVar10 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 1;
iVar7 = 0;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
goto joined_r0x00101a97;
}
}
else {
lVar11 = *(long *)(lVar10 + 8);
if (lVar11 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 0;
iVar7 = 1;
if (lVar10 != 0) goto LAB_001018be;
}
else {
if (*(long *)(lVar11 + 8) == 0) {
iVar7 = 0;
iVar4 = 1;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_0010189f;
}
else {
iVar7 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_0010189f:
iVar5 = func0_part_0();
}
iVar4 = iVar5 + 1;
if (iVar5 < iVar7) {
iVar4 = iVar7 + 1;
}
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 0;
if (lVar10 != 0) {
LAB_001018be:
if (*(long *)(lVar10 + 8) == 0) {
iVar5 = 1;
iVar7 = 0;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_001018de;
}
else {
iVar7 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_001018de:
iVar6 = func0_part_0();
}
iVar5 = iVar7 + 1;
if (iVar7 <= iVar6) {
iVar5 = iVar6 + 1;
}
}
}
iVar7 = iVar5 + 1;
if (iVar5 < iVar4) {
iVar7 = iVar4 + 1;
}
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar5 = 0;
if (lVar9 != 0) {
lVar10 = *(long *)(lVar9 + 8);
joined_r0x00101a97:
if (lVar10 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar5 = 1;
iVar4 = 0;
if (lVar9 != 0) goto LAB_0010195c;
}
else {
if (*(long *)(lVar10 + 8) == 0) {
iVar5 = 0;
iVar4 = 1;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_0010193d;
}
else {
iVar5 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_0010193d:
iVar6 = func0_part_0();
}
iVar4 = iVar6 + 1;
if (iVar6 < iVar5) {
iVar4 = iVar5 + 1;
}
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar6 = 0;
if (lVar9 != 0) {
LAB_0010195c:
if (*(long *)(lVar9 + 8) == 0) {
iVar6 = 1;
iVar5 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_0010197c;
}
else {
iVar5 = func0_part_0();
iVar8 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
LAB_0010197c:
iVar8 = func0_part_0();
}
iVar6 = iVar5 + 1;
if (iVar5 <= iVar8) {
iVar6 = iVar8 + 1;
}
}
}
iVar5 = iVar6 + 1;
if (iVar6 < iVar4) {
iVar5 = iVar4 + 1;
}
}
}
iVar4 = iVar5 + 1;
if (iVar5 < iVar7) {
iVar4 = iVar7 + 1;
}
}
}
iVar7 = iVar4 + 1;
if (iVar4 < iVar3) {
iVar7 = iVar3 + 1;
}
LAB_001019b8:
if (iVar7 < iVar2) {
iVar7 = iVar2;
}
return iVar7 + 1;
} |
7,603 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
// Function to find the maximum height of the binary tree
| int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
}
}
}
| int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->right->left = newNode(5);
root1->right->right = newNode(6);
root1->right->right->right = newNode(7);
root1->right->right->right->right = newNode(8);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(6);
root2->left->left->right = newNode(7);
// Testing the max_height function
assert(func0(root) == 3);
assert(func0(root1) == 5);
assert(func0(root2) == 4);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %rdi,%rdi
je 1aa0 <func0+0x5d0>
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%rax
mov 0x10(%rdi),%r8
test %rax,%rax
je 1a50 <func0+0x580>
mov 0x8(%rax),%rdx
mov 0x10(%rax),%r10
test %rdx,%rdx
je 1ae0 <func0+0x610>
mov 0x8(%rdx),%rax
mov 0x10(%rdx),%r11
test %rax,%rax
je 1b20 <func0+0x650>
mov 0x8(%rax),%rsi
mov 0x10(%rax),%rbx
test %rsi,%rsi
je 1aa8 <func0+0x5d8>
mov 0x8(%rsi),%rdi
test %rdi,%rdi
je 1d20 <func0+0x850>
callq 1450 <func0.part.0>
mov 0x10(%rsi),%rdi
mov %eax,%ebp
xor %eax,%eax
test %rdi,%rdi
je 154d <func0+0x7d>
callq 1450 <func0.part.0>
lea 0x1(%rbp),%edx
lea 0x1(%rax),%r9d
cmp %ebp,%eax
cmovl %edx,%r9d
xor %eax,%eax
test %rbx,%rbx
je 1592 <func0+0xc2>
mov 0x8(%rbx),%rdi
test %rdi,%rdi
je 1d00 <func0+0x830>
callq 1450 <func0.part.0>
mov 0x10(%rbx),%rdi
xor %edx,%edx
mov %eax,%esi
test %rdi,%rdi
je 1587 <func0+0xb7>
callq 1450 <func0.part.0>
mov %eax,%edx
lea 0x1(%rsi),%ecx
lea 0x1(%rdx),%eax
cmp %esi,%edx
cmovl %ecx,%eax
lea 0x1(%r9),%edx
lea 0x1(%rax),%esi
cmp %r9d,%eax
cmovl %edx,%esi
xor %eax,%eax
test %r11,%r11
je 162f <func0+0x15f>
mov 0x8(%r11),%r9
mov 0x10(%r11),%r11
test %r9,%r9
je 1ba0 <func0+0x6d0>
mov 0x8(%r9),%rdi
test %rdi,%rdi
je 1ce0 <func0+0x810>
callq 1450 <func0.part.0>
mov 0x10(%r9),%rdi
mov %eax,%ebx
xor %eax,%eax
test %rdi,%rdi
je 15df <func0+0x10f>
callq 1450 <func0.part.0>
lea 0x1(%rbx),%edx
lea 0x1(%rax),%r9d
cmp %ebx,%eax
cmovl %edx,%r9d
xor %edx,%edx
test %r11,%r11
je 1622 <func0+0x152>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1cc0 <func0+0x7f0>
callq 1450 <func0.part.0>
mov 0x10(%r11),%rdi
mov %eax,%ebx
xor %eax,%eax
test %rdi,%rdi
je 1617 <func0+0x147>
callq 1450 <func0.part.0>
lea 0x1(%rbx),%ecx
lea 0x1(%rax),%edx
cmp %ebx,%eax
cmovl %ecx,%edx
lea 0x1(%r9),%ecx
lea 0x1(%rdx),%eax
cmp %r9d,%edx
cmovl %ecx,%eax
lea 0x1(%rsi),%edx
lea 0x1(%rax),%r9d
cmp %esi,%eax
cmovl %edx,%r9d
xor %eax,%eax
test %r10,%r10
je 177c <func0+0x2ac>
mov 0x8(%r10),%rax
mov 0x10(%r10),%r10
test %rax,%rax
je 1b02 <func0+0x632>
mov 0x8(%rax),%rsi
mov 0x10(%rax),%rbx
test %rsi,%rsi
je 1b80 <func0+0x6b0>
mov 0x8(%rsi),%rdi
test %rdi,%rdi
je 1ca0 <func0+0x7d0>
callq 1450 <func0.part.0>
mov 0x10(%rsi),%rdi
mov %eax,%ebp
xor %eax,%eax
test %rdi,%rdi
je 168d <func0+0x1bd>
callq 1450 <func0.part.0>
lea 0x1(%rbp),%edx
lea 0x1(%rax),%r11d
cmp %ebp,%eax
cmovl %edx,%r11d
xor %eax,%eax
test %rbx,%rbx
je 16d2 <func0+0x202>
mov 0x8(%rbx),%rdi
test %rdi,%rdi
je 1c80 <func0+0x7b0>
callq 1450 <func0.part.0>
mov 0x10(%rbx),%rdi
xor %edx,%edx
mov %eax,%esi
test %rdi,%rdi
je 16c7 <func0+0x1f7>
callq 1450 <func0.part.0>
mov %eax,%edx
lea 0x1(%rsi),%ecx
lea 0x1(%rdx),%eax
cmp %esi,%edx
cmovl %ecx,%eax
lea 0x1(%r11),%edx
lea 0x1(%rax),%esi
cmp %r11d,%eax
cmovl %edx,%esi
xor %edx,%edx
test %r10,%r10
je 1771 <func0+0x2a1>
mov 0x8(%r10),%rbx
mov 0x10(%r10),%r11
test %rbx,%rbx
je 1b60 <func0+0x690>
mov 0x8(%rbx),%rdi
test %rdi,%rdi
je 1c60 <func0+0x790>
callq 1450 <func0.part.0>
mov 0x10(%rbx),%rdi
mov %eax,%ebp
xor %eax,%eax
test %rdi,%rdi
je 171f <func0+0x24f>
callq 1450 <func0.part.0>
lea 0x1(%rbp),%edx
lea 0x1(%rax),%r10d
cmp %ebp,%eax
cmovl %edx,%r10d
xor %eax,%eax
test %r11,%r11
je 1764 <func0+0x294>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1c40 <func0+0x770>
callq 1450 <func0.part.0>
xor %edx,%edx
mov 0x10(%r11),%rdi
mov %eax,%ebx
test %rdi,%rdi
je 1759 <func0+0x289>
callq 1450 <func0.part.0>
mov %eax,%edx
lea 0x1(%rbx),%ecx
lea 0x1(%rdx),%eax
cmp %ebx,%edx
cmovl %ecx,%eax
lea 0x1(%r10),%ecx
lea 0x1(%rax),%edx
cmp %r10d,%eax
cmovl %ecx,%edx
lea 0x1(%rsi),%ecx
lea 0x1(%rdx),%eax
cmp %esi,%edx
cmovl %ecx,%eax
lea 0x1(%r9),%edx
lea 0x1(%rax),%esi
cmp %r9d,%eax
cmovl %edx,%esi
xor %edx,%edx
test %r8,%r8
je 1a38 <func0+0x568>
mov 0x8(%r8),%rax
mov 0x10(%r8),%r9
test %rax,%rax
je 1a6d <func0+0x59d>
mov 0x8(%rax),%rdx
mov 0x10(%rax),%r11
test %rdx,%rdx
je 1b40 <func0+0x670>
mov 0x8(%rdx),%r8
mov 0x10(%rdx),%rbx
test %r8,%r8
je 1ac0 <func0+0x5f0>
mov 0x8(%r8),%rdi
test %rdi,%rdi
je 1c20 <func0+0x750>
callq 1450 <func0.part.0>
mov 0x10(%r8),%rdi
mov %eax,%r10d
xor %eax,%eax
test %rdi,%rdi
je 17ec <func0+0x31c>
callq 1450 <func0.part.0>
lea 0x1(%r10),%edx
lea 0x1(%rax),%r8d
cmp %r10d,%eax
cmovl %edx,%r8d
xor %eax,%eax
test %rbx,%rbx
je 1836 <func0+0x366>
mov 0x8(%rbx),%rdi
test %rdi,%rdi
je 1e00 <func0+0x930>
callq 1450 <func0.part.0>
mov 0x10(%rbx),%rdi
xor %edx,%edx
mov %eax,%r10d
test %rdi,%rdi
je 1829 <func0+0x359>
callq 1450 <func0.part.0>
mov %eax,%edx
lea 0x1(%r10),%ecx
lea 0x1(%rdx),%eax
cmp %r10d,%edx
cmovl %ecx,%eax
lea 0x1(%r8),%edx
lea 0x1(%rax),%r10d
cmp %r8d,%eax
cmovl %edx,%r10d
xor %eax,%eax
test %r11,%r11
je 18d5 <func0+0x405>
mov 0x8(%r11),%r8
mov 0x10(%r11),%r11
test %r8,%r8
je 1c00 <func0+0x730>
mov 0x8(%r8),%rdi
test %rdi,%rdi
je 1de0 <func0+0x910>
callq 1450 <func0.part.0>
mov 0x10(%r8),%rdi
mov %eax,%ebx
xor %eax,%eax
test %rdi,%rdi
je 1885 <func0+0x3b5>
callq 1450 <func0.part.0>
lea 0x1(%rbx),%edx
lea 0x1(%rax),%r8d
cmp %ebx,%eax
cmovl %edx,%r8d
xor %edx,%edx
test %r11,%r11
je 18c8 <func0+0x3f8>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1dc0 <func0+0x8f0>
callq 1450 <func0.part.0>
mov 0x10(%r11),%rdi
mov %eax,%ebx
xor %eax,%eax
test %rdi,%rdi
je 18bd <func0+0x3ed>
callq 1450 <func0.part.0>
lea 0x1(%rbx),%ecx
lea 0x1(%rax),%edx
cmp %ebx,%eax
cmovl %ecx,%edx
lea 0x1(%r8),%ecx
lea 0x1(%rdx),%eax
cmp %r8d,%edx
cmovl %ecx,%eax
lea 0x1(%r10),%edx
lea 0x1(%rax),%r8d
cmp %r10d,%eax
cmovl %edx,%r8d
xor %eax,%eax
test %r9,%r9
je 1a2b <func0+0x55b>
mov 0x8(%r9),%rax
mov 0x10(%r9),%r10
test %rax,%rax
je 1a8b <func0+0x5bb>
mov 0x8(%rax),%r9
mov 0x10(%rax),%rbx
test %r9,%r9
je 1bc0 <func0+0x6f0>
mov 0x8(%r9),%rdi
test %rdi,%rdi
je 1da0 <func0+0x8d0>
callq 1450 <func0.part.0>
mov 0x10(%r9),%rdi
mov %eax,%ebp
xor %eax,%eax
test %rdi,%rdi
je 1935 <func0+0x465>
callq 1450 <func0.part.0>
lea 0x1(%rbp),%edx
lea 0x1(%rax),%r11d
cmp %ebp,%eax
cmovl %edx,%r11d
xor %eax,%eax
test %rbx,%rbx
je 197d <func0+0x4ad>
mov 0x8(%rbx),%rdi
test %rdi,%rdi
je 1d80 <func0+0x8b0>
callq 1450 <func0.part.0>
mov 0x10(%rbx),%rdi
xor %edx,%edx
mov %eax,%r9d
test %rdi,%rdi
je 1970 <func0+0x4a0>
callq 1450 <func0.part.0>
mov %eax,%edx
lea 0x1(%r9),%ecx
lea 0x1(%rdx),%eax
cmp %r9d,%edx
cmovl %ecx,%eax
lea 0x1(%r11),%edx
lea 0x1(%rax),%r9d
cmp %r11d,%eax
cmovl %edx,%r9d
xor %edx,%edx
test %r10,%r10
je 1a1e <func0+0x54e>
mov 0x8(%r10),%rbx
mov 0x10(%r10),%r11
test %rbx,%rbx
je 1be0 <func0+0x710>
mov 0x8(%rbx),%rdi
test %rdi,%rdi
je 1d60 <func0+0x890>
callq 1450 <func0.part.0>
mov 0x10(%rbx),%rdi
mov %eax,%ebp
xor %eax,%eax
test %rdi,%rdi
je 19cc <func0+0x4fc>
callq 1450 <func0.part.0>
lea 0x1(%rbp),%edx
lea 0x1(%rax),%r10d
cmp %ebp,%eax
cmovl %edx,%r10d
xor %eax,%eax
test %r11,%r11
je 1a11 <func0+0x541>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1d40 <func0+0x870>
callq 1450 <func0.part.0>
xor %edx,%edx
mov 0x10(%r11),%rdi
mov %eax,%ebx
test %rdi,%rdi
je 1a06 <func0+0x536>
callq 1450 <func0.part.0>
mov %eax,%edx
lea 0x1(%rbx),%ecx
lea 0x1(%rdx),%eax
cmp %ebx,%edx
cmovl %ecx,%eax
lea 0x1(%r10),%ecx
lea 0x1(%rax),%edx
cmp %r10d,%eax
cmovl %ecx,%edx
lea 0x1(%r9),%ecx
lea 0x1(%rdx),%eax
cmp %r9d,%edx
cmovl %ecx,%eax
lea 0x1(%r8),%ecx
lea 0x1(%rax),%edx
cmp %r8d,%eax
cmovl %ecx,%edx
lea 0x1(%rsi),%ecx
lea 0x1(%rdx),%eax
cmp %esi,%edx
cmovl %ecx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
xor %esi,%esi
test %r8,%r8
je 1a43 <func0+0x573>
mov 0x8(%r8),%rax
mov 0x10(%r8),%r9
test %rax,%rax
jne 17a5 <func0+0x2d5>
mov $0x1,%edx
xor %r8d,%r8d
test %r9,%r9
je 1a38 <func0+0x568>
mov 0x8(%r9),%rax
mov 0x10(%r9),%r10
test %rax,%rax
jne 1900 <func0+0x430>
mov $0x1,%eax
xor %r9d,%r9d
test %r10,%r10
jne 1997 <func0+0x4c7>
jmp 1a2b <func0+0x55b>
xchg %ax,%ax
retq
nopl 0x0(%rax)
mov $0x1,%esi
xor %r9d,%r9d
test %rbx,%rbx
jne 1561 <func0+0x91>
jmpq 159f <func0+0xcf>
xchg %ax,%ax
mov $0x1,%r10d
xor %r8d,%r8d
test %rbx,%rbx
jne 1802 <func0+0x332>
jmpq 1845 <func0+0x375>
nopw 0x0(%rax,%rax,1)
mov $0x1,%esi
xor %r9d,%r9d
test %r10,%r10
je 1789 <func0+0x2b9>
mov 0x8(%r10),%rax
mov 0x10(%r10),%r10
test %rax,%rax
jne 1658 <func0+0x188>
mov $0x1,%eax
xor %esi,%esi
test %r10,%r10
jne 16ea <func0+0x21a>
jmpq 177c <func0+0x2ac>
nopw 0x0(%rax,%rax,1)
mov $0x1,%r9d
xor %esi,%esi
test %r11,%r11
jne 15aa <func0+0xda>
jmpq 163c <func0+0x16c>
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%r8d
xor %r10d,%r10d
test %r11,%r11
jne 1850 <func0+0x380>
jmpq 18e4 <func0+0x414>
nopw 0x0(%rax,%rax,1)
mov $0x1,%edx
xor %r10d,%r10d
test %r11,%r11
jne 1733 <func0+0x263>
jmpq 1771 <func0+0x2a1>
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%esi
xor %r11d,%r11d
test %rbx,%rbx
jne 16a1 <func0+0x1d1>
jmpq 16df <func0+0x20f>
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%eax
xor %r9d,%r9d
test %r11,%r11
jne 15f3 <func0+0x123>
jmpq 162f <func0+0x15f>
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%r9d
xor %r11d,%r11d
test %rbx,%rbx
jne 1949 <func0+0x479>
jmpq 198c <func0+0x4bc>
nopw 0x0(%rax,%rax,1)
mov $0x1,%edx
xor %r10d,%r10d
test %r11,%r11
jne 19e0 <func0+0x510>
jmpq 1a1e <func0+0x54e>
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%eax
xor %r8d,%r8d
test %r11,%r11
jne 1899 <func0+0x3c9>
jmpq 18d5 <func0+0x405>
nopw %cs:0x0(%rax,%rax,1)
mov 0x10(%r8),%rdi
xor %r10d,%r10d
mov $0x1,%r8d
test %rdi,%rdi
jne 17e7 <func0+0x317>
jmpq 17fb <func0+0x32b>
nopl 0x0(%rax,%rax,1)
mov 0x10(%r11),%rdi
mov $0x1,%eax
xor %ebx,%ebx
test %rdi,%rdi
jne 1752 <func0+0x282>
jmpq 1764 <func0+0x294>
nopl 0x0(%rax)
mov 0x10(%rbx),%rdi
mov $0x1,%r10d
xor %ebp,%ebp
test %rdi,%rdi
jne 171a <func0+0x24a>
jmpq 172c <func0+0x25c>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rbx),%rdi
mov $0x1,%eax
xor %esi,%esi
test %rdi,%rdi
jne 16c0 <func0+0x1f0>
jmpq 16d2 <func0+0x202>
nopl 0x0(%rax)
mov 0x10(%rsi),%rdi
mov $0x1,%r11d
xor %ebp,%ebp
test %rdi,%rdi
jne 1688 <func0+0x1b8>
jmpq 169a <func0+0x1ca>
nopw 0x0(%rax,%rax,1)
mov 0x10(%r11),%rdi
mov $0x1,%edx
xor %ebx,%ebx
test %rdi,%rdi
jne 1612 <func0+0x142>
jmpq 1622 <func0+0x152>
nopl 0x0(%rax)
mov 0x10(%r9),%rdi
xor %ebx,%ebx
mov $0x1,%r9d
test %rdi,%rdi
jne 15da <func0+0x10a>
jmpq 15ec <func0+0x11c>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rbx),%rdi
mov $0x1,%eax
xor %esi,%esi
test %rdi,%rdi
jne 1580 <func0+0xb0>
jmpq 1592 <func0+0xc2>
nopl 0x0(%rax)
mov 0x10(%rsi),%rdi
mov $0x1,%r9d
xor %ebp,%ebp
test %rdi,%rdi
jne 1548 <func0+0x78>
jmpq 155a <func0+0x8a>
nopw 0x0(%rax,%rax,1)
mov 0x10(%r11),%rdi
mov $0x1,%eax
xor %ebx,%ebx
test %rdi,%rdi
jne 19ff <func0+0x52f>
jmpq 1a11 <func0+0x541>
nopl 0x0(%rax)
mov 0x10(%rbx),%rdi
mov $0x1,%r10d
xor %ebp,%ebp
test %rdi,%rdi
jne 19c7 <func0+0x4f7>
jmpq 19d9 <func0+0x509>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rbx),%rdi
mov $0x1,%eax
xor %r9d,%r9d
test %rdi,%rdi
jne 1969 <func0+0x499>
jmpq 197d <func0+0x4ad>
nopw 0x0(%rax,%rax,1)
mov 0x10(%r9),%rdi
mov $0x1,%r11d
xor %ebp,%ebp
test %rdi,%rdi
jne 1930 <func0+0x460>
jmpq 1942 <func0+0x472>
nopw 0x0(%rax,%rax,1)
mov 0x10(%r11),%rdi
mov $0x1,%edx
xor %ebx,%ebx
test %rdi,%rdi
jne 18b8 <func0+0x3e8>
jmpq 18c8 <func0+0x3f8>
nopl 0x0(%rax)
mov 0x10(%r8),%rdi
xor %ebx,%ebx
mov $0x1,%r8d
test %rdi,%rdi
jne 1880 <func0+0x3b0>
jmpq 1892 <func0+0x3c2>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rbx),%rdi
mov $0x1,%eax
xor %r10d,%r10d
test %rdi,%rdi
jne 1822 <func0+0x352>
jmpq 1836 <func0+0x366>
nopw 0x0(%rax,%rax,1)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov rbp, [rdi+8]
test rbp, rbp
jz loc_16E8
mov r12, [rbp+8]
test r12, r12
jz loc_1590
mov r13, [r12+8]
test r13, r13
jz loc_1C10
mov r14, [r13+8]
test r14, r14
jz loc_1C50
mov rdi, [r14+8]
test rdi, rdi
jz loc_1AC0
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_143B
loc_1436:
call func0_part_0
loc_143B:
mov r13, [r13+10h]
lea r14d, [rax+1]
cmp eax, r15d
lea edx, [r15+1]
cmovl r14d, edx
xor eax, eax
test r13, r13
jz short loc_1489
loc_1455:
mov rdi, [r13+8]
test rdi, rdi
jz loc_1DF0
call func0_part_0
mov rdi, [r13+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_147A
loc_1475:
call func0_part_0
loc_147A:
lea ecx, [rax+1]
cmp eax, r15d
lea edx, [r15+1]
mov eax, ecx
cmovl eax, edx
loc_1489:
mov r12, [r12+10h]
lea r13d, [rax+1]
lea edx, [r14+1]
cmp eax, r14d
cmovl r13d, edx
xor eax, eax
test r12, r12
jz loc_1537
loc_14A8:
mov r14, [r12+8]
test r14, r14
jz loc_1D60
mov rdi, [r14+8]
test rdi, rdi
jz loc_1DA0
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_14DB
loc_14D6:
call func0_part_0
loc_14DB:
mov r12, [r12+10h]
lea edx, [r15+1]
cmp eax, r15d
lea r14d, [rax+1]
cmovl r14d, edx
xor edx, edx
test r12, r12
jz short loc_152A
loc_14F6:
mov rdi, [r12+8]
test rdi, rdi
jz loc_1DD0
call func0_part_0
mov rdi, [r12+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_151D
loc_1518:
call func0_part_0
loc_151D:
lea ecx, [rax+1]
lea edx, [r15+1]
cmp eax, r15d
cmovge edx, ecx
loc_152A:
lea ecx, [rdx+1]
lea eax, [r14+1]
cmp edx, r14d
cmovge eax, ecx
loc_1537:
lea edx, [r13+1]
lea r12d, [rax+1]
cmp eax, r13d
mov r13, [rbp+10h]
cmovl r12d, edx
xor eax, eax
test r13, r13
jnz short loc_159D
loc_1551:
lea ebp, [rax+1]
cmp eax, r12d
jge short loc_155E
loc_1559:
lea ebp, [r12+1]
loc_155E:
mov r12, [rbx+10h]
xor eax, eax
test r12, r12
jnz loc_16FA
loc_156D:
cmp eax, ebp
jge loc_19B9
loc_1575:
lea eax, [rbp+1]
loc_1578:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1590:
mov r13, [rbp+10h]
test r13, r13
jz loc_1B50
loc_159D:
mov rbp, [r13+8]
test rbp, rbp
jz loc_1BA0
mov r14, [rbp+8]
test r14, r14
jz loc_1D00
mov rdi, [r14+8]
test rdi, rdi
jz loc_1B10
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_15DC
loc_15D7:
call func0_part_0
loc_15DC:
mov rbp, [rbp+10h]
lea edx, [r15+1]
cmp eax, r15d
lea r14d, [rax+1]
cmovl r14d, edx
xor edx, edx
test rbp, rbp
jz short loc_1628
loc_15F6:
mov rdi, [rbp+8]
test rdi, rdi
jz loc_1ED0
call func0_part_0
mov rdi, [rbp+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_161B
loc_1616:
call func0_part_0
loc_161B:
lea ecx, [rax+1]
lea edx, [r15+1]
cmp eax, r15d
cmovge edx, ecx
loc_1628:
lea eax, [rdx+1]
lea ecx, [r14+1]
cmp edx, r14d
mov r13, [r13+10h]
cmovge ecx, eax
xor eax, eax
mov ebp, ecx
test r13, r13
jz loc_16D1
loc_1646:
mov r14, [r13+8]
test r14, r14
jz loc_1BBF
loc_1653:
mov rdi, [r14+8]
test rdi, rdi
jz loc_1F10
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_1678
loc_1673:
call func0_part_0
loc_1678:
mov r13, [r13+10h]
lea edx, [r15+1]
cmp eax, r15d
lea r14d, [rax+1]
cmovl r14d, edx
xor edx, edx
test r13, r13
jz short loc_16C4
loc_1692:
mov rdi, [r13+8]
test rdi, rdi
jz loc_1EF0
call func0_part_0
mov rdi, [r13+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_16B7
loc_16B2:
call func0_part_0
loc_16B7:
lea ecx, [rax+1]
lea edx, [r15+1]
cmp eax, r15d
cmovge edx, ecx
loc_16C4:
lea ecx, [rdx+1]
lea eax, [r14+1]
cmp edx, r14d
cmovge eax, ecx
loc_16D1:
cmp eax, ebp
jge loc_1B90
loc_16D9:
lea eax, [rbp+1]
jmp loc_1551
loc_16E8:
mov r12, [rdi+10h]
mov eax, 1
test r12, r12
jz loc_1578
loc_16FA:
mov rbx, [r12+8]
test rbx, rbx
jz loc_19D0
mov r13, [rbx+8]
test r13, r13
jz loc_1BE0
mov r14, [r13+8]
test r14, r14
jz loc_1CA0
mov rdi, [r14+8]
test rdi, rdi
jz loc_1A28
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_1747
loc_1742:
call func0_part_0
loc_1747:
mov r13, [r13+10h]
lea r14d, [rax+1]
cmp eax, r15d
lea edx, [r15+1]
cmovl r14d, edx
xor eax, eax
test r13, r13
jz short loc_1795
loc_1761:
mov rdi, [r13+8]
test rdi, rdi
jz loc_1D80
call func0_part_0
mov rdi, [r13+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_1786
loc_1781:
call func0_part_0
loc_1786:
lea ecx, [rax+1]
cmp eax, r15d
lea edx, [r15+1]
mov eax, ecx
cmovl eax, edx
loc_1795:
mov rbx, [rbx+10h]
lea edx, [r14+1]
lea r13d, [rax+1]
cmp eax, r14d
cmovl r13d, edx
xor edx, edx
test rbx, rbx
jz loc_1840
loc_17B3:
mov r14, [rbx+8]
test r14, r14
jz loc_1CE0
mov rdi, [r14+8]
test rdi, rdi
jz loc_1E70
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_17E5
loc_17E0:
call func0_part_0
loc_17E5:
mov rbx, [rbx+10h]
lea r14d, [rax+1]
cmp eax, r15d
lea edx, [r15+1]
cmovl r14d, edx
xor eax, eax
test rbx, rbx
jz short loc_1833
loc_17FF:
mov rdi, [rbx+8]
test rdi, rdi
jz loc_1E50
call func0_part_0
mov rdi, [rbx+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_1824
loc_181F:
call func0_part_0
loc_1824:
lea ecx, [rax+1]
cmp eax, r15d
lea edx, [r15+1]
mov eax, ecx
cmovl eax, edx
loc_1833:
lea ecx, [rax+1]
lea edx, [r14+1]
cmp eax, r14d
cmovge edx, ecx
loc_1840:
lea ecx, [r13+1]
lea eax, [rdx+1]
cmp edx, r13d
mov r13, [r12+10h]
cmovge ecx, eax
xor eax, eax
mov ebx, ecx
test r13, r13
jz loc_19A6
loc_185F:
mov r12, [r13+8]
test r12, r12
jz loc_19F0
loc_186C:
mov r14, [r12+8]
test r14, r14
jz loc_1D30
mov rdi, [r14+8]
test rdi, rdi
jz loc_1A80
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_189F
loc_189A:
call func0_part_0
loc_189F:
mov r12, [r12+10h]
lea edx, [r15+1]
cmp eax, r15d
lea r14d, [rax+1]
cmovl r14d, edx
xor edx, edx
test r12, r12
jz short loc_18EE
loc_18BA:
mov rdi, [r12+8]
test rdi, rdi
jz loc_1E30
call func0_part_0
mov rdi, [r12+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_18E1
loc_18DC:
call func0_part_0
loc_18E1:
lea ecx, [rax+1]
lea edx, [r15+1]
cmp eax, r15d
cmovge edx, ecx
loc_18EE:
lea eax, [rdx+1]
lea ecx, [r14+1]
cmp edx, r14d
mov r13, [r13+10h]
cmovge ecx, eax
xor eax, eax
mov r12d, ecx
test r13, r13
jz loc_1998
loc_190D:
mov r14, [r13+8]
test r14, r14
jz loc_1A0B
loc_191A:
mov rdi, [r14+8]
test rdi, rdi
jz loc_1EA0
call func0_part_0
mov rdi, [r14+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_193F
loc_193A:
call func0_part_0
loc_193F:
mov r13, [r13+10h]
lea edx, [r15+1]
cmp eax, r15d
lea r14d, [rax+1]
cmovl r14d, edx
xor edx, edx
test r13, r13
jz short loc_198B
loc_1959:
mov rdi, [r13+8]
test rdi, rdi
jz loc_1E10
call func0_part_0
mov rdi, [r13+10h]
mov r15d, eax
xor eax, eax
test rdi, rdi
jz short loc_197E
loc_1979:
call func0_part_0
loc_197E:
lea ecx, [rax+1]
lea edx, [r15+1]
cmp eax, r15d
cmovge edx, ecx
loc_198B:
lea ecx, [rdx+1]
lea eax, [r14+1]
cmp edx, r14d
cmovge eax, ecx
loc_1998:
cmp eax, r12d
jge loc_1B80
loc_19A1:
lea eax, [r12+1]
loc_19A6:
cmp eax, ebx
jge loc_1B70
loc_19AE:
lea eax, [rbx+1]
cmp eax, ebp
jl loc_1575
loc_19B9:
add rsp, 8
add eax, 1
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_19D0:
mov r13, [r12+10h]
mov eax, 1
test r13, r13
jz loc_156D
mov r12, [r13+8]
test r12, r12
jnz loc_186C
loc_19F0:
mov r13, [r13+10h]
mov eax, 1
test r13, r13
jz short loc_19A6
mov r14, [r13+8]
test r14, r14
jnz loc_191A
loc_1A0B:
mov r13, [r13+10h]
mov eax, 1
test r13, r13
jnz loc_1959
jmp loc_1998
loc_1A28:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_1742
mov r13, [r13+10h]
mov r14d, 1
test r13, r13
jnz loc_1761
mov rbx, [rbx+10h]
mov r13d, 2
test rbx, rbx
jnz loc_17B3
mov r13, [r12+10h]
mov ebx, 3
test r13, r13
jnz loc_185F
jmp loc_19AE
loc_1A80:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_189A
mov r12, [r12+10h]
mov r14d, 1
test r12, r12
jnz loc_18BA
mov r13, [r13+10h]
mov r12d, 2
test r13, r13
jnz loc_190D
jmp loc_19A1
loc_1AC0:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_1436
mov r13, [r13+10h]
mov r14d, 1
test r13, r13
jnz loc_1455
mov r12, [r12+10h]
mov r13d, 2
test r12, r12
jnz loc_14A8
mov r13, [rbp+10h]
mov r12d, 3
test r13, r13
jnz loc_159D
jmp loc_1559
loc_1B10:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_15D7
mov rbp, [rbp+10h]
mov r14d, 1
test rbp, rbp
jnz loc_15F6
mov r13, [r13+10h]
mov ebp, 2
test r13, r13
jnz loc_1646
jmp loc_16D9
loc_1B50:
mov r12, [rdi+10h]
mov eax, 2
mov ebp, 1
test r12, r12
jnz loc_16FA
jmp loc_1578
loc_1B70:
add eax, 1
jmp loc_156D
loc_1B80:
add eax, 1
jmp loc_19A6
loc_1B90:
add eax, 1
jmp loc_1551
loc_1BA0:
mov r13, [r13+10h]
mov eax, 1
test r13, r13
jz loc_1551
mov r14, [r13+8]
test r14, r14
jnz loc_1653
loc_1BBF:
mov r13, [r13+10h]
mov eax, 1
test r13, r13
jnz loc_1692
jmp loc_16D1
loc_1BE0:
mov rbx, [rbx+10h]
test rbx, rbx
jnz loc_17B3
mov r13, [r12+10h]
mov eax, 2
test r13, r13
jz loc_156D
mov ebx, 1
jmp loc_185F
loc_1C10:
mov r12, [r12+10h]
test r12, r12
jnz loc_14A8
mov r13, [rbp+10h]
mov r12d, 1
test r13, r13
jnz loc_159D
mov r12, [rdi+10h]
mov ebp, 2
test r12, r12
jnz loc_16FA
jmp loc_1575
loc_1C50:
mov r13, [r13+10h]
test r13, r13
jnz loc_1455
mov r12, [r12+10h]
mov r13d, 1
test r12, r12
jnz loc_14A8
mov r13, [rbp+10h]
mov r12d, 2
test r13, r13
jnz loc_159D
mov r12, [rdi+10h]
mov ebp, 3
test r12, r12
jnz loc_16FA
jmp loc_1575
loc_1CA0:
mov r13, [r13+10h]
test r13, r13
jnz loc_1761
mov rbx, [rbx+10h]
mov r13d, 1
test rbx, rbx
jnz loc_17B3
mov r13, [r12+10h]
mov ebx, 2
test r13, r13
jnz loc_185F
jmp loc_19AE
loc_1CE0:
mov rbx, [rbx+10h]
mov edx, 1
test rbx, rbx
jnz loc_17FF
jmp loc_1840
loc_1D00:
mov rbp, [rbp+10h]
test rbp, rbp
jnz loc_15F6
mov r13, [r13+10h]
mov eax, 2
test r13, r13
jz loc_1551
mov ebp, 1
jmp loc_1646
loc_1D30:
mov r12, [r12+10h]
test r12, r12
jnz loc_18BA
mov r13, [r13+10h]
mov eax, 2
test r13, r13
jz loc_19A6
mov r12d, 1
jmp loc_190D
loc_1D60:
mov r12, [r12+10h]
mov eax, 1
test r12, r12
jnz loc_14F6
jmp loc_1537
loc_1D80:
mov rdi, [r13+10h]
mov eax, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1781
jmp loc_1795
loc_1DA0:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_14D6
mov r12, [r12+10h]
mov eax, 2
test r12, r12
jz loc_1537
mov r14d, 1
jmp loc_14F6
loc_1DD0:
mov rdi, [r12+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1518
jmp loc_152A
loc_1DF0:
mov rdi, [r13+10h]
mov eax, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1475
jmp loc_1489
loc_1E10:
mov rdi, [r13+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1979
jmp loc_198B
loc_1E30:
mov rdi, [r12+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_18DC
jmp loc_18EE
loc_1E50:
mov rdi, [rbx+10h]
mov eax, 1
xor r15d, r15d
test rdi, rdi
jnz loc_181F
jmp loc_1833
loc_1E70:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_17E0
mov rbx, [rbx+10h]
mov edx, 2
test rbx, rbx
jz loc_1840
mov r14d, 1
jmp loc_17FF
loc_1EA0:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_193A
mov r13, [r13+10h]
mov eax, 2
test r13, r13
jz loc_1998
mov r14d, 1
jmp loc_1959
loc_1ED0:
mov rdi, [rbp+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_1616
jmp loc_1628
loc_1EF0:
mov rdi, [r13+10h]
mov edx, 1
xor r15d, r15d
test rdi, rdi
jnz loc_16B2
jmp loc_16C4
loc_1F10:
mov rdi, [r14+10h]
xor r15d, r15d
test rdi, rdi
jnz loc_1673
mov r13, [r13+10h]
mov eax, 2
test r13, r13
jz loc_16D1
mov r14d, 1
jmp loc_1692 | long long func0_part_0(long long a1, long long a2, long long a3)
{
long long v4; // rbp
long long v5; // r12
long long v6; // r13
long long v7; // r14
int v8; // r15d
int v9; // eax
long long v10; // r13
int v11; // eax
int v12; // r15d
int v13; // eax
bool v14; // cc
long long v15; // r12
int v16; // eax
long long v17; // r14
int v18; // r15d
int v19; // eax
long long v20; // r12
long long v21; // rdi
int v22; // eax
long long v23; // rdi
int v24; // r15d
int v25; // eax
long long v26; // r13
int v27; // eax
long long v28; // r12
int v29; // eax
long long result; // rax
long long v31; // rbp
long long v32; // r14
long long v33; // rdi
int v34; // eax
long long v35; // rdi
int v36; // r15d
int v37; // eax
long long v38; // rbp
long long v39; // rdi
int v40; // eax
long long v41; // rdi
int v42; // r15d
int v43; // eax
int v44; // ecx
long long v45; // r13
int v46; // eax
long long v47; // r14
long long v48; // rdi
int v49; // eax
long long v50; // rdi
int v51; // r15d
int v52; // eax
long long v53; // r13
long long v54; // rdi
int v55; // eax
long long v56; // rdi
int v57; // r15d
int v58; // eax
long long v59; // rbx
long long v60; // r13
long long v61; // r14
long long v62; // rdi
int v63; // eax
long long v64; // rdi
int v65; // r15d
int v66; // eax
long long v67; // r13
int v68; // eax
long long v69; // rdi
int v70; // eax
long long v71; // rdi
int v72; // r15d
int v73; // eax
long long v74; // rbx
long long v75; // r14
long long v76; // rdi
int v77; // eax
long long v78; // rdi
int v79; // r15d
int v80; // eax
long long v81; // rbx
int v82; // eax
long long v83; // rdi
int v84; // eax
long long v85; // rdi
int v86; // r15d
int v87; // eax
int v88; // ecx
long long v89; // r13
int v90; // eax
long long v91; // r12
long long v92; // r14
long long v93; // rdi
int v94; // eax
long long v95; // rdi
int v96; // r15d
int v97; // eax
long long v98; // r12
long long v99; // rdi
int v100; // eax
long long v101; // rdi
int v102; // r15d
int v103; // eax
int v104; // ecx
long long v105; // r13
int v106; // eax
long long v107; // r14
long long v108; // rdi
int v109; // eax
long long v110; // rdi
int v111; // r15d
int v112; // eax
long long v113; // r13
long long v114; // rdi
int v115; // eax
long long v116; // rdi
int v117; // r15d
int v118; // eax
v4 = *(_QWORD *)(a1 + 8);
if ( v4 )
{
v5 = *(_QWORD *)(v4 + 8);
if ( v5 )
{
v6 = *(_QWORD *)(v5 + 8);
if ( !v6 )
{
v15 = *(_QWORD *)(v5 + 16);
if ( !v15 )
{
v26 = *(_QWORD *)(v4 + 16);
LODWORD(v5) = 1;
if ( !v26 )
{
v28 = *(_QWORD *)(a1 + 16);
LODWORD(v4) = 2;
if ( !v28 )
return (unsigned int)(v4 + 1);
goto LABEL_76;
}
goto LABEL_43;
}
goto LABEL_19;
}
v7 = *(_QWORD *)(v6 + 8);
if ( !v7 )
{
v10 = *(_QWORD *)(v6 + 16);
if ( !v10 )
{
v15 = *(_QWORD *)(v5 + 16);
LODWORD(v6) = 1;
if ( !v15 )
{
v26 = *(_QWORD *)(v4 + 16);
LODWORD(v5) = 2;
if ( !v26 )
{
v28 = *(_QWORD *)(a1 + 16);
LODWORD(v4) = 3;
if ( !v28 )
return (unsigned int)(v4 + 1);
goto LABEL_76;
}
goto LABEL_43;
}
goto LABEL_19;
}
goto LABEL_11;
}
if ( *(_QWORD *)(v7 + 8) )
{
v8 = ((long long (*)(void))func0_part_0)();
v9 = 0;
if ( !*(_QWORD *)(v7 + 16) )
goto LABEL_8;
}
else
{
v8 = 0;
if ( !*(_QWORD *)(v7 + 16) )
{
v10 = *(_QWORD *)(v6 + 16);
LODWORD(v7) = 1;
if ( !v10 )
{
v15 = *(_QWORD *)(v5 + 16);
LODWORD(v6) = 2;
if ( !v15 )
{
v26 = *(_QWORD *)(v4 + 16);
LODWORD(v5) = 3;
if ( !v26 )
{
LABEL_37:
LODWORD(v4) = v5 + 1;
LABEL_38:
v28 = *(_QWORD *)(a1 + 16);
v29 = 0;
if ( !v28 )
goto LABEL_39;
LABEL_76:
v59 = *(_QWORD *)(v28 + 8);
if ( !v59 )
{
v89 = *(_QWORD *)(v28 + 16);
v29 = 1;
if ( !v89 )
goto LABEL_39;
v91 = *(_QWORD *)(v89 + 8);
if ( v91 )
{
LABEL_111:
v92 = *(_QWORD *)(v91 + 8);
if ( !v92 )
{
v98 = *(_QWORD *)(v91 + 16);
if ( !v98 )
{
v105 = *(_QWORD *)(v89 + 16);
v90 = 2;
if ( !v105 )
goto LABEL_142;
LODWORD(v91) = 1;
goto LABEL_126;
}
goto LABEL_118;
}
v93 = *(_QWORD *)(v92 + 8);
if ( v93 )
{
v94 = func0_part_0(v93, a2, a3);
v95 = *(_QWORD *)(v92 + 16);
v96 = v94;
v97 = 0;
if ( !v95 )
goto LABEL_115;
}
else
{
v95 = *(_QWORD *)(v92 + 16);
v96 = 0;
if ( !v95 )
{
v98 = *(_QWORD *)(v91 + 16);
LODWORD(v92) = 1;
if ( !v98 )
{
v105 = *(_QWORD *)(v89 + 16);
LODWORD(v91) = 2;
if ( !v105 )
{
LABEL_141:
v90 = v91 + 1;
LABEL_142:
if ( v90 < (int)v59 )
goto LABEL_143;
v29 = v90 + 1;
LABEL_39:
if ( v29 < (int)v4 )
return (unsigned int)(v4 + 1);
return (unsigned int)(v29 + 1);
}
goto LABEL_126;
}
goto LABEL_118;
}
}
v97 = func0_part_0(v95, a2, a3);
LABEL_115:
v98 = *(_QWORD *)(v91 + 16);
LODWORD(v92) = v97 + 1;
if ( v97 < v96 )
LODWORD(v92) = v96 + 1;
a3 = 0LL;
if ( !v98 )
{
LABEL_123:
v104 = v92 + 1;
v105 = *(_QWORD *)(v89 + 16);
if ( (int)a3 >= (int)v92 )
v104 = a3 + 1;
v106 = 0;
LODWORD(v91) = v104;
if ( !v105 )
{
LABEL_140:
if ( v106 >= (int)v91 )
{
v90 = v106 + 1;
goto LABEL_142;
}
goto LABEL_141;
}
LABEL_126:
v107 = *(_QWORD *)(v105 + 8);
if ( v107 )
goto LABEL_127;
goto LABEL_149;
}
LABEL_118:
v99 = *(_QWORD *)(v98 + 8);
if ( v99 )
{
v100 = func0_part_0(v99, a2, a3);
v101 = *(_QWORD *)(v98 + 16);
v102 = v100;
v103 = 0;
if ( !v101 )
goto LABEL_121;
}
else
{
v101 = *(_QWORD *)(v98 + 16);
a3 = 1LL;
v102 = 0;
if ( !v101 )
goto LABEL_123;
}
v103 = func0_part_0(v101, a2, a3);
LABEL_121:
a3 = (unsigned int)(v102 + 1);
if ( v103 >= v102 )
a3 = (unsigned int)(v103 + 1);
goto LABEL_123;
}
LABEL_147:
v105 = *(_QWORD *)(v89 + 16);
v90 = 1;
if ( !v105 )
goto LABEL_142;
v107 = *(_QWORD *)(v105 + 8);
if ( v107 )
{
LABEL_127:
v108 = *(_QWORD *)(v107 + 8);
if ( v108 )
{
v109 = func0_part_0(v108, a2, a3);
v110 = *(_QWORD *)(v107 + 16);
v111 = v109;
v112 = 0;
if ( !v110 )
goto LABEL_130;
}
else
{
v110 = *(_QWORD *)(v107 + 16);
v111 = 0;
if ( !v110 )
{
v113 = *(_QWORD *)(v105 + 16);
v106 = 2;
if ( !v113 )
goto LABEL_140;
LODWORD(v107) = 1;
goto LABEL_133;
}
}
v112 = func0_part_0(v110, a2, a3);
LABEL_130:
v113 = *(_QWORD *)(v105 + 16);
LODWORD(v107) = v112 + 1;
if ( v112 < v111 )
LODWORD(v107) = v111 + 1;
a3 = 0LL;
if ( !v113 )
goto LABEL_138;
LABEL_133:
v114 = *(_QWORD *)(v113 + 8);
if ( v114 )
{
v115 = func0_part_0(v114, a2, a3);
v116 = *(_QWORD *)(v113 + 16);
v117 = v115;
v118 = 0;
if ( !v116 )
goto LABEL_136;
}
else
{
v116 = *(_QWORD *)(v113 + 16);
a3 = 1LL;
v117 = 0;
if ( !v116 )
{
LABEL_138:
v106 = v107 + 1;
if ( (int)a3 >= (int)v107 )
v106 = a3 + 1;
goto LABEL_140;
}
}
v118 = func0_part_0(v116, a2, a3);
LABEL_136:
LODWORD(a3) = v117 + 1;
if ( v118 >= v117 )
LODWORD(a3) = v118 + 1;
goto LABEL_138;
}
LABEL_149:
v113 = *(_QWORD *)(v105 + 16);
v106 = 1;
if ( !v113 )
goto LABEL_140;
goto LABEL_133;
}
v60 = *(_QWORD *)(v59 + 8);
if ( !v60 )
{
v74 = *(_QWORD *)(v59 + 16);
if ( !v74 )
{
v89 = *(_QWORD *)(v28 + 16);
v29 = 2;
if ( !v89 )
goto LABEL_39;
LODWORD(v59) = 1;
goto LABEL_110;
}
goto LABEL_93;
}
v61 = *(_QWORD *)(v60 + 8);
if ( v61 )
{
v62 = *(_QWORD *)(v61 + 8);
if ( v62 )
{
v63 = func0_part_0(v62, a2, a3);
v64 = *(_QWORD *)(v61 + 16);
v65 = v63;
v66 = 0;
if ( !v64 )
goto LABEL_82;
goto LABEL_81;
}
v64 = *(_QWORD *)(v61 + 16);
v65 = 0;
if ( v64 )
{
LABEL_81:
v66 = func0_part_0(v64, a2, a3);
LABEL_82:
v67 = *(_QWORD *)(v60 + 16);
LODWORD(v61) = v66 + 1;
a3 = (unsigned int)(v65 + 1);
if ( v66 < v65 )
LODWORD(v61) = v65 + 1;
v68 = 0;
if ( !v67 )
{
LABEL_90:
v74 = *(_QWORD *)(v59 + 16);
LODWORD(v60) = v68 + 1;
if ( v68 < (int)v61 )
LODWORD(v60) = v61 + 1;
a3 = 0LL;
if ( !v74 )
{
LABEL_107:
v88 = v60 + 1;
v14 = (int)a3 < (int)v60;
v89 = *(_QWORD *)(v28 + 16);
if ( !v14 )
v88 = a3 + 1;
v90 = 0;
LODWORD(v59) = v88;
if ( !v89 )
goto LABEL_142;
LABEL_110:
v91 = *(_QWORD *)(v89 + 8);
if ( v91 )
goto LABEL_111;
goto LABEL_147;
}
LABEL_93:
v75 = *(_QWORD *)(v74 + 8);
if ( !v75 )
{
v81 = *(_QWORD *)(v74 + 16);
a3 = 1LL;
if ( !v81 )
goto LABEL_107;
goto LABEL_100;
}
v76 = *(_QWORD *)(v75 + 8);
if ( v76 )
{
v77 = func0_part_0(v76, a2, a3);
v78 = *(_QWORD *)(v75 + 16);
v79 = v77;
v80 = 0;
if ( !v78 )
goto LABEL_97;
}
else
{
v78 = *(_QWORD *)(v75 + 16);
v79 = 0;
if ( !v78 )
{
v81 = *(_QWORD *)(v74 + 16);
a3 = 2LL;
if ( !v81 )
goto LABEL_107;
LODWORD(v75) = 1;
goto LABEL_100;
}
}
v80 = func0_part_0(v78, a2, a3);
LABEL_97:
v81 = *(_QWORD *)(v74 + 16);
LODWORD(v75) = v80 + 1;
a3 = (unsigned int)(v79 + 1);
if ( v80 < v79 )
LODWORD(v75) = v79 + 1;
v82 = 0;
if ( !v81 )
goto LABEL_105;
LABEL_100:
v83 = *(_QWORD *)(v81 + 8);
if ( v83 )
{
v84 = func0_part_0(v83, a2, a3);
v85 = *(_QWORD *)(v81 + 16);
v86 = v84;
v87 = 0;
if ( !v85 )
goto LABEL_103;
}
else
{
v85 = *(_QWORD *)(v81 + 16);
v82 = 1;
v86 = 0;
if ( !v85 )
{
LABEL_105:
a3 = (unsigned int)(v75 + 1);
if ( v82 >= (int)v75 )
a3 = (unsigned int)(v82 + 1);
goto LABEL_107;
}
}
v87 = func0_part_0(v85, a2, a3);
LABEL_103:
v14 = v87 < v86;
v82 = v87 + 1;
if ( v14 )
v82 = v86 + 1;
goto LABEL_105;
}
LABEL_85:
v69 = *(_QWORD *)(v67 + 8);
if ( v69 )
{
v70 = func0_part_0(v69, a2, a3);
v71 = *(_QWORD *)(v67 + 16);
v72 = v70;
v73 = 0;
if ( !v71 )
goto LABEL_88;
}
else
{
v71 = *(_QWORD *)(v67 + 16);
v68 = 1;
v72 = 0;
if ( !v71 )
goto LABEL_90;
}
v73 = func0_part_0(v71, a2, a3);
LABEL_88:
v14 = v73 < v72;
v68 = v73 + 1;
if ( v14 )
v68 = v72 + 1;
goto LABEL_90;
}
v67 = *(_QWORD *)(v60 + 16);
LODWORD(v61) = 1;
if ( v67 )
goto LABEL_85;
v74 = *(_QWORD *)(v59 + 16);
LODWORD(v60) = 2;
if ( v74 )
goto LABEL_93;
v89 = *(_QWORD *)(v28 + 16);
LODWORD(v59) = 3;
if ( v89 )
goto LABEL_110;
}
else
{
v67 = *(_QWORD *)(v60 + 16);
if ( v67 )
goto LABEL_85;
v74 = *(_QWORD *)(v59 + 16);
LODWORD(v60) = 1;
if ( v74 )
goto LABEL_93;
v89 = *(_QWORD *)(v28 + 16);
LODWORD(v59) = 2;
if ( v89 )
goto LABEL_110;
}
LABEL_143:
v29 = v59 + 1;
if ( (int)v59 + 1 < (int)v4 )
return (unsigned int)(v4 + 1);
return (unsigned int)(v29 + 1);
}
goto LABEL_43;
}
goto LABEL_19;
}
goto LABEL_11;
}
}
v9 = ((long long (*)(void))func0_part_0)();
LABEL_8:
v10 = *(_QWORD *)(v6 + 16);
LODWORD(v7) = v9 + 1;
if ( v9 < v8 )
LODWORD(v7) = v8 + 1;
v11 = 0;
if ( !v10 )
{
LABEL_16:
v15 = *(_QWORD *)(v5 + 16);
LODWORD(v6) = v11 + 1;
a3 = (unsigned int)(v7 + 1);
if ( v11 < (int)v7 )
LODWORD(v6) = v7 + 1;
v16 = 0;
if ( !v15 )
{
LABEL_33:
a3 = (unsigned int)(v6 + 1);
LODWORD(v5) = v16 + 1;
v14 = v16 < (int)v6;
v26 = *(_QWORD *)(v4 + 16);
if ( v14 )
LODWORD(v5) = a3;
v27 = 0;
if ( !v26 )
{
LABEL_36:
LODWORD(v4) = v27 + 1;
if ( v27 >= (int)v5 )
goto LABEL_38;
goto LABEL_37;
}
LABEL_43:
v31 = *(_QWORD *)(v26 + 8);
if ( !v31 )
{
v45 = *(_QWORD *)(v26 + 16);
v27 = 1;
if ( !v45 )
goto LABEL_36;
v47 = *(_QWORD *)(v45 + 8);
if ( v47 )
{
LABEL_60:
v48 = *(_QWORD *)(v47 + 8);
if ( v48 )
{
v49 = func0_part_0(v48, a2, a3);
v50 = *(_QWORD *)(v47 + 16);
v51 = v49;
v52 = 0;
if ( !v50 )
goto LABEL_63;
}
else
{
v50 = *(_QWORD *)(v47 + 16);
v51 = 0;
if ( !v50 )
{
v53 = *(_QWORD *)(v45 + 16);
v46 = 2;
if ( !v53 )
goto LABEL_73;
LODWORD(v47) = 1;
goto LABEL_66;
}
}
v52 = func0_part_0(v50, a2, a3);
LABEL_63:
v53 = *(_QWORD *)(v45 + 16);
LODWORD(v47) = v52 + 1;
if ( v52 < v51 )
LODWORD(v47) = v51 + 1;
a3 = 0LL;
if ( !v53 )
goto LABEL_71;
LABEL_66:
v54 = *(_QWORD *)(v53 + 8);
if ( v54 )
{
v55 = func0_part_0(v54, a2, a3);
v56 = *(_QWORD *)(v53 + 16);
v57 = v55;
v58 = 0;
if ( !v56 )
goto LABEL_69;
}
else
{
v56 = *(_QWORD *)(v53 + 16);
a3 = 1LL;
v57 = 0;
if ( !v56 )
{
LABEL_71:
v46 = v47 + 1;
if ( (int)a3 >= (int)v47 )
v46 = a3 + 1;
goto LABEL_73;
}
}
v58 = func0_part_0(v56, a2, a3);
LABEL_69:
a3 = (unsigned int)(v57 + 1);
if ( v58 >= v57 )
a3 = (unsigned int)(v58 + 1);
goto LABEL_71;
}
LABEL_176:
v53 = *(_QWORD *)(v45 + 16);
v46 = 1;
if ( !v53 )
goto LABEL_73;
goto LABEL_66;
}
v32 = *(_QWORD *)(v31 + 8);
if ( !v32 )
{
v38 = *(_QWORD *)(v31 + 16);
if ( !v38 )
{
v45 = *(_QWORD *)(v26 + 16);
v27 = 2;
if ( !v45 )
goto LABEL_36;
LODWORD(v31) = 1;
goto LABEL_59;
}
goto LABEL_51;
}
v33 = *(_QWORD *)(v32 + 8);
if ( v33 )
{
v34 = func0_part_0(v33, a2, a3);
v35 = *(_QWORD *)(v32 + 16);
v36 = v34;
v37 = 0;
if ( !v35 )
goto LABEL_48;
}
else
{
v35 = *(_QWORD *)(v32 + 16);
v36 = 0;
if ( !v35 )
{
v38 = *(_QWORD *)(v31 + 16);
LODWORD(v32) = 1;
if ( !v38 )
{
v45 = *(_QWORD *)(v26 + 16);
LODWORD(v31) = 2;
if ( !v45 )
goto LABEL_74;
goto LABEL_59;
}
goto LABEL_51;
}
}
v37 = func0_part_0(v35, a2, a3);
LABEL_48:
v38 = *(_QWORD *)(v31 + 16);
LODWORD(v32) = v37 + 1;
if ( v37 < v36 )
LODWORD(v32) = v36 + 1;
a3 = 0LL;
if ( !v38 )
{
LABEL_56:
v44 = v32 + 1;
v45 = *(_QWORD *)(v26 + 16);
if ( (int)a3 >= (int)v32 )
v44 = a3 + 1;
v46 = 0;
LODWORD(v31) = v44;
if ( !v45 )
{
LABEL_73:
if ( v46 >= (int)v31 )
{
v27 = v46 + 1;
goto LABEL_36;
}
LABEL_74:
v27 = v31 + 1;
goto LABEL_36;
}
LABEL_59:
v47 = *(_QWORD *)(v45 + 8);
if ( v47 )
goto LABEL_60;
goto LABEL_176;
}
LABEL_51:
v39 = *(_QWORD *)(v38 + 8);
if ( v39 )
{
v40 = func0_part_0(v39, a2, a3);
v41 = *(_QWORD *)(v38 + 16);
v42 = v40;
v43 = 0;
if ( !v41 )
goto LABEL_54;
}
else
{
v41 = *(_QWORD *)(v38 + 16);
a3 = 1LL;
v42 = 0;
if ( !v41 )
goto LABEL_56;
}
v43 = func0_part_0(v41, a2, a3);
LABEL_54:
a3 = (unsigned int)(v42 + 1);
if ( v43 >= v42 )
a3 = (unsigned int)(v43 + 1);
goto LABEL_56;
}
LABEL_19:
v17 = *(_QWORD *)(v15 + 8);
if ( !v17 )
{
v20 = *(_QWORD *)(v15 + 16);
v16 = 1;
if ( !v20 )
goto LABEL_33;
goto LABEL_26;
}
if ( *(_QWORD *)(v17 + 8) )
{
v18 = ((long long (*)(void))func0_part_0)();
v19 = 0;
if ( !*(_QWORD *)(v17 + 16) )
goto LABEL_23;
}
else
{
v18 = 0;
if ( !*(_QWORD *)(v17 + 16) )
{
v20 = *(_QWORD *)(v15 + 16);
v16 = 2;
if ( !v20 )
goto LABEL_33;
LODWORD(v17) = 1;
goto LABEL_26;
}
}
v19 = ((long long (*)(void))func0_part_0)();
LABEL_23:
v20 = *(_QWORD *)(v15 + 16);
LODWORD(v17) = v19 + 1;
if ( v19 < v18 )
LODWORD(v17) = v18 + 1;
a3 = 0LL;
if ( !v20 )
goto LABEL_31;
LABEL_26:
v21 = *(_QWORD *)(v20 + 8);
if ( v21 )
{
v22 = func0_part_0(v21, a2, a3);
v23 = *(_QWORD *)(v20 + 16);
v24 = v22;
v25 = 0;
if ( !v23 )
goto LABEL_29;
}
else
{
v23 = *(_QWORD *)(v20 + 16);
a3 = 1LL;
v24 = 0;
if ( !v23 )
{
LABEL_31:
v16 = v17 + 1;
if ( (int)a3 >= (int)v17 )
v16 = a3 + 1;
goto LABEL_33;
}
}
v25 = func0_part_0(v23, a2, a3);
LABEL_29:
LODWORD(a3) = v24 + 1;
if ( v25 >= v24 )
LODWORD(a3) = v25 + 1;
goto LABEL_31;
}
LABEL_11:
if ( *(_QWORD *)(v10 + 8) )
{
v12 = ((long long (*)(void))func0_part_0)();
v13 = 0;
if ( !*(_QWORD *)(v10 + 16) )
goto LABEL_14;
}
else
{
v11 = 1;
v12 = 0;
if ( !*(_QWORD *)(v10 + 16) )
goto LABEL_16;
}
v13 = ((long long (*)(void))func0_part_0)();
LABEL_14:
v14 = v13 < v12;
v11 = v13 + 1;
if ( v14 )
v11 = v12 + 1;
goto LABEL_16;
}
v26 = *(_QWORD *)(v4 + 16);
if ( v26 )
goto LABEL_43;
v28 = *(_QWORD *)(a1 + 16);
result = 2LL;
LODWORD(v4) = 1;
if ( v28 )
goto LABEL_76;
}
else
{
v28 = *(_QWORD *)(a1 + 16);
result = 1LL;
if ( v28 )
goto LABEL_76;
}
return result;
} | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RBP,qword ptr [RDI + 0x8]
TEST RBP,RBP
JZ 0x001016e8
MOV R12,qword ptr [RBP + 0x8]
TEST R12,R12
JZ 0x00101590
MOV R13,qword ptr [R12 + 0x8]
TEST R13,R13
JZ 0x00101c10
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101c50
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101ac0
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010143b
LAB_00101436:
CALL 0x001013d0
LAB_0010143b:
MOV R13,qword ptr [R13 + 0x10]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
LEA EDX,[R15 + 0x1]
CMOVL R14D,EDX
XOR EAX,EAX
TEST R13,R13
JZ 0x00101489
LAB_00101455:
MOV RDI,qword ptr [R13 + 0x8]
TEST RDI,RDI
JZ 0x00101df0
CALL 0x001013d0
MOV RDI,qword ptr [R13 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010147a
LAB_00101475:
CALL 0x001013d0
LAB_0010147a:
LEA ECX,[RAX + 0x1]
CMP EAX,R15D
LEA EDX,[R15 + 0x1]
MOV EAX,ECX
CMOVL EAX,EDX
LAB_00101489:
MOV R12,qword ptr [R12 + 0x10]
LEA R13D,[RAX + 0x1]
LEA EDX,[R14 + 0x1]
CMP EAX,R14D
CMOVL R13D,EDX
XOR EAX,EAX
TEST R12,R12
JZ 0x00101537
LAB_001014a8:
MOV R14,qword ptr [R12 + 0x8]
TEST R14,R14
JZ 0x00101d60
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101da0
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001014db
LAB_001014d6:
CALL 0x001013d0
LAB_001014db:
MOV R12,qword ptr [R12 + 0x10]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
LEA R14D,[RAX + 0x1]
CMOVL R14D,EDX
XOR EDX,EDX
TEST R12,R12
JZ 0x0010152a
LAB_001014f6:
MOV RDI,qword ptr [R12 + 0x8]
TEST RDI,RDI
JZ 0x00101dd0
CALL 0x001013d0
MOV RDI,qword ptr [R12 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010151d
LAB_00101518:
CALL 0x001013d0
LAB_0010151d:
LEA ECX,[RAX + 0x1]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
CMOVGE EDX,ECX
LAB_0010152a:
LEA ECX,[RDX + 0x1]
LEA EAX,[R14 + 0x1]
CMP EDX,R14D
CMOVGE EAX,ECX
LAB_00101537:
LEA EDX,[R13 + 0x1]
LEA R12D,[RAX + 0x1]
CMP EAX,R13D
MOV R13,qword ptr [RBP + 0x10]
CMOVL R12D,EDX
XOR EAX,EAX
TEST R13,R13
JNZ 0x0010159d
LAB_00101551:
LEA EBP,[RAX + 0x1]
CMP EAX,R12D
JGE 0x0010155e
LAB_00101559:
LEA EBP,[R12 + 0x1]
LAB_0010155e:
MOV R12,qword ptr [RBX + 0x10]
XOR EAX,EAX
TEST R12,R12
JNZ 0x001016fa
LAB_0010156d:
CMP EAX,EBP
JGE 0x001019b9
LAB_00101575:
LEA EAX,[RBP + 0x1]
LAB_00101578:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101590:
MOV R13,qword ptr [RBP + 0x10]
TEST R13,R13
JZ 0x00101b50
LAB_0010159d:
MOV RBP,qword ptr [R13 + 0x8]
TEST RBP,RBP
JZ 0x00101ba0
MOV R14,qword ptr [RBP + 0x8]
TEST R14,R14
JZ 0x00101d00
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101b10
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001015dc
LAB_001015d7:
CALL 0x001013d0
LAB_001015dc:
MOV RBP,qword ptr [RBP + 0x10]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
LEA R14D,[RAX + 0x1]
CMOVL R14D,EDX
XOR EDX,EDX
TEST RBP,RBP
JZ 0x00101628
LAB_001015f6:
MOV RDI,qword ptr [RBP + 0x8]
TEST RDI,RDI
JZ 0x00101ed0
CALL 0x001013d0
MOV RDI,qword ptr [RBP + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010161b
LAB_00101616:
CALL 0x001013d0
LAB_0010161b:
LEA ECX,[RAX + 0x1]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
CMOVGE EDX,ECX
LAB_00101628:
LEA EAX,[RDX + 0x1]
LEA ECX,[R14 + 0x1]
CMP EDX,R14D
MOV R13,qword ptr [R13 + 0x10]
CMOVGE ECX,EAX
XOR EAX,EAX
MOV EBP,ECX
TEST R13,R13
JZ 0x001016d1
LAB_00101646:
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101bbf
LAB_00101653:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101f10
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101678
LAB_00101673:
CALL 0x001013d0
LAB_00101678:
MOV R13,qword ptr [R13 + 0x10]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
LEA R14D,[RAX + 0x1]
CMOVL R14D,EDX
XOR EDX,EDX
TEST R13,R13
JZ 0x001016c4
LAB_00101692:
MOV RDI,qword ptr [R13 + 0x8]
TEST RDI,RDI
JZ 0x00101ef0
CALL 0x001013d0
MOV RDI,qword ptr [R13 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001016b7
LAB_001016b2:
CALL 0x001013d0
LAB_001016b7:
LEA ECX,[RAX + 0x1]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
CMOVGE EDX,ECX
LAB_001016c4:
LEA ECX,[RDX + 0x1]
LEA EAX,[R14 + 0x1]
CMP EDX,R14D
CMOVGE EAX,ECX
LAB_001016d1:
CMP EAX,EBP
JGE 0x00101b90
LAB_001016d9:
LEA EAX,[RBP + 0x1]
JMP 0x00101551
LAB_001016e8:
MOV R12,qword ptr [RDI + 0x10]
MOV EAX,0x1
TEST R12,R12
JZ 0x00101578
LAB_001016fa:
MOV RBX,qword ptr [R12 + 0x8]
TEST RBX,RBX
JZ 0x001019d0
MOV R13,qword ptr [RBX + 0x8]
TEST R13,R13
JZ 0x00101be0
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101ca0
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101a28
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101747
LAB_00101742:
CALL 0x001013d0
LAB_00101747:
MOV R13,qword ptr [R13 + 0x10]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
LEA EDX,[R15 + 0x1]
CMOVL R14D,EDX
XOR EAX,EAX
TEST R13,R13
JZ 0x00101795
LAB_00101761:
MOV RDI,qword ptr [R13 + 0x8]
TEST RDI,RDI
JZ 0x00101d80
CALL 0x001013d0
MOV RDI,qword ptr [R13 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101786
LAB_00101781:
CALL 0x001013d0
LAB_00101786:
LEA ECX,[RAX + 0x1]
CMP EAX,R15D
LEA EDX,[R15 + 0x1]
MOV EAX,ECX
CMOVL EAX,EDX
LAB_00101795:
MOV RBX,qword ptr [RBX + 0x10]
LEA EDX,[R14 + 0x1]
LEA R13D,[RAX + 0x1]
CMP EAX,R14D
CMOVL R13D,EDX
XOR EDX,EDX
TEST RBX,RBX
JZ 0x00101840
LAB_001017b3:
MOV R14,qword ptr [RBX + 0x8]
TEST R14,R14
JZ 0x00101ce0
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101e70
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001017e5
LAB_001017e0:
CALL 0x001013d0
LAB_001017e5:
MOV RBX,qword ptr [RBX + 0x10]
LEA R14D,[RAX + 0x1]
CMP EAX,R15D
LEA EDX,[R15 + 0x1]
CMOVL R14D,EDX
XOR EAX,EAX
TEST RBX,RBX
JZ 0x00101833
LAB_001017ff:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x00101e50
CALL 0x001013d0
MOV RDI,qword ptr [RBX + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101824
LAB_0010181f:
CALL 0x001013d0
LAB_00101824:
LEA ECX,[RAX + 0x1]
CMP EAX,R15D
LEA EDX,[R15 + 0x1]
MOV EAX,ECX
CMOVL EAX,EDX
LAB_00101833:
LEA ECX,[RAX + 0x1]
LEA EDX,[R14 + 0x1]
CMP EAX,R14D
CMOVGE EDX,ECX
LAB_00101840:
LEA ECX,[R13 + 0x1]
LEA EAX,[RDX + 0x1]
CMP EDX,R13D
MOV R13,qword ptr [R12 + 0x10]
CMOVGE ECX,EAX
XOR EAX,EAX
MOV EBX,ECX
TEST R13,R13
JZ 0x001019a6
LAB_0010185f:
MOV R12,qword ptr [R13 + 0x8]
TEST R12,R12
JZ 0x001019f0
LAB_0010186c:
MOV R14,qword ptr [R12 + 0x8]
TEST R14,R14
JZ 0x00101d30
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101a80
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010189f
LAB_0010189a:
CALL 0x001013d0
LAB_0010189f:
MOV R12,qword ptr [R12 + 0x10]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
LEA R14D,[RAX + 0x1]
CMOVL R14D,EDX
XOR EDX,EDX
TEST R12,R12
JZ 0x001018ee
LAB_001018ba:
MOV RDI,qword ptr [R12 + 0x8]
TEST RDI,RDI
JZ 0x00101e30
CALL 0x001013d0
MOV RDI,qword ptr [R12 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001018e1
LAB_001018dc:
CALL 0x001013d0
LAB_001018e1:
LEA ECX,[RAX + 0x1]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
CMOVGE EDX,ECX
LAB_001018ee:
LEA EAX,[RDX + 0x1]
LEA ECX,[R14 + 0x1]
CMP EDX,R14D
MOV R13,qword ptr [R13 + 0x10]
CMOVGE ECX,EAX
XOR EAX,EAX
MOV R12D,ECX
TEST R13,R13
JZ 0x00101998
LAB_0010190d:
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101a0b
LAB_0010191a:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00101ea0
CALL 0x001013d0
MOV RDI,qword ptr [R14 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010193f
LAB_0010193a:
CALL 0x001013d0
LAB_0010193f:
MOV R13,qword ptr [R13 + 0x10]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
LEA R14D,[RAX + 0x1]
CMOVL R14D,EDX
XOR EDX,EDX
TEST R13,R13
JZ 0x0010198b
LAB_00101959:
MOV RDI,qword ptr [R13 + 0x8]
TEST RDI,RDI
JZ 0x00101e10
CALL 0x001013d0
MOV RDI,qword ptr [R13 + 0x10]
MOV R15D,EAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0010197e
LAB_00101979:
CALL 0x001013d0
LAB_0010197e:
LEA ECX,[RAX + 0x1]
LEA EDX,[R15 + 0x1]
CMP EAX,R15D
CMOVGE EDX,ECX
LAB_0010198b:
LEA ECX,[RDX + 0x1]
LEA EAX,[R14 + 0x1]
CMP EDX,R14D
CMOVGE EAX,ECX
LAB_00101998:
CMP EAX,R12D
JGE 0x00101b80
LAB_001019a1:
LEA EAX,[R12 + 0x1]
LAB_001019a6:
CMP EAX,EBX
JGE 0x00101b70
LAB_001019ae:
LEA EAX,[RBX + 0x1]
CMP EAX,EBP
JL 0x00101575
LAB_001019b9:
ADD RSP,0x8
ADD EAX,0x1
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001019d0:
MOV R13,qword ptr [R12 + 0x10]
MOV EAX,0x1
TEST R13,R13
JZ 0x0010156d
MOV R12,qword ptr [R13 + 0x8]
TEST R12,R12
JNZ 0x0010186c
LAB_001019f0:
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x1
TEST R13,R13
JZ 0x001019a6
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JNZ 0x0010191a
LAB_00101a0b:
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x1
TEST R13,R13
JNZ 0x00101959
JMP 0x00101998
LAB_00101a28:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101742
MOV R13,qword ptr [R13 + 0x10]
MOV R14D,0x1
TEST R13,R13
JNZ 0x00101761
MOV RBX,qword ptr [RBX + 0x10]
MOV R13D,0x2
TEST RBX,RBX
JNZ 0x001017b3
MOV R13,qword ptr [R12 + 0x10]
MOV EBX,0x3
TEST R13,R13
JNZ 0x0010185f
JMP 0x001019ae
LAB_00101a80:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x0010189a
MOV R12,qword ptr [R12 + 0x10]
MOV R14D,0x1
TEST R12,R12
JNZ 0x001018ba
MOV R13,qword ptr [R13 + 0x10]
MOV R12D,0x2
TEST R13,R13
JNZ 0x0010190d
JMP 0x001019a1
LAB_00101ac0:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101436
MOV R13,qword ptr [R13 + 0x10]
MOV R14D,0x1
TEST R13,R13
JNZ 0x00101455
MOV R12,qword ptr [R12 + 0x10]
MOV R13D,0x2
TEST R12,R12
JNZ 0x001014a8
MOV R13,qword ptr [RBP + 0x10]
MOV R12D,0x3
TEST R13,R13
JNZ 0x0010159d
JMP 0x00101559
LAB_00101b10:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x001015d7
MOV RBP,qword ptr [RBP + 0x10]
MOV R14D,0x1
TEST RBP,RBP
JNZ 0x001015f6
MOV R13,qword ptr [R13 + 0x10]
MOV EBP,0x2
TEST R13,R13
JNZ 0x00101646
JMP 0x001016d9
LAB_00101b50:
MOV R12,qword ptr [RDI + 0x10]
MOV EAX,0x2
MOV EBP,0x1
TEST R12,R12
JNZ 0x001016fa
JMP 0x00101578
LAB_00101b70:
ADD EAX,0x1
JMP 0x0010156d
LAB_00101b80:
ADD EAX,0x1
JMP 0x001019a6
LAB_00101b90:
ADD EAX,0x1
JMP 0x00101551
LAB_00101ba0:
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x1
TEST R13,R13
JZ 0x00101551
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JNZ 0x00101653
LAB_00101bbf:
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x1
TEST R13,R13
JNZ 0x00101692
JMP 0x001016d1
LAB_00101be0:
MOV RBX,qword ptr [RBX + 0x10]
TEST RBX,RBX
JNZ 0x001017b3
MOV R13,qword ptr [R12 + 0x10]
MOV EAX,0x2
TEST R13,R13
JZ 0x0010156d
MOV EBX,0x1
JMP 0x0010185f
LAB_00101c10:
MOV R12,qword ptr [R12 + 0x10]
TEST R12,R12
JNZ 0x001014a8
MOV R13,qword ptr [RBP + 0x10]
MOV R12D,0x1
TEST R13,R13
JNZ 0x0010159d
MOV R12,qword ptr [RDI + 0x10]
MOV EBP,0x2
TEST R12,R12
JNZ 0x001016fa
JMP 0x00101575
LAB_00101c50:
MOV R13,qword ptr [R13 + 0x10]
TEST R13,R13
JNZ 0x00101455
MOV R12,qword ptr [R12 + 0x10]
MOV R13D,0x1
TEST R12,R12
JNZ 0x001014a8
MOV R13,qword ptr [RBP + 0x10]
MOV R12D,0x2
TEST R13,R13
JNZ 0x0010159d
MOV R12,qword ptr [RDI + 0x10]
MOV EBP,0x3
TEST R12,R12
JNZ 0x001016fa
JMP 0x00101575
LAB_00101ca0:
MOV R13,qword ptr [R13 + 0x10]
TEST R13,R13
JNZ 0x00101761
MOV RBX,qword ptr [RBX + 0x10]
MOV R13D,0x1
TEST RBX,RBX
JNZ 0x001017b3
MOV R13,qword ptr [R12 + 0x10]
MOV EBX,0x2
TEST R13,R13
JNZ 0x0010185f
JMP 0x001019ae
LAB_00101ce0:
MOV RBX,qword ptr [RBX + 0x10]
MOV EDX,0x1
TEST RBX,RBX
JNZ 0x001017ff
JMP 0x00101840
LAB_00101d00:
MOV RBP,qword ptr [RBP + 0x10]
TEST RBP,RBP
JNZ 0x001015f6
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x2
TEST R13,R13
JZ 0x00101551
MOV EBP,0x1
JMP 0x00101646
LAB_00101d30:
MOV R12,qword ptr [R12 + 0x10]
TEST R12,R12
JNZ 0x001018ba
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x2
TEST R13,R13
JZ 0x001019a6
MOV R12D,0x1
JMP 0x0010190d
LAB_00101d60:
MOV R12,qword ptr [R12 + 0x10]
MOV EAX,0x1
TEST R12,R12
JNZ 0x001014f6
JMP 0x00101537
LAB_00101d80:
MOV RDI,qword ptr [R13 + 0x10]
MOV EAX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101781
JMP 0x00101795
LAB_00101da0:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x001014d6
MOV R12,qword ptr [R12 + 0x10]
MOV EAX,0x2
TEST R12,R12
JZ 0x00101537
MOV R14D,0x1
JMP 0x001014f6
LAB_00101dd0:
MOV RDI,qword ptr [R12 + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101518
JMP 0x0010152a
LAB_00101df0:
MOV RDI,qword ptr [R13 + 0x10]
MOV EAX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101475
JMP 0x00101489
LAB_00101e10:
MOV RDI,qword ptr [R13 + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101979
JMP 0x0010198b
LAB_00101e30:
MOV RDI,qword ptr [R12 + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x001018dc
JMP 0x001018ee
LAB_00101e50:
MOV RDI,qword ptr [RBX + 0x10]
MOV EAX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x0010181f
JMP 0x00101833
LAB_00101e70:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x001017e0
MOV RBX,qword ptr [RBX + 0x10]
MOV EDX,0x2
TEST RBX,RBX
JZ 0x00101840
MOV R14D,0x1
JMP 0x001017ff
LAB_00101ea0:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x0010193a
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x2
TEST R13,R13
JZ 0x00101998
MOV R14D,0x1
JMP 0x00101959
LAB_00101ed0:
MOV RDI,qword ptr [RBP + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101616
JMP 0x00101628
LAB_00101ef0:
MOV RDI,qword ptr [R13 + 0x10]
MOV EDX,0x1
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x001016b2
JMP 0x001016c4
LAB_00101f10:
MOV RDI,qword ptr [R14 + 0x10]
XOR R15D,R15D
TEST RDI,RDI
JNZ 0x00101673
MOV R13,qword ptr [R13 + 0x10]
MOV EAX,0x2
TEST R13,R13
JZ 0x001016d1
MOV R14D,0x1
JMP 0x00101692 | int func0_part_0(long param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
lVar10 = *(long *)(param_1 + 8);
if (lVar10 == 0) {
lVar10 = *(long *)(param_1 + 0x10);
iVar2 = 1;
iVar3 = 0;
joined_r0x001016f4:
if (lVar10 == 0) {
return iVar2;
}
LAB_001016fa:
iVar2 = iVar3;
lVar9 = *(long *)(lVar10 + 8);
if (lVar9 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 1;
if (lVar10 == 0) goto LAB_0010156d;
lVar9 = *(long *)(lVar10 + 8);
iVar4 = 0;
iVar3 = 0;
if (lVar9 != 0) goto LAB_0010186c;
LAB_001019f0:
iVar4 = iVar3;
iVar3 = (int)lVar9;
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 1;
if (lVar10 == 0) goto LAB_001019a6;
lVar9 = *(long *)(lVar10 + 8);
if (lVar9 == 0) goto LAB_00101a0b;
LAB_0010191a:
if (*(long *)(lVar9 + 8) == 0) {
iVar5 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_0010193a;
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 2;
if (lVar10 == 0) goto LAB_00101998;
iVar6 = 1;
LAB_00101959:
if (*(long *)(lVar10 + 8) == 0) {
iVar7 = 1;
iVar5 = 0;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_00101979;
}
else {
iVar5 = func0_part_0();
iVar8 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_00101979:
iVar8 = func0_part_0();
}
iVar7 = iVar5 + 1;
if (iVar5 <= iVar8) {
iVar7 = iVar8 + 1;
}
}
}
else {
iVar5 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
LAB_0010193a:
iVar6 = func0_part_0();
}
lVar10 = *(long *)(lVar10 + 0x10);
if (iVar6 < iVar5) {
iVar6 = iVar5;
}
iVar6 = iVar6 + 1;
iVar7 = 0;
if (lVar10 != 0) goto LAB_00101959;
}
iVar5 = iVar6 + 1;
if (iVar6 <= iVar7) {
iVar5 = iVar7 + 1;
}
LAB_00101998:
if (iVar5 < iVar3) {
LAB_001019a1:
iVar5 = iVar3 + 1;
}
else {
iVar5 = iVar5 + 1;
}
LAB_001019a6:
if (iVar4 <= iVar5) {
iVar4 = iVar5 + 1;
goto LAB_0010156d;
}
}
else {
lVar11 = *(long *)(lVar9 + 8);
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 0;
if (lVar9 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 2;
if (lVar10 == 0) goto LAB_0010156d;
iVar3 = 1;
LAB_0010185f:
lVar9 = *(long *)(lVar10 + 8);
iVar4 = iVar3;
if (lVar9 == 0) goto LAB_001019f0;
LAB_0010186c:
lVar11 = *(long *)(lVar9 + 8);
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
if (lVar9 != 0) {
LAB_001018ba:
if (*(long *)(lVar9 + 8) == 0) {
iVar5 = 1;
iVar6 = 0;
if (*(long *)(lVar9 + 0x10) == 0) goto LAB_001018ee;
LAB_001018dc:
iVar7 = func0_part_0();
}
else {
iVar6 = func0_part_0();
iVar7 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_001018dc;
}
iVar5 = iVar6 + 1;
if (iVar6 <= iVar7) {
iVar5 = iVar7 + 1;
}
goto LAB_001018ee;
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 2;
if (lVar10 == 0) goto LAB_001019a6;
iVar6 = 1;
LAB_0010190d:
iVar3 = iVar6;
lVar9 = *(long *)(lVar10 + 8);
if (lVar9 != 0) goto LAB_0010191a;
LAB_00101a0b:
iVar6 = (int)lVar9;
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 1;
if (lVar10 != 0) goto LAB_00101959;
goto LAB_00101998;
}
if (*(long *)(lVar11 + 8) != 0) {
iVar5 = func0_part_0();
iVar3 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_0010189a;
LAB_0010189f:
lVar9 = *(long *)(lVar9 + 0x10);
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
iVar3 = iVar3 + 1;
iVar5 = 0;
if (lVar9 != 0) goto LAB_001018ba;
LAB_001018ee:
lVar10 = *(long *)(lVar10 + 0x10);
if (iVar3 <= iVar5) {
iVar3 = iVar5;
}
iVar3 = iVar3 + 1;
iVar5 = 0;
iVar6 = iVar3;
if (lVar10 != 0) goto LAB_0010190d;
goto LAB_00101998;
}
iVar5 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_0010189a:
iVar3 = func0_part_0();
goto LAB_0010189f;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 1;
if (lVar9 != 0) goto LAB_001018ba;
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 2;
iVar6 = 2;
if (lVar10 != 0) goto LAB_0010190d;
goto LAB_001019a1;
}
LAB_001017b3:
lVar11 = *(long *)(lVar9 + 8);
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 1;
iVar5 = 0;
if (lVar9 != 0) goto LAB_001017ff;
}
else {
if (*(long *)(lVar11 + 8) == 0) {
iVar3 = 0;
if (*(long *)(lVar11 + 0x10) == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 2;
if (lVar9 != 0) {
iVar5 = 1;
goto LAB_001017ff;
}
goto LAB_00101840;
}
LAB_001017e0:
iVar5 = func0_part_0();
}
else {
iVar3 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_001017e0;
}
lVar9 = *(long *)(lVar9 + 0x10);
if (iVar5 < iVar3) {
iVar5 = iVar3;
}
iVar5 = iVar5 + 1;
iVar6 = 0;
if (lVar9 != 0) {
LAB_001017ff:
if (*(long *)(lVar9 + 8) == 0) {
iVar6 = 1;
iVar3 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_0010181f;
}
else {
iVar3 = func0_part_0();
iVar7 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
LAB_0010181f:
iVar7 = func0_part_0();
}
iVar6 = iVar7 + 1;
if (iVar7 < iVar3) {
iVar6 = iVar3 + 1;
}
}
}
iVar3 = iVar5 + 1;
if (iVar5 <= iVar6) {
iVar3 = iVar6 + 1;
}
}
LAB_00101840:
lVar10 = *(long *)(lVar10 + 0x10);
if (iVar4 <= iVar3) {
iVar4 = iVar3;
}
iVar4 = iVar4 + 1;
iVar5 = 0;
iVar3 = iVar4;
if (lVar10 != 0) goto LAB_0010185f;
goto LAB_001019a6;
}
lVar1 = *(long *)(lVar11 + 8);
if (lVar1 != 0) {
if (*(long *)(lVar1 + 8) == 0) {
iVar3 = 0;
if (*(long *)(lVar1 + 0x10) == 0) {
lVar11 = *(long *)(lVar11 + 0x10);
iVar5 = 1;
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 2;
if (lVar9 != 0) goto LAB_001017b3;
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 3;
iVar4 = 3;
goto joined_r0x00101a6b;
}
goto LAB_00101761;
}
LAB_00101742:
iVar5 = func0_part_0();
}
else {
iVar3 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar1 + 0x10) != 0) goto LAB_00101742;
}
lVar11 = *(long *)(lVar11 + 0x10);
if (iVar5 < iVar3) {
iVar5 = iVar3;
}
iVar5 = iVar5 + 1;
iVar4 = 0;
if (lVar11 != 0) goto LAB_00101761;
LAB_00101795:
lVar9 = *(long *)(lVar9 + 0x10);
if (iVar4 < iVar5) {
iVar4 = iVar5;
}
iVar4 = iVar4 + 1;
iVar3 = 0;
if (lVar9 != 0) goto LAB_001017b3;
goto LAB_00101840;
}
lVar11 = *(long *)(lVar11 + 0x10);
iVar5 = 0;
if (lVar11 != 0) {
LAB_00101761:
if (*(long *)(lVar11 + 8) == 0) {
iVar4 = 1;
iVar3 = 0;
if (*(long *)(lVar11 + 0x10) == 0) goto LAB_00101795;
LAB_00101781:
iVar6 = func0_part_0();
}
else {
iVar3 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_00101781;
}
iVar4 = iVar6 + 1;
if (iVar6 < iVar3) {
iVar4 = iVar3 + 1;
}
goto LAB_00101795;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 1;
if (lVar9 != 0) goto LAB_001017b3;
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 2;
iVar4 = 2;
joined_r0x00101a6b:
if (lVar10 != 0) goto LAB_0010185f;
}
iVar4 = iVar4 + 1;
if (iVar2 <= iVar4) {
LAB_001019b9:
return iVar4 + 1;
}
}
else {
lVar9 = *(long *)(lVar10 + 8);
if (lVar9 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 0;
if (lVar10 == 0) {
lVar10 = *(long *)(param_1 + 0x10);
iVar2 = 2;
iVar3 = 1;
goto joined_r0x001016f4;
}
LAB_0010159d:
iVar4 = iVar3;
lVar9 = *(long *)(lVar10 + 8);
if (lVar9 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar2 = 1;
if (lVar10 == 0) goto LAB_00101551;
lVar9 = *(long *)(lVar10 + 8);
iVar2 = 0;
iVar3 = 0;
if (lVar9 == 0) goto LAB_00101bbf;
LAB_00101653:
if (*(long *)(lVar9 + 8) == 0) {
iVar5 = 0;
if (*(long *)(lVar9 + 0x10) == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 2;
if (lVar10 == 0) goto LAB_001016d1;
iVar3 = 1;
goto LAB_00101692;
}
LAB_00101673:
iVar3 = func0_part_0();
}
else {
iVar5 = func0_part_0();
iVar3 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_00101673;
}
lVar10 = *(long *)(lVar10 + 0x10);
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
iVar3 = iVar3 + 1;
iVar6 = 0;
if (lVar10 != 0) {
LAB_00101692:
if (*(long *)(lVar10 + 8) == 0) {
iVar6 = 1;
iVar5 = 0;
if (*(long *)(lVar10 + 0x10) != 0) goto LAB_001016b2;
}
else {
iVar5 = func0_part_0();
iVar7 = 0;
if (*(long *)(lVar10 + 0x10) != 0) {
LAB_001016b2:
iVar7 = func0_part_0();
}
iVar6 = iVar5 + 1;
if (iVar5 <= iVar7) {
iVar6 = iVar7 + 1;
}
}
}
iVar5 = iVar3 + 1;
if (iVar3 <= iVar6) {
iVar5 = iVar6 + 1;
}
LAB_001016d1:
if (iVar2 <= iVar5) {
iVar2 = iVar5 + 1;
goto LAB_00101551;
}
}
else {
lVar11 = *(long *)(lVar9 + 8);
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar2 = 0;
if (lVar9 != 0) {
LAB_001015f6:
if (*(long *)(lVar9 + 8) == 0) {
iVar3 = 1;
iVar5 = 0;
if (*(long *)(lVar9 + 0x10) == 0) goto LAB_00101628;
LAB_00101616:
iVar6 = func0_part_0();
}
else {
iVar5 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_00101616;
}
iVar3 = iVar5 + 1;
if (iVar5 <= iVar6) {
iVar3 = iVar6 + 1;
}
goto LAB_00101628;
}
lVar10 = *(long *)(lVar10 + 0x10);
iVar2 = 2;
if (lVar10 == 0) goto LAB_00101551;
iVar3 = 1;
LAB_00101646:
lVar9 = *(long *)(lVar10 + 8);
iVar2 = iVar3;
if (lVar9 != 0) goto LAB_00101653;
LAB_00101bbf:
iVar2 = iVar3;
iVar3 = (int)lVar9;
lVar10 = *(long *)(lVar10 + 0x10);
iVar5 = 1;
if (lVar10 == 0) goto LAB_001016d1;
goto LAB_00101692;
}
if (*(long *)(lVar11 + 8) != 0) {
iVar3 = func0_part_0();
iVar2 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_001015d7;
LAB_001015dc:
lVar9 = *(long *)(lVar9 + 0x10);
if (iVar2 < iVar3) {
iVar2 = iVar3;
}
iVar2 = iVar2 + 1;
iVar3 = 0;
if (lVar9 != 0) goto LAB_001015f6;
LAB_00101628:
lVar10 = *(long *)(lVar10 + 0x10);
if (iVar2 <= iVar3) {
iVar2 = iVar3;
}
iVar2 = iVar2 + 1;
iVar5 = 0;
iVar3 = iVar2;
if (lVar10 != 0) goto LAB_00101646;
goto LAB_001016d1;
}
iVar3 = 0;
if (*(long *)(lVar11 + 0x10) != 0) {
LAB_001015d7:
iVar2 = func0_part_0();
goto LAB_001015dc;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar2 = 1;
if (lVar9 != 0) goto LAB_001015f6;
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 2;
iVar2 = 2;
if (lVar10 != 0) goto LAB_00101646;
}
iVar2 = iVar2 + 1;
LAB_00101551:
if (iVar2 < iVar4) goto LAB_00101559;
}
else {
lVar11 = *(long *)(lVar9 + 8);
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar2 = 0;
if (lVar9 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 1;
if (lVar10 != 0) goto LAB_0010159d;
lVar10 = *(long *)(param_1 + 0x10);
iVar3 = 2;
iVar2 = 2;
joined_r0x00101c90:
if (lVar10 == 0) goto LAB_00101575;
goto LAB_001016fa;
}
LAB_001014a8:
lVar11 = *(long *)(lVar9 + 8);
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 1;
iVar3 = 0;
if (lVar9 == 0) goto LAB_00101537;
LAB_001014f6:
if (*(long *)(lVar9 + 8) == 0) {
iVar5 = 1;
iVar4 = 0;
if (*(long *)(lVar9 + 0x10) != 0) goto LAB_00101518;
}
else {
iVar4 = func0_part_0();
iVar6 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
LAB_00101518:
iVar6 = func0_part_0();
}
iVar5 = iVar4 + 1;
if (iVar4 <= iVar6) {
iVar5 = iVar6 + 1;
}
}
}
else {
if (*(long *)(lVar11 + 8) == 0) {
iVar4 = 0;
if (*(long *)(lVar11 + 0x10) == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 2;
if (lVar9 != 0) {
iVar3 = 1;
goto LAB_001014f6;
}
goto LAB_00101537;
}
LAB_001014d6:
iVar3 = func0_part_0();
}
else {
iVar4 = func0_part_0();
iVar3 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_001014d6;
}
lVar9 = *(long *)(lVar9 + 0x10);
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
iVar3 = iVar3 + 1;
iVar5 = 0;
if (lVar9 != 0) goto LAB_001014f6;
}
iVar4 = iVar3 + 1;
if (iVar3 <= iVar5) {
iVar4 = iVar5 + 1;
}
LAB_00101537:
lVar10 = *(long *)(lVar10 + 0x10);
if (iVar4 < iVar2) {
iVar4 = iVar2;
}
iVar4 = iVar4 + 1;
iVar2 = 0;
iVar3 = iVar4;
if (lVar10 != 0) goto LAB_0010159d;
goto LAB_00101551;
}
lVar1 = *(long *)(lVar11 + 8);
if (lVar1 == 0) {
lVar11 = *(long *)(lVar11 + 0x10);
iVar3 = 0;
if (lVar11 == 0) {
lVar9 = *(long *)(lVar9 + 0x10);
iVar2 = 1;
if (lVar9 == 0) {
lVar10 = *(long *)(lVar10 + 0x10);
iVar3 = 2;
if (lVar10 != 0) goto LAB_0010159d;
lVar10 = *(long *)(param_1 + 0x10);
iVar3 = 3;
iVar2 = 3;
goto joined_r0x00101c90;
}
goto LAB_001014a8;
}
LAB_00101455:
if (*(long *)(lVar11 + 8) == 0) {
iVar2 = 1;
iVar4 = 0;
if (*(long *)(lVar11 + 0x10) == 0) goto LAB_00101489;
LAB_00101475:
iVar5 = func0_part_0();
}
else {
iVar4 = func0_part_0();
iVar5 = 0;
if (*(long *)(lVar11 + 0x10) != 0) goto LAB_00101475;
}
iVar2 = iVar5 + 1;
if (iVar5 < iVar4) {
iVar2 = iVar4 + 1;
}
LAB_00101489:
lVar9 = *(long *)(lVar9 + 0x10);
if (iVar2 < iVar3) {
iVar2 = iVar3;
}
iVar2 = iVar2 + 1;
iVar4 = 0;
if (lVar9 != 0) goto LAB_001014a8;
goto LAB_00101537;
}
if (*(long *)(lVar1 + 8) != 0) {
iVar2 = func0_part_0();
iVar3 = 0;
if (*(long *)(lVar1 + 0x10) != 0) goto LAB_00101436;
LAB_0010143b:
lVar11 = *(long *)(lVar11 + 0x10);
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
iVar3 = iVar3 + 1;
iVar2 = 0;
if (lVar11 != 0) goto LAB_00101455;
goto LAB_00101489;
}
iVar2 = 0;
if (*(long *)(lVar1 + 0x10) != 0) {
LAB_00101436:
iVar3 = func0_part_0();
goto LAB_0010143b;
}
lVar11 = *(long *)(lVar11 + 0x10);
iVar3 = 1;
if (lVar11 != 0) goto LAB_00101455;
lVar9 = *(long *)(lVar9 + 0x10);
iVar2 = 2;
if (lVar9 != 0) goto LAB_001014a8;
lVar10 = *(long *)(lVar10 + 0x10);
iVar4 = 3;
iVar3 = 3;
if (lVar10 != 0) goto LAB_0010159d;
LAB_00101559:
iVar2 = iVar4;
}
iVar2 = iVar2 + 1;
lVar10 = *(long *)(param_1 + 0x10);
iVar4 = 0;
iVar3 = iVar2;
if (lVar10 != 0) goto LAB_001016fa;
LAB_0010156d:
if (iVar2 <= iVar4) goto LAB_001019b9;
}
LAB_00101575:
return iVar2 + 1;
} |
7,604 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0xc(%rbp),%rsi
lea -0x10(%rbp),%rcx
lea -0x14(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rsi,%r8
lea 0xe06(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10c0 <__isoc99_sscanf@plt>
mov -0x14(%rbp),%ecx
mov -0x10(%rbp),%edx
mov -0xc(%rbp),%eax
mov %ecx,%r8d
mov %edx,%ecx
mov %eax,%edx
lea 0xdeb(%rip),%rsi
lea 0x2deb(%rip),%rdi
mov $0x0,%eax
callq 10d0 <sprintf@plt>
lea 0x2dda(%rip),%rax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
je 1252 <func0+0x89>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rsi, [rbp+var_C]
lea rcx, [rbp+var_10]
lea rdx, [rbp+var_14]
mov rax, [rbp+var_28]
mov r8, rsi
lea rsi, aDDD; "%d-%d-%d"
mov rdi, rax
mov eax, 0
call ___isoc99_sscanf
mov ecx, [rbp+var_14]
mov edx, [rbp+var_10]
mov eax, [rbp+var_C]
mov r8d, ecx
mov ecx, edx
mov edx, eax
lea rax, format; "%02d-%02d-%d"
mov rsi, rax; format
lea rax, new_format_1
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, new_format_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1258
call ___stack_chk_fail
locret_1258:
leave
retn | char * func0(long long a1)
{
int v2; // [rsp+1Ch] [rbp-14h] BYREF
int v3; // [rsp+20h] [rbp-10h] BYREF
int v4; // [rsp+24h] [rbp-Ch] BYREF
unsigned long long v5; // [rsp+28h] [rbp-8h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
sprintf(new_format_1, "%02d-%02d-%d", v4, v3, v2);
return new_format_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RSI,[RBP + -0xc]
LEA RCX,[RBP + -0x10]
LEA RDX,[RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8,RSI
LEA RSI,[0x102008]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010c0
MOV ECX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0xc]
MOV R8D,ECX
MOV ECX,EDX
MOV EDX,EAX
LEA RAX,[0x102011]
MOV RSI,RAX
LEA RAX,[0x104018]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010d0
LEA RAX,[0x104018]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101258
CALL 0x00101090
LAB_00101258:
LEAVE
RET | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
uint local_1c;
uint local_18;
uint local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
sprintf(new_format_1,"%02d-%02d-%d",(ulong)local_14,(ulong)local_18,(ulong)local_1c);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return new_format_1;
} |
7,605 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x20,%rsp
mov $0x28,%ebx
mov %fs:(%rbx),%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rcx
lea 0xc(%rsp),%rdx
lea 0x14(%rsp),%r8
lea 0xe2c(%rip),%rsi
callq 10a0 <__isoc99_sscanf@plt>
sub $0x8,%rsp
mov 0x14(%rsp),%eax
push %rax
mov 0x20(%rsp),%r9d
mov 0x24(%rsp),%r8d
lea 0xe16(%rip),%rcx
mov $0xb,%edx
mov $0x1,%esi
lea 0x2e10(%rip),%rdi
mov $0x0,%eax
callq 10b0 <__sprintf_chk@plt>
add $0x10,%rsp
mov 0x18(%rsp),%rax
xor %fs:(%rbx),%rax
jne 122e <func0+0x85>
lea 0x2df0(%rip),%rax
add $0x20,%rsp
pop %rbx
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
lea rcx, [rsp+28h+var_18]
lea rdx, [rsp+28h+var_1C]
lea r8, [rsp+28h+var_14]
lea rsi, aDDD; "%d-%d-%d"
call ___isoc99_sscanf
sub rsp, 8
mov eax, [rsp+30h+var_1C]
push rax
mov r9d, [rsp+38h+var_18]
mov r8d, [rsp+38h+var_14]
lea rcx, a02d02dD; "%02d-%02d-%d"
mov edx, 0Bh
mov esi, 1
lea rbx, new_format_1
mov rdi, rbx
mov eax, 0
call ___sprintf_chk
add rsp, 10h
mov rax, [rsp+28h+var_10]
sub rax, fs:28h
jnz short loc_1252
mov rax, rbx
add rsp, 20h
pop rbx
retn
loc_1252:
call ___stack_chk_fail | void * func0(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch] BYREF
int v3; // [rsp+10h] [rbp-18h] BYREF
int v4; // [rsp+14h] [rbp-14h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-10h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
__sprintf_chk(&new_format_1, 1LL, 11LL, "%02d-%02d-%d", v4, v3, v2);
return &new_format_1;
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA R8,[RSP + 0x14]
LEA RSI,[0x102004]
CALL 0x001010c0
SUB RSP,0x8
MOV EAX,dword ptr [RSP + 0x14]
PUSH RAX
MOV R9D,dword ptr [RSP + 0x20]
MOV R8D,dword ptr [RSP + 0x24]
LEA RCX,[0x10200d]
MOV EDX,0xb
MOV ESI,0x1
LEA RBX,[0x104018]
MOV RDI,RBX
MOV EAX,0x0
CALL 0x001010d0
ADD RSP,0x10
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101252
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
LAB_00101252:
CALL 0x00101090 | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
int4 local_1c;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
__sprintf_chk(new_format_1,1,0xb,"%02d-%02d-%d",local_14,local_18,local_1c);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return new_format_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,606 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x28,%rsp
lea 0xd65(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rcx
lea 0xc(%rsp),%rdx
lea 0x14(%rsp),%r8
callq 10a0 <__isoc99_sscanf@plt>
sub $0x8,%rsp
mov $0xb,%edx
lea 0xd3a(%rip),%rcx
mov 0x14(%rsp),%eax
mov $0x1,%esi
lea 0x2d35(%rip),%rdi
push %rax
mov 0x20(%rsp),%r9d
xor %eax,%eax
mov 0x24(%rsp),%r8d
callq 10b0 <__sprintf_chk@plt>
pop %rax
pop %rdx
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1313 <func0+0x83>
lea 0x2d0a(%rip),%rax
add $0x28,%rsp
retq
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
lea rsi, aDDD; "%d-%d-%d"
lea r12, new_format_1
sub rsp, 20h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
lea rcx, [rsp+28h+var_18]
lea rdx, [rsp+28h+var_1C]
lea r8, [rsp+28h+var_14]
call ___isoc99_sscanf
sub rsp, 8
mov edx, 0Bh
mov rdi, r12
mov eax, [rsp+30h+var_1C]
lea rcx, a02d02dD; "%02d-%02d-%d"
mov esi, 1
push rax
mov r9d, [rsp+38h+var_18]
xor eax, eax
mov r8d, [rsp+38h+var_14]
call ___sprintf_chk
pop rax
pop rdx
mov rax, [rsp+28h+var_10]
sub rax, fs:28h
jnz short loc_1326
add rsp, 20h
mov rax, r12
pop r12
retn
loc_1326:
call ___stack_chk_fail | void * func0(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch] BYREF
int v3; // [rsp+10h] [rbp-18h] BYREF
int v4; // [rsp+14h] [rbp-14h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-10h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
__sprintf_chk(&new_format_1, 1LL, 11LL, "%02d-%02d-%d", v4, v3, v2);
return &new_format_1;
} | func0:
ENDBR64
PUSH R12
LEA RSI,[0x102004]
LEA R12,[0x104018]
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA R8,[RSP + 0x14]
CALL 0x001010c0
SUB RSP,0x8
MOV EDX,0xb
MOV RDI,R12
MOV EAX,dword ptr [RSP + 0x14]
LEA RCX,[0x10200d]
MOV ESI,0x1
PUSH RAX
MOV R9D,dword ptr [RSP + 0x20]
XOR EAX,EAX
MOV R8D,dword ptr [RSP + 0x24]
CALL 0x001010d0
POP RAX
POP RDX
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101326
ADD RSP,0x20
MOV RAX,R12
POP R12
RET
LAB_00101326:
CALL 0x00101090 | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
int4 local_1c;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
__sprintf_chk(new_format_1,1,0xb,"%02d-%02d-%d",local_14,local_18,local_1c);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return new_format_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,607 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x28,%rsp
lea 0xd65(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rcx
lea 0xc(%rsp),%rdx
lea 0x14(%rsp),%r8
callq 10a0 <__isoc99_sscanf@plt>
sub $0x8,%rsp
mov $0xb,%edx
lea 0xd3a(%rip),%rcx
mov 0x14(%rsp),%eax
mov $0x1,%esi
lea 0x2d35(%rip),%rdi
push %rax
mov 0x20(%rsp),%r9d
xor %eax,%eax
mov 0x24(%rsp),%r8d
callq 10b0 <__sprintf_chk@plt>
pop %rax
pop %rdx
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1313 <func0+0x83>
lea 0x2d0a(%rip),%rax
add $0x28,%rsp
retq
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
lea rsi, aDDD; "%d-%d-%d"
lea rbx, new_format_1
sub rsp, 20h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
lea rcx, [rsp+28h+var_18]
lea rdx, [rsp+28h+var_1C]
lea r8, [rsp+28h+var_14]
call ___isoc99_sscanf
sub rsp, 8
mov edx, 0Bh
mov rdi, rbx
mov eax, [rsp+30h+var_1C]
lea rcx, a02d02dD; "%02d-%02d-%d"
mov esi, 2
push rax
mov r9d, [rsp+38h+var_18]
xor eax, eax
mov r8d, [rsp+38h+var_14]
call ___sprintf_chk
pop rax
pop rdx
mov rax, [rsp+28h+var_10]
sub rax, fs:28h
jnz short loc_1324
add rsp, 20h
mov rax, rbx
pop rbx
retn
loc_1324:
call ___stack_chk_fail | void * func0(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch] BYREF
int v3; // [rsp+10h] [rbp-18h] BYREF
int v4; // [rsp+14h] [rbp-14h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-10h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
__sprintf_chk(&new_format_1, 2LL, 11LL, "%02d-%02d-%d", v4, v3, v2);
return &new_format_1;
} | func0:
ENDBR64
PUSH RBX
LEA RSI,[0x102004]
LEA RBX,[0x104018]
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA R8,[RSP + 0x14]
CALL 0x001010c0
SUB RSP,0x8
MOV EDX,0xb
MOV RDI,RBX
MOV EAX,dword ptr [RSP + 0x14]
LEA RCX,[0x10200d]
MOV ESI,0x2
PUSH RAX
MOV R9D,dword ptr [RSP + 0x20]
XOR EAX,EAX
MOV R8D,dword ptr [RSP + 0x24]
CALL 0x001010d0
POP RAX
POP RDX
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101324
ADD RSP,0x20
MOV RAX,RBX
POP RBX
RET
LAB_00101324:
CALL 0x00101090 | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
int4 local_1c;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
__sprintf_chk(new_format_1,2,0xb,"%02d-%02d-%d",local_14,local_18,local_1c);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return new_format_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,608 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ae <func0+0x45>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jne 11aa <func0+0x41>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AE
loc_118B:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jnz short loc_11AA
add [rbp+var_8], 1
loc_11AA:
add [rbp+var_4], 1
loc_11AE:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118B
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( a3 == *(_DWORD *)(4LL * i + a1) )
++v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ae
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JNZ 0x001011aa
ADD dword ptr [RBP + -0x8],0x1
LAB_001011aa:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ae:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (param_3 == *(int *)(param_1 + (long)local_c * 4)) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
7,609 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1199 <func0+0x30>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rdi
mov $0x0,%ecx
cmp %edx,(%rax)
sete %sil
movzbl %sil,%esi
add %esi,%ecx
add $0x4,%rax
cmp %rdi,%rax
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1196 <func0+0x2d>
| func0:
endbr64
test esi, esi
jle short loc_1199
mov rax, rdi
lea ecx, [rsi-1]
lea rdi, [rdi+rcx*4+4]
mov ecx, 0
loc_1181:
cmp [rax], edx
setz sil
movzx esi, sil
add ecx, esi
add rax, 4
cmp rax, rdi
jnz short loc_1181
loc_1196:
mov eax, ecx
retn
loc_1199:
mov ecx, 0
jmp short loc_1196 | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
long long v4; // rdi
unsigned int v5; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
v5 += *v3++ == a3;
while ( v3 != (_DWORD *)v4 );
}
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101199
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RDI,[RDI + RCX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
CMP dword ptr [RAX],EDX
SETZ SIL
MOVZX ESI,SIL
ADD ECX,ESI
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101181
LAB_00101196:
MOV EAX,ECX
RET
LAB_00101199:
MOV ECX,0x0
JMP 0x00101196 | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 == param_3);
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,610 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1340 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
cmp %edx,(%rdi)
sete %cl
add $0x4,%rdi
add %ecx,%eax
cmp %rsi,%rdi
jne 1328 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1340
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1328:
xor ecx, ecx
cmp [rdi], edx
setz cl
add rdi, 4
add eax, ecx
cmp rdi, rsi
jnz short loc_1328
retn
loc_1340:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long v3; // rsi
long long result; // rax
BOOL v5; // ecx
if ( a2 <= 0 )
return 0LL;
v3 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v5 = *a1++ == a3;
result = (unsigned int)(v5 + result);
}
while ( a1 != (_DWORD *)v3 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101340
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101328:
XOR ECX,ECX
CMP dword ptr [RDI],EDX
SETZ CL
ADD RDI,0x4
ADD EAX,ECX
CMP RDI,RSI
JNZ 0x00101328
RET
LAB_00101340:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 + (uint)(iVar2 == param_3);
} while (param_1 != piVar1);
return iVar3;
}
return 0;
} |
7,611 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13a8 <func0+0xe8>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 13ab <func0+0xeb>
mov %esi,%ecx
movd %edx,%xmm3
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%ecx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax)
movdqu (%rax),%xmm1
add $0x10,%rax
pcmpeqd %xmm2,%xmm1
psubd %xmm1,%xmm0
cmp %rcx,%rax
jne 12f8 <func0+0x38>
movdqa %xmm0,%xmm1
mov %esi,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 1388 <func0+0xc8>
movslq %ecx,%r8
cmp %edx,(%rdi,%r8,4)
je 1378 <func0+0xb8>
lea 0x1(%rcx),%r8d
cmp %esi,%r8d
jge 1372 <func0+0xb2>
movslq %r8d,%r8
cmp (%rdi,%r8,4),%edx
je 1380 <func0+0xc0>
lea 0x2(%rcx),%r8d
cmp %r8d,%esi
jle 1372 <func0+0xb2>
movslq %r8d,%r8
cmp (%rdi,%r8,4),%edx
je 1390 <func0+0xd0>
add $0x3,%ecx
cmp %ecx,%esi
jle 1372 <func0+0xb2>
movslq %ecx,%rcx
cmp (%rdi,%rcx,4),%edx
je 13a0 <func0+0xe0>
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%eax
jmp 133f <func0+0x7f>
nopl (%rax)
add $0x1,%eax
jmp 1351 <func0+0x91>
nopl (%rax)
retq
nopl 0x0(%rax)
add $0x3,%ecx
add $0x1,%eax
cmp %ecx,%esi
jg 136a <func0+0xaa>
jmp 1372 <func0+0xb2>
nopl 0x0(%rax)
add $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 1336 <func0+0x76>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle loc_1210
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1213
mov ecx, esi
movd xmm3, edx
pxor xmm0, xmm0
mov rax, rdi
shr ecx, 2
pshufd xmm2, xmm3, 0
shl rcx, 4
add rcx, rdi
nop dword ptr [rax+00h]
loc_1178:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm1, xmm2
psubd xmm0, xmm1
cmp rcx, rax
jnz short loc_1178
movdqa xmm1, xmm0
mov ecx, esi
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short locret_1200
loc_11B6:
movsxd r8, ecx
lea r9, ds:0[r8*4]
cmp [rdi+r8*4], edx
jz short loc_11F0
loc_11C7:
lea r8d, [rcx+1]
cmp esi, r8d
jle short locret_11E5
cmp edx, [rdi+r9+4]
jz short loc_11F8
loc_11D7:
add ecx, 2
cmp esi, ecx
jle short locret_11E5
cmp edx, [rdi+r9+8]
jz short loc_1208
locret_11E5:
retn
loc_11F0:
add eax, 1
jmp short loc_11C7
loc_11F8:
add eax, 1
jmp short loc_11D7
locret_1200:
retn
loc_1208:
add eax, 1
retn
loc_1210:
xor eax, eax
retn
loc_1213:
xor ecx, ecx
xor eax, eax
jmp short loc_11B6 | long long func0(const __m128i *a1, int a2, unsigned int a3)
{
__m128i v3; // xmm0
const __m128i *v4; // rax
__m128i v5; // xmm2
__m128i v6; // xmm1
int v7; // ecx
__m128i v8; // xmm0
long long result; // rax
long long v10; // r9
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v7 = 0;
result = 0LL;
}
else
{
v3 = 0LL;
v4 = a1;
v5 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a3), 0);
do
{
v6 = _mm_loadu_si128(v4++);
v3 = _mm_sub_epi32(v3, _mm_cmpeq_epi32(v6, v5));
}
while ( &a1[(unsigned int)a2 >> 2] != v4 );
v7 = a2 & 0x7FFFFFFC;
v8 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v8, _mm_srli_si128(v8, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v10 = v7;
if ( a1->m128i_i32[v10] == a3 )
result = (unsigned int)(result + 1);
if ( a2 > v7 + 1 )
{
if ( a3 == a1->m128i_i32[v10 + 1] )
result = (unsigned int)(result + 1);
if ( a2 > v7 + 2 && a3 == a1->m128i_i32[v10 + 2] )
return (unsigned int)(result + 1);
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101210
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101213
MOV ECX,ESI
MOVD XMM3,EDX
PXOR XMM0,XMM0
MOV RAX,RDI
SHR ECX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RCX,0x4
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RCX,RAX
JNZ 0x00101178
MOVDQA XMM1,XMM0
MOV ECX,ESI
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x00101200
LAB_001011b6:
MOVSXD R8,ECX
LEA R9,[R8*0x4]
CMP dword ptr [RDI + R8*0x4],EDX
JZ 0x001011f0
LAB_001011c7:
LEA R8D,[RCX + 0x1]
CMP ESI,R8D
JLE 0x001011e5
CMP EDX,dword ptr [RDI + R9*0x1 + 0x4]
JZ 0x001011f8
LAB_001011d7:
ADD ECX,0x2
CMP ESI,ECX
JLE 0x001011e5
CMP EDX,dword ptr [RDI + R9*0x1 + 0x8]
JZ 0x00101208
LAB_001011e5:
RET
LAB_001011f0:
ADD EAX,0x1
JMP 0x001011c7
LAB_001011f8:
ADD EAX,0x1
JMP 0x001011d7
LAB_00101200:
RET
LAB_00101208:
ADD EAX,0x1
RET
LAB_00101210:
XOR EAX,EAX
RET
LAB_00101213:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x001011b6 | int func0(int *param_1,uint param_2,int param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
return 0;
}
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar7 = iVar7 + (uint)(iVar1 == param_3);
iVar8 = iVar8 + (uint)(*piVar2 == param_3);
iVar9 = iVar9 + (uint)(*piVar3 == param_3);
iVar10 = iVar10 + (uint)(*piVar4 == param_3);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != piVar5);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) {
return iVar7;
}
}
if (param_1[(int)uVar6] == param_3) {
iVar7 = iVar7 + 1;
}
if ((int)(uVar6 + 1) < (int)param_2) {
if (param_3 == param_1[(long)(int)uVar6 + 1]) {
iVar7 = iVar7 + 1;
}
if (((int)(uVar6 + 2) < (int)param_2) && (param_3 == param_1[(long)(int)uVar6 + 2])) {
return iVar7 + 1;
}
}
return iVar7;
} |
7,612 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found a match!";
} else if (ret == REG_NOMATCH) {
return "Not matched!";
} else {
return "Regex match failed";
}
}
| int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdf9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <regcomp@plt>
mov %eax,-0x5c(%rbp)
cmpl $0x0,-0x5c(%rbp)
je 123d <func0+0x54>
lea 0xdd2(%rip),%rax
jmp 1291 <func0+0xa8>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10f0 <regexec@plt>
mov %eax,-0x5c(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 10a0 <regfree@plt>
cmpl $0x0,-0x5c(%rbp)
jne 127b <func0+0x92>
lea 0xdaa(%rip),%rax
jmp 1291 <func0+0xa8>
cmpl $0x1,-0x5c(%rbp)
jne 128a <func0+0xa1>
lea 0xdaa(%rip),%rax
jmp 1291 <func0+0xa8>
lea 0xdae(%rip),%rax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 12a5 <func0+0xbc>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAb; "ab*?"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0
jz short loc_123D
lea rax, aErrorCompiling; "Error compiling regex"
jmp short loc_1291
loc_123D:
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_5C], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_5C], 0
jnz short loc_127B
lea rax, aFoundAMatch; "Found a match!"
jmp short loc_1291
loc_127B:
cmp [rbp+var_5C], 1
jnz short loc_128A
lea rax, s2; "Not matched!"
jmp short loc_1291
loc_128A:
lea rax, aRegexMatchFail; "Regex match failed"
loc_1291:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12A5
call ___stack_chk_fail
locret_12A5:
leave
retn | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "ab*?", 1) )
return "Error compiling regex";
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
if ( !v2 )
return "Found a match!";
if ( v2 == 1 )
return "Not matched!";
return "Regex match failed";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x0010123d
LEA RAX,[0x10200d]
JMP 0x00101291
LAB_0010123d:
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x5c],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001010a0
CMP dword ptr [RBP + -0x5c],0x0
JNZ 0x0010127b
LEA RAX,[0x102023]
JMP 0x00101291
LAB_0010127b:
CMP dword ptr [RBP + -0x5c],0x1
JNZ 0x0010128a
LEA RAX,[0x102032]
JMP 0x00101291
LAB_0010128a:
LEA RAX,[0x10203f]
LAB_00101291:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012a5
CALL 0x001010b0
LAB_001012a5:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"ab*?",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (iVar1 == 0) {
pcVar2 = "Found a match!";
}
else if (iVar1 == 1) {
pcVar2 = "Not matched!";
}
else {
pcVar2 = "Regex match failed";
}
}
else {
pcVar2 = "Error compiling regex";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,613 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found a match!";
} else if (ret == REG_NOMATCH) {
return "Not matched!";
} else {
return "Regex match failed";
}
}
| int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe54(%rip),%rsi
callq 10c0 <regcomp@plt>
mov %eax,%edx
lea 0xe1d(%rip),%rax
test %edx,%edx
je 121e <func0+0x55>
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1268 <func0+0x9f>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
mov %rsp,%rbp
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 1090 <regfree@plt>
lea 0xdb7(%rip),%rax
test %ebx,%ebx
je 1207 <func0+0x3e>
cmp $0x1,%ebx
lea 0xdb8(%rip),%rax
lea 0xdd4(%rip),%rdx
cmovne %rdx,%rax
jmp 1207 <func0+0x3e>
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aAb; "ab*?"
call _regcomp
mov edx, eax
lea rax, aErrorCompiling; "Error compiling regex"
test edx, edx
jz short loc_123E
loc_1227:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_1288
add rsp, 58h
pop rbx
pop rbp
retn
loc_123E:
mov rbp, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
lea rax, aFoundAMatch; "Found a match!"
test ebx, ebx
jz short loc_1227
cmp ebx, 1
lea rax, aNotMatched; "Not matched!"
lea rdx, aRegexMatchFail; "Regex match failed"
cmovnz rax, rdx
jmp short loc_1227
loc_1288:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "ab*?", 1LL);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(v4, a1, 0LL, 0LL, 0LL);
regfree(v4);
result = "Found a match!";
if ( v3 )
{
result = "Not matched!";
if ( v3 != 1 )
return "Regex match failed";
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102049]
CALL 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x0010123e
LAB_00101227:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101288
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_0010123e:
MOV RBP,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010f0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x001010a0
LEA RAX,[0x10201a]
TEST EBX,EBX
JZ 0x00101227
CMP EBX,0x1
LEA RAX,[0x102029]
LEA RDX,[0x102036]
CMOVNZ RAX,RDX
JMP 0x00101227
LAB_00101288:
CALL 0x001010b0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab*?",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!";
if ((iVar1 != 0) && (pcVar2 = "Not matched!", iVar1 != 1)) {
pcVar2 = "Regex match failed";
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,614 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found a match!";
} else if (ret == REG_NOMATCH) {
return "Not matched!";
} else {
return "Regex match failed";
}
}
| int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd87(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10c0 <regcomp@plt>
mov %eax,%r8d
lea 0xd31(%rip),%rax
test %r8d,%r8d
je 1310 <func0+0x60>
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 134b <func0+0x9b>
add $0x58,%rsp
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %rbp,%rsi
xor %ecx,%ecx
xor %edx,%edx
mov %r12,%rdi
callq 10d0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 1090 <regfree@plt>
lea 0xcd4(%rip),%rax
test %ebp,%ebp
je 12f4 <func0+0x44>
cmp $0x1,%ebp
lea 0xcd5(%rip),%rax
lea 0xcf1(%rip),%rdx
cmovne %rdx,%rax
jmp 12f4 <func0+0x44>
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
mov edx, 1
lea rsi, aAb; "ab*?"
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
mov r8d, eax
lea rax, aErrorCompiling; "Error compiling regex"
test r8d, r8d
jz short loc_1320
loc_1304:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_135B
add rsp, 58h
pop rbp
pop r12
retn
loc_1320:
mov rsi, rbp
xor ecx, ecx
xor edx, edx
mov rdi, r12
call _regexec
mov rdi, r12
mov ebp, eax
call _regfree
lea rax, aFoundAMatch; "Found a match!"
test ebp, ebp
jz short loc_1304
cmp ebp, 1
lea rax, aNotMatched; "Not matched!"
lea rdx, aRegexMatchFail; "Regex match failed"
cmovnz rax, rdx
jmp short loc_1304
loc_135B:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // r8d
const char *result; // rax
int v3; // ebp
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "ab*?", 1LL);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(v4, a1, 0LL, 0LL);
regfree(v4);
result = "Found a match!";
if ( v3 )
{
result = "Not matched!";
if ( v3 != 1 )
return "Regex match failed";
}
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102049]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010d0
MOV R8D,EAX
LEA RAX,[0x102004]
TEST R8D,R8D
JZ 0x00101320
LAB_00101304:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010135b
ADD RSP,0x58
POP RBP
POP R12
RET
LAB_00101320:
MOV RSI,RBP
XOR ECX,ECX
XOR EDX,EDX
MOV RDI,R12
CALL 0x001010f0
MOV RDI,R12
MOV EBP,EAX
CALL 0x001010a0
LEA RAX,[0x10201a]
TEST EBP,EBP
JZ 0x00101304
CMP EBP,0x1
LEA RAX,[0x102029]
LEA RDX,[0x102036]
CMOVNZ RAX,RDX
JMP 0x00101304
LAB_0010135b:
CALL 0x001010b0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab*?",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!";
if ((iVar1 != 0) && (pcVar2 = "Not matched!", iVar1 != 1)) {
pcVar2 = "Regex match failed";
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,615 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found a match!";
} else if (ret == REG_NOMATCH) {
return "Not matched!";
} else {
return "Regex match failed";
}
}
| int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd87(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10c0 <regcomp@plt>
mov %eax,%r8d
lea 0xd31(%rip),%rax
test %r8d,%r8d
je 1310 <func0+0x60>
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 134b <func0+0x9b>
add $0x58,%rsp
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %rbp,%rsi
xor %ecx,%ecx
xor %edx,%edx
mov %r12,%rdi
callq 10d0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 1090 <regfree@plt>
lea 0xcd4(%rip),%rax
test %ebp,%ebp
je 12f4 <func0+0x44>
cmp $0x1,%ebp
lea 0xcd5(%rip),%rax
lea 0xcf1(%rip),%rdx
cmovne %rdx,%rax
jmp 12f4 <func0+0x44>
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "ab*?"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
mov edx, eax
lea rax, aErrorCompiling; "Error compiling regex"
test edx, edx
jz short loc_1320
loc_1301:
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_135E
add rsp, 58h
pop rbx
pop rbp
retn
loc_1320:
mov rsi, rbx; string
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
lea rax, aFoundAMatch; "Found a match!"
test ebx, ebx
jz short loc_1301
cmp ebx, 1
lea rax, aRegexMatchFail; "Regex match failed"
lea rdx, s2; "Not matched!"
cmovz rax, rdx
jmp short loc_1301
loc_135E:
call ___stack_chk_fail | const char * func0(char *string)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
v1 = regcomp(&_0, "ab*?", 1);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
result = "Found a match!";
if ( v3 )
{
result = "Regex match failed";
if ( v3 == 1 )
return "Not matched!";
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102049]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x00101320
LAB_00101301:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010135e
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_00101320:
MOV RSI,RBX
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RDI,RBP
CALL 0x001010f0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x001010a0
LEA RAX,[0x10201a]
TEST EBX,EBX
JZ 0x00101301
CMP EBX,0x1
LEA RAX,[0x102036]
LEA RDX,[0x102029]
CMOVZ RAX,RDX
JMP 0x00101301
LAB_0010135e:
CALL 0x001010b0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab*?",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!";
if ((iVar1 != 0) && (pcVar2 = "Regex match failed", iVar1 == 1)) {
pcVar2 = "Not matched!";
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,616 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x8(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
imul -0x14(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd 0xee9(%rip),%xmm1
divsd %xmm1,%xmm0
movsd 0xedd(%rip),%xmm1
callq 1060 <pow@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm0, xmm0
movsd [rbp+var_8], xmm0
mov eax, [rbp+var_14]
add eax, 1
imul eax, [rbp+var_14]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, cs:y
divsd xmm0, xmm1
movq rax, xmm0
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
mov [rbp+var_8], rax
movsd xmm0, [rbp+var_8]
leave
retn | long long func0(int a1)
{
return pow((double)(a1 * (a1 + 1)) / 2.0, 2.0);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x14]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [0x00102060]
DIVSD XMM0,XMM1
MOVQ RAX,XMM0
MOVSD XMM0,qword ptr [0x00102060]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | double func0(int param_1)
{
double dVar1;
dVar1 = pow((double)((param_1 + 1) * param_1) / DAT_00102060,DAT_00102060);
return dVar1;
} |
7,617 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
lea 0x1(%rdi),%edi
imul %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xec3(%rip),%xmm0
mulsd %xmm0,%xmm0
retq
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm0
retn | double func0(int a1)
{
return (double)(a1 * (a1 + 1)) * 0.5 * ((double)(a1 * (a1 + 1)) * 0.5);
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = (double)((param_1 + 1) * param_1) * _DAT_00102008;
return dVar1 * dVar1;
} |
7,618 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%r8d
lea 0x1(%rdi),%edi
pxor %xmm0,%xmm0
imul %r8d,%edi
cvtsi2sd %edi,%xmm0
mulsd 0xeaa(%rip),%xmm0
mulsd %xmm0,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi+1]
pxor xmm0, xmm0
imul eax, edi
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm0
retn | double func0(int a1)
{
return (double)(a1 * (a1 + 1)) * 0.5 * ((double)(a1 * (a1 + 1)) * 0.5);
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PXOR XMM0,XMM0
IMUL EAX,EDI
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = (double)((param_1 + 1) * param_1) * _DAT_00102008;
return dVar1 * dVar1;
} |
7,619 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%r8d
lea 0x1(%rdi),%edi
pxor %xmm0,%xmm0
imul %r8d,%edi
cvtsi2sd %edi,%xmm0
mulsd 0xeaa(%rip),%xmm0
mulsd %xmm0,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi+1]
pxor xmm0, xmm0
imul eax, edi
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm0
retn | double func0(int a1)
{
return (double)(a1 * (a1 + 1)) * 0.5 * ((double)(a1 * (a1 + 1)) * 0.5);
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PXOR XMM0,XMM0
IMUL EAX,EDI
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = (double)((param_1 + 1) * param_1) * _DAT_00102008;
return dVar1 * dVar1;
} |
7,620 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}
}
if(!exists) {
output[count++] = input[i];
}
}
return count;
}
| int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < count1; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
const char *input2[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "Java"};
const char *expected2[] = {"Python", "Exercises", "Practice", "Solution", "Java"};
const char *output2[MAX_ELEMENTS];
int count2 = func0(input2, 6, output2);
assert(count2 == 5);
for(int i = 0; i < count2; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
const char *input3[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "C++", "C", "C++"};
const char *expected3[] = {"Python", "Exercises", "Practice", "Solution", "C++", "C"};
const char *output3[MAX_ELEMENTS];
int count3 = func0(input3, 8, output3);
assert(count3 == 6);
for(int i = 0; i < count3; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1254 <func0+0xcb>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 120d <func0+0x84>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jne 1209 <func0+0x80>
movl $0x1,-0x8(%rbp)
jmp 1215 <func0+0x8c>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 11c3 <func0+0x3a>
cmpl $0x0,-0x8(%rbp)
jne 1250 <func0+0xc7>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11b3 <func0+0x2a>
mov -0x10(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_1254
loc_11B3:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_120D
loc_11C3:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1209
mov [rbp+var_8], 1
jmp short loc_1215
loc_1209:
add [rbp+var_4], 1
loc_120D:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_10]
jl short loc_11C3
loc_1215:
cmp [rbp+var_8], 0
jnz short loc_1250
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
loc_1250:
add [rbp+var_C], 1
loc_1254:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_11B3
mov eax, [rbp+var_10]
leave
retn | long long func0(long long a1, int a2, long long a3)
{
int v3; // eax
unsigned int v6; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int v8; // [rsp+28h] [rbp-8h]
int j; // [rsp+2Ch] [rbp-4h]
v6 = 0;
for ( i = 0; i < a2; ++i )
{
v8 = 0;
for ( j = 0; j < (int)v6; ++j )
{
if ( !strcmp(*(const char **)(8LL * i + a1), *(const char **)(8LL * j + a3)) )
{
v8 = 1;
break;
}
}
if ( !v8 )
{
v3 = v6++;
*(_QWORD *)(a3 + 8LL * v3) = *(_QWORD *)(8LL * i + a1);
}
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101254
LAB_001011b3:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010120d
LAB_001011c3:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JNZ 0x00101209
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101215
LAB_00101209:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010120d:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x001011c3
LAB_00101215:
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00101250
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
LAB_00101250:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101254:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011b3
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | int func0(long param_1,int param_2,long param_3)
{
bool bVar1;
int iVar2;
int4 local_18;
int4 local_14;
int4 local_c;
local_18 = 0;
local_14 = 0;
do {
if (param_2 <= local_14) {
return local_18;
}
bVar1 = false;
for (local_c = 0; local_c < local_18; local_c = local_c + 1) {
iVar2 = strcmp(*(char **)(param_1 + (long)local_14 * 8),
*(char **)(param_3 + (long)local_c * 8));
if (iVar2 == 0) {
bVar1 = true;
break;
}
}
if (!bVar1) {
*(int8 *)((long)local_18 * 8 + param_3) = *(int8 *)((long)local_14 * 8 + param_1);
local_18 = local_18 + 1;
}
local_14 = local_14 + 1;
} while( true );
} |
7,621 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}
}
if(!exists) {
output[count++] = input[i];
}
}
return count;
}
| int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < count1; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
const char *input2[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "Java"};
const char *expected2[] = {"Python", "Exercises", "Practice", "Solution", "Java"};
const char *output2[MAX_ELEMENTS];
int count2 = func0(input2, 6, output2);
assert(count2 == 5);
for(int i = 0; i < count2; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
const char *input3[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "C++", "C", "C++"};
const char *expected3[] = {"Python", "Exercises", "Practice", "Solution", "C++", "C"};
const char *output3[MAX_ELEMENTS];
int count3 = func0(input3, 8, output3);
assert(count3 == 6);
for(int i = 0; i < count3; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %esi,%esi
jle 11c2 <func0+0x39>
mov %rdx,%r15
mov %rdi,%r13
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rax
mov %rax,(%rsp)
mov $0x0,%r14d
lea 0x8(%rdx),%rax
mov %rax,0x8(%rsp)
jmp 11f3 <func0+0x6a>
mov $0x0,%r14d
mov %r14d,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov 0x0(%r13),%rdx
movslq %r14d,%rax
mov %rdx,(%r15,%rax,8)
lea 0x1(%r14),%r14d
add $0x8,%r13
cmp (%rsp),%r13
je 11c8 <func0+0x3f>
test %r14d,%r14d
jle 11da <func0+0x51>
mov 0x0(%r13),%rbp
mov %r15,%rbx
lea -0x1(%r14),%eax
mov 0x8(%rsp),%rcx
lea (%rcx,%rax,8),%r12
mov (%rbx),%rsi
mov %rbp,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 11e9 <func0+0x60>
add $0x8,%rbx
cmp %r12,%rbx
jne 120c <func0+0x83>
jmp 11da <func0+0x51>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle short loc_11C2
mov r15, rdx
mov r13, rdi
lea eax, [rsi-1]
lea rax, [rdi+rax*8+8]
mov [rsp+48h+var_48], rax
mov r14d, 0
lea rax, [rdx+8]
mov [rsp+48h+var_40], rax
jmp short loc_11F3
loc_11C2:
mov r14d, 0
loc_11C8:
mov eax, r14d
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_11DA:
mov rdx, [r13+0]
movsxd rax, r14d
mov [r15+rax*8], rdx
lea r14d, [r14+1]
loc_11E9:
add r13, 8
cmp r13, [rsp+48h+var_48]
jz short loc_11C8
loc_11F3:
test r14d, r14d
jle short loc_11DA
mov rbp, [r13+0]
mov rbx, r15
lea eax, [r14-1]
mov rcx, [rsp+48h+var_40]
lea r12, [rcx+rax*8]
loc_120C:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_11E9
add rbx, 8
cmp rbx, r12
jnz short loc_120C
jmp short loc_11DA | long long func0(_QWORD *a1, int a2, _QWORD *a3)
{
_QWORD *v4; // r13
int v5; // r14d
long long v7; // rbp
_QWORD *v8; // rbx
_QWORD *v9; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 = 0;
v9 = a3 + 1;
do
{
if ( v5 <= 0 )
{
LABEL_5:
a3[v5++] = *v4;
}
else
{
v7 = *v4;
v8 = a3;
while ( (unsigned int)strcmp(v7, *v8) )
{
if ( ++v8 == &v9[v5 - 1] )
goto LABEL_5;
}
}
++v4;
}
while ( v4 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return (unsigned int)v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x001011c2
MOV R15,RDX
MOV R13,RDI
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP],RAX
MOV R14D,0x0
LEA RAX,[RDX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001011f3
LAB_001011c2:
MOV R14D,0x0
LAB_001011c8:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001011da:
MOV RDX,qword ptr [R13]
MOVSXD RAX,R14D
MOV qword ptr [R15 + RAX*0x8],RDX
LEA R14D,[R14 + 0x1]
LAB_001011e9:
ADD R13,0x8
CMP R13,qword ptr [RSP]
JZ 0x001011c8
LAB_001011f3:
TEST R14D,R14D
JLE 0x001011da
MOV RBP,qword ptr [R13]
MOV RBX,R15
LEA EAX,[R14 + -0x1]
MOV RCX,qword ptr [RSP + 0x8]
LEA R12,[RCX + RAX*0x8]
LAB_0010120c:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x00101090
TEST EAX,EAX
JZ 0x001011e9
ADD RBX,0x8
CMP RBX,R12
JNZ 0x0010120c
JMP 0x001011da | int func0(int8 *param_1,int param_2,int8 *param_3)
{
int8 *puVar1;
char *__s1;
int iVar2;
int8 *puVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0;
do {
if (0 < iVar4) {
__s1 = (char *)*param_1;
puVar3 = param_3;
do {
iVar2 = strcmp(__s1,(char *)*puVar3);
if (iVar2 == 0) goto LAB_001011e9;
puVar3 = puVar3 + 1;
} while (puVar3 != param_3 + (ulong)(iVar4 - 1) + 1);
}
param_3[iVar4] = *param_1;
iVar4 = iVar4 + 1;
LAB_001011e9:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar4;
} |
7,622 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}
}
if(!exists) {
output[count++] = input[i];
}
}
return count;
}
| int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < count1; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
const char *input2[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "Java"};
const char *expected2[] = {"Python", "Exercises", "Practice", "Solution", "Java"};
const char *output2[MAX_ELEMENTS];
int count2 = func0(input2, 6, output2);
assert(count2 == 5);
for(int i = 0; i < count2; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
const char *input3[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "C++", "C", "C++"};
const char *expected3[] = {"Python", "Exercises", "Practice", "Solution", "C++", "C"};
const char *output3[MAX_ELEMENTS];
int count3 = func0(input3, 8, output3);
assert(count3 == 6);
for(int i = 0; i < count3; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %esi,%esi
jle 155f <func0+0xaf>
lea -0x1(%rsi),%eax
mov %rdx,%r14
mov %rdi,%r12
xor %r13d,%r13d
lea 0x8(%rdi,%rax,8),%rax
mov %rax,(%rsp)
lea 0x8(%rdx),%rax
mov %rax,0x8(%rsp)
nopl 0x0(%rax,%rax,1)
mov (%r12),%rbx
test %r13d,%r13d
je 1548 <func0+0x98>
mov 0x8(%rsp),%rcx
lea -0x1(%r13),%eax
mov %r14,%r15
lea (%rcx,%rax,8),%rbp
jmp 1519 <func0+0x69>
nopl 0x0(%rax,%rax,1)
add $0x8,%r15
cmp %rbp,%r15
je 1548 <func0+0x98>
mov (%r15),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jne 1510 <func0+0x60>
add $0x8,%r12
cmp (%rsp),%r12
jne 14f0 <func0+0x40>
add $0x18,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movslq %r13d,%rax
add $0x8,%r12
add $0x1,%r13d
mov %rbx,(%r14,%rax,8)
cmp (%rsp),%r12
jne 14f0 <func0+0x40>
jmp 1532 <func0+0x82>
xor %r13d,%r13d
jmp 1532 <func0+0x82>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle loc_155F
lea eax, [rsi-1]
mov r14, rdx
mov r12, rdi
xor r13d, r13d
lea rax, [rdi+rax*8+8]
mov [rsp+48h+var_48], rax
lea rax, [rdx+8]
mov [rsp+48h+var_40], rax
nop dword ptr [rax+rax+00000000h]
loc_14F0:
mov rbx, [r12]
test r13d, r13d
jz short loc_1548
mov rcx, [rsp+48h+var_40]
lea eax, [r13-1]
mov r15, r14
lea rbp, [rcx+rax*8]
jmp short loc_1519
loc_1510:
add r15, 8
cmp r15, rbp
jz short loc_1548
loc_1519:
mov rsi, [r15]
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_1510
add r12, 8
cmp r12, [rsp+48h+var_48]
jnz short loc_14F0
loc_1532:
add rsp, 18h
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1548:
movsxd rax, r13d
add r12, 8
add r13d, 1
mov [r14+rax*8], rbx
cmp r12, [rsp+48h+var_48]
jnz short loc_14F0
jmp short loc_1532
loc_155F:
xor r13d, r13d
jmp short loc_1532 | long long func0(long long *a1, int a2, _QWORD *a3)
{
long long *v4; // r12
unsigned int v5; // r13d
long long v6; // rbx
_QWORD *v7; // r15
long long v9; // rax
long long v10; // [rsp+0h] [rbp-48h]
_QWORD *v11; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 = 0;
v10 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
v11 = a3 + 1;
do
{
while ( 1 )
{
v6 = *v4;
if ( v5 )
break;
LABEL_9:
v9 = (int)v5;
++v4;
++v5;
a3[v9] = v6;
if ( v4 == (long long *)v10 )
return v5;
}
v7 = a3;
while ( (unsigned int)strcmp(v6, *v7) )
{
if ( ++v7 == &v11[v5 - 1] )
goto LABEL_9;
}
++v4;
}
while ( v4 != (long long *)v10 );
}
return v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x0010155f
LEA EAX,[RSI + -0x1]
MOV R14,RDX
MOV R12,RDI
XOR R13D,R13D
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP],RAX
LEA RAX,[RDX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001014f0:
MOV RBX,qword ptr [R12]
TEST R13D,R13D
JZ 0x00101548
MOV RCX,qword ptr [RSP + 0x8]
LEA EAX,[R13 + -0x1]
MOV R15,R14
LEA RBP,[RCX + RAX*0x8]
JMP 0x00101519
LAB_00101510:
ADD R15,0x8
CMP R15,RBP
JZ 0x00101548
LAB_00101519:
MOV RSI,qword ptr [R15]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JNZ 0x00101510
ADD R12,0x8
CMP R12,qword ptr [RSP]
JNZ 0x001014f0
LAB_00101532:
ADD RSP,0x18
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101548:
MOVSXD RAX,R13D
ADD R12,0x8
ADD R13D,0x1
MOV qword ptr [R14 + RAX*0x8],RBX
CMP R12,qword ptr [RSP]
JNZ 0x001014f0
JMP 0x00101532
LAB_0010155f:
XOR R13D,R13D
JMP 0x00101532 | int func0(int8 *param_1,int param_2,int8 *param_3)
{
int8 *puVar1;
char *__s1;
int iVar2;
long lVar3;
int iVar4;
int8 *puVar5;
if (param_2 < 1) {
iVar4 = 0;
}
else {
iVar4 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
__s1 = (char *)*param_1;
if (iVar4 != 0) {
puVar5 = param_3;
do {
iVar2 = strcmp(__s1,(char *)*puVar5);
if (iVar2 == 0) goto joined_r0x00101530;
puVar5 = puVar5 + 1;
} while (puVar5 != param_3 + (ulong)(iVar4 - 1) + 1);
}
lVar3 = (long)iVar4;
iVar4 = iVar4 + 1;
param_3[lVar3] = __s1;
joined_r0x00101530:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar4;
} |
7,623 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}
}
if(!exists) {
output[count++] = input[i];
}
}
return count;
}
| int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < count1; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
const char *input2[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "Java"};
const char *expected2[] = {"Python", "Exercises", "Practice", "Solution", "Java"};
const char *output2[MAX_ELEMENTS];
int count2 = func0(input2, 6, output2);
assert(count2 == 5);
for(int i = 0; i < count2; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
const char *input3[] = {"Python", "Exercises", "Practice", "Solution", "Exercises", "C++", "C", "C++"};
const char *expected3[] = {"Python", "Exercises", "Practice", "Solution", "C++", "C"};
const char *output3[MAX_ELEMENTS];
int count3 = func0(input3, 8, output3);
assert(count3 == 6);
for(int i = 0; i < count3; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %esi,%esi
jle 165f <func0+0xaf>
lea -0x1(%rsi),%eax
mov %rdx,%r14
mov %rdi,%r12
xor %r13d,%r13d
lea 0x8(%rdi,%rax,8),%rax
mov %rax,(%rsp)
lea 0x8(%rdx),%rax
mov %rax,0x8(%rsp)
nopl 0x0(%rax,%rax,1)
mov (%r12),%rbx
test %r13d,%r13d
je 1648 <func0+0x98>
mov 0x8(%rsp),%rcx
lea -0x1(%r13),%eax
mov %r14,%r15
lea (%rcx,%rax,8),%rbp
jmp 1619 <func0+0x69>
nopl 0x0(%rax,%rax,1)
add $0x8,%r15
cmp %r15,%rbp
je 1648 <func0+0x98>
mov (%r15),%rsi
mov %rbx,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jne 1610 <func0+0x60>
add $0x8,%r12
cmp %r12,(%rsp)
jne 15f0 <func0+0x40>
add $0x18,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movslq %r13d,%rax
add $0x8,%r12
add $0x1,%r13d
mov %rbx,(%r14,%rax,8)
cmp %r12,(%rsp)
jne 15f0 <func0+0x40>
jmp 1632 <func0+0x82>
xor %r13d,%r13d
jmp 1632 <func0+0x82>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle loc_15F9
movsxd rsi, esi
mov r14, rdx
mov r12, rdi
xor r13d, r13d
lea rax, [rdi+rsi*8]
mov [rsp+48h+var_48], rax
xchg ax, ax
loc_1580:
movsxd rax, r13d
mov rbx, [r12]
mov [rsp+48h+var_40], rax
lea rbp, [r14+rax*8]
test r13d, r13d
jle short loc_15D0
loc_1595:
mov r15, r14
jmp short loc_15A9
loc_15A0:
add r15, 8
cmp rbp, r15
jz short loc_15D0
loc_15A9:
mov rsi, [r15]; s2
mov rdi, rbx; s1
call _strcmp
test eax, eax
jnz short loc_15A0
add r12, 8
cmp [rsp+48h+var_48], r12
jz short loc_15E7
mov rbx, [r12]
jmp short loc_1595
loc_15D0:
mov rax, [rsp+48h+var_40]
add r13d, 1
add r12, 8
mov [r14+rax*8], rbx
cmp [rsp+48h+var_48], r12
jnz short loc_1580
loc_15E7:
add rsp, 18h
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15F9:
xor r13d, r13d
jmp short loc_15E7 | long long func0(const char **a1, int a2, const char **a3)
{
const char **v4; // r12
int v5; // r13d
const char *v6; // rbx
const char **v7; // r15
const char **v9; // [rsp+0h] [rbp-48h]
long long v10; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 = 0;
v9 = &a1[a2];
while ( 1 )
{
v6 = *v4;
v10 = v5;
if ( v5 > 0 )
break;
LABEL_9:
++v5;
++v4;
a3[v10] = v6;
if ( v9 == v4 )
return (unsigned int)v5;
}
while ( 1 )
{
v7 = a3;
while ( strcmp(v6, *v7) )
{
if ( &a3[v5] == ++v7 )
goto LABEL_9;
}
if ( v9 == ++v4 )
break;
v6 = *v4;
}
}
return (unsigned int)v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x001015f9
MOVSXD RSI,ESI
MOV R14,RDX
MOV R12,RDI
XOR R13D,R13D
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP],RAX
NOP
LAB_00101580:
MOVSXD RAX,R13D
MOV RBX,qword ptr [R12]
MOV qword ptr [RSP + 0x8],RAX
LEA RBP,[R14 + RAX*0x8]
TEST R13D,R13D
JLE 0x001015d0
LAB_00101595:
MOV R15,R14
JMP 0x001015a9
LAB_001015a0:
ADD R15,0x8
CMP RBP,R15
JZ 0x001015d0
LAB_001015a9:
MOV RSI,qword ptr [R15]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JNZ 0x001015a0
ADD R12,0x8
CMP qword ptr [RSP],R12
JZ 0x001015e7
MOV RBX,qword ptr [R12]
JMP 0x00101595
LAB_001015d0:
MOV RAX,qword ptr [RSP + 0x8]
ADD R13D,0x1
ADD R12,0x8
MOV qword ptr [R14 + RAX*0x8],RBX
CMP qword ptr [RSP],R12
JNZ 0x00101580
LAB_001015e7:
ADD RSP,0x18
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015f9:
XOR R13D,R13D
JMP 0x001015e7 | int func0(int8 *param_1,int param_2,int8 *param_3)
{
int8 *puVar1;
int iVar2;
char *__s1;
int iVar3;
int8 *puVar4;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
__s1 = (char *)*param_1;
puVar4 = param_3;
if (0 < iVar3) {
do {
while (iVar2 = strcmp(__s1,(char *)*puVar4), iVar2 == 0) {
param_1 = param_1 + 1;
if (puVar1 == param_1) {
return iVar3;
}
__s1 = (char *)*param_1;
puVar4 = param_3;
}
puVar4 = puVar4 + 1;
} while (param_3 + iVar3 != puVar4);
}
iVar2 = iVar3 + 1;
param_1 = param_1 + 1;
param_3[iVar3] = __s1;
iVar3 = iVar2;
} while (puVar1 != param_1);
}
return iVar2;
} |
7,624 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else if (i > 0 && isupper(text[i]) && isupper(text[i - 1]) && islower(text[i + 1])) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else {
result[j++] = tolower(text[i]);
}
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_core") == 0);
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %rax,-0x18(%rbp)
movq $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
add %rax,%rax
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 147d <func0+0x274>
cmpl $0x0,-0x20(%rbp)
jle 134e <func0+0x145>
callq 1110 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 134e <func0+0x145>
callq 1110 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
jne 1300 <func0+0xf7>
callq 1110 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 134e <func0+0x145>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10f0 <tolower@plt>
mov %eax,%ecx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
jmpq 1479 <func0+0x270>
cmpl $0x0,-0x20(%rbp)
jle 1446 <func0+0x23d>
callq 1110 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 1446 <func0+0x23d>
callq 1110 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 1446 <func0+0x23d>
callq 1110 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea 0x1(%rdx),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 1446 <func0+0x23d>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10f0 <tolower@plt>
mov %eax,%ecx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
jmp 1479 <func0+0x270>
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10f0 <tolower@plt>
mov %eax,%ecx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cltq
cmp %rax,-0x18(%rbp)
ja 1257 <func0+0x4e>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], rax
mov [rbp+var_10], 0
mov rax, [rbp+var_18]
add rax, rax
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_1C], 0
mov [rbp+var_20], 0
jmp loc_147D
loc_1257:
cmp [rbp+var_20], 0
jle loc_134E
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz loc_134E
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jnz short loc_1300
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_134E
loc_1300:
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _tolower
mov ecx, eax
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov edx, ecx
mov [rax], dl
jmp loc_1479
loc_134E:
cmp [rbp+var_20], 0
jle loc_1446
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz loc_1446
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz loc_1446
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, [rdx+1]
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jz short loc_1446
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _tolower
mov ecx, eax
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov edx, ecx
mov [rax], dl
jmp short loc_1479
loc_1446:
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _tolower
mov ecx, eax
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov edx, ecx
mov [rax], dl
loc_1479:
add [rbp+var_20], 1
loc_147D:
mov eax, [rbp+var_20]
cdqe
cmp rax, [rbp+var_18]
jb loc_1257
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
leave
retn | _BYTE * func0(const char *a1)
{
char v1; // cl
int v2; // eax
char v3; // cl
int v4; // eax
int i; // [rsp+10h] [rbp-20h]
int v7; // [rsp+14h] [rbp-1Ch]
size_t v8; // [rsp+18h] [rbp-18h]
_BYTE *v9; // [rsp+28h] [rbp-8h]
v8 = strlen(a1);
v9 = malloc(2 * v8);
v7 = 0;
for ( i = 0; i < v8; ++i )
{
if ( i > 0
&& ((*__ctype_b_loc())[a1[i]] & 0x100) != 0
&& (((*__ctype_b_loc())[a1[i - 1]] & 0x200) != 0 || ((*__ctype_b_loc())[a1[i - 1]] & 0x800) != 0)
|| i > 0
&& ((*__ctype_b_loc())[a1[i]] & 0x100) != 0
&& ((*__ctype_b_loc())[a1[i - 1]] & 0x100) != 0
&& ((*__ctype_b_loc())[a1[i + 1]] & 0x200) != 0 )
{
v9[v7] = 95;
v1 = tolower(a1[i]);
v2 = v7 + 1;
v7 += 2;
v9[v2] = v1;
}
else
{
v3 = tolower(a1[i]);
v4 = v7++;
v9[v4] = v3;
}
}
v9[v7] = 0;
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RAX
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x0010147d
LAB_00101257:
CMP dword ptr [RBP + -0x20],0x0
JLE 0x0010134e
CALL 0x00101110
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x0010134e
CALL 0x00101110
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JNZ 0x00101300
CALL 0x00101110
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x0010134e
LAB_00101300:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010f0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
JMP 0x00101479
LAB_0010134e:
CMP dword ptr [RBP + -0x20],0x0
JLE 0x00101446
CALL 0x00101110
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x00101446
CALL 0x00101110
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x00101446
CALL 0x00101110
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX + 0x1]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x00101446
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010f0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
JMP 0x00101479
LAB_00101446:
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010f0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
LAB_00101479:
ADD dword ptr [RBP + -0x20],0x1
LAB_0010147d:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
CMP RAX,qword ptr [RBP + -0x18]
JC 0x00101257
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(char *param_1)
{
int iVar1;
size_t sVar2;
void *pvVar3;
ushort **ppuVar4;
int local_28;
int local_24;
sVar2 = strlen(param_1);
pvVar3 = malloc(sVar2 * 2);
local_24 = 0;
local_28 = 0;
do {
if (sVar2 <= (ulong)(long)local_28) {
*(int *)((long)pvVar3 + (long)local_24) = 0;
return pvVar3;
}
if (local_28 < 1) {
LAB_0010134e:
if (0 < local_28) {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[param_1[local_28]] & 0x100) != 0) {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[param_1[(long)local_28 + -1]] & 0x100) != 0) {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[param_1[(long)local_28 + 1]] & 0x200) != 0) {
*(int *)((long)pvVar3 + (long)local_24) = 0x5f;
iVar1 = tolower((int)param_1[local_28]);
*(char *)((long)pvVar3 + (long)(local_24 + 1)) = (char)iVar1;
local_24 = local_24 + 2;
goto LAB_00101479;
}
}
}
}
iVar1 = tolower((int)param_1[local_28]);
*(char *)((long)pvVar3 + (long)local_24) = (char)iVar1;
local_24 = local_24 + 1;
}
else {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[param_1[local_28]] & 0x100) == 0) goto LAB_0010134e;
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[param_1[(long)local_28 + -1]] & 0x200) == 0) {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[param_1[(long)local_28 + -1]] & 0x800) == 0) goto LAB_0010134e;
}
*(int *)((long)pvVar3 + (long)local_24) = 0x5f;
iVar1 = tolower((int)param_1[local_28]);
*(char *)((long)pvVar3 + (long)(local_24 + 1)) = (char)iVar1;
local_24 = local_24 + 2;
}
LAB_00101479:
local_28 = local_28 + 1;
} while( true );
} |
7,625 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else if (i > 0 && isupper(text[i]) && isupper(text[i - 1]) && islower(text[i + 1])) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else {
result[j++] = tolower(text[i]);
}
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_core") == 0);
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r12
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r13
lea 0x0(%r13,%r13,1),%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %r13,%r13
je 12e0 <func0+0x117>
mov $0x0,%ebx
mov $0x0,%ebp
jmp 1286 <func0+0xbd>
test %ax,%ax
je 1260 <func0+0x97>
movsbq -0x1(%r12,%rbx,1),%rax
testb $0x1,0x1(%rdx,%rax,2)
je 1260 <func0+0x97>
movsbq 0x1(%r12,%rbx,1),%rax
testb $0x2,0x1(%rdx,%rax,2)
je 1260 <func0+0x97>
lea 0x1(%rbp),%eax
mov %eax,0xc(%rsp)
movslq %ebp,%rax
movb $0x5f,(%r14,%rax,1)
callq 10c0 <__ctype_tolower_loc@plt>
mov %rax,%rdx
add $0x2,%ebp
movslq 0xc(%rsp),%rax
mov (%rdx),%rdx
mov (%rdx,%r15,4),%edx
mov %dl,(%r14,%rax,1)
jmp 127d <func0+0xb4>
callq 10c0 <__ctype_tolower_loc@plt>
mov %rax,%rdx
movslq %ebp,%rax
movsbq (%r12,%rbx,1),%rcx
mov (%rdx),%rdx
mov (%rdx,%rcx,4),%edx
mov %dl,(%r14,%rax,1)
lea 0x1(%rbp),%ebp
add $0x1,%rbx
cmp %rbx,%r13
je 12e5 <func0+0x11c>
test %ebx,%ebx
jle 1260 <func0+0x97>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rdx
movsbq (%r12,%rbx,1),%r15
movzwl (%rdx,%r15,2),%eax
and $0x100,%ax
je 1260 <func0+0x97>
movsbq -0x1(%r12,%rbx,1),%rcx
testw $0xa00,(%rdx,%rcx,2)
je 1215 <func0+0x4c>
lea 0x1(%rbp),%eax
mov %eax,0xc(%rsp)
movslq %ebp,%rax
movb $0x5f,(%r14,%rax,1)
callq 10c0 <__ctype_tolower_loc@plt>
mov %rax,%rdx
add $0x2,%ebp
movslq 0xc(%rsp),%rax
mov (%rdx),%rdx
mov (%rdx,%r15,4),%edx
mov %dl,(%r14,%rax,1)
jmp 127d <func0+0xb4>
mov $0x0,%ebp
movslq %ebp,%rbp
movb $0x0,(%r14,%rbp,1)
mov %r14,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
call _strlen
mov r14, rax
lea rdi, [rax+rax]
call _malloc
mov r13, rax
test r14, r14
jz loc_131E
mov r12d, 0
mov ebp, 0
jmp short loc_12C1
loc_1248:
test ax, ax
jz short loc_1296
movsx rax, byte ptr [rbx-1]
test byte ptr [rdx+rax*2+1], 1
jz short loc_1296
movsx rax, byte ptr [rbx+1]
test byte ptr [rdx+rax*2+1], 2
jz short loc_1296
lea eax, [r12+1]
mov [rsp+48h+var_3C], eax
movsxd rax, r12d
mov byte ptr [r13+rax+0], 5Fh ; '_'
call ___ctype_tolower_loc
mov rdx, rax
add r12d, 2
movsxd rax, [rsp+48h+var_3C]
mov rdx, [rdx]
mov edx, [rdx+r15*4]
mov [r13+rax+0], dl
jmp short loc_12B5
loc_1296:
call ___ctype_tolower_loc
mov rdx, rax
movsxd rax, r12d
movsx rcx, byte ptr [rbx]
mov rdx, [rdx]
mov edx, [rdx+rcx*4]
mov [r13+rax+0], dl
lea r12d, [r12+1]
loc_12B5:
add ebp, 1
add rbx, 1
cmp ebp, r14d
jz short loc_1324
loc_12C1:
test ebp, ebp
jle short loc_1296
call ___ctype_b_loc
mov rdx, [rax]
movsx r15, byte ptr [rbx]
movzx eax, word ptr [rdx+r15*2]
and ax, 100h
jz short loc_1296
movsx rsi, byte ptr [rbx-1]
test word ptr [rdx+rsi*2], 0A00h
jz loc_1248
lea eax, [r12+1]
mov [rsp+48h+var_3C], eax
movsxd rax, r12d
mov byte ptr [r13+rax+0], 5Fh ; '_'
call ___ctype_tolower_loc
mov rdx, rax
add r12d, 2
movsxd rax, [rsp+48h+var_3C]
mov rdx, [rdx]
mov edx, [rdx+r15*4]
mov [r13+rax+0], dl
jmp short loc_12B5
loc_131E:
mov r12d, 0
loc_1324:
movsxd r12, r12d
mov byte ptr [r13+r12+0], 0
mov rax, r13
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char *a1)
{
long long v2; // r14
long long v3; // r13
int v4; // r12d
int v5; // ebp
long long *v6; // rax
long long v7; // rdx
long long v8; // r15
int v10; // [rsp+Ch] [rbp-3Ch]
v2 = strlen();
v3 = malloc(2 * v2);
if ( v2 )
{
v4 = 0;
v5 = 0;
do
{
if ( v5 > 0
&& (v6 = (long long *)__ctype_b_loc(), v7 = *v6, v8 = *a1, (*(_WORD *)(*v6 + 2 * v8) & 0x100) != 0)
&& ((*(_WORD *)(v7 + 2LL * *(a1 - 1)) & 0xA00) != 0
|| (*(_BYTE *)(v7 + 2LL * *(a1 - 1) + 1) & 1) != 0 && (*(_BYTE *)(v7 + 2LL * a1[1] + 1) & 2) != 0) )
{
v10 = v4 + 1;
*(_BYTE *)(v3 + v4) = 95;
v4 += 2;
*(_BYTE *)(v3 + v10) = *(_DWORD *)(*(_QWORD *)__ctype_tolower_loc() + 4 * v8);
}
else
{
*(_BYTE *)(v3 + v4++) = *(_DWORD *)(*(_QWORD *)__ctype_tolower_loc() + 4LL * *a1);
}
++v5;
++a1;
}
while ( v5 != (_DWORD)v2 );
}
else
{
v4 = 0;
}
*(_BYTE *)(v3 + v4) = 0;
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x001010c0
MOV R14,RAX
LEA RDI,[RAX + RAX*0x1]
CALL 0x001010f0
MOV R13,RAX
TEST R14,R14
JZ 0x0010131e
MOV R12D,0x0
MOV EBP,0x0
JMP 0x001012c1
LAB_00101248:
TEST AX,AX
JZ 0x00101296
MOVSX RAX,byte ptr [RBX + -0x1]
TEST byte ptr [RDX + RAX*0x2 + 0x1],0x1
JZ 0x00101296
MOVSX RAX,byte ptr [RBX + 0x1]
TEST byte ptr [RDX + RAX*0x2 + 0x1],0x2
JZ 0x00101296
LEA EAX,[R12 + 0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RAX,R12D
MOV byte ptr [R13 + RAX*0x1],0x5f
CALL 0x00101100
MOV RDX,RAX
ADD R12D,0x2
MOVSXD RAX,dword ptr [RSP + 0xc]
MOV RDX,qword ptr [RDX]
MOV EDX,dword ptr [RDX + R15*0x4]
MOV byte ptr [R13 + RAX*0x1],DL
JMP 0x001012b5
LAB_00101296:
CALL 0x00101100
MOV RDX,RAX
MOVSXD RAX,R12D
MOVSX RCX,byte ptr [RBX]
MOV RDX,qword ptr [RDX]
MOV EDX,dword ptr [RDX + RCX*0x4]
MOV byte ptr [R13 + RAX*0x1],DL
LEA R12D,[R12 + 0x1]
LAB_001012b5:
ADD EBP,0x1
ADD RBX,0x1
CMP EBP,R14D
JZ 0x00101324
LAB_001012c1:
TEST EBP,EBP
JLE 0x00101296
CALL 0x00101110
MOV RDX,qword ptr [RAX]
MOVSX R15,byte ptr [RBX]
MOVZX EAX,word ptr [RDX + R15*0x2]
AND AX,0x100
JZ 0x00101296
MOVSX RSI,byte ptr [RBX + -0x1]
TEST word ptr [RDX + RSI*0x2],0xa00
JZ 0x00101248
LEA EAX,[R12 + 0x1]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RAX,R12D
MOV byte ptr [R13 + RAX*0x1],0x5f
CALL 0x00101100
MOV RDX,RAX
ADD R12D,0x2
MOVSXD RAX,dword ptr [RSP + 0xc]
MOV RDX,qword ptr [RDX]
MOV EDX,dword ptr [RDX + R15*0x4]
MOV byte ptr [R13 + RAX*0x1],DL
JMP 0x001012b5
LAB_0010131e:
MOV R12D,0x0
LAB_00101324:
MOVSXD R12,R12D
MOV byte ptr [R13 + R12*0x1],0x0
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(char *param_1)
{
char cVar1;
ushort *puVar2;
int iVar3;
size_t sVar4;
void *pvVar5;
ushort **ppuVar6;
__int32_t **pp_Var7;
int iVar8;
int iVar9;
sVar4 = strlen(param_1);
pvVar5 = malloc(sVar4 * 2);
if (sVar4 == 0) {
iVar9 = 0;
}
else {
iVar9 = 0;
iVar8 = 0;
do {
if (iVar8 < 1) {
LAB_00101296:
pp_Var7 = __ctype_tolower_loc();
*(char *)((long)pvVar5 + (long)iVar9) = (char)(*pp_Var7)[*param_1];
iVar9 = iVar9 + 1;
}
else {
ppuVar6 = __ctype_b_loc();
puVar2 = *ppuVar6;
cVar1 = *param_1;
if ((puVar2[cVar1] & 0x100) == 0) goto LAB_00101296;
if ((puVar2[param_1[-1]] & 0xa00) == 0) {
if ((((puVar2[cVar1] & 0x100) == 0) ||
((*(byte *)((long)puVar2 + (long)param_1[-1] * 2 + 1) & 1) == 0)) ||
((*(byte *)((long)puVar2 + (long)param_1[1] * 2 + 1) & 2) == 0)) goto LAB_00101296;
iVar3 = iVar9 + 1;
*(int1 *)((long)pvVar5 + (long)iVar9) = 0x5f;
pp_Var7 = __ctype_tolower_loc();
iVar9 = iVar9 + 2;
*(char *)((long)pvVar5 + (long)iVar3) = (char)(*pp_Var7)[cVar1];
}
else {
iVar3 = iVar9 + 1;
*(int1 *)((long)pvVar5 + (long)iVar9) = 0x5f;
pp_Var7 = __ctype_tolower_loc();
iVar9 = iVar9 + 2;
*(char *)((long)pvVar5 + (long)iVar3) = (char)(*pp_Var7)[cVar1];
}
}
iVar8 = iVar8 + 1;
param_1 = param_1 + 1;
} while (iVar8 != (int)sVar4);
}
*(int1 *)((long)pvVar5 + (long)iVar9) = 0;
return pvVar5;
} |
7,626 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else if (i > 0 && isupper(text[i]) && isupper(text[i - 1]) && islower(text[i + 1])) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else {
result[j++] = tolower(text[i]);
}
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_core") == 0);
free(result);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%rdi
mov %rax,0x10(%rsp)
mov %rax,%rbx
callq 10d0 <malloc@plt>
mov %rax,%r13
test %rbx,%rbx
je 1410 <func0+0x120>
callq 10e0 <__ctype_tolower_loc@plt>
xor %ebx,%ebx
xor %ebp,%ebp
mov (%rax),%rax
mov %rax,0x18(%rsp)
jmp 139e <func0+0xae>
nopw 0x0(%rax,%rax,1)
movzbl (%r12,%rbx,1),%eax
mov %ecx,0xc(%rsp)
mov %al,0xb(%rsp)
callq 10f0 <__ctype_b_loc@plt>
mov 0xc(%rsp),%ecx
mov (%rax),%rdi
movsbq 0xb(%rsp),%rax
testb $0x1,0x1(%rdi,%rax,2)
je 13b6 <func0+0xc6>
movsbq -0x1(%r12,%rbx,1),%r9
movzwl (%rdi,%r9,2),%r9d
test $0xa00,%r9w
je 13f0 <func0+0x100>
mov 0x18(%rsp),%rsi
movb $0x5f,(%r14)
add $0x2,%ebp
add $0x1,%rbx
mov (%rsi,%rax,4),%eax
mov %al,(%r15)
movslq %ebp,%rax
lea 0x0(%r13,%rax,1),%r15
cmp %rbx,0x10(%rsp)
je 13d3 <func0+0xe3>
lea 0x1(%rbp),%ecx
movslq %ecx,%rax
lea 0x0(%r13,%rax,1),%r15
movslq %ebp,%rax
lea 0x0(%r13,%rax,1),%r14
test %rbx,%rbx
jne 1340 <func0+0x50>
movsbq (%r12,%rbx,1),%rax
mov 0x18(%rsp),%rdx
mov %ecx,%ebp
add $0x1,%rbx
mov (%rdx,%rax,4),%eax
mov %al,(%r14)
cmp %rbx,0x10(%rsp)
jne 139e <func0+0xae>
movb $0x0,(%r15)
add $0x28,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
test $0x100,%r9w
je 13b6 <func0+0xc6>
movsbq 0x1(%r12,%rbx,1),%r9
testb $0x2,0x1(%rdi,%r9,2)
je 13b6 <func0+0xc6>
jmpq 1379 <func0+0x89>
nopl 0x0(%rax,%rax,1)
mov %rax,%r15
jmp 13d3 <func0+0xe3>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
call _strlen
lea rdi, [rax+rax]
mov [rsp+58h+var_48], rax
mov rbx, rax
call _malloc
mov r14, rax
test rbx, rbx
jz loc_1428
call ___ctype_tolower_loc
xor ebx, ebx
xor r12d, r12d
mov rax, [rax]
mov [rsp+58h+var_40], rax
jmp short loc_13A1
loc_1350:
mov [rsp+58h+var_4C], edx
call ___ctype_b_loc
mov edx, [rsp+58h+var_4C]
mov rsi, [rax]
movsx rax, bpl
test byte ptr [rsi+rax*2+1], 1
jz short loc_13BC
movsxd rdi, edx
lea r9, [r14+rdi]
movsx rdi, byte ptr [r13+rbx-1]
movzx edi, word ptr [rsi+rdi*2]
test di, 0A00h
jz short loc_13F8
mov rcx, [rsp+58h+var_40]
mov byte ptr [r15], 5Fh ; '_'
add r12d, 2
mov eax, [rcx+rax*4]
mov [r9], al
loc_1396:
add rbx, 1
cmp [rsp+58h+var_48], rbx
jz short loc_13D5
loc_13A1:
movzx ebp, byte ptr [r13+rbx+0]
movsxd rax, r12d
lea edx, [r12+1]
lea r15, [r14+rax]
movsx rax, bpl
test rbx, rbx
jnz short loc_1350
loc_13BC:
mov rcx, [rsp+58h+var_40]
mov r12d, edx
add rbx, 1
mov eax, [rcx+rax*4]
mov [r15], al
cmp [rsp+58h+var_48], rbx
jnz short loc_13A1
loc_13D5:
movsxd r12, r12d
add r12, r14
loc_13DB:
mov byte ptr [r12], 0
add rsp, 28h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13F8:
test di, 100h
jz short loc_13BC
movsx rdi, byte ptr [r13+rbx+1]
test byte ptr [rsi+rdi*2+1], 2
jz short loc_13BC
mov rsi, [rsp+58h+var_40]
mov byte ptr [r15], 5Fh ; '_'
add r12d, 2
mov eax, [rsi+rax*4]
mov [r9], al
jmp loc_1396
loc_1428:
mov r12, rax
jmp short loc_13DB | long long func0(long long a1)
{
long long v2; // rax
long long v3; // r14
long long v4; // rbx
int v5; // r12d
long long *v6; // rax
int v7; // edx
long long v8; // rsi
long long v9; // rax
_BYTE *v10; // r9
__int16 v11; // di
char v12; // bp
_BYTE *v13; // r15
_BYTE *v14; // r12
long long v16; // [rsp+10h] [rbp-48h]
long long v17; // [rsp+18h] [rbp-40h]
v16 = strlen();
v2 = malloc(2 * v16);
v3 = v2;
if ( !v16 )
{
v14 = (_BYTE *)v2;
goto LABEL_10;
}
v4 = 0LL;
v5 = 0;
v17 = *(_QWORD *)__ctype_tolower_loc();
do
{
while ( 1 )
{
v12 = *(_BYTE *)(a1 + v4);
v7 = v5 + 1;
v13 = (_BYTE *)(v3 + v5);
v9 = v12;
if ( !v4 )
goto LABEL_8;
v6 = (long long *)__ctype_b_loc();
v7 = v5 + 1;
v8 = *v6;
v9 = v12;
if ( (*(_BYTE *)(v8 + 2LL * v12 + 1) & 1) == 0 )
goto LABEL_8;
v10 = (_BYTE *)(v3 + v7);
v11 = *(_WORD *)(v8 + 2LL * *(char *)(a1 + v4 - 1));
if ( (v11 & 0xA00) == 0 )
break;
*v13 = 95;
v5 += 2;
*v10 = *(_DWORD *)(v17 + 4LL * v12);
LABEL_6:
if ( v16 == ++v4 )
goto LABEL_9;
}
if ( (v11 & 0x100) != 0 && (*(_BYTE *)(v8 + 2LL * *(char *)(a1 + v4 + 1) + 1) & 2) != 0 )
{
*v13 = 95;
v5 += 2;
*v10 = *(_DWORD *)(v17 + 4LL * v12);
goto LABEL_6;
}
LABEL_8:
v5 = v7;
++v4;
*v13 = *(_DWORD *)(v17 + 4 * v9);
}
while ( v16 != v4 );
LABEL_9:
v14 = (_BYTE *)(v3 + v5);
LABEL_10:
*v14 = 0;
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
CALL 0x001010c0
LEA RDI,[RAX + RAX*0x1]
MOV qword ptr [RSP + 0x10],RAX
MOV RBX,RAX
CALL 0x001010f0
MOV R14,RAX
TEST RBX,RBX
JZ 0x00101428
CALL 0x00101100
XOR EBX,EBX
XOR R12D,R12D
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001013a1
LAB_00101350:
MOV dword ptr [RSP + 0xc],EDX
CALL 0x00101110
MOV EDX,dword ptr [RSP + 0xc]
MOV RSI,qword ptr [RAX]
MOVSX RAX,BPL
TEST byte ptr [RSI + RAX*0x2 + 0x1],0x1
JZ 0x001013bc
MOVSXD RDI,EDX
LEA R9,[R14 + RDI*0x1]
MOVSX RDI,byte ptr [R13 + RBX*0x1 + -0x1]
MOVZX EDI,word ptr [RSI + RDI*0x2]
TEST DI,0xa00
JZ 0x001013f8
MOV RCX,qword ptr [RSP + 0x18]
MOV byte ptr [R15],0x5f
ADD R12D,0x2
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV byte ptr [R9],AL
LAB_00101396:
ADD RBX,0x1
CMP qword ptr [RSP + 0x10],RBX
JZ 0x001013d5
LAB_001013a1:
MOVZX EBP,byte ptr [R13 + RBX*0x1]
MOVSXD RAX,R12D
LEA EDX,[R12 + 0x1]
LEA R15,[R14 + RAX*0x1]
MOVSX RAX,BPL
TEST RBX,RBX
JNZ 0x00101350
LAB_001013bc:
MOV RCX,qword ptr [RSP + 0x18]
MOV R12D,EDX
ADD RBX,0x1
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV byte ptr [R15],AL
CMP qword ptr [RSP + 0x10],RBX
JNZ 0x001013a1
LAB_001013d5:
MOVSXD R12,R12D
ADD R12,R14
LAB_001013db:
MOV byte ptr [R12],0x0
ADD RSP,0x28
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013f8:
TEST DI,0x100
JZ 0x001013bc
MOVSX RDI,byte ptr [R13 + RBX*0x1 + 0x1]
TEST byte ptr [RSI + RDI*0x2 + 0x1],0x2
JZ 0x001013bc
MOV RSI,qword ptr [RSP + 0x18]
MOV byte ptr [R15],0x5f
ADD R12D,0x2
MOV EAX,dword ptr [RSI + RAX*0x4]
MOV byte ptr [R9],AL
JMP 0x00101396
LAB_00101428:
MOV R12,RAX
JMP 0x001013db | int1 * func0(char *param_1)
{
int iVar1;
char cVar2;
__int32_t *p_Var3;
ushort *puVar4;
size_t sVar5;
int1 *puVar6;
__int32_t **pp_Var7;
ushort **ppuVar8;
long lVar9;
size_t sVar10;
int iVar11;
int1 *puVar12;
sVar5 = strlen(param_1);
puVar6 = (int1 *)malloc(sVar5 * 2);
puVar12 = puVar6;
if (sVar5 != 0) {
pp_Var7 = __ctype_tolower_loc();
sVar10 = 0;
p_Var3 = *pp_Var7;
iVar11 = 0;
do {
while( true ) {
cVar2 = param_1[sVar10];
iVar1 = iVar11 + 1;
puVar12 = puVar6 + iVar11;
if (sVar10 != 0) break;
LAB_001013bc:
sVar10 = sVar10 + 1;
*puVar12 = (char)p_Var3[cVar2];
iVar11 = iVar1;
if (sVar5 == sVar10) goto LAB_001013d5;
}
ppuVar8 = __ctype_b_loc();
puVar4 = *ppuVar8;
lVar9 = (long)cVar2;
if ((*(byte *)((long)puVar4 + lVar9 * 2 + 1) & 1) == 0) goto LAB_001013bc;
if ((puVar4[param_1[sVar10 - 1]] & 0xa00) == 0) {
if (((puVar4[param_1[sVar10 - 1]] & 0x100) == 0) ||
((*(byte *)((long)puVar4 + (long)param_1[sVar10 + 1] * 2 + 1) & 2) == 0))
goto LAB_001013bc;
*puVar12 = 0x5f;
puVar6[iVar1] = (char)p_Var3[lVar9];
}
else {
*puVar12 = 0x5f;
puVar6[iVar1] = (char)p_Var3[lVar9];
}
iVar11 = iVar11 + 2;
sVar10 = sVar10 + 1;
} while (sVar5 != sVar10);
LAB_001013d5:
puVar12 = puVar6 + iVar11;
}
*puVar12 = 0;
return puVar6;
} |
7,627 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else if (i > 0 && isupper(text[i]) && isupper(text[i - 1]) && islower(text[i + 1])) {
result[j++] = '_';
result[j++] = tolower(text[i]);
} else {
result[j++] = tolower(text[i]);
}
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_core") == 0);
free(result);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%rdi
mov %rax,0x10(%rsp)
mov %rax,%rbx
callq 10d0 <malloc@plt>
mov %rax,%r13
test %rbx,%rbx
je 1410 <func0+0x120>
callq 10e0 <__ctype_tolower_loc@plt>
xor %ebx,%ebx
xor %ebp,%ebp
mov (%rax),%rax
mov %rax,0x18(%rsp)
jmp 139e <func0+0xae>
nopw 0x0(%rax,%rax,1)
movzbl (%r12,%rbx,1),%eax
mov %ecx,0xc(%rsp)
mov %al,0xb(%rsp)
callq 10f0 <__ctype_b_loc@plt>
mov 0xc(%rsp),%ecx
mov (%rax),%rdi
movsbq 0xb(%rsp),%rax
testb $0x1,0x1(%rdi,%rax,2)
je 13b6 <func0+0xc6>
movsbq -0x1(%r12,%rbx,1),%r9
movzwl (%rdi,%r9,2),%r9d
test $0xa00,%r9w
je 13f0 <func0+0x100>
mov 0x18(%rsp),%rsi
movb $0x5f,(%r14)
add $0x2,%ebp
add $0x1,%rbx
mov (%rsi,%rax,4),%eax
mov %al,(%r15)
movslq %ebp,%rax
lea 0x0(%r13,%rax,1),%r15
cmp %rbx,0x10(%rsp)
je 13d3 <func0+0xe3>
lea 0x1(%rbp),%ecx
movslq %ecx,%rax
lea 0x0(%r13,%rax,1),%r15
movslq %ebp,%rax
lea 0x0(%r13,%rax,1),%r14
test %rbx,%rbx
jne 1340 <func0+0x50>
movsbq (%r12,%rbx,1),%rax
mov 0x18(%rsp),%rdx
mov %ecx,%ebp
add $0x1,%rbx
mov (%rdx,%rax,4),%eax
mov %al,(%r14)
cmp %rbx,0x10(%rsp)
jne 139e <func0+0xae>
movb $0x0,(%r15)
add $0x28,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
test $0x100,%r9w
je 13b6 <func0+0xc6>
movsbq 0x1(%r12,%rbx,1),%r9
testb $0x2,0x1(%rdi,%r9,2)
je 13b6 <func0+0xc6>
jmpq 1379 <func0+0x89>
nopl 0x0(%rax,%rax,1)
mov %rax,%r15
jmp 13d3 <func0+0xe3>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
call _strlen
lea rdi, [rax+rax]; size
mov [rsp+58h+var_48], rax
mov rbx, rax
call _malloc
mov r14, rax
test rbx, rbx
jz loc_1418
call ___ctype_tolower_loc
xor ebx, ebx
xor r15d, r15d
mov rax, [rax]
mov [rsp+58h+var_40], rax
nop dword ptr [rax+00000000h]
loc_1350:
movzx ebp, byte ptr [r12+rbx]
movsxd rax, r15d
lea r13d, [r15+1]
lea rdx, [r14+rax]
movsx rax, bpl
test rbx, rbx
jz short loc_13C0
mov [rsp+58h+var_50], rdx
call ___ctype_b_loc
mov rdx, [rsp+58h+var_50]
mov rdi, [rax]
movsx rax, bpl
test byte ptr [rdi+rax*2+1], 1
jz short loc_13C0
movsxd r8, r13d
lea r9, [r14+r8]
movsx r8, byte ptr [r12+rbx-1]
movzx r8d, word ptr [rdi+r8*2]
test r8w, 0A00h
jnz short loc_1400
test r8w, 100h
jz short loc_13C0
movsx r8, byte ptr [r12+rbx+1]
test byte ptr [rdi+r8*2+1], 2
jnz short loc_1400
nop word ptr [rax+rax+00000000h]
loc_13C0:
mov rcx, [rsp+58h+var_40]
mov r15d, r13d
mov eax, [rcx+rax*4]
mov [rdx], al
loc_13CD:
add rbx, 1
cmp [rsp+58h+var_48], rbx
jnz loc_1350
movsxd r15, r15d
add r15, r14
loc_13E2:
mov byte ptr [r15], 0
add rsp, 28h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1400:
mov rsi, [rsp+58h+var_40]
mov byte ptr [rdx], 5Fh ; '_'
add r15d, 2
mov eax, [rsi+rax*4]
mov [r9], al
jmp short loc_13CD
loc_1418:
mov r15, rax
jmp short loc_13E2 | _BYTE * func0(const char *a1)
{
_BYTE *v2; // rax
_BYTE *v3; // r14
long long v4; // rbx
int v5; // r15d
char v6; // bp
int v7; // r13d
_BYTE *v8; // rdx
long long v9; // rax
const unsigned __int16 **v10; // rax
const unsigned __int16 *v11; // rdi
unsigned __int16 v12; // r8
_BYTE *v13; // r15
size_t v15; // [rsp+10h] [rbp-48h]
const __int32_t *v16; // [rsp+18h] [rbp-40h]
v15 = strlen(a1);
v2 = malloc(2 * v15);
v3 = v2;
if ( v15 )
{
v4 = 0LL;
v5 = 0;
v16 = *__ctype_tolower_loc();
do
{
v6 = a1[v4];
v7 = v5 + 1;
v8 = &v3[v5];
v9 = v6;
if ( v4
&& (v10 = __ctype_b_loc(), v8 = &v3[v5], v11 = *v10, v9 = v6, (v11[v6] & 0x100) != 0)
&& ((v12 = v11[a1[v4 - 1]], (v12 & 0xA00) != 0) || (v12 & 0x100) != 0 && (v11[a1[v4 + 1]] & 0x200) != 0) )
{
v3[v5] = 95;
v5 += 2;
v3[v7] = v16[v6];
}
else
{
++v5;
*v8 = v16[v9];
}
++v4;
}
while ( v15 != v4 );
v13 = &v3[v5];
}
else
{
v13 = v2;
}
*v13 = 0;
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
CALL 0x001010c0
LEA RDI,[RAX + RAX*0x1]
MOV qword ptr [RSP + 0x10],RAX
MOV RBX,RAX
CALL 0x001010f0
MOV R14,RAX
TEST RBX,RBX
JZ 0x00101418
CALL 0x00101100
XOR EBX,EBX
XOR R15D,R15D
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x18],RAX
NOP dword ptr [RAX]
LAB_00101350:
MOVZX EBP,byte ptr [R12 + RBX*0x1]
MOVSXD RAX,R15D
LEA R13D,[R15 + 0x1]
LEA RDX,[R14 + RAX*0x1]
MOVSX RAX,BPL
TEST RBX,RBX
JZ 0x001013c0
MOV qword ptr [RSP + 0x8],RDX
CALL 0x00101110
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
MOVSX RAX,BPL
TEST byte ptr [RDI + RAX*0x2 + 0x1],0x1
JZ 0x001013c0
MOVSXD R8,R13D
LEA R9,[R14 + R8*0x1]
MOVSX R8,byte ptr [R12 + RBX*0x1 + -0x1]
MOVZX R8D,word ptr [RDI + R8*0x2]
TEST R8W,0xa00
JNZ 0x00101400
TEST R8W,0x100
JZ 0x001013c0
MOVSX R8,byte ptr [R12 + RBX*0x1 + 0x1]
TEST byte ptr [RDI + R8*0x2 + 0x1],0x2
JNZ 0x00101400
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013c0:
MOV RCX,qword ptr [RSP + 0x18]
MOV R15D,R13D
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV byte ptr [RDX],AL
LAB_001013cd:
ADD RBX,0x1
CMP qword ptr [RSP + 0x10],RBX
JNZ 0x00101350
MOVSXD R15,R15D
ADD R15,R14
LAB_001013e2:
MOV byte ptr [R15],0x0
ADD RSP,0x28
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101400:
MOV RSI,qword ptr [RSP + 0x18]
MOV byte ptr [RDX],0x5f
ADD R15D,0x2
MOV EAX,dword ptr [RSI + RAX*0x4]
MOV byte ptr [R9],AL
JMP 0x001013cd
LAB_00101418:
MOV R15,RAX
JMP 0x001013e2 | int * func0(char *param_1)
{
int iVar1;
char cVar2;
__int32_t *p_Var3;
ushort *puVar4;
size_t sVar5;
int *puVar6;
__int32_t **pp_Var7;
ushort **ppuVar8;
size_t sVar9;
int iVar10;
int *puVar11;
sVar5 = strlen(param_1);
puVar6 = (int *)malloc(sVar5 * 2);
puVar11 = puVar6;
if (sVar5 != 0) {
pp_Var7 = __ctype_tolower_loc();
sVar9 = 0;
iVar10 = 0;
p_Var3 = *pp_Var7;
do {
cVar2 = param_1[sVar9];
iVar1 = iVar10 + 1;
if (sVar9 == 0) {
LAB_001013c0:
puVar6[iVar10] = (char)p_Var3[cVar2];
iVar10 = iVar1;
}
else {
ppuVar8 = __ctype_b_loc();
puVar4 = *ppuVar8;
if ((*(byte *)((long)puVar4 + (long)cVar2 * 2 + 1) & 1) == 0) goto LAB_001013c0;
if (((puVar4[param_1[sVar9 - 1]] & 0xa00) == 0) &&
(((puVar4[param_1[sVar9 - 1]] & 0x100) == 0 ||
((*(byte *)((long)puVar4 + (long)param_1[sVar9 + 1] * 2 + 1) & 2) == 0))))
goto LAB_001013c0;
puVar6[iVar10] = 0x5f;
iVar10 = iVar10 + 2;
puVar6[iVar1] = (char)p_Var3[cVar2];
}
sVar9 = sVar9 + 1;
} while (sVar5 != sVar9);
puVar11 = puVar6 + iVar10;
}
*puVar11 = 0;
return puVar6;
} |
7,628 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
je 1168 <func0+0x1f>
cmpl $0x0,-0x14(%rbp)
jne 116f <func0+0x26>
mov $0x1,%eax
jmp 11ae <func0+0x65>
mov -0x18(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x14(%rbp),%eax
mov %eax,%esi
mov %edx,%edi
callq 1149 <func0>
mov %eax,%ebx
mov -0x14(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%eax
sub $0x1,%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
add %eax,%ebx
mov -0x14(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
add %ebx,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
cmp [rbp+var_18], 0
jz short loc_1168
cmp [rbp+var_14], 0
jnz short loc_116F
loc_1168:
mov eax, 1
jmp short loc_11AE
loc_116F:
mov eax, [rbp+var_18]
lea edx, [rax-1]
mov eax, [rbp+var_14]
mov esi, eax
mov edi, edx
call func0
mov ebx, eax
mov eax, [rbp+var_14]
lea edx, [rax-1]
mov eax, [rbp+var_18]
sub eax, 1
mov esi, edx
mov edi, eax
call func0
add ebx, eax
mov eax, [rbp+var_14]
lea edx, [rax-1]
mov eax, [rbp+var_18]
mov esi, edx
mov edi, eax
call func0
add eax, ebx
loc_11AE:
mov rbx, [rbp+var_8]
leave
retn | long long func0(unsigned int a1, unsigned int a2)
{
int v3; // ebx
int v4; // ebx
if ( !a2 || !a1 )
return 1LL;
v3 = func0(a2 - 1, a1);
v4 = func0(a2 - 1, a1 - 1) + v3;
return v4 + (unsigned int)func0(a2, a1 - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
CMP dword ptr [RBP + -0x18],0x0
JZ 0x00101168
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010116f
LAB_00101168:
MOV EAX,0x1
JMP 0x001011ae
LAB_0010116f:
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EAX
MOV EDI,EDX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
ADD EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x18]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
ADD EAX,EBX
LAB_001011ae:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if ((param_2 == 0) || (param_1 == 0)) {
iVar3 = 1;
}
else {
iVar1 = func0(param_2 + -1,param_1);
iVar2 = func0(param_2 + -1,param_1 + -1);
iVar3 = func0(param_2,param_1 + -1);
iVar3 = iVar3 + iVar1 + iVar2;
}
return iVar3;
} |
7,629 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
je 11a0 <func0+0x57>
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %esi,%ebp
mov $0x1,%eax
test %edi,%edi
je 1195 <func0+0x4c>
lea -0x1(%rsi),%r13d
mov %edi,%esi
mov %r13d,%edi
callq 1149 <func0>
mov %eax,%r12d
sub $0x1,%ebx
mov %ebx,%esi
mov %r13d,%edi
callq 1149 <func0>
add %eax,%r12d
mov %ebx,%esi
mov %ebp,%edi
callq 1149 <func0>
add %r12d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jz short loc_11A0
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov ebp, esi
mov eax, 1
test edi, edi
jz short loc_1195
lea r13d, [rsi-1]
mov esi, edi
mov edi, r13d
call func0
mov r12d, eax
sub ebx, 1
mov esi, ebx
mov edi, r13d
call func0
add r12d, eax
mov esi, ebx
mov edi, ebp
call func0
add eax, r12d
loc_1195:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11A0:
mov eax, 1
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
int v4; // r12d
if ( !a2 )
return 1LL;
result = 1LL;
if ( a1 )
{
v3 = func0(a2 - 1, a1);
v4 = func0(a2 - 1, a1 - 1) + v3;
return v4 + (unsigned int)func0(a2, a1 - 1);
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JZ 0x001011a0
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV EBP,ESI
MOV EAX,0x1
TEST EDI,EDI
JZ 0x00101195
LEA R13D,[RSI + -0x1]
MOV ESI,EDI
MOV EDI,R13D
CALL 0x00101149
MOV R12D,EAX
SUB EBX,0x1
MOV ESI,EBX
MOV EDI,R13D
CALL 0x00101149
ADD R12D,EAX
MOV ESI,EBX
MOV EDI,EBP
CALL 0x00101149
ADD EAX,R12D
LAB_00101195:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011a0:
MOV EAX,0x1
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 != 0) {
iVar3 = 1;
if (param_1 != 0) {
iVar1 = func0(param_2 + -1,param_1);
iVar2 = func0(param_2 + -1,param_1 + -1);
iVar3 = func0(param_2,param_1 + -1);
iVar3 = iVar3 + iVar1 + iVar2;
}
return iVar3;
}
return 1;
} |
7,630 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
je 1278 <func0+0x78>
push %r15
mov $0x1,%eax
push %r14
xor %r14d,%r14d
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %edi,%ebp
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 1264 <func0+0x64>
lea -0x1(%r12),%r15d
mov %ebp,%esi
lea -0x1(%rbp),%r13d
mov %r12d,%ebp
mov %r15d,%edi
callq 1200 <func0>
mov %r13d,%esi
mov %r15d,%edi
mov %eax,%ebx
callq 1200 <func0>
add %eax,%ebx
add %ebx,%r14d
test %r13d,%r13d
je 1260 <func0+0x60>
mov %r13d,%r12d
jmp 1227 <func0+0x27>
nopl 0x0(%rax)
lea 0x1(%r14),%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_4C], edi
mov [rsp+98h+var_48], esi
test edi, edi
jz loc_1FF1
mov [rsp+98h+var_3C], 0
test esi, esi
jz loc_1FF1
loc_1232:
mov eax, [rsp+98h+var_48]
sub eax, 1
mov [rsp+98h+var_64], eax
setz [rsp+98h+var_41]
jz loc_1FE4
mov eax, [rsp+98h+var_64]
mov [rsp+98h+var_50], 0
mov [rsp+98h+var_5C], eax
mov eax, [rsp+98h+var_4C]
mov [rsp+98h+var_60], eax
loc_1260:
mov eax, [rsp+98h+var_60]
sub eax, 1
mov [rsp+98h+var_7C], eax
setz byte ptr [rsp+98h+var_58]
jz loc_1FA7
mov eax, [rsp+98h+var_7C]
mov [rsp+98h+var_68], 0
mov [rsp+98h+var_74], eax
mov eax, [rsp+98h+var_5C]
mov [rsp+98h+var_78], eax
loc_128E:
mov eax, [rsp+98h+var_78]
sub eax, 1
mov [rsp+98h+var_98], eax
setz byte ptr [rsp+98h+var_6C]
jz loc_18B0
mov eax, [rsp+98h+var_98]
mov [rsp+98h+var_80], 0
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_74]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jz loc_13AE
loc_12CC:
mov r12d, [rsp+98h+var_90]
xor r15d, r15d
mov [rsp+98h+var_8C], ebx
mov r13d, ebx
mov ebx, r15d
mov r15d, r12d
loc_12E1:
lea r12d, [r15-1]
mov esi, r13d
lea r14d, [r13-1]
mov r13d, r15d
mov edi, r12d
call func0
mov esi, r14d
mov edi, r12d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1318
mov r15d, r14d
jmp short loc_12E1
loc_1318:
mov r15d, ebx
mov ebx, [rsp+98h+var_8C]
lea eax, [r15+1]
mov [rsp+98h+var_88], eax
loc_1327:
mov eax, [rsp+98h+var_90]
lea r12d, [rax-1]
mov [rsp+98h+var_8C], r12d
cmp eax, 1
jz loc_13C0
cmp byte ptr [rsp+98h+var_84], 0
jnz short loc_13C0
xor ebp, ebp
loc_1346:
lea r15d, [r12-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r12d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r13d, eax
call func0
add r13d, eax
add ebp, r13d
test r14d, r14d
jz short loc_1380
mov r12d, r14d
jmp short loc_1346
loc_1380:
mov eax, [rsp+98h+var_88]
lea eax, [rbp+rax+1]
add [rsp+98h+var_80], eax
loc_138C:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_8C]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jnz loc_12CC
loc_13AE:
mov [rsp+98h+var_88], 1
jmp loc_1327
loc_13C0:
mov eax, [rsp+98h+var_80]
mov edx, [rsp+98h+var_88]
mov r15d, [rsp+98h+var_8C]
lea eax, [rax+rdx+1]
mov [rsp+98h+var_80], eax
test r15d, r15d
jnz short loc_138C
mov eax, [rsp+98h+var_80]
add eax, 1
mov [rsp+98h+var_70], eax
loc_13E5:
mov eax, [rsp+98h+var_74]
lea edx, [rax-1]
mov [rsp+98h+var_80], edx
cmp eax, 1
jz loc_1550
cmp byte ptr [rsp+98h+var_6C], 0
jnz loc_1550
mov [rsp+98h+var_94], edx
mov ebx, [rsp+98h+var_94]
mov [rsp+98h+var_84], 0
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jz loc_14FD
loc_1422:
mov r13d, [rsp+98h+var_98]
xor r15d, r15d
mov [rsp+98h+var_90], ebx
mov r12d, ebx
mov ebx, r15d
mov r15d, r13d
loc_1436:
lea r13d, [r15-1]
mov esi, r12d
lea r14d, [r12-1]
mov r12d, r15d
mov edi, r13d
call func0
mov esi, r14d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1470
mov r15d, r14d
jmp short loc_1436
loc_1470:
mov r15d, ebx
mov ebx, [rsp+98h+var_90]
lea eax, [r15+1]
mov [rsp+98h+var_8C], eax
loc_147F:
mov eax, [rsp+98h+var_98]
lea r13d, [rax-1]
mov [rsp+98h+var_90], r13d
cmp eax, 1
jz loc_1510
cmp byte ptr [rsp+98h+var_88], 0
jnz short loc_1510
xor ebp, ebp
loc_149D:
lea r15d, [r13-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r13d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r12d, eax
call func0
add r12d, eax
add ebp, r12d
test r14d, r14d
jz short loc_14D0
mov r13d, r14d
jmp short loc_149D
loc_14D0:
mov eax, [rsp+98h+var_8C]
lea eax, [rbp+rax+1]
add [rsp+98h+var_84], eax
loc_14DC:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_98], eax
mov eax, [rsp+98h+var_90]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jnz loc_1422
loc_14FD:
mov [rsp+98h+var_8C], 1
jmp loc_147F
loc_1510:
mov eax, [rsp+98h+var_84]
mov ecx, [rsp+98h+var_8C]
mov r13d, [rsp+98h+var_90]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_84], eax
test r13d, r13d
jnz short loc_14DC
mov eax, [rsp+98h+var_84]
mov edx, [rsp+98h+var_70]
lea eax, [rax+rdx+1]
add [rsp+98h+var_68], eax
loc_153A:
mov eax, [rsp+98h+var_78]
mov [rsp+98h+var_74], eax
mov eax, [rsp+98h+var_80]
mov [rsp+98h+var_78], eax
jmp loc_128E
loc_1550:
mov eax, [rsp+98h+var_68]
mov edx, [rsp+98h+var_70]
mov r14d, [rsp+98h+var_80]
lea eax, [rax+rdx+1]
mov [rsp+98h+var_68], eax
test r14d, r14d
jnz short loc_153A
mov eax, [rsp+98h+var_68]
add eax, 1
mov [rsp+98h+var_54], eax
loc_1575:
mov eax, [rsp+98h+var_5C]
lea edx, [rax-1]
mov [rsp+98h+var_68], edx
cmp eax, 1
jz loc_18BD
cmp byte ptr [rsp+98h+var_58], 0
jnz loc_18BD
mov [rsp+98h+var_78], edx
mov [rsp+98h+var_6C], 0
loc_15A0:
mov eax, [rsp+98h+var_78]
sub eax, 1
mov [rsp+98h+var_98], eax
setz byte ptr [rsp+98h+var_70]
jz loc_18A0
mov eax, [rsp+98h+var_98]
mov [rsp+98h+var_80], 0
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_7C]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jz loc_16BE
loc_15DE:
mov r12d, [rsp+98h+var_90]
xor r15d, r15d
mov [rsp+98h+var_8C], ebx
mov r13d, ebx
mov ebx, r15d
mov r15d, r12d
loc_15F3:
lea r12d, [r15-1]
mov esi, r13d
lea r14d, [r13-1]
mov r13d, r15d
mov edi, r12d
call func0
mov esi, r14d
mov edi, r12d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1628
mov r15d, r14d
jmp short loc_15F3
loc_1628:
mov r15d, ebx
mov ebx, [rsp+98h+var_8C]
lea eax, [r15+1]
mov [rsp+98h+var_88], eax
loc_1637:
mov eax, [rsp+98h+var_90]
lea r12d, [rax-1]
mov [rsp+98h+var_8C], r12d
cmp eax, 1
jz loc_16D0
cmp byte ptr [rsp+98h+var_84], 0
jnz short loc_16D0
xor ebp, ebp
loc_1656:
lea r15d, [r12-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r12d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r13d, eax
call func0
add r13d, eax
add ebp, r13d
test r14d, r14d
jz short loc_1690
mov r12d, r14d
jmp short loc_1656
loc_1690:
mov eax, [rsp+98h+var_88]
lea eax, [rbp+rax+1]
add [rsp+98h+var_80], eax
loc_169C:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_8C]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jnz loc_15DE
loc_16BE:
mov [rsp+98h+var_88], 1
jmp loc_1637
loc_16D0:
mov eax, [rsp+98h+var_80]
mov ecx, [rsp+98h+var_88]
mov ebp, [rsp+98h+var_8C]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_80], eax
test ebp, ebp
jnz short loc_169C
mov eax, [rsp+98h+var_80]
add eax, 1
mov [rsp+98h+var_74], eax
loc_16F3:
mov eax, [rsp+98h+var_7C]
lea ecx, [rax-1]
mov [rsp+98h+var_80], ecx
cmp eax, 1
jz loc_1860
cmp byte ptr [rsp+98h+var_70], 0
jnz loc_1860
mov [rsp+98h+var_94], ecx
mov ebx, [rsp+98h+var_94]
mov [rsp+98h+var_84], 0
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jz loc_180D
loc_1730:
mov r13d, [rsp+98h+var_98]
xor r15d, r15d
mov [rsp+98h+var_90], ebx
mov r12d, ebx
mov ebx, r15d
mov r15d, r13d
loc_1744:
lea r13d, [r15-1]
mov esi, r12d
lea r14d, [r12-1]
mov r12d, r15d
mov edi, r13d
call func0
mov esi, r14d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1780
mov r15d, r14d
jmp short loc_1744
loc_1780:
mov r15d, ebx
mov ebx, [rsp+98h+var_90]
lea eax, [r15+1]
mov [rsp+98h+var_8C], eax
loc_178F:
mov eax, [rsp+98h+var_98]
lea r13d, [rax-1]
mov [rsp+98h+var_90], r13d
cmp eax, 1
jz loc_1820
cmp byte ptr [rsp+98h+var_88], 0
jnz short loc_1820
xor ebp, ebp
loc_17AD:
lea r15d, [r13-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r13d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r12d, eax
call func0
add r12d, eax
add ebp, r12d
test r14d, r14d
jz short loc_17E0
mov r13d, r14d
jmp short loc_17AD
loc_17E0:
mov eax, [rsp+98h+var_8C]
lea eax, [rbp+rax+1]
add [rsp+98h+var_84], eax
loc_17EC:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_98], eax
mov eax, [rsp+98h+var_90]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jnz loc_1730
loc_180D:
mov [rsp+98h+var_8C], 1
jmp loc_178F
loc_1820:
mov eax, [rsp+98h+var_84]
mov edx, [rsp+98h+var_8C]
mov r11d, [rsp+98h+var_90]
lea eax, [rax+rdx+1]
mov [rsp+98h+var_84], eax
test r11d, r11d
jnz short loc_17EC
mov eax, [rsp+98h+var_84]
mov ecx, [rsp+98h+var_74]
lea eax, [rax+rcx+1]
add [rsp+98h+var_6C], eax
loc_184A:
mov eax, [rsp+98h+var_78]
mov [rsp+98h+var_7C], eax
mov eax, [rsp+98h+var_80]
mov [rsp+98h+var_78], eax
jmp loc_15A0
loc_1860:
mov eax, [rsp+98h+var_6C]
mov ecx, [rsp+98h+var_74]
mov ebx, [rsp+98h+var_80]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_6C], eax
test ebx, ebx
jnz short loc_184A
mov eax, [rsp+98h+var_6C]
mov edx, [rsp+98h+var_54]
lea eax, [rax+rdx+1]
add [rsp+98h+var_50], eax
loc_1888:
mov eax, [rsp+98h+var_60]
mov [rsp+98h+var_5C], eax
mov eax, [rsp+98h+var_68]
mov [rsp+98h+var_60], eax
jmp loc_1260
loc_18A0:
mov [rsp+98h+var_74], 1
jmp loc_16F3
loc_18B0:
mov [rsp+98h+var_70], 1
jmp loc_13E5
loc_18BD:
mov eax, [rsp+98h+var_50]
mov ecx, [rsp+98h+var_54]
mov r12d, [rsp+98h+var_68]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_50], eax
test r12d, r12d
jnz short loc_1888
mov eax, [rsp+98h+var_50]
add eax, 1
mov [rsp+98h+var_40], eax
loc_18E2:
mov eax, [rsp+98h+var_4C]
lea edx, [rax-1]
mov [rsp+98h+var_50], edx
cmp eax, 1
jz loc_1FB4
cmp [rsp+98h+var_41], 0
jnz loc_1FB4
mov [rsp+98h+var_60], edx
mov [rsp+98h+var_54], 0
loc_190D:
mov eax, [rsp+98h+var_60]
sub eax, 1
mov [rsp+98h+var_7C], eax
setz byte ptr [rsp+98h+var_5C]
jz loc_1F9A
mov eax, [rsp+98h+var_7C]
mov [rsp+98h+var_68], 0
mov [rsp+98h+var_74], eax
mov eax, [rsp+98h+var_64]
mov [rsp+98h+var_78], eax
loc_193B:
mov eax, [rsp+98h+var_78]
sub eax, 1
mov [rsp+98h+var_98], eax
setz byte ptr [rsp+98h+var_6C]
jz loc_1F50
mov eax, [rsp+98h+var_98]
mov [rsp+98h+var_80], 0
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_74]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jz loc_1A4E
loc_1979:
mov r12d, [rsp+98h+var_90]
xor r15d, r15d
mov [rsp+98h+var_8C], ebx
mov r13d, ebx
mov ebx, r15d
mov r15d, r12d
loc_198E:
lea r12d, [r15-1]
mov esi, r13d
lea r14d, [r13-1]
mov r13d, r15d
mov edi, r12d
call func0
mov esi, r14d
mov edi, r12d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_19C0
mov r15d, r14d
jmp short loc_198E
loc_19C0:
mov r15d, ebx
mov ebx, [rsp+98h+var_8C]
lea eax, [r15+1]
mov [rsp+98h+var_88], eax
loc_19CF:
mov eax, [rsp+98h+var_90]
lea r12d, [rax-1]
mov [rsp+98h+var_8C], r12d
cmp eax, 1
jz short loc_1A60
cmp byte ptr [rsp+98h+var_84], 0
jnz short loc_1A60
xor ebp, ebp
loc_19EA:
lea r15d, [r12-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r12d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r13d, eax
call func0
add r13d, eax
add ebp, r13d
test r14d, r14d
jz short loc_1A20
mov r12d, r14d
jmp short loc_19EA
loc_1A20:
mov eax, [rsp+98h+var_88]
lea eax, [rbp+rax+1]
add [rsp+98h+var_80], eax
loc_1A2C:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_8C]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jnz loc_1979
loc_1A4E:
mov [rsp+98h+var_88], 1
jmp loc_19CF
loc_1A60:
mov eax, [rsp+98h+var_80]
mov edx, [rsp+98h+var_88]
mov r9d, [rsp+98h+var_8C]
lea eax, [rax+rdx+1]
mov [rsp+98h+var_80], eax
test r9d, r9d
jnz short loc_1A2C
mov eax, [rsp+98h+var_80]
add eax, 1
mov [rsp+98h+var_70], eax
loc_1A85:
mov eax, [rsp+98h+var_74]
lea edx, [rax-1]
mov [rsp+98h+var_80], edx
cmp eax, 1
jz loc_1BF0
cmp byte ptr [rsp+98h+var_6C], 0
jnz loc_1BF0
mov [rsp+98h+var_94], edx
mov ebx, [rsp+98h+var_94]
mov [rsp+98h+var_84], 0
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jz loc_1B9D
loc_1AC2:
mov r13d, [rsp+98h+var_98]
xor r15d, r15d
mov [rsp+98h+var_90], ebx
mov r12d, ebx
mov ebx, r15d
mov r15d, r13d
loc_1AD6:
lea r13d, [r15-1]
mov esi, r12d
lea r14d, [r12-1]
mov r12d, r15d
mov edi, r13d
call func0
mov esi, r14d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1B10
mov r15d, r14d
jmp short loc_1AD6
loc_1B10:
mov r15d, ebx
mov ebx, [rsp+98h+var_90]
lea eax, [r15+1]
mov [rsp+98h+var_8C], eax
loc_1B1F:
mov eax, [rsp+98h+var_98]
lea r13d, [rax-1]
mov [rsp+98h+var_90], r13d
cmp eax, 1
jz loc_1BB0
cmp byte ptr [rsp+98h+var_88], 0
jnz short loc_1BB0
xor ebp, ebp
loc_1B3D:
lea r15d, [r13-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r13d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r12d, eax
call func0
add r12d, eax
add ebp, r12d
test r14d, r14d
jz short loc_1B70
mov r13d, r14d
jmp short loc_1B3D
loc_1B70:
mov eax, [rsp+98h+var_8C]
lea eax, [rbp+rax+1]
add [rsp+98h+var_84], eax
loc_1B7C:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_98], eax
mov eax, [rsp+98h+var_90]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jnz loc_1AC2
loc_1B9D:
mov [rsp+98h+var_8C], 1
jmp loc_1B1F
loc_1BB0:
mov eax, [rsp+98h+var_84]
mov ecx, [rsp+98h+var_8C]
mov edi, [rsp+98h+var_90]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_84], eax
test edi, edi
jnz short loc_1B7C
mov eax, [rsp+98h+var_84]
mov edx, [rsp+98h+var_70]
lea eax, [rax+rdx+1]
add [rsp+98h+var_68], eax
loc_1BD8:
mov eax, [rsp+98h+var_78]
mov [rsp+98h+var_74], eax
mov eax, [rsp+98h+var_80]
mov [rsp+98h+var_78], eax
jmp loc_193B
loc_1BF0:
mov eax, [rsp+98h+var_68]
mov ecx, [rsp+98h+var_70]
mov r8d, [rsp+98h+var_80]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_68], eax
test r8d, r8d
jnz short loc_1BD8
mov eax, [rsp+98h+var_68]
add eax, 1
mov [rsp+98h+var_58], eax
loc_1C15:
mov eax, [rsp+98h+var_64]
lea ecx, [rax-1]
mov [rsp+98h+var_68], ecx
cmp eax, 1
jz loc_1F5D
cmp byte ptr [rsp+98h+var_5C], 0
jnz loc_1F5D
mov [rsp+98h+var_78], ecx
mov [rsp+98h+var_6C], 0
loc_1C40:
mov eax, [rsp+98h+var_78]
sub eax, 1
mov [rsp+98h+var_98], eax
setz byte ptr [rsp+98h+var_70]
jz loc_1F40
mov eax, [rsp+98h+var_98]
mov [rsp+98h+var_80], 0
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_7C]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jz loc_1D5E
loc_1C7E:
mov r12d, [rsp+98h+var_90]
xor r15d, r15d
mov [rsp+98h+var_8C], ebx
mov r13d, ebx
mov ebx, r15d
mov r15d, r12d
loc_1C93:
lea r12d, [r15-1]
mov esi, r13d
lea r14d, [r13-1]
mov r13d, r15d
mov edi, r12d
call func0
mov esi, r14d
mov edi, r12d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1CC8
mov r15d, r14d
jmp short loc_1C93
loc_1CC8:
mov r15d, ebx
mov ebx, [rsp+98h+var_8C]
lea eax, [r15+1]
mov [rsp+98h+var_88], eax
loc_1CD7:
mov eax, [rsp+98h+var_90]
lea r12d, [rax-1]
mov [rsp+98h+var_8C], r12d
cmp eax, 1
jz loc_1D70
cmp byte ptr [rsp+98h+var_84], 0
jnz short loc_1D70
xor ebp, ebp
loc_1CF6:
lea r15d, [r12-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r12d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r13d, eax
call func0
add r13d, eax
add ebp, r13d
test r14d, r14d
jz short loc_1D30
mov r12d, r14d
jmp short loc_1CF6
loc_1D30:
mov eax, [rsp+98h+var_88]
lea eax, [rbp+rax+1]
add [rsp+98h+var_80], eax
loc_1D3C:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_90], eax
mov eax, [rsp+98h+var_8C]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_84]
jnz loc_1C7E
loc_1D5E:
mov [rsp+98h+var_88], 1
jmp loc_1CD7
loc_1D70:
mov eax, [rsp+98h+var_80]
mov ecx, [rsp+98h+var_88]
lea eax, [rax+rcx+1]
mov ecx, [rsp+98h+var_8C]
mov [rsp+98h+var_80], eax
test ecx, ecx
jnz short loc_1D3C
mov eax, [rsp+98h+var_80]
add eax, 1
mov [rsp+98h+var_74], eax
loc_1D93:
mov eax, [rsp+98h+var_7C]
lea ecx, [rax-1]
mov [rsp+98h+var_80], ecx
cmp eax, 1
jz loc_1F00
cmp byte ptr [rsp+98h+var_70], 0
jnz loc_1F00
mov [rsp+98h+var_94], ecx
mov ebx, [rsp+98h+var_94]
mov [rsp+98h+var_84], 0
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jz loc_1EAD
loc_1DD0:
mov r13d, [rsp+98h+var_98]
xor r15d, r15d
mov [rsp+98h+var_90], ebx
mov r12d, ebx
mov ebx, r15d
mov r15d, r13d
loc_1DE4:
lea r13d, [r15-1]
mov esi, r12d
lea r14d, [r12-1]
mov r12d, r15d
mov edi, r13d
call func0
mov esi, r14d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r14d, r14d
jz short loc_1E20
mov r15d, r14d
jmp short loc_1DE4
loc_1E20:
mov r15d, ebx
mov ebx, [rsp+98h+var_90]
lea eax, [r15+1]
mov [rsp+98h+var_8C], eax
loc_1E2F:
mov eax, [rsp+98h+var_98]
lea r13d, [rax-1]
mov [rsp+98h+var_90], r13d
cmp eax, 1
jz loc_1EC0
cmp byte ptr [rsp+98h+var_88], 0
jnz short loc_1EC0
xor ebp, ebp
loc_1E4D:
lea r15d, [r13-1]
mov esi, ebx
lea r14d, [rbx-1]
mov ebx, r13d
mov edi, r15d
call func0
mov esi, r14d
mov edi, r15d
mov r12d, eax
call func0
add r12d, eax
add ebp, r12d
test r14d, r14d
jz short loc_1E80
mov r13d, r14d
jmp short loc_1E4D
loc_1E80:
mov eax, [rsp+98h+var_8C]
lea eax, [rbp+rax+1]
add [rsp+98h+var_84], eax
loc_1E8C:
mov eax, [rsp+98h+var_94]
mov [rsp+98h+var_98], eax
mov eax, [rsp+98h+var_90]
mov [rsp+98h+var_94], eax
mov ebx, [rsp+98h+var_94]
sub ebx, 1
setz byte ptr [rsp+98h+var_88]
jnz loc_1DD0
loc_1EAD:
mov [rsp+98h+var_8C], 1
jmp loc_1E2F
loc_1EC0:
mov eax, [rsp+98h+var_84]
mov edx, [rsp+98h+var_8C]
lea eax, [rax+rdx+1]
mov [rsp+98h+var_84], eax
mov eax, [rsp+98h+var_90]
test eax, eax
jnz short loc_1E8C
mov eax, [rsp+98h+var_84]
mov ecx, [rsp+98h+var_74]
lea eax, [rax+rcx+1]
add [rsp+98h+var_6C], eax
loc_1EE8:
mov eax, [rsp+98h+var_78]
mov [rsp+98h+var_7C], eax
mov eax, [rsp+98h+var_80]
mov [rsp+98h+var_78], eax
jmp loc_1C40
loc_1F00:
mov eax, [rsp+98h+var_6C]
mov edx, [rsp+98h+var_74]
lea eax, [rax+rdx+1]
mov edx, [rsp+98h+var_80]
mov [rsp+98h+var_6C], eax
test edx, edx
jnz short loc_1EE8
mov eax, [rsp+98h+var_6C]
mov ecx, [rsp+98h+var_58]
lea eax, [rax+rcx+1]
add [rsp+98h+var_54], eax
loc_1F28:
mov eax, [rsp+98h+var_60]
mov [rsp+98h+var_64], eax
mov eax, [rsp+98h+var_68]
mov [rsp+98h+var_60], eax
jmp loc_190D
loc_1F40:
mov [rsp+98h+var_74], 1
jmp loc_1D93
loc_1F50:
mov [rsp+98h+var_70], 1
jmp loc_1A85
loc_1F5D:
mov eax, [rsp+98h+var_54]
mov ecx, [rsp+98h+var_58]
mov esi, [rsp+98h+var_68]
lea eax, [rax+rcx+1]
mov [rsp+98h+var_54], eax
test esi, esi
jnz short loc_1F28
mov eax, [rsp+98h+var_54]
mov ecx, [rsp+98h+var_40]
lea eax, [rax+rcx+1]
add [rsp+98h+var_3C], eax
loc_1F85:
mov eax, [rsp+98h+var_48]
mov [rsp+98h+var_4C], eax
mov eax, [rsp+98h+var_50]
mov [rsp+98h+var_48], eax
jmp loc_1232
loc_1F9A:
mov [rsp+98h+var_58], 1
jmp loc_1C15
loc_1FA7:
mov [rsp+98h+var_54], 1
jmp loc_1575
loc_1FB4:
mov eax, [rsp+98h+var_3C]
mov edx, [rsp+98h+var_40]
mov r10d, [rsp+98h+var_50]
lea eax, [rax+rdx+1]
mov [rsp+98h+var_3C], eax
test r10d, r10d
jnz short loc_1F85
mov eax, [rsp+98h+var_3C]
add rsp, 68h
pop rbx
pop rbp
add eax, 1
pop r12
pop r13
pop r14
pop r15
retn
loc_1FE4:
mov [rsp+98h+var_40], 1
jmp loc_18E2
loc_1FF1:
add rsp, 68h
mov eax, 1
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1, int a2)
{
unsigned int v2; // ebx
unsigned int v3; // r13d
int v4; // ebx
int i; // r15d
long long v6; // rsi
unsigned int v7; // r14d
int v8; // ebp
int v9; // r15d
unsigned int v10; // r12d
int v11; // ebp
long long v12; // rsi
unsigned int v13; // r14d
int v14; // r13d
unsigned int v15; // ebx
unsigned int v16; // r12d
int v17; // ebx
int j; // r15d
long long v19; // rsi
unsigned int v20; // r14d
int v21; // ebp
int v22; // r15d
unsigned int v23; // r13d
int v24; // ebp
long long v25; // rsi
unsigned int v26; // r14d
int v27; // r12d
unsigned int v28; // ebx
unsigned int v29; // r13d
int v30; // ebx
int k; // r15d
long long v32; // rsi
unsigned int v33; // r14d
int v34; // ebp
int v35; // r15d
unsigned int v36; // r12d
int v37; // ebp
long long v38; // rsi
unsigned int v39; // r14d
int v40; // r13d
unsigned int v41; // ebx
unsigned int v42; // r12d
int v43; // ebx
int m; // r15d
long long v45; // rsi
unsigned int v46; // r14d
int v47; // ebp
int v48; // r15d
unsigned int v49; // r13d
int v50; // ebp
long long v51; // rsi
unsigned int v52; // r14d
int v53; // r12d
unsigned int v54; // ebx
unsigned int v55; // r13d
int v56; // ebx
int n; // r15d
long long v58; // rsi
unsigned int v59; // r14d
int v60; // ebp
int v61; // r15d
unsigned int v62; // r12d
int v63; // ebp
long long v64; // rsi
unsigned int v65; // r14d
int v66; // r13d
unsigned int v67; // ebx
unsigned int v68; // r12d
int v69; // ebx
int ii; // r15d
long long v71; // rsi
unsigned int v72; // r14d
int v73; // ebp
int v74; // r15d
unsigned int v75; // r13d
int v76; // ebp
long long v77; // rsi
unsigned int v78; // r14d
int v79; // r12d
unsigned int v80; // ebx
unsigned int v81; // r13d
int v82; // ebx
int jj; // r15d
long long v84; // rsi
unsigned int v85; // r14d
int v86; // ebp
int v87; // r15d
unsigned int v88; // r12d
int v89; // ebp
long long v90; // rsi
unsigned int v91; // r14d
int v92; // r13d
unsigned int v93; // ebx
unsigned int v94; // r12d
int v95; // ebx
int kk; // r15d
long long v97; // rsi
unsigned int v98; // r14d
int v99; // ebp
int v100; // r15d
unsigned int v101; // r13d
int v102; // ebp
long long v103; // rsi
unsigned int v104; // r14d
int v105; // r12d
int v107; // [rsp+0h] [rbp-98h]
int v108; // [rsp+0h] [rbp-98h]
int v109; // [rsp+0h] [rbp-98h]
int v110; // [rsp+0h] [rbp-98h]
int v111; // [rsp+4h] [rbp-94h]
int v112; // [rsp+4h] [rbp-94h]
int v113; // [rsp+4h] [rbp-94h]
int v114; // [rsp+4h] [rbp-94h]
int v115; // [rsp+4h] [rbp-94h]
int v116; // [rsp+4h] [rbp-94h]
int v117; // [rsp+4h] [rbp-94h]
int v118; // [rsp+4h] [rbp-94h]
int v119; // [rsp+8h] [rbp-90h]
unsigned int v120; // [rsp+8h] [rbp-90h]
int v121; // [rsp+8h] [rbp-90h]
int v122; // [rsp+8h] [rbp-90h]
unsigned int v123; // [rsp+8h] [rbp-90h]
int v124; // [rsp+8h] [rbp-90h]
int v125; // [rsp+8h] [rbp-90h]
unsigned int v126; // [rsp+8h] [rbp-90h]
int v127; // [rsp+8h] [rbp-90h]
int v128; // [rsp+8h] [rbp-90h]
unsigned int v129; // [rsp+8h] [rbp-90h]
int v130; // [rsp+8h] [rbp-90h]
unsigned int v131; // [rsp+Ch] [rbp-8Ch]
int v132; // [rsp+Ch] [rbp-8Ch]
int v133; // [rsp+Ch] [rbp-8Ch]
unsigned int v134; // [rsp+Ch] [rbp-8Ch]
int v135; // [rsp+Ch] [rbp-8Ch]
int v136; // [rsp+Ch] [rbp-8Ch]
unsigned int v137; // [rsp+Ch] [rbp-8Ch]
int v138; // [rsp+Ch] [rbp-8Ch]
int v139; // [rsp+Ch] [rbp-8Ch]
unsigned int v140; // [rsp+Ch] [rbp-8Ch]
int v141; // [rsp+Ch] [rbp-8Ch]
int v142; // [rsp+Ch] [rbp-8Ch]
int v143; // [rsp+10h] [rbp-88h]
bool v144; // [rsp+10h] [rbp-88h]
int v145; // [rsp+10h] [rbp-88h]
bool v146; // [rsp+10h] [rbp-88h]
int v147; // [rsp+10h] [rbp-88h]
bool v148; // [rsp+10h] [rbp-88h]
int v149; // [rsp+10h] [rbp-88h]
bool v150; // [rsp+10h] [rbp-88h]
bool v151; // [rsp+14h] [rbp-84h]
int v152; // [rsp+14h] [rbp-84h]
bool v153; // [rsp+14h] [rbp-84h]
int v154; // [rsp+14h] [rbp-84h]
bool v155; // [rsp+14h] [rbp-84h]
int v156; // [rsp+14h] [rbp-84h]
bool v157; // [rsp+14h] [rbp-84h]
int v158; // [rsp+14h] [rbp-84h]
int v159; // [rsp+18h] [rbp-80h]
int v160; // [rsp+18h] [rbp-80h]
int v161; // [rsp+18h] [rbp-80h]
int v162; // [rsp+18h] [rbp-80h]
int v163; // [rsp+18h] [rbp-80h]
int v164; // [rsp+18h] [rbp-80h]
int v165; // [rsp+18h] [rbp-80h]
int v166; // [rsp+18h] [rbp-80h]
int v167; // [rsp+1Ch] [rbp-7Ch]
int v168; // [rsp+1Ch] [rbp-7Ch]
int v169; // [rsp+20h] [rbp-78h]
int v170; // [rsp+20h] [rbp-78h]
int v171; // [rsp+20h] [rbp-78h]
int v172; // [rsp+20h] [rbp-78h]
int v173; // [rsp+24h] [rbp-74h]
int v174; // [rsp+24h] [rbp-74h]
int v175; // [rsp+24h] [rbp-74h]
int v176; // [rsp+24h] [rbp-74h]
int v177; // [rsp+28h] [rbp-70h]
int v178; // [rsp+28h] [rbp-70h]
int v179; // [rsp+2Ch] [rbp-6Ch]
int v180; // [rsp+2Ch] [rbp-6Ch]
int v181; // [rsp+30h] [rbp-68h]
int v182; // [rsp+30h] [rbp-68h]
int v183; // [rsp+30h] [rbp-68h]
int v184; // [rsp+30h] [rbp-68h]
int v185; // [rsp+34h] [rbp-64h]
int v186; // [rsp+38h] [rbp-60h]
int v187; // [rsp+38h] [rbp-60h]
int v188; // [rsp+3Ch] [rbp-5Ch]
int v189; // [rsp+40h] [rbp-58h]
int v190; // [rsp+44h] [rbp-54h]
int v191; // [rsp+44h] [rbp-54h]
int v192; // [rsp+48h] [rbp-50h]
int v193; // [rsp+48h] [rbp-50h]
int v194; // [rsp+4Ch] [rbp-4Ch]
int v195; // [rsp+50h] [rbp-48h]
int v196; // [rsp+58h] [rbp-40h]
int v197; // [rsp+5Ch] [rbp-3Ch]
v194 = a1;
v195 = a2;
if ( !a1 )
return 1LL;
v197 = 0;
if ( !a2 )
return 1LL;
LABEL_3:
v185 = v195 - 1;
if ( v195 == 1 )
{
v196 = 1;
goto LABEL_87;
}
v192 = 0;
v188 = v195 - 1;
v186 = v194;
LABEL_5:
v167 = v186 - 1;
if ( v186 == 1 )
{
v190 = 1;
goto LABEL_43;
}
v181 = 0;
v173 = v186 - 1;
v169 = v188;
while ( 2 )
{
v107 = v169 - 1;
if ( v169 == 1 )
{
v177 = 1;
goto LABEL_23;
}
v159 = 0;
v119 = v169 - 1;
v111 = v173;
v2 = v173 - 1;
v151 = v173 == 1;
if ( v173 != 1 )
{
LABEL_9:
v131 = v2;
v3 = v2;
v4 = 0;
for ( i = v119; ; i = v7 )
{
v6 = v3;
v7 = v3 - 1;
v3 = i;
v8 = func0((unsigned int)(i - 1), v6);
v4 += func0((unsigned int)(i - 1), v7) + v8;
if ( !v7 )
break;
}
v9 = v4;
v2 = v131;
v143 = v9 + 1;
goto LABEL_13;
}
while ( 1 )
{
v143 = 1;
LABEL_13:
v10 = v119 - 1;
v132 = v119 - 1;
if ( v119 != 1 && !v151 )
{
v11 = 0;
while ( 1 )
{
v12 = v2;
v13 = v2 - 1;
v2 = v10;
v14 = func0(v10 - 1, v12);
v11 += func0(v10 - 1, v13) + v14;
if ( !v13 )
break;
v10 = v13;
}
v159 += v11 + v143 + 1;
goto LABEL_19;
}
v159 += v143 + 1;
if ( v119 == 1 )
break;
LABEL_19:
v119 = v111;
v111 = v132;
v2 = v132 - 1;
v151 = v132 == 1;
if ( v132 != 1 )
goto LABEL_9;
}
v177 = v159 + 1;
LABEL_23:
v160 = v173 - 1;
if ( v173 != 1 && v169 != 1 )
{
v112 = v173 - 1;
v152 = 0;
v15 = v173 - 2;
v144 = v173 == 2;
if ( v173 != 2 )
{
LABEL_26:
v120 = v15;
v16 = v15;
v17 = 0;
for ( j = v107; ; j = v20 )
{
v19 = v16;
v20 = v16 - 1;
v16 = j;
v21 = func0((unsigned int)(j - 1), v19);
v17 += func0((unsigned int)(j - 1), v20) + v21;
if ( !v20 )
break;
}
v22 = v17;
v15 = v120;
v133 = v22 + 1;
goto LABEL_30;
}
while ( 1 )
{
v133 = 1;
LABEL_30:
v23 = v107 - 1;
v121 = v107 - 1;
if ( v107 == 1 || v144 )
{
v152 += v133 + 1;
if ( v107 == 1 )
{
v181 += v152 + v177 + 1;
goto LABEL_40;
}
}
else
{
v24 = 0;
while ( 1 )
{
v25 = v15;
v26 = v15 - 1;
v15 = v23;
v27 = func0(v23 - 1, v25);
v24 += func0(v23 - 1, v26) + v27;
if ( !v26 )
break;
v23 = v26;
}
v152 += v24 + v133 + 1;
}
v107 = v112;
v112 = v121;
v15 = v121 - 1;
v144 = v121 == 1;
if ( v121 != 1 )
goto LABEL_26;
}
}
v181 += v177 + 1;
if ( v173 != 1 )
{
LABEL_40:
v173 = v169;
v169 = v160;
continue;
}
break;
}
v190 = v181 + 1;
LABEL_43:
v182 = v188 - 1;
if ( v188 != 1 && v186 != 1 )
{
v170 = v188 - 1;
v179 = 0;
LABEL_46:
v108 = v170 - 1;
if ( v170 == 1 )
{
v174 = 1;
goto LABEL_62;
}
v161 = 0;
v122 = v170 - 1;
v113 = v167;
v28 = v167 - 1;
v153 = v167 == 1;
if ( v167 != 1 )
{
LABEL_48:
v134 = v28;
v29 = v28;
v30 = 0;
for ( k = v122; ; k = v33 )
{
v32 = v29;
v33 = v29 - 1;
v29 = k;
v34 = func0((unsigned int)(k - 1), v32);
v30 += func0((unsigned int)(k - 1), v33) + v34;
if ( !v33 )
break;
}
v35 = v30;
v28 = v134;
v145 = v35 + 1;
goto LABEL_52;
}
while ( 1 )
{
v145 = 1;
LABEL_52:
v36 = v122 - 1;
v135 = v122 - 1;
if ( v122 == 1 || v153 )
{
v161 += v145 + 1;
if ( v122 == 1 )
{
v174 = v161 + 1;
LABEL_62:
v162 = v167 - 1;
if ( v167 != 1 && v170 != 1 )
{
v114 = v167 - 1;
v154 = 0;
v41 = v167 - 2;
v146 = v167 == 2;
if ( v167 != 2 )
{
LABEL_65:
v123 = v41;
v42 = v41;
v43 = 0;
for ( m = v108; ; m = v46 )
{
v45 = v42;
v46 = v42 - 1;
v42 = m;
v47 = func0((unsigned int)(m - 1), v45);
v43 += func0((unsigned int)(m - 1), v46) + v47;
if ( !v46 )
break;
}
v48 = v43;
v41 = v123;
v136 = v48 + 1;
goto LABEL_69;
}
while ( 1 )
{
v136 = 1;
LABEL_69:
v49 = v108 - 1;
v124 = v108 - 1;
if ( v108 == 1 || v146 )
{
v154 += v136 + 1;
if ( v108 == 1 )
{
v179 += v154 + v174 + 1;
goto LABEL_79;
}
}
else
{
v50 = 0;
while ( 1 )
{
v51 = v41;
v52 = v41 - 1;
v41 = v49;
v53 = func0(v49 - 1, v51);
v50 += func0(v49 - 1, v52) + v53;
if ( !v52 )
break;
v49 = v52;
}
v154 += v50 + v136 + 1;
}
v108 = v114;
v114 = v124;
v41 = v124 - 1;
v146 = v124 == 1;
if ( v124 != 1 )
goto LABEL_65;
}
}
v179 += v174 + 1;
if ( v167 != 1 )
{
LABEL_79:
v167 = v170;
v170 = v162;
goto LABEL_46;
}
v192 += v179 + v190 + 1;
LABEL_82:
v188 = v186;
v186 = v182;
goto LABEL_5;
}
}
else
{
v37 = 0;
while ( 1 )
{
v38 = v28;
v39 = v28 - 1;
v28 = v36;
v40 = func0(v36 - 1, v38);
v37 += func0(v36 - 1, v39) + v40;
if ( !v39 )
break;
v36 = v39;
}
v161 += v37 + v145 + 1;
}
v122 = v113;
v113 = v135;
v28 = v135 - 1;
v153 = v135 == 1;
if ( v135 != 1 )
goto LABEL_48;
}
}
v192 += v190 + 1;
if ( v188 != 1 )
goto LABEL_82;
v196 = v192 + 1;
LABEL_87:
v193 = v194 - 1;
if ( v194 != 1 && v195 != 1 )
{
v187 = v194 - 1;
v191 = 0;
LABEL_90:
v168 = v187 - 1;
if ( v187 == 1 )
{
v189 = 1;
goto LABEL_128;
}
v183 = 0;
v175 = v187 - 1;
v171 = v185;
LABEL_92:
v109 = v171 - 1;
if ( v171 == 1 )
{
v178 = 1;
goto LABEL_108;
}
v163 = 0;
v125 = v171 - 1;
v115 = v175;
v54 = v175 - 1;
v155 = v175 == 1;
if ( v175 != 1 )
{
LABEL_94:
v137 = v54;
v55 = v54;
v56 = 0;
for ( n = v125; ; n = v59 )
{
v58 = v55;
v59 = v55 - 1;
v55 = n;
v60 = func0((unsigned int)(n - 1), v58);
v56 += func0((unsigned int)(n - 1), v59) + v60;
if ( !v59 )
break;
}
v61 = v56;
v54 = v137;
v147 = v61 + 1;
goto LABEL_98;
}
while ( 1 )
{
v147 = 1;
LABEL_98:
v62 = v125 - 1;
v138 = v125 - 1;
if ( v125 == 1 || v155 )
{
v163 += v147 + 1;
if ( v125 == 1 )
{
v178 = v163 + 1;
LABEL_108:
v164 = v175 - 1;
if ( v175 != 1 && v171 != 1 )
{
v116 = v175 - 1;
v156 = 0;
v67 = v175 - 2;
v148 = v175 == 2;
if ( v175 != 2 )
{
LABEL_111:
v126 = v67;
v68 = v67;
v69 = 0;
for ( ii = v109; ; ii = v72 )
{
v71 = v68;
v72 = v68 - 1;
v68 = ii;
v73 = func0((unsigned int)(ii - 1), v71);
v69 += func0((unsigned int)(ii - 1), v72) + v73;
if ( !v72 )
break;
}
v74 = v69;
v67 = v126;
v139 = v74 + 1;
goto LABEL_115;
}
while ( 1 )
{
v139 = 1;
LABEL_115:
v75 = v109 - 1;
v127 = v109 - 1;
if ( v109 == 1 || v148 )
{
v156 += v139 + 1;
if ( v109 == 1 )
{
v183 += v156 + v178 + 1;
goto LABEL_125;
}
}
else
{
v76 = 0;
while ( 1 )
{
v77 = v67;
v78 = v67 - 1;
v67 = v75;
v79 = func0(v75 - 1, v77);
v76 += func0(v75 - 1, v78) + v79;
if ( !v78 )
break;
v75 = v78;
}
v156 += v76 + v139 + 1;
}
v109 = v116;
v116 = v127;
v67 = v127 - 1;
v148 = v127 == 1;
if ( v127 != 1 )
goto LABEL_111;
}
}
v183 += v178 + 1;
if ( v175 != 1 )
{
LABEL_125:
v175 = v171;
v171 = v164;
goto LABEL_92;
}
v189 = v183 + 1;
LABEL_128:
v184 = v185 - 1;
if ( v185 != 1 && v187 != 1 )
{
v172 = v185 - 1;
v180 = 0;
LABEL_131:
v110 = v172 - 1;
if ( v172 == 1 )
{
v176 = 1;
goto LABEL_147;
}
v165 = 0;
v128 = v172 - 1;
v117 = v168;
v80 = v168 - 1;
v157 = v168 == 1;
if ( v168 != 1 )
{
LABEL_133:
v140 = v80;
v81 = v80;
v82 = 0;
for ( jj = v128; ; jj = v85 )
{
v84 = v81;
v85 = v81 - 1;
v81 = jj;
v86 = func0((unsigned int)(jj - 1), v84);
v82 += func0((unsigned int)(jj - 1), v85) + v86;
if ( !v85 )
break;
}
v87 = v82;
v80 = v140;
v149 = v87 + 1;
goto LABEL_137;
}
while ( 1 )
{
v149 = 1;
LABEL_137:
v88 = v128 - 1;
v141 = v128 - 1;
if ( v128 == 1 || v157 )
{
v165 += v149 + 1;
if ( v128 == 1 )
{
v176 = v165 + 1;
LABEL_147:
v166 = v168 - 1;
if ( v168 != 1 && v172 != 1 )
{
v118 = v168 - 1;
v158 = 0;
v93 = v168 - 2;
v150 = v168 == 2;
if ( v168 != 2 )
{
LABEL_150:
v129 = v93;
v94 = v93;
v95 = 0;
for ( kk = v110; ; kk = v98 )
{
v97 = v94;
v98 = v94 - 1;
v94 = kk;
v99 = func0((unsigned int)(kk - 1), v97);
v95 += func0((unsigned int)(kk - 1), v98) + v99;
if ( !v98 )
break;
}
v100 = v95;
v93 = v129;
v142 = v100 + 1;
goto LABEL_154;
}
while ( 1 )
{
v142 = 1;
LABEL_154:
v101 = v110 - 1;
v130 = v110 - 1;
if ( v110 == 1 || v150 )
{
v158 += v142 + 1;
if ( v110 == 1 )
{
v180 += v158 + v176 + 1;
goto LABEL_164;
}
}
else
{
v102 = 0;
while ( 1 )
{
v103 = v93;
v104 = v93 - 1;
v93 = v101;
v105 = func0(v101 - 1, v103);
v102 += func0(v101 - 1, v104) + v105;
if ( !v104 )
break;
v101 = v104;
}
v158 += v102 + v142 + 1;
}
v110 = v118;
v118 = v130;
v93 = v130 - 1;
v150 = v130 == 1;
if ( v130 != 1 )
goto LABEL_150;
}
}
v180 += v176 + 1;
if ( v168 != 1 )
{
LABEL_164:
v168 = v172;
v172 = v166;
goto LABEL_131;
}
v191 += v180 + v189 + 1;
LABEL_167:
v185 = v187;
v187 = v184;
goto LABEL_90;
}
}
else
{
v89 = 0;
while ( 1 )
{
v90 = v80;
v91 = v80 - 1;
v80 = v88;
v92 = func0(v88 - 1, v90);
v89 += func0(v88 - 1, v91) + v92;
if ( !v91 )
break;
v88 = v91;
}
v165 += v89 + v149 + 1;
}
v128 = v117;
v117 = v141;
v80 = v141 - 1;
v157 = v141 == 1;
if ( v141 != 1 )
goto LABEL_133;
}
}
v191 += v189 + 1;
if ( v185 != 1 )
goto LABEL_167;
v197 += v191 + v196 + 1;
LABEL_172:
v194 = v195;
v195 = v193;
goto LABEL_3;
}
}
else
{
v63 = 0;
while ( 1 )
{
v64 = v54;
v65 = v54 - 1;
v54 = v62;
v66 = func0(v62 - 1, v64);
v63 += func0(v62 - 1, v65) + v66;
if ( !v65 )
break;
v62 = v65;
}
v163 += v63 + v147 + 1;
}
v125 = v115;
v115 = v138;
v54 = v138 - 1;
v155 = v138 == 1;
if ( v138 != 1 )
goto LABEL_94;
}
}
v197 += v196 + 1;
if ( v194 != 1 )
goto LABEL_172;
return (unsigned int)(v197 + 1);
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RSP + 0x4c],EDI
MOV dword ptr [RSP + 0x50],ESI
TEST EDI,EDI
JZ 0x00101ff1
MOV dword ptr [RSP + 0x5c],0x0
TEST ESI,ESI
JZ 0x00101ff1
LAB_00101232:
MOV EAX,dword ptr [RSP + 0x50]
SUB EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
SETZ byte ptr [RSP + 0x57]
JZ 0x00101fe4
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x48],0x0
MOV dword ptr [RSP + 0x3c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x38],EAX
LAB_00101260:
MOV EAX,dword ptr [RSP + 0x38]
SUB EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
SETZ byte ptr [RSP + 0x40]
JZ 0x00101fa7
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x30],0x0
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x20],EAX
LAB_0010128e:
MOV EAX,dword ptr [RSP + 0x20]
SUB EAX,0x1
MOV dword ptr [RSP],EAX
SETZ byte ptr [RSP + 0x2c]
JZ 0x001018b0
MOV EAX,dword ptr [RSP]
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JZ 0x001013ae
LAB_001012cc:
MOV R12D,dword ptr [RSP + 0x8]
XOR R15D,R15D
MOV dword ptr [RSP + 0xc],EBX
MOV R13D,EBX
MOV EBX,R15D
MOV R15D,R12D
LAB_001012e1:
LEA R12D,[R15 + -0x1]
MOV ESI,R13D
LEA R14D,[R13 + -0x1]
MOV R13D,R15D
MOV EDI,R12D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R12D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101318
MOV R15D,R14D
JMP 0x001012e1
LAB_00101318:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0xc]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0x10],EAX
LAB_00101327:
MOV EAX,dword ptr [RSP + 0x8]
LEA R12D,[RAX + -0x1]
MOV dword ptr [RSP + 0xc],R12D
CMP EAX,0x1
JZ 0x001013c0
CMP byte ptr [RSP + 0x14],0x0
JNZ 0x001013c0
XOR EBP,EBP
LAB_00101346:
LEA R15D,[R12 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R12D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R13D,EAX
CALL 0x00101200
ADD R13D,EAX
ADD EBP,R13D
TEST R14D,R14D
JZ 0x00101380
MOV R12D,R14D
JMP 0x00101346
LAB_00101380:
MOV EAX,dword ptr [RSP + 0x10]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x18],EAX
LAB_0010138c:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JNZ 0x001012cc
LAB_001013ae:
MOV dword ptr [RSP + 0x10],0x1
JMP 0x00101327
LAB_001013c0:
MOV EAX,dword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x10]
MOV R15D,dword ptr [RSP + 0xc]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV dword ptr [RSP + 0x18],EAX
TEST R15D,R15D
JNZ 0x0010138c
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x28],EAX
LAB_001013e5:
MOV EAX,dword ptr [RSP + 0x24]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RSP + 0x18],EDX
CMP EAX,0x1
JZ 0x00101550
CMP byte ptr [RSP + 0x2c],0x0
JNZ 0x00101550
MOV dword ptr [RSP + 0x4],EDX
MOV EBX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x14],0x0
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JZ 0x001014fd
LAB_00101422:
MOV R13D,dword ptr [RSP]
XOR R15D,R15D
MOV dword ptr [RSP + 0x8],EBX
MOV R12D,EBX
MOV EBX,R15D
MOV R15D,R13D
LAB_00101436:
LEA R13D,[R15 + -0x1]
MOV ESI,R12D
LEA R14D,[R12 + -0x1]
MOV R12D,R15D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101470
MOV R15D,R14D
JMP 0x00101436
LAB_00101470:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x8]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0xc],EAX
LAB_0010147f:
MOV EAX,dword ptr [RSP]
LEA R13D,[RAX + -0x1]
MOV dword ptr [RSP + 0x8],R13D
CMP EAX,0x1
JZ 0x00101510
CMP byte ptr [RSP + 0x10],0x0
JNZ 0x00101510
XOR EBP,EBP
LAB_0010149d:
LEA R15D,[R13 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R13D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R12D,EAX
CALL 0x00101200
ADD R12D,EAX
ADD EBP,R12D
TEST R14D,R14D
JZ 0x001014d0
MOV R13D,R14D
JMP 0x0010149d
LAB_001014d0:
MOV EAX,dword ptr [RSP + 0xc]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x14],EAX
LAB_001014dc:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP],EAX
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JNZ 0x00101422
LAB_001014fd:
MOV dword ptr [RSP + 0xc],0x1
JMP 0x0010147f
LAB_00101510:
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0xc]
MOV R13D,dword ptr [RSP + 0x8]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x14],EAX
TEST R13D,R13D
JNZ 0x001014dc
MOV EAX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0x28]
LEA EAX,[RAX + RDX*0x1 + 0x1]
ADD dword ptr [RSP + 0x30],EAX
LAB_0010153a:
MOV EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x20],EAX
JMP 0x0010128e
LAB_00101550:
MOV EAX,dword ptr [RSP + 0x30]
MOV EDX,dword ptr [RSP + 0x28]
MOV R14D,dword ptr [RSP + 0x18]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV dword ptr [RSP + 0x30],EAX
TEST R14D,R14D
JNZ 0x0010153a
MOV EAX,dword ptr [RSP + 0x30]
ADD EAX,0x1
MOV dword ptr [RSP + 0x44],EAX
LAB_00101575:
MOV EAX,dword ptr [RSP + 0x3c]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RSP + 0x30],EDX
CMP EAX,0x1
JZ 0x001018bd
CMP byte ptr [RSP + 0x40],0x0
JNZ 0x001018bd
MOV dword ptr [RSP + 0x20],EDX
MOV dword ptr [RSP + 0x2c],0x0
LAB_001015a0:
MOV EAX,dword ptr [RSP + 0x20]
SUB EAX,0x1
MOV dword ptr [RSP],EAX
SETZ byte ptr [RSP + 0x28]
JZ 0x001018a0
MOV EAX,dword ptr [RSP]
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JZ 0x001016be
LAB_001015de:
MOV R12D,dword ptr [RSP + 0x8]
XOR R15D,R15D
MOV dword ptr [RSP + 0xc],EBX
MOV R13D,EBX
MOV EBX,R15D
MOV R15D,R12D
LAB_001015f3:
LEA R12D,[R15 + -0x1]
MOV ESI,R13D
LEA R14D,[R13 + -0x1]
MOV R13D,R15D
MOV EDI,R12D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R12D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101628
MOV R15D,R14D
JMP 0x001015f3
LAB_00101628:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0xc]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0x10],EAX
LAB_00101637:
MOV EAX,dword ptr [RSP + 0x8]
LEA R12D,[RAX + -0x1]
MOV dword ptr [RSP + 0xc],R12D
CMP EAX,0x1
JZ 0x001016d0
CMP byte ptr [RSP + 0x14],0x0
JNZ 0x001016d0
XOR EBP,EBP
LAB_00101656:
LEA R15D,[R12 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R12D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R13D,EAX
CALL 0x00101200
ADD R13D,EAX
ADD EBP,R13D
TEST R14D,R14D
JZ 0x00101690
MOV R12D,R14D
JMP 0x00101656
LAB_00101690:
MOV EAX,dword ptr [RSP + 0x10]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x18],EAX
LAB_0010169c:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JNZ 0x001015de
LAB_001016be:
MOV dword ptr [RSP + 0x10],0x1
JMP 0x00101637
LAB_001016d0:
MOV EAX,dword ptr [RSP + 0x18]
MOV ECX,dword ptr [RSP + 0x10]
MOV EBP,dword ptr [RSP + 0xc]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x18],EAX
TEST EBP,EBP
JNZ 0x0010169c
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
LAB_001016f3:
MOV EAX,dword ptr [RSP + 0x1c]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSP + 0x18],ECX
CMP EAX,0x1
JZ 0x00101860
CMP byte ptr [RSP + 0x28],0x0
JNZ 0x00101860
MOV dword ptr [RSP + 0x4],ECX
MOV EBX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x14],0x0
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JZ 0x0010180d
LAB_00101730:
MOV R13D,dword ptr [RSP]
XOR R15D,R15D
MOV dword ptr [RSP + 0x8],EBX
MOV R12D,EBX
MOV EBX,R15D
MOV R15D,R13D
LAB_00101744:
LEA R13D,[R15 + -0x1]
MOV ESI,R12D
LEA R14D,[R12 + -0x1]
MOV R12D,R15D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101780
MOV R15D,R14D
JMP 0x00101744
LAB_00101780:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x8]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0xc],EAX
LAB_0010178f:
MOV EAX,dword ptr [RSP]
LEA R13D,[RAX + -0x1]
MOV dword ptr [RSP + 0x8],R13D
CMP EAX,0x1
JZ 0x00101820
CMP byte ptr [RSP + 0x10],0x0
JNZ 0x00101820
XOR EBP,EBP
LAB_001017ad:
LEA R15D,[R13 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R13D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R12D,EAX
CALL 0x00101200
ADD R12D,EAX
ADD EBP,R12D
TEST R14D,R14D
JZ 0x001017e0
MOV R13D,R14D
JMP 0x001017ad
LAB_001017e0:
MOV EAX,dword ptr [RSP + 0xc]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x14],EAX
LAB_001017ec:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP],EAX
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JNZ 0x00101730
LAB_0010180d:
MOV dword ptr [RSP + 0xc],0x1
JMP 0x0010178f
LAB_00101820:
MOV EAX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0xc]
MOV R11D,dword ptr [RSP + 0x8]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV dword ptr [RSP + 0x14],EAX
TEST R11D,R11D
JNZ 0x001017ec
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x24]
LEA EAX,[RAX + RCX*0x1 + 0x1]
ADD dword ptr [RSP + 0x2c],EAX
LAB_0010184a:
MOV EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x1c],EAX
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x20],EAX
JMP 0x001015a0
LAB_00101860:
MOV EAX,dword ptr [RSP + 0x2c]
MOV ECX,dword ptr [RSP + 0x24]
MOV EBX,dword ptr [RSP + 0x18]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x2c],EAX
TEST EBX,EBX
JNZ 0x0010184a
MOV EAX,dword ptr [RSP + 0x2c]
MOV EDX,dword ptr [RSP + 0x44]
LEA EAX,[RAX + RDX*0x1 + 0x1]
ADD dword ptr [RSP + 0x48],EAX
LAB_00101888:
MOV EAX,dword ptr [RSP + 0x38]
MOV dword ptr [RSP + 0x3c],EAX
MOV EAX,dword ptr [RSP + 0x30]
MOV dword ptr [RSP + 0x38],EAX
JMP 0x00101260
LAB_001018a0:
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001016f3
LAB_001018b0:
MOV dword ptr [RSP + 0x28],0x1
JMP 0x001013e5
LAB_001018bd:
MOV EAX,dword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0x44]
MOV R12D,dword ptr [RSP + 0x30]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x48],EAX
TEST R12D,R12D
JNZ 0x00101888
MOV EAX,dword ptr [RSP + 0x48]
ADD EAX,0x1
MOV dword ptr [RSP + 0x58],EAX
LAB_001018e2:
MOV EAX,dword ptr [RSP + 0x4c]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RSP + 0x48],EDX
CMP EAX,0x1
JZ 0x00101fb4
CMP byte ptr [RSP + 0x57],0x0
JNZ 0x00101fb4
MOV dword ptr [RSP + 0x38],EDX
MOV dword ptr [RSP + 0x44],0x0
LAB_0010190d:
MOV EAX,dword ptr [RSP + 0x38]
SUB EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
SETZ byte ptr [RSP + 0x3c]
JZ 0x00101f9a
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x30],0x0
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x20],EAX
LAB_0010193b:
MOV EAX,dword ptr [RSP + 0x20]
SUB EAX,0x1
MOV dword ptr [RSP],EAX
SETZ byte ptr [RSP + 0x2c]
JZ 0x00101f50
MOV EAX,dword ptr [RSP]
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JZ 0x00101a4e
LAB_00101979:
MOV R12D,dword ptr [RSP + 0x8]
XOR R15D,R15D
MOV dword ptr [RSP + 0xc],EBX
MOV R13D,EBX
MOV EBX,R15D
MOV R15D,R12D
LAB_0010198e:
LEA R12D,[R15 + -0x1]
MOV ESI,R13D
LEA R14D,[R13 + -0x1]
MOV R13D,R15D
MOV EDI,R12D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R12D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x001019c0
MOV R15D,R14D
JMP 0x0010198e
LAB_001019c0:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0xc]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0x10],EAX
LAB_001019cf:
MOV EAX,dword ptr [RSP + 0x8]
LEA R12D,[RAX + -0x1]
MOV dword ptr [RSP + 0xc],R12D
CMP EAX,0x1
JZ 0x00101a60
CMP byte ptr [RSP + 0x14],0x0
JNZ 0x00101a60
XOR EBP,EBP
LAB_001019ea:
LEA R15D,[R12 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R12D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R13D,EAX
CALL 0x00101200
ADD R13D,EAX
ADD EBP,R13D
TEST R14D,R14D
JZ 0x00101a20
MOV R12D,R14D
JMP 0x001019ea
LAB_00101a20:
MOV EAX,dword ptr [RSP + 0x10]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x18],EAX
LAB_00101a2c:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JNZ 0x00101979
LAB_00101a4e:
MOV dword ptr [RSP + 0x10],0x1
JMP 0x001019cf
LAB_00101a60:
MOV EAX,dword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x10]
MOV R9D,dword ptr [RSP + 0xc]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV dword ptr [RSP + 0x18],EAX
TEST R9D,R9D
JNZ 0x00101a2c
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x28],EAX
LAB_00101a85:
MOV EAX,dword ptr [RSP + 0x24]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RSP + 0x18],EDX
CMP EAX,0x1
JZ 0x00101bf0
CMP byte ptr [RSP + 0x2c],0x0
JNZ 0x00101bf0
MOV dword ptr [RSP + 0x4],EDX
MOV EBX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x14],0x0
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JZ 0x00101b9d
LAB_00101ac2:
MOV R13D,dword ptr [RSP]
XOR R15D,R15D
MOV dword ptr [RSP + 0x8],EBX
MOV R12D,EBX
MOV EBX,R15D
MOV R15D,R13D
LAB_00101ad6:
LEA R13D,[R15 + -0x1]
MOV ESI,R12D
LEA R14D,[R12 + -0x1]
MOV R12D,R15D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101b10
MOV R15D,R14D
JMP 0x00101ad6
LAB_00101b10:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x8]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0xc],EAX
LAB_00101b1f:
MOV EAX,dword ptr [RSP]
LEA R13D,[RAX + -0x1]
MOV dword ptr [RSP + 0x8],R13D
CMP EAX,0x1
JZ 0x00101bb0
CMP byte ptr [RSP + 0x10],0x0
JNZ 0x00101bb0
XOR EBP,EBP
LAB_00101b3d:
LEA R15D,[R13 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R13D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R12D,EAX
CALL 0x00101200
ADD R12D,EAX
ADD EBP,R12D
TEST R14D,R14D
JZ 0x00101b70
MOV R13D,R14D
JMP 0x00101b3d
LAB_00101b70:
MOV EAX,dword ptr [RSP + 0xc]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x14],EAX
LAB_00101b7c:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP],EAX
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JNZ 0x00101ac2
LAB_00101b9d:
MOV dword ptr [RSP + 0xc],0x1
JMP 0x00101b1f
LAB_00101bb0:
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0xc]
MOV EDI,dword ptr [RSP + 0x8]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x14],EAX
TEST EDI,EDI
JNZ 0x00101b7c
MOV EAX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0x28]
LEA EAX,[RAX + RDX*0x1 + 0x1]
ADD dword ptr [RSP + 0x30],EAX
LAB_00101bd8:
MOV EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x20],EAX
JMP 0x0010193b
LAB_00101bf0:
MOV EAX,dword ptr [RSP + 0x30]
MOV ECX,dword ptr [RSP + 0x28]
MOV R8D,dword ptr [RSP + 0x18]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x30],EAX
TEST R8D,R8D
JNZ 0x00101bd8
MOV EAX,dword ptr [RSP + 0x30]
ADD EAX,0x1
MOV dword ptr [RSP + 0x40],EAX
LAB_00101c15:
MOV EAX,dword ptr [RSP + 0x34]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSP + 0x30],ECX
CMP EAX,0x1
JZ 0x00101f5d
CMP byte ptr [RSP + 0x3c],0x0
JNZ 0x00101f5d
MOV dword ptr [RSP + 0x20],ECX
MOV dword ptr [RSP + 0x2c],0x0
LAB_00101c40:
MOV EAX,dword ptr [RSP + 0x20]
SUB EAX,0x1
MOV dword ptr [RSP],EAX
SETZ byte ptr [RSP + 0x28]
JZ 0x00101f40
MOV EAX,dword ptr [RSP]
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JZ 0x00101d5e
LAB_00101c7e:
MOV R12D,dword ptr [RSP + 0x8]
XOR R15D,R15D
MOV dword ptr [RSP + 0xc],EBX
MOV R13D,EBX
MOV EBX,R15D
MOV R15D,R12D
LAB_00101c93:
LEA R12D,[R15 + -0x1]
MOV ESI,R13D
LEA R14D,[R13 + -0x1]
MOV R13D,R15D
MOV EDI,R12D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R12D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101cc8
MOV R15D,R14D
JMP 0x00101c93
LAB_00101cc8:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0xc]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0x10],EAX
LAB_00101cd7:
MOV EAX,dword ptr [RSP + 0x8]
LEA R12D,[RAX + -0x1]
MOV dword ptr [RSP + 0xc],R12D
CMP EAX,0x1
JZ 0x00101d70
CMP byte ptr [RSP + 0x14],0x0
JNZ 0x00101d70
XOR EBP,EBP
LAB_00101cf6:
LEA R15D,[R12 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R12D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R13D,EAX
CALL 0x00101200
ADD R13D,EAX
ADD EBP,R13D
TEST R14D,R14D
JZ 0x00101d30
MOV R12D,R14D
JMP 0x00101cf6
LAB_00101d30:
MOV EAX,dword ptr [RSP + 0x10]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x18],EAX
LAB_00101d3c:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x14]
JNZ 0x00101c7e
LAB_00101d5e:
MOV dword ptr [RSP + 0x10],0x1
JMP 0x00101cd7
LAB_00101d70:
MOV EAX,dword ptr [RSP + 0x18]
MOV ECX,dword ptr [RSP + 0x10]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x18],EAX
TEST ECX,ECX
JNZ 0x00101d3c
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
LAB_00101d93:
MOV EAX,dword ptr [RSP + 0x1c]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSP + 0x18],ECX
CMP EAX,0x1
JZ 0x00101f00
CMP byte ptr [RSP + 0x28],0x0
JNZ 0x00101f00
MOV dword ptr [RSP + 0x4],ECX
MOV EBX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x14],0x0
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JZ 0x00101ead
LAB_00101dd0:
MOV R13D,dword ptr [RSP]
XOR R15D,R15D
MOV dword ptr [RSP + 0x8],EBX
MOV R12D,EBX
MOV EBX,R15D
MOV R15D,R13D
LAB_00101de4:
LEA R13D,[R15 + -0x1]
MOV ESI,R12D
LEA R14D,[R12 + -0x1]
MOV R12D,R15D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R14D,R14D
JZ 0x00101e20
MOV R15D,R14D
JMP 0x00101de4
LAB_00101e20:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x8]
LEA EAX,[R15 + 0x1]
MOV dword ptr [RSP + 0xc],EAX
LAB_00101e2f:
MOV EAX,dword ptr [RSP]
LEA R13D,[RAX + -0x1]
MOV dword ptr [RSP + 0x8],R13D
CMP EAX,0x1
JZ 0x00101ec0
CMP byte ptr [RSP + 0x10],0x0
JNZ 0x00101ec0
XOR EBP,EBP
LAB_00101e4d:
LEA R15D,[R13 + -0x1]
MOV ESI,EBX
LEA R14D,[RBX + -0x1]
MOV EBX,R13D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R14D
MOV EDI,R15D
MOV R12D,EAX
CALL 0x00101200
ADD R12D,EAX
ADD EBP,R12D
TEST R14D,R14D
JZ 0x00101e80
MOV R13D,R14D
JMP 0x00101e4d
LAB_00101e80:
MOV EAX,dword ptr [RSP + 0xc]
LEA EAX,[RBP + RAX*0x1 + 0x1]
ADD dword ptr [RSP + 0x14],EAX
LAB_00101e8c:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP],EAX
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],EAX
MOV EBX,dword ptr [RSP + 0x4]
SUB EBX,0x1
SETZ byte ptr [RSP + 0x10]
JNZ 0x00101dd0
LAB_00101ead:
MOV dword ptr [RSP + 0xc],0x1
JMP 0x00101e2f
LAB_00101ec0:
MOV EAX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0xc]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV dword ptr [RSP + 0x14],EAX
MOV EAX,dword ptr [RSP + 0x8]
TEST EAX,EAX
JNZ 0x00101e8c
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x24]
LEA EAX,[RAX + RCX*0x1 + 0x1]
ADD dword ptr [RSP + 0x2c],EAX
LAB_00101ee8:
MOV EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x1c],EAX
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x20],EAX
JMP 0x00101c40
LAB_00101f00:
MOV EAX,dword ptr [RSP + 0x2c]
MOV EDX,dword ptr [RSP + 0x24]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV EDX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x2c],EAX
TEST EDX,EDX
JNZ 0x00101ee8
MOV EAX,dword ptr [RSP + 0x2c]
MOV ECX,dword ptr [RSP + 0x40]
LEA EAX,[RAX + RCX*0x1 + 0x1]
ADD dword ptr [RSP + 0x44],EAX
LAB_00101f28:
MOV EAX,dword ptr [RSP + 0x38]
MOV dword ptr [RSP + 0x34],EAX
MOV EAX,dword ptr [RSP + 0x30]
MOV dword ptr [RSP + 0x38],EAX
JMP 0x0010190d
LAB_00101f40:
MOV dword ptr [RSP + 0x24],0x1
JMP 0x00101d93
LAB_00101f50:
MOV dword ptr [RSP + 0x28],0x1
JMP 0x00101a85
LAB_00101f5d:
MOV EAX,dword ptr [RSP + 0x44]
MOV ECX,dword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x30]
LEA EAX,[RAX + RCX*0x1 + 0x1]
MOV dword ptr [RSP + 0x44],EAX
TEST ESI,ESI
JNZ 0x00101f28
MOV EAX,dword ptr [RSP + 0x44]
MOV ECX,dword ptr [RSP + 0x58]
LEA EAX,[RAX + RCX*0x1 + 0x1]
ADD dword ptr [RSP + 0x5c],EAX
LAB_00101f85:
MOV EAX,dword ptr [RSP + 0x50]
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x48]
MOV dword ptr [RSP + 0x50],EAX
JMP 0x00101232
LAB_00101f9a:
MOV dword ptr [RSP + 0x40],0x1
JMP 0x00101c15
LAB_00101fa7:
MOV dword ptr [RSP + 0x44],0x1
JMP 0x00101575
LAB_00101fb4:
MOV EAX,dword ptr [RSP + 0x5c]
MOV EDX,dword ptr [RSP + 0x58]
MOV R10D,dword ptr [RSP + 0x48]
LEA EAX,[RAX + RDX*0x1 + 0x1]
MOV dword ptr [RSP + 0x5c],EAX
TEST R10D,R10D
JNZ 0x00101f85
MOV EAX,dword ptr [RSP + 0x5c]
ADD RSP,0x68
POP RBX
POP RBP
ADD EAX,0x1
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101fe4:
MOV dword ptr [RSP + 0x58],0x1
JMP 0x001018e2
LAB_00101ff1:
ADD RSP,0x68
MOV EAX,0x1
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
bool bVar11;
int local_98;
int local_94;
int local_90;
int local_8c;
int local_88;
int local_84;
int local_80;
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;
int local_58;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_40;
int local_3c;
if ((param_1 == 0) || (local_3c = 0, local_4c = param_1, local_48 = param_2, param_2 == 0)) {
return 1;
}
LAB_00101232:
local_64 = local_48 + -1;
if (local_64 != 0) {
local_50 = 0;
local_60 = local_4c;
local_5c = local_64;
LAB_00101260:
local_7c = local_60 + -1;
if (local_7c != 0) {
local_68 = 0;
local_78 = local_5c;
local_74 = local_7c;
do {
local_98 = local_78 + -1;
if (local_98 != 0) {
local_80 = 0;
local_94 = local_74;
iVar7 = local_74 + -1;
bVar11 = iVar7 == 0;
local_90 = local_98;
if (bVar11) goto LAB_001013ae;
do {
local_88 = 0;
iVar10 = local_90;
iVar1 = iVar7;
do {
iVar8 = iVar10;
iVar2 = iVar8 + -1;
iVar10 = iVar1 + -1;
iVar1 = func0(iVar2,iVar1);
iVar2 = func0(iVar2,iVar10);
local_88 = local_88 + iVar1 + iVar2;
iVar1 = iVar8;
} while (iVar10 != 0);
local_88 = local_88 + 1;
while( true ) {
iVar10 = local_90;
iVar1 = local_90 + -1;
if ((local_90 == 1) || (bVar11)) {
local_80 = local_80 + 1 + local_88;
if (iVar1 == 0) {
local_70 = local_80 + 1;
goto LAB_001013e5;
}
}
else {
iVar8 = 0;
iVar2 = iVar1;
do {
iVar9 = iVar7 + -1;
iVar7 = func0(iVar2 + -1,iVar7);
iVar3 = func0(iVar2 + -1,iVar9);
iVar8 = iVar8 + iVar7 + iVar3;
iVar7 = iVar2;
iVar2 = iVar9;
} while (iVar9 != 0);
local_80 = local_80 + iVar8 + 1 + local_88;
}
local_90 = local_94;
iVar7 = iVar10 + -2;
bVar11 = iVar7 == 0;
local_94 = iVar1;
if (!bVar11) break;
LAB_001013ae:
local_88 = 1;
}
} while( true );
}
local_70 = 1;
LAB_001013e5:
iVar7 = local_74 + -1;
if ((local_74 != 1) && (local_98 != 0)) {
local_84 = 0;
local_74 = local_74 + -2;
bVar11 = local_74 == 0;
local_94 = iVar7;
if (bVar11) goto LAB_001014fd;
do {
local_8c = 0;
iVar10 = local_98;
iVar1 = local_74;
do {
iVar8 = iVar10;
iVar2 = iVar8 + -1;
iVar10 = iVar1 + -1;
iVar1 = func0(iVar2,iVar1);
iVar2 = func0(iVar2,iVar10);
local_8c = local_8c + iVar1 + iVar2;
iVar1 = iVar8;
} while (iVar10 != 0);
local_8c = local_8c + 1;
while( true ) {
iVar10 = local_98;
iVar1 = local_98 + -1;
if ((local_98 == 1) || (bVar11)) {
local_84 = local_84 + 1 + local_8c;
if (iVar1 == 0) {
local_68 = local_68 + local_84 + 1 + local_70;
goto LAB_0010153a;
}
}
else {
iVar8 = 0;
iVar2 = iVar1;
do {
iVar9 = local_74 + -1;
iVar3 = func0(iVar2 + -1,local_74);
iVar4 = func0(iVar2 + -1,iVar9);
iVar8 = iVar8 + iVar3 + iVar4;
local_74 = iVar2;
iVar2 = iVar9;
} while (iVar9 != 0);
local_84 = local_84 + iVar8 + 1 + local_8c;
}
local_98 = local_94;
local_74 = iVar10 + -2;
bVar11 = local_74 == 0;
local_94 = iVar1;
if (!bVar11) break;
LAB_001014fd:
local_8c = 1;
}
} while( true );
}
local_68 = local_68 + 1 + local_70;
if (iVar7 == 0) goto code_r0x0010156a;
LAB_0010153a:
local_74 = local_78;
local_78 = iVar7;
} while( true );
}
local_54 = 1;
goto LAB_00101575;
}
local_40 = 1;
goto LAB_001018e2;
code_r0x0010156a:
local_54 = local_68 + 1;
LAB_00101575:
iVar7 = local_5c + -1;
if ((local_5c != 1) && (local_7c != 0)) {
local_6c = 0;
local_78 = iVar7;
do {
local_98 = local_78 + -1;
if (local_98 != 0) {
local_80 = 0;
local_94 = local_7c;
iVar1 = local_7c + -1;
bVar11 = iVar1 == 0;
local_90 = local_98;
if (bVar11) goto LAB_001016be;
do {
local_88 = 0;
iVar2 = local_90;
iVar10 = iVar1;
do {
iVar9 = iVar2;
iVar8 = iVar9 + -1;
iVar2 = iVar10 + -1;
iVar10 = func0(iVar8,iVar10);
iVar8 = func0(iVar8,iVar2);
local_88 = local_88 + iVar10 + iVar8;
iVar10 = iVar9;
} while (iVar2 != 0);
local_88 = local_88 + 1;
while( true ) {
iVar2 = local_90;
iVar10 = local_90 + -1;
if ((local_90 == 1) || (bVar11)) {
local_80 = local_80 + 1 + local_88;
if (iVar10 == 0) {
local_74 = local_80 + 1;
goto LAB_001016f3;
}
}
else {
iVar9 = 0;
iVar8 = iVar10;
do {
iVar3 = iVar1 + -1;
iVar1 = func0(iVar8 + -1,iVar1);
iVar4 = func0(iVar8 + -1,iVar3);
iVar9 = iVar9 + iVar1 + iVar4;
iVar1 = iVar8;
iVar8 = iVar3;
} while (iVar3 != 0);
local_80 = local_80 + iVar9 + 1 + local_88;
}
local_90 = local_94;
iVar1 = iVar2 + -2;
bVar11 = iVar1 == 0;
local_94 = iVar10;
if (!bVar11) break;
LAB_001016be:
local_88 = 1;
}
} while( true );
}
local_74 = 1;
LAB_001016f3:
iVar1 = local_7c + -1;
if ((local_7c != 1) && (local_98 != 0)) {
local_84 = 0;
local_7c = local_7c + -2;
bVar11 = local_7c == 0;
local_94 = iVar1;
if (bVar11) goto LAB_0010180d;
do {
local_8c = 0;
iVar2 = local_98;
iVar10 = local_7c;
do {
iVar9 = iVar2;
iVar8 = iVar9 + -1;
iVar2 = iVar10 + -1;
iVar10 = func0(iVar8,iVar10);
iVar8 = func0(iVar8,iVar2);
local_8c = local_8c + iVar10 + iVar8;
iVar10 = iVar9;
} while (iVar2 != 0);
local_8c = local_8c + 1;
while( true ) {
iVar2 = local_98;
iVar10 = local_98 + -1;
if ((local_98 == 1) || (bVar11)) {
local_84 = local_84 + 1 + local_8c;
if (iVar10 == 0) {
local_6c = local_6c + local_84 + 1 + local_74;
goto LAB_0010184a;
}
}
else {
iVar9 = 0;
iVar8 = iVar10;
do {
iVar3 = local_7c + -1;
iVar4 = func0(iVar8 + -1,local_7c);
iVar5 = func0(iVar8 + -1,iVar3);
iVar9 = iVar9 + iVar4 + iVar5;
local_7c = iVar8;
iVar8 = iVar3;
} while (iVar3 != 0);
local_84 = local_84 + iVar9 + 1 + local_8c;
}
local_98 = local_94;
local_7c = iVar2 + -2;
bVar11 = local_7c == 0;
local_94 = iVar10;
if (!bVar11) break;
LAB_0010180d:
local_8c = 1;
}
} while( true );
}
local_6c = local_6c + 1 + local_74;
if (iVar1 == 0) goto code_r0x00101878;
LAB_0010184a:
local_7c = local_78;
local_78 = iVar1;
} while( true );
}
local_50 = local_50 + 1 + local_54;
if (iVar7 == 0) goto code_r0x001018d7;
LAB_00101888:
local_5c = local_60;
local_60 = iVar7;
goto LAB_00101260;
code_r0x00101878:
local_50 = local_50 + local_6c + 1 + local_54;
goto LAB_00101888;
code_r0x001018d7:
local_40 = local_50 + 1;
LAB_001018e2:
iVar7 = local_4c + -1;
if ((local_4c != 1) && (local_64 != 0)) {
local_54 = 0;
local_60 = iVar7;
LAB_0010190d:
local_7c = local_60 + -1;
if (local_7c != 0) {
local_68 = 0;
local_78 = local_64;
local_74 = local_7c;
do {
local_98 = local_78 + -1;
if (local_98 != 0) {
local_80 = 0;
local_94 = local_74;
iVar1 = local_74 + -1;
bVar11 = iVar1 == 0;
local_90 = local_98;
if (bVar11) goto LAB_00101a4e;
do {
local_88 = 0;
iVar2 = local_90;
iVar10 = iVar1;
do {
iVar9 = iVar2;
iVar8 = iVar9 + -1;
iVar2 = iVar10 + -1;
iVar10 = func0(iVar8,iVar10);
iVar8 = func0(iVar8,iVar2);
local_88 = local_88 + iVar10 + iVar8;
iVar10 = iVar9;
} while (iVar2 != 0);
local_88 = local_88 + 1;
while( true ) {
iVar2 = local_90;
iVar10 = local_90 + -1;
if ((local_90 == 1) || (bVar11)) {
local_80 = local_80 + 1 + local_88;
if (iVar10 == 0) {
local_70 = local_80 + 1;
goto LAB_00101a85;
}
}
else {
iVar9 = 0;
iVar8 = iVar10;
do {
iVar3 = iVar1 + -1;
iVar1 = func0(iVar8 + -1,iVar1);
iVar4 = func0(iVar8 + -1,iVar3);
iVar9 = iVar9 + iVar1 + iVar4;
iVar1 = iVar8;
iVar8 = iVar3;
} while (iVar3 != 0);
local_80 = local_80 + iVar9 + 1 + local_88;
}
local_90 = local_94;
iVar1 = iVar2 + -2;
bVar11 = iVar1 == 0;
local_94 = iVar10;
if (!bVar11) break;
LAB_00101a4e:
local_88 = 1;
}
} while( true );
}
local_70 = 1;
LAB_00101a85:
iVar1 = local_74 + -1;
if ((local_74 != 1) && (local_98 != 0)) {
local_84 = 0;
local_74 = local_74 + -2;
bVar11 = local_74 == 0;
local_94 = iVar1;
if (bVar11) goto LAB_00101b9d;
do {
local_8c = 0;
iVar2 = local_98;
iVar10 = local_74;
do {
iVar9 = iVar2;
iVar8 = iVar9 + -1;
iVar2 = iVar10 + -1;
iVar10 = func0(iVar8,iVar10);
iVar8 = func0(iVar8,iVar2);
local_8c = local_8c + iVar10 + iVar8;
iVar10 = iVar9;
} while (iVar2 != 0);
local_8c = local_8c + 1;
while( true ) {
iVar2 = local_98;
iVar10 = local_98 + -1;
if ((local_98 == 1) || (bVar11)) {
local_84 = local_84 + 1 + local_8c;
if (iVar10 == 0) {
local_68 = local_68 + local_84 + 1 + local_70;
goto LAB_00101bd8;
}
}
else {
iVar9 = 0;
iVar8 = iVar10;
do {
iVar3 = local_74 + -1;
iVar4 = func0(iVar8 + -1,local_74);
iVar5 = func0(iVar8 + -1,iVar3);
iVar9 = iVar9 + iVar4 + iVar5;
local_74 = iVar8;
iVar8 = iVar3;
} while (iVar3 != 0);
local_84 = local_84 + iVar9 + 1 + local_8c;
}
local_98 = local_94;
local_74 = iVar2 + -2;
bVar11 = local_74 == 0;
local_94 = iVar10;
if (!bVar11) break;
LAB_00101b9d:
local_8c = 1;
}
} while( true );
}
local_68 = local_68 + 1 + local_70;
if (iVar1 == 0) goto code_r0x00101c0a;
LAB_00101bd8:
local_74 = local_78;
local_78 = iVar1;
} while( true );
}
local_58 = 1;
goto LAB_00101c15;
}
local_3c = local_3c + 1 + local_40;
if (iVar7 == 0) {
return local_3c + 1;
}
LAB_00101f85:
local_4c = local_48;
local_48 = iVar7;
goto LAB_00101232;
code_r0x00101c0a:
local_58 = local_68 + 1;
LAB_00101c15:
iVar1 = local_64 + -1;
if ((local_64 != 1) && (local_7c != 0)) {
local_6c = 0;
local_78 = iVar1;
do {
local_98 = local_78 + -1;
if (local_98 != 0) {
local_80 = 0;
local_94 = local_7c;
iVar10 = local_7c + -1;
bVar11 = iVar10 == 0;
local_90 = local_98;
if (bVar11) goto LAB_00101d5e;
do {
local_88 = 0;
iVar8 = local_90;
iVar2 = iVar10;
do {
iVar3 = iVar8;
iVar9 = iVar3 + -1;
iVar8 = iVar2 + -1;
iVar2 = func0(iVar9,iVar2);
iVar9 = func0(iVar9,iVar8);
local_88 = local_88 + iVar2 + iVar9;
iVar2 = iVar3;
} while (iVar8 != 0);
local_88 = local_88 + 1;
while( true ) {
iVar8 = local_90;
iVar2 = local_90 + -1;
if ((local_90 == 1) || (bVar11)) {
local_80 = local_80 + 1 + local_88;
if (iVar2 == 0) {
local_74 = local_80 + 1;
goto LAB_00101d93;
}
}
else {
iVar3 = 0;
iVar9 = iVar2;
do {
iVar4 = iVar10 + -1;
iVar10 = func0(iVar9 + -1,iVar10);
iVar5 = func0(iVar9 + -1,iVar4);
iVar3 = iVar3 + iVar10 + iVar5;
iVar10 = iVar9;
iVar9 = iVar4;
} while (iVar4 != 0);
local_80 = local_80 + iVar3 + 1 + local_88;
}
local_90 = local_94;
iVar10 = iVar8 + -2;
bVar11 = iVar10 == 0;
local_94 = iVar2;
if (!bVar11) break;
LAB_00101d5e:
local_88 = 1;
}
} while( true );
}
local_74 = 1;
LAB_00101d93:
iVar10 = local_7c + -1;
if ((local_7c != 1) && (local_98 != 0)) {
local_84 = 0;
local_7c = local_7c + -2;
bVar11 = local_7c == 0;
local_94 = iVar10;
if (bVar11) goto LAB_00101ead;
do {
local_8c = 0;
iVar8 = local_98;
iVar2 = local_7c;
do {
iVar3 = iVar8;
iVar9 = iVar3 + -1;
iVar8 = iVar2 + -1;
iVar2 = func0(iVar9,iVar2);
iVar9 = func0(iVar9,iVar8);
local_8c = local_8c + iVar2 + iVar9;
iVar2 = iVar3;
} while (iVar8 != 0);
local_8c = local_8c + 1;
while( true ) {
iVar8 = local_98;
iVar2 = local_98 + -1;
if ((local_98 == 1) || (bVar11)) {
local_84 = local_84 + 1 + local_8c;
if (iVar2 == 0) {
local_6c = local_6c + local_84 + 1 + local_74;
goto LAB_00101ee8;
}
}
else {
iVar3 = 0;
iVar9 = iVar2;
do {
iVar4 = local_7c + -1;
iVar5 = func0(iVar9 + -1,local_7c);
iVar6 = func0(iVar9 + -1,iVar4);
iVar3 = iVar3 + iVar5 + iVar6;
local_7c = iVar9;
iVar9 = iVar4;
} while (iVar4 != 0);
local_84 = local_84 + iVar3 + 1 + local_8c;
}
local_98 = local_94;
local_7c = iVar8 + -2;
bVar11 = local_7c == 0;
local_94 = iVar2;
if (!bVar11) break;
LAB_00101ead:
local_8c = 1;
}
} while( true );
}
local_6c = local_6c + 1 + local_74;
if (iVar10 == 0) goto code_r0x00101f18;
LAB_00101ee8:
local_7c = local_78;
local_78 = iVar10;
} while( true );
}
local_54 = local_54 + 1 + local_58;
if (iVar1 == 0) goto code_r0x00101f75;
LAB_00101f28:
local_64 = local_60;
local_60 = iVar1;
goto LAB_0010190d;
code_r0x00101f18:
local_54 = local_54 + local_6c + 1 + local_58;
goto LAB_00101f28;
code_r0x00101f75:
local_3c = local_3c + local_54 + 1 + local_40;
goto LAB_00101f85;
} |
7,631 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
je 1278 <func0+0x78>
push %r15
mov $0x1,%eax
push %r14
xor %r14d,%r14d
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %edi,%ebp
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 1264 <func0+0x64>
lea -0x1(%r12),%r15d
mov %ebp,%esi
lea -0x1(%rbp),%r13d
mov %r12d,%ebp
mov %r15d,%edi
callq 1200 <func0>
mov %r13d,%esi
mov %r15d,%edi
mov %eax,%ebx
callq 1200 <func0>
add %eax,%ebx
add %ebx,%r14d
test %r13d,%r13d
je 1260 <func0+0x60>
mov %r13d,%r12d
jmp 1227 <func0+0x27>
nopl 0x0(%rax)
lea 0x1(%r14),%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jz loc_1D9F
push r15
mov ecx, edi
mov eax, 1
push r14
push r13
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 48h
test edi, edi
jz loc_1D90
lea eax, [rcx-1]
mov r9d, esi
mov [rsp+78h+var_44], r12d
mov [rsp+78h+var_48], esi
mov r14d, eax
sub r9d, 1
jz loc_1D7D
loc_1248:
mov esi, r9d
mov ebp, eax
mov [rsp+78h+var_40], r9d
xor r15d, r15d
mov r9d, ebp
lea r14d, [rsi-1]
mov [rsp+78h+var_4C], r15d
mov [rsp+78h+var_3C], eax
mov ebp, r14d
mov [rsp+78h+var_58], ecx
test r9d, r9d
jz loc_17B4
loc_1275:
mov r8d, r9d
xor r13d, r13d
mov edx, r14d
mov [rsp+78h+var_68], esi
lea eax, [r8-1]
mov [rsp+78h+var_54], r9d
mov [rsp+78h+var_5C], r13d
mov r15d, eax
mov [rsp+78h+var_50], r14d
test edx, edx
jz loc_14F4
loc_12A0:
xor edi, edi
mov r12d, edx
mov esi, eax
mov [rsp+78h+var_60], eax
mov [rsp+78h+var_6C], edi
lea edi, [r12-1]
mov [rsp+78h+var_78], r8d
mov eax, edi
mov [rsp+78h+var_64], edx
test esi, esi
jz loc_1395
loc_12C6:
mov [rsp+78h+var_74], esi
xor r13d, r13d
mov r14d, r12d
mov ebp, esi
mov [rsp+78h+var_70], edi
mov r12d, r13d
mov r13d, edi
loc_12DC:
mov esi, ebp
mov edi, r13d
lea r15d, [rbp-1]
mov ebp, r14d
call func0
mov esi, r15d
mov edi, r13d
mov ebx, eax
call func0
add ebx, eax
add r12d, ebx
test r15d, r15d
jz short loc_1310
mov r14d, r15d
lea r13d, [r15-1]
jmp short loc_12DC
loc_1310:
mov eax, [rsp+78h+var_70]
mov r14d, [rsp+78h+var_74]
lea ebx, [r12+1]
test eax, eax
jz loc_1EE2
mov [rsp+78h+var_74], ebx
mov r13d, eax
mov ebx, r15d
loc_1330:
lea r15d, [r13-1]
mov esi, r14d
lea r12d, [r14-1]
mov r14d, r13d
mov edi, r15d
call func0
mov esi, r12d
mov edi, r15d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1368
mov r13d, r12d
jmp short loc_1330
loc_1368:
mov r15d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r15+rbx+1]
add [rsp+78h+var_6C], edx
loc_137C:
mov r12d, [rsp+78h+var_78]
lea esi, [rax-1]
mov [rsp+78h+var_78], eax
lea edi, [r12-1]
mov eax, edi
test esi, esi
jnz loc_12C6
loc_1395:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_137C
mov r9d, [rsp+78h+var_64]
mov edi, [rsp+78h+var_6C]
mov r15d, [rsp+78h+var_60]
loc_13AC:
lea r14d, [rdi+1]
test r15d, r15d
jz loc_1ECA
mov r12d, r9d
mov [rsp+78h+var_64], r14d
xor esi, esi
mov r14d, r15d
lea edi, [r12-1]
mov [rsp+78h+var_78], r15d
mov [rsp+78h+var_6C], esi
mov eax, edi
mov [rsp+78h+var_60], r15d
sub r14d, 1
jz loc_14B7
loc_13E4:
mov [rsp+78h+var_70], edi
xor r13d, r13d
mov ebp, r14d
mov [rsp+78h+var_74], r14d
mov r14d, r12d
mov r12d, r13d
mov r13d, edi
loc_13FC:
mov esi, ebp
mov edi, r13d
lea r15d, [rbp-1]
mov ebp, r14d
call func0
mov esi, r15d
mov edi, r13d
mov ebx, eax
call func0
add ebx, eax
add r12d, ebx
test r15d, r15d
jz short loc_1430
mov r14d, r15d
lea r13d, [r15-1]
jmp short loc_13FC
loc_1430:
mov eax, [rsp+78h+var_70]
mov r14d, [rsp+78h+var_74]
lea ebx, [r12+1]
test eax, eax
jz loc_1EB2
mov [rsp+78h+var_74], ebx
mov r13d, eax
mov ebx, r15d
loc_1450:
lea r15d, [r13-1]
mov esi, r14d
lea r12d, [r14-1]
mov r14d, r13d
mov edi, r15d
call func0
mov esi, r12d
mov edi, r15d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1488
mov r13d, r12d
jmp short loc_1450
loc_1488:
mov r15d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r15+rbx+1]
add [rsp+78h+var_6C], edx
loc_149C:
mov r12d, [rsp+78h+var_78]
mov r14d, eax
mov [rsp+78h+var_78], eax
lea edi, [r12-1]
mov eax, edi
sub r14d, 1
jnz loc_13E4
loc_14B7:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_149C
mov r14d, [rsp+78h+var_64]
mov esi, [rsp+78h+var_6C]
mov r15d, [rsp+78h+var_60]
loc_14CE:
lea eax, [r14+rsi+1]
add [rsp+78h+var_5C], eax
loc_14D7:
mov r8d, [rsp+78h+var_68]
lea edx, [r15-1]
mov [rsp+78h+var_68], r15d
lea eax, [r8-1]
mov r15d, eax
test edx, edx
jnz loc_12A0
loc_14F4:
add [rsp+78h+var_5C], 2
test eax, eax
jnz short loc_14D7
mov r9d, [rsp+78h+var_54]
mov r13d, [rsp+78h+var_5C]
mov ebp, [rsp+78h+var_50]
loc_150B:
lea ebx, [r13+1]
test ebp, ebp
jz loc_1E99
xor r13d, r13d
lea eax, [r9-1]
mov r10d, ebp
mov [rsp+78h+var_54], ebx
mov [rsp+78h+var_68], ebp
mov ecx, eax
mov [rsp+78h+var_5C], r13d
mov [rsp+78h+var_50], ebp
sub r10d, 1
jz loc_1777
loc_153E:
mov ebp, r10d
xor edx, edx
mov [rsp+78h+var_60], eax
lea edi, [rbp-1]
mov [rsp+78h+var_78], r9d
mov [rsp+78h+var_64], r10d
mov eax, edi
mov [rsp+78h+var_6C], edx
test ecx, ecx
jz loc_162A
loc_1561:
mov [rsp+78h+var_74], ecx
xor r12d, r12d
mov r15d, ebp
mov r14d, ecx
mov [rsp+78h+var_70], edi
mov ebp, r12d
mov r12d, edi
loc_1578:
mov esi, r14d
mov edi, r12d
lea r13d, [r14-1]
mov r14d, r15d
call func0
mov esi, r13d
mov edi, r12d
mov ebx, eax
call func0
add ebx, eax
add ebp, ebx
test r13d, r13d
jz short loc_15B0
mov r15d, r13d
lea r12d, [r13-1]
jmp short loc_1578
loc_15B0:
mov eax, [rsp+78h+var_70]
mov r15d, [rsp+78h+var_74]
lea ebx, [rbp+1]
test eax, eax
jz loc_1E83
mov [rsp+78h+var_74], ebx
mov r14d, eax
mov ebx, r13d
loc_15CE:
lea r13d, [r14-1]
mov esi, r15d
lea r12d, [r15-1]
mov r15d, r14d
mov edi, r13d
call func0
mov esi, r12d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1600
mov r14d, r12d
jmp short loc_15CE
loc_1600:
mov r13d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r13+rbx+1]
add [rsp+78h+var_6C], edx
loc_1614:
mov ebp, [rsp+78h+var_78]
lea ecx, [rax-1]
mov [rsp+78h+var_78], eax
lea edi, [rbp-1]
mov eax, edi
test ecx, ecx
jnz loc_1561
loc_162A:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_1614
mov r10d, [rsp+78h+var_64]
mov edx, [rsp+78h+var_6C]
mov ecx, [rsp+78h+var_60]
loc_1640:
lea r14d, [rdx+1]
test ecx, ecx
jz loc_1E6C
mov ebp, r10d
mov [rsp+78h+var_64], r14d
xor esi, esi
mov r14d, ecx
lea edi, [rbp-1]
mov [rsp+78h+var_78], ecx
mov [rsp+78h+var_6C], esi
mov eax, edi
mov [rsp+78h+var_60], ecx
sub r14d, 1
jz loc_173C
loc_1673:
mov [rsp+78h+var_70], edi
xor r12d, r12d
mov r15d, r14d
mov [rsp+78h+var_74], r14d
mov r14d, ebp
mov ebp, r12d
mov r12d, edi
loc_168B:
mov esi, r15d
mov edi, r12d
lea r13d, [r15-1]
mov r15d, r14d
call func0
mov esi, r13d
mov edi, r12d
mov ebx, eax
call func0
add ebx, eax
add ebp, ebx
test r13d, r13d
jz short loc_16C0
mov r14d, r13d
lea r12d, [r13-1]
jmp short loc_168B
loc_16C0:
mov eax, [rsp+78h+var_70]
mov r14d, [rsp+78h+var_74]
lea ebx, [rbp+1]
test eax, eax
jz loc_1E56
mov [rsp+78h+var_74], ebx
mov r15d, eax
mov ebx, r13d
loc_16DE:
lea r13d, [r15-1]
mov esi, r14d
lea r12d, [r14-1]
mov r14d, r15d
mov edi, r13d
call func0
mov esi, r12d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1710
mov r15d, r12d
jmp short loc_16DE
loc_1710:
mov r13d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r13+rbx+1]
add [rsp+78h+var_6C], edx
loc_1724:
mov ebp, [rsp+78h+var_78]
mov r14d, eax
mov [rsp+78h+var_78], eax
lea edi, [rbp-1]
mov eax, edi
sub r14d, 1
jnz loc_1673
loc_173C:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_1724
mov r14d, [rsp+78h+var_64]
mov esi, [rsp+78h+var_6C]
mov ecx, [rsp+78h+var_60]
loc_1752:
lea eax, [r14+rsi+1]
add [rsp+78h+var_5C], eax
loc_175B:
mov r9d, [rsp+78h+var_68]
mov r10d, ecx
mov [rsp+78h+var_68], ecx
lea eax, [r9-1]
mov ecx, eax
sub r10d, 1
jnz loc_153E
loc_1777:
add [rsp+78h+var_5C], 2
test eax, eax
jnz short loc_175B
mov ebx, [rsp+78h+var_54]
mov r13d, [rsp+78h+var_5C]
mov ebp, [rsp+78h+var_50]
loc_178D:
lea eax, [rbx+r13+1]
add [rsp+78h+var_4C], eax
loc_1796:
mov esi, [rsp+78h+var_58]
mov [rsp+78h+var_58], ebp
lea ebp, [rbp-1]
mov r9d, ebp
lea r14d, [rsi-1]
mov ebp, r14d
test r9d, r9d
jnz loc_1275
loc_17B4:
add [rsp+78h+var_4C], 2
test r14d, r14d
jnz short loc_1796
mov r9d, [rsp+78h+var_40]
mov r15d, [rsp+78h+var_4C]
mov r14d, [rsp+78h+var_3C]
loc_17CD:
lea ebx, [r15+1]
test r14d, r14d
jz loc_1E47
mov esi, r9d
xor ecx, ecx
mov r9d, r14d
mov [rsp+78h+var_58], r14d
lea r13d, [rsi-1]
mov [rsp+78h+var_40], ebx
mov [rsp+78h+var_4C], ecx
mov edx, r13d
mov [rsp+78h+var_3C], r14d
sub r9d, 1
jz loc_1D42
loc_1805:
mov r8d, r9d
xor r12d, r12d
mov [rsp+78h+var_68], esi
lea eax, [r8-1]
mov [rsp+78h+var_54], r9d
mov [rsp+78h+var_5C], r12d
mov r15d, eax
mov [rsp+78h+var_50], r13d
test edx, edx
jz loc_1A84
loc_182D:
xor edi, edi
mov r12d, edx
mov esi, eax
mov [rsp+78h+var_60], eax
mov [rsp+78h+var_6C], edi
lea edi, [r12-1]
mov [rsp+78h+var_78], r8d
mov eax, edi
mov [rsp+78h+var_64], edx
test esi, esi
jz loc_1925
loc_1853:
mov [rsp+78h+var_74], esi
xor r14d, r14d
mov r13d, r12d
mov ebp, esi
mov [rsp+78h+var_70], edi
mov r12d, r14d
mov r14d, edi
loc_1869:
mov esi, ebp
mov edi, r14d
lea r15d, [rbp-1]
mov ebp, r13d
call func0
mov esi, r15d
mov edi, r14d
mov ebx, eax
call func0
add ebx, eax
add r12d, ebx
test r15d, r15d
jz short loc_18A0
mov r13d, r15d
lea r14d, [r15-1]
jmp short loc_1869
loc_18A0:
mov eax, [rsp+78h+var_70]
mov r13d, [rsp+78h+var_74]
lea ebx, [r12+1]
test eax, eax
jz loc_1E2F
mov [rsp+78h+var_74], ebx
mov r14d, eax
mov ebx, r15d
loc_18C0:
lea r15d, [r14-1]
mov esi, r13d
lea r12d, [r13-1]
mov r13d, r14d
mov edi, r15d
call func0
mov esi, r12d
mov edi, r15d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_18F8
mov r14d, r12d
jmp short loc_18C0
loc_18F8:
mov r15d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r15+rbx+1]
add [rsp+78h+var_6C], edx
loc_190C:
mov r12d, [rsp+78h+var_78]
lea esi, [rax-1]
mov [rsp+78h+var_78], eax
lea edi, [r12-1]
mov eax, edi
test esi, esi
jnz loc_1853
loc_1925:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_190C
mov r9d, [rsp+78h+var_64]
mov edi, [rsp+78h+var_6C]
mov r15d, [rsp+78h+var_60]
loc_193C:
lea r13d, [rdi+1]
test r15d, r15d
jz loc_1E17
mov r12d, r9d
mov [rsp+78h+var_64], r13d
xor esi, esi
mov r13d, r15d
lea edi, [r12-1]
mov [rsp+78h+var_78], r15d
mov [rsp+78h+var_6C], esi
mov eax, edi
mov [rsp+78h+var_60], r15d
sub r13d, 1
jz loc_1A47
loc_1974:
mov [rsp+78h+var_70], edi
xor r14d, r14d
mov ebp, r13d
mov [rsp+78h+var_74], r13d
mov r13d, r12d
mov r12d, r14d
mov r14d, edi
loc_198C:
mov esi, ebp
mov edi, r14d
lea r15d, [rbp-1]
mov ebp, r13d
call func0
mov esi, r15d
mov edi, r14d
mov ebx, eax
call func0
add ebx, eax
add r12d, ebx
test r15d, r15d
jz short loc_19C0
mov r13d, r15d
lea r14d, [r15-1]
jmp short loc_198C
loc_19C0:
mov eax, [rsp+78h+var_70]
mov r13d, [rsp+78h+var_74]
lea ebx, [r12+1]
test eax, eax
jz loc_1DFF
mov [rsp+78h+var_74], ebx
mov r14d, eax
mov ebx, r15d
loc_19E0:
lea r15d, [r14-1]
mov esi, r13d
lea r12d, [r13-1]
mov r13d, r14d
mov edi, r15d
call func0
mov esi, r12d
mov edi, r15d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1A18
mov r14d, r12d
jmp short loc_19E0
loc_1A18:
mov r15d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r15+rbx+1]
add [rsp+78h+var_6C], edx
loc_1A2C:
mov r12d, [rsp+78h+var_78]
mov r13d, eax
mov [rsp+78h+var_78], eax
lea edi, [r12-1]
mov eax, edi
sub r13d, 1
jnz loc_1974
loc_1A47:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_1A2C
mov r13d, [rsp+78h+var_64]
mov esi, [rsp+78h+var_6C]
mov r15d, [rsp+78h+var_60]
loc_1A5E:
lea eax, [r13+rsi+1]
add [rsp+78h+var_5C], eax
loc_1A67:
mov r8d, [rsp+78h+var_68]
lea edx, [r15-1]
mov [rsp+78h+var_68], r15d
lea eax, [r8-1]
mov r15d, eax
test edx, edx
jnz loc_182D
loc_1A84:
add [rsp+78h+var_5C], 2
test eax, eax
jnz short loc_1A67
mov r9d, [rsp+78h+var_54]
mov r12d, [rsp+78h+var_5C]
mov edx, [rsp+78h+var_50]
loc_1A9B:
lea ebp, [r12+1]
test edx, edx
jz loc_1DE8
xor r13d, r13d
mov r8d, edx
lea eax, [r9-1]
mov [rsp+78h+var_68], edx
mov [rsp+78h+var_50], edx
mov edx, eax
mov [rsp+78h+var_54], ebp
mov [rsp+78h+var_5C], r13d
sub r8d, 1
jz loc_1D07
loc_1ACF:
xor esi, esi
mov ebp, r8d
mov [rsp+78h+var_60], eax
mov [rsp+78h+var_6C], esi
lea edi, [rbp-1]
mov esi, eax
mov [rsp+78h+var_78], r9d
mov eax, edi
mov [rsp+78h+var_64], r8d
test esi, esi
jz loc_1BBA
loc_1AF4:
mov [rsp+78h+var_74], esi
xor r12d, r12d
mov r15d, ebp
mov r14d, esi
mov [rsp+78h+var_70], edi
mov ebp, r12d
mov r12d, edi
loc_1B0B:
mov esi, r14d
mov edi, r12d
lea r13d, [r14-1]
mov r14d, r15d
call func0
mov esi, r13d
mov edi, r12d
mov ebx, eax
call func0
add ebx, eax
add ebp, ebx
test r13d, r13d
jz short loc_1B40
mov r15d, r13d
lea r12d, [r13-1]
jmp short loc_1B0B
loc_1B40:
mov eax, [rsp+78h+var_70]
mov r15d, [rsp+78h+var_74]
lea ebx, [rbp+1]
test eax, eax
jz loc_1DD2
mov [rsp+78h+var_74], ebx
mov r14d, eax
mov ebx, r13d
loc_1B5E:
lea r13d, [r14-1]
mov esi, r15d
lea r12d, [r15-1]
mov r15d, r14d
mov edi, r13d
call func0
mov esi, r12d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1B90
mov r14d, r12d
jmp short loc_1B5E
loc_1B90:
mov r13d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r13+rbx+1]
add [rsp+78h+var_6C], edx
loc_1BA4:
mov ebp, [rsp+78h+var_78]
lea esi, [rax-1]
mov [rsp+78h+var_78], eax
lea edi, [rbp-1]
mov eax, edi
test esi, esi
jnz loc_1AF4
loc_1BBA:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_1BA4
mov r8d, [rsp+78h+var_64]
mov esi, [rsp+78h+var_6C]
mov edx, [rsp+78h+var_60]
loc_1BD0:
lea r14d, [rsi+1]
test edx, edx
jz loc_1DBB
mov ebp, r8d
mov [rsp+78h+var_64], r14d
xor esi, esi
mov r14d, edx
lea edi, [rbp-1]
mov [rsp+78h+var_78], edx
mov [rsp+78h+var_6C], esi
mov eax, edi
mov [rsp+78h+var_60], edx
sub r14d, 1
jz loc_1CCC
loc_1C03:
mov [rsp+78h+var_70], edi
xor r12d, r12d
mov r15d, r14d
mov [rsp+78h+var_74], r14d
mov r14d, ebp
mov ebp, r12d
mov r12d, edi
loc_1C1B:
mov esi, r15d
mov edi, r12d
lea r13d, [r15-1]
mov r15d, r14d
call func0
mov esi, r13d
mov edi, r12d
mov ebx, eax
call func0
add ebx, eax
add ebp, ebx
test r13d, r13d
jz short loc_1C50
mov r14d, r13d
lea r12d, [r13-1]
jmp short loc_1C1B
loc_1C50:
mov eax, [rsp+78h+var_70]
mov r14d, [rsp+78h+var_74]
lea ebx, [rbp+1]
test eax, eax
jz loc_1DA5
mov [rsp+78h+var_74], ebx
mov r15d, eax
mov ebx, r13d
loc_1C6E:
lea r13d, [r15-1]
mov esi, r14d
lea r12d, [r14-1]
mov r14d, r15d
mov edi, r13d
call func0
mov esi, r12d
mov edi, r13d
mov ebp, eax
call func0
add ebp, eax
add ebx, ebp
test r12d, r12d
jz short loc_1CA0
mov r15d, r12d
jmp short loc_1C6E
loc_1CA0:
mov r13d, ebx
mov ebx, [rsp+78h+var_74]
mov eax, [rsp+78h+var_70]
lea edx, [r13+rbx+1]
add [rsp+78h+var_6C], edx
loc_1CB4:
mov ebp, [rsp+78h+var_78]
mov r14d, eax
mov [rsp+78h+var_78], eax
lea edi, [rbp-1]
mov eax, edi
sub r14d, 1
jnz loc_1C03
loc_1CCC:
add [rsp+78h+var_6C], 2
test edi, edi
jnz short loc_1CB4
mov r14d, [rsp+78h+var_64]
mov esi, [rsp+78h+var_6C]
mov edx, [rsp+78h+var_60]
loc_1CE2:
lea eax, [r14+rsi+1]
add [rsp+78h+var_5C], eax
loc_1CEB:
mov r9d, [rsp+78h+var_68]
mov r8d, edx
mov [rsp+78h+var_68], edx
lea eax, [r9-1]
mov edx, eax
sub r8d, 1
jnz loc_1ACF
loc_1D07:
add [rsp+78h+var_5C], 2
test eax, eax
jnz short loc_1CEB
mov ebp, [rsp+78h+var_54]
mov r13d, [rsp+78h+var_5C]
mov edx, [rsp+78h+var_50]
loc_1D1D:
lea eax, [rbp+r13+1]
add [rsp+78h+var_4C], eax
loc_1D26:
mov esi, [rsp+78h+var_58]
mov r9d, edx
mov [rsp+78h+var_58], edx
lea r13d, [rsi-1]
mov edx, r13d
sub r9d, 1
jnz loc_1805
loc_1D42:
add [rsp+78h+var_4C], 2
test r13d, r13d
jnz short loc_1D26
mov ebx, [rsp+78h+var_40]
mov ecx, [rsp+78h+var_4C]
mov r14d, [rsp+78h+var_3C]
loc_1D59:
lea eax, [rbx+rcx+1]
add [rsp+78h+var_44], eax
loc_1D61:
mov ecx, [rsp+78h+var_48]
mov r9d, r14d
mov [rsp+78h+var_48], r14d
lea eax, [rcx-1]
mov r14d, eax
sub r9d, 1
jnz loc_1248
loc_1D7D:
add [rsp+78h+var_44], 2
test eax, eax
jnz short loc_1D61
mov r12d, [rsp+78h+var_44]
loc_1D8B:
lea eax, [r12+1]
loc_1D90:
add rsp, 48h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1D9F:
mov eax, 1
retn
loc_1DA5:
mov esi, [rsp+78h+var_6C]
mov r14d, [rsp+78h+var_64]
mov edx, [rsp+78h+var_60]
lea esi, [rbp+rsi+2]
jmp loc_1CE2
loc_1DBB:
mov r13d, [rsp+78h+var_5C]
mov ebp, [rsp+78h+var_54]
mov edx, [rsp+78h+var_50]
lea r13d, [r13+rsi+2]
jmp loc_1D1D
loc_1DD2:
mov esi, [rsp+78h+var_6C]
mov r8d, [rsp+78h+var_64]
mov edx, [rsp+78h+var_60]
lea esi, [rbp+rsi+2]
jmp loc_1BD0
loc_1DE8:
mov ecx, [rsp+78h+var_4C]
mov ebx, [rsp+78h+var_40]
mov r14d, [rsp+78h+var_3C]
lea ecx, [rcx+r12+2]
jmp loc_1D59
loc_1DFF:
mov esi, [rsp+78h+var_6C]
mov r13d, [rsp+78h+var_64]
mov r15d, [rsp+78h+var_60]
lea esi, [r12+rsi+2]
jmp loc_1A5E
loc_1E17:
mov r12d, [rsp+78h+var_5C]
mov r9d, [rsp+78h+var_54]
mov edx, [rsp+78h+var_50]
lea r12d, [r12+rdi+2]
jmp loc_1A9B
loc_1E2F:
mov edi, [rsp+78h+var_6C]
mov r9d, [rsp+78h+var_64]
mov r15d, [rsp+78h+var_60]
lea edi, [r12+rdi+2]
jmp loc_193C
loc_1E47:
mov r12d, [rsp+78h+var_44]
lea r12d, [r12+r15+2]
jmp loc_1D8B
loc_1E56:
mov esi, [rsp+78h+var_6C]
mov r14d, [rsp+78h+var_64]
mov ecx, [rsp+78h+var_60]
lea esi, [rbp+rsi+2]
jmp loc_1752
loc_1E6C:
mov r13d, [rsp+78h+var_5C]
mov ebx, [rsp+78h+var_54]
mov ebp, [rsp+78h+var_50]
lea r13d, [r13+rdx+2]
jmp loc_178D
loc_1E83:
mov edx, [rsp+78h+var_6C]
mov r10d, [rsp+78h+var_64]
mov ecx, [rsp+78h+var_60]
lea edx, [rbp+rdx+2]
jmp loc_1640
loc_1E99:
mov r15d, [rsp+78h+var_4C]
mov r9d, [rsp+78h+var_40]
mov r14d, [rsp+78h+var_3C]
lea r15d, [r15+r13+2]
jmp loc_17CD
loc_1EB2:
mov esi, [rsp+78h+var_6C]
mov r14d, [rsp+78h+var_64]
mov r15d, [rsp+78h+var_60]
lea esi, [r12+rsi+2]
jmp loc_14CE
loc_1ECA:
mov r13d, [rsp+78h+var_5C]
mov r9d, [rsp+78h+var_54]
mov ebp, [rsp+78h+var_50]
lea r13d, [r13+rdi+2]
jmp loc_150B
loc_1EE2:
mov edi, [rsp+78h+var_6C]
mov r9d, [rsp+78h+var_64]
mov r15d, [rsp+78h+var_60]
lea edi, [r12+rdi+2]
jmp loc_13AC | long long func0(unsigned int a1, unsigned int a2)
{
unsigned int v2; // ecx
long long result; // rax
unsigned int v4; // eax
unsigned int v5; // r14d
unsigned int v6; // r9d
unsigned int v7; // esi
unsigned int v8; // r9d
unsigned int v9; // r14d
unsigned int v10; // ebp
unsigned int v11; // r8d
unsigned int v12; // edx
unsigned int v13; // eax
unsigned int v14; // r15d
unsigned int v15; // r12d
unsigned int v16; // esi
unsigned int v17; // edi
unsigned int v18; // eax
unsigned int v19; // r14d
unsigned int v20; // ebp
int v21; // r12d
unsigned int i; // r13d
long long v23; // rsi
unsigned int v24; // r15d
int v25; // ebx
unsigned int v26; // r14d
unsigned int v27; // r13d
int v28; // ebx
long long v29; // rsi
unsigned int v30; // r12d
int v31; // ebp
unsigned int v32; // r9d
int v33; // edi
unsigned int v34; // r15d
unsigned int v35; // r12d
unsigned int v36; // edi
unsigned int v37; // eax
unsigned int v38; // r14d
unsigned int v39; // ebp
unsigned int v40; // r14d
int v41; // r12d
unsigned int j; // r13d
long long v43; // rsi
unsigned int v44; // r15d
int v45; // ebx
unsigned int v46; // r14d
unsigned int v47; // r13d
int v48; // ebx
long long v49; // rsi
unsigned int v50; // r12d
int v51; // ebp
unsigned int v52; // r14d
int v53; // r14d
int v54; // esi
unsigned int v55; // r9d
int v56; // r13d
unsigned int v57; // ebp
unsigned int v58; // eax
unsigned int v59; // ecx
unsigned int v60; // r10d
unsigned int v61; // ebp
unsigned int v62; // edi
unsigned int v63; // eax
unsigned int v64; // r15d
unsigned int v65; // r14d
int v66; // ebp
unsigned int k; // r12d
long long v68; // rsi
unsigned int v69; // r13d
int v70; // ebx
unsigned int v71; // r15d
unsigned int v72; // r14d
int v73; // ebx
long long v74; // rsi
unsigned int v75; // r12d
int v76; // ebp
unsigned int v77; // r10d
int v78; // edx
unsigned int v79; // ecx
unsigned int v80; // ebp
unsigned int v81; // edi
unsigned int v82; // eax
unsigned int v83; // r14d
unsigned int v84; // r15d
unsigned int v85; // r14d
int v86; // ebp
unsigned int m; // r12d
long long v88; // rsi
unsigned int v89; // r13d
int v90; // ebx
unsigned int v91; // r14d
unsigned int v92; // r15d
int v93; // ebx
long long v94; // rsi
unsigned int v95; // r12d
int v96; // ebp
unsigned int v97; // r14d
int v98; // r14d
int v99; // esi
unsigned int v100; // r10d
int v101; // ebx
int v102; // r13d
unsigned int v103; // r9d
int v104; // r15d
unsigned int v105; // r14d
unsigned int v106; // esi
unsigned int v107; // r13d
unsigned int v108; // edx
unsigned int v109; // r9d
unsigned int v110; // r8d
unsigned int v111; // eax
unsigned int v112; // r15d
unsigned int v113; // r12d
unsigned int v114; // esi
unsigned int v115; // edi
unsigned int v116; // eax
unsigned int v117; // r13d
unsigned int v118; // ebp
int v119; // r12d
unsigned int n; // r14d
long long v121; // rsi
unsigned int v122; // r15d
int v123; // ebx
unsigned int v124; // r13d
unsigned int v125; // r14d
int v126; // ebx
long long v127; // rsi
unsigned int v128; // r12d
int v129; // ebp
unsigned int v130; // r9d
int v131; // edi
unsigned int v132; // r15d
unsigned int v133; // r12d
unsigned int v134; // edi
unsigned int v135; // eax
unsigned int v136; // r13d
unsigned int v137; // ebp
unsigned int v138; // r13d
int v139; // r12d
unsigned int ii; // r14d
long long v141; // rsi
unsigned int v142; // r15d
int v143; // ebx
unsigned int v144; // r13d
unsigned int v145; // r14d
int v146; // ebx
long long v147; // rsi
unsigned int v148; // r12d
int v149; // ebp
unsigned int v150; // r13d
int v151; // r13d
int v152; // esi
unsigned int v153; // r9d
int v154; // r12d
unsigned int v155; // edx
unsigned int v156; // r8d
unsigned int v157; // eax
unsigned int v158; // edx
unsigned int v159; // r8d
unsigned int v160; // ebp
unsigned int v161; // edi
unsigned int v162; // esi
unsigned int v163; // eax
unsigned int v164; // r15d
unsigned int v165; // r14d
int v166; // ebp
unsigned int jj; // r12d
long long v168; // rsi
unsigned int v169; // r13d
int v170; // ebx
unsigned int v171; // r15d
unsigned int v172; // r14d
int v173; // ebx
long long v174; // rsi
unsigned int v175; // r12d
int v176; // ebp
unsigned int v177; // r8d
int v178; // esi
unsigned int v179; // edx
unsigned int v180; // ebp
unsigned int v181; // edi
unsigned int v182; // eax
unsigned int v183; // r14d
unsigned int v184; // r15d
unsigned int v185; // r14d
int v186; // ebp
unsigned int kk; // r12d
long long v188; // rsi
unsigned int v189; // r13d
int v190; // ebx
unsigned int v191; // r14d
unsigned int v192; // r15d
int v193; // ebx
long long v194; // rsi
unsigned int v195; // r12d
int v196; // ebp
unsigned int v197; // r14d
int v198; // r14d
int v199; // esi
unsigned int v200; // r8d
int v201; // ebp
int v202; // r13d
unsigned int v203; // r9d
int v204; // ebx
int v205; // ecx
unsigned int v206; // r9d
int v207; // r12d
unsigned int v208; // [rsp+0h] [rbp-78h]
unsigned int v209; // [rsp+0h] [rbp-78h]
unsigned int v210; // [rsp+0h] [rbp-78h]
unsigned int v211; // [rsp+0h] [rbp-78h]
unsigned int v212; // [rsp+0h] [rbp-78h]
unsigned int v213; // [rsp+0h] [rbp-78h]
unsigned int v214; // [rsp+0h] [rbp-78h]
unsigned int v215; // [rsp+0h] [rbp-78h]
unsigned int v216; // [rsp+4h] [rbp-74h]
int v217; // [rsp+4h] [rbp-74h]
unsigned int v218; // [rsp+4h] [rbp-74h]
int v219; // [rsp+4h] [rbp-74h]
unsigned int v220; // [rsp+4h] [rbp-74h]
int v221; // [rsp+4h] [rbp-74h]
unsigned int v222; // [rsp+4h] [rbp-74h]
int v223; // [rsp+4h] [rbp-74h]
unsigned int v224; // [rsp+4h] [rbp-74h]
int v225; // [rsp+4h] [rbp-74h]
unsigned int v226; // [rsp+4h] [rbp-74h]
int v227; // [rsp+4h] [rbp-74h]
unsigned int v228; // [rsp+4h] [rbp-74h]
int v229; // [rsp+4h] [rbp-74h]
unsigned int v230; // [rsp+4h] [rbp-74h]
int v231; // [rsp+4h] [rbp-74h]
int v232; // [rsp+Ch] [rbp-6Ch]
int v233; // [rsp+Ch] [rbp-6Ch]
int v234; // [rsp+Ch] [rbp-6Ch]
int v235; // [rsp+Ch] [rbp-6Ch]
int v236; // [rsp+Ch] [rbp-6Ch]
int v237; // [rsp+Ch] [rbp-6Ch]
int v238; // [rsp+Ch] [rbp-6Ch]
int v239; // [rsp+Ch] [rbp-6Ch]
unsigned int v240; // [rsp+10h] [rbp-68h]
unsigned int v241; // [rsp+10h] [rbp-68h]
unsigned int v242; // [rsp+10h] [rbp-68h]
unsigned int v243; // [rsp+10h] [rbp-68h]
unsigned int v244; // [rsp+14h] [rbp-64h]
int v245; // [rsp+14h] [rbp-64h]
unsigned int v246; // [rsp+14h] [rbp-64h]
int v247; // [rsp+14h] [rbp-64h]
unsigned int v248; // [rsp+14h] [rbp-64h]
int v249; // [rsp+14h] [rbp-64h]
unsigned int v250; // [rsp+14h] [rbp-64h]
int v251; // [rsp+14h] [rbp-64h]
unsigned int v252; // [rsp+18h] [rbp-60h]
unsigned int v253; // [rsp+18h] [rbp-60h]
unsigned int v254; // [rsp+18h] [rbp-60h]
unsigned int v255; // [rsp+18h] [rbp-60h]
unsigned int v256; // [rsp+18h] [rbp-60h]
unsigned int v257; // [rsp+18h] [rbp-60h]
unsigned int v258; // [rsp+18h] [rbp-60h]
unsigned int v259; // [rsp+18h] [rbp-60h]
int v260; // [rsp+1Ch] [rbp-5Ch]
int v261; // [rsp+1Ch] [rbp-5Ch]
int v262; // [rsp+1Ch] [rbp-5Ch]
int v263; // [rsp+1Ch] [rbp-5Ch]
unsigned int v264; // [rsp+20h] [rbp-58h]
unsigned int v265; // [rsp+20h] [rbp-58h]
unsigned int v266; // [rsp+24h] [rbp-54h]
int v267; // [rsp+24h] [rbp-54h]
unsigned int v268; // [rsp+24h] [rbp-54h]
int v269; // [rsp+24h] [rbp-54h]
unsigned int v270; // [rsp+28h] [rbp-50h]
unsigned int v271; // [rsp+28h] [rbp-50h]
unsigned int v272; // [rsp+28h] [rbp-50h]
unsigned int v273; // [rsp+28h] [rbp-50h]
int v274; // [rsp+2Ch] [rbp-4Ch]
int v275; // [rsp+2Ch] [rbp-4Ch]
unsigned int v276; // [rsp+30h] [rbp-48h]
int v277; // [rsp+34h] [rbp-44h]
unsigned int v278; // [rsp+38h] [rbp-40h]
int v279; // [rsp+38h] [rbp-40h]
unsigned int v280; // [rsp+3Ch] [rbp-3Ch]
unsigned int v281; // [rsp+3Ch] [rbp-3Ch]
if ( !a2 )
return 1LL;
v2 = a1;
result = 1LL;
if ( a1 )
{
v4 = a1 - 1;
v277 = 0;
v276 = a2;
v5 = a1 - 1;
v6 = a2 - 1;
if ( a2 == 1 )
goto LABEL_139;
while ( 1 )
{
v7 = v6;
v278 = v6;
v8 = v4;
v9 = v7 - 1;
v274 = 0;
v280 = v4;
v10 = v7 - 1;
v264 = v2;
if ( v4 )
{
LABEL_5:
v11 = v8;
v12 = v9;
v240 = v7;
v13 = v8 - 1;
v266 = v8;
v260 = 0;
v14 = v8 - 1;
v270 = v9;
if ( v9 )
{
LABEL_6:
v15 = v12;
v16 = v13;
v252 = v13;
v232 = 0;
v17 = v12 - 1;
v208 = v11;
v18 = v12 - 1;
v244 = v12;
if ( v16 )
{
LABEL_7:
v216 = v16;
v19 = v15;
v20 = v16;
v21 = 0;
for ( i = v17; ; i = v24 - 1 )
{
v23 = v20;
v24 = v20 - 1;
v20 = v19;
v25 = func0(i, v23);
v21 += func0(i, v24) + v25;
if ( !v24 )
break;
v19 = v24;
}
v26 = v216;
if ( v17 )
{
v217 = v21 + 1;
v27 = v17;
v28 = 0;
while ( 1 )
{
v29 = v26;
v30 = v26 - 1;
v26 = v27;
v31 = func0(v27 - 1, v29);
v28 += func0(v27 - 1, v30) + v31;
if ( !v30 )
break;
v27 = v30;
}
v18 = v17;
v232 += v28 + v217 + 1;
goto LABEL_15;
}
v32 = v244;
v34 = v252;
v33 = v21 + v232 + 2;
}
else
{
while ( 1 )
{
v232 += 2;
if ( !v17 )
break;
LABEL_15:
v15 = v208;
v16 = v18 - 1;
v208 = v18;
v17 = v15 - 1;
v18 = v15 - 1;
if ( v16 )
goto LABEL_7;
}
v32 = v244;
v33 = v232;
v34 = v252;
}
if ( v34 )
{
v35 = v32;
v245 = v33 + 1;
v36 = v32 - 1;
v209 = v34;
v233 = 0;
v37 = v32 - 1;
v253 = v34;
v38 = v34 - 1;
if ( v34 == 1 )
goto LABEL_29;
LABEL_20:
v39 = v38;
v218 = v38;
v40 = v35;
v41 = 0;
for ( j = v36; ; j = v44 - 1 )
{
v43 = v39;
v44 = v39 - 1;
v39 = v40;
v45 = func0(j, v43);
v41 += func0(j, v44) + v45;
if ( !v44 )
break;
v40 = v44;
}
v46 = v218;
if ( v36 )
{
v219 = v41 + 1;
v47 = v36;
v48 = 0;
while ( 1 )
{
v49 = v46;
v50 = v46 - 1;
v46 = v47;
v51 = func0(v47 - 1, v49);
v48 += func0(v47 - 1, v50) + v51;
if ( !v50 )
break;
v47 = v50;
}
v37 = v36;
v233 += v48 + v219 + 1;
do
{
v35 = v209;
v52 = v37;
v209 = v37;
v36 = v35 - 1;
v37 = v35 - 1;
v38 = v52 - 1;
if ( v38 )
goto LABEL_20;
LABEL_29:
v233 += 2;
}
while ( v36 );
v53 = v245;
v54 = v233;
v14 = v253;
}
else
{
v53 = v245;
v14 = v253;
v54 = v41 + v233 + 2;
}
v260 += v53 + v54 + 1;
goto LABEL_32;
}
v55 = v266;
v57 = v270;
v56 = v260 + v33 + 2;
}
else
{
while ( 1 )
{
v260 += 2;
if ( !v13 )
break;
LABEL_32:
v11 = v240;
v12 = v14 - 1;
v240 = v14;
v13 = v11 - 1;
v14 = v11 - 1;
if ( v12 )
goto LABEL_6;
}
v55 = v266;
v56 = v260;
v57 = v270;
}
if ( v57 )
{
v58 = v55 - 1;
v267 = v56 + 1;
v241 = v57;
v59 = v55 - 1;
v261 = 0;
v271 = v57;
v60 = v57 - 1;
if ( v57 == 1 )
goto LABEL_64;
LABEL_37:
v61 = v60;
v254 = v58;
v62 = v60 - 1;
v210 = v55;
v246 = v60;
v63 = v60 - 1;
v234 = 0;
if ( !v59 )
goto LABEL_47;
LABEL_38:
v220 = v59;
v64 = v61;
v65 = v59;
v66 = 0;
for ( k = v62; ; k = v69 - 1 )
{
v68 = v65;
v69 = v65 - 1;
v65 = v64;
v70 = func0(k, v68);
v66 += func0(k, v69) + v70;
if ( !v69 )
break;
v64 = v69;
}
v71 = v220;
if ( v62 )
{
v221 = v66 + 1;
v72 = v62;
v73 = 0;
while ( 1 )
{
v74 = v71;
v75 = v71 - 1;
v71 = v72;
v76 = func0(v72 - 1, v74);
v73 += func0(v72 - 1, v75) + v76;
if ( !v75 )
break;
v72 = v75;
}
v63 = v62;
v234 += v73 + v221 + 1;
do
{
v61 = v210;
v59 = v63 - 1;
v210 = v63;
v62 = v61 - 1;
v63 = v61 - 1;
if ( v59 )
goto LABEL_38;
LABEL_47:
v234 += 2;
}
while ( v62 );
v77 = v246;
v78 = v234;
v79 = v254;
}
else
{
v77 = v246;
v79 = v254;
v78 = v66 + v234 + 2;
}
if ( v79 )
{
v80 = v77;
v247 = v78 + 1;
v81 = v77 - 1;
v211 = v79;
v235 = 0;
v82 = v77 - 1;
v255 = v79;
v83 = v79 - 1;
if ( v79 == 1 )
goto LABEL_60;
LABEL_51:
v84 = v83;
v222 = v83;
v85 = v80;
v86 = 0;
for ( m = v81; ; m = v89 - 1 )
{
v88 = v84;
v89 = v84 - 1;
v84 = v85;
v90 = func0(m, v88);
v86 += func0(m, v89) + v90;
if ( !v89 )
break;
v85 = v89;
}
v91 = v222;
if ( v81 )
{
v223 = v86 + 1;
v92 = v81;
v93 = 0;
while ( 1 )
{
v94 = v91;
v95 = v91 - 1;
v91 = v92;
v96 = func0(v92 - 1, v94);
v93 += func0(v92 - 1, v95) + v96;
if ( !v95 )
break;
v92 = v95;
}
v82 = v81;
v235 += v93 + v223 + 1;
do
{
v80 = v211;
v97 = v82;
v211 = v82;
v81 = v80 - 1;
v82 = v80 - 1;
v83 = v97 - 1;
if ( v83 )
goto LABEL_51;
LABEL_60:
v235 += 2;
}
while ( v81 );
v98 = v247;
v99 = v235;
v59 = v255;
}
else
{
v98 = v247;
v59 = v255;
v99 = v86 + v235 + 2;
}
v261 += v98 + v99 + 1;
do
{
v55 = v241;
v100 = v59;
v241 = v59;
v58 = v55 - 1;
v59 = v55 - 1;
v60 = v100 - 1;
if ( v60 )
goto LABEL_37;
LABEL_64:
v261 += 2;
}
while ( v58 );
v101 = v267;
v102 = v261;
v10 = v271;
}
else
{
v101 = v267;
v10 = v271;
v102 = v261 + v78 + 2;
}
v274 += v101 + v102 + 1;
goto LABEL_67;
}
v103 = v278;
v105 = v280;
v104 = v274 + v56 + 2;
}
else
{
while ( 1 )
{
v274 += 2;
if ( !v9 )
break;
LABEL_67:
v7 = v264;
v264 = v10;
v8 = v10 - 1;
v9 = v7 - 1;
v10 = v7 - 1;
if ( v8 )
goto LABEL_5;
}
v103 = v278;
v104 = v274;
v105 = v280;
}
if ( !v105 )
break;
v106 = v103;
v265 = v105;
v107 = v103 - 1;
v279 = v104 + 1;
v275 = 0;
v108 = v103 - 1;
v281 = v105;
v109 = v105 - 1;
if ( v105 == 1 )
{
while ( 1 )
{
v275 += 2;
if ( !v107 )
break;
LABEL_134:
v106 = v265;
v203 = v108;
v265 = v108;
v107 = v106 - 1;
v108 = v106 - 1;
v109 = v203 - 1;
if ( v109 )
goto LABEL_72;
}
v204 = v279;
v205 = v275;
v5 = v281;
}
else
{
LABEL_72:
v110 = v109;
v242 = v106;
v111 = v109 - 1;
v268 = v109;
v262 = 0;
v112 = v109 - 1;
v272 = v107;
if ( v108 )
{
LABEL_73:
v113 = v108;
v114 = v111;
v256 = v111;
v236 = 0;
v115 = v108 - 1;
v212 = v110;
v116 = v108 - 1;
v248 = v108;
if ( v114 )
{
LABEL_74:
v224 = v114;
v117 = v113;
v118 = v114;
v119 = 0;
for ( n = v115; ; n = v122 - 1 )
{
v121 = v118;
v122 = v118 - 1;
v118 = v117;
v123 = func0(n, v121);
v119 += func0(n, v122) + v123;
if ( !v122 )
break;
v117 = v122;
}
v124 = v224;
if ( v115 )
{
v225 = v119 + 1;
v125 = v115;
v126 = 0;
while ( 1 )
{
v127 = v124;
v128 = v124 - 1;
v124 = v125;
v129 = func0(v125 - 1, v127);
v126 += func0(v125 - 1, v128) + v129;
if ( !v128 )
break;
v125 = v128;
}
v116 = v115;
v236 += v126 + v225 + 1;
goto LABEL_82;
}
v130 = v248;
v132 = v256;
v131 = v119 + v236 + 2;
}
else
{
while ( 1 )
{
v236 += 2;
if ( !v115 )
break;
LABEL_82:
v113 = v212;
v114 = v116 - 1;
v212 = v116;
v115 = v113 - 1;
v116 = v113 - 1;
if ( v114 )
goto LABEL_74;
}
v130 = v248;
v131 = v236;
v132 = v256;
}
if ( v132 )
{
v133 = v130;
v249 = v131 + 1;
v134 = v130 - 1;
v213 = v132;
v237 = 0;
v135 = v130 - 1;
v257 = v132;
v136 = v132 - 1;
if ( v132 == 1 )
goto LABEL_96;
LABEL_87:
v137 = v136;
v226 = v136;
v138 = v133;
v139 = 0;
for ( ii = v134; ; ii = v142 - 1 )
{
v141 = v137;
v142 = v137 - 1;
v137 = v138;
v143 = func0(ii, v141);
v139 += func0(ii, v142) + v143;
if ( !v142 )
break;
v138 = v142;
}
v144 = v226;
if ( v134 )
{
v227 = v139 + 1;
v145 = v134;
v146 = 0;
while ( 1 )
{
v147 = v144;
v148 = v144 - 1;
v144 = v145;
v149 = func0(v145 - 1, v147);
v146 += func0(v145 - 1, v148) + v149;
if ( !v148 )
break;
v145 = v148;
}
v135 = v134;
v237 += v146 + v227 + 1;
do
{
v133 = v213;
v150 = v135;
v213 = v135;
v134 = v133 - 1;
v135 = v133 - 1;
v136 = v150 - 1;
if ( v136 )
goto LABEL_87;
LABEL_96:
v237 += 2;
}
while ( v134 );
v151 = v249;
v152 = v237;
v112 = v257;
}
else
{
v151 = v249;
v112 = v257;
v152 = v139 + v237 + 2;
}
v262 += v151 + v152 + 1;
goto LABEL_99;
}
v153 = v268;
v155 = v272;
v154 = v262 + v131 + 2;
}
else
{
while ( 1 )
{
v262 += 2;
if ( !v111 )
break;
LABEL_99:
v110 = v242;
v108 = v112 - 1;
v242 = v112;
v111 = v110 - 1;
v112 = v110 - 1;
if ( v108 )
goto LABEL_73;
}
v153 = v268;
v154 = v262;
v155 = v272;
}
if ( v155 )
{
v156 = v155;
v157 = v153 - 1;
v243 = v155;
v273 = v155;
v158 = v153 - 1;
v269 = v154 + 1;
v263 = 0;
v159 = v156 - 1;
if ( !v159 )
goto LABEL_131;
LABEL_104:
v160 = v159;
v258 = v157;
v238 = 0;
v161 = v159 - 1;
v162 = v157;
v214 = v153;
v163 = v159 - 1;
v250 = v159;
if ( !v162 )
goto LABEL_114;
LABEL_105:
v228 = v162;
v164 = v160;
v165 = v162;
v166 = 0;
for ( jj = v161; ; jj = v169 - 1 )
{
v168 = v165;
v169 = v165 - 1;
v165 = v164;
v170 = func0(jj, v168);
v166 += func0(jj, v169) + v170;
if ( !v169 )
break;
v164 = v169;
}
v171 = v228;
if ( v161 )
{
v229 = v166 + 1;
v172 = v161;
v173 = 0;
while ( 1 )
{
v174 = v171;
v175 = v171 - 1;
v171 = v172;
v176 = func0(v172 - 1, v174);
v173 += func0(v172 - 1, v175) + v176;
if ( !v175 )
break;
v172 = v175;
}
v163 = v161;
v238 += v173 + v229 + 1;
do
{
v160 = v214;
v162 = v163 - 1;
v214 = v163;
v161 = v160 - 1;
v163 = v160 - 1;
if ( v162 )
goto LABEL_105;
LABEL_114:
v238 += 2;
}
while ( v161 );
v177 = v250;
v178 = v238;
v179 = v258;
}
else
{
v177 = v250;
v179 = v258;
v178 = v166 + v238 + 2;
}
if ( v179 )
{
v180 = v177;
v251 = v178 + 1;
v181 = v177 - 1;
v215 = v179;
v239 = 0;
v182 = v177 - 1;
v259 = v179;
v183 = v179 - 1;
if ( v179 == 1 )
goto LABEL_127;
LABEL_118:
v184 = v183;
v230 = v183;
v185 = v180;
v186 = 0;
for ( kk = v181; ; kk = v189 - 1 )
{
v188 = v184;
v189 = v184 - 1;
v184 = v185;
v190 = func0(kk, v188);
v186 += func0(kk, v189) + v190;
if ( !v189 )
break;
v185 = v189;
}
v191 = v230;
if ( v181 )
{
v231 = v186 + 1;
v192 = v181;
v193 = 0;
while ( 1 )
{
v194 = v191;
v195 = v191 - 1;
v191 = v192;
v196 = func0(v192 - 1, v194);
v193 += func0(v192 - 1, v195) + v196;
if ( !v195 )
break;
v192 = v195;
}
v182 = v181;
v239 += v193 + v231 + 1;
do
{
v180 = v215;
v197 = v182;
v215 = v182;
v181 = v180 - 1;
v182 = v180 - 1;
v183 = v197 - 1;
if ( v183 )
goto LABEL_118;
LABEL_127:
v239 += 2;
}
while ( v181 );
v198 = v251;
v199 = v239;
v158 = v259;
}
else
{
v198 = v251;
v158 = v259;
v199 = v186 + v239 + 2;
}
v263 += v198 + v199 + 1;
do
{
v153 = v243;
v200 = v158;
v243 = v158;
v157 = v153 - 1;
v158 = v153 - 1;
v159 = v200 - 1;
if ( v159 )
goto LABEL_104;
LABEL_131:
v263 += 2;
}
while ( v157 );
v201 = v269;
v202 = v263;
v108 = v273;
}
else
{
v201 = v269;
v108 = v273;
v202 = v263 + v178 + 2;
}
v275 += v201 + v202 + 1;
goto LABEL_134;
}
v204 = v279;
v5 = v281;
v205 = v275 + v154 + 2;
}
v277 += v204 + v205 + 1;
while ( 1 )
{
v2 = v276;
v206 = v5;
v276 = v5;
v4 = v2 - 1;
v5 = v2 - 1;
v6 = v206 - 1;
if ( v6 )
break;
LABEL_139:
v277 += 2;
if ( !v4 )
{
v207 = v277;
return (unsigned int)(v207 + 1);
}
}
}
v207 = v277 + v104 + 2;
return (unsigned int)(v207 + 1);
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JZ 0x00101d9f
PUSH R15
MOV ECX,EDI
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x48
TEST EDI,EDI
JZ 0x00101d90
LEA EAX,[RCX + -0x1]
MOV R9D,ESI
MOV dword ptr [RSP + 0x34],R12D
MOV dword ptr [RSP + 0x30],ESI
MOV R14D,EAX
SUB R9D,0x1
JZ 0x00101d7d
LAB_00101248:
MOV ESI,R9D
MOV EBP,EAX
MOV dword ptr [RSP + 0x38],R9D
XOR R15D,R15D
MOV R9D,EBP
LEA R14D,[RSI + -0x1]
MOV dword ptr [RSP + 0x2c],R15D
MOV dword ptr [RSP + 0x3c],EAX
MOV EBP,R14D
MOV dword ptr [RSP + 0x20],ECX
TEST R9D,R9D
JZ 0x001017b4
LAB_00101275:
MOV R8D,R9D
XOR R13D,R13D
MOV EDX,R14D
MOV dword ptr [RSP + 0x10],ESI
LEA EAX,[R8 + -0x1]
MOV dword ptr [RSP + 0x24],R9D
MOV dword ptr [RSP + 0x1c],R13D
MOV R15D,EAX
MOV dword ptr [RSP + 0x28],R14D
TEST EDX,EDX
JZ 0x001014f4
LAB_001012a0:
XOR EDI,EDI
MOV R12D,EDX
MOV ESI,EAX
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0xc],EDI
LEA EDI,[R12 + -0x1]
MOV dword ptr [RSP],R8D
MOV EAX,EDI
MOV dword ptr [RSP + 0x14],EDX
TEST ESI,ESI
JZ 0x00101395
LAB_001012c6:
MOV dword ptr [RSP + 0x4],ESI
XOR R13D,R13D
MOV R14D,R12D
MOV EBP,ESI
MOV dword ptr [RSP + 0x8],EDI
MOV R12D,R13D
MOV R13D,EDI
LAB_001012dc:
MOV ESI,EBP
MOV EDI,R13D
LEA R15D,[RBP + -0x1]
MOV EBP,R14D
CALL 0x00101200
MOV ESI,R15D
MOV EDI,R13D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD R12D,EBX
TEST R15D,R15D
JZ 0x00101310
MOV R14D,R15D
LEA R13D,[R15 + -0x1]
JMP 0x001012dc
LAB_00101310:
MOV EAX,dword ptr [RSP + 0x8]
MOV R14D,dword ptr [RSP + 0x4]
LEA EBX,[R12 + 0x1]
TEST EAX,EAX
JZ 0x00101ee2
MOV dword ptr [RSP + 0x4],EBX
MOV R13D,EAX
MOV EBX,R15D
LAB_00101330:
LEA R15D,[R13 + -0x1]
MOV ESI,R14D
LEA R12D,[R14 + -0x1]
MOV R14D,R13D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R15D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101368
MOV R13D,R12D
JMP 0x00101330
LAB_00101368:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R15 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_0010137c:
MOV R12D,dword ptr [RSP]
LEA ESI,[RAX + -0x1]
MOV dword ptr [RSP],EAX
LEA EDI,[R12 + -0x1]
MOV EAX,EDI
TEST ESI,ESI
JNZ 0x001012c6
LAB_00101395:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x0010137c
MOV R9D,dword ptr [RSP + 0x14]
MOV EDI,dword ptr [RSP + 0xc]
MOV R15D,dword ptr [RSP + 0x18]
LAB_001013ac:
LEA R14D,[RDI + 0x1]
TEST R15D,R15D
JZ 0x00101eca
MOV R12D,R9D
MOV dword ptr [RSP + 0x14],R14D
XOR ESI,ESI
MOV R14D,R15D
LEA EDI,[R12 + -0x1]
MOV dword ptr [RSP],R15D
MOV dword ptr [RSP + 0xc],ESI
MOV EAX,EDI
MOV dword ptr [RSP + 0x18],R15D
SUB R14D,0x1
JZ 0x001014b7
LAB_001013e4:
MOV dword ptr [RSP + 0x8],EDI
XOR R13D,R13D
MOV EBP,R14D
MOV dword ptr [RSP + 0x4],R14D
MOV R14D,R12D
MOV R12D,R13D
MOV R13D,EDI
LAB_001013fc:
MOV ESI,EBP
MOV EDI,R13D
LEA R15D,[RBP + -0x1]
MOV EBP,R14D
CALL 0x00101200
MOV ESI,R15D
MOV EDI,R13D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD R12D,EBX
TEST R15D,R15D
JZ 0x00101430
MOV R14D,R15D
LEA R13D,[R15 + -0x1]
JMP 0x001013fc
LAB_00101430:
MOV EAX,dword ptr [RSP + 0x8]
MOV R14D,dword ptr [RSP + 0x4]
LEA EBX,[R12 + 0x1]
TEST EAX,EAX
JZ 0x00101eb2
MOV dword ptr [RSP + 0x4],EBX
MOV R13D,EAX
MOV EBX,R15D
LAB_00101450:
LEA R15D,[R13 + -0x1]
MOV ESI,R14D
LEA R12D,[R14 + -0x1]
MOV R14D,R13D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R15D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101488
MOV R13D,R12D
JMP 0x00101450
LAB_00101488:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R15 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_0010149c:
MOV R12D,dword ptr [RSP]
MOV R14D,EAX
MOV dword ptr [RSP],EAX
LEA EDI,[R12 + -0x1]
MOV EAX,EDI
SUB R14D,0x1
JNZ 0x001013e4
LAB_001014b7:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x0010149c
MOV R14D,dword ptr [RSP + 0x14]
MOV ESI,dword ptr [RSP + 0xc]
MOV R15D,dword ptr [RSP + 0x18]
LAB_001014ce:
LEA EAX,[R14 + RSI*0x1 + 0x1]
ADD dword ptr [RSP + 0x1c],EAX
LAB_001014d7:
MOV R8D,dword ptr [RSP + 0x10]
LEA EDX,[R15 + -0x1]
MOV dword ptr [RSP + 0x10],R15D
LEA EAX,[R8 + -0x1]
MOV R15D,EAX
TEST EDX,EDX
JNZ 0x001012a0
LAB_001014f4:
ADD dword ptr [RSP + 0x1c],0x2
TEST EAX,EAX
JNZ 0x001014d7
MOV R9D,dword ptr [RSP + 0x24]
MOV R13D,dword ptr [RSP + 0x1c]
MOV EBP,dword ptr [RSP + 0x28]
LAB_0010150b:
LEA EBX,[R13 + 0x1]
TEST EBP,EBP
JZ 0x00101e99
XOR R13D,R13D
LEA EAX,[R9 + -0x1]
MOV R10D,EBP
MOV dword ptr [RSP + 0x24],EBX
MOV dword ptr [RSP + 0x10],EBP
MOV ECX,EAX
MOV dword ptr [RSP + 0x1c],R13D
MOV dword ptr [RSP + 0x28],EBP
SUB R10D,0x1
JZ 0x00101777
LAB_0010153e:
MOV EBP,R10D
XOR EDX,EDX
MOV dword ptr [RSP + 0x18],EAX
LEA EDI,[RBP + -0x1]
MOV dword ptr [RSP],R9D
MOV dword ptr [RSP + 0x14],R10D
MOV EAX,EDI
MOV dword ptr [RSP + 0xc],EDX
TEST ECX,ECX
JZ 0x0010162a
LAB_00101561:
MOV dword ptr [RSP + 0x4],ECX
XOR R12D,R12D
MOV R15D,EBP
MOV R14D,ECX
MOV dword ptr [RSP + 0x8],EDI
MOV EBP,R12D
MOV R12D,EDI
LAB_00101578:
MOV ESI,R14D
MOV EDI,R12D
LEA R13D,[R14 + -0x1]
MOV R14D,R15D
CALL 0x00101200
MOV ESI,R13D
MOV EDI,R12D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD EBP,EBX
TEST R13D,R13D
JZ 0x001015b0
MOV R15D,R13D
LEA R12D,[R13 + -0x1]
JMP 0x00101578
LAB_001015b0:
MOV EAX,dword ptr [RSP + 0x8]
MOV R15D,dword ptr [RSP + 0x4]
LEA EBX,[RBP + 0x1]
TEST EAX,EAX
JZ 0x00101e83
MOV dword ptr [RSP + 0x4],EBX
MOV R14D,EAX
MOV EBX,R13D
LAB_001015ce:
LEA R13D,[R14 + -0x1]
MOV ESI,R15D
LEA R12D,[R15 + -0x1]
MOV R15D,R14D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101600
MOV R14D,R12D
JMP 0x001015ce
LAB_00101600:
MOV R13D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R13 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_00101614:
MOV EBP,dword ptr [RSP]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSP],EAX
LEA EDI,[RBP + -0x1]
MOV EAX,EDI
TEST ECX,ECX
JNZ 0x00101561
LAB_0010162a:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x00101614
MOV R10D,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x18]
LAB_00101640:
LEA R14D,[RDX + 0x1]
TEST ECX,ECX
JZ 0x00101e6c
MOV EBP,R10D
MOV dword ptr [RSP + 0x14],R14D
XOR ESI,ESI
MOV R14D,ECX
LEA EDI,[RBP + -0x1]
MOV dword ptr [RSP],ECX
MOV dword ptr [RSP + 0xc],ESI
MOV EAX,EDI
MOV dword ptr [RSP + 0x18],ECX
SUB R14D,0x1
JZ 0x0010173c
LAB_00101673:
MOV dword ptr [RSP + 0x8],EDI
XOR R12D,R12D
MOV R15D,R14D
MOV dword ptr [RSP + 0x4],R14D
MOV R14D,EBP
MOV EBP,R12D
MOV R12D,EDI
LAB_0010168b:
MOV ESI,R15D
MOV EDI,R12D
LEA R13D,[R15 + -0x1]
MOV R15D,R14D
CALL 0x00101200
MOV ESI,R13D
MOV EDI,R12D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD EBP,EBX
TEST R13D,R13D
JZ 0x001016c0
MOV R14D,R13D
LEA R12D,[R13 + -0x1]
JMP 0x0010168b
LAB_001016c0:
MOV EAX,dword ptr [RSP + 0x8]
MOV R14D,dword ptr [RSP + 0x4]
LEA EBX,[RBP + 0x1]
TEST EAX,EAX
JZ 0x00101e56
MOV dword ptr [RSP + 0x4],EBX
MOV R15D,EAX
MOV EBX,R13D
LAB_001016de:
LEA R13D,[R15 + -0x1]
MOV ESI,R14D
LEA R12D,[R14 + -0x1]
MOV R14D,R15D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101710
MOV R15D,R12D
JMP 0x001016de
LAB_00101710:
MOV R13D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R13 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_00101724:
MOV EBP,dword ptr [RSP]
MOV R14D,EAX
MOV dword ptr [RSP],EAX
LEA EDI,[RBP + -0x1]
MOV EAX,EDI
SUB R14D,0x1
JNZ 0x00101673
LAB_0010173c:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x00101724
MOV R14D,dword ptr [RSP + 0x14]
MOV ESI,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x18]
LAB_00101752:
LEA EAX,[R14 + RSI*0x1 + 0x1]
ADD dword ptr [RSP + 0x1c],EAX
LAB_0010175b:
MOV R9D,dword ptr [RSP + 0x10]
MOV R10D,ECX
MOV dword ptr [RSP + 0x10],ECX
LEA EAX,[R9 + -0x1]
MOV ECX,EAX
SUB R10D,0x1
JNZ 0x0010153e
LAB_00101777:
ADD dword ptr [RSP + 0x1c],0x2
TEST EAX,EAX
JNZ 0x0010175b
MOV EBX,dword ptr [RSP + 0x24]
MOV R13D,dword ptr [RSP + 0x1c]
MOV EBP,dword ptr [RSP + 0x28]
LAB_0010178d:
LEA EAX,[RBX + R13*0x1 + 0x1]
ADD dword ptr [RSP + 0x2c],EAX
LAB_00101796:
MOV ESI,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x20],EBP
LEA EBP,[RBP + -0x1]
MOV R9D,EBP
LEA R14D,[RSI + -0x1]
MOV EBP,R14D
TEST R9D,R9D
JNZ 0x00101275
LAB_001017b4:
ADD dword ptr [RSP + 0x2c],0x2
TEST R14D,R14D
JNZ 0x00101796
MOV R9D,dword ptr [RSP + 0x38]
MOV R15D,dword ptr [RSP + 0x2c]
MOV R14D,dword ptr [RSP + 0x3c]
LAB_001017cd:
LEA EBX,[R15 + 0x1]
TEST R14D,R14D
JZ 0x00101e47
MOV ESI,R9D
XOR ECX,ECX
MOV R9D,R14D
MOV dword ptr [RSP + 0x20],R14D
LEA R13D,[RSI + -0x1]
MOV dword ptr [RSP + 0x38],EBX
MOV dword ptr [RSP + 0x2c],ECX
MOV EDX,R13D
MOV dword ptr [RSP + 0x3c],R14D
SUB R9D,0x1
JZ 0x00101d42
LAB_00101805:
MOV R8D,R9D
XOR R12D,R12D
MOV dword ptr [RSP + 0x10],ESI
LEA EAX,[R8 + -0x1]
MOV dword ptr [RSP + 0x24],R9D
MOV dword ptr [RSP + 0x1c],R12D
MOV R15D,EAX
MOV dword ptr [RSP + 0x28],R13D
TEST EDX,EDX
JZ 0x00101a84
LAB_0010182d:
XOR EDI,EDI
MOV R12D,EDX
MOV ESI,EAX
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0xc],EDI
LEA EDI,[R12 + -0x1]
MOV dword ptr [RSP],R8D
MOV EAX,EDI
MOV dword ptr [RSP + 0x14],EDX
TEST ESI,ESI
JZ 0x00101925
LAB_00101853:
MOV dword ptr [RSP + 0x4],ESI
XOR R14D,R14D
MOV R13D,R12D
MOV EBP,ESI
MOV dword ptr [RSP + 0x8],EDI
MOV R12D,R14D
MOV R14D,EDI
LAB_00101869:
MOV ESI,EBP
MOV EDI,R14D
LEA R15D,[RBP + -0x1]
MOV EBP,R13D
CALL 0x00101200
MOV ESI,R15D
MOV EDI,R14D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD R12D,EBX
TEST R15D,R15D
JZ 0x001018a0
MOV R13D,R15D
LEA R14D,[R15 + -0x1]
JMP 0x00101869
LAB_001018a0:
MOV EAX,dword ptr [RSP + 0x8]
MOV R13D,dword ptr [RSP + 0x4]
LEA EBX,[R12 + 0x1]
TEST EAX,EAX
JZ 0x00101e2f
MOV dword ptr [RSP + 0x4],EBX
MOV R14D,EAX
MOV EBX,R15D
LAB_001018c0:
LEA R15D,[R14 + -0x1]
MOV ESI,R13D
LEA R12D,[R13 + -0x1]
MOV R13D,R14D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R15D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x001018f8
MOV R14D,R12D
JMP 0x001018c0
LAB_001018f8:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R15 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_0010190c:
MOV R12D,dword ptr [RSP]
LEA ESI,[RAX + -0x1]
MOV dword ptr [RSP],EAX
LEA EDI,[R12 + -0x1]
MOV EAX,EDI
TEST ESI,ESI
JNZ 0x00101853
LAB_00101925:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x0010190c
MOV R9D,dword ptr [RSP + 0x14]
MOV EDI,dword ptr [RSP + 0xc]
MOV R15D,dword ptr [RSP + 0x18]
LAB_0010193c:
LEA R13D,[RDI + 0x1]
TEST R15D,R15D
JZ 0x00101e17
MOV R12D,R9D
MOV dword ptr [RSP + 0x14],R13D
XOR ESI,ESI
MOV R13D,R15D
LEA EDI,[R12 + -0x1]
MOV dword ptr [RSP],R15D
MOV dword ptr [RSP + 0xc],ESI
MOV EAX,EDI
MOV dword ptr [RSP + 0x18],R15D
SUB R13D,0x1
JZ 0x00101a47
LAB_00101974:
MOV dword ptr [RSP + 0x8],EDI
XOR R14D,R14D
MOV EBP,R13D
MOV dword ptr [RSP + 0x4],R13D
MOV R13D,R12D
MOV R12D,R14D
MOV R14D,EDI
LAB_0010198c:
MOV ESI,EBP
MOV EDI,R14D
LEA R15D,[RBP + -0x1]
MOV EBP,R13D
CALL 0x00101200
MOV ESI,R15D
MOV EDI,R14D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD R12D,EBX
TEST R15D,R15D
JZ 0x001019c0
MOV R13D,R15D
LEA R14D,[R15 + -0x1]
JMP 0x0010198c
LAB_001019c0:
MOV EAX,dword ptr [RSP + 0x8]
MOV R13D,dword ptr [RSP + 0x4]
LEA EBX,[R12 + 0x1]
TEST EAX,EAX
JZ 0x00101dff
MOV dword ptr [RSP + 0x4],EBX
MOV R14D,EAX
MOV EBX,R15D
LAB_001019e0:
LEA R15D,[R14 + -0x1]
MOV ESI,R13D
LEA R12D,[R13 + -0x1]
MOV R13D,R14D
MOV EDI,R15D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R15D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101a18
MOV R14D,R12D
JMP 0x001019e0
LAB_00101a18:
MOV R15D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R15 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_00101a2c:
MOV R12D,dword ptr [RSP]
MOV R13D,EAX
MOV dword ptr [RSP],EAX
LEA EDI,[R12 + -0x1]
MOV EAX,EDI
SUB R13D,0x1
JNZ 0x00101974
LAB_00101a47:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x00101a2c
MOV R13D,dword ptr [RSP + 0x14]
MOV ESI,dword ptr [RSP + 0xc]
MOV R15D,dword ptr [RSP + 0x18]
LAB_00101a5e:
LEA EAX,[R13 + RSI*0x1 + 0x1]
ADD dword ptr [RSP + 0x1c],EAX
LAB_00101a67:
MOV R8D,dword ptr [RSP + 0x10]
LEA EDX,[R15 + -0x1]
MOV dword ptr [RSP + 0x10],R15D
LEA EAX,[R8 + -0x1]
MOV R15D,EAX
TEST EDX,EDX
JNZ 0x0010182d
LAB_00101a84:
ADD dword ptr [RSP + 0x1c],0x2
TEST EAX,EAX
JNZ 0x00101a67
MOV R9D,dword ptr [RSP + 0x24]
MOV R12D,dword ptr [RSP + 0x1c]
MOV EDX,dword ptr [RSP + 0x28]
LAB_00101a9b:
LEA EBP,[R12 + 0x1]
TEST EDX,EDX
JZ 0x00101de8
XOR R13D,R13D
MOV R8D,EDX
LEA EAX,[R9 + -0x1]
MOV dword ptr [RSP + 0x10],EDX
MOV dword ptr [RSP + 0x28],EDX
MOV EDX,EAX
MOV dword ptr [RSP + 0x24],EBP
MOV dword ptr [RSP + 0x1c],R13D
SUB R8D,0x1
JZ 0x00101d07
LAB_00101acf:
XOR ESI,ESI
MOV EBP,R8D
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0xc],ESI
LEA EDI,[RBP + -0x1]
MOV ESI,EAX
MOV dword ptr [RSP],R9D
MOV EAX,EDI
MOV dword ptr [RSP + 0x14],R8D
TEST ESI,ESI
JZ 0x00101bba
LAB_00101af4:
MOV dword ptr [RSP + 0x4],ESI
XOR R12D,R12D
MOV R15D,EBP
MOV R14D,ESI
MOV dword ptr [RSP + 0x8],EDI
MOV EBP,R12D
MOV R12D,EDI
LAB_00101b0b:
MOV ESI,R14D
MOV EDI,R12D
LEA R13D,[R14 + -0x1]
MOV R14D,R15D
CALL 0x00101200
MOV ESI,R13D
MOV EDI,R12D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD EBP,EBX
TEST R13D,R13D
JZ 0x00101b40
MOV R15D,R13D
LEA R12D,[R13 + -0x1]
JMP 0x00101b0b
LAB_00101b40:
MOV EAX,dword ptr [RSP + 0x8]
MOV R15D,dword ptr [RSP + 0x4]
LEA EBX,[RBP + 0x1]
TEST EAX,EAX
JZ 0x00101dd2
MOV dword ptr [RSP + 0x4],EBX
MOV R14D,EAX
MOV EBX,R13D
LAB_00101b5e:
LEA R13D,[R14 + -0x1]
MOV ESI,R15D
LEA R12D,[R15 + -0x1]
MOV R15D,R14D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101b90
MOV R14D,R12D
JMP 0x00101b5e
LAB_00101b90:
MOV R13D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R13 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_00101ba4:
MOV EBP,dword ptr [RSP]
LEA ESI,[RAX + -0x1]
MOV dword ptr [RSP],EAX
LEA EDI,[RBP + -0x1]
MOV EAX,EDI
TEST ESI,ESI
JNZ 0x00101af4
LAB_00101bba:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x00101ba4
MOV R8D,dword ptr [RSP + 0x14]
MOV ESI,dword ptr [RSP + 0xc]
MOV EDX,dword ptr [RSP + 0x18]
LAB_00101bd0:
LEA R14D,[RSI + 0x1]
TEST EDX,EDX
JZ 0x00101dbb
MOV EBP,R8D
MOV dword ptr [RSP + 0x14],R14D
XOR ESI,ESI
MOV R14D,EDX
LEA EDI,[RBP + -0x1]
MOV dword ptr [RSP],EDX
MOV dword ptr [RSP + 0xc],ESI
MOV EAX,EDI
MOV dword ptr [RSP + 0x18],EDX
SUB R14D,0x1
JZ 0x00101ccc
LAB_00101c03:
MOV dword ptr [RSP + 0x8],EDI
XOR R12D,R12D
MOV R15D,R14D
MOV dword ptr [RSP + 0x4],R14D
MOV R14D,EBP
MOV EBP,R12D
MOV R12D,EDI
LAB_00101c1b:
MOV ESI,R15D
MOV EDI,R12D
LEA R13D,[R15 + -0x1]
MOV R15D,R14D
CALL 0x00101200
MOV ESI,R13D
MOV EDI,R12D
MOV EBX,EAX
CALL 0x00101200
ADD EBX,EAX
ADD EBP,EBX
TEST R13D,R13D
JZ 0x00101c50
MOV R14D,R13D
LEA R12D,[R13 + -0x1]
JMP 0x00101c1b
LAB_00101c50:
MOV EAX,dword ptr [RSP + 0x8]
MOV R14D,dword ptr [RSP + 0x4]
LEA EBX,[RBP + 0x1]
TEST EAX,EAX
JZ 0x00101da5
MOV dword ptr [RSP + 0x4],EBX
MOV R15D,EAX
MOV EBX,R13D
LAB_00101c6e:
LEA R13D,[R15 + -0x1]
MOV ESI,R14D
LEA R12D,[R14 + -0x1]
MOV R14D,R15D
MOV EDI,R13D
CALL 0x00101200
MOV ESI,R12D
MOV EDI,R13D
MOV EBP,EAX
CALL 0x00101200
ADD EBP,EAX
ADD EBX,EBP
TEST R12D,R12D
JZ 0x00101ca0
MOV R15D,R12D
JMP 0x00101c6e
LAB_00101ca0:
MOV R13D,EBX
MOV EBX,dword ptr [RSP + 0x4]
MOV EAX,dword ptr [RSP + 0x8]
LEA EDX,[R13 + RBX*0x1 + 0x1]
ADD dword ptr [RSP + 0xc],EDX
LAB_00101cb4:
MOV EBP,dword ptr [RSP]
MOV R14D,EAX
MOV dword ptr [RSP],EAX
LEA EDI,[RBP + -0x1]
MOV EAX,EDI
SUB R14D,0x1
JNZ 0x00101c03
LAB_00101ccc:
ADD dword ptr [RSP + 0xc],0x2
TEST EDI,EDI
JNZ 0x00101cb4
MOV R14D,dword ptr [RSP + 0x14]
MOV ESI,dword ptr [RSP + 0xc]
MOV EDX,dword ptr [RSP + 0x18]
LAB_00101ce2:
LEA EAX,[R14 + RSI*0x1 + 0x1]
ADD dword ptr [RSP + 0x1c],EAX
LAB_00101ceb:
MOV R9D,dword ptr [RSP + 0x10]
MOV R8D,EDX
MOV dword ptr [RSP + 0x10],EDX
LEA EAX,[R9 + -0x1]
MOV EDX,EAX
SUB R8D,0x1
JNZ 0x00101acf
LAB_00101d07:
ADD dword ptr [RSP + 0x1c],0x2
TEST EAX,EAX
JNZ 0x00101ceb
MOV EBP,dword ptr [RSP + 0x24]
MOV R13D,dword ptr [RSP + 0x1c]
MOV EDX,dword ptr [RSP + 0x28]
LAB_00101d1d:
LEA EAX,[RBP + R13*0x1 + 0x1]
ADD dword ptr [RSP + 0x2c],EAX
LAB_00101d26:
MOV ESI,dword ptr [RSP + 0x20]
MOV R9D,EDX
MOV dword ptr [RSP + 0x20],EDX
LEA R13D,[RSI + -0x1]
MOV EDX,R13D
SUB R9D,0x1
JNZ 0x00101805
LAB_00101d42:
ADD dword ptr [RSP + 0x2c],0x2
TEST R13D,R13D
JNZ 0x00101d26
MOV EBX,dword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x2c]
MOV R14D,dword ptr [RSP + 0x3c]
LAB_00101d59:
LEA EAX,[RBX + RCX*0x1 + 0x1]
ADD dword ptr [RSP + 0x34],EAX
LAB_00101d61:
MOV ECX,dword ptr [RSP + 0x30]
MOV R9D,R14D
MOV dword ptr [RSP + 0x30],R14D
LEA EAX,[RCX + -0x1]
MOV R14D,EAX
SUB R9D,0x1
JNZ 0x00101248
LAB_00101d7d:
ADD dword ptr [RSP + 0x34],0x2
TEST EAX,EAX
JNZ 0x00101d61
MOV R12D,dword ptr [RSP + 0x34]
LAB_00101d8b:
LEA EAX,[R12 + 0x1]
LAB_00101d90:
ADD RSP,0x48
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101d9f:
MOV EAX,0x1
RET
LAB_00101da5:
MOV ESI,dword ptr [RSP + 0xc]
MOV R14D,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0x18]
LEA ESI,[RBP + RSI*0x1 + 0x2]
JMP 0x00101ce2
LAB_00101dbb:
MOV R13D,dword ptr [RSP + 0x1c]
MOV EBP,dword ptr [RSP + 0x24]
MOV EDX,dword ptr [RSP + 0x28]
LEA R13D,[R13 + RSI*0x1 + 0x2]
JMP 0x00101d1d
LAB_00101dd2:
MOV ESI,dword ptr [RSP + 0xc]
MOV R8D,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RSP + 0x18]
LEA ESI,[RBP + RSI*0x1 + 0x2]
JMP 0x00101bd0
LAB_00101de8:
MOV ECX,dword ptr [RSP + 0x2c]
MOV EBX,dword ptr [RSP + 0x38]
MOV R14D,dword ptr [RSP + 0x3c]
LEA ECX,[RCX + R12*0x1 + 0x2]
JMP 0x00101d59
LAB_00101dff:
MOV ESI,dword ptr [RSP + 0xc]
MOV R13D,dword ptr [RSP + 0x14]
MOV R15D,dword ptr [RSP + 0x18]
LEA ESI,[R12 + RSI*0x1 + 0x2]
JMP 0x00101a5e
LAB_00101e17:
MOV R12D,dword ptr [RSP + 0x1c]
MOV R9D,dword ptr [RSP + 0x24]
MOV EDX,dword ptr [RSP + 0x28]
LEA R12D,[R12 + RDI*0x1 + 0x2]
JMP 0x00101a9b
LAB_00101e2f:
MOV EDI,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x14]
MOV R15D,dword ptr [RSP + 0x18]
LEA EDI,[R12 + RDI*0x1 + 0x2]
JMP 0x0010193c
LAB_00101e47:
MOV R12D,dword ptr [RSP + 0x34]
LEA R12D,[R12 + R15*0x1 + 0x2]
JMP 0x00101d8b
LAB_00101e56:
MOV ESI,dword ptr [RSP + 0xc]
MOV R14D,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x18]
LEA ESI,[RBP + RSI*0x1 + 0x2]
JMP 0x00101752
LAB_00101e6c:
MOV R13D,dword ptr [RSP + 0x1c]
MOV EBX,dword ptr [RSP + 0x24]
MOV EBP,dword ptr [RSP + 0x28]
LEA R13D,[R13 + RDX*0x1 + 0x2]
JMP 0x0010178d
LAB_00101e83:
MOV EDX,dword ptr [RSP + 0xc]
MOV R10D,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x18]
LEA EDX,[RBP + RDX*0x1 + 0x2]
JMP 0x00101640
LAB_00101e99:
MOV R15D,dword ptr [RSP + 0x2c]
MOV R9D,dword ptr [RSP + 0x38]
MOV R14D,dword ptr [RSP + 0x3c]
LEA R15D,[R15 + R13*0x1 + 0x2]
JMP 0x001017cd
LAB_00101eb2:
MOV ESI,dword ptr [RSP + 0xc]
MOV R14D,dword ptr [RSP + 0x14]
MOV R15D,dword ptr [RSP + 0x18]
LEA ESI,[R12 + RSI*0x1 + 0x2]
JMP 0x001014ce
LAB_00101eca:
MOV R13D,dword ptr [RSP + 0x1c]
MOV R9D,dword ptr [RSP + 0x24]
MOV EBP,dword ptr [RSP + 0x28]
LEA R13D,[R13 + RDI*0x1 + 0x2]
JMP 0x0010150b
LAB_00101ee2:
MOV EDI,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x14]
MOV R15D,dword ptr [RSP + 0x18]
LEA EDI,[R12 + RDI*0x1 + 0x2]
JMP 0x001013ac | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int local_78;
int local_6c;
int local_68;
int local_5c;
int local_58;
int local_4c;
int local_48;
int local_44;
if (param_2 == 0) {
return 1;
}
if (param_1 == 0) {
return 1;
}
iVar1 = param_1 + -1;
local_44 = 0;
iVar11 = param_2 + -1;
iVar9 = param_2;
if (iVar11 == 0) goto LAB_00101d7d;
do {
local_48 = iVar9;
iVar13 = iVar11 + -1;
local_4c = 0;
local_68 = iVar11;
iVar9 = iVar1;
local_58 = param_1;
if (iVar1 == 0) goto LAB_001017b4;
LAB_00101275:
iVar2 = iVar9 + -1;
local_5c = 0;
local_78 = iVar9;
iVar14 = iVar13;
if (iVar13 == 0) goto LAB_001014f4;
LAB_001012a0:
local_6c = 0;
iVar8 = iVar14 + -1;
iVar3 = iVar14;
iVar5 = iVar2;
if (iVar2 == 0) goto LAB_00101395;
while( true ) {
iVar12 = 0;
iVar4 = iVar8;
iVar6 = iVar5;
while( true ) {
iVar10 = iVar3;
iVar3 = func0(iVar4,iVar6);
iVar4 = func0(iVar4);
iVar12 = iVar12 + iVar3 + iVar4;
if (iVar6 + -1 == 0) break;
iVar4 = iVar6 + -2;
iVar3 = iVar6 + -1;
iVar6 = iVar10;
}
if (iVar8 == 0) break;
iVar4 = 0;
iVar3 = iVar8;
do {
iVar10 = iVar3;
iVar6 = iVar10 + -1;
iVar3 = iVar5 + -1;
iVar5 = func0(iVar6,iVar5);
iVar6 = func0(iVar6,iVar3);
iVar4 = iVar4 + iVar5 + iVar6;
iVar5 = iVar10;
} while (iVar3 != 0);
local_6c = local_6c + iVar4 + iVar12 + 2;
iVar4 = iVar8;
while( true ) {
iVar5 = iVar4 + -1;
iVar8 = local_78 + -1;
iVar3 = local_78;
local_78 = iVar4;
if (iVar5 != 0) break;
LAB_00101395:
iVar5 = local_6c + 2;
local_6c = iVar5;
iVar4 = iVar8;
if (iVar8 == 0) goto LAB_001013ac;
}
}
iVar5 = iVar12 + 2 + local_6c;
LAB_001013ac:
if (iVar2 != 0) {
iVar8 = iVar14 + -1;
local_6c = 0;
iVar3 = iVar2 + -1;
local_78 = iVar2;
if (iVar3 == 0) goto LAB_001014b7;
while( true ) {
iVar12 = 0;
iVar4 = iVar8;
iVar6 = iVar3;
while( true ) {
iVar10 = iVar14;
iVar14 = iVar6 + -1;
iVar7 = func0(iVar4,iVar6);
iVar4 = func0(iVar4,iVar14);
iVar12 = iVar12 + iVar7 + iVar4;
if (iVar14 == 0) break;
iVar4 = iVar6 + -2;
iVar6 = iVar10;
}
if (iVar8 == 0) break;
iVar4 = 0;
iVar14 = iVar8;
do {
iVar10 = iVar14;
iVar6 = iVar10 + -1;
iVar14 = iVar3 + -1;
iVar3 = func0(iVar6,iVar3);
iVar6 = func0(iVar6,iVar14);
iVar4 = iVar4 + iVar3 + iVar6;
iVar3 = iVar10;
} while (iVar14 != 0);
local_6c = local_6c + iVar4 + iVar12 + 2;
iVar4 = iVar8;
while( true ) {
iVar8 = local_78 + -1;
iVar3 = iVar4 + -1;
iVar14 = local_78;
local_78 = iVar4;
if (iVar3 != 0) break;
LAB_001014b7:
local_6c = local_6c + 2;
iVar4 = iVar8;
if (iVar8 == 0) goto LAB_001014ce;
}
}
local_6c = iVar12 + 2 + local_6c;
LAB_001014ce:
iVar8 = iVar2;
local_5c = local_5c + iVar5 + 2 + local_6c;
while( true ) {
iVar14 = iVar8 + -1;
iVar2 = local_68 + -1;
local_78 = local_68;
local_68 = iVar8;
if (iVar14 != 0) break;
LAB_001014f4:
iVar5 = local_5c + 2;
iVar8 = iVar2;
local_5c = iVar5;
if (iVar2 == 0) goto LAB_0010150b;
}
goto LAB_001012a0;
}
iVar5 = local_5c + 2 + iVar5;
LAB_0010150b:
if (iVar13 != 0) {
iVar14 = iVar9 + -1;
local_5c = 0;
iVar2 = iVar13 + -1;
local_68 = iVar13;
if (iVar2 == 0) goto LAB_00101777;
LAB_0010153e:
iVar3 = iVar2 + -1;
local_6c = 0;
iVar8 = iVar2;
local_78 = iVar9;
iVar9 = iVar14;
if (iVar14 == 0) goto LAB_0010162a;
while( true ) {
iVar12 = 0;
iVar4 = iVar3;
iVar6 = iVar9;
while( true ) {
iVar10 = iVar8;
iVar8 = func0(iVar4,iVar6);
iVar4 = func0();
iVar12 = iVar12 + iVar8 + iVar4;
if (iVar6 + -1 == 0) break;
iVar4 = iVar6 + -2;
iVar8 = iVar6 + -1;
iVar6 = iVar10;
}
if (iVar3 == 0) break;
iVar8 = 0;
iVar4 = iVar3;
do {
iVar6 = iVar9 + -1;
iVar9 = func0(iVar4 + -1,iVar9);
iVar10 = func0(iVar4 + -1);
iVar8 = iVar8 + iVar9 + iVar10;
iVar9 = iVar4;
iVar4 = iVar6;
} while (iVar6 != 0);
local_6c = local_6c + iVar8 + iVar12 + 2;
iVar4 = iVar3;
while( true ) {
iVar9 = iVar4 + -1;
iVar3 = local_78 + -1;
iVar8 = local_78;
local_78 = iVar4;
if (iVar9 != 0) break;
LAB_0010162a:
iVar9 = local_6c + 2;
local_6c = iVar9;
iVar4 = iVar3;
if (iVar3 == 0) goto LAB_00101640;
}
}
iVar9 = iVar12 + 2 + local_6c;
LAB_00101640:
if (iVar14 != 0) break;
local_5c = local_5c + 2 + iVar9;
LAB_0010178d:
iVar14 = iVar13;
local_4c = local_4c + iVar5 + 2 + local_5c;
while( true ) {
iVar9 = iVar14 + -1;
iVar13 = local_58 + -1;
local_68 = local_58;
local_58 = iVar14;
if (iVar9 != 0) break;
LAB_001017b4:
iVar5 = local_4c + 2;
iVar14 = iVar13;
local_4c = iVar5;
if (iVar13 == 0) goto LAB_001017cd;
}
goto LAB_00101275;
}
iVar5 = local_4c + 2 + iVar5;
LAB_001017cd:
if (iVar1 == 0) {
local_44 = local_44 + 2 + iVar5;
LAB_00101d8b:
return local_44 + 1;
}
iVar13 = iVar11 + -1;
local_4c = 0;
iVar9 = iVar1 + -1;
local_58 = iVar1;
if (iVar9 == 0) goto LAB_00101d42;
LAB_00101805:
iVar2 = iVar9 + -1;
local_5c = 0;
iVar14 = iVar9;
local_68 = iVar11;
iVar11 = iVar13;
if (iVar13 == 0) goto LAB_00101a84;
LAB_0010182d:
local_6c = 0;
iVar4 = iVar11 + -1;
iVar3 = iVar11;
iVar8 = iVar2;
if (iVar2 == 0) goto LAB_00101925;
while( true ) {
local_78 = iVar14;
iVar12 = 0;
iVar14 = iVar4;
iVar6 = iVar8;
while( true ) {
iVar10 = iVar3;
iVar3 = func0(iVar14,iVar6);
iVar14 = func0(iVar14);
iVar12 = iVar12 + iVar3 + iVar14;
if (iVar6 + -1 == 0) break;
iVar14 = iVar6 + -2;
iVar3 = iVar6 + -1;
iVar6 = iVar10;
}
if (iVar4 == 0) break;
iVar3 = 0;
iVar14 = iVar4;
do {
iVar6 = iVar8 + -1;
iVar8 = func0(iVar14 + -1,iVar8);
iVar10 = func0(iVar14 + -1,iVar6);
iVar3 = iVar3 + iVar8 + iVar10;
iVar8 = iVar14;
iVar14 = iVar6;
} while (iVar6 != 0);
iVar14 = iVar4;
local_6c = local_6c + iVar3 + iVar12 + 2;
while( true ) {
iVar8 = iVar14 + -1;
iVar4 = local_78 + -1;
iVar3 = local_78;
if (iVar8 != 0) break;
LAB_00101925:
local_78 = iVar14;
iVar8 = local_6c + 2;
iVar14 = iVar4;
local_6c = iVar8;
if (iVar4 == 0) goto LAB_0010193c;
}
}
iVar8 = iVar12 + 2 + local_6c;
LAB_0010193c:
if (iVar2 != 0) {
iVar3 = iVar11 + -1;
local_6c = 0;
iVar14 = iVar2 + -1;
local_78 = iVar2;
if (iVar14 == 0) goto LAB_00101a47;
while( true ) {
iVar12 = 0;
iVar6 = iVar14;
iVar4 = iVar3;
while( true ) {
iVar10 = iVar11;
iVar11 = iVar6 + -1;
iVar7 = func0(iVar4,iVar6);
iVar4 = func0(iVar4,iVar11);
iVar12 = iVar12 + iVar7 + iVar4;
if (iVar11 == 0) break;
iVar4 = iVar6 + -2;
iVar6 = iVar10;
}
if (iVar3 == 0) break;
iVar4 = 0;
iVar11 = iVar3;
do {
iVar6 = iVar14 + -1;
iVar14 = func0(iVar11 + -1,iVar14);
iVar10 = func0(iVar11 + -1,iVar6);
iVar4 = iVar4 + iVar14 + iVar10;
iVar14 = iVar11;
iVar11 = iVar6;
} while (iVar6 != 0);
local_6c = local_6c + iVar4 + iVar12 + 2;
iVar4 = iVar3;
while( true ) {
iVar3 = local_78 + -1;
iVar14 = iVar4 + -1;
iVar11 = local_78;
local_78 = iVar4;
if (iVar14 != 0) break;
LAB_00101a47:
local_6c = local_6c + 2;
iVar4 = iVar3;
if (iVar3 == 0) goto LAB_00101a5e;
}
}
local_6c = iVar12 + 2 + local_6c;
LAB_00101a5e:
local_5c = local_5c + iVar8 + 2 + local_6c;
iVar3 = iVar2;
while( true ) {
iVar11 = iVar3 + -1;
iVar2 = local_68 + -1;
iVar14 = local_68;
local_68 = iVar3;
if (iVar11 != 0) break;
LAB_00101a84:
iVar8 = local_5c + 2;
local_5c = iVar8;
iVar3 = iVar2;
if (iVar2 == 0) goto LAB_00101a9b;
}
goto LAB_0010182d;
}
iVar8 = local_5c + 2 + iVar8;
LAB_00101a9b:
if (iVar13 != 0) {
iVar11 = iVar9 + -1;
local_5c = 0;
iVar14 = iVar13 + -1;
local_68 = iVar13;
if (iVar14 == 0) goto LAB_00101d07;
LAB_00101acf:
local_6c = 0;
iVar4 = iVar14 + -1;
iVar2 = iVar14;
iVar3 = iVar11;
local_78 = iVar9;
if (iVar11 == 0) goto LAB_00101bba;
while( true ) {
iVar12 = 0;
iVar9 = iVar4;
iVar6 = iVar3;
while( true ) {
iVar10 = iVar2;
iVar2 = iVar6 + -1;
iVar7 = func0(iVar9,iVar6);
iVar9 = func0(iVar9,iVar2);
iVar12 = iVar12 + iVar7 + iVar9;
if (iVar2 == 0) break;
iVar9 = iVar6 + -2;
iVar6 = iVar10;
}
if (iVar4 == 0) break;
iVar9 = 0;
iVar2 = iVar4;
do {
iVar10 = iVar2;
iVar6 = iVar10 + -1;
iVar2 = iVar3 + -1;
iVar3 = func0(iVar6,iVar3);
iVar6 = func0(iVar6,iVar2);
iVar9 = iVar9 + iVar3 + iVar6;
iVar3 = iVar10;
} while (iVar2 != 0);
local_6c = local_6c + iVar9 + iVar12 + 2;
iVar6 = iVar4;
while( true ) {
iVar3 = iVar6 + -1;
iVar4 = local_78 + -1;
iVar2 = local_78;
local_78 = iVar6;
if (iVar3 != 0) break;
LAB_00101bba:
iVar9 = local_6c + 2;
local_6c = iVar9;
iVar6 = iVar4;
if (iVar4 == 0) goto LAB_00101bd0;
}
}
iVar9 = iVar12 + 2 + local_6c;
LAB_00101bd0:
if (iVar11 != 0) goto code_r0x00101bdc;
local_5c = local_5c + 2 + iVar9;
LAB_00101d1d:
local_4c = local_4c + iVar8 + 2 + local_5c;
iVar14 = iVar13;
while( true ) {
iVar13 = local_58 + -1;
iVar9 = iVar14 + -1;
iVar11 = local_58;
local_58 = iVar14;
if (iVar9 != 0) break;
LAB_00101d42:
local_4c = local_4c + 2;
iVar14 = iVar13;
if (iVar13 == 0) goto LAB_00101d59;
}
goto LAB_00101805;
}
local_4c = local_4c + 2 + iVar8;
LAB_00101d59:
local_44 = local_44 + iVar5 + 2 + local_4c;
iVar9 = iVar1;
while( true ) {
iVar1 = local_48 + -1;
iVar11 = iVar9 + -1;
param_1 = local_48;
if (iVar11 != 0) break;
LAB_00101d7d:
local_48 = iVar9;
local_44 = local_44 + 2;
iVar9 = iVar1;
if (iVar1 == 0) goto LAB_00101d8b;
}
} while( true );
iVar3 = iVar2 + -1;
local_6c = 0;
iVar8 = iVar14 + -1;
local_78 = iVar14;
if (iVar8 == 0) goto LAB_0010173c;
while( true ) {
iVar12 = 0;
iVar4 = iVar3;
iVar6 = iVar8;
while( true ) {
iVar10 = iVar2;
iVar2 = iVar6 + -1;
iVar7 = func0(iVar4,iVar6);
iVar4 = func0(iVar4,iVar2);
iVar12 = iVar12 + iVar7 + iVar4;
if (iVar2 == 0) break;
iVar4 = iVar6 + -2;
iVar6 = iVar10;
}
if (iVar3 == 0) break;
iVar2 = 0;
iVar4 = iVar3;
do {
iVar6 = iVar8 + -1;
iVar8 = func0(iVar4 + -1,iVar8);
iVar10 = func0(iVar4 + -1,iVar6);
iVar2 = iVar2 + iVar8 + iVar10;
iVar8 = iVar4;
iVar4 = iVar6;
} while (iVar6 != 0);
local_6c = local_6c + iVar2 + iVar12 + 2;
iVar4 = iVar3;
while( true ) {
iVar3 = local_78 + -1;
iVar8 = iVar4 + -1;
iVar2 = local_78;
local_78 = iVar4;
if (iVar8 != 0) break;
LAB_0010173c:
local_6c = local_6c + 2;
iVar4 = iVar3;
if (iVar3 == 0) goto LAB_00101752;
}
}
local_6c = iVar12 + 2 + local_6c;
LAB_00101752:
local_5c = local_5c + iVar9 + 2 + local_6c;
iVar8 = iVar14;
while( true ) {
iVar14 = local_68 + -1;
iVar2 = iVar8 + -1;
iVar9 = local_68;
local_68 = iVar8;
if (iVar2 != 0) break;
LAB_00101777:
local_5c = local_5c + 2;
iVar8 = iVar14;
if (iVar14 == 0) goto LAB_0010178d;
}
goto LAB_0010153e;
code_r0x00101bdc:
iVar3 = iVar14 + -1;
local_6c = 0;
iVar2 = iVar11 + -1;
local_78 = iVar11;
if (iVar2 == 0) goto LAB_00101ccc;
while( true ) {
iVar12 = 0;
iVar4 = iVar3;
iVar6 = iVar2;
while( true ) {
iVar10 = iVar14;
iVar14 = iVar6 + -1;
iVar7 = func0(iVar4,iVar6);
iVar4 = func0(iVar4,iVar14);
iVar12 = iVar12 + iVar7 + iVar4;
if (iVar14 == 0) break;
iVar4 = iVar6 + -2;
iVar6 = iVar10;
}
if (iVar3 == 0) break;
iVar4 = 0;
iVar14 = iVar3;
do {
iVar6 = iVar2 + -1;
iVar2 = func0(iVar14 + -1,iVar2);
iVar10 = func0(iVar14 + -1,iVar6);
iVar4 = iVar4 + iVar2 + iVar10;
iVar2 = iVar14;
iVar14 = iVar6;
} while (iVar6 != 0);
local_6c = local_6c + iVar4 + iVar12 + 2;
iVar4 = iVar3;
while( true ) {
iVar3 = local_78 + -1;
iVar2 = iVar4 + -1;
iVar14 = local_78;
local_78 = iVar4;
if (iVar2 != 0) break;
LAB_00101ccc:
local_6c = local_6c + 2;
iVar4 = iVar3;
if (iVar3 == 0) goto LAB_00101ce2;
}
}
local_6c = iVar12 + 2 + local_6c;
LAB_00101ce2:
local_5c = local_5c + iVar9 + 2 + local_6c;
iVar2 = iVar11;
while( true ) {
iVar11 = local_68 + -1;
iVar14 = iVar2 + -1;
iVar9 = local_68;
local_68 = iVar2;
if (iVar14 != 0) break;
LAB_00101d07:
local_5c = local_5c + 2;
iVar2 = iVar11;
if (iVar11 == 0) goto LAB_00101d1d;
}
goto LAB_00101acf;
} |
7,632 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
imul -0x14(%rbp),%eax
mov -0x14(%rbp),%edx
add %edx,%edx
add $0x1,%edx
imul %edx,%eax
movslq %eax,%rdx
imul $0x2aaaaaab,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%ecx
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
mov eax, [rbp+var_14]
add eax, 1
imul eax, [rbp+var_14]
mov edx, [rbp+var_14]
add edx, edx
add edx, 1
imul eax, edx
movsxd rdx, eax
imul rdx, 2AAAAAABh
mov rcx, rdx
shr rcx, 20h
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x14]
ADD EDX,EDX
ADD EDX,0x1
IMUL EAX,EDX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x2aaaaaab
MOV RCX,RDX
SHR RCX,0x20
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,633 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%edx
imul %edi,%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %eax,%edx
movslq %edx,%rax
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sar $0x1f,%edx
sub %edx,%eax
retq
| func0:
endbr64
lea edx, [rdi+1]
imul edx, edi
lea eax, [rdi+rdi+1]
imul edx, eax
movsxd rax, edx
imul rax, 2AAAAAABh
shr rax, 20h
sar edx, 1Fh
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SAR EDX,0x1f
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,634 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %edi,%edx
imul %eax,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sub %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea eax, [rdi+rdi+1]
imul edx, edi
imul edx, eax
movsxd rax, edx
sar edx, 1Fh
imul rax, 2AAAAAABh
shr rax, 20h
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EDI
IMUL EDX,EAX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,635 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %edi,%edx
imul %eax,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sub %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea eax, [rdi+rdi+1]
imul edx, edi
imul edx, eax
movsxd rax, edx
sar edx, 1Fh
imul rax, 2AAAAAABh
shr rax, 20h
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EDI
IMUL EDX,EAX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,636 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
res[i].key = test_list[j].key;
res[i].value = test_list[j].value;
break;
}
}
}
return res;
}
| int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key == 2 && result1[2].value == 10) &&
(result1[3].key == 3 && result1[3].value == 2));
pair test_list2[] = {{5, 4}, {2, 10}, {3, 11}, {4, 3}};
int ord_list2[] = {3, 4, 2, 3};
pair *result2 = func0(test_list2, 4, ord_list2, 4);
assert((result2[0].key == 3 && result2[0].value == 11) &&
(result2[1].key == 4 && result2[1].value == 3) &&
(result2[2].key == 2 && result2[2].value == 10) &&
(result2[3].key == 3 && result2[3].value == 11));
pair test_list3[] = {{6, 3}, {3, 8}, {5, 7}, {2, 4}};
int ord_list3[] = {2, 5, 3, 6};
pair *result3 = func0(test_list3, 4, ord_list3, 4);
assert((result3[0].key == 2 && result3[0].value == 4) &&
(result3[1].key == 5 && result3[1].value == 7) &&
(result3[2].key == 3 && result3[2].value == 8) &&
(result3[3].key == 6 && result3[3].value == 3));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x20(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1090 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 1272 <func0+0xe9>
movl $0x0,-0xc(%rbp)
jmpq 1262 <func0+0xd9>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 125e <func0+0xd5>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov 0x4(%rax),%eax
mov %eax,0x4(%rdx)
jmp 126e <func0+0xe5>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11d0 <func0+0x47>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11c4 <func0+0x3b>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov eax, [rbp+var_20]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp loc_1272
loc_11C4:
mov [rbp+var_C], 0
jmp loc_1262
loc_11D0:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_125E
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax+4]
mov [rdx+4], eax
jmp short loc_126E
loc_125E:
add [rbp+var_C], 1
loc_1262:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_11D0
loc_126E:
add [rbp+var_10], 1
loc_1272:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_20]
jl loc_11C4
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v9 = malloc(8LL * a4);
for ( i = 0; i < a4; ++i )
{
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a3) == *(_DWORD *)(8LL * j + a1) )
{
v9[2 * i] = *(_DWORD *)(8LL * j + a1);
v9[2 * i + 1] = *(_DWORD *)(8LL * j + a1 + 4);
break;
}
}
}
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101272
LAB_001011c4:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101262
LAB_001011d0:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x0010125e
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RDX + 0x4],EAX
JMP 0x0010126e
LAB_0010125e:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101262:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011d0
LAB_0010126e:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101272:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011c4
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
int local_18;
int local_14;
pvVar1 = malloc((long)param_4 << 3);
local_18 = 0;
do {
if (param_4 <= local_18) {
return pvVar1;
}
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_3 + (long)local_18 * 4) == *(int *)(param_1 + (long)local_14 * 8)) {
*(int4 *)((long)pvVar1 + (long)local_18 * 8) =
*(int4 *)(param_1 + (long)local_14 * 8);
*(int4 *)((long)pvVar1 + (long)local_18 * 8 + 4) =
*(int4 *)(param_1 + (long)local_14 * 8 + 4);
break;
}
}
local_18 = local_18 + 1;
} while( true );
} |
7,637 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
res[i].key = test_list[j].key;
res[i].value = test_list[j].value;
break;
}
}
}
return res;
}
| int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key == 2 && result1[2].value == 10) &&
(result1[3].key == 3 && result1[3].value == 2));
pair test_list2[] = {{5, 4}, {2, 10}, {3, 11}, {4, 3}};
int ord_list2[] = {3, 4, 2, 3};
pair *result2 = func0(test_list2, 4, ord_list2, 4);
assert((result2[0].key == 3 && result2[0].value == 11) &&
(result2[1].key == 4 && result2[1].value == 3) &&
(result2[2].key == 2 && result2[2].value == 10) &&
(result2[3].key == 3 && result2[3].value == 11));
pair test_list3[] = {{6, 3}, {3, 8}, {5, 7}, {2, 4}};
int ord_list3[] = {2, 5, 3, 6};
pair *result3 = func0(test_list3, 4, ord_list3, 4);
assert((result3[0].key == 2 && result3[0].value == 4) &&
(result3[1].key == 5 && result3[1].value == 7) &&
(result3[2].key == 3 && result3[2].value == 8) &&
(result3[3].key == 6 && result3[3].value == 3));
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %rdx,%rbp
mov %ecx,%r13d
movslq %ecx,%rdi
shl $0x3,%rdi
callq 1090 <malloc@plt>
test %r13d,%r13d
jle 11ff <func0+0x76>
lea -0x1(%r13),%r10d
mov %r12,%r11
lea -0x1(%rbx),%edx
lea 0x8(%r12,%rdx,8),%r8
mov $0x0,%r9d
jmp 11e2 <func0+0x59>
mov %ecx,(%rax,%r9,8)
mov 0x4(%rdx),%edx
mov %edx,0x4(%rax,%r9,8)
lea 0x1(%r9),%rdx
cmp %r10,%r9
je 11ff <func0+0x76>
mov %rdx,%r9
test %ebx,%ebx
jle 11d6 <func0+0x4d>
mov 0x0(%rbp,%r9,4),%esi
mov %r11,%rdx
mov (%rdx),%ecx
cmp %ecx,%esi
je 11ca <func0+0x41>
add $0x8,%rdx
cmp %r8,%rdx
jne 11ee <func0+0x65>
jmp 11d6 <func0+0x4d>
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 rbp, rdi
mov ebx, esi
mov r12, rdx
mov r13d, ecx
movsxd rdi, ecx
shl rdi, 3
call _malloc
test r13d, r13d
jle short loc_11F7
mov r10d, r13d
lea edx, [rbx-1]
lea r8, [rbp+rdx*8+8]
mov r9d, 0
jmp short loc_11DB
loc_11C6:
mov [rax+r9*8], ecx
mov edx, [rdx+4]
mov [rax+r9*8+4], edx
loc_11D2:
add r9, 1
cmp r9, r10
jz short loc_11F7
loc_11DB:
test ebx, ebx
jle short loc_11D2
mov esi, [r12+r9*4]
mov rdx, rbp
loc_11E6:
mov ecx, [rdx]
cmp esi, ecx
jz short loc_11C6
add rdx, 8
cmp rdx, r8
jnz short loc_11E6
jmp short loc_11D2
loc_11F7:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(_DWORD *a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v7; // r9
_DWORD *v8; // rdx
result = malloc(8LL * a4);
if ( a4 > 0 )
{
v7 = 0LL;
do
{
if ( a2 > 0 )
{
v8 = a1;
while ( *(_DWORD *)(a3 + 4 * v7) != *v8 )
{
v8 += 2;
if ( v8 == &a1[2 * (a2 - 1) + 2] )
goto LABEL_4;
}
*(_DWORD *)(result + 8 * v7) = *v8;
*(_DWORD *)(result + 8 * v7 + 4) = v8[1];
}
LABEL_4:
++v7;
}
while ( v7 != a4 );
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
MOV R12,RDX
MOV R13D,ECX
MOVSXD RDI,ECX
SHL RDI,0x3
CALL 0x00101090
TEST R13D,R13D
JLE 0x001011f7
MOV R10D,R13D
LEA EDX,[RBX + -0x1]
LEA R8,[RBP + RDX*0x8 + 0x8]
MOV R9D,0x0
JMP 0x001011db
LAB_001011c6:
MOV dword ptr [RAX + R9*0x8],ECX
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RAX + R9*0x8 + 0x4],EDX
LAB_001011d2:
ADD R9,0x1
CMP R9,R10
JZ 0x001011f7
LAB_001011db:
TEST EBX,EBX
JLE 0x001011d2
MOV ESI,dword ptr [R12 + R9*0x4]
MOV RDX,RBP
LAB_001011e6:
MOV ECX,dword ptr [RDX]
CMP ESI,ECX
JZ 0x001011c6
ADD RDX,0x8
CMP RDX,R8
JNZ 0x001011e6
JMP 0x001011d2
LAB_001011f7:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(int *param_1,int param_2,long param_3,uint param_4)
{
void *pvVar1;
int *piVar2;
ulong uVar3;
pvVar1 = malloc((long)(int)param_4 << 3);
if (0 < (int)param_4) {
uVar3 = 0;
do {
if (0 < param_2) {
piVar2 = param_1;
do {
if (*(int *)(param_3 + uVar3 * 4) == *piVar2) {
*(int *)((long)pvVar1 + uVar3 * 8) = *piVar2;
*(int *)((long)pvVar1 + uVar3 * 8 + 4) = piVar2[1];
break;
}
piVar2 = piVar2 + 2;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) * 2 + 2);
}
uVar3 = uVar3 + 1;
} while (uVar3 != param_4);
}
return;
} |
7,638 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
res[i].key = test_list[j].key;
res[i].value = test_list[j].value;
break;
}
}
}
return res;
}
| int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key == 2 && result1[2].value == 10) &&
(result1[3].key == 3 && result1[3].value == 2));
pair test_list2[] = {{5, 4}, {2, 10}, {3, 11}, {4, 3}};
int ord_list2[] = {3, 4, 2, 3};
pair *result2 = func0(test_list2, 4, ord_list2, 4);
assert((result2[0].key == 3 && result2[0].value == 11) &&
(result2[1].key == 4 && result2[1].value == 3) &&
(result2[2].key == 2 && result2[2].value == 10) &&
(result2[3].key == 3 && result2[3].value == 11));
pair test_list3[] = {{6, 3}, {3, 8}, {5, 7}, {2, 4}};
int ord_list3[] = {2, 5, 3, 6};
pair *result3 = func0(test_list3, 4, ord_list3, 4);
assert((result3[0].key == 2 && result3[0].value == 4) &&
(result3[1].key == 5 && result3[1].value == 7) &&
(result3[2].key == 3 && result3[2].value == 8) &&
(result3[3].key == 6 && result3[3].value == 3));
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %ecx,%rdi
push %rbx
mov %rdi,%r13
shl $0x3,%rdi
mov %esi,%ebx
sub $0x8,%rsp
callq 1090 <malloc@plt>
test %r13d,%r13d
jle 14c0 <func0+0x80>
lea -0x1(%rbx),%ecx
lea -0x1(%r13),%edx
xor %r9d,%r9d
lea 0x8(%rbp,%rcx,8),%r8
nopl 0x0(%rax)
test %ebx,%ebx
jle 14a9 <func0+0x69>
mov (%r12,%r9,4),%edi
mov %rbp,%rcx
jmp 1499 <func0+0x59>
nopl (%rax)
add $0x8,%rcx
cmp %r8,%rcx
je 14a9 <func0+0x69>
cmp (%rcx),%edi
jne 1490 <func0+0x50>
mov 0x4(%rcx),%ecx
mov %edi,(%rax,%r9,8)
mov %ecx,0x4(%rax,%r9,8)
lea 0x1(%r9),%rcx
cmp %rdx,%r9
je 14c0 <func0+0x80>
mov %rcx,%r9
jmp 1480 <func0+0x40>
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
movsxd r13, ecx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
lea rdi, ds:0[r13*8]
push rbx
mov ebx, esi
call _malloc
test r13d, r13d
jle short loc_14A8
lea edx, [rbx-1]
xor edi, edi
lea rsi, [rbp+rdx*8+8]
nop dword ptr [rax+rax+00h]
loc_1478:
test ebx, ebx
jle short loc_149F
mov ecx, [r12+rdi*4]
mov rdx, rbp
jmp short loc_1491
loc_1488:
add rdx, 8
cmp rdx, rsi
jz short loc_149F
loc_1491:
cmp ecx, [rdx]
jnz short loc_1488
mov edx, [rdx+4]
mov [rax+rdi*8], ecx
mov [rax+rdi*8+4], edx
loc_149F:
add rdi, 1
cmp rdi, r13
jnz short loc_1478
loc_14A8:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(_DWORD *a1, int a2, long long a3, int a4)
{
long long v4; // r13
long long result; // rax
long long i; // rdi
int v9; // ecx
_DWORD *v10; // rdx
int v11; // edx
v4 = a4;
result = malloc(8LL * a4);
if ( (int)v4 > 0 )
{
for ( i = 0LL; i != v4; ++i )
{
if ( a2 > 0 )
{
v9 = *(_DWORD *)(a3 + 4 * i);
v10 = a1;
while ( v9 != *v10 )
{
v10 += 2;
if ( v10 == &a1[2 * (a2 - 1) + 2] )
goto LABEL_8;
}
v11 = v10[1];
*(_DWORD *)(result + 8 * i) = v9;
*(_DWORD *)(result + 8 * i + 4) = v11;
}
LABEL_8:
;
}
}
return result;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
LEA RDI,[R13*0x8]
PUSH RBX
MOV EBX,ESI
CALL 0x00101090
TEST R13D,R13D
JLE 0x001014a8
LEA EDX,[RBX + -0x1]
XOR EDI,EDI
LEA RSI,[RBP + RDX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101478:
TEST EBX,EBX
JLE 0x0010149f
MOV ECX,dword ptr [R12 + RDI*0x4]
MOV RDX,RBP
JMP 0x00101491
LAB_00101488:
ADD RDX,0x8
CMP RDX,RSI
JZ 0x0010149f
LAB_00101491:
CMP ECX,dword ptr [RDX]
JNZ 0x00101488
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RAX + RDI*0x8],ECX
MOV dword ptr [RAX + RDI*0x8 + 0x4],EDX
LAB_0010149f:
ADD RDI,0x1
CMP RDI,R13
JNZ 0x00101478
LAB_001014a8:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void func0(int *param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
void *pvVar3;
int *piVar4;
long lVar5;
pvVar3 = malloc((long)param_4 * 8);
if (0 < param_4) {
lVar5 = 0;
do {
if (0 < param_2) {
iVar1 = *(int *)(param_3 + lVar5 * 4);
piVar4 = param_1;
do {
if (iVar1 == *piVar4) {
iVar2 = piVar4[1];
*(int *)((long)pvVar3 + lVar5 * 8) = iVar1;
*(int *)((long)pvVar3 + lVar5 * 8 + 4) = iVar2;
break;
}
piVar4 = piVar4 + 2;
} while (piVar4 != param_1 + (ulong)(param_2 - 1) * 2 + 2);
}
lVar5 = lVar5 + 1;
} while (lVar5 != param_4);
}
return;
} |
7,639 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
res[i].key = test_list[j].key;
res[i].value = test_list[j].value;
break;
}
}
}
return res;
}
| int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key == 2 && result1[2].value == 10) &&
(result1[3].key == 3 && result1[3].value == 2));
pair test_list2[] = {{5, 4}, {2, 10}, {3, 11}, {4, 3}};
int ord_list2[] = {3, 4, 2, 3};
pair *result2 = func0(test_list2, 4, ord_list2, 4);
assert((result2[0].key == 3 && result2[0].value == 11) &&
(result2[1].key == 4 && result2[1].value == 3) &&
(result2[2].key == 2 && result2[2].value == 10) &&
(result2[3].key == 3 && result2[3].value == 11));
pair test_list3[] = {{6, 3}, {3, 8}, {5, 7}, {2, 4}};
int ord_list3[] = {2, 5, 3, 6};
pair *result3 = func0(test_list3, 4, ord_list3, 4);
assert((result3[0].key == 2 && result3[0].value == 4) &&
(result3[1].key == 5 && result3[1].value == 7) &&
(result3[2].key == 3 && result3[2].value == 8) &&
(result3[3].key == 6 && result3[3].value == 3));
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %ecx,%rdi
push %rbx
mov %rdi,%r13
shl $0x3,%rdi
mov %esi,%ebx
sub $0x8,%rsp
callq 1090 <malloc@plt>
test %r13d,%r13d
jle 1440 <func0+0x80>
lea -0x1(%rbx),%ecx
lea -0x1(%r13),%edx
xor %r9d,%r9d
lea 0x8(%rbp,%rcx,8),%r8
nopl 0x0(%rax)
test %ebx,%ebx
jle 1429 <func0+0x69>
mov (%r12,%r9,4),%edi
mov %rbp,%rcx
jmp 1419 <func0+0x59>
nopl (%rax)
add $0x8,%rcx
cmp %r8,%rcx
je 1429 <func0+0x69>
cmp (%rcx),%edi
jne 1410 <func0+0x50>
mov 0x4(%rcx),%ecx
mov %edi,(%rax,%r9,8)
mov %ecx,0x4(%rax,%r9,8)
lea 0x1(%r9),%rcx
cmp %rdx,%r9
je 1440 <func0+0x80>
mov %rcx,%r9
jmp 1400 <func0+0x40>
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
movsxd r13, esi
push r12
movsxd r12, ecx
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
lea rdi, ds:0[r12*8]; size
call _malloc
xor edi, edi
test r12d, r12d
jle short loc_13FA
loc_13EC:
test r13d, r13d
jg short loc_1403
add rdi, 1
cmp r12, rdi
jnz short loc_13EC
loc_13FA:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1403:
lea rsi, [rbx+r13*8]
nop word ptr [rax+rax+00000000h]
loc_1410:
mov ecx, [rbp+rdi*4+0]
mov rdx, rbx
jmp short loc_1429
loc_1420:
add rdx, 8
cmp rsi, rdx
jz short loc_1458
loc_1429:
cmp ecx, [rdx]
jnz short loc_1420
movd xmm0, dword ptr [rdx+4]
movd xmm1, ecx
punpckldq xmm1, xmm0
movq qword ptr [rax+rdi*8], xmm1
add rdi, 1
cmp r12, rdi
jnz short loc_1410
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1458:
add rdi, 1
cmp r12, rdi
jnz short loc_1410
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | _QWORD * func0(_DWORD *a1, int a2, long long a3, int a4)
{
long long v4; // r12
_QWORD *result; // rax
long long v8; // rdi
_DWORD *v9; // rsi
unsigned int v10; // ecx
_DWORD *v11; // rdx
v4 = a4;
result = malloc(8LL * a4);
v8 = 0LL;
if ( (int)v4 > 0 )
{
while ( a2 <= 0 )
{
if ( v4 == ++v8 )
return result;
}
v9 = &a1[2 * a2];
LABEL_6:
while ( 2 )
{
v10 = *(_DWORD *)(a3 + 4 * v8);
v11 = a1;
do
{
if ( v10 == *v11 )
{
result[v8++] = _mm_unpacklo_epi32(_mm_cvtsi32_si128(v10), _mm_cvtsi32_si128(v11[1])).m128i_u64[0];
if ( v4 != v8 )
goto LABEL_6;
return result;
}
v11 += 2;
}
while ( v9 != v11 );
if ( v4 != ++v8 )
continue;
break;
}
}
return result;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOVSXD R12,ECX
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
LEA RDI,[R12*0x8]
CALL 0x00101090
XOR EDI,EDI
TEST R12D,R12D
JLE 0x001013fa
LAB_001013ec:
TEST R13D,R13D
JG 0x00101403
ADD RDI,0x1
CMP R12,RDI
JNZ 0x001013ec
LAB_001013fa:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101403:
LEA RSI,[RBX + R13*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101410:
MOV ECX,dword ptr [RBP + RDI*0x4]
MOV RDX,RBX
JMP 0x00101429
LAB_00101420:
ADD RDX,0x8
CMP RSI,RDX
JZ 0x00101458
LAB_00101429:
CMP ECX,dword ptr [RDX]
JNZ 0x00101420
MOVD XMM0,dword ptr [RDX + 0x4]
MOVD XMM1,ECX
PUNPCKLDQ XMM1,XMM0
MOVQ qword ptr [RAX + RDI*0x8],XMM1
ADD RDI,0x1
CMP R12,RDI
JNZ 0x00101410
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101458:
ADD RDI,0x1
CMP R12,RDI
JNZ 0x00101410
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void func0(int *param_1,int param_2,long param_3,int param_4)
{
int iVar1;
void *pvVar2;
int *piVar3;
long lVar4;
long lVar5;
lVar5 = (long)param_4;
pvVar2 = malloc(lVar5 * 8);
lVar4 = 0;
if (0 < param_4) {
do {
if (0 < param_2) {
LAB_00101410:
do {
iVar1 = *(int *)(param_3 + lVar4 * 4);
piVar3 = param_1;
do {
if (iVar1 == *piVar3) {
*(ulong *)((long)pvVar2 + lVar4 * 8) = CONCAT44(piVar3[1],iVar1);
lVar4 = lVar4 + 1;
if (lVar5 == lVar4) {
return;
}
goto LAB_00101410;
}
piVar3 = piVar3 + 2;
} while (param_1 + (long)param_2 * 2 != piVar3);
lVar4 = lVar4 + 1;
if (lVar5 == lVar4) {
return;
}
} while( true );
}
lVar4 = lVar4 + 1;
} while (lVar5 != lVar4);
}
return;
} |
7,640 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
max_freq = frequency[(unsigned char)str1[i]];
max_char = str1[i];
}
}
return max_char;
}
| int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x41c(%rbp)
movb $0x0,-0x41d(%rbp)
mov -0x428(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x414(%rbp)
movl $0x0,-0x418(%rbp)
jmpq 129e <func0+0x115>
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
movslq %eax,%rdx
mov -0x410(%rbp,%rdx,4),%edx
add $0x1,%edx
cltq
mov %edx,-0x410(%rbp,%rax,4)
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
cmp %eax,-0x41c(%rbp)
jge 1297 <func0+0x10e>
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
mov %eax,-0x41c(%rbp)
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x41d(%rbp)
addl $0x1,-0x418(%rbp)
mov -0x418(%rbp),%eax
cmp -0x414(%rbp),%eax
jl 11fa <func0+0x71>
movzbl -0x41d(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 12cb <func0+0x142>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_41C], 0
mov [rbp+var_41D], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_414], eax
mov [rbp+var_418], 0
jmp loc_129E
loc_11FA:
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
movsxd rdx, eax
mov edx, [rbp+rdx*4+var_410]
add edx, 1
cdqe
mov [rbp+rax*4+var_410], edx
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
cdqe
mov eax, [rbp+rax*4+var_410]
cmp [rbp+var_41C], eax
jge short loc_1297
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
cdqe
mov eax, [rbp+rax*4+var_410]
mov [rbp+var_41C], eax
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_41D], al
loc_1297:
add [rbp+var_418], 1
loc_129E:
mov eax, [rbp+var_418]
cmp eax, [rbp+var_414]
jl loc_11FA
movzx eax, [rbp+var_41D]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12CB
call ___stack_chk_fail
locret_12CB:
leave
retn | long long func0(const char *a1)
{
unsigned __int8 v2; // [rsp+13h] [rbp-41Dh]
int v3; // [rsp+14h] [rbp-41Ch]
int i; // [rsp+18h] [rbp-418h]
int v5; // [rsp+1Ch] [rbp-414h]
_DWORD v6[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v7; // [rsp+428h] [rbp-8h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 0x400uLL);
v3 = 0;
v2 = 0;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( v3 < ++v6[(unsigned __int8)a1[i]] )
{
v3 = v6[(unsigned __int8)a1[i]];
v2 = a1[i];
}
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x41c],0x0
MOV byte ptr [RBP + -0x41d],0x0
MOV RAX,qword ptr [RBP + -0x428]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x414],EAX
MOV dword ptr [RBP + -0x418],0x0
JMP 0x0010129e
LAB_001011fa:
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
MOVSXD RDX,EAX
MOV EDX,dword ptr [RBP + RDX*0x4 + -0x410]
ADD EDX,0x1
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x410],EDX
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
CMP dword ptr [RBP + -0x41c],EAX
JGE 0x00101297
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
MOV dword ptr [RBP + -0x41c],EAX
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x41d],AL
LAB_00101297:
ADD dword ptr [RBP + -0x418],0x1
LAB_0010129e:
MOV EAX,dword ptr [RBP + -0x418]
CMP EAX,dword ptr [RBP + -0x414]
JL 0x001011fa
MOVZX EAX,byte ptr [RBP + -0x41d]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012cb
CALL 0x00101080
LAB_001012cb:
LEAVE
RET | char func0(char *param_1)
{
size_t sVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
char local_425;
int local_424;
int local_420;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_418;
for (lVar2 = 0x80; lVar2 != 0; lVar2 = lVar2 + -1) {
piVar3[0] = 0;
piVar3[1] = 0;
piVar3 = piVar3 + 2;
}
local_424 = 0;
local_425 = '\0';
sVar1 = strlen(param_1);
for (local_420 = 0; local_420 < (int)sVar1; local_420 = local_420 + 1) {
local_418[(int)(uint)(byte)param_1[local_420]] =
local_418[(int)(uint)(byte)param_1[local_420]] + 1;
if (local_424 < local_418[(int)(uint)(byte)param_1[local_420]]) {
local_424 = local_418[(int)(uint)(byte)param_1[local_420]];
local_425 = param_1[local_420];
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_425;
} |
7,641 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
max_freq = frequency[(unsigned char)str1[i]];
max_char = str1[i];
}
}
return max_char;
}
| int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O1 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rsi
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
mov $0xffffffffffffffff,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11e8 <func0+0x7f>
mov %rsi,%rdx
lea -0x1(%rcx),%eax
lea 0x1(%rsi,%rax,1),%r8
mov $0x0,%r9d
mov $0x0,%edi
jmp 11cd <func0+0x64>
add $0x1,%rdx
cmp %r8,%rdx
je 11ee <func0+0x85>
movzbl (%rdx),%esi
movzbl %sil,%ecx
mov (%rsp,%rcx,4),%eax
add $0x1,%eax
mov %eax,(%rsp,%rcx,4)
cmp %edi,%eax
jle 11c4 <func0+0x5b>
mov %esi,%r9d
mov %eax,%edi
jmp 11c4 <func0+0x5b>
mov $0x0,%r9d
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 120c <func0+0xa3>
mov %r9d,%eax
add $0x418,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 410h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_11FE
mov rdx, rbx
lea eax, [rax-1]
lea r8, [rbx+rax+1]
mov r9d, 0
mov edi, 0
jmp short loc_11E3
loc_11DA:
add rdx, 1
cmp rdx, r8
jz short loc_1204
loc_11E3:
movzx esi, byte ptr [rdx]
movzx ecx, sil
mov eax, [rsp+rcx*4+418h+var_418]
add eax, 1
mov [rsp+rcx*4+418h+var_418], eax
cmp eax, edi
jle short loc_11DA
mov r9d, esi
mov edi, eax
jmp short loc_11DA
loc_11FE:
mov r9d, 0
loc_1204:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_1223
mov eax, r9d
add rsp, 410h
pop rbx
retn
loc_1223:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
int v1; // eax
unsigned __int8 *v2; // rdx
long long v3; // r8
unsigned int v4; // r9d
int v5; // edi
unsigned int v6; // esi
int v7; // eax
_DWORD v9[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-10h]
v10 = __readfsqword(0x28u);
memset(v9, 0, 0x400uLL);
v1 = strlen(a1);
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[v1 - 1 + 1];
v4 = 0;
v5 = 0;
do
{
v6 = *v2;
v7 = v9[(unsigned __int8)v6] + 1;
v9[(unsigned __int8)v6] = v7;
if ( v7 > v5 )
{
v4 = v6;
v5 = v7;
}
++v2;
}
while ( v2 != (unsigned __int8 *)v3 );
}
return v4;
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x410
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001011fe
MOV RDX,RBX
LEA EAX,[RAX + -0x1]
LEA R8,[RBX + RAX*0x1 + 0x1]
MOV R9D,0x0
MOV EDI,0x0
JMP 0x001011e3
LAB_001011da:
ADD RDX,0x1
CMP RDX,R8
JZ 0x00101204
LAB_001011e3:
MOVZX ESI,byte ptr [RDX]
MOVZX ECX,SIL
MOV EAX,dword ptr [RSP + RCX*0x4]
ADD EAX,0x1
MOV dword ptr [RSP + RCX*0x4],EAX
CMP EAX,EDI
JLE 0x001011da
MOV R9D,ESI
MOV EDI,EAX
JMP 0x001011da
LAB_001011fe:
MOV R9D,0x0
LAB_00101204:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101223
MOV EAX,R9D
ADD RSP,0x410
POP RBX
RET
LAB_00101223:
CALL 0x00101080 | byte func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
int iVar3;
size_t sVar4;
long lVar5;
int iVar6;
int *piVar7;
byte bVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
*(int8 *)piVar7 = 0;
piVar7 = (int *)((long)piVar7 + 8);
}
sVar4 = strlen((char *)param_1);
if ((int)sVar4 < 1) {
bVar8 = 0;
}
else {
pbVar1 = param_1 + (ulong)((int)sVar4 - 1) + 1;
bVar8 = 0;
iVar6 = 0;
do {
bVar2 = *param_1;
iVar3 = aiStack_418[bVar2] + 1;
aiStack_418[bVar2] = iVar3;
if (iVar6 < iVar3) {
iVar6 = iVar3;
bVar8 = bVar2;
}
param_1 = param_1 + 1;
} while (param_1 != pbVar1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar8;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,642 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
max_freq = frequency[(unsigned char)str1[i]];
max_char = str1[i];
}
}
return max_char;
}
| int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
callq 1070 <strlen@plt>
test %eax,%eax
jle 12c0 <func0+0x90>
sub $0x1,%eax
mov %rbx,%rdi
xor %r9d,%r9d
xor %esi,%esi
lea 0x1(%rbx,%rax,1),%r8
nopl 0x0(%rax)
movzbl (%rdi),%edx
mov (%rsp,%rdx,4),%eax
add $0x1,%eax
mov %eax,(%rsp,%rdx,4)
cmp %esi,%eax
jle 1295 <func0+0x65>
mov %edx,%r9d
mov %eax,%esi
add $0x1,%rdi
cmp %r8,%rdi
jne 1280 <func0+0x50>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 12c5 <func0+0x95>
add $0x410,%rsp
mov %r9d,%eax
pop %rbx
retq
nopl (%rax)
xor %r9d,%r9d
jmp 129e <func0+0x6e>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_12C0
sub eax, 1
mov rdi, rbx
xor r9d, r9d
xor esi, esi
lea r8, [rbx+rax+1]
nop dword ptr [rax+00000000h]
loc_1280:
movzx edx, byte ptr [rdi]
mov eax, [rsp+rdx*4+418h+var_418]
add eax, 1
mov [rsp+rdx*4+418h+var_418], eax
cmp eax, esi
jle short loc_1295
mov r9d, edx
mov esi, eax
loc_1295:
add rdi, 1
cmp rdi, r8
jnz short loc_1280
loc_129E:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_12C5
add rsp, 410h
mov eax, r9d
pop rbx
retn
loc_12C0:
xor r9d, r9d
jmp short loc_129E
loc_12C5:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
int v1; // eax
unsigned int v2; // r9d
int v3; // esi
long long v4; // r8
long long v5; // rdx
int v6; // eax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
v1 = strlen(a1);
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = 0;
v3 = 0;
v4 = (long long)&a1[v1 - 1 + 1];
do
{
v5 = *a1;
v6 = v8[v5] + 1;
v8[v5] = v6;
if ( v6 > v3 )
{
v2 = v5;
v3 = v6;
}
++a1;
}
while ( a1 != (unsigned __int8 *)v4 );
}
return v2;
} | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001012c0
SUB EAX,0x1
MOV RDI,RBX
XOR R9D,R9D
XOR ESI,ESI
LEA R8,[RBX + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00101280:
MOVZX EDX,byte ptr [RDI]
MOV EAX,dword ptr [RSP + RDX*0x4]
ADD EAX,0x1
MOV dword ptr [RSP + RDX*0x4],EAX
CMP EAX,ESI
JLE 0x00101295
MOV R9D,EDX
MOV ESI,EAX
LAB_00101295:
ADD RDI,0x1
CMP RDI,R8
JNZ 0x00101280
LAB_0010129e:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012c5
ADD RSP,0x410
MOV EAX,R9D
POP RBX
RET
LAB_001012c0:
XOR R9D,R9D
JMP 0x0010129e
LAB_001012c5:
CALL 0x00101080 | byte func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
int iVar3;
size_t sVar4;
long lVar5;
int iVar6;
int *piVar7;
byte bVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
*(int8 *)piVar7 = 0;
piVar7 = (int *)((long)piVar7 + 8);
}
sVar4 = strlen((char *)param_1);
if ((int)sVar4 < 1) {
bVar8 = 0;
}
else {
bVar8 = 0;
iVar6 = 0;
pbVar1 = param_1 + (ulong)((int)sVar4 - 1) + 1;
do {
bVar2 = *param_1;
iVar3 = aiStack_418[bVar2] + 1;
aiStack_418[bVar2] = iVar3;
if (iVar6 < iVar3) {
iVar6 = iVar3;
bVar8 = bVar2;
}
param_1 = param_1 + 1;
} while (param_1 != pbVar1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar8;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,643 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
max_freq = frequency[(unsigned char)str1[i]];
max_char = str1[i];
}
}
return max_char;
}
| int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
callq 1070 <strlen@plt>
test %eax,%eax
jle 12c0 <func0+0x90>
sub $0x1,%eax
mov %rbx,%rdi
xor %r9d,%r9d
xor %esi,%esi
lea 0x1(%rbx,%rax,1),%r8
nopl 0x0(%rax)
movzbl (%rdi),%edx
mov (%rsp,%rdx,4),%eax
add $0x1,%eax
mov %eax,(%rsp,%rdx,4)
cmp %eax,%esi
jge 1295 <func0+0x65>
mov %edx,%r9d
mov %eax,%esi
add $0x1,%rdi
cmp %rdi,%r8
jne 1280 <func0+0x50>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 12c5 <func0+0x95>
add $0x410,%rsp
mov %r9d,%eax
pop %rbx
retq
nopl (%rax)
xor %r9d,%r9d
jmp 129e <func0+0x6e>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx; s
call _strlen
test eax, eax
jle short loc_12C0
sub eax, 1
mov rdi, rbx
xor r9d, r9d
xor esi, esi
lea r8, [rbx+rax+1]
nop dword ptr [rax+00000000h]
loc_1280:
movzx edx, byte ptr [rdi]
mov eax, [rsp+rdx*4+418h+var_418]
add eax, 1
mov [rsp+rdx*4+418h+var_418], eax
cmp esi, eax
jge short loc_1295
mov r9d, edx
mov esi, eax
loc_1295:
add rdi, 1
cmp r8, rdi
jnz short loc_1280
loc_129E:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_12C5
add rsp, 410h
mov eax, r9d
pop rbx
retn
loc_12C0:
xor r9d, r9d
jmp short loc_129E
loc_12C5:
call ___stack_chk_fail | long long func0(char *s)
{
int v1; // eax
unsigned int v2; // r9d
int v3; // esi
char *v4; // r8
long long v5; // rdx
int v6; // eax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
v1 = strlen(s);
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = 0;
v3 = 0;
v4 = &s[v1 - 1 + 1];
do
{
v5 = (unsigned __int8)*s;
v6 = v8[v5] + 1;
v8[v5] = v6;
if ( v3 < v6 )
{
v2 = v5;
v3 = v6;
}
++s;
}
while ( v4 != s );
}
return v2;
} | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001012c0
SUB EAX,0x1
MOV RDI,RBX
XOR R9D,R9D
XOR ESI,ESI
LEA R8,[RBX + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00101280:
MOVZX EDX,byte ptr [RDI]
MOV EAX,dword ptr [RSP + RDX*0x4]
ADD EAX,0x1
MOV dword ptr [RSP + RDX*0x4],EAX
CMP ESI,EAX
JGE 0x00101295
MOV R9D,EDX
MOV ESI,EAX
LAB_00101295:
ADD RDI,0x1
CMP R8,RDI
JNZ 0x00101280
LAB_0010129e:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012c5
ADD RSP,0x410
MOV EAX,R9D
POP RBX
RET
LAB_001012c0:
XOR R9D,R9D
JMP 0x0010129e
LAB_001012c5:
CALL 0x00101080 | byte func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
int iVar3;
size_t sVar4;
long lVar5;
int iVar6;
int *piVar7;
byte bVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
*(int8 *)piVar7 = 0;
piVar7 = (int *)((long)piVar7 + 8);
}
sVar4 = strlen((char *)param_1);
if ((int)sVar4 < 1) {
bVar8 = 0;
}
else {
bVar8 = 0;
iVar6 = 0;
pbVar1 = param_1 + (ulong)((int)sVar4 - 1) + 1;
do {
bVar2 = *param_1;
iVar3 = aiStack_418[bVar2] + 1;
aiStack_418[bVar2] = iVar3;
if (iVar6 < iVar3) {
iVar6 = iVar3;
bVar8 = bVar2;
}
param_1 = param_1 + 1;
} while (pbVar1 != param_1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar8;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,644 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C[k] ? B[j] : C[k]);
int maximum = A[i] > B[j] ? (A[i] > C[k] ? A[i] : C[k]) : (B[j] > C[k] ? B[j] : C[k]);
if (maximum - minimum < diff) {
res_i = i;
res_j = j;
res_k = k;
diff = maximum - minimum;
}
if (diff == 0) {
break;
}
if (A[i] == minimum) {
i++;
} else if (B[j] == minimum) {
j++;
} else {
k++;
}
}
res[0] = A[res_i];
res[1] = B[res_j];
res[2] = C[res_k];
}
| int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22 && res[2] == 23);
func0((int[]){2, 5, 11}, (int[]){3, 16, 21}, (int[]){11, 13}, 3, 3, 2, res);
assert(res[0] == 11 && res[1] == 16 && res[2] == 11);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x4c(%rbp)
mov %r8d,-0x50(%rbp)
mov %r9d,-0x54(%rbp)
movl $0x7fffffff,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 135e <func0+0x1f5>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 1221 <func0+0xb8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
cmovle %edx,%eax
jmp 1252 <func0+0xe9>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
cmovle %edx,%eax
mov %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 12b8 <func0+0x14f>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
cmovge %edx,%eax
jmp 12e9 <func0+0x180>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x40(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
cmovge %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
sub -0x8(%rbp),%eax
cmp %eax,-0x24(%rbp)
jle 1312 <func0+0x1a9>
mov -0x14(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x10(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0xc(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x4(%rbp),%eax
sub -0x8(%rbp),%eax
mov %eax,-0x24(%rbp)
cmpl $0x0,-0x24(%rbp)
je 137c <func0+0x213>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jne 1339 <func0+0x1d0>
addl $0x1,-0x14(%rbp)
jmp 135e <func0+0x1f5>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jne 135a <func0+0x1f1>
addl $0x1,-0x10(%rbp)
jmp 135e <func0+0x1f5>
addl $0x1,-0xc(%rbp)
mov -0x14(%rbp),%eax
cmp -0x4c(%rbp),%eax
jge 137d <func0+0x214>
mov -0x10(%rbp),%eax
cmp -0x50(%rbp),%eax
jge 137d <func0+0x214>
mov -0xc(%rbp),%eax
cmp -0x54(%rbp),%eax
jl 11be <func0+0x55>
jmp 137d <func0+0x214>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov 0x10(%rbp),%rax
mov %edx,(%rax)
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov 0x10(%rbp),%rdx
add $0x4,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov 0x10(%rbp),%rdx
add $0x8,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov [rbp+var_4C], ecx
mov [rbp+var_50], r8d
mov [rbp+var_54], r9d
mov [rbp+var_24], 7FFFFFFFh
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_135E
loc_11BE:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_1221
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
cmovle eax, edx
jmp short loc_1252
loc_1221:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
cmovle eax, edx
loc_1252:
mov [rbp+var_8], eax
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_12B8
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
cmovge eax, edx
jmp short loc_12E9
loc_12B8:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rcx
mov eax, [rax]
cmp edx, eax
cmovge eax, edx
loc_12E9:
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
sub eax, [rbp+var_8]
cmp [rbp+var_24], eax
jle short loc_1312
mov eax, [rbp+var_14]
mov [rbp+var_20], eax
mov eax, [rbp+var_10]
mov [rbp+var_1C], eax
mov eax, [rbp+var_C]
mov [rbp+var_18], eax
mov eax, [rbp+var_4]
sub eax, [rbp+var_8]
mov [rbp+var_24], eax
loc_1312:
cmp [rbp+var_24], 0
jz short loc_137C
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_8], eax
jnz short loc_1339
add [rbp+var_14], 1
jmp short loc_135E
loc_1339:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_8], eax
jnz short loc_135A
add [rbp+var_10], 1
jmp short loc_135E
loc_135A:
add [rbp+var_C], 1
loc_135E:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_4C]
jge short loc_137D
mov eax, [rbp+var_10]
cmp eax, [rbp+var_50]
jge short loc_137D
mov eax, [rbp+var_C]
cmp eax, [rbp+var_54]
jl loc_11BE
jmp short loc_137D
loc_137C:
nop
loc_137D:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+arg_0]
mov [rax], edx
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov rdx, [rbp+arg_0]
add rdx, 4
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov rdx, [rbp+arg_0]
add rdx, 8
mov eax, [rax]
mov [rdx], eax
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6, _DWORD *a7)
{
int v7; // eax
int v8; // eax
long long result; // rax
int v10; // [rsp+30h] [rbp-24h]
int v11; // [rsp+34h] [rbp-20h]
int v12; // [rsp+38h] [rbp-1Ch]
int v13; // [rsp+3Ch] [rbp-18h]
int v14; // [rsp+40h] [rbp-14h]
int v15; // [rsp+44h] [rbp-10h]
int v16; // [rsp+48h] [rbp-Ch]
int v17; // [rsp+4Ch] [rbp-8h]
v10 = 0x7FFFFFFF;
v11 = 0;
v12 = 0;
v13 = 0;
v14 = 0;
v15 = 0;
v16 = 0;
while ( v14 < a4 && v15 < a5 && v16 < a6 )
{
if ( *(_DWORD *)(4LL * v14 + a1) >= *(_DWORD *)(4LL * v15 + a2) )
{
v7 = *(_DWORD *)(4LL * v15 + a2);
if ( *(_DWORD *)(4LL * v16 + a3) <= v7 )
v7 = *(_DWORD *)(4LL * v16 + a3);
}
else
{
v7 = *(_DWORD *)(4LL * v14 + a1);
if ( *(_DWORD *)(4LL * v16 + a3) <= v7 )
v7 = *(_DWORD *)(4LL * v16 + a3);
}
v17 = v7;
if ( *(_DWORD *)(4LL * v14 + a1) <= *(_DWORD *)(4LL * v15 + a2) )
{
v8 = *(_DWORD *)(4LL * v15 + a2);
if ( *(_DWORD *)(4LL * v16 + a3) >= v8 )
v8 = *(_DWORD *)(4LL * v16 + a3);
}
else
{
v8 = *(_DWORD *)(4LL * v14 + a1);
if ( *(_DWORD *)(4LL * v16 + a3) >= v8 )
v8 = *(_DWORD *)(4LL * v16 + a3);
}
if ( v10 > v8 - v17 )
{
v11 = v14;
v12 = v15;
v13 = v16;
v10 = v8 - v17;
}
if ( !v10 )
break;
if ( v17 == *(_DWORD *)(4LL * v14 + a1) )
{
++v14;
}
else if ( v17 == *(_DWORD *)(4LL * v15 + a2) )
{
++v15;
}
else
{
++v16;
}
}
*a7 = *(_DWORD *)(4LL * v11 + a1);
a7[1] = *(_DWORD *)(4LL * v12 + a2);
result = *(unsigned int *)(4LL * v13 + a3);
a7[2] = result;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x4c],ECX
MOV dword ptr [RBP + -0x50],R8D
MOV dword ptr [RBP + -0x54],R9D
MOV dword ptr [RBP + -0x24],0x7fffffff
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010135e
LAB_001011be:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x00101221
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
CMOVLE EAX,EDX
JMP 0x00101252
LAB_00101221:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
CMOVLE EAX,EDX
LAB_00101252:
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001012b8
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
CMOVGE EAX,EDX
JMP 0x001012e9
LAB_001012b8:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
CMOVGE EAX,EDX
LAB_001012e9:
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,dword ptr [RBP + -0x8]
CMP dword ptr [RBP + -0x24],EAX
JLE 0x00101312
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x24],EAX
LAB_00101312:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0010137c
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x8],EAX
JNZ 0x00101339
ADD dword ptr [RBP + -0x14],0x1
JMP 0x0010135e
LAB_00101339:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x8],EAX
JNZ 0x0010135a
ADD dword ptr [RBP + -0x10],0x1
JMP 0x0010135e
LAB_0010135a:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010135e:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x4c]
JGE 0x0010137d
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x50]
JGE 0x0010137d
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x54]
JL 0x001011be
JMP 0x0010137d
LAB_0010137c:
NOP
LAB_0010137d:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV RDX,qword ptr [RBP + 0x10]
ADD RDX,0x4
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV RDX,qword ptr [RBP + 0x10]
ADD RDX,0x8
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,int param_4,int param_5,int param_6,
int4 *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
local_2c = 0x7fffffff;
local_28 = 0;
local_24 = 0;
local_20 = 0;
local_1c = 0;
local_18 = 0;
local_14 = 0;
while (((local_1c < param_4 && (local_18 < param_5)) && (local_14 < param_6))) {
if (*(int *)(param_1 + (long)local_1c * 4) < *(int *)(param_2 + (long)local_18 * 4)) {
iVar1 = *(int *)(param_3 + (long)local_14 * 4);
iVar2 = *(int *)(param_1 + (long)local_1c * 4);
if (iVar1 <= iVar2) {
iVar2 = iVar1;
}
}
else {
iVar1 = *(int *)(param_3 + (long)local_14 * 4);
iVar2 = *(int *)(param_2 + (long)local_18 * 4);
if (iVar1 <= iVar2) {
iVar2 = iVar1;
}
}
if (*(int *)(param_2 + (long)local_18 * 4) < *(int *)(param_1 + (long)local_1c * 4)) {
iVar1 = *(int *)(param_3 + (long)local_14 * 4);
iVar3 = *(int *)(param_1 + (long)local_1c * 4);
if (iVar3 <= iVar1) {
iVar3 = iVar1;
}
}
else {
iVar1 = *(int *)(param_3 + (long)local_14 * 4);
iVar3 = *(int *)(param_2 + (long)local_18 * 4);
if (iVar3 <= iVar1) {
iVar3 = iVar1;
}
}
if (iVar3 - iVar2 < local_2c) {
local_28 = local_1c;
local_24 = local_18;
local_20 = local_14;
local_2c = iVar3 - iVar2;
}
if (local_2c == 0) break;
if (iVar2 == *(int *)(param_1 + (long)local_1c * 4)) {
local_1c = local_1c + 1;
}
else if (iVar2 == *(int *)(param_2 + (long)local_18 * 4)) {
local_18 = local_18 + 1;
}
else {
local_14 = local_14 + 1;
}
}
*param_7 = *(int4 *)(param_1 + (long)local_28 * 4);
param_7[1] = *(int4 *)(param_2 + (long)local_24 * 4);
param_7[2] = *(int4 *)(param_3 + (long)local_20 * 4);
return;
} |
7,645 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C[k] ? B[j] : C[k]);
int maximum = A[i] > B[j] ? (A[i] > C[k] ? A[i] : C[k]) : (B[j] > C[k] ? B[j] : C[k]);
if (maximum - minimum < diff) {
res_i = i;
res_j = j;
res_k = k;
diff = maximum - minimum;
}
if (diff == 0) {
break;
}
if (A[i] == minimum) {
i++;
} else if (B[j] == minimum) {
j++;
} else {
k++;
}
}
res[0] = A[res_i];
res[1] = B[res_j];
res[2] = C[res_k];
}
| int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22 && res[2] == 23);
func0((int[]){2, 5, 11}, (int[]){3, 16, 21}, (int[]){11, 13}, 3, 3, 2, res);
assert(res[0] == 11 && res[1] == 16 && res[2] == 11);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov 0x38(%rsp),%r15
test %r8d,%r8d
setg %r10b
test %r9d,%r9d
setg %al
test %al,%r10b
je 1277 <func0+0x10e>
test %ecx,%ecx
jle 1277 <func0+0x10e>
mov $0x0,%ebx
mov $0x0,%r13d
mov $0x0,%r12d
movl $0x0,-0x4(%rsp)
movl $0x0,-0x8(%rsp)
movl $0x0,-0xc(%rsp)
mov $0x7fffffff,%r14d
jmp 122f <func0+0xc6>
movslq %ebx,%rax
mov (%rdx,%rax,4),%eax
cmp %eax,%r11d
mov %eax,%ebp
cmovle %r11d,%ebp
cmp %r11d,%r10d
jle 1250 <func0+0xe7>
cmp %eax,%r10d
cmovge %r10d,%eax
sub %ebp,%eax
cmp %r14d,%eax
jge 11fe <func0+0x95>
mov %ebx,-0x4(%rsp)
mov %r13d,-0x8(%rsp)
mov %r12d,-0xc(%rsp)
mov %eax,%r14d
test %r14d,%r14d
je 1291 <func0+0x128>
cmp %ebp,%r10d
je 1264 <func0+0xfb>
cmp %ebp,%r11d
je 126a <func0+0x101>
add $0x1,%ebx
cmp %ecx,%r12d
setl %r10b
cmp %r13d,%r8d
setg %al
test %al,%r10b
je 12c4 <func0+0x15b>
cmp %ebx,%r9d
jle 1270 <func0+0x107>
movslq %r12d,%rax
mov (%rdi,%rax,4),%r10d
movslq %r13d,%rax
mov (%rsi,%rax,4),%r11d
cmp %r11d,%r10d
jge 11cb <func0+0x62>
movslq %ebx,%rax
cmp %r10d,(%rdx,%rax,4)
mov %r10d,%ebp
cmovle (%rdx,%rax,4),%ebp
movslq %ebx,%rax
cmp %r11d,(%rdx,%rax,4)
mov %r11d,%r15d
cmovge (%rdx,%rax,4),%r15d
mov %r15d,%eax
jmp 11e6 <func0+0x7d>
add $0x1,%r12d
jmp 1214 <func0+0xab>
add $0x1,%r13d
jmp 1214 <func0+0xab>
mov 0x38(%rsp),%r15
jmp 1296 <func0+0x12d>
movl $0x0,-0x4(%rsp)
movl $0x0,-0x8(%rsp)
movl $0x0,-0xc(%rsp)
jmp 1296 <func0+0x12d>
mov 0x38(%rsp),%r15
movslq -0xc(%rsp),%rax
mov (%rdi,%rax,4),%eax
mov %eax,(%r15)
movslq -0x8(%rsp),%rax
mov (%rsi,%rax,4),%eax
mov %eax,0x4(%r15)
movslq -0x4(%rsp),%rax
mov (%rdx,%rax,4),%eax
mov %eax,0x8(%r15)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov 0x38(%rsp),%r15
jmp 1296 <func0+0x12d>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13, rsi
mov rbp, rdx
mov r15, [rsp+30h+arg_0]
test r8d, r8d
setnle dl
test r9d, r9d
setnle al
test dl, al
jz loc_125E
mov r14d, ecx
test ecx, ecx
jle loc_125E
mov edi, 0
mov r11d, 0
mov r10d, 0
mov [rsp+30h+var_34], 0
mov [rsp+30h+var_38], 0
mov [rsp+30h+var_3C], 0
mov ebx, 7FFFFFFFh
jmp short loc_1225
loc_11D4:
movsxd rax, edi
mov eax, [rbp+rax*4+0]
cmp ecx, eax
mov esi, eax
cmovle esi, ecx
cmp edx, ecx
jle short loc_1244
cmp edx, eax
cmovge eax, edx
loc_11EB:
sub eax, esi
cmp eax, ebx
jge short loc_1201
mov [rsp+30h+var_34], edi
mov [rsp+30h+var_38], r11d
mov [rsp+30h+var_3C], r10d
mov ebx, eax
loc_1201:
test ebx, ebx
jz short loc_1276
cmp edx, esi
jz short loc_1252
cmp ecx, esi
jz short loc_1258
add edi, 1
loc_1210:
cmp r10d, r14d
setl dl
cmp r8d, r11d
setnle al
test dl, al
jz short loc_1276
cmp r9d, edi
jle short loc_1276
loc_1225:
movsxd rax, r10d
mov edx, [r12+rax*4]
movsxd rax, r11d
mov ecx, [r13+rax*4+0]
cmp edx, ecx
jge short loc_11D4
movsxd rax, edi
mov esi, [rbp+rax*4+0]
cmp edx, esi
cmovle esi, edx
loc_1244:
movsxd rax, edi
mov eax, [rbp+rax*4+0]
cmp ecx, eax
cmovge eax, ecx
jmp short loc_11EB
loc_1252:
add r10d, 1
jmp short loc_1210
loc_1258:
add r11d, 1
jmp short loc_1210
loc_125E:
mov [rsp+30h+var_34], 0
mov [rsp+30h+var_38], 0
mov [rsp+30h+var_3C], 0
loc_1276:
movsxd rax, [rsp+30h+var_3C]
mov eax, [r12+rax*4]
mov [r15], eax
movsxd rax, [rsp+30h+var_38]
mov eax, [r13+rax*4+0]
mov [r15+4], eax
movsxd rax, [rsp+30h+var_34]
mov eax, [rbp+rax*4+0]
mov [r15+8], eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6, _DWORD *a7)
{
int v11; // edi
int v12; // r11d
int v13; // r10d
int v14; // ebx
int v15; // eax
int v16; // esi
int v17; // eax
int v18; // edx
int v19; // ecx
long long result; // rax
int v21; // [rsp+0h] [rbp-3Ch]
int v22; // [rsp+4h] [rbp-38h]
int v23; // [rsp+8h] [rbp-34h]
if ( a6 > 0 && a5 > 0 && a4 > 0 )
{
v11 = 0;
v12 = 0;
v13 = 0;
v23 = 0;
v22 = 0;
v21 = 0;
v14 = 0x7FFFFFFF;
while ( 1 )
{
v18 = *(_DWORD *)(a1 + 4LL * v13);
v19 = *(_DWORD *)(a2 + 4LL * v12);
if ( v18 >= v19 )
{
v15 = *(_DWORD *)(a3 + 4LL * v11);
v16 = v15;
if ( v19 <= v15 )
v16 = *(_DWORD *)(a2 + 4LL * v12);
if ( v18 > v19 )
{
if ( v18 >= v15 )
v15 = *(_DWORD *)(a1 + 4LL * v13);
goto LABEL_9;
}
}
else
{
v16 = *(_DWORD *)(a3 + 4LL * v11);
if ( v18 <= v16 )
v16 = *(_DWORD *)(a1 + 4LL * v13);
}
v15 = *(_DWORD *)(a3 + 4LL * v11);
if ( v19 >= v15 )
v15 = *(_DWORD *)(a2 + 4LL * v12);
LABEL_9:
v17 = v15 - v16;
if ( v17 < v14 )
{
v23 = v11;
v22 = v12;
v21 = v13;
v14 = v17;
}
if ( v14 )
{
if ( v18 == v16 )
{
++v13;
}
else if ( v19 == v16 )
{
++v12;
}
else
{
++v11;
}
if ( a5 > v12 && v13 < a4 && a6 > v11 )
continue;
}
goto LABEL_26;
}
}
v23 = 0;
v22 = 0;
v21 = 0;
LABEL_26:
*a7 = *(_DWORD *)(a1 + 4LL * v21);
a7[1] = *(_DWORD *)(a2 + 4LL * v22);
result = *(unsigned int *)(a3 + 4LL * v23);
a7[2] = result;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13,RSI
MOV RBP,RDX
MOV R15,qword ptr [RSP + 0x38]
TEST R8D,R8D
SETG DL
TEST R9D,R9D
SETG AL
TEST DL,AL
JZ 0x0010125e
MOV R14D,ECX
TEST ECX,ECX
JLE 0x0010125e
MOV EDI,0x0
MOV R11D,0x0
MOV R10D,0x0
MOV dword ptr [RSP + -0x4],0x0
MOV dword ptr [RSP + -0x8],0x0
MOV dword ptr [RSP + -0xc],0x0
MOV EBX,0x7fffffff
JMP 0x00101225
LAB_001011d4:
MOVSXD RAX,EDI
MOV EAX,dword ptr [RBP + RAX*0x4]
CMP ECX,EAX
MOV ESI,EAX
CMOVLE ESI,ECX
CMP EDX,ECX
JLE 0x00101244
CMP EDX,EAX
CMOVGE EAX,EDX
LAB_001011eb:
SUB EAX,ESI
CMP EAX,EBX
JGE 0x00101201
MOV dword ptr [RSP + -0x4],EDI
MOV dword ptr [RSP + -0x8],R11D
MOV dword ptr [RSP + -0xc],R10D
MOV EBX,EAX
LAB_00101201:
TEST EBX,EBX
JZ 0x00101276
CMP EDX,ESI
JZ 0x00101252
CMP ECX,ESI
JZ 0x00101258
ADD EDI,0x1
LAB_00101210:
CMP R10D,R14D
SETL DL
CMP R8D,R11D
SETG AL
TEST DL,AL
JZ 0x00101276
CMP R9D,EDI
JLE 0x00101276
LAB_00101225:
MOVSXD RAX,R10D
MOV EDX,dword ptr [R12 + RAX*0x4]
MOVSXD RAX,R11D
MOV ECX,dword ptr [R13 + RAX*0x4]
CMP EDX,ECX
JGE 0x001011d4
MOVSXD RAX,EDI
MOV ESI,dword ptr [RBP + RAX*0x4]
CMP EDX,ESI
CMOVLE ESI,EDX
LAB_00101244:
MOVSXD RAX,EDI
MOV EAX,dword ptr [RBP + RAX*0x4]
CMP ECX,EAX
CMOVGE EAX,ECX
JMP 0x001011eb
LAB_00101252:
ADD R10D,0x1
JMP 0x00101210
LAB_00101258:
ADD R11D,0x1
JMP 0x00101210
LAB_0010125e:
MOV dword ptr [RSP + -0x4],0x0
MOV dword ptr [RSP + -0x8],0x0
MOV dword ptr [RSP + -0xc],0x0
LAB_00101276:
MOVSXD RAX,dword ptr [RSP + -0xc]
MOV EAX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [R15],EAX
MOVSXD RAX,dword ptr [RSP + -0x8]
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV dword ptr [R15 + 0x4],EAX
MOVSXD RAX,dword ptr [RSP + -0x4]
MOV EAX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [R15 + 0x8],EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(long param_1,long param_2,long param_3,int param_4,int param_5,int param_6,
int4 *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int local_3c;
int local_38;
int local_34;
if ((0 < param_5 && 0 < param_6) && (0 < param_4)) {
iVar6 = 0;
iVar8 = 0;
iVar7 = 0;
local_34 = 0;
local_38 = 0;
local_3c = 0;
iVar4 = 0x7fffffff;
do {
iVar1 = *(int *)(param_1 + (long)iVar7 * 4);
iVar2 = *(int *)(param_2 + (long)iVar8 * 4);
if (iVar1 < iVar2) {
iVar5 = *(int *)(param_3 + (long)iVar6 * 4);
if (iVar1 <= iVar5) {
iVar5 = iVar1;
}
LAB_00101244:
iVar3 = *(int *)(param_3 + (long)iVar6 * 4);
if (iVar3 <= iVar2) {
iVar3 = iVar2;
}
}
else {
iVar3 = *(int *)(param_3 + (long)iVar6 * 4);
iVar5 = iVar3;
if (iVar2 <= iVar3) {
iVar5 = iVar2;
}
if (iVar1 <= iVar2) goto LAB_00101244;
if (iVar3 <= iVar1) {
iVar3 = iVar1;
}
}
if (iVar3 - iVar5 < iVar4) {
iVar4 = iVar3 - iVar5;
local_3c = iVar7;
local_38 = iVar8;
local_34 = iVar6;
}
if (iVar4 == 0) goto LAB_00101276;
if (iVar1 == iVar5) {
iVar7 = iVar7 + 1;
}
else if (iVar2 == iVar5) {
iVar8 = iVar8 + 1;
}
else {
iVar6 = iVar6 + 1;
}
if ((param_4 <= iVar7 || param_5 <= iVar8) || (param_6 <= iVar6)) goto LAB_00101276;
} while( true );
}
local_34 = 0;
local_38 = 0;
local_3c = 0;
LAB_00101276:
*param_7 = *(int4 *)(param_1 + (long)local_3c * 4);
param_7[1] = *(int4 *)(param_2 + (long)local_38 * 4);
param_7[2] = *(int4 *)(param_3 + (long)local_34 * 4);
return;
} |
7,646 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C[k] ? B[j] : C[k]);
int maximum = A[i] > B[j] ? (A[i] > C[k] ? A[i] : C[k]) : (B[j] > C[k] ? B[j] : C[k]);
if (maximum - minimum < diff) {
res_i = i;
res_j = j;
res_k = k;
diff = maximum - minimum;
}
if (diff == 0) {
break;
}
if (A[i] == minimum) {
i++;
} else if (B[j] == minimum) {
j++;
} else {
k++;
}
}
res[0] = A[res_i];
res[1] = B[res_j];
res[2] = C[res_k];
}
| int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22 && res[2] == 23);
func0((int[]){2, 5, 11}, (int[]){3, 16, 21}, (int[]){11, 13}, 3, 3, 2, res);
assert(res[0] == 11 && res[1] == 16 && res[2] == 11);
return 0;
}
| O2 | c | func0:
endbr64
mov %r9d,%eax
push %r15
test %eax,%eax
push %r14
push %r13
setg %r10b
test %r8d,%r8d
push %r12
setg %al
push %rbp
push %rbx
mov %r9d,-0x10(%rsp)
mov (%rdi),%r9d
test %al,%r10b
je 1510 <func0+0x140>
test %ecx,%ecx
jle 1510 <func0+0x140>
movl $0x0,-0x4(%rsp)
xor %ebx,%ebx
xor %r12d,%r12d
xor %ebp,%ebp
movl $0x0,-0xc(%rsp)
mov $0x7fffffff,%r15d
movl $0x0,-0x8(%rsp)
jmp 148c <func0+0xbc>
nopl (%rax)
cmp %r9d,%eax
mov %r9d,%r11d
cmovle %eax,%r11d
cmp %eax,%r10d
cmovge %r10d,%eax
sub %r11d,%eax
cmp %r15d,%eax
jge 1461 <func0+0x91>
test %eax,%eax
je 14eb <func0+0x11b>
mov %ebx,-0x4(%rsp)
mov %eax,%r15d
mov %r12d,-0xc(%rsp)
mov %ebp,-0x8(%rsp)
cmp %r9d,%r11d
je 14c0 <func0+0xf0>
cmp %r11d,%r10d
je 14c8 <func0+0xf8>
add $0x1,%ebx
cmp %ebp,%ecx
setg %r9b
cmp %r8d,%r12d
setl %al
test %al,%r9b
je 14d0 <func0+0x100>
cmp -0x10(%rsp),%ebx
jge 14d0 <func0+0x100>
movslq %ebp,%rax
mov (%rdi,%rax,4),%r9d
movslq %r12d,%rax
lea (%rsi,%rax,4),%r14
movslq %ebx,%rax
mov (%r14),%r10d
lea (%rdx,%rax,4),%r13
mov 0x0(%r13),%eax
cmp %r9d,%r10d
jg 1430 <func0+0x60>
cmp %eax,%r10d
mov %eax,%r11d
cmovle %r10d,%r11d
cmp %r9d,%r10d
jge 143a <func0+0x6a>
cmp %r9d,%eax
cmovl %r9d,%eax
jmp 1441 <func0+0x71>
xchg %ax,%ax
add $0x1,%ebp
jmp 146e <func0+0x9e>
nopl (%rax)
add $0x1,%r12d
jmp 146e <func0+0x9e>
xchg %ax,%ax
movslq -0x8(%rsp),%rax
mov (%rdi,%rax,4),%r9d
movslq -0xc(%rsp),%rax
lea (%rsi,%rax,4),%r14
movslq -0x4(%rsp),%rax
lea (%rdx,%rax,4),%r13
mov 0x38(%rsp),%rax
mov 0x38(%rsp),%rcx
mov %r9d,(%rax)
mov (%r14),%eax
mov %eax,0x4(%rcx)
mov 0x0(%r13),%eax
mov %eax,0x8(%rcx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rdx,%r13
mov %rsi,%r14
jmp 14eb <func0+0x11b>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
test r9d, r9d
push r14
mov r14d, ecx
setnle cl
test r8d, r8d
push r13
setnle al
mov r13, rdx
push r12
mov r12, rsi
push rbp
push rbx
mov edx, [rdi]
mov [rsp+30h+var_40], r9d
test cl, al
jz loc_1529
test r14d, r14d
jle loc_1529
mov rbp, rdi
mov [rsp+30h+var_34], 0
xor edi, edi
xor r10d, r10d
mov [rsp+30h+var_3C], 0
xor r9d, r9d
mov r15d, 7FFFFFFFh
mov [rsp+30h+var_38], 0
jmp short loc_1491
loc_1440:
cmp edx, eax
mov esi, eax
cmovle esi, edx
loc_1447:
cmp ecx, eax
cmovge eax, ecx
loc_144C:
sub eax, esi
cmp eax, r15d
jge short loc_146C
test eax, eax
jz loc_14FC
mov [rsp+30h+var_34], edi
mov r15d, eax
mov [rsp+30h+var_3C], r10d
mov [rsp+30h+var_38], r9d
loc_146C:
cmp edx, esi
jz short loc_14C8
cmp ecx, esi
jz loc_1520
add edi, 1
loc_147B:
cmp r14d, r9d
setnle dl
cmp r10d, r8d
setl al
test dl, al
jz short loc_14E0
loc_148B:
cmp edi, [rsp+30h+var_40]
jge short loc_14E0
loc_1491:
movsxd rax, r9d
mov edx, [rbp+rax*4+0]
movsxd rax, r10d
lea rbx, [r12+rax*4]
movsxd rax, edi
mov ecx, [rbx]
lea r11, [r13+rax*4+0]
mov eax, [r11]
cmp edx, ecx
jl short loc_1440
cmp ecx, eax
mov esi, eax
cmovle esi, ecx
cmp edx, ecx
jle short loc_1447
cmp edx, eax
cmovge eax, edx
jmp short loc_144C
loc_14C8:
add r9d, 1
cmp r14d, r9d
setnle dl
cmp r10d, r8d
setl al
test dl, al
jnz short loc_148B
nop dword ptr [rax+00h]
loc_14E0:
movsxd rax, [rsp+30h+var_38]
mov edx, [rbp+rax*4+0]
movsxd rax, [rsp+30h+var_3C]
lea rbx, [r12+rax*4]
movsxd rax, [rsp+30h+var_34]
lea r11, [r13+rax*4+0]
loc_14FC:
mov rax, [rsp+30h+arg_0]
mov [rax], edx
mov eax, [rbx]
mov rbx, [rsp+30h+arg_0]
mov [rbx+4], eax
mov eax, [r11]
mov [rbx+8], eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1520:
add r10d, 1
jmp loc_147B
loc_1529:
mov r11, r13
mov rbx, r12
jmp short loc_14FC | long long func0(int *a1, unsigned int *a2, unsigned int *a3, int a4, int a5, int a6, _DWORD *a7)
{
int v10; // edx
int v12; // edi
int v13; // r10d
int v14; // r9d
int v15; // r15d
unsigned int v16; // esi
signed int v17; // eax
int v18; // eax
unsigned int *v19; // rbx
int v20; // ecx
unsigned int *v21; // r11
long long result; // rax
int v24; // [rsp+4h] [rbp-3Ch]
int v25; // [rsp+8h] [rbp-38h]
int v26; // [rsp+Ch] [rbp-34h]
v10 = *a1;
if ( a5 <= 0 || a6 <= 0 || a4 <= 0 )
{
v21 = a3;
v19 = a2;
goto LABEL_25;
}
v26 = 0;
v12 = 0;
v13 = 0;
v24 = 0;
v14 = 0;
v15 = 0x7FFFFFFF;
v25 = 0;
while ( 1 )
{
v10 = a1[v14];
v19 = &a2[v13];
v20 = *v19;
v21 = &a3[v12];
v17 = *v21;
if ( v10 < (int)*v19 )
{
v16 = *v21;
if ( v10 <= v17 )
v16 = a1[v14];
}
else
{
v16 = *v21;
if ( v20 <= v17 )
v16 = *v19;
if ( v10 > v20 )
{
if ( v10 >= v17 )
v17 = a1[v14];
goto LABEL_8;
}
}
if ( v20 >= v17 )
v17 = *v19;
LABEL_8:
v18 = v17 - v16;
if ( v18 < v15 )
{
if ( !v18 )
goto LABEL_25;
v26 = v12;
v15 = v18;
v24 = v13;
v25 = v14;
}
if ( v10 != v16 )
break;
if ( ((v13 < a5) & (a4 > ++v14)) == 0 )
goto LABEL_24;
LABEL_15:
if ( v12 >= a6 )
goto LABEL_24;
}
if ( v20 == v16 )
++v13;
else
++v12;
if ( v13 < a5 && a4 > v14 )
goto LABEL_15;
LABEL_24:
v10 = a1[v25];
v19 = &a2[v24];
v21 = &a3[v26];
LABEL_25:
*a7 = v10;
a7[1] = *v19;
result = *v21;
a7[2] = result;
return result;
} | func0:
ENDBR64
PUSH R15
TEST R9D,R9D
PUSH R14
MOV R14D,ECX
SETG CL
TEST R8D,R8D
PUSH R13
SETG AL
MOV R13,RDX
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV EDX,dword ptr [RDI]
MOV dword ptr [RSP + -0x10],R9D
TEST CL,AL
JZ 0x00101529
TEST R14D,R14D
JLE 0x00101529
MOV RBP,RDI
MOV dword ptr [RSP + -0x4],0x0
XOR EDI,EDI
XOR R10D,R10D
MOV dword ptr [RSP + -0xc],0x0
XOR R9D,R9D
MOV R15D,0x7fffffff
MOV dword ptr [RSP + -0x8],0x0
JMP 0x00101491
LAB_00101440:
CMP EDX,EAX
MOV ESI,EAX
CMOVLE ESI,EDX
LAB_00101447:
CMP ECX,EAX
CMOVGE EAX,ECX
LAB_0010144c:
SUB EAX,ESI
CMP EAX,R15D
JGE 0x0010146c
TEST EAX,EAX
JZ 0x001014fc
MOV dword ptr [RSP + -0x4],EDI
MOV R15D,EAX
MOV dword ptr [RSP + -0xc],R10D
MOV dword ptr [RSP + -0x8],R9D
LAB_0010146c:
CMP EDX,ESI
JZ 0x001014c8
CMP ECX,ESI
JZ 0x00101520
ADD EDI,0x1
LAB_0010147b:
CMP R14D,R9D
SETG DL
CMP R10D,R8D
SETL AL
TEST DL,AL
JZ 0x001014e0
LAB_0010148b:
CMP EDI,dword ptr [RSP + -0x10]
JGE 0x001014e0
LAB_00101491:
MOVSXD RAX,R9D
MOV EDX,dword ptr [RBP + RAX*0x4]
MOVSXD RAX,R10D
LEA RBX,[R12 + RAX*0x4]
MOVSXD RAX,EDI
MOV ECX,dword ptr [RBX]
LEA R11,[R13 + RAX*0x4]
MOV EAX,dword ptr [R11]
CMP EDX,ECX
JL 0x00101440
CMP ECX,EAX
MOV ESI,EAX
CMOVLE ESI,ECX
CMP EDX,ECX
JLE 0x00101447
CMP EDX,EAX
CMOVGE EAX,EDX
JMP 0x0010144c
LAB_001014c8:
ADD R9D,0x1
CMP R14D,R9D
SETG DL
CMP R10D,R8D
SETL AL
TEST DL,AL
JNZ 0x0010148b
NOP dword ptr [RAX]
LAB_001014e0:
MOVSXD RAX,dword ptr [RSP + -0x8]
MOV EDX,dword ptr [RBP + RAX*0x4]
MOVSXD RAX,dword ptr [RSP + -0xc]
LEA RBX,[R12 + RAX*0x4]
MOVSXD RAX,dword ptr [RSP + -0x4]
LEA R11,[R13 + RAX*0x4]
LAB_001014fc:
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBX]
MOV RBX,qword ptr [RSP + 0x38]
MOV dword ptr [RBX + 0x4],EAX
MOV EAX,dword ptr [R11]
MOV dword ptr [RBX + 0x8],EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101520:
ADD R10D,0x1
JMP 0x0010147b
LAB_00101529:
MOV R11,R13
MOV RBX,R12
JMP 0x001014fc | void func0(int *param_1,int *param_2,int *param_3,int param_4,int param_5,int param_6,int *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int *piVar9;
int iVar10;
int local_3c;
int local_38;
int local_34;
iVar3 = *param_1;
piVar4 = param_2;
piVar9 = param_3;
if ((0 < param_6 && 0 < param_5) && (0 < param_4)) {
local_34 = 0;
iVar6 = 0;
iVar8 = 0;
local_3c = 0;
iVar7 = 0;
iVar10 = 0x7fffffff;
local_38 = 0;
do {
iVar3 = param_1[iVar7];
iVar1 = param_2[iVar8];
iVar2 = param_3[iVar6];
iVar5 = iVar2;
if (iVar3 < iVar1) {
if (iVar3 <= iVar2) {
iVar5 = iVar3;
}
LAB_00101447:
if (iVar2 <= iVar1) {
iVar2 = iVar1;
}
}
else {
if (iVar1 <= iVar2) {
iVar5 = iVar1;
}
if (iVar3 <= iVar1) goto LAB_00101447;
if (iVar2 <= iVar3) {
iVar2 = iVar3;
}
}
iVar2 = iVar2 - iVar5;
if ((iVar2 < iVar10) &&
(piVar4 = param_2 + iVar8, piVar9 = param_3 + iVar6, iVar10 = iVar2, local_3c = iVar8,
local_38 = iVar7, local_34 = iVar6, iVar2 == 0)) goto LAB_001014fc;
if (iVar3 == iVar5) {
iVar7 = iVar7 + 1;
if (param_4 <= iVar7 || param_5 <= iVar8) break;
}
else {
if (iVar1 == iVar5) {
iVar8 = iVar8 + 1;
}
else {
iVar6 = iVar6 + 1;
}
if (param_4 <= iVar7 || param_5 <= iVar8) break;
}
} while (iVar6 < param_6);
iVar3 = param_1[local_38];
piVar4 = param_2 + local_3c;
piVar9 = param_3 + local_34;
}
LAB_001014fc:
*param_7 = iVar3;
param_7[1] = *piVar4;
param_7[2] = *piVar9;
return;
} |
7,647 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C[k] ? B[j] : C[k]);
int maximum = A[i] > B[j] ? (A[i] > C[k] ? A[i] : C[k]) : (B[j] > C[k] ? B[j] : C[k]);
if (maximum - minimum < diff) {
res_i = i;
res_j = j;
res_k = k;
diff = maximum - minimum;
}
if (diff == 0) {
break;
}
if (A[i] == minimum) {
i++;
} else if (B[j] == minimum) {
j++;
} else {
k++;
}
}
res[0] = A[res_i];
res[1] = B[res_j];
res[2] = C[res_k];
}
| int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22 && res[2] == 23);
func0((int[]){2, 5, 11}, (int[]){3, 16, 21}, (int[]){11, 13}, 3, 3, 2, res);
assert(res[0] == 11 && res[1] == 16 && res[2] == 11);
return 0;
}
| O3 | c | func0:
endbr64
mov %r9d,%eax
push %r15
test %eax,%eax
push %r14
push %r13
setg %r10b
test %r8d,%r8d
push %r12
setg %al
push %rbp
push %rbx
mov %r9d,-0x10(%rsp)
mov (%rdi),%r9d
test %al,%r10b
je 14f0 <func0+0x140>
test %ecx,%ecx
jle 14f0 <func0+0x140>
movl $0x0,-0x4(%rsp)
xor %ebx,%ebx
xor %r12d,%r12d
xor %ebp,%ebp
movl $0x0,-0xc(%rsp)
mov $0x7fffffff,%r15d
movl $0x0,-0x8(%rsp)
jmp 146c <func0+0xbc>
nopl (%rax)
cmp %r9d,%eax
mov %r9d,%r11d
cmovle %eax,%r11d
cmp %eax,%r10d
cmovge %r10d,%eax
sub %r11d,%eax
cmp %r15d,%eax
jge 1441 <func0+0x91>
test %eax,%eax
je 14cb <func0+0x11b>
mov %ebx,-0x4(%rsp)
mov %eax,%r15d
mov %r12d,-0xc(%rsp)
mov %ebp,-0x8(%rsp)
cmp %r9d,%r11d
je 14a0 <func0+0xf0>
cmp %r11d,%r10d
je 14a8 <func0+0xf8>
add $0x1,%ebx
cmp %ebp,%ecx
setg %r9b
cmp %r8d,%r12d
setl %al
test %al,%r9b
je 14b0 <func0+0x100>
cmp -0x10(%rsp),%ebx
jge 14b0 <func0+0x100>
movslq %ebp,%rax
mov (%rdi,%rax,4),%r9d
movslq %r12d,%rax
lea (%rsi,%rax,4),%r14
movslq %ebx,%rax
mov (%r14),%r10d
lea (%rdx,%rax,4),%r13
mov 0x0(%r13),%eax
cmp %r9d,%r10d
jg 1410 <func0+0x60>
cmp %eax,%r10d
mov %eax,%r11d
cmovle %r10d,%r11d
cmp %r9d,%r10d
jge 141a <func0+0x6a>
cmp %r9d,%eax
cmovl %r9d,%eax
jmp 1421 <func0+0x71>
xchg %ax,%ax
add $0x1,%ebp
jmp 144e <func0+0x9e>
nopl (%rax)
add $0x1,%r12d
jmp 144e <func0+0x9e>
xchg %ax,%ax
movslq -0x8(%rsp),%rax
mov (%rdi,%rax,4),%r9d
movslq -0xc(%rsp),%rax
lea (%rsi,%rax,4),%r14
movslq -0x4(%rsp),%rax
lea (%rdx,%rax,4),%r13
mov 0x38(%rsp),%rax
mov 0x38(%rsp),%rcx
mov %r9d,(%rax)
mov (%r14),%eax
mov %eax,0x4(%rcx)
mov 0x0(%r13),%eax
mov %eax,0x8(%rcx)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rdx,%r13
mov %rsi,%r14
jmp 14cb <func0+0x11b>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
test r9d, r9d
push r14
mov r14, rdx
push r13
mov r13, rsi
setnle sil
test r8d, r8d
push r12
push rbp
push rbx
mov ebx, ecx
mov rax, [rsp+30h+arg_0]
mov edx, [rdi]
mov [rsp+30h+var_40], ecx
setnle cl
test sil, cl
jz loc_14F7
test ebx, ebx
jle loc_14F7
mov r12, rdi
mov [rsp+30h+var_34], 0
xor edi, edi
xor r11d, r11d
mov [rsp+30h+var_38], 0
xor r10d, r10d
mov r15d, 7FFFFFFFh
mov [rsp+30h+var_3C], 0
jmp short loc_145E
loc_1410:
cmp edx, eax
mov esi, eax
cmovle esi, edx
loc_1417:
cmp ecx, eax
cmovge eax, ecx
loc_141C:
sub eax, esi
cmp r15d, eax
jle short loc_143C
test eax, eax
jz loc_14F0
mov [rsp+30h+var_34], edi
mov r15d, eax
mov [rsp+30h+var_38], r11d
mov [rsp+30h+var_3C], r10d
loc_143C:
cmp edx, esi
jz short loc_1490
cmp ecx, esi
jz short loc_14A0
add edi, 1
loc_1447:
cmp [rsp+30h+var_40], r10d
setnle dl
cmp r11d, r8d
setl al
test dl, al
jz short loc_14B0
cmp edi, r9d
jge short loc_14B0
loc_145E:
movsxd rax, r10d
mov edx, [r12+rax*4]
movsxd rax, r11d
lea rbp, [r13+rax*4+0]
movsxd rax, edi
mov ecx, [rbp+0]
lea rbx, [r14+rax*4]
mov eax, [rbx]
cmp edx, ecx
jl short loc_1410
cmp ecx, eax
mov esi, eax
cmovle esi, ecx
cmp edx, ecx
jle short loc_1417
cmp edx, eax
cmovge eax, edx
jmp short loc_141C
loc_1490:
add r10d, 1
jmp short loc_1447
loc_14A0:
add r11d, 1
jmp short loc_1447
loc_14B0:
movsxd rcx, [rsp+30h+var_38]
movsxd rdx, [rsp+30h+var_3C]
mov rax, [rsp+30h+arg_0]
lea rbp, [r13+rcx*4+0]
movsxd rcx, [rsp+30h+var_34]
mov edx, [r12+rdx*4]
lea rbx, [r14+rcx*4]
loc_14D1:
mov [rax], edx
mov edx, [rbp+0]
mov [rax+4], edx
mov edx, [rbx]
mov [rax+8], edx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14F0:
mov rax, [rsp+30h+arg_0]
jmp short loc_14D1
loc_14F7:
mov rbx, r14
mov rbp, r13
jmp short loc_14D1 | _DWORD * func0(int *a1, int *a2, int *a3, int a4, int a5, int a6, _DWORD *a7)
{
_DWORD *result; // rax
int v10; // edx
int v12; // edi
int v13; // r11d
int v14; // r10d
int v15; // r15d
int v16; // esi
int v17; // eax
int v18; // eax
int *v19; // rbp
int v20; // ecx
int *v21; // rbx
int v23; // [rsp+4h] [rbp-3Ch]
int v24; // [rsp+8h] [rbp-38h]
int v25; // [rsp+Ch] [rbp-34h]
result = a7;
v10 = *a1;
if ( a5 <= 0 || a6 <= 0 || a4 <= 0 )
{
v21 = a3;
v19 = a2;
goto LABEL_26;
}
v25 = 0;
v12 = 0;
v13 = 0;
v24 = 0;
v14 = 0;
v15 = 0x7FFFFFFF;
v23 = 0;
while ( 1 )
{
v10 = a1[v14];
v19 = &a2[v13];
v20 = *v19;
v21 = &a3[v12];
v17 = *v21;
if ( v10 < *v19 )
{
v16 = *v21;
if ( v10 <= v17 )
v16 = a1[v14];
}
else
{
v16 = *v21;
if ( v20 <= v17 )
v16 = *v19;
if ( v10 > v20 )
{
if ( v10 >= v17 )
v17 = a1[v14];
goto LABEL_8;
}
}
if ( v20 >= v17 )
v17 = *v19;
LABEL_8:
v18 = v17 - v16;
if ( v15 > v18 )
break;
LABEL_11:
if ( v10 == v16 )
{
++v14;
}
else if ( v20 == v16 )
{
++v13;
}
else
{
++v12;
}
if ( v13 >= a5 || a4 <= v14 || v12 >= a6 )
{
result = a7;
v19 = &a2[v24];
v10 = a1[v23];
v21 = &a3[v25];
goto LABEL_26;
}
}
if ( v18 )
{
v25 = v12;
v15 = v18;
v24 = v13;
v23 = v14;
goto LABEL_11;
}
result = a7;
LABEL_26:
*result = v10;
result[1] = *v19;
result[2] = *v21;
return result;
} | func0:
ENDBR64
PUSH R15
TEST R9D,R9D
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13,RSI
SETG SIL
TEST R8D,R8D
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ECX
MOV RAX,qword ptr [RSP + 0x38]
MOV EDX,dword ptr [RDI]
MOV dword ptr [RSP + -0x10],ECX
SETG CL
TEST SIL,CL
JZ 0x001014f7
TEST EBX,EBX
JLE 0x001014f7
MOV R12,RDI
MOV dword ptr [RSP + -0x4],0x0
XOR EDI,EDI
XOR R11D,R11D
MOV dword ptr [RSP + -0x8],0x0
XOR R10D,R10D
MOV R15D,0x7fffffff
MOV dword ptr [RSP + -0xc],0x0
JMP 0x0010145e
LAB_00101410:
CMP EDX,EAX
MOV ESI,EAX
CMOVLE ESI,EDX
LAB_00101417:
CMP ECX,EAX
CMOVGE EAX,ECX
LAB_0010141c:
SUB EAX,ESI
CMP R15D,EAX
JLE 0x0010143c
TEST EAX,EAX
JZ 0x001014f0
MOV dword ptr [RSP + -0x4],EDI
MOV R15D,EAX
MOV dword ptr [RSP + -0x8],R11D
MOV dword ptr [RSP + -0xc],R10D
LAB_0010143c:
CMP EDX,ESI
JZ 0x00101490
CMP ECX,ESI
JZ 0x001014a0
ADD EDI,0x1
LAB_00101447:
CMP dword ptr [RSP + -0x10],R10D
SETG DL
CMP R11D,R8D
SETL AL
TEST DL,AL
JZ 0x001014b0
CMP EDI,R9D
JGE 0x001014b0
LAB_0010145e:
MOVSXD RAX,R10D
MOV EDX,dword ptr [R12 + RAX*0x4]
MOVSXD RAX,R11D
LEA RBP,[R13 + RAX*0x4]
MOVSXD RAX,EDI
MOV ECX,dword ptr [RBP]
LEA RBX,[R14 + RAX*0x4]
MOV EAX,dword ptr [RBX]
CMP EDX,ECX
JL 0x00101410
CMP ECX,EAX
MOV ESI,EAX
CMOVLE ESI,ECX
CMP EDX,ECX
JLE 0x00101417
CMP EDX,EAX
CMOVGE EAX,EDX
JMP 0x0010141c
LAB_00101490:
ADD R10D,0x1
JMP 0x00101447
LAB_001014a0:
ADD R11D,0x1
JMP 0x00101447
LAB_001014b0:
MOVSXD RCX,dword ptr [RSP + -0x8]
MOVSXD RDX,dword ptr [RSP + -0xc]
MOV RAX,qword ptr [RSP + 0x38]
LEA RBP,[R13 + RCX*0x4]
MOVSXD RCX,dword ptr [RSP + -0x4]
MOV EDX,dword ptr [R12 + RDX*0x4]
LEA RBX,[R14 + RCX*0x4]
LAB_001014d1:
MOV dword ptr [RAX],EDX
MOV EDX,dword ptr [RBP]
MOV dword ptr [RAX + 0x4],EDX
MOV EDX,dword ptr [RBX]
MOV dword ptr [RAX + 0x8],EDX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014f0:
MOV RAX,qword ptr [RSP + 0x38]
JMP 0x001014d1
LAB_001014f7:
MOV RBX,R14
MOV RBP,R13
JMP 0x001014d1 | void func0(int *param_1,int *param_2,int *param_3,int param_4,int param_5,int param_6,int *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int *piVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int local_3c;
int local_38;
int local_34;
iVar3 = *param_1;
piVar4 = param_3;
piVar5 = param_2;
if ((0 < param_6 && 0 < param_5) && (0 < param_4)) {
local_34 = 0;
iVar7 = 0;
iVar9 = 0;
local_38 = 0;
iVar8 = 0;
iVar10 = 0x7fffffff;
local_3c = 0;
do {
iVar3 = param_1[iVar8];
piVar5 = param_2 + iVar9;
iVar1 = *piVar5;
piVar4 = param_3 + iVar7;
iVar2 = *piVar4;
iVar6 = iVar2;
if (iVar3 < iVar1) {
if (iVar3 <= iVar2) {
iVar6 = iVar3;
}
LAB_00101417:
if (iVar2 <= iVar1) {
iVar2 = iVar1;
}
}
else {
if (iVar1 <= iVar2) {
iVar6 = iVar1;
}
if (iVar3 <= iVar1) goto LAB_00101417;
if (iVar2 <= iVar3) {
iVar2 = iVar3;
}
}
iVar2 = iVar2 - iVar6;
if ((iVar2 < iVar10) &&
(iVar10 = iVar2, local_3c = iVar8, local_38 = iVar9, local_34 = iVar7, iVar2 == 0))
goto LAB_001014d1;
if (iVar3 == iVar6) {
iVar8 = iVar8 + 1;
}
else if (iVar1 == iVar6) {
iVar9 = iVar9 + 1;
}
else {
iVar7 = iVar7 + 1;
}
} while ((iVar8 < param_4 && iVar9 < param_5) && (iVar7 < param_6));
iVar3 = param_1[local_3c];
piVar4 = param_3 + local_34;
piVar5 = param_2 + local_38;
}
LAB_001014d1:
*param_7 = iVar3;
param_7[1] = *piVar5;
param_7[2] = *piVar4;
return;
} |
7,648 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
| void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1; i++) {
assert(strcmp(phones1[i].make, sorted1[i].make) == 0);
assert(phones1[i].model == sorted1[i].model);
assert(strcmp(phones1[i].color, sorted1[i].color) == 0);
}
Phone phones2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
Phone sorted2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
int len2 = sizeof(phones2) / sizeof(phones2[0]);
func0(phones2, len2);
for (int i = 0; i < len2; i++) {
assert(strcmp(phones2[i].make, sorted2[i].make) == 0);
assert(phones2[i].model == sorted2[i].model);
assert(strcmp(phones2[i].color, sorted2[i].color) == 0);
}
Phone phones3[] = {{"micromax", 40, "grey"}, {"poco", 60, "blue"}};
Phone sorted3[] = {{"poco", 60, "blue"}, {"micromax", 40, "grey"}};
int len3 = sizeof(phones3) / sizeof(phones3[0]);
func0(phones3, len3);
for (int i = 0; i < len3; i++) {
assert(strcmp(phones3[i].make, sorted3[i].make) == 0);
assert(phones3[i].model == sorted3[i].model);
assert(strcmp(phones3[i].color, sorted3[i].color) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rsi
mov -0x8(%rbp),%rax
lea -0x65(%rip),%rcx
mov $0x18,%edx
mov %rax,%rdi
callq 1080 <qsort@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+base], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, comparator
mov rcx, rdx; compar
mov edx, 18h; size
mov rdi, rax; base
call _qsort
nop
leave
retn | void func0(void *a1, int a2)
{
qsort(a1, a2, 0x18uLL, comparator);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x1011a9]
MOV RCX,RDX
MOV EDX,0x18
MOV RDI,RAX
CALL 0x00101080
NOP
LEAVE
RET | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,649 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
| void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1; i++) {
assert(strcmp(phones1[i].make, sorted1[i].make) == 0);
assert(phones1[i].model == sorted1[i].model);
assert(strcmp(phones1[i].color, sorted1[i].color) == 0);
}
Phone phones2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
Phone sorted2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
int len2 = sizeof(phones2) / sizeof(phones2[0]);
func0(phones2, len2);
for (int i = 0; i < len2; i++) {
assert(strcmp(phones2[i].make, sorted2[i].make) == 0);
assert(phones2[i].model == sorted2[i].model);
assert(strcmp(phones2[i].color, sorted2[i].color) == 0);
}
Phone phones3[] = {{"micromax", 40, "grey"}, {"poco", 60, "blue"}};
Phone sorted3[] = {{"poco", 60, "blue"}, {"micromax", 40, "grey"}};
int len3 = sizeof(phones3) / sizeof(phones3[0]);
func0(phones3, len3);
for (int i = 0; i < len3; i++) {
assert(strcmp(phones3[i].make, sorted3[i].make) == 0);
assert(phones3[i].model == sorted3[i].model);
assert(strcmp(phones3[i].color, sorted3[i].color) == 0);
}
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
movslq %esi,%rsi
lea -0x2c(%rip),%rcx
mov $0x18,%edx
callq 1080 <qsort@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
movsxd rsi, esi
lea rcx, comparator
mov edx, 18h
call _qsort
add rsp, 8
retn | long long func0(long long a1, int a2)
{
return qsort(a1, a2, 24LL, comparator);
} | func0:
ENDBR64
SUB RSP,0x8
MOVSXD RSI,ESI
LEA RCX,[0x1011a9]
MOV EDX,0x18
CALL 0x00101080
ADD RSP,0x8
RET | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,650 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
| void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1; i++) {
assert(strcmp(phones1[i].make, sorted1[i].make) == 0);
assert(phones1[i].model == sorted1[i].model);
assert(strcmp(phones1[i].color, sorted1[i].color) == 0);
}
Phone phones2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
Phone sorted2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
int len2 = sizeof(phones2) / sizeof(phones2[0]);
func0(phones2, len2);
for (int i = 0; i < len2; i++) {
assert(strcmp(phones2[i].make, sorted2[i].make) == 0);
assert(phones2[i].model == sorted2[i].model);
assert(strcmp(phones2[i].color, sorted2[i].color) == 0);
}
Phone phones3[] = {{"micromax", 40, "grey"}, {"poco", 60, "blue"}};
Phone sorted3[] = {{"poco", 60, "blue"}, {"micromax", 40, "grey"}};
int len3 = sizeof(phones3) / sizeof(phones3[0]);
func0(phones3, len3);
for (int i = 0; i < len3; i++) {
assert(strcmp(phones3[i].make, sorted3[i].make) == 0);
assert(phones3[i].model == sorted3[i].model);
assert(strcmp(phones3[i].color, sorted3[i].color) == 0);
}
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%rsi
lea -0x2e(%rip),%rcx
mov $0x18,%edx
jmpq 1080 <qsort@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
lea rcx, comparator
mov edx, 18h
jmp _qsort | long long func0(long long a1, int a2)
{
return qsort(a1, a2, 24LL, comparator);
} | func0:
ENDBR64
MOVSXD RSI,ESI
LEA RCX,[0x101660]
MOV EDX,0x18
JMP 0x00101080 | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,651 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
| void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1; i++) {
assert(strcmp(phones1[i].make, sorted1[i].make) == 0);
assert(phones1[i].model == sorted1[i].model);
assert(strcmp(phones1[i].color, sorted1[i].color) == 0);
}
Phone phones2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
Phone sorted2[] = {{"Vivo", 20, "Blue"}, {"oppo", 17, "Gold"}, {"Apple", 11, "red"}};
int len2 = sizeof(phones2) / sizeof(phones2[0]);
func0(phones2, len2);
for (int i = 0; i < len2; i++) {
assert(strcmp(phones2[i].make, sorted2[i].make) == 0);
assert(phones2[i].model == sorted2[i].model);
assert(strcmp(phones2[i].color, sorted2[i].color) == 0);
}
Phone phones3[] = {{"micromax", 40, "grey"}, {"poco", 60, "blue"}};
Phone sorted3[] = {{"poco", 60, "blue"}, {"micromax", 40, "grey"}};
int len3 = sizeof(phones3) / sizeof(phones3[0]);
func0(phones3, len3);
for (int i = 0; i < len3; i++) {
assert(strcmp(phones3[i].make, sorted3[i].make) == 0);
assert(phones3[i].model == sorted3[i].model);
assert(strcmp(phones3[i].color, sorted3[i].color) == 0);
}
return 0;
}
| O3 | c | func0:
endbr64
movslq %esi,%rsi
lea -0x2e(%rip),%rcx
mov $0x18,%edx
jmpq 1080 <qsort@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi; nmemb
lea rcx, comparator; compar
mov edx, 18h; size
jmp _qsort | void func0(void *a1, int a2)
{
qsort(a1, a2, 0x18uLL, comparator);
} | func0:
ENDBR64
MOVSXD RSI,ESI
LEA RCX,[0x101690]
MOV EDX,0x18
JMP 0x00101080 | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,652 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[root] < arr[child]) {
int temp = arr[root];
arr[root] = arr[child];
arr[child] = temp;
root = child;
} else {
return;
}
}
}
void heapify(int arr[], int length) {
int start = (length - 2) / 2;
while (start >= 0) {
shift_down(arr, start, length - 1);
start -= 1;
}
}
| void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i = 0; i < 6; i++) {
assert(arr2[i] == sorted2[i]);
}
int arr3[] = {21, 15, 29, 78, 65};
func0(arr3, 5);
int sorted3[] = {15, 21, 29, 65, 78};
for (int i = 0; i < 5; i++) {
assert(arr3[i] == sorted3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1286 <heapify>
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 1357 <func0+0x85>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%rax
mov -0x4(%rbp),%edx
mov %edx,(%rax)
subl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%edx
mov -0x18(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 1169 <shift_down>
cmpl $0x0,-0x8(%rbp)
jg 1301 <func0+0x2f>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov edx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call heapify
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp short loc_1357
loc_1301:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rdx], eax
mov rax, [rbp+var_18]
mov edx, [rbp+var_4]
mov [rax], edx
sub [rbp+var_8], 1
mov edx, [rbp+var_8]
mov rax, [rbp+var_18]
mov esi, 0
mov rdi, rax
call shift_down
loc_1357:
cmp [rbp+var_8], 0
jg short loc_1301
nop
nop
leave
retn | long long func0(_DWORD *a1, unsigned int a2)
{
long long result; // rax
int i; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
heapify(a1, a2);
result = a2 - 1;
for ( i = a2 - 1; i > 0; result = shift_down(a1, 0LL, (unsigned int)i) )
{
v4 = a1[i];
a1[i] = *a1;
*a1 = v4;
--i;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101286
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101357
LAB_00101301:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x4]
MOV dword ptr [RAX],EDX
SUB dword ptr [RBP + -0x8],0x1
MOV EDX,dword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101169
LAB_00101357:
CMP dword ptr [RBP + -0x8],0x0
JG 0x00101301
NOP
NOP
LEAVE
RET | void func0(int4 *param_1,int param_2)
{
int4 uVar1;
int local_10;
heapify(param_1,param_2);
local_10 = param_2 + -1;
while (0 < local_10) {
uVar1 = param_1[local_10];
param_1[local_10] = *param_1;
*param_1 = uVar1;
local_10 = local_10 + -1;
shift_down(param_1,0,local_10);
}
return;
} |
7,653 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[root] < arr[child]) {
int temp = arr[root];
arr[root] = arr[child];
arr[child] = temp;
root = child;
} else {
return;
}
}
}
void heapify(int arr[], int length) {
int start = (length - 2) / 2;
while (start >= 0) {
shift_down(arr, start, length - 1);
start -= 1;
}
}
| void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i = 0; i < 6; i++) {
assert(arr2[i] == sorted2[i]);
}
int arr3[] = {21, 15, 29, 78, 65};
func0(arr3, 5);
int sorted3[] = {15, 21, 29, 65, 78};
for (int i = 0; i < 5; i++) {
assert(arr3[i] == sorted3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
callq 11bc <heapify>
sub $0x1,%ebx
test %ebx,%ebx
jle 1230 <func0+0x40>
movslq %ebx,%rbx
mov 0x0(%rbp,%rbx,4),%eax
mov 0x0(%rbp),%edx
mov %edx,0x0(%rbp,%rbx,4)
mov %eax,0x0(%rbp)
lea -0x1(%rbx),%edx
mov $0x0,%esi
mov %rbp,%rdi
callq 1169 <shift_down>
sub $0x1,%rbx
test %ebx,%ebx
jg 120a <func0+0x1a>
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
call heapify
sub ebx, 1
test ebx, ebx
jle short loc_1233
movsxd rbx, ebx
loc_120D:
mov eax, [rbp+rbx*4+0]
mov edx, [rbp+0]
mov [rbp+rbx*4+0], edx
mov [rbp+0], eax
lea edx, [rbx-1]
mov esi, 0
mov rdi, rbp
call shift_down
sub rbx, 1
test ebx, ebx
jg short loc_120D
loc_1233:
pop rbx
pop rbp
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
long long v3; // rbx
int v4; // eax
result = heapify();
LODWORD(v3) = a2 - 1;
if ( a2 - 1 > 0 )
{
v3 = (int)v3;
do
{
v4 = a1[v3];
a1[v3] = *a1;
*a1 = v4;
result = shift_down(a1, 0LL, (unsigned int)--v3);
}
while ( (int)v3 > 0 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
CALL 0x001011bf
SUB EBX,0x1
TEST EBX,EBX
JLE 0x00101233
MOVSXD RBX,EBX
LAB_0010120d:
MOV EAX,dword ptr [RBP + RBX*0x4]
MOV EDX,dword ptr [RBP]
MOV dword ptr [RBP + RBX*0x4],EDX
MOV dword ptr [RBP],EAX
LEA EDX,[RBX + -0x1]
MOV ESI,0x0
MOV RDI,RBP
CALL 0x00101169
SUB RBX,0x1
TEST EBX,EBX
JG 0x0010120d
LAB_00101233:
POP RBX
POP RBP
RET | void func0(int4 *param_1,int param_2)
{
int4 uVar1;
long lVar2;
heapify();
if (0 < param_2 + -1) {
lVar2 = (long)(param_2 + -1);
do {
uVar1 = param_1[lVar2];
param_1[lVar2] = *param_1;
*param_1 = uVar1;
shift_down(param_1,0,(int)lVar2 + -1);
lVar2 = lVar2 + -1;
} while (0 < (int)lVar2);
}
return;
} |
7,654 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[root] < arr[child]) {
int temp = arr[root];
arr[root] = arr[child];
arr[child] = temp;
root = child;
} else {
return;
}
}
}
void heapify(int arr[], int length) {
int start = (length - 2) / 2;
while (start >= 0) {
shift_down(arr, start, length - 1);
start -= 1;
}
}
| void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i = 0; i < 6; i++) {
assert(arr2[i] == sorted2[i]);
}
int arr3[] = {21, 15, 29, 78, 65};
func0(arr3, 5);
int sorted3[] = {15, 21, 29, 65, 78};
for (int i = 0; i < 5; i++) {
assert(arr3[i] == sorted3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%edx
mov %eax,%r10d
shr $0x1f,%r10d
add %eax,%r10d
sar %r10d
test %esi,%esi
jle 1482 <func0+0x32>
nopl 0x0(%rax,%rax,1)
mov %r10d,%esi
callq 13b0 <shift_down>
sub $0x1,%r10d
cmp $0xffffffff,%r10d
jne 1470 <func0+0x20>
movslq %edx,%r10
test %edx,%edx
jle 14b8 <func0+0x68>
nopl 0x0(%rax)
mov (%rdi,%r10,4),%eax
mov (%rdi),%edx
xor %esi,%esi
mov %edx,(%rdi,%r10,4)
lea -0x1(%r10),%edx
mov %eax,(%rdi)
callq 13b0 <shift_down>
sub $0x1,%r10
test %r10d,%r10d
jg 1490 <func0+0x40>
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, [rsi-2]
lea edx, [rsi-1]
mov r11d, eax
shr r11d, 1Fh
add r11d, eax
sar r11d, 1
test esi, esi
jle short loc_146E
nop dword ptr [rax+rax+00h]
loc_1460:
mov esi, r11d
call shift_down
sub r11d, 1
jnb short loc_1460
loc_146E:
movsxd r11, edx
test edx, edx
jle short locret_14A0
nop dword ptr [rax]
loc_1478:
mov eax, [rdi+r11*4]
mov edx, [rdi]
xor esi, esi
mov [rdi+r11*4], edx
lea edx, [r11-1]
sub r11, 1
mov [rdi], eax
call shift_down
test r11d, r11d
jg short loc_1478
retn
locret_14A0:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
long long v3; // rdx
unsigned int v4; // r11d
int v5; // r11d
bool v6; // cf
long long v7; // r11
int v8; // eax
result = (unsigned int)(a2 - 2);
v3 = (unsigned int)(a2 - 1);
v4 = (a2 - 2) / 2;
if ( a2 > 0 )
{
do
{
result = shift_down(a1, v4, v3);
v6 = v5 == 0;
v4 = v5 - 1;
}
while ( !v6 );
}
v7 = (int)v3;
if ( (int)v3 > 0 )
{
do
{
v8 = a1[v7];
a1[v7] = *a1;
*a1 = v8;
result = shift_down(a1, 0LL, (unsigned int)(v7 - 1));
}
while ( (int)v7 > 0 );
}
return result;
} | func0:
ENDBR64
LEA EAX,[RSI + -0x2]
LEA EDX,[RSI + -0x1]
MOV R11D,EAX
SHR R11D,0x1f
ADD R11D,EAX
SAR R11D,0x1
TEST ESI,ESI
JLE 0x0010146e
NOP dword ptr [RAX + RAX*0x1]
LAB_00101460:
MOV ESI,R11D
CALL 0x001013b0
SUB R11D,0x1
JNC 0x00101460
LAB_0010146e:
MOVSXD R11,EDX
TEST EDX,EDX
JLE 0x001014a0
NOP dword ptr [RAX]
LAB_00101478:
MOV EAX,dword ptr [RDI + R11*0x4]
MOV EDX,dword ptr [RDI]
XOR ESI,ESI
MOV dword ptr [RDI + R11*0x4],EDX
LEA EDX,[R11 + -0x1]
SUB R11,0x1
MOV dword ptr [RDI],EAX
CALL 0x001013b0
TEST R11D,R11D
JG 0x00101478
RET
LAB_001014a0:
RET | void func0(int4 *param_1,int param_2)
{
int4 uVar1;
int iVar2;
int extraout_EDX;
int iVar3;
long lVar4;
bool bVar5;
iVar2 = param_2 + -1;
iVar3 = (param_2 + -2) / 2;
if (0 < param_2) {
do {
shift_down();
bVar5 = iVar3 != 0;
iVar3 = iVar3 + -1;
iVar2 = extraout_EDX;
} while (bVar5);
}
lVar4 = (long)iVar2;
if (iVar2 < 1) {
return;
}
do {
uVar1 = param_1[lVar4];
param_1[lVar4] = *param_1;
lVar4 = lVar4 + -1;
*param_1 = uVar1;
shift_down();
} while (0 < (int)lVar4);
return;
} |
7,655 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[root] < arr[child]) {
int temp = arr[root];
arr[root] = arr[child];
arr[child] = temp;
root = child;
} else {
return;
}
}
}
void heapify(int arr[], int length) {
int start = (length - 2) / 2;
while (start >= 0) {
shift_down(arr, start, length - 1);
start -= 1;
}
}
| void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i = 0; i < 6; i++) {
assert(arr2[i] == sorted2[i]);
}
int arr3[] = {21, 15, 29, 78, 65};
func0(arr3, 5);
int sorted3[] = {15, 21, 29, 65, 78};
for (int i = 0; i < 5; i++) {
assert(arr3[i] == sorted3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
lea -0x2(%rsi),%edx
push %rbp
lea -0x1(%rsi),%r11d
push %rbx
mov %edx,%ebx
shr $0x1f,%ebx
add %edx,%ebx
mov %ebx,%ebp
and $0xfffffffe,%ebx
sar %ebp
test %esi,%esi
jle 152a <func0+0x8a>
mov %ebx,%r8d
movslq %ebp,%rcx
cmp %r11d,%ebx
jl 14f8 <func0+0x58>
jmp 151f <func0+0x7f>
nopl (%rax)
movslq %eax,%r8
lea (%rdi,%r8,4),%r8
mov (%r8),%r9d
lea (%rdi,%rcx,4),%r10
mov (%r10),%ecx
cmp %r9d,%ecx
jge 151f <func0+0x7f>
mov %r9d,(%r10)
mov %ecx,(%r8)
lea (%rax,%rax,1),%r8d
cmp %r11d,%r8d
jge 151f <func0+0x7f>
movslq %eax,%rcx
lea 0x1(%r8),%eax
cmp %r11d,%eax
jge 151a <func0+0x7a>
movslq %eax,%r10
shl $0x2,%r10
lea (%rdi,%r10,1),%r8
mov (%r8),%r9d
cmp 0x4(%rdi,%r10,1),%r9d
jge 14da <func0+0x3a>
lea 0x2(%rcx,%rcx,1),%eax
cmp %r11d,%eax
jle 14d0 <func0+0x30>
sub $0x1,%ebp
sub $0x2,%ebx
cmp $0xffffffff,%ebp
jne 14c0 <func0+0x20>
test %r11d,%r11d
jle 15bd <func0+0x11d>
movslq %r11d,%r11
mov (%rdi),%ecx
lea (%rdi,%r11,4),%rax
mov (%rax),%r10d
mov %ecx,(%rax)
mov %r10d,(%rdi)
cmp $0x2,%esi
je 15bd <func0+0x11d>
movslq %edx,%rdx
nopl 0x0(%rax)
xor %ecx,%ecx
xor %esi,%esi
mov %edx,%r11d
jmp 1584 <func0+0xe4>
nopl 0x0(%rax)
movslq %eax,%rsi
lea (%rdi,%rsi,4),%rsi
mov (%rsi),%r8d
lea (%rdi,%rcx,4),%rcx
cmp %r8d,%r10d
jge 15a9 <func0+0x109>
mov %r8d,(%rcx)
mov %r10d,(%rsi)
lea (%rax,%rax,1),%esi
cmp %r11d,%esi
jge 15a9 <func0+0x109>
movslq %eax,%rcx
lea 0x1(%rsi),%eax
cmp %edx,%eax
jge 15a4 <func0+0x104>
movslq %eax,%r9
shl $0x2,%r9
lea (%rdi,%r9,1),%rsi
mov (%rsi),%r8d
cmp 0x4(%rdi,%r9,1),%r8d
jge 156a <func0+0xca>
lea 0x2(%rcx,%rcx,1),%eax
cmp %r11d,%eax
jle 1560 <func0+0xc0>
mov (%rdi),%eax
mov (%rdi,%rdx,4),%r10d
mov %eax,(%rdi,%rdx,4)
sub $0x1,%rdx
mov %r10d,(%rdi)
test %edx,%edx
jg 1550 <func0+0xb0>
pop %rbx
pop %rbp
retq
| func0:
endbr64
lea r11d, [rsi-2]
push rbx
mov rdx, rdi
lea r9d, [rsi-1]
mov r10d, r11d
shr r10d, 1Fh
add r10d, r11d
mov ebx, r10d
and r10d, 0FFFFFFFEh
sar ebx, 1
test esi, esi
jle short loc_14B5
nop word ptr [rax+rax+00000000h]
loc_1450:
mov esi, r10d
movsxd rcx, ebx
cmp r10d, r9d
jl short loc_1484
jmp short loc_14A9
loc_1460:
movsxd rsi, eax
lea rdi, [rdx+rsi*4]
mov esi, [rdi]
loc_1469:
lea r8, [rdx+rcx*4]
mov ecx, [r8]
cmp ecx, esi
jge short loc_14A9
mov [r8], esi
lea esi, [rax+rax]
mov [rdi], ecx
cmp esi, r9d
jge short loc_14A9
movsxd rcx, eax
loc_1484:
lea eax, [rsi+1]
cmp eax, r9d
jge short loc_14A4
movsxd r8, eax
shl r8, 2
lea rdi, [rdx+r8]
mov esi, [rdi]
cmp esi, [rdx+r8+4]
jge short loc_1469
lea eax, [rcx+rcx+2]
loc_14A4:
cmp eax, r9d
jle short loc_1460
loc_14A9:
sub ebx, 1
sub r10d, 2
cmp ebx, 0FFFFFFFFh
jnz short loc_1450
loc_14B5:
test r9d, r9d
jle loc_1546
movsxd r9, r9d
mov esi, [rdx]
movsxd r10, r11d
lea rax, [rdx+r9*4]
mov ecx, [rax]
mov [rax], esi
mov [rdx], ecx
test r11d, r11d
jz short loc_1546
nop dword ptr [rax]
loc_14D8:
xor ecx, ecx
xor esi, esi
mov r9d, r10d
jmp short loc_150C
loc_14E8:
movsxd rsi, eax
lea rdi, [rdx+rsi*4]
mov esi, [rdi]
loc_14F1:
lea r8, [rdx+rcx*4]
mov ecx, [r8]
cmp ecx, esi
jge short loc_1531
mov [r8], esi
lea esi, [rax+rax]
mov [rdi], ecx
cmp esi, r9d
jge short loc_1531
movsxd rcx, eax
loc_150C:
lea eax, [rsi+1]
cmp eax, r10d
jge short loc_152C
movsxd r8, eax
shl r8, 2
lea rdi, [rdx+r8]
mov esi, [rdi]
cmp esi, [rdx+r8+4]
jge short loc_14F1
lea eax, [rcx+rcx+2]
loc_152C:
cmp eax, r9d
jle short loc_14E8
loc_1531:
mov ecx, [rdx]
mov eax, [rdx+r10*4]
mov [rdx+r10*4], ecx
sub r10, 1
mov [rdx], eax
test r10d, r10d
jg short loc_14D8
loc_1546:
pop rbx
retn | void func0(int *a1, int a2)
{
int v2; // r11d
int v4; // r9d
signed int v5; // r10d
int v6; // ebx
int v7; // esi
long long v8; // rcx
int *v9; // rdi
int v10; // esi
int *v11; // r8
int v12; // ecx
int v13; // eax
long long v14; // r10
int *v15; // rax
int v16; // ecx
long long v17; // rcx
int v18; // esi
int *v19; // rdi
int v20; // esi
int *v21; // r8
int v22; // ecx
int v23; // eax
int v24; // eax
v2 = a2 - 2;
v4 = a2 - 1;
v5 = (a2 - 2 + ((unsigned int)(a2 - 2) >> 31)) & 0xFFFFFFFE;
v6 = (a2 - 2) / 2;
if ( a2 > 0 )
{
while ( 1 )
{
v7 = v5;
v8 = v6;
if ( v5 < v4 )
break;
LABEL_12:
--v6;
v5 -= 2;
if ( v6 == -1 )
goto LABEL_13;
}
while ( 1 )
{
v13 = v7 + 1;
if ( v7 + 1 < v4 )
{
v9 = &a1[v13];
v10 = *v9;
if ( *v9 >= v9[1] )
goto LABEL_5;
v13 = 2 * v8 + 2;
}
if ( v13 > v4 )
goto LABEL_12;
v9 = &a1[v13];
v10 = *v9;
LABEL_5:
v11 = &a1[v8];
v12 = *v11;
if ( *v11 >= v10 )
goto LABEL_12;
*v11 = v10;
v7 = 2 * v13;
*v9 = v12;
if ( 2 * v13 >= v4 )
goto LABEL_12;
v8 = v13;
}
}
LABEL_13:
if ( v4 > 0 )
{
v14 = v2;
v15 = &a1[v4];
v16 = *v15;
*v15 = *a1;
*a1 = v16;
if ( v2 )
{
LABEL_15:
v17 = 0LL;
v18 = 0;
while ( 1 )
{
v23 = v18 + 1;
if ( v18 + 1 < (int)v14 )
{
v19 = &a1[v23];
v20 = *v19;
if ( *v19 >= v19[1] )
goto LABEL_17;
v23 = 2 * v17 + 2;
}
if ( v23 > (int)v14 )
goto LABEL_24;
v19 = &a1[v23];
v20 = *v19;
LABEL_17:
v21 = &a1[v17];
v22 = *v21;
if ( *v21 >= v20 || (*v21 = v20, v18 = 2 * v23, *v19 = v22, 2 * v23 >= (int)v14) )
{
LABEL_24:
v24 = a1[v14];
a1[v14--] = *a1;
*a1 = v24;
if ( (int)v14 <= 0 )
return;
goto LABEL_15;
}
v17 = v23;
}
}
}
} | func0:
ENDBR64
LEA R11D,[RSI + -0x2]
PUSH RBX
MOV RDX,RDI
LEA R9D,[RSI + -0x1]
MOV R10D,R11D
SHR R10D,0x1f
ADD R10D,R11D
MOV EBX,R10D
AND R10D,0xfffffffe
SAR EBX,0x1
TEST ESI,ESI
JLE 0x001014b5
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV ESI,R10D
MOVSXD RCX,EBX
CMP R10D,R9D
JL 0x00101484
JMP 0x001014a9
LAB_00101460:
MOVSXD RSI,EAX
LEA RDI,[RDX + RSI*0x4]
MOV ESI,dword ptr [RDI]
LAB_00101469:
LEA R8,[RDX + RCX*0x4]
MOV ECX,dword ptr [R8]
CMP ECX,ESI
JGE 0x001014a9
MOV dword ptr [R8],ESI
LEA ESI,[RAX + RAX*0x1]
MOV dword ptr [RDI],ECX
CMP ESI,R9D
JGE 0x001014a9
MOVSXD RCX,EAX
LAB_00101484:
LEA EAX,[RSI + 0x1]
CMP EAX,R9D
JGE 0x001014a4
MOVSXD R8,EAX
SHL R8,0x2
LEA RDI,[RDX + R8*0x1]
MOV ESI,dword ptr [RDI]
CMP ESI,dword ptr [RDX + R8*0x1 + 0x4]
JGE 0x00101469
LEA EAX,[RCX + RCX*0x1 + 0x2]
LAB_001014a4:
CMP EAX,R9D
JLE 0x00101460
LAB_001014a9:
SUB EBX,0x1
SUB R10D,0x2
CMP EBX,-0x1
JNZ 0x00101450
LAB_001014b5:
TEST R9D,R9D
JLE 0x00101546
MOVSXD R9,R9D
MOV ESI,dword ptr [RDX]
MOVSXD R10,R11D
LEA RAX,[RDX + R9*0x4]
MOV ECX,dword ptr [RAX]
MOV dword ptr [RAX],ESI
MOV dword ptr [RDX],ECX
TEST R11D,R11D
JZ 0x00101546
NOP dword ptr [RAX]
LAB_001014d8:
XOR ECX,ECX
XOR ESI,ESI
MOV R9D,R10D
JMP 0x0010150c
LAB_001014e8:
MOVSXD RSI,EAX
LEA RDI,[RDX + RSI*0x4]
MOV ESI,dword ptr [RDI]
LAB_001014f1:
LEA R8,[RDX + RCX*0x4]
MOV ECX,dword ptr [R8]
CMP ECX,ESI
JGE 0x00101531
MOV dword ptr [R8],ESI
LEA ESI,[RAX + RAX*0x1]
MOV dword ptr [RDI],ECX
CMP ESI,R9D
JGE 0x00101531
MOVSXD RCX,EAX
LAB_0010150c:
LEA EAX,[RSI + 0x1]
CMP EAX,R10D
JGE 0x0010152c
MOVSXD R8,EAX
SHL R8,0x2
LEA RDI,[RDX + R8*0x1]
MOV ESI,dword ptr [RDI]
CMP ESI,dword ptr [RDX + R8*0x1 + 0x4]
JGE 0x001014f1
LEA EAX,[RCX + RCX*0x1 + 0x2]
LAB_0010152c:
CMP EAX,R9D
JLE 0x001014e8
LAB_00101531:
MOV ECX,dword ptr [RDX]
MOV EAX,dword ptr [RDX + R10*0x4]
MOV dword ptr [RDX + R10*0x4],ECX
SUB R10,0x1
MOV dword ptr [RDX],EAX
TEST R10D,R10D
JG 0x001014d8
LAB_00101546:
POP RBX
RET | void func0(int4 *param_1,int param_2)
{
int iVar1;
int4 uVar2;
int iVar3;
int iVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
int *piVar9;
uint uVar10;
uint uVar11;
long lVar12;
int iVar13;
iVar13 = param_2 + -2;
iVar8 = param_2 + -1;
uVar10 = iVar13 - (iVar13 >> 0x1f) & 0xfffffffe;
iVar6 = iVar13 / 2;
uVar11 = uVar10;
iVar4 = iVar6;
if (0 < param_2) {
joined_r0x00101459:
do {
if ((int)uVar10 < iVar8) {
iVar3 = uVar10 + 1;
if (iVar3 < iVar8) {
piVar9 = param_1 + iVar3;
iVar7 = *piVar9;
if (iVar7 < (int)param_1[(long)iVar3 + 1]) {
iVar3 = iVar6 * 2 + 2;
goto LAB_001014a4;
}
}
else {
LAB_001014a4:
if (iVar8 < iVar3) goto LAB_001014a9;
piVar9 = param_1 + iVar3;
iVar7 = *piVar9;
}
iVar1 = param_1[iVar6];
if (iVar1 < iVar7) {
param_1[iVar6] = iVar7;
uVar10 = iVar3 * 2;
*piVar9 = iVar1;
iVar6 = iVar3;
goto joined_r0x00101459;
}
}
LAB_001014a9:
iVar6 = iVar4 + -1;
uVar10 = uVar11 - 2;
uVar11 = uVar10;
iVar4 = iVar6;
} while (iVar6 != -1);
}
if (0 < iVar8) {
lVar12 = (long)iVar13;
uVar2 = param_1[iVar8];
param_1[iVar8] = *param_1;
*param_1 = uVar2;
if (iVar13 != 0) {
LAB_001014d8:
lVar5 = 0;
iVar8 = 0;
iVar6 = (int)lVar12;
do {
iVar4 = iVar8 + 1;
if (iVar4 < iVar6) {
piVar9 = param_1 + iVar4;
iVar8 = *piVar9;
if (iVar8 < (int)param_1[(long)iVar4 + 1]) {
iVar4 = (int)lVar5 * 2 + 2;
goto LAB_0010152c;
}
}
else {
LAB_0010152c:
if (iVar6 < iVar4) goto LAB_00101531;
piVar9 = param_1 + iVar4;
iVar8 = *piVar9;
}
iVar13 = param_1[lVar5];
if (iVar8 <= iVar13) goto LAB_00101531;
param_1[lVar5] = iVar8;
iVar8 = iVar4 * 2;
*piVar9 = iVar13;
if (iVar6 <= iVar8) goto LAB_00101531;
lVar5 = (long)iVar4;
} while( true );
}
}
return;
LAB_00101531:
uVar2 = param_1[lVar12];
param_1[lVar12] = *param_1;
lVar12 = lVar12 + -1;
*param_1 = uVar2;
if ((int)lVar12 < 1) {
return;
}
goto LAB_001014d8;
} |
7,656 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_elim++;
}
return count_elim;
}
| int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert(func0(arr3, 1) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ab <func0+0x42>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0xffffffff,%eax
je 11b5 <func0+0x4c>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
jmp 11b6 <func0+0x4d>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp eax, 0FFFFFFFFh
jz short loc_11B5
add [rbp+var_8], 1
add [rbp+var_4], 1
loc_11AB:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
jmp short loc_11B6
loc_11B5:
nop
loc_11B6:
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2 && *(_DWORD *)(4LL * i + a1) != -1; ++i )
++v3;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ab
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,-0x1
JZ 0x001011b5
ADD dword ptr [RBP + -0x8],0x1
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ab:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
JMP 0x001011b6
LAB_001011b5:
NOP
LAB_001011b6:
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while ((local_c < param_2 && (*(int *)(param_1 + (long)local_c * 4) != -1))) {
local_10 = local_10 + 1;
local_c = local_c + 1;
}
return local_10;
} |
7,657 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_elim++;
}
return count_elim;
}
| int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert(func0(arr3, 1) == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 117e <func0+0x15>
mov %rcx,%rax
mov %eax,%edx
cmpl $0xffffffff,(%rdi,%rax,4)
je 1192 <func0+0x29>
lea 0x1(%rax),%edx
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne 117b <func0+0x12>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1192 <func0+0x29>
| func0:
endbr64
test esi, esi
jle short loc_1189
mov eax, 0
loc_1176:
cmp dword ptr [rdi], 0FFFFFFFFh
jz short locret_118E
add eax, 1
add rdi, 4
cmp esi, eax
jnz short loc_1176
mov eax, esi
retn
loc_1189:
mov eax, 0
locret_118E:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
if ( a2 <= 0 )
return 0LL;
result = 0LL;
while ( *a1 != -1 )
{
result = (unsigned int)(result + 1);
++a1;
if ( a2 == (_DWORD)result )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101189
MOV EAX,0x0
LAB_00101176:
CMP dword ptr [RDI],-0x1
JZ 0x0010118e
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JNZ 0x00101176
MOV EAX,ESI
RET
LAB_00101189:
MOV EAX,0x0
LAB_0010118e:
RET | int func0(int *param_1,int param_2)
{
int iVar1;
if (param_2 < 1) {
iVar1 = 0;
}
else {
iVar1 = 0;
while (*param_1 != -1) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return param_2;
}
}
}
return iVar1;
} |
7,658 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_elim++;
}
return count_elim;
}
| int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert(func0(arr3, 1) == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 116d <func0+0x2d>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 1160 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1169 <func0+0x29>
mov %rdx,%rax
cmpl $0xffffffff,(%rdi,%rax,4)
mov %eax,%r8d
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
xor %r8d,%r8d
jmp 1169 <func0+0x29>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_123B
jmp short locret_1240
loc_1230:
add eax, 1
add rdi, 4
cmp esi, eax
jz short locret_1248
loc_123B:
cmp dword ptr [rdi], 0FFFFFFFFh
jnz short loc_1230
locret_1240:
retn
locret_1248:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( *a1 == -1 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010123b
JMP 0x00101240
LAB_00101230:
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JZ 0x00101248
LAB_0010123b:
CMP dword ptr [RDI],-0x1
JNZ 0x00101230
LAB_00101240:
RET
LAB_00101248:
RET | void func0(int *param_1,int param_2)
{
int iVar1;
iVar1 = 0;
if (0 < param_2) {
while (*param_1 != -1) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return;
}
}
}
return;
} |
7,659 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_elim++;
}
return count_elim;
}
| int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert(func0(arr3, 1) == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 121d <func0+0x2d>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 1210 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1219 <func0+0x29>
mov %rdx,%rax
cmpl $0xffffffff,(%rdi,%rax,4)
mov %eax,%r8d
jne 1200 <func0+0x10>
mov %r8d,%eax
retq
xor %r8d,%r8d
jmp 1219 <func0+0x29>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_115B
retn
loc_1150:
add eax, 1
add rdi, 4
cmp esi, eax
jz short locret_1168
loc_115B:
cmp dword ptr [rdi], 0FFFFFFFFh
jnz short loc_1150
retn
locret_1168:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( *a1 == -1 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010115b
RET
LAB_00101150:
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JZ 0x00101168
LAB_0010115b:
CMP dword ptr [RDI],-0x1
JNZ 0x00101150
RET
LAB_00101168:
RET | void func0(int *param_1,int param_2)
{
int iVar1;
iVar1 = 0;
if (param_2 < 1) {
return;
}
do {
if (*param_1 == -1) {
return;
}
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
} while (param_2 != iVar1);
return;
} |
7,660 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
if (res) break;
}
return res;
}
| int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
assert(func0(test_tup2, 4, check_list2, 5) == true);
assert(func0(test_tup3, 5, check_list3, 4) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movb $0x0,-0x9(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e1 <func0+0x78>
movl $0x0,-0x4(%rbp)
jmp 11cf <func0+0x66>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11cb <func0+0x62>
movb $0x1,-0x9(%rbp)
jmp 11d7 <func0+0x6e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1195 <func0+0x2c>
cmpb $0x0,-0x9(%rbp)
jne 11eb <func0+0x82>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 118c <func0+0x23>
jmp 11ec <func0+0x83>
movzbl -0x9(%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_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_9], 0
mov [rbp+var_8], 0
jmp short loc_11E1
loc_118C:
mov [rbp+var_4], 0
jmp short loc_11CF
loc_1195:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11CB
mov [rbp+var_9], 1
jmp short loc_11D7
loc_11CB:
add [rbp+var_4], 1
loc_11CF:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1195
loc_11D7:
cmp [rbp+var_9], 0
jnz short loc_11EB
add [rbp+var_8], 1
loc_11E1:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
jl short loc_118C
jmp short loc_11EC
loc_11EB:
nop
loc_11EC:
movzx eax, [rbp+var_9]
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
unsigned __int8 v5; // [rsp+1Fh] [rbp-9h]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a4; ++i )
{
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a3) == *(_DWORD *)(4LL * j + a1) )
{
v5 = 1;
break;
}
}
if ( v5 )
break;
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011e1
LAB_0010118c:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cf
LAB_00101195:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011cb
MOV byte ptr [RBP + -0x9],0x1
JMP 0x001011d7
LAB_001011cb:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011cf:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101195
LAB_001011d7:
CMP byte ptr [RBP + -0x9],0x0
JNZ 0x001011eb
ADD dword ptr [RBP + -0x8],0x1
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x0010118c
JMP 0x001011ec
LAB_001011eb:
NOP
LAB_001011ec:
MOVZX EAX,byte ptr [RBP + -0x9]
POP RBP
RET | char func0(long param_1,int param_2,long param_3,int param_4)
{
char local_11;
int local_10;
int local_c;
local_11 = '\0';
local_10 = 0;
do {
if (param_4 <= local_10) {
return local_11;
}
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_3 + (long)local_10 * 4) == *(int *)(param_1 + (long)local_c * 4)) {
local_11 = '\x01';
break;
}
}
if (local_11 != '\0') {
return local_11;
}
local_10 = local_10 + 1;
} while( true );
} |
7,661 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
if (res) break;
}
return res;
}
| int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
assert(func0(test_tup2, 4, check_list2, 5) == true);
assert(func0(test_tup3, 5, check_list3, 4) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 11ab <func0+0x42>
mov %rdx,%r8
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r10
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
jmp 1192 <func0+0x29>
add $0x4,%r8
cmp %r10,%r8
je 11b7 <func0+0x4e>
test %esi,%esi
jle 1189 <func0+0x20>
mov (%r8),%edx
mov %r9,%rax
cmp (%rax),%edx
je 11b1 <func0+0x48>
add $0x4,%rax
cmp %rcx,%rax
jne 119c <func0+0x33>
jmp 1189 <func0+0x20>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_11AA
mov rdi, rdx
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rcx, [r8+rax*4+4]
jmp short loc_1192
loc_1189:
add rdi, 4
cmp rdi, r9
jz short loc_11B6
loc_1192:
test esi, esi
jle short loc_1189
mov edx, [rdi]
mov rax, r8
loc_119B:
cmp edx, [rax]
jz short loc_11B0
add rax, 4
cmp rax, rcx
jnz short loc_119B
jmp short loc_1189
loc_11AA:
mov eax, 0
retn
loc_11B0:
mov eax, 1
retn
loc_11B6:
mov eax, 0
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // rdi
_DWORD *v6; // rax
if ( a4 <= 0 )
return 0LL;
v5 = a3;
while ( a2 <= 0 )
{
LABEL_3:
if ( ++v5 == &a3[a4 - 1 + 1] )
return 0LL;
}
v6 = a1;
while ( *v5 != *v6 )
{
if ( ++v6 == &a1[a2 - 1 + 1] )
goto LABEL_3;
}
return 1LL;
} | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x001011aa
MOV RDI,RDX
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RCX,[R8 + RAX*0x4 + 0x4]
JMP 0x00101192
LAB_00101189:
ADD RDI,0x4
CMP RDI,R9
JZ 0x001011b6
LAB_00101192:
TEST ESI,ESI
JLE 0x00101189
MOV EDX,dword ptr [RDI]
MOV RAX,R8
LAB_0010119b:
CMP EDX,dword ptr [RAX]
JZ 0x001011b0
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010119b
JMP 0x00101189
LAB_001011aa:
MOV EAX,0x0
RET
LAB_001011b0:
MOV EAX,0x1
RET
LAB_001011b6:
MOV EAX,0x0
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (param_4 < 1) {
return 0;
}
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (0 < param_2) {
piVar2 = param_1;
do {
if (*param_3 == *piVar2) {
return 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
}
param_3 = param_3 + 1;
} while (param_3 != piVar1);
return 0;
} |
7,662 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
if (res) break;
}
return res;
}
| int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
assert(func0(test_tup2, 4, check_list2, 5) == true);
assert(func0(test_tup3, 5, check_list3, 4) == false);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1371 <func0+0x51>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1368 <func0+0x48>
mov (%r8),%edx
mov %rdi,%rax
jmp 1359 <func0+0x39>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rcx,%rax
je 1368 <func0+0x48>
cmp (%rax),%edx
jne 1350 <func0+0x30>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x4,%r8
cmp %r9,%r8
jne 1340 <func0+0x20>
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1381
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1350:
test esi, esi
jle short loc_1378
mov ecx, [rdx]
mov rax, r8
jmp short loc_1369
loc_1360:
add rax, 4
cmp rax, rdi
jz short loc_1378
loc_1369:
cmp ecx, [rax]
jnz short loc_1360
mov eax, 1
retn
loc_1378:
add rdx, 4
cmp rdx, r9
jnz short loc_1350
loc_1381:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long v5; // r9
long long v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 0LL;
v5 = (long long)&a3[a4 - 1 + 1];
v6 = (long long)&a1[a2 - 1 + 1];
while ( a2 <= 0 )
{
LABEL_8:
if ( ++a3 == (_DWORD *)v5 )
return 0LL;
}
v7 = a1;
while ( *a3 != *v7 )
{
if ( ++v7 == (_DWORD *)v6 )
goto LABEL_8;
}
return 1LL;
} | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101381
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101350:
TEST ESI,ESI
JLE 0x00101378
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101369
LAB_00101360:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101378
LAB_00101369:
CMP ECX,dword ptr [RAX]
JNZ 0x00101360
MOV EAX,0x1
RET
LAB_00101378:
ADD RDX,0x4
CMP RDX,R9
JNZ 0x00101350
LAB_00101381:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (0 < param_2) {
piVar2 = param_1;
do {
if (*param_3 == *piVar2) {
return 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
}
param_3 = param_3 + 1;
} while (param_3 != piVar1);
}
return 0;
} |
7,663 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
if (res) break;
}
return res;
}
| int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
assert(func0(test_tup2, 4, check_list2, 5) == true);
assert(func0(test_tup3, 5, check_list3, 4) == false);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1251 <func0+0x51>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1248 <func0+0x48>
mov (%r8),%edx
mov %rdi,%rax
jmp 1239 <func0+0x39>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rcx,%rax
je 1248 <func0+0x48>
cmp (%rax),%edx
jne 1230 <func0+0x30>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x4,%r8
cmp %r9,%r8
jne 1220 <func0+0x20>
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1191
movsxd rcx, ecx
movsxd rax, esi
lea r9, [rdx+rcx*4]
lea rdi, [rdi+rax*4]
nop dword ptr [rax+00000000h]
loc_1160:
test esi, esi
jle short loc_1188
loc_1164:
mov ecx, [rdx]
mov rax, r8
jmp short loc_1179
loc_1170:
add rax, 4
cmp rax, rdi
jz short loc_1198
loc_1179:
cmp ecx, [rax]
jnz short loc_1170
mov eax, 1
retn
loc_1188:
add rdx, 4
cmp rdx, r9
jnz short loc_1160
loc_1191:
xor eax, eax
retn
loc_1198:
add rdx, 4
cmp rdx, r9
jnz short loc_1164
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // r9
_DWORD *v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 0LL;
v5 = &a3[a4];
v6 = &a1[a2];
while ( a2 <= 0 )
{
if ( ++a3 == v5 )
return 0LL;
}
do
{
v7 = a1;
do
{
if ( *a3 == *v7 )
return 1LL;
++v7;
}
while ( v7 != v6 );
++a3;
}
while ( a3 != v5 );
return 0LL;
} | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101191
MOVSXD RCX,ECX
MOVSXD RAX,ESI
LEA R9,[RDX + RCX*0x4]
LEA RDI,[RDI + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101160:
TEST ESI,ESI
JLE 0x00101188
LAB_00101164:
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101179
LAB_00101170:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101198
LAB_00101179:
CMP ECX,dword ptr [RAX]
JNZ 0x00101170
MOV EAX,0x1
RET
LAB_00101188:
ADD RDX,0x4
CMP RDX,R9
JNZ 0x00101160
LAB_00101191:
XOR EAX,EAX
RET
LAB_00101198:
ADD RDX,0x4
CMP RDX,R9
JNZ 0x00101164
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + param_4;
do {
if (0 < param_2) {
do {
piVar2 = param_1;
do {
if (*param_3 == *piVar2) {
return 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + param_2);
param_3 = param_3 + 1;
} while (param_3 != piVar1);
return 0;
}
param_3 = param_3 + 1;
} while (param_3 != piVar1);
}
return 0;
} |
7,664 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
result[k++] = num1[i++];
} else {
result[k++] = num2[j++];
}
}
// If there are remaining elements in num1, add them
while (i < size1) {
result[k++] = num1[i++];
}
// If there are remaining elements in num2, add them
while (j < size2) {
result[k++] = num2[j++];
}
return result;
}
| int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int arr4[] = {2, 5, 7, 11};
int expected2[] = {1, 2, 3, 5, 5, 6, 7, 8, 9, 11};
int* result2 = func0(arr3, 6, arr4, 4);
for (int i = 0; i < 10; i++) assert(result2[i] == expected2[i]);
int arr5[] = {1, 3, 7};
int arr6[] = {2, 4, 6};
int expected3[] = {1, 2, 3, 4, 6, 7};
int* result3 = func0(arr5, 3, arr6, 3);
for (int i = 0; i < 6; i++) assert(result3[i] == expected3[i]);
// Free allocated memory
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %ecx,-0x30(%rbp)
mov -0x2c(%rbp),%edx
mov -0x30(%rbp),%eax
add %edx,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 12bb <func0+0xf2>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 1282 <func0+0xb9>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
jmp 12bb <func0+0xf2>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 130a <func0+0x141>
mov -0x10(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1217 <func0+0x4e>
jmp 130a <func0+0x141>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 12d1 <func0+0x108>
jmp 134d <func0+0x184>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1314 <func0+0x14b>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_30], ecx
mov edx, [rbp+var_2C]
mov eax, [rbp+var_30]
add eax, edx
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_12BB
loc_1217:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_1282
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_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
jmp short loc_12BB
loc_1282:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_12BB:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jge short loc_130A
mov eax, [rbp+var_10]
cmp eax, [rbp+var_30]
jl loc_1217
jmp short loc_130A
loc_12D1:
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_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_130A:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_12D1
jmp short loc_134D
loc_1314:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_134D:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_30]
jl short loc_1314
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int v4; // eax
_DWORD *v5; // rcx
int v6; // eax
int v7; // eax
int v8; // eax
_DWORD *v9; // rcx
int v10; // eax
int v11; // eax
_DWORD *v12; // rcx
int v13; // eax
int v17; // [rsp+2Ch] [rbp-14h]
int v18; // [rsp+30h] [rbp-10h]
int v19; // [rsp+34h] [rbp-Ch]
_DWORD *v20; // [rsp+38h] [rbp-8h]
v20 = malloc(4LL * (a2 + a4));
v17 = 0;
v18 = 0;
v19 = 0;
while ( v17 < a2 && v18 < a4 )
{
if ( *(_DWORD *)(4LL * v17 + a1) >= *(_DWORD *)(4LL * v18 + a3) )
{
v7 = v18++;
v5 = (_DWORD *)(4LL * v7 + a3);
}
else
{
v4 = v17++;
v5 = (_DWORD *)(4LL * v4 + a1);
}
v6 = v19++;
v20[v6] = *v5;
}
while ( v17 < a2 )
{
v8 = v17++;
v9 = (_DWORD *)(4LL * v8 + a1);
v10 = v19++;
v20[v10] = *v9;
}
while ( v18 < a4 )
{
v11 = v18++;
v12 = (_DWORD *)(4LL * v11 + a3);
v13 = v19++;
v20[v13] = *v12;
}
return v20;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x30],ECX
MOV EDX,dword ptr [RBP + -0x2c]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EDX
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012bb
LAB_00101217:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x00101282
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 + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
JMP 0x001012bb
LAB_00101282:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_001012bb:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x0010130a
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101217
JMP 0x0010130a
LAB_001012d1:
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 + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010130a:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001012d1
JMP 0x0010134d
LAB_00101314:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010134d:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101314
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
int local_1c;
int local_18;
int local_14;
pvVar1 = malloc((long)(param_4 + param_2) << 2);
local_1c = 0;
local_18 = 0;
local_14 = 0;
while ((local_1c < param_2 && (local_18 < param_4))) {
if (*(int *)(param_1 + (long)local_1c * 4) < *(int *)(param_3 + (long)local_18 * 4)) {
*(int4 *)((long)local_14 * 4 + (long)pvVar1) =
*(int4 *)((long)local_1c * 4 + param_1);
local_1c = local_1c + 1;
local_14 = local_14 + 1;
}
else {
*(int4 *)((long)local_14 * 4 + (long)pvVar1) =
*(int4 *)((long)local_18 * 4 + param_3);
local_18 = local_18 + 1;
local_14 = local_14 + 1;
}
}
while (local_1c < param_2) {
*(int4 *)((long)local_14 * 4 + (long)pvVar1) =
*(int4 *)((long)local_1c * 4 + param_1);
local_1c = local_1c + 1;
local_14 = local_14 + 1;
}
while (local_18 < param_4) {
*(int4 *)((long)local_14 * 4 + (long)pvVar1) =
*(int4 *)((long)local_18 * 4 + param_3);
local_18 = local_18 + 1;
local_14 = local_14 + 1;
}
return pvVar1;
} |
7,665 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
result[k++] = num1[i++];
} else {
result[k++] = num2[j++];
}
}
// If there are remaining elements in num1, add them
while (i < size1) {
result[k++] = num1[i++];
}
// If there are remaining elements in num2, add them
while (j < size2) {
result[k++] = num2[j++];
}
return result;
}
| int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int arr4[] = {2, 5, 7, 11};
int expected2[] = {1, 2, 3, 5, 5, 6, 7, 8, 9, 11};
int* result2 = func0(arr3, 6, arr4, 4);
for (int i = 0; i < 10; i++) assert(result2[i] == expected2[i]);
int arr5[] = {1, 3, 7};
int arr6[] = {2, 4, 6};
int expected3[] = {1, 2, 3, 4, 6, 7};
int* result3 = func0(arr5, 3, arr6, 3);
for (int i = 0; i < 6; i++) assert(result3[i] == expected3[i]);
// Free allocated memory
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%ebx
mov %rdx,%r12
mov %ecx,%ebp
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebx,%ebx
jle 123f <func0+0x76>
test %ebp,%ebp
jle 123f <func0+0x76>
mov $0x0,%ecx
mov $0x0,%edx
mov $0x0,%edi
jmp 121f <func0+0x56>
add $0x1,%edx
lea 0x1(%rcx),%esi
mov %r8d,(%rax,%rcx,4)
add $0x1,%rcx
cmp %ebx,%edi
jge 124e <func0+0x85>
cmp %ebp,%edx
jge 124e <func0+0x85>
movslq %edi,%rsi
mov 0x0(%r13,%rsi,4),%r9d
movslq %edx,%rsi
mov (%r12,%rsi,4),%r8d
cmp %r8d,%r9d
jge 1209 <func0+0x40>
add $0x1,%edi
lea 0x1(%rcx),%esi
mov %r9d,(%rax,%rcx,4)
jmp 1213 <func0+0x4a>
mov $0x0,%esi
mov $0x0,%edx
mov $0x0,%edi
cmp %edi,%ebx
jle 1276 <func0+0xad>
movslq %edi,%rcx
movslq %esi,%r8
sub %rcx,%r8
lea (%rax,%r8,4),%r9
mov 0x0(%r13,%rcx,4),%r8d
mov %r8d,(%r9,%rcx,4)
add $0x1,%rcx
cmp %ecx,%ebx
jg 125f <func0+0x96>
add %esi,%ebx
sub %edi,%ebx
mov %ebx,%esi
cmp %edx,%ebp
jle 1296 <func0+0xcd>
movslq %edx,%rdx
movslq %esi,%rbx
sub %rdx,%rbx
lea (%rax,%rbx,4),%rsi
mov (%r12,%rdx,4),%ecx
mov %ecx,(%rsi,%rdx,4)
add $0x1,%rdx
cmp %edx,%ebp
jg 1287 <func0+0xbe>
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 r13, rdi
mov ebx, esi
mov r12, rdx
mov ebp, ecx
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r9, rax
test ebx, ebx
jle short loc_1245
test ebp, ebp
jle short loc_1245
mov rsi, rax
mov edx, 1
mov eax, 0
mov ecx, 0
jmp short loc_1226
loc_120F:
add eax, 1
mov r10d, edx
mov [rsi], edi
loc_1217:
add edx, 1
add rsi, 4
cmp ecx, ebx
jge short loc_1255
cmp eax, ebp
jge short loc_1255
loc_1226:
movsxd rdi, ecx
mov r8d, [r13+rdi*4+0]
movsxd rdi, eax
mov edi, [r12+rdi*4]
cmp r8d, edi
jge short loc_120F
add ecx, 1
mov r10d, edx
mov [rsi], r8d
jmp short loc_1217
loc_1245:
mov r10d, 0
mov eax, 0
mov ecx, 0
loc_1255:
cmp ebx, ecx
jle short loc_127E
movsxd rdx, ecx
movsxd rsi, r10d
sub rsi, rdx
lea rdi, [r9+rsi*4]
loc_1266:
mov esi, [r13+rdx*4+0]
mov [rdi+rdx*4], esi
add rdx, 1
cmp ebx, edx
jg short loc_1266
add ebx, r10d
sub ebx, ecx
mov r10d, ebx
loc_127E:
cmp ebp, eax
jle short loc_129D
cdqe
movsxd r10, r10d
sub r10, rax
lea rcx, [r9+r10*4]
loc_128E:
mov edx, [r12+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp ebp, eax
jg short loc_128E
loc_129D:
mov rax, r9
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v8; // rax
long long v9; // r9
_DWORD *v10; // rsi
int v11; // edx
int v12; // ecx
int v13; // r10d
int v14; // r8d
int v15; // edi
long long v16; // rdx
long long v17; // r10
v8 = malloc(4LL * (a2 + a4));
v9 = v8;
if ( a2 <= 0 || a4 <= 0 )
{
v13 = 0;
LODWORD(v8) = 0;
v12 = 0;
}
else
{
v10 = (_DWORD *)v8;
v11 = 1;
LODWORD(v8) = 0;
v12 = 0;
do
{
v14 = *(_DWORD *)(a1 + 4LL * v12);
v15 = *(_DWORD *)(a3 + 4LL * (int)v8);
if ( v14 >= v15 )
{
LODWORD(v8) = v8 + 1;
v13 = v11;
*v10 = v15;
}
else
{
++v12;
v13 = v11;
*v10 = v14;
}
++v11;
++v10;
}
while ( v12 < a2 && (int)v8 < a4 );
}
if ( a2 > v12 )
{
v16 = v12;
do
{
*(_DWORD *)(v9 + 4 * (v13 - (long long)v12) + 4 * v16) = *(_DWORD *)(a1 + 4 * v16);
++v16;
}
while ( a2 > (int)v16 );
v13 = v13 + a2 - v12;
}
if ( a4 > (int)v8 )
{
v8 = (int)v8;
v17 = v13 - (long long)(int)v8;
do
{
*(_DWORD *)(v9 + 4 * v17 + 4 * v8) = *(_DWORD *)(a3 + 4 * v8);
++v8;
}
while ( a4 > (int)v8 );
}
return v9;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV EBX,ESI
MOV R12,RDX
MOV EBP,ECX
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R9,RAX
TEST EBX,EBX
JLE 0x00101245
TEST EBP,EBP
JLE 0x00101245
MOV RSI,RAX
MOV EDX,0x1
MOV EAX,0x0
MOV ECX,0x0
JMP 0x00101226
LAB_0010120f:
ADD EAX,0x1
MOV R10D,EDX
MOV dword ptr [RSI],EDI
LAB_00101217:
ADD EDX,0x1
ADD RSI,0x4
CMP ECX,EBX
JGE 0x00101255
CMP EAX,EBP
JGE 0x00101255
LAB_00101226:
MOVSXD RDI,ECX
MOV R8D,dword ptr [R13 + RDI*0x4]
MOVSXD RDI,EAX
MOV EDI,dword ptr [R12 + RDI*0x4]
CMP R8D,EDI
JGE 0x0010120f
ADD ECX,0x1
MOV R10D,EDX
MOV dword ptr [RSI],R8D
JMP 0x00101217
LAB_00101245:
MOV R10D,0x0
MOV EAX,0x0
MOV ECX,0x0
LAB_00101255:
CMP EBX,ECX
JLE 0x0010127e
MOVSXD RDX,ECX
MOVSXD RSI,R10D
SUB RSI,RDX
LEA RDI,[R9 + RSI*0x4]
LAB_00101266:
MOV ESI,dword ptr [R13 + RDX*0x4]
MOV dword ptr [RDI + RDX*0x4],ESI
ADD RDX,0x1
CMP EBX,EDX
JG 0x00101266
ADD EBX,R10D
SUB EBX,ECX
MOV R10D,EBX
LAB_0010127e:
CMP EBP,EAX
JLE 0x0010129d
CDQE
MOVSXD R10,R10D
SUB R10,RAX
LEA RCX,[R9 + R10*0x4]
LAB_0010128e:
MOV EDX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP EBP,EAX
JG 0x0010128e
LAB_0010129d:
MOV RAX,R9
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int * func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int iVar5;
long lVar6;
int iVar7;
int *piVar8;
long lVar9;
piVar4 = (int *)malloc((long)(param_2 + param_4) << 2);
if ((param_2 < 1) || (param_4 < 1)) {
iVar7 = 0;
iVar3 = 0;
iVar5 = 0;
}
else {
iVar3 = 0;
iVar5 = 0;
piVar8 = piVar4;
iVar1 = 1;
do {
iVar7 = iVar1;
iVar1 = *(int *)(param_1 + (long)iVar5 * 4);
iVar2 = *(int *)(param_3 + (long)iVar3 * 4);
if (iVar1 < iVar2) {
iVar5 = iVar5 + 1;
*piVar8 = iVar1;
}
else {
iVar3 = iVar3 + 1;
*piVar8 = iVar2;
}
piVar8 = piVar8 + 1;
} while ((iVar5 < param_2) && (iVar1 = iVar7 + 1, iVar3 < param_4));
}
if (iVar5 < param_2) {
lVar6 = (long)iVar5;
lVar9 = iVar7 - lVar6;
do {
piVar4[lVar9 + lVar6] = *(int *)(param_1 + lVar6 * 4);
lVar6 = lVar6 + 1;
} while ((int)lVar6 < param_2);
iVar7 = (param_2 + iVar7) - iVar5;
}
if (iVar3 < param_4) {
lVar6 = (long)iVar3;
lVar9 = iVar7 - lVar6;
do {
piVar4[lVar9 + lVar6] = *(int *)(param_3 + lVar6 * 4);
lVar6 = lVar6 + 1;
} while ((int)lVar6 < param_4);
}
return piVar4;
} |
7,666 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
result[k++] = num1[i++];
} else {
result[k++] = num2[j++];
}
}
// If there are remaining elements in num1, add them
while (i < size1) {
result[k++] = num1[i++];
}
// If there are remaining elements in num2, add them
while (j < size2) {
result[k++] = num2[j++];
}
return result;
}
| int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int arr4[] = {2, 5, 7, 11};
int expected2[] = {1, 2, 3, 5, 5, 6, 7, 8, 9, 11};
int* result2 = func0(arr3, 6, arr4, 4);
for (int i = 0; i < 10; i++) assert(result2[i] == expected2[i]);
int arr5[] = {1, 3, 7};
int arr6[] = {2, 4, 6};
int expected3[] = {1, 2, 3, 4, 6, 7};
int* result3 = func0(arr5, 3, arr6, 3);
for (int i = 0; i < 6; i++) assert(result3[i] == expected3[i]);
// Free allocated memory
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
lea (%rsi,%rcx,1),%edi
push %r12
movslq %edi,%rdi
mov %rdx,%r12
push %rbp
shl $0x2,%rdi
mov %ecx,%ebp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %ebx,%ebx
jle 1610 <func0+0xf0>
test %ebp,%ebp
jle 1610 <func0+0xf0>
mov $0x1,%edi
xor %esi,%esi
xor %r8d,%r8d
jmp 157e <func0+0x5e>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
mov %r9d,-0x4(%rax,%rdi,4)
add $0x1,%rdi
cmp %ebx,%r8d
jge 15a5 <func0+0x85>
cmp %ebp,%esi
jge 15a5 <func0+0x85>
movslq %r8d,%rdx
mov %edi,%r10d
mov 0x0(%r13,%rdx,4),%r9d
movslq %esi,%rdx
mov (%r12,%rdx,4),%ecx
cmp %ecx,%r9d
jl 1568 <func0+0x48>
mov %ecx,-0x4(%rax,%rdi,4)
add $0x1,%esi
add $0x1,%rdi
cmp %ebx,%r8d
jl 157a <func0+0x5a>
cmp %r8d,%ebx
jle 15d9 <func0+0xb9>
movslq %r8d,%rdi
movslq %r10d,%rdx
sub %rdi,%rdx
lea (%rax,%rdx,4),%rcx
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13,%rdi,4),%edx
mov %edx,(%rcx,%rdi,4)
add $0x1,%rdi
cmp %edi,%ebx
jg 15c0 <func0+0xa0>
add %r10d,%ebx
sub %r8d,%ebx
mov %ebx,%r10d
cmp %esi,%ebp
jle 15ff <func0+0xdf>
movslq %esi,%rsi
movslq %r10d,%rbx
sub %rsi,%rbx
lea (%rax,%rbx,4),%rcx
nopw 0x0(%rax,%rax,1)
mov (%r12,%rsi,4),%edx
mov %edx,(%rcx,%rsi,4)
add $0x1,%rsi
cmp %esi,%ebp
jg 15f0 <func0+0xd0>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
xor %r10d,%r10d
xor %esi,%esi
xor %r8d,%r8d
jmp 15a5 <func0+0x85>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov r15, rdx
push r14
push r13
mov r13d, esi
push r12
mov r12d, ecx
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2
call _malloc
test r13d, r13d
mov r8, [rsp+48h+var_40]
mov r14, rax
jle loc_1650
test r12d, r12d
jle loc_1650
mov eax, 1
xor ebx, ebx
xor ebp, ebp
jmp short loc_15AE
loc_1598:
add ebp, 1
mov [r14+rax*4-4], edx
add rax, 1
cmp ebp, r13d
jge short loc_15D6
loc_15A9:
cmp ebx, r12d
jge short loc_15D6
loc_15AE:
movsxd rdx, ebp
movsxd rcx, ebx
mov r9d, eax
mov edx, [r8+rdx*4]
mov ecx, [r15+rcx*4]
cmp edx, ecx
jl short loc_1598
mov edx, ecx
add ebx, 1
mov [r14+rax*4-4], edx
add rax, 1
cmp ebp, r13d
jl short loc_15A9
loc_15D6:
cmp r13d, ebp
jle short loc_160F
movsxd rax, r9d
mov dword ptr [rsp+48h+var_40], r9d
lea rdi, [r14+rax*4]
lea eax, [r13-1]
sub eax, ebp
lea rdx, ds:4[rax*4]
movsxd rax, ebp
lea rsi, [r8+rax*4]
call _memcpy
mov r9d, dword ptr [rsp+48h+var_40]
add r13d, r9d
mov r9d, r13d
sub r9d, ebp
loc_160F:
cmp r12d, ebx
jle short loc_1636
sub r12d, 1
movsxd r9, r9d
sub r12d, ebx
movsxd rbx, ebx
lea rdi, [r14+r9*4]
lea rdx, ds:4[r12*4]
lea rsi, [r15+rbx*4]
call _memcpy
loc_1636:
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1650:
xor r9d, r9d
xor ebx, ebx
xor ebp, ebp
jmp loc_15D6 | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v6; // r14
long long v7; // rax
int v8; // ebx
int v9; // ebp
int v10; // r9d
int v11; // edx
int v12; // ecx
int v14; // [rsp+8h] [rbp-40h]
v6 = malloc(4LL * (a2 + a4));
if ( a2 > 0 && a4 > 0 )
{
v7 = 1LL;
v8 = 0;
v9 = 0;
while ( 1 )
{
v10 = v7;
v11 = *(_DWORD *)(a1 + 4LL * v9);
v12 = *(_DWORD *)(a3 + 4LL * v8);
if ( v11 < v12 )
{
++v9;
*(_DWORD *)(v6 + 4 * v7++ - 4) = v11;
if ( v9 >= a2 )
goto LABEL_8;
}
else
{
++v8;
*(_DWORD *)(v6 + 4 * v7++ - 4) = v12;
if ( v9 >= a2 )
goto LABEL_8;
}
if ( v8 >= a4 )
goto LABEL_8;
}
}
v10 = 0;
v8 = 0;
v9 = 0;
LABEL_8:
if ( a2 > v9 )
{
v14 = v10;
memcpy(v6 + 4LL * v10, a1 + 4LL * v9, 4LL * (unsigned int)(a2 - 1 - v9) + 4);
v10 = v14 + a2 - v9;
}
if ( a4 > v8 )
memcpy(v6 + 4LL * v10, a3 + 4LL * v8, 4LL * (unsigned int)(a4 - 1 - v8) + 4);
return v6;
} | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12D,ECX
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010f0
TEST R13D,R13D
MOV R8,qword ptr [RSP + 0x8]
MOV R14,RAX
JLE 0x00101650
TEST R12D,R12D
JLE 0x00101650
MOV EAX,0x1
XOR EBX,EBX
XOR EBP,EBP
JMP 0x001015ae
LAB_00101598:
ADD EBP,0x1
MOV dword ptr [R14 + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP EBP,R13D
JGE 0x001015d6
LAB_001015a9:
CMP EBX,R12D
JGE 0x001015d6
LAB_001015ae:
MOVSXD RDX,EBP
MOVSXD RCX,EBX
MOV R9D,EAX
MOV EDX,dword ptr [R8 + RDX*0x4]
MOV ECX,dword ptr [R15 + RCX*0x4]
CMP EDX,ECX
JL 0x00101598
MOV EDX,ECX
ADD EBX,0x1
MOV dword ptr [R14 + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP EBP,R13D
JL 0x001015a9
LAB_001015d6:
CMP R13D,EBP
JLE 0x0010160f
MOVSXD RAX,R9D
MOV dword ptr [RSP + 0x8],R9D
LEA RDI,[R14 + RAX*0x4]
LEA EAX,[R13 + -0x1]
SUB EAX,EBP
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,EBP
LEA RSI,[R8 + RAX*0x4]
CALL 0x001010e0
MOV R9D,dword ptr [RSP + 0x8]
ADD R13D,R9D
MOV R9D,R13D
SUB R9D,EBP
LAB_0010160f:
CMP R12D,EBX
JLE 0x00101636
SUB R12D,0x1
MOVSXD R9,R9D
SUB R12D,EBX
MOVSXD RBX,EBX
LEA RDI,[R14 + R9*0x4]
LEA RDX,[0x4 + R12*0x4]
LEA RSI,[R15 + RBX*0x4]
CALL 0x001010e0
LAB_00101636:
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101650:
XOR R9D,R9D
XOR EBX,EBX
XOR EBP,EBP
JMP 0x001015d6 | void * func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
void *pvVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
pvVar3 = malloc((long)(param_2 + param_4) << 2);
if ((param_2 < 1) || (param_4 < 1)) {
iVar7 = 0;
iVar5 = 0;
iVar6 = 0;
}
else {
lVar4 = 1;
iVar5 = 0;
iVar6 = 0;
do {
iVar7 = (int)lVar4;
iVar1 = *(int *)(param_1 + (long)iVar6 * 4);
iVar2 = *(int *)(param_3 + (long)iVar5 * 4);
if (iVar1 < iVar2) {
iVar6 = iVar6 + 1;
*(int *)((long)pvVar3 + lVar4 * 4 + -4) = iVar1;
}
else {
iVar5 = iVar5 + 1;
*(int *)((long)pvVar3 + lVar4 * 4 + -4) = iVar2;
}
} while ((iVar6 < param_2) && (lVar4 = lVar4 + 1, iVar5 < param_4));
}
if (iVar6 < param_2) {
memcpy((void *)((long)pvVar3 + (long)iVar7 * 4),(void *)(param_1 + (long)iVar6 * 4),
(ulong)(uint)((param_2 + -1) - iVar6) * 4 + 4);
iVar7 = (param_2 + iVar7) - iVar6;
}
if (iVar5 < param_4) {
memcpy((void *)((long)pvVar3 + (long)iVar7 * 4),(void *)(param_3 + (long)iVar5 * 4),
(ulong)(uint)((param_4 + -1) - iVar5) * 4 + 4);
}
return pvVar3;
} |
7,667 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
result[k++] = num1[i++];
} else {
result[k++] = num2[j++];
}
}
// If there are remaining elements in num1, add them
while (i < size1) {
result[k++] = num1[i++];
}
// If there are remaining elements in num2, add them
while (j < size2) {
result[k++] = num2[j++];
}
return result;
}
| int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int arr4[] = {2, 5, 7, 11};
int expected2[] = {1, 2, 3, 5, 5, 6, 7, 8, 9, 11};
int* result2 = func0(arr3, 6, arr4, 4);
for (int i = 0; i < 10; i++) assert(result2[i] == expected2[i]);
int arr5[] = {1, 3, 7};
int arr6[] = {2, 4, 6};
int expected3[] = {1, 2, 3, 4, 6, 7};
int* result3 = func0(arr5, 3, arr6, 3);
for (int i = 0; i < 6; i++) assert(result3[i] == expected3[i]);
// Free allocated memory
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov %esi,%r15d
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %ecx,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,0x8(%rsp)
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
test %r15d,%r15d
mov 0x8(%rsp),%r8
mov %rax,%r14
jle 1688 <func0+0xa8>
test %r12d,%r12d
jle 1688 <func0+0xa8>
mov $0x1,%eax
xor %ebx,%ebx
xor %ebp,%ebp
xor %r9d,%r9d
xor %edi,%edi
mov (%r8,%r9,4),%esi
mov 0x0(%r13,%rdi,4),%edx
mov %eax,%ecx
cmp %edx,%esi
jge 1667 <func0+0x87>
add $0x1,%ebp
mov %esi,-0x4(%r14,%rax,4)
add $0x1,%rax
cmp %r15d,%ebp
jge 1690 <func0+0xb0>
cmp %ebx,%r12d
jle 1690 <func0+0xb0>
movslq %ebp,%r9
mov 0x0(%r13,%rdi,4),%edx
mov %eax,%ecx
mov (%r8,%r9,4),%esi
cmp %edx,%esi
jl 163f <func0+0x5f>
add $0x1,%ebx
mov %edx,-0x4(%r14,%rax,4)
add $0x1,%rax
cmp %r12d,%ebx
jge 1690 <func0+0xb0>
cmp %ebp,%r15d
jle 16c6 <func0+0xe6>
movslq %ebx,%rdi
jmp 1630 <func0+0x50>
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
xor %ebx,%ebx
xor %ebp,%ebp
xchg %ax,%ax
cmp %ebp,%r15d
jle 16c6 <func0+0xe6>
movslq %ecx,%rax
mov %ecx,0x8(%rsp)
lea (%r14,%rax,4),%rdi
lea -0x1(%r15),%eax
sub %ebp,%eax
lea 0x4(,%rax,4),%rdx
movslq %ebp,%rax
lea (%r8,%rax,4),%rsi
callq 10e0 <memcpy@plt>
mov 0x8(%rsp),%ecx
add %ecx,%r15d
mov %r15d,%ecx
sub %ebp,%ecx
cmp %ebx,%r12d
jle 16ee <func0+0x10e>
sub $0x1,%r12d
movslq %ecx,%r15
sub %ebx,%r12d
movslq %ebx,%rbx
lea (%r14,%r15,4),%rdi
lea 0x4(,%r12,4),%rdx
lea 0x0(%r13,%rbx,4),%rsi
callq 10e0 <memcpy@plt>
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
mov r15d, esi
push r14
push r13
mov r13, rdx
push r12
mov r12d, ecx
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2; size
call _malloc
test r15d, r15d
mov r8, [rsp+48h+var_40]
mov r14, rax
jle short loc_1558
test r12d, r12d
jle short loc_1558
mov eax, 1
xor ebx, ebx
xor ebp, ebp
xor edi, edi
xor esi, esi
xchg ax, ax
loc_1500:
mov ecx, [r8+rdi*4]
mov edx, [r13+rsi*4+0]
movsxd r9, eax
cmp ecx, edx
jge short loc_1539
loc_1510:
add ebp, 1
mov [r14+rax*4-4], ecx
add rax, 1
cmp ebp, r15d
jge short loc_1560
cmp r12d, ebx
jle short loc_1560
movsxd rdi, ebp
mov edx, [r13+rsi*4+0]
movsxd r9, eax
mov ecx, [r8+rdi*4]
cmp ecx, edx
jl short loc_1510
loc_1539:
add ebx, 1
mov [r14+rax*4-4], edx
add rax, 1
cmp ebx, r12d
jge short loc_1560
cmp r15d, ebp
jle short loc_1599
movsxd rsi, ebx
jmp short loc_1500
loc_1558:
xor r9d, r9d
xor ebx, ebx
xor ebp, ebp
nop
loc_1560:
cmp r15d, ebp
jle short loc_1599
movsxd rax, r9d
mov dword ptr [rsp+48h+var_40], r9d
lea rdi, [r14+rax*4]; dest
lea eax, [r15-1]
sub eax, ebp
lea rdx, ds:4[rax*4]; n
movsxd rax, ebp
lea rsi, [r8+rax*4]; src
call _memcpy
mov r9d, dword ptr [rsp+48h+var_40]
add r15d, r9d
sub r15d, ebp
movsxd r9, r15d
loc_1599:
cmp r12d, ebx
jle short loc_15BE
sub r12d, 1
lea rdi, [r14+r9*4]; dest
sub r12d, ebx
movsxd rbx, ebx
lea rdx, ds:4[r12*4]; n
lea rsi, [r13+rbx*4+0]; src
call _memcpy
loc_15BE:
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
_DWORD *v7; // rax
_DWORD *v9; // r14
long long v10; // rax
int v11; // ebx
int v12; // ebp
long long v13; // rdi
long long i; // rsi
int v15; // ecx
int v16; // edx
long long v17; // r9
int v19; // [rsp+8h] [rbp-40h]
v7 = malloc(4LL * (a2 + a4));
v9 = v7;
if ( a2 <= 0 || a4 <= 0 )
{
v17 = 0LL;
v11 = 0;
v12 = 0;
}
else
{
v10 = 1LL;
v11 = 0;
v12 = 0;
v13 = 0LL;
for ( i = 0LL; ; i = v11 )
{
v15 = *(_DWORD *)(a1 + 4 * v13);
v16 = *(_DWORD *)(a3 + 4 * i);
v17 = (int)v10;
if ( v15 < v16 )
break;
LABEL_8:
++v11;
v9[v10++ - 1] = v16;
if ( v11 >= a4 )
goto LABEL_12;
if ( a2 <= v12 )
goto LABEL_14;
}
while ( 1 )
{
++v12;
v9[v10++ - 1] = v15;
if ( v12 >= a2 || a4 <= v11 )
break;
v13 = v12;
v16 = *(_DWORD *)(a3 + 4 * i);
v17 = (int)v10;
v15 = *(_DWORD *)(a1 + 4LL * v12);
if ( v15 >= v16 )
goto LABEL_8;
}
}
LABEL_12:
if ( a2 > v12 )
{
v19 = v17;
memcpy(&v9[(int)v17], (const void *)(a1 + 4LL * v12), 4LL * (unsigned int)(a2 - 1 - v12) + 4);
v17 = v19 + a2 - v12;
}
LABEL_14:
if ( a4 > v11 )
memcpy(&v9[v17], (const void *)(a3 + 4LL * v11), 4LL * (unsigned int)(a4 - 1 - v11) + 4);
return v9;
} | func0:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12D,ECX
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010f0
TEST R15D,R15D
MOV R8,qword ptr [RSP + 0x8]
MOV R14,RAX
JLE 0x00101558
TEST R12D,R12D
JLE 0x00101558
MOV EAX,0x1
XOR EBX,EBX
XOR EBP,EBP
XOR EDI,EDI
XOR ESI,ESI
NOP
LAB_00101500:
MOV ECX,dword ptr [R8 + RDI*0x4]
MOV EDX,dword ptr [R13 + RSI*0x4]
MOVSXD R9,EAX
CMP ECX,EDX
JGE 0x00101539
LAB_00101510:
ADD EBP,0x1
MOV dword ptr [R14 + RAX*0x4 + -0x4],ECX
ADD RAX,0x1
CMP EBP,R15D
JGE 0x00101560
CMP R12D,EBX
JLE 0x00101560
MOVSXD RDI,EBP
MOV EDX,dword ptr [R13 + RSI*0x4]
MOVSXD R9,EAX
MOV ECX,dword ptr [R8 + RDI*0x4]
CMP ECX,EDX
JL 0x00101510
LAB_00101539:
ADD EBX,0x1
MOV dword ptr [R14 + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP EBX,R12D
JGE 0x00101560
CMP R15D,EBP
JLE 0x00101599
MOVSXD RSI,EBX
JMP 0x00101500
LAB_00101558:
XOR R9D,R9D
XOR EBX,EBX
XOR EBP,EBP
NOP
LAB_00101560:
CMP R15D,EBP
JLE 0x00101599
MOVSXD RAX,R9D
MOV dword ptr [RSP + 0x8],R9D
LEA RDI,[R14 + RAX*0x4]
LEA EAX,[R15 + -0x1]
SUB EAX,EBP
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,EBP
LEA RSI,[R8 + RAX*0x4]
CALL 0x001010e0
MOV R9D,dword ptr [RSP + 0x8]
ADD R15D,R9D
SUB R15D,EBP
MOVSXD R9,R15D
LAB_00101599:
CMP R12D,EBX
JLE 0x001015be
SUB R12D,0x1
LEA RDI,[R14 + R9*0x4]
SUB R12D,EBX
MOVSXD RBX,EBX
LEA RDX,[0x4 + R12*0x4]
LEA RSI,[R13 + RBX*0x4]
CALL 0x001010e0
LAB_001015be:
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
long lVar7;
long lVar8;
long lVar9;
pvVar1 = malloc((long)(param_2 + param_4) << 2);
if ((param_2 < 1) || (param_4 < 1)) {
lVar9 = 0;
iVar5 = 0;
iVar6 = 0;
LAB_00101560:
if (iVar6 < param_2) {
memcpy((void *)((long)pvVar1 + (long)(int)lVar9 * 4),(void *)(param_1 + (long)iVar6 * 4),
(ulong)(uint)((param_2 + -1) - iVar6) * 4 + 4);
lVar9 = (long)((param_2 + (int)lVar9) - iVar6);
}
}
else {
lVar2 = 1;
iVar5 = 0;
iVar6 = 0;
lVar8 = 0;
lVar7 = 0;
while( true ) {
iVar3 = *(int *)(param_1 + lVar8 * 4);
iVar4 = *(int *)(param_3 + lVar7 * 4);
lVar9 = (long)(int)lVar2;
if (iVar3 < iVar4) {
do {
iVar6 = iVar6 + 1;
*(int *)((long)pvVar1 + lVar2 * 4 + -4) = iVar3;
lVar2 = lVar2 + 1;
if ((param_2 <= iVar6) || (param_4 <= iVar5)) goto LAB_00101560;
lVar8 = (long)iVar6;
iVar4 = *(int *)(param_3 + lVar7 * 4);
lVar9 = (long)(int)lVar2;
iVar3 = *(int *)(param_1 + lVar8 * 4);
} while (iVar3 < iVar4);
}
iVar5 = iVar5 + 1;
*(int *)((long)pvVar1 + lVar2 * 4 + -4) = iVar4;
lVar2 = lVar2 + 1;
if (param_4 <= iVar5) goto LAB_00101560;
if (param_2 <= iVar6) break;
lVar7 = (long)iVar5;
}
}
if (iVar5 < param_4) {
memcpy((void *)((long)pvVar1 + lVar9 * 4),(void *)(param_3 + (long)iVar5 * 4),
(ulong)(uint)((param_4 + -1) - iVar5) * 4 + 4);
}
return pvVar1;
} |
7,668 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11bc <func0+0x53>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 11b8 <func0+0x4f>
mov -0x4(%rbp),%eax
jmp 11d5 <func0+0x6c>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1182 <func0+0x19>
mov $0xffffffff,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_11BC
loc_1182:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_11B8
mov eax, [rbp+var_4]
jmp short locret_11D5
loc_11B8:
add [rbp+var_4], 1
loc_11BC:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1182
mov eax, 0FFFFFFFFh
locret_11D5:
leave
retn | long long func0(long long a1)
{
unsigned int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; *(_BYTE *)((int)i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)((int)i + a1)] & 0x800) != 0 )
return i;
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bc
LAB_00101182:
CALL 0x00101070
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x001011b8
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x001011d5
LAB_001011b8:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011bc:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101182
MOV EAX,0xffffffff
LAB_001011d5:
LEAVE
RET | int func0(long param_1)
{
ushort **ppuVar1;
int local_c;
local_c = 0;
while( true ) {
if (*(char *)(param_1 + local_c) == '\0') {
return -1;
}
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 + local_c)] & 0x800) != 0) break;
local_c = local_c + 1;
}
return local_c;
} |
7,669 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 11b2 <func0+0x49>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rcx
mov $0x0,%eax
mov %eax,%edx
movsbq %bl,%rbx
testb $0x8,0x1(%rcx,%rbx,2)
jne 11a9 <func0+0x40>
add $0x1,%rax
movzbl 0x0(%rbp,%rax,1),%ebx
test %bl,%bl
jne 118a <func0+0x21>
mov $0xffffffff,%edx
mov %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
mov $0xffffffff,%edx
jmp 11a9 <func0+0x40>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11B2
mov rbp, rdi
call ___ctype_b_loc
mov rcx, [rax]
mov eax, 0
loc_118A:
mov edx, eax
movsx rbx, bl
test byte ptr [rcx+rbx*2+1], 8
jnz short loc_11A9
add rax, 1
movzx ebx, byte ptr [rbp+rax+0]
test bl, bl
jnz short loc_118A
mov edx, 0FFFFFFFFh
loc_11A9:
mov eax, edx
add rsp, 8
pop rbx
pop rbp
retn
loc_11B2:
mov edx, 0FFFFFFFFh
jmp short loc_11A9 | long long func0(char *a1)
{
char v1; // bl
long long v2; // rcx
long long v3; // rax
unsigned int v4; // edx
v1 = *a1;
if ( *a1 )
{
v2 = *(_QWORD *)__ctype_b_loc();
v3 = 0LL;
while ( 1 )
{
v4 = v3;
if ( (*(_BYTE *)(v2 + 2LL * v1 + 1) & 8) != 0 )
break;
v1 = a1[++v3];
if ( !v1 )
return (unsigned int)-1;
}
}
else
{
return (unsigned int)-1;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011b2
MOV RBP,RDI
CALL 0x00101070
MOV RCX,qword ptr [RAX]
MOV EAX,0x0
LAB_0010118a:
MOV EDX,EAX
MOVSX RBX,BL
TEST byte ptr [RCX + RBX*0x2 + 0x1],0x8
JNZ 0x001011a9
ADD RAX,0x1
MOVZX EBX,byte ptr [RBP + RAX*0x1]
TEST BL,BL
JNZ 0x0010118a
MOV EDX,0xffffffff
LAB_001011a9:
MOV EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011b2:
MOV EDX,0xffffffff
JMP 0x001011a9 | ulong func0(char *param_1)
{
ushort **ppuVar1;
ulong uVar2;
char cVar3;
cVar3 = *param_1;
if (cVar3 != '\0') {
ppuVar1 = __ctype_b_loc();
uVar2 = 0;
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar3 * 2 + 1) & 8) != 0) {
return uVar2 & 0xffffffff;
}
uVar2 = uVar2 + 1;
cVar3 = param_1[uVar2];
} while (cVar3 != '\0');
}
return 0xffffffff;
} |
7,670 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1260 <func0+0x50>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rdx
xor %eax,%eax
jmp 1246 <func0+0x36>
nopl 0x0(%rax)
add $0x1,%rax
movsbq 0x0(%rbp,%rax,1),%rbx
test %bl,%bl
je 1260 <func0+0x50>
mov %eax,%r8d
testb $0x8,0x1(%rdx,%rbx,2)
je 1238 <func0+0x28>
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
mov $0xffffffff,%r8d
mov %r8d,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1260
mov rbp, rdi
call ___ctype_b_loc
mov rdx, [rax]
xor eax, eax
jmp short loc_1246
loc_1238:
add rax, 1
movsx rbx, byte ptr [rbp+rax+0]
test bl, bl
jz short loc_1260
loc_1246:
mov r8d, eax
test byte ptr [rdx+rbx*2+1], 8
jz short loc_1238
add rsp, 8
mov eax, r8d
pop rbx
pop rbp
retn
loc_1260:
add rsp, 8
mov r8d, 0FFFFFFFFh
mov eax, r8d
pop rbx
pop rbp
retn | long long func0(char *a1)
{
long long v1; // rbx
long long v2; // rdx
long long result; // rax
v1 = *a1;
if ( !(_BYTE)v1 )
return 0xFFFFFFFFLL;
v2 = *(_QWORD *)__ctype_b_loc();
result = 0LL;
while ( (*(_BYTE *)(v2 + 2 * v1 + 1) & 8) == 0 )
{
v1 = a1[++result];
if ( !(_BYTE)v1 )
return 0xFFFFFFFFLL;
}
return (unsigned int)result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101260
MOV RBP,RDI
CALL 0x00101070
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
JMP 0x00101246
LAB_00101238:
ADD RAX,0x1
MOVSX RBX,byte ptr [RBP + RAX*0x1]
TEST BL,BL
JZ 0x00101260
LAB_00101246:
MOV R8D,EAX
TEST byte ptr [RDX + RBX*0x2 + 0x1],0x8
JZ 0x00101238
ADD RSP,0x8
MOV EAX,R8D
POP RBX
POP RBP
RET
LAB_00101260:
ADD RSP,0x8
MOV R8D,0xffffffff
MOV EAX,R8D
POP RBX
POP RBP
RET | ulong func0(char *param_1)
{
char cVar1;
ushort **ppuVar2;
ulong uVar3;
cVar1 = *param_1;
if (cVar1 != '\0') {
ppuVar2 = __ctype_b_loc();
uVar3 = 0;
do {
if ((*(byte *)((long)*ppuVar2 + (long)cVar1 * 2 + 1) & 8) != 0) {
return uVar3 & 0xffffffff;
}
uVar3 = uVar3 + 1;
cVar1 = param_1[uVar3];
} while (cVar1 != '\0');
}
return 0xffffffff;
} |
7,671 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1260 <func0+0x50>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rdx
xor %eax,%eax
jmp 1246 <func0+0x36>
nopl 0x0(%rax)
add $0x1,%rax
movsbq 0x0(%rbp,%rax,1),%rbx
test %bl,%bl
je 1260 <func0+0x50>
mov %eax,%r8d
testb $0x8,0x1(%rdx,%rbx,2)
je 1238 <func0+0x28>
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
mov $0xffffffff,%r8d
mov %r8d,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1258
mov rbp, rdi
call ___ctype_b_loc
mov rdx, [rax]
xor eax, eax
jmp short loc_1246
loc_1238:
add rax, 1
movsx rbx, byte ptr [rbp+rax+0]
test bl, bl
jz short loc_1258
loc_1246:
test byte ptr [rdx+rbx*2+1], 8
jz short loc_1238
add rsp, 8
pop rbx
pop rbp
retn
loc_1258:
add rsp, 8
mov eax, 0FFFFFFFFh
pop rbx
pop rbp
retn | long long func0(char *a1)
{
long long v1; // rbx
const unsigned __int16 *v2; // rdx
long long result; // rax
v1 = *a1;
if ( !(_BYTE)v1 )
return 0xFFFFFFFFLL;
v2 = *__ctype_b_loc();
result = 0LL;
while ( (v2[v1] & 0x800) == 0 )
{
v1 = a1[++result];
if ( !(_BYTE)v1 )
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101258
MOV RBP,RDI
CALL 0x00101070
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
JMP 0x00101246
LAB_00101238:
ADD RAX,0x1
MOVSX RBX,byte ptr [RBP + RAX*0x1]
TEST BL,BL
JZ 0x00101258
LAB_00101246:
TEST byte ptr [RDX + RBX*0x2 + 0x1],0x8
JZ 0x00101238
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101258:
ADD RSP,0x8
MOV EAX,0xffffffff
POP RBX
POP RBP
RET | long func0(char *param_1)
{
char cVar1;
ushort **ppuVar2;
long lVar3;
cVar1 = *param_1;
if (cVar1 != '\0') {
ppuVar2 = __ctype_b_loc();
lVar3 = 0;
do {
if ((*(byte *)((long)*ppuVar2 + (long)cVar1 * 2 + 1) & 8) != 0) {
return lVar3;
}
lVar3 = lVar3 + 1;
cVar1 = param_1[lVar3];
} while (cVar1 != '\0');
}
return 0xffffffff;
} |
7,672 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
}
return 0;
}
int sets_are_equal(Set *set1, Set *set2) {
if (set1->size != set2->size) return 0;
for (int i = 0; i < set1->size; i++) {
if (!set_contains(set2, set1->elements[i]))
return 0;
}
return 1;
}
void free_set(Set *s) {
for (int i = 0; i < s->size; i++) {
free(s->elements[i]);
}
free(s->elements);
}
| Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3);
Set result3 = func0(test3, 3);
Set expected3 = func0((char *[]){"d", "e", "z"}, 3);
assert(sets_are_equal(&result1, &expected1));
assert(sets_are_equal(&result2, &expected2));
assert(sets_are_equal(&result3, &expected3));
free_set(&result1);
free_set(&expected1);
free_set(&result2);
free_set(&expected2);
free_set(&result3);
free_set(&expected3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x24(%rbp)
jmp 1396 <func0+0x70>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%rdx
mov -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl $0x3,%rcx
lea (%rdx,%rcx,1),%rbx
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,(%rbx)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 135e <func0+0x38>
mov -0x20(%rbp),%rax
mov -0x18(%rbp),%rdx
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov eax, [rbp+var_3C]
mov dword ptr [rbp+var_18], eax
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov [rbp+var_24], 0
jmp short loc_1396
loc_135E:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
movsxd rcx, ecx
shl rcx, 3
lea rbx, [rdx+rcx]
mov rdi, rax; s
call _strdup
mov [rbx], rax
add [rbp+var_24], 1
loc_1396:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl short loc_135E
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-24h]
_QWORD *v4; // [rsp+20h] [rbp-20h]
v4 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = strdup(*(const char **)(8LL * i + a1));
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101396
LAB_0010135e:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOVSXD RCX,ECX
SHL RCX,0x3
LEA RBX,[RDX + RCX*0x1]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBX],RAX
ADD dword ptr [RBP + -0x24],0x1
LAB_00101396:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010135e
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(long param_1,int param_2)
{
int auVar1 [16];
void *pvVar2;
char *pcVar3;
int4 local_2c;
int4 uStack_1c;
pvVar2 = malloc((long)param_2 << 3);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
pcVar3 = strdup(*(char **)(param_1 + (long)local_2c * 8));
*(char **)((long)pvVar2 + (long)local_2c * 8) = pcVar3;
}
auVar1._8_4_ = param_2;
auVar1._0_8_ = pvVar2;
auVar1._12_4_ = uStack_1c;
return auVar1;
} |
7,673 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
}
return 0;
}
int sets_are_equal(Set *set1, Set *set2) {
if (set1->size != set2->size) return 0;
for (int i = 0; i < set1->size; i++) {
if (!set_contains(set2, set1->elements[i]))
return 0;
}
return 1;
}
void free_set(Set *s) {
for (int i = 0; i < s->size; i++) {
free(s->elements[i]);
}
free(s->elements);
}
| Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3);
Set result3 = func0(test3, 3);
Set expected3 = func0((char *[]){"d", "e", "z"}, 3);
assert(sets_are_equal(&result1, &expected1));
assert(sets_are_equal(&result2, &expected2));
assert(sets_are_equal(&result3, &expected3));
free_set(&result1);
free_set(&expected1);
free_set(&result2);
free_set(&expected2);
free_set(&result3);
free_set(&expected3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%r14d
movslq %esi,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %r14d,%r14d
jle 130d <func0+0x49>
lea -0x1(%r14),%r13d
mov $0x0,%ebx
mov (%r12,%rbx,8),%rdi
callq 10f0 <strdup@plt>
mov %rax,0x0(%rbp,%rbx,8)
mov %rbx,%rax
add $0x1,%rbx
cmp %r13,%rax
jne 12f3 <func0+0x2f>
mov %r14d,%edx
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r14d, esi
movsxd rdi, esi
shl rdi, 3
call _malloc
mov rbp, rax
test r14d, r14d
jle short loc_1309
mov r13d, r14d
mov ebx, 0
loc_12F2:
mov rdi, [r12+rbx*8]
call _strdup
mov [rbp+rbx*8+0], rax
add rbx, 1
cmp rbx, r13
jnz short loc_12F2
loc_1309:
mov edx, r14d
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, int a2)
{
long long v2; // rbp
long long i; // rbx
v2 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_QWORD *)(v2 + 8 * i) = strdup(*(_QWORD *)(a1 + 8 * i));
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R14D,ESI
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x001010e0
MOV RBP,RAX
TEST R14D,R14D
JLE 0x00101309
MOV R13D,R14D
MOV EBX,0x0
LAB_001012f2:
MOV RDI,qword ptr [R12 + RBX*0x8]
CALL 0x001010f0
MOV qword ptr [RBP + RBX*0x8],RAX
ADD RBX,0x1
CMP RBX,R13
JNZ 0x001012f2
LAB_00101309:
MOV EDX,R14D
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int1 [16] func0(long param_1,uint param_2)
{
char *pcVar1;
ulong uVar2;
int1 auVar3 [16];
auVar3._0_8_ = malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
uVar2 = 0;
do {
pcVar1 = strdup(*(char **)(param_1 + uVar2 * 8));
*(char **)((long)auVar3._0_8_ + uVar2 * 8) = pcVar1;
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
auVar3._8_4_ = param_2;
auVar3._12_4_ = 0;
return auVar3;
} |
7,674 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
}
return 0;
}
int sets_are_equal(Set *set1, Set *set2) {
if (set1->size != set2->size) return 0;
for (int i = 0; i < set1->size; i++) {
if (!set_contains(set2, set1->elements[i]))
return 0;
}
return 1;
}
void free_set(Set *s) {
for (int i = 0; i < s->size; i++) {
free(s->elements[i]);
}
free(s->elements);
}
| Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3);
Set result3 = func0(test3, 3);
Set expected3 = func0((char *[]){"d", "e", "z"}, 3);
assert(sets_are_equal(&result1, &expected1));
assert(sets_are_equal(&result2, &expected2));
assert(sets_are_equal(&result3, &expected3));
free_set(&result1);
free_set(&expected1);
free_set(&result2);
free_set(&expected2);
free_set(&result3);
free_set(&expected3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r14
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %r14d,%r14d
jle 15fa <func0+0x4a>
lea -0x1(%r14),%r13d
xor %ebx,%ebx
nopl 0x0(%rax)
mov 0x0(%rbp,%rbx,8),%rdi
callq 10f0 <strdup@plt>
mov %rax,(%r12,%rbx,8)
mov %rbx,%rax
add $0x1,%rbx
cmp %r13,%rax
jne 15e0 <func0+0x30>
pop %rbx
mov %r14d,%edx
pop %rbp
mov %r12,%rax
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
movsxd r13, esi
push r12
mov r14, r13
push rbp
mov rbp, rdi
lea rdi, ds:0[r13*8]
push rbx
call _malloc
mov r12, rax
test r13d, r13d
jle short loc_1657
xor ebx, ebx
nop dword ptr [rax+00h]
loc_1640:
mov rdi, [rbp+rbx*8+0]
call _strdup
mov [r12+rbx*8], rax
add rbx, 1
cmp rbx, r13
jnz short loc_1640
loc_1657:
pop rbx
mov edx, r14d
pop rbp
mov rax, r12
pop r12
pop r13
pop r14
retn | long long func0(long long a1, int a2)
{
long long v2; // r12
long long i; // rbx
v2 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_QWORD *)(v2 + 8 * i) = strdup(*(_QWORD *)(a1 + 8 * i));
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R14,R13
PUSH RBP
MOV RBP,RDI
LEA RDI,[R13*0x8]
PUSH RBX
CALL 0x001010e0
MOV R12,RAX
TEST R13D,R13D
JLE 0x00101657
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_00101640:
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x001010f0
MOV qword ptr [R12 + RBX*0x8],RAX
ADD RBX,0x1
CMP RBX,R13
JNZ 0x00101640
LAB_00101657:
POP RBX
MOV EDX,R14D
POP RBP
MOV RAX,R12
POP R12
POP R13
POP R14
RET | int1 [16] func0(long param_1,int param_2)
{
char *pcVar1;
long lVar2;
int1 auVar3 [16];
auVar3._0_8_ = malloc((long)param_2 * 8);
if (0 < param_2) {
lVar2 = 0;
do {
pcVar1 = strdup(*(char **)(param_1 + lVar2 * 8));
*(char **)((long)auVar3._0_8_ + lVar2 * 8) = pcVar1;
lVar2 = lVar2 + 1;
} while (lVar2 != param_2);
}
auVar3._8_4_ = param_2;
auVar3._12_4_ = 0;
return auVar3;
} |
7,675 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
}
return 0;
}
int sets_are_equal(Set *set1, Set *set2) {
if (set1->size != set2->size) return 0;
for (int i = 0; i < set1->size; i++) {
if (!set_contains(set2, set1->elements[i]))
return 0;
}
return 1;
}
void free_set(Set *s) {
for (int i = 0; i < s->size; i++) {
free(s->elements[i]);
}
free(s->elements);
}
| Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3);
Set result3 = func0(test3, 3);
Set expected3 = func0((char *[]){"d", "e", "z"}, 3);
assert(sets_are_equal(&result1, &expected1));
assert(sets_are_equal(&result2, &expected2));
assert(sets_are_equal(&result3, &expected3));
free_set(&result1);
free_set(&expected1);
free_set(&result2);
free_set(&expected2);
free_set(&result3);
free_set(&expected3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r14
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %r14d,%r14d
jle 169a <func0+0x4a>
lea -0x1(%r14),%r13d
xor %ebx,%ebx
nopl 0x0(%rax)
mov 0x0(%rbp,%rbx,8),%rdi
callq 10f0 <strdup@plt>
mov %rax,(%r12,%rbx,8)
mov %rbx,%rax
add $0x1,%rbx
cmp %rax,%r13
jne 1680 <func0+0x30>
pop %rbx
mov %r14d,%edx
pop %rbp
mov %r12,%rax
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
| func0:
endbr64
push r14
movsxd r14, esi
push r13
push r12
mov r12, r14
shl r14, 3
push rbp
push rbx
mov rbx, rdi
mov rdi, r14; size
call _malloc
mov r13, rax
test r12d, r12d
jle short loc_1679
mov rbp, rax
add r14, rbx
nop
loc_1660:
mov rdi, [rbx]; s
add rbx, 8
add rbp, 8
call _strdup
mov [rbp-8], rax
cmp rbx, r14
jnz short loc_1660
loc_1679:
pop rbx
mov edx, r12d
pop rbp
mov rax, r13
pop r12
pop r13
pop r14
retn | void * func0(const char **a1, int a2)
{
const char **v2; // rbx
void *v3; // rax
void *v4; // r13
_QWORD *v5; // rbp
const char **v6; // r14
const char *v7; // rdi
v2 = a1;
v3 = malloc(8LL * a2);
v4 = v3;
if ( a2 > 0 )
{
v5 = v3;
v6 = &a1[a2];
do
{
v7 = *v2++;
*v5++ = strdup(v7);
}
while ( v2 != v6 );
}
return v4;
} | func0:
ENDBR64
PUSH R14
MOVSXD R14,ESI
PUSH R13
PUSH R12
MOV R12,R14
SHL R14,0x3
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
CALL 0x001010e0
MOV R13,RAX
TEST R12D,R12D
JLE 0x00101679
MOV RBP,RAX
ADD R14,RBX
NOP
LAB_00101660:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
ADD RBP,0x8
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP RBX,R14
JNZ 0x00101660
LAB_00101679:
POP RBX
MOV EDX,R12D
POP RBP
MOV RAX,R13
POP R12
POP R13
POP R14
RET | int [16] func0(int8 *param_1,int param_2)
{
char *pcVar1;
int8 *puVar2;
int8 *puVar3;
int auVar4 [16];
auVar4._0_8_ = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar3 = param_1 + param_2;
puVar2 = auVar4._0_8_;
do {
pcVar1 = (char *)*param_1;
param_1 = param_1 + 1;
pcVar1 = strdup(pcVar1);
*puVar2 = pcVar1;
puVar2 = puVar2 + 1;
} while (param_1 != puVar3);
}
auVar4._8_4_ = param_2;
auVar4._12_4_ = 0;
return auVar4;
} |
7,676 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count != cc1->count)
return cc2->count - cc1->count;
return cc1->first_index - cc2->first_index;
}
| CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_occurrence[c] = i;
}
CharCount temp[256];
int unique = 0;
for (int i = 0; i < 256; i++) {
if (counts[i] > 0) {
temp[unique].character = (char)i;
temp[unique].count = counts[i];
temp[unique].first_index = first_occurrence[i];
unique++;
}
}
qsort(temp, unique, sizeof(CharCount), compare);
CharCount* result = malloc(a * sizeof(CharCount));
for (int i = 0; i < a && i < unique; i++) {
result[i] = temp[i];
}
return result;
}
| int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafsdfafkpwe", 2);
assert(res2[0].character == 's' && res2[0].count == 4);
assert(res2[1].character == 'e' && res2[1].count == 3);
free(res2);
CharCount* res3 = func0("lkseropewdssafsdfafkpwe", 7);
assert(res3[0].character == 's' && res3[0].count == 4);
assert(res3[1].character == 'e' && res3[1].count == 3);
assert(res3[2].character == 'f' && res3[2].count == 3);
assert(res3[3].character == 'k' && res3[3].count == 2);
assert(res3[4].character == 'p' && res3[4].count == 2);
assert(res3[5].character == 'w' && res3[5].count == 2);
assert(res3[6].character == 'd' && res3[6].count == 2);
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x440,%rsp
mov %rdi,-0x1438(%rbp)
mov %esi,-0x143c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x1410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x142c(%rbp)
jmp 1297 <func0+0x74>
mov -0x142c(%rbp),%eax
cltq
movl $0xffffffff,-0x1010(%rbp,%rax,4)
addl $0x1,-0x142c(%rbp)
cmpl $0xff,-0x142c(%rbp)
jle 127d <func0+0x5a>
movl $0x0,-0x1428(%rbp)
jmp 131a <func0+0xf7>
mov -0x1428(%rbp),%eax
movslq %eax,%rdx
mov -0x1438(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x142d(%rbp)
movzbl -0x142d(%rbp),%eax
movslq %eax,%rdx
mov -0x1410(%rbp,%rdx,4),%edx
add $0x1,%edx
cltq
mov %edx,-0x1410(%rbp,%rax,4)
movzbl -0x142d(%rbp),%eax
cltq
mov -0x1010(%rbp,%rax,4),%eax
cmp $0xffffffff,%eax
jne 1313 <func0+0xf0>
movzbl -0x142d(%rbp),%eax
cltq
mov -0x1428(%rbp),%edx
mov %edx,-0x1010(%rbp,%rax,4)
addl $0x1,-0x1428(%rbp)
mov -0x1428(%rbp),%eax
movslq %eax,%rdx
mov -0x1438(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 12af <func0+0x8c>
movl $0x0,-0x1424(%rbp)
movl $0x0,-0x1420(%rbp)
jmpq 13ff <func0+0x1dc>
mov -0x1420(%rbp),%eax
cltq
mov -0x1410(%rbp,%rax,4),%eax
test %eax,%eax
jle 13f8 <func0+0x1d5>
mov -0x1420(%rbp),%eax
mov %eax,%ecx
mov -0x1424(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
add %rbp,%rax
sub $0xc10,%rax
mov %cl,(%rax)
mov -0x1420(%rbp),%eax
cltq
mov -0x1410(%rbp,%rax,4),%ecx
mov -0x1424(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
add %rbp,%rax
sub $0xc0c,%rax
mov %ecx,(%rax)
mov -0x1420(%rbp),%eax
cltq
mov -0x1010(%rbp,%rax,4),%ecx
mov -0x1424(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
add %rbp,%rax
sub $0xc08,%rax
mov %ecx,(%rax)
addl $0x1,-0x1424(%rbp)
addl $0x1,-0x1420(%rbp)
cmpl $0xff,-0x1420(%rbp)
jle 1351 <func0+0x12e>
mov -0x1424(%rbp),%eax
movslq %eax,%rsi
lea -0xc10(%rbp),%rax
lea -0x25d(%rip),%rcx
mov $0xc,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x143c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x1418(%rbp)
movl $0x0,-0x141c(%rbp)
jmp 14b9 <func0+0x296>
mov -0x141c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x1418(%rbp),%rax
add %rax,%rdx
mov -0x141c(%rbp),%eax
movslq %eax,%rcx
mov %rcx,%rax
add %rax,%rax
add %rcx,%rax
shl $0x2,%rax
add %rbp,%rax
sub $0xc10,%rax
mov (%rax),%rcx
mov %rcx,(%rdx)
mov 0x8(%rax),%eax
mov %eax,0x8(%rdx)
addl $0x1,-0x141c(%rbp)
mov -0x141c(%rbp),%eax
cmp -0x143c(%rbp),%eax
jge 14d5 <func0+0x2b2>
mov -0x141c(%rbp),%eax
cmp -0x1424(%rbp),%eax
jl 1464 <func0+0x241>
mov -0x1418(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 14f0 <func0+0x2cd>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1000h
or [rsp+1000h+var_1000], 0
sub rsp, 440h
mov [rbp+var_1438], rdi
mov [rbp+var_143C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_1410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_142C], 0
jmp short loc_1297
loc_127D:
mov eax, [rbp+var_142C]
cdqe
mov [rbp+rax*4+var_1010], 0FFFFFFFFh
add [rbp+var_142C], 1
loc_1297:
cmp [rbp+var_142C], 0FFh
jle short loc_127D
mov [rbp+var_1428], 0
jmp short loc_131A
loc_12AF:
mov eax, [rbp+var_1428]
movsxd rdx, eax
mov rax, [rbp+var_1438]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_142D], al
movzx eax, [rbp+var_142D]
movsxd rdx, eax
mov edx, [rbp+rdx*4+var_1410]
add edx, 1
cdqe
mov [rbp+rax*4+var_1410], edx
movzx eax, [rbp+var_142D]
cdqe
mov eax, [rbp+rax*4+var_1010]
cmp eax, 0FFFFFFFFh
jnz short loc_1313
movzx eax, [rbp+var_142D]
cdqe
mov edx, [rbp+var_1428]
mov [rbp+rax*4+var_1010], edx
loc_1313:
add [rbp+var_1428], 1
loc_131A:
mov eax, [rbp+var_1428]
movsxd rdx, eax
mov rax, [rbp+var_1438]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_12AF
mov [rbp+var_1424], 0
mov [rbp+var_1420], 0
jmp loc_13FF
loc_1351:
mov eax, [rbp+var_1420]
cdqe
mov eax, [rbp+rax*4+var_1410]
test eax, eax
jle loc_13F8
mov eax, [rbp+var_1420]
mov ecx, eax
mov eax, [rbp+var_1424]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
add rax, rbp
sub rax, 0C10h
mov [rax], cl
mov eax, [rbp+var_1420]
cdqe
mov ecx, [rbp+rax*4+var_1410]
mov eax, [rbp+var_1424]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
add rax, rbp
sub rax, 0C0Ch
mov [rax], ecx
mov eax, [rbp+var_1420]
cdqe
mov ecx, [rbp+rax*4+var_1010]
mov eax, [rbp+var_1424]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
add rax, rbp
sub rax, 0C08h
mov [rax], ecx
add [rbp+var_1424], 1
loc_13F8:
add [rbp+var_1420], 1
loc_13FF:
cmp [rbp+var_1420], 0FFh
jle loc_1351
mov eax, [rbp+var_1424]
movsxd rsi, eax; nmemb
lea rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 0Ch; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_143C]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_1418], rax
mov [rbp+var_141C], 0
jmp short loc_14BC
loc_1467:
mov eax, [rbp+var_141C]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_1418]
add rdx, rax
mov eax, [rbp+var_141C]
movsxd rcx, eax
mov rax, rcx
add rax, rax
add rax, rcx
shl rax, 2
add rax, rbp
sub rax, 0C10h
mov rcx, [rax]
mov [rdx], rcx
mov eax, [rax+8]
mov [rdx+8], eax
add [rbp+var_141C], 1
loc_14BC:
mov eax, [rbp+var_141C]
cmp eax, [rbp+var_143C]
jge short loc_14D8
mov eax, [rbp+var_141C]
cmp eax, [rbp+var_1424]
jl short loc_1467
loc_14D8:
mov rax, [rbp+var_1418]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_14F3
call ___stack_chk_fail
locret_14F3:
leave
retn | char * func0(long long a1, int a2)
{
char *v2; // rdx
unsigned __int8 v4; // [rsp+13h] [rbp-142Dh]
int i; // [rsp+14h] [rbp-142Ch]
int j; // [rsp+18h] [rbp-1428h]
int v7; // [rsp+1Ch] [rbp-1424h]
int k; // [rsp+20h] [rbp-1420h]
int m; // [rsp+24h] [rbp-141Ch]
char *v10; // [rsp+28h] [rbp-1418h]
_DWORD v11[260]; // [rsp+30h] [rbp-1410h] BYREF
_BYTE base[3080]; // [rsp+830h] [rbp-C10h] BYREF
unsigned long long v13; // [rsp+1438h] [rbp-8h]
v13 = __readfsqword(0x28u);
memset(v11, 0, 0x400uLL);
for ( i = 0; i <= 255; ++i )
v11[i + 256] = -1;
for ( j = 0; *(_BYTE *)(j + a1); ++j )
{
v4 = *(_BYTE *)(j + a1);
++v11[v4];
if ( v11[v4 + 256] == -1 )
v11[v4 + 256] = j;
}
v7 = 0;
for ( k = 0; k <= 255; ++k )
{
if ( (int)v11[k] > 0 )
{
base[12 * v7] = k;
*(_DWORD *)&base[12 * v7 + 4] = v11[k];
*(_DWORD *)&base[12 * v7++ + 8] = v11[k + 256];
}
}
qsort(base, v7, 0xCuLL, compare);
v10 = (char *)malloc(12LL * a2);
for ( m = 0; m < a2 && m < v7; ++m )
{
v2 = &v10[12 * m];
*(_QWORD *)v2 = *(_QWORD *)&base[12 * m];
*((_DWORD *)v2 + 2) = *(_DWORD *)&base[12 * m + 8];
}
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x440
MOV qword ptr [RBP + -0x1438],RDI
MOV dword ptr [RBP + -0x143c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x1410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x142c],0x0
JMP 0x00101297
LAB_0010127d:
MOV EAX,dword ptr [RBP + -0x142c]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1010],0xffffffff
ADD dword ptr [RBP + -0x142c],0x1
LAB_00101297:
CMP dword ptr [RBP + -0x142c],0xff
JLE 0x0010127d
MOV dword ptr [RBP + -0x1428],0x0
JMP 0x0010131a
LAB_001012af:
MOV EAX,dword ptr [RBP + -0x1428]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x1438]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x142d],AL
MOVZX EAX,byte ptr [RBP + -0x142d]
MOVSXD RDX,EAX
MOV EDX,dword ptr [RBP + RDX*0x4 + -0x1410]
ADD EDX,0x1
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1410],EDX
MOVZX EAX,byte ptr [RBP + -0x142d]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1010]
CMP EAX,-0x1
JNZ 0x00101313
MOVZX EAX,byte ptr [RBP + -0x142d]
CDQE
MOV EDX,dword ptr [RBP + -0x1428]
MOV dword ptr [RBP + RAX*0x4 + -0x1010],EDX
LAB_00101313:
ADD dword ptr [RBP + -0x1428],0x1
LAB_0010131a:
MOV EAX,dword ptr [RBP + -0x1428]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x1438]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001012af
MOV dword ptr [RBP + -0x1424],0x0
MOV dword ptr [RBP + -0x1420],0x0
JMP 0x001013ff
LAB_00101351:
MOV EAX,dword ptr [RBP + -0x1420]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1410]
TEST EAX,EAX
JLE 0x001013f8
MOV EAX,dword ptr [RBP + -0x1420]
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x1424]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RBP
SUB RAX,0xc10
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1420]
CDQE
MOV ECX,dword ptr [RBP + RAX*0x4 + -0x1410]
MOV EAX,dword ptr [RBP + -0x1424]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RBP
SUB RAX,0xc0c
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x1420]
CDQE
MOV ECX,dword ptr [RBP + RAX*0x4 + -0x1010]
MOV EAX,dword ptr [RBP + -0x1424]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RBP
SUB RAX,0xc08
MOV dword ptr [RAX],ECX
ADD dword ptr [RBP + -0x1424],0x1
LAB_001013f8:
ADD dword ptr [RBP + -0x1420],0x1
LAB_001013ff:
CMP dword ptr [RBP + -0x1420],0xff
JLE 0x00101351
MOV EAX,dword ptr [RBP + -0x1424]
MOVSXD RSI,EAX
LEA RAX,[RBP + -0xc10]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0xc
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP + -0x143c]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x1418],RAX
MOV dword ptr [RBP + -0x141c],0x0
JMP 0x001014bc
LAB_00101467:
MOV EAX,dword ptr [RBP + -0x141c]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x1418]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x141c]
MOVSXD RCX,EAX
MOV RAX,RCX
ADD RAX,RAX
ADD RAX,RCX
SHL RAX,0x2
ADD RAX,RBP
SUB RAX,0xc10
MOV RCX,qword ptr [RAX]
MOV qword ptr [RDX],RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RDX + 0x8],EAX
ADD dword ptr [RBP + -0x141c],0x1
LAB_001014bc:
MOV EAX,dword ptr [RBP + -0x141c]
CMP EAX,dword ptr [RBP + -0x143c]
JGE 0x001014d8
MOV EAX,dword ptr [RBP + -0x141c]
CMP EAX,dword ptr [RBP + -0x1424]
JL 0x00101467
LAB_001014d8:
MOV RAX,qword ptr [RBP + -0x1418]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014f3
CALL 0x001010b0
LAB_001014f3:
LEAVE
RET | void * func0(long param_1,int param_2)
{
byte bVar1;
void *pvVar2;
long lVar3;
int8 *puVar4;
int *piVar5;
long in_FS_OFFSET;
int local_1434;
int local_1430;
int local_142c;
int local_1428;
int local_1424;
int local_1418 [256];
int aiStack_1018 [256];
int8 local_c18;
int aiStack_c10 [768];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar5 = local_1418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
piVar5[0] = 0;
piVar5[1] = 0;
piVar5 = piVar5 + 2;
}
for (local_1434 = 0; local_1434 < 0x100; local_1434 = local_1434 + 1) {
aiStack_1018[local_1434] = -1;
}
for (local_1430 = 0; *(char *)(param_1 + local_1430) != '\0'; local_1430 = local_1430 + 1) {
bVar1 = *(byte *)(param_1 + local_1430);
aiStack_1018[(long)(int)(uint)bVar1 + -0x100] =
aiStack_1018[(long)(int)(uint)bVar1 + -0x100] + 1;
if (aiStack_1018[(int)(uint)bVar1] == -1) {
aiStack_1018[(int)(uint)bVar1] = local_1430;
}
}
local_142c = 0;
for (local_1428 = 0; local_1428 < 0x100; local_1428 = local_1428 + 1) {
if (0 < aiStack_1018[(long)local_1428 + -0x100]) {
*(char *)((long)&local_c18 + (long)local_142c * 0xc) = (char)local_1428;
aiStack_c10[(long)local_142c * 3 + -1] = aiStack_1018[(long)local_1428 + -0x100];
aiStack_c10[(long)local_142c * 3] = aiStack_1018[local_1428];
local_142c = local_142c + 1;
}
}
qsort(&local_c18,(long)local_142c,0xc,compare);
pvVar2 = malloc((long)param_2 * 0xc);
for (local_1424 = 0; (local_1424 < param_2 && (local_1424 < local_142c));
local_1424 = local_1424 + 1) {
puVar4 = (int8 *)((long)local_1424 * 0xc + (long)pvVar2);
*puVar4 = *(int8 *)((long)&local_c18 + (long)local_1424 * 0xc);
*(int *)(puVar4 + 1) = aiStack_c10[(long)local_1424 * 3];
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pvVar2;
} |
7,677 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count != cc1->count)
return cc2->count - cc1->count;
return cc1->first_index - cc2->first_index;
}
| CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_occurrence[c] = i;
}
CharCount temp[256];
int unique = 0;
for (int i = 0; i < 256; i++) {
if (counts[i] > 0) {
temp[unique].character = (char)i;
temp[unique].count = counts[i];
temp[unique].first_index = first_occurrence[i];
unique++;
}
}
qsort(temp, unique, sizeof(CharCount), compare);
CharCount* result = malloc(a * sizeof(CharCount));
for (int i = 0; i < a && i < unique; i++) {
result[i] = temp[i];
}
return result;
}
| int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafsdfafkpwe", 2);
assert(res2[0].character == 's' && res2[0].count == 4);
assert(res2[1].character == 'e' && res2[1].count == 3);
free(res2);
CharCount* res3 = func0("lkseropewdssafsdfafkpwe", 7);
assert(res3[0].character == 's' && res3[0].count == 4);
assert(res3[1].character == 'e' && res3[1].count == 3);
assert(res3[2].character == 'f' && res3[2].count == 3);
assert(res3[3].character == 'k' && res3[3].count == 2);
assert(res3[4].character == 'p' && res3[4].count == 2);
assert(res3[5].character == 'w' && res3[5].count == 2);
assert(res3[6].character == 'd' && res3[6].count == 2);
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x418,%rsp
mov %rdi,%r8
mov %esi,%ebx
mov %fs:0x28,%rax
mov %rax,0x1408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
lea 0x400(%rsp),%rax
lea 0x800(%rsp),%rdx
movl $0xffffffff,(%rax)
add $0x4,%rax
cmp %rax,%rdx
jne 122d <func0+0x4c>
movzbl (%r8),%eax
test %al,%al
je 1278 <func0+0x97>
mov $0x0,%edx
jmp 1258 <func0+0x77>
add $0x1,%rdx
movzbl (%r8,%rdx,1),%eax
test %al,%al
je 1278 <func0+0x97>
movzbl %al,%ecx
movzbl %al,%eax
addl $0x1,(%rsp,%rax,4)
cmpl $0xffffffff,0x400(%rsp,%rax,4)
jne 124b <func0+0x6a>
movslq %ecx,%rcx
mov %edx,0x400(%rsp,%rcx,4)
jmp 124b <func0+0x6a>
mov $0x0,%eax
mov $0x0,%ebp
jmp 1290 <func0+0xaf>
add $0x1,%rax
cmp $0x100,%rax
je 12c3 <func0+0xe2>
mov (%rsp,%rax,4),%esi
test %esi,%esi
jle 1284 <func0+0xa3>
movslq %ebp,%rcx
lea (%rcx,%rcx,1),%rdx
lea (%rdx,%rcx,1),%rdi
mov %al,0x800(%rsp,%rdi,4)
mov %esi,0x804(%rsp,%rdi,4)
mov 0x400(%rsp,%rax,4),%ecx
mov %ecx,0x808(%rsp,%rdi,4)
add $0x1,%ebp
jmp 1284 <func0+0xa3>
movslq %ebp,%rsi
lea 0x800(%rsp),%rdi
lea -0x10c(%rip),%rcx
mov $0xc,%edx
callq 10a0 <qsort@plt>
movslq %ebx,%rax
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
cmp %ebx,%ebp
cmovle %ebp,%ebx
test %ebx,%ebx
jle 1329 <func0+0x148>
lea -0x1(%rbx),%edx
lea 0x3(%rdx,%rdx,2),%rsi
shl $0x2,%rsi
mov $0x0,%edx
mov 0x800(%rsp,%rdx,1),%rcx
mov %rcx,(%rax,%rdx,1)
mov 0x808(%rsp,%rdx,1),%ecx
mov %ecx,0x8(%rax,%rdx,1)
add $0xc,%rdx
cmp %rdx,%rsi
jne 1309 <func0+0x128>
mov 0x1408(%rsp),%rbx
xor %fs:0x28,%rbx
jne 1346 <func0+0x165>
add $0x1418,%rsp
pop %rbx
pop %rbp
retq
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 1000h
or [rsp+1010h+var_1010], 0
sub rsp, 418h
mov r8, rdi
mov ebx, esi
mov rax, fs:28h
mov [rsp+1428h+var_20], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
lea rax, [rsp+1428h+var_1028]
lea rdx, [rsp+1428h+var_C28]
loc_122D:
mov dword ptr [rax], 0FFFFFFFFh
add rax, 4
cmp rdx, rax
jnz short loc_122D
movzx eax, byte ptr [r8]
test al, al
jz short loc_1284
mov ecx, 0
jmp short loc_1262
loc_124B:
movsxd rdx, edx
mov [rsp+rdx*4+1428h+var_1028], esi
add rcx, 1
movzx eax, byte ptr [r8+rcx]
test al, al
jz short loc_1284
loc_1262:
mov esi, ecx
movzx edx, al
movzx eax, al
add [rsp+rax*4+1428h+var_1428], 1
cmp [rsp+rax*4+1428h+var_1028], 0FFFFFFFFh
jz short loc_124B
movsxd rax, edx
mov esi, [rsp+rax*4+1428h+var_1028]
jmp short loc_124B
loc_1284:
mov eax, 0
mov ebp, 0
jmp short loc_129C
loc_1290:
add rax, 1
cmp rax, 100h
jz short loc_12CF
loc_129C:
mov esi, [rsp+rax*4+1428h+var_1428]
test esi, esi
jle short loc_1290
movsxd rcx, ebp
lea rdx, [rcx+rcx]
lea rdi, [rdx+rcx]
mov byte ptr [rsp+rdi*4+1428h+var_C28], al
mov dword ptr [rsp+rdi*4+1428h+var_C28+4], esi
mov ecx, [rsp+rax*4+1428h+var_1028]
mov [rsp+rdi*4+1428h+var_C20], ecx
add ebp, 1
jmp short loc_1290
loc_12CF:
movsxd rsi, ebp
lea rdi, [rsp+1428h+var_C28]
lea rcx, compare
mov edx, 0Ch
call _qsort
movsxd rax, ebx
lea rdi, [rax+rax*2]
shl rdi, 2
call _malloc
cmp ebp, ebx
cmovg ebp, ebx
test ebp, ebp
jle short loc_1334
mov ebp, ebp
lea rsi, [rbp+rbp*2+0]
shl rsi, 2
mov edx, 0
loc_1314:
mov rcx, [rsp+rdx+1428h+var_C28]
mov [rax+rdx], rcx
mov ecx, [rsp+rdx+1428h+var_C20]
mov [rax+rdx+8], ecx
add rdx, 0Ch
cmp rsi, rdx
jnz short loc_1314
loc_1334:
mov rdx, [rsp+1428h+var_20]
sub rdx, fs:28h
jnz short loc_1351
add rsp, 1418h
pop rbx
pop rbp
retn
loc_1351:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1, int a2)
{
_QWORD *v3; // rax
unsigned __int8 v4; // al
long long v5; // rcx
int v6; // esi
long long v7; // rax
int v8; // ebp
int v9; // esi
long long v10; // rdi
long long result; // rax
long long v12; // rdx
_DWORD v13[256]; // [rsp+0h] [rbp-1428h] BYREF
_DWORD v14[6]; // [rsp+400h] [rbp-1028h] BYREF
_QWORD v15[389]; // [rsp+800h] [rbp-C28h] BYREF
v15[385] = __readfsqword(0x28u);
memset(v13, 0, sizeof(v13));
v3 = v14;
do
{
*(_DWORD *)v3 = -1;
v3 = (_QWORD *)((char *)v3 + 4);
}
while ( v15 != v3 );
v4 = *a1;
if ( *a1 )
{
v5 = 0LL;
do
{
v6 = v5;
++v13[v4];
if ( v14[v4] != -1 )
v6 = v14[v4];
v14[v4] = v6;
v4 = a1[++v5];
}
while ( v4 );
}
v7 = 0LL;
v8 = 0;
do
{
v9 = v13[v7];
if ( v9 > 0 )
{
v10 = 3LL * v8;
*((_BYTE *)v15 + 4 * v10) = v7;
*((_DWORD *)v15 + v10 + 1) = v9;
*((_DWORD *)&v15[1] + v10) = v14[v7];
++v8;
}
++v7;
}
while ( v7 != 256 );
qsort(v15, v8, 12LL, compare);
result = malloc(12LL * a2);
if ( v8 > a2 )
v8 = a2;
if ( v8 > 0 )
{
v12 = 0LL;
do
{
*(_QWORD *)(result + v12) = *(_QWORD *)((char *)v15 + v12);
*(_DWORD *)(result + v12 + 8) = *(_DWORD *)((char *)&v15[1] + v12);
v12 += 12LL;
}
while ( 12LL * (unsigned int)v8 != v12 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x418
MOV R8,RDI
MOV EBX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
LEA RAX,[RSP + 0x400]
LEA RDX,[RSP + 0x800]
LAB_0010122d:
MOV dword ptr [RAX],0xffffffff
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x0010122d
MOVZX EAX,byte ptr [R8]
TEST AL,AL
JZ 0x00101284
MOV ECX,0x0
JMP 0x00101262
LAB_0010124b:
MOVSXD RDX,EDX
MOV dword ptr [RSP + RDX*0x4 + 0x400],ESI
ADD RCX,0x1
MOVZX EAX,byte ptr [R8 + RCX*0x1]
TEST AL,AL
JZ 0x00101284
LAB_00101262:
MOV ESI,ECX
MOVZX EDX,AL
MOVZX EAX,AL
ADD dword ptr [RSP + RAX*0x4],0x1
CMP dword ptr [RSP + RAX*0x4 + 0x400],-0x1
JZ 0x0010124b
MOVSXD RAX,EDX
MOV ESI,dword ptr [RSP + RAX*0x4 + 0x400]
JMP 0x0010124b
LAB_00101284:
MOV EAX,0x0
MOV EBP,0x0
JMP 0x0010129c
LAB_00101290:
ADD RAX,0x1
CMP RAX,0x100
JZ 0x001012cf
LAB_0010129c:
MOV ESI,dword ptr [RSP + RAX*0x4]
TEST ESI,ESI
JLE 0x00101290
MOVSXD RCX,EBP
LEA RDX,[RCX + RCX*0x1]
LEA RDI,[RDX + RCX*0x1]
MOV byte ptr [RSP + RDI*0x4 + 0x800],AL
MOV dword ptr [RSP + RDI*0x4 + 0x804],ESI
MOV ECX,dword ptr [RSP + RAX*0x4 + 0x400]
MOV dword ptr [RSP + RDI*0x4 + 0x808],ECX
ADD EBP,0x1
JMP 0x00101290
LAB_001012cf:
MOVSXD RSI,EBP
LEA RDI,[RSP + 0x800]
LEA RCX,[0x1011c9]
MOV EDX,0xc
CALL 0x001010a0
MOVSXD RAX,EBX
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010d0
CMP EBP,EBX
CMOVG EBP,EBX
TEST EBP,EBP
JLE 0x00101334
MOV EBP,EBP
LEA RSI,[RBP + RBP*0x2]
SHL RSI,0x2
MOV EDX,0x0
LAB_00101314:
MOV RCX,qword ptr [RSP + RDX*0x1 + 0x800]
MOV qword ptr [RAX + RDX*0x1],RCX
MOV ECX,dword ptr [RSP + RDX*0x1 + 0x808]
MOV dword ptr [RAX + RDX*0x1 + 0x8],ECX
ADD RDX,0xc
CMP RSI,RDX
JNZ 0x00101314
LAB_00101334:
MOV RDX,qword ptr [RSP + 0x1408]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101351
ADD RSP,0x1418
POP RBX
POP RBP
RET
LAB_00101351:
CALL 0x001010b0 | void func0(byte *param_1,uint param_2)
{
byte bVar1;
int *piVar2;
void *pvVar3;
int iVar4;
long lVar5;
long lVar6;
uint uVar7;
long in_FS_OFFSET;
int local_1428 [256];
int local_1028 [256];
int local_c28 [770];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = local_1428;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
*(int8 *)piVar2 = 0;
piVar2 = (int *)((long)piVar2 + 8);
}
piVar2 = local_1028;
do {
*piVar2 = -1;
piVar2 = piVar2 + 1;
} while (local_c28 != piVar2);
bVar1 = *param_1;
if (bVar1 != 0) {
lVar5 = 0;
do {
iVar4 = (int)lVar5;
local_1428[bVar1] = local_1428[bVar1] + 1;
if (local_1028[bVar1] != -1) {
iVar4 = local_1028[(int)(uint)bVar1];
}
local_1028[(int)(uint)bVar1] = iVar4;
lVar5 = lVar5 + 1;
bVar1 = param_1[lVar5];
} while (bVar1 != 0);
}
lVar5 = 0;
uVar7 = 0;
do {
iVar4 = local_1428[lVar5];
if (0 < iVar4) {
lVar6 = (long)(int)uVar7;
*(char *)(local_c28 + lVar6 * 3) = (char)lVar5;
local_c28[lVar6 * 3 + 1] = iVar4;
local_c28[lVar6 * 3 + 2] = local_1028[lVar5];
uVar7 = uVar7 + 1;
}
lVar5 = lVar5 + 1;
} while (lVar5 != 0x100);
qsort(local_c28,(long)(int)uVar7,0xc,compare);
pvVar3 = malloc((long)(int)param_2 * 0xc);
if ((int)param_2 < (int)uVar7) {
uVar7 = param_2;
}
if (0 < (int)uVar7) {
lVar5 = 0;
do {
*(int8 *)((long)pvVar3 + lVar5) = *(int8 *)((long)local_c28 + lVar5);
*(int4 *)((long)pvVar3 + lVar5 + 8) = *(int4 *)((long)local_c28 + lVar5 + 8);
lVar5 = lVar5 + 0xc;
} while ((ulong)uVar7 * 0xc != lVar5);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,678 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count != cc1->count)
return cc2->count - cc1->count;
return cc1->first_index - cc2->first_index;
}
| CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_occurrence[c] = i;
}
CharCount temp[256];
int unique = 0;
for (int i = 0; i < 256; i++) {
if (counts[i] > 0) {
temp[unique].character = (char)i;
temp[unique].count = counts[i];
temp[unique].first_index = first_occurrence[i];
unique++;
}
}
qsort(temp, unique, sizeof(CharCount), compare);
CharCount* result = malloc(a * sizeof(CharCount));
for (int i = 0; i < a && i < unique; i++) {
result[i] = temp[i];
}
return result;
}
| int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafsdfafkpwe", 2);
assert(res2[0].character == 's' && res2[0].count == 4);
assert(res2[1].character == 'e' && res2[1].count == 3);
free(res2);
CharCount* res3 = func0("lkseropewdssafsdfafkpwe", 7);
assert(res3[0].character == 's' && res3[0].count == 4);
assert(res3[1].character == 'e' && res3[1].count == 3);
assert(res3[2].character == 'f' && res3[2].count == 3);
assert(res3[3].character == 'k' && res3[3].count == 2);
assert(res3[4].character == 'p' && res3[4].count == 2);
assert(res3[5].character == 'w' && res3[5].count == 2);
assert(res3[6].character == 'd' && res3[6].count == 2);
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x410,%rsp
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x1408(%rsp)
xor %eax,%eax
mov %esi,%ebx
mov %rsp,%rsi
mov %rdi,%r8
mov %rsi,%rdi
lea 0x800(%rsp),%r12
rep stos %rax,%es:(%rdi)
lea 0x400(%rsp),%rdi
mov %rdi,%rax
nopl 0x0(%rax)
movl $0xffffffff,(%rax)
add $0x4,%rax
cmp %r12,%rax
jne 14f8 <func0+0x58>
movzbl (%r8),%eax
xor %edx,%edx
test %al,%al
je 153a <func0+0x9a>
nopl 0x0(%rax)
addl $0x1,(%rsp,%rax,4)
cmpl $0xffffffff,0x400(%rsp,%rax,4)
jne 152d <func0+0x8d>
mov %edx,0x400(%rsp,%rax,4)
add $0x1,%rdx
movzbl (%r8,%rdx,1),%eax
test %al,%al
jne 1518 <func0+0x78>
xor %eax,%eax
xor %ebp,%ebp
xchg %ax,%ax
add $0x1,%rax
cmp $0x100,%rax
je 1585 <func0+0xe5>
mov (%rsi,%rax,4),%ecx
test %ecx,%ecx
jle 1540 <func0+0xa0>
movslq %ebp,%rdx
add $0x1,%ebp
lea (%rdx,%rdx,2),%rdx
shl $0x2,%rdx
mov %ecx,0x804(%rsp,%rdx,1)
mov (%rdi,%rax,4),%ecx
mov %al,0x800(%rsp,%rdx,1)
add $0x1,%rax
mov %ecx,0x808(%rsp,%rdx,1)
cmp $0x100,%rax
jne 154c <func0+0xac>
movslq %ebp,%rsi
lea -0x10f(%rip),%rcx
mov $0xc,%edx
mov %r12,%rdi
callq 10a0 <qsort@plt>
movslq %ebx,%rax
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
cmp %ebx,%ebp
cmovle %ebp,%ebx
test %ebx,%ebx
jle 15e2 <func0+0x142>
lea -0x1(%rbx),%edx
lea 0x3(%rdx,%rdx,2),%rsi
xor %edx,%edx
shl $0x2,%rsi
nopl 0x0(%rax,%rax,1)
mov (%r12,%rdx,1),%rcx
mov %rcx,(%rax,%rdx,1)
mov 0x8(%r12,%rdx,1),%ecx
mov %ecx,0x8(%rax,%rdx,1)
add $0xc,%rdx
cmp %rdx,%rsi
jne 15c8 <func0+0x128>
mov 0x1408(%rsp),%rbx
xor %fs:0x28,%rbx
jne 1601 <func0+0x161>
add $0x1410,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1018h+var_1018], 0
sub rsp, 410h
mov ecx, 80h
mov rax, fs:28h
mov [rsp+1428h+var_20], rax
xor eax, eax
mov ebp, esi
mov rsi, rsp
mov r9, rdi
lea r8, [rsp+1428h+var_1028]
mov rdi, rsi
rep stosq
mov rax, 0FFFFFFFFFFFFFFFFh
mov ecx, 80h
mov rdi, r8
rep stosq
movzx eax, byte ptr [r9]
test al, al
jz short loc_153D
nop dword ptr [rax+rax+00h]
loc_1518:
mov edx, [rsp+rax*4+1428h+var_1028]
add [rsp+rax*4+1428h+var_1428], 1
cmp edx, 0FFFFFFFFh
cmovz edx, ecx
add rcx, 1
mov [rsp+rax*4+1428h+var_1028], edx
movzx eax, byte ptr [r9+rcx]
test al, al
jnz short loc_1518
loc_153D:
xor eax, eax
xor ebx, ebx
nop dword ptr [rax+00000000h]
loc_1548:
add rax, 1
cmp rax, 100h
jz short loc_158E
loc_1554:
mov ecx, [rsi+rax*4]
test ecx, ecx
jle short loc_1548
movsxd rdx, ebx
add ebx, 1
lea rdx, [rdx+rdx*2]
shl rdx, 2
mov [rsp+rdx+1428h+var_C24], ecx
mov ecx, [r8+rax*4]
mov [rsp+rdx+1428h+var_C28], al
add rax, 1
mov [rsp+rdx+1428h+var_C20], ecx
cmp rax, 100h
jnz short loc_1554
loc_158E:
lea r12, [rsp+1428h+var_C28]
movsxd rsi, ebx
mov edx, 0Ch
lea rcx, compare
mov rdi, r12
call _qsort
movsxd rax, ebp
lea rdi, [rax+rax*2]
shl rdi, 2
call _malloc
cmp ebx, ebp
cmovg ebx, ebp
mov r8, rax
test ebx, ebx
jle short loc_15E2
movsxd rbx, ebx
mov rsi, r12
mov rdi, rax
lea rdx, [rbx+rbx*2]
shl rdx, 2
call _memcpy
mov r8, rax
loc_15E2:
mov rax, [rsp+1428h+var_20]
sub rax, fs:28h
jnz short loc_1604
add rsp, 1410h
mov rax, r8
pop rbx
pop rbp
pop r12
retn
loc_1604:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1, int a2)
{
long long v2; // rcx
long long i; // rax
int v4; // edx
long long v5; // rax
int v6; // ebx
int v7; // ecx
long long v8; // rdx
int v9; // ecx
long long v10; // rax
long long v11; // rcx
long long v12; // r8
_DWORD v14[256]; // [rsp+0h] [rbp-1428h] BYREF
_QWORD v15[128]; // [rsp+400h] [rbp-1028h] BYREF
_BYTE v16[3080]; // [rsp+800h] [rbp-C28h] BYREF
unsigned long long v17; // [rsp+1408h] [rbp-20h]
v17 = __readfsqword(0x28u);
memset(v14, 0, sizeof(v14));
memset(v15, 0xFFu, sizeof(v15));
v2 = 0LL;
for ( i = *a1; (_BYTE)i; i = a1[v2] )
{
v4 = *((_DWORD *)v15 + i);
++v14[i];
if ( v4 == -1 )
v4 = v2;
++v2;
*((_DWORD *)v15 + i) = v4;
}
v5 = 0LL;
v6 = 0;
while ( ++v5 != 256 )
{
while ( 1 )
{
v7 = v14[v5];
if ( v7 <= 0 )
break;
v8 = v6++;
v8 *= 12LL;
*(_DWORD *)&v16[v8 + 4] = v7;
v9 = *((_DWORD *)v15 + v5);
v16[v8] = v5++;
*(_DWORD *)&v16[v8 + 8] = v9;
if ( v5 == 256 )
goto LABEL_9;
}
}
LABEL_9:
qsort(v16, v6, 12LL, compare);
v10 = malloc(12LL * a2);
if ( v6 > a2 )
v6 = a2;
v12 = v10;
if ( v6 > 0 )
return memcpy(v10, v16, 12LL * v6, v11, v10);
return v12;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x410
MOV ECX,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1408],RAX
XOR EAX,EAX
MOV EBP,ESI
MOV RSI,RSP
MOV R9,RDI
LEA R8,[RSP + 0x400]
MOV RDI,RSI
STOSQ.REP RDI
MOV RAX,-0x1
MOV ECX,0x80
MOV RDI,R8
STOSQ.REP RDI
MOVZX EAX,byte ptr [R9]
TEST AL,AL
JZ 0x0010153d
NOP dword ptr [RAX + RAX*0x1]
LAB_00101518:
MOV EDX,dword ptr [RSP + RAX*0x4 + 0x400]
ADD dword ptr [RSP + RAX*0x4],0x1
CMP EDX,-0x1
CMOVZ EDX,ECX
ADD RCX,0x1
MOV dword ptr [RSP + RAX*0x4 + 0x400],EDX
MOVZX EAX,byte ptr [R9 + RCX*0x1]
TEST AL,AL
JNZ 0x00101518
LAB_0010153d:
XOR EAX,EAX
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_00101548:
ADD RAX,0x1
CMP RAX,0x100
JZ 0x0010158e
LAB_00101554:
MOV ECX,dword ptr [RSI + RAX*0x4]
TEST ECX,ECX
JLE 0x00101548
MOVSXD RDX,EBX
ADD EBX,0x1
LEA RDX,[RDX + RDX*0x2]
SHL RDX,0x2
MOV dword ptr [RSP + RDX*0x1 + 0x804],ECX
MOV ECX,dword ptr [R8 + RAX*0x4]
MOV byte ptr [RSP + RDX*0x1 + 0x800],AL
ADD RAX,0x1
MOV dword ptr [RSP + RDX*0x1 + 0x808],ECX
CMP RAX,0x100
JNZ 0x00101554
LAB_0010158e:
LEA R12,[RSP + 0x800]
MOVSXD RSI,EBX
MOV EDX,0xc
LEA RCX,[0x101490]
MOV RDI,R12
CALL 0x001010b0
MOVSXD RAX,EBP
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010f0
CMP EBX,EBP
CMOVG EBX,EBP
MOV R8,RAX
TEST EBX,EBX
JLE 0x001015e2
MOVSXD RBX,EBX
MOV RSI,R12
MOV RDI,RAX
LEA RDX,[RBX + RBX*0x2]
SHL RDX,0x2
CALL 0x001010e0
MOV R8,RAX
LAB_001015e2:
MOV RAX,qword ptr [RSP + 0x1408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101604
ADD RSP,0x1410
MOV RAX,R8
POP RBX
POP RBP
POP R12
RET
LAB_00101604:
CALL 0x001010c0 | void * func0(byte *param_1,int param_2)
{
byte bVar1;
int iVar2;
void *__dest;
long lVar3;
long lVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int aiStack_1428 [256];
int local_1028 [256];
int1 local_c28 [4];
int aiStack_c24 [769];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = aiStack_1428;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar6 = 0;
piVar6 = (int *)((long)piVar6 + 8);
}
piVar6 = local_1028;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
piVar6[0] = -1;
piVar6[1] = -1;
piVar6 = piVar6 + 2;
}
bVar1 = *param_1;
if (bVar1 != 0) {
lVar3 = 0;
do {
iVar5 = local_1028[bVar1];
aiStack_1428[bVar1] = aiStack_1428[bVar1] + 1;
if (iVar5 == -1) {
iVar5 = (int)lVar3;
}
lVar3 = lVar3 + 1;
local_1028[bVar1] = iVar5;
bVar1 = param_1[lVar3];
} while (bVar1 != 0);
}
lVar3 = 0;
iVar5 = 0;
while (lVar3 = lVar3 + 1, lVar3 != 0x100) {
while (0 < aiStack_1428[lVar3]) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
aiStack_c24[lVar4 * 3] = aiStack_1428[lVar3];
iVar2 = local_1028[lVar3];
local_c28[lVar4 * 0xc] = (char)lVar3;
lVar3 = lVar3 + 1;
aiStack_c24[lVar4 * 3 + 1] = iVar2;
if (lVar3 == 0x100) goto LAB_0010158e;
}
}
LAB_0010158e:
qsort(local_c28,(long)iVar5,0xc,compare);
__dest = malloc((long)param_2 * 0xc);
if (param_2 < iVar5) {
iVar5 = param_2;
}
if (0 < iVar5) {
__dest = memcpy(__dest,local_c28,(long)iVar5 * 0xc);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,679 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count != cc1->count)
return cc2->count - cc1->count;
return cc1->first_index - cc2->first_index;
}
| CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_occurrence[c] = i;
}
CharCount temp[256];
int unique = 0;
for (int i = 0; i < 256; i++) {
if (counts[i] > 0) {
temp[unique].character = (char)i;
temp[unique].count = counts[i];
temp[unique].first_index = first_occurrence[i];
unique++;
}
}
qsort(temp, unique, sizeof(CharCount), compare);
CharCount* result = malloc(a * sizeof(CharCount));
for (int i = 0; i < a && i < unique; i++) {
result[i] = temp[i];
}
return result;
}
| int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafsdfafkpwe", 2);
assert(res2[0].character == 's' && res2[0].count == 4);
assert(res2[1].character == 'e' && res2[1].count == 3);
free(res2);
CharCount* res3 = func0("lkseropewdssafsdfafkpwe", 7);
assert(res3[0].character == 's' && res3[0].count == 4);
assert(res3[1].character == 'e' && res3[1].count == 3);
assert(res3[2].character == 'f' && res3[2].count == 3);
assert(res3[3].character == 'k' && res3[3].count == 2);
assert(res3[4].character == 'p' && res3[4].count == 2);
assert(res3[5].character == 'w' && res3[5].count == 2);
assert(res3[6].character == 'd' && res3[6].count == 2);
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x410,%rsp
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x1408(%rsp)
xor %eax,%eax
mov %esi,%ebp
mov %rsp,%rsi
mov %rdi,%r9
lea 0x400(%rsp),%r8
mov %rsi,%rdi
rep stos %rax,%es:(%rdi)
mov $0xffffffffffffffff,%rax
mov $0x80,%ecx
mov %r8,%rdi
rep stos %rax,%es:(%rdi)
movzbl (%r9),%eax
test %al,%al
je 1547 <func0+0x87>
xor %edx,%edx
nopl (%rax)
addl $0x1,(%rsp,%rax,4)
cmpl $0xffffffff,0x400(%rsp,%rax,4)
je 1608 <func0+0x148>
add $0x1,%rdx
movzbl (%r9,%rdx,1),%eax
test %al,%al
jne 1528 <func0+0x68>
xor %eax,%eax
xor %ebx,%ebx
nopl 0x0(%rax,%rax,1)
mov (%rsi,%rax,4),%ecx
test %ecx,%ecx
jle 157e <func0+0xbe>
movslq %ebx,%rdx
add $0x1,%ebx
lea (%rdx,%rdx,2),%rdx
shl $0x2,%rdx
mov %ecx,0x804(%rsp,%rdx,1)
mov (%r8,%rax,4),%ecx
mov %al,0x800(%rsp,%rdx,1)
mov %ecx,0x808(%rsp,%rdx,1)
add $0x1,%rax
cmp $0x100,%rax
jne 1550 <func0+0x90>
lea 0x800(%rsp),%r12
movslq %ebx,%rsi
mov $0xc,%edx
lea -0x101(%rip),%rcx
mov %r12,%rdi
callq 10b0 <qsort@plt>
movslq %ebp,%rax
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
cmp %ebp,%ebx
cmovg %ebp,%ebx
mov %rax,%r8
test %ebx,%ebx
jle 15df <func0+0x11f>
lea -0x1(%rbx),%eax
mov %r8,%rdi
mov %r12,%rsi
lea 0x3(%rax,%rax,2),%rdx
shl $0x2,%rdx
callq 10e0 <memcpy@plt>
mov %rax,%r8
mov 0x1408(%rsp),%rax
xor %fs:0x28,%rax
jne 1625 <func0+0x165>
add $0x1410,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %edx,0x400(%rsp,%rax,4)
add $0x1,%rdx
movzbl (%r9,%rdx,1),%eax
test %al,%al
jne 1528 <func0+0x68>
jmpq 1547 <func0+0x87>
callq 10c0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1018h+var_1018], 0
sub rsp, 410h
mov ecx, 80h
xor edx, edx
mov rax, fs:28h
mov [rsp+1428h+var_20], rax
xor eax, eax
mov ebx, esi
mov rsi, rsp
mov r9, rdi
lea r8, [rsp+1428h+var_1028]
mov rdi, rsi
rep stosq
mov rax, 0FFFFFFFFFFFFFFFFh
mov ecx, 80h
mov rdi, r8
rep stosq
movzx eax, byte ptr [r9]
test al, al
jz short loc_1540
nop dword ptr [rax]
loc_1518:
mov ecx, [rsp+rax*4+1428h+var_1028]
add [rsp+rax*4+1428h+var_1428], 1
cmp ecx, 0FFFFFFFFh
jz loc_1600
add rdx, 1
mov [rsp+rax*4+1428h+var_1028], ecx
movzx eax, byte ptr [r9+rdx]
test al, al
jnz short loc_1518
loc_1540:
xor eax, eax
xor ebp, ebp
lea r12, [rsp+1428h+base]
nop dword ptr [rax+00h]
loc_1550:
mov edx, [rsi+rax*4]
test edx, edx
jle short loc_1581
movd xmm1, dword ptr [r8+rax*4]
movsxd rcx, ebp
movd xmm0, edx
add ebp, 1
lea rcx, [rcx+rcx*2]
shl rcx, 2
punpckldq xmm0, xmm1
mov [rsp+rcx+1428h+base], al
movq qword ptr [r12+rcx+4], xmm0
loc_1581:
add rax, 1
cmp rax, 100h
jnz short loc_1550
movsxd rsi, ebp; nmemb
lea rcx, compare; compar
mov edx, 0Ch; size
mov rdi, r12; base
call _qsort
movsxd rax, ebx
lea rdi, [rax+rax*2]
shl rdi, 2; size
call _malloc
cmp ebp, ebx
cmovg rbp, rbx
mov rcx, rax
test ebp, ebp
jle short loc_15D8
lea rdx, [rbp+rbp*2+0]
mov rsi, r12; src
mov rdi, rax; dest
shl rdx, 2; n
call _memcpy
mov rcx, rax
loc_15D8:
mov rax, [rsp+1428h+var_20]
sub rax, fs:28h
jnz short loc_161D
add rsp, 1410h
mov rax, rcx
pop rbx
pop rbp
pop r12
retn
loc_1600:
mov [rsp+rax*4+1428h+var_1028], edx
add rdx, 1
movzx eax, byte ptr [r9+rdx]
test al, al
jnz loc_1518
jmp loc_1540
loc_161D:
call ___stack_chk_fail | void * func0(unsigned __int8 *a1, int a2)
{
long long v2; // rdx
long long i; // rax
int v4; // ecx
long long v5; // rax
long long v6; // rbp
signed int v7; // edx
long long v8; // rcx
unsigned long long v9; // xmm0_8
void *v10; // rax
void *v11; // rcx
_DWORD v13[256]; // [rsp+0h] [rbp-1428h] BYREF
_QWORD v14[128]; // [rsp+400h] [rbp-1028h] BYREF
_BYTE base[3080]; // [rsp+800h] [rbp-C28h] BYREF
unsigned long long v16; // [rsp+1408h] [rbp-20h]
v2 = 0LL;
v16 = __readfsqword(0x28u);
memset(v13, 0, sizeof(v13));
memset(v14, 0xFFu, sizeof(v14));
for ( i = *a1; (_BYTE)i; i = a1[v2] )
{
while ( 1 )
{
v4 = *((_DWORD *)v14 + i);
++v13[i];
if ( v4 == -1 )
break;
++v2;
*((_DWORD *)v14 + i) = v4;
i = a1[v2];
if ( !(_BYTE)i )
goto LABEL_4;
}
*((_DWORD *)v14 + i) = v2++;
}
LABEL_4:
v5 = 0LL;
v6 = 0LL;
do
{
v7 = v13[v5];
if ( v7 > 0 )
{
v8 = (int)v6;
v6 = (unsigned int)(v6 + 1);
v8 *= 12LL;
v9 = _mm_unpacklo_epi32(_mm_cvtsi32_si128(v7), _mm_cvtsi32_si128(*((_DWORD *)v14 + v5))).m128i_u64[0];
base[v8] = v5;
*(_QWORD *)&base[v8 + 4] = v9;
}
++v5;
}
while ( v5 != 256 );
qsort(base, (int)v6, 0xCuLL, compare);
v10 = malloc(12LL * a2);
if ( (int)v6 > a2 )
v6 = (unsigned int)a2;
v11 = v10;
if ( (int)v6 > 0 )
return memcpy(v10, base, 12 * v6);
return v11;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x410
MOV ECX,0x80
XOR EDX,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1408],RAX
XOR EAX,EAX
MOV EBX,ESI
MOV RSI,RSP
MOV R9,RDI
LEA R8,[RSP + 0x400]
MOV RDI,RSI
STOSQ.REP RDI
MOV RAX,-0x1
MOV ECX,0x80
MOV RDI,R8
STOSQ.REP RDI
MOVZX EAX,byte ptr [R9]
TEST AL,AL
JZ 0x00101540
NOP dword ptr [RAX]
LAB_00101518:
MOV ECX,dword ptr [RSP + RAX*0x4 + 0x400]
ADD dword ptr [RSP + RAX*0x4],0x1
CMP ECX,-0x1
JZ 0x00101600
ADD RDX,0x1
MOV dword ptr [RSP + RAX*0x4 + 0x400],ECX
MOVZX EAX,byte ptr [R9 + RDX*0x1]
TEST AL,AL
JNZ 0x00101518
LAB_00101540:
XOR EAX,EAX
XOR EBP,EBP
LEA R12,[RSP + 0x800]
NOP dword ptr [RAX]
LAB_00101550:
MOV EDX,dword ptr [RSI + RAX*0x4]
TEST EDX,EDX
JLE 0x00101581
MOVD XMM1,dword ptr [R8 + RAX*0x4]
MOVSXD RCX,EBP
MOVD XMM0,EDX
ADD EBP,0x1
LEA RCX,[RCX + RCX*0x2]
SHL RCX,0x2
PUNPCKLDQ XMM0,XMM1
MOV byte ptr [RSP + RCX*0x1 + 0x800],AL
MOVQ qword ptr [R12 + RCX*0x1 + 0x4],XMM0
LAB_00101581:
ADD RAX,0x1
CMP RAX,0x100
JNZ 0x00101550
MOVSXD RSI,EBP
LEA RCX,[0x101490]
MOV EDX,0xc
MOV RDI,R12
CALL 0x001010b0
MOVSXD RAX,EBX
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010f0
CMP EBP,EBX
CMOVG RBP,RBX
MOV RCX,RAX
TEST EBP,EBP
JLE 0x001015d8
LEA RDX,[RBP + RBP*0x2]
MOV RSI,R12
MOV RDI,RAX
SHL RDX,0x2
CALL 0x001010e0
MOV RCX,RAX
LAB_001015d8:
MOV RAX,qword ptr [RSP + 0x1408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010161d
ADD RSP,0x1410
MOV RAX,RCX
POP RBX
POP RBP
POP R12
RET
LAB_00101600:
MOV dword ptr [RSP + RAX*0x4 + 0x400],EDX
ADD RDX,0x1
MOVZX EAX,byte ptr [R9 + RDX*0x1]
TEST AL,AL
JNZ 0x00101518
JMP 0x00101540
LAB_0010161d:
CALL 0x001010c0 | void * func0(byte *param_1,uint param_2)
{
byte bVar1;
int iVar2;
int iVar3;
void *__dest;
long lVar4;
long lVar5;
int iVar6;
ulong uVar7;
int *piVar8;
long in_FS_OFFSET;
int local_1428 [256];
int local_1028 [256];
int local_c28 [4];
int8 auStack_c24 [384];
long local_20;
lVar5 = 0;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = local_1428;
for (lVar4 = 0x80; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)piVar8 = 0;
piVar8 = (int *)((long)piVar8 + 8);
}
piVar8 = local_1028;
for (lVar4 = 0x80; lVar4 != 0; lVar4 = lVar4 + -1) {
piVar8[0] = -1;
piVar8[1] = -1;
piVar8 = piVar8 + 2;
}
bVar1 = *param_1;
while (bVar1 != 0) {
while( true ) {
local_1428[bVar1] = local_1428[bVar1] + 1;
if (local_1028[bVar1] == -1) break;
lVar5 = lVar5 + 1;
local_1028[bVar1] = local_1028[bVar1];
bVar1 = param_1[lVar5];
if (bVar1 == 0) goto LAB_00101540;
}
local_1028[bVar1] = (int)lVar5;
lVar5 = lVar5 + 1;
bVar1 = param_1[lVar5];
}
LAB_00101540:
lVar5 = 0;
uVar7 = 0;
do {
iVar2 = local_1428[lVar5];
if (0 < iVar2) {
iVar3 = local_1028[lVar5];
iVar6 = (int)uVar7;
uVar7 = (ulong)(iVar6 + 1);
lVar4 = (long)iVar6 * 0xc;
local_c28[lVar4] = (char)lVar5;
*(ulong *)((long)auStack_c24 + lVar4) = CONCAT44(iVar3,iVar2);
}
lVar5 = lVar5 + 1;
} while (lVar5 != 0x100);
qsort(local_c28,(long)(int)uVar7,0xc,compare);
__dest = malloc((long)(int)param_2 * 0xc);
if ((int)param_2 < (int)uVar7) {
uVar7 = (ulong)param_2;
}
if (0 < (int)uVar7) {
__dest = memcpy(__dest,local_c28,uVar7 * 0xc);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,680 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char *list1[], int n) {
int min = strlen(list1[0]);
for (int i = 0; i < n; i++) {
if (strlen(list1[i]) < min) {
min = strlen(list1[i]);
}
}
return min;
}
| int main() {
char *list1[] = {"win", "lose", "great"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"12", "12", "1234"};
assert(func0(list1, 3) == 3);
assert(func0(list2, 3) == 1);
assert(func0(list3, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1207 <func0+0x7e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov -0x8(%rbp),%edx
movslq %edx,%rdx
cmp %rdx,%rax
jae 1203 <func0+0x7a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11b7 <func0+0x2e>
mov -0x8(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_1209
loc_11B7:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov eax, [rbp+var_8]
cdqe
cmp rdx, rax
jnb short loc_1205
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
loc_1205:
add [rbp+var_4], 1
loc_1209:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11B7
mov eax, [rbp+var_8]
leave
retn | long long func0(const char **a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = strlen(*a1);
for ( i = 0; i < a2; ++i )
{
if ( strlen(a1[i]) < (int)v3 )
v3 = strlen(a1[i]);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101209
LAB_001011b7:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
CMP RDX,RAX
JNC 0x00101205
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x8],EAX
LAB_00101205:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101209:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011b7
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET | int func0(int8 *param_1,int param_2)
{
size_t sVar1;
int local_10;
int local_c;
sVar1 = strlen((char *)*param_1);
local_10 = (int)sVar1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
sVar1 = strlen((char *)param_1[local_c]);
if (sVar1 < (ulong)(long)local_10) {
sVar1 = strlen((char *)param_1[local_c]);
local_10 = (int)sVar1;
}
}
return local_10;
} |
7,681 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char *list1[], int n) {
int min = strlen(list1[0]);
for (int i = 0; i < n; i++) {
if (strlen(list1[i]) < min) {
min = strlen(list1[i]);
}
}
return min;
}
| int main() {
char *list1[] = {"win", "lose", "great"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"12", "12", "1234"};
assert(func0(list1, 3) == 3);
assert(func0(list2, 3) == 1);
assert(func0(list3, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r9
mov (%rdi),%rdi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r8d
test %esi,%esi
jle 11c5 <func0+0x5c>
mov %r9,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%r9,%rax,8),%r10
mov $0xffffffffffffffff,%r9
mov $0x0,%eax
mov (%rdx),%rdi
mov %r9,%rcx
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
movslq %r8d,%rsi
cmp %rsi,%rcx
cmovb %ecx,%r8d
add $0x8,%rdx
cmp %r10,%rdx
jne 11a3 <func0+0x3a>
mov %r8d,%eax
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov r13d, esi
mov rdi, [rdi]
call _strlen
mov ebp, eax
test r13d, r13d
jle short loc_11D2
mov rbx, r12
lea eax, [r13-1]
lea r12, [r12+rax*8+8]
loc_11B8:
mov rdi, [rbx]
call _strlen
movsxd rdx, ebp
cmp rax, rdx
cmovb ebp, eax
add rbx, 8
cmp rbx, r12
jnz short loc_11B8
loc_11D2:
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(_QWORD *a1, int a2)
{
unsigned int v2; // ebp
_QWORD *v3; // rbx
unsigned long long v4; // rax
v2 = strlen(*a1);
if ( a2 > 0 )
{
v3 = a1;
do
{
v4 = strlen(*v3);
if ( v4 < (int)v2 )
v2 = v4;
++v3;
}
while ( v3 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV R13D,ESI
MOV RDI,qword ptr [RDI]
CALL 0x00101070
MOV EBP,EAX
TEST R13D,R13D
JLE 0x001011d2
MOV RBX,R12
LEA EAX,[R13 + -0x1]
LEA R12,[R12 + RAX*0x8 + 0x8]
LAB_001011b8:
MOV RDI,qword ptr [RBX]
CALL 0x00101070
MOVSXD RDX,EBP
CMP RAX,RDX
CMOVC EBP,EAX
ADD RBX,0x8
CMP RBX,R12
JNZ 0x001011b8
LAB_001011d2:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | ulong func0(int8 *param_1,int param_2)
{
int8 *puVar1;
size_t sVar2;
ulong uVar3;
sVar2 = strlen((char *)*param_1);
uVar3 = sVar2 & 0xffffffff;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
sVar2 = strlen((char *)*param_1);
if (sVar2 < (ulong)(long)(int)uVar3) {
uVar3 = sVar2 & 0xffffffff;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return uVar3;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.