index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
4,782 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int* test_array, int size) {
for (int i = 1; i < size; i++) {
if (sizeof(test_array[i]) != sizeof(test_array[0])) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {5, 6, 7, 3, 5, 6};
int arr2[] = {1, 2}; // Incomplete test, as third element is a string in Python.
int arr3[] = {3, 2, 1, 4, 5};
assert(func0(arr1, sizeof(arr1) / sizeof(arr1[0])) == true);
// assert line for arr2 is omitted as C cannot handle mixed data types like Python tuples.
assert(func0(arr3, sizeof(arr3) / sizeof(arr3[0])) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
retn | long long func0()
{
return 1LL;
} | func0:
ENDBR64
MOV EAX,0x1
RET | int8 func0(void)
{
return 1;
} |
4,783 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int* test_array, int size) {
for (int i = 1; i < size; i++) {
if (sizeof(test_array[i]) != sizeof(test_array[0])) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {5, 6, 7, 3, 5, 6};
int arr2[] = {1, 2}; // Incomplete test, as third element is a string in Python.
int arr3[] = {3, 2, 1, 4, 5};
assert(func0(arr1, sizeof(arr1) / sizeof(arr1[0])) == true);
// assert line for arr2 is omitted as C cannot handle mixed data types like Python tuples.
assert(func0(arr3, sizeof(arr3) / sizeof(arr3[0])) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
retn | long long func0()
{
return 1LL;
} | func0:
ENDBR64
MOV EAX,0x1
RET | int8 func0(void)
{
return 1;
} |
4,784 | func0 |
#include <stdbool.h>
#include <assert.h>
int binary_search(int arr[], int low, int high, int x) {
while (high >= low) {
int mid = (low + high) / 2;
if ((mid == 0 || x > arr[mid - 1]) && (arr[mid] == x)) {
return mid;
} else if (x > arr[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
| bool func0(int arr[], int n, int x) {
int i = binary_search(arr, 0, n - 1, x);
if (i == -1) {
return false;
}
if ((i + n / 2) <= (n - 1) && arr[i + n / 2] == x) {
return true;
} else {
return false;
}
}
| int main() {
int arr1[] = {1, 2, 3, 3, 3, 3, 10};
assert(func0(arr1, 7, 3) == true);
int arr2[] = {1, 1, 2, 4, 4, 4, 6, 6};
assert(func0(arr2, 8, 4) == false);
int arr3[] = {1, 1, 1, 2, 2};
assert(func0(arr3, 5, 1) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x20(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%ecx
mov %esi,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 1169 <binary_search>
mov %eax,-0x4(%rbp)
cmpl $0xffffffff,-0x4(%rbp)
jne 125e <func0+0x44>
mov $0x0,%eax
jmp 12ad <func0+0x93>
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x4(%rbp),%eax
add %edx,%eax
cmp %eax,-0x1c(%rbp)
jle 12a8 <func0+0x8e>
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x4(%rbp),%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jne 12a8 <func0+0x8e>
mov $0x1,%eax
jmp 12ad <func0+0x93>
mov $0x0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
lea esi, [rax-1]
mov edx, [rbp+var_20]
mov rax, [rbp+var_18]
mov ecx, edx
mov edx, esi
mov esi, 0
mov rdi, rax
call binary_search
mov [rbp+var_4], eax
cmp [rbp+var_4], 0FFFFFFFFh
jnz short loc_125E
mov eax, 0
jmp short locret_12AD
loc_125E:
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_4]
add eax, edx
cmp [rbp+var_1C], eax
jle short loc_12A8
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_4]
add eax, edx
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_12A8
mov eax, 1
jmp short locret_12AD
loc_12A8:
mov eax, 0
locret_12AD:
leave
retn | _BOOL8 func0(long long a1, int a2, unsigned int a3)
{
int v5; // [rsp+1Ch] [rbp-4h]
v5 = binary_search(a1, 0LL, (unsigned int)(a2 - 1), a3);
if ( v5 == -1 )
return 0LL;
return a2 > a2 / 2 + v5 && a3 == *(_DWORD *)(4LL * (a2 / 2 + v5) + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
LEA ESI,[RAX + -0x1]
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,EDX
MOV EDX,ESI
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101169
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],-0x1
JNZ 0x0010125e
MOV EAX,0x0
JMP 0x001012ad
LAB_0010125e:
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
CMP dword ptr [RBP + -0x1c],EAX
JLE 0x001012a8
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
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 0x001012a8
MOV EAX,0x1
JMP 0x001012ad
LAB_001012a8:
MOV EAX,0x0
LAB_001012ad:
LEAVE
RET | int8 func0(long param_1,int param_2,int param_3)
{
int iVar1;
int8 uVar2;
iVar1 = binary_search(param_1,0,param_2 + -1,param_3);
if (iVar1 == -1) {
uVar2 = 0;
}
else if ((iVar1 + param_2 / 2 < param_2) &&
(param_3 == *(int *)(param_1 + (long)(iVar1 + param_2 / 2) * 4))) {
uVar2 = 1;
}
else {
uVar2 = 0;
}
return uVar2;
} |
4,785 | func0 |
#include <stdbool.h>
#include <assert.h>
int binary_search(int arr[], int low, int high, int x) {
while (high >= low) {
int mid = (low + high) / 2;
if ((mid == 0 || x > arr[mid - 1]) && (arr[mid] == x)) {
return mid;
} else if (x > arr[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
| bool func0(int arr[], int n, int x) {
int i = binary_search(arr, 0, n - 1, x);
if (i == -1) {
return false;
}
if ((i + n / 2) <= (n - 1) && arr[i + n / 2] == x) {
return true;
} else {
return false;
}
}
| int main() {
int arr1[] = {1, 2, 3, 3, 3, 3, 10};
assert(func0(arr1, 7, 3) == true);
int arr2[] = {1, 1, 2, 4, 4, 4, 6, 6};
assert(func0(arr2, 8, 4) == false);
int arr3[] = {1, 1, 1, 2, 2};
assert(func0(arr3, 5, 1) == true);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebx
mov %edx,%ebp
lea -0x1(%rsi),%edx
mov %ebp,%ecx
mov $0x0,%esi
callq 1169 <binary_search>
mov $0x0,%ecx
cmp $0xffffffff,%eax
je 1203 <func0+0x42>
mov %eax,%edx
mov %ebx,%eax
shr $0x1f,%eax
add %ebx,%eax
sar %eax
add %edx,%eax
cmp %ebx,%eax
jge 1203 <func0+0x42>
cltq
cmp %ebp,(%r12,%rax,4)
sete %cl
mov %ecx,%eax
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov ebx, esi
mov ebp, edx
lea edx, [rsi-1]
mov ecx, ebp
mov esi, 0
call binary_search
mov edx, 0
cmp eax, 0FFFFFFFFh
jz short loc_1208
mov edx, ebx
shr edx, 1Fh
add edx, ebx
sar edx, 1
add eax, edx
mov edx, 0
cmp eax, ebx
jge short loc_1208
cdqe
cmp [r12+rax*4], ebp
setz dl
loc_1208:
mov eax, edx
pop rbx
pop rbp
pop r12
retn | long long func0(long long a1, int a2, unsigned int a3)
{
int v4; // eax
unsigned int v5; // edx
int v6; // eax
v4 = binary_search(a1, 0LL, (unsigned int)(a2 - 1), a3);
v5 = 0;
if ( v4 != -1 )
{
v6 = a2 / 2 + v4;
v5 = 0;
if ( v6 < a2 )
LOBYTE(v5) = *(_DWORD *)(a1 + 4LL * v6) == a3;
}
return v5;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV EBX,ESI
MOV EBP,EDX
LEA EDX,[RSI + -0x1]
MOV ECX,EBP
MOV ESI,0x0
CALL 0x00101169
MOV EDX,0x0
CMP EAX,-0x1
JZ 0x00101208
MOV EDX,EBX
SHR EDX,0x1f
ADD EDX,EBX
SAR EDX,0x1
ADD EAX,EDX
MOV EDX,0x0
CMP EAX,EBX
JGE 0x00101208
CDQE
CMP dword ptr [R12 + RAX*0x4],EBP
SETZ DL
LAB_00101208:
MOV EAX,EDX
POP RBX
POP RBP
POP R12
RET | bool func0(long param_1,int param_2,int param_3)
{
int iVar1;
bool bVar2;
iVar1 = binary_search(param_1,0,param_2 + -1,param_3);
bVar2 = false;
if (iVar1 != -1) {
iVar1 = iVar1 + param_2 / 2;
bVar2 = false;
if (iVar1 < param_2) {
bVar2 = *(int *)(param_1 + (long)iVar1 * 4) == param_3;
}
}
return bVar2;
} |
4,786 | func0 |
#include <stdbool.h>
#include <assert.h>
int binary_search(int arr[], int low, int high, int x) {
while (high >= low) {
int mid = (low + high) / 2;
if ((mid == 0 || x > arr[mid - 1]) && (arr[mid] == x)) {
return mid;
} else if (x > arr[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
| bool func0(int arr[], int n, int x) {
int i = binary_search(arr, 0, n - 1, x);
if (i == -1) {
return false;
}
if ((i + n / 2) <= (n - 1) && arr[i + n / 2] == x) {
return true;
} else {
return false;
}
}
| int main() {
int arr1[] = {1, 2, 3, 3, 3, 3, 10};
assert(func0(arr1, 7, 3) == true);
int arr2[] = {1, 1, 2, 4, 4, 4, 6, 6};
assert(func0(arr2, 8, 4) == false);
int arr3[] = {1, 1, 1, 2, 2};
assert(func0(arr3, 5, 1) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%r11d
mov %edx,%ecx
lea -0x1(%rsi),%edx
xor %esi,%esi
callq 12d0 <binary_search>
xor %r8d,%r8d
mov %eax,%edx
cmp $0xffffffff,%eax
je 1368 <func0+0x38>
mov %r11d,%eax
shr $0x1f,%eax
add %r11d,%eax
sar %eax
add %edx,%eax
cmp %r11d,%eax
jge 1368 <func0+0x38>
cltq
cmp %ecx,(%rdi,%rax,4)
sete %r8b
mov %r8d,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov ecx, edx
mov r11d, esi
lea edx, [rsi-1]
xor esi, esi
mov rbx, rdi
call binary_search
xor r8d, r8d
cmp eax, 0FFFFFFFFh
jz short loc_136A
mov edx, r11d
shr edx, 1Fh
add edx, r11d
sar edx, 1
add eax, edx
cmp eax, r11d
jge short loc_136A
cdqe
cmp [rbx+rax*4], ecx
setz r8b
loc_136A:
mov eax, r8d
pop rbx
retn | long long func0(long long a1, int a2, unsigned int a3)
{
int v3; // eax
int v4; // ecx
int v5; // r11d
unsigned int v6; // r8d
int v7; // eax
v3 = binary_search(a1, 0LL, (unsigned int)(a2 - 1), a3);
v6 = 0;
if ( v3 != -1 )
{
v7 = v5 / 2 + v3;
if ( v7 < v5 )
LOBYTE(v6) = *(_DWORD *)(a1 + 4LL * v7) == v4;
}
return v6;
} | func0:
ENDBR64
PUSH RBX
MOV ECX,EDX
MOV R11D,ESI
LEA EDX,[RSI + -0x1]
XOR ESI,ESI
MOV RBX,RDI
CALL 0x001012d0
XOR R8D,R8D
CMP EAX,-0x1
JZ 0x0010136a
MOV EDX,R11D
SHR EDX,0x1f
ADD EDX,R11D
SAR EDX,0x1
ADD EAX,EDX
CMP EAX,R11D
JGE 0x0010136a
CDQE
CMP dword ptr [RBX + RAX*0x4],ECX
SETZ R8B
LAB_0010136a:
MOV EAX,R8D
POP RBX
RET | bool func0(long param_1,uint param_2,int param_3)
{
int iVar1;
ulong uVar2;
bool bVar3;
uVar2 = (ulong)param_2;
iVar1 = binary_search(param_1,0,param_2 - 1,param_3);
bVar3 = false;
if ((iVar1 != -1) &&
(iVar1 = iVar1 + ((int)(((uint)(uVar2 >> 0x1f) & 1) + (int)uVar2) >> 1), iVar1 < (int)uVar2)) {
bVar3 = *(int *)(param_1 + (long)iVar1 * 4) == param_3;
}
return bVar3;
} |
4,787 | func0 |
#include <stdbool.h>
#include <assert.h>
int binary_search(int arr[], int low, int high, int x) {
while (high >= low) {
int mid = (low + high) / 2;
if ((mid == 0 || x > arr[mid - 1]) && (arr[mid] == x)) {
return mid;
} else if (x > arr[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
| bool func0(int arr[], int n, int x) {
int i = binary_search(arr, 0, n - 1, x);
if (i == -1) {
return false;
}
if ((i + n / 2) <= (n - 1) && arr[i + n / 2] == x) {
return true;
} else {
return false;
}
}
| int main() {
int arr1[] = {1, 2, 3, 3, 3, 3, 10};
assert(func0(arr1, 7, 3) == true);
int arr2[] = {1, 1, 2, 4, 4, 4, 6, 6};
assert(func0(arr2, 8, 4) == false);
int arr3[] = {1, 1, 1, 2, 2};
assert(func0(arr3, 5, 1) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%r8d
sub $0x1,%r8d
js 134f <func0+0x3f>
xor %r9d,%r9d
lea (%r9,%r8,1),%eax
sar %eax
mov %eax,%ecx
cltq
lea 0x0(,%rax,4),%r10
mov (%rdi,%rax,4),%eax
je 133e <func0+0x2e>
cmp -0x4(%rdi,%r10,1),%edx
jle 1342 <func0+0x32>
cmp %eax,%edx
je 1368 <func0+0x58>
cmp %eax,%edx
jle 1358 <func0+0x48>
lea 0x1(%rcx),%r9d
cmp %r8d,%r9d
jle 1320 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
lea -0x1(%rcx),%r8d
cmp %r9d,%r8d
jge 1320 <func0+0x10>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov %esi,%eax
shr $0x1f,%eax
add %esi,%eax
sar %eax
add %ecx,%eax
cmp %esi,%eax
jge 134f <func0+0x3f>
cltq
cmp %edx,(%rdi,%rax,4)
sete %al
retq
| func0:
endbr64
mov r8, rdi
mov r10d, esi
mov ecx, edx
sub esi, 1
js short loc_134B
xor edi, edi
nop dword ptr [rax+rax+00h]
loc_1318:
lea edx, [rdi+rsi]
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
movsxd rdx, eax
lea r9, ds:0[rdx*4]
mov edx, [r8+rdx*4]
jz short loc_133C
cmp ecx, [r8+r9-4]
jle short loc_1340
loc_133C:
cmp ecx, edx
jz short loc_1360
loc_1340:
cmp ecx, edx
jle short loc_1350
lea edi, [rax+1]
cmp edi, esi
jle short loc_1318
loc_134B:
xor edx, edx
loc_134D:
mov eax, edx
retn
loc_1350:
lea esi, [rax-1]
cmp esi, edi
jge short loc_1318
jmp short loc_134B
loc_1360:
cmp eax, 0FFFFFFFFh
jz short loc_134B
mov edx, r10d
sar edx, 1
add eax, edx
xor edx, edx
cmp eax, r10d
jge short loc_134D
cdqe
cmp [r8+rax*4], ecx
setz dl
mov eax, edx
retn | long long func0(long long a1, int a2, int a3)
{
int v6; // esi
int v7; // edi
int v8; // eax
long long v9; // r9
int v10; // edx
int v12; // eax
unsigned int v13; // edx
v6 = a2 - 1;
if ( v6 < 0 )
return 0LL;
v7 = 0;
while ( 1 )
{
v8 = (v7 + v6) / 2;
v9 = 4LL * v8;
v10 = *(_DWORD *)(a1 + v9);
if ( (!v8 || a3 > *(_DWORD *)(a1 + v9 - 4)) && a3 == v10 )
break;
if ( a3 <= v10 )
{
v6 = v8 - 1;
if ( v8 - 1 < v7 )
return 0LL;
}
else
{
v7 = v8 + 1;
if ( v8 + 1 > v6 )
return 0LL;
}
}
if ( v8 == -1 )
return 0LL;
v12 = (a2 >> 1) + v8;
v13 = 0;
if ( v12 >= a2 )
return 0LL;
LOBYTE(v13) = *(_DWORD *)(a1 + 4LL * v12) == a3;
return v13;
} | func0:
ENDBR64
MOV R8,RDI
MOV R10D,ESI
MOV ECX,EDX
SUB ESI,0x1
JS 0x0010134b
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101318:
LEA EDX,[RDI + RSI*0x1]
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOVSXD RDX,EAX
LEA R9,[RDX*0x4]
MOV EDX,dword ptr [R8 + RDX*0x4]
JZ 0x0010133c
CMP ECX,dword ptr [R8 + R9*0x1 + -0x4]
JLE 0x00101340
LAB_0010133c:
CMP ECX,EDX
JZ 0x00101360
LAB_00101340:
CMP ECX,EDX
JLE 0x00101350
LEA EDI,[RAX + 0x1]
CMP EDI,ESI
JLE 0x00101318
LAB_0010134b:
XOR EDX,EDX
LAB_0010134d:
MOV EAX,EDX
RET
LAB_00101350:
LEA ESI,[RAX + -0x1]
CMP ESI,EDI
JGE 0x00101318
JMP 0x0010134b
LAB_00101360:
CMP EAX,-0x1
JZ 0x0010134b
MOV EDX,R10D
SAR EDX,0x1
ADD EAX,EDX
XOR EDX,EDX
CMP EAX,R10D
JGE 0x0010134d
CDQE
CMP dword ptr [R8 + RAX*0x4],ECX
SETZ DL
MOV EAX,EDX
RET | bool func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar3 = param_2 + -1;
if (-1 < iVar3) {
iVar4 = 0;
do {
while( true ) {
iVar2 = (iVar4 + iVar3) / 2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (((iVar2 == 0) || (*(int *)(param_1 + -4 + (long)iVar2 * 4) < param_3)) &&
(param_3 == iVar1)) {
if (iVar2 == -1) {
return false;
}
iVar2 = iVar2 + (param_2 >> 1);
if (param_2 <= iVar2) {
return false;
}
return *(int *)(param_1 + (long)iVar2 * 4) == param_3;
}
if (param_3 <= iVar1) break;
iVar4 = iVar2 + 1;
if (iVar3 < iVar4) {
return false;
}
}
iVar3 = iVar2 + -1;
} while (iVar4 <= iVar3);
}
return false;
} |
4,788 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(4) == 1);
assert(func0(6) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1169 <func0+0x20>
mov -0x14(%rbp),%eax
and $0x1,%eax
add %eax,-0x4(%rbp)
sarl -0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 115d <func0+0x14>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_1169
loc_115D:
mov eax, [rbp+var_14]
and eax, 1
add [rbp+var_4], eax
sar [rbp+var_14], 1
loc_1169:
cmp [rbp+var_14], 0
jnz short loc_115D
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
unsigned int v3; // [rsp+10h] [rbp-4h]
v3 = 0;
while ( a1 )
{
v3 += a1 & 1;
a1 >>= 1;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101169
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
ADD dword ptr [RBP + -0x4],EAX
SAR dword ptr [RBP + -0x14],0x1
LAB_00101169:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010115d
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(uint param_1)
{
int4 local_1c;
int4 local_c;
local_c = 0;
for (local_1c = param_1; local_1c != 0; local_1c = (int)local_1c >> 1) {
local_c = local_c + (local_1c & 1);
}
return local_c;
} |
4,789 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(4) == 1);
assert(func0(6) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
je 1162 <func0+0x19>
mov $0x0,%eax
mov %edi,%edx
and $0x1,%edx
add %edx,%eax
sar %edi
jne 1156 <func0+0xd>
retq
mov %edi,%eax
retq
| func0:
endbr64
test edi, edi
jz short loc_1162
mov eax, 0
loc_1156:
mov edx, edi
and edx, 1
add eax, edx
sar edi, 1
jnz short loc_1156
retn
loc_1162:
mov eax, edi
retn | long long func0(int a1)
{
long long result; // rax
if ( !a1 )
return 0LL;
LODWORD(result) = 0;
do
{
result = (a1 & 1) + (unsigned int)result;
a1 >>= 1;
}
while ( a1 );
return result;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101162
MOV EAX,0x0
LAB_00101156:
MOV EDX,EDI
AND EDX,0x1
ADD EAX,EDX
SAR EDI,0x1
JNZ 0x00101156
RET
LAB_00101162:
MOV EAX,EDI
RET | int func0(uint param_1)
{
int iVar1;
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + (param_1 & 1);
param_1 = (int)param_1 >> 1;
} while (param_1 != 0);
return iVar1;
}
return 0;
} |
4,790 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(4) == 1);
assert(func0(6) == 2);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
je 1160 <func0+0x20>
nopw 0x0(%rax,%rax,1)
mov %edi,%edx
and $0x1,%edx
add %edx,%eax
sar %edi
jne 1150 <func0+0x10>
retq
nopl 0x0(%rax)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
test edi, edi
jz short locret_1160
nop word ptr [rax+rax+00h]
loc_1150:
mov edx, edi
and edx, 1
add eax, edx
sar edi, 1
jnz short loc_1150
retn
locret_1160:
retn | long long func0(int a1)
{
long long result; // rax
for ( result = 0LL; a1; a1 >>= 1 )
result = (a1 & 1) + (unsigned int)result;
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JZ 0x00101160
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
MOV EDX,EDI
AND EDX,0x1
ADD EAX,EDX
SAR EDI,0x1
JNZ 0x00101150
RET
LAB_00101160:
RET | int func0(uint param_1)
{
int iVar1;
iVar1 = 0;
if (param_1 == 0) {
return 0;
}
do {
iVar1 = iVar1 + (param_1 & 1);
param_1 = (int)param_1 >> 1;
} while (param_1 != 0);
return iVar1;
} |
4,791 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(4) == 1);
assert(func0(6) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
je 1160 <func0+0x20>
nopw 0x0(%rax,%rax,1)
mov %edi,%edx
and $0x1,%edx
add %edx,%eax
sar %edi
jne 1150 <func0+0x10>
retq
nopl 0x0(%rax)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
test edi, edi
jz short locret_1160
nop word ptr [rax+rax+00h]
loc_1150:
mov edx, edi
and edx, 1
add eax, edx
sar edi, 1
jnz short loc_1150
retn
locret_1160:
retn | long long func0(int a1)
{
long long result; // rax
for ( result = 0LL; a1; a1 >>= 1 )
result = (a1 & 1) + (unsigned int)result;
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JZ 0x00101160
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
MOV EDX,EDI
AND EDX,0x1
ADD EAX,EDX
SAR EDI,0x1
JNZ 0x00101150
RET
LAB_00101160:
RET | int func0(uint param_1)
{
int iVar1;
iVar1 = 0;
if (param_1 == 0) {
return 0;
}
do {
iVar1 = iVar1 + (param_1 & 1);
param_1 = (int)param_1 >> 1;
} while (param_1 != 0);
return iVar1;
} |
4,792 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
while (low < high) {
int mid = low + (high - low) / 2;
if (arr[mid] == arr[high]) {
high -= 1;
} else if (arr[mid] > arr[high]) {
low = mid + 1;
} else {
high = mid;
}
}
return arr[high];
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {4, 6, 8};
int arr3[] = {2, 3, 5, 7, 9};
assert(func0(arr1, 0, 4) == 1);
assert(func0(arr2, 0, 2) == 4);
assert(func0(arr3, 0, 4) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
jmpq 1210 <func0+0xa7>
mov -0x20(%rbp),%eax
sub -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11cf <func0+0x66>
subl $0x1,-0x20(%rbp)
jmp 1210 <func0+0xa7>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 120a <func0+0xa1>
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0x1c(%rbp)
jmp 1210 <func0+0xa7>
mov -0x4(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 1180 <func0+0x17>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
jmp loc_1210
loc_1180:
mov eax, [rbp+var_20]
sub eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_20]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11CF
sub [rbp+var_20], 1
jmp short loc_1210
loc_11CF:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_20]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_120A
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_1210
loc_120A:
mov eax, [rbp+var_4]
mov [rbp+var_20], eax
loc_1210:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jl loc_1180
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
int v6; // [rsp+1Ch] [rbp-4h]
while ( a2 < a3 )
{
v6 = (a3 - a2) / 2 + a2;
if ( *(_DWORD *)(4LL * v6 + a1) == *(_DWORD *)(4LL * a3 + a1) )
{
--a3;
}
else if ( *(_DWORD *)(4LL * v6 + a1) <= *(_DWORD *)(4LL * a3 + a1) )
{
a3 = (a3 - a2) / 2 + a2;
}
else
{
a2 = v6 + 1;
}
}
return *(unsigned int *)(4LL * a3 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
JMP 0x00101210
LAB_00101180:
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011cf
SUB dword ptr [RBP + -0x20],0x1
JMP 0x00101210
LAB_001011cf:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010120a
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00101210
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x20],EAX
LAB_00101210:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101180
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
POP RBP
RET | int4 func0(long param_1,int param_2,int param_3)
{
int iVar1;
int local_28;
int local_24;
iVar1 = param_3;
local_24 = param_2;
while (local_28 = iVar1, local_24 < local_28) {
iVar1 = local_24 + (local_28 - local_24) / 2;
if (*(int *)(param_1 + (long)iVar1 * 4) == *(int *)(param_1 + (long)local_28 * 4)) {
iVar1 = local_28 + -1;
}
else if (*(int *)(param_1 + (long)local_28 * 4) < *(int *)(param_1 + (long)iVar1 * 4)) {
local_24 = iVar1 + 1;
iVar1 = local_28;
}
}
return *(int4 *)(param_1 + (long)local_28 * 4);
} |
4,793 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
while (low < high) {
int mid = low + (high - low) / 2;
if (arr[mid] == arr[high]) {
high -= 1;
} else if (arr[mid] > arr[high]) {
low = mid + 1;
} else {
high = mid;
}
}
return arr[high];
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {4, 6, 8};
int arr3[] = {2, 3, 5, 7, 9};
assert(func0(arr1, 0, 4) == 1);
assert(func0(arr2, 0, 2) == 4);
assert(func0(arr3, 0, 4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edx,%esi
jl 117f <func0+0x16>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%eax
retq
sub $0x1,%edx
cmp %edx,%esi
jge 1171 <func0+0x8>
mov %edx,%ecx
sub %esi,%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
add %esi,%eax
movslq %eax,%rcx
mov (%rdi,%rcx,4),%r8d
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%r8d
je 1178 <func0+0xf>
jle 11a7 <func0+0x3e>
lea 0x1(%rax),%esi
jmp 117b <func0+0x12>
mov %eax,%edx
jmp 117b <func0+0x12>
| func0:
endbr64
mov r8, rdi
cmp esi, edx
jl short loc_1183
loc_1174:
movsxd rdx, edx
mov eax, [r8+rdx*4]
retn
loc_117C:
sub edx, 1
loc_117F:
cmp esi, edx
jge short loc_1174
loc_1183:
mov ecx, edx
sub ecx, esi
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
add eax, esi
movsxd rcx, eax
mov edi, [r8+rcx*4]
movsxd rcx, edx
mov ecx, [r8+rcx*4]
cmp edi, ecx
jz short loc_117C
jle short loc_11AB
lea esi, [rax+1]
jmp short loc_117F
loc_11AB:
mov edx, eax
jmp short loc_117F | long long func0(long long a1, int a2, int a3)
{
int v5; // eax
int v6; // edi
int v7; // ecx
while ( a2 < a3 )
{
v5 = a2 + (a3 - a2) / 2;
v6 = *(_DWORD *)(a1 + 4LL * v5);
v7 = *(_DWORD *)(a1 + 4LL * a3);
if ( v6 == v7 )
{
--a3;
}
else if ( v6 <= v7 )
{
a3 = a2 + (a3 - a2) / 2;
}
else
{
a2 = v5 + 1;
}
}
return *(unsigned int *)(a1 + 4LL * a3);
} | func0:
ENDBR64
MOV R8,RDI
CMP ESI,EDX
JL 0x00101183
LAB_00101174:
MOVSXD RDX,EDX
MOV EAX,dword ptr [R8 + RDX*0x4]
RET
LAB_0010117c:
SUB EDX,0x1
LAB_0010117f:
CMP ESI,EDX
JGE 0x00101174
LAB_00101183:
MOV ECX,EDX
SUB ECX,ESI
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
ADD EAX,ESI
MOVSXD RCX,EAX
MOV EDI,dword ptr [R8 + RCX*0x4]
MOVSXD RCX,EDX
MOV ECX,dword ptr [R8 + RCX*0x4]
CMP EDI,ECX
JZ 0x0010117c
JLE 0x001011ab
LEA ESI,[RAX + 0x1]
JMP 0x0010117f
LAB_001011ab:
MOV EDX,EAX
JMP 0x0010117f | int4 func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 < param_3) {
do {
iVar3 = (param_3 - param_2) / 2 + param_2;
iVar1 = *(int *)(param_1 + (long)iVar3 * 4);
iVar2 = *(int *)(param_1 + (long)param_3 * 4);
if (iVar1 == iVar2) {
iVar3 = param_3 + -1;
}
else if (iVar2 < iVar1) {
param_2 = iVar3 + 1;
iVar3 = param_3;
}
param_3 = iVar3;
} while (param_2 < param_3);
}
return *(int4 *)(param_1 + (long)param_3 * 4);
} |
4,794 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
while (low < high) {
int mid = low + (high - low) / 2;
if (arr[mid] == arr[high]) {
high -= 1;
} else if (arr[mid] > arr[high]) {
low = mid + 1;
} else {
high = mid;
}
}
return arr[high];
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {4, 6, 8};
int arr3[] = {2, 3, 5, 7, 9};
assert(func0(arr1, 0, 4) == 1);
assert(func0(arr2, 0, 2) == 4);
assert(func0(arr3, 0, 4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
movslq %edx,%rax
mov (%rdi,%rax,4),%r8d
cmp %edx,%esi
jl 12d1 <func0+0x21>
jmp 12f2 <func0+0x42>
nopl 0x0(%rax)
jle 1300 <func0+0x50>
lea 0x1(%rax),%esi
cmp %esi,%edx
jle 12f2 <func0+0x42>
mov %edx,%eax
sub %esi,%eax
sar %eax
add %esi,%eax
movslq %eax,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %r8d,%ecx
jne 12c8 <func0+0x18>
sub $0x1,%edx
movslq %edx,%rax
mov (%rdi,%rax,4),%r8d
cmp %esi,%edx
jg 12d1 <func0+0x21>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov %ecx,%r8d
mov %eax,%edx
jmp 12cd <func0+0x1d>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rax, edx
mov r8d, [rdi+rax*4]
cmp esi, edx
jl short loc_12D1
jmp short loc_12F2
loc_12C8:
jle short loc_1300
lea esi, [rax+1]
loc_12CD:
cmp edx, esi
jle short loc_12F2
loc_12D1:
mov eax, edx
sub eax, esi
sar eax, 1
add eax, esi
movsxd rcx, eax
mov ecx, [rdi+rcx*4]
cmp ecx, r8d
jnz short loc_12C8
sub edx, 1
movsxd rax, edx
mov r8d, [rdi+rax*4]
cmp edx, esi
jg short loc_12D1
loc_12F2:
mov eax, r8d
retn
loc_1300:
mov r8d, ecx
mov edx, eax
jmp short loc_12CD | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
int v4; // eax
int v5; // ecx
v3 = *(_DWORD *)(a1 + 4LL * a3);
while ( a3 > a2 )
{
while ( 1 )
{
v4 = a2 + ((a3 - a2) >> 1);
v5 = *(_DWORD *)(a1 + 4LL * v4);
if ( v5 != v3 )
break;
v3 = *(_DWORD *)(a1 + 4LL * --a3);
if ( a3 <= a2 )
return v3;
}
if ( v5 <= (int)v3 )
{
v3 = *(_DWORD *)(a1 + 4LL * v4);
a3 = a2 + ((a3 - a2) >> 1);
}
else
{
a2 = v4 + 1;
}
}
return v3;
} | func0:
ENDBR64
MOVSXD RAX,EDX
MOV R8D,dword ptr [RDI + RAX*0x4]
CMP ESI,EDX
JL 0x001012d1
JMP 0x001012f2
LAB_001012c8:
JLE 0x00101300
LEA ESI,[RAX + 0x1]
LAB_001012cd:
CMP EDX,ESI
JLE 0x001012f2
LAB_001012d1:
MOV EAX,EDX
SUB EAX,ESI
SAR EAX,0x1
ADD EAX,ESI
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP ECX,R8D
JNZ 0x001012c8
SUB EDX,0x1
MOVSXD RAX,EDX
MOV R8D,dword ptr [RDI + RAX*0x4]
CMP EDX,ESI
JG 0x001012d1
LAB_001012f2:
MOV EAX,R8D
RET
LAB_00101300:
MOV R8D,ECX
MOV EDX,EAX
JMP 0x001012cd | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = *(int *)(param_1 + (long)param_3 * 4);
if (param_2 < param_3) {
do {
while( true ) {
iVar2 = (param_3 - param_2 >> 1) + param_2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (iVar1 != iVar3) break;
param_3 = param_3 + -1;
iVar3 = *(int *)(param_1 + (long)param_3 * 4);
if (param_3 <= param_2) {
return iVar3;
}
}
if (iVar3 < iVar1) {
param_2 = iVar2 + 1;
iVar2 = param_3;
iVar1 = iVar3;
}
iVar3 = iVar1;
param_3 = iVar2;
} while (param_2 < param_3);
}
return iVar3;
} |
4,795 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
while (low < high) {
int mid = low + (high - low) / 2;
if (arr[mid] == arr[high]) {
high -= 1;
} else if (arr[mid] > arr[high]) {
low = mid + 1;
} else {
high = mid;
}
}
return arr[high];
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {4, 6, 8};
int arr3[] = {2, 3, 5, 7, 9};
assert(func0(arr1, 0, 4) == 1);
assert(func0(arr2, 0, 2) == 4);
assert(func0(arr3, 0, 4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
movslq %edx,%rax
mov (%rdi,%rax,4),%r8d
cmp %edx,%esi
jl 12b1 <func0+0x21>
jmp 12d2 <func0+0x42>
nopl 0x0(%rax)
jle 12e0 <func0+0x50>
lea 0x1(%rax),%esi
cmp %esi,%edx
jle 12d2 <func0+0x42>
mov %edx,%eax
sub %esi,%eax
sar %eax
add %esi,%eax
movslq %eax,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %r8d,%ecx
jne 12a8 <func0+0x18>
sub $0x1,%edx
movslq %edx,%rax
mov (%rdi,%rax,4),%r8d
cmp %esi,%edx
jg 12b1 <func0+0x21>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov %ecx,%r8d
mov %eax,%edx
jmp 12ad <func0+0x1d>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rax, edx
mov r8d, [rdi+rax*4]
cmp esi, edx
jl short loc_12A1
jmp short loc_12C2
loc_1298:
jle short loc_12D0
lea esi, [rax+1]
loc_129D:
cmp edx, esi
jle short loc_12C2
loc_12A1:
mov eax, edx
sub eax, esi
sar eax, 1
add eax, esi
movsxd rcx, eax
mov ecx, [rdi+rcx*4]
cmp ecx, r8d
jnz short loc_1298
sub edx, 1
movsxd rax, edx
mov r8d, [rdi+rax*4]
cmp edx, esi
jg short loc_12A1
loc_12C2:
mov eax, r8d
retn
loc_12D0:
mov r8d, ecx
mov edx, eax
jmp short loc_129D | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
int v4; // eax
int v5; // ecx
v3 = *(_DWORD *)(a1 + 4LL * a3);
while ( a3 > a2 )
{
while ( 1 )
{
v4 = a2 + ((a3 - a2) >> 1);
v5 = *(_DWORD *)(a1 + 4LL * v4);
if ( v5 != v3 )
break;
v3 = *(_DWORD *)(a1 + 4LL * --a3);
if ( a3 <= a2 )
return v3;
}
if ( v5 <= (int)v3 )
{
v3 = *(_DWORD *)(a1 + 4LL * v4);
a3 = a2 + ((a3 - a2) >> 1);
}
else
{
a2 = v4 + 1;
}
}
return v3;
} | func0:
ENDBR64
MOVSXD RAX,EDX
MOV R8D,dword ptr [RDI + RAX*0x4]
CMP ESI,EDX
JL 0x001012a1
JMP 0x001012c2
LAB_00101298:
JLE 0x001012d0
LEA ESI,[RAX + 0x1]
LAB_0010129d:
CMP EDX,ESI
JLE 0x001012c2
LAB_001012a1:
MOV EAX,EDX
SUB EAX,ESI
SAR EAX,0x1
ADD EAX,ESI
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP ECX,R8D
JNZ 0x00101298
SUB EDX,0x1
MOVSXD RAX,EDX
MOV R8D,dword ptr [RDI + RAX*0x4]
CMP EDX,ESI
JG 0x001012a1
LAB_001012c2:
MOV EAX,R8D
RET
LAB_001012d0:
MOV R8D,ECX
MOV EDX,EAX
JMP 0x0010129d | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = *(int *)(param_1 + (long)param_3 * 4);
if (param_2 < param_3) {
do {
while( true ) {
iVar2 = (param_3 - param_2 >> 1) + param_2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (iVar1 != iVar3) break;
param_3 = param_3 + -1;
iVar3 = *(int *)(param_1 + (long)param_3 * 4);
if (param_3 <= param_2) {
return iVar3;
}
}
if (iVar3 < iVar1) {
param_2 = iVar2 + 1;
iVar2 = param_3;
iVar1 = iVar3;
}
iVar3 = iVar1;
param_3 = iVar2;
} while (param_2 < param_3);
}
return iVar3;
} |
4,796 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* str) {
static char result[100];
int j = 0;
for(int i = 0; i < strlen(str); i++) {
if(i % 2 == 0) {
result[j++] = str[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("abcdef"), "ace") == 0);
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("data"), "dt") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11de <func0+0x55>
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 11da <func0+0x51>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2e69(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
cmp %rax,%rbx
jb 11aa <func0+0x21>
mov -0x18(%rbp),%eax
cltq
lea 0x2e3f(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2e34(%rip),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11DE
loc_11AA:
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jnz short loc_11DA
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, result_1
mov [rax+rcx], dl
loc_11DA:
add [rbp+var_14], 1
loc_11DE:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_11AA
mov eax, [rbp+var_18]
cdqe
lea rdx, result_1
mov byte ptr [rax+rdx], 0
lea rax, result_1
mov rbx, [rbp+var_8]
leave
retn | _BYTE * func0(const char *a1)
{
int v1; // eax
int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( (i & 1) == 0 )
{
v1 = v3++;
result_1[v1] = a1[i];
}
}
result_1[v3] = 0;
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011de
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011da
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_001011da:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011de:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
CMP RBX,RAX
JC 0x001011aa
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int1 * func0(char *param_1)
{
size_t sVar1;
int local_20;
uint local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)(int)local_1c) break;
if ((local_1c & 1) == 0) {
result_1[local_20] = param_1[(int)local_1c];
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
}
result_1[local_20] = 0;
return result_1;
} |
4,797 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* str) {
static char result[100];
int j = 0;
for(int i = 0; i < strlen(str); i++) {
if(i % 2 == 0) {
result[j++] = str[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("abcdef"), "ace") == 0);
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("data"), "dt") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0x0,%edx
mov $0x0,%esi
mov $0xffffffffffffffff,%r9
mov $0x0,%eax
lea 0x2ed3(%rip),%r10
jmp 1173 <func0+0x2a>
add $0x1,%rdx
mov %r9,%rcx
mov %r8,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp %rdx,%rcx
jbe 119d <func0+0x54>
test $0x1,%dl
jne 116f <func0+0x26>
movzbl (%r8,%rdx,1),%edi
movslq %esi,%rcx
mov %dil,(%r10,%rcx,1)
lea 0x1(%rsi),%esi
jmp 116f <func0+0x26>
lea 0x2e9c(%rip),%rax
movslq %esi,%rsi
movb $0x0,(%rax,%rsi,1)
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov ebx, 0
mov ebp, 0
lea r13, result_1
jmp short loc_11B1
loc_11AD:
add rbx, 1
loc_11B1:
mov rdi, r12
call _strlen
cmp rax, rbx
jbe short loc_11D5
test bl, 1
jnz short loc_11AD
movzx edx, byte ptr [r12+rbx]
movsxd rax, ebp
mov [r13+rax+0], dl
lea ebp, [rbp+1]
jmp short loc_11AD
loc_11D5:
lea rax, result_1
movsxd rbp, ebp
mov byte ptr [rax+rbp], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(long long a1)
{
unsigned long long v1; // rbx
int v2; // ebp
_BYTE *result; // rax
v1 = 0LL;
v2 = 0;
while ( strlen(a1) > v1 )
{
if ( (v1 & 1) == 0 )
result_1[v2++] = *(_BYTE *)(a1 + v1);
++v1;
}
result = result_1;
result_1[v2] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV EBX,0x0
MOV EBP,0x0
LEA R13,[0x104040]
JMP 0x001011b1
LAB_001011ad:
ADD RBX,0x1
LAB_001011b1:
MOV RDI,R12
CALL 0x00101070
CMP RAX,RBX
JBE 0x001011d5
TEST BL,0x1
JNZ 0x001011ad
MOVZX EDX,byte ptr [R12 + RBX*0x1]
MOVSXD RAX,EBP
MOV byte ptr [R13 + RAX*0x1],DL
LEA EBP,[RBP + 0x1]
JMP 0x001011ad
LAB_001011d5:
LEA RAX,[0x104040]
MOVSXD RBP,EBP
MOV byte ptr [RAX + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(char *param_1)
{
size_t sVar1;
ulong uVar2;
int iVar3;
uVar2 = 0;
iVar3 = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= uVar2) break;
if ((uVar2 & 1) == 0) {
(&result_1)[iVar3] = param_1[uVar2];
iVar3 = iVar3 + 1;
}
uVar2 = uVar2 + 1;
}
(&result_1)[iVar3] = 0;
return;
} |
4,798 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* str) {
static char result[100];
int j = 0;
for(int i = 0; i < strlen(str); i++) {
if(i % 2 == 0) {
result[j++] = str[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("abcdef"), "ace") == 0);
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("data"), "dt") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
push %rbp
lea 0x2ddd(%rip),%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
callq 1060 <strlen@plt>
xor %edx,%edx
jmp 129a <func0+0x4a>
nopl 0x0(%rax,%rax,1)
test $0x1,%bl
jne 1296 <func0+0x46>
movzbl 0x0(%r13,%rbx,1),%eax
lea 0x1(%rdx),%r12d
mov %r13,%rdi
mov %al,0x0(%rbp,%rdx,1)
callq 1060 <strlen@plt>
movslq %r12d,%rdx
add $0x1,%rbx
cmp %rax,%rbx
jb 1278 <func0+0x28>
movb $0x0,0x0(%rbp,%rdx,1)
add $0x8,%rsp
lea 0x2d91(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r13
lea r13, result_1
push r12
mov r12, rdi
push rbp
xor ebp, ebp
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_1299
loc_1280:
test bl, 1
jnz short loc_1295
movzx edx, byte ptr [r12+rbx]
movsxd rax, ebp
add ebp, 1
mov [r13+rax+0], dl
loc_1295:
add rbx, 1
loc_1299:
mov rdi, r12
call _strlen
cmp rax, rbx
ja short loc_1280
movsxd rbp, ebp
mov rax, r13
mov byte ptr [r13+rbp+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(long long a1)
{
int v1; // ebp
unsigned long long i; // rbx
long long v3; // rax
_BYTE *result; // rax
v1 = 0;
for ( i = 0LL; strlen(a1) > i; ++i )
{
if ( (i & 1) == 0 )
{
v3 = v1++;
result_1[v3] = *(_BYTE *)(a1 + i);
}
}
result = result_1;
result_1[v1] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
LEA R13,[0x104040]
PUSH R12
MOV R12,RDI
PUSH RBP
XOR EBP,EBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x00101299
LAB_00101280:
TEST BL,0x1
JNZ 0x00101295
MOVZX EDX,byte ptr [R12 + RBX*0x1]
MOVSXD RAX,EBP
ADD EBP,0x1
MOV byte ptr [R13 + RAX*0x1],DL
LAB_00101295:
ADD RBX,0x1
LAB_00101299:
MOV RDI,R12
CALL 0x00101070
CMP RAX,RBX
JA 0x00101280
MOVSXD RBP,EBP
MOV RAX,R13
MOV byte ptr [R13 + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
long lVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
iVar4 = 0;
uVar3 = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= uVar3) break;
if ((uVar3 & 1) == 0) {
lVar1 = (long)iVar4;
iVar4 = iVar4 + 1;
(&result_1)[lVar1] = param_1[uVar3];
}
uVar3 = uVar3 + 1;
}
(&result_1)[iVar4] = 0;
return &result_1;
} |
4,799 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* str) {
static char result[100];
int j = 0;
for(int i = 0; i < strlen(str); i++) {
if(i % 2 == 0) {
result[j++] = str[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("abcdef"), "ace") == 0);
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("data"), "dt") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %rax,%rax
je 12d8 <func0+0x88>
xor %edx,%edx
xor %ebx,%ebx
lea 0x2dca(%rip),%rbp
nopw %cs:0x0(%rax,%rax,1)
test $0x1,%bl
jne 12ab <func0+0x5b>
movzbl (%r12,%rbx,1),%eax
mov %r12,%rdi
lea 0x1(%rdx),%r13d
add $0x1,%rbx
mov %al,0x0(%rbp,%rdx,1)
callq 1060 <strlen@plt>
cmp %rax,%rbx
jae 12b7 <func0+0x67>
movslq %r13d,%rdx
test $0x1,%bl
je 1285 <func0+0x35>
add $0x1,%rbx
cmp %rax,%rbx
jb 1280 <func0+0x30>
mov %edx,%r13d
movslq %r13d,%r13
lea 0x2d7f(%rip),%rax
movb $0x0,0x0(%rbp,%r13,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
xor %r13d,%r13d
lea 0x2d5e(%rip),%rbp
jmp 12b7 <func0+0x67>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r13
lea r13, result_1
push r12
mov r12, rdi
push rbp
xor ebp, ebp
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_1299
loc_1280:
test bl, 1
jnz short loc_1295
movzx edx, byte ptr [r12+rbx]
movsxd rax, ebp
add ebp, 1
mov [r13+rax+0], dl
loc_1295:
add rbx, 1
loc_1299:
mov rdi, r12; s
call _strlen
cmp rbx, rax
jb short loc_1280
movsxd rbp, ebp
mov rax, r13
mov byte ptr [r13+rbp+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(char *s)
{
int v1; // ebp
size_t i; // rbx
long long v3; // rax
_BYTE *result; // rax
v1 = 0;
for ( i = 0LL; i < strlen(s); ++i )
{
if ( (i & 1) == 0 )
{
v3 = v1++;
result_1[v3] = s[i];
}
}
result = result_1;
result_1[v1] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
LEA R13,[0x104040]
PUSH R12
MOV R12,RDI
PUSH RBP
XOR EBP,EBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x00101299
LAB_00101280:
TEST BL,0x1
JNZ 0x00101295
MOVZX EDX,byte ptr [R12 + RBX*0x1]
MOVSXD RAX,EBP
ADD EBP,0x1
MOV byte ptr [R13 + RAX*0x1],DL
LAB_00101295:
ADD RBX,0x1
LAB_00101299:
MOV RDI,R12
CALL 0x00101070
CMP RBX,RAX
JC 0x00101280
MOVSXD RBP,EBP
MOV RAX,R13
MOV byte ptr [R13 + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
long lVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
iVar4 = 0;
uVar3 = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= uVar3) break;
if ((uVar3 & 1) == 0) {
lVar1 = (long)iVar4;
iVar4 = iVar4 + 1;
(&result_1)[lVar1] = param_1[uVar3];
}
uVar3 = uVar3 + 1;
}
(&result_1)[iVar4] = 0;
return &result_1;
} |
4,800 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int smallest;
if (a <= b && a <= c) {
smallest = a;
} else if (b <= a && b <= c) {
smallest = b;
} else {
smallest = c;
}
return smallest;
}
| int main() {
assert(func0(10, 20, 0) == 0);
assert(func0(19, 15, 18) == 15);
assert(func0(-10, -20, -30) == -30);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jg 1172 <func0+0x29>
mov -0x14(%rbp),%eax
cmp -0x1c(%rbp),%eax
jg 1172 <func0+0x29>
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1190 <func0+0x47>
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 118a <func0+0x41>
mov -0x18(%rbp),%eax
cmp -0x1c(%rbp),%eax
jg 118a <func0+0x41>
mov -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1190 <func0+0x47>
mov -0x1c(%rbp),%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_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jg short loc_1172
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jg short loc_1172
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_1190
loc_1172:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jg short loc_118A
mov eax, [rbp+var_18]
cmp eax, [rbp+var_1C]
jg short loc_118A
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
jmp short loc_1190
loc_118A:
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_1190:
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
if ( a1 > a2 || a1 > a3 )
{
if ( a2 > a1 || a2 > a3 )
return (unsigned int)a3;
else
return (unsigned int)a2;
}
else
{
return (unsigned int)a1;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JG 0x00101172
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JG 0x00101172
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101190
LAB_00101172:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JG 0x0010118a
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x1c]
JG 0x0010118a
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101190
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00101190:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2,int param_3)
{
int local_c;
if ((((param_2 < param_1) || (local_c = param_1, param_3 < param_1)) &&
(local_c = param_3, param_2 <= param_1)) && (param_2 <= param_3)) {
local_c = param_2;
}
return local_c;
} |
4,801 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int smallest;
if (a <= b && a <= c) {
smallest = a;
} else if (b <= a && b <= c) {
smallest = b;
} else {
smallest = c;
}
return smallest;
}
| int main() {
assert(func0(10, 20, 0) == 0);
assert(func0(19, 15, 18) == 15);
assert(func0(-10, -20, -30) == -30);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp %edx,%esi
mov %edx,%ecx
cmovle %esi,%ecx
cmp %ecx,%edi
jle 1146 <func0+0x1d>
cmp %edx,%edi
cmovg %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
| func0:
endbr64
mov eax, edi
cmp esi, edx
mov ecx, edx
cmovle ecx, esi
cmp edi, ecx
jle short locret_1146
cmp edi, edx
cmovg eax, edx
cmp esi, eax
mov eax, edx
cmovle eax, esi
locret_1146:
retn | long long func0(int a1, int a2, int a3)
{
long long result; // rax
int v4; // ecx
bool v5; // cc
result = (unsigned int)a1;
v4 = a3;
if ( a2 <= a3 )
v4 = a2;
if ( a1 > v4 )
{
if ( a1 > a3 )
LODWORD(result) = a3;
v5 = a2 <= (int)result;
result = (unsigned int)a3;
if ( v5 )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP ESI,EDX
MOV ECX,EDX
CMOVLE ECX,ESI
CMP EDI,ECX
JLE 0x00101146
CMP EDI,EDX
CMOVG EAX,EDX
CMP ESI,EAX
MOV EAX,EDX
CMOVLE EAX,ESI
LAB_00101146:
RET | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = param_3;
if (param_2 <= param_3) {
iVar1 = param_2;
}
if (iVar1 < param_1) {
iVar1 = param_1;
if (param_3 < param_1) {
iVar1 = param_3;
}
param_1 = param_3;
if (param_2 <= iVar1) {
param_1 = param_2;
}
}
return param_1;
} |
4,802 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int smallest;
if (a <= b && a <= c) {
smallest = a;
} else if (b <= a && b <= c) {
smallest = b;
} else {
smallest = c;
}
return smallest;
}
| int main() {
assert(func0(10, 20, 0) == 0);
assert(func0(19, 15, 18) == 15);
assert(func0(-10, -20, -30) == -30);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovle %esi,%ecx
cmp %ecx,%edi
jle 115d <func0+0x1d>
cmp %edx,%edi
cmovg %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovle ecx, esi
cmp edi, ecx
jle short locret_115D
cmp edi, edx
cmovg eax, edx
cmp esi, eax
mov eax, edx
cmovle eax, esi
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 <= a3 )
v3 = a2;
if ( a1 > v3 )
{
if ( a1 > a3 )
LODWORD(result) = a3;
v5 = a2 <= (int)result;
result = (unsigned int)a3;
if ( v5 )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVLE ECX,ESI
CMP EDI,ECX
JLE 0x0010115d
CMP EDI,EDX
CMOVG EAX,EDX
CMP ESI,EAX
MOV EAX,EDX
CMOVLE EAX,ESI
LAB_0010115d:
RET | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = param_3;
if (param_2 <= param_3) {
iVar1 = param_2;
}
if (iVar1 < param_1) {
iVar1 = param_1;
if (param_3 < param_1) {
iVar1 = param_3;
}
param_1 = param_3;
if (param_2 <= iVar1) {
param_1 = param_2;
}
}
return param_1;
} |
4,803 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int smallest;
if (a <= b && a <= c) {
smallest = a;
} else if (b <= a && b <= c) {
smallest = b;
} else {
smallest = c;
}
return smallest;
}
| int main() {
assert(func0(10, 20, 0) == 0);
assert(func0(19, 15, 18) == 15);
assert(func0(-10, -20, -30) == -30);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovle %esi,%ecx
cmp %ecx,%edi
jle 115d <func0+0x1d>
cmp %edx,%edi
cmovg %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovle ecx, esi
cmp edi, ecx
jle short locret_115D
cmp edi, edx
cmovg eax, edx
cmp esi, eax
mov eax, esi
cmovg eax, edx
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 <= a3 )
v3 = a2;
if ( a1 > v3 )
{
if ( a1 > a3 )
LODWORD(result) = a3;
v5 = a2 <= (int)result;
result = (unsigned int)a2;
if ( !v5 )
return (unsigned int)a3;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVLE ECX,ESI
CMP EDI,ECX
JLE 0x0010115d
CMP EDI,EDX
CMOVG EAX,EDX
CMP ESI,EAX
MOV EAX,ESI
CMOVG EAX,EDX
LAB_0010115d:
RET | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = param_3;
if (param_2 <= param_3) {
iVar1 = param_2;
}
if (iVar1 < param_1) {
iVar1 = param_1;
if (param_3 < param_1) {
iVar1 = param_3;
}
param_1 = param_2;
if (iVar1 < param_2) {
param_1 = param_3;
}
}
return param_1;
} |
4,804 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n, int l, int r) {
int num = (((1 << r) - 1) ^ ((1 << (l - 1)) - 1));
int new_num = n & num;
if (new_num == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(4, 1, 2) == true);
assert(func0(17, 2, 4) == true);
assert(func0(39, 4, 6) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%eax
sub $0x1,%eax
mov $0x1,%esi
mov %eax,%ecx
shl %cl,%esi
mov %esi,%eax
sub $0x1,%eax
xor %edx,%eax
mov %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
and -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 119a <func0+0x51>
mov $0x1,%eax
jmp 119f <func0+0x56>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_1C]
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
lea edx, [rax-1]
mov eax, [rbp+var_18]
sub eax, 1
mov esi, 1
mov ecx, eax
shl esi, cl
mov eax, esi
sub eax, 1
xor eax, edx
mov [rbp+var_8], eax
mov eax, [rbp+var_14]
and eax, [rbp+var_8]
mov [rbp+var_4], eax
cmp [rbp+var_4], 0
jnz short loc_119A
mov eax, 1
jmp short loc_119F
loc_119A:
mov eax, 0
loc_119F:
pop rbp
retn | _BOOL8 func0(int a1, char a2, char a3)
{
return ((((1 << a3) - 1) ^ ((1 << (a2 - 1)) - 1)) & a1) == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
MOV ESI,0x1
MOV ECX,EAX
SHL ESI,CL
MOV EAX,ESI
SUB EAX,0x1
XOR EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x0010119a
MOV EAX,0x1
JMP 0x0010119f
LAB_0010119a:
MOV EAX,0x0
LAB_0010119f:
POP RBP
RET | bool func0(uint param_1,char param_2,byte param_3)
{
return (param_1 & ((1 << (param_2 - 1U & 0x1f)) - 1U ^ (1 << (param_3 & 0x1f)) - 1U)) == 0;
} |
4,805 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n, int l, int r) {
int num = (((1 << r) - 1) ^ ((1 << (l - 1)) - 1));
int new_num = n & num;
if (new_num == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(4, 1, 2) == true);
assert(func0(17, 2, 4) == true);
assert(func0(39, 4, 6) == false);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
mov $0x1,%eax
mov %eax,%esi
shl %cl,%esi
sub $0x1,%esi
mov %edx,%ecx
shl %cl,%eax
sub $0x1,%eax
xor %esi,%eax
test %edi,%eax
sete %al
retq
| func0:
endbr64
lea ecx, [rsi-1]
mov eax, 1
mov esi, eax
shl esi, cl
sub esi, 1
mov ecx, edx
shl eax, cl
sub eax, 1
xor esi, eax
test esi, edi
setz al
retn | bool func0(int a1, char a2, char a3)
{
return (a1 & (((1 << a3) - 1) ^ ((1 << (a2 - 1)) - 1))) == 0;
} | func0:
ENDBR64
LEA ECX,[RSI + -0x1]
MOV EAX,0x1
MOV ESI,EAX
SHL ESI,CL
SUB ESI,0x1
MOV ECX,EDX
SHL EAX,CL
SUB EAX,0x1
XOR ESI,EAX
TEST ESI,EDI
SETZ AL
RET | int4 func0(uint param_1,char param_2,byte param_3)
{
uint uVar1;
uVar1 = (1 << (param_3 & 0x1f)) - 1;
return CONCAT31((int3)(uVar1 >> 8),(((1 << (param_2 - 1U & 0x1f)) - 1U ^ uVar1) & param_1) == 0);
} |
4,806 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n, int l, int r) {
int num = (((1 << r) - 1) ^ ((1 << (l - 1)) - 1));
int new_num = n & num;
if (new_num == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(4, 1, 2) == true);
assert(func0(17, 2, 4) == true);
assert(func0(39, 4, 6) == false);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
lea -0x1(%rsi),%ecx
mov %eax,%esi
shl %cl,%esi
mov %edx,%ecx
shl %cl,%eax
sub $0x1,%esi
sub $0x1,%eax
xor %esi,%eax
test %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, 1
lea ecx, [rsi-1]
mov esi, eax
shl esi, cl
mov ecx, edx
shl eax, cl
sub esi, 1
sub eax, 1
xor esi, eax
test esi, edi
setz al
retn | bool func0(int a1, char a2, char a3)
{
return (a1 & (((1 << a3) - 1) ^ ((1 << (a2 - 1)) - 1))) == 0;
} | func0:
ENDBR64
MOV EAX,0x1
LEA ECX,[RSI + -0x1]
MOV ESI,EAX
SHL ESI,CL
MOV ECX,EDX
SHL EAX,CL
SUB ESI,0x1
SUB EAX,0x1
XOR ESI,EAX
TEST ESI,EDI
SETZ AL
RET | int4 func0(uint param_1,char param_2,byte param_3)
{
uint uVar1;
uVar1 = (1 << (param_3 & 0x1f)) - 1;
return CONCAT31((int3)(uVar1 >> 8),(((1 << (param_2 - 1U & 0x1f)) - 1U ^ uVar1) & param_1) == 0);
} |
4,807 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n, int l, int r) {
int num = (((1 << r) - 1) ^ ((1 << (l - 1)) - 1));
int new_num = n & num;
if (new_num == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(4, 1, 2) == true);
assert(func0(17, 2, 4) == true);
assert(func0(39, 4, 6) == false);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
lea -0x1(%rsi),%ecx
mov %eax,%esi
shl %cl,%esi
mov %edx,%ecx
shl %cl,%eax
sub $0x1,%esi
sub $0x1,%eax
xor %esi,%eax
test %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, 1
lea ecx, [rsi-1]
mov esi, eax
shl esi, cl
mov ecx, edx
shl eax, cl
sub esi, 1
sub eax, 1
xor esi, eax
test esi, edi
setz al
retn | bool func0(int a1, char a2, char a3)
{
return (a1 & (((1 << a3) - 1) ^ ((1 << (a2 - 1)) - 1))) == 0;
} | func0:
ENDBR64
MOV EAX,0x1
LEA ECX,[RSI + -0x1]
MOV ESI,EAX
SHL ESI,CL
MOV ECX,EDX
SHL EAX,CL
SUB ESI,0x1
SUB EAX,0x1
XOR ESI,EAX
TEST ESI,EDI
SETZ AL
RET | int4 func0(uint param_1,char param_2,byte param_3)
{
uint uVar1;
uVar1 = (1 << (param_3 & 0x1f)) - 1;
return CONCAT31((int3)(uVar1 >> 8),(((1 << (param_2 - 1U & 0x1f)) - 1U ^ uVar1) & param_1) == 0);
} |
4,808 | func0 |
#include <assert.h>
#include <stdbool.h>
void re_arrange_array(int arr[], int n) {
int j = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < 0) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
j++;
}
}
}
| bool func0(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9};
int n1 = 9;
re_arrange_array(arr1, n1);
int expected1[] = {-1, -3, -7, 4, 5, 6, 2, 8, 9};
assert(func0(arr1, expected1, n1));
int arr2[] = {12, -14, -26, 13, 15};
int n2 = 5;
re_arrange_array(arr2, n2);
int expected2[] = {-14, -26, 12, 13, 15};
assert(func0(arr2, expected2, n2));
int arr3[] = {10, 24, 36, -42, -39, -78, 85};
int n3 = 7;
re_arrange_array(arr3, n3);
int expected3[] = {-42, -39, -78, 10, 24, 36, 85};
assert(func0(arr3, expected3, n3));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1273 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 126f <func0+0x53>
mov $0x0,%eax
jmp 1280 <func0+0x64>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1238 <func0+0x1c>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_4], 0
jmp short loc_1273
loc_1238:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_126F
mov eax, 0
jmp short loc_1280
loc_126F:
add [rbp+var_4], 1
loc_1273:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_1238
mov eax, 1
loc_1280:
pop rbp
retn | long long func0(long long a1, long long a2, int a3)
{
int i; // [rsp+20h] [rbp-4h]
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * i + a2) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101273
LAB_00101238:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x0010126f
MOV EAX,0x0
JMP 0x00101280
LAB_0010126f:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101273:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101238
MOV EAX,0x1
LAB_00101280:
POP RBP
RET | int8 func0(long param_1,long param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_3 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 4) != *(int *)(param_2 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
4,809 | func0 |
#include <assert.h>
#include <stdbool.h>
void re_arrange_array(int arr[], int n) {
int j = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < 0) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
j++;
}
}
}
| bool func0(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9};
int n1 = 9;
re_arrange_array(arr1, n1);
int expected1[] = {-1, -3, -7, 4, 5, 6, 2, 8, 9};
assert(func0(arr1, expected1, n1));
int arr2[] = {12, -14, -26, 13, 15};
int n2 = 5;
re_arrange_array(arr2, n2);
int expected2[] = {-14, -26, 12, 13, 15};
assert(func0(arr2, expected2, n2));
int arr3[] = {10, 24, 36, -42, -39, -78, 85};
int n3 = 7;
re_arrange_array(arr3, n3);
int expected3[] = {-42, -39, -78, 10, 24, 36, 85};
assert(func0(arr3, expected3, n3));
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 11d3 <func0+0x2c>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
jmp 11bc <func0+0x15>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jne 11d9 <func0+0x32>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 11b9 <func0+0x12>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test edx, edx
jle short loc_11CD
mov edx, edx
mov eax, 0
loc_11B6:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jnz short loc_11D3
add rax, 1
cmp rax, rdx
jnz short loc_11B6
mov eax, 1
retn
loc_11CD:
mov eax, 1
retn
loc_11D3:
mov eax, 0
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) == *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011cd
MOV EDX,EDX
MOV EAX,0x0
LAB_001011b6:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x001011d3
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011b6
MOV EAX,0x1
RET
LAB_001011cd:
MOV EAX,0x1
RET
LAB_001011d3:
MOV EAX,0x0
RET | int8 func0(long param_1,long param_2,uint param_3)
{
ulong uVar1;
if ((int)param_3 < 1) {
return 1;
}
uVar1 = 0;
do {
if (*(int *)(param_1 + uVar1 * 4) != *(int *)(param_2 + uVar1 * 4)) {
return 0;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
return 1;
} |
4,810 | func0 |
#include <assert.h>
#include <stdbool.h>
void re_arrange_array(int arr[], int n) {
int j = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < 0) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
j++;
}
}
}
| bool func0(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9};
int n1 = 9;
re_arrange_array(arr1, n1);
int expected1[] = {-1, -3, -7, 4, 5, 6, 2, 8, 9};
assert(func0(arr1, expected1, n1));
int arr2[] = {12, -14, -26, 13, 15};
int n2 = 5;
re_arrange_array(arr2, n2);
int expected2[] = {-14, -26, 12, 13, 15};
assert(func0(arr2, expected2, n2));
int arr3[] = {10, 24, 36, -42, -39, -78, 85};
int n3 = 7;
re_arrange_array(arr3, n3);
int expected3[] = {-42, -39, -78, 10, 24, 36, 85};
assert(func0(arr3, expected3, n3));
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 1510 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 14fc <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1510 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
je 14f0 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
jle short loc_1468
movsxd rdx, edx
xor eax, eax
jmp short loc_1459
loc_1450:
add rax, 1
cmp rax, rdx
jz short loc_1468
loc_1459:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jz short loc_1450
xor eax, eax
retn
loc_1468:
mov eax, 1
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) == *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101468
MOVSXD RDX,EDX
XOR EAX,EAX
JMP 0x00101459
LAB_00101450:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x00101468
LAB_00101459:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x00101450
XOR EAX,EAX
RET
LAB_00101468:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) != *(int *)(param_2 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
}
return 1;
} |
4,811 | func0 |
#include <assert.h>
#include <stdbool.h>
void re_arrange_array(int arr[], int n) {
int j = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < 0) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
j++;
}
}
}
| bool func0(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9};
int n1 = 9;
re_arrange_array(arr1, n1);
int expected1[] = {-1, -3, -7, 4, 5, 6, 2, 8, 9};
assert(func0(arr1, expected1, n1));
int arr2[] = {12, -14, -26, 13, 15};
int n2 = 5;
re_arrange_array(arr2, n2);
int expected2[] = {-14, -26, 12, 13, 15};
assert(func0(arr2, expected2, n2));
int arr3[] = {10, 24, 36, -42, -39, -78, 85};
int n3 = 7;
re_arrange_array(arr3, n3);
int expected3[] = {-42, -39, -78, 10, 24, 36, 85};
assert(func0(arr3, expected3, n3));
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 1650 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 163c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1650 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
je 1630 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
jle short loc_11B0
movsxd rdx, edx
xor eax, eax
shl rdx, 2
jmp short loc_11A1
loc_1198:
add rax, 4
cmp rdx, rax
jz short loc_11B0
loc_11A1:
mov ecx, [rsi+rax]
cmp [rdi+rax], ecx
jz short loc_1198
xor eax, eax
retn
loc_11B0:
mov eax, 1
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rdx
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
v4 = 4LL * a3;
while ( *(_DWORD *)(a1 + v3) == *(_DWORD *)(a2 + v3) )
{
v3 += 4LL;
if ( v4 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011b0
MOVSXD RDX,EDX
XOR EAX,EAX
SHL RDX,0x2
JMP 0x001011a1
LAB_00101198:
ADD RAX,0x4
CMP RDX,RAX
JZ 0x001011b0
LAB_001011a1:
MOV ECX,dword ptr [RSI + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ECX
JZ 0x00101198
XOR EAX,EAX
RET
LAB_001011b0:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1) != *(int *)(param_2 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_3 * 4 != lVar1);
}
return 1;
} |
4,812 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str1, char* char_replacement) {
static char str2[100];
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (str1[i] == ' ') {
str2[j++] = char_replacement[0];
} else {
str2[j++] = str1[i];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("hello people", "@"), "hello@people") == 0);
assert(strcmp(func0("python program language", "$"), "python$program$language") == 0);
assert(strcmp(func0("blank space", "-"), "blank-space") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11e5 <func0+0x7c>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 11bb <func0+0x52>
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
mov -0x20(%rbp),%rdx
movzbl (%rdx),%edx
cltq
lea 0x2e8a(%rip),%rcx
mov %dl,(%rax,%rcx,1)
jmp 11e1 <func0+0x78>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2e62(%rip),%rcx
mov %dl,(%rax,%rcx,1)
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 1189 <func0+0x20>
mov -0x8(%rbp),%eax
cltq
lea 0x2e3b(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2e30(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11E5
loc_1189:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_11BB
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
mov rdx, [rbp+var_20]
movzx edx, byte ptr [rdx]
cdqe
lea rcx, str2_1
mov [rax+rcx], dl
jmp short loc_11E1
loc_11BB:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, str2_1
mov [rax+rcx], dl
loc_11E1:
add [rbp+var_4], 1
loc_11E5:
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_1189
mov eax, [rbp+var_8]
cdqe
lea rdx, str2_1
mov byte ptr [rax+rdx], 0
lea rax, str2_1
pop rbp
retn | _BYTE * func0(long long a1, char *a2)
{
int v2; // eax
char v3; // dl
int v5; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v5 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
v2 = v5++;
if ( *(_BYTE *)(i + a1) == 32 )
v3 = *a2;
else
v3 = *(_BYTE *)(i + a1);
str2_1[v2] = v3;
}
str2_1[v5] = 0;
return str2_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e5
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x001011bb
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOV RDX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RDX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x001011e1
LAB_001011bb:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_001011e1:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011e5:
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 0x00101189
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(long param_1,int *param_2)
{
int local_10;
int local_c;
local_10 = 0;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == ' ') {
str2_1[local_10] = *param_2;
}
else {
str2_1[local_10] = *(int *)(local_c + param_1);
}
local_10 = local_10 + 1;
}
str2_1[local_10] = 0;
return str2_1;
} |
4,813 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str1, char* char_replacement) {
static char str2[100];
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (str1[i] == ' ') {
str2[j++] = char_replacement[0];
} else {
str2[j++] = str1[i];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("hello people", "@"), "hello@people") == 0);
assert(strcmp(func0("python program language", "$"), "python$program$language") == 0);
assert(strcmp(func0("blank space", "-"), "blank-space") == 0);
return 0;
}
| O1 | c | func0:
endbr64
movzbl (%rdi),%edx
test %dl,%dl
je 117f <func0+0x36>
mov $0x1,%eax
lea 0x2edf(%rip),%r8
jmp 1173 <func0+0x2a>
mov %dl,(%rax,%r8,1)
add $0x1,%rax
movzbl -0x1(%rdi,%rax,1),%edx
test %dl,%dl
je 1184 <func0+0x3b>
mov %eax,%ecx
cmp $0x20,%dl
jne 1162 <func0+0x19>
movzbl (%rsi),%edx
jmp 1162 <func0+0x19>
mov $0x0,%ecx
lea 0x2eb5(%rip),%rax
movslq %ecx,%rcx
movb $0x0,(%rax,%rcx,1)
retq
| func0:
endbr64
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_119F
mov eax, 1
lea r8, unk_403F
jmp short loc_1193
loc_1182:
mov [rax+r8], dl
add rax, 1
movzx edx, byte ptr [rdi+rax-1]
test dl, dl
jz short loc_11A4
loc_1193:
mov ecx, eax
cmp dl, 20h ; ' '
jnz short loc_1182
movzx edx, byte ptr [rsi]
jmp short loc_1182
loc_119F:
mov ecx, 0
loc_11A4:
lea rax, str2_1
movsxd rcx, ecx
mov byte ptr [rax+rcx], 0
retn | _BYTE * func0(char *a1, char *a2)
{
char v2; // dl
long long v3; // rax
int v4; // ecx
_BYTE *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = 1LL;
do
{
v4 = v3;
if ( v2 == 32 )
v2 = *a2;
*((_BYTE *)&unk_403F + v3++) = v2;
v2 = a1[v3 - 1];
}
while ( v2 );
}
else
{
v4 = 0;
}
result = str2_1;
str2_1[v4] = 0;
return result;
} | func0:
ENDBR64
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x0010119f
MOV EAX,0x1
LEA R8,[0x10403f]
JMP 0x00101193
LAB_00101182:
MOV byte ptr [RAX + R8*0x1],DL
ADD RAX,0x1
MOVZX EDX,byte ptr [RDI + RAX*0x1 + -0x1]
TEST DL,DL
JZ 0x001011a4
LAB_00101193:
MOV ECX,EAX
CMP DL,0x20
JNZ 0x00101182
MOVZX EDX,byte ptr [RSI]
JMP 0x00101182
LAB_0010119f:
MOV ECX,0x0
LAB_001011a4:
LEA RAX,[0x104040]
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],0x0
RET | void func0(char *param_1,char *param_2)
{
long lVar1;
int iVar2;
char cVar3;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar2 = 0;
}
else {
lVar1 = 1;
do {
iVar2 = (int)lVar1;
if (cVar3 == ' ') {
cVar3 = *param_2;
}
(&DAT_0010403f)[lVar1] = cVar3;
cVar3 = param_1[lVar1];
lVar1 = lVar1 + 1;
} while (cVar3 != '\0');
}
(&str2_1)[iVar2] = 0;
return;
} |
4,814 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str1, char* char_replacement) {
static char str2[100];
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (str1[i] == ' ') {
str2[j++] = char_replacement[0];
} else {
str2[j++] = str1[i];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("hello people", "@"), "hello@people") == 0);
assert(strcmp(func0("python program language", "$"), "python$program$language") == 0);
assert(strcmp(func0("blank space", "-"), "blank-space") == 0);
return 0;
}
| O2 | c | func0:
endbr64
movzbl (%rdi),%edx
test %dl,%dl
je 1350 <func0+0x50>
mov $0x1,%eax
lea 0x2d28(%rip),%r8
nopw 0x0(%rax,%rax,1)
movslq %eax,%rcx
cmp $0x20,%dl
jne 132b <func0+0x2b>
movzbl (%rsi),%edx
mov %dl,(%r8,%rax,1)
add $0x1,%rax
movzbl -0x1(%rdi,%rax,1),%edx
test %dl,%dl
jne 1320 <func0+0x20>
lea 0x2cfd(%rip),%rax
movb $0x0,(%rax,%rcx,1)
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
lea 0x2ce7(%rip),%rax
movb $0x0,(%rax,%rcx,1)
retq
xchg %ax,%ax
| func0:
endbr64
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_12A0
mov eax, 1
lea r8, unk_403F
nop word ptr [rax+rax+00000000h]
loc_1270:
movsxd rcx, eax
cmp dl, 20h ; ' '
jnz short loc_127B
movzx edx, byte ptr [rsi]
loc_127B:
mov [r8+rax], dl
add rax, 1
movzx edx, byte ptr [rdi+rax-1]
test dl, dl
jnz short loc_1270
lea rax, str2_1
mov byte ptr [rax+rcx], 0
retn
loc_12A0:
xor ecx, ecx
lea rax, str2_1
mov byte ptr [rax+rcx], 0
retn | _BYTE * func0(char *a1, char *a2)
{
char v2; // dl
long long v3; // rax
long long v4; // rcx
_BYTE *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = 1LL;
do
{
v4 = (int)v3;
if ( v2 == 32 )
v2 = *a2;
*((_BYTE *)&unk_403F + v3++) = v2;
v2 = a1[v3 - 1];
}
while ( v2 );
result = str2_1;
str2_1[v4] = 0;
}
else
{
result = str2_1;
str2_1[0] = 0;
}
return result;
} | func0:
ENDBR64
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x001012a0
MOV EAX,0x1
LEA R8,[0x10403f]
NOP word ptr [RAX + RAX*0x1]
LAB_00101270:
MOVSXD RCX,EAX
CMP DL,0x20
JNZ 0x0010127b
MOVZX EDX,byte ptr [RSI]
LAB_0010127b:
MOV byte ptr [R8 + RAX*0x1],DL
ADD RAX,0x1
MOVZX EDX,byte ptr [RDI + RAX*0x1 + -0x1]
TEST DL,DL
JNZ 0x00101270
LEA RAX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],0x0
RET
LAB_001012a0:
XOR ECX,ECX
LEA RAX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],0x0
RET | void func0(char *param_1,char *param_2)
{
int iVar1;
char cVar3;
long lVar2;
cVar3 = *param_1;
if (cVar3 != '\0') {
lVar2 = 1;
do {
iVar1 = (int)lVar2;
if (cVar3 == ' ') {
cVar3 = *param_2;
}
(&DAT_0010403f)[lVar2] = cVar3;
cVar3 = param_1[lVar2];
lVar2 = lVar2 + 1;
} while (cVar3 != '\0');
(&str2_1)[iVar1] = 0;
return;
}
str2_1 = 0;
return;
} |
4,815 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str1, char* char_replacement) {
static char str2[100];
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (str1[i] == ' ') {
str2[j++] = char_replacement[0];
} else {
str2[j++] = str1[i];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("hello people", "@"), "hello@people") == 0);
assert(strcmp(func0("python program language", "$"), "python$program$language") == 0);
assert(strcmp(func0("blank space", "-"), "blank-space") == 0);
return 0;
}
| O3 | c | func0:
endbr64
movzbl (%rdi),%edx
test %dl,%dl
je 1370 <func0+0x50>
mov $0x1,%eax
lea 0x2d08(%rip),%r8
nopw 0x0(%rax,%rax,1)
movslq %eax,%rcx
cmp $0x20,%dl
jne 134b <func0+0x2b>
movzbl (%rsi),%edx
mov %dl,(%r8,%rax,1)
add $0x1,%rax
movzbl -0x1(%rdi,%rax,1),%edx
test %dl,%dl
jne 1340 <func0+0x20>
lea 0x2cdd(%rip),%rax
movb $0x0,(%rax,%rcx,1)
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
lea 0x2cc7(%rip),%rax
movb $0x0,(%rax,%rcx,1)
retq
xchg %ax,%ax
| func0:
endbr64
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_1380
mov eax, 1
lea r8, unk_403F
nop word ptr [rax+rax+00000000h]
loc_1350:
movsxd rcx, eax
cmp dl, 20h ; ' '
jnz short loc_135B
movzx edx, byte ptr [rsi]
loc_135B:
mov [r8+rax], dl
add rax, 1
movzx edx, byte ptr [rdi+rax-1]
test dl, dl
jnz short loc_1350
lea rax, str2_1
mov byte ptr [rax+rcx], 0
retn
loc_1380:
xor ecx, ecx
lea rax, str2_1
mov byte ptr [rax+rcx], 0
retn | long long * func0(char *a1, char *a2)
{
char v2; // dl
long long v3; // rax
long long v4; // rcx
long long *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = 1LL;
do
{
v4 = (int)v3;
if ( v2 == 32 )
v2 = *a2;
*((_BYTE *)&unk_403F + v3++) = v2;
v2 = a1[v3 - 1];
}
while ( v2 );
result = &str2_1;
*((_BYTE *)&str2_1 + v4) = 0;
}
else
{
result = &str2_1;
LOBYTE(str2_1) = 0;
}
return result;
} | func0:
ENDBR64
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x00101380
MOV EAX,0x1
LEA R8,[0x10403f]
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
MOVSXD RCX,EAX
CMP DL,0x20
JNZ 0x0010135b
MOVZX EDX,byte ptr [RSI]
LAB_0010135b:
MOV byte ptr [R8 + RAX*0x1],DL
ADD RAX,0x1
MOVZX EDX,byte ptr [RDI + RAX*0x1 + -0x1]
TEST DL,DL
JNZ 0x00101350
LEA RAX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],0x0
RET
LAB_00101380:
XOR ECX,ECX
LEA RAX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],0x0
RET | void func0(char *param_1,char *param_2)
{
int iVar1;
char cVar3;
long lVar2;
cVar3 = *param_1;
if (cVar3 != '\0') {
lVar2 = 1;
do {
iVar1 = (int)lVar2;
if (cVar3 == ' ') {
cVar3 = *param_2;
}
(&DAT_0010403f)[lVar2] = cVar3;
cVar3 = param_1[lVar2];
lVar2 = lVar2 + 1;
} while (cVar3 != '\0');
*(int *)((long)&str2_1 + (long)iVar1) = 0;
return;
}
str2_1._0_1_ = 0;
return;
} |
4,816 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int tri[][100], int n) {
if (n > 1) {
tri[1][1] = tri[1][1] + tri[0][0];
tri[1][0] = tri[1][0] + tri[0][0];
}
for (int i = 2; i < n; i++) {
tri[i][0] = tri[i][0] + tri[i-1][0];
tri[i][i] = tri[i][i] + tri[i-1][i-1];
for (int j = 1; j < i; j++) {
if (tri[i][j] + tri[i-1][j-1] >= tri[i][j] + tri[i-1][j]) {
tri[i][j] = tri[i][j] + tri[i-1][j-1];
} else {
tri[i][j] = tri[i][j] + tri[i-1][j];
}
}
}
int max_value = tri[n-1][0];
for (int j = 1; j < n; j++) {
if (tri[n-1][j] > max_value) {
max_value = tri[n-1][j];
}
}
return max_value;
}
| int main() {
int tri1[3][100] = {{1}, {2, 1}, {3, 3, 2}};
assert(func0(tri1, 3) == 6);
int tri2[3][100] = {{1}, {1, 2}, {4, 1, 12}};
assert(func0(tri2, 3) == 15);
int tri3[3][100] = {{2}, {3, 2}, {13, 23, 12}};
assert(func0(tri3, 3) == 28);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x1,-0x1c(%rbp)
jle 11c0 <func0+0x57>
mov -0x18(%rbp),%rax
add $0x190,%rax
mov 0x4(%rax),%ecx
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
add $0x190,%rax
add %ecx,%edx
mov %edx,0x4(%rax)
mov -0x18(%rbp),%rax
add $0x190,%rax
mov (%rax),%ecx
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
add $0x190,%rax
add %ecx,%edx
mov %edx,(%rax)
movl $0x2,-0x10(%rbp)
jmpq 14bf <func0+0x356>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%esi
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
lea (%rsi,%rcx,1),%edx
mov %edx,(%rax)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
cltq
mov (%rdx,%rax,4),%esi
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
sub $0x1,%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
add %esi,%ecx
mov -0x10(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
movl $0x1,-0xc(%rbp)
jmpq 14af <func0+0x346>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
sub $0x1,%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
cmp %eax,%ecx
jl 1412 <func0+0x2a9>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
mov (%rdx,%rax,4),%esi
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
sub $0x1,%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
add %esi,%ecx
mov -0xc(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
jmpq 14ab <func0+0x342>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
mov (%rdx,%rax,4),%esi
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
add %esi,%ecx
mov -0xc(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 12fc <func0+0x193>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11cc <func0+0x63>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 157c <func0+0x413>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
cmp %eax,-0x8(%rbp)
jge 1578 <func0+0x40f>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
lea -0x190(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1506 <func0+0x39d>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 1
jle short loc_11C0
mov rax, [rbp+var_18]
add rax, 190h
mov ecx, [rax+4]
mov rax, [rbp+var_18]
mov edx, [rax]
mov rax, [rbp+var_18]
add rax, 190h
add edx, ecx
mov [rax+4], edx
mov rax, [rbp+var_18]
add rax, 190h
mov ecx, [rax]
mov rax, [rbp+var_18]
mov edx, [rax]
mov rax, [rbp+var_18]
add rax, 190h
add edx, ecx
mov [rax], edx
loc_11C0:
mov [rbp+var_10], 2
jmp loc_14BF
loc_11CC:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov esi, [rax]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
lea edx, [rsi+rcx]
mov [rax], edx
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_10]
cdqe
mov esi, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_10]
sub eax, 1
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
add ecx, esi
mov eax, [rbp+var_10]
cdqe
mov [rdx+rax*4], ecx
mov [rbp+var_C], 1
jmp loc_14AF
loc_12FC:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
sub eax, 1
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
mov eax, [rdx+rax*4]
cmp ecx, eax
jl loc_1412
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
mov esi, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
sub eax, 1
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
add ecx, esi
mov eax, [rbp+var_C]
cdqe
mov [rdx+rax*4], ecx
jmp loc_14AB
loc_1412:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
mov esi, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
add ecx, esi
mov eax, [rbp+var_C]
cdqe
mov [rdx+rax*4], ecx
loc_14AB:
add [rbp+var_C], 1
loc_14AF:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jl loc_12FC
add [rbp+var_10], 1
loc_14BF:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jl loc_11CC
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
mov [rbp+var_4], 1
jmp short loc_157C
loc_1506:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov eax, [rdx+rax*4]
cmp [rbp+var_8], eax
jge short loc_1578
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
lea rdx, [rax-190h]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov eax, [rdx+rax*4]
mov [rbp+var_8], eax
loc_1578:
add [rbp+var_4], 1
loc_157C:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1506
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // ecx
int i; // [rsp+Ch] [rbp-10h]
int j; // [rsp+10h] [rbp-Ch]
unsigned int v6; // [rsp+14h] [rbp-8h]
int k; // [rsp+18h] [rbp-4h]
if ( a2 > 1 )
{
a1[101] += *a1;
a1[100] += *a1;
}
for ( i = 2; i < a2; ++i )
{
a1[100 * i] += a1[100 * i - 100];
a1[100 * i + i] += a1[100 * i - 101 + i];
for ( j = 1; j < i; ++j )
{
if ( a1[100 * i - 101 + j] < a1[100 * i - 100 + j] )
v2 = a1[100 * i - 100 + j];
else
v2 = a1[100 * i - 101 + j];
a1[100 * i + j] += v2;
}
}
v6 = a1[100 * a2 - 100];
for ( k = 1; k < a2; ++k )
{
if ( (signed int)v6 < a1[100 * a2 - 100 + k] )
v6 = a1[100 * a2 - 100 + k];
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x1
JLE 0x001011c0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x190
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x190
ADD EDX,ECX
MOV dword ptr [RAX + 0x4],EDX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x190
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x190
ADD EDX,ECX
MOV dword ptr [RAX],EDX
LAB_001011c0:
MOV dword ptr [RBP + -0x10],0x2
JMP 0x001014bf
LAB_001011cc:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ESI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
LEA EDX,[RSI + RCX*0x1]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x1
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
ADD ECX,ESI
MOV EAX,dword ptr [RBP + -0x10]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001014af
LAB_001012fc:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP ECX,EAX
JL 0x00101412
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
ADD ECX,ESI
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
JMP 0x001014ab
LAB_00101412:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
ADD ECX,ESI
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
LAB_001014ab:
ADD dword ptr [RBP + -0xc],0x1
LAB_001014af:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x001012fc
ADD dword ptr [RBP + -0x10],0x1
LAB_001014bf:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011cc
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010157c
LAB_00101506:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RBP + -0x8],EAX
JGE 0x00101578
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
LEA RDX,[RAX + -0x190]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RBP + -0x8],EAX
LAB_00101578:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010157c:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101506
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(int *param_1,int param_2)
{
int local_18;
int local_14;
int local_10;
int local_c;
if (1 < param_2) {
param_1[0x65] = *param_1 + param_1[0x65];
param_1[100] = *param_1 + param_1[100];
}
for (local_18 = 2; local_18 < param_2; local_18 = local_18 + 1) {
param_1[(long)local_18 * 100] =
param_1[(long)local_18 * 100] + param_1[(long)local_18 * 100 + -100];
param_1[(long)local_18 * 100 + (long)local_18] =
param_1[(long)local_18 * 100 + (long)(local_18 + -1) + -100] +
param_1[(long)local_18 * 100 + (long)local_18];
for (local_14 = 1; local_14 < local_18; local_14 = local_14 + 1) {
if (param_1[(long)local_18 * 100 + (long)(local_14 + -1) + -100] <
param_1[(long)local_18 * 100 + (long)local_14 + -100]) {
param_1[(long)local_18 * 100 + (long)local_14] =
param_1[(long)local_18 * 100 + (long)local_14 + -100] +
param_1[(long)local_18 * 100 + (long)local_14];
}
else {
param_1[(long)local_18 * 100 + (long)local_14] =
param_1[(long)local_18 * 100 + (long)(local_14 + -1) + -100] +
param_1[(long)local_18 * 100 + (long)local_14];
}
}
}
local_10 = param_1[(long)param_2 * 100 + -100];
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (local_10 < param_1[(long)param_2 * 100 + (long)local_c + -100]) {
local_10 = param_1[(long)param_2 * 100 + (long)local_c + -100];
}
}
return local_10;
} |
4,817 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int tri[][100], int n) {
if (n > 1) {
tri[1][1] = tri[1][1] + tri[0][0];
tri[1][0] = tri[1][0] + tri[0][0];
}
for (int i = 2; i < n; i++) {
tri[i][0] = tri[i][0] + tri[i-1][0];
tri[i][i] = tri[i][i] + tri[i-1][i-1];
for (int j = 1; j < i; j++) {
if (tri[i][j] + tri[i-1][j-1] >= tri[i][j] + tri[i-1][j]) {
tri[i][j] = tri[i][j] + tri[i-1][j-1];
} else {
tri[i][j] = tri[i][j] + tri[i-1][j];
}
}
}
int max_value = tri[n-1][0];
for (int j = 1; j < n; j++) {
if (tri[n-1][j] > max_value) {
max_value = tri[n-1][j];
}
}
return max_value;
}
| int main() {
int tri1[3][100] = {{1}, {2, 1}, {3, 3, 2}};
assert(func0(tri1, 3) == 6);
int tri2[3][100] = {{1}, {1, 2}, {4, 1, 12}};
assert(func0(tri2, 3) == 15);
int tri3[3][100] = {{2}, {3, 2}, {13, 23, 12}};
assert(func0(tri3, 3) == 28);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%edi
cmp $0x1,%esi
jle 1188 <func0+0x1f>
mov 0x0(%rbp),%eax
add %eax,0x194(%rbp)
add %eax,0x190(%rbp)
cmp $0x2,%edi
jle 1214 <func0+0xab>
lea 0x320(%rbp),%r11
lea 0x328(%rbp),%rsi
lea -0x3(%rdi),%ebx
add $0x3,%rbx
mov $0x2,%r10d
jmp 11eb <func0+0x82>
add (%r8,%rax,4),%edx
mov %edx,(%r8,%rax,4)
add $0x1,%rax
cmp %r10,%rax
je 11d4 <func0+0x6b>
mov -0x4(%r9,%rax,4),%ecx
mov (%r9,%rax,4),%edx
cmp %edx,%ecx
jl 11ae <func0+0x45>
add (%r8,%rax,4),%ecx
mov %ecx,%edx
jmp 11b2 <func0+0x49>
add $0x1,%r10
add $0x190,%r11
add $0x194,%rsi
cmp %rbx,%r10
je 123c <func0+0xd3>
mov %r11,%r8
lea -0x190(%r11),%r9
mov -0x190(%r11),%eax
add %eax,(%r11)
mov -0x194(%rsi),%eax
add %eax,(%rsi)
cmp $0x1,%r10d
jle 11d4 <func0+0x6b>
mov $0x1,%eax
jmp 11bf <func0+0x56>
movslq %edi,%rax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
shl $0x4,%rax
lea -0x190(%rbp,%rax,1),%rax
mov (%rax),%edx
cmp $0x2,%edi
jne 126a <func0+0x101>
mov 0x4(%rax),%eax
cmp %eax,%edx
cmovl %eax,%edx
jmp 126a <func0+0x101>
movslq %edi,%rax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
shl $0x4,%rax
lea -0x190(%rbp,%rax,1),%rsi
mov (%rsi),%edx
mov $0x1,%eax
mov (%rsi,%rax,4),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x1,%rax
cmp %eax,%edi
jg 125a <func0+0xf1>
mov %edx,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
mov rbp, rdi
mov r11d, esi
cmp esi, 1
jle short loc_1188
mov eax, [rdi]
add [rdi+194h], eax
add [rdi+190h], eax
loc_1188:
cmp r11d, 2
jle short loc_120A
lea r9, [rbp+320h]
lea r10, [rbp+328h]
mov ebx, r11d
mov r8d, 2
jmp short loc_11DF
loc_11A7:
add edx, [rsi+rax*4]
loc_11AA:
mov [rsi+rax*4], edx
add rax, 1
cmp rax, r8
jz short loc_11C8
loc_11B6:
mov ecx, [rdi+rax*4-4]
mov edx, [rdi+rax*4]
cmp ecx, edx
jl short loc_11A7
add ecx, [rsi+rax*4]
mov edx, ecx
jmp short loc_11AA
loc_11C8:
add r8, 1
add r9, 190h
add r10, 194h
cmp r8, rbx
jz short loc_1233
loc_11DF:
mov rsi, r9
lea rdi, [r9-190h]
mov eax, [r9-190h]
add [r9], eax
mov eax, [r10-194h]
add [r10], eax
cmp r8d, 1
jle short loc_11C8
mov eax, 1
jmp short loc_11B6
loc_120A:
movsxd rax, r11d
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
shl rax, 4
lea rax, [rbp+rax-190h]
mov edx, [rax]
cmp r11d, 2
jnz short loc_1262
mov eax, [rax+4]
cmp edx, eax
cmovl edx, eax
jmp short loc_1262
loc_1233:
movsxd rax, r11d
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
shl rax, 4
lea rsi, [rbp+rax-190h]
mov edx, [rsi]
mov eax, 1
loc_1251:
mov ecx, [rsi+rax*4]
cmp edx, ecx
cmovl edx, ecx
add rax, 1
cmp r11d, eax
jg short loc_1251
loc_1262:
mov eax, edx
pop rbx
pop rbp
retn | long long func0(int *a1, int a2)
{
int v4; // eax
_DWORD *v5; // r9
_DWORD *v6; // r10
long long i; // r8
int v8; // edx
long long v9; // rax
int v10; // ecx
int v11; // edx
_DWORD *v12; // rdi
signed int *v13; // rax
signed int v14; // edx
unsigned int v15; // eax
signed int *v16; // rsi
long long v17; // rax
if ( a2 > 1 )
{
v4 = *a1;
a1[101] += *a1;
a1[100] += v4;
}
if ( a2 <= 2 )
{
v13 = &a1[100 * a2 - 100];
v14 = *v13;
if ( a2 == 2 )
{
v15 = v13[1];
if ( v14 < (int)v15 )
return v15;
}
}
else
{
v5 = a1 + 200;
v6 = a1 + 202;
for ( i = 2LL; i != a2; ++i )
{
v12 = v5 - 100;
*v5 += *(v5 - 100);
*v6 += *(v6 - 101);
if ( (int)i > 1 )
{
v9 = 1LL;
do
{
v10 = v12[v9 - 1];
v11 = v12[v9];
if ( v10 < v11 )
v8 = v5[v9] + v11;
else
v8 = v5[v9] + v10;
v5[v9++] = v8;
}
while ( v9 != i );
}
v5 += 100;
v6 += 101;
}
v16 = &a1[100 * a2 - 100];
v14 = *v16;
v17 = 1LL;
do
{
if ( v14 < v16[v17] )
v14 = v16[v17];
++v17;
}
while ( a2 > (int)v17 );
}
return (unsigned int)v14;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV R11D,ESI
CMP ESI,0x1
JLE 0x00101188
MOV EAX,dword ptr [RDI]
ADD dword ptr [RDI + 0x194],EAX
ADD dword ptr [RDI + 0x190],EAX
LAB_00101188:
CMP R11D,0x2
JLE 0x0010120a
LEA R9,[RBP + 0x320]
LEA R10,[RBP + 0x328]
MOV EBX,R11D
MOV R8D,0x2
JMP 0x001011df
LAB_001011a7:
ADD EDX,dword ptr [RSI + RAX*0x4]
LAB_001011aa:
MOV dword ptr [RSI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R8
JZ 0x001011c8
LAB_001011b6:
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP ECX,EDX
JL 0x001011a7
ADD ECX,dword ptr [RSI + RAX*0x4]
MOV EDX,ECX
JMP 0x001011aa
LAB_001011c8:
ADD R8,0x1
ADD R9,0x190
ADD R10,0x194
CMP R8,RBX
JZ 0x00101233
LAB_001011df:
MOV RSI,R9
LEA RDI,[R9 + -0x190]
MOV EAX,dword ptr [R9 + -0x190]
ADD dword ptr [R9],EAX
MOV EAX,dword ptr [R10 + -0x194]
ADD dword ptr [R10],EAX
CMP R8D,0x1
JLE 0x001011c8
MOV EAX,0x1
JMP 0x001011b6
LAB_0010120a:
MOVSXD RAX,R11D
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
LEA RAX,[RBP + RAX*0x1 + -0x190]
MOV EDX,dword ptr [RAX]
CMP R11D,0x2
JNZ 0x00101262
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
CMOVL EDX,EAX
JMP 0x00101262
LAB_00101233:
MOVSXD RAX,R11D
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
LEA RSI,[RBP + RAX*0x1 + -0x190]
MOV EDX,dword ptr [RSI]
MOV EAX,0x1
LAB_00101251:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x1
CMP R11D,EAX
JG 0x00101251
LAB_00101262:
MOV EAX,EDX
POP RBX
POP RBP
RET | int func0(int *param_1,uint param_2)
{
int iVar1;
ulong uVar2;
long lVar3;
int iVar4;
ulong uVar5;
int *piVar6;
int *piVar7;
if (1 < (int)param_2) {
param_1[0x65] = param_1[0x65] + *param_1;
param_1[100] = param_1[100] + *param_1;
}
if ((int)param_2 < 3) {
iVar4 = param_1[(long)(int)param_2 * 100 + -100];
if ((param_2 == 2) && (iVar1 = (param_1 + (long)(int)param_2 * 100 + -100)[1], iVar4 < iVar1)) {
iVar4 = iVar1;
}
}
else {
piVar6 = param_1 + 200;
piVar7 = param_1 + 0xca;
uVar5 = 2;
do {
*piVar6 = *piVar6 + piVar6[-100];
*piVar7 = *piVar7 + piVar7[-0x65];
if (1 < (int)uVar5) {
uVar2 = 1;
do {
if (piVar6[uVar2 - 0x65] < piVar6[uVar2 - 100]) {
iVar4 = piVar6[uVar2 - 100] + piVar6[uVar2];
}
else {
iVar4 = piVar6[uVar2 - 0x65] + piVar6[uVar2];
}
piVar6[uVar2] = iVar4;
uVar2 = uVar2 + 1;
} while (uVar2 != uVar5);
}
uVar5 = uVar5 + 1;
piVar6 = piVar6 + 100;
piVar7 = piVar7 + 0x65;
} while (uVar5 != param_2);
iVar4 = param_1[(long)(int)param_2 * 100 + -100];
lVar3 = 1;
do {
iVar1 = (param_1 + (long)(int)param_2 * 100 + -100)[lVar3];
if (iVar4 < iVar1) {
iVar4 = iVar1;
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < (int)param_2);
}
return iVar4;
} |
4,818 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int tri[][100], int n) {
if (n > 1) {
tri[1][1] = tri[1][1] + tri[0][0];
tri[1][0] = tri[1][0] + tri[0][0];
}
for (int i = 2; i < n; i++) {
tri[i][0] = tri[i][0] + tri[i-1][0];
tri[i][i] = tri[i][i] + tri[i-1][i-1];
for (int j = 1; j < i; j++) {
if (tri[i][j] + tri[i-1][j-1] >= tri[i][j] + tri[i-1][j]) {
tri[i][j] = tri[i][j] + tri[i-1][j-1];
} else {
tri[i][j] = tri[i][j] + tri[i-1][j];
}
}
}
int max_value = tri[n-1][0];
for (int j = 1; j < n; j++) {
if (tri[n-1][j] > max_value) {
max_value = tri[n-1][j];
}
}
return max_value;
}
| int main() {
int tri1[3][100] = {{1}, {2, 1}, {3, 3, 2}};
assert(func0(tri1, 3) == 6);
int tri2[3][100] = {{1}, {1, 2}, {4, 1, 12}};
assert(func0(tri2, 3) == 15);
int tri3[3][100] = {{2}, {3, 2}, {13, 23, 12}};
assert(func0(tri3, 3) == 28);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %esi,%ebx
cmp $0x1,%esi
jle 142b <func0+0xeb>
mov (%rdi),%eax
add %eax,0x194(%rdi)
add %eax,0x190(%rdi)
movslq %esi,%rax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
shl $0x4,%rax
lea -0x190(%rdi,%rax,1),%rbp
cmp $0x2,%esi
jle 1442 <func0+0x102>
lea -0x3(%rbx),%r12d
lea 0x320(%rdi),%r8
mov $0x2,%r11d
lea 0x328(%rdi),%rsi
add $0x3,%r12
nopl (%rax)
mov -0x190(%r8),%eax
lea -0x190(%r8),%r9
add %eax,(%r8)
mov -0x194(%rsi),%eax
add %eax,(%rsi)
mov $0x1,%eax
xchg %ax,%ax
mov -0x4(%r9,%rax,4),%edi
mov (%r9,%rax,4),%ecx
mov (%r8,%rax,4),%edx
lea (%rdi,%rdx,1),%r10d
add %ecx,%edx
cmp %ecx,%edi
cmovge %r10d,%edx
mov %edx,(%r8,%rax,4)
add $0x1,%rax
cmp %rax,%r11
jne 13c0 <func0+0x80>
add $0x1,%r11
add $0x190,%r8
add $0x194,%rsi
cmp %r11,%r12
jne 13a0 <func0+0x60>
mov 0x0(%rbp),%r8d
mov $0x1,%eax
nopw %cs:0x0(%rax,%rax,1)
mov 0x0(%rbp,%rax,4),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x1,%rax
cmp %eax,%ebx
jg 1410 <func0+0xd0>
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r12
retq
movslq %esi,%rax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
shl $0x4,%rax
lea -0x190(%rdi,%rax,1),%rbp
mov 0x0(%rbp),%r8d
cmp $0x2,%ebx
jne 1423 <func0+0xe3>
mov 0x4(%rbp),%eax
cmp %eax,%r8d
cmovl %eax,%r8d
jmp 1423 <func0+0xe3>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
mov ebx, esi
cmp esi, 1
jle loc_1423
movsxd r12, esi
mov eax, [rdi]
add [rdi+194h], eax
add [rdi+190h], eax
lea rax, [r12+r12*4]
lea rax, [rax+rax*4]
shl rax, 4
lea rbp, [rdi+rax-190h]
cmp esi, 2
jle loc_143A
lea r8, [rdi+320h]
lea r11, [rdi+328h]
mov r10d, 2
nop dword ptr [rax]
loc_1398:
mov eax, [r8-190h]
lea rdi, [r8-190h]
add [r8], eax
mov eax, [r11-194h]
add [r11], eax
mov eax, 1
nop dword ptr [rax+rax+00000000h]
loc_13C0:
mov esi, [rdi+rax*4-4]
mov ecx, [rdi+rax*4]
mov edx, [r8+rax*4]
lea r9d, [rsi+rdx]
add edx, ecx
cmp esi, ecx
cmovge edx, r9d
mov [r8+rax*4], edx
add rax, 1
cmp r10, rax
jnz short loc_13C0
add r10, 1
add r8, 190h
add r11, 194h
cmp r10, r12
jnz short loc_1398
mov r8d, [rbp+0]
mov eax, 1
nop dword ptr [rax+00h]
loc_1408:
mov edx, [rbp+rax*4+0]
cmp r8d, edx
cmovl r8d, edx
add rax, 1
cmp ebx, eax
jg short loc_1408
loc_141B:
pop rbx
mov eax, r8d
pop rbp
pop r12
retn
loc_1423:
movsxd rax, esi
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
shl rax, 4
lea rbp, [rdi+rax-190h]
loc_143A:
mov r8d, [rbp+0]
cmp ebx, 2
jnz short loc_141B
mov eax, [rbp+4]
cmp r8d, eax
cmovl r8d, eax
jmp short loc_141B | long long func0(int *a1, int a2)
{
long long v3; // r12
int v4; // eax
unsigned int *v5; // rbp
_DWORD *v6; // r8
_DWORD *v7; // r11
long long v8; // r10
_DWORD *v9; // rdi
long long v10; // rax
int v11; // esi
int v12; // ecx
int v13; // edx
int v14; // r9d
int v15; // edx
unsigned int v16; // r8d
long long v17; // rax
if ( a2 <= 1 )
{
v5 = (unsigned int *)&a1[100 * a2 - 100];
}
else
{
v3 = a2;
v4 = *a1;
a1[101] += *a1;
a1[100] += v4;
v5 = (unsigned int *)&a1[100 * a2 - 100];
if ( a2 > 2 )
{
v6 = a1 + 200;
v7 = a1 + 202;
v8 = 2LL;
do
{
v9 = v6 - 100;
*v6 += *(v6 - 100);
*v7 += *(v7 - 101);
v10 = 1LL;
do
{
v11 = v9[v10 - 1];
v12 = v9[v10];
v13 = v6[v10];
v14 = v11 + v13;
v15 = v12 + v13;
if ( v11 >= v12 )
v15 = v14;
v6[v10++] = v15;
}
while ( v8 != v10 );
++v8;
v6 += 100;
v7 += 101;
}
while ( v8 != v3 );
v16 = *v5;
v17 = 1LL;
do
{
if ( (int)v16 < (int)v5[v17] )
v16 = v5[v17];
++v17;
}
while ( a2 > (int)v17 );
return v16;
}
}
v16 = *v5;
if ( a2 == 2 && (int)v16 < (int)v5[1] )
return v5[1];
return v16;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JLE 0x00101423
MOVSXD R12,ESI
MOV EAX,dword ptr [RDI]
ADD dword ptr [RDI + 0x194],EAX
ADD dword ptr [RDI + 0x190],EAX
LEA RAX,[R12 + R12*0x4]
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
LEA RBP,[RDI + RAX*0x1 + -0x190]
CMP ESI,0x2
JLE 0x0010143a
LEA R8,[RDI + 0x320]
LEA R11,[RDI + 0x328]
MOV R10D,0x2
NOP dword ptr [RAX]
LAB_00101398:
MOV EAX,dword ptr [R8 + -0x190]
LEA RDI,[R8 + -0x190]
ADD dword ptr [R8],EAX
MOV EAX,dword ptr [R11 + -0x194]
ADD dword ptr [R11],EAX
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c0:
MOV ESI,dword ptr [RDI + RAX*0x4 + -0x4]
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV EDX,dword ptr [R8 + RAX*0x4]
LEA R9D,[RSI + RDX*0x1]
ADD EDX,ECX
CMP ESI,ECX
CMOVGE EDX,R9D
MOV dword ptr [R8 + RAX*0x4],EDX
ADD RAX,0x1
CMP R10,RAX
JNZ 0x001013c0
ADD R10,0x1
ADD R8,0x190
ADD R11,0x194
CMP R10,R12
JNZ 0x00101398
MOV R8D,dword ptr [RBP]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101408:
MOV EDX,dword ptr [RBP + RAX*0x4]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0x1
CMP EBX,EAX
JG 0x00101408
LAB_0010141b:
POP RBX
MOV EAX,R8D
POP RBP
POP R12
RET
LAB_00101423:
MOVSXD RAX,ESI
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
LEA RBP,[RDI + RAX*0x1 + -0x190]
LAB_0010143a:
MOV R8D,dword ptr [RBP]
CMP EBX,0x2
JNZ 0x0010141b
MOV EAX,dword ptr [RBP + 0x4]
CMP R8D,EAX
CMOVL R8D,EAX
JMP 0x0010141b | int func0(int *param_1,int param_2)
{
long lVar1;
int *piVar2;
int iVar3;
int *piVar4;
long lVar5;
if (param_2 < 2) {
piVar2 = param_1 + (long)param_2 * 100 + -100;
}
else {
param_1[0x65] = param_1[0x65] + *param_1;
param_1[100] = param_1[100] + *param_1;
piVar2 = param_1 + (long)param_2 * 100 + -100;
if (2 < param_2) {
piVar4 = param_1 + 200;
param_1 = param_1 + 0xca;
lVar5 = 2;
do {
*piVar4 = *piVar4 + piVar4[-100];
*param_1 = *param_1 + param_1[-0x65];
lVar1 = 1;
do {
iVar3 = piVar4[lVar1 + -100];
if (piVar4[lVar1 + -100] <= piVar4[lVar1 + -0x65]) {
iVar3 = piVar4[lVar1 + -0x65];
}
piVar4[lVar1] = piVar4[lVar1] + iVar3;
lVar1 = lVar1 + 1;
} while (lVar5 != lVar1);
lVar5 = lVar5 + 1;
piVar4 = piVar4 + 100;
param_1 = param_1 + 0x65;
} while (lVar5 != param_2);
iVar3 = *piVar2;
lVar5 = 1;
do {
if (iVar3 < piVar2[lVar5]) {
iVar3 = piVar2[lVar5];
}
lVar5 = lVar5 + 1;
} while ((int)lVar5 < param_2);
return iVar3;
}
}
iVar3 = *piVar2;
if ((param_2 == 2) && (iVar3 < piVar2[1])) {
iVar3 = piVar2[1];
}
return iVar3;
} |
4,819 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int tri[][100], int n) {
if (n > 1) {
tri[1][1] = tri[1][1] + tri[0][0];
tri[1][0] = tri[1][0] + tri[0][0];
}
for (int i = 2; i < n; i++) {
tri[i][0] = tri[i][0] + tri[i-1][0];
tri[i][i] = tri[i][i] + tri[i-1][i-1];
for (int j = 1; j < i; j++) {
if (tri[i][j] + tri[i-1][j-1] >= tri[i][j] + tri[i-1][j]) {
tri[i][j] = tri[i][j] + tri[i-1][j-1];
} else {
tri[i][j] = tri[i][j] + tri[i-1][j];
}
}
}
int max_value = tri[n-1][0];
for (int j = 1; j < n; j++) {
if (tri[n-1][j] > max_value) {
max_value = tri[n-1][j];
}
}
return max_value;
}
| int main() {
int tri1[3][100] = {{1}, {2, 1}, {3, 3, 2}};
assert(func0(tri1, 3) == 6);
int tri2[3][100] = {{1}, {1, 2}, {4, 1, 12}};
assert(func0(tri2, 3) == 15);
int tri3[3][100] = {{2}, {3, 2}, {13, 23, 12}};
assert(func0(tri3, 3) == 28);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %esi,%r13d
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
cmp $0x1,%esi
jle 15db <func0+0x29b>
mov (%rdi),%eax
add %eax,0x194(%rdi)
add %eax,0x190(%rdi)
movslq %esi,%rax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
shl $0x4,%rax
mov %rax,-0x10(%rsp)
lea -0x190(%rdi,%rax,1),%r14
cmp $0x2,%esi
jle 15f2 <func0+0x2b2>
lea 0x320(%rdi),%rcx
lea -0x1(%rsi),%r12d
mov $0x1,%r8d
lea 0x328(%rdi),%r10
mov $0xc8,%edi
nopl (%rax)
mov -0x190(%rcx),%eax
add %eax,(%rcx)
lea -0x190(%rcx),%rsi
mov -0x194(%r10),%eax
add %eax,(%r10)
lea -0x1(%r8),%eax
cmp $0x2,%eax
jbe 15d0 <func0+0x290>
mov %r8d,%r9d
lea -0x18c(%rcx),%r11
lea 0x4(%rcx),%rdx
xor %eax,%eax
shr $0x2,%r9d
shl $0x4,%r9
xchg %ax,%ax
movdqu (%r11,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm6
movdqu (%rdx,%rax,1),%xmm4
movdqu (%rsi,%rax,1),%xmm2
movdqu (%r11,%rax,1),%xmm1
pcmpgtd %xmm6,%xmm0
paddd %xmm4,%xmm2
paddd %xmm4,%xmm1
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %r9,%rax
jne 13f0 <func0+0xb0>
mov %r8d,%eax
lea 0x1(%r8),%r9d
and $0xfffffffc,%eax
lea 0x1(%rax),%r11d
cmp %eax,%r8d
je 14b4 <func0+0x174>
movslq %r11d,%rax
lea (%rax,%rdi,1),%rdx
shl $0x2,%rax
add %rax,%rsi
add %rcx,%rax
mov -0x194(%rbp,%rdx,4),%r9d
mov (%rsi),%ebx
mov (%rax),%edx
lea (%rdx,%rbx,1),%r15d
add %r9d,%edx
cmp %ebx,%r9d
cmovl %r15d,%edx
lea 0x1(%r8),%r9d
mov %edx,(%rax)
lea 0x1(%r11),%edx
cmp %r9d,%edx
jge 14b4 <func0+0x174>
mov 0x4(%rsi),%r8d
mov 0x4(%rax),%edx
lea (%r8,%rdx,1),%r15d
add %ebx,%edx
cmp %ebx,%r8d
cmovg %r15d,%edx
add $0x2,%r11d
mov %edx,0x4(%rax)
cmp %r9d,%r11d
jge 14b4 <func0+0x174>
mov 0x8(%rsi),%esi
mov 0x8(%rax),%edx
lea (%rsi,%rdx,1),%r11d
add %r8d,%edx
cmp %esi,%r8d
cmovl %r11d,%edx
mov %edx,0x8(%rax)
add $0x190,%rcx
mov %r9d,%r8d
add $0x64,%rdi
add $0x194,%r10
cmp %r12d,%r9d
jne 13b0 <func0+0x70>
cmp $0x1,%r13d
mov $0x1,%edx
mov (%r14),%eax
cmovle %edx,%r9d
cmp $0x4,%r13d
jle 1610 <func0+0x2d0>
movd %eax,%xmm7
mov %r9d,%edx
mov -0x10(%rsp),%rax
shr $0x2,%edx
pshufd $0x0,%xmm7,%xmm0
lea -0x18c(%rbp,%rax,1),%rax
shl $0x4,%rdx
add %rax,%rdx
movdqu (%rax),%xmm2
add $0x10,%rax
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
movdqa %xmm1,%xmm0
por %xmm2,%xmm0
cmp %rdx,%rax
jne 1510 <func0+0x1d0>
movdqa %xmm0,%xmm1
mov %r9d,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
movdqa %xmm1,%xmm2
movdqa %xmm1,%xmm3
lea 0x1(%rdx),%ecx
pcmpgtd %xmm0,%xmm2
pand %xmm2,%xmm3
pandn %xmm0,%xmm2
movdqa %xmm2,%xmm1
por %xmm3,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
cmp %edx,%r9d
je 15bd <func0+0x27d>
movslq %ecx,%rcx
mov (%r14,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x2,%edx
cmp %edx,%r13d
jle 15bd <func0+0x27d>
movslq %edx,%rcx
mov (%r14,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%r13d
jle 15bd <func0+0x27d>
movslq %edx,%rdx
mov (%r14,%rdx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%r11d
jmpq 1443 <func0+0x103>
movslq %esi,%rax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
shl $0x4,%rax
lea -0x190(%rdi,%rax,1),%r14
mov (%r14),%eax
cmp $0x2,%r13d
jne 15bd <func0+0x27d>
mov 0x4(%r14),%edx
cmp %edx,%eax
cmovl %edx,%eax
jmp 15bd <func0+0x27d>
nopw %cs:0x0(%rax,%rax,1)
cmp %eax,0x4(%r14)
mov $0x2,%edx
cmovge 0x4(%r14),%eax
jmpq 159d <func0+0x25d>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
movsxd rax, esi
push r15
mov rdx, rax
lea rax, [rax+rax*4]
push r14
lea r11, [rax+rax*4]
push r13
shl r11, 4
push r12
push rbp
push rbx
lea rbx, [rdi+r11-190h]
cmp edx, 1
jle loc_15D5
mov eax, [rdi]
add [rdi+194h], eax
add [rdi+190h], eax
cmp edx, 2
jz loc_15F9
lea r10d, [rdx-1]
lea rcx, [rdi+320h]
mov r9d, 0C8h
mov r8d, 1
lea rsi, [rdi+328h]
nop word ptr [rax+rax+00000000h]
loc_13A0:
mov r13d, r8d
mov eax, [rcx-190h]
add [rcx], eax
lea rbp, [rcx-190h]
mov eax, [rsi-194h]
add [rsi], eax
lea eax, [r13-1]
add r8d, 1
cmp eax, 2
jbe loc_15C8
mov r14d, r13d
lea r15, [rcx-18Ch]
lea r12, [rcx+4]
xor eax, eax
shr r14d, 2
shl r14, 4
nop dword ptr [rax+rax+00h]
loc_13E8:
movdqu xmm0, xmmword ptr [r15+rax]
movdqu xmm6, xmmword ptr [rbp+rax+0]
movdqu xmm4, xmmword ptr [r12+rax]
movdqu xmm2, xmmword ptr [rbp+rax+0]
movdqu xmm1, xmmword ptr [r15+rax]
pcmpgtd xmm0, xmm6
paddd xmm2, xmm4
paddd xmm1, xmm4
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movups xmmword ptr [r12+rax], xmm0
add rax, 10h
cmp rax, r14
jnz short loc_13E8
mov r12d, r13d
and r12d, 0FFFFFFFCh
and r13d, 3
lea eax, [r12+1]
jz loc_14CC
loc_1442:
mov r14d, r8d
sub r14d, r12d
lea r13d, [r14-1]
cmp r14d, 2
jz short loc_14A5
add r12, r9
shl r12, 2
movq xmm2, qword ptr [rdi+r12-190h]
lea r14, [rdi+r12+4]
movq xmm0, qword ptr [rdi+r12-18Ch]
movq xmm1, qword ptr [r14]
movdqa xmm3, xmm2
paddd xmm3, xmm1
paddd xmm1, xmm0
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm3
por xmm0, xmm1
movq qword ptr [r14], xmm0
test r13b, 1
jz short loc_14CC
and r13d, 0FFFFFFFEh
add eax, r13d
loc_14A5:
cdqe
shl rax, 2
add rbp, rax
add rax, rcx
mov r12d, [rbp-4]
mov r13d, [rbp+0]
mov ebp, [rax]
lea r14d, [r13+rbp+0]
add ebp, r12d
cmp r12d, r13d
cmovl ebp, r14d
mov [rax], ebp
loc_14CC:
add rcx, 190h
add r9, 64h ; 'd'
add rsi, 194h
cmp r10d, r8d
jnz loc_13A0
lea eax, [rdx-2]
movd xmm0, dword ptr [rbx]
cmp eax, 2
jbe loc_15E2
mov ecx, r10d
lea rax, [rdi+r11-18Ch]
pshufd xmm0, xmm0, 0
shr ecx, 2
shl rcx, 4
add rcx, rax
nop dword ptr [rax+00000000h]
loc_1518:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
movdqa xmm2, xmm1
pcmpgtd xmm2, xmm0
pand xmm1, xmm2
pandn xmm2, xmm0
por xmm2, xmm1
movdqa xmm0, xmm2
cmp rcx, rax
jnz short loc_1518
movdqa xmm2, xmm0
mov ecx, r10d
psrldq xmm2, 8
and ecx, 0FFFFFFFCh
and r10d, 3
movdqa xmm1, xmm2
lea esi, [rcx+1]
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
jz short loc_15B9
movsxd rdi, esi
lea rdi, [rbx+rdi*4]
mov r8d, [rdi]
cmp eax, r8d
cmovl eax, r8d
add ecx, 2
cmp ecx, edx
jge short loc_15B9
loc_15A2:
mov ecx, [rdi+4]
cmp eax, ecx
cmovl eax, ecx
add esi, 2
cmp esi, edx
jge short loc_15B9
mov edx, [rdi+8]
cmp eax, edx
cmovl eax, edx
loc_15B9:
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15C8:
xor r12d, r12d
mov eax, 1
jmp loc_1442
loc_15D5:
mov eax, [rbx]
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15E2:
mov eax, [rbx+4]
lea rdi, [rbx+4]
movd ebx, xmm0
mov esi, 1
cmp ebx, eax
cmovge eax, ebx
jmp short loc_15A2
loc_15F9:
mov eax, [rbx+4]
mov edx, [rbx]
cmp eax, edx
cmovl eax, edx
jmp short loc_15B9 | long long func0(int *a1, int a2)
{
long long v3; // r11
unsigned int *v4; // rbx
int v5; // eax
unsigned int v6; // r10d
_DWORD *v7; // rcx
long long v8; // r9
int v9; // r8d
_DWORD *v10; // rsi
unsigned int v11; // r13d
_DWORD *v12; // rbp
unsigned int v13; // eax
_DWORD *v14; // r15
_DWORD *v15; // r12
long long v16; // rax
__m128i v17; // xmm4
__m128i v18; // xmm0
long long v19; // r12
int v20; // eax
int v21; // r13d
long long v22; // r12
__m128i v23; // xmm2
__m128i *v24; // r14
__m128i v25; // xmm0
__m128i v26; // xmm1
__m128i v27; // xmm3
__m128i v28; // xmm1
__m128i v29; // xmm0
long long v30; // rax
int *v31; // rbp
int *v32; // rax
int v33; // r12d
int v34; // r13d
int v35; // r14d
int v36; // ebp
__m128i v37; // xmm0
const __m128i *v38; // rax
__m128i v39; // xmm0
const __m128i *v40; // rcx
__m128i v41; // xmm1
__m128i v42; // xmm2
__m128i v43; // xmm2
__m128i v44; // xmm2
signed int v45; // esi
__m128i v46; // xmm1
__m128i v47; // xmm1
__m128i v48; // xmm2
__m128i v49; // xmm0
long long result; // rax
int *v51; // rdi
int v52; // ecx
int v53; // edx
int v54; // ebx
v3 = 100LL * a2;
v4 = (unsigned int *)&a1[v3 - 100];
if ( a2 <= 1 )
return *v4;
v5 = *a1;
a1[101] += *a1;
a1[100] += v5;
if ( a2 == 2 )
{
result = v4[1];
if ( (int)result < (int)*v4 )
return *v4;
return result;
}
v6 = a2 - 1;
v7 = a1 + 200;
v8 = 200LL;
v9 = 1;
v10 = a1 + 202;
do
{
v11 = v9;
*v7 += *(v7 - 100);
v12 = v7 - 100;
*v10 += *(v10 - 101);
v13 = v9++ - 1;
if ( v13 <= 2 )
{
v19 = 0LL;
v20 = 1;
}
else
{
v14 = v7 - 99;
v15 = v7 + 1;
v16 = 0LL;
do
{
v17 = _mm_loadu_si128((const __m128i *)&v15[v16]);
v18 = _mm_cmpgt_epi32(_mm_loadu_si128((const __m128i *)&v14[v16]), _mm_loadu_si128((const __m128i *)&v12[v16]));
*(__m128i *)&v15[v16] = _mm_or_si128(
_mm_andnot_si128(v18, _mm_add_epi32(_mm_loadu_si128((const __m128i *)&v12[v16]), v17)),
_mm_and_si128(_mm_add_epi32(_mm_loadu_si128((const __m128i *)&v14[v16]), v17), v18));
v16 += 4LL;
}
while ( v16 != 4LL * (v11 >> 2) );
v19 = v11 & 0xFFFFFFFC;
v20 = v19 + 1;
if ( (v11 & 3) == 0 )
goto LABEL_14;
}
v21 = v9 - v19 - 1;
if ( v9 - (_DWORD)v19 != 2 )
{
v22 = v8 + v19;
v23 = _mm_loadl_epi64((const __m128i *)&a1[v22 - 100]);
v24 = (__m128i *)&a1[v22 + 1];
v25 = _mm_loadl_epi64((const __m128i *)&a1[v22 - 99]);
v26 = _mm_loadl_epi64(v24);
v27 = _mm_add_epi32(v23, v26);
v28 = _mm_add_epi32(v26, v25);
v29 = _mm_cmpgt_epi32(v25, v23);
v24->m128i_i64[0] = _mm_or_si128(_mm_andnot_si128(v29, v27), _mm_and_si128(v28, v29)).m128i_u64[0];
if ( (v21 & 1) == 0 )
goto LABEL_14;
v20 += v21 & 0xFFFFFFFE;
}
v30 = v20;
v31 = &v12[v30];
v32 = &v7[v30];
v33 = *(v31 - 1);
v34 = *v31;
v35 = *v31 + *v32;
v36 = v33 + *v32;
if ( v33 < v34 )
v36 = v35;
*v32 = v36;
LABEL_14:
v7 += 100;
v8 += 100LL;
v10 += 101;
}
while ( v6 != v9 );
v37 = _mm_cvtsi32_si128(*v4);
if ( (unsigned int)(a2 - 2) <= 2 )
{
result = v4[1];
v51 = (int *)(v4 + 1);
v54 = _mm_cvtsi128_si32(v37);
v45 = 1;
if ( v54 >= (int)result )
result = (unsigned int)v54;
LABEL_22:
v52 = v51[1];
if ( (int)result < v52 )
result = (unsigned int)v52;
if ( v45 + 2 < a2 )
{
v53 = v51[2];
if ( (int)result < v53 )
return (unsigned int)v53;
}
}
else
{
v38 = (const __m128i *)&a1[v3 - 99];
v39 = _mm_shuffle_epi32(v37, 0);
v40 = &v38[v6 >> 2];
do
{
v41 = _mm_loadu_si128(v38++);
v42 = _mm_cmpgt_epi32(v41, v39);
v43 = _mm_or_si128(_mm_andnot_si128(v42, v39), _mm_and_si128(v41, v42));
v39 = v43;
}
while ( v40 != v38 );
v44 = _mm_srli_si128(v43, 8);
v45 = (v6 & 0xFFFFFFFC) + 1;
v46 = _mm_cmpgt_epi32(v44, v39);
v47 = _mm_or_si128(_mm_andnot_si128(v46, v39), _mm_and_si128(v44, v46));
v48 = _mm_srli_si128(v47, 4);
v49 = _mm_cmpgt_epi32(v48, v47);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v49, v47), _mm_and_si128(v48, v49)));
if ( (v6 & 3) != 0 )
{
v51 = (int *)&v4[v45];
if ( (int)result < *v51 )
result = (unsigned int)*v51;
if ( (int)((v6 & 0xFFFFFFFC) + 2) < a2 )
goto LABEL_22;
}
}
return result;
} | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R15
MOV RDX,RAX
LEA RAX,[RAX + RAX*0x4]
PUSH R14
LEA R11,[RAX + RAX*0x4]
PUSH R13
SHL R11,0x4
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[RDI + R11*0x1 + -0x190]
CMP EDX,0x1
JLE 0x001015d5
MOV EAX,dword ptr [RDI]
ADD dword ptr [RDI + 0x194],EAX
ADD dword ptr [RDI + 0x190],EAX
CMP EDX,0x2
JZ 0x001015f9
LEA R10D,[RDX + -0x1]
LEA RCX,[RDI + 0x320]
MOV R9D,0xc8
MOV R8D,0x1
LEA RSI,[RDI + 0x328]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013a0:
MOV R13D,R8D
MOV EAX,dword ptr [RCX + -0x190]
ADD dword ptr [RCX],EAX
LEA RBP,[RCX + -0x190]
MOV EAX,dword ptr [RSI + -0x194]
ADD dword ptr [RSI],EAX
LEA EAX,[R13 + -0x1]
ADD R8D,0x1
CMP EAX,0x2
JBE 0x001015c8
MOV R14D,R13D
LEA R15,[RCX + -0x18c]
LEA R12,[RCX + 0x4]
XOR EAX,EAX
SHR R14D,0x2
SHL R14,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e8:
MOVDQU XMM0,xmmword ptr [R15 + RAX*0x1]
MOVDQU XMM6,xmmword ptr [RBP + RAX*0x1]
MOVDQU XMM4,xmmword ptr [R12 + RAX*0x1]
MOVDQU XMM2,xmmword ptr [RBP + RAX*0x1]
MOVDQU XMM1,xmmword ptr [R15 + RAX*0x1]
PCMPGTD XMM0,XMM6
PADDD XMM2,XMM4
PADDD XMM1,XMM4
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVUPS xmmword ptr [R12 + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,R14
JNZ 0x001013e8
MOV R12D,R13D
AND R12D,0xfffffffc
AND R13D,0x3
LEA EAX,[R12 + 0x1]
JZ 0x001014cc
LAB_00101442:
MOV R14D,R8D
SUB R14D,R12D
LEA R13D,[R14 + -0x1]
CMP R14D,0x2
JZ 0x001014a5
ADD R12,R9
SHL R12,0x2
MOVQ XMM2,qword ptr [RDI + R12*0x1 + -0x190]
LEA R14,[RDI + R12*0x1 + 0x4]
MOVQ XMM0,qword ptr [RDI + R12*0x1 + -0x18c]
MOVQ XMM1,qword ptr [R14]
MOVDQA XMM3,XMM2
PADDD XMM3,XMM1
PADDD XMM1,XMM0
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM3
POR XMM0,XMM1
MOVQ qword ptr [R14],XMM0
TEST R13B,0x1
JZ 0x001014cc
AND R13D,0xfffffffe
ADD EAX,R13D
LAB_001014a5:
CDQE
SHL RAX,0x2
ADD RBP,RAX
ADD RAX,RCX
MOV R12D,dword ptr [RBP + -0x4]
MOV R13D,dword ptr [RBP]
MOV EBP,dword ptr [RAX]
LEA R14D,[R13 + RBP*0x1]
ADD EBP,R12D
CMP R12D,R13D
CMOVL EBP,R14D
MOV dword ptr [RAX],EBP
LAB_001014cc:
ADD RCX,0x190
ADD R9,0x64
ADD RSI,0x194
CMP R10D,R8D
JNZ 0x001013a0
LEA EAX,[RDX + -0x2]
MOVD XMM0,dword ptr [RBX]
CMP EAX,0x2
JBE 0x001015e2
MOV ECX,R10D
LEA RAX,[RDI + R11*0x1 + -0x18c]
PSHUFD XMM0,XMM0,0x0
SHR ECX,0x2
SHL RCX,0x4
ADD RCX,RAX
NOP dword ptr [RAX]
LAB_00101518:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM2,XMM1
PCMPGTD XMM2,XMM0
PAND XMM1,XMM2
PANDN XMM2,XMM0
POR XMM2,XMM1
MOVDQA XMM0,XMM2
CMP RCX,RAX
JNZ 0x00101518
MOVDQA XMM2,XMM0
MOV ECX,R10D
PSRLDQ XMM2,0x8
AND ECX,0xfffffffc
AND R10D,0x3
MOVDQA XMM1,XMM2
LEA ESI,[RCX + 0x1]
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
JZ 0x001015b9
MOVSXD RDI,ESI
LEA RDI,[RBX + RDI*0x4]
MOV R8D,dword ptr [RDI]
CMP EAX,R8D
CMOVL EAX,R8D
ADD ECX,0x2
CMP ECX,EDX
JGE 0x001015b9
LAB_001015a2:
MOV ECX,dword ptr [RDI + 0x4]
CMP EAX,ECX
CMOVL EAX,ECX
ADD ESI,0x2
CMP ESI,EDX
JGE 0x001015b9
MOV EDX,dword ptr [RDI + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_001015b9:
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015c8:
XOR R12D,R12D
MOV EAX,0x1
JMP 0x00101442
LAB_001015d5:
MOV EAX,dword ptr [RBX]
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015e2:
MOV EAX,dword ptr [RBX + 0x4]
LEA RDI,[RBX + 0x4]
MOVD EBX,XMM0
MOV ESI,0x1
CMP EBX,EAX
CMOVGE EAX,EBX
JMP 0x001015a2
LAB_001015f9:
MOV EAX,dword ptr [RBX + 0x4]
MOV EDX,dword ptr [RBX]
CMP EAX,EDX
CMOVL EAX,EDX
JMP 0x001015b9 | uint func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint *puVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
uint uVar15;
uint *puVar16;
uint *puVar17;
uint *puVar18;
int iVar19;
long lVar20;
uint *puVar21;
int *piVar22;
uint *puVar23;
int *piVar24;
uint uVar25;
long lVar26;
uint uVar27;
ulong uVar28;
int iVar29;
int iVar30;
uint uVar31;
int iVar32;
int iVar33;
int iVar34;
uint uVar35;
uint uVar36;
uint uVar37;
uint uVar38;
uint uVar39;
uint uVar40;
int iVar41;
puVar6 = (uint *)(param_1 + (long)param_2 * 100 + -100);
if (param_2 < 2) {
return *puVar6;
}
param_1[0x65] = param_1[0x65] + *param_1;
param_1[100] = param_1[100] + *param_1;
if (param_2 == 2) {
if ((int)*puVar6 <= (int)puVar6[1]) {
return puVar6[1];
}
return *puVar6;
}
uVar27 = param_2 - 1;
piVar22 = param_1 + 200;
lVar26 = 200;
piVar24 = param_1 + 0xca;
uVar31 = 1;
do {
*piVar22 = *piVar22 + piVar22[-100];
*piVar24 = *piVar24 + piVar24[-0x65];
uVar25 = uVar31 + 1;
if (uVar31 - 1 < 3) {
uVar28 = 0;
iVar19 = 1;
LAB_00101442:
iVar29 = uVar25 - (int)uVar28;
uVar31 = iVar29 - 1;
if (iVar29 != 2) {
lVar20 = uVar28 + lVar26;
uVar28 = *(ulong *)(param_1 + lVar20 + 1);
iVar33 = (int)uVar28;
iVar41 = (int)*(int8 *)(param_1 + lVar20 + -100);
iVar29 = (int)((ulong)*(int8 *)(param_1 + lVar20 + -100) >> 0x20);
iVar34 = (int)(uVar28 >> 0x20);
iVar30 = (int)*(int8 *)(param_1 + lVar20 + -99);
iVar32 = (int)((ulong)*(int8 *)(param_1 + lVar20 + -99) >> 0x20);
uVar28 = CONCAT44(-(uint)(iVar29 < iVar32),-(uint)(iVar41 < iVar30));
*(ulong *)(param_1 + lVar20 + 1) =
~uVar28 & CONCAT44(iVar29 + iVar34,iVar41 + iVar33) |
CONCAT44(iVar34 + iVar32,iVar33 + iVar30) & uVar28;
if ((uVar31 & 1) == 0) goto LAB_001014cc;
iVar19 = iVar19 + (uVar31 & 0xfffffffe);
}
iVar30 = (piVar22 + (long)iVar19 + -100)[-1];
iVar29 = piVar22[(long)iVar19 + -100];
if (iVar30 < iVar29) {
iVar30 = iVar29;
}
piVar22[iVar19] = piVar22[iVar19] + iVar30;
}
else {
lVar20 = 0;
do {
piVar1 = (int *)((long)piVar22 + lVar20 + -0x18c);
iVar19 = piVar1[1];
iVar29 = piVar1[2];
iVar30 = piVar1[3];
piVar4 = (int *)((long)piVar22 + lVar20 + -400);
iVar32 = piVar4[1];
iVar33 = piVar4[2];
iVar34 = piVar4[3];
piVar2 = (int *)((long)piVar22 + lVar20 + 4);
iVar41 = piVar2[1];
iVar7 = piVar2[2];
iVar8 = piVar2[3];
piVar5 = (int *)((long)piVar22 + lVar20 + -400);
iVar9 = piVar5[1];
iVar10 = piVar5[2];
iVar11 = piVar5[3];
piVar3 = (int *)((long)piVar22 + lVar20 + -0x18c);
iVar12 = piVar3[1];
iVar13 = piVar3[2];
iVar14 = piVar3[3];
puVar21 = (uint *)((long)piVar22 + lVar20 + 4);
*puVar21 = ~-(uint)(*piVar4 < *piVar1) & *piVar5 + *piVar2 |
*piVar3 + *piVar2 & -(uint)(*piVar4 < *piVar1);
puVar21[1] = ~-(uint)(iVar32 < iVar19) & iVar9 + iVar41 |
iVar12 + iVar41 & -(uint)(iVar32 < iVar19);
puVar21[2] = ~-(uint)(iVar33 < iVar29) & iVar10 + iVar7 |
iVar13 + iVar7 & -(uint)(iVar33 < iVar29);
puVar21[3] = ~-(uint)(iVar34 < iVar30) & iVar11 + iVar8 |
iVar14 + iVar8 & -(uint)(iVar34 < iVar30);
lVar20 = lVar20 + 0x10;
} while (lVar20 != (ulong)(uVar31 >> 2) << 4);
uVar28 = (ulong)(uVar31 & 0xfffffffc);
iVar19 = (uVar31 & 0xfffffffc) + 1;
if ((uVar31 & 3) != 0) goto LAB_00101442;
}
LAB_001014cc:
piVar22 = piVar22 + 100;
lVar26 = lVar26 + 100;
piVar24 = piVar24 + 0x65;
uVar31 = uVar25;
if (uVar27 == uVar25) {
uVar31 = *puVar6;
if (param_2 - 2U < 3) {
puVar21 = puVar6 + 1;
iVar19 = 1;
uVar25 = puVar6[1];
if ((int)puVar6[1] <= (int)uVar31) {
uVar25 = uVar31;
}
}
else {
puVar21 = (uint *)(param_1 + (long)param_2 * 100 + -99);
puVar23 = puVar21 + (ulong)(uVar27 >> 2) * 4;
uVar25 = uVar31;
uVar38 = uVar31;
uVar40 = uVar31;
do {
uVar15 = *puVar21;
puVar16 = puVar21 + 1;
puVar17 = puVar21 + 2;
puVar18 = puVar21 + 3;
puVar21 = puVar21 + 4;
uVar35 = -(uint)((int)uVar31 < (int)uVar15);
uVar36 = -(uint)((int)uVar25 < (int)*puVar16);
uVar37 = -(uint)((int)uVar38 < (int)*puVar17);
uVar39 = -(uint)((int)uVar40 < (int)*puVar18);
uVar31 = ~uVar35 & uVar31 | uVar15 & uVar35;
uVar25 = ~uVar36 & uVar25 | *puVar16 & uVar36;
uVar38 = ~uVar37 & uVar38 | *puVar17 & uVar37;
uVar40 = ~uVar39 & uVar40 | *puVar18 & uVar39;
} while (puVar23 != puVar21);
iVar19 = (uVar27 & 0xfffffffc) + 1;
uVar38 = ~-(uint)((int)uVar31 < (int)uVar38) & uVar31 |
uVar38 & -(uint)((int)uVar31 < (int)uVar38);
uVar25 = ~-(uint)((int)uVar25 < (int)uVar40) & uVar25 |
uVar40 & -(uint)((int)uVar25 < (int)uVar40);
uVar31 = -(uint)((int)uVar38 < (int)uVar25);
uVar25 = ~uVar31 & uVar38 | uVar25 & uVar31;
if ((uVar27 & 3) == 0) {
return uVar25;
}
puVar21 = puVar6 + iVar19;
if ((int)uVar25 < (int)*puVar21) {
uVar25 = *puVar21;
}
if (param_2 <= (int)((uVar27 & 0xfffffffc) + 2)) {
return uVar25;
}
}
if ((int)uVar25 < (int)puVar21[1]) {
uVar25 = puVar21[1];
}
if ((iVar19 + 2 < param_2) && ((int)uVar25 < (int)puVar21[2])) {
uVar25 = puVar21[2];
}
return uVar25;
}
} while( true );
} |
4,820 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *list1, int size, int n, int *result) {
int i, j, max_idx, temp;
// Make a copy of the array
int *copy = (int *)malloc(size * sizeof(int));
for (i = 0; i < size; i++) {
copy[i] = list1[i];
}
// Selection sort to find n largest elements
for (i = 0; i < n; i++) {
max_idx = i;
for (j = i+1; j < size; j++) {
if (copy[j] > copy[max_idx]) {
max_idx = j;
}
}
// Swap
temp = copy[max_idx];
copy[max_idx] = copy[i];
copy[i] = temp;
result[i] = copy[i];
}
free(copy);
}
| int main() {
int list1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size = sizeof(list1) / sizeof(list1[0]);
int result[5];
func0(list1, size, 2, result);
assert(result[0] == 100 && result[1] == 90);
func0(list1, size, 5, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80 && result[3] == 70 && result[4] == 60);
func0(list1, size, 3, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
jmp 1212 <func0+0x69>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11e1 <func0+0x38>
movl $0x0,-0x18(%rbp)
jmpq 1309 <func0+0x160>
mov -0x18(%rbp),%eax
mov %eax,-0x10(%rbp)
mov -0x18(%rbp),%eax
add $0x1,%eax
mov %eax,-0x14(%rbp)
jmp 1271 <func0+0xc8>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 126d <func0+0xc4>
mov -0x14(%rbp),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1237 <func0+0x8e>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1226 <func0+0x7d>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_18], 0
jmp short loc_1212
loc_11E1:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_18]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_18], 1
loc_1212:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_11E1
mov [rbp+var_18], 0
jmp loc_1309
loc_1226:
mov eax, [rbp+var_18]
mov [rbp+var_10], eax
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_1271
loc_1237:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_126D
mov eax, [rbp+var_14]
mov [rbp+var_10], eax
loc_126D:
add [rbp+var_14], 1
loc_1271:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_1237
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_18]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_38]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_18], 1
loc_1309:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_30]
jl loc_1226
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
nop
leave
retn | void func0(long long a1, int a2, int a3, long long a4)
{
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+28h] [rbp-18h]
int k; // [rsp+2Ch] [rbp-14h]
int v9; // [rsp+30h] [rbp-10h]
int v10; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38h] [rbp-8h]
ptr = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
ptr[i] = *(_DWORD *)(4LL * i + a1);
for ( j = 0; j < a3; ++j )
{
v9 = j;
for ( k = j + 1; k < a2; ++k )
{
if ( ptr[k] > ptr[v9] )
v9 = k;
}
v10 = ptr[v9];
ptr[v9] = ptr[j];
ptr[j] = v10;
*(_DWORD *)(4LL * j + a4) = ptr[j];
}
free(ptr);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101212
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x18],0x1
LAB_00101212:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011e1
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101309
LAB_00101226:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00101271
LAB_00101237:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010126d
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x10],EAX
LAB_0010126d:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101271:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101237
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x18],0x1
LAB_00101309:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101226
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101080
NOP
LEAVE
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
int4 uVar1;
void *__ptr;
int4 local_20;
int4 local_1c;
int4 local_18;
__ptr = malloc((long)param_2 << 2);
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
*(int4 *)((long)__ptr + (long)local_20 * 4) =
*(int4 *)(param_1 + (long)local_20 * 4);
}
for (local_20 = 0; local_20 < param_3; local_20 = local_20 + 1) {
local_18 = local_20;
local_1c = local_20;
while (local_1c = local_1c + 1, local_1c < param_2) {
if (*(int *)((long)__ptr + (long)local_18 * 4) < *(int *)((long)__ptr + (long)local_1c * 4)) {
local_18 = local_1c;
}
}
uVar1 = *(int4 *)((long)__ptr + (long)local_18 * 4);
*(int4 *)((long)__ptr + (long)local_18 * 4) =
*(int4 *)((long)__ptr + (long)local_20 * 4);
*(int4 *)((long)local_20 * 4 + (long)__ptr) = uVar1;
*(int4 *)(param_4 + (long)local_20 * 4) =
*(int4 *)((long)__ptr + (long)local_20 * 4);
}
free(__ptr);
return;
} |
4,821 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *list1, int size, int n, int *result) {
int i, j, max_idx, temp;
// Make a copy of the array
int *copy = (int *)malloc(size * sizeof(int));
for (i = 0; i < size; i++) {
copy[i] = list1[i];
}
// Selection sort to find n largest elements
for (i = 0; i < n; i++) {
max_idx = i;
for (j = i+1; j < size; j++) {
if (copy[j] > copy[max_idx]) {
max_idx = j;
}
}
// Swap
temp = copy[max_idx];
copy[max_idx] = copy[i];
copy[i] = temp;
result[i] = copy[i];
}
free(copy);
}
| int main() {
int list1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size = sizeof(list1) / sizeof(list1[0]);
int result[5];
func0(list1, size, 2, result);
assert(result[0] == 100 && result[1] == 90);
func0(list1, size, 5, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80 && result[3] == 70 && result[4] == 60);
func0(list1, size, 3, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %edx,%r13d
mov %rcx,%rbp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 11f0 <func0+0x47>
lea -0x1(%rbx),%ecx
mov $0x0,%eax
mov (%r12,%rax,4),%edx
mov %edx,(%rdi,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 11dd <func0+0x34>
test %r13d,%r13d
jle 1244 <func0+0x9b>
lea -0x1(%r13),%r8d
add $0x2,%r8
mov $0x1,%esi
jmp 1224 <func0+0x7b>
movslq %ecx,%rcx
lea (%rdi,%rcx,4),%rdx
mov (%rdx),%eax
mov -0x4(%rdi,%rsi,4),%ecx
mov %ecx,(%rdx)
mov %eax,-0x4(%rdi,%rsi,4)
mov %eax,-0x4(%rbp,%rsi,4)
add $0x1,%rsi
cmp %r8,%rsi
je 1244 <func0+0x9b>
lea -0x1(%rsi),%ecx
cmp %esi,%ebx
jle 1204 <func0+0x5b>
mov %rsi,%rdx
movslq %ecx,%rax
mov (%rdi,%rax,4),%eax
cmp %eax,(%rdi,%rdx,4)
cmovg %edx,%ecx
add $0x1,%rdx
cmp %edx,%ebx
jg 122e <func0+0x85>
jmp 1204 <func0+0x5b>
callq 1080 <free@plt>
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 r12, rdi
mov ebx, esi
mov r13d, edx
mov rbp, rcx
movsxd rdi, esi
shl rdi, 2
call _malloc
mov rdi, rax
test ebx, ebx
jle short loc_11EC
mov ecx, ebx
mov eax, 0
loc_11DC:
mov edx, [r12+rax*4]
mov [rdi+rax*4], edx
add rax, 1
cmp rax, rcx
jnz short loc_11DC
loc_11EC:
test r13d, r13d
jle short loc_1238
lea r8d, [r13+1]
mov esi, 1
loc_11FA:
lea edx, [rsi-1]
cmp ebx, esi
jle short loc_1218
mov rax, rsi
loc_1204:
movsxd rcx, edx
mov ecx, [rdi+rcx*4]
cmp [rdi+rax*4], ecx
cmovg edx, eax
add rax, 1
cmp ebx, eax
jg short loc_1204
loc_1218:
movsxd rdx, edx
lea rdx, [rdi+rdx*4]
mov eax, [rdx]
mov ecx, [rdi+rsi*4-4]
mov [rdx], ecx
mov [rdi+rsi*4-4], eax
mov [rbp+rsi*4-4], eax
add rsi, 1
cmp rsi, r8
jnz short loc_11FA
loc_1238:
call _free
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long v8; // rdi
long long i; // rax
long long v10; // rsi
int v11; // edx
long long v12; // rax
int *v13; // rdx
int v14; // eax
v8 = malloc(4LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(v8 + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
if ( a3 > 0 )
{
v10 = 1LL;
do
{
v11 = v10 - 1;
if ( a2 > (int)v10 )
{
v12 = v10;
do
{
if ( *(_DWORD *)(v8 + 4 * v12) > *(_DWORD *)(v8 + 4LL * v11) )
v11 = v12;
++v12;
}
while ( a2 > (int)v12 );
}
v13 = (int *)(v8 + 4LL * v11);
v14 = *v13;
*v13 = *(_DWORD *)(v8 + 4 * v10 - 4);
*(_DWORD *)(v8 + 4 * v10 - 4) = v14;
*(_DWORD *)(a4 + 4 * v10++ - 4) = v14;
}
while ( v10 != a3 + 1 );
}
return free(v8);
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV EBX,ESI
MOV R13D,EDX
MOV RBP,RCX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x001011ec
MOV ECX,EBX
MOV EAX,0x0
LAB_001011dc:
MOV EDX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x001011dc
LAB_001011ec:
TEST R13D,R13D
JLE 0x00101238
LEA R8D,[R13 + 0x1]
MOV ESI,0x1
LAB_001011fa:
LEA EDX,[RSI + -0x1]
CMP EBX,ESI
JLE 0x00101218
MOV RAX,RSI
LAB_00101204:
MOVSXD RCX,EDX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
CMOVG EDX,EAX
ADD RAX,0x1
CMP EBX,EAX
JG 0x00101204
LAB_00101218:
MOVSXD RDX,EDX
LEA RDX,[RDI + RDX*0x4]
MOV EAX,dword ptr [RDX]
MOV ECX,dword ptr [RDI + RSI*0x4 + -0x4]
MOV dword ptr [RDX],ECX
MOV dword ptr [RDI + RSI*0x4 + -0x4],EAX
MOV dword ptr [RBP + RSI*0x4 + -0x4],EAX
ADD RSI,0x1
CMP RSI,R8
JNZ 0x001011fa
LAB_00101238:
CALL 0x00101080
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(long param_1,uint param_2,int param_3,long param_4)
{
int4 *puVar1;
int4 uVar2;
int iVar3;
void *__ptr;
ulong uVar4;
ulong uVar5;
int iVar6;
__ptr = malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
uVar4 = 0;
do {
*(int4 *)((long)__ptr + uVar4 * 4) = *(int4 *)(param_1 + uVar4 * 4);
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
if (0 < param_3) {
uVar4 = 1;
do {
iVar3 = (int)uVar4;
iVar6 = iVar3 + -1;
uVar5 = uVar4;
while (iVar3 < (int)param_2) {
if (*(int *)((long)__ptr + (long)iVar6 * 4) < *(int *)((long)__ptr + uVar5 * 4)) {
iVar6 = (int)uVar5;
}
uVar5 = uVar5 + 1;
iVar3 = (int)uVar5;
}
puVar1 = (int4 *)((long)__ptr + (long)iVar6 * 4);
uVar2 = *puVar1;
*puVar1 = *(int4 *)((long)__ptr + uVar4 * 4 + -4);
*(int4 *)((long)__ptr + uVar4 * 4 + -4) = uVar2;
*(int4 *)(param_4 + -4 + uVar4 * 4) = uVar2;
uVar4 = uVar4 + 1;
} while (uVar4 != param_3 + 1);
}
free(__ptr);
return;
} |
4,822 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *list1, int size, int n, int *result) {
int i, j, max_idx, temp;
// Make a copy of the array
int *copy = (int *)malloc(size * sizeof(int));
for (i = 0; i < size; i++) {
copy[i] = list1[i];
}
// Selection sort to find n largest elements
for (i = 0; i < n; i++) {
max_idx = i;
for (j = i+1; j < size; j++) {
if (copy[j] > copy[max_idx]) {
max_idx = j;
}
}
// Swap
temp = copy[max_idx];
copy[max_idx] = copy[i];
copy[i] = temp;
result[i] = copy[i];
}
free(copy);
}
| int main() {
int list1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size = sizeof(list1) / sizeof(list1[0]);
int result[5];
func0(list1, size, 2, result);
assert(result[0] == 100 && result[1] == 90);
func0(list1, size, 5, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80 && result[3] == 70 && result[4] == 60);
func0(list1, size, 3, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rcx,%r13
push %r12
mov %edx,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
lea -0x1(%rbx),%ecx
mov %rax,%rbp
xor %eax,%eax
test %ebx,%ebx
jle 1374 <func0+0x44>
mov (%r14,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rcx
jne 1360 <func0+0x30>
mov %rbp,%rax
mov %r13,%rdx
xor %r11d,%r11d
test %r12d,%r12d
jle 13f4 <func0+0xc4>
nopw 0x0(%rax,%rax,1)
mov %r11d,%esi
add $0x1,%r11d
mov (%rax),%r13d
cmp %r11d,%ebx
jle 1408 <func0+0xd8>
lea 0x4(%rax),%r14
mov %r13d,%r9d
mov %r11d,%edi
mov %r14,%rcx
jmp 13c3 <func0+0x93>
nopw %cs:0x0(%rax,%rax,1)
movslq %esi,%r8
add $0x1,%edi
add $0x4,%rcx
lea 0x0(%rbp,%r8,4),%r10
cmp %edi,%ebx
je 13de <func0+0xae>
mov (%rcx),%r8d
mov %rcx,%r10
cmp %r9d,%r8d
jle 13b0 <func0+0x80>
mov %edi,%esi
add $0x1,%edi
mov %r8d,%r9d
add $0x4,%rcx
cmp %edi,%ebx
jne 13c3 <func0+0x93>
mov %r13d,(%r10)
add $0x4,%rdx
mov %r9d,(%rax)
mov %r14,%rax
mov %r9d,-0x4(%rdx)
cmp %r11d,%r12d
jne 1388 <func0+0x58>
pop %rbx
mov %rbp,%rdi
pop %rbp
pop %r12
pop %r13
pop %r14
jmpq 1080 <free@plt>
nopl 0x0(%rax)
mov %r13d,%r9d
mov %rax,%r10
lea 0x4(%rax),%r14
jmp 13de <func0+0xae>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
mov r12, rcx
push rbp
mov ebp, edx
push rbx
mov rbx, r13
shl r13, 2
mov rdi, r13
call _malloc
mov r10, rax
test ebx, ebx
jle short loc_138E
mov rdx, r13
mov rsi, r14
mov rdi, rax
call _memcpy
mov r10, rax
loc_138E:
mov r11, r10
xor r9d, r9d
test ebp, ebp
jle short loc_1402
nop dword ptr [rax+rax+00000000h]
loc_13A0:
mov r8d, r9d
add r9d, 1
mov r13d, [r11]
cmp ebx, r9d
jle short loc_1418
lea r14, [r11+4]
mov esi, r13d
mov edx, r9d
mov rax, r14
jmp short loc_13D2
loc_13C0:
movsxd rcx, r8d
add edx, 1
add rax, 4
lea rdi, [r10+rcx*4]
cmp ebx, edx
jz short loc_13EB
loc_13D2:
mov ecx, [rax]
mov rdi, rax
cmp ecx, esi
jle short loc_13C0
mov r8d, edx
add edx, 1
mov esi, ecx
add rax, 4
cmp ebx, edx
jnz short loc_13D2
loc_13EB:
mov [rdi], r13d
add r12, 4
mov [r11], esi
mov r11, r14
mov [r12-4], esi
cmp ebp, r9d
jnz short loc_13A0
loc_1402:
pop rbx
mov rdi, r10
pop rbp
pop r12
pop r13
pop r14
jmp _free
loc_1418:
mov esi, r13d
mov rdi, r11
lea r14, [r11+4]
jmp short loc_13EB | long long func0(long long a1, long long a2, int a3, long long a4)
{
int v6; // ebx
long long v7; // rax
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r10
long long v12; // rdx
unsigned int *v13; // r11
long long v14; // r9
unsigned int v15; // r13d
unsigned int *v16; // r14
unsigned int *v17; // rax
unsigned int *v18; // rdi
v6 = a2;
v7 = malloc(4LL * (int)a2);
v11 = v7;
if ( (int)a2 > 0 )
{
v12 = 4LL * (int)a2;
a2 = a1;
v11 = memcpy(v7, a1, v12);
}
v13 = (unsigned int *)v11;
v14 = 0LL;
if ( a3 > 0 )
{
do
{
v10 = (unsigned int)v14;
v14 = (unsigned int)(v14 + 1);
v15 = *v13;
if ( v6 <= (int)v14 )
{
a2 = v15;
v18 = v13;
v16 = v13 + 1;
}
else
{
v16 = v13 + 1;
a2 = v15;
LODWORD(v8) = v14;
v17 = v13 + 1;
do
{
while ( 1 )
{
v9 = *v17;
v18 = v17;
if ( (int)v9 > (int)a2 )
break;
v9 = (int)v10;
v8 = (unsigned int)(v8 + 1);
++v17;
v18 = (unsigned int *)(v11 + 4LL * (int)v10);
if ( v6 == (_DWORD)v8 )
goto LABEL_9;
}
v10 = (unsigned int)v8;
v8 = (unsigned int)(v8 + 1);
a2 = (unsigned int)v9;
++v17;
}
while ( v6 != (_DWORD)v8 );
}
LABEL_9:
*v18 = v15;
a4 += 4LL;
*v13 = a2;
v13 = v16;
*(_DWORD *)(a4 - 4) = a2;
}
while ( a3 != (_DWORD)v14 );
}
return free(v11, a2, v8, v9, v10, v14);
} | func0:
ENDBR64
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R12,RCX
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,R13
SHL R13,0x2
MOV RDI,R13
CALL 0x001010d0
MOV R10,RAX
TEST EBX,EBX
JLE 0x0010138e
MOV RDX,R13
MOV RSI,R14
MOV RDI,RAX
CALL 0x001010c0
MOV R10,RAX
LAB_0010138e:
MOV R11,R10
XOR R9D,R9D
TEST EBP,EBP
JLE 0x00101402
NOP dword ptr [RAX + RAX*0x1]
LAB_001013a0:
MOV R8D,R9D
ADD R9D,0x1
MOV R13D,dword ptr [R11]
CMP EBX,R9D
JLE 0x00101418
LEA R14,[R11 + 0x4]
MOV ESI,R13D
MOV EDX,R9D
MOV RAX,R14
JMP 0x001013d2
LAB_001013c0:
MOVSXD RCX,R8D
ADD EDX,0x1
ADD RAX,0x4
LEA RDI,[R10 + RCX*0x4]
CMP EBX,EDX
JZ 0x001013eb
LAB_001013d2:
MOV ECX,dword ptr [RAX]
MOV RDI,RAX
CMP ECX,ESI
JLE 0x001013c0
MOV R8D,EDX
ADD EDX,0x1
MOV ESI,ECX
ADD RAX,0x4
CMP EBX,EDX
JNZ 0x001013d2
LAB_001013eb:
MOV dword ptr [RDI],R13D
ADD R12,0x4
MOV dword ptr [R11],ESI
MOV R11,R14
MOV dword ptr [R12 + -0x4],ESI
CMP EBP,R9D
JNZ 0x001013a0
LAB_00101402:
POP RBX
MOV RDI,R10
POP RBP
POP R12
POP R13
POP R14
JMP 0x00101090
LAB_00101418:
MOV ESI,R13D
MOV RDI,R11
LEA R14,[R11 + 0x4]
JMP 0x001013eb | void func0(void *param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
int *piVar2;
int *__dest;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int *piVar7;
int iVar8;
int iVar9;
int *piVar10;
__dest = (int *)malloc((long)param_2 << 2);
if (0 < param_2) {
__dest = (int *)memcpy(__dest,param_1,(long)param_2 << 2);
}
iVar8 = 0;
piVar10 = __dest;
if (0 < param_3) {
do {
iVar9 = iVar8 + 1;
iVar1 = *piVar10;
piVar7 = piVar10;
iVar6 = iVar1;
if (iVar9 < param_2) {
piVar2 = piVar10 + 1;
iVar5 = iVar1;
iVar3 = iVar9;
do {
while (piVar7 = piVar2, iVar6 = *piVar7, iVar6 <= iVar5) {
iVar3 = iVar3 + 1;
piVar2 = piVar7 + 1;
piVar7 = __dest + iVar8;
iVar6 = iVar5;
if (param_2 == iVar3) goto LAB_001013eb;
}
iVar4 = iVar3 + 1;
piVar2 = piVar7 + 1;
iVar8 = iVar3;
iVar5 = iVar6;
iVar3 = iVar4;
} while (param_2 != iVar4);
}
LAB_001013eb:
*piVar7 = iVar1;
*piVar10 = iVar6;
*param_4 = iVar6;
piVar10 = piVar10 + 1;
param_4 = param_4 + 1;
iVar8 = iVar9;
} while (param_3 != iVar9);
}
free(__dest);
return;
} |
4,823 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *list1, int size, int n, int *result) {
int i, j, max_idx, temp;
// Make a copy of the array
int *copy = (int *)malloc(size * sizeof(int));
for (i = 0; i < size; i++) {
copy[i] = list1[i];
}
// Selection sort to find n largest elements
for (i = 0; i < n; i++) {
max_idx = i;
for (j = i+1; j < size; j++) {
if (copy[j] > copy[max_idx]) {
max_idx = j;
}
}
// Swap
temp = copy[max_idx];
copy[max_idx] = copy[i];
copy[i] = temp;
result[i] = copy[i];
}
free(copy);
}
| int main() {
int list1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size = sizeof(list1) / sizeof(list1[0]);
int result[5];
func0(list1, size, 2, result);
assert(result[0] == 100 && result[1] == 90);
func0(list1, size, 5, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80 && result[3] == 70 && result[4] == 60);
func0(list1, size, 3, result);
assert(result[0] == 100 && result[1] == 90 && result[2] == 80);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
mov %rdi,%r13
movslq %esi,%rdi
push %r12
mov %rcx,%r12
push %rbp
mov %edx,%ebp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r10
test %ebx,%ebx
jle 1373 <func0+0x43>
lea -0x1(%rbx),%eax
mov %r10,%rdi
mov %r13,%rsi
lea 0x4(,%rax,4),%rdx
callq 10c0 <memcpy@plt>
mov %rax,%r10
mov %r10,%r11
xor %r9d,%r9d
test %ebp,%ebp
jle 13e2 <func0+0xb2>
nopl (%rax)
mov %r9d,%r8d
add $0x1,%r9d
mov (%r11),%r13d
cmp %r9d,%ebx
jle 13f8 <func0+0xc8>
lea 0x4(%r11),%r14
mov %r13d,%esi
mov %r9d,%edx
mov %r14,%rax
jmp 13b2 <func0+0x82>
xchg %ax,%ax
movslq %r8d,%rcx
add $0x1,%edx
add $0x4,%rax
lea (%r10,%rcx,4),%rdi
cmp %edx,%ebx
je 13cb <func0+0x9b>
mov (%rax),%ecx
mov %rax,%rdi
cmp %ecx,%esi
jge 13a0 <func0+0x70>
mov %edx,%r8d
add $0x1,%edx
mov %ecx,%esi
add $0x4,%rax
cmp %edx,%ebx
jne 13b2 <func0+0x82>
mov %r13d,(%rdi)
add $0x4,%r12
mov %esi,(%r11)
mov %r14,%r11
mov %esi,-0x4(%r12)
cmp %r9d,%ebp
jne 1380 <func0+0x50>
pop %rbx
mov %r10,%rdi
pop %rbp
pop %r12
pop %r13
pop %r14
jmpq 1090 <free@plt>
nopw 0x0(%rax,%rax,1)
mov %r13d,%esi
mov %r11,%rdi
lea 0x4(%r11),%r14
jmp 13cb <func0+0x9b>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r14
push r13
mov r13, rdi
movsxd rdi, esi
push r12
mov r12, rcx
push rbp
mov ebp, edx
push rbx
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov r10, rax
test ebx, ebx
jle short loc_136E
mov edx, ebx
mov rsi, r13; src
mov rdi, rax; dest
shl rdx, 2; n
call _memcpy
mov r10, rax
loc_136E:
mov r11, r10
xor r9d, r9d
test ebp, ebp
jle short loc_13E2
nop dword ptr [rax+rax+00000000h]
loc_1380:
mov r8d, r9d
add r9d, 1
mov r13d, [r11]
cmp ebx, r9d
jle short loc_13F8
lea r14, [r11+4]
mov esi, r13d
mov edx, r9d
mov rax, r14
jmp short loc_13B2
loc_13A0:
movsxd rcx, r8d
add edx, 1
add rax, 4
lea rdi, [r10+rcx*4]
cmp ebx, edx
jz short loc_13CB
loc_13B2:
mov ecx, [rax]
mov rdi, rax
cmp esi, ecx
jge short loc_13A0
mov r8d, edx
add edx, 1
mov esi, ecx
add rax, 4
cmp ebx, edx
jnz short loc_13B2
loc_13CB:
mov [rdi], r13d
add r12, 4
mov [r11], esi
mov r11, r14
mov [r12-4], esi
cmp ebp, r9d
jnz short loc_1380
loc_13E2:
pop rbx
mov rdi, r10; ptr
pop rbp
pop r12
pop r13
pop r14
jmp _free
loc_13F8:
mov esi, r13d
mov rdi, r11
lea r14, [r11+4]
jmp short loc_13CB | void func0(void *src, int a2, int a3, long long a4)
{
int *v7; // rax
int *v8; // r10
int *v9; // r11
int v10; // r9d
int v11; // r8d
int *v12; // r14
int v13; // esi
int v14; // edx
int *v15; // rax
int *v16; // rdi
v7 = (int *)malloc(4LL * a2);
v8 = v7;
if ( a2 > 0 )
v8 = (int *)memcpy(v7, src, 4LL * (unsigned int)a2);
v9 = v8;
v10 = 0;
if ( a3 > 0 )
{
do
{
v11 = v10++;
if ( a2 <= v10 )
{
v13 = *v9;
v16 = v9;
v12 = v9 + 1;
}
else
{
v12 = v9 + 1;
v13 = *v9;
v14 = v10;
v15 = v9 + 1;
do
{
while ( 1 )
{
v16 = v15;
if ( v13 < *v15 )
break;
++v14;
++v15;
v16 = &v8[v11];
if ( a2 == v14 )
goto LABEL_9;
}
v11 = v14++;
v13 = *v15++;
}
while ( a2 != v14 );
}
LABEL_9:
*v16 = *v9;
a4 += 4LL;
*v9 = v13;
v9 = v12;
*(_DWORD *)(a4 - 4) = v13;
}
while ( a3 != v10 );
}
free(v8);
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDI
MOVSXD RDI,ESI
PUSH R12
MOV R12,RCX
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010d0
MOV R10,RAX
TEST EBX,EBX
JLE 0x0010136e
MOV EDX,EBX
MOV RSI,R13
MOV RDI,RAX
SHL RDX,0x2
CALL 0x001010c0
MOV R10,RAX
LAB_0010136e:
MOV R11,R10
XOR R9D,R9D
TEST EBP,EBP
JLE 0x001013e2
NOP dword ptr [RAX + RAX*0x1]
LAB_00101380:
MOV R8D,R9D
ADD R9D,0x1
MOV R13D,dword ptr [R11]
CMP EBX,R9D
JLE 0x001013f8
LEA R14,[R11 + 0x4]
MOV ESI,R13D
MOV EDX,R9D
MOV RAX,R14
JMP 0x001013b2
LAB_001013a0:
MOVSXD RCX,R8D
ADD EDX,0x1
ADD RAX,0x4
LEA RDI,[R10 + RCX*0x4]
CMP EBX,EDX
JZ 0x001013cb
LAB_001013b2:
MOV ECX,dword ptr [RAX]
MOV RDI,RAX
CMP ESI,ECX
JGE 0x001013a0
MOV R8D,EDX
ADD EDX,0x1
MOV ESI,ECX
ADD RAX,0x4
CMP EBX,EDX
JNZ 0x001013b2
LAB_001013cb:
MOV dword ptr [RDI],R13D
ADD R12,0x4
MOV dword ptr [R11],ESI
MOV R11,R14
MOV dword ptr [R12 + -0x4],ESI
CMP EBP,R9D
JNZ 0x00101380
LAB_001013e2:
POP RBX
MOV RDI,R10
POP RBP
POP R12
POP R13
POP R14
JMP 0x00101090
LAB_001013f8:
MOV ESI,R13D
MOV RDI,R11
LEA R14,[R11 + 0x4]
JMP 0x001013cb | void func0(void *param_1,uint param_2,uint param_3,int *param_4)
{
int iVar1;
int *piVar2;
int *__dest;
uint uVar3;
uint uVar4;
int iVar5;
int iVar6;
int *piVar7;
uint uVar8;
uint uVar9;
int *piVar10;
__dest = (int *)malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
__dest = (int *)memcpy(__dest,param_1,(ulong)param_2 << 2);
}
uVar8 = 0;
piVar10 = __dest;
if (0 < (int)param_3) {
do {
uVar9 = uVar8 + 1;
iVar1 = *piVar10;
piVar7 = piVar10;
iVar6 = iVar1;
if ((int)uVar9 < (int)param_2) {
piVar2 = piVar10 + 1;
iVar5 = iVar1;
uVar3 = uVar9;
do {
while (piVar7 = piVar2, iVar6 = *piVar7, iVar6 <= iVar5) {
uVar3 = uVar3 + 1;
piVar2 = piVar7 + 1;
piVar7 = __dest + (int)uVar8;
iVar6 = iVar5;
if (param_2 == uVar3) goto LAB_001013cb;
}
uVar4 = uVar3 + 1;
piVar2 = piVar7 + 1;
uVar8 = uVar3;
iVar5 = iVar6;
uVar3 = uVar4;
} while (param_2 != uVar4);
}
LAB_001013cb:
*piVar7 = iVar1;
*piVar10 = iVar6;
*param_4 = iVar6;
piVar10 = piVar10 + 1;
param_4 = param_4 + 1;
uVar8 = uVar9;
} while (param_3 != uVar9);
}
free(__dest);
return;
} |
4,824 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double lateralsurface = 2 * 3.1415 * r * h;
return lateralsurface;
}
| int main() {
assert(func0(10, 5) == 314.15000000000003);
assert(func0(4, 5) == 125.66000000000001);
assert(func0(4, 10) == 251.32000000000002);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf58(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20A0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_20]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1, double a2)
{
return 6.283 * a1 * a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020a0]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x20]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1,double param_2)
{
return DAT_001020a0 * param_1 * param_2;
} |
4,825 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double lateralsurface = 2 * 3.1415 * r * h;
return lateralsurface;
}
| int main() {
assert(func0(10, 5) == 314.15000000000003);
assert(func0(4, 5) == 125.66000000000001);
assert(func0(4, 10) == 251.32000000000002);
return 0;
}
| O1 | c | func0:
endbr64
mulsd 0xed3(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
return a1 * 6.283 * a2;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * param_2;
} |
4,826 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double lateralsurface = 2 * 3.1415 * r * h;
return lateralsurface;
}
| int main() {
assert(func0(10, 5) == 314.15000000000003);
assert(func0(4, 5) == 125.66000000000001);
assert(func0(4, 10) == 251.32000000000002);
return 0;
}
| O2 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
return a1 * 6.283 * a2;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * param_2;
} |
4,827 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double lateralsurface = 2 * 3.1415 * r * h;
return lateralsurface;
}
| int main() {
assert(func0(10, 5) == 314.15000000000003);
assert(func0(4, 5) == 125.66000000000001);
assert(func0(4, 10) == 251.32000000000002);
return 0;
}
| O3 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
return a1 * 6.283 * a2;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * param_2;
} |
4,828 | func0 |
#include <assert.h>
| double func0(double l) {
double volume = l * l * l;
return volume;
}
| int main() {
assert(func0(3) == 27);
assert(func0(2) == 8);
assert(func0(5) == 125);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm0
mulsd %xmm0,%xmm0
movsd -0x18(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm0, [rbp+var_18]
mulsd xmm0, xmm0
movsd xmm1, [rbp+var_18]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return a1 * a1 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM0,qword ptr [RBP + -0x18]
MULSD XMM0,XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return param_1 * param_1 * param_1;
} |
4,829 | func0 |
#include <assert.h>
| double func0(double l) {
double volume = l * l * l;
return volume;
}
| int main() {
assert(func0(3) == 27);
assert(func0(2) == 8);
assert(func0(5) == 125);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
movapd xmm1, xmm0
mulsd xmm0, xmm0
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return a1 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MULSD XMM0,XMM0
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return param_1 * param_1 * param_1;
} |
4,830 | func0 |
#include <assert.h>
| double func0(double l) {
double volume = l * l * l;
return volume;
}
| int main() {
assert(func0(3) == 27);
assert(func0(2) == 8);
assert(func0(5) == 125);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movapd xmm1, xmm0
mulsd xmm0, xmm0
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return a1 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MULSD XMM0,XMM0
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return param_1 * param_1 * param_1;
} |
4,831 | func0 |
#include <assert.h>
| double func0(double l) {
double volume = l * l * l;
return volume;
}
| int main() {
assert(func0(3) == 27);
assert(func0(2) == 8);
assert(func0(5) == 125);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movapd xmm1, xmm0
mulsd xmm0, xmm0
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return a1 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MULSD XMM0,XMM0
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return param_1 * param_1 * param_1;
} |
4,832 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res |= (1 << count);
}
count++;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 10);
assert(func0(20) == 30);
assert(func0(30) == 30);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1195 <func0+0x4c>
mov -0xc(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 118e <func0+0x45>
mov -0xc(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
or %eax,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
sarl -0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jg 116a <func0+0x21>
mov -0x14(%rbp),%eax
or -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_119B
loc_116A:
mov edx, [rbp+var_C]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_1194
mov eax, [rbp+var_C]
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
or [rbp+var_8], eax
loc_1194:
add [rbp+var_C], 1
sar [rbp+var_4], 1
loc_119B:
cmp [rbp+var_4], 0
jg short loc_116A
mov eax, [rbp+var_14]
or eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
int v2; // [rsp+8h] [rbp-Ch]
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i >>= 1 )
{
if ( v2 % 2 == 1 )
v3 |= 1 << v2;
++v2;
}
return v3 | (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010119b
LAB_0010116a:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x00101194
MOV EAX,dword ptr [RBP + -0xc]
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
OR dword ptr [RBP + -0x8],EAX
LAB_00101194:
ADD dword ptr [RBP + -0xc],0x1
SAR dword ptr [RBP + -0x4],0x1
LAB_0010119b:
CMP dword ptr [RBP + -0x4],0x0
JG 0x0010116a
MOV EAX,dword ptr [RBP + -0x14]
OR EAX,dword ptr [RBP + -0x8]
POP RBP
RET | uint func0(uint param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
local_10 = 0;
for (local_c = param_1; 0 < (int)local_c; local_c = (int)local_c >> 1) {
if (local_14 % 2 == 1) {
local_10 = local_10 | 1 << ((byte)local_14 & 0x1f);
}
local_14 = local_14 + 1;
}
return param_1 | local_10;
} |
4,833 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res |= (1 << count);
}
count++;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 10);
assert(func0(20) == 30);
assert(func0(30) == 30);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%r10d
mov %edi,%esi
mov $0x0,%ecx
mov $0x0,%eax
mov $0x1,%r9d
test %edi,%edi
jle 1193 <func0+0x4a>
add $0x1,%ecx
sar %esi
test %esi,%esi
jle 1193 <func0+0x4a>
mov %ecx,%r8d
shr $0x1f,%r8d
lea (%rcx,%r8,1),%edx
and $0x1,%edx
sub %r8d,%edx
mov %eax,%r8d
mov %r9d,%edi
shl %cl,%edi
or %edi,%eax
cmp $0x1,%edx
cmovne %r8d,%eax
jmp 1166 <func0+0x1d>
or %r10d,%eax
retq
| func0:
endbr64
mov eax, edi
mov r8d, edi
mov ecx, 0
mov esi, 0
mov r11d, 1
test edi, edi
jg short loc_118C
jmp short loc_1197
loc_1168:
mov r9d, ecx
shr r9d, 1Fh
lea edx, [rcx+r9]
and edx, 1
sub edx, r9d
mov r9d, esi
mov r10d, r11d
shl r10d, cl
or esi, r10d
cmp edx, 1
cmovnz esi, r9d
loc_118C:
add ecx, 1
sar r8d, 1
test r8d, r8d
jg short loc_1168
loc_1197:
or eax, esi
retn | long long func0(int a1)
{
int v1; // r8d
int v2; // ecx
int v3; // esi
int v4; // r9d
v1 = a1;
v2 = 0;
v3 = 0;
if ( a1 > 0 )
{
while ( 1 )
{
++v2;
v1 >>= 1;
if ( v1 <= 0 )
break;
v4 = v3;
v3 |= 1 << v2;
if ( v2 % 2 != 1 )
v3 = v4;
}
}
return v3 | (unsigned int)a1;
} | func0:
ENDBR64
MOV EAX,EDI
MOV R8D,EDI
MOV ECX,0x0
MOV ESI,0x0
MOV R11D,0x1
TEST EDI,EDI
JG 0x0010118c
JMP 0x00101197
LAB_00101168:
MOV R9D,ECX
SHR R9D,0x1f
LEA EDX,[RCX + R9*0x1]
AND EDX,0x1
SUB EDX,R9D
MOV R9D,ESI
MOV R10D,R11D
SHL R10D,CL
OR ESI,R10D
CMP EDX,0x1
CMOVNZ ESI,R9D
LAB_0010118c:
ADD ECX,0x1
SAR R8D,0x1
TEST R8D,R8D
JG 0x00101168
LAB_00101197:
OR EAX,ESI
RET | uint func0(uint param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
iVar2 = 0;
uVar3 = 0;
uVar4 = param_1;
uVar1 = uVar3;
if (0 < (int)param_1) {
while( true ) {
uVar3 = uVar1;
iVar2 = iVar2 + 1;
uVar4 = (int)uVar4 >> 1;
if ((int)uVar4 < 1) break;
uVar1 = uVar3 | 1 << ((byte)iVar2 & 0x1f);
if (iVar2 % 2 != 1) {
uVar1 = uVar3;
}
}
}
return param_1 | uVar3;
} |
4,834 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res |= (1 << count);
}
count++;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 10);
assert(func0(20) == 30);
assert(func0(30) == 30);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%edx
xor %ecx,%ecx
xor %eax,%eax
mov $0x1,%r8d
test %edi,%edi
jle 1178 <func0+0x38>
add $0x1,%ecx
sar %edx
je 116e <func0+0x2e>
test $0x1,%cl
je 1154 <func0+0x14>
mov %r8d,%esi
shl %cl,%esi
add $0x1,%ecx
or %esi,%eax
sar %edx
jne 115b <func0+0x1b>
or %edi,%eax
retq
nopl 0x0(%rax)
mov %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov edx, edi
xor ecx, ecx
xor eax, eax
mov r8d, 1
test edi, edi
jle short loc_1228
nop dword ptr [rax+00h]
loc_1208:
add ecx, 1
sar edx, 1
jz short loc_1222
loc_120F:
test cl, 1
jz short loc_1208
mov esi, r8d
shl esi, cl
add ecx, 1
or eax, esi
sar edx, 1
jnz short loc_120F
loc_1222:
or eax, edi
retn
loc_1228:
mov eax, edi
retn | long long func0(int a1)
{
int v1; // edx
int v2; // ecx
unsigned int v3; // eax
int v4; // esi
v1 = a1;
v2 = 0;
v3 = 0;
if ( a1 <= 0 )
return (unsigned int)a1;
while ( 1 )
{
++v2;
v1 >>= 1;
if ( !v1 )
break;
while ( (v2 & 1) != 0 )
{
v4 = 1 << v2++;
v3 |= v4;
v1 >>= 1;
if ( !v1 )
return a1 | v3;
}
}
return a1 | v3;
} | func0:
ENDBR64
MOV EDX,EDI
XOR ECX,ECX
XOR EAX,EAX
MOV R8D,0x1
TEST EDI,EDI
JLE 0x00101228
NOP dword ptr [RAX]
LAB_00101208:
ADD ECX,0x1
SAR EDX,0x1
JZ 0x00101222
LAB_0010120f:
TEST CL,0x1
JZ 0x00101208
MOV ESI,R8D
SHL ESI,CL
ADD ECX,0x1
OR EAX,ESI
SAR EDX,0x1
JNZ 0x0010120f
LAB_00101222:
OR EAX,EDI
RET
LAB_00101228:
MOV EAX,EDI
RET | uint func0(uint param_1)
{
bool bVar1;
uint uVar2;
uint uVar3;
bVar1 = false;
uVar2 = 0;
uVar3 = param_1;
if ((int)param_1 < 1) {
return param_1;
}
while (uVar3 = (int)uVar3 >> 1, uVar3 != 0) {
while( true ) {
bVar1 = (bool)(bVar1 ^ 1);
if (!bVar1) break;
uVar2 = uVar2 | 1 << bVar1;
uVar3 = (int)uVar3 >> 1;
if (uVar3 == 0) goto LAB_00101222;
}
}
LAB_00101222:
return uVar2 | param_1;
} |
4,835 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res |= (1 << count);
}
count++;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 10);
assert(func0(20) == 30);
assert(func0(30) == 30);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1180 <func0+0x40>
mov %edi,%edx
sar %edx
je 1188 <func0+0x48>
mov $0x1,%ecx
xor %eax,%eax
mov $0x1,%r8d
nopl 0x0(%rax,%rax,1)
test $0x1,%cl
je 116c <func0+0x2c>
mov %r8d,%esi
shl %cl,%esi
or %esi,%eax
add $0x1,%ecx
sar %edx
jne 1160 <func0+0x20>
or %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
jmp 1173 <func0+0x33>
nopl 0x0(%rax)
| func0:
endbr64
test edi, edi
jle short loc_1178
mov edx, edi
xor esi, esi
xor ecx, ecx
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_1158:
test cl, 1
jz short loc_1166
mov r8d, eax
shl r8d, cl
or esi, r8d
loc_1166:
add ecx, 1
sar edx, 1
jnz short loc_1158
mov eax, edi
or eax, esi
retn
loc_1178:
mov eax, edi
retn | long long func0(int a1)
{
int v1; // edx
int v2; // esi
char v3; // cl
if ( a1 <= 0 )
return (unsigned int)a1;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
if ( (v3 & 1) != 0 )
v2 |= 1 << v3;
++v3;
v1 >>= 1;
}
while ( v1 );
return v2 | (unsigned int)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
MOV EDX,EDI
XOR ESI,ESI
XOR ECX,ECX
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
TEST CL,0x1
JZ 0x00101166
MOV R8D,EAX
SHL R8D,CL
OR ESI,R8D
LAB_00101166:
ADD ECX,0x1
SAR EDX,0x1
JNZ 0x00101158
MOV EAX,EDI
OR EAX,ESI
RET
LAB_00101178:
MOV EAX,EDI
RET | uint func0(uint param_1)
{
byte bVar1;
uint uVar2;
uint uVar3;
if (0 < (int)param_1) {
uVar3 = 0;
bVar1 = 0;
uVar2 = param_1;
do {
if ((bool)(bVar1 & 1)) {
uVar3 = uVar3 | 1 << (bVar1 & 0x1f);
}
bVar1 = bVar1 + 1;
uVar2 = (int)uVar2 >> 1;
} while (uVar2 != 0);
return param_1 | uVar3;
}
return param_1;
} |
4,836 | func0 |
#include <assert.h>
| int func0(int N, int K) {
if (N < K) {
return -1;
} else {
int Tri_up = ((N - K + 1) * (N - K + 2)) / 2;
int Tri_down = ((N - 2 * K + 1) * (N - 2 * K + 2)) / 2;
return Tri_up + Tri_down;
}
}
| int main() {
assert(func0(4,2) == 7);
assert(func0(4,3) == 3);
assert(func0(1,3) == -1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jge 1166 <func0+0x1d>
mov $0xffffffff,%eax
jmp 11ba <func0+0x71>
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
add $0x2,%eax
imul %edx,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0x14(%rbp),%eax
sub %edx,%eax
lea 0x1(%rax),%edx
mov -0x18(%rbp),%eax
lea (%rax,%rax,1),%ecx
mov -0x14(%rbp),%eax
sub %ecx,%eax
add $0x2,%eax
imul %edx,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%edx
mov -0x4(%rbp),%eax
add %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jge short loc_1166
mov eax, 0FFFFFFFFh
jmp short loc_11B8
loc_1166:
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
lea edx, [rax+1]
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
add eax, 2
imul eax, edx
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_8], eax
mov eax, [rbp+var_18]
add eax, eax
mov edx, [rbp+var_14]
sub edx, eax
add edx, 1
mov eax, [rbp+var_18]
add eax, eax
mov ecx, [rbp+var_14]
sub ecx, eax
lea eax, [rcx+2]
imul eax, edx
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_4], eax
mov edx, [rbp+var_8]
mov eax, [rbp+var_4]
add eax, edx
loc_11B8:
pop rbp
retn | long long func0(int a1, int a2)
{
if ( a1 >= a2 )
return (unsigned int)((a1 - a2 + 1) * (a1 - a2 + 2) / 2 + (a1 - 2 * a2 + 1) * (a1 - 2 * a2 + 2) / 2);
else
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JGE 0x00101166
MOV EAX,0xffffffff
JMP 0x001011b8
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
ADD EAX,0x2
IMUL EAX,EDX
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EAX
MOV EDX,dword ptr [RBP + -0x14]
SUB EDX,EAX
ADD EDX,0x1
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EAX
MOV ECX,dword ptr [RBP + -0x14]
SUB ECX,EAX
LEA EAX,[RCX + 0x2]
IMUL EAX,EDX
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
LAB_001011b8:
POP RBP
RET | int func0(int param_1,int param_2)
{
int iVar1;
if (param_1 < param_2) {
iVar1 = -1;
}
else {
iVar1 = ((param_1 + param_2 * -2 + 2) * (param_1 + param_2 * -2 + 1)) / 2 +
(((param_1 - param_2) + 2) * ((param_1 - param_2) + 1)) / 2;
}
return iVar1;
} |
4,837 | func0 |
#include <assert.h>
| int func0(int N, int K) {
if (N < K) {
return -1;
} else {
int Tri_up = ((N - K + 1) * (N - K + 2)) / 2;
int Tri_down = ((N - 2 * K + 1) * (N - 2 * K + 2)) / 2;
return Tri_up + Tri_down;
}
}
| int main() {
assert(func0(4,2) == 7);
assert(func0(4,3) == 3);
assert(func0(1,3) == -1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
jl 1160 <func0+0x37>
sub %esi,%edi
mov %edi,%edx
sub %esi,%edx
lea 0x1(%rdi),%eax
add $0x2,%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
mov %eax,%edi
lea 0x1(%rdx),%eax
add $0x2,%edx
imul %eax,%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
add %edi,%eax
retq
mov $0xffffffff,%eax
retq
| func0:
endbr64
cmp edi, esi
jl short loc_115E
sub edi, esi
mov edx, edi
sub edx, esi
lea ecx, [rdi+1]
add edi, 2
imul ecx, edi
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
lea ecx, [rdx+1]
add edx, 2
imul ecx, edx
mov edx, ecx
shr edx, 1Fh
add edx, ecx
sar edx, 1
add eax, edx
retn
loc_115E:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1, int a2)
{
if ( a1 < a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)((a1 - a2 - a2 + 2) * (a1 - a2 - a2 + 1) / 2 + (a1 - a2 + 2) * (a1 - a2 + 1) / 2);
} | func0:
ENDBR64
CMP EDI,ESI
JL 0x0010115e
SUB EDI,ESI
MOV EDX,EDI
SUB EDX,ESI
LEA ECX,[RDI + 0x1]
ADD EDI,0x2
IMUL ECX,EDI
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
LEA ECX,[RDX + 0x1]
ADD EDX,0x2
IMUL ECX,EDX
MOV EDX,ECX
SHR EDX,0x1f
ADD EDX,ECX
SAR EDX,0x1
ADD EAX,EDX
RET
LAB_0010115e:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_1 = param_1 - param_2;
return ((param_1 + 1) * (param_1 + 2)) / 2 +
(((param_1 - param_2) + 1) * ((param_1 - param_2) + 2)) / 2;
}
return -1;
} |
4,838 | func0 |
#include <assert.h>
| int func0(int N, int K) {
if (N < K) {
return -1;
} else {
int Tri_up = ((N - K + 1) * (N - K + 2)) / 2;
int Tri_down = ((N - 2 * K + 1) * (N - 2 * K + 2)) / 2;
return Tri_up + Tri_down;
}
}
| int main() {
assert(func0(4,2) == 7);
assert(func0(4,3) == 3);
assert(func0(1,3) == -1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
jl 1170 <func0+0x30>
sub %esi,%edi
mov %edi,%edx
lea 0x1(%rdi),%eax
add $0x2,%edi
sub %esi,%edx
imul %eax,%edi
lea 0x1(%rdx),%eax
add $0x2,%edx
imul %eax,%edx
sar %edi
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
add %edi,%eax
retq
xchg %ax,%ax
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
jl short loc_1170
sub edi, esi
mov edx, edi
lea eax, [rdi+1]
add edi, 2
sub edx, esi
imul eax, edi
lea ecx, [rdx+1]
add edx, 2
imul ecx, edx
sar eax, 1
mov edx, ecx
shr edx, 1Fh
add edx, ecx
sar edx, 1
add eax, edx
retn
loc_1170:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1, int a2)
{
if ( a1 < a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)((a1 - a2 - a2 + 2) * (a1 - a2 - a2 + 1) / 2 + (((a1 - a2 + 2) * (a1 - a2 + 1)) >> 1));
} | func0:
ENDBR64
CMP EDI,ESI
JL 0x00101170
SUB EDI,ESI
MOV EDX,EDI
LEA EAX,[RDI + 0x1]
ADD EDI,0x2
SUB EDX,ESI
IMUL EAX,EDI
LEA ECX,[RDX + 0x1]
ADD EDX,0x2
IMUL ECX,EDX
SAR EAX,0x1
MOV EDX,ECX
SHR EDX,0x1f
ADD EDX,ECX
SAR EDX,0x1
ADD EAX,EDX
RET
LAB_00101170:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_1 = param_1 - param_2;
return ((param_1 + 1) * (param_1 + 2) >> 1) +
(((param_1 - param_2) + 1) * ((param_1 - param_2) + 2)) / 2;
}
return -1;
} |
4,839 | func0 |
#include <assert.h>
| int func0(int N, int K) {
if (N < K) {
return -1;
} else {
int Tri_up = ((N - K + 1) * (N - K + 2)) / 2;
int Tri_down = ((N - 2 * K + 1) * (N - 2 * K + 2)) / 2;
return Tri_up + Tri_down;
}
}
| int main() {
assert(func0(4,2) == 7);
assert(func0(4,3) == 3);
assert(func0(1,3) == -1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
jl 1170 <func0+0x30>
sub %esi,%edi
mov %edi,%edx
lea 0x1(%rdi),%eax
add $0x2,%edi
sub %esi,%edx
imul %eax,%edi
lea 0x1(%rdx),%eax
add $0x2,%edx
imul %eax,%edx
sar %edi
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
add %edi,%eax
retq
xchg %ax,%ax
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
jl short loc_1170
sub edi, esi
mov edx, edi
lea eax, [rdi+1]
add edi, 2
sub edx, esi
imul eax, edi
lea ecx, [rdx+1]
add edx, 2
imul ecx, edx
sar eax, 1
mov edx, ecx
shr edx, 1Fh
add edx, ecx
sar edx, 1
add eax, edx
retn
loc_1170:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1, int a2)
{
if ( a1 < a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)((a1 - a2 - a2 + 2) * (a1 - a2 - a2 + 1) / 2 + (((a1 - a2 + 2) * (a1 - a2 + 1)) >> 1));
} | func0:
ENDBR64
CMP EDI,ESI
JL 0x00101170
SUB EDI,ESI
MOV EDX,EDI
LEA EAX,[RDI + 0x1]
ADD EDI,0x2
SUB EDX,ESI
IMUL EAX,EDI
LEA ECX,[RDX + 0x1]
ADD EDX,0x2
IMUL ECX,EDX
SAR EAX,0x1
MOV EDX,ECX
SHR EDX,0x1f
ADD EDX,ECX
SAR EDX,0x1
ADD EAX,EDX
RET
LAB_00101170:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_1 = param_1 - param_2;
return ((param_1 + 1) * (param_1 + 2) >> 1) +
(((param_1 - param_2) + 1) * ((param_1 - param_2) + 2)) / 2;
}
return -1;
} |
4,840 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} pair;
typedef struct {
int first;
int second;
int count;
} pair_count;
// Comparison function for qsort
int compare_pairs(const void* a, const void* b) {
pair* pa = (pair*)a;
pair* pb = (pair*)b;
if (pa->first != pb->first)
return pa->first - pb->first;
return pa->second - pb->second;
}
// Function to check occurrences
pair_count* check_occurences(pair* test_list, int size, int* out_size) {
// Sort each pair
for(int i = 0; i < size; i++) {
if(test_list[i].first > test_list[i].second) {
int temp = test_list[i].first;
test_list[i].first = test_list[i].second;
test_list[i].second = temp;
}
}
// Sort the list of pairs
qsort(test_list, size, sizeof(pair), compare_pairs);
// Count occurrences
pair_count* result = malloc(size * sizeof(pair_count));
int unique = 0;
for(int i = 0; i < size; i++) {
if(unique == 0 || result[unique-1].first != test_list[i].first || result[unique-1].second != test_list[i].second) {
result[unique].first = test_list[i].first;
result[unique].second = test_list[i].second;
result[unique].count = 1;
unique++;
}
else {
result[unique-1].count++;
}
}
*out_size = unique;
return result;
}
// Function to compare two pair_count arrays
| int func0(pair_count* a, int size_a, pair_count* b, int size_b) {
if(size_a != size_b)
return 0;
for(int i = 0; i < size_a; i++) {
if(a[i].first != b[i].first || a[i].second != b[i].second || a[i].count != b[i].count)
return 0;
}
return 1;
}
| int main() {
// First test case
pair test1[] = { {3,1}, {1,3}, {2,5}, {5,2}, {6,3} };
int size1 = sizeof(test1)/sizeof(pair);
int out_size1;
pair_count* res1 = check_occurences(test1, size1, &out_size1);
pair_count expected1[] = { {1,3,2}, {2,5,2}, {3,6,1} };
assert(func0(res1, out_size1, expected1, 3));
free(res1);
// Second test case
pair test2[] = { {4,2}, {2,4}, {3,6}, {6,3}, {7,4} };
int size2 = sizeof(test2)/sizeof(pair);
int out_size2;
pair_count* res2 = check_occurences(test2, size2, &out_size2);
pair_count expected2[] = { {2,4,2}, {3,6,2}, {4,7,1} };
assert(func0(res2, out_size2, expected2, 3));
free(res2);
// Third test case
pair test3[] = { {13,2}, {11,23}, {12,25}, {25,12}, {16,23} };
int size3 = sizeof(test3)/sizeof(pair);
int out_size3;
pair_count* res3 = check_occurences(test3, size3, &out_size3);
pair_count expected3[] = { {2,13,1}, {11,23,1}, {12,25,2}, {16,23,1} };
assert(func0(res3, out_size3, expected3, 4));
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
je 14ba <func0+0x28>
mov $0x0,%eax
jmpq 15b0 <func0+0x11e>
movl $0x0,-0x4(%rbp)
jmpq 159f <func0+0x10d>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,%ecx
jne 1594 <func0+0x102>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%ecx
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%eax
cmp %eax,%ecx
jne 1594 <func0+0x102>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%ecx
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
cmp %eax,%ecx
je 159b <func0+0x109>
mov $0x0,%eax
jmp 15b0 <func0+0x11e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 14c6 <func0+0x34>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jz short loc_14BD
mov eax, 0
jmp loc_15B3
loc_14BD:
mov [rbp+var_4], 0
jmp loc_15A2
loc_14C9:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp ecx, eax
jnz loc_1597
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax+4]
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax+4]
cmp ecx, eax
jnz short loc_1597
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax+8]
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax+8]
cmp ecx, eax
jz short loc_159E
loc_1597:
mov eax, 0
jmp short loc_15B3
loc_159E:
add [rbp+var_4], 1
loc_15A2:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_14C9
mov eax, 1
loc_15B3:
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+24h] [rbp-4h]
if ( a2 != a4 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(12LL * i + a1) != *(_DWORD *)(12LL * i + a3)
|| *(_DWORD *)(12LL * i + a1 + 4) != *(_DWORD *)(12LL * i + a3 + 4)
|| *(_DWORD *)(12LL * i + a1 + 8) != *(_DWORD *)(12LL * i + a3 + 8) )
{
return 0LL;
}
}
return 1LL;
} | 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 EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JZ 0x001014bd
MOV EAX,0x0
JMP 0x001015b3
LAB_001014bd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001015a2
LAB_001014c9:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP ECX,EAX
JNZ 0x00101597
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x4]
CMP ECX,EAX
JNZ 0x00101597
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX + 0x8]
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
CMP ECX,EAX
JZ 0x0010159e
LAB_00101597:
MOV EAX,0x0
JMP 0x001015b3
LAB_0010159e:
ADD dword ptr [RBP + -0x4],0x1
LAB_001015a2:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001014c9
MOV EAX,0x1
LAB_001015b3:
POP RBP
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int8 uVar1;
int local_c;
if (param_2 == param_4) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (((*(int *)(param_1 + (long)local_c * 0xc) != *(int *)(param_3 + (long)local_c * 0xc)) ||
(*(int *)(param_1 + (long)local_c * 0xc + 4) !=
*(int *)(param_3 + (long)local_c * 0xc + 4))) ||
(*(int *)(param_1 + (long)local_c * 0xc + 8) != *(int *)(param_3 + (long)local_c * 0xc + 8)
)) {
return 0;
}
}
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
4,841 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} pair;
typedef struct {
int first;
int second;
int count;
} pair_count;
// Comparison function for qsort
int compare_pairs(const void* a, const void* b) {
pair* pa = (pair*)a;
pair* pb = (pair*)b;
if (pa->first != pb->first)
return pa->first - pb->first;
return pa->second - pb->second;
}
// Function to check occurrences
pair_count* check_occurences(pair* test_list, int size, int* out_size) {
// Sort each pair
for(int i = 0; i < size; i++) {
if(test_list[i].first > test_list[i].second) {
int temp = test_list[i].first;
test_list[i].first = test_list[i].second;
test_list[i].second = temp;
}
}
// Sort the list of pairs
qsort(test_list, size, sizeof(pair), compare_pairs);
// Count occurrences
pair_count* result = malloc(size * sizeof(pair_count));
int unique = 0;
for(int i = 0; i < size; i++) {
if(unique == 0 || result[unique-1].first != test_list[i].first || result[unique-1].second != test_list[i].second) {
result[unique].first = test_list[i].first;
result[unique].second = test_list[i].second;
result[unique].count = 1;
unique++;
}
else {
result[unique-1].count++;
}
}
*out_size = unique;
return result;
}
// Function to compare two pair_count arrays
| int func0(pair_count* a, int size_a, pair_count* b, int size_b) {
if(size_a != size_b)
return 0;
for(int i = 0; i < size_a; i++) {
if(a[i].first != b[i].first || a[i].second != b[i].second || a[i].count != b[i].count)
return 0;
}
return 1;
}
| int main() {
// First test case
pair test1[] = { {3,1}, {1,3}, {2,5}, {5,2}, {6,3} };
int size1 = sizeof(test1)/sizeof(pair);
int out_size1;
pair_count* res1 = check_occurences(test1, size1, &out_size1);
pair_count expected1[] = { {1,3,2}, {2,5,2}, {3,6,1} };
assert(func0(res1, out_size1, expected1, 3));
free(res1);
// Second test case
pair test2[] = { {4,2}, {2,4}, {3,6}, {6,3}, {7,4} };
int size2 = sizeof(test2)/sizeof(pair);
int out_size2;
pair_count* res2 = check_occurences(test2, size2, &out_size2);
pair_count expected2[] = { {2,4,2}, {3,6,2}, {4,7,1} };
assert(func0(res2, out_size2, expected2, 3));
free(res2);
// Third test case
pair test3[] = { {13,2}, {11,23}, {12,25}, {25,12}, {16,23} };
int size3 = sizeof(test3)/sizeof(pair);
int out_size3;
pair_count* res3 = check_occurences(test3, size3, &out_size3);
pair_count expected3[] = { {2,13,1}, {11,23,1}, {12,25,2}, {16,23,1} };
assert(func0(res3, out_size3, expected3, 4));
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%esi
jne 1335 <func0+0x64>
test %esi,%esi
jle 131e <func0+0x4d>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea (%rcx,%rcx,2),%rcx
lea 0xc(%rdi,%rcx,4),%rdi
mov (%rdx),%r8d
cmp %r8d,(%rax)
jne 1324 <func0+0x53>
mov 0x4(%rdx),%r9d
cmp %r9d,0x4(%rax)
jne 132a <func0+0x59>
mov 0x8(%rdx),%ecx
cmp %ecx,0x8(%rax)
jne 1330 <func0+0x5f>
add $0xc,%rax
add $0xc,%rdx
cmp %rdi,%rax
jne 12f1 <func0+0x20>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov eax, 0
cmp esi, ecx
jnz short locret_1335
test esi, esi
jle short loc_131E
mov rax, rdi
lea ecx, [rsi-1]
lea rcx, [rcx+rcx*2]
lea rdi, [rdi+rcx*4+0Ch]
loc_12F1:
mov r8d, [rdx]
cmp [rax], r8d
jnz short loc_1324
mov r9d, [rdx+4]
cmp [rax+4], r9d
jnz short loc_132A
mov ecx, [rdx+8]
cmp [rax+8], ecx
jnz short loc_1330
add rax, 0Ch
add rdx, 0Ch
cmp rax, rdi
jnz short loc_12F1
mov eax, 1
retn
loc_131E:
mov eax, 1
retn
loc_1324:
mov eax, 0
retn
loc_132A:
mov eax, 0
retn
loc_1330:
mov eax, 0
locret_1335:
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long result; // rax
_DWORD *v5; // rax
long long v6; // rdi
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = a1;
v6 = (long long)&a1[3 * (a2 - 1) + 3];
while ( 1 )
{
if ( *v5 != *a3 )
return 0LL;
if ( v5[1] != a3[1] )
return 0LL;
if ( v5[2] != a3[2] )
break;
v5 += 3;
a3 += 3;
if ( v5 == (_DWORD *)v6 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,ECX
JNZ 0x00101335
TEST ESI,ESI
JLE 0x0010131e
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RCX,[RCX + RCX*0x2]
LEA RDI,[RDI + RCX*0x4 + 0xc]
LAB_001012f1:
MOV R8D,dword ptr [RDX]
CMP dword ptr [RAX],R8D
JNZ 0x00101324
MOV R9D,dword ptr [RDX + 0x4]
CMP dword ptr [RAX + 0x4],R9D
JNZ 0x0010132a
MOV ECX,dword ptr [RDX + 0x8]
CMP dword ptr [RAX + 0x8],ECX
JNZ 0x00101330
ADD RAX,0xc
ADD RDX,0xc
CMP RAX,RDI
JNZ 0x001012f1
MOV EAX,0x1
RET
LAB_0010131e:
MOV EAX,0x1
RET
LAB_00101324:
MOV EAX,0x0
RET
LAB_0010132a:
MOV EAX,0x0
RET
LAB_00101330:
MOV EAX,0x0
LAB_00101335:
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
if (param_2 == param_4) {
if (param_2 < 1) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 1) * 3 + 3;
while( true ) {
if (*param_1 != *param_3) {
return 0;
}
if (param_1[1] != param_3[1]) {
return 0;
}
if (param_1[2] != param_3[2]) break;
param_1 = param_1 + 3;
param_3 = param_3 + 3;
if (param_1 == piVar1) {
return 1;
}
}
}
return 0;
} |
4,842 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} pair;
typedef struct {
int first;
int second;
int count;
} pair_count;
// Comparison function for qsort
int compare_pairs(const void* a, const void* b) {
pair* pa = (pair*)a;
pair* pb = (pair*)b;
if (pa->first != pb->first)
return pa->first - pb->first;
return pa->second - pb->second;
}
// Function to check occurrences
pair_count* check_occurences(pair* test_list, int size, int* out_size) {
// Sort each pair
for(int i = 0; i < size; i++) {
if(test_list[i].first > test_list[i].second) {
int temp = test_list[i].first;
test_list[i].first = test_list[i].second;
test_list[i].second = temp;
}
}
// Sort the list of pairs
qsort(test_list, size, sizeof(pair), compare_pairs);
// Count occurrences
pair_count* result = malloc(size * sizeof(pair_count));
int unique = 0;
for(int i = 0; i < size; i++) {
if(unique == 0 || result[unique-1].first != test_list[i].first || result[unique-1].second != test_list[i].second) {
result[unique].first = test_list[i].first;
result[unique].second = test_list[i].second;
result[unique].count = 1;
unique++;
}
else {
result[unique-1].count++;
}
}
*out_size = unique;
return result;
}
// Function to compare two pair_count arrays
| int func0(pair_count* a, int size_a, pair_count* b, int size_b) {
if(size_a != size_b)
return 0;
for(int i = 0; i < size_a; i++) {
if(a[i].first != b[i].first || a[i].second != b[i].second || a[i].count != b[i].count)
return 0;
}
return 1;
}
| int main() {
// First test case
pair test1[] = { {3,1}, {1,3}, {2,5}, {5,2}, {6,3} };
int size1 = sizeof(test1)/sizeof(pair);
int out_size1;
pair_count* res1 = check_occurences(test1, size1, &out_size1);
pair_count expected1[] = { {1,3,2}, {2,5,2}, {3,6,1} };
assert(func0(res1, out_size1, expected1, 3));
free(res1);
// Second test case
pair test2[] = { {4,2}, {2,4}, {3,6}, {6,3}, {7,4} };
int size2 = sizeof(test2)/sizeof(pair);
int out_size2;
pair_count* res2 = check_occurences(test2, size2, &out_size2);
pair_count expected2[] = { {2,4,2}, {3,6,2}, {4,7,1} };
assert(func0(res2, out_size2, expected2, 3));
free(res2);
// Third test case
pair test3[] = { {13,2}, {11,23}, {12,25}, {25,12}, {16,23} };
int size3 = sizeof(test3)/sizeof(pair);
int out_size3;
pair_count* res3 = check_occurences(test3, size3, &out_size3);
pair_count expected3[] = { {2,13,1}, {11,23,1}, {12,25,2}, {16,23,1} };
assert(func0(res3, out_size3, expected3, 4));
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
cmp %ecx,%esi
jne 1690 <func0+0x10>
jmpq 1520 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
test esi, esi
jle short loc_1560
lea eax, [rsi-1]
lea rax, [rax+rax*2]
lea rax, [rdi+rax*4+0Ch]
jmp short loc_1555
loc_1538:
mov esi, [rdx+4]
cmp [rdi+4], esi
jnz short loc_155B
mov ecx, [rdx+8]
cmp [rdi+8], ecx
jnz short loc_155B
add rdi, 0Ch
add rdx, 0Ch
cmp rdi, rax
jz short loc_1560
loc_1555:
mov ecx, [rdx]
cmp [rdi], ecx
jz short loc_1538
loc_155B:
xor eax, eax
retn
loc_1560:
mov eax, 1
retn | long long func0_part_0(_DWORD *a1, int a2, _DWORD *a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = (long long)&a1[3 * (a2 - 1) + 3];
while ( *a1 == *a3 && a1[1] == a3[1] && a1[2] == a3[2] )
{
a1 += 3;
a3 += 3;
if ( a1 == (_DWORD *)v3 )
return 1LL;
}
return 0LL;
} | func0.part.0:
TEST ESI,ESI
JLE 0x00101560
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x2]
LEA RAX,[RDI + RAX*0x4 + 0xc]
JMP 0x00101555
LAB_00101538:
MOV ESI,dword ptr [RDX + 0x4]
CMP dword ptr [RDI + 0x4],ESI
JNZ 0x0010155b
MOV ECX,dword ptr [RDX + 0x8]
CMP dword ptr [RDI + 0x8],ECX
JNZ 0x0010155b
ADD RDI,0xc
ADD RDX,0xc
CMP RDI,RAX
JZ 0x00101560
LAB_00101555:
MOV ECX,dword ptr [RDX]
CMP dword ptr [RDI],ECX
JZ 0x00101538
LAB_0010155b:
XOR EAX,EAX
RET
LAB_00101560:
MOV EAX,0x1
RET | int8 func0_part_0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 3 + 3;
do {
if (((*param_1 != *param_3) || (param_1[1] != param_3[1])) || (param_1[2] != param_3[2])) {
return 0;
}
param_1 = param_1 + 3;
param_3 = param_3 + 3;
} while (param_1 != piVar1);
}
return 1;
} |
4,843 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} pair;
typedef struct {
int first;
int second;
int count;
} pair_count;
// Comparison function for qsort
int compare_pairs(const void* a, const void* b) {
pair* pa = (pair*)a;
pair* pb = (pair*)b;
if (pa->first != pb->first)
return pa->first - pb->first;
return pa->second - pb->second;
}
// Function to check occurrences
pair_count* check_occurences(pair* test_list, int size, int* out_size) {
// Sort each pair
for(int i = 0; i < size; i++) {
if(test_list[i].first > test_list[i].second) {
int temp = test_list[i].first;
test_list[i].first = test_list[i].second;
test_list[i].second = temp;
}
}
// Sort the list of pairs
qsort(test_list, size, sizeof(pair), compare_pairs);
// Count occurrences
pair_count* result = malloc(size * sizeof(pair_count));
int unique = 0;
for(int i = 0; i < size; i++) {
if(unique == 0 || result[unique-1].first != test_list[i].first || result[unique-1].second != test_list[i].second) {
result[unique].first = test_list[i].first;
result[unique].second = test_list[i].second;
result[unique].count = 1;
unique++;
}
else {
result[unique-1].count++;
}
}
*out_size = unique;
return result;
}
// Function to compare two pair_count arrays
| int func0(pair_count* a, int size_a, pair_count* b, int size_b) {
if(size_a != size_b)
return 0;
for(int i = 0; i < size_a; i++) {
if(a[i].first != b[i].first || a[i].second != b[i].second || a[i].count != b[i].count)
return 0;
}
return 1;
}
| int main() {
// First test case
pair test1[] = { {3,1}, {1,3}, {2,5}, {5,2}, {6,3} };
int size1 = sizeof(test1)/sizeof(pair);
int out_size1;
pair_count* res1 = check_occurences(test1, size1, &out_size1);
pair_count expected1[] = { {1,3,2}, {2,5,2}, {3,6,1} };
assert(func0(res1, out_size1, expected1, 3));
free(res1);
// Second test case
pair test2[] = { {4,2}, {2,4}, {3,6}, {6,3}, {7,4} };
int size2 = sizeof(test2)/sizeof(pair);
int out_size2;
pair_count* res2 = check_occurences(test2, size2, &out_size2);
pair_count expected2[] = { {2,4,2}, {3,6,2}, {4,7,1} };
assert(func0(res2, out_size2, expected2, 3));
free(res2);
// Third test case
pair test3[] = { {13,2}, {11,23}, {12,25}, {25,12}, {16,23} };
int size3 = sizeof(test3)/sizeof(pair);
int out_size3;
pair_count* res3 = check_occurences(test3, size3, &out_size3);
pair_count expected3[] = { {2,13,1}, {11,23,1}, {12,25,2}, {16,23,1} };
assert(func0(res3, out_size3, expected3, 4));
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
jne 1615 <func0+0x45>
test %esi,%esi
jle 1620 <func0+0x50>
lea -0x1(%rsi),%eax
lea (%rax,%rax,2),%rax
lea 0xc(%rdi,%rax,4),%rax
jmp 160d <func0+0x3d>
nopl 0x0(%rax)
mov 0x4(%rdx),%esi
cmp %esi,0x4(%rdi)
jne 1613 <func0+0x43>
mov 0x8(%rdx),%ecx
cmp %ecx,0x8(%rdi)
jne 1613 <func0+0x43>
add $0xc,%rdi
add $0xc,%rdx
cmp %rax,%rdi
je 1620 <func0+0x50>
mov (%rdx),%ecx
cmp %ecx,(%rdi)
je 15f0 <func0+0x20>
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
test esi, esi
jle short loc_14A0
movsxd rsi, esi
lea rax, [rsi+rsi*2]
lea rax, [rdi+rax*4]
jmp short loc_1495
loc_1478:
mov esi, [rdx+4]
cmp [rdi+4], esi
jnz short loc_149B
mov ecx, [rdx+8]
cmp [rdi+8], ecx
jnz short loc_149B
add rdi, 0Ch
add rdx, 0Ch
cmp rdi, rax
jz short loc_14A0
loc_1495:
mov ecx, [rdx]
cmp [rdi], ecx
jz short loc_1478
loc_149B:
xor eax, eax
retn
loc_14A0:
mov eax, 1
retn | long long func0_part_0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = &a1[3 * a2];
while ( *a1 == *a3 && a1[1] == a3[1] && a1[2] == a3[2] )
{
a1 += 3;
a3 += 3;
if ( a1 == v3 )
return 1LL;
}
return 0LL;
} | func0.part.0:
TEST ESI,ESI
JLE 0x001014a0
MOVSXD RSI,ESI
LEA RAX,[RSI + RSI*0x2]
LEA RAX,[RDI + RAX*0x4]
JMP 0x00101495
LAB_00101478:
MOV ESI,dword ptr [RDX + 0x4]
CMP dword ptr [RDI + 0x4],ESI
JNZ 0x0010149b
MOV ECX,dword ptr [RDX + 0x8]
CMP dword ptr [RDI + 0x8],ECX
JNZ 0x0010149b
ADD RDI,0xc
ADD RDX,0xc
CMP RDI,RAX
JZ 0x001014a0
LAB_00101495:
MOV ECX,dword ptr [RDX]
CMP dword ptr [RDI],ECX
JZ 0x00101478
LAB_0010149b:
XOR EAX,EAX
RET
LAB_001014a0:
MOV EAX,0x1
RET | int8 func0_part_0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + (long)param_2 * 3;
do {
if (((*param_1 != *param_3) || (param_1[1] != param_3[1])) || (param_1[2] != param_3[2])) {
return 0;
}
param_1 = param_1 + 3;
param_3 = param_3 + 3;
} while (param_1 != piVar1);
}
return 1;
} |
4,844 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* str) {
int str_len = strlen(str);
return (str_len * (str_len + 1)) / 2;
}
| int main() {
assert(func0("abc") == 6);
assert(func0("abcd") == 10);
assert(func0("abcde") == 15);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
add $0x1,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
add eax, 1
imul eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
leave
retn | long long func0(const char *a1)
{
int v2; // [rsp+1Ch] [rbp-4h]
v2 = strlen(a1);
return (unsigned int)(v2 * (v2 + 1) / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
LEAVE
RET | int func0(char *param_1)
{
size_t sVar1;
sVar1 = strlen(param_1);
return (((int)sVar1 + 1) * (int)sVar1) / 2;
} |
4,845 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* str) {
int str_len = strlen(str);
return (str_len * (str_len + 1)) / 2;
}
| int main() {
assert(func0("abc") == 6);
assert(func0("abcd") == 10);
assert(func0("abcde") == 15);
return 0;
}
| O1 | c | func0:
endbr64
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rax
imul %eax,%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
retq
| func0:
endbr64
sub rsp, 8
call _strlen
lea edx, [rax+1]
imul edx, eax
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
add rsp, 8
retn | long long func0()
{
int v0; // eax
v0 = strlen();
return (unsigned int)(v0 * (v0 + 1) / 2);
} | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101060
LEA EDX,[RAX + 0x1]
IMUL EDX,EAX
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
ADD RSP,0x8
RET | int func0(char *param_1)
{
size_t sVar1;
sVar1 = strlen(param_1);
return (((int)sVar1 + 1) * (int)sVar1) / 2;
} |
4,846 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* str) {
int str_len = strlen(str);
return (str_len * (str_len + 1)) / 2;
}
| int main() {
assert(func0("abc") == 6);
assert(func0("abcd") == 10);
assert(func0("abcde") == 15);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x8,%rsp
callq 1050 <strlen@plt>
add $0x8,%rsp
mov %rax,%rdx
lea 0x1(%rax),%eax
imul %eax,%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
sub rsp, 8
call _strlen
add rsp, 8
lea edx, [rax+1]
imul edx, eax
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0()
{
int v0; // eax
v0 = strlen();
return (unsigned int)(v0 * (v0 + 1) / 2);
} | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101050
ADD RSP,0x8
LEA EDX,[RAX + 0x1]
IMUL EDX,EAX
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | int func0(char *param_1)
{
size_t sVar1;
sVar1 = strlen(param_1);
return (((int)sVar1 + 1) * (int)sVar1) / 2;
} |
4,847 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* str) {
int str_len = strlen(str);
return (str_len * (str_len + 1)) / 2;
}
| int main() {
assert(func0("abc") == 6);
assert(func0("abcd") == 10);
assert(func0("abcde") == 15);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x8,%rsp
callq 1050 <strlen@plt>
add $0x8,%rsp
mov %rax,%rdx
lea 0x1(%rax),%eax
imul %eax,%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
sub rsp, 8
call _strlen
add rsp, 8
lea edx, [rax+1]
imul edx, eax
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(const char *a1)
{
int v1; // eax
v1 = strlen(a1);
return (unsigned int)(v1 * (v1 + 1) / 2);
} | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101050
ADD RSP,0x8
LEA EDX,[RAX + 0x1]
IMUL EDX,EAX
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | int func0(char *param_1)
{
size_t sVar1;
sVar1 = strlen(param_1);
return (((int)sVar1 + 1) * (int)sVar1) / 2;
} |
4,848 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int m, int n) {
int T[m+1][n+1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
T[i][j] = 0;
} else if (i < j) {
T[i][j] = 0;
} else if (j == 1) {
T[i][j] = i;
} else {
T[i][j] = T[i-1][j] + T[i/2][j-1];
}
}
}
return T[m][n];
}
| int main() {
assert(func0(10, 4) == 4);
assert(func0(5, 2) == 6);
assert(func0(16, 3) == 84);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %edi,-0x64(%rbp)
mov %esi,-0x68(%rbp)
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
mov %rsp,%rcx
mov %rcx,%r15
mov -0x68(%rbp),%ecx
lea 0x1(%rcx),%esi
mov -0x64(%rbp),%ecx
lea 0x1(%rcx),%edi
movslq %esi,%rcx
sub $0x1,%rcx
mov %rcx,-0x50(%rbp)
movslq %esi,%rcx
mov %rcx,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movslq %esi,%rcx
shl $0x2,%rcx
movslq %edi,%rbx
sub $0x1,%rbx
mov %rbx,-0x48(%rbp)
movslq %esi,%rbx
mov %rbx,%r12
mov $0x0,%r13d
movslq %edi,%rbx
mov %rbx,%rax
mov $0x0,%edx
mov %r13,%r14
imul %rax,%r14
mov %rdx,%rbx
imul %r12,%rbx
add %r14,%rbx
mul %r12
add %rdx,%rbx
mov %rbx,%rdx
movslq %esi,%rax
mov %rax,%r10
mov $0x0,%r11d
movslq %edi,%rax
mov %rax,%r8
mov $0x0,%r9d
mov %r11,%rdx
imul %r8,%rdx
mov %r9,%rax
imul %r10,%rax
lea (%rdx,%rax,1),%rbx
mov %r10,%rax
mul %r8
lea (%rbx,%rdx,1),%r8
mov %r8,%rdx
movslq %esi,%rdx
movslq %edi,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 1292 <func0+0x129>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 127b <func0+0x112>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12bc <func0+0x153>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x54(%rbp)
jmpq 1408 <func0+0x29f>
movl $0x0,-0x58(%rbp)
jmpq 13f8 <func0+0x28f>
cmpl $0x0,-0x54(%rbp)
je 12f3 <func0+0x18a>
cmpl $0x0,-0x58(%rbp)
jne 131d <func0+0x1b4>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rsi
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x0,(%rax,%rdx,4)
jmpq 13f4 <func0+0x28b>
mov -0x54(%rbp),%eax
cmp -0x58(%rbp),%eax
jge 134f <func0+0x1e6>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rsi
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x0,(%rax,%rdx,4)
jmpq 13f4 <func0+0x28b>
cmpl $0x1,-0x58(%rbp)
jne 137b <func0+0x212>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rsi
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rdx,%rsi
mov -0x54(%rbp),%edx
mov %edx,(%rax,%rsi,4)
jmp 13f4 <func0+0x28b>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x54(%rbp),%eax
lea -0x1(%rax),%r8d
mov -0x40(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rsi
movslq %r8d,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%edx
mov %rcx,%r8
shr $0x2,%r8
mov -0x54(%rbp),%eax
mov %eax,%esi
shr $0x1f,%esi
add %esi,%eax
sar %eax
mov %eax,%r9d
mov -0x58(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rdi
movslq %r9d,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov (%rax,%rsi,4),%eax
mov %rcx,%r8
shr $0x2,%r8
lea (%rdx,%rax,1),%esi
mov -0x40(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rdi
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov %esi,(%rax,%rdx,4)
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x68(%rbp),%eax
jle 12e7 <func0+0x17e>
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 12db <func0+0x172>
shr $0x2,%rcx
mov %rcx,%rsi
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rcx
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %rsi,%rdx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov %r15,%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 144c <func0+0x2e3>
callq 1060 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov [rbp+var_48], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov eax, [rbp+var_48]
lea r8d, [rax+1]
mov eax, [rbp+var_44]
lea r9d, [rax+1]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, r8d
lea rcx, ds:0[rax*4]
movsxd rax, r9d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rdx, r8d
movsxd rax, r9d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rsi, rax
and rsi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rsi
loc_1261:
cmp rsp, rdx
jz short loc_1278
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_1261
loc_1278:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12A2
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12A2:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_38], 0
jmp loc_13ED
loc_12C1:
mov [rbp+var_34], 0
jmp loc_13DD
loc_12CD:
cmp [rbp+var_38], 0
jz short loc_12D9
cmp [rbp+var_34], 0
jnz short loc_1303
loc_12D9:
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov dword ptr [rax+rdx*4], 0
jmp loc_13D9
loc_1303:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jge short loc_1335
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov dword ptr [rax+rdx*4], 0
jmp loc_13D9
loc_1335:
cmp [rbp+var_34], 1
jnz short loc_1361
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, rdi
add rsi, rdx
mov edx, [rbp+var_38]
mov [rax+rsi*4], edx
jmp short loc_13D9
loc_1361:
mov rdi, rcx
shr rdi, 2
mov eax, [rbp+var_38]
lea r8d, [rax-1]
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
movsxd rdx, r8d
imul rdx, rdi
add rdx, rsi
mov esi, [rax+rdx*4]
mov r8, rcx
shr r8, 2
mov eax, [rbp+var_38]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov r9d, eax
mov eax, [rbp+var_34]
lea edx, [rax-1]
mov rax, [rbp+var_20]
movsxd rdi, edx
movsxd rdx, r9d
imul rdx, r8
add rdx, rdi
mov eax, [rax+rdx*4]
mov r8, rcx
shr r8, 2
add esi, eax
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov [rax+rdx*4], esi
loc_13D9:
add [rbp+var_34], 1
loc_13DD:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_48]
jle loc_12CD
add [rbp+var_38], 1
loc_13ED:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_44]
jle loc_12C1
shr rcx, 2
mov rsi, rcx
mov rax, [rbp+var_20]
mov edx, [rbp+var_48]
movsxd rcx, edx
mov edx, [rbp+var_44]
movsxd rdx, edx
imul rdx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1431
call ___stack_chk_fail
loc_1431:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1, int a2)
{
unsigned long long v2; // rcx
unsigned long long v3; // rax
void *v4; // rsp
_BYTE v6[8]; // [rsp+8h] [rbp-50h] BYREF
int v7; // [rsp+10h] [rbp-48h]
int v8; // [rsp+14h] [rbp-44h]
int i; // [rsp+20h] [rbp-38h]
int j; // [rsp+24h] [rbp-34h]
long long v11; // [rsp+28h] [rbp-30h]
long long v12; // [rsp+30h] [rbp-28h]
_BYTE *v13; // [rsp+38h] [rbp-20h]
unsigned long long v14; // [rsp+40h] [rbp-18h]
v8 = a1;
v7 = a2;
v14 = __readfsqword(0x28u);
v11 = a2 + 1 - 1LL;
v2 = 4LL * (a2 + 1);
v12 = a1 + 1 - 1LL;
v3 = 16 * ((4 * (a2 + 1) * (long long)(a1 + 1) + 15) / 0x10uLL);
while ( v6 != &v6[-(v3 & 0xFFFFFFFFFFFFF000LL)] )
;
v4 = alloca(v3 & 0xFFF);
if ( (v3 & 0xFFF) != 0 )
*(_QWORD *)&v6[(v3 & 0xFFF) - 8] = *(_QWORD *)&v6[(v3 & 0xFFF) - 8];
v13 = v6;
for ( i = 0; i <= v8; ++i )
{
for ( j = 0; j <= v7; ++j )
{
if ( i && j )
{
if ( i >= j )
{
if ( j == 1 )
*(_DWORD *)&v13[4 * (v2 >> 2) * i + 4] = i;
else
*(_DWORD *)&v13[4 * j + 4 * (v2 >> 2) * i] = *(_DWORD *)&v13[4 * j - 4 + 4 * (v2 >> 2) * (i / 2)]
+ *(_DWORD *)&v13[4 * j + 4 * (v2 >> 2) * (i - 1)];
}
else
{
*(_DWORD *)&v13[4 * j + 4 * (v2 >> 2) * i] = 0;
}
}
else
{
*(_DWORD *)&v13[4 * j + 4 * (v2 >> 2) * i] = 0;
}
}
}
return *(unsigned int *)&v13[4 * v7 + 4 * (v2 >> 2) * v8];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV dword ptr [RBP + -0x48],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x48]
LEA R8D,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x44]
LEA R9D,[RAX + 0x1]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,R8D
LEA RCX,[RAX*0x4]
MOVSXD RAX,R9D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RDX,R8D
MOVSXD RAX,R9D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RSI,RAX
AND RSI,-0x1000
MOV RDX,RSP
SUB RDX,RSI
LAB_00101261:
CMP RSP,RDX
JZ 0x00101278
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101261
LAB_00101278:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012a2
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012a2:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001013ed
LAB_001012c1:
MOV dword ptr [RBP + -0x34],0x0
JMP 0x001013dd
LAB_001012cd:
CMP dword ptr [RBP + -0x38],0x0
JZ 0x001012d9
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x00101303
LAB_001012d9:
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV dword ptr [RAX + RDX*0x4],0x0
JMP 0x001013d9
LAB_00101303:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JGE 0x00101335
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV dword ptr [RAX + RDX*0x4],0x0
JMP 0x001013d9
LAB_00101335:
CMP dword ptr [RBP + -0x34],0x1
JNZ 0x00101361
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RSI,RDX
MOV EDX,dword ptr [RBP + -0x38]
MOV dword ptr [RAX + RSI*0x4],EDX
JMP 0x001013d9
LAB_00101361:
MOV RDI,RCX
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x38]
LEA R8D,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOVSXD RDX,R8D
IMUL RDX,RDI
ADD RDX,RSI
MOV ESI,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV R9D,EAX
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDI,EDX
MOVSXD RDX,R9D
IMUL RDX,R8
ADD RDX,RDI
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
ADD ESI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV dword ptr [RAX + RDX*0x4],ESI
LAB_001013d9:
ADD dword ptr [RBP + -0x34],0x1
LAB_001013dd:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x48]
JLE 0x001012cd
ADD dword ptr [RBP + -0x38],0x1
LAB_001013ed:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x001012c1
SHR RCX,0x2
MOV RSI,RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x48]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
IMUL RDX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101431
CALL 0x00101060
LAB_00101431:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int4 func0(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_58 [8];
int local_50;
int local_4c;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
local_4c = param_1;
local_50 = param_2;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
param_2 = param_2 + 1;
local_38 = (long)param_2 + -1;
uVar2 = (ulong)param_2;
local_30 = (long)(param_1 + 1) + -1;
uVar3 = (((long)(param_1 + 1) * (long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar4 = auStack_58; puVar4 != auStack_58 + -(uVar3 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
for (local_40 = 0; local_40 <= local_4c; local_40 = local_40 + 1) {
for (local_3c = 0; local_3c <= local_50; local_3c = local_3c + 1) {
if ((local_40 == 0) || (local_3c == 0)) {
*(int4 *)
(puVar4 + ((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar1) = 0
;
}
else if (local_40 < local_3c) {
*(int4 *)
(puVar4 + ((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar1) = 0
;
}
else if (local_3c == 1) {
*(int *)(puVar4 + ((long)local_40 * (uVar2 & 0x3fffffffffffffff) + 1) * 4 + lVar1) =
local_40;
}
else {
*(int *)(puVar4 + ((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)local_3c) * 4 +
lVar1) =
*(int *)(puVar4 + ((long)(local_40 + -1) * (uVar2 & 0x3fffffffffffffff) +
(long)local_3c) * 4 + lVar1) +
*(int *)(puVar4 + ((long)(local_40 / 2) * (uVar2 & 0x3fffffffffffffff) +
(long)(local_3c + -1)) * 4 + lVar1);
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = puVar4 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)
(puVar4 + ((long)local_4c * (uVar2 & 0x3fffffffffffffff) + (long)local_50) * 4 + lVar1);
} |
4,849 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int m, int n) {
int T[m+1][n+1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
T[i][j] = 0;
} else if (i < j) {
T[i][j] = 0;
} else if (j == 1) {
T[i][j] = i;
} else {
T[i][j] = T[i-1][j] + T[i/2][j-1];
}
}
}
return T[m][n];
}
| int main() {
assert(func0(10, 4) == 4);
assert(func0(5, 2) == 6);
assert(func0(16, 3) == 84);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %edi,-0x48(%rbp)
mov %esi,%r13d
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
movslq %eax,%rcx
lea 0x0(,%rcx,4),%r11
lea 0x1(%rdi),%edx
movslq %edx,%rax
imul %rcx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11e0 <func0+0x77>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11c9 <func0+0x60>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f6 <func0+0x8d>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rax
mov %rax,-0x58(%rbp)
mov %rax,%r14
mov -0x48(%rbp),%esi
test %esi,%esi
js 12b6 <func0+0x14d>
mov %rax,%r9
lea 0x1(%rsi),%ebx
mov %ebx,-0x44(%rbp)
mov %r11,%rbx
shr $0x2,%rbx
mov %rbx,-0x50(%rbp)
mov %r11,%r15
neg %r15
mov %rax,%rsi
mov %rax,%rbx
mov $0x0,%edx
mov %r13d,%r8d
jmp 1287 <func0+0x11e>
movl $0x0,(%r9,%rax,4)
lea 0x1(%rax),%rcx
cmp %rax,%r8
je 1276 <func0+0x10d>
mov %rcx,%rax
test %edx,%edx
je 1235 <func0+0xcc>
test %eax,%eax
je 1235 <func0+0xcc>
cmp %edx,%eax
jle 125e <func0+0xf5>
movl $0x0,(%rbx,%rax,4)
jmp 123d <func0+0xd4>
cmp $0x1,%eax
je 1270 <func0+0x107>
mov -0x4(%rdi,%rax,4),%ecx
add (%r12,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
jmp 123d <func0+0xd4>
mov %edx,(%r14,%r10,4)
jmp 123d <func0+0xd4>
add $0x1,%edx
add %r11,%r9
add %r11,%rbx
add %r11,%rsi
cmp -0x44(%rbp),%edx
je 12b6 <func0+0x14d>
test %r13d,%r13d
js 1276 <func0+0x10d>
lea (%rsi,%r15,1),%r12
mov %edx,%edi
shr $0x1f,%edi
add %edx,%edi
sar %edi
movslq %edi,%rdi
imul %r11,%rdi
add %r14,%rdi
mov $0x0,%eax
movslq %edx,%r10
imul -0x50(%rbp),%r10
add $0x1,%r10
jmp 1249 <func0+0xe0>
movslq %r13d,%r13
movslq -0x48(%rbp),%rax
shr $0x2,%r11
imul %rax,%r11
lea 0x0(%r13,%r11,1),%rax
mov -0x58(%rbp),%rsi
mov (%rsi,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 12ef <func0+0x186>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_54], edi
mov r13d, esi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea edx, [rsi+1]
movsxd rdx, edx
lea r10, ds:0[rdx*4]
lea eax, [rdi+1]
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C5:
cmp rsp, rdx
jz short loc_11DC
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_11C5
loc_11DC:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11F2
or [rsp+rax+60h+var_68], 0
loc_11F2:
mov r14, rsp
mov eax, [rbp+var_54]
test eax, eax
js loc_12B0
mov r8, r14
lea r15d, [rax+1]
mov rax, r10
shr rax, 2
mov [rbp+var_48], rax
mov rax, r10
neg rax
mov [rbp+var_50], rax
mov r11, r14
mov rbx, r14
mov edx, 0
lea edi, [r13+1]
jmp short loc_127D
loc_122D:
mov dword ptr [r8+rax*4], 0
loc_1235:
add rax, 1
cmp rax, rdi
jz short loc_126C
loc_123E:
test edx, edx
jz short loc_122D
test eax, eax
jz short loc_122D
cmp eax, edx
jle short loc_1253
mov dword ptr [rbx+rax*4], 0
jmp short loc_1235
loc_1253:
cmp eax, 1
jz short loc_1266
mov ecx, [rsi+rax*4-4]
add ecx, [r12+rax*4]
mov [r11+rax*4], ecx
jmp short loc_1235
loc_1266:
mov [r14+r9*4], edx
jmp short loc_1235
loc_126C:
add edx, 1
add r8, r10
add rbx, r10
add r11, r10
cmp edx, r15d
jz short loc_12B0
loc_127D:
test r13d, r13d
js short loc_126C
mov rax, [rbp+var_50]
lea r12, [r11+rax]
mov esi, edx
shr esi, 1Fh
add esi, edx
sar esi, 1
movsxd rsi, esi
imul rsi, r10
add rsi, r14
mov eax, 0
movsxd r9, edx
imul r9, [rbp+var_48]
add r9, 1
jmp short loc_123E
loc_12B0:
movsxd rax, r13d
movsxd rdx, [rbp+var_54]
shr r10, 2
imul rdx, r10
add rax, rdx
mov eax, [r14+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_12E4
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12E4:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v2; // rdx
unsigned long long v3; // r10
_BYTE *v4; // rdx
signed long long v5; // rax
void *v6; // rsp
_BYTE *v7; // r8
int v8; // r15d
_BYTE *v9; // r11
_BYTE *v10; // rbx
int v11; // edx
long long v12; // rax
_BYTE *v13; // r12
long long v14; // r9
_BYTE v17[12]; // [rsp+8h] [rbp-60h] BYREF
int v18; // [rsp+14h] [rbp-54h]
long long v19; // [rsp+18h] [rbp-50h]
unsigned long long v20; // [rsp+20h] [rbp-48h]
unsigned long long v21; // [rsp+30h] [rbp-38h]
v18 = a1;
v21 = __readfsqword(0x28u);
v2 = a2 + 1;
v3 = 4 * v2;
v4 = &v17[-((4 * v2 * (a1 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)];
while ( v17 != v4 )
;
v5 = (4 * ((_WORD)a2 + 1) * ((_WORD)a1 + 1) + 15) & 0xFF0;
v6 = alloca(v5);
if ( ((4 * ((_WORD)a2 + 1) * ((_WORD)a1 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)&v17[v5 - 8] = *(_QWORD *)&v17[v5 - 8];
if ( v18 >= 0 )
{
v7 = v17;
v8 = v18 + 1;
v20 = v3 >> 2;
v19 = -(long long)v3;
v9 = v17;
v10 = v17;
v11 = 0;
do
{
if ( a2 >= 0 )
{
v13 = &v9[v19];
v12 = 0LL;
v14 = v20 * v11 + 1;
do
{
if ( v11 && (_DWORD)v12 )
{
if ( (int)v12 <= v11 )
{
if ( (_DWORD)v12 == 1 )
*(_DWORD *)&v17[4 * v14] = v11;
else
*(_DWORD *)&v9[4 * v12] = *(_DWORD *)&v13[4 * v12] + *(_DWORD *)&v17[4 * v12 - 4 + v3 * (v11 / 2)];
}
else
{
*(_DWORD *)&v10[4 * v12] = 0;
}
}
else
{
*(_DWORD *)&v7[4 * v12] = 0;
}
++v12;
}
while ( v12 != a2 + 1 );
}
++v11;
v7 += v3;
v10 += v3;
v9 += v3;
}
while ( v11 != v8 );
}
return *(unsigned int *)&v17[4 * (v3 >> 2) * v18 + 4 * a2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RBP + -0x54],EDI
MOV R13D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EDX,[RSI + 0x1]
MOVSXD RDX,EDX
LEA R10,[RDX*0x4]
LEA EAX,[RDI + 0x1]
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c5:
CMP RSP,RDX
JZ 0x001011dc
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011c5
LAB_001011dc:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011f2
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011f2:
MOV R14,RSP
MOV EAX,dword ptr [RBP + -0x54]
TEST EAX,EAX
JS 0x001012b0
MOV R8,R14
LEA R15D,[RAX + 0x1]
MOV RAX,R10
SHR RAX,0x2
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,R10
NEG RAX
MOV qword ptr [RBP + -0x50],RAX
MOV R11,R14
MOV RBX,R14
MOV EDX,0x0
LEA EDI,[R13 + 0x1]
JMP 0x0010127d
LAB_0010122d:
MOV dword ptr [R8 + RAX*0x4],0x0
LAB_00101235:
ADD RAX,0x1
CMP RAX,RDI
JZ 0x0010126c
LAB_0010123e:
TEST EDX,EDX
JZ 0x0010122d
TEST EAX,EAX
JZ 0x0010122d
CMP EAX,EDX
JLE 0x00101253
MOV dword ptr [RBX + RAX*0x4],0x0
JMP 0x00101235
LAB_00101253:
CMP EAX,0x1
JZ 0x00101266
MOV ECX,dword ptr [RSI + RAX*0x4 + -0x4]
ADD ECX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [R11 + RAX*0x4],ECX
JMP 0x00101235
LAB_00101266:
MOV dword ptr [R14 + R9*0x4],EDX
JMP 0x00101235
LAB_0010126c:
ADD EDX,0x1
ADD R8,R10
ADD RBX,R10
ADD R11,R10
CMP EDX,R15D
JZ 0x001012b0
LAB_0010127d:
TEST R13D,R13D
JS 0x0010126c
MOV RAX,qword ptr [RBP + -0x50]
LEA R12,[R11 + RAX*0x1]
MOV ESI,EDX
SHR ESI,0x1f
ADD ESI,EDX
SAR ESI,0x1
MOVSXD RSI,ESI
IMUL RSI,R10
ADD RSI,R14
MOV EAX,0x0
MOVSXD R9,EDX
IMUL R9,qword ptr [RBP + -0x48]
ADD R9,0x1
JMP 0x0010123e
LAB_001012b0:
MOVSXD RAX,R13D
MOVSXD RDX,dword ptr [RBP + -0x54]
SHR R10,0x2
IMUL RDX,R10
ADD RAX,RDX
MOV EAX,dword ptr [R14 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012e4
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001012e4:
CALL 0x00101060 | int4 func0(int param_1,int param_2)
{
int iVar1;
long lVar2;
long lVar3;
long lVar4;
int iVar5;
ulong uVar6;
int iVar7;
ulong uVar8;
int1 *puVar9;
int1 *puVar10;
int1 *puVar11;
long lVar12;
int1 *puVar13;
long in_FS_OFFSET;
int1 auStack_68 [12];
int local_5c;
long local_58;
ulong local_50;
long local_40;
local_5c = param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar8 = (ulong)(param_2 + 1);
lVar2 = uVar8 * 4;
uVar6 = (long)(param_1 + 1) * uVar8 * 4 + 0xf;
for (puVar10 = auStack_68; puVar10 != auStack_68 + -(uVar6 & 0xfffffffffffff000);
puVar10 = puVar10 + -0x1000) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar3 = -uVar6;
puVar9 = puVar10 + lVar3;
puVar11 = puVar10 + lVar3;
puVar13 = puVar10 + lVar3;
if (uVar6 != 0) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
if (-1 < local_5c) {
iVar1 = local_5c + 1;
local_50 = uVar8 & 0x3fffffffffffffff;
local_58 = uVar8 * -4;
iVar7 = 0;
do {
lVar4 = local_58;
if (-1 < param_2) {
uVar6 = 0;
lVar12 = (long)iVar7 * local_50;
do {
if ((iVar7 == 0) || (iVar5 = (int)uVar6, iVar5 == 0)) {
*(int4 *)(puVar11 + uVar6 * 4) = 0;
}
else if (iVar7 < iVar5) {
*(int4 *)(puVar9 + uVar6 * 4) = 0;
}
else if (iVar5 == 1) {
*(int *)(puVar10 + (lVar12 + 1) * 4 + lVar3) = iVar7;
}
else {
*(int *)(puVar13 + uVar6 * 4) =
*(int *)(puVar10 + uVar6 * 4 + (iVar7 / 2) * lVar2 + lVar3 + -4) +
*(int *)(puVar13 + uVar6 * 4 + lVar4);
}
uVar6 = uVar6 + 1;
} while (uVar6 != param_2 + 1);
}
iVar7 = iVar7 + 1;
puVar11 = puVar11 + lVar2;
puVar9 = puVar9 + lVar2;
puVar13 = puVar13 + lVar2;
} while (iVar7 != iVar1);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)
(puVar10 + ((long)param_2 + (long)local_5c * (uVar8 & 0x3fffffffffffffff)) * 4 + lVar3);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar10 + lVar3 + -8) = main;
__stack_chk_fail();
} |
4,850 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int m, int n) {
int T[m+1][n+1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
T[i][j] = 0;
} else if (i < j) {
T[i][j] = 0;
} else if (j == 1) {
T[i][j] = i;
} else {
T[i][j] = T[i-1][j] + T[i/2][j-1];
}
}
}
return T[m][n];
}
| int main() {
assert(func0(10, 4) == 4);
assert(func0(5, 2) == 6);
assert(func0(16, 3) == 84);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
lea 0x1(%rsi),%ecx
lea 0x1(%rdi),%edx
mov %rsp,%rbp
push %r15
push %r14
push %r13
mov %esi,%r13d
movslq %ecx,%rsi
push %r12
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x0(,%rsi,4),%rax
mov %rsp,%rbx
mov %rax,-0x50(%rbp)
movslq %edx,%rax
imul %rsi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 129b <func0+0x7b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1286 <func0+0x66>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13b0 <func0+0x190>
mov -0x50(%rbp),%r14
mov %rsp,-0x58(%rbp)
shr $0x2,%r14
test %edi,%edi
js 1372 <func0+0x152>
movslq %edi,%rax
mov %r14,%r15
mov -0x58(%rbp),%rbx
xor %r8d,%r8d
mov %rax,-0x48(%rbp)
neg %r15
nopl (%rax)
mov %r8d,%r12d
test %r13d,%r13d
js 134b <func0+0x12b>
test %r8d,%r8d
mov %r8d,%esi
movslq %r12d,%r11
mov %r8d,%r10d
sete %dil
imul %r14,%r11
sar %esi
mov %rbx,%rdx
movslq %esi,%rsi
xor %eax,%eax
sub %r8,%rsi
imul %r14,%rsi
add $0x1,%r11
jmp 1331 <func0+0x111>
nopl 0x0(%rax,%rax,1)
cmp %r10d,%eax
jg 133a <func0+0x11a>
cmp $0x1,%eax
je 1368 <func0+0x148>
mov -0x4(%rdx,%rsi,4),%r9d
add (%rdx,%r15,4),%r9d
mov %r9d,(%rdx)
add $0x1,%eax
add $0x4,%rdx
cmp %eax,%ecx
je 134b <func0+0x12b>
test %eax,%eax
je 133a <func0+0x11a>
test %dil,%dil
je 1310 <func0+0xf0>
add $0x1,%eax
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %eax,%ecx
jne 1331 <func0+0x111>
lea 0x1(%r8),%rax
add -0x50(%rbp),%rbx
cmp -0x48(%rbp),%r8
je 1380 <func0+0x160>
mov %rax,%r8
jmpq 12d8 <func0+0xb8>
nopl 0x0(%rax)
mov -0x58(%rbp),%r9
mov %r12d,(%r9,%r11,4)
jmp 1326 <func0+0x106>
movslq %edi,%rax
mov %rax,-0x48(%rbp)
nopl 0x0(%rax)
imul -0x48(%rbp),%r14
mov -0x58(%rbp),%rbx
movslq %r13d,%rax
add %r14,%rax
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 13bb <func0+0x19b>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12ad <func0+0x8d>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
lea ecx, [rsi+1]
mov edx, edi
movsxd rcx, ecx
mov rbp, rsp
push r15
lea r15, ds:0[rcx*4]
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+1]
mov rdi, rsp
cdqe
imul rax, rcx
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rdi, rax
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdi
jz short loc_1292
loc_127D:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rdi
jnz short loc_127D
loc_1292:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_13AB
loc_12A4:
mov r13, r15
mov [rbp+var_50], rsp
shr r13, 2
test edx, edx
js loc_136A
movsxd rax, edx
mov r14, r13
mov rbx, [rbp+var_50]
xor r8d, r8d
mov [rbp+var_48], rax
neg r14
nop dword ptr [rax+rax+00h]
loc_12D0:
mov r12d, r8d
test esi, esi
js short loc_1343
test r8d, r8d
mov edi, r8d
movsxd r11, r12d
mov r10d, r8d
setz r9b
imul r11, r13
sar edi, 1
mov rdx, rbx
movsxd rdi, edi
xor eax, eax
sub rdi, r8
imul rdi, r13
add r11, 1
jmp short loc_1329
loc_1308:
cmp eax, r10d
jg short loc_1332
cmp eax, 1
jz short loc_1360
mov ecx, [rdx+rdi*4-4]
add ecx, [rdx+r14*4]
mov [rdx], ecx
loc_131C:
lea ecx, [rax+1]
add rdx, 4
cmp esi, eax
jz short loc_1343
loc_1327:
mov eax, ecx
loc_1329:
test eax, eax
jz short loc_1332
test r9b, r9b
jz short loc_1308
loc_1332:
mov dword ptr [rdx], 0
lea ecx, [rax+1]
add rdx, 4
cmp esi, eax
jnz short loc_1327
loc_1343:
lea rax, [r8+1]
add rbx, r15
cmp r8, [rbp+var_48]
jz short loc_1378
mov r8, rax
jmp loc_12D0
loc_1360:
mov rcx, [rbp+var_50]
mov [rcx+r11*4], r12d
jmp short loc_131C
loc_136A:
movsxd rax, edx
mov [rbp+var_48], rax
nop dword ptr [rax+00000000h]
loc_1378:
mov rdx, [rbp+var_48]
mov rbx, [rbp+var_50]
movsxd rax, esi
imul rdx, r13
add rax, rdx
mov eax, [rbx+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_13B6
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13AB:
or [rsp+rcx+1050h+var_1058], 0
jmp loc_12A4
loc_13B6:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v3; // rcx
unsigned long long v4; // r15
long long v5; // rcx
_BYTE *v6; // rdi
__int16 v7; // cx
signed long long v8; // rcx
void *v9; // rsp
unsigned long long v10; // r13
_DWORD *v11; // rbx
long long v12; // r8
_DWORD *v13; // rdx
int i; // eax
int v15; // ecx
_BYTE v18[4088]; // [rsp+8h] [rbp-1050h] BYREF
_BYTE *v19; // [rsp+1008h] [rbp-50h] BYREF
long long v20; // [rsp+1010h] [rbp-48h]
unsigned long long v21; // [rsp+1020h] [rbp-38h]
v3 = a2 + 1;
v4 = 4 * v3;
v21 = __readfsqword(0x28u);
v5 = 4 * v3 * (a1 + 1) + 15;
v6 = (char *)&v19 - (v5 & 0xFFFFFFFFFFFFF000LL);
v7 = v5 & 0xFFF0;
if ( &v19 != (_BYTE **)v6 )
{
while ( v18 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)&v18[v8 - 8] = *(_QWORD *)&v18[v8 - 8];
v19 = v18;
v10 = v4 >> 2;
if ( a1 < 0 )
{
v20 = a1;
}
else
{
v11 = v19;
v12 = 0LL;
v20 = a1;
while ( 1 )
{
if ( a2 >= 0 )
{
v13 = v11;
for ( i = 0; ; i = v15 )
{
if ( i && (_DWORD)v12 && i <= (int)v12 )
{
if ( i == 1 )
*(_DWORD *)&v19[4 * v10 * (int)v12 + 4] = v12;
else
*v13 = v13[-v10] + v13[v10 * (((int)v12 >> 1) - v12) - 1];
v15 = i + 1;
++v13;
if ( a2 == i )
break;
}
else
{
*v13 = 0;
v15 = i + 1;
++v13;
if ( a2 == i )
break;
}
}
}
v11 = (_DWORD *)((char *)v11 + v4);
if ( v12 == v20 )
break;
++v12;
}
}
return *(unsigned int *)&v19[4 * v10 * v20 + 4 * a2];
} | func0:
ENDBR64
PUSH RBP
LEA ECX,[RSI + 0x1]
MOV EDX,EDI
MOVSXD RCX,ECX
MOV RBP,RSP
PUSH R15
LEA R15,[RCX*0x4]
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RDI,RSP
CDQE
IMUL RAX,RCX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RAX,-0x1000
SUB RDI,RAX
AND RCX,-0x10
CMP RSP,RDI
JZ 0x00101292
LAB_0010127d:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDI
JNZ 0x0010127d
LAB_00101292:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x001013ab
LAB_001012a4:
MOV R13,R15
MOV qword ptr [RBP + -0x50],RSP
SHR R13,0x2
TEST EDX,EDX
JS 0x0010136a
MOVSXD RAX,EDX
MOV R14,R13
MOV RBX,qword ptr [RBP + -0x50]
XOR R8D,R8D
MOV qword ptr [RBP + -0x48],RAX
NEG R14
NOP dword ptr [RAX + RAX*0x1]
LAB_001012d0:
MOV R12D,R8D
TEST ESI,ESI
JS 0x00101343
TEST R8D,R8D
MOV EDI,R8D
MOVSXD R11,R12D
MOV R10D,R8D
SETZ R9B
IMUL R11,R13
SAR EDI,0x1
MOV RDX,RBX
MOVSXD RDI,EDI
XOR EAX,EAX
SUB RDI,R8
IMUL RDI,R13
ADD R11,0x1
JMP 0x00101329
LAB_00101308:
CMP EAX,R10D
JG 0x00101332
CMP EAX,0x1
JZ 0x00101360
MOV ECX,dword ptr [RDX + RDI*0x4 + -0x4]
ADD ECX,dword ptr [RDX + R14*0x4]
MOV dword ptr [RDX],ECX
LAB_0010131c:
LEA ECX,[RAX + 0x1]
ADD RDX,0x4
CMP ESI,EAX
JZ 0x00101343
LAB_00101327:
MOV EAX,ECX
LAB_00101329:
TEST EAX,EAX
JZ 0x00101332
TEST R9B,R9B
JZ 0x00101308
LAB_00101332:
MOV dword ptr [RDX],0x0
LEA ECX,[RAX + 0x1]
ADD RDX,0x4
CMP ESI,EAX
JNZ 0x00101327
LAB_00101343:
LEA RAX,[R8 + 0x1]
ADD RBX,R15
CMP R8,qword ptr [RBP + -0x48]
JZ 0x00101378
MOV R8,RAX
JMP 0x001012d0
LAB_00101360:
MOV RCX,qword ptr [RBP + -0x50]
MOV dword ptr [RCX + R11*0x4],R12D
JMP 0x0010131c
LAB_0010136a:
MOVSXD RAX,EDX
MOV qword ptr [RBP + -0x48],RAX
NOP dword ptr [RAX]
LAB_00101378:
MOV RDX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x50]
MOVSXD RAX,ESI
IMUL RDX,R13
ADD RAX,RDX
MOV EAX,dword ptr [RBX + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b6
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001013ab:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x001012a4
LAB_001013b6:
CALL 0x00101060 | int4 func0(int param_1,int param_2)
{
long lVar1;
int1 **ppuVar2;
int iVar3;
ulong uVar4;
int *piVar5;
int *piVar6;
int1 **ppuVar7;
int iVar9;
ulong uVar11;
long in_FS_OFFSET;
bool bVar12;
int1 *local_58;
long local_50;
long local_40;
int1 **ppuVar8;
long lVar10;
uVar4 = (ulong)(param_2 + 1);
ppuVar7 = &local_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar11 = (long)(param_1 + 1) * uVar4 * 4 + 0xf;
ppuVar8 = &local_58;
ppuVar2 = &local_58;
while (ppuVar8 != (int1 **)((long)&local_58 - (uVar11 & 0xfffffffffffff000))) {
ppuVar7 = (int1 **)((long)ppuVar2 + -0x1000);
*(int8 *)((long)ppuVar2 + -8) = *(int8 *)((long)ppuVar2 + -8);
ppuVar8 = (int1 **)((long)ppuVar2 + -0x1000);
ppuVar2 = (int1 **)((long)ppuVar2 + -0x1000);
}
uVar11 = (ulong)((uint)uVar11 & 0xff0);
lVar1 = -uVar11;
piVar6 = (int *)((long)ppuVar7 + lVar1);
local_58 = (int1 *)((long)ppuVar7 + lVar1);
if (uVar11 != 0) {
*(int8 *)((long)ppuVar7 + -8) = *(int8 *)((long)ppuVar7 + -8);
}
uVar11 = uVar4 & 0x3fffffffffffffff;
if (-1 < param_1) {
lVar10 = 0;
do {
iVar9 = (int)lVar10;
if (-1 < param_2) {
iVar3 = 0;
piVar5 = piVar6;
while( true ) {
if (((iVar3 == 0) || (iVar9 == 0)) || (iVar9 < iVar3)) {
*piVar5 = 0;
}
else if (iVar3 == 1) {
*(int *)((long)ppuVar7 + ((long)iVar9 * uVar11 + 1) * 4 + lVar1) = iVar9;
}
else {
*piVar5 = piVar5[((iVar9 >> 1) - lVar10) * uVar11 + -1] + piVar5[-uVar11];
}
if (param_2 == iVar3) break;
iVar3 = iVar3 + 1;
piVar5 = piVar5 + 1;
}
}
piVar6 = piVar6 + uVar4;
bVar12 = lVar10 != param_1;
lVar10 = lVar10 + 1;
} while (bVar12);
}
local_50 = (long)param_1;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)ppuVar7 + ((long)param_2 + local_50 * uVar11) * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)ppuVar7 + lVar1 + -8) = 0x1013bb;
__stack_chk_fail();
} |
4,851 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int m, int n) {
int T[m+1][n+1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
T[i][j] = 0;
} else if (i < j) {
T[i][j] = 0;
} else if (j == 1) {
T[i][j] = i;
} else {
T[i][j] = T[i-1][j] + T[i/2][j-1];
}
}
}
return T[m][n];
}
| int main() {
assert(func0(10, 4) == 4);
assert(func0(5, 2) == 6);
assert(func0(16, 3) == 84);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
lea 0x1(%rsi),%edx
movslq %edx,%rdx
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rbx
cltq
imul %rdx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rcx
mov %rbx,%rax
cmp %rax,%rsp
je 128b <func0+0x6b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1276 <func0+0x56>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 147e <func0+0x25e>
lea 0x0(,%rdx,4),%r12
movslq %edi,%rax
mov %rsp,%r13
mov %rax,-0x50(%rbp)
shr $0x2,%r12
test %edi,%edi
js 1439 <func0+0x219>
test %esi,%esi
js 1439 <func0+0x219>
mov %r12,%r15
xor %r14d,%r14d
pxor %xmm0,%xmm0
xor %edi,%edi
neg %r15
nopw 0x0(%rax,%rax,1)
test %edi,%edi
movslq %edi,%r11
mov %edi,%ecx
mov %edi,%r8d
sete %r9b
movslq %r11d,%r10
cmp %edi,%esi
mov %edi,%ebx
cmovle %esi,%ecx
imul %r12,%r10
sar %r8d
lea 0x0(%r13,%r14,4),%rdx
movslq %r8d,%r8
xor %eax,%eax
sub %rdi,%r8
add $0x1,%r10
imul %r12,%r8
mov %r10,-0x48(%rbp)
jmp 1338 <func0+0x118>
nopw 0x0(%rax,%rax,1)
cmp $0x1,%eax
je 1470 <func0+0x250>
mov -0x4(%rdx,%r8,4),%r10d
add (%rdx,%r15,4),%r10d
mov %r10d,(%rdx)
add $0x1,%eax
add $0x4,%rdx
cmp %ecx,%eax
jg 1352 <func0+0x132>
test %eax,%eax
je 1341 <func0+0x121>
test %r9b,%r9b
je 1318 <func0+0xf8>
add $0x1,%eax
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %ecx,%eax
jle 1338 <func0+0x118>
cmp %eax,%esi
jl 13e8 <func0+0x1c8>
mov %esi,%edx
sub %eax,%edx
lea 0x1(%rdx),%r8d
cmp $0x2,%edx
jbe 1399 <func0+0x179>
movslq %eax,%rdx
mov %r8d,%ecx
add %r14,%rdx
shr $0x2,%ecx
lea 0x0(%r13,%rdx,4),%rdx
shl $0x4,%rcx
add %rdx,%rcx
movups %xmm0,(%rdx)
add $0x10,%rdx
cmp %rcx,%rdx
jne 1380 <func0+0x160>
mov %r8d,%edx
and $0xfffffffc,%edx
add %edx,%eax
cmp %edx,%r8d
je 13e8 <func0+0x1c8>
mov %r11,%rcx
movslq %eax,%rdx
imul %r12,%rcx
add %rcx,%rdx
movl $0x0,0x0(%r13,%rdx,4)
lea 0x1(%rax),%edx
test %eax,%eax
je 1400 <func0+0x1e0>
test %r9b,%r9b
jne 1400 <func0+0x1e0>
cmp %edx,%esi
jl 13e8 <func0+0x1c8>
imul %r12,%r11
movslq %edx,%rax
add $0x1,%edx
add %r11,%rax
movl $0x0,0x0(%r13,%rax,4)
cmp %edx,%esi
jl 13e8 <func0+0x1c8>
movslq %edx,%rdx
add %r11,%rdx
movl $0x0,0x0(%r13,%rdx,4)
lea 0x1(%rdi),%rax
add %r12,%r14
cmp -0x50(%rbp),%rdi
je 1439 <func0+0x219>
mov %rax,%rdi
jmpq 12d8 <func0+0xb8>
nopl (%rax)
cmp %edx,%esi
jl 13e8 <func0+0x1c8>
test %ebx,%ebx
jne 13bf <func0+0x19f>
movslq %edx,%rdx
add $0x2,%eax
add %rcx,%rdx
movl $0x0,0x0(%r13,%rdx,4)
cmp %eax,%esi
jl 13e8 <func0+0x1c8>
cltq
add %r12,%r14
add %rcx,%rax
movl $0x0,0x0(%r13,%rax,4)
lea 0x1(%rdi),%rax
cmp -0x50(%rbp),%rdi
jne 13f5 <func0+0x1d5>
imul -0x50(%rbp),%r12
movslq %esi,%rax
add %r12,%rax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov 0x0(%r13,%rax,4),%eax
jne 1489 <func0+0x269>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
mov -0x48(%rbp),%r10
mov %r11d,0x0(%r13,%r10,4)
jmpq 132d <func0+0x10d>
orq $0x0,-0x8(%rsp,%rcx,1)
jmpq 129d <func0+0x7d>
callq 1060 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push rbp
lea edx, [rsi+1]
mov ecx, esi
movsxd rdx, edx
mov rbp, rsp
push r15
push r14
lea r14, ds:0[rdx*4]
push r13
push r12
push rbx
movsxd rbx, edi
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rbx+1]
mov rsi, rsp
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_1295
loc_1280:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rsi
jnz short loc_1280
loc_1295:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13A7
loc_12A7:
mov r12, r14
mov [rbp+var_50], rsp
shr r12, 2
test ebx, ebx
js loc_1378
test ecx, ecx
js loc_1378
mov r15, r12
mov r10, rsp
xor edi, edi
neg r15
mov [rbp+var_48], r15
nop dword ptr [rax+00000000h]
loc_12D8:
test edi, edi
mov esi, edi
mov r8d, edi
mov r13d, edi
setz r9b
cmp ecx, edi
mov rdx, r10
cmovle esi, ecx
sar r8d, 1
xor eax, eax
movsxd r8, r8d
sub r8, rdi
imul r8, r12
loc_12FD:
test eax, eax
jz short loc_1358
test r9b, r9b
jnz short loc_1358
cmp eax, 1
jz short loc_1360
mov r15, [rbp+var_48]
mov r11d, [rdx+r8*4-4]
add r11d, [rdx+r15*4]
mov [rdx], r11d
loc_131B:
add eax, 1
add rdx, 4
cmp eax, esi
jle short loc_12FD
movsxd rdx, eax
cmp ecx, eax
jl short loc_1340
nop dword ptr [rax]
loc_1330:
mov dword ptr [r10+rdx*4], 0
add rdx, 1
cmp ecx, edx
jge short loc_1330
loc_1340:
lea rax, [rdi+1]
add r10, r14
cmp rdi, rbx
jz short loc_1378
mov rdi, rax
jmp short loc_12D8
loc_1358:
mov dword ptr [rdx], 0
jmp short loc_131B
loc_1360:
movsxd r11, r13d
mov r15, [rbp+var_50]
imul r11, r12
mov [r15+r11*4+4], r13d
jmp short loc_131B
loc_1378:
imul rbx, r12
movsxd rax, ecx
add rax, rbx
mov rbx, [rbp+var_50]
mov eax, [rbx+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_13B2
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13A7:
or [rsp+rdx+1050h+var_1058], 0
jmp loc_12A7
loc_13B2:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v3; // rdx
unsigned long long v4; // r14
long long v5; // rbx
long long v6; // rdx
_BYTE *v7; // rsi
__int16 v8; // dx
signed long long v9; // rdx
void *v10; // rsp
unsigned long long v11; // r12
_BYTE *v12; // r10
long long v13; // rdi
int v14; // esi
_DWORD *v15; // rdx
int v16; // eax
long long v17; // rdx
_BYTE v20[4088]; // [rsp+8h] [rbp-1050h] BYREF
_BYTE *v21; // [rsp+1008h] [rbp-50h] BYREF
long long v22; // [rsp+1010h] [rbp-48h]
unsigned long long v23; // [rsp+1020h] [rbp-38h]
v3 = a2 + 1;
v4 = 4 * v3;
v5 = a1;
v23 = __readfsqword(0x28u);
v6 = 4 * v3 * (a1 + 1) + 15;
v7 = (char *)&v21 - (v6 & 0xFFFFFFFFFFFFF000LL);
v8 = v6 & 0xFFF0;
if ( &v21 != (_BYTE **)v7 )
{
while ( v20 != v7 )
;
}
v9 = v8 & 0xFFF;
v10 = alloca(v9);
if ( v9 )
*(_QWORD *)&v20[v9 - 8] = *(_QWORD *)&v20[v9 - 8];
v21 = v20;
v11 = v4 >> 2;
if ( a1 >= 0 && a2 >= 0 )
{
v12 = v20;
v13 = 0LL;
v22 = -(long long)v11;
while ( 1 )
{
v14 = v13;
v15 = v12;
if ( a2 <= (int)v13 )
v14 = a2;
v16 = 0;
do
{
if ( v16 && (_DWORD)v13 )
{
if ( v16 == 1 )
*(_DWORD *)&v21[4 * v11 * (int)v13 + 4] = v13;
else
*v15 = v15[v22] + v15[v11 * (((int)v13 >> 1) - v13) - 1];
}
else
{
*v15 = 0;
}
++v16;
++v15;
}
while ( v16 <= v14 );
v17 = v16;
if ( a2 >= v16 )
{
do
*(_DWORD *)&v12[4 * v17++] = 0;
while ( a2 >= (int)v17 );
}
v12 += v4;
if ( v13 == v5 )
break;
++v13;
}
}
return *(unsigned int *)&v21[4 * v11 * v5 + 4 * a2];
} | func0:
ENDBR64
PUSH RBP
LEA EDX,[RSI + 0x1]
MOV ECX,ESI
MOVSXD RDX,EDX
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R14,[RDX*0x4]
PUSH R13
PUSH R12
PUSH RBX
MOVSXD RBX,EDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RBX + 0x1]
MOV RSI,RSP
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x00101295
LAB_00101280:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x00101280
LAB_00101295:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013a7
LAB_001012a7:
MOV R12,R14
MOV qword ptr [RBP + -0x50],RSP
SHR R12,0x2
TEST EBX,EBX
JS 0x00101378
TEST ECX,ECX
JS 0x00101378
MOV R15,R12
MOV R10,RSP
XOR EDI,EDI
NEG R15
MOV qword ptr [RBP + -0x48],R15
NOP dword ptr [RAX]
LAB_001012d8:
TEST EDI,EDI
MOV ESI,EDI
MOV R8D,EDI
MOV R13D,EDI
SETZ R9B
CMP ECX,EDI
MOV RDX,R10
CMOVLE ESI,ECX
SAR R8D,0x1
XOR EAX,EAX
MOVSXD R8,R8D
SUB R8,RDI
IMUL R8,R12
LAB_001012fd:
TEST EAX,EAX
JZ 0x00101358
TEST R9B,R9B
JNZ 0x00101358
CMP EAX,0x1
JZ 0x00101360
MOV R15,qword ptr [RBP + -0x48]
MOV R11D,dword ptr [RDX + R8*0x4 + -0x4]
ADD R11D,dword ptr [RDX + R15*0x4]
MOV dword ptr [RDX],R11D
LAB_0010131b:
ADD EAX,0x1
ADD RDX,0x4
CMP EAX,ESI
JLE 0x001012fd
MOVSXD RDX,EAX
CMP ECX,EAX
JL 0x00101340
NOP dword ptr [RAX]
LAB_00101330:
MOV dword ptr [R10 + RDX*0x4],0x0
ADD RDX,0x1
CMP ECX,EDX
JGE 0x00101330
LAB_00101340:
LEA RAX,[RDI + 0x1]
ADD R10,R14
CMP RDI,RBX
JZ 0x00101378
MOV RDI,RAX
JMP 0x001012d8
LAB_00101358:
MOV dword ptr [RDX],0x0
JMP 0x0010131b
LAB_00101360:
MOVSXD R11,R13D
MOV R15,qword ptr [RBP + -0x50]
IMUL R11,R12
MOV dword ptr [R15 + R11*0x4 + 0x4],R13D
JMP 0x0010131b
LAB_00101378:
IMUL RBX,R12
MOVSXD RAX,ECX
ADD RAX,RBX
MOV RBX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBX + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b2
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001013a7:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012a7
LAB_001013b2:
CALL 0x00101060 | int4 func0(int param_1,int param_2)
{
long lVar1;
int **ppuVar2;
int iVar3;
ulong uVar4;
int *piVar5;
long lVar6;
int **ppuVar7;
int iVar9;
int iVar10;
int *piVar12;
ulong uVar13;
long in_FS_OFFSET;
bool bVar14;
int *local_58;
long local_50;
long local_40;
int **ppuVar8;
long lVar11;
uVar4 = (ulong)(param_2 + 1);
ppuVar7 = &local_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar13 = (long)(param_1 + 1) * uVar4 * 4 + 0xf;
ppuVar8 = &local_58;
ppuVar2 = &local_58;
while (ppuVar8 != (int **)((long)&local_58 - (uVar13 & 0xfffffffffffff000))) {
ppuVar7 = (int **)((long)ppuVar2 + -0x1000);
*(int8 *)((long)ppuVar2 + -8) = *(int8 *)((long)ppuVar2 + -8);
ppuVar8 = (int **)((long)ppuVar2 + -0x1000);
ppuVar2 = (int **)((long)ppuVar2 + -0x1000);
}
uVar13 = (ulong)((uint)uVar13 & 0xff0);
lVar1 = -uVar13;
local_58 = (int *)((long)ppuVar7 + lVar1);
piVar12 = (int *)((long)ppuVar7 + lVar1);
if (uVar13 != 0) {
*(int8 *)((long)ppuVar7 + -8) = *(int8 *)((long)ppuVar7 + -8);
}
uVar13 = uVar4 & 0x3fffffffffffffff;
if ((-1 < param_1) && (-1 < param_2)) {
local_50 = -uVar13;
lVar11 = 0;
do {
iVar10 = (int)lVar11;
iVar9 = iVar10;
if (param_2 <= iVar10) {
iVar9 = param_2;
}
iVar3 = 0;
piVar5 = piVar12;
do {
if ((iVar3 == 0) || (iVar10 == 0)) {
*piVar5 = 0;
}
else if (iVar3 == 1) {
*(int *)((long)ppuVar7 + (long)iVar10 * uVar13 * 4 + lVar1 + 4) = iVar10;
}
else {
*piVar5 = piVar5[((iVar10 >> 1) - lVar11) * uVar13 + -1] + piVar5[-uVar13];
}
iVar3 = iVar3 + 1;
piVar5 = piVar5 + 1;
} while (iVar3 <= iVar9);
lVar6 = (long)iVar3;
while (iVar3 <= param_2) {
piVar12[lVar6] = 0;
lVar6 = lVar6 + 1;
iVar3 = (int)lVar6;
}
piVar12 = piVar12 + uVar4;
bVar14 = lVar11 != param_1;
lVar11 = lVar11 + 1;
} while (bVar14);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)ppuVar7 + ((long)param_2 + (long)param_1 * uVar13) * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)ppuVar7 + lVar1 + -8) = 0x1013b7;
__stack_chk_fail();
} |
4,852 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
| void func0(int list1[], int list1_size, int list2[], int list2_size, int result[]) {
for (int i = 0; i < list1_size - 1; i++) {
result[i] = list1[i];
}
for (int j = 0; j < list2_size; j++) {
result[list1_size - 1 + j] = list2[j];
}
}
| int main() {
int list1[] = {1, 3, 5, 7, 9, 10};
int list2[] = {2, 4, 6, 8};
int expected[] = {1, 3, 5, 7, 9, 2, 4, 6, 8};
int result[9];
func0(list1, 6, list2, 4, result);
assert(memcmp(result, expected, sizeof(expected)) == 0);
int list1b[] = {1, 2, 3, 4, 5};
int list2b[] = {5, 6, 7, 8};
int expectedb[] = {1, 2, 3, 4, 5, 6, 7, 8};
int resultb[8];
func0(list1b, 5, list2b, 4, resultb);
assert(memcmp(resultb, expectedb, sizeof(expectedb)) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov %r8,-0x30(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11dd <func0+0x54>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x30(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x8(%rbp)
jl 11ac <func0+0x23>
movl $0x0,-0x4(%rbp)
jmp 122a <func0+0xa1>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
lea -0x1(%rdx),%ecx
mov -0x4(%rbp),%edx
add %ecx,%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x30(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11f1 <func0+0x68>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_30], r8
mov [rbp+var_8], 0
jmp short loc_11DD
loc_11AC:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_30]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_8], 1
loc_11DD:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_8], eax
jl short loc_11AC
mov [rbp+var_4], 0
jmp short loc_122A
loc_11F1:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_1C]
lea ecx, [rdx-1]
mov edx, [rbp+var_4]
add edx, ecx
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_30]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4], 1
loc_122A:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl short loc_11F1
nop
nop
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long result; // rax
int i; // [rsp+28h] [rbp-8h]
unsigned int j; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
*(_DWORD *)(4LL * i + a5) = *(_DWORD *)(4LL * i + a1);
for ( j = 0; ; ++j )
{
result = j;
if ( (int)j >= a4 )
break;
*(_DWORD *)(4LL * (int)(a2 - 1 + j) + a5) = *(_DWORD *)(4LL * (int)j + a3);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011dd
LAB_001011ac:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x30]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x8],EAX
JL 0x001011ac
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010122a
LAB_001011f1:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
LEA ECX,[RDX + -0x1]
MOV EDX,dword ptr [RBP + -0x4]
ADD EDX,ECX
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x30]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010122a:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011f1
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2,long param_3,int param_4,long param_5)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_2 + -1; local_10 = local_10 + 1) {
*(int4 *)(param_5 + (long)local_10 * 4) = *(int4 *)(param_1 + (long)local_10 * 4);
}
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int4 *)(param_5 + (long)(local_c + param_2 + -1) * 4) =
*(int4 *)(param_3 + (long)local_c * 4);
}
return;
} |
4,853 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
| void func0(int list1[], int list1_size, int list2[], int list2_size, int result[]) {
for (int i = 0; i < list1_size - 1; i++) {
result[i] = list1[i];
}
for (int j = 0; j < list2_size; j++) {
result[list1_size - 1 + j] = list2[j];
}
}
| int main() {
int list1[] = {1, 3, 5, 7, 9, 10};
int list2[] = {2, 4, 6, 8};
int expected[] = {1, 3, 5, 7, 9, 2, 4, 6, 8};
int result[9];
func0(list1, 6, list2, 4, result);
assert(memcmp(result, expected, sizeof(expected)) == 0);
int list1b[] = {1, 2, 3, 4, 5};
int list2b[] = {5, 6, 7, 8};
int expectedb[] = {1, 2, 3, 4, 5, 6, 7, 8};
int resultb[8];
func0(list1b, 5, list2b, 4, resultb);
assert(memcmp(resultb, expectedb, sizeof(expectedb)) == 0);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11af <func0+0x26>
lea -0x2(%rsi),%r10d
mov $0x0,%eax
mov (%rdi,%rax,4),%r9d
mov %r9d,(%r8,%rax,4)
mov %rax,%r9
add $0x1,%rax
cmp %r10,%r9
jne 119b <func0+0x12>
test %ecx,%ecx
jle 11d5 <func0+0x4c>
lea -0x1(%rcx),%edi
movslq %esi,%rsi
lea (%r8,%rsi,4),%rsi
mov $0x0,%eax
mov (%rdx,%rax,4),%ecx
mov %ecx,-0x4(%rsi,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rdi,%rcx
jne 11c2 <func0+0x39>
retq
| func0:
endbr64
mov r10d, esi
mov rsi, rdx
cmp r10d, 1
jle short loc_11B5
lea r9d, [r10-2]
mov eax, 0
loc_11A2:
mov edx, [rdi+rax*4]
mov [r8+rax*4], edx
mov rdx, rax
add rax, 1
cmp rdx, r9
jnz short loc_11A2
loc_11B5:
test ecx, ecx
jle short locret_11D7
mov ecx, ecx
movsxd r10, r10d
lea rdi, [r8+r10*4]
mov eax, 0
loc_11C7:
mov edx, [rsi+rax*4]
mov [rdi+rax*4-4], edx
add rax, 1
cmp rcx, rax
jnz short loc_11C7
locret_11D7:
retn | void func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long v7; // rax
long long v8; // rdx
long long i; // rax
if ( a2 > 1 )
{
v7 = 0LL;
do
{
*(_DWORD *)(a5 + 4 * v7) = *(_DWORD *)(a1 + 4 * v7);
v8 = v7++;
}
while ( v8 != a2 - 2 );
}
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a5 + 4LL * a2 + 4 * i - 4) = *(_DWORD *)(a3 + 4 * i);
}
} | func0:
ENDBR64
MOV R10D,ESI
MOV RSI,RDX
CMP R10D,0x1
JLE 0x001011b5
LEA R9D,[R10 + -0x2]
MOV EAX,0x0
LAB_001011a2:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],EDX
MOV RDX,RAX
ADD RAX,0x1
CMP RDX,R9
JNZ 0x001011a2
LAB_001011b5:
TEST ECX,ECX
JLE 0x001011d7
MOV ECX,ECX
MOVSXD R10,R10D
LEA RDI,[R8 + R10*0x4]
MOV EAX,0x0
LAB_001011c7:
MOV EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x001011c7
LAB_001011d7:
RET | void func0(long param_1,int param_2,long param_3,uint param_4,long param_5)
{
ulong uVar1;
bool bVar2;
if (1 < param_2) {
uVar1 = 0;
do {
*(int4 *)(param_5 + uVar1 * 4) = *(int4 *)(param_1 + uVar1 * 4);
bVar2 = uVar1 != param_2 - 2;
uVar1 = uVar1 + 1;
} while (bVar2);
}
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int4 *)(param_5 + (long)param_2 * 4 + -4 + uVar1 * 4) =
*(int4 *)(param_3 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (param_4 != uVar1);
}
return;
} |
4,854 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
| void func0(int list1[], int list1_size, int list2[], int list2_size, int result[]) {
for (int i = 0; i < list1_size - 1; i++) {
result[i] = list1[i];
}
for (int j = 0; j < list2_size; j++) {
result[list1_size - 1 + j] = list2[j];
}
}
| int main() {
int list1[] = {1, 3, 5, 7, 9, 10};
int list2[] = {2, 4, 6, 8};
int expected[] = {1, 3, 5, 7, 9, 2, 4, 6, 8};
int result[9];
func0(list1, 6, list2, 4, result);
assert(memcmp(result, expected, sizeof(expected)) == 0);
int list1b[] = {1, 2, 3, 4, 5};
int list2b[] = {5, 6, 7, 8};
int expectedb[] = {1, 2, 3, 4, 5, 6, 7, 8};
int resultb[8];
func0(list1b, 5, list2b, 4, resultb);
assert(memcmp(resultb, expectedb, sizeof(expectedb)) == 0);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1274 <func0+0x24>
lea -0x2(%rsi),%r10d
xor %eax,%eax
mov (%rdi,%rax,4),%r9d
mov %r9d,(%r8,%rax,4)
mov %rax,%r9
add $0x1,%rax
cmp %r10,%r9
jne 1260 <func0+0x10>
test %ecx,%ecx
jle 129b <func0+0x4b>
movslq %esi,%rsi
lea -0x1(%rcx),%edi
xor %eax,%eax
lea (%r8,%rsi,4),%rsi
nopl 0x0(%rax)
mov (%rdx,%rax,4),%ecx
mov %ecx,-0x4(%rsi,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rcx,%rdi
jne 1288 <func0+0x38>
retq
nopl 0x0(%rax)
| func0:
endbr64
movsxd r10, esi
mov rsi, rdx
cmp r10d, 1
jle short loc_13E3
lea r9d, [r10-2]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13D0:
mov edx, [rdi+rax*4]
mov [r8+rax*4], edx
mov rdx, rax
add rax, 1
cmp rdx, r9
jnz short loc_13D0
loc_13E3:
test ecx, ecx
jle short locret_1400
movsxd rcx, ecx
lea rdi, [r8+r10*4]
xor eax, eax
loc_13F0:
mov edx, [rsi+rax*4]
mov [rdi+rax*4-4], edx
add rax, 1
cmp rcx, rax
jnz short loc_13F0
locret_1400:
retn | void func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long v5; // r10
long long v7; // rax
long long v8; // rdx
long long i; // rax
v5 = a2;
if ( (int)v5 > 1 )
{
v7 = 0LL;
do
{
*(_DWORD *)(a5 + 4 * v7) = *(_DWORD *)(a1 + 4 * v7);
v8 = v7++;
}
while ( v8 != (_DWORD)v5 - 2 );
}
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a5 + 4 * v5 + 4 * i - 4) = *(_DWORD *)(a3 + 4 * i);
}
} | func0:
ENDBR64
MOVSXD R10,ESI
MOV RSI,RDX
CMP R10D,0x1
JLE 0x001013e3
LEA R9D,[R10 + -0x2]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013d0:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],EDX
MOV RDX,RAX
ADD RAX,0x1
CMP RDX,R9
JNZ 0x001013d0
LAB_001013e3:
TEST ECX,ECX
JLE 0x00101400
MOVSXD RCX,ECX
LEA RDI,[R8 + R10*0x4]
XOR EAX,EAX
LAB_001013f0:
MOV EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x001013f0
LAB_00101400:
RET | void func0(long param_1,int param_2,long param_3,int param_4,long param_5)
{
ulong uVar1;
long lVar2;
bool bVar3;
if (1 < param_2) {
uVar1 = 0;
do {
*(int4 *)(param_5 + uVar1 * 4) = *(int4 *)(param_1 + uVar1 * 4);
bVar3 = uVar1 != param_2 - 2;
uVar1 = uVar1 + 1;
} while (bVar3);
}
if (0 < param_4) {
lVar2 = 0;
do {
*(int4 *)(param_5 + (long)param_2 * 4 + -4 + lVar2 * 4) =
*(int4 *)(param_3 + lVar2 * 4);
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
}
return;
} |
4,855 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
| void func0(int list1[], int list1_size, int list2[], int list2_size, int result[]) {
for (int i = 0; i < list1_size - 1; i++) {
result[i] = list1[i];
}
for (int j = 0; j < list2_size; j++) {
result[list1_size - 1 + j] = list2[j];
}
}
| int main() {
int list1[] = {1, 3, 5, 7, 9, 10};
int list2[] = {2, 4, 6, 8};
int expected[] = {1, 3, 5, 7, 9, 2, 4, 6, 8};
int result[9];
func0(list1, 6, list2, 4, result);
assert(memcmp(result, expected, sizeof(expected)) == 0);
int list1b[] = {1, 2, 3, 4, 5};
int list2b[] = {5, 6, 7, 8};
int expectedb[] = {1, 2, 3, 4, 5, 6, 7, 8};
int resultb[8];
func0(list1b, 5, list2b, 4, resultb);
assert(memcmp(resultb, expectedb, sizeof(expectedb)) == 0);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%r9d
test %r9d,%r9d
jle 135e <func0+0x8e>
lea 0xf(%r8),%rax
sub $0x2,%esi
sub %rdi,%rax
cmp $0x1e,%rax
jbe 1430 <func0+0x160>
cmp $0x3,%esi
jbe 1430 <func0+0x160>
mov %r9d,%esi
xor %eax,%eax
shr $0x2,%esi
shl $0x4,%rsi
nopw 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm0
movups %xmm0,(%r8,%rax,1)
add $0x10,%rax
cmp %rsi,%rax
jne 1310 <func0+0x40>
mov %r9d,%eax
and $0xfffffffc,%eax
test $0x3,%r9b
je 135e <func0+0x8e>
movslq %eax,%rsi
mov (%rdi,%rsi,4),%r10d
mov %r10d,(%r8,%rsi,4)
lea 0x1(%rax),%esi
cmp %esi,%r9d
jle 135e <func0+0x8e>
movslq %esi,%rsi
add $0x2,%eax
mov (%rdi,%rsi,4),%r10d
mov %r10d,(%r8,%rsi,4)
cmp %eax,%r9d
jle 135e <func0+0x8e>
cltq
mov (%rdi,%rax,4),%esi
mov %esi,(%r8,%rax,4)
test %ecx,%ecx
jle 142b <func0+0x15b>
movslq %r9d,%rsi
lea -0x1(%rcx),%eax
lea 0x10(,%rsi,4),%r10
lea (%r8,%rsi,4),%rdi
lea (%r8,%r10,1),%rsi
cmp %rsi,%rdx
lea 0x10(%rdx),%rsi
setae %r11b
cmp %rsi,%rdi
setae %sil
or %sil,%r11b
je 1408 <func0+0x138>
cmp $0x3,%eax
jbe 1408 <func0+0x138>
mov %ecx,%esi
xor %eax,%eax
shr $0x2,%esi
shl $0x4,%rsi
nopl 0x0(%rax,%rax,1)
movdqu (%rdx,%rax,1),%xmm1
movups %xmm1,(%rdi,%rax,1)
add $0x10,%rax
cmp %rsi,%rax
jne 13a8 <func0+0xd8>
mov %ecx,%eax
and $0xfffffffc,%eax
test $0x3,%cl
je 142b <func0+0x15b>
mov %eax,%esi
mov (%rdx,%rsi,4),%edi
lea (%r9,%rax,1),%esi
movslq %esi,%rsi
mov %edi,(%r8,%rsi,4)
lea 0x1(%rax),%esi
cmp %ecx,%esi
jge 142b <func0+0x15b>
movslq %esi,%rdi
add %r9d,%esi
add $0x2,%eax
mov (%rdx,%rdi,4),%edi
movslq %esi,%rsi
mov %edi,(%r8,%rsi,4)
cmp %eax,%ecx
jle 142b <func0+0x15b>
movslq %eax,%rcx
add %eax,%r9d
mov (%rdx,%rcx,4),%edx
movslq %r9d,%r9
mov %edx,(%r8,%r9,4)
retq
nopl 0x0(%rax,%rax,1)
mov %eax,%ecx
lea -0xc(%r8,%r10,1),%rdi
xor %eax,%eax
nopl 0x0(%rax)
mov (%rdx,%rax,4),%esi
mov %esi,-0x4(%rdi,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %rcx,%rsi
jne 1418 <func0+0x148>
retq
nopl 0x0(%rax)
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%r10d
mov %r10d,(%r8,%rax,4)
mov %rax,%r10
add $0x1,%rax
cmp %rsi,%r10
jne 1438 <func0+0x168>
jmpq 135e <func0+0x8e>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd r9, esi
push rbx
mov rsi, rdx
movsxd rdx, ecx
lea r10d, [r9-1]
test r10d, r10d
jle short loc_1328
lea eax, [r9-2]
cmp eax, 2
jbe short loc_1310
lea rcx, [rdi+4]
mov rax, r8
sub rax, rcx
cmp rax, 8
ja short loc_1378
loc_1310:
mov r11d, r10d
xor eax, eax
nop dword ptr [rax]
loc_1318:
mov ecx, [rdi+rax*4]
mov [r8+rax*4], ecx
add rax, 1
cmp rax, r11
jnz short loc_1318
loc_1328:
test edx, edx
jle short loc_1370
lea eax, [rdx-1]
cmp eax, 2
jbe short loc_134D
lea rdi, [r8+r9*4-4]
lea rcx, [rsi+4]
mov rax, rdi
sub rax, rcx
cmp rax, 8
ja loc_13F0
loc_134D:
shl rdx, 2
lea rdi, [r8+r9*4]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_1360:
mov ecx, [rsi+rax]
mov [rdi+rax-4], ecx
add rax, 4
cmp rdx, rax
jnz short loc_1360
loc_1370:
pop rbx
retn
loc_1378:
mov ecx, r10d
xor eax, eax
shr ecx, 2
shl rcx, 4
nop dword ptr [rax+00h]
loc_1388:
movdqu xmm0, xmmword ptr [rdi+rax]
movups xmmword ptr [r8+rax], xmm0
add rax, 10h
cmp rax, rcx
jnz short loc_1388
mov eax, r10d
and eax, 0FFFFFFFCh
test r10b, 3
jz short loc_1328
mov r11d, eax
mov ebx, [rdi+r11*4]
lea rcx, ds:0[r11*4]
mov [r8+r11*4], ebx
lea r11d, [rax+1]
cmp r10d, r11d
jle loc_1328
mov r11d, [rdi+rcx+4]
add eax, 2
mov [r8+rcx+4], r11d
cmp r10d, eax
jle loc_1328
mov eax, [rdi+rcx+8]
mov [r8+rcx+8], eax
jmp loc_1328
loc_13F0:
mov ecx, edx
xor eax, eax
shr ecx, 2
shl rcx, 4
nop dword ptr [rax+rax+00h]
loc_1400:
movdqu xmm1, xmmword ptr [rsi+rax]
movups xmmword ptr [rdi+rax], xmm1
add rax, 10h
cmp rax, rcx
jnz short loc_1400
mov eax, edx
and eax, 0FFFFFFFCh
test dl, 3
jz loc_1370
mov ecx, eax
mov r9d, [rsi+rcx*4]
lea rdi, ds:0[rcx*4]
lea ecx, [rax+r10]
movsxd rcx, ecx
mov [r8+rcx*4], r9d
lea ecx, [rax+1]
cmp ecx, edx
jge loc_1370
mov r9d, [rsi+rdi+4]
add ecx, r10d
add eax, 2
movsxd rcx, ecx
mov [r8+rcx*4], r9d
cmp edx, eax
jle loc_1370
mov edx, [rsi+rdi+8]
add r10d, eax
pop rbx
movsxd r10, r10d
mov [r8+r10*4], edx
retn | void func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long v5; // r9
long long v7; // rdx
signed int v8; // r10d
long long v9; // rax
long long v10; // rdx
long long v11; // rax
long long v12; // rax
unsigned int v13; // eax
long long v14; // rcx
long long v15; // rax
unsigned int v16; // eax
long long v17; // rdi
unsigned int v18; // ecx
int v19; // eax
v5 = a2;
v7 = a4;
v8 = v5 - 1;
if ( (int)v5 - 1 > 0 )
{
if ( (unsigned int)(v5 - 2) > 2 && (unsigned long long)(a5 - (a1 + 4)) > 8 )
{
v12 = 0LL;
do
{
*(__m128i *)(a5 + v12) = _mm_loadu_si128((const __m128i *)(a1 + v12));
v12 += 16LL;
}
while ( v12 != 16LL * ((unsigned int)v8 >> 2) );
v13 = v8 & 0xFFFFFFFC;
if ( (v8 & 3) != 0 )
{
v14 = 4LL * v13;
*(_DWORD *)(a5 + v14) = *(_DWORD *)(a1 + v14);
if ( v8 > (int)(v13 + 1) )
{
*(_DWORD *)(a5 + v14 + 4) = *(_DWORD *)(a1 + v14 + 4);
if ( v8 > (int)(v13 + 2) )
*(_DWORD *)(a5 + v14 + 8) = *(_DWORD *)(a1 + v14 + 8);
}
}
}
else
{
v9 = 0LL;
do
{
*(_DWORD *)(a5 + 4 * v9) = *(_DWORD *)(a1 + 4 * v9);
++v9;
}
while ( v9 != v8 );
}
}
if ( (int)v7 > 0 )
{
if ( (unsigned int)(v7 - 1) > 2 && (unsigned long long)(a5 + 4 * v5 - 4 - (a3 + 4)) > 8 )
{
v15 = 0LL;
do
{
*(__m128i *)(a5 + 4 * v5 - 4 + v15) = _mm_loadu_si128((const __m128i *)(a3 + v15));
v15 += 16LL;
}
while ( v15 != 16LL * ((unsigned int)v7 >> 2) );
v16 = v7 & 0xFFFFFFFC;
if ( (v7 & 3) != 0 )
{
v17 = 4LL * v16;
*(_DWORD *)(a5 + 4LL * (int)(v16 + v8)) = *(_DWORD *)(a3 + v17);
v18 = v16 + 1;
if ( (int)(v16 + 1) < (int)v7 )
{
v19 = v16 + 2;
*(_DWORD *)(a5 + 4LL * (int)(v8 + v18)) = *(_DWORD *)(a3 + v17 + 4);
if ( (int)v7 > v19 )
*(_DWORD *)(a5 + 4LL * (v19 + v8)) = *(_DWORD *)(a3 + v17 + 8);
}
}
}
else
{
v10 = 4 * v7;
v11 = 0LL;
do
{
*(_DWORD *)(a5 + 4 * v5 + v11 - 4) = *(_DWORD *)(a3 + v11);
v11 += 4LL;
}
while ( v10 != v11 );
}
}
} | func0:
ENDBR64
MOVSXD R9,ESI
PUSH RBX
MOV RSI,RDX
MOVSXD RDX,ECX
LEA R10D,[R9 + -0x1]
TEST R10D,R10D
JLE 0x00101328
LEA EAX,[R9 + -0x2]
CMP EAX,0x2
JBE 0x00101310
LEA RCX,[RDI + 0x4]
MOV RAX,R8
SUB RAX,RCX
CMP RAX,0x8
JA 0x00101378
LAB_00101310:
MOV R11D,R10D
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101318:
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],ECX
ADD RAX,0x1
CMP RAX,R11
JNZ 0x00101318
LAB_00101328:
TEST EDX,EDX
JLE 0x00101370
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x0010134d
LEA RDI,[R8 + R9*0x4 + -0x4]
LEA RCX,[RSI + 0x4]
MOV RAX,RDI
SUB RAX,RCX
CMP RAX,0x8
JA 0x001013f0
LAB_0010134d:
SHL RDX,0x2
LEA RDI,[R8 + R9*0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101360:
MOV ECX,dword ptr [RSI + RAX*0x1]
MOV dword ptr [RDI + RAX*0x1 + -0x4],ECX
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x00101360
LAB_00101370:
POP RBX
RET
LAB_00101378:
MOV ECX,R10D
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_00101388:
MOVDQU XMM0,xmmword ptr [RDI + RAX*0x1]
MOVUPS xmmword ptr [R8 + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x00101388
MOV EAX,R10D
AND EAX,0xfffffffc
TEST R10B,0x3
JZ 0x00101328
MOV R11D,EAX
MOV EBX,dword ptr [RDI + R11*0x4]
LEA RCX,[R11*0x4]
MOV dword ptr [R8 + R11*0x4],EBX
LEA R11D,[RAX + 0x1]
CMP R10D,R11D
JLE 0x00101328
MOV R11D,dword ptr [RDI + RCX*0x1 + 0x4]
ADD EAX,0x2
MOV dword ptr [R8 + RCX*0x1 + 0x4],R11D
CMP R10D,EAX
JLE 0x00101328
MOV EAX,dword ptr [RDI + RCX*0x1 + 0x8]
MOV dword ptr [R8 + RCX*0x1 + 0x8],EAX
JMP 0x00101328
LAB_001013f0:
MOV ECX,EDX
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101400:
MOVDQU XMM1,xmmword ptr [RSI + RAX*0x1]
MOVUPS xmmword ptr [RDI + RAX*0x1],XMM1
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x00101400
MOV EAX,EDX
AND EAX,0xfffffffc
TEST DL,0x3
JZ 0x00101370
MOV ECX,EAX
MOV R9D,dword ptr [RSI + RCX*0x4]
LEA RDI,[RCX*0x4]
LEA ECX,[RAX + R10*0x1]
MOVSXD RCX,ECX
MOV dword ptr [R8 + RCX*0x4],R9D
LEA ECX,[RAX + 0x1]
CMP ECX,EDX
JGE 0x00101370
MOV R9D,dword ptr [RSI + RDI*0x1 + 0x4]
ADD ECX,R10D
ADD EAX,0x2
MOVSXD RCX,ECX
MOV dword ptr [R8 + RCX*0x4],R9D
CMP EDX,EAX
JLE 0x00101370
MOV EDX,dword ptr [RSI + RDI*0x1 + 0x8]
ADD R10D,EAX
POP RBX
MOVSXD R10,R10D
MOV dword ptr [R8 + R10*0x4],EDX
RET | void func0(long param_1,int param_2,long param_3,uint param_4,long param_5)
{
int8 *puVar1;
int8 uVar2;
uint uVar3;
ulong uVar4;
long lVar5;
long lVar6;
uint uVar7;
uVar7 = param_2 - 1;
if (0 < (int)uVar7) {
if ((param_2 - 2U < 3) || ((ulong)(param_5 - (param_1 + 4)) < 9)) {
uVar4 = 0;
do {
*(int4 *)(param_5 + uVar4 * 4) = *(int4 *)(param_1 + uVar4 * 4);
uVar4 = uVar4 + 1;
} while (uVar4 != uVar7);
}
else {
lVar5 = 0;
do {
uVar2 = ((int8 *)(param_1 + lVar5))[1];
*(int8 *)(param_5 + lVar5) = *(int8 *)(param_1 + lVar5);
((int8 *)(param_5 + lVar5))[1] = uVar2;
lVar5 = lVar5 + 0x10;
} while (lVar5 != (ulong)(uVar7 >> 2) << 4);
uVar3 = uVar7 & 0xfffffffc;
if ((uVar7 & 3) != 0) {
uVar4 = (ulong)uVar3;
lVar5 = uVar4 * 4;
*(int4 *)(param_5 + uVar4 * 4) = *(int4 *)(param_1 + uVar4 * 4);
if (((int)(uVar3 + 1) < (int)uVar7) &&
(*(int4 *)(param_5 + 4 + lVar5) = *(int4 *)(param_1 + 4 + lVar5),
(int)(uVar3 + 2) < (int)uVar7)) {
*(int4 *)(param_5 + 8 + lVar5) = *(int4 *)(param_1 + 8 + lVar5);
}
}
}
}
if (0 < (int)param_4) {
if ((param_4 - 1 < 3) ||
(lVar5 = param_5 + -4 + (long)param_2 * 4, (ulong)(lVar5 - (param_3 + 4)) < 9)) {
lVar5 = 0;
do {
*(int4 *)(param_5 + (long)param_2 * 4 + -4 + lVar5) = *(int4 *)(param_3 + lVar5)
;
lVar5 = lVar5 + 4;
} while ((long)(int)param_4 * 4 != lVar5);
}
else {
lVar6 = 0;
do {
uVar2 = ((int8 *)(param_3 + lVar6))[1];
puVar1 = (int8 *)(lVar5 + lVar6);
*puVar1 = *(int8 *)(param_3 + lVar6);
puVar1[1] = uVar2;
lVar6 = lVar6 + 0x10;
} while (lVar6 != (ulong)(param_4 >> 2) << 4);
uVar3 = param_4 & 0xfffffffc;
if (((long)(int)param_4 & 3U) != 0) {
lVar5 = (ulong)uVar3 * 4;
*(int4 *)(param_5 + (long)(int)(uVar3 + uVar7) * 4) =
*(int4 *)(param_3 + (ulong)uVar3 * 4);
if ((int)(uVar3 + 1) < (int)param_4) {
*(int4 *)(param_5 + (long)(int)(uVar3 + 1 + uVar7) * 4) =
*(int4 *)(param_3 + 4 + lVar5);
if ((int)(uVar3 + 2) < (int)param_4) {
*(int4 *)(param_5 + (long)(int)(uVar7 + uVar3 + 2) * 4) =
*(int4 *)(param_3 + 8 + lVar5);
return;
}
}
}
}
}
return;
} |
4,856 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char*** func0(int m, int n, int o) {
char*** result = (char***)malloc(o * sizeof(char**));
for (int i = 0; i < o; i++) {
result[i] = (char**)malloc(n * sizeof(char*));
for (int j = 0; j < n; j++) {
result[i][j] = (char*)malloc(m * sizeof(char));
for (int k = 0; k < m; k++) {
result[i][j][k] = '*';
}
}
}
return result;
}
| int main() {
char*** output;
int m, n, o, i, j, k;
m = 6; n = 4; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 5; n = 3; o = 4;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 1; n = 2; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %edi,-0x34(%rbp)
mov %esi,-0x38(%rbp)
mov %edx,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1070 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 1267 <func0+0xfe>
mov -0x38(%rbp),%eax
cltq
shl $0x3,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1070 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x20(%rbp)
jmpq 1257 <func0+0xee>
mov -0x34(%rbp),%eax
cltq
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x20(%rbp),%ecx
movslq %ecx,%rcx
shl $0x3,%rcx
lea (%rdx,%rcx,1),%rbx
mov %rax,%rdi
callq 1070 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x1c(%rbp)
jmp 124b <func0+0xe2>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movb $0x2a,(%rax)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 1215 <func0+0xac>
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 11d6 <func0+0x6d>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 11a0 <func0+0x37>
mov -0x18(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_3C], edx
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
jmp loc_1267
loc_11A0:
mov eax, [rbp+var_38]
cdqe
shl rax, 3
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov [rbp+var_20], 0
jmp loc_1257
loc_11D6:
mov eax, [rbp+var_34]
cdqe
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_20]
movsxd rcx, ecx
shl rcx, 3
lea rbx, [rdx+rcx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov [rbp+var_1C], 0
jmp short loc_124B
loc_1215:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
shl rdx, 3
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
mov byte ptr [rax], 2Ah ; '*'
add [rbp+var_1C], 1
loc_124B:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_34]
jl short loc_1215
add [rbp+var_20], 1
loc_1257:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_38]
jl loc_11D6
add [rbp+var_24], 1
loc_1267:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl loc_11A0
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(int a1, int a2, int a3)
{
void **v3; // rbx
int i; // [rsp+1Ch] [rbp-24h]
int j; // [rsp+20h] [rbp-20h]
int k; // [rsp+24h] [rbp-1Ch]
_QWORD *v9; // [rsp+28h] [rbp-18h]
v9 = malloc(8LL * a3);
for ( i = 0; i < a3; ++i )
{
v9[i] = malloc(8LL * a2);
for ( j = 0; j < a2; ++j )
{
v3 = (void **)(v9[i] + 8LL * j);
*v3 = malloc(a1);
for ( k = 0; k < a1; ++k )
*(_BYTE *)(*(_QWORD *)(8LL * j + v9[i]) + k) = 42;
}
}
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV dword ptr [RBP + -0x3c],EDX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101070
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101267
LAB_001011a0:
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x3
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101070
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101257
LAB_001011d6:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x20]
MOVSXD RCX,ECX
SHL RCX,0x3
LEA RBX,[RDX + RCX*0x1]
MOV RDI,RAX
CALL 0x00101070
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010124b
LAB_00101215:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
SHL RDX,0x3
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOV byte ptr [RAX],0x2a
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010124b:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x00101215
ADD dword ptr [RBP + -0x20],0x1
LAB_00101257:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x001011d6
ADD dword ptr [RBP + -0x24],0x1
LAB_00101267:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001011a0
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int param_1,int param_2,int param_3)
{
long lVar1;
void *pvVar2;
void *pvVar3;
int4 local_2c;
int4 local_28;
int4 local_24;
pvVar2 = malloc((long)param_3 << 3);
for (local_2c = 0; local_2c < param_3; local_2c = local_2c + 1) {
pvVar3 = malloc((long)param_2 << 3);
*(void **)((long)local_2c * 8 + (long)pvVar2) = pvVar3;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
lVar1 = *(long *)((long)pvVar2 + (long)local_2c * 8);
pvVar3 = malloc((long)param_1);
*(void **)(lVar1 + (long)local_28 * 8) = pvVar3;
for (local_24 = 0; local_24 < param_1; local_24 = local_24 + 1) {
*(int *)
((long)local_24 +
*(long *)(*(long *)((long)pvVar2 + (long)local_2c * 8) + (long)local_28 * 8)) = 0x2a;
}
}
}
return pvVar2;
} |
4,857 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char*** func0(int m, int n, int o) {
char*** result = (char***)malloc(o * sizeof(char**));
for (int i = 0; i < o; i++) {
result[i] = (char**)malloc(n * sizeof(char*));
for (int j = 0; j < n; j++) {
result[i][j] = (char*)malloc(m * sizeof(char));
for (int k = 0; k < m; k++) {
result[i][j][k] = '*';
}
}
}
return result;
}
| int main() {
char*** output;
int m, n, o, i, j, k;
m = 6; n = 4; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 5; n = 3; o = 4;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 1; n = 2; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %edi,%r13d
mov %esi,%r14d
mov %esi,0x24(%rsp)
mov %edx,%ebx
movslq %edx,%rdi
shl $0x3,%rdi
callq 1070 <malloc@plt>
mov %rax,0x28(%rsp)
test %ebx,%ebx
jle 124b <func0+0xe2>
mov %rax,%rdi
movslq %r14d,%rax
shl $0x3,%rax
mov %rax,0x10(%rsp)
mov %rdi,0x8(%rsp)
lea -0x1(%rbx),%eax
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x18(%rsp)
lea -0x1(%r14),%eax
lea 0x8(,%rax,8),%r15
movslq %r13d,%r14
jmp 1228 <func0+0xbf>
add $0x8,%rbx
cmp %r15,%rbx
je 1216 <func0+0xad>
mov %rbx,%r12
add 0x0(%rbp),%r12
mov %r14,%rdi
callq 1070 <malloc@plt>
mov %rax,(%r12)
test %r13d,%r13d
jle 11d2 <func0+0x69>
lea -0x1(%r13),%ecx
mov $0x0,%eax
mov 0x0(%rbp),%rdx
mov (%rdx,%rbx,1),%rdx
movb $0x2a,(%rdx,%rax,1)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rcx
jne 11fc <func0+0x93>
jmp 11d2 <func0+0x69>
addq $0x8,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp 0x18(%rsp),%rax
je 124b <func0+0xe2>
mov 0x10(%rsp),%rdi
callq 1070 <malloc@plt>
mov 0x8(%rsp),%rsi
mov %rsi,%rbp
mov %rax,(%rsi)
cmpl $0x0,0x24(%rsp)
jle 1216 <func0+0xad>
mov $0x0,%ebx
jmp 11db <func0+0x72>
mov 0x28(%rsp),%rax
add $0x38,%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, 28h
mov ebp, edi
mov r15d, esi
mov ebx, edx
movsxd rdi, edx
shl rdi, 3
call _malloc
mov [rsp+58h+var_40], rax
test ebx, ebx
jle loc_121B
mov rsi, rax
movsxd rax, r15d
shl rax, 3
mov [rsp+58h+var_58], rax
mov r14, rsi
mov ebx, ebx
lea rax, [rsi+rbx*8]
mov [rsp+58h+var_50], rax
lea eax, [r15-1]
add rax, 1
mov [rsp+58h+var_48], rax
loc_11C4:
mov rdi, [rsp+58h+var_58]
call _malloc
mov [r14], rax
test r15d, r15d
jle short loc_1210
mov rbx, rax
mov rsi, [rsp+58h+var_48]
lea r13, [rax+rsi*8]
movsxd r12, ebp
loc_11E4:
mov rdi, r12
call _malloc
mov [rbx], rax
test ebp, ebp
jle short loc_1207
mov rdx, rax
mov ecx, ebp
add rax, rcx
loc_11FB:
mov byte ptr [rdx], 2Ah ; '*'
add rdx, 1
cmp rdx, rax
jnz short loc_11FB
loc_1207:
add rbx, 8
cmp rbx, r13
jnz short loc_11E4
loc_1210:
add r14, 8
cmp r14, [rsp+58h+var_50]
jnz short loc_11C4
loc_121B:
mov rax, [rsp+58h+var_40]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1, int a2, int a3)
{
long long v4; // rax
_QWORD *v5; // r14
long long v6; // rax
_QWORD *v7; // rbx
_QWORD *v8; // r13
long long v9; // rax
_BYTE *v10; // rdx
_BYTE *v11; // rax
_QWORD *v13; // [rsp+8h] [rbp-50h]
long long v14; // [rsp+18h] [rbp-40h]
v4 = malloc(8LL * a3);
v14 = v4;
if ( a3 > 0 )
{
v5 = (_QWORD *)v4;
v13 = (_QWORD *)(v4 + 8LL * (unsigned int)a3);
do
{
v6 = malloc(8LL * a2);
*v5 = v6;
if ( a2 > 0 )
{
v7 = (_QWORD *)v6;
v8 = (_QWORD *)(v6 + 8 * ((unsigned int)(a2 - 1) + 1LL));
do
{
v9 = malloc(a1);
*v7 = v9;
if ( a1 > 0 )
{
v10 = (_BYTE *)v9;
v11 = (_BYTE *)((unsigned int)a1 + v9);
do
*v10++ = 42;
while ( v10 != v11 );
}
++v7;
}
while ( v7 != v8 );
}
++v5;
}
while ( v5 != v13 );
}
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV EBP,EDI
MOV R15D,ESI
MOV EBX,EDX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x00101070
MOV qword ptr [RSP + 0x18],RAX
TEST EBX,EBX
JLE 0x0010121b
MOV RSI,RAX
MOVSXD RAX,R15D
SHL RAX,0x3
MOV qword ptr [RSP],RAX
MOV R14,RSI
MOV EBX,EBX
LEA RAX,[RSI + RBX*0x8]
MOV qword ptr [RSP + 0x8],RAX
LEA EAX,[R15 + -0x1]
ADD RAX,0x1
MOV qword ptr [RSP + 0x10],RAX
LAB_001011c4:
MOV RDI,qword ptr [RSP]
CALL 0x00101070
MOV qword ptr [R14],RAX
TEST R15D,R15D
JLE 0x00101210
MOV RBX,RAX
MOV RSI,qword ptr [RSP + 0x10]
LEA R13,[RAX + RSI*0x8]
MOVSXD R12,EBP
LAB_001011e4:
MOV RDI,R12
CALL 0x00101070
MOV qword ptr [RBX],RAX
TEST EBP,EBP
JLE 0x00101207
MOV RDX,RAX
MOV ECX,EBP
ADD RAX,RCX
LAB_001011fb:
MOV byte ptr [RDX],0x2a
ADD RDX,0x1
CMP RDX,RAX
JNZ 0x001011fb
LAB_00101207:
ADD RBX,0x8
CMP RBX,R13
JNZ 0x001011e4
LAB_00101210:
ADD R14,0x8
CMP R14,qword ptr [RSP + 0x8]
JNZ 0x001011c4
LAB_0010121b:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(uint param_1,int param_2,uint param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 *puVar3;
int1 *puVar4;
int1 *puVar5;
int8 *puVar6;
puVar2 = (int8 *)malloc((long)(int)param_3 << 3);
if (0 < (int)param_3) {
puVar6 = puVar2;
do {
puVar3 = (int8 *)malloc((long)param_2 << 3);
*puVar6 = puVar3;
if (0 < param_2) {
puVar1 = puVar3 + (ulong)(param_2 - 1) + 1;
do {
puVar4 = (int1 *)malloc((long)(int)param_1);
*puVar3 = puVar4;
if (0 < (int)param_1) {
puVar5 = puVar4 + param_1;
do {
*puVar4 = 0x2a;
puVar4 = puVar4 + 1;
} while (puVar4 != puVar5);
}
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
}
puVar6 = puVar6 + 1;
} while (puVar6 != puVar2 + param_3);
}
return puVar2;
} |
4,858 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char*** func0(int m, int n, int o) {
char*** result = (char***)malloc(o * sizeof(char**));
for (int i = 0; i < o; i++) {
result[i] = (char**)malloc(n * sizeof(char*));
for (int j = 0; j < n; j++) {
result[i][j] = (char*)malloc(m * sizeof(char));
for (int k = 0; k < m; k++) {
result[i][j][k] = '*';
}
}
}
return result;
}
| int main() {
char*** output;
int m, n, o, i, j, k;
m = 6; n = 4; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 5; n = 3; o = 4;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 1; n = 2; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %esi,%r14d
push %r13
push %r12
push %rbp
push %rbx
mov %edi,%ebx
movslq %edx,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x28,%rsp
mov %esi,0x14(%rsp)
callq 1070 <malloc@plt>
mov %rax,0x18(%rsp)
test %ebp,%ebp
jle 1393 <func0+0xe3>
movslq %r14d,%r15
mov %rax,%r14
movslq %ebx,%r12
lea 0x0(,%r15,8),%rdi
mov %rdi,(%rsp)
mov %rax,%rdi
lea -0x1(%rbp),%eax
lea -0x1(%r15),%ebp
lea 0x8(%rdi,%rax,8),%rax
shl $0x3,%rbp
mov %rax,0x8(%rsp)
lea -0x1(%rbx),%eax
mov %eax,0x10(%rsp)
nopl 0x0(%rax,%rax,1)
mov (%rsp),%rdi
callq 1070 <malloc@plt>
mov %rax,(%r14)
mov %rax,%r13
mov 0x14(%rsp),%eax
test %eax,%eax
jle 1388 <func0+0xd8>
xor %r15d,%r15d
nopw 0x0(%rax,%rax,1)
mov %r12,%rdi
callq 1070 <malloc@plt>
mov %rax,0x0(%r13,%r15,1)
test %ebx,%ebx
jle 1377 <func0+0xc7>
mov 0x10(%rsp),%edi
xor %edx,%edx
jmp 136a <func0+0xba>
nopl 0x0(%rax)
mov (%r14),%rax
mov %rcx,%rdx
mov (%rax,%r15,1),%rax
movb $0x2a,(%rax,%rdx,1)
lea 0x1(%rdx),%rcx
cmp %rdi,%rdx
jne 1360 <func0+0xb0>
cmp %r15,%rbp
je 1388 <func0+0xd8>
mov (%r14),%r13
add $0x8,%r15
jmp 1340 <func0+0x90>
nopl (%rax)
add $0x8,%r14
cmp 0x8(%rsp),%r14
jne 1320 <func0+0x70>
mov 0x18(%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14d, esi
push r13
push r12
push rbp
mov ebp, edi
movsxd rdi, edx
push rbx
mov rbx, rdi
shl rdi, 3
sub rsp, 28h
mov [rsp+58h+var_4C], esi
call _malloc
mov [rsp+58h+var_40], rax
test ebx, ebx
jle loc_1377
movsxd r14, r14d
mov ebx, ebx
mov r12, rax
movsxd r15, ebp
mov rsi, r14
lea rax, [rax+rbx*8]
shl r14, 3
mov [rsp+58h+var_58], rax
lea eax, [rsi-1]
lea rax, ds:8[rax*8]
mov [rsp+58h+var_48], rax
nop dword ptr [rax+00000000h]
loc_1318:
mov rdi, r14
call _malloc
mov rcx, rax
mov [r12], rax
mov r13, rax
mov rax, [rsp+58h+var_48]
lea rbx, [rcx+rax]
mov eax, [rsp+58h+var_4C]
test eax, eax
jle short loc_136D
nop dword ptr [rax+rax+00h]
loc_1340:
mov rdi, r15
call _malloc
mov [r13+0], rax
lea rdx, [rax+r15]
test ebp, ebp
jle short loc_1364
nop dword ptr [rax+00h]
loc_1358:
mov byte ptr [rax], 2Ah ; '*'
add rax, 1
cmp rdx, rax
jnz short loc_1358
loc_1364:
add r13, 8
cmp r13, rbx
jnz short loc_1340
loc_136D:
add r12, 8
cmp r12, [rsp+58h+var_58]
jnz short loc_1318
loc_1377:
mov rax, [rsp+58h+var_40]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1, int a2, int a3)
{
long long v4; // rax
_QWORD *v5; // r12
long long v6; // rcx
_QWORD *v7; // r13
_QWORD *v8; // rbx
_BYTE *v9; // rax
_BYTE *v10; // rdx
_QWORD *v12; // [rsp+0h] [rbp-58h]
long long v13; // [rsp+18h] [rbp-40h]
v4 = malloc(8LL * a3);
v13 = v4;
if ( a3 > 0 )
{
v5 = (_QWORD *)v4;
v12 = (_QWORD *)(v4 + 8LL * (unsigned int)a3);
do
{
v6 = malloc(8LL * a2);
*v5 = v6;
v7 = (_QWORD *)v6;
v8 = (_QWORD *)(v6 + 8LL * (unsigned int)(a2 - 1) + 8);
if ( a2 > 0 )
{
do
{
v9 = (_BYTE *)malloc(a1);
*v7 = v9;
v10 = &v9[a1];
if ( a1 > 0 )
{
do
*v9++ = 42;
while ( v10 != v9 );
}
++v7;
}
while ( v7 != v8 );
}
++v5;
}
while ( v5 != v12 );
}
return v13;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
MOVSXD RDI,EDX
PUSH RBX
MOV RBX,RDI
SHL RDI,0x3
SUB RSP,0x28
MOV dword ptr [RSP + 0xc],ESI
CALL 0x00101070
MOV qword ptr [RSP + 0x18],RAX
TEST EBX,EBX
JLE 0x00101377
MOVSXD R14,R14D
MOV EBX,EBX
MOV R12,RAX
MOVSXD R15,EBP
MOV RSI,R14
LEA RAX,[RAX + RBX*0x8]
SHL R14,0x3
MOV qword ptr [RSP],RAX
LEA EAX,[RSI + -0x1]
LEA RAX,[0x8 + RAX*0x8]
MOV qword ptr [RSP + 0x10],RAX
NOP dword ptr [RAX]
LAB_00101318:
MOV RDI,R14
CALL 0x00101070
MOV RCX,RAX
MOV qword ptr [R12],RAX
MOV R13,RAX
MOV RAX,qword ptr [RSP + 0x10]
LEA RBX,[RCX + RAX*0x1]
MOV EAX,dword ptr [RSP + 0xc]
TEST EAX,EAX
JLE 0x0010136d
NOP dword ptr [RAX + RAX*0x1]
LAB_00101340:
MOV RDI,R15
CALL 0x00101070
MOV qword ptr [R13],RAX
LEA RDX,[RAX + R15*0x1]
TEST EBP,EBP
JLE 0x00101364
NOP dword ptr [RAX]
LAB_00101358:
MOV byte ptr [RAX],0x2a
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x00101358
LAB_00101364:
ADD R13,0x8
CMP R13,RBX
JNZ 0x00101340
LAB_0010136d:
ADD R12,0x8
CMP R12,qword ptr [RSP]
JNZ 0x00101318
LAB_00101377:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int param_1,int param_2,uint param_3)
{
int8 *puVar1;
int1 *puVar2;
int8 *puVar3;
int8 *puVar4;
int1 *puVar5;
int8 *puVar6;
puVar3 = (int8 *)malloc((long)(int)param_3 << 3);
if (0 < (int)param_3) {
puVar6 = puVar3;
do {
puVar4 = (int8 *)malloc((long)param_2 << 3);
*puVar6 = puVar4;
puVar1 = puVar4 + (ulong)(param_2 - 1) + 1;
if (0 < param_2) {
do {
puVar5 = (int1 *)malloc((long)param_1);
*puVar4 = puVar5;
puVar2 = puVar5 + param_1;
if (0 < param_1) {
do {
*puVar5 = 0x2a;
puVar5 = puVar5 + 1;
} while (puVar2 != puVar5);
}
puVar4 = puVar4 + 1;
} while (puVar4 != puVar1);
}
puVar6 = puVar6 + 1;
} while (puVar6 != puVar3 + param_3);
}
return puVar3;
} |
4,859 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char*** func0(int m, int n, int o) {
char*** result = (char***)malloc(o * sizeof(char**));
for (int i = 0; i < o; i++) {
result[i] = (char**)malloc(n * sizeof(char*));
for (int j = 0; j < n; j++) {
result[i][j] = (char*)malloc(m * sizeof(char));
for (int k = 0; k < m; k++) {
result[i][j][k] = '*';
}
}
}
return result;
}
| int main() {
char*** output;
int m, n, o, i, j, k;
m = 6; n = 4; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 5; n = 3; o = 4;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
m = 1; n = 2; o = 3;
output = func0(m, n, o);
for (i = 0; i < o; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) {
assert(output[i][j][k] == '*');
}
}
}
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %esi,%r14d
push %r13
push %r12
push %rbp
push %rbx
mov %edi,%ebx
movslq %edx,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x28,%rsp
mov %esi,0x14(%rsp)
callq 1070 <malloc@plt>
mov %rax,0x18(%rsp)
test %ebp,%ebp
jle 1517 <func0+0xf7>
movslq %r14d,%r15
mov %rax,%r14
movslq %ebx,%r12
lea 0x0(,%r15,8),%rdi
mov %rdi,(%rsp)
mov %rax,%rdi
lea -0x1(%rbp),%eax
lea -0x1(%r15),%ebp
lea 0x8(%rdi,%rax,8),%rax
shl $0x3,%rbp
mov %rax,0x8(%rsp)
lea -0x2(%rbx),%eax
mov %eax,0x10(%rsp)
nopl 0x0(%rax,%rax,1)
mov (%rsp),%rdi
callq 1070 <malloc@plt>
mov %rax,(%r14)
mov %rax,%r13
mov 0x14(%rsp),%eax
test %eax,%eax
jle 1508 <func0+0xe8>
xor %r15d,%r15d
nopw 0x0(%rax,%rax,1)
mov %r12,%rdi
callq 1070 <malloc@plt>
mov %rax,0x0(%r13,%r15,1)
test %ebx,%ebx
jle 14f4 <func0+0xd4>
movb $0x2a,(%rax)
cmp $0x1,%ebx
je 14f4 <func0+0xd4>
mov 0x10(%rsp),%esi
mov $0x1,%eax
add $0x2,%rsi
nopw %cs:0x0(%rax,%rax,1)
mov (%r14),%rdx
mov (%rdx,%r15,1),%rdx
movb $0x2a,(%rdx,%rax,1)
add $0x1,%rax
cmp %rax,%rsi
jne 14e0 <func0+0xc0>
cmp %r15,%rbp
je 1508 <func0+0xe8>
mov (%r14),%r13
add $0x8,%r15
jmp 14b0 <func0+0x90>
nopw 0x0(%rax,%rax,1)
add $0x8,%r14
cmp %r14,0x8(%rsp)
jne 1490 <func0+0x70>
mov 0x18(%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14d, esi
push r13
push r12
push rbp
movsxd rbp, edx
push rbx
mov r12, rbp
shl rbp, 3
mov ebx, edi
mov rdi, rbp; size
sub rsp, 28h
mov [rsp+58h+var_44], esi
call _malloc
mov [rsp+58h+var_40], rax
test r12d, r12d
jle short loc_14F6
movsxd r15, r14d
mov r14, rax
add rax, rbp
movsxd r12, ebx
lea rcx, ds:0[r15*8]
mov [rsp+58h+var_50], rax
mov [rsp+58h+size], rcx
nop dword ptr [rax+00h]
loc_1498:
mov rbp, [rsp+58h+size]
mov r13d, ebx
mov rdi, rbp; size
call _malloc
mov [r14], rax
mov r15, rax
add rbp, rax
mov eax, [rsp+58h+var_44]
test eax, eax
jle short loc_14E8
nop dword ptr [rax+rax+00000000h]
loc_14C0:
mov rdi, r12; size
call _malloc
mov [r15], rax
mov rdi, rax; s
test ebx, ebx
jle short loc_14DF
mov rdx, r13; n
mov esi, 2Ah ; '*'; c
call _memset
loc_14DF:
add r15, 8
cmp rbp, r15
jnz short loc_14C0
loc_14E8:
mov rax, [rsp+58h+var_50]
add r14, 8
cmp r14, rax
jnz short loc_1498
loc_14F6:
mov rax, [rsp+58h+var_40]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _QWORD * func0(size_t n, int a2, int a3)
{
size_t v4; // rbp
_QWORD *v5; // rax
_QWORD *v6; // r14
_QWORD *v7; // rax
_QWORD *v8; // r15
_QWORD *v9; // rbp
void *v10; // rax
long long size; // [rsp+0h] [rbp-58h]
_QWORD *v13; // [rsp+8h] [rbp-50h]
_QWORD *v14; // [rsp+18h] [rbp-40h]
v4 = a3;
v5 = malloc(v4 * 8);
v14 = v5;
if ( a3 > 0 )
{
v6 = v5;
v13 = &v5[v4];
size = a2;
do
{
v7 = malloc(size * 8);
*v6 = v7;
v8 = v7;
v9 = &v7[size];
if ( a2 > 0 )
{
do
{
v10 = malloc((int)n);
*v8 = v10;
if ( (int)n > 0 )
memset(v10, 42, (unsigned int)n);
++v8;
}
while ( v9 != v8 );
}
++v6;
}
while ( v6 != v13 );
}
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
MOV R12,RBP
SHL RBP,0x3
MOV EBX,EDI
MOV RDI,RBP
SUB RSP,0x28
MOV dword ptr [RSP + 0x14],ESI
CALL 0x00101090
MOV qword ptr [RSP + 0x18],RAX
TEST R12D,R12D
JLE 0x001014f6
MOVSXD R15,R14D
MOV R14,RAX
ADD RAX,RBP
MOVSXD R12,EBX
LEA RCX,[R15*0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],RCX
NOP dword ptr [RAX]
LAB_00101498:
MOV RBP,qword ptr [RSP]
MOV R13D,EBX
MOV RDI,RBP
CALL 0x00101090
MOV qword ptr [R14],RAX
MOV R15,RAX
ADD RBP,RAX
MOV EAX,dword ptr [RSP + 0x14]
TEST EAX,EAX
JLE 0x001014e8
NOP dword ptr [RAX + RAX*0x1]
LAB_001014c0:
MOV RDI,R12
CALL 0x00101090
MOV qword ptr [R15],RAX
MOV RDI,RAX
TEST EBX,EBX
JLE 0x001014df
MOV RDX,R13
MOV ESI,0x2a
CALL 0x00101080
LAB_001014df:
ADD R15,0x8
CMP RBP,R15
JNZ 0x001014c0
LAB_001014e8:
MOV RAX,qword ptr [RSP + 0x8]
ADD R14,0x8
CMP R14,RAX
JNZ 0x00101498
LAB_001014f6:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(uint param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 *puVar2;
void *__s;
int8 *puVar3;
int8 *puVar4;
puVar1 = (int8 *)malloc((long)param_3 * 8);
if (0 < param_3) {
puVar4 = puVar1;
do {
puVar2 = (int8 *)malloc((long)param_2 * 8);
*puVar4 = puVar2;
puVar3 = puVar2 + param_2;
if (0 < param_2) {
do {
__s = malloc((long)(int)param_1);
*puVar2 = __s;
if (0 < (int)param_1) {
memset(__s,0x2a,(ulong)param_1);
}
puVar2 = puVar2 + 1;
} while (puVar3 != puVar2);
}
puVar4 = puVar4 + 1;
} while (puVar4 != puVar1 + param_3);
}
return puVar1;
} |
4,860 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str1) {
int total = 0;
while(*str1) {
total++;
str1++;
}
return total;
}
| int main() {
assert(func0("python programming") == 18);
assert(func0("language") == 8);
assert(func0("words") == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1167 <func0+0x1e>
addl $0x1,-0x4(%rbp)
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 115e <func0+0x15>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_1167
loc_115E:
add [rbp+var_4], 1
add [rbp+var_18], 1
loc_1167:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_115E
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(_BYTE *a1)
{
unsigned int v3; // [rsp+14h] [rbp-4h]
v3 = 0;
while ( *a1 )
{
++v3;
++a1;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101167
LAB_0010115e:
ADD dword ptr [RBP + -0x4],0x1
ADD qword ptr [RBP + -0x18],0x1
LAB_00101167:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010115e
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(char *param_1)
{
char *local_20;
int local_c;
local_c = 0;
for (local_20 = param_1; *local_20 != '\0'; local_20 = local_20 + 1) {
local_c = local_c + 1;
}
return local_c;
} |
4,861 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str1) {
int total = 0;
while(*str1) {
total++;
str1++;
}
return total;
}
| int main() {
assert(func0("python programming") == 18);
assert(func0("language") == 8);
assert(func0("words") == 5);
return 0;
}
| O1 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 116b <func0+0x22>
mov %rdi,%rax
mov $0x1,%edx
sub %edi,%edx
lea (%rdx,%rax,1),%ecx
add $0x1,%rax
cmpb $0x0,(%rax)
jne 115c <func0+0x13>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1168 <func0+0x1f>
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_116B
mov rax, rdi
mov edx, 1
sub edx, edi
loc_115C:
lea ecx, [rdx+rax]
add rax, 1
cmp byte ptr [rax], 0
jnz short loc_115C
loc_1168:
mov eax, ecx
retn
loc_116B:
mov ecx, 0
jmp short loc_1168 | long long func0(_BYTE *a1)
{
_BYTE *v1; // rax
unsigned int v2; // ecx
if ( *a1 )
{
v1 = a1;
do
v2 = 1 - (_DWORD)a1 + (_DWORD)v1++;
while ( *v1 );
}
else
{
return 0;
}
return v2;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x0010116b
MOV RAX,RDI
MOV EDX,0x1
SUB EDX,EDI
LAB_0010115c:
LEA ECX,[RDX + RAX*0x1]
ADD RAX,0x1
CMP byte ptr [RAX],0x0
JNZ 0x0010115c
LAB_00101168:
MOV EAX,ECX
RET
LAB_0010116b:
MOV ECX,0x0
JMP 0x00101168 | int func0(char *param_1)
{
int iVar1;
int iVar2;
iVar2 = (int)param_1;
if (*param_1 == '\0') {
iVar1 = 0;
}
else {
do {
iVar1 = (1 - iVar2) + (int)param_1;
param_1 = param_1 + 1;
} while (*param_1 != '\0');
}
return iVar1;
} |
4,862 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str1) {
int total = 0;
while(*str1) {
total++;
str1++;
}
return total;
}
| int main() {
assert(func0("python programming") == 18);
assert(func0("language") == 8);
assert(func0("words") == 5);
return 0;
}
| O2 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 1278 <func0+0x28>
mov $0x1,%eax
sub %edi,%eax
lea (%rax,%rdi,1),%r8d
add $0x1,%rdi
cmpb $0x0,(%rdi)
jne 1260 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1278
mov eax, 1
sub eax, edi
loc_1260:
lea r8d, [rax+rdi]
add rdi, 1
cmp byte ptr [rdi], 0
jnz short loc_1260
mov eax, r8d
retn
loc_1278:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_BYTE *a1)
{
int v1; // eax
unsigned int v2; // r8d
if ( !*a1 )
return 0LL;
v1 = 1 - (_DWORD)a1;
do
v2 = v1 + (_DWORD)a1++;
while ( *a1 );
return v2;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101278
MOV EAX,0x1
SUB EAX,EDI
LAB_00101260:
LEA R8D,[RAX + RDI*0x1]
ADD RDI,0x1
CMP byte ptr [RDI],0x0
JNZ 0x00101260
MOV EAX,R8D
RET
LAB_00101278:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(char *param_1)
{
int iVar1;
int iVar2;
if (*param_1 != '\0') {
iVar2 = (int)param_1;
do {
iVar1 = (int)param_1;
param_1 = param_1 + 1;
} while (*param_1 != '\0');
return (1 - iVar2) + iVar1;
}
return 0;
} |
4,863 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str1) {
int total = 0;
while(*str1) {
total++;
str1++;
}
return total;
}
| int main() {
assert(func0("python programming") == 18);
assert(func0("language") == 8);
assert(func0("words") == 5);
return 0;
}
| O3 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 1258 <func0+0x28>
mov $0x1,%eax
sub %edi,%eax
lea (%rax,%rdi,1),%r8d
add $0x1,%rdi
cmpb $0x0,(%rdi)
jne 1240 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1180
sub rsp, 8
add rdi, 1; s
call _strlen
add rsp, 8
add eax, 1
retn
loc_1180:
xor eax, eax
retn | long long func0(long long a1)
{
if ( *(_BYTE *)a1 )
return (unsigned int)strlen((const char *)(a1 + 1)) + 1;
else
return 0LL;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101180
SUB RSP,0x8
ADD RDI,0x1
CALL 0x00101050
ADD RSP,0x8
ADD EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
RET | int func0(char *param_1)
{
size_t sVar1;
if (*param_1 != '\0') {
sVar1 = strlen(param_1 + 1);
return (int)sVar1 + 1;
}
return 0;
} |
4,864 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *key;
char **values;
int values_size;
int num_values;
} DictItem;
DictItem *find_or_create(DictItem **dict, int *size, char *key) {
for (int i = 0; i < *size; i++) {
if (strcmp(dict[i]->key, key) == 0) {
return dict[i];
}
}
DictItem *item = malloc(sizeof(DictItem));
item->key = strdup(key);
item->values = malloc(sizeof(char*) * 10);
item->values_size = 10;
item->num_values = 0;
dict[*size] = item;
(*size)++;
return item;
}
void add_value(DictItem *item, char *value) {
for (int i = 0; i < item->num_values; i++) {
if (strcmp(item->values[i], value) == 0) {
return;
}
}
if (item->num_values == item->values_size) {
item->values_size += 10;
item->values = realloc(item->values, item->values_size * sizeof(char *));
}
item->values[item->num_values] = strdup(value);
item->num_values++;
}
| DictItem **func0(char *lst[], int lst_size) {
DictItem **dict = malloc(sizeof(DictItem*) * 10);
int dict_size = 0;
for (int i = 0; i < lst_size; i += 2) {
char *key = lst[i];
char *value = lst[i+1];
DictItem *item = find_or_create(dict, &dict_size, key);
add_value(item, value);
}
return dict;
}
| int main(void) {
char *test1[] = { "1", "Jake", "2", "Bob", "1", "Cara" };
DictItem **res1 = func0(test1, 6);
assert(res1[0]->num_values == 2);
assert(res1[1]->num_values == 1);
char *test2[] = { "b", "ball", "a", "arm", "b", "b", "a", "ant" };
DictItem **res2 = func0(test2, 8);
assert(res2[0]->num_values == 2);
assert(res2[1]->num_values == 2);
char *test3[] = { "2", "Mark", "3", "Maze", "2", "Sara" };
DictItem **res3 = func0(test3, 6);
assert(res3[0]->num_values == 2);
assert(res3[1]->num_values == 1);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov $0x50,%edi
callq 10f0 <malloc@plt>
mov %rax,-0x28(%rbp)
movl $0x0,-0x30(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 149f <func0+0xac>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x20(%rbp)
mov -0x2c(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x18(%rbp)
mov -0x20(%rbp),%rdx
lea -0x30(%rbp),%rcx
mov -0x28(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1209 <find_or_create>
mov %rax,-0x10(%rbp)
mov -0x18(%rbp),%rdx
mov -0x10(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1304 <add_value>
addl $0x2,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1433 <func0+0x40>
mov -0x28(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 14bf <func0+0xcc>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edi, 50h ; 'P'; size
call _malloc
mov [rbp+var_28], rax
mov [rbp+var_30], 0
mov [rbp+var_2C], 0
jmp short loc_149E
loc_1432:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov [rbp+var_20], rax
mov eax, [rbp+var_2C]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov [rbp+var_18], rax
mov rdx, [rbp+var_20]
lea rcx, [rbp+var_30]
mov rax, [rbp+var_28]
mov rsi, rcx
mov rdi, rax
call find_or_create
mov [rbp+var_10], rax
mov rdx, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, rdx
mov rdi, rax
call add_value
add [rbp+var_2C], 2
loc_149E:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_3C]
jl short loc_1432
mov rax, [rbp+var_28]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_14BE
call ___stack_chk_fail
locret_14BE:
leave
retn | void * func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-30h] BYREF
int i; // [rsp+14h] [rbp-2Ch]
void *v5; // [rsp+18h] [rbp-28h]
long long v6; // [rsp+20h] [rbp-20h]
long long v7; // [rsp+28h] [rbp-18h]
long long v8; // [rsp+30h] [rbp-10h]
unsigned long long v9; // [rsp+38h] [rbp-8h]
v9 = __readfsqword(0x28u);
v5 = malloc(0x50uLL);
v3 = 0;
for ( i = 0; i < a2; i += 2 )
{
v6 = *(_QWORD *)(8LL * i + a1);
v7 = *(_QWORD *)(8 * (i + 1LL) + a1);
v8 = find_or_create(v5, &v3, v6);
add_value(v8, v7);
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDI,0x50
CALL 0x001010f0
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0010149e
LAB_00101432:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RDX,qword ptr [RBP + -0x20]
LEA RCX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101209
MOV qword ptr [RBP + -0x10],RAX
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101304
ADD dword ptr [RBP + -0x2c],0x2
LAB_0010149e:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101432
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014be
CALL 0x001010c0
LAB_001014be:
LEAVE
RET | void * func0(long param_1,int param_2)
{
long in_FS_OFFSET;
int4 local_38;
int local_34;
void *local_30;
int8 local_28;
int8 local_20;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = malloc(0x50);
local_38 = 0;
for (local_34 = 0; local_34 < param_2; local_34 = local_34 + 2) {
local_28 = *(int8 *)(param_1 + (long)local_34 * 8);
local_20 = *(int8 *)(param_1 + ((long)local_34 + 1) * 8);
local_18 = find_or_create(local_30,&local_38,local_28);
add_value(local_18,local_20);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_30;
} |
4,865 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *key;
char **values;
int values_size;
int num_values;
} DictItem;
DictItem *find_or_create(DictItem **dict, int *size, char *key) {
for (int i = 0; i < *size; i++) {
if (strcmp(dict[i]->key, key) == 0) {
return dict[i];
}
}
DictItem *item = malloc(sizeof(DictItem));
item->key = strdup(key);
item->values = malloc(sizeof(char*) * 10);
item->values_size = 10;
item->num_values = 0;
dict[*size] = item;
(*size)++;
return item;
}
void add_value(DictItem *item, char *value) {
for (int i = 0; i < item->num_values; i++) {
if (strcmp(item->values[i], value) == 0) {
return;
}
}
if (item->num_values == item->values_size) {
item->values_size += 10;
item->values = realloc(item->values, item->values_size * sizeof(char *));
}
item->values[item->num_values] = strdup(value);
item->num_values++;
}
| DictItem **func0(char *lst[], int lst_size) {
DictItem **dict = malloc(sizeof(DictItem*) * 10);
int dict_size = 0;
for (int i = 0; i < lst_size; i += 2) {
char *key = lst[i];
char *value = lst[i+1];
DictItem *item = find_or_create(dict, &dict_size, key);
add_value(item, value);
}
return dict;
}
| int main(void) {
char *test1[] = { "1", "Jake", "2", "Bob", "1", "Cara" };
DictItem **res1 = func0(test1, 6);
assert(res1[0]->num_values == 2);
assert(res1[1]->num_values == 1);
char *test2[] = { "b", "ball", "a", "arm", "b", "b", "a", "ant" };
DictItem **res2 = func0(test2, 8);
assert(res2[0]->num_values == 2);
assert(res2[1]->num_values == 2);
char *test3[] = { "2", "Mark", "3", "Maze", "2", "Sara" };
DictItem **res3 = func0(test3, 6);
assert(res3[0]->num_values == 2);
assert(res3[1]->num_values == 1);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%r13
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov $0x50,%edi
callq 10f0 <malloc@plt>
mov %rax,%r12
movl $0x0,0x4(%rsp)
test %ebp,%ebp
jle 13ad <func0+0x7c>
mov %r13,%rbx
sub $0x1,%ebp
shr %ebp
mov %ebp,%ebp
shl $0x4,%rbp
lea 0x10(%r13,%rbp,1),%r14
lea 0x4(%rsp),%r13
mov 0x8(%rbx),%rbp
mov (%rbx),%rdx
mov %r13,%rsi
mov %r12,%rdi
callq 1209 <find_or_create>
mov %rax,%rdi
mov %rbp,%rsi
callq 12a3 <add_value>
add $0x10,%rbx
cmp %r14,%rbx
jne 1387 <func0+0x56>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13cd <func0+0x9c>
mov %r12,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 10c0 <__stack_chk_fail@plt>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov r13, rdi
mov ebp, esi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov edi, 50h ; 'P'
call _malloc
mov r12, rax
mov [rsp+38h+var_34], 0
test ebp, ebp
jle short loc_13AD
mov rbx, r13
sub ebp, 1
shr ebp, 1
mov ebp, ebp
shl rbp, 4
lea r14, [r13+rbp+10h]
lea r13, [rsp+38h+var_34]
loc_1387:
mov rbp, [rbx+8]
mov rdx, [rbx]
mov rsi, r13
mov rdi, r12
call find_or_create
mov rdi, rax
mov rsi, rbp
call add_value
add rbx, 10h
cmp rbx, r14
jnz short loc_1387
loc_13AD:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_13CD
mov rax, r12
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_13CD:
call ___stack_chk_fail | long long func0(_QWORD *a1, int a2)
{
long long v2; // r12
_QWORD *v3; // rbx
long long v4; // rbp
long long v5; // rax
int v7; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-30h]
v8 = __readfsqword(0x28u);
v2 = malloc(80LL);
v7 = 0;
if ( a2 > 0 )
{
v3 = a1;
do
{
v4 = v3[1];
v5 = find_or_create(v2, &v7, *v3);
add_value(v5, v4);
v3 += 2;
}
while ( v3 != &a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2] );
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV R13,RDI
MOV EBP,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV EDI,0x50
CALL 0x001010f0
MOV R12,RAX
MOV dword ptr [RSP + 0x4],0x0
TEST EBP,EBP
JLE 0x001013ad
MOV RBX,R13
SUB EBP,0x1
SHR EBP,0x1
MOV EBP,EBP
SHL RBP,0x4
LEA R14,[R13 + RBP*0x1 + 0x10]
LEA R13,[RSP + 0x4]
LAB_00101387:
MOV RBP,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBX]
MOV RSI,R13
MOV RDI,R12
CALL 0x00101209
MOV RDI,RAX
MOV RSI,RBP
CALL 0x001012a3
ADD RBX,0x10
CMP RBX,R14
JNZ 0x00101387
LAB_001013ad:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013cd
MOV RAX,R12
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013cd:
CALL 0x001010c0 | void * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int8 uVar2;
void *pvVar3;
int8 uVar4;
long in_FS_OFFSET;
int4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pvVar3 = malloc(0x50);
local_34 = 0;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
do {
uVar2 = param_1[1];
uVar4 = find_or_create(pvVar3,&local_34,*param_1);
add_value(uVar4,uVar2);
param_1 = param_1 + 2;
} while (param_1 != puVar1);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,866 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *key;
char **values;
int values_size;
int num_values;
} DictItem;
DictItem *find_or_create(DictItem **dict, int *size, char *key) {
for (int i = 0; i < *size; i++) {
if (strcmp(dict[i]->key, key) == 0) {
return dict[i];
}
}
DictItem *item = malloc(sizeof(DictItem));
item->key = strdup(key);
item->values = malloc(sizeof(char*) * 10);
item->values_size = 10;
item->num_values = 0;
dict[*size] = item;
(*size)++;
return item;
}
void add_value(DictItem *item, char *value) {
for (int i = 0; i < item->num_values; i++) {
if (strcmp(item->values[i], value) == 0) {
return;
}
}
if (item->num_values == item->values_size) {
item->values_size += 10;
item->values = realloc(item->values, item->values_size * sizeof(char *));
}
item->values[item->num_values] = strdup(value);
item->num_values++;
}
| DictItem **func0(char *lst[], int lst_size) {
DictItem **dict = malloc(sizeof(DictItem*) * 10);
int dict_size = 0;
for (int i = 0; i < lst_size; i += 2) {
char *key = lst[i];
char *value = lst[i+1];
DictItem *item = find_or_create(dict, &dict_size, key);
add_value(item, value);
}
return dict;
}
| int main(void) {
char *test1[] = { "1", "Jake", "2", "Bob", "1", "Cara" };
DictItem **res1 = func0(test1, 6);
assert(res1[0]->num_values == 2);
assert(res1[1]->num_values == 1);
char *test2[] = { "b", "ball", "a", "arm", "b", "b", "a", "ant" };
DictItem **res2 = func0(test2, 8);
assert(res2[0]->num_values == 2);
assert(res2[1]->num_values == 2);
char *test3[] = { "2", "Mark", "3", "Maze", "2", "Sara" };
DictItem **res3 = func0(test3, 6);
assert(res3[0]->num_values == 2);
assert(res3[1]->num_values == 1);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov $0x50,%edi
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
callq 10f0 <malloc@plt>
movl $0x0,0x4(%rsp)
mov %rax,%r14
test %ebp,%ebp
jle 164e <func0+0x7e>
sub $0x1,%ebp
lea 0x4(%rsp),%r12
shr %ebp
shl $0x4,%rbp
lea 0x10(%rbx,%rbp,1),%r13
nopl 0x0(%rax)
mov (%rbx),%rdx
mov 0x8(%rbx),%rbp
mov %r12,%rsi
mov %r14,%rdi
add $0x10,%rbx
callq 1460 <find_or_create>
mov %rbp,%rsi
mov %rax,%rdi
callq 1510 <add_value>
cmp %r13,%rbx
jne 1628 <func0+0x58>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 166e <func0+0x9e>
add $0x10,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 10c0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
mov edi, 50h ; 'P'
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
call _malloc
mov [rsp+38h+var_34], 0
mov r14, rax
test ebp, ebp
jle short loc_164E
sub ebp, 1
lea r12, [rsp+38h+var_34]
shr ebp, 1
shl rbp, 4
lea r13, [rbx+rbp+10h]
nop dword ptr [rax+00000000h]
loc_1628:
mov rdx, [rbx]
mov rbp, [rbx+8]
mov rsi, r12
mov rdi, r14
add rbx, 10h
call find_or_create
mov rsi, rbp
mov rdi, rax
call add_value
cmp rbx, r13
jnz short loc_1628
loc_164E:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_166E
add rsp, 10h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_166E:
call ___stack_chk_fail | long long func0(long long *a1, int a2)
{
long long *v2; // rbx
long long v3; // r14
long long v4; // rdx
long long v5; // rbp
long long v6; // rax
int v8; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v9; // [rsp+8h] [rbp-30h]
v2 = a1;
v9 = __readfsqword(0x28u);
v8 = 0;
v3 = malloc(80LL);
if ( a2 > 0 )
{
do
{
v4 = *v2;
v5 = v2[1];
v2 += 2;
v6 = find_or_create(v3, &v8, v4);
add_value(v6, v5);
}
while ( v2 != &a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2] );
}
return v3;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
MOV EDI,0x50
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV dword ptr [RSP + 0x4],0x0
MOV R14,RAX
TEST EBP,EBP
JLE 0x0010164e
SUB EBP,0x1
LEA R12,[RSP + 0x4]
SHR EBP,0x1
SHL RBP,0x4
LEA R13,[RBX + RBP*0x1 + 0x10]
NOP dword ptr [RAX]
LAB_00101628:
MOV RDX,qword ptr [RBX]
MOV RBP,qword ptr [RBX + 0x8]
MOV RSI,R12
MOV RDI,R14
ADD RBX,0x10
CALL 0x00101460
MOV RSI,RBP
MOV RDI,RAX
CALL 0x00101510
CMP RBX,R13
JNZ 0x00101628
LAB_0010164e:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010166e
ADD RSP,0x10
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010166e:
CALL 0x001010c0 | void * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int8 uVar2;
void *pvVar3;
int8 uVar4;
long in_FS_OFFSET;
int4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pvVar3 = malloc(0x50);
local_34 = 0;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
do {
uVar4 = *param_1;
uVar2 = param_1[1];
param_1 = param_1 + 2;
uVar4 = find_or_create(pvVar3,&local_34,uVar4);
add_value(uVar4,uVar2);
} while (param_1 != puVar1);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,867 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *key;
char **values;
int values_size;
int num_values;
} DictItem;
DictItem *find_or_create(DictItem **dict, int *size, char *key) {
for (int i = 0; i < *size; i++) {
if (strcmp(dict[i]->key, key) == 0) {
return dict[i];
}
}
DictItem *item = malloc(sizeof(DictItem));
item->key = strdup(key);
item->values = malloc(sizeof(char*) * 10);
item->values_size = 10;
item->num_values = 0;
dict[*size] = item;
(*size)++;
return item;
}
void add_value(DictItem *item, char *value) {
for (int i = 0; i < item->num_values; i++) {
if (strcmp(item->values[i], value) == 0) {
return;
}
}
if (item->num_values == item->values_size) {
item->values_size += 10;
item->values = realloc(item->values, item->values_size * sizeof(char *));
}
item->values[item->num_values] = strdup(value);
item->num_values++;
}
| DictItem **func0(char *lst[], int lst_size) {
DictItem **dict = malloc(sizeof(DictItem*) * 10);
int dict_size = 0;
for (int i = 0; i < lst_size; i += 2) {
char *key = lst[i];
char *value = lst[i+1];
DictItem *item = find_or_create(dict, &dict_size, key);
add_value(item, value);
}
return dict;
}
| int main(void) {
char *test1[] = { "1", "Jake", "2", "Bob", "1", "Cara" };
DictItem **res1 = func0(test1, 6);
assert(res1[0]->num_values == 2);
assert(res1[1]->num_values == 1);
char *test2[] = { "b", "ball", "a", "arm", "b", "b", "a", "ant" };
DictItem **res2 = func0(test2, 8);
assert(res2[0]->num_values == 2);
assert(res2[1]->num_values == 2);
char *test3[] = { "2", "Mark", "3", "Maze", "2", "Sara" };
DictItem **res3 = func0(test3, 6);
assert(res3[0]->num_values == 2);
assert(res3[1]->num_values == 1);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov $0x50,%edi
sub $0x28,%rsp
callq 10f0 <malloc@plt>
mov %rax,0x10(%rsp)
test %ebp,%ebp
jle 170d <func0+0xed>
sub $0x1,%ebp
shr %ebp
shl $0x4,%rbp
lea 0x10(%rbx,%rbp,1),%rax
xor %ebp,%ebp
mov %rax,0x18(%rsp)
nopl 0x0(%rax,%rax,1)
mov (%rbx),%r12
mov 0x8(%rbx),%r13
test %ebp,%ebp
je 1728 <func0+0x108>
mov 0x10(%rsp),%rdx
lea -0x1(%rbp),%eax
lea 0x8(%rdx,%rax,8),%rax
mov %rdx,%r14
mov %rax,(%rsp)
jmp 169e <func0+0x7e>
nopl (%rax)
add $0x8,%r14
cmp %r14,(%rsp)
je 1728 <func0+0x108>
mov (%r14),%r15
mov %r12,%rsi
mov (%r15),%rdi
callq 10e0 <strcmp@plt>
test %eax,%eax
jne 1690 <func0+0x70>
mov 0x14(%r15),%r14d
mov 0x8(%r15),%r12
test %r14d,%r14d
jle 17a0 <func0+0x180>
lea -0x1(%r14),%eax
mov %r12,%r9
lea 0x8(%r12,%rax,8),%rax
mov %rax,0x8(%rsp)
jmp 16eb <func0+0xcb>
nopl 0x0(%rax)
mov (%rsp),%r9
add $0x8,%r9
cmp %r9,0x8(%rsp)
je 17a0 <func0+0x180>
mov (%r9),%rdi
mov %r13,%rsi
mov %r9,(%rsp)
callq 10e0 <strcmp@plt>
test %eax,%eax
jne 16d8 <func0+0xb8>
add $0x10,%rbx
cmp %rbx,0x18(%rsp)
jne 1668 <func0+0x48>
mov 0x10(%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov $0x18,%edi
xor %r14d,%r14d
callq 10f0 <malloc@plt>
mov %r12,%rdi
mov %rax,%r15
callq 1110 <strdup@plt>
mov $0x50,%edi
mov %rax,(%r15)
callq 10f0 <malloc@plt>
mov 0x10(%rsp),%rcx
movq $0xa,0x10(%r15)
mov %rax,0x8(%r15)
mov %rax,%r12
movslq %ebp,%rax
add $0x1,%ebp
mov %r15,(%rcx,%rax,8)
mov %r13,%rdi
add $0x10,%rbx
callq 1110 <strdup@plt>
lea 0x1(%r14),%ecx
mov %rax,%r9
movslq %r14d,%rax
mov %r9,(%r12,%rax,8)
mov %ecx,0x14(%r15)
cmp %rbx,0x18(%rsp)
jne 1668 <func0+0x48>
jmpq 170d <func0+0xed>
nopl 0x0(%rax)
mov 0x10(%r15),%eax
cmp %eax,%r14d
jne 176b <func0+0x14b>
lea 0xa(%r14),%ecx
mov %r12,%rdi
mov %ecx,0x10(%r15)
movslq %ecx,%rcx
lea 0x0(,%rcx,8),%rsi
callq 1100 <realloc@plt>
mov 0x14(%r15),%r14d
mov %rax,0x8(%r15)
mov %rax,%r12
jmp 176b <func0+0x14b>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
mov ebx, esi
sub rsp, 28h
call _malloc
mov [rsp+58h+var_50], rax
test ebx, ebx
jle loc_1773
lea eax, [rbx-1]
mov [rsp+58h+var_48], 0
shr eax, 1
shl rax, 4
lea rax, [r14+rax+10h]
mov [rsp+58h+var_40], rax
nop dword ptr [rax+00000000h]
loc_16D0:
mov eax, [rsp+58h+var_48]
mov r12, [r14]
mov rbp, [r14+8]
test eax, eax
jle loc_1787
mov rcx, [rsp+58h+var_50]
movsxd rax, [rsp+58h+var_48]
mov r15, rcx
mov [rsp+58h+var_58], rax
lea r13, [rcx+rax*8]
jmp short loc_170D
loc_1700:
add r15, 8
cmp r13, r15
jz loc_1790
loc_170D:
mov rbx, [r15]
mov rsi, r12; s2
mov rdi, [rbx]; s1
call _strcmp
test eax, eax
jnz short loc_1700
movsxd rax, dword ptr [rbx+14h]
mov r13, [rbx+8]
mov [rsp+58h+var_44], eax
test eax, eax
jle loc_1849
shl rax, 3
mov r15, r13
mov [rsp+58h+var_58], rax
lea r12, [r13+rax+0]
jmp short loc_1755
loc_1748:
add r15, 8
cmp r15, r12
jz loc_1810
loc_1755:
mov rdi, [r15]; s1
mov rsi, rbp; s2
call _strcmp
test eax, eax
jnz short loc_1748
add r14, 10h
cmp [rsp+58h+var_40], r14
jnz loc_16D0
loc_1773:
mov rax, [rsp+58h+var_50]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1787:
movsxd rax, [rsp+58h+var_48]
mov [rsp+58h+var_58], rax
loc_1790:
mov edi, 18h; size
call _malloc
mov rdi, r12; s
mov r12d, 1
mov rbx, rax
call _strdup
mov edi, 50h ; 'P'; size
mov [rbx], rax
call _malloc
mov rdx, [rsp+58h+var_58]
add [rsp+58h+var_48], 1
mov [rbx+8], rax
mov r13, rax
mov rax, cs:qword_2100
mov [rsp+58h+var_58], 0
mov [rbx+10h], rax
mov rax, [rsp+58h+var_50]
mov [rax+rdx*8], rbx
loc_17E4:
mov rdi, rbp; s
add r14, 10h
call _strdup
mov rdx, [rsp+58h+var_58]
mov [rbx+14h], r12d
mov [r13+rdx+0], rax
cmp [rsp+58h+var_40], r14
jnz loc_16D0
jmp loc_1773
loc_1810:
mov edx, [rsp+58h+var_44]
mov eax, [rbx+10h]
lea r12d, [rdx+1]
loc_181B:
mov r15d, [rsp+58h+var_44]
cmp r15d, eax
jnz short loc_17E4
add r15d, 0Ah
mov rdi, r13; ptr
mov [rbx+10h], r15d
movsxd r15, r15d
lea rsi, ds:0[r15*8]; size
call _realloc
mov [rbx+8], rax
mov r13, rax
jmp short loc_17E4
loc_1849:
movsxd rdx, [rsp+58h+var_44]
mov eax, [rbx+10h]
mov rcx, rdx
shl rdx, 3
mov [rsp+58h+var_58], rdx
lea r12d, [rcx+1]
jmp short loc_181B | const char *** func0(const char **a1, int a2)
{
const char **v2; // r14
const char *v3; // r12
const char *v4; // rbp
const char ***v5; // r15
const char **v6; // rbx
long long v7; // rax
char *v8; // r13
const char **v9; // r15
const char **v10; // r12
const char *v12; // rdi
int v13; // r12d
const char *v14; // rax
long long v15; // rdx
char *v16; // rax
int v17; // eax
const char *v18; // rax
long long v19; // [rsp+0h] [rbp-58h]
long long v20; // [rsp+0h] [rbp-58h]
const char ***v21; // [rsp+8h] [rbp-50h]
int v22; // [rsp+10h] [rbp-48h]
int v23; // [rsp+14h] [rbp-44h]
long long v24; // [rsp+18h] [rbp-40h]
v2 = a1;
v21 = (const char ***)malloc(0x50uLL);
if ( a2 <= 0 )
return v21;
v22 = 0;
v24 = (long long)&a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
while ( 1 )
{
LABEL_3:
v3 = *v2;
v4 = v2[1];
if ( v22 <= 0 )
{
v19 = v22;
LABEL_14:
v12 = v3;
v13 = 1;
v6 = (const char **)malloc(0x18uLL);
*v6 = strdup(v12);
v14 = (const char *)malloc(0x50uLL);
v15 = v19;
++v22;
v6[1] = v14;
v8 = (char *)v14;
v20 = 0LL;
v6[2] = byte_9 + 1;
v21[v15] = v6;
goto LABEL_15;
}
v5 = v21;
v19 = v22;
while ( 1 )
{
v6 = *v5;
if ( !strcmp(**v5, v3) )
break;
if ( &v21[v22] == ++v5 )
goto LABEL_14;
}
v7 = *((int *)v6 + 5);
v8 = (char *)v6[1];
v23 = v7;
if ( (int)v7 > 0 )
break;
v17 = *((_DWORD *)v6 + 4);
v20 = 8LL * v23;
v13 = v23 + 1;
LABEL_18:
if ( v23 == v17 )
{
*((_DWORD *)v6 + 4) = v23 + 10;
v18 = (const char *)realloc(v8, 8LL * (v23 + 10));
v6[1] = v18;
v8 = (char *)v18;
}
LABEL_15:
v2 += 2;
v16 = strdup(v4);
*((_DWORD *)v6 + 5) = v13;
*(_QWORD *)&v8[v20] = v16;
if ( (const char **)v24 == v2 )
return v21;
}
v9 = (const char **)v6[1];
v20 = 8 * v7;
v10 = (const char **)&v8[8 * v7];
while ( strcmp(*v9, v4) )
{
if ( ++v9 == v10 )
{
v17 = *((_DWORD *)v6 + 4);
v13 = v23 + 1;
goto LABEL_18;
}
}
v2 += 2;
if ( (const char **)v24 != v2 )
goto LABEL_3;
return v21;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x28
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
TEST EBX,EBX
JLE 0x00101773
LEA EAX,[RBX + -0x1]
MOV dword ptr [RSP + 0x10],0x0
SHR EAX,0x1
SHL RAX,0x4
LEA RAX,[R14 + RAX*0x1 + 0x10]
MOV qword ptr [RSP + 0x18],RAX
NOP dword ptr [RAX]
LAB_001016d0:
MOV EAX,dword ptr [RSP + 0x10]
MOV R12,qword ptr [R14]
MOV RBP,qword ptr [R14 + 0x8]
TEST EAX,EAX
JLE 0x00101787
MOV RCX,qword ptr [RSP + 0x8]
MOVSXD RAX,dword ptr [RSP + 0x10]
MOV R15,RCX
MOV qword ptr [RSP],RAX
LEA R13,[RCX + RAX*0x8]
JMP 0x0010170d
LAB_00101700:
ADD R15,0x8
CMP R13,R15
JZ 0x00101790
LAB_0010170d:
MOV RBX,qword ptr [R15]
MOV RSI,R12
MOV RDI,qword ptr [RBX]
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101700
MOVSXD RAX,dword ptr [RBX + 0x14]
MOV R13,qword ptr [RBX + 0x8]
MOV dword ptr [RSP + 0x14],EAX
TEST EAX,EAX
JLE 0x00101849
SHL RAX,0x3
MOV R15,R13
MOV qword ptr [RSP],RAX
LEA R12,[R13 + RAX*0x1]
JMP 0x00101755
LAB_00101748:
ADD R15,0x8
CMP R15,R12
JZ 0x00101810
LAB_00101755:
MOV RDI,qword ptr [R15]
MOV RSI,RBP
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101748
ADD R14,0x10
CMP qword ptr [RSP + 0x18],R14
JNZ 0x001016d0
LAB_00101773:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101787:
MOVSXD RAX,dword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
LAB_00101790:
MOV EDI,0x18
CALL 0x001010f0
MOV RDI,R12
MOV R12D,0x1
MOV RBX,RAX
CALL 0x00101110
MOV EDI,0x50
MOV qword ptr [RBX],RAX
CALL 0x001010f0
MOV RDX,qword ptr [RSP]
ADD dword ptr [RSP + 0x10],0x1
MOV qword ptr [RBX + 0x8],RAX
MOV R13,RAX
MOV RAX,qword ptr [0x00102100]
MOV qword ptr [RSP],0x0
MOV qword ptr [RBX + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + RDX*0x8],RBX
LAB_001017e4:
MOV RDI,RBP
ADD R14,0x10
CALL 0x00101110
MOV RDX,qword ptr [RSP]
MOV dword ptr [RBX + 0x14],R12D
MOV qword ptr [R13 + RDX*0x1],RAX
CMP qword ptr [RSP + 0x18],R14
JNZ 0x001016d0
JMP 0x00101773
LAB_00101810:
MOV EDX,dword ptr [RSP + 0x14]
MOV EAX,dword ptr [RBX + 0x10]
LEA R12D,[RDX + 0x1]
LAB_0010181b:
MOV R15D,dword ptr [RSP + 0x14]
CMP R15D,EAX
JNZ 0x001017e4
ADD R15D,0xa
MOV RDI,R13
MOV dword ptr [RBX + 0x10],R15D
MOVSXD R15,R15D
LEA RSI,[R15*0x8]
CALL 0x00101100
MOV qword ptr [RBX + 0x8],RAX
MOV R13,RAX
JMP 0x001017e4
LAB_00101849:
MOVSXD RDX,dword ptr [RSP + 0x14]
MOV EAX,dword ptr [RBX + 0x10]
MOV RCX,RDX
SHL RDX,0x3
MOV qword ptr [RSP],RDX
LEA R12D,[RCX + 0x1]
JMP 0x0010181b | long * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s2;
long lVar2;
int iVar3;
int iVar4;
long *plVar5;
int8 *puVar6;
char *pcVar7;
int8 *__ptr;
int iVar8;
long *plVar9;
int8 *puVar10;
long local_58;
int local_48;
plVar5 = (long *)malloc(0x50);
if (param_2 < 1) {
return plVar5;
}
local_48 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
LAB_001016d0:
pcVar7 = (char *)*param_1;
__s2 = (char *)param_1[1];
if (0 < local_48) {
plVar9 = plVar5;
do {
puVar6 = (int8 *)*plVar9;
iVar3 = strcmp((char *)*puVar6,pcVar7);
if (iVar3 == 0) {
iVar3 = *(int *)((long)puVar6 + 0x14);
__ptr = (int8 *)puVar6[1];
if (0 < iVar3) {
local_58 = (long)iVar3 * 8;
puVar10 = __ptr;
goto LAB_00101755;
}
iVar4 = *(int *)(puVar6 + 2);
local_58 = (long)iVar3 << 3;
goto LAB_0010181b;
}
plVar9 = plVar9 + 1;
} while (plVar5 + local_48 != plVar9);
}
local_58 = (long)local_48;
lVar2 = local_58;
puVar6 = (int8 *)malloc(0x18);
iVar8 = 1;
pcVar7 = strdup(pcVar7);
*puVar6 = pcVar7;
__ptr = (int8 *)malloc(0x50);
local_48 = local_48 + 1;
puVar6[1] = __ptr;
local_58 = 0;
puVar6[2] = DAT_00102100;
plVar5[lVar2] = (long)puVar6;
goto LAB_001017e4;
while (puVar10 = puVar10 + 1, puVar10 != __ptr + iVar3) {
LAB_00101755:
iVar4 = strcmp((char *)*puVar10,__s2);
if (iVar4 == 0) {
param_1 = param_1 + 2;
if (puVar1 == param_1) {
return plVar5;
}
goto LAB_001016d0;
}
}
iVar4 = *(int *)(puVar6 + 2);
LAB_0010181b:
iVar8 = iVar3 + 1;
if (iVar3 == iVar4) {
*(int *)(puVar6 + 2) = iVar3 + 10;
__ptr = (int8 *)realloc(__ptr,(long)(iVar3 + 10) * 8);
puVar6[1] = __ptr;
}
LAB_001017e4:
param_1 = param_1 + 2;
pcVar7 = strdup(__s2);
*(int *)((long)puVar6 + 0x14) = iVar8;
*(char **)((long)__ptr + local_58) = pcVar7;
if (puVar1 == param_1) {
return plVar5;
}
goto LAB_001016d0;
} |
4,868 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int N) {
int nextN = (int)floor(sqrt(N)) + 1;
return nextN * nextN;
}
| int main() {
assert(func0(35) == 36);
assert(func0(6) == 9);
assert(func0(9) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
callq 1090 <sqrt@plt>
callq 1080 <floor@plt>
cvttsd2si %xmm0,%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
movq rax, xmm1
movq xmm0, rax; x
call _sqrt
movq rax, xmm0
movq xmm0, rax; x
call _floor
cvttsd2si eax, xmm0
add eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
imul eax, eax
leave
retn | long long func0(int a1)
{
double v1; // xmm0_8
int v3; // [rsp+1Ch] [rbp-4h]
v1 = sqrt((double)a1);
v3 = (int)floor(v1) + 1;
return (unsigned int)(v3 * v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101090
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x00101080
CVTTSD2SI EAX,XMM0
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
LEAVE
RET | int func0(int param_1)
{
double dVar1;
dVar1 = sqrt((double)param_1);
dVar1 = floor(dVar1);
return ((int)dVar1 + 1) * ((int)dVar1 + 1);
} |
4,869 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int N) {
int nextN = (int)floor(sqrt(N)) + 1;
return nextN * nextN;
}
| int main() {
assert(func0(35) == 36);
assert(func0(6) == 9);
assert(func0(9) == 16);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movapd %xmm0,%xmm6
sqrtsd %xmm6,%xmm6
movsd %xmm6,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 11fb <func0+0x92>
movsd 0x8(%rsp),%xmm5
movapd %xmm5,%xmm0
movsd 0xeed(%rip),%xmm2
movapd %xmm5,%xmm1
andpd %xmm2,%xmm1
movsd 0xec5(%rip),%xmm3
ucomisd %xmm1,%xmm3
jbe 11ec <func0+0x83>
cvttsd2si %xmm5,%rax
pxor %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
movapd %xmm1,%xmm0
cmpnlesd %xmm5,%xmm0
movsd 0xea8(%rip),%xmm3
andpd %xmm3,%xmm0
subsd %xmm0,%xmm1
andnpd %xmm5,%xmm2
movapd %xmm2,%xmm0
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add $0x1,%eax
imul %eax,%eax
add $0x18,%rsp
retq
callq 1070 <sqrt@plt>
jmp 1191 <func0+0x28>
| func0:
endbr64
sub rsp, 8
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_11EB
sqrtsd xmm0, xmm0
loc_1187:
movapd xmm3, xmm0
movsd xmm2, cs:qword_2070
movapd xmm1, xmm0
andpd xmm1, xmm2
movsd xmm4, cs:qword_2058
ucomisd xmm4, xmm1
jbe short loc_11DC
cvttsd2si rax, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
movsd xmm4, cs:qword_2060
andpd xmm3, xmm4
subsd xmm1, xmm3
andnpd xmm2, xmm0
movapd xmm3, xmm1
orpd xmm3, xmm2
loc_11DC:
cvttsd2si eax, xmm3
add eax, 1
imul eax, eax
add rsp, 8
retn
loc_11EB:
call _sqrt
jmp short loc_1187 | long long func0(int a1)
{
double v1; // xmm0_8
__m128d v2; // xmm0
double v3; // xmm3_8
__m128d v4; // xmm1
v1 = (double)a1;
if ( (double)a1 < 0.0 )
v2.m128d_f64[0] = sqrt(v1);
else
v2.m128d_f64[0] = sqrt(v1);
v3 = v2.m128d_f64[0];
if ( fabs(v2.m128d_f64[0]) < 4.503599627370496e15 )
{
v4 = 0LL;
v4.m128d_f64[0] = (double)(int)v2.m128d_f64[0];
*(_QWORD *)&v3 = COERCE_UNSIGNED_INT64(v4.m128d_f64[0] - COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v4, v2) & 0x3FF0000000000000LL)) | *(_QWORD *)&v2.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)(((int)v3 + 1) * ((int)v3 + 1));
} | func0:
ENDBR64
SUB RSP,0x8
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x001011eb
SQRTSD XMM0,XMM0
LAB_00101187:
MOVAPD XMM3,XMM0
MOVSD XMM2,qword ptr [0x00102070]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVSD XMM4,qword ptr [0x00102058]
UCOMISD XMM4,XMM1
JBE 0x001011dc
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102060]
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ANDNPD XMM2,XMM0
MOVAPD XMM3,XMM1
ORPD XMM3,XMM2
LAB_001011dc:
CVTTSD2SI EAX,XMM3
ADD EAX,0x1
IMUL EAX,EAX
ADD RSP,0x8
RET
LAB_001011eb:
CALL 0x00101070
JMP 0x00101187 | int func0(int param_1)
{
double dVar1;
dVar1 = (double)param_1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
if ((double)((ulong)dVar1 & DAT_00102070) < DAT_00102058) {
dVar1 = (double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_00102060)) |
~DAT_00102070 & (ulong)dVar1);
}
return ((int)dVar1 + 1) * ((int)dVar1 + 1);
} |
4,870 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int N) {
int nextN = (int)floor(sqrt(N)) + 1;
return nextN * nextN;
}
| int main() {
assert(func0(35) == 36);
assert(func0(6) == 9);
assert(func0(9) == 16);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm0,%xmm0
pxor %xmm2,%xmm2
sub $0x18,%rsp
cvtsi2sd %edi,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 1292 <func0+0x82>
movsd 0xe56(%rip),%xmm2
movsd 0xe36(%rip),%xmm3
movapd %xmm1,%xmm0
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
jbe 1283 <func0+0x73>
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movsd 0xe1f(%rip),%xmm4
andnpd %xmm0,%xmm2
cvtsi2sd %rax,%xmm1
movapd %xmm1,%xmm3
cmpnlesd %xmm0,%xmm3
movapd %xmm2,%xmm0
andpd %xmm4,%xmm3
subsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add $0x18,%rsp
add $0x1,%eax
imul %eax,%eax
retq
movsd %xmm1,0x8(%rsp)
callq 1070 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 1232 <func0+0x22>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
sub rsp, 8
cvtsi2sd xmm0, edi
ucomisd xmm1, xmm0
ja short loc_128E
sqrtsd xmm0, xmm0
loc_122E:
movsd xmm2, cs:qword_2070
movsd xmm3, cs:qword_2058
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
jbe short loc_127F
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movsd xmm4, cs:qword_2060
andnpd xmm2, xmm0
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
andpd xmm3, xmm4
subsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
loc_127F:
cvttsd2si eax, xmm0
add rsp, 8
add eax, 1
imul eax, eax
retn
loc_128E:
call _sqrt
jmp short loc_122E | long long func0(int a1)
{
double v1; // xmm0_8
__m128d v2; // xmm0
__m128d v3; // xmm1
v1 = (double)a1;
if ( (double)a1 < 0.0 )
v2.m128d_f64[0] = sqrt(v1);
else
v2.m128d_f64[0] = sqrt(v1);
if ( fabs(v2.m128d_f64[0]) < 4.503599627370496e15 )
{
v3 = 0LL;
v3.m128d_f64[0] = (double)(int)v2.m128d_f64[0];
*(_QWORD *)&v2.m128d_f64[0] = COERCE_UNSIGNED_INT64(
v3.m128d_f64[0]
- COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v3, v2) & 0x3FF0000000000000LL)) | *(_QWORD *)&v2.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)(((int)v2.m128d_f64[0] + 1) * ((int)v2.m128d_f64[0] + 1));
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB RSP,0x8
CVTSI2SD XMM0,EDI
UCOMISD XMM1,XMM0
JA 0x0010128e
SQRTSD XMM0,XMM0
LAB_0010122e:
MOVSD XMM2,qword ptr [0x00102070]
MOVSD XMM3,qword ptr [0x00102058]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JBE 0x0010127f
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVSD XMM4,qword ptr [0x00102060]
ANDNPD XMM2,XMM0
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
LAB_0010127f:
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
ADD EAX,0x1
IMUL EAX,EAX
RET
LAB_0010128e:
CALL 0x00101070
JMP 0x0010122e | int func0(int param_1)
{
double dVar1;
dVar1 = (double)param_1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
if ((double)((ulong)dVar1 & DAT_00102070) < DAT_00102058) {
dVar1 = (double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_00102060)) |
~DAT_00102070 & (ulong)dVar1);
}
return ((int)dVar1 + 1) * ((int)dVar1 + 1);
} |
4,871 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int N) {
int nextN = (int)floor(sqrt(N)) + 1;
return nextN * nextN;
}
| int main() {
assert(func0(35) == 36);
assert(func0(6) == 9);
assert(func0(9) == 16);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm0,%xmm0
pxor %xmm2,%xmm2
sub $0x18,%rsp
cvtsi2sd %edi,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 1292 <func0+0x82>
movsd 0xe56(%rip),%xmm2
movsd 0xe36(%rip),%xmm3
movapd %xmm1,%xmm0
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
jbe 1283 <func0+0x73>
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movsd 0xe1f(%rip),%xmm4
andnpd %xmm0,%xmm2
cvtsi2sd %rax,%xmm1
movapd %xmm1,%xmm3
cmpnlesd %xmm0,%xmm3
movapd %xmm2,%xmm0
andpd %xmm4,%xmm3
subsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add $0x18,%rsp
add $0x1,%eax
imul %eax,%eax
retq
movsd %xmm1,0x8(%rsp)
callq 1070 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 1232 <func0+0x22>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
sub rsp, 8
cvtsi2sd xmm0, edi; x
ucomisd xmm1, xmm0
ja short loc_128E
sqrtsd xmm0, xmm0
loc_122E:
movsd xmm2, cs:qword_2068
movsd xmm3, cs:qword_2058
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
jbe short loc_127F
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movsd xmm4, cs:qword_2060
andnpd xmm2, xmm0
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
andpd xmm3, xmm4
subsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
loc_127F:
cvttsd2si eax, xmm0
add rsp, 8
add eax, 1
imul eax, eax
retn
loc_128E:
call _sqrt
jmp short loc_122E | long long func0(int a1)
{
double v1; // xmm0_8
__m128d v2; // xmm0
__m128d v3; // xmm1
v1 = (double)a1;
if ( (double)a1 < 0.0 )
v2.m128d_f64[0] = sqrt(v1);
else
v2.m128d_f64[0] = sqrt(v1);
if ( fabs(v2.m128d_f64[0]) < 4.503599627370496e15 )
{
v3 = 0LL;
v3.m128d_f64[0] = (double)(int)v2.m128d_f64[0];
*(_QWORD *)&v2.m128d_f64[0] = COERCE_UNSIGNED_INT64(
v3.m128d_f64[0]
- COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v3, v2) & 0x3FF0000000000000LL)) | *(_QWORD *)&v2.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)(((int)v2.m128d_f64[0] + 1) * ((int)v2.m128d_f64[0] + 1));
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB RSP,0x8
CVTSI2SD XMM0,EDI
UCOMISD XMM1,XMM0
JA 0x0010128e
SQRTSD XMM0,XMM0
LAB_0010122e:
MOVSD XMM2,qword ptr [0x00102068]
MOVSD XMM3,qword ptr [0x00102058]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JBE 0x0010127f
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVSD XMM4,qword ptr [0x00102060]
ANDNPD XMM2,XMM0
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
LAB_0010127f:
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
ADD EAX,0x1
IMUL EAX,EAX
RET
LAB_0010128e:
CALL 0x00101070
JMP 0x0010122e | int func0(int param_1)
{
double dVar1;
dVar1 = (double)param_1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
if ((double)((ulong)dVar1 & DAT_00102068) < DAT_00102058) {
dVar1 = (double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_00102060)) |
~DAT_00102068 & (ulong)dVar1);
}
return ((int)dVar1 + 1) * ((int)dVar1 + 1);
} |
4,872 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int MSIBS[n];
for (int i = 0; i < n; i++) {
MSIBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && MSIBS[i] < MSIBS[j] + arr[i]) {
MSIBS[i] = MSIBS[j] + arr[i];
}
}
}
int MSDBS[n];
for (int i = 0; i < n; i++) {
MSDBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[n - i - 1] > arr[n - j - 1] && MSDBS[n - i - 1] < MSDBS[n - j - 1] + arr[n - i - 1]) {
MSDBS[n - i - 1] = MSDBS[n - j - 1] + arr[n - i - 1];
}
}
}
int max_sum = -99999999;
for (int i = 0; i < n; i++) {
if (max_sum < MSIBS[i] + MSDBS[i] - arr[i]) {
max_sum = MSIBS[i] + MSDBS[i] - arr[i];
}
}
return max_sum;
}
| int main() {
assert(func0((int[]){1, 15, 51, 45, 33, 100, 12, 18, 9}, 9) == 194);
assert(func0((int[]){80, 60, 30, 40, 20, 10}, 6) == 210);
assert(func0((int[]){2, 3, 14, 16, 21, 23, 29, 30}, 8) == 138);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x68,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rdi
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x48(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 122c <func0+0xa3>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1215 <func0+0x8c>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1256 <func0+0xcd>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x4c(%rbp)
jmp 1299 <func0+0x110>
mov -0x4c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x40(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 1272 <func0+0xe9>
movl $0x1,-0x50(%rbp)
jmpq 1366 <func0+0x1dd>
movl $0x0,-0x54(%rbp)
jmpq 1356 <func0+0x1cd>
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x54(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1352 <func0+0x1c9>
mov -0x40(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x78(%rbp),%rax
add %rsi,%rax
mov (%rax),%eax
add %edx,%eax
cmp %eax,%ecx
jge 1352 <func0+0x1c9>
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
lea (%rdx,%rax,1),%ecx
mov -0x40(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x50(%rbp),%eax
jl 12b9 <func0+0x130>
addl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 12ad <func0+0x124>
mov -0x7c(%rbp),%eax
mov %rsp,%rdx
mov %rdx,%r8
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x38(%rbp)
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%esi
mov $0x0,%edx
div %rsi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 13ef <func0+0x266>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 13d8 <func0+0x24f>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1419 <func0+0x290>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x30(%rbp)
movl $0x0,-0x58(%rbp)
jmp 145c <func0+0x2d3>
mov -0x58(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x30(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 1435 <func0+0x2ac>
movl $0x1,-0x5c(%rbp)
jmpq 1550 <func0+0x3c7>
movl $0x0,-0x60(%rbp)
jmpq 1540 <func0+0x3b7>
mov -0x7c(%rbp),%eax
sub -0x5c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x7c(%rbp),%eax
sub -0x60(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 153c <func0+0x3b3>
mov -0x7c(%rbp),%eax
sub -0x5c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x30(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x7c(%rbp),%eax
sub -0x60(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x30(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x7c(%rbp),%eax
sub -0x5c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rsi
mov -0x78(%rbp),%rax
add %rsi,%rax
mov (%rax),%eax
add %edx,%eax
cmp %eax,%ecx
jge 153c <func0+0x3b3>
mov -0x7c(%rbp),%eax
sub -0x60(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x30(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x7c(%rbp),%eax
sub -0x5c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x7c(%rbp),%eax
sub -0x5c(%rbp),%eax
lea -0x1(%rax),%esi
add %edx,%ecx
mov -0x30(%rbp),%rax
movslq %esi,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x5c(%rbp),%eax
jl 147c <func0+0x2f3>
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 1470 <func0+0x2e7>
movl $0xfa0a1f01,-0x64(%rbp)
movl $0x0,-0x68(%rbp)
jmp 15e6 <func0+0x45d>
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x30(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea (%rcx,%rax,1),%edx
mov -0x68(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
cmp %eax,-0x64(%rbp)
jge 15e2 <func0+0x459>
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x30(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea (%rcx,%rax,1),%edx
mov -0x68(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x64(%rbp)
addl $0x1,-0x68(%rbp)
mov -0x68(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 156c <func0+0x3e3>
mov -0x64(%rbp),%eax
mov %r8,%rsp
mov %rdi,%rsp
mov -0x28(%rbp),%rdi
xor %fs:0x28,%rdi
je 160f <func0+0x486>
callq 1080 <__stack_chk_fail@plt>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rdi, rax
mov eax, [rbp+var_5C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov esi, 10h
mov edx, 0
div rsi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11F6:
cmp rsp, rdx
jz short loc_120D
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_11F6
loc_120D:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1237
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1237:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_48], 0
jmp short loc_127A
loc_1253:
mov eax, [rbp+var_48]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_20]
mov edx, [rbp+var_48]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_48], 1
loc_127A:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_5C]
jl short loc_1253
mov [rbp+var_44], 1
jmp loc_1347
loc_128E:
mov [rbp+var_40], 0
jmp loc_1337
loc_129A:
mov eax, [rbp+var_44]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_40]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1333
mov rax, [rbp+var_20]
mov edx, [rbp+var_44]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_20]
mov edx, [rbp+var_40]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov eax, [rbp+var_44]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rsi
mov eax, [rax]
add eax, edx
cmp ecx, eax
jge short loc_1333
mov rax, [rbp+var_20]
mov edx, [rbp+var_40]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov eax, [rbp+var_44]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rcx
mov eax, [rax]
lea ecx, [rdx+rax]
mov rax, [rbp+var_20]
mov edx, [rbp+var_44]
movsxd rdx, edx
mov [rax+rdx*4], ecx
loc_1333:
add [rbp+var_40], 1
loc_1337:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_44]
jl loc_129A
add [rbp+var_44], 1
loc_1347:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_5C]
jl loc_128E
mov eax, [rbp+var_5C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov esi, 10h
mov edx, 0
div rsi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_1398:
cmp rsp, rdx
jz short loc_13AF
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_1398
loc_13AF:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_13D9
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_13D9:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_3C], 0
jmp short loc_141C
loc_13F5:
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_3C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_3C], 1
loc_141C:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_5C]
jl short loc_13F5
mov [rbp+var_38], 1
jmp loc_1510
loc_1430:
mov [rbp+var_34], 0
jmp loc_1500
loc_143C:
mov eax, [rbp+var_5C]
sub eax, [rbp+var_38]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_58]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_5C]
sub eax, [rbp+var_34]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_58]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle loc_14FC
mov eax, [rbp+var_5C]
sub eax, [rbp+var_38]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_5C]
sub eax, [rbp+var_34]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov eax, [rbp+var_5C]
sub eax, [rbp+var_38]
cdqe
shl rax, 2
lea rsi, [rax-4]
mov rax, [rbp+var_58]
add rax, rsi
mov eax, [rax]
add eax, edx
cmp ecx, eax
jge short loc_14FC
mov eax, [rbp+var_5C]
sub eax, [rbp+var_34]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_5C]
sub eax, [rbp+var_38]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_58]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_5C]
sub eax, [rbp+var_38]
lea esi, [rax-1]
add ecx, edx
mov rax, [rbp+var_10]
movsxd rdx, esi
mov [rax+rdx*4], ecx
loc_14FC:
add [rbp+var_34], 1
loc_1500:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_38]
jl loc_143C
add [rbp+var_38], 1
loc_1510:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_5C]
jl loc_1430
mov [rbp+var_30], 0FA0A1F01h
mov [rbp+var_2C], 0
jmp short loc_15A2
loc_152C:
mov rax, [rbp+var_20]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea edx, [rcx+rax]
mov eax, [rbp+var_2C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rcx
mov eax, [rax]
sub edx, eax
cmp [rbp+var_30], edx
jge short loc_159E
mov rax, [rbp+var_20]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea edx, [rcx+rax]
mov eax, [rbp+var_2C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rcx
mov eax, [rax]
sub edx, eax
mov [rbp+var_30], edx
loc_159E:
add [rbp+var_2C], 1
loc_15A2:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_5C]
jl short loc_152C
mov eax, [rbp+var_30]
mov rsp, rdi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_15C4
call ___stack_chk_fail
locret_15C4:
leave
retn | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
unsigned long long v4; // rax
void *v5; // rsp
_BYTE v7[4]; // [rsp+8h] [rbp-60h] BYREF
int v8; // [rsp+Ch] [rbp-5Ch]
long long v9; // [rsp+10h] [rbp-58h]
int i; // [rsp+20h] [rbp-48h]
int j; // [rsp+24h] [rbp-44h]
int k; // [rsp+28h] [rbp-40h]
int m; // [rsp+2Ch] [rbp-3Ch]
int n; // [rsp+30h] [rbp-38h]
int ii; // [rsp+34h] [rbp-34h]
int v16; // [rsp+38h] [rbp-30h]
int jj; // [rsp+3Ch] [rbp-2Ch]
long long v18; // [rsp+40h] [rbp-28h]
_BYTE *v19; // [rsp+48h] [rbp-20h]
long long v20; // [rsp+50h] [rbp-18h]
_BYTE *v21; // [rsp+58h] [rbp-10h]
unsigned long long v22; // [rsp+60h] [rbp-8h]
v9 = a1;
v8 = a2;
v22 = __readfsqword(0x28u);
v18 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v7 != &v7[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v2 & 0xFFF) - 8] = *(_QWORD *)&v7[(v2 & 0xFFF) - 8];
v19 = v7;
for ( i = 0; i < v8; ++i )
*(_DWORD *)&v19[4 * i] = *(_DWORD *)(4LL * i + v9);
for ( j = 1; j < v8; ++j )
{
for ( k = 0; k < j; ++k )
{
if ( *(_DWORD *)(4LL * j + v9) > *(_DWORD *)(4LL * k + v9)
&& *(_DWORD *)&v19[4 * j] < *(_DWORD *)&v19[4 * k] + *(_DWORD *)(4LL * j + v9) )
{
*(_DWORD *)&v19[4 * j] = *(_DWORD *)&v19[4 * k] + *(_DWORD *)(4LL * j + v9);
}
}
}
v20 = v8 - 1LL;
v4 = 16 * ((4LL * v8 + 15) / 0x10uLL);
while ( v7 != &v7[-(v4 & 0xFFFFFFFFFFFFF000LL)] )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v4 & 0xFFF) - 8] = *(_QWORD *)&v7[(v4 & 0xFFF) - 8];
v21 = v7;
for ( m = 0; m < v8; ++m )
*(_DWORD *)&v21[4 * m] = *(_DWORD *)(4LL * m + v9);
for ( n = 1; n < v8; ++n )
{
for ( ii = 0; ii < n; ++ii )
{
if ( *(_DWORD *)(4LL * (v8 - n) - 4 + v9) > *(_DWORD *)(4LL * (v8 - ii) - 4 + v9)
&& *(_DWORD *)&v21[4 * (v8 - n) - 4] < *(_DWORD *)&v21[4 * (v8 - ii) - 4] + *(_DWORD *)(4LL * (v8 - n) - 4 + v9) )
{
*(_DWORD *)&v21[4 * (v8 - n) - 4] = *(_DWORD *)(4LL * (v8 - n) - 4 + v9) + *(_DWORD *)&v21[4 * (v8 - ii) - 4];
}
}
}
v16 = -99999999;
for ( jj = 0; jj < v8; ++jj )
{
if ( v16 < *(_DWORD *)&v19[4 * jj] + *(_DWORD *)&v21[4 * jj] - *(_DWORD *)(4LL * jj + v9) )
v16 = *(_DWORD *)&v19[4 * jj] + *(_DWORD *)&v21[4 * jj] - *(_DWORD *)(4LL * jj + v9);
}
return (unsigned int)v16;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RDI,RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV ESI,0x10
MOV EDX,0x0
DIV RSI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011f6:
CMP RSP,RDX
JZ 0x0010120d
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011f6
LAB_0010120d:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101237
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101237:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x48],0x0
JMP 0x0010127a
LAB_00101253:
MOV EAX,dword ptr [RBP + -0x48]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x48]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x48],0x1
LAB_0010127a:
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x00101253
MOV dword ptr [RBP + -0x44],0x1
JMP 0x00101347
LAB_0010128e:
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101337
LAB_0010129a:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x40]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101333
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x44]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RSI
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
CMP ECX,EAX
JGE 0x00101333
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x44]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
LEA ECX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_00101333:
ADD dword ptr [RBP + -0x40],0x1
LAB_00101337:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x0010129a
ADD dword ptr [RBP + -0x44],0x1
LAB_00101347:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x0010128e
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV ESI,0x10
MOV EDX,0x0
DIV RSI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_00101398:
CMP RSP,RDX
JZ 0x001013af
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101398
LAB_001013af:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001013d9
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001013d9:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x0010141c
LAB_001013f5:
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x3c],0x1
LAB_0010141c:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x001013f5
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00101510
LAB_00101430:
MOV dword ptr [RBP + -0x34],0x0
JMP 0x00101500
LAB_0010143c:
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001014fc
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x2
LEA RSI,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RSI
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
CMP ECX,EAX
JGE 0x001014fc
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x38]
LEA ESI,[RAX + -0x1]
ADD ECX,EDX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,ESI
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_001014fc:
ADD dword ptr [RBP + -0x34],0x1
LAB_00101500:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x0010143c
ADD dword ptr [RBP + -0x38],0x1
LAB_00101510:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x00101430
MOV dword ptr [RBP + -0x30],0xfa0a1f01
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001015a2
LAB_0010152c:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA EDX,[RCX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
SUB EDX,EAX
CMP dword ptr [RBP + -0x30],EDX
JGE 0x0010159e
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA EDX,[RCX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
SUB EDX,EAX
MOV dword ptr [RBP + -0x30],EDX
LAB_0010159e:
ADD dword ptr [RBP + -0x2c],0x1
LAB_001015a2:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x0010152c
MOV EAX,dword ptr [RBP + -0x30]
MOV RSP,RDI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001015c4
CALL 0x00101080
LAB_001015c4:
LEAVE
RET | int func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_68 [4];
int local_64;
long local_60;
int local_50;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
int *local_28;
long local_20;
int *local_18;
long local_10;
local_60 = param_1;
local_64 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = (long)param_2 + -1;
uVar2 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_68; puVar3 != auStack_68 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
puVar4 = puVar3 + lVar1;
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
local_28 = puVar3 + lVar1;
for (local_50 = 0; local_50 < local_64; local_50 = local_50 + 1) {
*(int4 *)(puVar3 + (long)local_50 * 4 + lVar1) =
*(int4 *)(local_60 + (long)local_50 * 4);
}
for (local_4c = 1; local_4c < local_64; local_4c = local_4c + 1) {
for (local_48 = 0; local_48 < local_4c; local_48 = local_48 + 1) {
if ((*(int *)(local_60 + (long)local_48 * 4) < *(int *)(local_60 + (long)local_4c * 4)) &&
(*(int *)(puVar3 + (long)local_4c * 4 + lVar1) <
*(int *)(local_60 + (long)local_4c * 4) + *(int *)(puVar3 + (long)local_48 * 4 + lVar1)))
{
*(int *)(puVar3 + (long)local_4c * 4 + lVar1) =
*(int *)(puVar3 + (long)local_48 * 4 + lVar1) + *(int *)(local_60 + (long)local_4c * 4)
;
}
}
}
local_20 = (long)local_64 + -1;
uVar2 = (((long)local_64 * 4 + 0xfU) / 0x10) * 0x10;
for (; puVar4 != puVar3 + (lVar1 - (uVar2 & 0xfffffffffffff000)); puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_44 = 0; local_44 < local_64; local_44 = local_44 + 1) {
*(int4 *)(puVar4 + (long)local_44 * 4 + lVar1) =
*(int4 *)(local_60 + (long)local_44 * 4);
}
for (local_40 = 1; local_40 < local_64; local_40 = local_40 + 1) {
for (local_3c = 0; local_3c < local_40; local_3c = local_3c + 1) {
if (*(int *)(local_60 + (long)(local_64 - local_3c) * 4 + -4) <
*(int *)(local_60 + (long)(local_64 - local_40) * 4 + -4)) {
if (*(int *)(puVar4 + (long)((local_64 - local_40) + -1) * 4 + lVar1) <
*(int *)(local_60 + (long)(local_64 - local_40) * 4 + -4) +
*(int *)(puVar4 + (long)((local_64 - local_3c) + -1) * 4 + lVar1)) {
*(int *)(puVar4 + (long)((local_64 - local_40) + -1) * 4 + lVar1) =
*(int *)(puVar4 + (long)((local_64 - local_3c) + -1) * 4 + lVar1) +
*(int *)(local_60 + (long)(local_64 - local_40) * 4 + -4);
}
}
}
}
local_38 = -99999999;
for (local_34 = 0; local_34 < local_64; local_34 = local_34 + 1) {
if (local_38 <
(*(int *)(local_28 + (long)local_34 * 4) + *(int *)(puVar4 + (long)local_34 * 4 + lVar1)) -
*(int *)(local_60 + (long)local_34 * 4)) {
local_38 = (*(int *)(local_28 + (long)local_34 * 4) +
*(int *)(puVar4 + (long)local_34 * 4 + lVar1)) -
*(int *)(local_60 + (long)local_34 * 4);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar4 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_38;
} |
4,873 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int MSIBS[n];
for (int i = 0; i < n; i++) {
MSIBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && MSIBS[i] < MSIBS[j] + arr[i]) {
MSIBS[i] = MSIBS[j] + arr[i];
}
}
}
int MSDBS[n];
for (int i = 0; i < n; i++) {
MSDBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[n - i - 1] > arr[n - j - 1] && MSDBS[n - i - 1] < MSDBS[n - j - 1] + arr[n - i - 1]) {
MSDBS[n - i - 1] = MSDBS[n - j - 1] + arr[n - i - 1];
}
}
}
int max_sum = -99999999;
for (int i = 0; i < n; i++) {
if (max_sum < MSIBS[i] + MSDBS[i] - arr[i]) {
max_sum = MSIBS[i] + MSDBS[i] - arr[i];
}
}
return max_sum;
}
| int main() {
assert(func0((int[]){1, 15, 51, 45, 33, 100, 12, 18, 9}, 9) == 194);
assert(func0((int[]){80, 60, 30, 40, 20, 10}, 6) == 210);
assert(func0((int[]){2, 3, 14, 16, 21, 23, 29, 30}, 8) == 138);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%r12
shl $0x2,%r12
lea 0xf(%r12),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11e4 <func0+0x5b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11cd <func0+0x44>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11fa <func0+0x71>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r9
mov %r9,%r10
shr $0x2,%r10
and $0xfffffffffffffffc,%r9
test %esi,%esi
jle 1229 <func0+0xa0>
lea -0x1(%rsi),%ecx
mov $0x0,%eax
mov (%rdi,%rax,4),%edx
mov %edx,(%r9,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 1216 <func0+0x8d>
cmp $0x1,%esi
jle 1279 <func0+0xf0>
lea -0x2(%rsi),%r11d
add $0x2,%r11
mov $0x1,%edx
jmp 126b <func0+0xe2>
add $0x1,%rax
cmp %rdx,%rax
je 125e <func0+0xd5>
cmp (%rdi,%rax,4),%ecx
jle 123d <func0+0xb4>
mov %ecx,%r8d
add (%r9,%rax,4),%r8d
cmp %r8d,(%r9,%rdx,4)
jge 123d <func0+0xb4>
mov %r8d,(%r9,%rdx,4)
jmp 123d <func0+0xb4>
add $0x1,%rdx
cmp %r11,%rdx
je 137f <func0+0x1f6>
test %edx,%edx
jle 125e <func0+0xd5>
mov (%rdi,%rdx,4),%ecx
mov $0x0,%eax
jmp 1246 <func0+0xbd>
lea 0xf(%r12),%rdx
mov %rdx,%rax
and $0xfffffffffffffff0,%rax
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 12ac <func0+0x123>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1295 <func0+0x10c>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
je 12c3 <func0+0x13a>
orq $0x0,-0x8(%rsp,%rdx,1)
lea 0x3(%rsp),%r11
mov %r11,%rax
shr $0x2,%rax
and $0xfffffffffffffffc,%r11
cmp $0x1,%esi
je 1416 <func0+0x28d>
cmp $0x1,%esi
je 13f6 <func0+0x26d>
mov $0xfa0a1f01,%ecx
jmp 135d <func0+0x1d4>
sub $0x4,%rdx
sub $0x1,%eax
cmp %ecx,%eax
je 1311 <func0+0x188>
cmp -0x4(%rdx),%r8d
jle 12ec <func0+0x163>
movslq %eax,%r10
mov %r8d,%r14d
add (%r11,%r10,4),%r14d
cmp %r14d,(%rbx)
jge 12ec <func0+0x163>
mov %r14d,(%rbx)
jmp 12ec <func0+0x163>
sub $0x1,%ecx
cmp $0xffffffff,%ecx
je 133b <func0+0x1b2>
mov %r13d,%eax
sub %ecx,%eax
test %eax,%eax
jle 1311 <func0+0x188>
lea 0x1(%rcx),%eax
cltq
mov -0x4(%rdi,%rax,4),%r8d
lea -0x1(%rsi),%eax
mov %r12,%rdx
movslq %ecx,%r10
lea (%r11,%r10,4),%rbx
jmp 12f7 <func0+0x16e>
mov $0x0,%edx
mov $0xfa0a1f01,%ecx
mov (%r11,%rdx,4),%eax
add (%r9,%rdx,4),%eax
sub (%rdi,%rdx,4),%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x1,%rdx
cmp %edx,%esi
jg 1345 <func0+0x1bc>
mov -0x28(%rbp),%rax
xor %fs:0x28,%rax
jne 1421 <func0+0x298>
mov %ecx,%eax
lea -0x20(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
lea 0xf(%r12),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 13b1 <func0+0x228>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 139a <func0+0x211>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 13c7 <func0+0x23e>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r11
mov $0x0,%eax
mov (%rdi,%rax,4),%edx
mov %edx,(%r11,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 13cf <func0+0x246>
cmp $0x1,%esi
jle 12dc <func0+0x153>
lea -0x2(%rsi),%ecx
add %rdi,%r12
lea -0x1(%rsi),%r13d
jmpq 1319 <func0+0x190>
mov (%r11),%ecx
add 0x0(,%r10,4),%ecx
sub (%rdi),%ecx
cmp $0xfa0a1f01,%ecx
mov $0xfa0a1f01,%eax
cmovl %eax,%ecx
jmpq 135d <func0+0x1d4>
mov (%rdi),%edx
mov %edx,0x0(,%rax,4)
jmp 13de <func0+0x255>
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r11d, esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd r10, esi
shl r10, 2
lea rax, [r10+0Fh]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11CC:
cmp rsp, rdx
jz short loc_11E3
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11CC
loc_11E3:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11F9
or [rsp+rax+30h+var_38], 0
loc_11F9:
lea r8, [rsp+30h+var_2D]
mov rbx, r8
shr rbx, 2
and r8, 0FFFFFFFFFFFFFFFCh
test r11d, r11d
jle short loc_1226
mov ecx, r11d
mov eax, 0
loc_1216:
mov edx, [rdi+rax*4]
mov [r8+rax*4], edx
add rax, 1
cmp rax, rcx
jnz short loc_1216
loc_1226:
cmp r11d, 1
jle short loc_1271
mov r9d, r11d
mov edx, 1
jmp short loc_1263
loc_1236:
add rax, 1
cmp rax, rdx
jz short loc_1256
loc_123F:
cmp ecx, [rdi+rax*4]
jle short loc_1236
mov esi, ecx
add esi, [r8+rax*4]
cmp [r8+rdx*4], esi
jge short loc_1236
mov [r8+rdx*4], esi
jmp short loc_1236
loc_1256:
add rdx, 1
cmp rdx, r9
jz loc_1372
loc_1263:
test edx, edx
jle short loc_1256
mov ecx, [rdi+rdx*4]
mov eax, 0
jmp short loc_123F
loc_1271:
lea rdx, [r10+0Fh]
mov rax, rdx
and rax, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rdx
loc_1289:
cmp rsp, rcx
jz short loc_12A0
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_1289
loc_12A0:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jz short loc_12B7
or [rsp+rdx+30h+var_38], 0
loc_12B7:
lea r9, [rsp+30h+var_2D]
mov rax, r9
shr rax, 2
and r9, 0FFFFFFFFFFFFFFFCh
cmp r11d, 1
jz loc_1405
loc_12D1:
cmp r11d, 1
jz loc_13EA
mov ecx, 0FA0A1F01h
jmp short loc_1350
loc_12E2:
sub rdx, 4
sub eax, 1
cmp eax, ecx
jz short loc_1307
loc_12ED:
cmp esi, [rdx]
jle short loc_12E2
movsxd r10, eax
mov r14d, esi
add r14d, [r9+r10*4]
cmp [r9+rbx*4], r14d
jge short loc_12E2
mov [r9+rbx*4], r14d
jmp short loc_12E2
loc_1307:
sub ecx, 1
cmp ecx, 0FFFFFFFFh
jz short loc_132D
loc_130F:
mov eax, r12d
sub eax, ecx
test eax, eax
jle short loc_1307
lea eax, [rcx+1]
cdqe
mov esi, [rdi+rax*4-4]
lea eax, [r11-1]
mov rdx, r13
movsxd rbx, ecx
jmp short loc_12ED
loc_132D:
mov edx, 0
mov ecx, 0FA0A1F01h
loc_1337:
mov eax, [r9+rdx*4]
add eax, [r8+rdx*4]
sub eax, [rdi+rdx*4]
cmp ecx, eax
cmovl ecx, eax
add rdx, 1
cmp r11d, edx
jg short loc_1337
loc_1350:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz loc_1410
mov eax, ecx
lea rsp, [rbp-20h]
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_1372:
lea rax, [r10+0Fh]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_1389:
cmp rsp, rdx
jz short loc_13A0
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_1389
loc_13A0:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_13B6
or [rsp+rax+30h+var_38], 0
loc_13B6:
mov r9, rsp
mov eax, 0
loc_13BE:
mov edx, [rdi+rax*4]
mov [r9+rax*4], edx
add rax, 1
cmp r11d, eax
jg short loc_13BE
loc_13CE:
cmp r11d, 1
jle loc_12D1
lea ecx, [r11-2]
lea r13, [rdi+r10-4]
lea r12d, [r11-1]
jmp loc_130F
loc_13EA:
mov ecx, [r9]
add ecx, ds:dword_0[rbx*4]
sub ecx, [rdi]
mov eax, 0FA0A1F01h
cmp ecx, eax
cmovl ecx, eax
jmp loc_1350
loc_1405:
mov edx, [rdi]
mov ds:dword_0[rax*4], edx
jmp short loc_13CE
loc_1410:
call ___stack_chk_fail | long long func0(_DWORD *a1, int a2)
{
long long v3; // r10
signed long long v4; // rax
void *v5; // rsp
long long i; // rax
long long j; // rdx
long long v8; // rax
int v9; // esi
int v10; // ecx
signed long long v11; // rdx
void *v12; // rsp
int v13; // ecx
_DWORD *v14; // rdx
int v15; // eax
int v16; // r14d
int v17; // ecx
int v18; // esi
long long v19; // rdx
signed long long v21; // rax
void *v22; // rsp
long long v23; // rax
_DWORD v25[2]; // [rsp+8h] [rbp-30h] BYREF
unsigned long long v26; // [rsp+10h] [rbp-28h]
v26 = __readfsqword(0x28u);
v3 = 4LL * a2;
while ( v25 != (_DWORD *)((char *)v25 - ((v3 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = ((_WORD)v3 + 15) & 0xFF0;
v5 = alloca(v4);
if ( (((_WORD)v3 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v25[-2] + v4) = *(_QWORD *)((char *)&v25[-2] + v4);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
v25[i] = a1[i];
}
if ( a2 <= 1 )
{
while ( v25 != (_DWORD *)((char *)v25 - ((v3 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v11 = ((_WORD)v3 + 15) & 0xFF0;
v12 = alloca(v11);
if ( (((_WORD)v3 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v25[-2] + v11) = *(_QWORD *)((char *)&v25[-2] + v11);
if ( a2 != 1 )
goto LABEL_21;
v25[0] = *a1;
}
else
{
for ( j = 1LL; j != a2; ++j )
{
if ( (int)j > 0 )
{
v10 = a1[j];
v8 = 0LL;
do
{
if ( v10 > a1[v8] )
{
v9 = v25[v8] + v10;
if ( v25[j] < v9 )
v25[j] = v9;
}
++v8;
}
while ( v8 != j );
}
}
while ( v25 != (_DWORD *)((char *)v25 - ((v3 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v21 = ((_WORD)v3 + 15) & 0xFF0;
v22 = alloca(v21);
if ( (((_WORD)v3 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v25[-2] + v21) = *(_QWORD *)((char *)&v25[-2] + v21);
v23 = 0LL;
do
{
v25[v23] = a1[v23];
++v23;
}
while ( a2 > (int)v23 );
}
if ( a2 > 1 )
{
v17 = a2 - 2;
do
{
if ( a2 - 1 - v17 > 0 )
{
v18 = a1[v17];
v15 = a2 - 1;
v14 = &a1[(unsigned long long)v3 / 4 - 1];
do
{
if ( v18 > *v14 )
{
v16 = v25[v15] + v18;
if ( v25[v17] < v16 )
v25[v17] = v16;
}
--v14;
--v15;
}
while ( v15 != v17 );
}
--v17;
}
while ( v17 != -1 );
v19 = 0LL;
v13 = -99999999;
do
{
if ( v13 < 2 * v25[v19] - a1[v19] )
v13 = 2 * v25[v19] - a1[v19];
++v19;
}
while ( a2 > (int)v19 );
return (unsigned int)v13;
}
LABEL_21:
if ( a2 == 1 )
{
v13 = 2 * v25[0] - *a1;
if ( v13 < -99999999 )
return (unsigned int)-99999999;
}
else
{
return (unsigned int)-99999999;
}
return (unsigned int)v13;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R11D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD R10,ESI
SHL R10,0x2
LEA RAX,[R10 + 0xf]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011cc:
CMP RSP,RDX
JZ 0x001011e3
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011cc
LAB_001011e3:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011f9
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011f9:
LEA R8,[RSP + 0x3]
MOV RBX,R8
SHR RBX,0x2
AND R8,-0x4
TEST R11D,R11D
JLE 0x00101226
MOV ECX,R11D
MOV EAX,0x0
LAB_00101216:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101216
LAB_00101226:
CMP R11D,0x1
JLE 0x00101271
MOV R9D,R11D
MOV EDX,0x1
JMP 0x00101263
LAB_00101236:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x00101256
LAB_0010123f:
CMP ECX,dword ptr [RDI + RAX*0x4]
JLE 0x00101236
MOV ESI,ECX
ADD ESI,dword ptr [R8 + RAX*0x4]
CMP dword ptr [R8 + RDX*0x4],ESI
JGE 0x00101236
MOV dword ptr [R8 + RDX*0x4],ESI
JMP 0x00101236
LAB_00101256:
ADD RDX,0x1
CMP RDX,R9
JZ 0x00101372
LAB_00101263:
TEST EDX,EDX
JLE 0x00101256
MOV ECX,dword ptr [RDI + RDX*0x4]
MOV EAX,0x0
JMP 0x0010123f
LAB_00101271:
LEA RDX,[R10 + 0xf]
MOV RAX,RDX
AND RAX,-0x10
AND RDX,-0x1000
MOV RCX,RSP
SUB RCX,RDX
LAB_00101289:
CMP RSP,RCX
JZ 0x001012a0
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101289
LAB_001012a0:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JZ 0x001012b7
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
LAB_001012b7:
LEA R9,[RSP + 0x3]
MOV RAX,R9
SHR RAX,0x2
AND R9,-0x4
CMP R11D,0x1
JZ 0x00101405
LAB_001012d1:
CMP R11D,0x1
JZ 0x001013ea
MOV ECX,0xfa0a1f01
JMP 0x00101350
LAB_001012e2:
SUB RDX,0x4
SUB EAX,0x1
CMP EAX,ECX
JZ 0x00101307
LAB_001012ed:
CMP ESI,dword ptr [RDX]
JLE 0x001012e2
MOVSXD R10,EAX
MOV R14D,ESI
ADD R14D,dword ptr [R9 + R10*0x4]
CMP dword ptr [R9 + RBX*0x4],R14D
JGE 0x001012e2
MOV dword ptr [R9 + RBX*0x4],R14D
JMP 0x001012e2
LAB_00101307:
SUB ECX,0x1
CMP ECX,-0x1
JZ 0x0010132d
LAB_0010130f:
MOV EAX,R12D
SUB EAX,ECX
TEST EAX,EAX
JLE 0x00101307
LEA EAX,[RCX + 0x1]
CDQE
MOV ESI,dword ptr [RDI + RAX*0x4 + -0x4]
LEA EAX,[R11 + -0x1]
MOV RDX,R13
MOVSXD RBX,ECX
JMP 0x001012ed
LAB_0010132d:
MOV EDX,0x0
MOV ECX,0xfa0a1f01
LAB_00101337:
MOV EAX,dword ptr [R9 + RDX*0x4]
ADD EAX,dword ptr [R8 + RDX*0x4]
SUB EAX,dword ptr [RDI + RDX*0x4]
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x1
CMP R11D,EDX
JG 0x00101337
LAB_00101350:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101410
MOV EAX,ECX
LEA RSP,[RBP + -0x20]
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00101372:
LEA RAX,[R10 + 0xf]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_00101389:
CMP RSP,RDX
JZ 0x001013a0
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101389
LAB_001013a0:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001013b6
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001013b6:
MOV R9,RSP
MOV EAX,0x0
LAB_001013be:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [R9 + RAX*0x4],EDX
ADD RAX,0x1
CMP R11D,EAX
JG 0x001013be
LAB_001013ce:
CMP R11D,0x1
JLE 0x001012d1
LEA ECX,[R11 + -0x2]
LEA R13,[RDI + R10*0x1 + -0x4]
LEA R12D,[R11 + -0x1]
JMP 0x0010130f
LAB_001013ea:
MOV ECX,dword ptr [R9]
ADD ECX,dword ptr [RBX*0x4]
SUB ECX,dword ptr [RDI]
MOV EAX,0xfa0a1f01
CMP ECX,EAX
CMOVL ECX,EAX
JMP 0x00101350
LAB_00101405:
MOV EDX,dword ptr [RDI]
MOV dword ptr [RAX*0x4],EDX
JMP 0x001013ce
LAB_00101410:
CALL 0x00101080 | int func0(int *param_1,uint param_2)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
int iVar6;
int *piVar7;
int1 *puVar8;
int1 *puVar9;
int1 *puVar10;
int1 *puVar11;
int1 *puVar12;
int iVar13;
int *piVar14;
long lVar15;
int iVar16;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar15 = (long)(int)param_2 * 4;
for (puVar8 = auStack_38; puVar8 != auStack_38 + -(lVar15 + 0xfU & 0xfffffffffffff000);
puVar8 = puVar8 + -0x1000) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
uVar3 = (ulong)((uint)(lVar15 + 0xfU) & 0xff0);
lVar1 = -uVar3;
puVar9 = puVar8 + lVar1;
puVar11 = puVar8 + lVar1;
if (uVar3 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (0 < (int)param_2) {
uVar3 = 0;
do {
*(int *)(puVar8 + uVar3 * 4 + lVar1) = param_1[uVar3];
uVar3 = uVar3 + 1;
} while (uVar3 != param_2);
}
if ((int)param_2 < 2) {
for (; puVar9 != puVar8 + (lVar1 - (lVar15 + 0xfU & 0xfffffffffffff000));
puVar9 = puVar9 + -0x1000) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
uVar3 = (ulong)((uint)(lVar15 + 0xfU) & 0xff0);
lVar15 = -uVar3;
piVar7 = (int *)(puVar9 + lVar15);
piVar14 = (int *)(puVar9 + lVar15);
puVar10 = puVar9 + lVar15;
puVar12 = puVar9 + lVar15;
if (uVar3 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
if (param_2 == 1) {
*(int *)(puVar9 + lVar15) = *param_1;
goto LAB_001013ce;
}
}
else {
uVar3 = 1;
do {
if (0 < (int)uVar3) {
iVar6 = param_1[uVar3];
uVar4 = 0;
do {
if ((param_1[uVar4] < iVar6) &&
(iVar13 = iVar6 + *(int *)(puVar8 + uVar4 * 4 + lVar1),
*(int *)(puVar8 + uVar3 * 4 + lVar1) < iVar13)) {
*(int *)(puVar8 + uVar3 * 4 + lVar1) = iVar13;
}
uVar4 = uVar4 + 1;
} while (uVar4 != uVar3);
}
uVar3 = uVar3 + 1;
} while (uVar3 != param_2);
for (; puVar11 != puVar8 + (lVar1 - (lVar15 + 0xfU & 0xfffffffffffff000));
puVar11 = puVar11 + -0x1000) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
uVar3 = (ulong)((uint)(lVar15 + 0xfU) & 0xff0);
lVar15 = -uVar3;
puVar12 = puVar11 + lVar15;
piVar14 = (int *)(puVar11 + lVar15);
if (uVar3 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
lVar5 = 0;
do {
*(int *)(puVar11 + lVar5 * 4 + lVar15) = param_1[lVar5];
lVar5 = lVar5 + 1;
} while ((int)lVar5 < (int)param_2);
LAB_001013ce:
puVar10 = puVar12;
piVar7 = piVar14;
if (1 < (int)param_2) {
iVar6 = param_2 - 2;
do {
if (0 < (int)((param_2 - 1) - iVar6)) {
iVar13 = param_1[(long)(iVar6 + 1) + -1];
iVar2 = param_2 - 1;
piVar7 = param_1 + (long)(int)param_2 + -1;
do {
if ((*piVar7 < iVar13) && (iVar16 = iVar13 + piVar14[iVar2], piVar14[iVar6] < iVar16)) {
piVar14[iVar6] = iVar16;
}
piVar7 = piVar7 + -1;
iVar2 = iVar2 + -1;
} while (iVar2 != iVar6);
}
iVar6 = iVar6 + -1;
} while (iVar6 != -1);
lVar15 = 0;
iVar6 = -99999999;
do {
if (iVar6 < (piVar14[lVar15] + *(int *)(puVar8 + lVar15 * 4 + lVar1)) - param_1[lVar15]) {
iVar6 = (piVar14[lVar15] + *(int *)(puVar8 + lVar15 * 4 + lVar1)) - param_1[lVar15];
}
lVar15 = lVar15 + 1;
} while ((int)lVar15 < (int)param_2);
goto LAB_00101350;
}
}
if (param_2 == 1) {
iVar6 = (*piVar7 + *(int *)(puVar8 + lVar1)) - *param_1;
if ((*piVar7 + *(int *)(puVar8 + lVar1)) - *param_1 < -99999999) {
iVar6 = -99999999;
}
}
else {
iVar6 = -99999999;
}
LAB_00101350:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar10 + -8) = main;
__stack_chk_fail();
}
return iVar6;
} |
4,874 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int MSIBS[n];
for (int i = 0; i < n; i++) {
MSIBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && MSIBS[i] < MSIBS[j] + arr[i]) {
MSIBS[i] = MSIBS[j] + arr[i];
}
}
}
int MSDBS[n];
for (int i = 0; i < n; i++) {
MSDBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[n - i - 1] > arr[n - j - 1] && MSDBS[n - i - 1] < MSDBS[n - j - 1] + arr[n - i - 1]) {
MSDBS[n - i - 1] = MSDBS[n - j - 1] + arr[n - i - 1];
}
}
}
int max_sum = -99999999;
for (int i = 0; i < n; i++) {
if (max_sum < MSIBS[i] + MSDBS[i] - arr[i]) {
max_sum = MSIBS[i] + MSDBS[i] - arr[i];
}
}
return max_sum;
}
| int main() {
assert(func0((int[]){1, 15, 51, 45, 33, 100, 12, 18, 9}, 9) == 194);
assert(func0((int[]){80, 60, 30, 40, 20, 10}, 6) == 210);
assert(func0((int[]){2, 3, 14, 16, 21, 23, 29, 30}, 8) == 138);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
movslq %esi,%r14
push %r13
shl $0x2,%r14
push %r12
push %rbx
lea 0xf(%r14),%rbx
mov %rbx,%rdx
and $0xfffffffffffff000,%rdx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rcx
mov %rbx,%rax
sub %rdx,%rcx
and $0xfffffffffffffff0,%rax
mov %rcx,%rdx
cmp %rdx,%rsp
je 1383 <func0+0x63>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 136e <func0+0x4e>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
jne 150e <func0+0x1ee>
lea 0x3(%rsp),%r9
mov %r9,%r8
and $0xfffffffffffffffc,%r9
shr $0x2,%r8
test %esi,%esi
jle 1524 <func0+0x204>
lea -0x1(%rsi),%ecx
xor %eax,%eax
mov %rcx,%r11
nopl 0x0(%rax)
mov (%rdi,%rax,4),%edx
mov %edx,(%r9,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rcx
jne 13b8 <func0+0x98>
cmp $0x1,%esi
jle 1524 <func0+0x204>
lea -0x2(%rsi),%r12d
mov $0x1,%edx
mov %r12,%r8
add $0x2,%r12
nopl 0x0(%rax)
mov (%rdi,%rdx,4),%ecx
xor %eax,%eax
nopl (%rax)
cmp (%rdi,%rax,4),%ecx
jle 1406 <func0+0xe6>
mov (%r9,%rax,4),%r10d
add %ecx,%r10d
cmp %r10d,(%r9,%rdx,4)
jge 1406 <func0+0xe6>
mov %r10d,(%r9,%rdx,4)
add $0x1,%rax
cmp %rax,%rdx
jne 13f0 <func0+0xd0>
add $0x1,%rdx
cmp %rdx,%r12
jne 13e8 <func0+0xc8>
mov %rbx,%rax
mov %rsp,%rdx
and $0xfffffffffffff000,%rbx
sub %rbx,%rdx
and $0xfffffffffffffff0,%rax
cmp %rdx,%rsp
je 1446 <func0+0x126>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 1431 <func0+0x111>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
jne 1519 <func0+0x1f9>
mov %rsp,%rbx
xor %eax,%eax
nopl 0x0(%rax)
mov (%rdi,%rax,4),%edx
mov %edx,(%rbx,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 1460 <func0+0x140>
add %rdi,%r14
mov %r14,%r13
nopl 0x0(%rax)
mov %r8d,%r10d
mov -0x8(%r13),%ecx
mov %r11d,%eax
mov %r14,%rdx
lea (%rbx,%r10,4),%r12
nopl 0x0(%rax)
cmp -0x4(%rdx),%ecx
jle 14a9 <func0+0x189>
movslq %eax,%r10
mov (%rbx,%r10,4),%r15d
add %ecx,%r15d
cmp %r15d,(%r12)
jge 14a9 <func0+0x189>
mov %r15d,(%r12)
sub $0x1,%eax
sub $0x4,%rdx
cmp %eax,%r8d
jne 1490 <func0+0x170>
sub $0x1,%r8d
sub $0x4,%r13
cmp $0xffffffff,%r8d
jne 1478 <func0+0x158>
xor %edx,%edx
mov $0xfa0a1f01,%r8d
nopl 0x0(%rax,%rax,1)
mov (%rbx,%rdx,4),%eax
add (%r9,%rdx,4),%eax
sub (%rdi,%rdx,4),%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x1,%rdx
cmp %edx,%esi
jg 14d0 <func0+0x1b0>
mov -0x38(%rbp),%rax
xor %fs:0x28,%rax
jne 157e <func0+0x25e>
lea -0x28(%rbp),%rsp
mov %r8d,%eax
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rax,1)
jmpq 1394 <func0+0x74>
orq $0x0,-0x8(%rsp,%rax,1)
jmpq 1457 <func0+0x137>
mov %rbx,%rax
mov %rsp,%rdx
and $0xfffffffffffff000,%rbx
sub %rbx,%rdx
and $0xfffffffffffffff0,%rax
cmp %rdx,%rsp
je 1552 <func0+0x232>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 153d <func0+0x21d>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1565 <func0+0x245>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%rdx
shr $0x2,%rdx
cmp $0x1,%esi
je 1583 <func0+0x263>
mov $0xfa0a1f01,%r8d
jmpq 14e9 <func0+0x1c9>
callq 1080 <__stack_chk_fail@plt>
mov (%rdi),%eax
mov %eax,0x0(,%rdx,4)
add 0x0(,%r8,4),%eax
sub (%rdi),%eax
mov %eax,%r8d
cmp $0xfa0a1f01,%eax
mov $0xfa0a1f01,%eax
cmovl %eax,%r8d
jmpq 14e9 <func0+0x1c9>
nopl 0x0(%rax)
| func0:
endbr64
push rbp
movsxd r8, esi
mov rbp, rsp
push r15
lea r15, ds:0[r8*4]
push r14
lea r14, [r15+0Fh]
push r13
mov rcx, r14
mov r13, r8
push r12
and rcx, 0FFFFFFFFFFFFF000h
mov r12, rdi
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov rdx, rsp
mov rax, r14
sub rdx, rcx
and rax, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdx
jz short loc_13AA
loc_1395:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rdx
jnz short loc_1395
loc_13AA:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jnz loc_153B
loc_13BB:
lea rbx, [rsp+1050h+var_104D]
mov rax, rbx
and rbx, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov [rbp+var_50], rax
test r13d, r13d
jle loc_1551
lea rdx, ds:0[r8*4]
mov rsi, r12
mov rdi, rbx
mov [rbp+var_48], r8
call _memcpy
cmp r13d, 1
jz loc_155E
mov r8, [rbp+var_48]
mov edx, 1
nop word ptr [rax+rax+00h]
loc_1408:
mov ecx, [r12+rdx*4]
xor eax, eax
xchg ax, ax
loc_1410:
cmp ecx, [r12+rax*4]
jle short loc_1423
mov esi, [rbx+rax*4]
add esi, ecx
cmp [rbx+rdx*4], esi
jge short loc_1423
mov [rbx+rdx*4], esi
loc_1423:
add rax, 1
cmp rdx, rax
jnz short loc_1410
add rdx, 1
cmp r8, rdx
jnz short loc_1408
mov rax, r14
mov rdx, rsp
and r14, 0FFFFFFFFFFFFF000h
sub rdx, r14
and rax, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdx
jz short loc_1463
loc_144E:
sub rsp, 1000h
or [rsp+2050h+var_1058], 0
cmp rsp, rdx
jnz short loc_144E
loc_1463:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jnz loc_1546
loc_1474:
lea eax, [r13-1]
test r13d, r13d
mov rdi, rsp
mov rsi, r12
lea rdx, ds:4[rax*4]
mov r14, rax
mov eax, 4
cmovle rdx, rax
call _memcpy
lea r10, [r12+r15]
lea esi, [r13-2]
mov rdi, rax
lea r11, [r12+r15-4]
nop word ptr [rax+rax+00h]
loc_14B0:
mov ecx, [r10-8]
mov eax, r14d
mov rdx, r11
movsxd r9, esi
nop dword ptr [rax]
loc_14C0:
cmp ecx, [rdx]
jle short loc_14D8
movsxd r8, eax
mov r15d, [rdi+r8*4]
add r15d, ecx
cmp [rdi+r9*4], r15d
jge short loc_14D8
mov [rdi+r9*4], r15d
loc_14D8:
sub eax, 1
sub rdx, 4
cmp eax, esi
jnz short loc_14C0
sub r10, 4
lea esi, [rax-1]
test eax, eax
jnz short loc_14B0
xor edx, edx
mov r8d, 0FA0A1F01h
nop word ptr [rax+rax+00000000h]
loc_1500:
mov eax, [rdi+rdx*4]
add eax, [rbx+rdx*4]
sub eax, [r12+rdx*4]
cmp r8d, eax
cmovl r8d, eax
add rdx, 1
cmp r13d, edx
jg short loc_1500
loc_151A:
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz short loc_1559
lea rsp, [rbp-28h]
mov eax, r8d
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_153B:
or [rsp+rax+1050h+var_1058], 0
jmp loc_13BB
loc_1546:
or [rsp+rax+2050h+var_2058], 0
jmp loc_1474
loc_1551:
mov r8d, 0FA0A1F01h
jmp short loc_151A
loc_1559:
call ___stack_chk_fail
loc_155E:
mov rax, r14
mov rdx, rsp
and r14, 0FFFFFFFFFFFFF000h
and rax, 0FFFFFFFFFFFFFFF0h
sub rdx, r14
loc_1572:
cmp rsp, rdx
jz short loc_1589
sub rsp, 1000h
or [rsp+2050h+var_1058], 0
jmp short loc_1572
loc_1589:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_159C
or [rsp+rax+1050h+var_1058], 0
loc_159C:
lea rax, [rsp+1050h+var_104D]
mov edx, 4
mov rsi, r12
mov rbx, rax
and rax, 0FFFFFFFFFFFFFFFCh
mov rdi, rax
shr rbx, 2
call _memcpy
mov rax, [rbp+var_50]
mov r8d, ds:dword_0[rbx*4]
add r8d, ds:dword_0[rax*4]
mov eax, 0FA0A1F01h
sub r8d, [r12]
cmp r8d, eax
cmovl r8d, eax
jmp loc_151A | long long func0(_DWORD *a1, int a2)
{
long long v2; // r15
long long v3; // r14
unsigned long long *v6; // rdx
signed long long v7; // rax
void *v8; // rsp
long long v9; // r8
long long v10; // rdx
int v11; // ecx
long long v12; // rax
int v13; // esi
_BYTE *v14; // rdx
signed long long v15; // rax
void *v16; // rsp
long long v17; // rax
_DWORD *v18; // r10
int v19; // esi
long long v20; // rdi
long long v21; // r11
int v22; // ecx
int v23; // eax
_DWORD *v24; // rdx
int v25; // r15d
long long v26; // rdx
int v27; // r8d
signed long long v29; // rax
void *v30; // rsp
_BYTE v32[4096]; // [rsp+8h] [rbp-2050h] BYREF
_DWORD v33[1022]; // [rsp+1008h] [rbp-1050h] BYREF
unsigned long long v34; // [rsp+2008h] [rbp-50h] BYREF
long long v35; // [rsp+2010h] [rbp-48h]
unsigned long long v36; // [rsp+2020h] [rbp-38h]
v2 = 4LL * a2;
v3 = v2 + 15;
v36 = __readfsqword(0x28u);
v6 = (unsigned long long *)((char *)&v34 - ((v2 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( &v34 != v6 )
{
while ( v33 != (_DWORD *)v6 )
;
}
v7 = ((_WORD)v2 + 15) & 0xFF0;
v8 = alloca(v7);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v32[v7 + 4088] = *(_QWORD *)&v32[v7 + 4088];
v34 = ((unsigned long long)v33 + 3) >> 2;
if ( a2 <= 0 )
{
return (unsigned int)-99999999;
}
else
{
v35 = a2;
memcpy(v33, a1, 4LL * a2);
if ( a2 == 1 )
{
while ( v33 != (_DWORD *)((char *)v33 - (v3 & 0xFFFFFFFFFFFFF000LL)) )
;
v29 = ((_WORD)v2 + 15) & 0xFF0;
v30 = alloca(v29);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v32[v29 + 4088] = *(_QWORD *)&v32[v29 + 4088];
memcpy(v33, a1, 4LL);
v27 = *(_DWORD *)(4 * v34) + v33[0] - *a1;
if ( v27 < -99999999 )
return (unsigned int)-99999999;
}
else
{
v9 = v35;
v10 = 1LL;
do
{
v11 = a1[v10];
v12 = 0LL;
do
{
if ( v11 > a1[v12] )
{
v13 = v11 + v33[v12];
if ( v33[v10] < v13 )
v33[v10] = v13;
}
++v12;
}
while ( v10 != v12 );
++v10;
}
while ( v9 != v10 );
v14 = (char *)v33 - (v3 & 0xFFFFFFFFFFFFF000LL);
if ( v33 != (_DWORD *)v14 )
{
while ( v32 != v14 )
;
}
v15 = ((_WORD)v2 + 15) & 0xFF0;
v16 = alloca(v15);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v32[v15 - 8] = *(_QWORD *)&v32[v15 - 8];
v17 = memcpy(v32, a1, 4LL * (unsigned int)(a2 - 1) + 4);
v18 = &a1[(unsigned long long)v2 / 4];
v19 = a2 - 2;
v20 = v17;
v21 = (long long)&a1[(unsigned long long)v2 / 4 - 1];
do
{
v22 = *(v18 - 2);
v23 = a2 - 1;
v24 = (_DWORD *)v21;
do
{
if ( v22 > *v24 )
{
v25 = v22 + *(_DWORD *)(v20 + 4LL * v23);
if ( *(_DWORD *)(v20 + 4LL * v19) < v25 )
*(_DWORD *)(v20 + 4LL * v19) = v25;
}
--v23;
--v24;
}
while ( v23 != v19 );
--v18;
v19 = v23 - 1;
}
while ( v23 );
v26 = 0LL;
v27 = -99999999;
do
{
if ( v27 < v33[v26] + *(_DWORD *)(v20 + 4 * v26) - a1[v26] )
v27 = v33[v26] + *(_DWORD *)(v20 + 4 * v26) - a1[v26];
++v26;
}
while ( a2 > (int)v26 );
}
}
return (unsigned int)v27;
} | func0:
ENDBR64
PUSH RBP
MOVSXD R8,ESI
MOV RBP,RSP
PUSH R15
LEA R15,[R8*0x4]
PUSH R14
LEA R14,[R15 + 0xf]
PUSH R13
MOV RCX,R14
MOV R13,R8
PUSH R12
AND RCX,-0x1000
MOV R12,RDI
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV RDX,RSP
MOV RAX,R14
SUB RDX,RCX
AND RAX,-0x10
CMP RSP,RDX
JZ 0x001013aa
LAB_00101395:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDX
JNZ 0x00101395
LAB_001013aa:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JNZ 0x0010153b
LAB_001013bb:
LEA RBX,[RSP + 0x3]
MOV RAX,RBX
AND RBX,-0x4
SHR RAX,0x2
MOV qword ptr [RBP + -0x50],RAX
TEST R13D,R13D
JLE 0x00101551
LEA RDX,[R8*0x4]
MOV RSI,R12
MOV RDI,RBX
MOV qword ptr [RBP + -0x48],R8
CALL 0x001010b0
CMP R13D,0x1
JZ 0x0010155e
MOV R8,qword ptr [RBP + -0x48]
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101408:
MOV ECX,dword ptr [R12 + RDX*0x4]
XOR EAX,EAX
NOP
LAB_00101410:
CMP ECX,dword ptr [R12 + RAX*0x4]
JLE 0x00101423
MOV ESI,dword ptr [RBX + RAX*0x4]
ADD ESI,ECX
CMP dword ptr [RBX + RDX*0x4],ESI
JGE 0x00101423
MOV dword ptr [RBX + RDX*0x4],ESI
LAB_00101423:
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x00101410
ADD RDX,0x1
CMP R8,RDX
JNZ 0x00101408
MOV RAX,R14
MOV RDX,RSP
AND R14,-0x1000
SUB RDX,R14
AND RAX,-0x10
CMP RSP,RDX
JZ 0x00101463
LAB_0010144e:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDX
JNZ 0x0010144e
LAB_00101463:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JNZ 0x00101546
LAB_00101474:
LEA EAX,[R13 + -0x1]
TEST R13D,R13D
MOV RDI,RSP
MOV RSI,R12
LEA RDX,[0x4 + RAX*0x4]
MOV R14,RAX
MOV EAX,0x4
CMOVLE RDX,RAX
CALL 0x001010b0
LEA R10,[R12 + R15*0x1]
LEA ESI,[R13 + -0x2]
MOV RDI,RAX
LEA R11,[R12 + R15*0x1 + -0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001014b0:
MOV ECX,dword ptr [R10 + -0x8]
MOV EAX,R14D
MOV RDX,R11
MOVSXD R9,ESI
NOP dword ptr [RAX]
LAB_001014c0:
CMP ECX,dword ptr [RDX]
JLE 0x001014d8
MOVSXD R8,EAX
MOV R15D,dword ptr [RDI + R8*0x4]
ADD R15D,ECX
CMP dword ptr [RDI + R9*0x4],R15D
JGE 0x001014d8
MOV dword ptr [RDI + R9*0x4],R15D
LAB_001014d8:
SUB EAX,0x1
SUB RDX,0x4
CMP EAX,ESI
JNZ 0x001014c0
SUB R10,0x4
LEA ESI,[RAX + -0x1]
TEST EAX,EAX
JNZ 0x001014b0
XOR EDX,EDX
MOV R8D,0xfa0a1f01
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101500:
MOV EAX,dword ptr [RDI + RDX*0x4]
ADD EAX,dword ptr [RBX + RDX*0x4]
SUB EAX,dword ptr [R12 + RDX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDX,0x1
CMP R13D,EDX
JG 0x00101500
LAB_0010151a:
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101559
LEA RSP,[RBP + -0x28]
MOV EAX,R8D
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010153b:
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
JMP 0x001013bb
LAB_00101546:
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
JMP 0x00101474
LAB_00101551:
MOV R8D,0xfa0a1f01
JMP 0x0010151a
LAB_00101559:
CALL 0x00101090
LAB_0010155e:
MOV RAX,R14
MOV RDX,RSP
AND R14,-0x1000
AND RAX,-0x10
SUB RDX,R14
LAB_00101572:
CMP RSP,RDX
JZ 0x00101589
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101572
LAB_00101589:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x0010159c
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_0010159c:
LEA RAX,[RSP + 0x3]
MOV EDX,0x4
MOV RSI,R12
MOV RBX,RAX
AND RAX,-0x4
MOV RDI,RAX
SHR RBX,0x2
CALL 0x001010b0
MOV RAX,qword ptr [RBP + -0x50]
MOV R8D,dword ptr [RBX*0x4]
ADD R8D,dword ptr [RAX*0x4]
MOV EAX,0xfa0a1f01
SUB R8D,dword ptr [R12]
CMP R8D,EAX
CMOVL R8D,EAX
JMP 0x0010151a | int func0(int *param_1,int param_2)
{
long lVar1;
ulong *puVar2;
uint uVar3;
long lVar4;
void *pvVar5;
long lVar7;
size_t __n;
int *piVar8;
ulong *puVar9;
int1 *puVar11;
int1 *puVar13;
int1 *puVar14;
int iVar15;
uint uVar16;
int iVar17;
long lVar18;
int *piVar19;
int iVar20;
long in_FS_OFFSET;
ulong local_58;
long local_50;
long local_40;
ulong uVar6;
ulong *puVar10;
int1 *puVar12;
lVar18 = (long)param_2;
uVar6 = lVar18 * 4 + 0xf;
puVar9 = &local_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar16 = (uint)uVar6;
puVar10 = &local_58;
puVar2 = &local_58;
while (puVar10 != (ulong *)((long)&local_58 - (uVar6 & 0xfffffffffffff000))) {
puVar9 = (ulong *)((long)puVar2 + -0x1000);
*(int8 *)((long)puVar2 + -8) = *(int8 *)((long)puVar2 + -8);
puVar10 = (ulong *)((long)puVar2 + -0x1000);
puVar2 = (ulong *)((long)puVar2 + -0x1000);
}
lVar1 = -(ulong)(uVar16 & 0xff0);
puVar11 = (int1 *)((long)puVar9 + lVar1);
puVar12 = (int1 *)((long)puVar9 + lVar1);
puVar14 = (int1 *)((long)puVar9 + lVar1);
if ((ulong)(uVar16 & 0xff0) != 0) {
*(int8 *)((long)puVar9 + -8) = *(int8 *)((long)puVar9 + -8);
}
local_58 = (ulong)((long)puVar9 + lVar1 + 3) >> 2;
if (param_2 < 1) {
puVar13 = (int1 *)((long)puVar9 + lVar1);
iVar17 = -99999999;
}
else {
*(int8 *)((long)puVar9 + lVar1 + -8) = 0x1013ef;
local_50 = lVar18;
memcpy((int1 *)((long)puVar9 + lVar1),param_1,lVar18 * 4);
if (param_2 == 1) {
for (; puVar14 != (int1 *)((long)puVar9 + (lVar1 - (uVar6 & 0xfffffffffffff000)));
puVar14 = puVar14 + -0x1000) {
*(int8 *)(puVar14 + -8) = *(int8 *)(puVar14 + -8);
}
lVar18 = -(ulong)(uVar16 & 0xff0);
if ((ulong)(uVar16 & 0xff0) != 0) {
*(int8 *)(puVar14 + -8) = *(int8 *)(puVar14 + -8);
}
*(int8 *)(puVar14 + lVar18 + -8) = 0x1015bc;
memcpy(puVar14 + lVar18,param_1,4);
iVar17 = (*(int *)(puVar14 + lVar18) + *(int *)(local_58 * 4)) - *param_1;
puVar13 = puVar14 + lVar18;
if (iVar17 < -99999999) {
puVar13 = puVar14 + lVar18;
iVar17 = -99999999;
}
}
else {
lVar7 = 1;
do {
iVar17 = param_1[lVar7];
lVar4 = 0;
do {
if ((param_1[lVar4] < iVar17) &&
(iVar15 = *(int *)((long)puVar9 + lVar4 * 4 + lVar1) + iVar17,
*(int *)((long)puVar9 + lVar7 * 4 + lVar1) < iVar15)) {
*(int *)((long)puVar9 + lVar7 * 4 + lVar1) = iVar15;
}
lVar4 = lVar4 + 1;
} while (lVar7 != lVar4);
lVar7 = lVar7 + 1;
} while (local_50 != lVar7);
puVar13 = (int1 *)((long)puVar9 + lVar1);
while (puVar11 != (int1 *)((long)puVar9 + (lVar1 - (uVar6 & 0xfffffffffffff000)))) {
puVar12 = puVar13 + -0x1000;
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
puVar11 = puVar13 + -0x1000;
puVar13 = puVar13 + -0x1000;
}
lVar7 = -(ulong)(uVar16 & 0xff0);
if ((ulong)(uVar16 & 0xff0) != 0) {
*(int8 *)(puVar12 + -8) = *(int8 *)(puVar12 + -8);
}
__n = (ulong)(param_2 - 1) * 4 + 4;
if (param_2 < 1) {
__n = 4;
}
*(int8 *)(puVar12 + lVar7 + -8) = 0x10149a;
pvVar5 = memcpy(puVar12 + lVar7,param_1,__n);
piVar19 = param_1 + lVar18;
uVar16 = param_2 - 2;
do {
iVar17 = piVar19[-2];
uVar6 = (ulong)(param_2 - 1);
piVar8 = param_1 + lVar18 + -1;
do {
iVar15 = (int)uVar6;
if ((*piVar8 < iVar17) &&
(iVar20 = *(int *)((long)pvVar5 + (long)iVar15 * 4) + iVar17,
*(int *)((long)pvVar5 + (long)(int)uVar16 * 4) < iVar20)) {
*(int *)((long)pvVar5 + (long)(int)uVar16 * 4) = iVar20;
}
uVar3 = iVar15 - 1;
uVar6 = (ulong)uVar3;
piVar8 = piVar8 + -1;
} while (uVar3 != uVar16);
piVar19 = piVar19 + -1;
uVar16 = iVar15 - 2;
} while (uVar3 != 0);
lVar18 = 0;
iVar17 = -99999999;
do {
iVar15 = (*(int *)((long)pvVar5 + lVar18 * 4) + *(int *)((long)puVar9 + lVar18 * 4 + lVar1))
- param_1[lVar18];
if (iVar17 < iVar15) {
iVar17 = iVar15;
}
lVar18 = lVar18 + 1;
puVar13 = puVar12 + lVar7;
} while ((int)lVar18 < param_2);
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar17;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar13 + -8) = 0x10155e;
__stack_chk_fail();
} |
4,875 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int MSIBS[n];
for (int i = 0; i < n; i++) {
MSIBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && MSIBS[i] < MSIBS[j] + arr[i]) {
MSIBS[i] = MSIBS[j] + arr[i];
}
}
}
int MSDBS[n];
for (int i = 0; i < n; i++) {
MSDBS[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[n - i - 1] > arr[n - j - 1] && MSDBS[n - i - 1] < MSDBS[n - j - 1] + arr[n - i - 1]) {
MSDBS[n - i - 1] = MSDBS[n - j - 1] + arr[n - i - 1];
}
}
}
int max_sum = -99999999;
for (int i = 0; i < n; i++) {
if (max_sum < MSIBS[i] + MSDBS[i] - arr[i]) {
max_sum = MSIBS[i] + MSDBS[i] - arr[i];
}
}
return max_sum;
}
| int main() {
assert(func0((int[]){1, 15, 51, 45, 33, 100, 12, 18, 9}, 9) == 194);
assert(func0((int[]){80, 60, 30, 40, 20, 10}, 6) == 210);
assert(func0((int[]){2, 3, 14, 16, 21, 23, 29, 30}, 8) == 138);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
movslq %esi,%r13
push %r12
mov %r13,%r14
shl $0x2,%r13
mov %rdi,%r12
push %rbx
lea 0xf(%r13),%r9
mov %r9,%rdx
and $0xfffffffffffff000,%rdx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rdi
mov %r9,%rax
sub %rdx,%rdi
and $0xfffffffffffffff0,%rax
mov %rdi,%rdx
cmp %rdx,%rsp
je 1359 <func0+0x69>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 1344 <func0+0x54>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
jne 15d0 <func0+0x2e0>
mov %r9,-0x48(%rbp)
mov %rsp,%rbx
test %r14d,%r14d
jle 15c9 <func0+0x2d9>
lea -0x1(%r14),%eax
mov %r12,%rsi
mov %rbx,%rdi
lea 0x4(,%rax,4),%rdx
mov %rax,%r15
callq 10b0 <memcpy@plt>
cmp $0x1,%r14d
mov -0x48(%rbp),%r9
je 15f2 <func0+0x302>
lea -0x2(%r14),%edi
mov $0x1,%edx
mov %rdi,%r8
add $0x2,%rdi
nopw 0x0(%rax,%rax,1)
mov (%r12,%rdx,4),%ecx
xor %eax,%eax
xchg %ax,%ax
cmp (%r12,%rax,4),%ecx
jle 13d3 <func0+0xe3>
mov (%rbx,%rax,4),%esi
add %ecx,%esi
cmp %esi,(%rbx,%rdx,4)
jge 13d3 <func0+0xe3>
mov %esi,(%rbx,%rdx,4)
add $0x1,%rax
cmp %rdx,%rax
jne 13c0 <func0+0xd0>
lea 0x1(%rax),%rdx
cmp %rdx,%rdi
jne 13b8 <func0+0xc8>
mov %r9,%rax
mov %rsp,%rdx
and $0xfffffffffffff000,%r9
sub %r9,%rdx
and $0xfffffffffffffff0,%rax
cmp %rdx,%rsp
je 1413 <func0+0x123>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 13fe <func0+0x10e>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
jne 15db <func0+0x2eb>
mov %r15d,%eax
test %r14d,%r14d
mov %rsp,%rdi
mov %r12,%rsi
lea 0x4(,%rax,4),%rdx
mov $0x4,%eax
mov %r8d,-0x4c(%rbp)
cmovle %rax,%rdx
mov %rdi,-0x48(%rbp)
add %r12,%r13
callq 10b0 <memcpy@plt>
mov -0x4c(%rbp),%r8d
mov %r13,%r11
mov %rax,%rdi
nopl 0x0(%rax,%rax,1)
mov %r8d,%esi
mov -0x8(%r11),%ecx
mov %r15d,%eax
mov %r13,%rdx
lea (%rdi,%rsi,4),%r10
nopl 0x0(%rax)
cmp -0x4(%rdx),%ecx
jle 148f <func0+0x19f>
movslq %eax,%rsi
mov (%rdi,%rsi,4),%r9d
add %ecx,%r9d
cmp %r9d,(%r10)
jge 148f <func0+0x19f>
mov %r9d,(%r10)
sub $0x1,%eax
sub $0x4,%rdx
cmp %eax,%r8d
jne 1478 <func0+0x188>
sub $0x1,%r8d
sub $0x4,%r11
cmp $0xffffffff,%r8d
jne 1460 <func0+0x170>
test %r14d,%r14d
mov $0x1,%ecx
cmovg %r14d,%ecx
cmp $0x3,%r14d
jle 15e6 <func0+0x2f6>
mov %ecx,%edx
movdqa 0xc57(%rip),%xmm2
xor %eax,%eax
shr $0x2,%edx
shl $0x4,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm0
movdqu (%rbx,%rax,1),%xmm4
movdqu (%r12,%rax,1),%xmm5
add $0x10,%rax
paddd %xmm4,%xmm0
psubd %xmm5,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 14d8 <func0+0x1e8>
movdqa %xmm2,%xmm0
mov %ecx,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
and $0x3,%ecx
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm3
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm0
por %xmm3,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%eax
je 15ab <func0+0x2bb>
mov -0x48(%rbp),%rdi
movslq %edx,%rsi
mov (%rdi,%rsi,4),%ecx
add (%rbx,%rsi,4),%ecx
sub (%r12,%rsi,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%r14d
jle 15ab <func0+0x2bb>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%esi
add (%rbx,%rcx,4),%esi
sub (%r12,%rcx,4),%esi
cmp %esi,%eax
cmovl %esi,%eax
add $0x2,%edx
cmp %edx,%r14d
jle 15ab <func0+0x2bb>
movslq %edx,%rdx
mov (%rbx,%rdx,4),%ecx
add (%rdi,%rdx,4),%ecx
sub (%r12,%rdx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
mov -0x38(%rbp),%rdi
xor %fs:0x28,%rdi
jne 161d <func0+0x32d>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
mov $0xfa0a1f01,%eax
jmp 15ab <func0+0x2bb>
orq $0x0,-0x8(%rsp,%rax,1)
jmpq 136a <func0+0x7a>
orq $0x0,-0x8(%rsp,%rax,1)
jmpq 1424 <func0+0x134>
mov $0xfa0a1f01,%eax
xor %edx,%edx
jmpq 1561 <func0+0x271>
mov %r9,%rax
mov %rsp,%rdx
and $0xfffffffffffff000,%r9
and $0xfffffffffffffff0,%rax
sub %r9,%rdx
cmp %rdx,%rsp
je 1622 <func0+0x332>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1606 <func0+0x316>
callq 1090 <__stack_chk_fail@plt>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1635 <func0+0x345>
orq $0x0,-0x8(%rsp,%rax,1)
mov $0x4,%edx
mov %rsp,%rdi
mov %r12,%rsi
callq 10b0 <memcpy@plt>
xor %edx,%edx
mov %rax,-0x48(%rbp)
mov $0xfa0a1f01,%eax
jmpq 1561 <func0+0x271>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
mov r15, r13
shl r13, 2
push rbx
lea r8, [r13+0Fh]
mov rcx, r8
and rcx, 0FFFFFFFFFFFFF000h
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov rdx, rsp
mov rax, r8
sub rdx, rcx
and rax, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdx
jz short loc_1356
loc_1341:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rdx
jnz short loc_1341
loc_1356:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jnz loc_15AD
loc_1367:
mov [rbp+var_58], r8
mov r12, rsp
test r15d, r15d
jle loc_15C3
mov r9d, r15d
lea ecx, [r15-1]
mov rsi, r14; src
mov rdi, r12; dest
shl r9, 2
mov [rbp+var_4C], ecx
mov rdx, r9; n
mov [rbp+n], r9
call _memcpy
cmp r15d, 1
jz loc_15D6
mov r9, [rbp+n]
mov ecx, [rbp+var_4C]
lea ebx, [r15-2]
mov edx, 4
mov r8, [rbp+var_58]
nop dword ptr [rax]
loc_13B8:
mov esi, [r14+rdx]
xor eax, eax
xchg ax, ax
loc_13C0:
cmp esi, [r14+rax]
jle short loc_13D6
mov edi, [r12+rax]
add edi, esi
cmp [r12+rdx], edi
jge short loc_13D6
mov [r12+rdx], edi
loc_13D6:
add rax, 4
cmp rdx, rax
jnz short loc_13C0
add rdx, 4
cmp r9, rdx
jnz short loc_13B8
mov rax, r8
mov rdx, rsp
and r8, 0FFFFFFFFFFFFF000h
sub rdx, r8
and rax, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdx
jz short loc_1416
loc_1401:
sub rsp, 1000h
or [rsp+2060h+var_1068], 0
cmp rsp, rdx
jnz short loc_1401
loc_1416:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jnz loc_15B8
loc_1427:
mov rdi, rsp; dest
mov rdx, r9; n
mov rsi, r14; src
mov [rbp+var_4C], ecx
mov [rbp+n], rdi
call _memcpy
mov ecx, [rbp+var_4C]
lea r11, [r14+r13]
lea r13, [r14+r13-4]
mov rdi, rax
nop dword ptr [rax+rax+00h]
loc_1450:
mov esi, [r11-8]
mov eax, ecx
mov rdx, r13
movsxd r10, ebx
nop dword ptr [rax+00h]
loc_1460:
cmp esi, [rdx]
jle short loc_1478
movsxd r9, eax
mov r8d, [rdi+r9*4]
add r8d, esi
cmp [rdi+r10*4], r8d
jge short loc_1478
mov [rdi+r10*4], r8d
loc_1478:
sub eax, 1
sub rdx, 4
cmp ebx, eax
jnz short loc_1460
sub r11, 4
sub ebx, 1
jnb short loc_1450
cmp ecx, 2
jbe loc_15CA
mov edx, r15d
movdqa xmm2, cs:xmmword_2100
xor eax, eax
shr edx, 2
shl rdx, 4
nop dword ptr [rax+00000000h]
loc_14B0:
movdqu xmm0, xmmword ptr [rdi+rax]
movdqu xmm3, xmmword ptr [r12+rax]
movdqu xmm4, xmmword ptr [r14+rax]
add rax, 10h
paddd xmm0, xmm3
psubd xmm0, xmm4
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_14B0
movdqa xmm1, xmm2
mov ecx, r15d
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
test r15b, 3
jz short loc_158F
loc_1534:
movsxd rdi, ecx
mov r8, [rbp+n]
lea rsi, ds:0[rdi*4]
add r12, rsi
add r8, rsi
mov edx, [r8]
add edx, [r12]
sub edx, [r14+rdi*4]
cmp eax, edx
cmovl eax, edx
lea edx, [rcx+1]
cmp r15d, edx
jle short loc_158F
mov edx, [r12+4]
add edx, [r8+4]
sub edx, [r14+rsi+4]
cmp eax, edx
cmovl eax, edx
add ecx, 2
cmp r15d, ecx
jle short loc_158F
mov edx, [r12+8]
add edx, [r8+8]
sub edx, [r14+rsi+8]
cmp eax, edx
cmovl eax, edx
loc_158F:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_15F0
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_15AD:
or [rsp+rax+1060h+var_1068], 0
jmp loc_1367
loc_15B8:
or [rsp+rax+2060h+var_2068], 0
jmp loc_1427
loc_15C3:
mov eax, 0FA0A1F01h
jmp short loc_158F
loc_15CA:
xor ecx, ecx
mov eax, 0FA0A1F01h
jmp loc_1534
loc_15D6:
mov eax, [r14]
xor ecx, ecx
mov [rbp+var_3C], eax
lea rax, [rbp+var_3C]
mov [rbp+n], rax
mov eax, 0FA0A1F01h
jmp loc_1534
loc_15F0:
call ___stack_chk_fail | long long func0(char *src, int a2)
{
long long v4; // r13
long long *v5; // rdx
signed long long v6; // rax
void *v7; // rsp
size_t v8; // r9
unsigned int v9; // ecx
int v10; // ebx
long long v11; // rdx
long long v12; // r8
int v13; // esi
long long v14; // rax
int v15; // edi
_BYTE *v16; // rdx
signed long long v17; // rax
void *v18; // rsp
_DWORD *v19; // rax
unsigned int v20; // ecx
char *v21; // r11
char *v22; // r13
_DWORD *v23; // rdi
int v24; // esi
signed int v25; // eax
char *v26; // rdx
int v27; // r8d
__m128i si128; // xmm2
long long v30; // rax
__m128i v31; // xmm0
__m128i v32; // xmm3
__m128i v33; // xmm4
__m128i v34; // xmm0
__m128i v35; // xmm1
__m128i v36; // xmm1
signed int v37; // ecx
__m128i v38; // xmm0
__m128i v39; // xmm0
__m128i v40; // xmm2
__m128i v41; // xmm1
long long result; // rax
long long v43; // rsi
_BYTE *v44; // r12
size_t v45; // r8
int v46; // edx
int v47; // edx
int v48; // edx
_BYTE v50[4096]; // [rsp+8h] [rbp-2060h] BYREF
_BYTE v51[4088]; // [rsp+1008h] [rbp-1060h] BYREF
long long v52; // [rsp+2008h] [rbp-60h] BYREF
long long v53; // [rsp+2010h] [rbp-58h]
unsigned int v54; // [rsp+201Ch] [rbp-4Ch]
size_t n; // [rsp+2020h] [rbp-48h]
int v56; // [rsp+202Ch] [rbp-3Ch] BYREF
unsigned long long v57; // [rsp+2030h] [rbp-38h]
v4 = 4LL * a2;
v57 = __readfsqword(0x28u);
v5 = (long long *)((char *)&v52 - ((v4 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( &v52 != v5 )
{
while ( v51 != (_BYTE *)v5 )
;
}
v6 = ((_WORD)v4 + 15) & 0xFF0;
v7 = alloca(v6);
if ( (((_WORD)v4 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v50[v6 + 4088] = *(_QWORD *)&v50[v6 + 4088];
v53 = v4 + 15;
if ( a2 <= 0 )
return 4194967297LL;
v54 = a2 - 1;
n = 4LL * (unsigned int)a2;
memcpy(v51, src, n);
if ( a2 == 1 )
{
v37 = 0;
v56 = *(_DWORD *)src;
n = (size_t)&v56;
result = 4194967297LL;
}
else
{
v8 = n;
v9 = v54;
v10 = a2 - 2;
v11 = 4LL;
v12 = v53;
do
{
v13 = *(_DWORD *)&src[v11];
v14 = 0LL;
do
{
if ( v13 > *(_DWORD *)&src[v14] )
{
v15 = v13 + *(_DWORD *)&v51[v14];
if ( *(_DWORD *)&v51[v11] < v15 )
*(_DWORD *)&v51[v11] = v15;
}
v14 += 4LL;
}
while ( v11 != v14 );
v11 += 4LL;
}
while ( v8 != v11 );
v16 = &v51[-(v12 & 0xFFFFFFFFFFFFF000LL)];
if ( v51 != v16 )
{
while ( v50 != v16 )
;
}
v17 = v12 & 0xFF0;
v18 = alloca(v17);
if ( (v12 & 0xFF0) != 0 )
*(_QWORD *)&v50[v17 - 8] = *(_QWORD *)&v50[v17 - 8];
v54 = v9;
n = (size_t)v50;
v19 = memcpy(v50, src, v8);
v20 = v54;
v21 = &src[v4];
v22 = &src[v4 - 4];
v23 = v19;
do
{
v24 = *((_DWORD *)v21 - 2);
v25 = v20;
v26 = v22;
do
{
if ( v24 > *(_DWORD *)v26 )
{
v27 = v24 + v23[v25];
if ( v23[v10] < v27 )
v23[v10] = v27;
}
--v25;
v26 -= 4;
}
while ( v10 != v25 );
v21 -= 4;
}
while ( v10-- != 0 );
if ( v20 <= 2 )
{
v37 = 0;
result = 4194967297LL;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2100);
v30 = 0LL;
do
{
v31 = _mm_loadu_si128((const __m128i *)&v23[v30]);
v32 = _mm_loadu_si128((const __m128i *)&v51[v30 * 4]);
v33 = _mm_loadu_si128((const __m128i *)&src[v30 * 4]);
v30 += 4LL;
v34 = _mm_sub_epi32(_mm_add_epi32(v31, v32), v33);
v35 = _mm_cmpgt_epi32(v34, si128);
si128 = _mm_or_si128(_mm_andnot_si128(v35, si128), _mm_and_si128(v34, v35));
}
while ( v30 != 4LL * ((unsigned int)a2 >> 2) );
v36 = _mm_srli_si128(si128, 8);
v37 = a2 & 0xFFFFFFFC;
v38 = _mm_cmpgt_epi32(v36, si128);
v39 = _mm_or_si128(_mm_andnot_si128(v38, si128), _mm_and_si128(v36, v38));
v40 = _mm_srli_si128(v39, 4);
v41 = _mm_cmpgt_epi32(v40, v39);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v41, v39), _mm_and_si128(v40, v41)));
if ( (a2 & 3) == 0 )
return result;
}
}
v43 = 4LL * v37;
v44 = &v51[v43];
v45 = v43 + n;
v46 = *(_DWORD *)&v51[v43] + *(_DWORD *)(v43 + n) - *(_DWORD *)&src[v43];
if ( (int)result < v46 )
result = (unsigned int)v46;
if ( a2 > v37 + 1 )
{
v47 = *(_DWORD *)(v45 + 4) + *((_DWORD *)v44 + 1) - *(_DWORD *)&src[v43 + 4];
if ( (int)result < v47 )
result = (unsigned int)v47;
if ( a2 > v37 + 2 )
{
v48 = *(_DWORD *)(v45 + 8) + *((_DWORD *)v44 + 2) - *(_DWORD *)&src[v43 + 8];
if ( (int)result < v48 )
return (unsigned int)v48;
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R15,R13
SHL R13,0x2
PUSH RBX
LEA R8,[R13 + 0xf]
MOV RCX,R8
AND RCX,-0x1000
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV RDX,RSP
MOV RAX,R8
SUB RDX,RCX
AND RAX,-0x10
CMP RSP,RDX
JZ 0x00101356
LAB_00101341:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDX
JNZ 0x00101341
LAB_00101356:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JNZ 0x001015ad
LAB_00101367:
MOV qword ptr [RBP + -0x58],R8
MOV R12,RSP
TEST R15D,R15D
JLE 0x001015c3
MOV R9D,R15D
LEA ECX,[R15 + -0x1]
MOV RSI,R14
MOV RDI,R12
SHL R9,0x2
MOV dword ptr [RBP + -0x4c],ECX
MOV RDX,R9
MOV qword ptr [RBP + -0x48],R9
CALL 0x001010b0
CMP R15D,0x1
JZ 0x001015d6
MOV R9,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RBP + -0x4c]
LEA EBX,[R15 + -0x2]
MOV EDX,0x4
MOV R8,qword ptr [RBP + -0x58]
NOP dword ptr [RAX]
LAB_001013b8:
MOV ESI,dword ptr [R14 + RDX*0x1]
XOR EAX,EAX
NOP
LAB_001013c0:
CMP ESI,dword ptr [R14 + RAX*0x1]
JLE 0x001013d6
MOV EDI,dword ptr [R12 + RAX*0x1]
ADD EDI,ESI
CMP dword ptr [R12 + RDX*0x1],EDI
JGE 0x001013d6
MOV dword ptr [R12 + RDX*0x1],EDI
LAB_001013d6:
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x001013c0
ADD RDX,0x4
CMP R9,RDX
JNZ 0x001013b8
MOV RAX,R8
MOV RDX,RSP
AND R8,-0x1000
SUB RDX,R8
AND RAX,-0x10
CMP RSP,RDX
JZ 0x00101416
LAB_00101401:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDX
JNZ 0x00101401
LAB_00101416:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JNZ 0x001015b8
LAB_00101427:
MOV RDI,RSP
MOV RDX,R9
MOV RSI,R14
MOV dword ptr [RBP + -0x4c],ECX
MOV qword ptr [RBP + -0x48],RDI
CALL 0x001010b0
MOV ECX,dword ptr [RBP + -0x4c]
LEA R11,[R14 + R13*0x1]
LEA R13,[R14 + R13*0x1 + -0x4]
MOV RDI,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101450:
MOV ESI,dword ptr [R11 + -0x8]
MOV EAX,ECX
MOV RDX,R13
MOVSXD R10,EBX
NOP dword ptr [RAX]
LAB_00101460:
CMP ESI,dword ptr [RDX]
JLE 0x00101478
MOVSXD R9,EAX
MOV R8D,dword ptr [RDI + R9*0x4]
ADD R8D,ESI
CMP dword ptr [RDI + R10*0x4],R8D
JGE 0x00101478
MOV dword ptr [RDI + R10*0x4],R8D
LAB_00101478:
SUB EAX,0x1
SUB RDX,0x4
CMP EBX,EAX
JNZ 0x00101460
SUB R11,0x4
SUB EBX,0x1
JNC 0x00101450
CMP ECX,0x2
JBE 0x001015ca
MOV EDX,R15D
MOVDQA XMM2,xmmword ptr [0x00102100]
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP dword ptr [RAX]
LAB_001014b0:
MOVDQU XMM0,xmmword ptr [RDI + RAX*0x1]
MOVDQU XMM3,xmmword ptr [R12 + RAX*0x1]
MOVDQU XMM4,xmmword ptr [R14 + RAX*0x1]
ADD RAX,0x10
PADDD XMM0,XMM3
PSUBD XMM0,XMM4
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x001014b0
MOVDQA XMM1,XMM2
MOV ECX,R15D
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
TEST R15B,0x3
JZ 0x0010158f
LAB_00101534:
MOVSXD RDI,ECX
MOV R8,qword ptr [RBP + -0x48]
LEA RSI,[RDI*0x4]
ADD R12,RSI
ADD R8,RSI
MOV EDX,dword ptr [R8]
ADD EDX,dword ptr [R12]
SUB EDX,dword ptr [R14 + RDI*0x4]
CMP EAX,EDX
CMOVL EAX,EDX
LEA EDX,[RCX + 0x1]
CMP R15D,EDX
JLE 0x0010158f
MOV EDX,dword ptr [R12 + 0x4]
ADD EDX,dword ptr [R8 + 0x4]
SUB EDX,dword ptr [R14 + RSI*0x1 + 0x4]
CMP EAX,EDX
CMOVL EAX,EDX
ADD ECX,0x2
CMP R15D,ECX
JLE 0x0010158f
MOV EDX,dword ptr [R12 + 0x8]
ADD EDX,dword ptr [R8 + 0x8]
SUB EDX,dword ptr [R14 + RSI*0x1 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_0010158f:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001015f0
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001015ad:
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
JMP 0x00101367
LAB_001015b8:
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
JMP 0x00101427
LAB_001015c3:
MOV EAX,0xfa0a1f01
JMP 0x0010158f
LAB_001015ca:
XOR ECX,ECX
MOV EAX,0xfa0a1f01
JMP 0x00101534
LAB_001015d6:
MOV EAX,dword ptr [R14]
XOR ECX,ECX
MOV dword ptr [RBP + -0x3c],EAX
LEA RAX,[RBP + -0x3c]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,0xfa0a1f01
JMP 0x00101534
LAB_001015f0:
CALL 0x00101090 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(int4 *param_1,ulong param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int *puVar4;
uint uVar5;
ulong uVar6;
size_t sVar7;
void *pvVar8;
long lVar9;
uint uVar10;
uint uVar11;
size_t sVar12;
int *piVar13;
uint uVar14;
int *puVar15;
int *puVar17;
int *puVar19;
int iVar20;
long lVar21;
int4 *puVar22;
int *piVar23;
ulong uVar24;
long in_FS_OFFSET;
bool bVar25;
uint uVar26;
uint uVar27;
uint uVar28;
uint uVar29;
uint uVar30;
uint uVar31;
uint uVar32;
uint uVar33;
uint uVar34;
int auStack_68 [8];
ulong local_60;
uint local_54;
int4 *local_50;
int4 local_44;
long local_40;
int *puVar16;
int *puVar18;
uVar11 = (uint)param_2;
uVar24 = (ulong)(int)uVar11;
local_60 = uVar24 * 4 + 0xf;
puVar15 = auStack_68;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar16 = auStack_68;
puVar18 = auStack_68;
while (puVar16 != auStack_68 + -(local_60 & 0xfffffffffffff000)) {
puVar15 = puVar18 + -0x1000;
*(int8 *)(puVar18 + -8) = *(int8 *)(puVar18 + -8);
puVar16 = puVar18 + -0x1000;
puVar18 = puVar18 + -0x1000;
}
uVar6 = (ulong)((uint)local_60 & 0xff0);
lVar3 = -uVar6;
puVar19 = puVar15 + lVar3;
puVar17 = puVar15 + lVar3;
puVar18 = puVar15 + lVar3;
if (uVar6 != 0) {
*(int8 *)(puVar15 + -8) = *(int8 *)(puVar15 + -8);
}
if ((int)uVar11 < 1) {
uVar14 = 0xfa0a1f01;
}
else {
local_54 = uVar11 - 1;
local_50 = (int4 *)((param_2 & 0xffffffff) << 2);
*(int8 *)(puVar15 + lVar3 + -8) = 0x101397;
memcpy(puVar15 + lVar3,param_1,(size_t)local_50);
puVar22 = local_50;
if (uVar11 == 1) {
local_44 = *param_1;
uVar5 = 0;
local_50 = &local_44;
uVar14 = 0xfa0a1f01;
puVar18 = puVar15 + lVar3;
}
else {
uVar14 = uVar11 - 2;
sVar12 = 4;
do {
iVar2 = *(int *)((long)param_1 + sVar12);
sVar7 = 0;
do {
if ((*(int *)((long)param_1 + sVar7) < iVar2) &&
(iVar20 = *(int *)(puVar15 + sVar7 + lVar3) + iVar2,
*(int *)(puVar15 + sVar12 + lVar3) < iVar20)) {
*(int *)(puVar15 + sVar12 + lVar3) = iVar20;
}
sVar7 = sVar7 + 4;
} while (sVar12 != sVar7);
sVar12 = sVar12 + 4;
} while (local_50 != (int4 *)sVar12);
puVar4 = puVar15 + lVar3;
while (puVar17 != puVar15 + (lVar3 - (local_60 & 0xfffffffffffff000))) {
puVar18 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar17 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar6 = (ulong)((uint)local_60 & 0xff0);
lVar21 = -uVar6;
local_50 = (int4 *)(puVar18 + lVar21);
puVar19 = puVar18 + lVar21;
if (uVar6 != 0) {
*(int8 *)(puVar18 + -8) = *(int8 *)(puVar18 + -8);
}
*(int8 *)(puVar18 + lVar21 + -8) = 0x10143c;
pvVar8 = memcpy(puVar18 + lVar21,param_1,(size_t)puVar22);
puVar22 = param_1 + uVar24;
do {
iVar2 = puVar22[-2];
piVar13 = param_1 + (uVar24 - 1);
uVar5 = local_54;
do {
if ((*piVar13 < iVar2) &&
(iVar20 = *(int *)((long)pvVar8 + (long)(int)uVar5 * 4) + iVar2,
*(int *)((long)pvVar8 + (long)(int)uVar14 * 4) < iVar20)) {
*(int *)((long)pvVar8 + (long)(int)uVar14 * 4) = iVar20;
}
uVar5 = uVar5 - 1;
piVar13 = piVar13 + -1;
} while (uVar14 != uVar5);
puVar22 = puVar22 + -1;
bVar25 = uVar14 != 0;
uVar14 = uVar14 - 1;
} while (bVar25);
if (local_54 < 3) {
uVar5 = 0;
uVar14 = 0xfa0a1f01;
puVar18 = puVar18 + lVar21;
}
else {
lVar9 = 0;
uVar14 = _DAT_00102100;
uVar10 = _UNK_00102104;
uVar30 = _UNK_00102108;
uVar34 = _UNK_0010210c;
do {
piVar13 = (int *)((long)pvVar8 + lVar9);
piVar23 = (int *)(puVar15 + lVar9 + lVar3);
piVar1 = (int *)((long)param_1 + lVar9);
lVar9 = lVar9 + 0x10;
uVar5 = (*piVar13 + *piVar23) - *piVar1;
uVar26 = (piVar13[1] + piVar23[1]) - piVar1[1];
uVar27 = (piVar13[2] + piVar23[2]) - piVar1[2];
uVar28 = (piVar13[3] + piVar23[3]) - piVar1[3];
uVar29 = -(uint)((int)uVar14 < (int)uVar5);
uVar31 = -(uint)((int)uVar10 < (int)uVar26);
uVar32 = -(uint)((int)uVar30 < (int)uVar27);
uVar33 = -(uint)((int)uVar34 < (int)uVar28);
uVar14 = ~uVar29 & uVar14 | uVar5 & uVar29;
uVar10 = ~uVar31 & uVar10 | uVar26 & uVar31;
uVar30 = ~uVar32 & uVar30 | uVar27 & uVar32;
uVar34 = ~uVar33 & uVar34 | uVar28 & uVar33;
} while (lVar9 != (param_2 >> 2 & 0x3fffffff) << 4);
uVar5 = uVar11 & 0xfffffffc;
uVar14 = ~-(uint)((int)uVar14 < (int)uVar30) & uVar14 |
uVar30 & -(uint)((int)uVar14 < (int)uVar30);
uVar10 = ~-(uint)((int)uVar10 < (int)uVar34) & uVar10 |
uVar34 & -(uint)((int)uVar10 < (int)uVar34);
uVar30 = -(uint)((int)uVar14 < (int)uVar10);
uVar14 = ~uVar30 & uVar14 | uVar10 & uVar30;
puVar18 = puVar18 + lVar21;
if ((uVar24 & 3) == 0) goto LAB_0010158f;
}
}
puVar19 = puVar18;
lVar21 = (long)(int)uVar5;
piVar23 = (int *)(puVar15 + lVar21 * 4 + lVar3);
piVar13 = local_50 + lVar21;
uVar10 = (*piVar13 + *piVar23) - param_1[lVar21];
if ((int)uVar14 < (int)uVar10) {
uVar14 = uVar10;
}
if ((int)(uVar5 + 1) < (int)uVar11) {
uVar10 = (piVar23[1] + piVar13[1]) - param_1[lVar21 + 1];
if ((int)uVar14 < (int)uVar10) {
uVar14 = uVar10;
}
if (((int)(uVar5 + 2) < (int)uVar11) &&
(uVar11 = (piVar23[2] + piVar13[2]) - param_1[lVar21 + 2], (int)uVar14 < (int)uVar11)) {
uVar14 = uVar11;
}
}
}
LAB_0010158f:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar19 + -8) = 0x1015f5;
__stack_chk_fail();
}
return uVar14;
} |
4,876 | func0 |
#include <assert.h>
| double func0(double number) {
if (number == 0) {
return 0;
}
double g = number / 2.0;
double g2 = g + 1;
while (g != g2) {
double n = number / g;
g2 = g;
g = (g + n) / 2;
}
return g;
}
| int main() {
assert(func0(10) == 3.162277660168379);
assert(func0(2) == 1.414213562373095);
assert(func0(9) == 3.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x28(%rbp)
pxor %xmm0,%xmm0
ucomisd -0x28(%rbp),%xmm0
jp 1172 <func0+0x29>
pxor %xmm0,%xmm0
ucomisd -0x28(%rbp),%xmm0
jne 1172 <func0+0x29>
pxor %xmm0,%xmm0
jmp 11f1 <func0+0xa8>
movsd -0x28(%rbp),%xmm0
movsd 0xf21(%rip),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf13(%rip),%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
jmp 11d4 <func0+0x8b>
movsd -0x28(%rbp),%xmm0
divsd -0x18(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x18(%rbp),%xmm0
movsd %xmm0,-0x10(%rbp)
movsd -0x18(%rbp),%xmm0
addsd -0x8(%rbp),%xmm0
movsd 0xed5(%rip),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm0
ucomisd -0x10(%rbp),%xmm0
jp 11a0 <func0+0x57>
movsd -0x18(%rbp),%xmm0
ucomisd -0x10(%rbp),%xmm0
jne 11a0 <func0+0x57>
movsd -0x18(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_28], xmm0
pxor xmm0, xmm0
ucomisd xmm0, [rbp+var_28]
jp short loc_1172
pxor xmm0, xmm0
ucomisd xmm0, [rbp+var_28]
jnz short loc_1172
pxor xmm0, xmm0
jmp short loc_11F1
loc_1172:
movsd xmm0, [rbp+var_28]
movsd xmm1, cs:qword_2080
divsd xmm0, xmm1
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2088
addsd xmm0, xmm1
movsd [rbp+var_10], xmm0
jmp short loc_11D4
loc_11A0:
movsd xmm0, [rbp+var_28]
divsd xmm0, [rbp+var_18]
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_18]
movsd [rbp+var_10], xmm0
movsd xmm0, [rbp+var_18]
addsd xmm0, [rbp+var_8]
movsd xmm1, cs:qword_2080
divsd xmm0, xmm1
movsd [rbp+var_18], xmm0
loc_11D4:
movsd xmm0, [rbp+var_18]
ucomisd xmm0, [rbp+var_10]
jp short loc_11A0
movsd xmm0, [rbp+var_18]
ucomisd xmm0, [rbp+var_10]
jnz short loc_11A0
movsd xmm0, [rbp+var_18]
loc_11F1:
pop rbp
retn | double func0(double a1)
{
double v2; // [rsp+10h] [rbp-18h]
double v3; // [rsp+18h] [rbp-10h]
if ( a1 == 0.0 )
return 0.0;
v2 = a1 / 2.0;
v3 = a1 / 2.0 + 1.0;
while ( v2 != v3 )
{
v3 = v2;
v2 = (v2 + a1 / v2) / 2.0;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x28],XMM0
PXOR XMM0,XMM0
UCOMISD XMM0,qword ptr [RBP + -0x28]
JP 0x00101172
PXOR XMM0,XMM0
UCOMISD XMM0,qword ptr [RBP + -0x28]
JNZ 0x00101172
PXOR XMM0,XMM0
JMP 0x001011f1
LAB_00101172:
MOVSD XMM0,qword ptr [RBP + -0x28]
MOVSD XMM1,qword ptr [0x00102080]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102088]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
JMP 0x001011d4
LAB_001011a0:
MOVSD XMM0,qword ptr [RBP + -0x28]
DIVSD XMM0,qword ptr [RBP + -0x18]
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVSD qword ptr [RBP + -0x10],XMM0
MOVSD XMM0,qword ptr [RBP + -0x18]
ADDSD XMM0,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [0x00102080]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x18],XMM0
LAB_001011d4:
MOVSD XMM0,qword ptr [RBP + -0x18]
UCOMISD XMM0,qword ptr [RBP + -0x10]
JP 0x001011a0
MOVSD XMM0,qword ptr [RBP + -0x18]
UCOMISD XMM0,qword ptr [RBP + -0x10]
JNZ 0x001011a0
MOVSD XMM0,qword ptr [RBP + -0x18]
LAB_001011f1:
POP RBP
RET | double func0(double param_1)
{
int8 local_20;
int8 local_18;
if (param_1 == 0.0) {
local_20 = 0.0;
}
else {
local_20 = param_1 / DAT_00102080;
local_18 = DAT_00102088 + local_20;
for (; local_20 != local_18; local_20 = (local_20 + param_1 / local_20) / DAT_00102080) {
local_18 = local_20;
}
}
return local_20;
} |
4,877 | func0 |
#include <assert.h>
| double func0(double number) {
if (number == 0) {
return 0;
}
double g = number / 2.0;
double g2 = g + 1;
while (g != g2) {
double n = number / g;
g2 = g;
g = (g + n) / 2;
}
return g;
}
| int main() {
assert(func0(10) == 3.162277660168379);
assert(func0(2) == 1.414213562373095);
assert(func0(9) == 3.0);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm3
ucomisd 0xf47(%rip),%xmm0
jnp 11a4 <func0+0x5b>
movapd %xmm3,%xmm0
mulsd 0xf41(%rip),%xmm0
movapd %xmm0,%xmm1
addsd 0xf3d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jp 117b <func0+0x32>
je 11aa <func0+0x61>
movsd 0xf25(%rip),%xmm4
movapd %xmm3,%xmm1
divsd %xmm0,%xmm1
addsd %xmm0,%xmm1
movapd %xmm0,%xmm2
mulsd %xmm4,%xmm1
movapd %xmm1,%xmm0
ucomisd %xmm2,%xmm1
jp 1183 <func0+0x3a>
jne 1183 <func0+0x3a>
retq
jne 115b <func0+0x12>
pxor %xmm0,%xmm0
retq
| func0:
endbr64
ucomisd xmm0, cs:qword_2078
jp short loc_115D
pxor xmm1, xmm1
jz short loc_11A5
loc_115D:
movapd xmm1, xmm0
mulsd xmm1, cs:qword_2080
movapd xmm2, xmm1
addsd xmm2, cs:qword_2088
ucomisd xmm1, xmm2
jp short loc_117D
jz short loc_11A5
loc_117D:
movsd xmm4, cs:qword_2080
loc_1185:
movapd xmm2, xmm0
divsd xmm2, xmm1
addsd xmm2, xmm1
movapd xmm3, xmm1
movapd xmm1, xmm2
mulsd xmm1, xmm4
ucomisd xmm1, xmm3
jp short loc_1185
jnz short loc_1185
loc_11A5:
movapd xmm0, xmm1
retn | __int128 __usercall func0@<xmm0>(__m128 a1@<xmm0>)
{
__int128 v1; // xmm1
double v2; // xmm3_8
v1 = 0LL;
if ( *(double *)a1.m128_u64 != 0.0 )
{
*((_QWORD *)&v1 + 1) = a1.m128_u64[1];
*(double *)&v1 = *(double *)a1.m128_u64 * 0.5;
if ( *(double *)a1.m128_u64 * 0.5 != *(double *)a1.m128_u64 * 0.5 + 1.0 )
{
do
{
v2 = *(double *)&v1;
*((_QWORD *)&v1 + 1) = a1.m128_u64[1];
*(double *)&v1 = (*(double *)a1.m128_u64 / *(double *)&v1 + *(double *)&v1) * 0.5;
}
while ( *(double *)&v1 != v2 );
}
}
return v1;
} | func0:
ENDBR64
UCOMISD XMM0,qword ptr [0x00102078]
JP 0x0010115d
PXOR XMM1,XMM1
JZ 0x001011a5
LAB_0010115d:
MOVAPD XMM1,XMM0
MULSD XMM1,qword ptr [0x00102080]
MOVAPD XMM2,XMM1
ADDSD XMM2,qword ptr [0x00102088]
UCOMISD XMM1,XMM2
JP 0x0010117d
JZ 0x001011a5
LAB_0010117d:
MOVSD XMM4,qword ptr [0x00102080]
LAB_00101185:
MOVAPD XMM2,XMM0
DIVSD XMM2,XMM1
ADDSD XMM2,XMM1
MOVAPD XMM3,XMM1
MOVAPD XMM1,XMM2
MULSD XMM1,XMM4
UCOMISD XMM1,XMM3
JP 0x00101185
JNZ 0x00101185
LAB_001011a5:
MOVAPD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
bool bVar1;
double dVar2;
double dVar3;
dVar3 = 0.0;
if ((param_1 != _DAT_00102078) &&
(dVar2 = param_1 * DAT_00102080, dVar3 = dVar2, dVar2 != dVar2 + _DAT_00102088)) {
do {
dVar3 = (param_1 / dVar2 + dVar2) * DAT_00102080;
bVar1 = dVar3 != dVar2;
dVar2 = dVar3;
} while (bVar1);
}
return dVar3;
} |
4,878 | func0 |
#include <assert.h>
| double func0(double number) {
if (number == 0) {
return 0;
}
double g = number / 2.0;
double g2 = g + 1;
while (g != g2) {
double n = number / g;
g2 = g;
g = (g + n) / 2;
}
return g;
}
| int main() {
assert(func0(10) == 3.162277660168379);
assert(func0(2) == 1.414213562373095);
assert(func0(9) == 3.0);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm5,%xmm5
movapd %xmm0,%xmm3
ucomisd %xmm5,%xmm0
jnp 12f8 <func0+0x68>
movsd 0xdf6(%rip),%xmm4
movapd %xmm3,%xmm0
movsd 0xdf2(%rip),%xmm1
mulsd %xmm4,%xmm0
addsd %xmm0,%xmm1
ucomisd %xmm1,%xmm0
jp 12d0 <func0+0x40>
je 12fe <func0+0x6e>
nopw %cs:0x0(%rax,%rax,1)
movapd %xmm3,%xmm1
movapd %xmm0,%xmm2
divsd %xmm0,%xmm1
addsd %xmm0,%xmm1
movapd %xmm1,%xmm0
mulsd %xmm4,%xmm0
ucomisd %xmm0,%xmm2
jp 12d0 <func0+0x40>
jne 12d0 <func0+0x40>
retq
nopl 0x0(%rax)
jne 12a2 <func0+0x12>
pxor %xmm0,%xmm0
retq
| func0:
endbr64
pxor xmm5, xmm5
movapd xmm3, xmm0
ucomisd xmm0, xmm5
jp short loc_12A8
pxor xmm0, xmm0
jz short locret_12F0
loc_12A8:
movsd xmm4, cs:qword_2078
movapd xmm0, xmm3
movsd xmm1, cs:qword_2080
mulsd xmm0, xmm4
addsd xmm1, xmm0
ucomisd xmm0, xmm1
jp short loc_12D0
jz short locret_12F0
nop dword ptr [rax+00h]
loc_12D0:
movapd xmm1, xmm3
movapd xmm2, xmm0
divsd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, xmm1
mulsd xmm0, xmm4
ucomisd xmm2, xmm0
jp short loc_12D0
jnz short loc_12D0
locret_12F0:
retn | double func0(double a1)
{
bool v2; // zf
double result; // xmm0_8
double v4; // xmm2_8
v2 = a1 == 0.0;
result = 0.0;
if ( !v2 )
{
result = a1 * 0.5;
if ( a1 * 0.5 != a1 * 0.5 + 1.0 )
{
do
{
v4 = result;
result = (a1 / result + result) * 0.5;
}
while ( v4 != result );
}
}
return result;
} | func0:
ENDBR64
PXOR XMM5,XMM5
MOVAPD XMM3,XMM0
UCOMISD XMM0,XMM5
JP 0x001012a8
PXOR XMM0,XMM0
JZ 0x001012f0
LAB_001012a8:
MOVSD XMM4,qword ptr [0x00102078]
MOVAPD XMM0,XMM3
MOVSD XMM1,qword ptr [0x00102080]
MULSD XMM0,XMM4
ADDSD XMM1,XMM0
UCOMISD XMM0,XMM1
JP 0x001012d0
JZ 0x001012f0
NOP dword ptr [RAX]
LAB_001012d0:
MOVAPD XMM1,XMM3
MOVAPD XMM2,XMM0
DIVSD XMM1,XMM0
ADDSD XMM1,XMM0
MOVAPD XMM0,XMM1
MULSD XMM0,XMM4
UCOMISD XMM2,XMM0
JP 0x001012d0
JNZ 0x001012d0
LAB_001012f0:
RET | double func0(double param_1)
{
bool bVar1;
double dVar2;
double dVar3;
dVar2 = 0.0;
if ((param_1 != 0.0) &&
(dVar2 = param_1 * DAT_00102078, dVar3 = dVar2, dVar2 != DAT_00102080 + dVar2)) {
do {
dVar2 = (param_1 / dVar3 + dVar3) * DAT_00102078;
bVar1 = dVar3 != dVar2;
dVar3 = dVar2;
} while (bVar1);
}
return dVar2;
} |
4,879 | func0 |
#include <assert.h>
| double func0(double number) {
if (number == 0) {
return 0;
}
double g = number / 2.0;
double g2 = g + 1;
while (g != g2) {
double n = number / g;
g2 = g;
g = (g + n) / 2;
}
return g;
}
| int main() {
assert(func0(10) == 3.162277660168379);
assert(func0(2) == 1.414213562373095);
assert(func0(9) == 3.0);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm5,%xmm5
movapd %xmm0,%xmm3
ucomisd %xmm5,%xmm0
jnp 12f8 <func0+0x68>
movsd 0xdf6(%rip),%xmm4
movapd %xmm3,%xmm0
movsd 0xdf2(%rip),%xmm1
mulsd %xmm4,%xmm0
addsd %xmm0,%xmm1
ucomisd %xmm1,%xmm0
jp 12d0 <func0+0x40>
je 12fe <func0+0x6e>
nopw %cs:0x0(%rax,%rax,1)
movapd %xmm3,%xmm1
movapd %xmm0,%xmm2
divsd %xmm0,%xmm1
addsd %xmm0,%xmm1
movapd %xmm1,%xmm0
mulsd %xmm4,%xmm0
ucomisd %xmm0,%xmm2
jp 12d0 <func0+0x40>
jne 12d0 <func0+0x40>
retq
nopl 0x0(%rax)
jne 12a2 <func0+0x12>
pxor %xmm0,%xmm0
retq
| func0:
endbr64
movapd xmm3, xmm0
pxor xmm0, xmm0
ucomisd xmm3, xmm0
jp short loc_12A4
jz short locret_12F0
loc_12A4:
movsd xmm4, cs:qword_2078
movapd xmm0, xmm3
movsd xmm1, cs:qword_2080
mulsd xmm0, xmm4
addsd xmm1, xmm0
ucomisd xmm0, xmm1
jp short loc_12D0
jz short locret_12F0
nop dword ptr [rax+rax+00000000h]
loc_12D0:
movapd xmm1, xmm3
movapd xmm2, xmm0
divsd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, xmm1
mulsd xmm0, xmm4
ucomisd xmm2, xmm0
jp short loc_12D0
jnz short loc_12D0
locret_12F0:
retn | double func0(double a1)
{
double result; // xmm0_8
double v3; // xmm2_8
result = 0.0;
if ( a1 != 0.0 )
{
result = a1 * 0.5;
if ( a1 * 0.5 != a1 * 0.5 + 1.0 )
{
do
{
v3 = result;
result = (a1 / result + result) * 0.5;
}
while ( v3 != result );
}
}
return result;
} | func0:
ENDBR64
MOVAPD XMM3,XMM0
PXOR XMM0,XMM0
UCOMISD XMM3,XMM0
JP 0x001012a4
JZ 0x001012f0
LAB_001012a4:
MOVSD XMM4,qword ptr [0x00102078]
MOVAPD XMM0,XMM3
MOVSD XMM1,qword ptr [0x00102080]
MULSD XMM0,XMM4
ADDSD XMM1,XMM0
UCOMISD XMM0,XMM1
JP 0x001012d0
JZ 0x001012f0
NOP dword ptr [RAX + RAX*0x1]
LAB_001012d0:
MOVAPD XMM1,XMM3
MOVAPD XMM2,XMM0
DIVSD XMM1,XMM0
ADDSD XMM1,XMM0
MOVAPD XMM0,XMM1
MULSD XMM0,XMM4
UCOMISD XMM2,XMM0
JP 0x001012d0
JNZ 0x001012d0
LAB_001012f0:
RET | void func0(double param_1)
{
bool bVar1;
double dVar2;
double dVar3;
if ((param_1 != 0.0) && (dVar2 = param_1 * DAT_00102078, dVar2 != DAT_00102080 + dVar2)) {
do {
dVar3 = (param_1 / dVar2 + dVar2) * DAT_00102078;
bVar1 = dVar2 != dVar3;
dVar2 = dVar3;
} while (bVar1);
}
return;
} |
4,880 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char str[]) {
int n = strlen(str);
int L[n][n];
for (int i = 0; i < n; i++) {
L[i][i] = 1;
}
for (int cl = 2; cl <= n; cl++) {
for (int i = 0; i < n - cl + 1; i++) {
int j = i + cl - 1;
if (str[i] == str[j] && cl == 2) {
L[i][j] = 2;
} else if (str[i] == str[j]) {
L[i][j] = L[i+1][j-1] + 2;
} else {
L[i][j] = (L[i][j-1] > L[i+1][j]) ? L[i][j-1] : L[i+1][j];
}
}
}
return L[0][n-1];
}
| int main() {
assert(func0("TENS FOR TENS") == 5);
assert(func0("CARDIO FOR CARDS") == 7);
assert(func0("PART OF THE JOURNEY IS PART") == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x88,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x58(%rbp)
mov -0x58(%rbp),%esi
mov -0x58(%rbp),%edi
movslq %esi,%rax
sub $0x1,%rax
mov %rax,-0x50(%rbp)
movslq %esi,%rax
mov %rax,-0xb0(%rbp)
movq $0x0,-0xa8(%rbp)
movslq %esi,%rax
lea 0x0(,%rax,4),%rcx
movslq %edi,%rax
sub $0x1,%rax
mov %rax,-0x48(%rbp)
movslq %esi,%rax
mov %rax,-0xa0(%rbp)
movq $0x0,-0x98(%rbp)
movslq %edi,%rax
mov %rax,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
mov -0xa0(%rbp),%r9
mov -0x98(%rbp),%r10
mov %r10,%rdx
imul -0x90(%rbp),%rdx
mov -0x88(%rbp),%rax
imul %r9,%rax
lea (%rdx,%rax,1),%r8
mov %r9,%rax
mulq -0x90(%rbp)
add %rdx,%r8
mov %r8,%rdx
movslq %esi,%rax
mov %rax,%r14
mov $0x0,%r15d
movslq %edi,%rax
mov %rax,%r12
mov $0x0,%r13d
mov %r15,%rdx
imul %r12,%rdx
mov %r13,%rax
imul %r14,%rax
lea (%rdx,%rax,1),%r8
mov %r14,%rax
mul %r12
add %rdx,%r8
mov %r8,%rdx
movslq %esi,%rdx
movslq %edi,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 12f6 <func0+0x16d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12df <func0+0x156>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1320 <func0+0x197>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x5c(%rbp)
jmp 1360 <func0+0x1d7>
mov %rcx,%rdx
shr $0x2,%rdx
mov -0x40(%rbp),%rax
lea 0x1(%rdx),%rsi
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
imul %rsi,%rdx
movl $0x1,(%rax,%rdx,4)
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x58(%rbp),%eax
jl 133c <func0+0x1b3>
movl $0x2,-0x60(%rbp)
jmpq 14d9 <func0+0x350>
movl $0x0,-0x64(%rbp)
jmpq 14c6 <func0+0x33d>
mov -0x64(%rbp),%edx
mov -0x60(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
mov %eax,-0x54(%rbp)
mov -0x64(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x54(%rbp),%eax
movslq %eax,%rsi
mov -0x78(%rbp),%rax
add %rsi,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 13e2 <func0+0x259>
cmpl $0x2,-0x60(%rbp)
jne 13e2 <func0+0x259>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
movslq %edx,%rsi
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x2,(%rax,%rdx,4)
jmpq 14c2 <func0+0x339>
mov -0x64(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x54(%rbp),%eax
movslq %eax,%rsi
mov -0x78(%rbp),%rax
add %rsi,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 1453 <func0+0x2ca>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x64(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x54(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rsi
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%eax
mov %rcx,%r8
shr $0x2,%r8
lea 0x2(%rax),%esi
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
movslq %edx,%rdi
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov %esi,(%rax,%rdx,4)
jmp 14c2 <func0+0x339>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x64(%rbp),%eax
lea 0x1(%rax),%r8d
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
movslq %edx,%rsi
movslq %r8d,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%edx
mov %rcx,%r8
shr $0x2,%r8
mov -0x54(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rdi
mov -0x64(%rbp),%esi
movslq %esi,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov (%rax,%rsi,4),%eax
mov %rcx,%r8
shr $0x2,%r8
cmp %eax,%edx
cmovl %eax,%edx
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%esi
movslq %esi,%rdi
mov -0x64(%rbp),%esi
movslq %esi,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov %edx,(%rax,%rsi,4)
addl $0x1,-0x64(%rbp)
mov -0x58(%rbp),%eax
sub -0x60(%rbp),%eax
cmp %eax,-0x64(%rbp)
jle 1380 <func0+0x1f7>
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x58(%rbp),%eax
jle 1374 <func0+0x1eb>
mov -0x58(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x40(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rbx,%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 150c <func0+0x383>
callq 1080 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_38], eax
mov r8d, [rbp+var_38]
mov r9d, [rbp+var_38]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, r8d
lea rcx, ds:0[rax*4]
movsxd rax, r9d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rdx, r8d
movsxd rax, r9d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rsi, rax
and rsi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rsi
loc_1288:
cmp rsp, rdx
jz short loc_129F
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_1288
loc_129F:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12C9
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12C9:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_44], 0
jmp short loc_1309
loc_12E5:
mov rdx, rcx
shr rdx, 2
mov rax, [rbp+var_20]
lea rsi, [rdx+1]
mov edx, [rbp+var_44]
movsxd rdx, edx
imul rdx, rsi
mov dword ptr [rax+rdx*4], 1
add [rbp+var_44], 1
loc_1309:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_38]
jl short loc_12E5
mov [rbp+var_40], 2
jmp loc_1482
loc_131D:
mov [rbp+var_3C], 0
jmp loc_146F
loc_1329:
mov edx, [rbp+var_3C]
mov eax, [rbp+var_40]
add eax, edx
sub eax, 1
mov [rbp+var_34], eax
mov eax, [rbp+var_3C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_34]
movsxd rsi, eax
mov rax, [rbp+s]
add rax, rsi
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_138B
cmp [rbp+var_40], 2
jnz short loc_138B
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov dword ptr [rax+rdx*4], 2
jmp loc_146B
loc_138B:
mov eax, [rbp+var_3C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_34]
movsxd rsi, eax
mov rax, [rbp+s]
add rax, rsi
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_13FC
mov rdi, rcx
shr rdi, 2
mov eax, [rbp+var_3C]
lea edx, [rax+1]
mov eax, [rbp+var_34]
lea esi, [rax-1]
mov rax, [rbp+var_20]
movsxd rsi, esi
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov eax, [rax+rdx*4]
mov r8, rcx
shr r8, 2
lea esi, [rax+2]
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdi, edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov [rax+rdx*4], esi
jmp short loc_146B
loc_13FC:
mov rdi, rcx
shr rdi, 2
mov eax, [rbp+var_3C]
lea r8d, [rax+1]
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
movsxd rdx, r8d
imul rdx, rdi
add rdx, rsi
mov edx, [rax+rdx*4]
mov r8, rcx
shr r8, 2
mov eax, [rbp+var_34]
lea esi, [rax-1]
mov rax, [rbp+var_20]
movsxd rdi, esi
mov esi, [rbp+var_3C]
movsxd rsi, esi
imul rsi, r8
add rsi, rdi
mov eax, [rax+rsi*4]
mov r8, rcx
shr r8, 2
cmp edx, eax
cmovl edx, eax
mov rax, [rbp+var_20]
mov esi, [rbp+var_34]
movsxd rdi, esi
mov esi, [rbp+var_3C]
movsxd rsi, esi
imul rsi, r8
add rsi, rdi
mov [rax+rsi*4], edx
loc_146B:
add [rbp+var_3C], 1
loc_146F:
mov eax, [rbp+var_38]
sub eax, [rbp+var_40]
cmp [rbp+var_3C], eax
jle loc_1329
add [rbp+var_40], 1
loc_1482:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_38]
jle loc_131D
mov eax, [rbp+var_38]
lea edx, [rax-1]
mov rax, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_14B5
call ___stack_chk_fail
loc_14B5:
mov rbx, [rbp+var_8]
leave
retn | long long func0(char *a1)
{
unsigned long long v1; // rcx
unsigned long long v2; // rax
void *v3; // rsp
int v4; // edx
_BYTE v6[8]; // [rsp+8h] [rbp-60h] BYREF
char *s; // [rsp+10h] [rbp-58h]
int i; // [rsp+24h] [rbp-44h]
int j; // [rsp+28h] [rbp-40h]
int k; // [rsp+2Ch] [rbp-3Ch]
int v11; // [rsp+30h] [rbp-38h]
int v12; // [rsp+34h] [rbp-34h]
long long v13; // [rsp+38h] [rbp-30h]
long long v14; // [rsp+40h] [rbp-28h]
_BYTE *v15; // [rsp+48h] [rbp-20h]
unsigned long long v16; // [rsp+50h] [rbp-18h]
s = a1;
v16 = __readfsqword(0x28u);
v11 = strlen(a1);
v13 = v11 - 1LL;
v1 = 4LL * v11;
v14 = v13;
v2 = 16 * ((4 * v11 * (long long)v11 + 15) / 0x10uLL);
while ( v6 != &v6[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v6[(v2 & 0xFFF) - 8] = *(_QWORD *)&v6[(v2 & 0xFFF) - 8];
v15 = v6;
for ( i = 0; i < v11; ++i )
*(_DWORD *)&v15[4 * ((v1 >> 2) + 1) * i] = 1;
for ( j = 2; j <= v11; ++j )
{
for ( k = 0; k <= v11 - j; ++k )
{
v12 = k + j - 1;
if ( s[k] == s[v12] && j == 2 )
{
*(_DWORD *)&v15[4 * v12 + 4 * (v1 >> 2) * k] = 2;
}
else if ( s[k] == s[v12] )
{
*(_DWORD *)&v15[4 * v12 + 4 * (v1 >> 2) * k] = *(_DWORD *)&v15[4 * v12 - 4 + 4 * (v1 >> 2) * (k + 1)] + 2;
}
else
{
v4 = *(_DWORD *)&v15[4 * v12 + 4 * (v1 >> 2) * (k + 1)];
if ( v4 < *(_DWORD *)&v15[4 * v12 - 4 + 4 * (v1 >> 2) * k] )
v4 = *(_DWORD *)&v15[4 * v12 - 4 + 4 * (v1 >> 2) * k];
*(_DWORD *)&v15[4 * v12 + 4 * (v1 >> 2) * k] = v4;
}
}
}
return *(unsigned int *)&v15[4 * v11 - 4];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x38],EAX
MOV R8D,dword ptr [RBP + -0x38]
MOV R9D,dword ptr [RBP + -0x38]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,R8D
LEA RCX,[RAX*0x4]
MOVSXD RAX,R9D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RDX,R8D
MOVSXD RAX,R9D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RSI,RAX
AND RSI,-0x1000
MOV RDX,RSP
SUB RDX,RSI
LAB_00101288:
CMP RSP,RDX
JZ 0x0010129f
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101288
LAB_0010129f:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012c9
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012c9:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101309
LAB_001012e5:
MOV RDX,RCX
SHR RDX,0x2
MOV RAX,qword ptr [RBP + -0x20]
LEA RSI,[RDX + 0x1]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
IMUL RDX,RSI
MOV dword ptr [RAX + RDX*0x4],0x1
ADD dword ptr [RBP + -0x44],0x1
LAB_00101309:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x001012e5
MOV dword ptr [RBP + -0x40],0x2
JMP 0x00101482
LAB_0010131d:
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x0010146f
LAB_00101329:
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,EDX
SUB EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RSI
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x0010138b
CMP dword ptr [RBP + -0x40],0x2
JNZ 0x0010138b
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV dword ptr [RAX + RDX*0x4],0x2
JMP 0x0010146b
LAB_0010138b:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RSI
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001013fc
MOV RDI,RCX
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x34]
LEA ESI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RSI,ESI
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
LEA ESI,[RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDI,EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV dword ptr [RAX + RDX*0x4],ESI
JMP 0x0010146b
LAB_001013fc:
MOV RDI,RCX
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA R8D,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOVSXD RDX,R8D
IMUL RDX,RDI
ADD RDX,RSI
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x34]
LEA ESI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDI,ESI
MOV ESI,dword ptr [RBP + -0x3c]
MOVSXD RSI,ESI
IMUL RSI,R8
ADD RSI,RDI
MOV EAX,dword ptr [RAX + RSI*0x4]
MOV R8,RCX
SHR R8,0x2
CMP EDX,EAX
CMOVL EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x34]
MOVSXD RDI,ESI
MOV ESI,dword ptr [RBP + -0x3c]
MOVSXD RSI,ESI
IMUL RSI,R8
ADD RSI,RDI
MOV dword ptr [RAX + RSI*0x4],EDX
LAB_0010146b:
ADD dword ptr [RBP + -0x3c],0x1
LAB_0010146f:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,dword ptr [RBP + -0x40]
CMP dword ptr [RBP + -0x3c],EAX
JLE 0x00101329
ADD dword ptr [RBP + -0x40],0x1
LAB_00101482:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x38]
JLE 0x0010131d
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014b5
CALL 0x00101080
LAB_001014b5:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int4 func0(char *param_1)
{
long lVar1;
int iVar2;
int iVar3;
size_t sVar4;
ulong uVar5;
ulong uVar6;
int *puVar7;
long in_FS_OFFSET;
int auStack_68 [8];
char *local_60;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = param_1;
sVar4 = strlen(param_1);
local_40 = (int)sVar4;
local_38 = (long)local_40 + -1;
uVar5 = (ulong)local_40;
local_30 = (long)local_40 + -1;
uVar6 = (((long)local_40 * (long)local_40 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar7 = auStack_68; puVar7 != auStack_68 + -(uVar6 & 0xfffffffffffff000);
puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
lVar1 = -(ulong)((uint)uVar6 & 0xfff);
if ((uVar6 & 0xfff) != 0) {
*(int8 *)(puVar7 + ((ulong)((uint)uVar6 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar7 + ((ulong)((uint)uVar6 & 0xfff) - 8) + lVar1);
}
for (local_4c = 0; local_4c < local_40; local_4c = local_4c + 1) {
*(int4 *)(puVar7 + (long)local_4c * ((uVar5 & 0x3fffffffffffffff) + 1) * 4 + lVar1) = 1;
}
for (local_48 = 2; local_48 <= local_40; local_48 = local_48 + 1) {
for (local_44 = 0; local_44 <= local_40 - local_48; local_44 = local_44 + 1) {
iVar3 = local_48 + local_44;
local_3c = iVar3 + -1;
if ((local_60[local_44] == local_60[local_3c]) && (local_48 == 2)) {
*(int4 *)
(puVar7 + ((long)local_44 * (uVar5 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar1) = 2
;
}
else if (local_60[local_44] == local_60[local_3c]) {
*(int *)(puVar7 + ((long)local_44 * (uVar5 & 0x3fffffffffffffff) + (long)local_3c) * 4 +
lVar1) =
*(int *)(puVar7 + ((long)(local_44 + 1) * (uVar5 & 0x3fffffffffffffff) +
(long)(iVar3 + -2)) * 4 + lVar1) + 2;
}
else {
iVar2 = *(int *)(puVar7 + ((long)(local_44 + 1) * (uVar5 & 0x3fffffffffffffff) +
(long)local_3c) * 4 + lVar1);
if (*(int *)(puVar7 + ((long)(local_44 + 1) * (uVar5 & 0x3fffffffffffffff) + (long)local_3c)
* 4 + lVar1) <
*(int *)(puVar7 + ((long)local_44 * (uVar5 & 0x3fffffffffffffff) + (long)(iVar3 + -2)) *
4 + lVar1)) {
iVar2 = *(int *)(puVar7 + ((long)local_44 * (uVar5 & 0x3fffffffffffffff) +
(long)(iVar3 + -2)) * 4 + lVar1);
}
*(int *)(puVar7 + ((long)local_44 * (uVar5 & 0x3fffffffffffffff) + (long)local_3c) * 4 +
lVar1) = iVar2;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = puVar7 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar7 + (long)(local_40 + -1) * 4 + lVar1);
} |
4,881 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char str[]) {
int n = strlen(str);
int L[n][n];
for (int i = 0; i < n; i++) {
L[i][i] = 1;
}
for (int cl = 2; cl <= n; cl++) {
for (int i = 0; i < n - cl + 1; i++) {
int j = i + cl - 1;
if (str[i] == str[j] && cl == 2) {
L[i][j] = 2;
} else if (str[i] == str[j]) {
L[i][j] = L[i+1][j-1] + 2;
} else {
L[i][j] = (L[i][j-1] > L[i+1][j]) ? L[i][j-1] : L[i+1][j];
}
}
}
return L[0][n-1];
}
| int main() {
assert(func0("TENS FOR TENS") == 5);
assert(func0("CARDIO FOR CARDS") == 7);
assert(func0("PART OF THE JOURNEY IS PART") == 9);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov %rax,-0x50(%rbp)
mov %eax,%esi
cltq
lea 0x0(,%rax,4),%r9
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rdi
sub %rax,%rdi
mov %rdi,%rax
cmp %rax,%rsp
je 11ec <func0+0x83>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11d5 <func0+0x6c>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1202 <func0+0x99>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r8
mov %r8,-0x58(%rbp)
cmpl $0x0,-0x50(%rbp)
jle 1235 <func0+0xcc>
mov %r9,%rcx
shr $0x2,%rcx
mov $0x0,%eax
add $0x1,%rcx
movslq %eax,%rdx
imul %rcx,%rdx
movl $0x1,(%r8,%rdx,4)
add $0x1,%eax
cmp %eax,%esi
jne 121f <func0+0xb6>
mov -0x50(%rbp),%rax
cmp $0x1,%eax
jle 1339 <func0+0x1d0>
shr $0x2,%r9
lea 0x2(%rbx),%r12
mov %eax,-0x44(%rbp)
add $0x1,%eax
mov %eax,-0x48(%rbp)
mov $0x2,%r11d
jmpq 1316 <func0+0x1ad>
cmp %dil,%r15b
je 12db <func0+0x172>
movslq %esi,%rsi
movslq %ecx,%rcx
imul %r9,%rcx
lea (%rsi,%rcx,1),%rdi
lea (%r10,%rax,1),%r15d
movslq %r15d,%r15
add %r15,%rcx
add $0x1,%eax
cltq
imul %r9,%rax
add %rsi,%rax
mov (%r8,%rax,4),%eax
cmp %eax,(%r8,%rcx,4)
cmovge (%r8,%rcx,4),%eax
mov %eax,(%r8,%rdi,4)
lea 0x1(%rdx),%rax
cmp %rdx,%r14
je 1308 <func0+0x19f>
mov %rax,%rdx
mov %edx,%eax
mov %edx,%ecx
lea 0x0(%r13,%rdx,1),%esi
movzbl (%rbx,%rdx,1),%r15d
movzbl -0x1(%r12,%rdx,1),%edi
cmp $0x2,%r11d
jne 125e <func0+0xf5>
cmp %dil,%r15b
jne 125e <func0+0xf5>
movslq %esi,%rax
movslq %edx,%rsi
imul %r9,%rsi
lea (%rax,%rsi,1),%rsi
movl $0x2,(%r8,%rsi,4)
jmp 1298 <func0+0x12f>
movslq %esi,%rsi
movslq %ecx,%rcx
imul %r9,%rcx
add %rcx,%rsi
lea (%r10,%rax,1),%ecx
movslq %ecx,%rcx
add $0x1,%eax
cltq
imul %r9,%rax
add %rax,%rcx
mov (%r8,%rcx,4),%eax
add $0x2,%eax
mov %eax,(%r8,%rsi,4)
jmp 1298 <func0+0x12f>
add $0x1,%r11d
add $0x1,%r12
cmp -0x48(%rbp),%r11d
je 1339 <func0+0x1d0>
mov %r11d,%r10d
mov -0x44(%rbp),%eax
sub %r11d,%eax
mov %eax,%r14d
mov $0x0,%edx
lea -0x1(%r11),%r13d
sub $0x2,%r10d
test %eax,%eax
jns 12a4 <func0+0x13b>
jmp 1308 <func0+0x19f>
mov -0x50(%rbp),%eax
sub $0x1,%eax
cltq
mov -0x58(%rbp),%rbx
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1366 <func0+0x1fd>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
call _strlen
mov [rbp+var_50], rax
mov esi, eax
cdqe
lea r10, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11E4:
cmp rsp, rdx
jz short loc_11FB
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11E4
loc_11FB:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1211
or [rsp+rax+50h+var_58], 0
loc_1211:
mov r9, rsp
cmp dword ptr [rbp+var_50], 0
jle short loc_1240
mov rcx, r10
shr rcx, 2
mov eax, 0
add rcx, 1
loc_122A:
movsxd rdx, eax
imul rdx, rcx
mov dword ptr [r9+rdx*4], 1
add eax, 1
cmp esi, eax
jnz short loc_122A
loc_1240:
mov rax, [rbp+var_50]
cmp eax, 1
jle loc_1332
shr r10, 2
lea r14d, [rax-2]
lea r13, [rbx+2]
add eax, 1
mov [rbp+var_44], eax
mov r11d, 2
jmp loc_1318
loc_126A:
cmp r15b, r8b
jz short loc_12DF
movsxd rdx, edx
movsxd rcx, ecx
imul rcx, r10
lea r8, [rdx+rcx]
movsxd r15, eax
imul r15, r10
add rdx, r15
movsxd rsi, esi
add rsi, rcx
mov edx, [r9+rdx*4]
mov ecx, [r9+rsi*4]
cmp edx, ecx
cmovl edx, ecx
mov [r9+r8*4], edx
loc_129E:
add rax, 1
cmp rax, r12
jz short loc_1306
loc_12A7:
lea ecx, [rax-1]
mov esi, edi
add edi, 1
mov edx, edi
movzx r15d, byte ptr [rbx+rax-1]
movzx r8d, byte ptr [r13+rax-2]
cmp r11d, 2
jnz short loc_126A
cmp r15b, r8b
jnz short loc_126A
movsxd rdx, edi
movsxd rcx, ecx
imul rcx, r10
add rdx, rcx
mov dword ptr [r9+rdx*4], 2
jmp short loc_129E
loc_12DF:
movsxd rdx, edx
movsxd rcx, ecx
imul rcx, r10
add rdx, rcx
movsxd rsi, esi
movsxd rcx, eax
imul rcx, r10
add rsi, rcx
mov ecx, [r9+rsi*4]
add ecx, 2
mov [r9+rdx*4], ecx
jmp short loc_129E
loc_1306:
add r11d, 1
sub r14d, 1
add r13, 1
cmp r11d, [rbp+var_44]
jz short loc_1332
loc_1318:
test r14d, r14d
js short loc_1306
lea edi, [r11-2]
mov r12d, r14d
add r12, 2
mov eax, 1
jmp loc_12A7
loc_1332:
mov eax, dword ptr [rbp+var_50]
sub eax, 1
cdqe
mov eax, [r9+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_135C
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_135C:
call ___stack_chk_fail | long long func0(long long a1)
{
int v2; // esi
unsigned long long v3; // r10
long long v4; // rax
__int16 v5; // cx
signed long long v6; // rax
void *v7; // rsp
int v8; // eax
unsigned long long v9; // r10
int v10; // r14d
long long v11; // r13
int v12; // r11d
unsigned long long v13; // rcx
unsigned long long v14; // r8
int v15; // edx
int v16; // ecx
long long v17; // rax
int v18; // ecx
int v19; // esi
int v20; // edi
char v21; // r15
char v22; // r8
long long v24; // [rsp+0h] [rbp-58h]
long long v25; // [rsp+8h] [rbp-50h] BYREF
int v26; // [rsp+14h] [rbp-44h]
unsigned long long v27; // [rsp+20h] [rbp-38h]
v27 = __readfsqword(0x28u);
v25 = strlen();
v2 = v25;
v3 = 4LL * (int)v25;
v4 = 4 * (int)v25 * (long long)(int)v25 + 15;
v5 = v4 & 0xFFF0;
while ( &v25 != (long long *)((char *)&v25 - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v6 = v4 & 0xFF0;
v7 = alloca(v6);
if ( (v5 & 0xFFF) != 0 )
*(long long *)((char *)&v24 + v6) = *(long long *)((char *)&v24 + v6);
if ( (int)v25 > 0 )
{
v8 = 0;
do
*((_DWORD *)&v25 + ((v3 >> 2) + 1) * v8++) = 1;
while ( v2 != v8 );
}
if ( (int)v25 > 1 )
{
v9 = v3 >> 2;
v10 = v25 - 2;
v11 = a1 + 2;
v26 = v25 + 1;
v12 = 2;
do
{
if ( v10 >= 0 )
{
v20 = v12 - 2;
v17 = 1LL;
do
{
v18 = v17 - 1;
v19 = v20++;
v21 = *(_BYTE *)(a1 + v17 - 1);
v22 = *(_BYTE *)(v11 + v17 - 2);
if ( v12 == 2 && v21 == v22 )
{
*((_DWORD *)&v25 + v9 * v18 + v20) = 2;
}
else if ( v21 == v22 )
{
*((_DWORD *)&v25 + v9 * v18 + v20) = *((_DWORD *)&v25 + v9 * (int)v17 + v19) + 2;
}
else
{
v13 = v9 * v18;
v14 = v20 + v13;
v15 = *((_DWORD *)&v25 + v9 * (int)v17 + v20);
v16 = *((_DWORD *)&v25 + v13 + v19);
if ( v15 < v16 )
v15 = v16;
*((_DWORD *)&v25 + v14) = v15;
}
++v17;
}
while ( v17 != (unsigned int)v10 + 2LL );
}
++v12;
--v10;
++v11;
}
while ( v12 != v26 );
}
return *((unsigned int *)&v25 + (int)v25 - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CALL 0x00101070
MOV qword ptr [RBP + -0x50],RAX
MOV ESI,EAX
CDQE
LEA R10,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011e4:
CMP RSP,RDX
JZ 0x001011fb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e4
LAB_001011fb:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101211
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101211:
MOV R9,RSP
CMP dword ptr [RBP + -0x50],0x0
JLE 0x00101240
MOV RCX,R10
SHR RCX,0x2
MOV EAX,0x0
ADD RCX,0x1
LAB_0010122a:
MOVSXD RDX,EAX
IMUL RDX,RCX
MOV dword ptr [R9 + RDX*0x4],0x1
ADD EAX,0x1
CMP ESI,EAX
JNZ 0x0010122a
LAB_00101240:
MOV RAX,qword ptr [RBP + -0x50]
CMP EAX,0x1
JLE 0x00101332
SHR R10,0x2
LEA R14D,[RAX + -0x2]
LEA R13,[RBX + 0x2]
ADD EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
MOV R11D,0x2
JMP 0x00101318
LAB_0010126a:
CMP R15B,R8B
JZ 0x001012df
MOVSXD RDX,EDX
MOVSXD RCX,ECX
IMUL RCX,R10
LEA R8,[RDX + RCX*0x1]
MOVSXD R15,EAX
IMUL R15,R10
ADD RDX,R15
MOVSXD RSI,ESI
ADD RSI,RCX
MOV EDX,dword ptr [R9 + RDX*0x4]
MOV ECX,dword ptr [R9 + RSI*0x4]
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [R9 + R8*0x4],EDX
LAB_0010129e:
ADD RAX,0x1
CMP RAX,R12
JZ 0x00101306
LAB_001012a7:
LEA ECX,[RAX + -0x1]
MOV ESI,EDI
ADD EDI,0x1
MOV EDX,EDI
MOVZX R15D,byte ptr [RBX + RAX*0x1 + -0x1]
MOVZX R8D,byte ptr [R13 + RAX*0x1 + -0x2]
CMP R11D,0x2
JNZ 0x0010126a
CMP R15B,R8B
JNZ 0x0010126a
MOVSXD RDX,EDI
MOVSXD RCX,ECX
IMUL RCX,R10
ADD RDX,RCX
MOV dword ptr [R9 + RDX*0x4],0x2
JMP 0x0010129e
LAB_001012df:
MOVSXD RDX,EDX
MOVSXD RCX,ECX
IMUL RCX,R10
ADD RDX,RCX
MOVSXD RSI,ESI
MOVSXD RCX,EAX
IMUL RCX,R10
ADD RSI,RCX
MOV ECX,dword ptr [R9 + RSI*0x4]
ADD ECX,0x2
MOV dword ptr [R9 + RDX*0x4],ECX
JMP 0x0010129e
LAB_00101306:
ADD R11D,0x1
SUB R14D,0x1
ADD R13,0x1
CMP R11D,dword ptr [RBP + -0x44]
JZ 0x00101332
LAB_00101318:
TEST R14D,R14D
JS 0x00101306
LEA EDI,[R11 + -0x2]
MOV R12D,R14D
ADD R12,0x2
MOV EAX,0x1
JMP 0x001012a7
LAB_00101332:
MOV EAX,dword ptr [RBP + -0x50]
SUB EAX,0x1
CDQE
MOV EAX,dword ptr [R9 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010135c
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010135c:
CALL 0x00101080 | int4 func0(char *param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
size_t sVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
int iVar9;
int iVar10;
size_t *psVar11;
int iVar12;
char *pcVar13;
uint uVar14;
long in_FS_OFFSET;
size_t local_58;
int local_4c;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar5 = strlen(param_1);
local_58 = sVar5;
uVar6 = (ulong)(int)sVar5;
uVar7 = uVar6 * uVar6 * 4 + 0xf;
for (psVar11 = &local_58; psVar11 != (size_t *)((long)&local_58 - (uVar7 & 0xfffffffffffff000));
psVar11 = (size_t *)((long)psVar11 + -0x1000)) {
*(int8 *)((long)psVar11 + -8) = *(int8 *)((long)psVar11 + -8);
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar1 = -uVar7;
if (uVar7 != 0) {
*(int8 *)((long)psVar11 + -8) = *(int8 *)((long)psVar11 + -8);
}
if (0 < (int)local_58) {
iVar4 = 0;
do {
*(int4 *)((long)psVar11 + (long)iVar4 * ((uVar6 & 0x3fffffffffffffff) + 1) * 4 + lVar1)
= 1;
iVar4 = iVar4 + 1;
} while ((int)sVar5 != iVar4);
}
iVar4 = (int)local_58;
if (1 < iVar4) {
uVar6 = uVar6 & 0x3fffffffffffffff;
uVar14 = iVar4 - 2;
pcVar13 = param_1 + 2;
local_4c = iVar4 + 1;
iVar4 = 2;
do {
if (-1 < (int)uVar14) {
lVar8 = 1;
iVar3 = iVar4 + -2;
do {
iVar2 = (int)lVar8;
iVar9 = iVar2 + -1;
iVar12 = iVar3 + 1;
if ((iVar4 == 2) && (param_1[lVar8 + -1] == pcVar13[lVar8 + -2])) {
*(int4 *)((long)psVar11 + ((long)iVar12 + (long)iVar9 * uVar6) * 4 + lVar1) = 2;
}
else if (param_1[lVar8 + -1] == pcVar13[lVar8 + -2]) {
*(int *)((long)psVar11 + ((long)iVar12 + (long)iVar9 * uVar6) * 4 + lVar1) =
*(int *)((long)psVar11 + ((long)iVar3 + (long)iVar2 * uVar6) * 4 + lVar1) + 2;
}
else {
iVar10 = *(int *)((long)psVar11 + ((long)iVar12 + (long)iVar2 * uVar6) * 4 + lVar1);
if (*(int *)((long)psVar11 + ((long)iVar12 + (long)iVar2 * uVar6) * 4 + lVar1) <
*(int *)((long)psVar11 + ((long)iVar3 + (long)iVar9 * uVar6) * 4 + lVar1)) {
iVar10 = *(int *)((long)psVar11 + ((long)iVar3 + (long)iVar9 * uVar6) * 4 + lVar1);
}
*(int *)((long)psVar11 + ((long)iVar12 + (long)iVar9 * uVar6) * 4 + lVar1) = iVar10;
}
lVar8 = lVar8 + 1;
iVar3 = iVar12;
} while (lVar8 != (ulong)uVar14 + 2);
}
iVar4 = iVar4 + 1;
uVar14 = uVar14 - 1;
pcVar13 = pcVar13 + 1;
} while (iVar4 != local_4c);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)psVar11 + (long)((int)local_58 + -1) * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)((long)psVar11 + lVar1 + -8) = main;
__stack_chk_fail();
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.