index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,282 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr1[], int arr2[], int m, int n, int k) {
int sorted1[m + n];
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
d++;
i++;
}
while (j < n) {
sorted1[d] = arr2[j];
d++;
j++;
}
return sorted1[k - 1];
}
| int main() {
int arr1_1[] = {2, 3, 6, 7, 9};
int arr2_1[] = {1, 4, 8, 10};
int arr1_2[] = {100, 112, 256, 349, 770};
int arr2_2[] = {72, 86, 113, 119, 265, 445, 892};
int arr1_3[] = {3, 4, 7, 8, 10};
int arr2_3[] = {2, 5, 9, 11};
assert(func0(arr1_1, arr2_1, 5, 4, 5) == 6);
assert(func0(arr1_2, arr2_2, 5, 7, 7) == 256);
assert(func0(arr1_3, arr2_3, 5, 4, 6) == 8);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea (%rdx,%rcx,1),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r9
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%r9
mov %rbx,%rax
cmp %rax,%rsp
je 13cd <func0+0x5d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 13b8 <func0+0x48>
and $0xfff,%r9d
sub %r9,%rsp
test %r9,%r9
jne 14c0 <func0+0x150>
mov %rsp,%r12
test %edx,%edx
jle 1433 <func0+0xc3>
test %ecx,%ecx
jle 1433 <func0+0xc3>
mov $0x1,%r9d
xor %r11d,%r11d
xor %eax,%eax
jmp 1419 <func0+0xa9>
nopl 0x0(%rax,%rax,1)
add $0x1,%r11d
mov %r10d,-0x4(%r12,%r9,4)
mov %r9d,%ebx
add $0x1,%r9
cmp %edx,%r11d
jge 1440 <func0+0xd0>
cmp %ecx,%eax
jge 1440 <func0+0xd0>
movslq %r11d,%r10
movslq %eax,%rbx
mov (%rdi,%r10,4),%r10d
mov (%rsi,%rbx,4),%ebx
cmp %ebx,%r10d
jl 1400 <func0+0x90>
add $0x1,%eax
mov %ebx,%r10d
jmp 1404 <func0+0x94>
xor %ebx,%ebx
xor %r11d,%r11d
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
cmp %r11d,%edx
jle 1471 <func0+0x101>
movslq %r11d,%r9
movslq %ebx,%r10
sub %r9,%r10
lea (%r12,%r10,4),%r13
nopw 0x0(%rax,%rax,1)
mov (%rdi,%r9,4),%r10d
mov %r10d,0x0(%r13,%r9,4)
add $0x1,%r9
cmp %r9d,%edx
jg 1458 <func0+0xe8>
add %ebx,%edx
sub %r11d,%edx
mov %edx,%ebx
cmp %eax,%ecx
jle 1496 <func0+0x126>
cltq
movslq %ebx,%rdx
sub %rax,%rdx
lea (%r12,%rdx,4),%rdi
nopl 0x0(%rax)
mov (%rsi,%rax,4),%edx
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%ecx
jg 1488 <func0+0x118>
sub $0x1,%r8d
mov -0x28(%rbp),%rsi
xor %fs:0x28,%rsi
movslq %r8d,%r8
mov (%r12,%r8,4),%eax
jne 14cb <func0+0x15b>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%r9,1)
jmpq 13e0 <func0+0x70>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov r9d, edx
mov rbp, rsp
push r15
mov r15, rsi
push r14
mov r14d, ecx
push r13
mov r13d, r8d
push r12
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdx+rcx]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_13FA
loc_13E5:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rcx
jnz short loc_13E5
loc_13FA:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1510
loc_140C:
mov rcx, rsp
test r9d, r9d
jle loc_151B
test r14d, r14d
jle loc_151B
mov eax, 1
xor ebx, ebx
xor r12d, r12d
jmp short loc_1449
loc_1430:
add r12d, 1
mov [rcx+rax*4-4], edx
movsxd r8, eax
add rax, 1
cmp r12d, r9d
jge short loc_146F
loc_1444:
cmp ebx, r14d
jge short loc_146F
loc_1449:
movsxd rdx, r12d
movsxd rsi, ebx
mov edx, [rdi+rdx*4]
mov esi, [r15+rsi*4]
cmp edx, esi
jl short loc_1430
mov edx, esi
movsxd r8, eax
add ebx, 1
mov [rcx+rax*4-4], edx
add rax, 1
cmp r12d, r9d
jl short loc_1444
loc_146F:
cmp r9d, r12d
jle short loc_14BA
movsxd rax, r8d
mov [rbp+var_54], r8d
lea r10, [rcx+rax*4]
lea eax, [r9-1]
mov [rbp+var_50], rcx
sub eax, r12d
mov dword ptr [rbp+var_48], r9d
lea rdx, ds:4[rax*4]
movsxd rax, r12d
lea rsi, [rdi+rax*4]
mov rdi, r10
call _memcpy
mov r8d, [rbp+var_54]
mov r9d, dword ptr [rbp+var_48]
mov rcx, [rbp+var_50]
add r9d, r8d
sub r9d, r12d
movsxd r8, r9d
loc_14BA:
cmp r14d, ebx
jle short loc_14E6
sub r14d, 1
lea rdi, [rcx+r8*4]
mov [rbp+var_48], rcx
sub r14d, ebx
movsxd rbx, ebx
lea rdx, ds:4[r14*4]
lea rsi, [r15+rbx*4]
call _memcpy
mov rcx, [rbp+var_48]
loc_14E6:
sub r13d, 1
movsxd r13, r13d
mov eax, [rcx+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1528
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1510:
or [rsp+rdx+1060h+var_1068], 0
jmp loc_140C
loc_151B:
xor r8d, r8d
xor ebx, ebx
xor r12d, r12d
jmp loc_146F
loc_1528:
call ___stack_chk_fail | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
long long v9; // rdx
_DWORD *v10; // rcx
__int16 v11; // dx
signed long long v12; // rdx
void *v13; // rsp
_DWORD *v14; // rcx
long long v15; // rax
int v16; // ebx
int v17; // r12d
long long v18; // r8
int v19; // edx
int v20; // esi
_DWORD v23[1022]; // [rsp+8h] [rbp-1060h] BYREF
_BYTE v24[12]; // [rsp+1008h] [rbp-60h] BYREF
int v25; // [rsp+1014h] [rbp-54h]
_DWORD *v26; // [rsp+1018h] [rbp-50h]
_DWORD *v27; // [rsp+1020h] [rbp-48h]
unsigned long long v28; // [rsp+1030h] [rbp-38h]
v28 = __readfsqword(0x28u);
v9 = 4LL * (a3 + a4) + 15;
v10 = &v24[-(v9 & 0xFFFFFFFFFFFFF000LL)];
v11 = v9 & 0xFFF0;
if ( v24 != (_BYTE *)v10 )
{
while ( v23 != v10 )
;
}
v12 = v11 & 0xFFF;
v13 = alloca(v12);
if ( v12 )
*(_QWORD *)((char *)&v23[-2] + v12) = *(_QWORD *)((char *)&v23[-2] + v12);
v14 = v23;
if ( a3 > 0 && a4 > 0 )
{
v15 = 1LL;
v16 = 0;
v17 = 0;
while ( 1 )
{
v19 = *(_DWORD *)(a1 + 4LL * v17);
v20 = *(_DWORD *)(a2 + 4LL * v16);
if ( v19 < v20 )
{
++v17;
v23[v15 - 1] = v19;
v18 = (int)v15++;
if ( v17 >= a3 )
goto LABEL_12;
}
else
{
v18 = (int)v15;
++v16;
v23[v15++ - 1] = v20;
if ( v17 >= a3 )
goto LABEL_12;
}
if ( v16 >= a4 )
goto LABEL_12;
}
}
v18 = 0LL;
v16 = 0;
v17 = 0;
LABEL_12:
if ( a3 > v17 )
{
v25 = v18;
v26 = v23;
LODWORD(v27) = a3;
memcpy(&v23[(int)v18], a1 + 4LL * v17, 4LL * (unsigned int)(a3 - 1 - v17) + 4);
v14 = v26;
v18 = v25 + (int)v27 - v17;
}
if ( a4 > v16 )
{
v27 = v14;
memcpy(&v14[v18], a2 + 4LL * v16, 4LL * (unsigned int)(a4 - 1 - v16) + 4);
v14 = v27;
}
return (unsigned int)v14[a5 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV R9D,EDX
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14D,ECX
PUSH R13
MOV R13D,R8D
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + RCX*0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001013fa
LAB_001013e5:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001013e5
LAB_001013fa:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101510
LAB_0010140c:
MOV RCX,RSP
TEST R9D,R9D
JLE 0x0010151b
TEST R14D,R14D
JLE 0x0010151b
MOV EAX,0x1
XOR EBX,EBX
XOR R12D,R12D
JMP 0x00101449
LAB_00101430:
ADD R12D,0x1
MOV dword ptr [RCX + RAX*0x4 + -0x4],EDX
MOVSXD R8,EAX
ADD RAX,0x1
CMP R12D,R9D
JGE 0x0010146f
LAB_00101444:
CMP EBX,R14D
JGE 0x0010146f
LAB_00101449:
MOVSXD RDX,R12D
MOVSXD RSI,EBX
MOV EDX,dword ptr [RDI + RDX*0x4]
MOV ESI,dword ptr [R15 + RSI*0x4]
CMP EDX,ESI
JL 0x00101430
MOV EDX,ESI
MOVSXD R8,EAX
ADD EBX,0x1
MOV dword ptr [RCX + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP R12D,R9D
JL 0x00101444
LAB_0010146f:
CMP R9D,R12D
JLE 0x001014ba
MOVSXD RAX,R8D
MOV dword ptr [RBP + -0x54],R8D
LEA R10,[RCX + RAX*0x4]
LEA EAX,[R9 + -0x1]
MOV qword ptr [RBP + -0x50],RCX
SUB EAX,R12D
MOV dword ptr [RBP + -0x48],R9D
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,R12D
LEA RSI,[RDI + RAX*0x4]
MOV RDI,R10
CALL 0x00101090
MOV R8D,dword ptr [RBP + -0x54]
MOV R9D,dword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
ADD R9D,R8D
SUB R9D,R12D
MOVSXD R8,R9D
LAB_001014ba:
CMP R14D,EBX
JLE 0x001014e6
SUB R14D,0x1
LEA RDI,[RCX + R8*0x4]
MOV qword ptr [RBP + -0x48],RCX
SUB R14D,EBX
MOVSXD RBX,EBX
LEA RDX,[0x4 + R14*0x4]
LEA RSI,[R15 + RBX*0x4]
CALL 0x00101090
MOV RCX,qword ptr [RBP + -0x48]
LAB_001014e6:
SUB R13D,0x1
MOVSXD R13,R13D
MOV EAX,dword ptr [RCX + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101528
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101510:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010140c
LAB_0010151b:
XOR R8D,R8D
XOR EBX,EBX
XOR R12D,R12D
JMP 0x0010146f
LAB_00101528:
CALL 0x00101070 | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
int1 *puVar5;
ulong uVar6;
int iVar7;
int1 *puVar8;
long lVar10;
int iVar11;
long in_FS_OFFSET;
int1 auStack_68 [12];
int local_5c;
int1 *local_58;
int1 *local_50;
long local_40;
int1 *puVar9;
puVar8 = auStack_68;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(param_3 + param_4) * 4 + 0xf;
puVar9 = auStack_68;
puVar5 = auStack_68;
while (puVar9 != auStack_68 + -(uVar6 & 0xfffffffffffff000)) {
puVar8 = puVar5 + -0x1000;
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
puVar9 = puVar5 + -0x1000;
puVar5 = puVar5 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar3 = -uVar6;
if (uVar6 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if ((param_3 < 1) || (param_4 < 1)) {
lVar10 = 0;
iVar7 = 0;
iVar11 = 0;
}
else {
lVar4 = 1;
iVar7 = 0;
iVar11 = 0;
do {
iVar1 = *(int *)(param_1 + (long)iVar11 * 4);
iVar2 = *(int *)(param_2 + (long)iVar7 * 4);
if (iVar1 < iVar2) {
iVar11 = iVar11 + 1;
*(int *)(puVar8 + lVar4 * 4 + lVar3 + -4) = iVar1;
}
else {
iVar7 = iVar7 + 1;
*(int *)(puVar8 + lVar4 * 4 + lVar3 + -4) = iVar2;
}
lVar10 = (long)(int)lVar4;
if (param_3 <= iVar11) break;
lVar10 = (long)(int)lVar4;
lVar4 = lVar4 + 1;
} while (iVar7 < param_4);
}
puVar5 = puVar8 + lVar3;
if (iVar11 < param_3) {
local_5c = (int)lVar10;
local_50 = (int1 *)CONCAT44(local_50._4_4_,param_3);
*(int8 *)(puVar8 + lVar3 + -8) = 0x1014a5;
local_58 = puVar8 + lVar3;
memcpy(puVar8 + (long)local_5c * 4 + lVar3,(void *)(param_1 + (long)iVar11 * 4),
(ulong)(uint)((param_3 + -1) - iVar11) * 4 + 4);
lVar10 = (long)(((int)local_50 + local_5c) - iVar11);
puVar5 = local_58;
}
if (iVar7 < param_4) {
*(int8 *)(puVar8 + lVar3 + -8) = 0x1014e2;
local_50 = puVar5;
memcpy(puVar5 + lVar10 * 4,(void *)(param_2 + (long)iVar7 * 4),
(ulong)(uint)((param_4 + -1) - iVar7) * 4 + 4);
puVar5 = local_50;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + lVar3 + -8) = 0x10152d;
__stack_chk_fail();
}
return *(int4 *)(puVar5 + (long)(param_5 + -1) * 4);
} |
6,283 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr1[], int arr2[], int m, int n, int k) {
int sorted1[m + n];
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
d++;
i++;
}
while (j < n) {
sorted1[d] = arr2[j];
d++;
j++;
}
return sorted1[k - 1];
}
| int main() {
int arr1_1[] = {2, 3, 6, 7, 9};
int arr2_1[] = {1, 4, 8, 10};
int arr1_2[] = {100, 112, 256, 349, 770};
int arr2_2[] = {72, 86, 113, 119, 265, 445, 892};
int arr1_3[] = {3, 4, 7, 8, 10};
int arr2_3[] = {2, 5, 9, 11};
assert(func0(arr1_1, arr2_1, 5, 4, 5) == 6);
assert(func0(arr1_2, arr2_2, 5, 7, 7) == 256);
assert(func0(arr1_3, arr2_3, 5, 4, 6) == 8);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %edx,%r9d
mov %rsp,%rbp
push %r15
mov %rsi,%r15
push %r14
mov %ecx,%r14d
push %r13
mov %r8d,%r13d
push %r12
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea (%rdx,%rcx,1),%eax
mov %rsp,%rsi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 139d <func0+0x6d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1388 <func0+0x58>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14d8 <func0+0x1a8>
mov %rsp,%r10
test %r9d,%r9d
jle 1421 <func0+0xf1>
test %r14d,%r14d
jle 1421 <func0+0xf1>
mov $0x1,%eax
xor %r12d,%r12d
xor %ebx,%ebx
xor %r8d,%r8d
xor %esi,%esi
nopl 0x0(%rax,%rax,1)
mov (%rdi,%r8,4),%ecx
mov (%r15,%rsi,4),%edx
cmp %edx,%ecx
jge 1404 <func0+0xd4>
mov %ecx,-0x4(%r10,%rax,4)
add $0x1,%r12d
mov %eax,%ecx
add $0x1,%rax
cmp %ebx,%r14d
jle 1430 <func0+0x100>
cmp %r9d,%r12d
jge 1430 <func0+0x100>
movslq %r12d,%r8
mov (%r15,%rsi,4),%edx
mov (%rdi,%r8,4),%ecx
cmp %edx,%ecx
jl 13dc <func0+0xac>
mov %edx,-0x4(%r10,%rax,4)
mov %eax,%ecx
add $0x1,%ebx
add $0x1,%rax
cmp %r12d,%r9d
jle 1479 <func0+0x149>
cmp %r14d,%ebx
jge 1430 <func0+0x100>
movslq %ebx,%rsi
jmp 13d0 <func0+0xa0>
xor %ecx,%ecx
xor %r12d,%r12d
xor %ebx,%ebx
nopl 0x0(%rax,%rax,1)
cmp %r12d,%r9d
jle 1479 <func0+0x149>
movslq %ecx,%rax
mov %ecx,-0x54(%rbp)
lea (%r10,%rax,4),%r8
lea -0x1(%r9),%eax
mov %r10,-0x50(%rbp)
sub %r12d,%eax
mov %r9d,-0x48(%rbp)
lea 0x4(,%rax,4),%rdx
movslq %r12d,%rax
lea (%rdi,%rax,4),%rsi
mov %r8,%rdi
callq 1090 <memcpy@plt>
mov -0x54(%rbp),%ecx
mov -0x48(%rbp),%r9d
mov -0x50(%rbp),%r10
add %ecx,%r9d
mov %r9d,%ecx
sub %r12d,%ecx
cmp %ebx,%r14d
jle 14a8 <func0+0x178>
sub $0x1,%r14d
movslq %ecx,%r9
mov %r10,-0x48(%rbp)
sub %ebx,%r14d
movslq %ebx,%rbx
lea (%r10,%r9,4),%rdi
lea 0x4(,%r14,4),%rdx
lea (%r15,%rbx,4),%rsi
callq 1090 <memcpy@plt>
mov -0x48(%rbp),%r10
sub $0x1,%r13d
mov -0x38(%rbp),%rdi
xor %fs:0x28,%rdi
movslq %r13d,%r13
mov (%r10,%r13,4),%eax
jne 14e3 <func0+0x1b3>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 13af <func0+0x7f>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov r9d, edx
mov rbp, rsp
push r15
mov r15, rsi
push r14
mov r14d, ecx
push r13
mov r13d, r8d
push r12
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdx+rcx]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_139A
loc_1385:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rcx
jnz short loc_1385
loc_139A:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_14E0
loc_13AC:
mov rcx, rsp
test r9d, r9d
jle loc_14EB
test r14d, r14d
jle loc_14EB
mov eax, 1
xor ebx, ebx
xor r12d, r12d
xor r10d, r10d
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_13D8:
mov esi, [rdi+r10*4]
mov edx, [r15+r8*4]
cmp esi, edx
jge short loc_140C
loc_13E4:
mov [rcx+rax*4-4], esi
add r12d, 1
lea rdx, [rax+1]
cmp r14d, ebx
jle short loc_1430
cmp r12d, r9d
jge short loc_1430
movsxd r10, r12d
mov rax, rdx
mov edx, [r15+r8*4]
mov esi, [rdi+r10*4]
cmp esi, edx
jl short loc_13E4
loc_140C:
mov [rcx+rax*4-4], edx
add ebx, 1
lea rdx, [rax+1]
cmp r9d, r12d
jle short loc_1430
cmp ebx, r14d
jge short loc_1430
mov rax, rdx
movsxd r8, ebx
jmp short loc_13D8
loc_1430:
mov r8d, eax
loc_1433:
cmp r9d, r12d
jle short loc_147E
movsxd rax, r8d
mov [rbp+var_54], r8d
lea r10, [rcx+rax*4]
lea eax, [r9-1]
mov [rbp+var_50], rcx
sub eax, r12d
mov dword ptr [rbp+var_48], r9d
lea rdx, ds:4[rax*4]; n
movsxd rax, r12d
lea rsi, [rdi+rax*4]; src
mov rdi, r10; dest
call _memcpy
mov r8d, [rbp+var_54]
mov r9d, dword ptr [rbp+var_48]
mov rcx, [rbp+var_50]
add r9d, r8d
sub r9d, r12d
mov r8d, r9d
loc_147E:
cmp r14d, ebx
jle short loc_14AD
sub r14d, 1
movsxd rax, r8d
mov [rbp+var_48], rcx
sub r14d, ebx
movsxd rbx, ebx
lea rdi, [rcx+rax*4]; dest
lea rdx, ds:4[r14*4]; n
lea rsi, [r15+rbx*4]; src
call _memcpy
mov rcx, [rbp+var_48]
loc_14AD:
sub r13d, 1
movsxd r13, r13d
mov eax, [rcx+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_14F8
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_14E0:
or [rsp+rdx+1060h+var_1068], 0
jmp loc_13AC
loc_14EB:
xor r8d, r8d
xor ebx, ebx
xor r12d, r12d
jmp loc_1433
loc_14F8:
call ___stack_chk_fail | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
long long v9; // rdx
_DWORD *v10; // rcx
__int16 v11; // dx
signed long long v12; // rdx
void *v13; // rsp
_DWORD *v14; // rcx
long long v15; // rax
int v16; // ebx
int v17; // r12d
long long v18; // r10
long long i; // r8
int v20; // esi
int v21; // edx
int v22; // r8d
_DWORD v25[1022]; // [rsp+8h] [rbp-1060h] BYREF
_BYTE v26[12]; // [rsp+1008h] [rbp-60h] BYREF
int v27; // [rsp+1014h] [rbp-54h]
_DWORD *v28; // [rsp+1018h] [rbp-50h]
_DWORD *v29; // [rsp+1020h] [rbp-48h]
unsigned long long v30; // [rsp+1030h] [rbp-38h]
v30 = __readfsqword(0x28u);
v9 = 4LL * (a3 + a4) + 15;
v10 = &v26[-(v9 & 0xFFFFFFFFFFFFF000LL)];
v11 = v9 & 0xFFF0;
if ( v26 != (_BYTE *)v10 )
{
while ( v25 != v10 )
;
}
v12 = v11 & 0xFFF;
v13 = alloca(v12);
if ( v12 )
*(_QWORD *)((char *)&v25[-2] + v12) = *(_QWORD *)((char *)&v25[-2] + v12);
v14 = v25;
if ( a3 <= 0 || a4 <= 0 )
{
v22 = 0;
v16 = 0;
v17 = 0;
}
else
{
v15 = 1LL;
v16 = 0;
v17 = 0;
v18 = 0LL;
for ( i = 0LL; ; i = v16 )
{
v20 = *(_DWORD *)(a1 + 4 * v18);
v21 = *(_DWORD *)(a2 + 4 * i);
if ( v20 < v21 )
break;
LABEL_12:
v25[v15 - 1] = v21;
++v16;
if ( a3 <= v17 || v16 >= a4 )
goto LABEL_15;
++v15;
}
while ( 1 )
{
v25[v15 - 1] = v20;
++v17;
if ( a4 <= v16 || v17 >= a3 )
break;
v18 = v17;
++v15;
v21 = *(_DWORD *)(a2 + 4 * i);
v20 = *(_DWORD *)(a1 + 4LL * v17);
if ( v20 >= v21 )
goto LABEL_12;
}
LABEL_15:
v22 = v15;
}
if ( a3 > v17 )
{
v27 = v22;
v28 = v25;
LODWORD(v29) = a3;
memcpy(&v25[v22], (const void *)(a1 + 4LL * v17), 4LL * (unsigned int)(a3 - 1 - v17) + 4);
v14 = v28;
v22 = v27 + (_DWORD)v29 - v17;
}
if ( a4 > v16 )
{
v29 = v14;
memcpy(&v14[v22], (const void *)(a2 + 4LL * v16), 4LL * (unsigned int)(a4 - 1 - v16) + 4);
v14 = v29;
}
return (unsigned int)v14[a5 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV R9D,EDX
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14D,ECX
PUSH R13
MOV R13D,R8D
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + RCX*0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010139a
LAB_00101385:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101385
LAB_0010139a:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001014e0
LAB_001013ac:
MOV RCX,RSP
TEST R9D,R9D
JLE 0x001014eb
TEST R14D,R14D
JLE 0x001014eb
MOV EAX,0x1
XOR EBX,EBX
XOR R12D,R12D
XOR R10D,R10D
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001013d8:
MOV ESI,dword ptr [RDI + R10*0x4]
MOV EDX,dword ptr [R15 + R8*0x4]
CMP ESI,EDX
JGE 0x0010140c
LAB_001013e4:
MOV dword ptr [RCX + RAX*0x4 + -0x4],ESI
ADD R12D,0x1
LEA RDX,[RAX + 0x1]
CMP R14D,EBX
JLE 0x00101430
CMP R12D,R9D
JGE 0x00101430
MOVSXD R10,R12D
MOV RAX,RDX
MOV EDX,dword ptr [R15 + R8*0x4]
MOV ESI,dword ptr [RDI + R10*0x4]
CMP ESI,EDX
JL 0x001013e4
LAB_0010140c:
MOV dword ptr [RCX + RAX*0x4 + -0x4],EDX
ADD EBX,0x1
LEA RDX,[RAX + 0x1]
CMP R9D,R12D
JLE 0x00101430
CMP EBX,R14D
JGE 0x00101430
MOV RAX,RDX
MOVSXD R8,EBX
JMP 0x001013d8
LAB_00101430:
MOV R8D,EAX
LAB_00101433:
CMP R9D,R12D
JLE 0x0010147e
MOVSXD RAX,R8D
MOV dword ptr [RBP + -0x54],R8D
LEA R10,[RCX + RAX*0x4]
LEA EAX,[R9 + -0x1]
MOV qword ptr [RBP + -0x50],RCX
SUB EAX,R12D
MOV dword ptr [RBP + -0x48],R9D
LEA RDX,[0x4 + RAX*0x4]
MOVSXD RAX,R12D
LEA RSI,[RDI + RAX*0x4]
MOV RDI,R10
CALL 0x00101090
MOV R8D,dword ptr [RBP + -0x54]
MOV R9D,dword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
ADD R9D,R8D
SUB R9D,R12D
MOV R8D,R9D
LAB_0010147e:
CMP R14D,EBX
JLE 0x001014ad
SUB R14D,0x1
MOVSXD RAX,R8D
MOV qword ptr [RBP + -0x48],RCX
SUB R14D,EBX
MOVSXD RBX,EBX
LEA RDI,[RCX + RAX*0x4]
LEA RDX,[0x4 + R14*0x4]
LEA RSI,[R15 + RBX*0x4]
CALL 0x00101090
MOV RCX,qword ptr [RBP + -0x48]
LAB_001014ad:
SUB R13D,0x1
MOVSXD R13,R13D
MOV EAX,dword ptr [RCX + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001014f8
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001014e0:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001013ac
LAB_001014eb:
XOR R8D,R8D
XOR EBX,EBX
XOR R12D,R12D
JMP 0x00101433
LAB_001014f8:
CALL 0x00101070 | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
int *puVar5;
int iVar6;
ulong uVar7;
int iVar8;
int *puVar9;
long lVar11;
int iVar12;
long lVar13;
int iVar14;
long in_FS_OFFSET;
int auStack_68 [12];
int local_5c;
int *local_58;
int *local_50;
long local_40;
int *puVar10;
puVar9 = auStack_68;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar7 = (long)(param_3 + param_4) * 4 + 0xf;
puVar10 = auStack_68;
puVar5 = auStack_68;
while (puVar10 != auStack_68 + -(uVar7 & 0xfffffffffffff000)) {
puVar9 = puVar5 + -0x1000;
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
puVar10 = puVar5 + -0x1000;
puVar5 = puVar5 + -0x1000;
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar1 = -uVar7;
if (uVar7 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
if ((param_3 < 1) || (param_4 < 1)) {
iVar12 = 0;
iVar8 = 0;
iVar14 = 0;
}
else {
lVar2 = 1;
iVar8 = 0;
iVar14 = 0;
lVar13 = 0;
lVar11 = 0;
while( true ) {
iVar12 = *(int *)(param_1 + lVar13 * 4);
iVar6 = *(int *)(param_2 + lVar11 * 4);
lVar3 = lVar2;
if (iVar12 < iVar6) {
do {
*(int *)(puVar9 + lVar2 * 4 + lVar1 + -4) = iVar12;
iVar14 = iVar14 + 1;
lVar3 = lVar2 + 1;
lVar4 = lVar2;
if ((param_4 <= iVar8) || (param_3 <= iVar14)) goto LAB_00101430;
lVar13 = (long)iVar14;
iVar6 = *(int *)(param_2 + lVar11 * 4);
iVar12 = *(int *)(param_1 + lVar13 * 4);
lVar2 = lVar3;
} while (iVar12 < iVar6);
}
*(int *)(puVar9 + lVar3 * 4 + lVar1 + -4) = iVar6;
iVar8 = iVar8 + 1;
lVar2 = lVar3 + 1;
lVar4 = lVar3;
if ((param_3 <= iVar14) || (param_4 <= iVar8)) break;
lVar11 = (long)iVar8;
}
LAB_00101430:
iVar12 = (int)lVar4;
}
puVar5 = puVar9 + lVar1;
if (iVar14 < param_3) {
local_50 = (int *)CONCAT44(local_50._4_4_,param_3);
*(int8 *)(puVar9 + lVar1 + -8) = 0x101469;
local_5c = iVar12;
local_58 = puVar9 + lVar1;
memcpy(puVar9 + (long)iVar12 * 4 + lVar1,(void *)(param_1 + (long)iVar14 * 4),
(ulong)(uint)((param_3 + -1) - iVar14) * 4 + 4);
iVar12 = ((int)local_50 + local_5c) - iVar14;
puVar5 = local_58;
}
if (iVar8 < param_4) {
*(int8 *)(puVar9 + lVar1 + -8) = 0x1014a9;
local_50 = puVar5;
memcpy(puVar5 + (long)iVar12 * 4,(void *)(param_2 + (long)iVar8 * 4),
(ulong)(uint)((param_4 + -1) - iVar8) * 4 + 4);
puVar5 = local_50;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar9 + lVar1 + -8) = 0x1014fd;
__stack_chk_fail();
}
return *(int4 *)(puVar5 + (long)(param_5 + -1) * 4);
} |
6,284 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == sum) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11b0 <func0+0x47>
addl $0x1,-0xc(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jg 118e <func0+0x25>
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 1228 <func0+0xbf>
mov -0x8(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
cvtsi2sdl -0x4(%rbp),%xmm0
callq 1060 <pow@plt>
cvtsi2sdl -0x10(%rbp),%xmm1
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov %eax,-0x10(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jg 11be <func0+0x55>
mov -0x14(%rbp),%eax
cmp -0x10(%rbp),%eax
jne 123d <func0+0xd4>
mov $0x1,%eax
jmp 1242 <func0+0xd9>
mov $0x0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11B0
loc_118E:
add [rbp+var_C], 1
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_8], eax
loc_11B0:
cmp [rbp+var_8], 0
jg short loc_118E
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp loc_1243
loc_11C1:
mov edx, [rbp+var_8]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_4], edx
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_C]
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_4]
movq rax, xmm2
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_10]
addsd xmm0, xmm1
cvttsd2si eax, xmm0
mov [rbp+var_10], eax
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_8], eax
loc_1243:
cmp [rbp+var_8], 0
jg loc_11C1
mov eax, [rbp+var_14]
cmp eax, [rbp+var_10]
jnz short loc_125C
mov eax, 1
jmp short locret_1261
loc_125C:
mov eax, 0
locret_1261:
leave
retn | _BOOL8 func0(int a1)
{
int v2; // [rsp+10h] [rbp-10h]
int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+18h] [rbp-8h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i /= 10 )
++v3;
for ( j = a1; j > 0; j /= 10 )
v2 = (int)(pow((double)(j % 10), (double)v3) + (double)v2);
return a1 == v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011b0
LAB_0010118e:
ADD dword ptr [RBP + -0xc],0x1
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_001011b0:
CMP dword ptr [RBP + -0x8],0x0
JG 0x0010118e
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101243
LAB_001011c1:
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0xc]
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x4]
MOVQ RAX,XMM2
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x10]
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_00101243:
CMP dword ptr [RBP + -0x8],0x0
JG 0x001011c1
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x10]
JNZ 0x0010125c
MOV EAX,0x1
JMP 0x00101261
LAB_0010125c:
MOV EAX,0x0
LAB_00101261:
LEAVE
RET | bool func0(int param_1)
{
int iVar1;
double dVar2;
int local_18;
int local_14;
int local_10;
local_18 = 0;
local_14 = 0;
for (local_10 = param_1; iVar1 = param_1, 0 < local_10; local_10 = local_10 / 10) {
local_14 = local_14 + 1;
}
while (local_10 = iVar1, 0 < local_10) {
dVar2 = pow((double)(local_10 % 10),(double)local_14);
local_18 = (int)(dVar2 + (double)local_18);
iVar1 = local_10 / 10;
}
return param_1 == local_18;
} |
6,285 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == sum) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%ebp
test %edi,%edi
jle 1226 <func0+0xbd>
mov %edi,%eax
mov $0x0,%ecx
add $0x1,%ecx
mov %eax,%esi
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
cmp $0x9,%esi
jg 1188 <func0+0x1f>
mov %ebp,%r13d
mov $0x0,%r12d
pxor %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
movsd %xmm2,0x8(%rsp)
movslq %r13d,%rbx
imul $0x66666667,%rbx,%rbx
sar $0x22,%rbx
mov %r13d,%eax
sar $0x1f,%eax
sub %eax,%ebx
lea (%rbx,%rbx,4),%eax
add %eax,%eax
mov %r13d,%edi
sub %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd 0x8(%rsp),%xmm1
callq 1060 <pow@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%r12d
mov %r13d,%eax
mov %ebx,%r13d
cmp $0x9,%eax
jg 11be <func0+0x55>
cmp %r12d,%ebp
sete %al
movzbl %al,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%r12d
jmp 1212 <func0+0xa9>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13d, edi
test edi, edi
jle loc_121F
mov edx, edi
mov ecx, 0
loc_1187:
add ecx, 1
mov esi, edx
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov edi, edx
sar edi, 1Fh
sub eax, edi
mov edx, eax
cmp esi, 9
jg short loc_1187
mov ebp, r13d
mov r12d, 0
pxor xmm2, xmm2
cvtsi2sd xmm2, ecx
movq r14, xmm2
loc_11BE:
movsxd rbx, ebp
imul rbx, 66666667h
sar rbx, 22h
mov eax, ebp
sar eax, 1Fh
sub ebx, eax
lea eax, [rbx+rbx*4]
add eax, eax
mov edx, ebp
sub edx, eax
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
movq xmm1, r14
call _pow
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, r12d
addsd xmm0, xmm1
cvttsd2si r12d, xmm0
mov eax, ebp
mov ebp, ebx
cmp eax, 9
jg short loc_11BE
loc_120D:
cmp r13d, r12d
setz al
movzx eax, al
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_121F:
mov r12d, 0
jmp short loc_120D | _BOOL8 func0(int a1)
{
int v1; // edx
int v2; // ecx
int v3; // esi
int v4; // ebp
int v5; // r12d
double v6; // r14
int v7; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 10;
}
while ( v3 > 9 );
v4 = a1;
v5 = 0;
v6 = (double)v2;
do
{
v5 = (int)((double)v5 + pow((double)(v4 % 10), v6));
v7 = v4;
v4 /= 10;
}
while ( v7 > 9 );
}
return a1 == v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13D,EDI
TEST EDI,EDI
JLE 0x0010121f
MOV EDX,EDI
MOV ECX,0x0
LAB_00101187:
ADD ECX,0x1
MOV ESI,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
MOV EDX,EAX
CMP ESI,0x9
JG 0x00101187
MOV EBP,R13D
MOV R12D,0x0
PXOR XMM2,XMM2
CVTSI2SD XMM2,ECX
MOVQ R14,XMM2
LAB_001011be:
MOVSXD RBX,EBP
IMUL RBX,RBX,0x66666667
SAR RBX,0x22
MOV EAX,EBP
SAR EAX,0x1f
SUB EBX,EAX
LEA EAX,[RBX + RBX*0x4]
ADD EAX,EAX
MOV EDX,EBP
SUB EDX,EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MOVQ XMM1,R14
CALL 0x00101060
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,R12D
ADDSD XMM0,XMM1
CVTTSD2SI R12D,XMM0
MOV EAX,EBP
MOV EBP,EBX
CMP EAX,0x9
JG 0x001011be
LAB_0010120d:
CMP R13D,R12D
SETZ AL
MOVZX EAX,AL
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010121f:
MOV R12D,0x0
JMP 0x0010120d | bool func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
double dVar5;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = param_1;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < iVar4;
iVar4 = iVar4 / 10;
} while (bVar1);
iVar4 = 0;
iVar3 = param_1;
do {
dVar5 = pow((double)(iVar3 % 10),(double)iVar2);
iVar4 = (int)((double)iVar4 + dVar5);
bVar1 = 9 < iVar3;
iVar3 = iVar3 / 10;
} while (bVar1);
}
return param_1 == iVar4;
} |
6,286 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == sum) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 12c8 <func0+0xb8>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp $0x9,%edx
jg 1238 <func0+0x28>
pxor %xmm1,%xmm1
mov %r12d,%r14d
xor %ebp,%ebp
mov $0xcccccccd,%r13d
cvtsi2sd %ecx,%xmm1
mov %r14d,%ebx
mov %r14d,%edi
pxor %xmm0,%xmm0
movsd %xmm1,0x8(%rsp)
imul %r13,%rbx
shr $0x23,%rbx
lea (%rbx,%rbx,4),%eax
add %eax,%eax
sub %eax,%edi
cvtsi2sd %edi,%xmm0
callq 1060 <pow@plt>
mov %r14d,%eax
movsd 0x8(%rsp),%xmm1
mov %ebx,%r14d
movapd %xmm0,%xmm2
pxor %xmm0,%xmm0
cmp $0x9,%eax
cvtsi2sd %ebp,%xmm0
addsd %xmm2,%xmm0
cvttsd2si %xmm0,%ebp
jg 1260 <func0+0x50>
xor %eax,%eax
cmp %ebp,%r12d
sete %al
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
xor %ebp,%ebp
jmp 12ad <func0+0x9d>
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr rax, 23h
cmp edx, 9
jg short loc_1238
pxor xmm1, xmm1
mov r12d, ebp
xor r14d, r14d
mov r13d, 0CCCCCCCDh
cvtsi2sd xmm1, ecx
nop dword ptr [rax+00000000h]
loc_1268:
mov ebx, r12d
mov edx, r12d
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm1
imul rbx, r13
shr rbx, 23h
lea eax, [rbx+rbx*4]
add eax, eax
sub edx, eax
cvtsi2sd xmm0, edx
call _pow
mov eax, r12d
movsd xmm1, [rsp+38h+var_30]
mov r12d, ebx
movapd xmm2, xmm0
pxor xmm0, xmm0
cmp eax, 9
cvtsi2sd xmm0, r14d
addsd xmm0, xmm2
cvttsd2si r14d, xmm0
jg short loc_1268
loc_12B7:
xor eax, eax
cmp ebp, r14d
setz al
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12D0:
xor r14d, r14d
jmp short loc_12B7 | _BOOL8 func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0xAu;
}
while ( v3 > 9 );
v4 = a1;
v5 = 0;
v6 = (double)v2;
do
{
v7 = pow((double)(v4 % 0xA), v6);
v8 = v4;
v4 /= 0xAu;
v5 = (int)((double)v5 + v7);
}
while ( v8 > 9 );
}
return a1 == v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR R14D,R14D
MOV R13D,0xcccccccd
CVTSI2SD XMM1,ECX
NOP dword ptr [RAX]
LAB_00101268:
MOV EBX,R12D
MOV EDX,R12D
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
IMUL RBX,R13
SHR RBX,0x23
LEA EAX,[RBX + RBX*0x4]
ADD EAX,EAX
SUB EDX,EAX
CVTSI2SD XMM0,EDX
CALL 0x00101060
MOV EAX,R12D
MOVSD XMM1,qword ptr [RSP + 0x8]
MOV R12D,EBX
MOVAPD XMM2,XMM0
PXOR XMM0,XMM0
CMP EAX,0x9
CVTSI2SD XMM0,R14D
ADDSD XMM0,XMM2
CVTTSD2SI R14D,XMM0
JG 0x00101268
LAB_001012b7:
XOR EAX,EAX
CMP EBP,R14D
SETZ AL
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012d0:
XOR R14D,R14D
JMP 0x001012b7 | bool func0(uint param_1)
{
bool bVar1;
int iVar2;
uint uVar3;
uint uVar4;
double dVar5;
if ((int)param_1 < 1) {
uVar4 = 0;
}
else {
iVar2 = 0;
uVar4 = param_1;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < (int)uVar4;
uVar4 = uVar4 / 10;
} while (bVar1);
uVar4 = 0;
uVar3 = param_1;
do {
dVar5 = pow((double)(uVar3 % 10),(double)iVar2);
uVar4 = (uint)((double)(int)uVar4 + dVar5);
bVar1 = 9 < (int)uVar3;
uVar3 = uVar3 / 10;
} while (bVar1);
}
return param_1 == uVar4;
} |
6,287 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == sum) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 12c8 <func0+0xb8>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp $0x9,%edx
jg 1238 <func0+0x28>
pxor %xmm1,%xmm1
mov %r12d,%r14d
xor %ebp,%ebp
mov $0xcccccccd,%r13d
cvtsi2sd %ecx,%xmm1
mov %r14d,%ebx
mov %r14d,%edi
pxor %xmm0,%xmm0
movsd %xmm1,0x8(%rsp)
imul %r13,%rbx
shr $0x23,%rbx
lea (%rbx,%rbx,4),%eax
add %eax,%eax
sub %eax,%edi
cvtsi2sd %edi,%xmm0
callq 1060 <pow@plt>
mov %r14d,%eax
movsd 0x8(%rsp),%xmm1
mov %ebx,%r14d
movapd %xmm0,%xmm2
pxor %xmm0,%xmm0
cmp $0x9,%eax
cvtsi2sd %ebp,%xmm0
addsd %xmm2,%xmm0
cvttsd2si %xmm0,%ebp
jg 1260 <func0+0x50>
xor %eax,%eax
cmp %ebp,%r12d
sete %al
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
xor %ebp,%ebp
jmp 12ad <func0+0x9d>
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr rax, 23h
cmp edx, 9
jg short loc_1238
pxor xmm1, xmm1
mov r12d, ebp
xor r14d, r14d
mov r13d, 0CCCCCCCDh
cvtsi2sd xmm1, ecx; y
nop dword ptr [rax+00000000h]
loc_1268:
mov ebx, r12d
mov edx, r12d
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm1
imul rbx, r13
shr rbx, 23h
lea eax, [rbx+rbx*4]
add eax, eax
sub edx, eax
cvtsi2sd xmm0, edx; x
call _pow
mov eax, r12d
movsd xmm1, [rsp+38h+var_30]
mov r12d, ebx
movapd xmm2, xmm0
pxor xmm0, xmm0
cmp eax, 9
cvtsi2sd xmm0, r14d
addsd xmm0, xmm2
cvttsd2si r14d, xmm0
jg short loc_1268
loc_12B7:
xor eax, eax
cmp ebp, r14d
setz al
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12D0:
xor r14d, r14d
jmp short loc_12B7 | _BOOL8 func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0xAu;
}
while ( v3 > 9 );
v4 = a1;
v5 = 0;
v6 = (double)v2;
do
{
v7 = pow((double)(v4 % 0xA), v6);
v8 = v4;
v4 /= 0xAu;
v5 = (int)((double)v5 + v7);
}
while ( v8 > 9 );
}
return a1 == v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR R14D,R14D
MOV R13D,0xcccccccd
CVTSI2SD XMM1,ECX
NOP dword ptr [RAX]
LAB_00101268:
MOV EBX,R12D
MOV EDX,R12D
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
IMUL RBX,R13
SHR RBX,0x23
LEA EAX,[RBX + RBX*0x4]
ADD EAX,EAX
SUB EDX,EAX
CVTSI2SD XMM0,EDX
CALL 0x00101060
MOV EAX,R12D
MOVSD XMM1,qword ptr [RSP + 0x8]
MOV R12D,EBX
MOVAPD XMM2,XMM0
PXOR XMM0,XMM0
CMP EAX,0x9
CVTSI2SD XMM0,R14D
ADDSD XMM0,XMM2
CVTTSD2SI R14D,XMM0
JG 0x00101268
LAB_001012b7:
XOR EAX,EAX
CMP EBP,R14D
SETZ AL
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012d0:
XOR R14D,R14D
JMP 0x001012b7 | bool func0(uint param_1)
{
bool bVar1;
ulong uVar2;
int iVar3;
int iVar4;
uint uVar5;
uint uVar6;
double dVar7;
if ((int)param_1 < 1) {
uVar6 = 0;
}
else {
iVar3 = 0;
uVar2 = (ulong)param_1;
do {
iVar3 = iVar3 + 1;
iVar4 = (int)uVar2;
uVar2 = uVar2 / 10;
} while (9 < iVar4);
uVar6 = 0;
uVar5 = param_1;
do {
dVar7 = pow((double)(uVar5 % 10),(double)iVar3);
uVar6 = (uint)((double)(int)uVar6 + dVar7);
bVar1 = 9 < (int)uVar5;
uVar5 = uVar5 / 10;
} while (bVar1);
}
return param_1 == uVar6;
} |
6,288 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 116e <func0+0x25>
mov -0xc(%rbp),%eax
add %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
cvtsi2sdl -0x10(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
cvtsi2sdl -0x10(%rbp),%xmm0
movsd %xmm0,0x2e8a(%rip)
movsd -0x8(%rbp),%xmm0
movsd %xmm0,0x2e85(%rip)
lea 0x2e76(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp short loc_116E
loc_1164:
mov eax, [rbp+var_C]
add [rbp+var_10], eax
add [rbp+var_C], 1
loc_116E:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jle short loc_1164
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_10]
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_10]
movsd cs:result_1, xmm0
movsd xmm0, [rbp+var_8]
movsd cs:qword_4028, xmm0
lea rax, result_1
pop rbp
retn | long long * func0(int a1)
{
int v2; // [rsp+4h] [rbp-10h]
int i; // [rsp+8h] [rbp-Ch]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i;
*(double *)&result_1 = (double)v2;
*(double *)&qword_4028 = (double)v2 / (double)a1;
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0010116e
LAB_00101164:
MOV EAX,dword ptr [RBP + -0xc]
ADD dword ptr [RBP + -0x10],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010116e:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101164
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x10]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x10]
MOVSD qword ptr [0x00104020],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVSD qword ptr [0x00104028],XMM0
LEA RAX,[0x104020]
POP RBP
RET | int1 * func0(int param_1)
{
int local_18;
int local_14;
local_18 = 0;
for (local_14 = 1; local_14 <= param_1; local_14 = local_14 + 1) {
local_18 = local_18 + local_14;
}
result_1._0_8_ = (double)local_18;
result_1._8_8_ = (double)local_18 / (double)param_1;
return result_1;
} |
6,289 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1193 <func0+0x4a>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x0,%edx
add %eax,%edx
add $0x1,%eax
cmp %ecx,%eax
jne 115e <func0+0x15>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd %xmm0,0x2ea9(%rip)
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,0x2e9d(%rip)
lea 0x2e8e(%rip),%rax
retq
mov $0x0,%edx
jmp 1167 <func0+0x1e>
| func0:
endbr64
test edi, edi
jle short loc_1193
lea ecx, [rdi+1]
mov eax, 1
mov edx, 0
loc_115E:
add edx, eax
add eax, 1
cmp eax, ecx
jnz short loc_115E
loc_1167:
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
movsd cs:result_1, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
movsd cs:qword_4028, xmm0
lea rax, result_1
retn
loc_1193:
mov edx, 0
jmp short loc_1167 | long long * func0(int a1)
{
int v1; // eax
int v2; // edx
if ( a1 <= 0 )
{
v2 = 0;
}
else
{
v1 = 1;
v2 = 0;
do
v2 += v1++;
while ( v1 != a1 + 1 );
}
*(double *)&result_1 = (double)v2;
*(double *)&qword_4028 = (double)v2 / (double)a1;
return &result_1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101193
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
MOV EDX,0x0
LAB_0010115e:
ADD EDX,EAX
ADD EAX,0x1
CMP EAX,ECX
JNZ 0x0010115e
LAB_00101167:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MOVSD qword ptr [0x00104020],XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MOVSD qword ptr [0x00104028],XMM0
LEA RAX,[0x104020]
RET
LAB_00101193:
MOV EDX,0x0
JMP 0x00101167 | int1 * func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
result_1._0_8_ = (double)iVar2;
result_1._8_8_ = (double)iVar2 / (double)param_1;
return result_1;
} |
6,290 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 11b0 <func0+0x50>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
add %eax,%edx
add $0x1,%eax
cmp %eax,%ecx
jne 1178 <func0+0x18>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
movsd %xmm0,0x2e8b(%rip)
lea 0x2e84(%rip),%rax
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,0x2e7c(%rip)
retq
nopl (%rax)
pxor %xmm0,%xmm0
jmp 1189 <func0+0x29>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_11B0
lea ecx, [rdi+1]
mov eax, 1
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1178:
add edx, eax
add eax, 1
cmp ecx, eax
jnz short loc_1178
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
loc_1189:
pxor xmm1, xmm1
movsd cs:result_1, xmm0
lea rax, result_1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
movsd cs:qword_4028, xmm0
retn
loc_11B0:
pxor xmm0, xmm0
jmp short loc_1189 | long long * func0(int a1)
{
int v1; // eax
int v2; // edx
double v3; // xmm0_8
long long *result; // rax
if ( a1 <= 0 )
{
v3 = 0.0;
}
else
{
v1 = 1;
v2 = 0;
do
v2 += v1++;
while ( a1 + 1 != v1 );
v3 = (double)v2;
}
result_1 = *(_QWORD *)&v3;
result = &result_1;
*(double *)&qword_4028 = v3 / (double)a1;
return result;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011b0
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
ADD EDX,EAX
ADD EAX,0x1
CMP ECX,EAX
JNZ 0x00101178
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
LAB_00101189:
PXOR XMM1,XMM1
MOVSD qword ptr [0x00104020],XMM0
LEA RAX,[0x104020]
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MOVSD qword ptr [0x00104028],XMM0
RET
LAB_001011b0:
PXOR XMM0,XMM0
JMP 0x00101189 | int1 * func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
result_1._0_8_ = 0.0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1;
iVar1 = iVar1 + 1;
} while (param_1 + 1 != iVar1);
result_1._0_8_ = (int8)iVar2;
}
result_1._8_8_ = (double)result_1._0_8_ / (double)param_1;
return result_1;
} |
6,291 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1200 <func0+0xb0>
lea -0x1(%rdi),%eax
cmp $0x11,%eax
jbe 1206 <func0+0xb6>
mov %edi,%edx
movdqa 0xe9e(%rip),%xmm1
xor %eax,%eax
pxor %xmm0,%xmm0
movdqa 0xea0(%rip),%xmm3
shr $0x2,%edx
nopl 0x0(%rax,%rax,1)
movdqa %xmm1,%xmm2
add $0x1,%eax
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
cmp %edx,%eax
jne 1188 <func0+0x38>
movdqa %xmm0,%xmm1
mov %edi,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
paddd %xmm1,%xmm0
lea 0x1(%rcx),%edx
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %ecx,%edi
je 11d1 <func0+0x81>
nopl (%rax)
add %edx,%eax
add $0x1,%edx
cmp %edx,%edi
jge 11c8 <func0+0x78>
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor %xmm1,%xmm1
movsd %xmm0,0x2e3b(%rip)
lea 0x2e34(%rip),%rax
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,0x2e2c(%rip)
retq
nopl (%rax)
pxor %xmm0,%xmm0
jmp 11d9 <func0+0x89>
mov $0x1,%edx
xor %eax,%eax
jmp 11c8 <func0+0x78>
| func0:
endbr64
mov edx, edi
test edi, edi
jle loc_1250
lea eax, [rdi-1]
cmp eax, 9
jbe loc_1256
mov ecx, edi
movdqa xmm1, cs:xmmword_2010
xor eax, eax
pxor xmm0, xmm0
movdqa xmm3, cs:xmmword_2020
shr ecx, 2
nop dword ptr [rax]
loc_1188:
movdqa xmm2, xmm1
add eax, 1
paddd xmm1, xmm3
paddd xmm0, xmm2
cmp eax, ecx
jnz short loc_1188
movdqa xmm1, xmm0
mov ecx, edx
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
paddd xmm0, xmm1
add ecx, 1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test dl, 3
jz short loc_121B
loc_11C6:
lea esi, [rcx+1]
add eax, ecx
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+2]
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+3]
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+4]
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+5]
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+6]
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+7]
cmp edx, esi
jl short loc_121B
add eax, esi
lea esi, [rcx+8]
cmp edx, esi
jl short loc_121B
add eax, esi
add ecx, 9
lea esi, [rax+rcx]
cmp edx, ecx
cmovge eax, esi
loc_121B:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
loc_1223:
pxor xmm2, xmm2
movapd xmm1, xmm0
lea rax, result_1
cvtsi2sd xmm2, edx
divsd xmm1, xmm2
unpcklpd xmm0, xmm1
movaps cs:result_1, xmm0
retn
loc_1250:
pxor xmm0, xmm0
jmp short loc_1223
loc_1256:
mov ecx, 1
xor eax, eax
jmp loc_11C6 | __int128 * func0(int a1)
{
__m128i si128; // xmm1
int v2; // eax
__m128i v3; // xmm0
__m128i v4; // xmm3
__m128i v5; // xmm2
__m128i v6; // xmm0
unsigned int v7; // ecx
int v8; // eax
int v9; // ecx
__m128d v10; // xmm0
__m128d v11; // xmm1
__int128 *result; // rax
if ( a1 <= 0 )
{
v10 = 0LL;
goto LABEL_17;
}
if ( (unsigned int)(a1 - 1) <= 9 )
{
v7 = 1;
v8 = 0;
goto LABEL_6;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v2 = 0;
v3 = 0LL;
v4 = _mm_load_si128((const __m128i *)&xmmword_2020);
do
{
v5 = si128;
++v2;
si128 = _mm_add_epi32(si128, v4);
v3 = _mm_add_epi32(v3, v5);
}
while ( v2 != (unsigned int)a1 >> 2 );
v6 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
v7 = (a1 & 0xFFFFFFFC) + 1;
v8 = _mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a1 & 3) != 0 )
{
LABEL_6:
v8 += v7;
if ( a1 >= (int)(v7 + 1) )
{
v8 += v7 + 1;
if ( a1 >= (int)(v7 + 2) )
{
v8 += v7 + 2;
if ( a1 >= (int)(v7 + 3) )
{
v8 += v7 + 3;
if ( a1 >= (int)(v7 + 4) )
{
v8 += v7 + 4;
if ( a1 >= (int)(v7 + 5) )
{
v8 += v7 + 5;
if ( a1 >= (int)(v7 + 6) )
{
v8 += v7 + 6;
if ( a1 >= (int)(v7 + 7) )
{
v8 += v7 + 7;
if ( a1 >= (int)(v7 + 8) )
{
v8 += v7 + 8;
v9 = v7 + 9;
if ( a1 >= v9 )
v8 += v9;
}
}
}
}
}
}
}
}
}
v10 = 0LL;
v10.m128d_f64[0] = (double)v8;
LABEL_17:
v11.m128d_f64[1] = v10.m128d_f64[1];
result = &result_1;
v11.m128d_f64[0] = v10.m128d_f64[0] / (double)a1;
result_1 = (__int128)_mm_unpacklo_pd(v10, v11);
return result;
} | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101250
LEA EAX,[RDI + -0x1]
CMP EAX,0x9
JBE 0x00101256
MOV ECX,EDI
MOVDQA XMM1,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM0,XMM0
MOVDQA XMM3,xmmword ptr [0x00102020]
SHR ECX,0x2
NOP dword ptr [RAX]
LAB_00101188:
MOVDQA XMM2,XMM1
ADD EAX,0x1
PADDD XMM1,XMM3
PADDD XMM0,XMM2
CMP EAX,ECX
JNZ 0x00101188
MOVDQA XMM1,XMM0
MOV ECX,EDX
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
PADDD XMM0,XMM1
ADD ECX,0x1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST DL,0x3
JZ 0x0010121b
LAB_001011c6:
LEA ESI,[RCX + 0x1]
ADD EAX,ECX
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x2]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x3]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x4]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x5]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x6]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x7]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
LEA ESI,[RCX + 0x8]
CMP EDX,ESI
JL 0x0010121b
ADD EAX,ESI
ADD ECX,0x9
LEA ESI,[RAX + RCX*0x1]
CMP EDX,ECX
CMOVGE EAX,ESI
LAB_0010121b:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_00101223:
PXOR XMM2,XMM2
MOVAPD XMM1,XMM0
LEA RAX,[0x104020]
CVTSI2SD XMM2,EDX
DIVSD XMM1,XMM2
UNPCKLPD XMM0,XMM1
MOVAPS xmmword ptr [0x00104020],XMM0
RET
LAB_00101250:
PXOR XMM0,XMM0
JMP 0x00101223
LAB_00101256:
MOV ECX,0x1
XOR EAX,EAX
JMP 0x001011c6 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(uint param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if ((int)param_1 < 1) {
result_1._0_8_ = 0.0;
goto LAB_00101223;
}
if (param_1 - 1 < 10) {
iVar3 = 1;
iVar5 = 0;
LAB_001011c6:
iVar2 = iVar5 + iVar3;
if (iVar3 + 1 <= (int)param_1) {
iVar2 = iVar5 + iVar3 + iVar3 + 1;
if (iVar3 + 2 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 2;
if (iVar3 + 3 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 3;
if (iVar3 + 4 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 4;
if (iVar3 + 5 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 5;
if (iVar3 + 6 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 6;
if (iVar3 + 7 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 7;
if (iVar3 + 8 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 8;
if (iVar3 + 9 <= (int)param_1) {
iVar2 = iVar2 + iVar3 + 9;
}
}
}
}
}
}
}
}
}
}
else {
uVar1 = 0;
iVar4 = 0;
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
iVar5 = _DAT_00102010;
iVar3 = _UNK_00102014;
iVar2 = _UNK_00102018;
iVar9 = _UNK_0010201c;
do {
uVar1 = uVar1 + 1;
iVar4 = iVar4 + iVar5;
iVar6 = iVar6 + iVar3;
iVar7 = iVar7 + iVar2;
iVar8 = iVar8 + iVar9;
iVar5 = iVar5 + _DAT_00102020;
iVar3 = iVar3 + _UNK_00102024;
iVar2 = iVar2 + _UNK_00102028;
iVar9 = iVar9 + _UNK_0010202c;
} while (uVar1 != param_1 >> 2);
iVar3 = (param_1 & 0xfffffffc) + 1;
iVar5 = iVar4 + iVar7 + iVar6 + iVar8;
iVar2 = iVar5;
if ((param_1 & 3) != 0) goto LAB_001011c6;
}
result_1._0_8_ = (int8)iVar2;
LAB_00101223:
result_1._8_8_ = (double)result_1._0_8_ / (double)(int)param_1;
return result_1;
} |
6,292 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
xor $0x1,%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
add $0x1,%eax
cmp %eax,%edx
jne 116d <func0+0x24>
mov $0x1,%eax
jmp 1172 <func0+0x29>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
xor eax, 1
mov edx, eax
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
jnz short loc_116D
mov eax, 1
jmp short loc_1172
loc_116D:
mov eax, 0
loc_1172:
pop rbp
retn | _BOOL8 func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
JNZ 0x0010116d
MOV EAX,0x1
JMP 0x00101172
LAB_0010116d:
MOV EAX,0x0
LAB_00101172:
POP RBP
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,293 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
xor $0x1,%eax
add $0x1,%edi
cmp %edi,%eax
sete %al
retq
| func0:
endbr64
mov eax, edi
xor eax, 1
add edi, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EAX,0x1
ADD EDI,0x1
CMP EAX,EDI
SETZ AL
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,294 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,295 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,296 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1d0,%rsp
mov %rdi,-0x1c8(%rbp)
mov %esi,-0x1cc(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x1b4(%rbp)
movl $0x0,-0x1b0(%rbp)
jmp 11c4 <func0+0x5b>
mov -0x1b0(%rbp),%eax
cltq
movl $0x1,-0x1a0(%rbp,%rax,4)
addl $0x1,-0x1b0(%rbp)
mov -0x1b0(%rbp),%eax
cmp -0x1cc(%rbp),%eax
jl 11aa <func0+0x41>
movl $0x1,-0x1ac(%rbp)
jmpq 1290 <func0+0x127>
movl $0x0,-0x1a8(%rbp)
jmpq 1277 <func0+0x10e>
mov -0x1ac(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x1c8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x1a8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x1c8(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
cmp %eax,%edx
jle 1270 <func0+0x107>
mov -0x1a8(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%edx
mov -0x1ac(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
cmp %eax,%edx
jl 1270 <func0+0x107>
mov -0x1a8(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
lea 0x1(%rax),%edx
mov -0x1ac(%rbp),%eax
cltq
mov %edx,-0x1a0(%rbp,%rax,4)
addl $0x1,-0x1a8(%rbp)
mov -0x1a8(%rbp),%eax
cmp -0x1ac(%rbp),%eax
jl 11f0 <func0+0x87>
addl $0x1,-0x1ac(%rbp)
mov -0x1ac(%rbp),%eax
cmp -0x1cc(%rbp),%eax
jl 11e1 <func0+0x78>
movl $0x0,-0x1a4(%rbp)
jmp 12e1 <func0+0x178>
mov -0x1a4(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
cmp %eax,-0x1b4(%rbp)
jge 12da <func0+0x171>
mov -0x1a4(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
mov %eax,-0x1b4(%rbp)
addl $0x1,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1cc(%rbp),%eax
jl 12ae <func0+0x145>
mov -0x1b4(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1309 <func0+0x1a0>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1D0h
mov [rbp+var_1C8], rdi
mov [rbp+var_1CC], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1B4], 0
mov [rbp+var_1B0], 0
jmp short loc_11C4
loc_11AA:
mov eax, [rbp+var_1B0]
cdqe
mov [rbp+rax*4+var_1A0], 1
add [rbp+var_1B0], 1
loc_11C4:
mov eax, [rbp+var_1B0]
cmp eax, [rbp+var_1CC]
jl short loc_11AA
mov [rbp+var_1AC], 1
jmp loc_1290
loc_11E1:
mov [rbp+var_1A8], 0
jmp loc_1277
loc_11F0:
mov eax, [rbp+var_1AC]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_1C8]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_1A8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_1C8]
add rax, rcx
mov eax, [rax+4]
cmp edx, eax
jle short loc_1270
mov eax, [rbp+var_1A8]
cdqe
mov edx, [rbp+rax*4+var_1A0]
mov eax, [rbp+var_1AC]
cdqe
mov eax, [rbp+rax*4+var_1A0]
cmp edx, eax
jl short loc_1270
mov eax, [rbp+var_1A8]
cdqe
mov eax, [rbp+rax*4+var_1A0]
lea edx, [rax+1]
mov eax, [rbp+var_1AC]
cdqe
mov [rbp+rax*4+var_1A0], edx
loc_1270:
add [rbp+var_1A8], 1
loc_1277:
mov eax, [rbp+var_1A8]
cmp eax, [rbp+var_1AC]
jl loc_11F0
add [rbp+var_1AC], 1
loc_1290:
mov eax, [rbp+var_1AC]
cmp eax, [rbp+var_1CC]
jl loc_11E1
mov [rbp+var_1A4], 0
jmp short loc_12E1
loc_12AE:
mov eax, [rbp+var_1A4]
cdqe
mov eax, [rbp+rax*4+var_1A0]
cmp [rbp+var_1B4], eax
jge short loc_12DA
mov eax, [rbp+var_1A4]
cdqe
mov eax, [rbp+rax*4+var_1A0]
mov [rbp+var_1B4], eax
loc_12DA:
add [rbp+var_1A4], 1
loc_12E1:
mov eax, [rbp+var_1A4]
cmp eax, [rbp+var_1CC]
jl short loc_12AE
mov eax, [rbp+var_1B4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1309
call ___stack_chk_fail
locret_1309:
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+1Ch] [rbp-1B4h]
int i; // [rsp+20h] [rbp-1B0h]
int j; // [rsp+24h] [rbp-1ACh]
int k; // [rsp+28h] [rbp-1A8h]
int m; // [rsp+2Ch] [rbp-1A4h]
_DWORD v8[102]; // [rsp+30h] [rbp-1A0h]
unsigned long long v9; // [rsp+1C8h] [rbp-8h]
v9 = __readfsqword(0x28u);
v3 = 0;
for ( i = 0; i < a2; ++i )
v8[i] = 1;
for ( j = 1; j < a2; ++j )
{
for ( k = 0; k < j; ++k )
{
if ( *(_DWORD *)(8LL * j + a1) > *(_DWORD *)(8LL * k + a1 + 4) && v8[k] >= v8[j] )
v8[j] = v8[k] + 1;
}
}
for ( m = 0; m < a2; ++m )
{
if ( (signed int)v3 < v8[m] )
v3 = v8[m];
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1d0
MOV qword ptr [RBP + -0x1c8],RDI
MOV dword ptr [RBP + -0x1cc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1b4],0x0
MOV dword ptr [RBP + -0x1b0],0x0
JMP 0x001011c4
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x1b0]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1a0],0x1
ADD dword ptr [RBP + -0x1b0],0x1
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x1b0]
CMP EAX,dword ptr [RBP + -0x1cc]
JL 0x001011aa
MOV dword ptr [RBP + -0x1ac],0x1
JMP 0x00101290
LAB_001011e1:
MOV dword ptr [RBP + -0x1a8],0x0
JMP 0x00101277
LAB_001011f0:
MOV EAX,dword ptr [RBP + -0x1ac]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x1c8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1a8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x1c8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
JLE 0x00101270
MOV EAX,dword ptr [RBP + -0x1a8]
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV EAX,dword ptr [RBP + -0x1ac]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
CMP EDX,EAX
JL 0x00101270
MOV EAX,dword ptr [RBP + -0x1a8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x1ac]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX
LAB_00101270:
ADD dword ptr [RBP + -0x1a8],0x1
LAB_00101277:
MOV EAX,dword ptr [RBP + -0x1a8]
CMP EAX,dword ptr [RBP + -0x1ac]
JL 0x001011f0
ADD dword ptr [RBP + -0x1ac],0x1
LAB_00101290:
MOV EAX,dword ptr [RBP + -0x1ac]
CMP EAX,dword ptr [RBP + -0x1cc]
JL 0x001011e1
MOV dword ptr [RBP + -0x1a4],0x0
JMP 0x001012e1
LAB_001012ae:
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
CMP dword ptr [RBP + -0x1b4],EAX
JGE 0x001012da
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV dword ptr [RBP + -0x1b4],EAX
LAB_001012da:
ADD dword ptr [RBP + -0x1a4],0x1
LAB_001012e1:
MOV EAX,dword ptr [RBP + -0x1a4]
CMP EAX,dword ptr [RBP + -0x1cc]
JL 0x001012ae
MOV EAX,dword ptr [RBP + -0x1b4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101309
CALL 0x00101060
LAB_00101309:
LEAVE
RET | int func0(long param_1,int param_2)
{
long in_FS_OFFSET;
int local_1bc;
int local_1b8;
int local_1b4;
int local_1b0;
int local_1ac;
int aiStack_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1bc = 0;
for (local_1b8 = 0; local_1b8 < param_2; local_1b8 = local_1b8 + 1) {
aiStack_1a8[local_1b8] = 1;
}
for (local_1b4 = 1; local_1b4 < param_2; local_1b4 = local_1b4 + 1) {
for (local_1b0 = 0; local_1b0 < local_1b4; local_1b0 = local_1b0 + 1) {
if ((*(int *)(param_1 + (long)local_1b0 * 8 + 4) < *(int *)(param_1 + (long)local_1b4 * 8)) &&
(aiStack_1a8[local_1b4] <= aiStack_1a8[local_1b0])) {
aiStack_1a8[local_1b4] = aiStack_1a8[local_1b0] + 1;
}
}
}
for (local_1ac = 0; local_1ac < param_2; local_1ac = local_1ac + 1) {
if (local_1bc < aiStack_1a8[local_1ac]) {
local_1bc = aiStack_1a8[local_1ac];
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1bc;
} |
6,297 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %esi,%esi
jle 11a5 <func0+0x3c>
mov %rsp,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rsp,%rdx,4),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1196 <func0+0x2d>
cmp $0x1,%esi
jle 11fa <func0+0x91>
lea 0x4(%rsp),%r9
lea -0x2(%rsi),%r10d
add $0x2,%r10
mov $0x1,%ecx
jmp 11eb <func0+0x82>
add $0x1,%rax
cmp %rcx,%rax
je 11de <func0+0x75>
cmp 0x4(%rdi,%rax,8),%r8d
jle 11be <func0+0x55>
mov (%rsp,%rax,4),%edx
cmp (%r9),%edx
jl 11be <func0+0x55>
add $0x1,%edx
mov %edx,(%r9)
jmp 11be <func0+0x55>
add $0x1,%rcx
add $0x4,%r9
cmp %r10,%rcx
je 1203 <func0+0x9a>
test %ecx,%ecx
jle 11de <func0+0x75>
mov (%rdi,%rcx,8),%r8d
mov $0x0,%eax
jmp 11c7 <func0+0x5e>
je 123a <func0+0xd1>
mov $0x0,%edx
jmp 121d <func0+0xb4>
mov $0x0,%eax
mov $0x0,%edx
mov (%rsp,%rax,4),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x1,%rax
cmp %eax,%esi
jg 120d <func0+0xa4>
mov 0x198(%rsp),%rax
xor %fs:0x28,%rax
jne 1249 <func0+0xe0>
mov %edx,%eax
add $0x1a8,%rsp
retq
cmpl $0x0,(%rsp)
mov $0x0,%edx
cmovns (%rsp),%edx
jmp 121d <func0+0xb4>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
sub rsp, 1A8h
mov r9d, esi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test esi, esi
jle short loc_11A8
mov rax, rsp
lea edx, [rsi-1]
lea rdx, [rsp+rdx*4+1A8h+var_1A4]
loc_1199:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1199
loc_11A8:
cmp r9d, 1
jle short loc_11F7
lea r8, [rsp+1A8h+var_1A4]
mov r10d, r9d
mov ecx, 1
jmp short loc_11E9
loc_11BD:
add rax, 1
cmp rax, rcx
jz short loc_11DC
loc_11C6:
cmp esi, [rdi+rax*8+4]
jle short loc_11BD
mov edx, [rsp+rax*4+1A8h+var_1A8]
cmp edx, [r8]
jl short loc_11BD
add edx, 1
mov [r8], edx
jmp short loc_11BD
loc_11DC:
add rcx, 1
add r8, 4
cmp rcx, r10
jz short loc_1200
loc_11E9:
test ecx, ecx
jle short loc_11DC
mov esi, [rdi+rcx*8]
mov eax, 0
jmp short loc_11C6
loc_11F7:
jz short loc_123B
mov edx, 0
jmp short loc_121E
loc_1200:
mov eax, 0
mov edx, 0
mov rsi, rsp
loc_120D:
mov ecx, [rsi+rax*4]
cmp edx, ecx
cmovl edx, ecx
add rax, 1
cmp r9d, eax
jg short loc_120D
loc_121E:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_124A
mov eax, edx
add rsp, 1A8h
retn
loc_123B:
mov edx, [rsp+1A8h+var_1A8]
test edx, edx
mov eax, 0
cmovs edx, eax
jmp short loc_121E
loc_124A:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
int *v3; // rax
_DWORD *v4; // r8
long long i; // rcx
long long v6; // rax
int v7; // edx
int v8; // esi
int v9; // edx
long long v10; // rax
int v12; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v13[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v14; // [rsp+198h] [rbp-10h]
v14 = __readfsqword(0x28u);
if ( a2 > 0 )
{
v3 = &v12;
do
*v3++ = 1;
while ( v3 != &v13[a2 - 1] );
}
if ( a2 <= 1 )
{
if ( a2 == 1 )
{
v9 = v12;
if ( v12 < 0 )
return 0;
}
else
{
return 0;
}
}
else
{
v4 = v13;
for ( i = 1LL; i != a2; ++i )
{
if ( (int)i > 0 )
{
v8 = *(_DWORD *)(a1 + 8 * i);
v6 = 0LL;
do
{
if ( v8 > *(_DWORD *)(a1 + 8 * v6 + 4) )
{
v7 = v13[v6 - 1];
if ( v7 >= *v4 )
*v4 = v7 + 1;
}
++v6;
}
while ( v6 != i );
}
++v4;
}
v10 = 0LL;
v9 = 0;
do
{
if ( v9 < v13[v10 - 1] )
v9 = v13[v10 - 1];
++v10;
}
while ( a2 > (int)v10 );
}
return (unsigned int)v9;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001011a8
MOV RAX,RSP
LEA EDX,[RSI + -0x1]
LEA RDX,[RSP + RDX*0x4 + 0x4]
LAB_00101199:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101199
LAB_001011a8:
CMP R9D,0x1
JLE 0x001011f7
LEA R8,[RSP + 0x4]
MOV R10D,R9D
MOV ECX,0x1
JMP 0x001011e9
LAB_001011bd:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001011dc
LAB_001011c6:
CMP ESI,dword ptr [RDI + RAX*0x8 + 0x4]
JLE 0x001011bd
MOV EDX,dword ptr [RSP + RAX*0x4]
CMP EDX,dword ptr [R8]
JL 0x001011bd
ADD EDX,0x1
MOV dword ptr [R8],EDX
JMP 0x001011bd
LAB_001011dc:
ADD RCX,0x1
ADD R8,0x4
CMP RCX,R10
JZ 0x00101200
LAB_001011e9:
TEST ECX,ECX
JLE 0x001011dc
MOV ESI,dword ptr [RDI + RCX*0x8]
MOV EAX,0x0
JMP 0x001011c6
LAB_001011f7:
JZ 0x0010123b
MOV EDX,0x0
JMP 0x0010121e
LAB_00101200:
MOV EAX,0x0
MOV EDX,0x0
MOV RSI,RSP
LAB_0010120d:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x1
CMP R9D,EAX
JG 0x0010120d
LAB_0010121e:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010124a
MOV EAX,EDX
ADD RSP,0x1a8
RET
LAB_0010123b:
MOV EDX,dword ptr [RSP]
TEST EDX,EDX
MOV EAX,0x0
CMOVS EDX,EAX
JMP 0x0010121e
LAB_0010124a:
CALL 0x00101060 | int func0(long param_1,uint param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar2 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < (int)param_2) {
do {
*piVar2 = 1;
piVar2 = piVar2 + 1;
} while (piVar2 != local_1a8 + (ulong)(param_2 - 1) + 1);
}
if ((int)param_2 < 2) {
if (param_2 == 1) {
if (local_1a8[0] < 0) {
local_1a8[0] = 0;
}
}
else {
local_1a8[0] = 0;
}
}
else {
piVar2 = local_1a8;
uVar5 = 1;
do {
piVar2 = piVar2 + 1;
if (0 < (int)uVar5) {
iVar1 = *(int *)(param_1 + uVar5 * 8);
uVar3 = 0;
do {
if ((*(int *)(param_1 + 4 + uVar3 * 8) < iVar1) && (*piVar2 <= local_1a8[uVar3])) {
*piVar2 = local_1a8[uVar3] + 1;
}
uVar3 = uVar3 + 1;
} while (uVar3 != uVar5);
}
uVar5 = uVar5 + 1;
} while (uVar5 != param_2);
lVar4 = 0;
local_1a8[0] = 0;
do {
if (local_1a8[0] < local_1a8[lVar4]) {
local_1a8[0] = local_1a8[lVar4];
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < (int)param_2);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1a8[0];
} |
6,298 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13e9 <func0+0xd9>
mov %rsp,%r10
lea -0x1(%rsi),%edx
lea 0x4(%rsp),%r9
mov %r10,%rax
lea (%r9,%rdx,4),%rdx
nopl 0x0(%rax,%rax,1)
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1350 <func0+0x40>
cmp $0x1,%esi
jle 13e9 <func0+0xd9>
lea -0x2(%rsi),%r11d
mov $0x1,%ecx
add $0x2,%r11
nopl (%rax)
mov (%rdi,%rcx,8),%r8d
xor %eax,%eax
xchg %ax,%ax
cmp 0x4(%rdi,%rax,8),%r8d
jle 1396 <func0+0x86>
mov (%r10,%rax,4),%edx
cmp (%r9),%edx
jl 1396 <func0+0x86>
add $0x1,%edx
mov %edx,(%r9)
add $0x1,%rax
cmp %rax,%rcx
jne 1380 <func0+0x70>
add $0x1,%rcx
add $0x4,%r9
cmp %rcx,%r11
jne 1378 <func0+0x68>
xor %eax,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov (%r10,%rax,4),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 13b8 <func0+0xa8>
mov 0x198(%rsp),%rax
xor %fs:0x28,%rax
jne 1404 <func0+0xf4>
mov %r8d,%eax
add $0x1a8,%rsp
retq
cmp $0x1,%esi
je 13f3 <func0+0xe3>
xor %r8d,%r8d
jmp 13cb <func0+0xbb>
cmpl $0x0,(%rsp)
mov $0x0,%r8d
cmovns (%rsp),%r8d
jmp 13cb <func0+0xbb>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
sub rsp, 1A8h
mov r10d, esi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test esi, esi
jle loc_13E2
mov r9, rsp
lea edx, [rsi-1]
lea r8, [rsp+1A8h+var_1A4]
mov rax, r9
lea rdx, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_1350:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1350
cmp r10d, 1
jle short loc_13E2
movsxd r11, r10d
mov ecx, 1
nop dword ptr [rax]
loc_1370:
mov esi, [rdi+rcx*8]
xor eax, eax
nop dword ptr [rax]
loc_1378:
cmp esi, [rdi+rax*8+4]
jle short loc_138D
mov edx, [r9+rax*4]
cmp edx, [r8]
jl short loc_138D
add edx, 1
mov [r8], edx
loc_138D:
add rax, 1
cmp rcx, rax
jnz short loc_1378
add rcx, 1
add r8, 4
cmp rcx, r11
jnz short loc_1370
xor eax, eax
xor r8d, r8d
nop dword ptr [rax+rax+00000000h]
loc_13B0:
mov edx, [r9+rax*4]
cmp r8d, edx
cmovl r8d, edx
add rax, 1
cmp r10d, eax
jg short loc_13B0
loc_13C4:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_13FC
mov eax, r8d
add rsp, 1A8h
retn
loc_13E2:
cmp r10d, 1
jz short loc_13ED
xor r8d, r8d
jmp short loc_13C4
loc_13ED:
mov r8d, [rsp+1A8h+var_1A8]
xor eax, eax
test r8d, r8d
cmovs r8d, eax
jmp short loc_13C4
loc_13FC:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
_DWORD *v3; // r8
int *v4; // rax
long long i; // rcx
int v6; // esi
long long v7; // rax
int v8; // edx
long long v9; // rax
int v10; // r8d
int v12; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v13[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v14; // [rsp+198h] [rbp-10h]
v14 = __readfsqword(0x28u);
if ( a2 <= 0 )
goto LABEL_17;
v3 = v13;
v4 = &v12;
do
*v4++ = 1;
while ( v4 != &v13[a2 - 1] );
if ( a2 <= 1 )
{
LABEL_17:
if ( a2 == 1 )
{
v10 = v12;
if ( v12 < 0 )
return 0;
}
else
{
return 0;
}
}
else
{
for ( i = 1LL; i != a2; ++i )
{
v6 = *(_DWORD *)(a1 + 8 * i);
v7 = 0LL;
do
{
if ( v6 > *(_DWORD *)(a1 + 8 * v7 + 4) )
{
v8 = v13[v7 - 1];
if ( v8 >= *v3 )
*v3 = v8 + 1;
}
++v7;
}
while ( i != v7 );
++v3;
}
v9 = 0LL;
v10 = 0;
do
{
if ( v10 < v13[v9 - 1] )
v10 = v13[v9 - 1];
++v9;
}
while ( a2 > (int)v9 );
}
return (unsigned int)v10;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV R10D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001013e2
MOV R9,RSP
LEA EDX,[RSI + -0x1]
LEA R8,[RSP + 0x4]
MOV RAX,R9
LEA RDX,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101350:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101350
CMP R10D,0x1
JLE 0x001013e2
MOVSXD R11,R10D
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_00101370:
MOV ESI,dword ptr [RDI + RCX*0x8]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101378:
CMP ESI,dword ptr [RDI + RAX*0x8 + 0x4]
JLE 0x0010138d
MOV EDX,dword ptr [R9 + RAX*0x4]
CMP EDX,dword ptr [R8]
JL 0x0010138d
ADD EDX,0x1
MOV dword ptr [R8],EDX
LAB_0010138d:
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101378
ADD RCX,0x1
ADD R8,0x4
CMP RCX,R11
JNZ 0x00101370
XOR EAX,EAX
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV EDX,dword ptr [R9 + RAX*0x4]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0x1
CMP R10D,EAX
JG 0x001013b0
LAB_001013c4:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013fc
MOV EAX,R8D
ADD RSP,0x1a8
RET
LAB_001013e2:
CMP R10D,0x1
JZ 0x001013ed
XOR R8D,R8D
JMP 0x001013c4
LAB_001013ed:
MOV R8D,dword ptr [RSP]
XOR EAX,EAX
TEST R8D,R8D
CMOVS R8D,EAX
JMP 0x001013c4
LAB_001013fc:
CALL 0x00101060 | int func0(long param_1,int param_2)
{
int iVar1;
int *piVar2;
long lVar3;
long lVar4;
int *piVar5;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar2 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_2) {
piVar5 = local_1a8 + 1;
do {
*piVar2 = 1;
piVar2 = piVar2 + 1;
} while (piVar2 != piVar5 + (param_2 - 1));
if (1 < param_2) {
lVar4 = 1;
do {
iVar1 = *(int *)(param_1 + lVar4 * 8);
lVar3 = 0;
do {
if ((*(int *)(param_1 + 4 + lVar3 * 8) < iVar1) && (*piVar5 <= local_1a8[lVar3])) {
*piVar5 = local_1a8[lVar3] + 1;
}
lVar3 = lVar3 + 1;
} while (lVar4 != lVar3);
lVar4 = lVar4 + 1;
piVar5 = piVar5 + 1;
} while (lVar4 != param_2);
lVar4 = 0;
local_1a8[0] = 0;
do {
if (local_1a8[0] < local_1a8[lVar4]) {
local_1a8[0] = local_1a8[lVar4];
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_2);
goto LAB_001013c4;
}
}
if (param_2 == 1) {
if (local_1a8[0] < 0) {
local_1a8[0] = 0;
}
}
else {
local_1a8[0] = 0;
}
LAB_001013c4:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1a8[0];
} |
6,299 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %esi,%esi
jle 1471 <func0+0x1d1>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 147a <func0+0x1da>
mov %esi,%edx
mov %rsp,%rax
movdqa 0xdb1(%rip),%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rax,%rdx
nopl 0x0(%rax)
movaps %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 12f0 <func0+0x50>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 1332 <func0+0x92>
movslq %eax,%rdx
movl $0x1,(%rsp,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%esi
jle 1332 <func0+0x92>
movslq %edx,%rdx
add $0x2,%eax
movl $0x1,(%rsp,%rdx,4)
cmp %eax,%esi
jle 1332 <func0+0x92>
cltq
movl $0x1,(%rsp,%rax,4)
cmp $0x1,%esi
jle 1471 <func0+0x1d1>
lea -0x2(%rsi),%r10d
lea 0x4(%rsp),%r9
mov $0x1,%ecx
add $0x2,%r10
nopl (%rax)
mov (%rdi,%rcx,8),%r8d
xor %eax,%eax
nopw %cs:0x0(%rax,%rax,1)
cmp 0x4(%rdi,%rax,8),%r8d
jle 1375 <func0+0xd5>
mov (%rsp,%rax,4),%edx
cmp (%r9),%edx
jl 1375 <func0+0xd5>
add $0x1,%edx
mov %edx,(%r9)
add $0x1,%rax
cmp %rcx,%rax
jne 1360 <func0+0xc0>
lea 0x1(%rax),%rcx
add $0x4,%r9
cmp %r10,%rcx
jne 1350 <func0+0xb0>
test %esi,%esi
mov $0x1,%ecx
cmovg %esi,%ecx
cmp $0x3,%esi
jle 1481 <func0+0x1e1>
mov %ecx,%edx
pxor %xmm0,%xmm0
mov %rsp,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rax,%rdx
nopl 0x0(%rax)
movdqa %xmm0,%xmm1
add $0x10,%rax
pcmpgtd -0x10(%rax),%xmm1
pand %xmm1,%xmm0
pandn -0x10(%rax),%xmm1
por %xmm1,%xmm0
cmp %rdx,%rax
jne 13b8 <func0+0x118>
movdqa %xmm0,%xmm1
mov %ecx,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
and $0x3,%ecx
movdqa %xmm1,%xmm2
movdqa %xmm1,%xmm3
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
je 1456 <func0+0x1b6>
movslq %edx,%rcx
mov (%rsp,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%esi
jle 1456 <func0+0x1b6>
movslq %edx,%rcx
mov (%rsp,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%esi
jle 1456 <func0+0x1b6>
movslq %edx,%rdx
mov (%rsp,%rdx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
mov 0x198(%rsp),%rsi
xor %fs:0x28,%rsi
jne 14a5 <func0+0x205>
add $0x1a8,%rsp
retq
cmp $0x1,%esi
je 1496 <func0+0x1f6>
xor %eax,%eax
jmp 1456 <func0+0x1b6>
xor %eax,%eax
jmpq 1307 <func0+0x67>
mov (%rsp),%eax
mov $0x1,%edx
test %eax,%eax
mov $0x0,%eax
cmovns (%rsp),%eax
jmp 1439 <func0+0x199>
cmpl $0x0,(%rsp)
mov $0x0,%eax
cmovns (%rsp),%eax
jmp 1456 <func0+0x1b6>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test esi, esi
jle loc_1465
lea r11d, [rsi-1]
mov r9d, esi
cmp r11d, 2
jbe loc_147A
mov edx, esi
mov rax, rsp
movdqa xmm0, cs:xmmword_2070
shr edx, 2
shl rdx, 4
lea rcx, [rdx+rax]
and edx, 10h
jz short loc_1308
movaps xmmword ptr [rax], xmm0
lea rax, [rsp+1A8h+var_198]
cmp rax, rcx
jz short loc_1318
nop dword ptr [rax+00000000h]
loc_1308:
movaps xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movaps xmmword ptr [rax-10h], xmm0
cmp rax, rcx
jnz short loc_1308
loc_1318:
mov eax, r9d
and eax, 0FFFFFFFCh
test r9b, 3
jz short loc_1351
movsxd rdx, eax
mov [rsp+rdx*4+1A8h+var_1A8], 1
lea edx, [rax+1]
cmp r9d, edx
jle short loc_1351
loc_1336:
movsxd rdx, edx
add eax, 2
mov [rsp+rdx*4+1A8h+var_1A8], 1
cmp eax, r9d
jge short loc_1351
cdqe
mov [rsp+rax*4+1A8h+var_1A8], 1
loc_1351:
lea r8, [rsp+1A8h+var_1A4]
mov r10d, r9d
mov ecx, 1
xchg ax, ax
loc_1360:
mov esi, [rdi+rcx*8]
xor eax, eax
nop dword ptr [rax]
loc_1368:
cmp esi, [rdi+rax*8+4]
jle short loc_137C
mov edx, [rsp+rax*4+1A8h+var_1A8]
cmp edx, [r8]
jl short loc_137C
add edx, 1
mov [r8], edx
loc_137C:
add rax, 1
cmp rax, rcx
jnz short loc_1368
lea rcx, [rax+1]
add r8, 4
cmp rcx, r10
jnz short loc_1360
cmp r11d, 2
jbe loc_1469
mov edx, r9d
mov rax, rsp
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rax
loc_13B0:
movdqa xmm1, xmm0
add rax, 10h
pcmpgtd xmm1, xmmword ptr [rax-10h]
pand xmm0, xmm1
pandn xmm1, xmmword ptr [rax-10h]
por xmm0, xmm1
cmp rdx, rax
jnz short loc_13B0
movdqa xmm2, xmm0
mov edx, r9d
psrldq xmm2, 8
and edx, 0FFFFFFFCh
movdqa xmm1, xmm2
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
test r9b, 3
jz short loc_144A
movsxd rcx, edx
mov ecx, [rsp+rcx*4+1A8h+var_1A8]
cmp eax, ecx
cmovl eax, ecx
lea ecx, [rdx+1]
cmp ecx, r9d
jge short loc_144A
loc_142C:
movsxd rcx, ecx
mov ecx, [rsp+rcx*4+1A8h+var_1A8]
cmp eax, ecx
cmovl eax, ecx
add edx, 2
cmp r9d, edx
jle short loc_144A
movsxd rdx, edx
mov edx, [rsp+rdx*4+1A8h+var_1A8]
cmp eax, edx
cmovl eax, edx
loc_144A:
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_1496
add rsp, 1A8h
retn
loc_1465:
xor eax, eax
jmp short loc_144A
loc_1469:
mov eax, [rsp+1A8h+var_1A8]
xor edx, edx
mov ecx, 1
test eax, eax
cmovs eax, edx
jmp short loc_142C
loc_147A:
mov [rsp+1A8h+var_1A8], 1
mov edx, 1
cmp esi, 1
jnz loc_1336
mov eax, 1
jmp short loc_144A
loc_1496:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
int v2; // eax
unsigned int v3; // r11d
__m128i *v5; // rax
__m128i si128; // xmm0
long long v7; // rdx
__m128i *v8; // rcx
int v9; // edx
int v10; // eax
__int32 *v11; // r8
long long v12; // rcx
int v13; // esi
long long v14; // rax
__int32 v15; // edx
__m128i *v16; // rax
__m128i v17; // xmm0
__m128i v18; // xmm1
__m128i v19; // xmm2
unsigned int v20; // edx
__m128i v21; // xmm1
__m128i v22; // xmm1
__m128i v23; // xmm2
__m128i v24; // xmm0
long long result; // rax
int v26; // ecx
int v27; // ecx
int v28; // ecx
int v29; // edx
int v30; // edx
__m128i v31; // [rsp+0h] [rbp-1A8h] BYREF
_BYTE v32[392]; // [rsp+10h] [rbp-198h] BYREF
unsigned long long v33; // [rsp+198h] [rbp-10h]
v33 = __readfsqword(0x28u);
v2 = 0;
if ( a2 <= 0 )
return 0LL;
v3 = a2 - 1;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v31.m128i_i32[0] = 1;
v9 = 1;
if ( a2 == 1 )
return 1LL;
goto LABEL_8;
}
v5 = &v31;
si128 = _mm_load_si128((const __m128i *)&xmmword_2070);
v7 = 16LL * ((unsigned int)a2 >> 2);
v8 = (__m128i *)((char *)&v31 + v7);
if ( (v7 & 0x10) == 0 || (v31 = si128, v5 = (__m128i *)v32, v32 != (_BYTE *)v8) )
{
do
{
*v5 = si128;
v5 += 2;
v5[-1] = si128;
}
while ( v5 != v8 );
}
v2 = a2 & 0x7FFFFFFC;
if ( (a2 & 3) != 0 )
{
v31.m128i_i32[v2] = 1;
v9 = v2 + 1;
if ( a2 > v2 + 1 )
{
LABEL_8:
v10 = v2 + 2;
v31.m128i_i32[v9] = 1;
if ( v10 < a2 )
v31.m128i_i32[v10] = 1;
}
}
v11 = &v31.m128i_i32[1];
v12 = 1LL;
do
{
v13 = *(_DWORD *)(a1 + 8 * v12);
v14 = 0LL;
do
{
if ( v13 > *(_DWORD *)(a1 + 8 * v14 + 4) )
{
v15 = v31.m128i_i32[v14];
if ( v15 >= *v11 )
*v11 = v15 + 1;
}
++v14;
}
while ( v14 != v12 );
v12 = v14 + 1;
++v11;
}
while ( v14 + 1 != a2 );
if ( v3 <= 2 )
{
result = v31.m128i_u32[0];
v20 = 0;
v27 = 1;
if ( v31.m128i_i32[0] < 0 )
result = 0LL;
goto LABEL_24;
}
v16 = &v31;
v17 = 0LL;
do
{
++v16;
v18 = _mm_cmpgt_epi32(v17, v16[-1]);
v17 = _mm_or_si128(_mm_and_si128(v17, v18), _mm_andnot_si128(v18, v16[-1]));
}
while ( &v31 + ((unsigned int)a2 >> 2) != v16 );
v19 = _mm_srli_si128(v17, 8);
v20 = a2 & 0xFFFFFFFC;
v21 = _mm_cmpgt_epi32(v19, v17);
v22 = _mm_or_si128(_mm_andnot_si128(v21, v17), _mm_and_si128(v19, v21));
v23 = _mm_srli_si128(v22, 4);
v24 = _mm_cmpgt_epi32(v23, v22);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v24, v22), _mm_and_si128(v23, v24)));
if ( (a2 & 3) != 0 )
{
v26 = v31.m128i_i32[v20];
if ( (int)result < v26 )
result = (unsigned int)v26;
v27 = v20 + 1;
if ( (int)(v20 + 1) < a2 )
{
LABEL_24:
v28 = v31.m128i_i32[v27];
if ( (int)result < v28 )
result = (unsigned int)v28;
v29 = v20 + 2;
if ( a2 > v29 )
{
v30 = v31.m128i_i32[v29];
if ( (int)result < v30 )
return (unsigned int)v30;
}
}
}
return result;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101465
LEA R11D,[RSI + -0x1]
MOV R9D,ESI
CMP R11D,0x2
JBE 0x0010147a
MOV EDX,ESI
MOV RAX,RSP
MOVDQA XMM0,xmmword ptr [0x00102070]
SHR EDX,0x2
SHL RDX,0x4
LEA RCX,[RDX + RAX*0x1]
AND EDX,0x10
JZ 0x00101308
MOVAPS xmmword ptr [RAX],XMM0
LEA RAX,[RSP + 0x10]
CMP RAX,RCX
JZ 0x00101318
NOP dword ptr [RAX]
LAB_00101308:
MOVAPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVAPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RCX
JNZ 0x00101308
LAB_00101318:
MOV EAX,R9D
AND EAX,0xfffffffc
TEST R9B,0x3
JZ 0x00101351
MOVSXD RDX,EAX
MOV dword ptr [RSP + RDX*0x4],0x1
LEA EDX,[RAX + 0x1]
CMP R9D,EDX
JLE 0x00101351
LAB_00101336:
MOVSXD RDX,EDX
ADD EAX,0x2
MOV dword ptr [RSP + RDX*0x4],0x1
CMP EAX,R9D
JGE 0x00101351
CDQE
MOV dword ptr [RSP + RAX*0x4],0x1
LAB_00101351:
LEA R8,[RSP + 0x4]
MOV R10D,R9D
MOV ECX,0x1
NOP
LAB_00101360:
MOV ESI,dword ptr [RDI + RCX*0x8]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101368:
CMP ESI,dword ptr [RDI + RAX*0x8 + 0x4]
JLE 0x0010137c
MOV EDX,dword ptr [RSP + RAX*0x4]
CMP EDX,dword ptr [R8]
JL 0x0010137c
ADD EDX,0x1
MOV dword ptr [R8],EDX
LAB_0010137c:
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101368
LEA RCX,[RAX + 0x1]
ADD R8,0x4
CMP RCX,R10
JNZ 0x00101360
CMP R11D,0x2
JBE 0x00101469
MOV EDX,R9D
MOV RAX,RSP
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RAX
LAB_001013b0:
MOVDQA XMM1,XMM0
ADD RAX,0x10
PCMPGTD XMM1,xmmword ptr [RAX + -0x10]
PAND XMM0,XMM1
PANDN XMM1,xmmword ptr [RAX + -0x10]
POR XMM0,XMM1
CMP RDX,RAX
JNZ 0x001013b0
MOVDQA XMM2,XMM0
MOV EDX,R9D
PSRLDQ XMM2,0x8
AND EDX,0xfffffffc
MOVDQA XMM1,XMM2
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
TEST R9B,0x3
JZ 0x0010144a
MOVSXD RCX,EDX
MOV ECX,dword ptr [RSP + RCX*0x4]
CMP EAX,ECX
CMOVL EAX,ECX
LEA ECX,[RDX + 0x1]
CMP ECX,R9D
JGE 0x0010144a
LAB_0010142c:
MOVSXD RCX,ECX
MOV ECX,dword ptr [RSP + RCX*0x4]
CMP EAX,ECX
CMOVL EAX,ECX
ADD EDX,0x2
CMP R9D,EDX
JLE 0x0010144a
MOVSXD RDX,EDX
MOV EDX,dword ptr [RSP + RDX*0x4]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_0010144a:
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101496
ADD RSP,0x1a8
RET
LAB_00101465:
XOR EAX,EAX
JMP 0x0010144a
LAB_00101469:
MOV EAX,dword ptr [RSP]
XOR EDX,EDX
MOV ECX,0x1
TEST EAX,EAX
CMOVS EAX,EDX
JMP 0x0010142c
LAB_0010147a:
MOV dword ptr [RSP],0x1
MOV EDX,0x1
CMP ESI,0x1
JNZ 0x00101336
MOV EAX,0x1
JMP 0x0010144a
LAB_00101496:
CALL 0x00101060 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(long param_1,ulong param_2)
{
int iVar1;
ulong uVar2;
uint uVar3;
int8 *puVar4;
ulong uVar5;
uint *puVar6;
uint *puVar7;
ulong uVar8;
int iVar9;
uint uVar10;
uint uVar11;
int *piVar12;
long in_FS_OFFSET;
uint uVar13;
uint uVar14;
uint uVar15;
int8 local_1a8;
int8 uStack_1a0;
int8 local_198 [49];
long local_10;
puVar4 = &local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = 0;
uVar11 = (uint)param_2;
if ((int)uVar11 < 1) {
uVar3 = 0;
goto LAB_0010144a;
}
if (uVar11 - 1 < 3) {
local_1a8 = CONCAT44(local_1a8._4_4_,1);
iVar9 = 1;
if (uVar11 == 1) {
uVar3 = 1;
goto LAB_0010144a;
}
LAB_00101336:
*(int4 *)((long)&local_1a8 + (long)iVar9 * 4) = 1;
if ((int)(uVar3 + 2) < (int)uVar11) {
*(int4 *)((long)&local_1a8 + (long)(int)(uVar3 + 2) * 4) = 1;
}
}
else {
uVar8 = param_2 >> 2 & 0x3fffffff;
if ((uVar8 * 0x10 & 0x10) == 0) goto LAB_00101308;
local_1a8 = _DAT_00102070;
uStack_1a0 = _UNK_00102078;
for (puVar4 = local_198; puVar4 != &local_1a8 + uVar8 * 2; puVar4 = puVar4 + 4) {
LAB_00101308:
*puVar4 = _DAT_00102070;
puVar4[1] = _UNK_00102078;
puVar4[2] = _DAT_00102070;
puVar4[3] = _UNK_00102078;
}
uVar3 = uVar11 & 0xfffffffc;
if ((param_2 & 3) != 0) {
*(int4 *)((long)&local_1a8 + (long)(int)uVar3 * 4) = 1;
iVar9 = uVar3 + 1;
if (iVar9 < (int)uVar11) goto LAB_00101336;
}
}
piVar12 = (int *)((long)&local_1a8 + 4);
uVar8 = 1;
do {
iVar9 = *(int *)(param_1 + uVar8 * 8);
uVar2 = 0;
do {
uVar5 = uVar2;
if ((*(int *)(param_1 + 4 + uVar5 * 8) < iVar9) &&
(iVar1 = *(int *)((long)&local_1a8 + uVar5 * 4), *piVar12 <= iVar1)) {
*piVar12 = iVar1 + 1;
}
uVar2 = uVar5 + 1;
} while (uVar5 + 1 != uVar8);
uVar8 = uVar5 + 2;
piVar12 = piVar12 + 1;
} while (uVar8 != (param_2 & 0xffffffff));
if (uVar11 - 1 < 3) {
uVar10 = 0;
iVar9 = 1;
uVar3 = (uint)local_1a8;
if ((int)(uint)local_1a8 < 0) {
uVar3 = 0;
}
}
else {
uVar3 = 0;
uVar13 = 0;
uVar14 = 0;
uVar15 = 0;
puVar6 = (uint *)&local_1a8;
do {
puVar7 = puVar6 + 4;
uVar3 = uVar3 & -(uint)((int)*puVar6 < (int)uVar3) |
~-(uint)((int)*puVar6 < (int)uVar3) & *puVar6;
uVar13 = uVar13 & -(uint)((int)puVar6[1] < (int)uVar13) |
~-(uint)((int)puVar6[1] < (int)uVar13) & puVar6[1];
uVar14 = uVar14 & -(uint)((int)puVar6[2] < (int)uVar14) |
~-(uint)((int)puVar6[2] < (int)uVar14) & puVar6[2];
uVar15 = uVar15 & -(uint)((int)puVar6[3] < (int)uVar15) |
~-(uint)((int)puVar6[3] < (int)uVar15) & puVar6[3];
puVar6 = puVar7;
} while ((uint *)(&local_1a8 + ((param_2 & 0xffffffff) >> 2) * 2) != puVar7);
uVar10 = uVar11 & 0xfffffffc;
uVar14 = ~-(uint)((int)uVar3 < (int)uVar14) & uVar3 | uVar14 & -(uint)((int)uVar3 < (int)uVar14)
;
uVar13 = ~-(uint)((int)uVar13 < (int)uVar15) & uVar13 |
uVar15 & -(uint)((int)uVar13 < (int)uVar15);
uVar3 = -(uint)((int)uVar14 < (int)uVar13);
uVar3 = ~uVar3 & uVar14 | uVar13 & uVar3;
if ((param_2 & 3) == 0) goto LAB_0010144a;
uVar13 = *(uint *)((long)&local_1a8 + (long)(int)uVar10 * 4);
if ((int)uVar3 < (int)uVar13) {
uVar3 = uVar13;
}
iVar9 = uVar10 + 1;
if ((int)uVar11 <= iVar9) goto LAB_0010144a;
}
uVar13 = *(uint *)((long)&local_1a8 + (long)iVar9 * 4);
if ((int)uVar3 < (int)uVar13) {
uVar3 = uVar13;
}
if (((int)(uVar10 + 2) < (int)uVar11) &&
(uVar11 = *(uint *)((long)&local_1a8 + (long)(int)(uVar10 + 2) * 4), (int)uVar3 < (int)uVar11))
{
uVar3 = uVar11;
}
LAB_0010144a:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,300 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c;
}
}
return '0'; // Using '0' to represent "None"
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11e9 <func0+0x80>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x11(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d1 <func0+0x68>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x11(%rbp)
jne 11cd <func0+0x64>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x10(%rbp),%eax
jle 11b4 <func0+0x4b>
cmpl $0x1,-0xc(%rbp)
jle 11e5 <func0+0x7c>
movzbl -0x11(%rbp),%eax
jmp 11f6 <func0+0x8d>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 1191 <func0+0x28>
mov $0x30,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_10], 0
jmp short loc_11E9
loc_1191:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_11], al
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D1
loc_11B4:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_11], al
jnz short loc_11CD
add [rbp+var_C], 1
loc_11CD:
add [rbp+var_8], 1
loc_11D1:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_10]
jle short loc_11B4
cmp [rbp+var_C], 1
jle short loc_11E5
movzx eax, [rbp+var_11]
jmp short locret_11F6
loc_11E5:
add [rbp+var_10], 1
loc_11E9:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_4]
jl short loc_1191
mov eax, 30h ; '0'
locret_11F6:
leave
retn | long long func0(const char *a1)
{
unsigned __int8 v2; // [rsp+1Fh] [rbp-11h]
int i; // [rsp+20h] [rbp-10h]
int v4; // [rsp+24h] [rbp-Ch]
int j; // [rsp+28h] [rbp-8h]
int v6; // [rsp+2Ch] [rbp-4h]
v6 = strlen(a1);
for ( i = 0; i < v6; ++i )
{
v2 = a1[i];
v4 = 0;
for ( j = 0; j <= i; ++j )
{
if ( v2 == a1[j] )
++v4;
}
if ( v4 > 1 )
return v2;
}
return 48LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011e9
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d1
LAB_001011b4:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x11],AL
JNZ 0x001011cd
ADD dword ptr [RBP + -0xc],0x1
LAB_001011cd:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x10]
JLE 0x001011b4
CMP dword ptr [RBP + -0xc],0x1
JLE 0x001011e5
MOVZX EAX,byte ptr [RBP + -0x11]
JMP 0x001011f6
LAB_001011e5:
ADD dword ptr [RBP + -0x10],0x1
LAB_001011e9:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x00101191
MOV EAX,0x30
LAB_001011f6:
LEAVE
RET | char func0(char *param_1)
{
size_t sVar1;
int local_18;
int local_14;
int local_10;
sVar1 = strlen(param_1);
local_18 = 0;
while( true ) {
if ((int)sVar1 <= local_18) {
return '0';
}
local_14 = 0;
for (local_10 = 0; local_10 <= local_18; local_10 = local_10 + 1) {
if (param_1[local_18] == param_1[local_10]) {
local_14 = local_14 + 1;
}
}
if (1 < local_14) break;
local_18 = local_18 + 1;
}
return param_1[local_18];
} |
6,301 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c;
}
}
return '0'; // Using '0' to represent "None"
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
mov %ecx,%r10d
test %ecx,%ecx
jle 11ba <func0+0x71>
mov %rdx,%r9
lea 0x1(%rdx),%rdi
mov $0x0,%r8d
movzbl -0x1(%rdi),%esi
test %r8d,%r8d
js 11a6 <func0+0x5d>
mov %r9,%rax
mov $0x0,%edx
cmp %sil,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x1,%rax
cmp %rdi,%rax
jne 118a <func0+0x41>
cmp $0x1,%edx
jle 11a6 <func0+0x5d>
mov %esi,%eax
retq
add $0x1,%r8d
add $0x1,%rdi
cmp %r8d,%r10d
jne 1179 <func0+0x30>
mov $0x30,%esi
jmp 11a3 <func0+0x5a>
mov $0x30,%esi
jmp 11a3 <func0+0x5a>
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_11C9
mov r9d, eax
lea rsi, [rbx+1]
mov r8d, 0
loc_1187:
movzx edi, byte ptr [rsi-1]
test r8d, r8d
js short loc_11B5
mov rax, rbx
mov edx, 0
loc_1198:
cmp [rax], dil
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1198
cmp edx, 1
jle short loc_11B5
loc_11B1:
mov eax, edi
pop rbx
retn
loc_11B5:
add r8d, 1
add rsi, 1
cmp r9d, r8d
jnz short loc_1187
mov edi, 30h ; '0'
jmp short loc_11B1
loc_11C9:
mov edi, 30h ; '0'
jmp short loc_11B1 | long long func0(_BYTE *a1)
{
int v2; // eax
int v3; // r9d
_BYTE *v4; // rsi
int v5; // r8d
unsigned int v6; // edi
_BYTE *v7; // rax
int v8; // edx
v2 = strlen();
if ( v2 <= 0 )
{
return 48;
}
else
{
v3 = v2;
v4 = a1 + 1;
v5 = 0;
while ( 1 )
{
v6 = (unsigned __int8)*(v4 - 1);
if ( v5 >= 0 )
{
v7 = a1;
v8 = 0;
do
v8 += *v7++ == (unsigned __int8)v6;
while ( v7 != v4 );
if ( v8 > 1 )
break;
}
++v5;
++v4;
if ( v3 == v5 )
return 48;
}
}
return v6;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011c9
MOV R9D,EAX
LEA RSI,[RBX + 0x1]
MOV R8D,0x0
LAB_00101187:
MOVZX EDI,byte ptr [RSI + -0x1]
TEST R8D,R8D
JS 0x001011b5
MOV RAX,RBX
MOV EDX,0x0
LAB_00101198:
CMP byte ptr [RAX],DIL
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101198
CMP EDX,0x1
JLE 0x001011b5
LAB_001011b1:
MOV EAX,EDI
POP RBX
RET
LAB_001011b5:
ADD R8D,0x1
ADD RSI,0x1
CMP R9D,R8D
JNZ 0x00101187
MOV EDI,0x30
JMP 0x001011b1
LAB_001011c9:
MOV EDI,0x30
JMP 0x001011b1 | char func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
int iVar5;
sVar1 = strlen(param_1);
if (0 < (int)sVar1) {
pcVar4 = param_1 + 1;
iVar5 = 0;
do {
if (-1 < iVar5) {
iVar3 = 0;
pcVar2 = param_1;
do {
iVar3 = iVar3 + (uint)(*pcVar2 == pcVar4[-1]);
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar4);
if (1 < iVar3) {
return pcVar4[-1];
}
}
iVar5 = iVar5 + 1;
pcVar4 = pcVar4 + 1;
} while ((int)sVar1 != iVar5);
}
return '0';
} |
6,302 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c;
}
}
return '0'; // Using '0' to represent "None"
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %eax,%eax
jle 1261 <func0+0x51>
sub $0x1,%eax
lea 0x1(%rbx),%rsi
lea 0x2(%rbx,%rax,1),%rdi
nopl (%rax)
movzbl -0x1(%rsi),%r8d
mov %rbx,%rax
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
cmp %r8b,(%rax)
sete %cl
add $0x1,%rax
add %ecx,%edx
cmp %rsi,%rax
jne 1240 <func0+0x30>
cmp $0x1,%edx
jg 1267 <func0+0x57>
lea 0x1(%rax),%rsi
cmp %rdi,%rsi
jne 1230 <func0+0x20>
mov $0x30,%r8d
mov %r8d,%eax
pop %rbx
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_1261
sub eax, 1
lea rsi, [rbx+1]
lea rdi, [rbx+rax+2]
nop dword ptr [rax]
loc_1230:
movzx r8d, byte ptr [rsi-1]
mov rax, rbx
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1240:
xor ecx, ecx
cmp [rax], r8b
setz cl
add rax, 1
add edx, ecx
cmp rax, rsi
jnz short loc_1240
cmp edx, 1
jg short loc_1267
lea rsi, [rax+1]
cmp rsi, rdi
jnz short loc_1230
loc_1261:
mov r8d, 30h ; '0'
loc_1267:
mov eax, r8d
pop rbx
retn | long long func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rsi
long long v4; // rdi
unsigned int v5; // r8d
_BYTE *v6; // rax
int v7; // edx
int v8; // ecx
v2 = strlen();
if ( v2 <= 0 )
{
return 48;
}
else
{
v3 = a1 + 1;
v4 = (long long)&a1[v2 - 1 + 2];
while ( 1 )
{
v5 = (unsigned __int8)*(v3 - 1);
v6 = a1;
v7 = 0;
do
{
v8 = *v6++ == (unsigned __int8)v5;
v7 += v8;
}
while ( v6 != v3 );
if ( v7 > 1 )
break;
v3 = v6 + 1;
if ( v6 + 1 == (_BYTE *)v4 )
return 48;
}
}
return v5;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101261
SUB EAX,0x1
LEA RSI,[RBX + 0x1]
LEA RDI,[RBX + RAX*0x1 + 0x2]
NOP dword ptr [RAX]
LAB_00101230:
MOVZX R8D,byte ptr [RSI + -0x1]
MOV RAX,RBX
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101240:
XOR ECX,ECX
CMP byte ptr [RAX],R8B
SETZ CL
ADD RAX,0x1
ADD EDX,ECX
CMP RAX,RSI
JNZ 0x00101240
CMP EDX,0x1
JG 0x00101267
LEA RSI,[RAX + 0x1]
CMP RSI,RDI
JNZ 0x00101230
LAB_00101261:
MOV R8D,0x30
LAB_00101267:
MOV EAX,R8D
POP RBX
RET | char func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
pcVar5 = param_1 + 1;
do {
iVar4 = 0;
pcVar1 = param_1;
do {
pcVar3 = pcVar1;
iVar4 = iVar4 + (uint)(*pcVar3 == pcVar5[-1]);
pcVar1 = pcVar3 + 1;
} while (pcVar3 + 1 != pcVar5);
if (1 < iVar4) {
return pcVar5[-1];
}
pcVar5 = pcVar3 + 2;
} while (pcVar5 != param_1 + (ulong)((int)sVar2 - 1) + 2);
}
return '0';
} |
6,303 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c;
}
}
return '0'; // Using '0' to represent "None"
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %eax,%eax
jle 14ad <func0+0x29d>
mov %eax,%r9d
mov $0x1,%esi
pxor %xmm4,%xmm4
xor %ecx,%ecx
movdqa 0xe65(%rip),%xmm5
pxor %xmm3,%xmm3
movzbl -0x1(%rbx,%rsi,1),%r8d
mov %esi,%edi
cmp $0xe,%ecx
jle 14c0 <func0+0x2b0>
movd %r8d,%xmm7
mov %esi,%edx
pxor %xmm1,%xmm1
mov %rbx,%rax
punpcklbw %xmm7,%xmm7
shr $0x4,%edx
punpcklwd %xmm7,%xmm7
shl $0x4,%rdx
pshufd $0x0,%xmm7,%xmm7
add %rbx,%rdx
nopw %cs:0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm4,%xmm6
add $0x10,%rax
pcmpeqb %xmm7,%xmm0
pand %xmm5,%xmm0
pcmpgtb %xmm0,%xmm6
movdqa %xmm0,%xmm2
punpcklbw %xmm6,%xmm2
punpckhbw %xmm6,%xmm0
movdqa %xmm3,%xmm6
pcmpgtw %xmm2,%xmm6
movdqa %xmm2,%xmm8
punpcklwd %xmm6,%xmm8
punpckhwd %xmm6,%xmm2
movdqa %xmm0,%xmm6
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm3,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm6
punpckhwd %xmm2,%xmm0
paddd %xmm6,%xmm1
paddd %xmm0,%xmm1
cmp %rax,%rdx
jne 1280 <func0+0x70>
movdqa %xmm1,%xmm0
mov %edi,%edx
psrldq $0x8,%xmm0
and $0xfffffff0,%edx
and $0xf,%edi
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
je 1498 <func0+0x288>
movslq %edx,%rdi
cmp %r8b,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x1(%rdx),%edi
cmp %ecx,%edi
jg 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x2(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x3(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x4(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x5(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x6(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x7(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x8(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0x9(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0xa(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0xb(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0xc(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
lea 0xd(%rdx),%edi
cmp %edi,%ecx
jl 1498 <func0+0x288>
movslq %edi,%rdi
cmp (%rbx,%rdi,1),%r8b
sete %dil
add $0xe,%edx
movzbl %dil,%edi
add %edi,%eax
cmp %edx,%ecx
jl 1498 <func0+0x288>
movslq %edx,%rdx
cmp (%rbx,%rdx,1),%r8b
sete %dl
movzbl %dl,%edx
add %edx,%eax
nopl 0x0(%rax,%rax,1)
cmp $0x1,%eax
jg 14b3 <func0+0x2a3>
add $0x1,%ecx
add $0x1,%rsi
cmp %ecx,%r9d
jne 1240 <func0+0x30>
mov $0x30,%r8d
mov %r8d,%eax
pop %rbx
retq
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
xor %eax,%eax
jmpq 1310 <func0+0x100>
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle loc_1474
mov edi, eax
mov esi, 1
pxor xmm6, xmm6
xor edx, edx
pxor xmm5, xmm5
pxor xmm4, xmm4
pxor xmm3, xmm3
xchg ax, ax
loc_1240:
movzx ecx, byte ptr [rbx+rsi-1]
mov r9d, esi
cmp edx, 0Eh
jle loc_1480
movd xmm8, ecx
mov r8d, esi
pxor xmm1, xmm1
mov rax, rbx
punpcklbw xmm8, xmm8
shr r8d, 4
punpcklwd xmm8, xmm8
shl r8, 4
pshufd xmm8, xmm8, 0
add r8, rbx
nop dword ptr [rax+rax+00h]
loc_1280:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm7, xmm4
add rax, 10h
pcmpeqb xmm0, xmm8
pcmpgtb xmm7, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm7
punpckhbw xmm0, xmm7
movdqa xmm7, xmm3
pcmpgtw xmm7, xmm2
movdqa xmm9, xmm2
punpcklwd xmm9, xmm7
punpckhwd xmm2, xmm7
movdqa xmm7, xmm0
psubd xmm1, xmm9
psubd xmm1, xmm2
movdqa xmm2, xmm3
pcmpgtw xmm2, xmm0
punpcklwd xmm7, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm7
psubd xmm1, xmm0
cmp r8, rax
jnz short loc_1280
movdqa xmm0, xmm1
mov r10d, r9d
psrldq xmm0, 8
and r10d, 0FFFFFFF0h
and r9d, 0Fh
paddd xmm0, xmm1
mov r8d, r10d
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
jz loc_1460
loc_1320:
mov r11d, edx
sub r11d, r10d
lea r9d, [r11+1]
cmp r11d, 6
jbe loc_13CF
movzx eax, cl
movq xmm1, qword ptr [rbx+r10]
movdqa xmm7, xmm6
mov ah, al
movd xmm2, eax
pshuflw xmm2, xmm2, 0
pcmpeqb xmm1, xmm2
pcmpgtb xmm7, xmm1
movdqa xmm2, xmm1
punpcklbw xmm2, xmm7
punpcklbw xmm1, xmm7
movdqa xmm7, xmm5
pcmpgtw xmm7, xmm2
movdqa xmm8, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
punpcklwd xmm8, xmm7
punpcklwd xmm2, xmm7
movdqa xmm7, xmm1
psubd xmm0, xmm8
pshufd xmm2, xmm2, 4Eh ; 'N'
psubd xmm0, xmm2
movdqa xmm2, xmm5
pcmpgtw xmm2, xmm1
punpcklwd xmm7, xmm2
punpcklwd xmm1, xmm2
psubd xmm0, xmm7
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm1
movd r10d, xmm0
pshufd xmm1, xmm0, 0E5h
movd eax, xmm1
add eax, r10d
mov r10d, r9d
and r10d, 0FFFFFFF8h
add r8d, r10d
and r9d, 7
jz loc_1460
loc_13CF:
movsxd r9, r8d
cmp [rbx+r9], cl
jnz short loc_13DB
add eax, 1
loc_13DB:
lea r9d, [r8+1]
cmp edx, r9d
jl short loc_1460
movsxd r9, r9d
cmp cl, [rbx+r9]
jnz short loc_13F0
add eax, 1
loc_13F0:
lea r9d, [r8+2]
cmp edx, r9d
jl short loc_1460
movsxd r9, r9d
cmp cl, [rbx+r9]
jnz short loc_1405
add eax, 1
loc_1405:
lea r9d, [r8+3]
cmp edx, r9d
jl short loc_1460
movsxd r9, r9d
cmp [rbx+r9], cl
jnz short loc_141A
add eax, 1
loc_141A:
lea r9d, [r8+4]
cmp edx, r9d
jl short loc_1460
movsxd r9, r9d
cmp cl, [rbx+r9]
jnz short loc_142F
add eax, 1
loc_142F:
lea r9d, [r8+5]
cmp r9d, edx
jg short loc_1460
movsxd r9, r9d
cmp cl, [rbx+r9]
jnz short loc_1444
add eax, 1
loc_1444:
add r8d, 6
cmp edx, r8d
jl short loc_1460
movsxd r8, r8d
cmp cl, [rbx+r8]
jnz short loc_1460
add eax, 1
nop dword ptr [rax+00000000h]
loc_1460:
cmp eax, 1
jg short loc_1479
add edx, 1
add rsi, 1
cmp edi, edx
jnz loc_1240
loc_1474:
mov ecx, 30h ; '0'
loc_1479:
mov eax, ecx
pop rbx
retn
loc_1480:
pxor xmm0, xmm0
xor r10d, r10d
xor r8d, r8d
xor eax, eax
jmp loc_1320 | long long func0(const char *a1)
{
int v2; // eax
int v3; // edi
long long v4; // rsi
int v5; // edx
unsigned int v6; // ecx
__m128i v7; // xmm8
__m128i v8; // xmm1
const __m128i *v9; // rax
__m128i v10; // xmm8
__m128i v11; // xmm8
__m128i v12; // xmm0
__m128i v13; // xmm0
__m128i v14; // xmm7
__m128i v15; // xmm2
__m128i v16; // xmm0
__m128i v17; // xmm7
__m128i v18; // xmm1
__m128i v19; // xmm2
long long v20; // r10
__m128i v21; // xmm0
int v22; // r8d
int v23; // eax
__m128i v24; // xmm0
int v25; // r9d
unsigned int v26; // eax
__m128i v27; // xmm1
__m128i v28; // xmm2
__m128i v29; // xmm1
__m128i v30; // xmm2
__m128i v31; // xmm1
__m128i v32; // xmm0
int v33; // r8d
v2 = strlen(a1);
if ( v2 > 0 )
{
v3 = v2;
v4 = 1LL;
v5 = 0;
while ( 1 )
{
v6 = (unsigned __int8)a1[v4 - 1];
if ( v5 <= 14 )
break;
v7 = _mm_cvtsi32_si128(v6);
v8 = 0LL;
v9 = (const __m128i *)a1;
v10 = _mm_unpacklo_epi8(v7, v7);
v11 = _mm_shuffle_epi32(_mm_unpacklo_epi16(v10, v10), 0);
do
{
v12 = _mm_loadu_si128(v9++);
v13 = _mm_cmpeq_epi8(v12, v11);
v14 = _mm_cmpgt_epi8((__m128i)0LL, v13);
v15 = _mm_unpacklo_epi8(v13, v14);
v16 = _mm_unpackhi_epi8(v13, v14);
v17 = _mm_cmpgt_epi16((__m128i)0LL, v15);
v18 = _mm_sub_epi32(_mm_sub_epi32(v8, _mm_unpacklo_epi16(v15, v17)), _mm_unpackhi_epi16(v15, v17));
v19 = _mm_cmpgt_epi16((__m128i)0LL, v16);
v8 = _mm_sub_epi32(_mm_sub_epi32(v18, _mm_unpacklo_epi16(v16, v19)), _mm_unpackhi_epi16(v16, v19));
}
while ( &a1[16 * ((unsigned int)v4 >> 4)] != (const char *)v9 );
v20 = (unsigned int)v4 & 0xFFFFFFF0;
v21 = _mm_add_epi32(_mm_srli_si128(v8, 8), v8);
v22 = v4 & 0xFFFFFFF0;
v23 = _mm_cvtsi128_si32(_mm_add_epi32(v21, _mm_srli_si128(v21, 4)));
v24 = _mm_add_epi32(v8, _mm_srli_si128(v8, 8));
if ( (v4 & 0xF) != 0 )
goto LABEL_7;
LABEL_29:
if ( v23 > 1 )
return v6;
++v5;
++v4;
if ( v3 == v5 )
return 48;
}
v24 = 0LL;
v20 = 0LL;
v22 = 0;
v23 = 0;
LABEL_7:
v25 = v5 - v20 + 1;
if ( (unsigned int)(v5 - v20) <= 6 )
goto LABEL_9;
v26 = (unsigned __int8)v6;
BYTE1(v26) = a1[v4 - 1];
v27 = _mm_cmpeq_epi8(_mm_loadl_epi64((const __m128i *)&a1[v20]), _mm_shufflelo_epi16(_mm_cvtsi32_si128(v26), 0));
v28 = _mm_unpacklo_epi8(v27, _mm_cmpgt_epi8((__m128i)0LL, v27));
v29 = _mm_shuffle_epi32(v28, 78);
v30 = _mm_unpacklo_epi16(v28, _mm_cmpgt_epi16((__m128i)0LL, v28));
v31 = _mm_unpacklo_epi16(v29, _mm_cmpgt_epi16((__m128i)0LL, v29));
v32 = _mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(_mm_sub_epi32(v24, v30), _mm_shuffle_epi32(v30, 78)), v31),
_mm_shuffle_epi32(v31, 78));
v23 = _mm_cvtsi128_si32(v32) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v32, 229));
v22 += v25 & 0xFFFFFFF8;
if ( (v25 & 7) != 0 )
{
LABEL_9:
if ( a1[v22] == (_BYTE)v6 )
++v23;
if ( v5 >= v22 + 1 )
{
if ( (_BYTE)v6 == a1[v22 + 1] )
++v23;
if ( v5 >= v22 + 2 )
{
if ( (_BYTE)v6 == a1[v22 + 2] )
++v23;
if ( v5 >= v22 + 3 )
{
if ( a1[v22 + 3] == (_BYTE)v6 )
++v23;
if ( v5 >= v22 + 4 )
{
if ( (_BYTE)v6 == a1[v22 + 4] )
++v23;
if ( v22 + 5 <= v5 )
{
if ( (_BYTE)v6 == a1[v22 + 5] )
++v23;
v33 = v22 + 6;
if ( v5 >= v33 && (_BYTE)v6 == a1[v33] )
++v23;
}
}
}
}
}
}
goto LABEL_29;
}
return 48;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101474
MOV EDI,EAX
MOV ESI,0x1
PXOR XMM6,XMM6
XOR EDX,EDX
PXOR XMM5,XMM5
PXOR XMM4,XMM4
PXOR XMM3,XMM3
NOP
LAB_00101240:
MOVZX ECX,byte ptr [RBX + RSI*0x1 + -0x1]
MOV R9D,ESI
CMP EDX,0xe
JLE 0x00101480
MOVD XMM8,ECX
MOV R8D,ESI
PXOR XMM1,XMM1
MOV RAX,RBX
PUNPCKLBW XMM8,XMM8
SHR R8D,0x4
PUNPCKLWD XMM8,XMM8
SHL R8,0x4
PSHUFD XMM8,XMM8,0x0
ADD R8,RBX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101280:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM7,XMM4
ADD RAX,0x10
PCMPEQB XMM0,XMM8
PCMPGTB XMM7,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM7
PUNPCKHBW XMM0,XMM7
MOVDQA XMM7,XMM3
PCMPGTW XMM7,XMM2
MOVDQA XMM9,XMM2
PUNPCKLWD XMM9,XMM7
PUNPCKHWD XMM2,XMM7
MOVDQA XMM7,XMM0
PSUBD XMM1,XMM9
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM3
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM7,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM7
PSUBD XMM1,XMM0
CMP R8,RAX
JNZ 0x00101280
MOVDQA XMM0,XMM1
MOV R10D,R9D
PSRLDQ XMM0,0x8
AND R10D,0xfffffff0
AND R9D,0xf
PADDD XMM0,XMM1
MOV R8D,R10D
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
JZ 0x00101460
LAB_00101320:
MOV R11D,EDX
SUB R11D,R10D
LEA R9D,[R11 + 0x1]
CMP R11D,0x6
JBE 0x001013cf
MOVZX EAX,CL
MOVQ XMM1,qword ptr [RBX + R10*0x1]
MOVDQA XMM7,XMM6
MOV AH,AL
MOVD XMM2,EAX
PSHUFLW XMM2,XMM2,0x0
PCMPEQB XMM1,XMM2
PCMPGTB XMM7,XMM1
MOVDQA XMM2,XMM1
PUNPCKLBW XMM2,XMM7
PUNPCKLBW XMM1,XMM7
MOVDQA XMM7,XMM5
PCMPGTW XMM7,XMM2
MOVDQA XMM8,XMM2
PSHUFD XMM1,XMM1,0x4e
PUNPCKLWD XMM8,XMM7
PUNPCKLWD XMM2,XMM7
MOVDQA XMM7,XMM1
PSUBD XMM0,XMM8
PSHUFD XMM2,XMM2,0x4e
PSUBD XMM0,XMM2
MOVDQA XMM2,XMM5
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM7,XMM2
PUNPCKLWD XMM1,XMM2
PSUBD XMM0,XMM7
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM1
MOVD R10D,XMM0
PSHUFD XMM1,XMM0,0xe5
MOVD EAX,XMM1
ADD EAX,R10D
MOV R10D,R9D
AND R10D,0xfffffff8
ADD R8D,R10D
AND R9D,0x7
JZ 0x00101460
LAB_001013cf:
MOVSXD R9,R8D
CMP byte ptr [RBX + R9*0x1],CL
JNZ 0x001013db
ADD EAX,0x1
LAB_001013db:
LEA R9D,[R8 + 0x1]
CMP EDX,R9D
JL 0x00101460
MOVSXD R9,R9D
CMP CL,byte ptr [RBX + R9*0x1]
JNZ 0x001013f0
ADD EAX,0x1
LAB_001013f0:
LEA R9D,[R8 + 0x2]
CMP EDX,R9D
JL 0x00101460
MOVSXD R9,R9D
CMP CL,byte ptr [RBX + R9*0x1]
JNZ 0x00101405
ADD EAX,0x1
LAB_00101405:
LEA R9D,[R8 + 0x3]
CMP EDX,R9D
JL 0x00101460
MOVSXD R9,R9D
CMP byte ptr [RBX + R9*0x1],CL
JNZ 0x0010141a
ADD EAX,0x1
LAB_0010141a:
LEA R9D,[R8 + 0x4]
CMP EDX,R9D
JL 0x00101460
MOVSXD R9,R9D
CMP CL,byte ptr [RBX + R9*0x1]
JNZ 0x0010142f
ADD EAX,0x1
LAB_0010142f:
LEA R9D,[R8 + 0x5]
CMP R9D,EDX
JG 0x00101460
MOVSXD R9,R9D
CMP CL,byte ptr [RBX + R9*0x1]
JNZ 0x00101444
ADD EAX,0x1
LAB_00101444:
ADD R8D,0x6
CMP EDX,R8D
JL 0x00101460
MOVSXD R8,R8D
CMP CL,byte ptr [RBX + R8*0x1]
JNZ 0x00101460
ADD EAX,0x1
NOP dword ptr [RAX]
LAB_00101460:
CMP EAX,0x1
JG 0x00101479
ADD EDX,0x1
ADD RSI,0x1
CMP EDI,EDX
JNZ 0x00101240
LAB_00101474:
MOV ECX,0x30
LAB_00101479:
MOV EAX,ECX
POP RBX
RET
LAB_00101480:
PXOR XMM0,XMM0
XOR R10D,R10D
XOR R8D,R8D
XOR EAX,EAX
JMP 0x00101320 | char func0(char *param_1)
{
uint uVar1;
char cVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
char *pcVar24;
char *pcVar25;
int auVar26 [14];
int auVar27 [12];
unkbyte10 Var28;
int auVar29 [12];
int auVar30 [14];
int auVar31 [12];
int auVar32 [16];
int auVar33 [16];
int auVar34 [16];
int auVar35 [12];
unkbyte9 Var36;
int6 uVar37;
int4 uVar38;
int2 uVar39;
size_t sVar40;
char *pcVar41;
int iVar42;
ulong uVar43;
uint uVar44;
uint uVar46;
int4 uVar47;
int iVar48;
char cVar55;
short sVar56;
int auVar52 [12];
int iVar57;
int auVar58 [12];
char cVar63;
short sVar64;
char cVar67;
int iVar65;
char cVar66;
char cVar68;
int iVar69;
int iVar71;
int auVar59 [16];
int auVar60 [16];
int iVar72;
short sVar81;
short sVar82;
int auVar74 [16];
int auVar76 [16];
int auVar77 [16];
int auVar78 [16];
char cVar92;
char cVar93;
char cVar94;
char cVar95;
char cVar96;
char cVar97;
int auVar83 [16];
int auVar88 [16];
int auVar98 [16];
int auVar101 [16];
ulong uVar45;
int6 uVar49;
int8 uVar50;
int auVar51 [12];
int auVar53 [14];
int auVar54 [16];
int auVar61 [16];
int auVar62 [16];
long lVar70;
int auVar73 [12];
int auVar79 [16];
int auVar75 [16];
int auVar80 [16];
int auVar84 [16];
int auVar85 [16];
int auVar89 [16];
int auVar86 [16];
int auVar90 [16];
int auVar87 [16];
int auVar91 [16];
int auVar99 [16];
int auVar100 [16];
int auVar102 [16];
int auVar103 [16];
sVar40 = strlen(param_1);
if (0 < (int)sVar40) {
uVar43 = 1;
iVar42 = 0;
do {
cVar2 = param_1[uVar43 - 1];
if (iVar42 < 0xf) {
iVar57 = 0;
iVar65 = 0;
uVar45 = 0;
uVar44 = 0;
iVar48 = 0;
LAB_00101320:
uVar46 = iVar42 - (int)uVar45;
uVar1 = uVar46 + 1;
if (6 < uVar46) {
uVar50 = *(int8 *)(param_1 + uVar45);
auVar76 = pshuflw(ZEXT216(CONCAT11(cVar2,cVar2)),ZEXT216(CONCAT11(cVar2,cVar2)),0);
bVar3 = (char)uVar50 == auVar76[0];
auVar59[0] = -bVar3;
bVar7 = (char)((ulong)uVar50 >> 8) == auVar76[1];
cVar55 = -bVar7;
bVar8 = (char)((ulong)uVar50 >> 0x10) == auVar76[2];
bVar9 = (char)((ulong)uVar50 >> 0x18) == auVar76[3];
bVar10 = (char)((ulong)uVar50 >> 0x20) == auVar76[4];
cVar63 = -bVar10;
bVar4 = (char)((ulong)uVar50 >> 0x28) == auVar76[5];
cVar66 = -bVar4;
bVar5 = (char)((ulong)uVar50 >> 0x30) == auVar76[6];
cVar67 = -bVar5;
bVar6 = (char)((ulong)uVar50 >> 0x38) == auVar76[7];
cVar68 = -bVar6;
cVar92 = -bVar7;
cVar93 = -bVar9;
cVar94 = -bVar10;
cVar95 = -bVar4;
cVar96 = -bVar5;
cVar97 = -bVar6;
Var28 = CONCAT91(CONCAT81((long)(CONCAT72(CONCAT61(CONCAT51(CONCAT41(CONCAT31(CONCAT21(
CONCAT11(cVar97,cVar68),cVar96),cVar67),cVar95),
cVar66),cVar94),CONCAT11(cVar63,cVar68)) >> 8),
cVar93),-bVar9);
auVar31._2_10_ = Var28;
auVar31[1] = -bVar8;
auVar31[0] = -bVar8;
auVar30._2_12_ = auVar31;
auVar30[1] = cVar92;
auVar30[0] = cVar55;
auVar77._0_2_ = CONCAT11(-bVar3,auVar59[0]);
auVar77._2_14_ = auVar30;
uVar39 = CONCAT11(cVar97,cVar68);
uVar38 = CONCAT31(CONCAT21(uVar39,cVar96),cVar67);
uVar37 = CONCAT51(CONCAT41(uVar38,cVar95),cVar66);
Var36 = CONCAT72(CONCAT61(uVar37,cVar94),CONCAT11(cVar63,cVar68));
lVar70 = (long)((unkuint9)Var36 >> 8);
auVar34._1_8_ = lVar70;
auVar34[0] = cVar93;
auVar34._9_7_ = 0;
auVar33._10_6_ = 0;
auVar33._0_10_ = SUB1610(auVar34 << 0x38,6);
auVar32._11_5_ = 0;
auVar32._0_11_ = SUB1611(auVar33 << 0x30,5);
auVar59._4_12_ = SUB1612(auVar32 << 0x28,4);
auVar59[3] = cVar92;
auVar59[2] = cVar55;
auVar59[1] = -bVar3;
sVar56 = auVar31._0_2_;
sVar64 = (short)Var28;
iVar48 = (int)((unkuint9)Var36 >> 8);
auVar58._8_4_ = auVar59._0_4_;
auVar58._0_8_ = lVar70;
auVar100._0_12_ = auVar77._0_12_;
auVar100._12_2_ = sVar64;
auVar100._14_2_ = -(ushort)(sVar64 < 0);
auVar99._12_4_ = auVar100._12_4_;
auVar99._0_10_ = auVar77._0_10_;
auVar99._10_2_ = -(ushort)(sVar56 < 0);
auVar98._10_6_ = auVar99._10_6_;
auVar98._0_8_ = auVar77._0_8_;
auVar98._8_2_ = sVar56;
auVar35._4_8_ = auVar98._8_8_;
auVar35._2_2_ = -(ushort)(auVar30._0_2_ < 0);
auVar35._0_2_ = auVar30._0_2_;
auVar80._12_2_ = sVar64;
auVar80._0_12_ = auVar100._0_12_;
auVar80._14_2_ = -(ushort)(sVar64 < 0);
auVar79._12_4_ = auVar80._12_4_;
auVar79._10_2_ = -(ushort)(sVar56 < 0);
auVar79._0_10_ = auVar99._0_10_;
auVar78._10_6_ = auVar79._10_6_;
auVar78._8_2_ = sVar56;
auVar78._0_8_ = auVar98._0_8_;
sVar56 = (short)((unkuint9)Var36 >> 8);
sVar64 = (short)uVar38;
auVar91._12_2_ = uVar39;
auVar91._0_12_ = auVar58;
auVar91._14_2_ = -(ushort)(lVar70 < 0);
auVar90._12_4_ = auVar91._12_4_;
auVar90._0_10_ = auVar58._0_10_;
auVar90._10_2_ = -(ushort)(sVar64 < 0);
auVar89._10_6_ = auVar90._10_6_;
auVar89._8_2_ = sVar64;
auVar89._0_8_ = lVar70;
auVar88._8_8_ = auVar89._8_8_;
auVar88._6_2_ = -(ushort)(iVar48 < 0);
auVar88._4_2_ = (short)uVar37;
auVar88._0_4_ = iVar48;
auVar62._12_2_ = uVar39;
auVar62._0_12_ = auVar58;
auVar62._14_2_ = -(ushort)(lVar70 < 0);
auVar61._12_4_ = auVar62._12_4_;
auVar61._10_2_ = -(ushort)(sVar64 < 0);
auVar61._0_10_ = auVar90._0_10_;
auVar60._10_6_ = auVar61._10_6_;
auVar60._8_2_ = sVar64;
auVar60._0_8_ = lVar70;
iVar48 = ((((iVar65 - auVar35._0_4_) - auVar79._12_4_) - auVar88._4_4_) - auVar61._12_4_)
+ ((((iVar57 - CONCAT22(-(ushort)bVar3,auVar77._0_2_)) - auVar78._8_4_) -
CONCAT22(-(ushort)(sVar56 < 0),sVar56)) - auVar60._8_4_);
uVar44 = uVar44 + (uVar1 & 0xfffffff8);
if ((uVar1 & 7) == 0) goto LAB_00101460;
}
if (param_1[(int)uVar44] == cVar2) {
iVar48 = iVar48 + 1;
}
if ((int)(uVar44 + 1) <= iVar42) {
if (cVar2 == param_1[(int)(uVar44 + 1)]) {
iVar48 = iVar48 + 1;
}
if ((int)(uVar44 + 2) <= iVar42) {
if (cVar2 == param_1[(int)(uVar44 + 2)]) {
iVar48 = iVar48 + 1;
}
if ((int)(uVar44 + 3) <= iVar42) {
if (param_1[(int)(uVar44 + 3)] == cVar2) {
iVar48 = iVar48 + 1;
}
if ((int)(uVar44 + 4) <= iVar42) {
if (cVar2 == param_1[(int)(uVar44 + 4)]) {
iVar48 = iVar48 + 1;
}
if ((int)(uVar44 + 5) <= iVar42) {
if (cVar2 == param_1[(int)(uVar44 + 5)]) {
iVar48 = iVar48 + 1;
}
if (((int)(uVar44 + 6) <= iVar42) && (cVar2 == param_1[(int)(uVar44 + 6)])) {
iVar48 = iVar48 + 1;
}
}
}
}
}
}
}
else {
iVar57 = 0;
iVar65 = 0;
iVar69 = 0;
iVar71 = 0;
pcVar41 = param_1;
do {
cVar55 = *pcVar41;
pcVar11 = pcVar41 + 1;
pcVar12 = pcVar41 + 2;
pcVar13 = pcVar41 + 3;
pcVar14 = pcVar41 + 4;
pcVar15 = pcVar41 + 5;
pcVar16 = pcVar41 + 6;
pcVar17 = pcVar41 + 7;
pcVar18 = pcVar41 + 8;
pcVar19 = pcVar41 + 9;
pcVar20 = pcVar41 + 10;
pcVar21 = pcVar41 + 0xb;
pcVar22 = pcVar41 + 0xc;
pcVar23 = pcVar41 + 0xd;
pcVar24 = pcVar41 + 0xe;
pcVar25 = pcVar41 + 0xf;
pcVar41 = pcVar41 + 0x10;
bVar3 = cVar55 == cVar2;
cVar55 = -(*pcVar17 == cVar2);
bVar7 = *pcVar18 == cVar2;
bVar8 = *pcVar19 == cVar2;
bVar9 = *pcVar20 == cVar2;
bVar10 = *pcVar21 == cVar2;
uVar39 = CONCAT11(-(*pcVar17 == cVar2),cVar55);
uVar38 = CONCAT31(CONCAT21(uVar39,-(*pcVar16 == cVar2)),-(*pcVar16 == cVar2));
uVar37 = CONCAT51(CONCAT41(uVar38,-(*pcVar15 == cVar2)),-(*pcVar15 == cVar2));
Var36 = CONCAT72(CONCAT61(uVar37,-(*pcVar14 == cVar2)),
CONCAT11(-(*pcVar14 == cVar2),cVar55));
lVar70 = (long)((unkuint9)Var36 >> 8);
Var28 = CONCAT91(CONCAT81(lVar70,-(*pcVar13 == cVar2)),-(*pcVar13 == cVar2));
auVar27._2_10_ = Var28;
auVar27[1] = -(*pcVar12 == cVar2);
auVar27[0] = -(*pcVar12 == cVar2);
auVar26._2_12_ = auVar27;
auVar26[1] = -(*pcVar11 == cVar2);
auVar26[0] = -(*pcVar11 == cVar2);
auVar74._0_2_ = CONCAT11(-bVar3,-bVar3);
auVar74._2_14_ = auVar26;
uVar47 = CONCAT13(-bVar8,CONCAT12(-bVar8,CONCAT11(-bVar7,-bVar7)));
uVar49 = CONCAT15(-bVar9,CONCAT14(-bVar9,uVar47));
uVar50 = CONCAT17(-bVar10,CONCAT16(-bVar10,uVar49));
auVar51._0_10_ = CONCAT19(-(*pcVar22 == cVar2),CONCAT18(-(*pcVar22 == cVar2),uVar50));
auVar51[10] = -(*pcVar23 == cVar2);
auVar51[0xb] = -(*pcVar23 == cVar2);
auVar53[0xc] = -(*pcVar24 == cVar2);
auVar53._0_12_ = auVar51;
auVar53[0xd] = -(*pcVar24 == cVar2);
auVar76[0xe] = -(*pcVar25 == cVar2);
auVar76._0_14_ = auVar53;
auVar76[0xf] = -(*pcVar25 == cVar2);
sVar56 = (short)Var28;
sVar64 = (short)((unkuint9)Var36 >> 8);
sVar81 = (short)uVar37;
sVar82 = (short)uVar38;
auVar103._0_12_ = auVar74._0_12_;
auVar103._12_2_ = sVar56;
auVar103._14_2_ = -(ushort)(sVar56 < 0);
auVar102._12_4_ = auVar103._12_4_;
auVar102._0_10_ = auVar74._0_10_;
auVar102._10_2_ = -(ushort)(auVar27._0_2_ < 0);
auVar101._10_6_ = auVar102._10_6_;
auVar101._0_8_ = auVar74._0_8_;
auVar101._8_2_ = auVar27._0_2_;
auVar29._4_8_ = auVar101._8_8_;
auVar29._2_2_ = -(ushort)(auVar26._0_2_ < 0);
auVar29._0_2_ = auVar26._0_2_;
iVar72 = CONCAT22(-(ushort)(sVar64 < 0),sVar64);
auVar73._0_8_ = CONCAT26(-(ushort)(sVar81 < 0),CONCAT24(sVar81,iVar72));
auVar73._8_2_ = sVar82;
auVar73._10_2_ = -(ushort)(sVar82 < 0);
auVar75._12_2_ = uVar39;
auVar75._0_12_ = auVar73;
auVar75._14_2_ = -(ushort)(lVar70 < 0);
sVar56 = (short)((unkuint10)auVar51._0_10_ >> 0x40);
auVar87._12_2_ = (short)((ulong)uVar50 >> 0x30);
auVar87._0_12_ = auVar51;
auVar87._14_2_ = -(ushort)bVar10;
auVar86._12_4_ = auVar87._12_4_;
auVar86._10_2_ = -(ushort)bVar9;
auVar86._0_10_ = auVar51._0_10_;
auVar85._10_6_ = auVar86._10_6_;
auVar85._8_2_ = (short)((uint6)uVar49 >> 0x20);
auVar85._0_8_ = uVar50;
auVar84._8_8_ = auVar85._8_8_;
auVar84._6_2_ = -(ushort)bVar8;
auVar84._0_6_ = uVar49;
auVar83._6_10_ = auVar84._6_10_;
auVar83._4_2_ = (short)((uint)uVar47 >> 0x10);
auVar83._0_4_ = uVar47;
iVar48 = CONCAT22(-(ushort)(sVar56 < 0),sVar56);
auVar52._0_8_ = CONCAT26(-(ushort)(auVar51._10_2_ < 0),CONCAT24(auVar51._10_2_,iVar48));
auVar52._8_2_ = auVar53._12_2_;
auVar52._10_2_ = -(ushort)(auVar53._12_2_ < 0);
auVar54._12_2_ = auVar76._14_2_;
auVar54._0_12_ = auVar52;
auVar54._14_2_ = -(ushort)(auVar76._14_2_ < 0);
iVar57 = (((iVar57 - CONCAT22(-(ushort)bVar3,auVar74._0_2_)) - iVar72) -
CONCAT22(-(ushort)bVar7,CONCAT11(-bVar7,-bVar7))) - iVar48;
iVar65 = (((iVar65 - auVar29._0_4_) - (int)((ulong)auVar73._0_8_ >> 0x20)) - auVar83._4_4_
) - (int)((ulong)auVar52._0_8_ >> 0x20);
iVar69 = (((iVar69 - auVar101._8_4_) - auVar73._8_4_) - auVar85._8_4_) - auVar52._8_4_;
iVar71 = (((iVar71 - auVar102._12_4_) - auVar75._12_4_) - auVar86._12_4_) - auVar54._12_4_
;
} while (param_1 + (uVar43 >> 4 & 0xfffffff) * 0x10 != pcVar41);
uVar44 = (uint)uVar43 & 0xfffffff0;
uVar45 = (ulong)uVar44;
iVar48 = iVar69 + iVar57 + iVar71 + iVar65;
iVar57 = iVar57 + iVar69;
iVar65 = iVar65 + iVar71;
if ((uVar43 & 0xf) != 0) goto LAB_00101320;
}
LAB_00101460:
if (1 < iVar48) {
return cVar2;
}
iVar42 = iVar42 + 1;
uVar43 = uVar43 + 1;
} while ((int)sVar40 != iVar42);
}
return '0';
} |
6,304 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < current_size) {
for (int j = remove_index; j < current_size - 1; j++) {
ludics[j] = ludics[j + 1];
}
current_size -= 1;
remove_index += first_ludic - 1;
}
index += 1;
}
*ludic_size = current_size;
return ludics;
}
| int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25);
free(result);
result = func0(45, &size);
assert(size == 14 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25 && result[10] == 29 && result[11] == 37 && result[12] == 41 && result[13] == 43);
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x20(%rbp)
jmp 11fa <func0+0x51>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x20(%rbp),%edx
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11da <func0+0x31>
mov -0x24(%rbp),%eax
mov %eax,-0x1c(%rbp)
movl $0x1,-0x18(%rbp)
jmpq 129b <func0+0xf2>
mov -0x18(%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),%edx
mov -0xc(%rbp),%eax
add %edx,%eax
mov %eax,-0x14(%rbp)
jmp 128f <func0+0xe6>
mov -0x14(%rbp),%eax
mov %eax,-0x10(%rbp)
jmp 1277 <func0+0xce>
mov -0x10(%rbp),%eax
cltq
add $0x1,%rax
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)
addl $0x1,-0x10(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x10(%rbp)
jl 1242 <func0+0x99>
subl $0x1,-0x1c(%rbp)
mov -0xc(%rbp),%eax
sub $0x1,%eax
add %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 123a <func0+0x91>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1214 <func0+0x6b>
mov -0x30(%rbp),%rax
mov -0x1c(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_20], 0
jmp short loc_11FA
loc_11DA:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rbp+var_20]
add edx, 1
mov [rax], edx
add [rbp+var_20], 1
loc_11FA:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jl short loc_11DA
mov eax, [rbp+var_24]
mov [rbp+var_1C], eax
mov [rbp+var_18], 1
jmp loc_129B
loc_1214:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov edx, [rbp+var_18]
mov eax, [rbp+var_C]
add eax, edx
mov [rbp+var_14], eax
jmp short loc_128F
loc_123A:
mov eax, [rbp+var_14]
mov [rbp+var_10], eax
jmp short loc_1277
loc_1242:
mov eax, [rbp+var_10]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_10], 1
loc_1277:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_10], eax
jl short loc_1242
sub [rbp+var_1C], 1
mov eax, [rbp+var_C]
sub eax, 1
add [rbp+var_14], eax
loc_128F:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jl short loc_123A
add [rbp+var_18], 1
loc_129B:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_1C]
jl loc_1214
mov rax, [rbp+var_30]
mov edx, [rbp+var_1C]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(int a1, int *a2)
{
int i; // [rsp+10h] [rbp-20h]
int v4; // [rsp+14h] [rbp-1Ch]
int j; // [rsp+18h] [rbp-18h]
int k; // [rsp+1Ch] [rbp-14h]
int m; // [rsp+20h] [rbp-10h]
int v8; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v9 = malloc(4LL * a1);
for ( i = 0; i < a1; ++i )
v9[i] = i + 1;
v4 = a1;
for ( j = 1; j < v4; ++j )
{
v8 = v9[j];
for ( k = j + v8; k < v4; k += v8 - 1 )
{
for ( m = k; m < v4 - 1; ++m )
v9[m] = v9[m + 1];
--v4;
}
}
*a2 = v4;
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001011fa
LAB_001011da:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x20]
ADD EDX,0x1
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x20],0x1
LAB_001011fa:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011da
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x18],0x1
JMP 0x0010129b
LAB_00101214:
MOV EAX,dword ptr [RBP + -0x18]
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 EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0010128f
LAB_0010123a:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00101277
LAB_00101242:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
ADD RAX,0x1
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
ADD dword ptr [RBP + -0x10],0x1
LAB_00101277:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x10],EAX
JL 0x00101242
SUB dword ptr [RBP + -0x1c],0x1
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
ADD dword ptr [RBP + -0x14],EAX
LAB_0010128f:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010123a
ADD dword ptr [RBP + -0x18],0x1
LAB_0010129b:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101214
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int param_1,int *param_2)
{
int iVar1;
void *pvVar2;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
pvVar2 = malloc((long)param_1 << 2);
for (local_28 = 0; local_28 < param_1; local_28 = local_28 + 1) {
*(int *)((long)pvVar2 + (long)local_28 * 4) = local_28 + 1;
}
local_24 = param_1;
for (local_20 = 1; local_20 < local_24; local_20 = local_20 + 1) {
iVar1 = *(int *)((long)pvVar2 + (long)local_20 * 4);
for (local_1c = iVar1 + local_20; local_1c < local_24; local_1c = local_1c + iVar1 + -1) {
for (local_18 = local_1c; local_18 < local_24 + -1; local_18 = local_18 + 1) {
*(int4 *)((long)pvVar2 + (long)local_18 * 4) =
*(int4 *)((long)pvVar2 + ((long)local_18 + 1) * 4);
}
local_24 = local_24 + -1;
}
}
*param_2 = local_24;
return pvVar2;
} |
6,305 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < current_size) {
for (int j = remove_index; j < current_size - 1; j++) {
ludics[j] = ludics[j + 1];
}
current_size -= 1;
remove_index += first_ludic - 1;
}
index += 1;
}
*ludic_size = current_size;
return ludics;
}
| int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25);
free(result);
result = func0(45, &size);
assert(size == 14 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25 && result[10] == 29 && result[11] == 37 && result[12] == 41 && result[13] == 43);
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %rsi,%r14
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r11
test %ebx,%ebx
jle 11e7 <func0+0x3e>
lea -0x1(%rbx),%edx
add $0x2,%rdx
mov $0x1,%eax
mov %eax,-0x4(%r11,%rax,4)
add $0x1,%rax
cmp %rdx,%rax
jne 11d9 <func0+0x30>
cmp $0x1,%ebx
jle 1255 <func0+0xac>
mov $0x1,%r13d
lea 0x4(%r11),%r12
jmp 1232 <func0+0x89>
lea (%r11,%rdi,4),%rax
mov %r8d,%edx
add %rdi,%rdx
lea (%r12,%rdx,4),%rcx
mov 0x4(%rax),%edx
mov %edx,(%rax)
add $0x4,%rax
cmp %rcx,%rax
jne 1206 <func0+0x5d>
add %ebp,%esi
sub %r9d,%r8d
add %r10,%rdi
cmp %ebx,%esi
jge 1229 <func0+0x80>
sub $0x1,%ebx
cmp %esi,%ebx
jg 11f8 <func0+0x4f>
jmp 1214 <func0+0x6b>
add $0x1,%r13
cmp %r13d,%ebx
jle 1255 <func0+0xac>
mov (%r11,%r13,4),%r9d
lea (%r9,%r13,1),%esi
cmp %ebx,%esi
jge 1229 <func0+0x80>
lea -0x2(%rbx),%r8d
sub %esi,%r8d
movslq %r9d,%r10
sub $0x1,%r10
movslq %esi,%rdi
lea -0x1(%r9),%ebp
jmp 1220 <func0+0x77>
mov %ebx,(%r14)
mov %r11,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov ebx, edi
mov r14, rsi
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r11, rax
test ebx, ebx
jle short loc_11E3
lea edx, [rbx+1]
mov eax, 1
loc_11D5:
mov [r11+rax*4-4], eax
add rax, 1
cmp rax, rdx
jnz short loc_11D5
loc_11E3:
cmp ebx, 1
jle short loc_1251
mov r13d, 1
lea r12, [r11+4]
jmp short loc_122E
loc_11F4:
lea rax, [r11+rdi*4]
mov edx, r8d
add rdx, rdi
lea rcx, [r12+rdx*4]
loc_1202:
mov edx, [rax+4]
mov [rax], edx
add rax, 4
cmp rax, rcx
jnz short loc_1202
loc_1210:
add esi, ebp
sub r8d, r9d
add rdi, r10
cmp esi, ebx
jge short loc_1225
loc_121C:
sub ebx, 1
cmp ebx, esi
jg short loc_11F4
jmp short loc_1210
loc_1225:
add r13, 1
cmp ebx, r13d
jle short loc_1251
loc_122E:
mov r9d, [r11+r13*4]
lea esi, [r9+r13]
cmp esi, ebx
jge short loc_1225
lea r8d, [rbx-2]
sub r8d, esi
movsxd r10, r9d
sub r10, 1
movsxd rdi, esi
lea ebp, [r9-1]
jmp short loc_121C
loc_1251:
mov [r14], ebx
mov rax, r11
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(int a1, int *a2)
{
int v2; // ebx
long long v4; // r11
long long v5; // rax
long long v6; // r13
_DWORD *v7; // rax
int v8; // esi
unsigned int v9; // r8d
long long v10; // rdi
int v11; // r9d
v2 = a1;
v4 = malloc(4LL * a1);
if ( a1 > 0 )
{
v5 = 1LL;
do
{
*(_DWORD *)(v4 + 4 * v5 - 4) = v5;
++v5;
}
while ( v5 != a1 + 1 );
}
if ( a1 > 1 )
{
v6 = 1LL;
do
{
v11 = *(_DWORD *)(v4 + 4 * v6);
v8 = v11 + v6;
if ( v11 + (int)v6 < v2 )
{
v9 = v2 - 2 - v8;
v10 = v8;
do
{
if ( --v2 > v8 )
{
v7 = (_DWORD *)(v4 + 4 * v10);
do
{
*v7 = v7[1];
++v7;
}
while ( v7 != (_DWORD *)(v4 + 4 + 4 * (v10 + v9)) );
}
v8 += v11 - 1;
v9 -= v11;
v10 += v11 - 1LL;
}
while ( v8 < v2 );
}
++v6;
}
while ( v2 > (int)v6 );
}
*a2 = v2;
return v4;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV R14,RSI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R11,RAX
TEST EBX,EBX
JLE 0x001011e3
LEA EDX,[RBX + 0x1]
MOV EAX,0x1
LAB_001011d5:
MOV dword ptr [R11 + RAX*0x4 + -0x4],EAX
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011d5
LAB_001011e3:
CMP EBX,0x1
JLE 0x00101251
MOV R13D,0x1
LEA R12,[R11 + 0x4]
JMP 0x0010122e
LAB_001011f4:
LEA RAX,[R11 + RDI*0x4]
MOV EDX,R8D
ADD RDX,RDI
LEA RCX,[R12 + RDX*0x4]
LAB_00101202:
MOV EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RAX],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101202
LAB_00101210:
ADD ESI,EBP
SUB R8D,R9D
ADD RDI,R10
CMP ESI,EBX
JGE 0x00101225
LAB_0010121c:
SUB EBX,0x1
CMP EBX,ESI
JG 0x001011f4
JMP 0x00101210
LAB_00101225:
ADD R13,0x1
CMP EBX,R13D
JLE 0x00101251
LAB_0010122e:
MOV R9D,dword ptr [R11 + R13*0x4]
LEA ESI,[R9 + R13*0x1]
CMP ESI,EBX
JGE 0x00101225
LEA R8D,[RBX + -0x2]
SUB R8D,ESI
MOVSXD R10,R9D
SUB R10,0x1
MOVSXD RDI,ESI
LEA EBP,[R9 + -0x1]
JMP 0x0010121c
LAB_00101251:
MOV dword ptr [R14],EBX
MOV RAX,R11
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void * func0(int param_1,int *param_2)
{
int iVar1;
void *pvVar2;
ulong uVar3;
int4 *puVar4;
int iVar5;
long lVar6;
uint uVar7;
long lVar8;
pvVar2 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
do {
*(int *)((long)pvVar2 + uVar3 * 4 + -4) = (int)uVar3;
uVar3 = uVar3 + 1;
} while (uVar3 != param_1 + 1);
}
if (1 < param_1) {
lVar8 = 1;
do {
iVar1 = *(int *)((long)pvVar2 + lVar8 * 4);
iVar5 = iVar1 + (int)lVar8;
if (iVar5 < param_1) {
uVar7 = (param_1 + -2) - iVar5;
lVar6 = (long)iVar5;
do {
param_1 = param_1 + -1;
if (iVar5 < param_1) {
puVar4 = (int4 *)((long)pvVar2 + lVar6 * 4);
do {
*puVar4 = puVar4[1];
puVar4 = puVar4 + 1;
} while (puVar4 != (int4 *)((long)pvVar2 + ((ulong)uVar7 + lVar6) * 4 + 4));
}
iVar5 = iVar5 + iVar1 + -1;
uVar7 = uVar7 - iVar1;
lVar6 = lVar6 + (long)iVar1 + -1;
} while (iVar5 < param_1);
}
lVar8 = lVar8 + 1;
} while ((int)lVar8 < param_1);
}
*param_2 = param_1;
return pvVar2;
} |
6,306 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < current_size) {
for (int j = remove_index; j < current_size - 1; j++) {
ludics[j] = ludics[j + 1];
}
current_size -= 1;
remove_index += first_ludic - 1;
}
index += 1;
}
*ludic_size = current_size;
return ludics;
}
| int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25);
free(result);
result = func0(45, &size);
assert(size == 14 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25 && result[10] == 29 && result[11] == 37 && result[12] == 41 && result[13] == 43);
free(result);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
movslq %edi,%rdi
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r11
test %ebx,%ebx
jle 1445 <func0+0xb5>
lea -0x1(%rbx),%edx
mov $0x1,%eax
add $0x2,%rdx
nopl (%rax)
mov %eax,-0x4(%r11,%rax,4)
add $0x1,%rax
cmp %rdx,%rax
jne 13c8 <func0+0x38>
cmp $0x1,%ebx
jle 1445 <func0+0xb5>
mov $0x1,%r14d
lea 0x4(%r11),%r13
nopl (%rax)
mov (%r11,%r14,4),%r9d
lea (%r9,%r14,1),%esi
cmp %ebx,%esi
jge 143c <func0+0xac>
lea -0x1(%r9),%r10d
lea -0x2(%rbx),%r8d
movslq %esi,%rdi
sub %esi,%r8d
movslq %r10d,%rbp
nopl (%rax)
sub $0x1,%ebx
cmp %esi,%ebx
jle 142f <func0+0x9f>
mov %r8d,%edx
lea (%r11,%rdi,4),%rax
add %rdi,%rdx
lea 0x0(%r13,%rdx,4),%rcx
xchg %ax,%ax
mov 0x4(%rax),%edx
add $0x4,%rax
mov %edx,-0x4(%rax)
cmp %rax,%rcx
jne 1420 <func0+0x90>
add %r10d,%esi
sub %r9d,%r8d
add %rbp,%rdi
cmp %ebx,%esi
jl 1408 <func0+0x78>
add $0x1,%r14
cmp %r14d,%ebx
jg 13e8 <func0+0x58>
mov %ebx,(%r12)
mov %r11,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
movsxd rdi, edi
push r14
mov r14, rdi
shl rdi, 2
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
lea edx, [r14+1]
mov [rsp+48h+var_48], rax
mov eax, 1
test r14d, r14d
jle loc_147C
nop dword ptr [rax+00h]
loc_13F0:
mov rdi, [rsp+48h+var_48]
mov [rdi+rax*4-4], eax
add rax, 1
cmp rax, rdx
jnz short loc_13F0
cmp r14d, 1
jle short loc_147C
mov r12d, 1
nop dword ptr [rax]
loc_1410:
mov rdi, [rsp+48h+var_48]
mov r9d, [rdi+r12*4]
lea r15d, [r9+r12]
cmp r15d, r14d
jge short loc_1473
lea r13d, [r9-1]
lea ebx, [r14-2]
movsxd rax, r15d
movsxd rbp, r13d
sub ebx, r15d
lea rcx, [rdi+rax*4]
shl rbp, 2
nop word ptr [rax+rax+00h]
loc_1440:
sub r14d, 1
cmp r14d, r15d
jle short loc_1462
mov eax, ebx
lea rsi, [rcx+4]
mov rdi, rcx
lea rdx, ds:4[rax*4]
call _memmove
mov rcx, rax
loc_1462:
sub ebx, r13d
add r15d, r13d
add rcx, rbp
sub ebx, 1
cmp r15d, r14d
jl short loc_1440
loc_1473:
add r12, 1
cmp r14d, r12d
jg short loc_1410
loc_147C:
mov rax, [rsp+48h+var_40]
mov [rax], r14d
mov rax, [rsp+48h+var_48]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1, int *a2)
{
int v2; // r14d
long long v3; // rax
long long v4; // r12
int v5; // r9d
int v6; // r15d
int v7; // r13d
unsigned int v8; // ebx
long long v9; // rcx
long long v11; // [rsp+0h] [rbp-48h]
v2 = a1;
v11 = malloc(4LL * a1);
v3 = 1LL;
if ( a1 > 0 )
{
do
{
*(_DWORD *)(v11 + 4 * v3 - 4) = v3;
++v3;
}
while ( v3 != a1 + 1 );
if ( a1 > 1 )
{
v4 = 1LL;
do
{
v5 = *(_DWORD *)(v11 + 4 * v4);
v6 = v5 + v4;
if ( v5 + (int)v4 < v2 )
{
v7 = v5 - 1;
v8 = v2 - 2 - v6;
v9 = v11 + 4LL * v6;
do
{
if ( --v2 > v6 )
v9 = memmove(v9, v9 + 4, 4LL * v8 + 4);
v6 += v7;
v9 += 4LL * v7;
v8 = v8 - v7 - 1;
}
while ( v6 < v2 );
}
++v4;
}
while ( v2 > (int)v4 );
}
}
*a2 = v2;
return v11;
} | func0:
ENDBR64
PUSH R15
MOVSXD RDI,EDI
PUSH R14
MOV R14,RDI
SHL RDI,0x2
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x001010c0
LEA EDX,[R14 + 0x1]
MOV qword ptr [RSP],RAX
MOV EAX,0x1
TEST R14D,R14D
JLE 0x0010147c
NOP dword ptr [RAX]
LAB_001013f0:
MOV RDI,qword ptr [RSP]
MOV dword ptr [RDI + RAX*0x4 + -0x4],EAX
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001013f0
CMP R14D,0x1
JLE 0x0010147c
MOV R12D,0x1
NOP dword ptr [RAX]
LAB_00101410:
MOV RDI,qword ptr [RSP]
MOV R9D,dword ptr [RDI + R12*0x4]
LEA R15D,[R9 + R12*0x1]
CMP R15D,R14D
JGE 0x00101473
LEA R13D,[R9 + -0x1]
LEA EBX,[R14 + -0x2]
MOVSXD RAX,R15D
MOVSXD RBP,R13D
SUB EBX,R15D
LEA RCX,[RDI + RAX*0x4]
SHL RBP,0x2
NOP word ptr [RAX + RAX*0x1]
LAB_00101440:
SUB R14D,0x1
CMP R14D,R15D
JLE 0x00101462
MOV EAX,EBX
LEA RSI,[RCX + 0x4]
MOV RDI,RCX
LEA RDX,[0x4 + RAX*0x4]
CALL 0x001010d0
MOV RCX,RAX
LAB_00101462:
SUB EBX,R13D
ADD R15D,R13D
ADD RCX,RBP
SUB EBX,0x1
CMP R15D,R14D
JL 0x00101440
LAB_00101473:
ADD R12,0x1
CMP R14D,R12D
JG 0x00101410
LAB_0010147c:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R14D
MOV RAX,qword ptr [RSP]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(int param_1,int *param_2)
{
void *pvVar1;
ulong uVar2;
void *__dest;
uint uVar3;
ulong uVar4;
long lVar5;
int iVar6;
uint uVar7;
int iVar8;
uVar4 = (ulong)param_1;
pvVar1 = malloc(uVar4 << 2);
uVar2 = 1;
if (0 < param_1) {
do {
*(int *)((long)pvVar1 + uVar2 * 4 + -4) = (int)uVar2;
uVar2 = uVar2 + 1;
} while (uVar2 != param_1 + 1);
if (1 < param_1) {
lVar5 = 1;
do {
iVar6 = *(int *)((long)pvVar1 + lVar5 * 4);
iVar8 = iVar6 + (int)lVar5;
if (iVar8 < (int)uVar4) {
iVar6 = iVar6 + -1;
uVar3 = ((int)uVar4 + -2) - iVar8;
__dest = (void *)((long)pvVar1 + (long)iVar8 * 4);
do {
uVar7 = (int)uVar4 - 1;
uVar4 = (ulong)uVar7;
if (iVar8 < (int)uVar7) {
__dest = memmove(__dest,(void *)((long)__dest + 4),(ulong)uVar3 * 4 + 4);
}
iVar8 = iVar8 + iVar6;
__dest = (void *)((long)__dest + (long)iVar6 * 4);
uVar3 = (uVar3 - iVar6) - 1;
} while (iVar8 < (int)uVar7);
}
lVar5 = lVar5 + 1;
param_1 = (int)uVar4;
} while ((int)lVar5 < param_1);
}
}
*param_2 = param_1;
return pvVar1;
} |
6,307 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < current_size) {
for (int j = remove_index; j < current_size - 1; j++) {
ludics[j] = ludics[j + 1];
}
current_size -= 1;
remove_index += first_ludic - 1;
}
index += 1;
}
*ludic_size = current_size;
return ludics;
}
| int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25);
free(result);
result = func0(45, &size);
assert(size == 14 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7 && result[5] == 11 && result[6] == 13 && result[7] == 17 && result[8] == 23 && result[9] == 25 && result[10] == 29 && result[11] == 37 && result[12] == 41 && result[13] == 43);
free(result);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
movslq %edi,%rdi
push %r14
mov %rdi,%r15
shl $0x2,%rdi
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rsi,0x18(%rsp)
callq 10c0 <malloc@plt>
mov %rax,0x10(%rsp)
test %r15d,%r15d
jle 14f6 <func0+0x146>
mov %rax,%rcx
lea -0x1(%r15),%eax
cmp $0x2,%eax
jbe 1512 <func0+0x162>
mov %r15d,%edx
movdqa 0xea1(%rip),%xmm1
mov %rcx,%rax
movdqa 0xea6(%rip),%xmm3
shr $0x2,%edx
movdqa 0xeab(%rip),%xmm2
shl $0x4,%rdx
add %rcx,%rdx
movdqa %xmm1,%xmm0
add $0x10,%rax
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
movups %xmm0,-0x10(%rax)
cmp %rdx,%rax
jne 141c <func0+0x6c>
mov %r15d,%eax
and $0xfffffffc,%eax
test $0x3,%r15b
je 146f <func0+0xbf>
mov 0x10(%rsp),%rcx
lea 0x1(%rax),%esi
movslq %eax,%rdx
mov %esi,(%rcx,%rdx,4)
cmp %esi,%r15d
jle 1519 <func0+0x169>
lea 0x2(%rax),%edx
movslq %esi,%rsi
mov %edx,(%rcx,%rsi,4)
cmp %edx,%r15d
jle 146f <func0+0xbf>
movslq %edx,%rdx
add $0x3,%eax
mov %eax,(%rcx,%rdx,4)
movq $0x1,0x8(%rsp)
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rax
mov 0x10(%rsp),%rcx
mov (%rcx,%rax,4),%ebx
lea (%rbx,%rax,1),%r14d
cmp %r15d,%r14d
jge 14e6 <func0+0x136>
lea -0x1(%rbx),%r12d
lea -0x2(%r15),%r9d
movslq %r14d,%rax
sub %r14d,%r9d
movslq %r12d,%rbp
lea (%rcx,%rax,4),%rdi
mov %r9d,%r13d
shl $0x2,%rbp
nopw 0x0(%rax,%rax,1)
sub $0x1,%r15d
cmp %r14d,%r15d
jle 14d8 <func0+0x128>
mov %r13d,%eax
lea 0x4(%rdi),%rsi
lea 0x4(,%rax,4),%rdx
callq 10d0 <memmove@plt>
mov %rax,%rdi
add %r12d,%r14d
sub %ebx,%r13d
add %rbp,%rdi
cmp %r15d,%r14d
jl 14b8 <func0+0x108>
addq $0x1,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp %eax,%r15d
jg 1480 <func0+0xd0>
mov 0x18(%rsp),%rax
mov %r15d,(%rax)
mov 0x10(%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %eax,%eax
jmpq 1441 <func0+0x91>
cmp $0x1,%r15d
jg 146f <func0+0xbf>
jmp 14f6 <func0+0x146>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
movsxd rdi, edi
push r14
mov r15, rdi
shl rdi, 2; size
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
mov [rsp+48h+var_48], rax
test r15d, r15d
jle loc_14EC
lea eax, [r15-1]
cmp eax, 2
jbe loc_1507
mov edx, r15d
mov rdi, [rsp+48h+var_48]
movdqa xmm1, cs:xmmword_2280
shr edx, 2
movdqa xmm3, cs:xmmword_2290
movdqa xmm2, cs:xmmword_22A0
shl rdx, 4
mov rax, rdi
add rdx, rdi
loc_141C:
movdqa xmm0, xmm1
add rax, 10h
paddd xmm1, xmm3
paddd xmm0, xmm2
movups xmmword ptr [rax-10h], xmm0
cmp rax, rdx
jnz short loc_141C
mov eax, r15d
and eax, 0FFFFFFFCh
test r15b, 3
jz short loc_1471
mov rdi, [rsp+48h+var_48]
mov esi, eax
lea ecx, [rax+1]
lea rdx, ds:0[rsi*4]
mov [rdi+rsi*4], ecx
cmp r15d, ecx
jle short loc_1471
loc_145A:
mov rdi, [rsp+48h+var_48]
lea ecx, [rax+2]
mov [rdi+rdx+4], ecx
cmp ecx, r15d
jge short loc_1471
add eax, 3
mov [rdi+rdx+8], eax
loc_1471:
mov r12d, 1
nop word ptr [rax+rax+00000000h]
loc_1480:
mov rdi, [rsp+48h+var_48]
mov r9d, [rdi+r12*4]
lea r14d, [r9+r12]
cmp r14d, r15d
jge short loc_14E3
lea r13d, [r9-1]
lea ebx, [r15-2]
movsxd rax, r14d
movsxd rbp, r13d
sub ebx, r14d
lea rcx, [rdi+rax*4]
shl rbp, 2
nop word ptr [rax+rax+00h]
loc_14B0:
sub r15d, 1
cmp r15d, r14d
jle short loc_14D2
mov eax, ebx
lea rsi, [rcx+4]; src
mov rdi, rcx; dest
lea rdx, ds:4[rax*4]; n
call _memmove
mov rcx, rax
loc_14D2:
sub ebx, r13d
add r14d, r13d
add rcx, rbp
sub ebx, 1
cmp r14d, r15d
jl short loc_14B0
loc_14E3:
add r12, 1
cmp r15d, r12d
jg short loc_1480
loc_14EC:
mov rax, [rsp+48h+var_40]
mov [rax], r15d
mov rax, [rsp+48h+var_48]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1507:
mov rax, [rsp+48h+var_48]
xor edx, edx
mov dword ptr [rax], 1
xor eax, eax
cmp r15d, 1
jnz loc_145A
jmp short loc_14EC | __m128i * func0(int a1, int *a2)
{
int v2; // r15d
__m128i si128; // xmm1
__m128i v4; // xmm3
__m128i v5; // xmm2
__m128i *v6; // rax
__m128i v7; // xmm0
unsigned int v8; // eax
long long v9; // rdx
long long v10; // r12
int v11; // r9d
int v12; // r14d
int v13; // r13d
unsigned int v14; // ebx
char *v15; // rcx
long long v16; // rbp
__m128i *v18; // [rsp+0h] [rbp-48h]
v2 = a1;
v18 = (__m128i *)malloc(4LL * a1);
if ( a1 <= 0 )
goto LABEL_16;
if ( (unsigned int)(a1 - 1) <= 2 )
{
v9 = 0LL;
v18->m128i_i32[0] = 1;
v8 = 0;
if ( a1 == 1 )
goto LABEL_16;
goto LABEL_7;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2280);
v4 = _mm_load_si128((const __m128i *)&xmmword_2290);
v5 = _mm_load_si128((const __m128i *)&xmmword_22A0);
v6 = v18;
do
{
v7 = si128;
++v6;
si128 = _mm_add_epi32(si128, v4);
v6[-1] = _mm_add_epi32(v7, v5);
}
while ( v6 != &v18[(unsigned int)a1 >> 2] );
v8 = a1 & 0x7FFFFFFC;
if ( (a1 & 3) != 0 )
{
v9 = v8;
v18->m128i_i32[v9] = v8 + 1;
if ( a1 > (int)(v8 + 1) )
{
LABEL_7:
v18->m128i_i32[v9 + 1] = v8 + 2;
if ( (int)(v8 + 2) < a1 )
v18->m128i_i32[v9 + 2] = v8 + 3;
}
}
v10 = 1LL;
do
{
v11 = v18->m128i_i32[v10];
v12 = v11 + v10;
if ( v11 + (int)v10 < v2 )
{
v13 = v11 - 1;
v14 = v2 - 2 - v12;
v15 = &v18->m128i_i8[4 * v12];
v16 = 4LL * (v11 - 1);
do
{
if ( --v2 > v12 )
v15 = (char *)memmove(v15, v15 + 4, 4LL * v14 + 4);
v12 += v13;
v15 += v16;
v14 = v14 - v13 - 1;
}
while ( v12 < v2 );
}
++v10;
}
while ( v2 > (int)v10 );
LABEL_16:
*a2 = v2;
return v18;
} | func0:
ENDBR64
PUSH R15
MOVSXD RDI,EDI
PUSH R14
MOV R15,RDI
SHL RDI,0x2
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x001010c0
MOV qword ptr [RSP],RAX
TEST R15D,R15D
JLE 0x001014ec
LEA EAX,[R15 + -0x1]
CMP EAX,0x2
JBE 0x00101507
MOV EDX,R15D
MOV RDI,qword ptr [RSP]
MOVDQA XMM1,xmmword ptr [0x00102280]
SHR EDX,0x2
MOVDQA XMM3,xmmword ptr [0x00102290]
MOVDQA XMM2,xmmword ptr [0x001022a0]
SHL RDX,0x4
MOV RAX,RDI
ADD RDX,RDI
LAB_0010141c:
MOVDQA XMM0,XMM1
ADD RAX,0x10
PADDD XMM1,XMM3
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RDX
JNZ 0x0010141c
MOV EAX,R15D
AND EAX,0xfffffffc
TEST R15B,0x3
JZ 0x00101471
MOV RDI,qword ptr [RSP]
MOV ESI,EAX
LEA ECX,[RAX + 0x1]
LEA RDX,[RSI*0x4]
MOV dword ptr [RDI + RSI*0x4],ECX
CMP R15D,ECX
JLE 0x00101471
LAB_0010145a:
MOV RDI,qword ptr [RSP]
LEA ECX,[RAX + 0x2]
MOV dword ptr [RDI + RDX*0x1 + 0x4],ECX
CMP ECX,R15D
JGE 0x00101471
ADD EAX,0x3
MOV dword ptr [RDI + RDX*0x1 + 0x8],EAX
LAB_00101471:
MOV R12D,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101480:
MOV RDI,qword ptr [RSP]
MOV R9D,dword ptr [RDI + R12*0x4]
LEA R14D,[R9 + R12*0x1]
CMP R14D,R15D
JGE 0x001014e3
LEA R13D,[R9 + -0x1]
LEA EBX,[R15 + -0x2]
MOVSXD RAX,R14D
MOVSXD RBP,R13D
SUB EBX,R14D
LEA RCX,[RDI + RAX*0x4]
SHL RBP,0x2
NOP word ptr [RAX + RAX*0x1]
LAB_001014b0:
SUB R15D,0x1
CMP R15D,R14D
JLE 0x001014d2
MOV EAX,EBX
LEA RSI,[RCX + 0x4]
MOV RDI,RCX
LEA RDX,[0x4 + RAX*0x4]
CALL 0x001010d0
MOV RCX,RAX
LAB_001014d2:
SUB EBX,R13D
ADD R14D,R13D
ADD RCX,RBP
SUB EBX,0x1
CMP R14D,R15D
JL 0x001014b0
LAB_001014e3:
ADD R12,0x1
CMP R15D,R12D
JG 0x00101480
LAB_001014ec:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],R15D
MOV RAX,qword ptr [RSP]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101507:
MOV RAX,qword ptr [RSP]
XOR EDX,EDX
MOV dword ptr [RAX],0x1
XOR EAX,EAX
CMP R15D,0x1
JNZ 0x0010145a
JMP 0x001014ec | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int * func0(uint param_1,uint *param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
uint uVar7;
int *piVar8;
int *piVar9;
int *piVar10;
ulong uVar11;
long lVar12;
int iVar13;
int iVar14;
uint uVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
uVar11 = (ulong)(int)param_1;
piVar8 = (int *)malloc(uVar11 << 2);
iVar6 = _UNK_001022ac;
iVar5 = _UNK_001022a8;
iVar4 = _UNK_001022a4;
iVar3 = _DAT_001022a0;
iVar2 = _UNK_0010229c;
iVar1 = _UNK_00102298;
iVar13 = _UNK_00102294;
iVar14 = _DAT_00102290;
if ((int)param_1 < 1) goto LAB_001014ec;
if (param_1 - 1 < 3) {
lVar12 = 0;
*piVar8 = 1;
uVar7 = 0;
if (param_1 == 1) goto LAB_001014ec;
LAB_0010145a:
*(uint *)((long)piVar8 + lVar12 + 4) = uVar7 + 2;
if ((int)(uVar7 + 2) < (int)param_1) {
*(uint *)((long)piVar8 + lVar12 + 8) = uVar7 + 3;
}
}
else {
piVar10 = piVar8;
iVar16 = _DAT_00102280;
iVar17 = _UNK_00102284;
iVar18 = _UNK_00102288;
iVar19 = _UNK_0010228c;
do {
piVar9 = piVar10 + 4;
*piVar10 = iVar16 + iVar3;
piVar10[1] = iVar17 + iVar4;
piVar10[2] = iVar18 + iVar5;
piVar10[3] = iVar19 + iVar6;
piVar10 = piVar9;
iVar16 = iVar16 + iVar14;
iVar17 = iVar17 + iVar13;
iVar18 = iVar18 + iVar1;
iVar19 = iVar19 + iVar2;
} while (piVar9 != piVar8 + (ulong)(param_1 >> 2) * 4);
uVar7 = param_1 & 0xfffffffc;
if ((uVar11 & 3) != 0) {
lVar12 = (ulong)uVar7 * 4;
piVar8[uVar7] = uVar7 + 1;
if ((int)(uVar7 + 1) < (int)param_1) goto LAB_0010145a;
}
}
lVar12 = 1;
do {
iVar14 = piVar8[lVar12] + (int)lVar12;
if (iVar14 < (int)uVar11) {
iVar13 = piVar8[lVar12] + -1;
uVar7 = ((int)uVar11 + -2) - iVar14;
piVar10 = piVar8 + iVar14;
do {
uVar15 = (int)uVar11 - 1;
uVar11 = (ulong)uVar15;
if (iVar14 < (int)uVar15) {
piVar10 = (int *)memmove(piVar10,piVar10 + 1,(ulong)uVar7 * 4 + 4);
}
iVar14 = iVar14 + iVar13;
piVar10 = piVar10 + iVar13;
uVar7 = (uVar7 - iVar13) - 1;
} while (iVar14 < (int)uVar15);
}
lVar12 = lVar12 + 1;
param_1 = (uint)uVar11;
} while ((int)lVar12 < (int)param_1);
LAB_001014ec:
*param_2 = param_1;
return piVar8;
} |
6,308 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0; i--) {
strcat(result, words[i]);
if (i > 0) {
strcat(result, " ");
}
}
return result;
}
| int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "man indian") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x70(%rbp)
mov -0x78(%rbp),%rax
lea 0xe0e(%rip),%rsi
mov %rax,%rdi
callq 10c0 <strtok@plt>
mov %rax,-0x68(%rbp)
jmp 1231 <func0+0x68>
mov -0x70(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x70(%rbp)
cltq
mov -0x68(%rbp),%rdx
mov %rdx,-0x60(%rbp,%rax,8)
lea 0xde5(%rip),%rsi
mov $0x0,%edi
callq 10c0 <strtok@plt>
mov %rax,-0x68(%rbp)
cmpq $0x0,-0x68(%rbp)
jne 1208 <func0+0x3f>
movb $0x0,0x2e01(%rip)
mov -0x70(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x6c(%rbp)
jmp 12a1 <func0+0xd8>
mov -0x6c(%rbp),%eax
cltq
mov -0x60(%rbp,%rax,8),%rax
mov %rax,%rsi
lea 0x2de2(%rip),%rdi
callq 10d0 <strcat@plt>
cmpl $0x0,-0x6c(%rbp)
jle 129d <func0+0xd4>
lea 0x2dd0(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2dab(%rip),%rax
add %rdx,%rax
movw $0x20,(%rax)
subl $0x1,-0x6c(%rbp)
cmpl $0x0,-0x6c(%rbp)
jns 124a <func0+0x81>
lea 0x2d92(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 12c2 <func0+0xf9>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_70], 0
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_68], rax
jmp short loc_1257
loc_122B:
mov eax, [rbp+var_70]
lea edx, [rax+1]
mov [rbp+var_70], edx
cdqe
mov rdx, [rbp+var_68]
mov [rbp+rax*8+src], rdx
lea rax, delim; " "
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+var_68], rax
loc_1257:
cmp [rbp+var_68], 0
jnz short loc_122B
mov cs:result_1, 0
mov eax, [rbp+var_70]
sub eax, 1
mov [rbp+var_6C], eax
jmp short loc_12B7
loc_1270:
mov eax, [rbp+var_6C]
cdqe
mov rax, [rbp+rax*8+src]
mov rsi, rax; src
lea rax, result_1
mov rdi, rax; dest
call _strcat
cmp [rbp+var_6C], 0
jle short loc_12B3
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 20h ; ' '
loc_12B3:
sub [rbp+var_6C], 1
loc_12B7:
cmp [rbp+var_6C], 0
jns short loc_1270
lea rax, result_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12D8
call ___stack_chk_fail
locret_12D8:
leave
retn | char * func0(char *a1)
{
int v1; // eax
int v3; // [rsp+10h] [rbp-70h]
long long j; // [rsp+14h] [rbp-6Ch]
char *i; // [rsp+18h] [rbp-68h]
char *src[12]; // [rsp+20h] [rbp-60h]
src[11] = (char *)__readfsqword(0x28u);
v3 = 0;
for ( i = strtok(a1, " "); i; i = strtok(0LL, " ") )
{
v1 = v3++;
src[v1] = i;
}
result_1 = 0;
for ( j = (unsigned int)(v3 - 1); (int)j >= 0; LODWORD(j) = j - 1 )
{
strcat(&result_1, src[(int)j]);
if ( (int)j > 0 )
*(_WORD *)(&result_1 + strlen(&result_1)) = 32;
}
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x70],0x0
MOV RAX,qword ptr [RBP + -0x78]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00101257
LAB_0010122b:
MOV EAX,dword ptr [RBP + -0x70]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x70],EDX
CDQE
MOV RDX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + RAX*0x8 + -0x60],RDX
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x001010e0
MOV qword ptr [RBP + -0x68],RAX
LAB_00101257:
CMP qword ptr [RBP + -0x68],0x0
JNZ 0x0010122b
MOV byte ptr [0x00104040],0x0
MOV EAX,dword ptr [RBP + -0x70]
SUB EAX,0x1
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x001012b7
LAB_00101270:
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x60]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010f0
CMP dword ptr [RBP + -0x6c],0x0
JLE 0x001012b3
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010a0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x20
LAB_001012b3:
SUB dword ptr [RBP + -0x6c],0x1
LAB_001012b7:
CMP dword ptr [RBP + -0x6c],0x0
JNS 0x00101270
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012d8
CALL 0x001010b0
LAB_001012d8:
LEAVE
RET | int1 * func0(char *param_1)
{
size_t sVar1;
long in_FS_OFFSET;
int local_78;
int local_74;
char *local_70;
int8 auStack_68 [11];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_78 = 0;
local_70 = strtok(param_1," ");
while (local_70 != (char *)0x0) {
auStack_68[local_78] = local_70;
local_70 = strtok((char *)0x0," ");
local_78 = local_78 + 1;
}
result_1[0] = 0;
while (local_74 = local_78 + -1, -1 < local_74) {
strcat(result_1,(char *)auStack_68[local_74]);
local_78 = local_74;
if (0 < local_74) {
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x20;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return result_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,309 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0; i--) {
strcat(result, words[i]);
if (i > 0) {
strcat(result, " ");
}
}
return result;
}
| int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "man indian") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xe38(%rip),%rsi
callq 10b0 <strtok@plt>
test %rax,%rax
je 1279 <func0+0xd0>
mov $0x0,%ebx
lea 0xe1e(%rip),%r12
mov %ebx,%ebp
mov %rax,(%rsp,%rbx,8)
mov %r12,%rsi
mov $0x0,%edi
callq 10b0 <strtok@plt>
mov %rbx,%rdx
add $0x1,%rbx
test %rax,%rax
jne 11e6 <func0+0x3d>
movb $0x0,0x2e34(%rip)
test %ebp,%ebp
js 1259 <func0+0xb0>
movslq %ebp,%rbp
lea (%rsp,%rbp,8),%rbp
mov %edx,%ebx
lea 0x2e20(%rip),%r12
jmp 123d <func0+0x94>
mov $0x64,%edx
lea 0xdd6(%rip),%rsi
mov %r12,%rdi
callq 1080 <__strcat_chk@plt>
sub $0x8,%rbp
sub $0x1,%ebx
mov $0x64,%edx
mov 0x0(%rbp),%rsi
mov %r12,%rdi
callq 1080 <__strcat_chk@plt>
test %ebx,%ebx
jg 1222 <func0+0x79>
mov %ebx,%eax
sub $0x1,%eax
jns 1236 <func0+0x8d>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1282 <func0+0xd9>
lea 0x2dd0(%rip),%rax
add $0x60,%rsp
pop %rbx
pop %rbp
pop %r12
retq
movb $0x0,0x2dc0(%rip)
jmp 1259 <func0+0xb0>
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rsi, unk_2004
call _strtok
test rax, rax
jz loc_127E
mov ebp, 0
lea r12, unk_2004
loc_1208:
mov ebx, ebp
mov [rsp+rbp*8+88h+var_88], rax
mov rsi, r12
mov edi, 0
call _strtok
add rbp, 1
test rax, rax
jnz short loc_1208
mov cs:result_1, 0
test ebx, ebx
js short loc_1285
movsxd rax, ebx
lea rbp, [rsp+rax*8+88h+var_88]
sub ebx, 1
lea r12, result_1
lea r13, unk_2004
jmp short loc_1254
loc_1249:
test ebx, ebx
js short loc_1285
loc_124D:
sub rbp, 8
sub ebx, 1
loc_1254:
mov edx, 64h ; 'd'
mov rsi, [rbp+0]
mov rdi, r12
call ___strcat_chk
lea eax, [rbx+1]
test eax, eax
jle short loc_1249
mov edx, 64h ; 'd'
mov rsi, r13
mov rdi, r12
call ___strcat_chk
jmp short loc_124D
loc_127E:
mov cs:result_1, 0
loc_1285:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_12A7
lea rax, result_1
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12A7:
call ___stack_chk_fail | char * func0(long long a1)
{
long long v1; // rax
long long v2; // rbp
int v3; // ebx
_QWORD *v4; // rbp
int i; // ebx
_QWORD v7[17]; // [rsp+0h] [rbp-88h] BYREF
v7[11] = __readfsqword(0x28u);
v1 = strtok(a1, &unk_2004);
if ( v1 )
{
v2 = 0LL;
do
{
v3 = v2;
v7[v2] = v1;
v1 = strtok(0LL, &unk_2004);
++v2;
}
while ( v1 );
result_1 = 0;
if ( v3 >= 0 )
{
v4 = &v7[v3];
for ( i = v3 - 1; ; --i )
{
__strcat_chk(&result_1, *v4, 100LL);
if ( i + 1 <= 0 )
{
if ( i < 0 )
return &result_1;
}
else
{
__strcat_chk(&result_1, &unk_2004, 100LL);
}
--v4;
}
}
}
else
{
result_1 = 0;
}
return &result_1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RSI,[0x102004]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010127e
MOV EBP,0x0
LEA R12,[0x102004]
LAB_00101208:
MOV EBX,EBP
MOV qword ptr [RSP + RBP*0x8],RAX
MOV RSI,R12
MOV EDI,0x0
CALL 0x001010d0
ADD RBP,0x1
TEST RAX,RAX
JNZ 0x00101208
MOV byte ptr [0x00104040],0x0
TEST EBX,EBX
JS 0x00101285
MOVSXD RAX,EBX
LEA RBP,[RSP + RAX*0x8]
SUB EBX,0x1
LEA R12,[0x104040]
LEA R13,[0x102004]
JMP 0x00101254
LAB_00101249:
TEST EBX,EBX
JS 0x00101285
LAB_0010124d:
SUB RBP,0x8
SUB EBX,0x1
LAB_00101254:
MOV EDX,0x64
MOV RSI,qword ptr [RBP]
MOV RDI,R12
CALL 0x00101090
LEA EAX,[RBX + 0x1]
TEST EAX,EAX
JLE 0x00101249
MOV EDX,0x64
MOV RSI,R13
MOV RDI,R12
CALL 0x00101090
JMP 0x0010124d
LAB_0010127e:
MOV byte ptr [0x00104040],0x0
LAB_00101285:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012a7
LEA RAX,[0x104040]
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012a7:
CALL 0x001010a0 | int1 * func0(char *param_1)
{
long lVar1;
char *pcVar2;
int iVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
int8 local_88 [11];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strtok(param_1," ");
if (pcVar2 == (char *)0x0) {
result_1[0] = 0;
}
else {
lVar1 = 0;
do {
lVar4 = lVar1;
local_88[lVar4] = pcVar2;
pcVar2 = strtok((char *)0x0," ");
lVar1 = lVar4 + 1;
} while (pcVar2 != (char *)0x0);
result_1[0] = 0;
iVar3 = (int)lVar4;
if (-1 < iVar3) {
puVar5 = local_88 + iVar3;
do {
__strcat_chk(result_1,*puVar5,100);
if (iVar3 < 1) {
if (iVar3 + -1 < 0) break;
}
else {
__strcat_chk(result_1,&DAT_00102004,100);
}
puVar5 = puVar5 + -1;
iVar3 = iVar3 + -1;
} while( true );
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return result_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,310 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0; i--) {
strcat(result, words[i]);
if (i > 0) {
strcat(result, " ");
}
}
return result;
}
| int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "man indian") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
lea 0xcc7(%rip),%rsi
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10d0 <strtok@plt>
test %rax,%rax
je 1458 <func0+0x128>
xor %r13d,%r13d
mov %rsp,%rbp
lea 0xc90(%rip),%r12
nopl 0x0(%rax)
mov %r12,%rsi
xor %edi,%edi
mov %rax,0x0(%rbp,%r13,8)
mov %rax,%r15
callq 10d0 <strtok@plt>
movslq %r13d,%rbx
add $0x1,%r13
test %rax,%rax
jne 1378 <func0+0x48>
lea 0x2ca3(%rip),%r12
movb $0x0,0x2c9c(%rip)
lea 0x0(%rbp,%rbx,8),%rbx
mov %r12,%r13
lea 0x64(%r12),%r14
jmp 13d6 <func0+0xa6>
nopl 0x0(%rax,%rax,1)
mov %r14,%rcx
mov $0x2,%edx
lea 0xc3d(%rip),%rsi
sub $0x8,%rbx
sub %rax,%rcx
callq 10b0 <__memcpy_chk@plt>
mov (%rbx),%r15
lea 0x2c63(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 13dd <func0+0xad>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x64,%edx
mov %eax,%esi
add %al,%sil
mov %r15,%rsi
sbb $0x3,%rdi
sub %r12,%rdi
add %r13,%rdi
callq 10c0 <__stpcpy_chk@plt>
mov %rax,%rdi
cmp %rbp,%rbx
jne 13b8 <func0+0x88>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1461 <func0+0x131>
add $0x68,%rsp
lea 0x2bf8(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
movb $0x0,0x2be1(%rip)
jmp 142d <func0+0xfd>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
lea rbx, unk_2004
mov rsi, rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
call _strtok
test rax, rax
jz loc_1450
xor r14d, r14d
mov r13, rsp
loc_13A0:
mov [r13+r14*8+0], rax
mov rsi, rbx
xor edi, edi
mov rbp, rax
movsxd r12, r14d
call _strtok
mov rdx, r14
add r14, 1
test rax, rax
jnz short loc_13A0
lea r12, [r13+r12*8+0]
mov cs:result_1, 0
shl rdx, 3
lea r13, result_1
mov r14, r12
lea r15, [r13+64h]
sub r14, rdx
nop word ptr [rax+rax+00h]
loc_13E8:
mov rdi, r13
call _strlen
mov edx, 64h ; 'd'
mov rsi, rbp
lea rdi, [r13+rax+0]
call ___stpcpy_chk
mov rdi, rax
cmp r12, r14
jnz short loc_1430
loc_140A:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_1460
add rsp, 68h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1430:
mov rcx, r15
mov edx, 2
mov rsi, rbx
sub r12, 8
sub rcx, rax
call ___memcpy_chk
mov rbp, [r12]
jmp short loc_13E8
loc_1450:
mov cs:result_1, 0
lea r13, result_1
jmp short loc_140A
loc_1460:
call ___stack_chk_fail | char * func0(long long a1)
{
long long v1; // rax
long long v2; // r14
long long v3; // rbp
long long v4; // r12
long long v5; // rdx
long long *v6; // r12
long long *v7; // r14
long long v8; // rax
long long v9; // rax
_QWORD v11[19]; // [rsp+0h] [rbp-98h] BYREF
v11[11] = __readfsqword(0x28u);
v1 = strtok(a1, &unk_2004);
if ( v1 )
{
v2 = 0LL;
do
{
v11[v2] = v1;
v3 = v1;
v4 = (int)v2;
v1 = strtok(0LL, &unk_2004);
v5 = v2++;
}
while ( v1 );
v6 = &v11[v4];
result_1[0] = 0;
v7 = &v6[-v5];
while ( 1 )
{
v8 = strlen(result_1);
v9 = __stpcpy_chk(&result_1[v8], v3, 100LL);
if ( v6 == v7 )
break;
--v6;
__memcpy_chk(v9, &unk_2004, 2LL, &result_1[-v9 + 100]);
v3 = *v6;
}
}
else
{
result_1[0] = 0;
}
return result_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x102004]
MOV RSI,RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101450
XOR R14D,R14D
MOV R13,RSP
LAB_001013a0:
MOV qword ptr [R13 + R14*0x8],RAX
MOV RSI,RBX
XOR EDI,EDI
MOV RBP,RAX
MOVSXD R12,R14D
CALL 0x00101110
MOV RDX,R14
ADD R14,0x1
TEST RAX,RAX
JNZ 0x001013a0
LEA R12,[R13 + R12*0x8]
MOV byte ptr [0x00104040],0x0
SHL RDX,0x3
LEA R13,[0x104040]
MOV R14,R12
LEA R15,[R13 + 0x64]
SUB R14,RDX
NOP word ptr [RAX + RAX*0x1]
LAB_001013e8:
MOV RDI,R13
CALL 0x001010b0
MOV EDX,0x64
MOV RSI,RBP
LEA RDI,[R13 + RAX*0x1]
CALL 0x00101100
MOV RDI,RAX
CMP R12,R14
JNZ 0x00101430
LAB_0010140a:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101460
ADD RSP,0x68
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101430:
MOV RCX,R15
MOV EDX,0x2
MOV RSI,RBX
SUB R12,0x8
SUB RCX,RAX
CALL 0x001010f0
MOV RBP,qword ptr [R12]
JMP 0x001013e8
LAB_00101450:
MOV byte ptr [0x00104040],0x0
LEA R13,[0x104040]
JMP 0x0010140a
LAB_00101460:
CALL 0x001010c0 | int1 * func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
int8 *puVar5;
long lVar6;
int8 *puVar7;
long in_FS_OFFSET;
int8 local_98 [11];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = strtok(param_1," ");
if (pcVar1 == (char *)0x0) {
result_1[0] = 0;
}
else {
lVar3 = 0;
do {
lVar6 = lVar3;
pcVar4 = pcVar1;
local_98[lVar6] = pcVar4;
pcVar1 = strtok((char *)0x0," ");
lVar3 = lVar6 + 1;
} while (pcVar1 != (char *)0x0);
puVar5 = local_98 + (int)lVar6;
result_1[0] = 0;
puVar7 = puVar5 + -lVar6;
while( true ) {
sVar2 = strlen(result_1);
lVar3 = __stpcpy_chk(result_1 + sVar2,pcVar4,100);
if (puVar5 == puVar7) break;
puVar5 = puVar5 + -1;
__memcpy_chk(lVar3,&DAT_00102004,2,(long)&DAT_001040a4 - lVar3);
pcVar4 = (char *)*puVar5;
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return result_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,311 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0; i--) {
strcat(result, words[i]);
if (i > 0) {
strcat(result, " ");
}
}
return result;
}
| int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "man indian") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
lea 0xcc7(%rip),%rsi
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10d0 <strtok@plt>
test %rax,%rax
je 1458 <func0+0x128>
xor %ebp,%ebp
mov %rsp,%rbx
lea 0xc91(%rip),%r13
nopl 0x0(%rax,%rax,1)
mov %r13,%rsi
xor %edi,%edi
mov %rax,(%rbx,%rbp,8)
movslq %ebp,%r12
callq 10d0 <strtok@plt>
add $0x1,%rbp
test %rax,%rax
jne 1378 <func0+0x48>
lea (%rbx,%r12,8),%r15
lea 0x2ca3(%rip),%rbp
movb $0x0,0x2c9c(%rip)
lea -0x8(%rsp),%r14
mov %rbp,%r12
lea 0x64(%rbp),%r13
jmp 13d8 <func0+0xa8>
nopw 0x0(%rax,%rax,1)
mov %r13,%rcx
mov $0x2,%edx
lea 0xc3d(%rip),%rsi
sub $0x8,%r15
sub %rax,%rcx
callq 10b0 <__memcpy_chk@plt>
cmp %r14,%r15
je 142f <func0+0xff>
lea 0x2c61(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 13df <func0+0xaf>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x64,%edx
mov %eax,%esi
add %al,%sil
mov (%r15),%rsi
sbb $0x3,%rdi
sub %rbp,%rdi
add %r12,%rdi
callq 10c0 <__stpcpy_chk@plt>
mov %rax,%rdi
cmp %rbx,%r15
jne 13b8 <func0+0x88>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1461 <func0+0x131>
add $0x68,%rsp
lea 0x2bf6(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
movb $0x0,0x2be1(%rip)
jmp 142f <func0+0xff>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
push rbp
lea rbp, delim; " "
push rbx
mov rsi, rbp; delim
sub rsp, 60h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
call _strtok
test rax, rax
jz loc_1430
xor ebx, ebx
mov r12, rsp
nop dword ptr [rax]
loc_1390:
mov rsi, rbp; delim
xor edi, edi; s
mov [r12+rbx*8], rax
call _strtok
mov rdx, rbx
add rbx, 1
test rax, rax
jnz short loc_1390
movsxd rax, edx
mov cs:result_1, 0
shl rdx, 3
lea rbx, [r12+rax*8]
lea r12, result_1
mov r13, rbx
lea r14, [r12+64h]
sub r13, rdx
xchg ax, ax
loc_13D0:
mov rdi, r12; s
call _strlen
mov rsi, [rbx]
mov edx, 64h ; 'd'
lea rdi, [r12+rax]
call ___stpcpy_chk
cmp rbx, r13
jnz short loc_1410
loc_13EE:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_1440
add rsp, 60h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1410:
mov rcx, r14
mov edx, 2
mov rsi, rbp
mov rdi, rax
sub rcx, rax
sub rbx, 8
call ___memcpy_chk
jmp short loc_13D0
loc_1430:
mov cs:result_1, 0
lea r12, result_1
jmp short loc_13EE
loc_1440:
call ___stack_chk_fail | char * func0(char *a1)
{
char *v1; // rax
long long v2; // rbx
long long v3; // rdx
_QWORD *v4; // rbx
_QWORD *v5; // r13
size_t v6; // rax
long long v7; // rax
_QWORD v9[17]; // [rsp+0h] [rbp-88h] BYREF
v9[11] = __readfsqword(0x28u);
v1 = strtok(a1, " ");
if ( v1 )
{
v2 = 0LL;
do
{
v9[v2] = v1;
v1 = strtok(0LL, " ");
v3 = v2++;
}
while ( v1 );
result_1[0] = 0;
v4 = &v9[(int)v3];
v5 = &v4[-v3];
while ( 1 )
{
v6 = strlen(result_1);
v7 = __stpcpy_chk(&result_1[v6], *v4, 100LL);
if ( v4 == v5 )
break;
--v4;
__memcpy_chk(v7, " ", 2LL, &result_1[-v7 + 100]);
}
}
else
{
result_1[0] = 0;
}
return result_1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
LEA RBP,[0x102004]
PUSH RBX
MOV RSI,RBP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101430
XOR EBX,EBX
MOV R12,RSP
NOP dword ptr [RAX]
LAB_00101390:
MOV RSI,RBP
XOR EDI,EDI
MOV qword ptr [R12 + RBX*0x8],RAX
CALL 0x00101110
MOV RDX,RBX
ADD RBX,0x1
TEST RAX,RAX
JNZ 0x00101390
MOVSXD RAX,EDX
MOV byte ptr [0x00104040],0x0
SHL RDX,0x3
LEA RBX,[R12 + RAX*0x8]
LEA R12,[0x104040]
MOV R13,RBX
LEA R14,[R12 + 0x64]
SUB R13,RDX
NOP
LAB_001013d0:
MOV RDI,R12
CALL 0x001010b0
MOV RSI,qword ptr [RBX]
MOV EDX,0x64
LEA RDI,[R12 + RAX*0x1]
CALL 0x00101100
CMP RBX,R13
JNZ 0x00101410
LAB_001013ee:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101440
ADD RSP,0x60
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101410:
MOV RCX,R14
MOV EDX,0x2
MOV RSI,RBP
MOV RDI,RAX
SUB RCX,RAX
SUB RBX,0x8
CALL 0x001010f0
JMP 0x001013d0
LAB_00101430:
MOV byte ptr [0x00104040],0x0
LEA R12,[0x104040]
JMP 0x001013ee
LAB_00101440:
CALL 0x001010c0 | int1 * func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
long lVar3;
long lVar4;
int8 *puVar5;
int8 *puVar6;
long in_FS_OFFSET;
int8 local_88 [11];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = strtok(param_1," ");
if (pcVar1 == (char *)0x0) {
result_1[0] = 0;
}
else {
lVar3 = 0;
do {
lVar4 = lVar3;
local_88[lVar4] = pcVar1;
pcVar1 = strtok((char *)0x0," ");
lVar3 = lVar4 + 1;
} while (pcVar1 != (char *)0x0);
result_1[0] = 0;
puVar5 = local_88 + (int)lVar4;
puVar6 = puVar5 + -lVar4;
while( true ) {
sVar2 = strlen(result_1);
lVar3 = __stpcpy_chk(result_1 + sVar2,*puVar5,100);
if (puVar5 == puVar6) break;
puVar5 = puVar5 + -1;
__memcpy_chk(lVar3,&DAT_00102004,2,(long)&DAT_001040a4 - lVar3);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return result_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,312 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 1193 <func0+0x4a>
movl $0x2,-0x4(%rbp)
jmp 117b <func0+0x32>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1177 <func0+0x2e>
mov $0x0,%eax
jmp 1198 <func0+0x4f>
addl $0x1,-0x4(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x4(%rbp)
jle 1163 <func0+0x1a>
mov $0x1,%eax
jmp 1198 <func0+0x4f>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jle short loc_1193
mov [rbp+var_4], 2
jmp short loc_117B
loc_1163:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, 0
jmp short loc_1198
loc_1177:
add [rbp+var_4], 1
loc_117B:
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_4], eax
jle short loc_1163
mov eax, 1
jmp short loc_1198
loc_1193:
mov eax, 0
loc_1198:
pop rbp
retn | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( a1 <= 0 )
return 0LL;
for ( i = 2; i <= a1 / 2; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JLE 0x00101193
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010117b
LAB_00101163:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,0x0
JMP 0x00101198
LAB_00101177:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117b:
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JLE 0x00101163
MOV EAX,0x1
JMP 0x00101198
LAB_00101193:
MOV EAX,0x0
LAB_00101198:
POP RBP
RET | int8 func0(int param_1)
{
int8 uVar1;
int local_c;
if (param_1 < 1) {
uVar1 = 0;
}
else {
for (local_c = 2; local_c <= param_1 / 2; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
return 0;
}
}
uVar1 = 1;
}
return uVar1;
} |
6,313 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
test %edi,%edi
jle 1184 <func0+0x3b>
mov %edi,%esi
shr $0x1f,%esi
add %edi,%esi
sar %esi
cmp $0x3,%edi
jle 118b <func0+0x42>
test $0x1,%dil
je 1191 <func0+0x48>
mov $0x2,%ecx
add $0x1,%ecx
cmp %esi,%ecx
jg 1185 <func0+0x3c>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 116f <func0+0x26>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov eax, 0
test edi, edi
jle short locret_1184
mov esi, edi
shr esi, 1Fh
add esi, edi
sar esi, 1
cmp edi, 3
jle short loc_118B
test dil, 1
jz short loc_1191
mov ecx, 2
loc_116F:
add ecx, 1
cmp ecx, esi
jg short loc_1185
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_116F
mov eax, 0
locret_1184:
retn
loc_1185:
mov eax, 1
retn
loc_118B:
mov eax, 1
retn
loc_1191:
mov eax, 0
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( ++v2 <= a1 / 2 )
{
if ( !(a1 % v2) )
return 0LL;
}
return 1LL;
}
else
{
return 0LL;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x00101184
MOV ESI,EDI
SHR ESI,0x1f
ADD ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x0010118b
TEST DIL,0x1
JZ 0x00101191
MOV ECX,0x2
LAB_0010116f:
ADD ECX,0x1
CMP ECX,ESI
JG 0x00101185
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010116f
MOV EAX,0x0
LAB_00101184:
RET
LAB_00101185:
MOV EAX,0x1
RET
LAB_0010118b:
MOV EAX,0x1
RET
LAB_00101191:
MOV EAX,0x0
RET | int8 func0(uint param_1)
{
int iVar1;
if (0 < (int)param_1) {
if ((int)param_1 < 4) {
return 1;
}
if ((param_1 & 1) == 0) {
return 0;
}
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)param_1 / 2 < iVar1) {
return 1;
}
} while ((int)param_1 % iVar1 != 0);
}
return 0;
} |
6,314 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
jle 1182 <func0+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 1178 <func0+0x38>
test $0x1,%dil
je 1182 <func0+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 1171 <func0+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <func0+0x40>
add $0x1,%ecx
cmp %esi,%ecx
jne 1168 <func0+0x28>
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1171:
add ecx, 1
cmp ecx, esi
jnz short loc_1168
loc_1178:
mov eax, 1
retn
loc_1180:
xor eax, eax
locret_1182:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
LAB_00101182:
RET | int8 func0(uint param_1)
{
int iVar1;
if (0 < (int)param_1) {
if ((int)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == ((int)param_1 >> 1) + 1) {
return 1;
}
} while ((int)param_1 % iVar1 != 0);
}
}
return 0;
} |
6,315 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
jle 1182 <func0+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 1178 <func0+0x38>
test $0x1,%dil
je 1182 <func0+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 1171 <func0+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <func0+0x40>
add $0x1,%ecx
cmp %esi,%ecx
jne 1168 <func0+0x28>
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1171:
add ecx, 1
cmp ecx, esi
jnz short loc_1168
loc_1178:
mov eax, 1
retn
loc_1180:
xor eax, eax
locret_1182:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
LAB_00101182:
RET | int8 func0(uint param_1)
{
int iVar1;
if (0 < (int)param_1) {
if ((int)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == ((int)param_1 >> 1) + 1) {
return 1;
}
} while ((int)param_1 % iVar1 != 0);
}
}
return 0;
} |
6,316 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf4d(%rip),%xmm0
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 xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2090
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 0.0174532925199433 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102090]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_00102090 * param_1;
} |
6,317 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O1 | c | func0:
endbr64
mulsd 0xed3(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
6,318 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O2 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
6,319 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O3 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
6,320 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern = (char *)malloc(strlen(pattern) + 1);
strcpy(result.pattern, pattern);
result.start = (int)(start - text);
result.end = (int)(end - text);
}
return result;
}
| int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 16 && r1.end == 19);
assert(strcmp(r2.pattern, "crazy") == 0 && r2.start == 16 && r2.end == 21);
assert(strcmp(r3.pattern, "will") == 0 && r3.start == 35 && r3.end == 39);
free(r1.pattern);
free(r2.pattern);
free(r3.pattern);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movq $0x0,-0x10(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0xffffffff,-0x4(%rbp)
mov -0x30(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1110 <strstr@plt>
mov %rax,-0x20(%rbp)
cmpq $0x0,-0x20(%rbp)
je 12ad <func0+0xa4>
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov -0x20(%rbp),%rdx
add %rdx,%rax
mov %rax,-0x18(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
add $0x1,%rax
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov -0x30(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10c0 <strcpy@plt>
mov -0x20(%rbp),%rax
sub -0x28(%rbp),%rax
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
sub -0x28(%rbp),%rax
mov %eax,-0x4(%rbp)
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+haystack], rdi
mov [rbp+needle], rsi
mov [rbp+dest], 0
mov dword ptr [rbp+var_8], 0FFFFFFFFh
mov dword ptr [rbp+var_8+4], 0FFFFFFFFh
mov rdx, [rbp+needle]
mov rax, [rbp+haystack]
mov rsi, rdx; needle
mov rdi, rax; haystack
call _strstr
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_12AD
mov rax, [rbp+needle]
mov rdi, rax; s
call _strlen
mov rdx, [rbp+var_20]
add rax, rdx
mov [rbp+var_18], rax
mov rax, [rbp+needle]
mov rdi, rax; s
call _strlen
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
mov rax, [rbp+dest]
mov rdx, [rbp+needle]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+var_20]
sub rax, [rbp+haystack]
mov dword ptr [rbp+var_8], eax
mov rax, [rbp+var_18]
sub rax, [rbp+haystack]
mov dword ptr [rbp+var_8+4], eax
loc_12AD:
mov rax, [rbp+dest]
mov rdx, [rbp+var_8]
leave
retn | char * func0(const char *a1, const char *a2)
{
size_t v2; // rax
char *dest; // [rsp+20h] [rbp-10h]
dest = 0LL;
if ( strstr(a1, a2) )
{
strlen(a2);
v2 = strlen(a2);
dest = (char *)malloc(v2 + 1);
strcpy(dest, a2);
}
return dest;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
MOV RDX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001012ad
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010d0
ADD RAX,0x1
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010c0
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
LAB_001012ad:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(char *param_1,char *param_2)
{
int auVar1 [16];
char *pcVar2;
size_t sVar3;
size_t sVar4;
int8 local_18;
int4 local_10;
int4 uStack_c;
local_18 = (char *)0x0;
local_10 = -1;
uStack_c = -1;
pcVar2 = strstr(param_1,param_2);
if (pcVar2 != (char *)0x0) {
sVar3 = strlen(param_2);
sVar4 = strlen(param_2);
local_18 = (char *)malloc(sVar4 + 1);
strcpy(local_18,param_2);
local_10 = (int)pcVar2 - (int)param_1;
uStack_c = ((int)sVar3 + (int)pcVar2) - (int)param_1;
}
auVar1._8_4_ = local_10;
auVar1._0_8_ = local_18;
auVar1._12_4_ = uStack_c;
return auVar1;
} |
6,321 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern = (char *)malloc(strlen(pattern) + 1);
strcpy(result.pattern, pattern);
result.start = (int)(start - text);
result.end = (int)(end - text);
}
return result;
}
| int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 16 && r1.end == 19);
assert(strcmp(r2.pattern, "crazy") == 0 && r2.start == 16 && r2.end == 21);
assert(strcmp(r3.pattern, "will") == 0 && r3.start == 35 && r3.end == 39);
free(r1.pattern);
free(r2.pattern);
free(r3.pattern);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r13
mov %rsi,%r14
callq 10d0 <strstr@plt>
mov %rax,%rbx
test %rax,%rax
je 123a <func0+0x71>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r14,%rdi
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
lea -0x1(%rcx),%rbp
callq 10c0 <malloc@plt>
mov %rax,%r12
mov %r14,%rsi
mov %rax,%rdi
callq 10a0 <strcpy@plt>
mov %ebx,%eax
sub %r13d,%eax
lea (%rbx,%rbp,1),%rdx
sub %r13d,%edx
mov %r12,%rbx
shl $0x20,%rdx
mov %eax,%eax
or %rax,%rdx
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0xffffffff,%edx
mov $0xffffffff,%eax
jmp 1225 <func0+0x5c>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r14, rsi
call _strstr
mov rbp, rax
test rax, rax
jz short loc_126F
mov rdi, r14
call _strlen
mov rbx, rax
lea rdi, [rax+1]
call _malloc
mov r13, rax
mov rsi, r14
mov rdi, rax
call _strcpy
mov edx, ebp
sub edx, r12d
lea rax, [rbp+rbx+0]
sub eax, r12d
mov rbp, r13
loc_125A:
shl rax, 20h
mov edx, edx
or rdx, rax
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_126F:
mov eax, 0FFFFFFFFh
mov edx, 0FFFFFFFFh
jmp short loc_125A | long long func0(long long a1, long long a2)
{
long long v2; // rbp
long long v3; // rbx
long long v4; // r13
v2 = strstr();
if ( v2 )
{
v3 = strlen(a2);
v4 = malloc(v3 + 1);
strcpy(v4, a2);
return v4;
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R14,RSI
CALL 0x00101110
MOV RBP,RAX
TEST RAX,RAX
JZ 0x0010126f
MOV RDI,R14
CALL 0x001010d0
MOV RBX,RAX
LEA RDI,[RAX + 0x1]
CALL 0x00101100
MOV R13,RAX
MOV RSI,R14
MOV RDI,RAX
CALL 0x001010c0
MOV EDX,EBP
SUB EDX,R12D
LEA RAX,[RBP + RBX*0x1]
SUB EAX,R12D
MOV RBP,R13
LAB_0010125a:
SHL RAX,0x20
MOV EDX,EDX
OR RDX,RAX
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010126f:
MOV EAX,0xffffffff
MOV EDX,0xffffffff
JMP 0x0010125a | int1 [16] func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
char *__dest;
ulong uVar3;
uint uVar4;
int1 auVar5 [16];
pcVar1 = strstr(param_1,param_2);
if (pcVar1 == (char *)0x0) {
uVar3 = 0xffffffff;
uVar4 = 0xffffffff;
__dest = (char *)0x0;
}
else {
sVar2 = strlen(param_2);
__dest = (char *)malloc(sVar2 + 1);
strcpy(__dest,param_2);
uVar4 = (int)pcVar1 - (int)param_1;
uVar3 = (ulong)(uint)(((int)pcVar1 + (int)sVar2) - (int)param_1);
}
auVar5._8_8_ = (ulong)uVar4 | uVar3 << 0x20;
auVar5._0_8_ = __dest;
return auVar5;
} |
6,322 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern = (char *)malloc(strlen(pattern) + 1);
strcpy(result.pattern, pattern);
result.start = (int)(start - text);
result.end = (int)(end - text);
}
return result;
}
| int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 16 && r1.end == 19);
assert(strcmp(r2.pattern, "crazy") == 0 && r2.start == 16 && r2.end == 21);
assert(strcmp(r3.pattern, "will") == 0 && r3.start == 35 && r3.end == 39);
free(r1.pattern);
free(r2.pattern);
free(r3.pattern);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
callq 10f0 <strstr@plt>
mov %rax,%r12
test %rax,%rax
je 13c0 <func0+0x70>
mov %r13,%rdi
callq 10b0 <strlen@plt>
lea 0x1(%rax),%r14
mov %rax,%rbx
mov %r14,%rdi
callq 10e0 <malloc@plt>
mov %r14,%rdx
mov %r13,%rsi
mov %rax,%rdi
callq 10d0 <memcpy@plt>
lea (%r12,%rbx,1),%rdx
mov %rax,%rcx
mov %r12d,%eax
sub %ebp,%edx
sub %ebp,%eax
mov %rcx,%r12
shl $0x20,%rdx
pop %rbx
pop %rbp
or %rax,%rdx
mov %r12,%rax
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%edx
mov $0xffffffff,%eax
jmp 13a5 <func0+0x55>
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
push rbp
mov rbp, rdi
push rbx
call _strstr
mov r12, rax
test rax, rax
jz short loc_13E0
mov rdi, r13
call _strlen
lea r14, [rax+1]
mov rbx, rax
mov rdi, r14
call _malloc
mov rdx, r14
mov rsi, r13
mov rdi, rax
call _memcpy
mov edx, r12d
mov rcx, rax
lea rax, [r12+rbx]
sub edx, ebp
sub eax, ebp
mov r12, rcx
loc_13C5:
shl rax, 20h
pop rbx
pop rbp
or rdx, rax
mov rax, r12
pop r12
pop r13
pop r14
retn
loc_13E0:
mov eax, 0FFFFFFFFh
mov edx, 0FFFFFFFFh
jmp short loc_13C5 | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // r14
long long v4; // rax
v2 = strstr();
if ( v2 )
{
v3 = strlen(a2) + 1;
v4 = malloc(v3);
return memcpy(v4, a2, v3);
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101110
MOV R12,RAX
TEST RAX,RAX
JZ 0x001013e0
MOV RDI,R13
CALL 0x001010c0
LEA R14,[RAX + 0x1]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00101100
MOV RDX,R14
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010f0
MOV EDX,R12D
MOV RCX,RAX
LEA RAX,[R12 + RBX*0x1]
SUB EDX,EBP
SUB EAX,EBP
MOV R12,RCX
LAB_001013c5:
SHL RAX,0x20
POP RBX
POP RBP
OR RDX,RAX
MOV RAX,R12
POP R12
POP R13
POP R14
RET
LAB_001013e0:
MOV EAX,0xffffffff
MOV EDX,0xffffffff
JMP 0x001013c5 | int1 [16] func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
void *pvVar3;
ulong uVar4;
ulong uVar5;
int1 auVar6 [16];
pcVar1 = strstr(param_1,param_2);
if (pcVar1 == (char *)0x0) {
uVar4 = 0xffffffff;
uVar5 = 0xffffffff;
pvVar3 = (void *)0x0;
}
else {
sVar2 = strlen(param_2);
pvVar3 = malloc(sVar2 + 1);
pvVar3 = memcpy(pvVar3,param_2,sVar2 + 1);
uVar5 = (ulong)(uint)((int)pcVar1 - (int)param_1);
uVar4 = (ulong)(uint)(((int)pcVar1 + (int)sVar2) - (int)param_1);
}
auVar6._8_8_ = uVar5 | uVar4 << 0x20;
auVar6._0_8_ = pvVar3;
return auVar6;
} |
6,323 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern = (char *)malloc(strlen(pattern) + 1);
strcpy(result.pattern, pattern);
result.start = (int)(start - text);
result.end = (int)(end - text);
}
return result;
}
| int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 16 && r1.end == 19);
assert(strcmp(r2.pattern, "crazy") == 0 && r2.start == 16 && r2.end == 21);
assert(strcmp(r3.pattern, "will") == 0 && r3.start == 35 && r3.end == 39);
free(r1.pattern);
free(r2.pattern);
free(r3.pattern);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
callq 10f0 <strstr@plt>
mov %rax,%r12
test %rax,%rax
je 13c0 <func0+0x70>
mov %r13,%rdi
callq 10b0 <strlen@plt>
lea 0x1(%rax),%r14
mov %rax,%rbx
mov %r14,%rdi
callq 10e0 <malloc@plt>
mov %r14,%rdx
mov %r13,%rsi
mov %rax,%rdi
callq 10d0 <memcpy@plt>
lea (%r12,%rbx,1),%rdx
mov %rax,%rcx
mov %r12d,%eax
sub %ebp,%edx
sub %ebp,%eax
mov %rcx,%r12
shl $0x20,%rdx
pop %rbx
pop %rbp
or %rax,%rdx
mov %r12,%rax
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%edx
mov $0xffffffff,%eax
jmp 13a5 <func0+0x55>
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
call _strstr
mov rbp, rax
test rax, rax
jz short loc_13E0
mov rdi, r13; s
call _strlen
lea r14, [rax+1]
mov rbx, rax
mov rdi, r14; size
call _malloc
mov rdx, r14
mov rcx, r14
mov rsi, r13
mov rdi, rax
call ___memcpy_chk
mov edx, ebp
mov rdi, rax
lea rax, [rbp+rbx+0]
sub edx, r12d
sub eax, r12d
mov rbp, rdi
loc_13CA:
shl rax, 20h
pop rbx
or rdx, rax
mov rax, rbp
pop rbp
pop r12
pop r13
pop r14
retn
loc_13E0:
mov eax, 0FFFFFFFFh
mov edx, 0FFFFFFFFh
jmp short loc_13CA | long long func0(const char *a1, const char *a2)
{
char *v2; // rbp
size_t v3; // r14
void *v4; // rax
v2 = strstr(a1, a2);
if ( v2 )
{
v3 = strlen(a2) + 1;
v4 = malloc(v3);
return __memcpy_chk(v4, a2, v3, v3);
}
return (long long)v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
CALL 0x00101110
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001013e0
MOV RDI,R13
CALL 0x001010c0
LEA R14,[RAX + 0x1]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00101100
MOV RDX,R14
MOV RCX,R14
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010f0
MOV EDX,EBP
MOV RDI,RAX
LEA RAX,[RBP + RBX*0x1]
SUB EDX,R12D
SUB EAX,R12D
MOV RBP,RDI
LAB_001013ca:
SHL RAX,0x20
POP RBX
OR RDX,RAX
MOV RAX,RBP
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013e0:
MOV EAX,0xffffffff
MOV EDX,0xffffffff
JMP 0x001013ca | int [16] func0(char *param_1,char *param_2)
{
size_t __size;
char *pcVar1;
size_t sVar2;
void *pvVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
int auVar7 [16];
pcVar1 = strstr(param_1,param_2);
if (pcVar1 == (char *)0x0) {
uVar5 = 0xffffffff;
uVar6 = 0xffffffff;
uVar4 = 0;
}
else {
sVar2 = strlen(param_2);
__size = sVar2 + 1;
pvVar3 = malloc(__size);
uVar4 = __memcpy_chk(pvVar3,param_2,__size,__size);
uVar6 = (ulong)(uint)((int)pcVar1 - (int)param_1);
uVar5 = (ulong)(uint)(((int)pcVar1 + (int)sVar2) - (int)param_1);
}
auVar7._8_8_ = uVar6 | uVar5 << 0x20;
auVar7._0_8_ = uVar4;
return auVar7;
} |
6,324 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
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 %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
mov %rsp,%rcx
mov %rcx,%r15
mov -0x64(%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 12af <func0+0x126>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1298 <func0+0x10f>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12d9 <func0+0x150>
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)
mov -0x40(%rbp),%rax
movl $0x1,(%rax)
movl $0x1,-0x54(%rbp)
jmpq 13c9 <func0+0x240>
mov %rcx,%r8
shr $0x2,%r8
mov -0x54(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x54(%rbp),%eax
lea -0x1(%rax),%esi
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
movslq %esi,%rsi
movslq %edx,%rdx
imul %r8,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%esi
mov -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
mov %esi,(%rax,%rdx,4)
movl $0x1,-0x58(%rbp)
jmp 13bd <func0+0x234>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x54(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x58(%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),%edx
mov %rcx,%r8
shr $0x2,%r8
mov -0x58(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rdi
mov -0x54(%rbp),%esi
movslq %esi,%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 -0x54(%rbp),%eax
jle 134a <func0+0x1c1>
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 1302 <func0+0x179>
shr $0x2,%rcx
mov -0x40(%rbp),%rax
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov %r15,%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 1401 <func0+0x278>
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, 48h
mov [rbp+var_44], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov r11, rax
mov eax, [rbp+var_44]
lea edi, [rax+1]
mov eax, [rbp+var_44]
lea r8d, [rax+1]
movsxd rax, edi
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, edi
lea rsi, ds:0[rax*4]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, edi
mov rcx, rax
mov ebx, 0
movsxd rax, r8d
mov rax, rax
mov edx, 0
mov r10, rbx
imul r10, rax
mov r9, rdx
imul r9, rcx
add r9, r10
mul rcx
lea rcx, [r9+rdx]
mov rdx, rcx
movsxd rax, edi
mov rcx, rax
mov ebx, 0
movsxd rax, r8d
mov rax, rax
mov edx, 0
mov r10, rbx
imul r10, rax
mov r9, rdx
imul r9, rcx
add r9, r10
mul rcx
lea rcx, [r9+rdx]
mov rdx, rcx
movsxd rdx, edi
movsxd rax, r8d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov ebx, 10h
mov edx, 0
div rbx
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_127D:
cmp rsp, rdx
jz short loc_1294
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_127D
loc_1294:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12BE
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12BE:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov dword ptr [rax], 1
mov [rbp+var_38], 1
jmp loc_13AD
loc_12E7:
mov r8, rsi
shr r8, 2
mov eax, [rbp+var_38]
lea edx, [rax-1]
mov eax, [rbp+var_38]
lea ecx, [rax-1]
mov rdi, rsi
shr rdi, 2
mov rax, [rbp+var_20]
movsxd rcx, ecx
movsxd rdx, edx
imul rdx, r8
add rdx, rcx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, rdi
mov [rax+rdx*4], ecx
mov [rbp+var_34], 1
jmp short loc_13A1
loc_132F:
mov rdi, rsi
shr rdi, 2
mov eax, [rbp+var_38]
lea edx, [rax-1]
mov eax, [rbp+var_34]
lea ecx, [rax-1]
mov rax, [rbp+var_20]
movsxd rcx, ecx
movsxd rdx, edx
imul rdx, rdi
add rdx, rcx
mov ecx, [rax+rdx*4]
mov r8, rsi
shr r8, 2
mov eax, [rbp+var_34]
lea edx, [rax-1]
mov rax, [rbp+var_20]
movsxd rdi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov eax, [rax+rdx*4]
mov r8, rsi
shr r8, 2
add ecx, 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], ecx
add [rbp+var_34], 1
loc_13A1:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_38]
jle short loc_132F
add [rbp+var_38], 1
loc_13AD:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_44]
jle loc_12E7
shr rsi, 2
mov rcx, rsi
mov rax, [rbp+var_20]
mov edx, [rbp+var_44]
movsxd rdx, edx
imul rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, r11
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_13E8
call ___stack_chk_fail
loc_13E8:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
int v1; // edi
unsigned long long v2; // rsi
unsigned long long v3; // rax
void *v4; // rsp
_DWORD v6[3]; // [rsp+8h] [rbp-50h] BYREF
int v7; // [rsp+14h] [rbp-44h]
int i; // [rsp+20h] [rbp-38h]
int j; // [rsp+24h] [rbp-34h]
long long v10; // [rsp+28h] [rbp-30h]
long long v11; // [rsp+30h] [rbp-28h]
_DWORD *v12; // [rsp+38h] [rbp-20h]
unsigned long long v13; // [rsp+40h] [rbp-18h]
v7 = a1;
v13 = __readfsqword(0x28u);
v1 = a1 + 1;
v10 = v1 - 1LL;
v2 = 4LL * v1;
v11 = v7 + 1 - 1LL;
v3 = 16 * ((4 * v1 * (long long)(v7 + 1) + 15) / 0x10uLL);
while ( v6 != (_DWORD *)((char *)v6 - (v3 & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = alloca(v3 & 0xFFF);
if ( (v3 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v6[-2] + (v3 & 0xFFF)) = *(_QWORD *)((char *)&v6[-2] + (v3 & 0xFFF));
v12 = v6;
v6[0] = 1;
for ( i = 1; i <= v7; ++i )
{
v12[(v2 >> 2) * i] = v12[i - 1 + (v2 >> 2) * (i - 1)];
for ( j = 1; j <= i; ++j )
v12[j + (v2 >> 2) * i] = v12[j - 1 + (v2 >> 2) * i] + v12[j - 1 + (v2 >> 2) * (i - 1)];
}
return (unsigned int)v12[(v2 >> 2) * v7];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV R11,RAX
MOV EAX,dword ptr [RBP + -0x44]
LEA EDI,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x44]
LEA R8D,[RAX + 0x1]
MOVSXD RAX,EDI
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,EDI
LEA RSI,[RAX*0x4]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,EDI
MOV RCX,RAX
MOV EBX,0x0
MOVSXD RAX,R8D
MOV RAX,RAX
MOV EDX,0x0
MOV R10,RBX
IMUL R10,RAX
MOV R9,RDX
IMUL R9,RCX
ADD R9,R10
MUL RCX
LEA RCX,[R9 + RDX*0x1]
MOV RDX,RCX
MOVSXD RAX,EDI
MOV RCX,RAX
MOV EBX,0x0
MOVSXD RAX,R8D
MOV RAX,RAX
MOV EDX,0x0
MOV R10,RBX
IMUL R10,RAX
MOV R9,RDX
IMUL R9,RCX
ADD R9,R10
MUL RCX
LEA RCX,[R9 + RDX*0x1]
MOV RDX,RCX
MOVSXD RDX,EDI
MOVSXD RAX,R8D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EBX,0x10
MOV EDX,0x0
DIV RBX
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_0010127d:
CMP RSP,RDX
JZ 0x00101294
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x0010127d
LAB_00101294:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012be
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012be:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x1
MOV dword ptr [RBP + -0x38],0x1
JMP 0x001013ad
LAB_001012e7:
MOV R8,RSI
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x38]
LEA ECX,[RAX + -0x1]
MOV RDI,RSI
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RCX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,RDI
MOV dword ptr [RAX + RDX*0x4],ECX
MOV dword ptr [RBP + -0x34],0x1
JMP 0x001013a1
LAB_0010132f:
MOV RDI,RSI
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x34]
LEA ECX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RCX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV R8,RSI
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV R8,RSI
SHR R8,0x2
ADD ECX,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],ECX
ADD dword ptr [RBP + -0x34],0x1
LAB_001013a1:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x38]
JLE 0x0010132f
ADD dword ptr [RBP + -0x38],0x1
LAB_001013ad:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x001012e7
SHR RSI,0x2
MOV RCX,RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
IMUL RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,R11
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013e8
CALL 0x00101080
LAB_001013e8:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int4 func0(int param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_58 [12];
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_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = param_1 + 1;
local_38 = (long)iVar1 + -1;
uVar3 = (ulong)iVar1;
local_30 = (long)(param_1 + 1) + -1;
uVar4 = (((long)(param_1 + 1) * (long)iVar1 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar5 = auStack_58; puVar5 != auStack_58 + -(uVar4 & 0xfffffffffffff000);
puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
lVar2 = -(ulong)((uint)uVar4 & 0xfff);
if ((uVar4 & 0xfff) != 0) {
*(int8 *)(puVar5 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar2) =
*(int8 *)(puVar5 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar2);
}
*(int4 *)(puVar5 + lVar2) = 1;
for (local_40 = 1; local_40 <= local_4c; local_40 = local_40 + 1) {
*(int4 *)(puVar5 + (long)local_40 * (uVar3 & 0x3fffffffffffffff) * 4 + lVar2) =
*(int4 *)
(puVar5 + ((long)(local_40 + -1) * (uVar3 & 0x3fffffffffffffff) + (long)(local_40 + -1)) *
4 + lVar2);
for (local_3c = 1; local_3c <= local_40; local_3c = local_3c + 1) {
*(int *)(puVar5 + ((long)local_40 * (uVar3 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar2
) = *(int *)(puVar5 + ((long)(local_40 + -1) * (uVar3 & 0x3fffffffffffffff) +
(long)(local_3c + -1)) * 4 + lVar2) +
*(int *)(puVar5 + ((long)local_40 * (uVar3 & 0x3fffffffffffffff) +
(long)(local_3c + -1)) * 4 + lVar2);
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = puVar5 + lVar2;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar5 + (long)local_4c * (uVar3 & 0x3fffffffffffffff) * 4 + lVar2);
} |
6,325 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %edi,%eax
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
add $0x1,%eax
cltq
lea 0x0(,%rax,4),%rbx
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 11f8 <func0+0x6f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11e1 <func0+0x58>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 120e <func0+0x85>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r15
mov %r15,%rax
shr $0x2,%rax
and $0xfffffffffffffffc,%r15
mov %r15,%r11
mov %rbx,%r10
shr $0x2,%r10
movl $0x1,0x0(,%rax,4)
mov -0x44(%rbp),%eax
test %eax,%eax
jle 12ac <func0+0x123>
lea (%r15,%rbx,1),%r9
lea 0x4(%rbx),%r13
lea (%r15,%r13,1),%rsi
lea -0x1(%rax),%r12d
add $0x2,%r12
mov $0x1,%edi
mov $0x0,%r8d
lea 0x1(%r10),%r14
jmp 1272 <func0+0xe9>
add $0x1,%r8
add $0x1,%rdi
add %rbx,%r9
add %r13,%rsi
cmp %r12,%rdi
je 12ac <func0+0x123>
movslq %r8d,%rax
imul %r14,%rax
mov (%r11,%rax,4),%edx
movslq %edi,%rax
imul %r10,%rax
mov %edx,(%r11,%rax,4)
test %edi,%edi
jle 125f <func0+0xd6>
mov %r8,%rcx
sub %rdi,%rcx
imul %r10,%rcx
mov %r9,%rax
mov (%rax),%edx
add (%rax,%rcx,4),%edx
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rsi,%rax
jne 1299 <func0+0x110>
jmp 125f <func0+0xd6>
movslq -0x44(%rbp),%rax
imul %rax,%r10
mov (%r15,%r10,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 12d6 <func0+0x14d>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13d, edi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rbx, 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_11DC:
cmp rsp, rdx
jz short loc_11F3
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11DC
loc_11F3:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1209
or [rsp+rax+40h+var_48], 0
loc_1209:
lea r10, [rsp+40h+var_3D]
mov rax, r10
shr rax, 2
and r10, 0FFFFFFFFFFFFFFFCh
mov r11, rbx
shr r11, 2
mov ds:dword_0[rax*4], 1
test r13d, r13d
jle short loc_129A
lea r9, [r10+rbx]
lea r12, [rbx+4]
lea rsi, [r10+r12]
lea r15d, [r13+1]
mov edi, 1
mov r8d, 0
lea r14, [r11+1]
loc_124F:
movsxd rax, r8d
imul rax, r14
mov edx, [r10+rax*4]
movsxd rax, edi
imul rax, r11
mov [r10+rax*4], edx
test edi, edi
jle short loc_1287
mov rcx, r8
sub rcx, rdi
imul rcx, r11
mov rax, r9
loc_1276:
mov edx, [rax]
add edx, [rax+rcx*4]
mov [rax+4], edx
add rax, 4
cmp rax, rsi
jnz short loc_1276
loc_1287:
add r8, 1
add rdi, 1
add r9, rbx
add rsi, r12
cmp rdi, r15
jnz short loc_124F
loc_129A:
movsxd r13, r13d
imul r13, r11
mov eax, [r10+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_12C3
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12C3:
call ___stack_chk_fail | long long func0(int a1)
{
long long v2; // rax
unsigned long long v3; // rbx
long long v4; // rax
__int16 v5; // cx
signed long long v6; // rax
void *v7; // rsp
unsigned long long v8; // r11
_DWORD *v9; // r9
_DWORD *v10; // rsi
long long v11; // r15
long long v12; // rdi
long long v13; // r8
_DWORD *v14; // rax
_DWORD v17[2]; // [rsp+8h] [rbp-40h] BYREF
unsigned long long v18; // [rsp+10h] [rbp-38h]
v18 = __readfsqword(0x28u);
v2 = a1 + 1;
v3 = 4 * v2;
v4 = 4 * v2 * v2 + 15;
v5 = v4 & 0xFFF0;
while ( v17 != (_DWORD *)((char *)v17 - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v6 = v4 & 0xFF0;
v7 = alloca(v6);
if ( (v5 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v17[-2] + v6) = *(_QWORD *)((char *)&v17[-2] + v6);
v8 = v3 >> 2;
v17[0] = 1;
if ( a1 > 0 )
{
v9 = &v17[v3 / 4];
v10 = &v17[v3 / 4 + 1];
v11 = (unsigned int)(a1 + 1);
v12 = 1LL;
v13 = 0LL;
do
{
v17[v8 * (int)v12] = v17[(v8 + 1) * (int)v13];
if ( (int)v12 > 0 )
{
v14 = v9;
do
{
v14[1] = v14[v8 * (v13 - v12)] + *v14;
++v14;
}
while ( v14 != v10 );
}
++v13;
++v12;
v9 = (_DWORD *)((char *)v9 + v3);
v10 = (_DWORD *)((char *)v10 + v3 + 4);
}
while ( v12 != v11 );
}
return (unsigned int)v17[v8 * a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RBX,[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_001011dc:
CMP RSP,RDX
JZ 0x001011f3
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011dc
LAB_001011f3:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101209
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101209:
LEA R10,[RSP + 0x3]
MOV RAX,R10
SHR RAX,0x2
AND R10,-0x4
MOV R11,RBX
SHR R11,0x2
MOV dword ptr [RAX*0x4],0x1
TEST R13D,R13D
JLE 0x0010129a
LEA R9,[R10 + RBX*0x1]
LEA R12,[RBX + 0x4]
LEA RSI,[R10 + R12*0x1]
LEA R15D,[R13 + 0x1]
MOV EDI,0x1
MOV R8D,0x0
LEA R14,[R11 + 0x1]
LAB_0010124f:
MOVSXD RAX,R8D
IMUL RAX,R14
MOV EDX,dword ptr [R10 + RAX*0x4]
MOVSXD RAX,EDI
IMUL RAX,R11
MOV dword ptr [R10 + RAX*0x4],EDX
TEST EDI,EDI
JLE 0x00101287
MOV RCX,R8
SUB RCX,RDI
IMUL RCX,R11
MOV RAX,R9
LAB_00101276:
MOV EDX,dword ptr [RAX]
ADD EDX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RAX + 0x4],EDX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101276
LAB_00101287:
ADD R8,0x1
ADD RDI,0x1
ADD R9,RBX
ADD RSI,R12
CMP RDI,R15
JNZ 0x0010124f
LAB_0010129a:
MOVSXD R13,R13D
IMUL R13,R11
MOV EAX,dword ptr [R10 + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012c3
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001012c3:
CALL 0x00101080 | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *piVar3;
int1 *puVar4;
int *piVar5;
ulong uVar7;
long lVar8;
ulong uVar9;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int *piVar6;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = (ulong)(param_1 + 1);
uVar9 = uVar2 * uVar2 * 4 + 0xf;
for (puVar4 = auStack_48; puVar4 != auStack_48 + -(uVar9 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar1 = -uVar9;
piVar5 = (int *)(puVar4 + lVar1);
piVar6 = (int *)(puVar4 + lVar1);
if (uVar9 != 0) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
uVar9 = uVar2 & 0x3fffffffffffffff;
*(int4 *)(puVar4 + lVar1) = 1;
if (0 < param_1) {
uVar7 = 1;
lVar8 = 0;
do {
piVar6 = piVar6 + uVar2;
piVar5 = piVar5 + uVar2 + 1;
*(int4 *)(puVar4 + (long)(int)uVar7 * uVar9 * 4 + lVar1) =
*(int4 *)(puVar4 + (long)(int)lVar8 * (uVar9 + 1) * 4 + lVar1);
if (0 < (int)uVar7) {
piVar3 = piVar6;
do {
piVar3[1] = *piVar3 + piVar3[(lVar8 - uVar7) * uVar9];
piVar3 = piVar3 + 1;
} while (piVar3 != piVar5);
}
lVar8 = lVar8 + 1;
uVar7 = uVar7 + 1;
} while (uVar7 != param_1 + 1);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar4 + (long)param_1 * uVar9 * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar4 + lVar1 + -8) = main;
__stack_chk_fail();
} |
6,326 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
movslq %edi,%r14
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%r14),%eax
mov %rsp,%rbx
cltq
lea 0x0(,%rax,4),%r12
imul %rax,%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 1451 <func0+0x71>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 143c <func0+0x5c>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1526 <func0+0x146>
lea 0x3(%rsp),%rdi
mov %r12,%r11
mov %rdi,%rax
shr $0x2,%r11
and $0xfffffffffffffffc,%rdi
shr $0x2,%rax
movl $0x1,0x0(,%rax,4)
test %r14d,%r14d
jle 1500 <func0+0x120>
lea -0x1(%r14),%ebx
xor %r9d,%r9d
lea 0x1(%r11),%r15
mov $0x1,%edx
lea 0x4(%r12),%r13
add $0x2,%rbx
mov $0x1,%r8d
lea (%rdi,%r13,1),%r10
mov %r10,%rsi
movslq %r8d,%rax
mov %r9,%rcx
imul %r11,%rax
sub %r8,%rcx
imul %r11,%rcx
mov %edx,(%rdi,%rax,4)
mov %r10,%rax
jmp 14d4 <func0+0xf4>
nopl 0x0(%rax)
add $0x4,%rax
add -0x4(%rax,%rcx,4),%edx
mov %edx,(%rax)
cmp %rsi,%rax
jne 14d0 <func0+0xf0>
add $0x1,%r8
add $0x1,%r9
add %r12,%r10
add %r13,%rsi
cmp %rbx,%r8
je 1500 <func0+0x120>
movslq %r9d,%rax
imul %r15,%rax
mov (%rdi,%rax,4),%edx
jmp 14b0 <func0+0xd0>
xchg %ax,%ax
imul %r14,%r11
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%rdi,%r11,4),%eax
jne 1531 <func0+0x151>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1463 <func0+0x83>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
movsxd r14, edi
push r13
push r12
push rbx
lea ebx, [r14+1]
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, ebx
mov rcx, rsp
lea r12, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12AF
loc_129A:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_129A
loc_12AF:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1386
loc_12C1:
lea r11, [rsp+1040h+var_103D]
mov r10, r12
mov rax, r11
shr r10, 2
and r11, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov ds:dword_0[rax*4], 1
test r14d, r14d
jle short loc_1360
lea r13, [r12+4]
mov ebx, ebx
mov edi, 1
xor r8d, r8d
lea r9, [r11+r13]
mov edx, 1
lea r15, [r10+1]
mov rsi, r9
nop word ptr [rax+rax+00000000h]
loc_1310:
movsxd rax, edi
mov rcx, r8
imul rax, r10
sub rcx, rdi
imul rcx, r10
mov [r11+rax*4], edx
mov rax, r9
jmp short loc_1334
loc_1330:
add rax, 4
loc_1334:
add edx, [rax+rcx*4-4]
mov [rax], edx
cmp rax, rsi
jnz short loc_1330
add rdi, 1
add r8, 1
add r9, r12
add rsi, r13
cmp rdi, rbx
jz short loc_1360
movsxd rax, r8d
imul rax, r15
mov edx, [r11+rax*4]
jmp short loc_1310
loc_1360:
imul r14, r10
mov eax, [r11+r14*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1391
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1386:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_12C1
loc_1391:
call ___stack_chk_fail | long long func0(int a1)
{
long long v1; // r14
int v2; // ebx
unsigned long long v3; // r12
long long v4; // rdx
_DWORD *v5; // rcx
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned long long v9; // r10
long long v10; // rdi
long long v11; // r8
int *v12; // r9
int v13; // edx
int *v14; // rsi
int *i; // rax
_DWORD v18[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v19[8]; // [rsp+1008h] [rbp-40h] BYREF
v1 = a1;
v2 = a1 + 1;
v19[1] = __readfsqword(0x28u);
v3 = 4LL * (a1 + 1);
v4 = 4 * v2 * (long long)v2 + 15;
v5 = (_DWORD *)((char *)v19 - (v4 & 0xFFFFFFFFFFFFF000LL));
v6 = v4 & 0xFFF0;
if ( v19 != (_QWORD *)v5 )
{
while ( v18 != v5 )
;
}
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( v7 )
*(_QWORD *)((char *)&v18[-2] + v7) = *(_QWORD *)((char *)&v18[-2] + v7);
v9 = v3 >> 2;
v18[0] = 1;
if ( a1 > 0 )
{
v10 = 1LL;
v11 = 0LL;
v12 = &v18[v3 / 4 + 1];
v13 = 1;
v14 = v12;
while ( 1 )
{
v18[v9 * (int)v10] = v13;
for ( i = v12; ; ++i )
{
v13 += i[v9 * (v11 - v10) - 1];
*i = v13;
if ( i == v14 )
break;
}
++v10;
++v11;
v12 = (int *)((char *)v12 + v3);
v14 = (int *)((char *)v14 + v3 + 4);
if ( v10 == v2 )
break;
v13 = v18[(v9 + 1) * (int)v11];
}
}
return (unsigned int)v18[v9 * v1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
PUSH R12
PUSH RBX
LEA EBX,[R14 + 0x1]
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,EBX
MOV RCX,RSP
LEA R12,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012af
LAB_0010129a:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010129a
LAB_001012af:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101386
LAB_001012c1:
LEA R11,[RSP + 0x3]
MOV R10,R12
MOV RAX,R11
SHR R10,0x2
AND R11,-0x4
SHR RAX,0x2
MOV dword ptr [RAX*0x4],0x1
TEST R14D,R14D
JLE 0x00101360
LEA R13,[R12 + 0x4]
MOV EBX,EBX
MOV EDI,0x1
XOR R8D,R8D
LEA R9,[R11 + R13*0x1]
MOV EDX,0x1
LEA R15,[R10 + 0x1]
MOV RSI,R9
NOP word ptr [RAX + RAX*0x1]
LAB_00101310:
MOVSXD RAX,EDI
MOV RCX,R8
IMUL RAX,R10
SUB RCX,RDI
IMUL RCX,R10
MOV dword ptr [R11 + RAX*0x4],EDX
MOV RAX,R9
JMP 0x00101334
LAB_00101330:
ADD RAX,0x4
LAB_00101334:
ADD EDX,dword ptr [RAX + RCX*0x4 + -0x4]
MOV dword ptr [RAX],EDX
CMP RAX,RSI
JNZ 0x00101330
ADD RDI,0x1
ADD R8,0x1
ADD R9,R12
ADD RSI,R13
CMP RDI,RBX
JZ 0x00101360
MOVSXD RAX,R8D
IMUL RAX,R15
MOV EDX,dword ptr [R11 + RAX*0x4]
JMP 0x00101310
LAB_00101360:
IMUL R14,R10
MOV EAX,dword ptr [R11 + R14*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101391
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101386:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012c1
LAB_00101391:
CALL 0x00101080 | int4 func0(int param_1)
{
long lVar1;
int1 *puVar2;
ulong uVar3;
int *piVar4;
int iVar5;
int1 *puVar6;
int *piVar8;
ulong uVar9;
long lVar10;
int *piVar11;
ulong uVar12;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int1 *puVar7;
puVar6 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (ulong)(int)(param_1 + 1U);
uVar12 = uVar3 * uVar3 * 4 + 0xf;
puVar7 = auStack_48;
puVar2 = auStack_48;
while (puVar7 != auStack_48 + -(uVar12 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar12 = (ulong)((uint)uVar12 & 0xff0);
lVar1 = -uVar12;
if (uVar12 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar12 = uVar3 & 0x3fffffffffffffff;
*(int4 *)(puVar6 + lVar1) = 1;
if (0 < param_1) {
uVar9 = 1;
lVar10 = 0;
piVar8 = (int *)(puVar6 + uVar3 * 4 + 4 + lVar1);
iVar5 = 1;
piVar11 = piVar8;
while( true ) {
*(int *)(puVar6 + (long)(int)uVar9 * uVar12 * 4 + lVar1) = iVar5;
piVar4 = piVar11;
while( true ) {
iVar5 = iVar5 + piVar4[(lVar10 - uVar9) * uVar12 + -1];
*piVar4 = iVar5;
if (piVar4 == piVar8) break;
piVar4 = piVar4 + 1;
}
uVar9 = uVar9 + 1;
lVar10 = lVar10 + 1;
piVar11 = piVar11 + uVar3;
piVar8 = piVar8 + uVar3 + 1;
if (uVar9 == param_1 + 1U) break;
iVar5 = *(int *)(puVar6 + (long)(int)lVar10 * (uVar12 + 1) * 4 + lVar1);
}
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x101396;
__stack_chk_fail();
}
return *(int4 *)(puVar6 + (long)param_1 * uVar12 * 4 + lVar1);
} |
6,327 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
movslq %edi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%r12),%eax
mov %rsp,%rdi
cltq
lea 0x0(,%rax,4),%rbx
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 1402 <func0+0x72>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 13ed <func0+0x5d>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14de <func0+0x14e>
lea 0x3(%rsp),%rdi
mov %rbx,%r11
mov %rdi,%rax
shr $0x2,%r11
and $0xfffffffffffffffc,%rdi
shr $0x2,%rax
movl $0x1,0x0(,%rax,4)
test %r12d,%r12d
jle 14b8 <func0+0x128>
mov %rdi,%r8
lea 0x4(%rbx),%r14
lea 0x4(%rdi),%rsi
xor %r9d,%r9d
lea -0x1(%r12),%r13d
mov $0x1,%r10d
mov $0x1,%edx
lea 0x1(%r11),%r15
nopl (%rax)
movslq %r10d,%rax
mov %r10,%rcx
imul %r11,%rax
sub %r9,%rcx
imul %r11,%rcx
mov %edx,(%rdi,%rax,4)
mov (%r8,%r11,4),%edx
mov %r8,%rax
nopl 0x0(%rax,%rax,1)
add (%rax),%edx
mov %edx,0x4(%rax,%rcx,4)
add $0x4,%rax
cmp %rsi,%rax
jne 1480 <func0+0xf0>
lea 0x1(%r9),%rcx
add %rbx,%r8
add %r14,%rsi
cmp %r13,%r9
je 14b8 <func0+0x128>
movslq %ecx,%rax
add $0x1,%r10
mov %rcx,%r9
imul %r15,%rax
mov (%rdi,%rax,4),%edx
jmp 1460 <func0+0xd0>
nopl 0x0(%rax)
imul %r12,%r11
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%rdi,%r11,4),%eax
jne 14e9 <func0+0x159>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1414 <func0+0x84>
callq 1070 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
mov r12d, edi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+1]
mov rcx, rsp
cdqe
lea rbx, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12AD
loc_1298:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_1298
loc_12AD:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1389
loc_12BF:
lea r11, [rsp+1040h+var_103D]
mov r10, rbx
mov rax, r11
shr r10, 2
and r11, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov ds:dword_0[rax*4], 1
test r12d, r12d
jle short loc_1360
mov r8, r11
lea r14, [rbx+4]
lea rsi, [r11+4]
mov r13d, r12d
mov r9d, 1
xor edi, edi
lea r15, [r10+1]
mov edx, 1
nop dword ptr [rax]
loc_1308:
movsxd rax, r9d
mov rcx, r9
imul rax, r10
sub rcx, rdi
imul rcx, r10
mov [r11+rax*4], edx
mov edx, [r8+r10*4]
mov rax, r8
nop dword ptr [rax+00h]
loc_1328:
add edx, [rax]
mov [rax+rcx*4+4], edx
add rax, 4
cmp rax, rsi
jnz short loc_1328
add rdi, 1
add r8, rbx
add rsi, r14
cmp rdi, r13
jz short loc_1360
movsxd rax, edi
add r9, 1
imul rax, r15
mov edx, [r11+rax*4]
jmp short loc_1308
loc_1360:
movsxd r12, r12d
imul r12, r10
mov eax, [r11+r12*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1394
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1389:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_12BF
loc_1394:
call ___stack_chk_fail | long long func0(int a1)
{
long long v2; // rax
unsigned long long v3; // rbx
long long v4; // rdx
int *v5; // rcx
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned long long v9; // r10
int *v10; // r8
int *v11; // rsi
long long v12; // r9
long long v13; // rdi
int i; // edx
int v15; // edx
int *v16; // rax
long long v18; // [rsp+0h] [rbp-1048h]
int v19; // [rsp+8h] [rbp-1040h] BYREF
int v20; // [rsp+Ch] [rbp-103Ch] BYREF
_QWORD v21[8]; // [rsp+1008h] [rbp-40h] BYREF
v21[1] = __readfsqword(0x28u);
v2 = a1 + 1;
v3 = 4 * v2;
v4 = 4 * v2 * v2 + 15;
v5 = (int *)((char *)v21 - (v4 & 0xFFFFFFFFFFFFF000LL));
v6 = v4 & 0xFFF0;
if ( v21 != (_QWORD *)v5 )
{
while ( &v19 != v5 )
;
}
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( v7 )
*(long long *)((char *)&v18 + v7) = *(long long *)((char *)&v18 + v7);
v9 = v3 >> 2;
v19 = 1;
if ( a1 > 0 )
{
v10 = &v19;
v11 = &v20;
v12 = 1LL;
v13 = 0LL;
for ( i = 1; ; i = *(&v19 + (v9 + 1) * (int)v13) )
{
*(&v19 + v9 * (int)v12) = i;
v15 = v10[v9];
v16 = v10;
do
{
v15 += *v16;
v16[v9 * (v12 - v13) + 1] = v15;
++v16;
}
while ( v16 != v11 );
++v13;
v10 = (int *)((char *)v10 + v3);
v11 = (int *)((char *)v11 + v3 + 4);
if ( v13 == a1 )
break;
++v12;
}
}
return (unsigned int)*(&v19 + v9 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RCX,RSP
CDQE
LEA RBX,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012ad
LAB_00101298:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101298
LAB_001012ad:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101389
LAB_001012bf:
LEA R11,[RSP + 0x3]
MOV R10,RBX
MOV RAX,R11
SHR R10,0x2
AND R11,-0x4
SHR RAX,0x2
MOV dword ptr [RAX*0x4],0x1
TEST R12D,R12D
JLE 0x00101360
MOV R8,R11
LEA R14,[RBX + 0x4]
LEA RSI,[R11 + 0x4]
MOV R13D,R12D
MOV R9D,0x1
XOR EDI,EDI
LEA R15,[R10 + 0x1]
MOV EDX,0x1
NOP dword ptr [RAX]
LAB_00101308:
MOVSXD RAX,R9D
MOV RCX,R9
IMUL RAX,R10
SUB RCX,RDI
IMUL RCX,R10
MOV dword ptr [R11 + RAX*0x4],EDX
MOV EDX,dword ptr [R8 + R10*0x4]
MOV RAX,R8
NOP dword ptr [RAX]
LAB_00101328:
ADD EDX,dword ptr [RAX]
MOV dword ptr [RAX + RCX*0x4 + 0x4],EDX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101328
ADD RDI,0x1
ADD R8,RBX
ADD RSI,R14
CMP RDI,R13
JZ 0x00101360
MOVSXD RAX,EDI
ADD R9,0x1
IMUL RAX,R15
MOV EDX,dword ptr [R11 + RAX*0x4]
JMP 0x00101308
LAB_00101360:
MOVSXD R12,R12D
IMUL R12,R10
MOV EAX,dword ptr [R11 + R12*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101394
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101389:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012bf
LAB_00101394:
CALL 0x00101080 | int4 func0(uint param_1)
{
long lVar1;
int *puVar2;
ulong uVar3;
int *piVar4;
int4 uVar5;
int iVar6;
int *puVar7;
int *piVar9;
ulong uVar10;
int *piVar11;
long lVar12;
ulong uVar13;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int *puVar8;
puVar7 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (ulong)(int)(param_1 + 1);
uVar13 = uVar3 * uVar3 * 4 + 0xf;
puVar8 = auStack_48;
puVar2 = auStack_48;
while (puVar8 != auStack_48 + -(uVar13 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar13 = (ulong)((uint)uVar13 & 0xff0);
lVar1 = -uVar13;
piVar11 = (int *)(puVar7 + lVar1);
if (uVar13 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar13 = uVar3 & 0x3fffffffffffffff;
*(int4 *)(puVar7 + lVar1) = 1;
if (0 < (int)param_1) {
piVar9 = (int *)(puVar7 + lVar1 + 4);
lVar12 = 1;
uVar10 = 0;
uVar5 = 1;
while( true ) {
*(int4 *)(puVar7 + (long)(int)lVar12 * uVar13 * 4 + lVar1) = uVar5;
iVar6 = piVar11[uVar13];
piVar4 = piVar11;
do {
iVar6 = iVar6 + *piVar4;
piVar4[(lVar12 - uVar10) * uVar13 + 1] = iVar6;
piVar4 = piVar4 + 1;
} while (piVar4 != piVar9);
uVar10 = uVar10 + 1;
piVar11 = piVar11 + uVar3;
piVar9 = piVar9 + uVar3 + 1;
if (uVar10 == param_1) break;
lVar12 = lVar12 + 1;
uVar5 = *(int4 *)(puVar7 + (long)(int)uVar10 * (uVar13 + 1) * 4 + lVar1);
}
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x101399;
__stack_chk_fail();
}
return *(int4 *)(puVar7 + (long)(int)param_1 * uVar13 * 4 + lVar1);
} |
6,328 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1c(%rbp)
cmovge -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
imul -0x4(%rbp),%eax
cltd
idivl -0x18(%rbp)
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_18]
sub eax, 1
mov edx, [rbp+var_1C]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
imul eax, [rbp+var_4]
cdq
idiv [rbp+var_18]
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a2 - 1;
if ( a3 >= a2 - 1 )
v3 = a3;
return (unsigned int)(v3 * a1 / a2);
} | 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 + -0x18]
SUB EAX,0x1
MOV EDX,dword ptr [RBP + -0x1c]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x18]
POP RBP
RET | int [16] func0(int param_1,int param_2,int param_3)
{
int iVar1;
int auVar2 [16];
iVar1 = param_2 + -1;
if (param_2 + -1 <= param_3) {
iVar1 = param_3;
}
auVar2._0_8_ = (long)(param_1 * iVar1) / (long)param_2 & 0xffffffff;
auVar2._8_8_ = (long)(param_1 * iVar1) % (long)param_2 & 0xffffffff;
return auVar2;
} |
6,329 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
cmp %edx,%ecx
mov %edx,%eax
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
int1 auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
6,330 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r8d, edx
lea edx, [rsi-1]
cmp edx, r8d
mov eax, r8d
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV R8D,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,R8D
MOV EAX,R8D
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
int1 auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
6,331 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
6,332 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int expected2[] = {0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
for (int i = 0; i < 15; i++) {
assert(list2[i] == expected2[i]);
}
int list3[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
func0(list3, 12, 5);
int expected3[] = {10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10};
for (int i = 0; i < 11; i++) {
assert(list3[i] == expected3[i]);
}
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
cmpl $0x0,-0x20(%rbp)
jle 11f4 <func0+0x6b>
mov -0x20(%rbp),%eax
cmp -0x1c(%rbp),%eax
jg 11f4 <func0+0x6b>
mov -0x20(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11e9 <func0+0x60>
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 11b4 <func0+0x2b>
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
cmp [rbp+var_20], 0
jle short loc_11F4
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jg short loc_11F4
mov eax, [rbp+var_20]
sub eax, 1
mov [rbp+var_4], eax
jmp short loc_11E9
loc_11B4:
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4], 1
loc_11E9:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_11B4
loc_11F4:
nop
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
int i; // [rsp+1Ch] [rbp-4h]
if ( a3 > 0 )
{
result = (unsigned int)a3;
if ( a3 <= a2 )
{
for ( i = a3 - 1; ; ++i )
{
result = (unsigned int)(a2 - 1);
if ( i >= (int)result )
break;
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(4 * (i + 1LL) + a1);
}
}
}
return result;
} | 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
CMP dword ptr [RBP + -0x20],0x0
JLE 0x001011f4
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JG 0x001011f4
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011e9
LAB_001011b4:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011e9:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011b4
LAB_001011f4:
NOP
POP RBP
RET | void func0(long param_1,int param_2,int param_3)
{
int4 local_c;
if ((0 < param_3) && (param_3 <= param_2)) {
for (local_c = param_3 + -1; local_c < param_2 + -1; local_c = local_c + 1) {
*(int4 *)(param_1 + (long)local_c * 4) =
*(int4 *)(param_1 + ((long)local_c + 1) * 4);
}
}
return;
} |
6,333 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int expected2[] = {0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
for (int i = 0; i < 15; i++) {
assert(list2[i] == expected2[i]);
}
int list3[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
func0(list3, 12, 5);
int expected3[] = {10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10};
for (int i = 0; i < 11; i++) {
assert(list3[i] == expected3[i]);
}
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 11bd <func0+0x34>
cmp %esi,%edx
jg 11bd <func0+0x34>
lea -0x1(%rdx),%eax
jge 11bd <func0+0x34>
cltq
lea (%rdi,%rax,4),%rax
sub $0x1,%esi
sub %edx,%esi
movslq %edx,%rdx
add %rsi,%rdx
lea (%rdi,%rdx,4),%rcx
mov 0x4(%rax),%edx
mov %edx,(%rax)
add $0x4,%rax
cmp %rcx,%rax
jne 11af <func0+0x26>
retq
| func0:
endbr64
test edx, edx
jle short locret_11BD
cmp edx, esi
jg short locret_11BD
lea eax, [rdx-1]
jge short locret_11BD
cdqe
lea rax, [rdi+rax*4]
sub esi, 1
sub esi, edx
movsxd rdx, edx
add rsi, rdx
lea rcx, [rdi+rsi*4]
loc_11AF:
mov edx, [rax+4]
mov [rax], edx
add rax, 4
cmp rax, rcx
jnz short loc_11AF
locret_11BD:
retn | void func0(long long a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a3 > 0 && a3 < a2 )
{
v3 = (_DWORD *)(a1 + 4LL * (a3 - 1));
do
{
*v3 = v3[1];
++v3;
}
while ( v3 != (_DWORD *)(a1 + 4 * (a3 + (unsigned long long)(unsigned int)(a2 - 1 - a3))) );
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011bd
CMP EDX,ESI
JG 0x001011bd
LEA EAX,[RDX + -0x1]
JGE 0x001011bd
CDQE
LEA RAX,[RDI + RAX*0x4]
SUB ESI,0x1
SUB ESI,EDX
MOVSXD RDX,EDX
ADD RSI,RDX
LEA RCX,[RDI + RSI*0x4]
LAB_001011af:
MOV EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RAX],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011af
LAB_001011bd:
RET | void func0(long param_1,int param_2,int param_3)
{
int4 *puVar1;
if (((0 < param_3) && (param_3 <= param_2)) && (param_3 < param_2)) {
puVar1 = (int4 *)(param_1 + (long)(param_3 + -1) * 4);
do {
*puVar1 = puVar1[1];
puVar1 = puVar1 + 1;
} while (puVar1 != (int4 *)
(param_1 + ((ulong)(uint)((param_2 + -1) - param_3) + (long)param_3) * 4));
}
return;
} |
6,334 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int expected2[] = {0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
for (int i = 0; i < 15; i++) {
assert(list2[i] == expected2[i]);
}
int list3[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
func0(list3, 12, 5);
int expected3[] = {10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10};
for (int i = 0; i < 11; i++) {
assert(list3[i] == expected3[i]);
}
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 14e0 <func0+0x10>
cmp %esi,%edx
jg 14e0 <func0+0x10>
jmp 14a0 <func0.part.0>
xchg %ax,%ax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0_part_0:
lea eax, [rdx-1]
cmp edx, esi
jge short locret_1510
cdqe
sub esi, 1
shl rax, 2
sub esi, edx
lea rdx, ds:4[rsi*4]
lea rsi, [rdi+rax+4]
add rdi, rax
jmp _memmove
locret_1510:
retn | long long func0_part_0(long long a1, int a2, int a3)
{
long long result; // rax
result = (unsigned int)(a3 - 1);
if ( a3 < a2 )
return memmove(4LL * (int)result + a1, a1 + 4LL * (int)result + 4, 4LL * (unsigned int)(a2 - 1 - a3) + 4);
return result;
} | func0.part.0:
LEA EAX,[RDX + -0x1]
CMP EDX,ESI
JGE 0x00101510
CDQE
SUB ESI,0x1
SHL RAX,0x2
SUB ESI,EDX
LEA RDX,[0x4 + RSI*0x4]
LEA RSI,[RDI + RAX*0x1 + 0x4]
ADD RDI,RAX
JMP 0x001010b0
LAB_00101510:
RET | void func0_part_0(long param_1,int param_2,int param_3)
{
long lVar1;
if (param_3 < param_2) {
lVar1 = (long)(param_3 + -1) * 4;
memmove((void *)(param_1 + lVar1),(void *)(param_1 + 4 + lVar1),
(ulong)(uint)((param_2 + -1) - param_3) * 4 + 4);
return;
}
return;
} |
6,335 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int expected2[] = {0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
for (int i = 0; i < 15; i++) {
assert(list2[i] == expected2[i]);
}
int list3[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
func0(list3, 12, 5);
int expected3[] = {10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10};
for (int i = 0; i < 11; i++) {
assert(list3[i] == expected3[i]);
}
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 1760 <func0+0xe0>
cmp %esi,%edx
jg 1760 <func0+0xe0>
lea -0x1(%rdx),%r9d
lea -0x1(%rsi),%r10d
jge 1760 <func0+0xe0>
movslq %edx,%r11
push %rbp
lea 0x10(,%r11,4),%rcx
push %rbx
mov %r10d,%ebx
lea 0x0(,%r11,4),%r8
lea -0x14(%rcx),%rax
sub %edx,%ebx
cmp %rcx,%rax
setge %bpl
sub $0x4,%rcx
cmp %r8,%rcx
setle %cl
or %cl,%bpl
je 1768 <func0+0xe8>
cmp $0x3,%ebx
jbe 1768 <func0+0xe8>
sub %edx,%esi
add %rdi,%r8
lea (%rdi,%rax,1),%rdx
xor %eax,%eax
mov %esi,%ecx
shr $0x2,%ecx
shl $0x4,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%r8,%rax,1),%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %rcx,%rax
jne 1700 <func0+0x80>
mov %esi,%eax
and $0xfffffffc,%eax
add %eax,%r9d
cmp %eax,%esi
je 1756 <func0+0xd6>
movslq %r9d,%rax
add $0x1,%rax
mov (%rdi,%rax,4),%ecx
lea 0x0(,%rax,4),%rdx
mov %ecx,-0x4(%rdi,%rdx,1)
lea 0x1(%r9),%ecx
cmp %ecx,%r10d
jle 1756 <func0+0xd6>
mov 0x4(%rdi,%rdx,1),%ecx
add $0x2,%r9d
mov %ecx,(%rdi,%rax,4)
cmp %r9d,%r10d
jle 1756 <func0+0xd6>
mov 0x8(%rdi,%rdx,1),%eax
mov %eax,0x4(%rdi,%rdx,1)
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
add %rbx,%r11
add %rdi,%rax
lea (%rdi,%r11,4),%rcx
nopw 0x0(%rax,%rax,1)
mov 0x4(%rax),%edx
add $0x4,%rax
mov %edx,-0x4(%rax)
cmp %rcx,%rax
jne 1778 <func0+0xf8>
jmp 1756 <func0+0xd6>
nopl 0x0(%rax)
| func0_part_0:
lea eax, [rdx-1]
cmp edx, esi
jge short locret_1490
cdqe
sub esi, 1
shl rax, 2
sub esi, edx
lea rdx, ds:4[rsi*4]; n
lea rsi, [rdi+rax+4]; src
add rdi, rax; dest
jmp _memmove
locret_1490:
retn | unsigned long long func0_part_0(long long a1, int a2, int a3)
{
unsigned long long result; // rax
result = (unsigned int)(a3 - 1);
if ( a3 < a2 )
return (unsigned long long)memmove(
(void *)(4LL * (int)result + a1),
(const void *)(a1 + 4LL * (int)result + 4),
4LL * (unsigned int)(a2 - 1 - a3) + 4);
return result;
} | func0.part.0:
LEA EAX,[RDX + -0x1]
CMP EDX,ESI
JGE 0x00101490
CDQE
SUB ESI,0x1
SHL RAX,0x2
SUB ESI,EDX
LEA RDX,[0x4 + RSI*0x4]
LEA RSI,[RDI + RAX*0x1 + 0x4]
ADD RDI,RAX
JMP 0x001010b0
LAB_00101490:
RET | void func0_part_0(long param_1,int param_2,int param_3)
{
long lVar1;
if (param_3 < param_2) {
lVar1 = (long)(param_3 + -1) * 4;
memmove((void *)(param_1 + lVar1),(void *)(param_1 + 4 + lVar1),
(ulong)(uint)((param_2 + -1) - param_3) * 4 + 4);
return;
}
return;
} |
6,336 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(test_list3, 3, 1) == 11);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11ea <func0+0x81>
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 %rax,%rdx
mov -0x20(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
cmp %eax,-0x8(%rbp)
jge 11e6 <func0+0x7d>
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 %rax,%rdx
mov -0x20(%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 1194 <func0+0x2b>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rbp+var_8], eax
mov [rbp+var_4], 1
jmp short loc_11EA
loc_1194:
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 rdx, rax
mov eax, [rbp+var_20]
cdqe
mov eax, [rdx+rax*4]
cmp [rbp+var_8], eax
jge short loc_11E6
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 rdx, rax
mov eax, [rbp+var_20]
cdqe
mov eax, [rdx+rax*4]
mov [rbp+var_8], eax
loc_11E6:
add [rbp+var_4], 1
loc_11EA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1194
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = *(_DWORD *)(a1 + 4LL * a3);
for ( i = 1; i < a2; ++i )
{
if ( (signed int)v4 < *(_DWORD *)(a1 + 12LL * i + 4LL * a3) )
v4 = *(_DWORD *)(a1 + 12LL * i + 4LL * a3);
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011ea
LAB_00101194:
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 RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RBP + -0x8],EAX
JGE 0x001011e6
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 RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011e6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ea:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101194
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = *(int *)(param_1 + (long)param_3 * 4);
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (local_10 < *(int *)((long)local_c * 0xc + param_1 + (long)param_3 * 4)) {
local_10 = *(int *)((long)local_c * 0xc + param_1 + (long)param_3 * 4);
}
}
return local_10;
} |
6,337 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(test_list3, 3, 1) == 11);
return 0;
}
| O1 | c | func0:
endbr64
movslq %edx,%rax
mov (%rdi,%rax,4),%ecx
cmp $0x1,%esi
jle 119f <func0+0x36>
mov %rax,%rdx
lea (%rdi,%rax,4),%rax
lea -0x2(%rsi),%esi
lea (%rsi,%rsi,2),%rsi
add %rsi,%rdx
lea 0xc(%rdi,%rdx,4),%rsi
mov 0xc(%rax),%edx
cmp %edx,%ecx
cmovl %edx,%ecx
add $0xc,%rax
cmp %rsi,%rax
jne 118e <func0+0x25>
mov %ecx,%eax
retq
| func0:
endbr64
movsxd rax, edx
mov ecx, [rdi+rax*4]
cmp esi, 1
jle short loc_119F
mov rdx, rax
lea rax, [rdi+rax*4]
lea esi, [rsi-2]
lea rsi, [rsi+rsi*2]
add rdx, rsi
lea rsi, [rdi+rdx*4+0Ch]
loc_118E:
mov edx, [rax+0Ch]
cmp ecx, edx
cmovl ecx, edx
add rax, 0Ch
cmp rax, rsi
jnz short loc_118E
loc_119F:
mov eax, ecx
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // ecx
long long v4; // rax
long long v5; // rsi
v3 = *(_DWORD *)(a1 + 4LL * a3);
if ( a2 > 1 )
{
v4 = a1 + 4LL * a3;
v5 = a1 + 4 * (3LL * (unsigned int)(a2 - 2) + a3) + 12;
do
{
if ( (signed int)v3 < *(_DWORD *)(v4 + 12) )
v3 = *(_DWORD *)(v4 + 12);
v4 += 12LL;
}
while ( v4 != v5 );
}
return v3;
} | func0:
ENDBR64
MOVSXD RAX,EDX
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP ESI,0x1
JLE 0x0010119f
MOV RDX,RAX
LEA RAX,[RDI + RAX*0x4]
LEA ESI,[RSI + -0x2]
LEA RSI,[RSI + RSI*0x2]
ADD RDX,RSI
LEA RSI,[RDI + RDX*0x4 + 0xc]
LAB_0010118e:
MOV EDX,dword ptr [RAX + 0xc]
CMP ECX,EDX
CMOVL ECX,EDX
ADD RAX,0xc
CMP RAX,RSI
JNZ 0x0010118e
LAB_0010119f:
MOV EAX,ECX
RET | int func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
int iVar3;
lVar1 = (long)param_3;
iVar3 = *(int *)(param_1 + lVar1 * 4);
if (1 < param_2) {
lVar2 = param_1 + lVar1 * 4;
do {
if (iVar3 < *(int *)(lVar2 + 0xc)) {
iVar3 = *(int *)(lVar2 + 0xc);
}
lVar2 = lVar2 + 0xc;
} while (lVar2 != param_1 + 0xc + (lVar1 + (ulong)(param_2 - 2) * 3) * 4);
}
return iVar3;
} |
6,338 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(test_list3, 3, 1) == 11);
return 0;
}
| O2 | c | func0:
endbr64
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r8d
cmp $0x1,%esi
jle 117b <func0+0x3b>
lea -0x2(%rsi),%ecx
lea (%rdi,%rdx,4),%rax
lea (%rcx,%rcx,2),%rcx
add %rcx,%rdx
lea 0xc(%rdi,%rdx,4),%rcx
nopl 0x0(%rax,%rax,1)
mov 0xc(%rax),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0xc,%rax
cmp %rcx,%rax
jne 1168 <func0+0x28>
mov %r8d,%eax
retq
| func0:
endbr64
movsxd rdx, edx
mov r8d, [rdi+rdx*4]
cmp esi, 1
jle short loc_117B
lea ecx, [rsi-2]
lea rax, [rdi+rdx*4]
lea rcx, [rcx+rcx*2]
add rdx, rcx
lea rcx, [rdi+rdx*4+0Ch]
nop dword ptr [rax+rax+00h]
loc_1168:
mov edx, [rax+0Ch]
cmp r8d, edx
cmovl r8d, edx
add rax, 0Ch
cmp rax, rcx
jnz short loc_1168
loc_117B:
mov eax, r8d
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
long long v4; // rax
v3 = *(_DWORD *)(a1 + 4LL * a3);
if ( a2 > 1 )
{
v4 = a1 + 4LL * a3;
do
{
if ( (signed int)v3 < *(_DWORD *)(v4 + 12) )
v3 = *(_DWORD *)(v4 + 12);
v4 += 12LL;
}
while ( v4 != a1 + 4 * (3LL * (unsigned int)(a2 - 2) + a3) + 12 );
}
return v3;
} | func0:
ENDBR64
MOVSXD RDX,EDX
MOV R8D,dword ptr [RDI + RDX*0x4]
CMP ESI,0x1
JLE 0x0010117b
LEA ECX,[RSI + -0x2]
LEA RAX,[RDI + RDX*0x4]
LEA RCX,[RCX + RCX*0x2]
ADD RDX,RCX
LEA RCX,[RDI + RDX*0x4 + 0xc]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101168:
MOV EDX,dword ptr [RAX + 0xc]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0xc
CMP RAX,RCX
JNZ 0x00101168
LAB_0010117b:
MOV EAX,R8D
RET | int func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
int iVar3;
lVar2 = (long)param_3;
iVar3 = *(int *)(param_1 + lVar2 * 4);
if (1 < param_2) {
lVar1 = param_1 + lVar2 * 4;
do {
if (iVar3 < *(int *)(lVar1 + 0xc)) {
iVar3 = *(int *)(lVar1 + 0xc);
}
lVar1 = lVar1 + 0xc;
} while (lVar1 != param_1 + 0xc + (lVar2 + (ulong)(param_2 - 2) * 3) * 4);
}
return iVar3;
} |
6,339 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(test_list3, 3, 1) == 11);
return 0;
}
| O3 | c | func0:
endbr64
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r8d
cmp $0x1,%esi
jle 117b <func0+0x3b>
lea -0x2(%rsi),%ecx
lea (%rdi,%rdx,4),%rax
lea (%rcx,%rcx,2),%rcx
add %rcx,%rdx
lea 0xc(%rdi,%rdx,4),%rcx
nopl 0x0(%rax,%rax,1)
mov 0xc(%rax),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0xc,%rax
cmp %rcx,%rax
jne 1168 <func0+0x28>
mov %r8d,%eax
retq
| func0:
endbr64
mov r8, rdi
mov edi, esi
movsxd rsi, edx
mov eax, [r8+rsi*4]
cmp edi, 1
jle locret_1252
lea edx, [rdi-2]
cmp edx, 3
jbe loc_1253
mov ecx, edx
movd xmm4, eax
lea rax, [r8+rsi*4+0Ch]
shr ecx, 2
pshufd xmm2, xmm4, 0
lea rcx, [rcx+rcx*2]
shl rcx, 4
add rcx, rax
nop dword ptr [rax+rax+00h]
loc_1188:
movdqu xmm3, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
add rax, 30h ; '0'
movdqa xmm0, xmm3
shufps xmm1, xmm3, 0Ah
shufps xmm0, xmm1, 8Ch
movdqu xmm1, xmmword ptr [rax-10h]
shufps xmm1, xmm0, 0A5h
shufps xmm0, xmm1, 24h ; '$'
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rcx, rax
jnz short loc_1188
movdqa xmm1, xmm2
and edx, 0FFFFFFFCh
psrldq xmm1, 8
add edx, 1
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
loc_120F:
movsxd rcx, edx
lea rcx, [rcx+rcx*2]
lea rcx, [r8+rcx*4]
lea rcx, [rcx+rsi*4]
mov esi, [rcx]
cmp eax, esi
cmovl eax, esi
lea esi, [rdx+1]
cmp edi, esi
jle short locret_1252
mov esi, [rcx+0Ch]
cmp eax, esi
cmovl eax, esi
lea esi, [rdx+2]
cmp edi, esi
jle short locret_1252
mov esi, [rcx+18h]
cmp eax, esi
cmovl eax, esi
add edx, 3
cmp edi, edx
jle short locret_1252
mov edx, [rcx+24h]
cmp eax, edx
cmovl eax, edx
locret_1252:
retn
loc_1253:
mov edx, 1
jmp short loc_120F | long long func0(long long a1, int a2, int a3)
{
long long v5; // rsi
long long result; // rax
unsigned int v7; // edx
__m128i v8; // xmm4
const __m128i *v9; // rax
__m128i v10; // xmm2
const __m128i *v11; // rcx
__m128 v12; // xmm3
__m128 v13; // xmm1
__m128 v14; // xmm0
__m128i v15; // xmm0
__m128i v16; // xmm1
__m128i v17; // xmm1
signed int v18; // edx
__m128i v19; // xmm0
__m128i v20; // xmm0
__m128i v21; // xmm2
__m128i v22; // xmm1
int *v23; // rcx
int v24; // esi
int v25; // esi
int v26; // edx
v5 = a3;
result = *(unsigned int *)(a1 + 4LL * a3);
if ( a2 > 1 )
{
v7 = a2 - 2;
if ( (unsigned int)(a2 - 2) <= 3 )
{
v18 = 1;
}
else
{
v8 = _mm_cvtsi32_si128(result);
v9 = (const __m128i *)(a1 + 4 * v5 + 12);
v10 = _mm_shuffle_epi32(v8, 0);
v11 = &v9[3 * (v7 >> 2)];
do
{
v12 = (__m128)_mm_loadu_si128(v9);
v13 = (__m128)_mm_loadu_si128(v9 + 1);
v9 += 3;
v14 = _mm_shuffle_ps(v12, _mm_shuffle_ps(v13, v12, 10), 140);
v15 = (__m128i)_mm_shuffle_ps(v14, _mm_shuffle_ps((__m128)_mm_loadu_si128(v9 - 1), v14, 165), 36);
v16 = _mm_cmpgt_epi32(v15, v10);
v10 = _mm_or_si128(_mm_andnot_si128(v16, v10), _mm_and_si128(v15, v16));
}
while ( v11 != v9 );
v17 = _mm_srli_si128(v10, 8);
v18 = (v7 & 0xFFFFFFFC) + 1;
v19 = _mm_cmpgt_epi32(v17, v10);
v20 = _mm_or_si128(_mm_andnot_si128(v19, v10), _mm_and_si128(v17, v19));
v21 = _mm_srli_si128(v20, 4);
v22 = _mm_cmpgt_epi32(v21, v20);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v22, v20), _mm_and_si128(v21, v22)));
}
v23 = (int *)(a1 + 12LL * v18 + 4 * v5);
if ( (int)result < *v23 )
result = (unsigned int)*v23;
if ( a2 > v18 + 1 )
{
v24 = v23[3];
if ( (int)result < v24 )
result = (unsigned int)v24;
if ( a2 > v18 + 2 )
{
v25 = v23[6];
if ( (int)result < v25 )
result = (unsigned int)v25;
if ( a2 > v18 + 3 )
{
v26 = v23[9];
if ( (int)result < v26 )
return (unsigned int)v26;
}
}
}
}
return result;
} | func0:
ENDBR64
MOV R8,RDI
MOV EDI,ESI
MOVSXD RSI,EDX
MOV EAX,dword ptr [R8 + RSI*0x4]
CMP EDI,0x1
JLE 0x00101252
LEA EDX,[RDI + -0x2]
CMP EDX,0x3
JBE 0x00101253
MOV ECX,EDX
MOVD XMM4,EAX
LEA RAX,[R8 + RSI*0x4 + 0xc]
SHR ECX,0x2
PSHUFD XMM2,XMM4,0x0
LEA RCX,[RCX + RCX*0x2]
SHL RCX,0x4
ADD RCX,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101188:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
ADD RAX,0x30
MOVDQA XMM0,XMM3
SHUFPS XMM1,XMM3,0xa
SHUFPS XMM0,XMM1,0x8c
MOVDQU XMM1,xmmword ptr [RAX + -0x10]
SHUFPS XMM1,XMM0,0xa5
SHUFPS XMM0,XMM1,0x24
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RCX,RAX
JNZ 0x00101188
MOVDQA XMM1,XMM2
AND EDX,0xfffffffc
PSRLDQ XMM1,0x8
ADD EDX,0x1
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
LAB_0010120f:
MOVSXD RCX,EDX
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[R8 + RCX*0x4]
LEA RCX,[RCX + RSI*0x4]
MOV ESI,dword ptr [RCX]
CMP EAX,ESI
CMOVL EAX,ESI
LEA ESI,[RDX + 0x1]
CMP EDI,ESI
JLE 0x00101252
MOV ESI,dword ptr [RCX + 0xc]
CMP EAX,ESI
CMOVL EAX,ESI
LEA ESI,[RDX + 0x2]
CMP EDI,ESI
JLE 0x00101252
MOV ESI,dword ptr [RCX + 0x18]
CMP EAX,ESI
CMOVL EAX,ESI
ADD EDX,0x3
CMP EDI,EDX
JLE 0x00101252
MOV EDX,dword ptr [RCX + 0x24]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_00101252:
RET
LAB_00101253:
MOV EDX,0x1
JMP 0x0010120f | uint func0(long param_1,int param_2,int param_3)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
int iVar6;
long lVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
lVar7 = (long)param_3;
uVar2 = *(uint *)(param_1 + lVar7 * 4);
if (1 < param_2) {
uVar5 = param_2 - 2;
if (uVar5 < 4) {
iVar6 = 1;
}
else {
puVar1 = (uint *)(param_1 + 0xc + lVar7 * 4);
puVar3 = puVar1;
uVar9 = uVar2;
uVar13 = uVar2;
uVar14 = uVar2;
do {
puVar4 = puVar3 + 0xc;
uVar8 = -(uint)((int)uVar2 < (int)*puVar3);
uVar10 = -(uint)((int)uVar9 < (int)puVar3[3]);
uVar11 = -(uint)((int)uVar13 < (int)puVar3[6]);
uVar12 = -(uint)((int)uVar14 < (int)puVar3[9]);
uVar2 = ~uVar8 & uVar2 | *puVar3 & uVar8;
uVar9 = ~uVar10 & uVar9 | puVar3[3] & uVar10;
uVar13 = ~uVar11 & uVar13 | puVar3[6] & uVar11;
uVar14 = ~uVar12 & uVar14 | puVar3[9] & uVar12;
puVar3 = puVar4;
} while (puVar1 + (ulong)(uVar5 >> 2) * 0xc != puVar4);
iVar6 = (uVar5 & 0xfffffffc) + 1;
uVar2 = ~-(uint)((int)uVar2 < (int)uVar13) & uVar2 |
uVar13 & -(uint)((int)uVar2 < (int)uVar13);
uVar5 = ~-(uint)((int)uVar9 < (int)uVar14) & uVar9 |
uVar14 & -(uint)((int)uVar9 < (int)uVar14);
uVar9 = -(uint)((int)uVar2 < (int)uVar5);
uVar2 = ~uVar9 & uVar2 | uVar5 & uVar9;
}
puVar1 = (uint *)(param_1 + (long)iVar6 * 0xc + lVar7 * 4);
if ((int)uVar2 < (int)*puVar1) {
uVar2 = *puVar1;
}
if (iVar6 + 1 < param_2) {
if ((int)uVar2 < (int)puVar1[3]) {
uVar2 = puVar1[3];
}
if (iVar6 + 2 < param_2) {
if ((int)uVar2 < (int)puVar1[6]) {
uVar2 = puVar1[6];
}
if ((iVar6 + 3 < param_2) && ((int)uVar2 < (int)puVar1[9])) {
uVar2 = puVar1[9];
}
}
}
}
return uVar2;
} |
6,340 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1[1][3] == 8);
int* test2[] = {(int[]){'x', 'y'}, (int[]){'a', 'b'}, (int[]){'m', 'n'}};
int** result2 = func0(test2, 3, 2);
assert(result2[0][0] == 'x' && result2[0][1] == 'a' && result2[0][2] == 'm');
assert(result2[1][0] == 'y' && result2[1][1] == 'b' && result2[1][2] == 'n');
int* test3[] = {(int[]){'x', 'y', 'z'}, (int[]){'a', 'b', 'c'}, (int[]){'m', 'n', 'o'}};
int** result3 = func0(test3, 3, 3);
assert(result3[0][0] == 'x' && result3[0][1] == 'a' && result3[0][2] == 'm');
assert(result3[1][0] == 'y' && result3[1][1] == 'b' && result3[1][2] == 'n');
assert(result3[2][0] == 'z' && result3[2][1] == 'c' && result3[2][2] == 'o');
// Free allocated memory
for (int i = 0; i < 2; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 1271 <func0+0xc8>
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x1c(%rbp)
jmp 1265 <func0+0xbc>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1214 <func0+0x6b>
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 11e1 <func0+0x38>
mov -0x18(%rbp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov eax, [rbp+var_30]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_20], 0
jmp loc_1271
loc_11E1:
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov edx, [rbp+var_20]
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_1C], 0
jmp short loc_1265
loc_1214:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_1C]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_1C], 1
loc_1265:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jl short loc_1214
add [rbp+var_20], 1
loc_1271:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_30]
jl loc_11E1
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, int a3)
{
int i; // [rsp+10h] [rbp-20h]
int j; // [rsp+14h] [rbp-1Ch]
_QWORD *v7; // [rsp+18h] [rbp-18h]
v7 = malloc(8LL * a3);
for ( i = 0; i < a3; ++i )
{
v7[i] = malloc(4LL * a2);
for ( j = 0; j < a2; ++j )
*(_DWORD *)(4LL * j + v7[i]) = *(_DWORD *)(4LL * i + *(_QWORD *)(8LL * j + a1));
}
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101271
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101265
LAB_00101214:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x20]
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 + -0x1c]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101265:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101214
ADD dword ptr [RBP + -0x20],0x1
LAB_00101271:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001011e1
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
void *pvVar2;
int4 local_28;
int4 local_24;
pvVar1 = malloc((long)param_3 << 3);
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
pvVar2 = malloc((long)param_2 << 2);
*(void **)((long)local_28 * 8 + (long)pvVar1) = pvVar2;
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
*(int4 *)(*(long *)((long)pvVar1 + (long)local_28 * 8) + (long)local_24 * 4) =
*(int4 *)(*(long *)(param_1 + (long)local_24 * 8) + (long)local_28 * 4);
}
}
return pvVar1;
} |
6,341 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1[1][3] == 8);
int* test2[] = {(int[]){'x', 'y'}, (int[]){'a', 'b'}, (int[]){'m', 'n'}};
int** result2 = func0(test2, 3, 2);
assert(result2[0][0] == 'x' && result2[0][1] == 'a' && result2[0][2] == 'm');
assert(result2[1][0] == 'y' && result2[1][1] == 'b' && result2[1][2] == 'n');
int* test3[] = {(int[]){'x', 'y', 'z'}, (int[]){'a', 'b', 'c'}, (int[]){'m', 'n', 'o'}};
int** result3 = func0(test3, 3, 3);
assert(result3[0][0] == 'x' && result3[0][1] == 'a' && result3[0][2] == 'm');
assert(result3[1][0] == 'y' && result3[1][1] == 'b' && result3[1][2] == 'n');
assert(result3[2][0] == 'z' && result3[2][1] == 'c' && result3[2][2] == 'o');
// Free allocated memory
for (int i = 0; i < 2; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%r14d
mov %edx,%ebx
movslq %edx,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 1244 <func0+0x9b>
mov %rax,%rdi
movslq %r14d,%rax
shl $0x2,%rax
mov %rax,(%rsp)
mov %rdi,%r13
lea -0x1(%rbx),%eax
lea 0x8(%rdi,%rax,8),%r15
lea -0x1(%r14),%eax
lea 0x4(,%rax,4),%r12
mov $0x0,%ebx
jmp 1211 <func0+0x68>
add $0x8,%r13
add $0x4,%rbx
cmp %r15,%r13
je 1244 <func0+0x9b>
mov (%rsp),%rdi
callq 10b0 <malloc@plt>
mov %r13,%rsi
mov %rax,0x0(%r13)
test %r14d,%r14d
jle 1204 <func0+0x5b>
mov $0x0,%eax
mov 0x0(%rbp,%rax,2),%rdx
mov (%rdx,%rbx,1),%ecx
mov (%rsi),%rdx
mov %ecx,(%rdx,%rax,1)
add $0x4,%rax
cmp %r12,%rax
jne 122b <func0+0x82>
jmp 1204 <func0+0x5b>
mov 0x8(%rsp),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r14d, esi
mov ebx, edx
movsxd rdi, edx
shl rdi, 3
call _malloc
mov r15, rax
test ebx, ebx
jle short loc_1229
movsxd rax, r14d
shl rax, 2
mov [rsp+48h+var_40], rax
mov ebx, ebx
lea r13, ds:0[rbx*4]
mov ebx, 0
mov r12d, r14d
loc_11F4:
mov rdi, [rsp+48h+var_40]
call _malloc
mov [r15+rbx*2], rax
test r14d, r14d
jle short loc_1220
mov edx, 0
loc_120C:
mov rcx, [rbp+rdx*8+0]
mov ecx, [rcx+rbx]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rdx, r12
jnz short loc_120C
loc_1220:
add rbx, 4
cmp rbx, r13
jnz short loc_11F4
loc_1229:
mov rax, r15
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2, int a3)
{
long long v4; // r15
long long v5; // r13
long long v6; // rbx
long long v7; // rax
long long i; // rdx
v4 = malloc(8LL * a3);
if ( a3 > 0 )
{
v5 = 4LL * (unsigned int)a3;
v6 = 0LL;
do
{
v7 = malloc(4LL * a2);
*(_QWORD *)(v4 + 2 * v6) = v7;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(v7 + 4 * i) = *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + v6);
}
v6 += 4LL;
}
while ( v6 != v5 );
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R14D,ESI
MOV EBX,EDX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x001010b0
MOV R15,RAX
TEST EBX,EBX
JLE 0x00101229
MOVSXD RAX,R14D
SHL RAX,0x2
MOV qword ptr [RSP + 0x8],RAX
MOV EBX,EBX
LEA R13,[RBX*0x4]
MOV EBX,0x0
MOV R12D,R14D
LAB_001011f4:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001010b0
MOV qword ptr [R15 + RBX*0x2],RAX
TEST R14D,R14D
JLE 0x00101220
MOV EDX,0x0
LAB_0010120c:
MOV RCX,qword ptr [RBP + RDX*0x8]
MOV ECX,dword ptr [RCX + RBX*0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,R12
JNZ 0x0010120c
LAB_00101220:
ADD RBX,0x4
CMP RBX,R13
JNZ 0x001011f4
LAB_00101229:
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,uint param_2,uint param_3)
{
void *pvVar1;
void *pvVar2;
ulong uVar3;
long lVar4;
pvVar1 = malloc((long)(int)param_3 << 3);
if (0 < (int)param_3) {
lVar4 = 0;
do {
pvVar2 = malloc((long)(int)param_2 << 2);
*(void **)((long)pvVar1 + lVar4 * 2) = pvVar2;
if (0 < (int)param_2) {
uVar3 = 0;
do {
*(int4 *)((long)pvVar2 + uVar3 * 4) =
*(int4 *)(*(long *)(param_1 + uVar3 * 8) + lVar4);
uVar3 = uVar3 + 1;
} while (uVar3 != param_2);
}
lVar4 = lVar4 + 4;
} while (lVar4 != (ulong)param_3 * 4);
}
return pvVar1;
} |
6,342 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1[1][3] == 8);
int* test2[] = {(int[]){'x', 'y'}, (int[]){'a', 'b'}, (int[]){'m', 'n'}};
int** result2 = func0(test2, 3, 2);
assert(result2[0][0] == 'x' && result2[0][1] == 'a' && result2[0][2] == 'm');
assert(result2[1][0] == 'y' && result2[1][1] == 'b' && result2[1][2] == 'n');
int* test3[] = {(int[]){'x', 'y', 'z'}, (int[]){'a', 'b', 'c'}, (int[]){'m', 'n', 'o'}};
int** result3 = func0(test3, 3, 3);
assert(result3[0][0] == 'x' && result3[0][1] == 'a' && result3[0][2] == 'm');
assert(result3[1][0] == 'y' && result3[1][1] == 'b' && result3[1][2] == 'n');
assert(result3[2][0] == 'z' && result3[2][1] == 'c' && result3[2][2] == 'o');
// Free allocated memory
for (int i = 0; i < 2; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %edx,%rdi
push %r13
mov %rdi,%r13
shl $0x3,%rdi
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
callq 10b0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 1630 <func0+0x90>
lea -0x1(%r13),%eax
movslq %ebx,%rbp
xor %r15d,%r15d
lea 0x4(,%rax,4),%r13
lea -0x1(%rbx),%eax
shl $0x2,%rbp
mov %eax,0xc(%rsp)
nopl 0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%r12,%r15,2)
test %ebx,%ebx
jle 1627 <func0+0x87>
mov 0xc(%rsp),%esi
xor %edx,%edx
nopw %cs:0x0(%rax,%rax,1)
mov (%r14,%rdx,8),%rcx
mov (%rcx,%r15,1),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rsi
jne 1610 <func0+0x70>
add $0x4,%r15
cmp %r13,%r15
jne 15f0 <func0+0x50>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
movsxd rbp, edx
push rbx
lea rdi, ds:0[rbp*8]
movsxd rbx, esi
sub rsp, 18h
mov [rsp+48h+var_3C], ebx
call _malloc
mov r12, rax
test ebp, ebp
jle short loc_161D
lea r13, ds:0[rbx*4]
shl rbp, 2
xor r14d, r14d
nop word ptr [rax+rax+00h]
loc_15E8:
mov rdi, r13
call _malloc
mov edx, [rsp+48h+var_3C]
mov [r12+r14*2], rax
test edx, edx
jle short loc_1614
xor edx, edx
xchg ax, ax
loc_1600:
mov rcx, [r15+rdx*8]
mov ecx, [rcx+r14]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rbx, rdx
jnz short loc_1600
loc_1614:
add r14, 4
cmp r14, rbp
jnz short loc_15E8
loc_161D:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2, int a3)
{
long long v3; // rbp
long long v4; // r12
long long v5; // rbp
long long v6; // r14
long long v7; // rax
long long i; // rdx
v3 = a3;
v4 = malloc(8LL * a3);
if ( (int)v3 > 0 )
{
v5 = 4 * v3;
v6 = 0LL;
do
{
v7 = malloc(4LL * a2);
*(_QWORD *)(v4 + 2 * v6) = v7;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(v7 + 4 * i) = *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + v6);
}
v6 += 4LL;
}
while ( v6 != v5 );
}
return v4;
} | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
LEA RDI,[RBP*0x8]
MOVSXD RBX,ESI
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EBX
CALL 0x001010b0
MOV R12,RAX
TEST EBP,EBP
JLE 0x0010161d
LEA R13,[RBX*0x4]
SHL RBP,0x2
XOR R14D,R14D
NOP word ptr [RAX + RAX*0x1]
LAB_001015e8:
MOV RDI,R13
CALL 0x001010b0
MOV EDX,dword ptr [RSP + 0xc]
MOV qword ptr [R12 + R14*0x2],RAX
TEST EDX,EDX
JLE 0x00101614
XOR EDX,EDX
NOP
LAB_00101600:
MOV RCX,qword ptr [R15 + RDX*0x8]
MOV ECX,dword ptr [RCX + R14*0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RBX,RDX
JNZ 0x00101600
LAB_00101614:
ADD R14,0x4
CMP R14,RBP
JNZ 0x001015e8
LAB_0010161d:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
void *pvVar2;
long lVar3;
long lVar4;
pvVar1 = malloc((long)param_3 * 8);
if (0 < param_3) {
lVar4 = 0;
do {
pvVar2 = malloc((long)param_2 * 4);
*(void **)((long)pvVar1 + lVar4 * 2) = pvVar2;
if (0 < param_2) {
lVar3 = 0;
do {
*(int4 *)((long)pvVar2 + lVar3 * 4) =
*(int4 *)(*(long *)(param_1 + lVar3 * 8) + lVar4);
lVar3 = lVar3 + 1;
} while (param_2 != lVar3);
}
lVar4 = lVar4 + 4;
} while (lVar4 != (long)param_3 * 4);
}
return pvVar1;
} |
6,343 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1[1][3] == 8);
int* test2[] = {(int[]){'x', 'y'}, (int[]){'a', 'b'}, (int[]){'m', 'n'}};
int** result2 = func0(test2, 3, 2);
assert(result2[0][0] == 'x' && result2[0][1] == 'a' && result2[0][2] == 'm');
assert(result2[1][0] == 'y' && result2[1][1] == 'b' && result2[1][2] == 'n');
int* test3[] = {(int[]){'x', 'y', 'z'}, (int[]){'a', 'b', 'c'}, (int[]){'m', 'n', 'o'}};
int** result3 = func0(test3, 3, 3);
assert(result3[0][0] == 'x' && result3[0][1] == 'a' && result3[0][2] == 'm');
assert(result3[1][0] == 'y' && result3[1][1] == 'b' && result3[1][2] == 'n');
assert(result3[2][0] == 'z' && result3[2][1] == 'c' && result3[2][2] == 'o');
// Free allocated memory
for (int i = 0; i < 2; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %edx,%rdi
push %r13
mov %rdi,%r13
shl $0x3,%rdi
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
callq 10b0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 1650 <func0+0x90>
lea -0x1(%r13),%eax
movslq %ebx,%rbp
xor %r15d,%r15d
lea 0x4(,%rax,4),%r13
lea -0x1(%rbx),%eax
shl $0x2,%rbp
mov %eax,0xc(%rsp)
nopl 0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%r12,%r15,2)
test %ebx,%ebx
jle 1647 <func0+0x87>
mov 0xc(%rsp),%esi
xor %edx,%edx
nopw %cs:0x0(%rax,%rax,1)
mov (%r14,%rdx,8),%rcx
mov (%rcx,%r15,1),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 1630 <func0+0x70>
add $0x4,%r15
cmp %r15,%r13
jne 1610 <func0+0x50>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
movsxd r12, edx
push rbp
lea rdi, ds:0[r12*8]; size
mov ebp, esi
push rbx
sub rsp, 18h
call _malloc
mov rbx, rax
test r12d, r12d
jle short loc_1645
movsxd r13, ebp
shl r12, 2
xor r14d, r14d
lea rax, ds:0[r13*4]
mov [rsp+48h+size], rax
nop word ptr [rax+rax+00000000h]
loc_1610:
mov rdi, [rsp+48h+size]; size
call _malloc
mov [rbx+r14*2], rax
test ebp, ebp
jle short loc_163C
xor edx, edx
nop dword ptr [rax+00h]
loc_1628:
mov rcx, [r15+rdx*8]
mov ecx, [rcx+r14]
mov [rax+rdx*4], ecx
add rdx, 1
cmp r13, rdx
jnz short loc_1628
loc_163C:
add r14, 4
cmp r12, r14
jnz short loc_1610
loc_1645:
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | char * func0(long long a1, int a2, int a3)
{
long long v3; // r12
char *v4; // rbx
long long v5; // r12
long long v6; // r14
_DWORD *v7; // rax
long long i; // rdx
v3 = a3;
v4 = (char *)malloc(8LL * a3);
if ( (int)v3 > 0 )
{
v5 = 4 * v3;
v6 = 0LL;
do
{
v7 = malloc(4LL * a2);
*(_QWORD *)&v4[2 * v6] = v7;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
v7[i] = *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + v6);
}
v6 += 4LL;
}
while ( v5 != v6 );
}
return v4;
} | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
LEA RDI,[R12*0x8]
MOV EBP,ESI
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
MOV RBX,RAX
TEST R12D,R12D
JLE 0x00101645
MOVSXD R13,EBP
SHL R12,0x2
XOR R14D,R14D
LEA RAX,[R13*0x4]
MOV qword ptr [RSP + 0x8],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101610:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001010b0
MOV qword ptr [RBX + R14*0x2],RAX
TEST EBP,EBP
JLE 0x0010163c
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101628:
MOV RCX,qword ptr [R15 + RDX*0x8]
MOV ECX,dword ptr [RCX + R14*0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP R13,RDX
JNZ 0x00101628
LAB_0010163c:
ADD R14,0x4
CMP R12,R14
JNZ 0x00101610
LAB_00101645:
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
void *pvVar2;
long lVar3;
long lVar4;
pvVar1 = malloc((long)param_3 * 8);
if (0 < param_3) {
lVar4 = 0;
do {
pvVar2 = malloc((long)param_2 * 4);
*(void **)((long)pvVar1 + lVar4 * 2) = pvVar2;
if (0 < param_2) {
lVar3 = 0;
do {
*(int4 *)((long)pvVar2 + lVar3 * 4) =
*(int4 *)(*(long *)(param_1 + lVar3 * 8) + lVar4);
lVar3 = lVar3 + 1;
} while (param_2 != lVar3);
}
lVar4 = lVar4 + 4;
} while ((long)param_3 * 4 != lVar4);
}
return pvVar1;
} |
6,344 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] > max) {
max = test_list.items[i].values[j];
}
}
res[i].key = test_list.items[i].key;
res[i].max_value = max;
}
return res;
}
| int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", a6, 2}};
KeyValueList kv2 = {items2, 3};
int a7[] = {5, 6, 7}, a8[] = {3, 6, 4}, a9[] = {11, 5};
KeyValue items3[] = {{"key1", a7, 3}, {"key2", a8, 3}, {"key3", a9, 2}};
KeyValueList kv3 = {items3, 3};
Result *result1 = func0(kv1);
Result *result2 = func0(kv2);
Result *result3 = func0(kv3);
assert(result1[0].max_value == 5 && result1[1].max_value == 4 && result1[2].max_value == 9);
assert(result2[0].max_value == 6 && result2[1].max_value == 5 && result2[2].max_value == 10);
assert(result3[0].max_value == 7 && result3[1].max_value == 6 && result3[2].max_value == 11);
free(result1);
free(result2);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x30(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x28(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 12f0 <func0+0x147>
mov -0x30(%rbp),%rcx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
add %rcx,%rax
mov 0x8(%rax),%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 1279 <func0+0xd0>
mov -0x30(%rbp),%rcx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
add %rcx,%rax
mov 0x8(%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x10(%rbp)
jge 1275 <func0+0xcc>
mov -0x30(%rbp),%rcx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
add %rcx,%rax
mov 0x8(%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0x30(%rbp),%rcx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
add %rcx,%rax
mov 0x10(%rax),%eax
cmp %eax,-0xc(%rbp)
jl 1213 <func0+0x6a>
mov -0x30(%rbp),%rcx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
add %rcx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%rax
mov %rax,(%rdx)
mov -0x14(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
mov %eax,0x8(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x28(%rbp),%eax
cmp %eax,-0x14(%rbp)
jl 11e7 <func0+0x3e>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_30], rax
mov [rbp+var_28], rdx
mov eax, dword ptr [rbp+var_28]
cdqe
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
jmp loc_12F0
loc_11E7:
mov rcx, [rbp+var_30]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
add rax, rcx
mov rax, [rax+8]
mov eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_C], 1
jmp short loc_1279
loc_1213:
mov rcx, [rbp+var_30]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
add rax, rcx
mov rax, [rax+8]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_10], eax
jge short loc_1275
mov rcx, [rbp+var_30]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
add rax, rcx
mov rax, [rax+8]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
loc_1275:
add [rbp+var_C], 1
loc_1279:
mov rcx, [rbp+var_30]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
add rax, rcx
mov eax, [rax+10h]
cmp [rbp+var_C], eax
jl loc_1213
mov rcx, [rbp+var_30]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
add rax, rcx
mov edx, [rbp+var_14]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_8]
add rdx, rcx
mov rax, [rax]
mov [rdx], rax
mov eax, [rbp+var_14]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_10]
mov [rdx+8], eax
add [rbp+var_14], 1
loc_12F0:
mov eax, dword ptr [rbp+var_28]
cmp [rbp+var_14], eax
jl loc_11E7
mov rax, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_QWORD *v6; // [rsp+28h] [rbp-8h]
v6 = malloc(16LL * a2);
for ( i = 0; i < a2; ++i )
{
v4 = **(_DWORD **)(a1 + 24LL * i + 8);
for ( j = 1; j < *(_DWORD *)(a1 + 24LL * i + 16); ++j )
{
if ( v4 < *(_DWORD *)(4LL * j + *(_QWORD *)(a1 + 24LL * i + 8)) )
v4 = *(_DWORD *)(4LL * j + *(_QWORD *)(a1 + 24LL * i + 8));
}
v6[2 * i] = *(_QWORD *)(a1 + 24LL * i);
LODWORD(v6[2 * i + 1]) = v4;
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012f0
LAB_001011e7:
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101279
LAB_00101213:
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x10],EAX
JGE 0x00101275
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
LAB_00101275:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101279:
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x10]
CMP dword ptr [RBP + -0xc],EAX
JL 0x00101213
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
ADD RAX,RCX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDX],RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RDX + 0x8],EAX
ADD dword ptr [RBP + -0x14],0x1
LAB_001012f0:
MOV EAX,dword ptr [RBP + -0x28]
CMP dword ptr [RBP + -0x14],EAX
JL 0x001011e7
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
void *pvVar1;
int local_1c;
int local_18;
int local_14;
pvVar1 = malloc((long)param_2 << 4);
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = **(int **)((long)local_1c * 0x18 + param_1 + 8);
for (local_14 = 1; local_14 < *(int *)((long)local_1c * 0x18 + param_1 + 0x10);
local_14 = local_14 + 1) {
if (local_18 < *(int *)(*(long *)((long)local_1c * 0x18 + param_1 + 8) + (long)local_14 * 4))
{
local_18 = *(int *)(*(long *)((long)local_1c * 0x18 + param_1 + 8) + (long)local_14 * 4);
}
}
*(int8 *)((long)pvVar1 + (long)local_1c * 0x10) =
*(int8 *)((long)local_1c * 0x18 + param_1);
*(int *)((long)pvVar1 + (long)local_1c * 0x10 + 8) = local_18;
}
return pvVar1;
} |
6,345 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] > max) {
max = test_list.items[i].values[j];
}
}
res[i].key = test_list.items[i].key;
res[i].max_value = max;
}
return res;
}
| int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", a6, 2}};
KeyValueList kv2 = {items2, 3};
int a7[] = {5, 6, 7}, a8[] = {3, 6, 4}, a9[] = {11, 5};
KeyValue items3[] = {{"key1", a7, 3}, {"key2", a8, 3}, {"key3", a9, 2}};
KeyValueList kv3 = {items3, 3};
Result *result1 = func0(kv1);
Result *result2 = func0(kv2);
Result *result3 = func0(kv3);
assert(result1[0].max_value == 5 && result1[1].max_value == 4 && result1[2].max_value == 9);
assert(result2[0].max_value == 6 && result2[1].max_value == 5 && result2[2].max_value == 10);
assert(result3[0].max_value == 7 && result3[1].max_value == 6 && result3[2].max_value == 11);
free(result1);
free(result2);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
movslq %esi,%rdi
shl $0x4,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1227 <func0+0x7e>
mov %rbp,%r8
mov %rax,%r9
lea -0x1(%rbx),%r11d
add $0x1,%r11
shl $0x4,%r11
add %rax,%r11
jmp 11f7 <func0+0x4e>
mov (%r10),%rdx
mov %rdx,(%r9)
mov %ecx,0x8(%r9)
add $0x18,%r8
add $0x10,%r9
cmp %r11,%r9
je 1227 <func0+0x7e>
mov %r8,%r10
mov 0x8(%r8),%rsi
mov (%rsi),%ecx
mov 0x10(%r8),%edi
cmp $0x1,%edi
jle 11e0 <func0+0x37>
lea 0x4(%rsi),%rdx
lea -0x2(%rdi),%edi
lea 0x8(%rsi,%rdi,4),%rdi
mov (%rdx),%esi
cmp %esi,%ecx
cmovl %esi,%ecx
add $0x4,%rdx
cmp %rdi,%rdx
jne 1215 <func0+0x6c>
jmp 11e0 <func0+0x37>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
movsxd rdi, esi
shl rdi, 4
call _malloc
mov r11, rax
test ebx, ebx
jle short loc_1220
mov rdi, rbp
mov r8, rax
mov ebx, ebx
shl rbx, 4
lea r9, [rbx+rax]
loc_11DC:
mov r10, rdi
mov rcx, [rdi+8]
mov edx, [rcx]
mov esi, [rdi+10h]
cmp esi, 1
jle short loc_1209
lea rax, [rcx+4]
lea esi, [rsi-2]
lea rsi, [rcx+rsi*4+8]
loc_11F9:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_11F9
loc_1209:
mov rax, [r10]
mov [r8], rax
mov [r8+8], edx
add rdi, 18h
add r8, 10h
cmp r8, r9
jnz short loc_11DC
loc_1220:
mov rax, r11
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // r11
long long v4; // r8
long long v5; // r9
int *v6; // rcx
int v7; // edx
int v8; // esi
int *v9; // rax
long long v10; // rsi
v2 = malloc(16LL * a2);
v3 = v2;
if ( a2 > 0 )
{
v4 = v2;
v5 = 16LL * (unsigned int)a2 + v2;
do
{
v6 = *(int **)(a1 + 8);
v7 = *v6;
v8 = *(_DWORD *)(a1 + 16);
if ( v8 > 1 )
{
v9 = v6 + 1;
v10 = (long long)&v6[v8 - 2 + 2];
do
{
if ( v7 < *v9 )
v7 = *v9;
++v9;
}
while ( v9 != (int *)v10 );
}
*(_QWORD *)v4 = *(_QWORD *)a1;
*(_DWORD *)(v4 + 8) = v7;
a1 += 24LL;
v4 += 16LL;
}
while ( v4 != v5 );
}
return v3;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOVSXD RDI,ESI
SHL RDI,0x4
CALL 0x001010b0
MOV R11,RAX
TEST EBX,EBX
JLE 0x00101220
MOV RDI,RBP
MOV R8,RAX
MOV EBX,EBX
SHL RBX,0x4
LEA R9,[RBX + RAX*0x1]
LAB_001011dc:
MOV R10,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV EDX,dword ptr [RCX]
MOV ESI,dword ptr [RDI + 0x10]
CMP ESI,0x1
JLE 0x00101209
LEA RAX,[RCX + 0x4]
LEA ESI,[RSI + -0x2]
LEA RSI,[RCX + RSI*0x4 + 0x8]
LAB_001011f9:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001011f9
LAB_00101209:
MOV RAX,qword ptr [R10]
MOV qword ptr [R8],RAX
MOV dword ptr [R8 + 0x8],EDX
ADD RDI,0x18
ADD R8,0x10
CMP R8,R9
JNZ 0x001011dc
LAB_00101220:
MOV RAX,R11
ADD RSP,0x8
POP RBX
POP RBP
RET | int8 * func0(int8 *param_1,uint param_2)
{
int *piVar1;
int8 *puVar2;
int *piVar3;
int iVar4;
int8 *puVar5;
puVar2 = (int8 *)malloc((long)(int)param_2 << 4);
if (0 < (int)param_2) {
puVar5 = puVar2;
do {
piVar1 = (int *)param_1[1];
iVar4 = *piVar1;
if (1 < *(int *)(param_1 + 2)) {
piVar3 = piVar1 + 1;
do {
if (iVar4 < *piVar3) {
iVar4 = *piVar3;
}
piVar3 = piVar3 + 1;
} while (piVar3 != piVar1 + (ulong)(*(int *)(param_1 + 2) - 2) + 2);
}
*puVar5 = *param_1;
*(int *)(puVar5 + 1) = iVar4;
param_1 = param_1 + 3;
puVar5 = puVar5 + 2;
} while (puVar5 != puVar2 + (ulong)param_2 * 2);
}
return puVar2;
} |
6,346 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] > max) {
max = test_list.items[i].values[j];
}
}
res[i].key = test_list.items[i].key;
res[i].max_value = max;
}
return res;
}
| int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", a6, 2}};
KeyValueList kv2 = {items2, 3};
int a7[] = {5, 6, 7}, a8[] = {3, 6, 4}, a9[] = {11, 5};
KeyValue items3[] = {{"key1", a7, 3}, {"key2", a8, 3}, {"key3", a9, 2}};
KeyValueList kv3 = {items3, 3};
Result *result1 = func0(kv1);
Result *result2 = func0(kv2);
Result *result3 = func0(kv3);
assert(result1[0].max_value == 5 && result1[1].max_value == 4 && result1[2].max_value == 9);
assert(result2[0].max_value == 6 && result2[1].max_value == 5 && result2[2].max_value == 10);
assert(result3[0].max_value == 7 && result3[1].max_value == 6 && result3[2].max_value == 11);
free(result1);
free(result2);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x4,%rdi
mov %rsi,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1550 <func0+0x80>
lea -0x1(%rbx),%r10d
mov %rbp,%r8
mov %rax,%r9
add $0x1,%r10
shl $0x4,%r10
add %rax,%r10
nopl (%rax)
mov 0x8(%r8),%rsi
mov 0x10(%r8),%edi
mov (%rsi),%ecx
cmp $0x1,%edi
jle 1538 <func0+0x68>
sub $0x2,%edi
lea 0x4(%rsi),%rdx
lea 0x8(%rsi,%rdi,4),%rdi
nopl 0x0(%rax,%rax,1)
mov (%rdx),%esi
cmp %esi,%ecx
cmovl %esi,%ecx
add $0x4,%rdx
cmp %rdx,%rdi
jne 1528 <func0+0x58>
mov (%r8),%rdx
mov %ecx,0x8(%r9)
add $0x10,%r9
add $0x18,%r8
mov %rdx,-0x10(%r9)
cmp %r10,%r9
jne 1508 <func0+0x38>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
movsxd rdi, esi
shl rdi, 4
sub rsp, 8
call _malloc
mov r10, rax
test ebp, ebp
jle short loc_1550
mov ebp, ebp
mov rdi, rbx
mov r8, rax
shl rbp, 4
lea r9, [rbp+rax+0]
nop dword ptr [rax+00h]
loc_1508:
mov rcx, [rdi+8]
mov esi, [rdi+10h]
mov edx, [rcx]
cmp esi, 1
jle short loc_1538
sub esi, 2
lea rax, [rcx+4]
lea rsi, [rcx+rsi*4+8]
nop word ptr [rax+rax+00h]
loc_1528:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rsi, rax
jnz short loc_1528
loc_1538:
mov rax, [rdi]
mov [r8+8], edx
add r8, 10h
add rdi, 18h
mov [r8-10h], rax
cmp r8, r9
jnz short loc_1508
loc_1550:
add rsp, 8
mov rax, r10
pop rbx
pop rbp
retn | long long func0(long long *a1, int a2)
{
long long v2; // rax
long long v3; // r10
long long v4; // r8
long long v5; // r9
int *v6; // rcx
int v7; // esi
int v8; // edx
int *v9; // rax
long long v10; // rsi
long long v11; // rax
v2 = malloc(16LL * a2);
v3 = v2;
if ( a2 > 0 )
{
v4 = v2;
v5 = 16LL * (unsigned int)a2 + v2;
do
{
v6 = (int *)a1[1];
v7 = *((_DWORD *)a1 + 4);
v8 = *v6;
if ( v7 > 1 )
{
v9 = v6 + 1;
v10 = (long long)&v6[v7 - 2 + 2];
do
{
if ( v8 < *v9 )
v8 = *v9;
++v9;
}
while ( (int *)v10 != v9 );
}
v11 = *a1;
*(_DWORD *)(v4 + 8) = v8;
v4 += 16LL;
a1 += 3;
*(_QWORD *)(v4 - 16) = v11;
}
while ( v4 != v5 );
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
SHL RDI,0x4
SUB RSP,0x8
CALL 0x001010b0
MOV R10,RAX
TEST EBP,EBP
JLE 0x00101550
MOV EBP,EBP
MOV RDI,RBX
MOV R8,RAX
SHL RBP,0x4
LEA R9,[RBP + RAX*0x1]
NOP dword ptr [RAX]
LAB_00101508:
MOV RCX,qword ptr [RDI + 0x8]
MOV ESI,dword ptr [RDI + 0x10]
MOV EDX,dword ptr [RCX]
CMP ESI,0x1
JLE 0x00101538
SUB ESI,0x2
LEA RAX,[RCX + 0x4]
LEA RSI,[RCX + RSI*0x4 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101528:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x00101528
LAB_00101538:
MOV RAX,qword ptr [RDI]
MOV dword ptr [R8 + 0x8],EDX
ADD R8,0x10
ADD RDI,0x18
MOV qword ptr [R8 + -0x10],RAX
CMP R8,R9
JNZ 0x00101508
LAB_00101550:
ADD RSP,0x8
MOV RAX,R10
POP RBX
POP RBP
RET | int8 * func0(int8 *param_1,uint param_2)
{
int *piVar1;
int8 uVar2;
int8 *puVar3;
int *piVar4;
int iVar5;
int8 *puVar6;
int8 *puVar7;
puVar3 = (int8 *)malloc((long)(int)param_2 << 4);
if (0 < (int)param_2) {
puVar6 = puVar3;
do {
piVar1 = (int *)param_1[1];
iVar5 = *piVar1;
if (1 < *(int *)(param_1 + 2)) {
piVar4 = piVar1 + 1;
do {
if (iVar5 < *piVar4) {
iVar5 = *piVar4;
}
piVar4 = piVar4 + 1;
} while (piVar1 + (ulong)(*(int *)(param_1 + 2) - 2) + 2 != piVar4);
}
uVar2 = *param_1;
*(int *)(puVar6 + 1) = iVar5;
puVar7 = puVar6 + 2;
param_1 = param_1 + 3;
*puVar6 = uVar2;
puVar6 = puVar7;
} while (puVar7 != puVar3 + (ulong)param_2 * 2);
}
return puVar3;
} |
6,347 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] > max) {
max = test_list.items[i].values[j];
}
}
res[i].key = test_list.items[i].key;
res[i].max_value = max;
}
return res;
}
| int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", a6, 2}};
KeyValueList kv2 = {items2, 3};
int a7[] = {5, 6, 7}, a8[] = {3, 6, 4}, a9[] = {11, 5};
KeyValue items3[] = {{"key1", a7, 3}, {"key2", a8, 3}, {"key3", a9, 2}};
KeyValueList kv3 = {items3, 3};
Result *result1 = func0(kv1);
Result *result2 = func0(kv2);
Result *result3 = func0(kv3);
assert(result1[0].max_value == 5 && result1[1].max_value == 4 && result1[2].max_value == 9);
assert(result2[0].max_value == 6 && result2[1].max_value == 5 && result2[2].max_value == 10);
assert(result3[0].max_value == 7 && result3[1].max_value == 6 && result3[2].max_value == 11);
free(result1);
free(result2);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x4,%rdi
mov %rsi,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 164a <func0+0x14a>
lea -0x1(%rbx),%r11d
mov %rbp,%rdi
mov %rax,%r8
add $0x1,%r11
shl $0x4,%r11
add %rax,%r11
nopl 0x0(%rax)
mov 0x8(%rdi),%rsi
mov 0x10(%rdi),%r9d
mov (%rsi),%edx
cmp $0x1,%r9d
jle 162e <func0+0x12e>
lea -0x2(%r9),%ecx
lea -0x1(%r9),%r10d
cmp $0x2,%ecx
jbe 1651 <func0+0x151>
mov %r10d,%ecx
movd %edx,%xmm3
mov %rsi,%rdx
shr $0x2,%ecx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rcx
add %rsi,%rcx
xchg %ax,%ax
movdqu 0x4(%rdx),%xmm0
add $0x10,%rdx
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rcx,%rdx
jne 1580 <func0+0x80>
movdqa %xmm2,%xmm0
mov %r10d,%ebx
psrldq $0x8,%xmm0
and $0xfffffffc,%ebx
movdqa %xmm0,%xmm1
lea 0x1(%rbx),%ecx
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%edx
cmp %r10d,%ebx
je 162e <func0+0x12e>
movslq %ecx,%r10
lea 0x0(,%r10,4),%rbx
mov (%rsi,%r10,4),%r10d
cmp %r10d,%edx
cmovl %r10d,%edx
lea 0x1(%rcx),%r10d
cmp %r9d,%r10d
jge 162e <func0+0x12e>
mov 0x4(%rsi,%rbx,1),%r10d
cmp %r10d,%edx
cmovl %r10d,%edx
add $0x2,%ecx
cmp %ecx,%r9d
jle 162e <func0+0x12e>
mov 0x8(%rsi,%rbx,1),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
mov (%rdi),%rcx
mov %edx,0x8(%r8)
add $0x10,%r8
add $0x18,%rdi
mov %rcx,-0x10(%r8)
cmp %r11,%r8
jne 1540 <func0+0x40>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
mov $0x1,%ecx
jmp 15f2 <func0+0xf2>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
movsxd r10, esi
mov r12, rdi
push rbp
shl r10, 4
push rbx
mov rdi, r10; size
mov rbx, rsi
mov rbp, r10
call _malloc
mov r11, rax
test ebx, ebx
jle loc_1640
mov rsi, r12
mov r8, rax
lea r10, [rbp+rax+0]
nop word ptr [rax+rax+00000000h]
loc_1540:
mov rdi, [rsi+8]
mov r9d, [rsi+10h]
mov eax, [rdi]
cmp r9d, 1
jle loc_1624
lea edx, [r9-2]
lea ecx, [r9-1]
cmp edx, 2
jbe loc_1648
mov edx, ecx
movd xmm3, eax
mov rax, rdi
shr edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax]
loc_1580:
movdqu xmm0, xmmword ptr [rax+4]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_1580
movdqa xmm1, xmm2
psrldq xmm1, 8
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 cl, 3
jz short loc_1624
and ecx, 0FFFFFFFCh
add ecx, 1
loc_15EF:
movsxd rdx, ecx
lea rbx, ds:0[rdx*4]
mov edx, [rdi+rdx*4]
cmp eax, edx
cmovl eax, edx
lea edx, [rcx+1]
cmp edx, r9d
jge short loc_1624
mov edx, [rdi+rbx+4]
cmp eax, edx
cmovl eax, edx
add ecx, 2
cmp r9d, ecx
jle short loc_1624
mov edx, [rdi+rbx+8]
cmp eax, edx
cmovl eax, edx
loc_1624:
mov rdx, [rsi]
mov [r8+8], eax
add r8, 10h
add rsi, 18h
mov [r8-10h], rdx
cmp r8, r10
jnz loc_1540
loc_1640:
pop rbx
mov rax, r11
pop rbp
pop r12
retn
loc_1648:
mov ecx, 1
jmp short loc_15EF | char * func0(long long *a1, int a2)
{
size_t v2; // rbp
char *v3; // rax
char *v4; // r11
char *v6; // r8
char *v7; // r10
signed int *v8; // rdi
int v9; // r9d
signed int v10; // eax
unsigned int v11; // ecx
__m128i v12; // xmm3
long long v13; // rax
__m128i v14; // xmm2
__m128i v15; // xmm0
__m128i v16; // xmm1
__m128i v17; // xmm1
__m128i v18; // xmm0
__m128i v19; // xmm0
__m128i v20; // xmm2
__m128i v21; // xmm1
signed int v22; // ecx
long long v23; // rbx
long long v24; // rdx
v2 = 16LL * a2;
v3 = (char *)malloc(v2);
v4 = v3;
if ( a2 > 0 )
{
v6 = v3;
v7 = &v3[v2];
do
{
v8 = (signed int *)a1[1];
v9 = *((_DWORD *)a1 + 4);
v10 = *v8;
if ( v9 > 1 )
{
v11 = v9 - 1;
if ( (unsigned int)(v9 - 2) <= 2 )
{
v22 = 1;
goto LABEL_9;
}
v12 = _mm_cvtsi32_si128(v10);
v13 = a1[1];
v14 = _mm_shuffle_epi32(v12, 0);
do
{
v15 = _mm_loadu_si128((const __m128i *)(v13 + 4));
v13 += 16LL;
v16 = _mm_cmpgt_epi32(v15, v14);
v14 = _mm_or_si128(_mm_andnot_si128(v16, v14), _mm_and_si128(v15, v16));
}
while ( (signed int *)v13 != &v8[4 * (v11 >> 2)] );
v17 = _mm_srli_si128(v14, 8);
v18 = _mm_cmpgt_epi32(v17, v14);
v19 = _mm_or_si128(_mm_andnot_si128(v18, v14), _mm_and_si128(v17, v18));
v20 = _mm_srli_si128(v19, 4);
v21 = _mm_cmpgt_epi32(v20, v19);
v10 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v21, v19), _mm_and_si128(v20, v21)));
if ( (v11 & 3) != 0 )
{
v22 = (v11 & 0xFFFFFFFC) + 1;
LABEL_9:
v23 = v22;
if ( v10 < v8[v23] )
v10 = v8[v22];
if ( v22 + 1 < v9 )
{
if ( v10 < v8[v23 + 1] )
v10 = v8[v23 + 1];
if ( v9 > v22 + 2 && v10 < v8[v23 + 2] )
v10 = v8[v23 + 2];
}
}
}
v24 = *a1;
*((_DWORD *)v6 + 2) = v10;
v6 += 16;
a1 += 3;
*((_QWORD *)v6 - 2) = v24;
}
while ( v6 != v7 );
}
return v4;
} | func0:
ENDBR64
PUSH R12
MOVSXD R10,ESI
MOV R12,RDI
PUSH RBP
SHL R10,0x4
PUSH RBX
MOV RDI,R10
MOV RBX,RSI
MOV RBP,R10
CALL 0x001010b0
MOV R11,RAX
TEST EBX,EBX
JLE 0x00101640
MOV RSI,R12
MOV R8,RAX
LEA R10,[RBP + RAX*0x1]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101540:
MOV RDI,qword ptr [RSI + 0x8]
MOV R9D,dword ptr [RSI + 0x10]
MOV EAX,dword ptr [RDI]
CMP R9D,0x1
JLE 0x00101624
LEA EDX,[R9 + -0x2]
LEA ECX,[R9 + -0x1]
CMP EDX,0x2
JBE 0x00101648
MOV EDX,ECX
MOVD XMM3,EAX
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101580:
MOVDQU XMM0,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x00101580
MOVDQA XMM1,XMM2
PSRLDQ XMM1,0x8
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 CL,0x3
JZ 0x00101624
AND ECX,0xfffffffc
ADD ECX,0x1
LAB_001015ef:
MOVSXD RDX,ECX
LEA RBX,[RDX*0x4]
MOV EDX,dword ptr [RDI + RDX*0x4]
CMP EAX,EDX
CMOVL EAX,EDX
LEA EDX,[RCX + 0x1]
CMP EDX,R9D
JGE 0x00101624
MOV EDX,dword ptr [RDI + RBX*0x1 + 0x4]
CMP EAX,EDX
CMOVL EAX,EDX
ADD ECX,0x2
CMP R9D,ECX
JLE 0x00101624
MOV EDX,dword ptr [RDI + RBX*0x1 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_00101624:
MOV RDX,qword ptr [RSI]
MOV dword ptr [R8 + 0x8],EAX
ADD R8,0x10
ADD RSI,0x18
MOV qword ptr [R8 + -0x10],RDX
CMP R8,R10
JNZ 0x00101540
LAB_00101640:
POP RBX
MOV RAX,R11
POP RBP
POP R12
RET
LAB_00101648:
MOV ECX,0x1
JMP 0x001015ef | int8 * func0(int8 *param_1,int param_2)
{
uint uVar1;
uint *puVar2;
int iVar3;
uint *puVar4;
int8 uVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
int8 *puVar10;
uint *puVar11;
int iVar12;
int8 *puVar13;
int8 *puVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
puVar10 = (int8 *)malloc((long)param_2 * 0x10);
if (0 < param_2) {
puVar13 = puVar10;
do {
puVar4 = (uint *)param_1[1];
iVar3 = *(int *)(param_1 + 2);
uVar9 = *puVar4;
if (1 < iVar3) {
uVar1 = iVar3 - 1;
if (iVar3 - 2U < 3) {
iVar12 = 1;
}
else {
puVar11 = puVar4;
uVar20 = uVar9;
uVar16 = uVar9;
uVar21 = uVar9;
do {
puVar2 = puVar11 + 1;
puVar6 = puVar11 + 2;
puVar7 = puVar11 + 3;
puVar8 = puVar11 + 4;
puVar11 = puVar11 + 4;
uVar15 = -(uint)((int)uVar9 < (int)*puVar2);
uVar17 = -(uint)((int)uVar20 < (int)*puVar6);
uVar18 = -(uint)((int)uVar16 < (int)*puVar7);
uVar19 = -(uint)((int)uVar21 < (int)*puVar8);
uVar9 = ~uVar15 & uVar9 | *puVar2 & uVar15;
uVar20 = ~uVar17 & uVar20 | *puVar6 & uVar17;
uVar16 = ~uVar18 & uVar16 | *puVar7 & uVar18;
uVar21 = ~uVar19 & uVar21 | *puVar8 & uVar19;
} while (puVar11 != puVar4 + (ulong)(uVar1 >> 2) * 4);
uVar9 = ~-(uint)((int)uVar9 < (int)uVar16) & uVar9 |
uVar16 & -(uint)((int)uVar9 < (int)uVar16);
uVar20 = ~-(uint)((int)uVar20 < (int)uVar21) & uVar20 |
uVar21 & -(uint)((int)uVar20 < (int)uVar21);
uVar16 = -(uint)((int)uVar9 < (int)uVar20);
uVar9 = ~uVar16 & uVar9 | uVar20 & uVar16;
if ((uVar1 & 3) == 0) goto LAB_00101624;
iVar12 = (uVar1 & 0xfffffffc) + 1;
}
if ((int)uVar9 < (int)puVar4[iVar12]) {
uVar9 = puVar4[iVar12];
}
if (iVar12 + 1 < iVar3) {
if ((int)uVar9 < (int)puVar4[(long)iVar12 + 1]) {
uVar9 = puVar4[(long)iVar12 + 1];
}
if ((iVar12 + 2 < iVar3) && ((int)uVar9 < (int)puVar4[(long)iVar12 + 2])) {
uVar9 = puVar4[(long)iVar12 + 2];
}
}
}
LAB_00101624:
uVar5 = *param_1;
*(uint *)(puVar13 + 1) = uVar9;
puVar14 = puVar13 + 2;
param_1 = param_1 + 3;
*puVar13 = uVar5;
puVar13 = puVar14;
} while (puVar14 != puVar10 + (long)param_2 * 2);
}
return puVar10;
} |
6,348 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes, 3) == 30);
assert(func0(list2, list2_sizes, 3) == 37);
assert(func0(list3, list3_sizes, 3) == 44);
printf("All test cases passed.\n");
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,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 1201 <func0+0x78>
movl $0x0,-0x4(%rbp)
jmp 11e2 <func0+0x59>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jl 11b5 <func0+0x2c>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11ac <func0+0x23>
mov -0xc(%rbp),%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_C], 0
mov [rbp+var_8], 0
jmp short loc_1201
loc_11AC:
mov [rbp+var_4], 0
jmp short loc_11E2
loc_11B5:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_C], eax
add [rbp+var_4], 1
loc_11E2:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jl short loc_11B5
add [rbp+var_8], 1
loc_1201:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_24]
jl short loc_11AC
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, long long a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-Ch]
int i; // [rsp+1Ch] [rbp-8h]
int j; // [rsp+20h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a3; ++i )
{
for ( j = 0; j < *(_DWORD *)(4LL * i + a2); ++j )
v4 += *(_DWORD *)(a1 + 40LL * i + 4LL * j);
}
return v4;
} | 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 + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101201
LAB_001011ac:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e2
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011e2:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011b5
ADD dword ptr [RBP + -0x8],0x1
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011ac
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,long param_2,int param_3)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_3; local_10 = local_10 + 1) {
for (local_c = 0; local_c < *(int *)(param_2 + (long)local_10 * 4); local_c = local_c + 1) {
local_14 = local_14 + *(int *)((long)local_10 * 0x28 + param_1 + (long)local_c * 4);
}
}
return local_14;
} |
6,349 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes, 3) == 30);
assert(func0(list2, list2_sizes, 3) == 37);
assert(func0(list3, list3_sizes, 3) == 44);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 11cf <func0+0x46>
mov %rsi,%r8
lea -0x1(%rdx),%eax
lea 0x4(%rsi,%rax,4),%rsi
mov $0x0,%edx
jmp 11c6 <func0+0x3d>
lea -0x1(%rax),%eax
lea 0x4(%rdi,%rax,4),%rcx
mov %rdi,%rax
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 11ae <func0+0x25>
add $0x4,%r8
add $0x28,%rdi
cmp %rsi,%r8
je 11d4 <func0+0x4b>
mov (%r8),%eax
test %eax,%eax
jg 11a3 <func0+0x1a>
jmp 11b9 <func0+0x30>
mov $0x0,%edx
mov %edx,%eax
retq
| func0:
endbr64
test edx, edx
jle short loc_11CF
mov r8, rsi
lea eax, [rdx-1]
lea rsi, [rsi+rax*4+4]
mov edx, 0
jmp short loc_11C6
loc_11A3:
lea eax, [rax-1]
lea rcx, [rdi+rax*4+4]
mov rax, rdi
loc_11AE:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_11AE
loc_11B9:
add r8, 4
add rdi, 28h ; '('
cmp r8, rsi
jz short loc_11D4
loc_11C6:
mov eax, [r8]
test eax, eax
jg short loc_11A3
jmp short loc_11B9
loc_11CF:
mov edx, 0
loc_11D4:
mov eax, edx
retn | long long func0(_DWORD *a1, int *a2, int a3)
{
int *v3; // r8
long long v4; // rsi
unsigned int v5; // edx
_DWORD *v6; // rax
if ( a3 <= 0 )
{
return 0;
}
else
{
v3 = a2;
v4 = (long long)&a2[a3 - 1 + 1];
v5 = 0;
do
{
if ( *v3 > 0 )
{
v6 = a1;
do
v5 += *v6++;
while ( v6 != &a1[*v3 - 1 + 1] );
}
++v3;
a1 += 10;
}
while ( v3 != (int *)v4 );
}
return v5;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011cf
MOV R8,RSI
LEA EAX,[RDX + -0x1]
LEA RSI,[RSI + RAX*0x4 + 0x4]
MOV EDX,0x0
JMP 0x001011c6
LAB_001011a3:
LEA EAX,[RAX + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV RAX,RDI
LAB_001011ae:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011ae
LAB_001011b9:
ADD R8,0x4
ADD RDI,0x28
CMP R8,RSI
JZ 0x001011d4
LAB_001011c6:
MOV EAX,dword ptr [R8]
TEST EAX,EAX
JG 0x001011a3
JMP 0x001011b9
LAB_001011cf:
MOV EDX,0x0
LAB_001011d4:
MOV EAX,EDX
RET | int func0(int *param_1,int *param_2,int param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
if (param_3 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
iVar3 = 0;
do {
if (0 < *param_2) {
piVar2 = param_1;
do {
iVar3 = iVar3 + *piVar2;
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(*param_2 - 1) + 1);
}
param_2 = param_2 + 1;
param_1 = param_1 + 10;
} while (param_2 != piVar1);
}
return iVar3;
} |
6,350 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes, 3) == 30);
assert(func0(list2, list2_sizes, 3) == 37);
assert(func0(list3, list3_sizes, 3) == 44);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 147d <func0+0x4d>
lea -0x1(%rdx),%eax
xor %r8d,%r8d
lea 0x4(%rsi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rsi),%eax
test %eax,%eax
jle 146c <func0+0x3c>
sub $0x1,%eax
lea 0x4(%rdi,%rax,4),%rdx
mov %rdi,%rax
nopl 0x0(%rax)
add (%rax),%r8d
add $0x4,%rax
cmp %rax,%rdx
jne 1460 <func0+0x30>
add $0x4,%rsi
add $0x28,%rdi
cmp %rcx,%rsi
jne 1448 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test edx, edx
jle short loc_141D
lea eax, [rdx-1]
xor r8d, r8d
lea rcx, [rsi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_13E8:
mov eax, [rsi]
test eax, eax
jle short loc_140C
sub eax, 1
lea rdx, [rdi+rax*4+4]
mov rax, rdi
nop dword ptr [rax+00000000h]
loc_1400:
add r8d, [rax]
add rax, 4
cmp rax, rdx
jnz short loc_1400
loc_140C:
add rsi, 4
add rdi, 28h ; '('
cmp rsi, rcx
jnz short loc_13E8
mov eax, r8d
retn
loc_141D:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_DWORD *a1, int *a2, int a3)
{
unsigned int v3; // r8d
long long v4; // rcx
_DWORD *v5; // rax
if ( a3 <= 0 )
return 0LL;
v3 = 0;
v4 = (long long)&a2[a3 - 1 + 1];
do
{
if ( *a2 > 0 )
{
v5 = a1;
do
v3 += *v5++;
while ( v5 != &a1[*a2 - 1 + 1] );
}
++a2;
a1 += 10;
}
while ( a2 != (int *)v4 );
return v3;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010141d
LEA EAX,[RDX + -0x1]
XOR R8D,R8D
LEA RCX,[RSI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e8:
MOV EAX,dword ptr [RSI]
TEST EAX,EAX
JLE 0x0010140c
SUB EAX,0x1
LEA RDX,[RDI + RAX*0x4 + 0x4]
MOV RAX,RDI
NOP dword ptr [RAX]
LAB_00101400:
ADD R8D,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101400
LAB_0010140c:
ADD RSI,0x4
ADD RDI,0x28
CMP RSI,RCX
JNZ 0x001013e8
MOV EAX,R8D
RET
LAB_0010141d:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int *param_1,int *param_2,int param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
if (0 < param_3) {
iVar3 = 0;
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
do {
if (0 < *param_2) {
piVar2 = param_1;
do {
iVar3 = iVar3 + *piVar2;
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(*param_2 - 1) + 1);
}
param_2 = param_2 + 1;
param_1 = param_1 + 10;
} while (param_2 != piVar1);
return iVar3;
}
return 0;
} |
6,351 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes, 3) == 30);
assert(func0(list2, list2_sizes, 3) == 37);
assert(func0(list3, list3_sizes, 3) == 44);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 16d6 <func0+0xe6>
lea -0x1(%rdx),%eax
xor %r8d,%r8d
lea 0x4(%rsi,%rax,4),%r10
nopw 0x0(%rax,%rax,1)
mov (%rsi),%edx
test %edx,%edx
jle 16bd <func0+0xcd>
lea -0x1(%rdx),%eax
cmp $0x3,%eax
jbe 16d2 <func0+0xe2>
mov %edx,%eax
movdqu (%rdi),%xmm0
shr $0x2,%eax
cmp $0x1,%eax
je 1663 <func0+0x73>
movdqu 0x10(%rdi),%xmm2
paddd %xmm2,%xmm0
cmp $0x2,%eax
je 1663 <func0+0x73>
xor %ecx,%ecx
mov %rcx,%r9
add $0x1,%rcx
shl $0x4,%r9
movdqu 0x20(%rdi,%r9,1),%xmm1
lea 0x2(%rcx),%r9d
paddd %xmm1,%xmm0
cmp %r9d,%eax
ja 1644 <func0+0x54>
movdqa %xmm0,%xmm1
psrldq $0x8,%xmm1
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
add %eax,%r8d
mov %edx,%eax
and $0xfffffffc,%eax
test $0x3,%dl
je 16bd <func0+0xcd>
movslq %eax,%rcx
lea 0x1(%rax),%r9d
lea (%rdi,%rcx,4),%rcx
add (%rcx),%r8d
cmp %edx,%r9d
jge 16bd <func0+0xcd>
lea 0x2(%rax),%r9d
add 0x4(%rcx),%r8d
cmp %r9d,%edx
jle 16bd <func0+0xcd>
add $0x3,%eax
add 0x8(%rcx),%r8d
cmp %eax,%edx
jle 16bd <func0+0xcd>
add 0xc(%rcx),%r8d
add $0x4,%rsi
add $0x28,%rdi
cmp %rsi,%r10
jne 1610 <func0+0x20>
mov %r8d,%eax
retq
xor %eax,%eax
jmp 168e <func0+0x9e>
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
test edx, edx
jle loc_16A5
mov r8, rsi
movsxd rdx, edx
mov rsi, rdi
xor ecx, ecx
lea r10, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_15F0:
mov edx, [r8]
test edx, edx
jle loc_168D
lea eax, [rdx-1]
cmp eax, 2
jbe loc_16A1
mov eax, edx
movdqu xmm0, xmmword ptr [rsi]
shr eax, 2
cmp eax, 1
jz short loc_1644
movdqu xmm2, xmmword ptr [rsi+10h]
paddd xmm0, xmm2
cmp eax, 2
jz short loc_1644
xor edi, edi
loc_1625:
mov r9, rdi
add rdi, 1
shl r9, 4
movdqu xmm1, xmmword ptr [rsi+r9+20h]
lea r9d, [rdi+2]
paddd xmm0, xmm1
cmp r9d, eax
jb short loc_1625
loc_1644:
movdqa xmm1, xmm0
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
add ecx, eax
mov eax, edx
and eax, 0FFFFFFFCh
test dl, 3
jz short loc_168D
loc_166E:
movsxd rdi, eax
lea r9d, [rax+1]
lea rdi, [rsi+rdi*4]
add ecx, [rdi]
cmp r9d, edx
jge short loc_168D
add eax, 2
add ecx, [rdi+4]
cmp edx, eax
jle short loc_168D
add ecx, [rdi+8]
loc_168D:
add r8, 4
add rsi, 28h ; '('
cmp r10, r8
jnz loc_15F0
mov eax, ecx
retn
loc_16A1:
xor eax, eax
jmp short loc_166E
loc_16A5:
xor ecx, ecx
mov eax, ecx
retn | long long func0(const __m128i *a1, int *a2, int a3)
{
unsigned int v5; // ecx
int *v6; // r10
int v7; // edx
__m128i v8; // xmm0
unsigned int v9; // eax
long long v10; // rdi
long long v11; // r9
__m128i v12; // xmm0
signed int v13; // eax
__int32 *v14; // rdi
if ( a3 > 0 )
{
v5 = 0;
v6 = &a2[a3];
while ( 1 )
{
v7 = *a2;
if ( *a2 > 0 )
{
if ( (unsigned int)(v7 - 1) <= 2 )
{
v13 = 0;
}
else
{
v8 = _mm_loadu_si128(a1);
v9 = (unsigned int)v7 >> 2;
if ( (unsigned int)v7 >> 2 != 1 )
{
v8 = _mm_add_epi32(v8, _mm_loadu_si128(a1 + 1));
if ( v9 != 2 )
{
v10 = 0LL;
do
{
v11 = v10++;
v8 = _mm_add_epi32(v8, _mm_loadu_si128(&a1[v11 + 2]));
}
while ( (int)v10 + 2 < v9 );
}
}
v12 = _mm_add_epi32(v8, _mm_srli_si128(v8, 8));
v5 += _mm_cvtsi128_si32(_mm_add_epi32(v12, _mm_srli_si128(v12, 4)));
v13 = v7 & 0xFFFFFFFC;
if ( (v7 & 3) == 0 )
goto LABEL_13;
}
v14 = &a1->m128i_i32[v13];
v5 += *v14;
if ( v13 + 1 < v7 )
{
v5 += v14[1];
if ( v7 > v13 + 2 )
v5 += v14[2];
}
}
LABEL_13:
++a2;
a1 = (const __m128i *)((char *)a1 + 40);
if ( v6 == a2 )
return v5;
}
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001016a5
MOV R8,RSI
MOVSXD RDX,EDX
MOV RSI,RDI
XOR ECX,ECX
LEA R10,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001015f0:
MOV EDX,dword ptr [R8]
TEST EDX,EDX
JLE 0x0010168d
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x001016a1
MOV EAX,EDX
MOVDQU XMM0,xmmword ptr [RSI]
SHR EAX,0x2
CMP EAX,0x1
JZ 0x00101644
MOVDQU XMM2,xmmword ptr [RSI + 0x10]
PADDD XMM0,XMM2
CMP EAX,0x2
JZ 0x00101644
XOR EDI,EDI
LAB_00101625:
MOV R9,RDI
ADD RDI,0x1
SHL R9,0x4
MOVDQU XMM1,xmmword ptr [RSI + R9*0x1 + 0x20]
LEA R9D,[RDI + 0x2]
PADDD XMM0,XMM1
CMP R9D,EAX
JC 0x00101625
LAB_00101644:
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
ADD ECX,EAX
MOV EAX,EDX
AND EAX,0xfffffffc
TEST DL,0x3
JZ 0x0010168d
LAB_0010166e:
MOVSXD RDI,EAX
LEA R9D,[RAX + 0x1]
LEA RDI,[RSI + RDI*0x4]
ADD ECX,dword ptr [RDI]
CMP R9D,EDX
JGE 0x0010168d
ADD EAX,0x2
ADD ECX,dword ptr [RDI + 0x4]
CMP EDX,EAX
JLE 0x0010168d
ADD ECX,dword ptr [RDI + 0x8]
LAB_0010168d:
ADD R8,0x4
ADD RSI,0x28
CMP R10,R8
JNZ 0x001015f0
MOV EAX,ECX
RET
LAB_001016a1:
XOR EAX,EAX
JMP 0x0010166e
LAB_001016a5:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int *param_1,uint *param_2,int param_3)
{
uint *puVar1;
int *piVar2;
uint uVar3;
int iVar4;
uint uVar5;
int iVar6;
long lVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
if (param_3 < 1) {
return 0;
}
iVar6 = 0;
puVar1 = param_2 + param_3;
do {
uVar3 = *param_2;
if (0 < (int)uVar3) {
if (uVar3 - 1 < 3) {
uVar5 = 0;
}
else {
iVar8 = *param_1;
iVar9 = param_1[1];
iVar10 = param_1[2];
iVar11 = param_1[3];
uVar5 = uVar3 >> 2;
if (uVar5 != 1) {
iVar8 = iVar8 + param_1[4];
iVar9 = iVar9 + param_1[5];
iVar10 = iVar10 + param_1[6];
iVar11 = iVar11 + param_1[7];
if (uVar5 != 2) {
lVar7 = 0;
do {
piVar2 = param_1 + lVar7 * 4 + 8;
iVar4 = (int)lVar7;
iVar8 = iVar8 + *piVar2;
iVar9 = iVar9 + piVar2[1];
iVar10 = iVar10 + piVar2[2];
iVar11 = iVar11 + piVar2[3];
lVar7 = lVar7 + 1;
} while (iVar4 + 3U < uVar5);
}
}
iVar6 = iVar6 + iVar8 + iVar10 + iVar9 + iVar11;
uVar5 = uVar3 & 0xfffffffc;
if ((uVar3 & 3) == 0) goto LAB_0010168d;
}
piVar2 = param_1 + (int)uVar5;
iVar6 = iVar6 + *piVar2;
if ((int)(uVar5 + 1) < (int)uVar3) {
iVar6 = iVar6 + piVar2[1];
if ((int)(uVar5 + 2) < (int)uVar3) {
iVar6 = iVar6 + piVar2[2];
}
}
}
LAB_0010168d:
param_2 = param_2 + 1;
param_1 = param_1 + 10;
if (puVar1 == param_2) {
return iVar6;
}
} while( true );
} |
6,352 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = sum / num_tuples;
}
return result;
}
| int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second assertion
int nums2[][3] = {
{1, 1, -5},
{30, -15, 56},
{81, -60, -39},
{-10, 2, 3}
};
double expected2[] = {25.5, -18.0, 3.75};
double* result2 = func0(4, 3, nums2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third assertion
int nums3[][4] = {
{100, 100, 100, 120},
{300, 450, 560, 450},
{810, 800, 390, 320},
{10, 20, 30, 40}
};
double expected3[] = {305.0, 342.5, 270.0, 232.5};
double* result3 = func0(4, 4, nums3);
for(int i = 0; i < 4; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
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 %rdx,-0x40(%rbp)
mov -0x38(%rbp),%ebx
movslq %ebx,%rax
sub $0x1,%rax
mov %rax,-0x20(%rbp)
movslq %ebx,%rax
mov %rax,%r8
mov $0x0,%r9d
mov -0x38(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 1276 <func0+0xcd>
pxor %xmm0,%xmm0
movsd %xmm0,-0x28(%rbp)
movl $0x0,-0x30(%rbp)
jmp 1244 <func0+0x9b>
mov -0x30(%rbp),%eax
movslq %eax,%rdx
movslq %ebx,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rax,%rdx
mov -0x2c(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
cvtsi2sd %eax,%xmm0
movsd -0x28(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x28(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 120a <func0+0x61>
cvtsi2sdl -0x34(%rbp),%xmm1
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movsd -0x28(%rbp),%xmm0
divsd %xmm1,%xmm0
movsd %xmm0,(%rax)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 11f8 <func0+0x4f>
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_40], rdx
mov ebx, [rbp+var_38]
movsxd rax, ebx
sub rax, 1
mov [rbp+var_20], rax
mov eax, [rbp+var_38]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_30], 0
jmp loc_1275
loc_11EF:
pxor xmm0, xmm0
movsd [rbp+var_28], xmm0
mov [rbp+var_2C], 0
jmp short loc_123F
loc_1201:
mov eax, [rbp+var_2C]
movsxd rdx, eax
movsxd rax, ebx
imul rax, rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rdx, rax
mov eax, [rbp+var_30]
cdqe
mov eax, [rdx+rax*4]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, [rbp+var_28]
addsd xmm0, xmm1
movsd [rbp+var_28], xmm0
add [rbp+var_2C], 1
loc_123F:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_34]
jl short loc_1201
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_34]
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
movsd xmm0, [rbp+var_28]
divsd xmm0, xmm1
movsd qword ptr [rax], xmm0
add [rbp+var_30], 1
loc_1275:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_38]
jl loc_11EF
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | double * func0(int a1, int a2, long long a3)
{
int i; // [rsp+10h] [rbp-30h]
int j; // [rsp+14h] [rbp-2Ch]
double v7; // [rsp+18h] [rbp-28h]
double *v8; // [rsp+28h] [rbp-18h]
v8 = (double *)malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
v7 = 0.0;
for ( j = 0; j < a1; ++j )
v7 = (double)*(int *)(a3 + 4 * j * (long long)a2 + 4LL * i) + v7;
v8[i] = v7 / (double)a1;
}
return v8;
} | 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 qword ptr [RBP + -0x40],RDX
MOV EBX,dword ptr [RBP + -0x38]
MOVSXD RAX,EBX
SUB RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00101275
LAB_001011ef:
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0010123f
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EAX
MOVSXD RAX,EBX
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [RBP + -0x28]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x28],XMM0
ADD dword ptr [RBP + -0x2c],0x1
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x00101201
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x34]
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSD XMM0,qword ptr [RBP + -0x28]
DIVSD XMM0,XMM1
MOVSD qword ptr [RAX],XMM0
ADD dword ptr [RBP + -0x30],0x1
LAB_00101275:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x001011ef
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int param_1,int param_2,long param_3)
{
void *pvVar1;
int4 local_38;
int4 local_34;
int8 local_30;
pvVar1 = malloc((long)param_2 << 3);
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
local_30 = 0.0;
for (local_34 = 0; local_34 < param_1; local_34 = local_34 + 1) {
local_30 = (double)*(int *)((long)param_2 * (long)local_34 * 4 + param_3 + (long)local_38 * 4)
+ local_30;
}
*(double *)((long)pvVar1 + (long)local_38 * 8) = local_30 / (double)param_1;
}
return pvVar1;
} |
6,353 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = sum / num_tuples;
}
return result;
}
| int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second assertion
int nums2[][3] = {
{1, 1, -5},
{30, -15, 56},
{81, -60, -39},
{-10, 2, 3}
};
double expected2[] = {25.5, -18.0, 3.75};
double* result2 = func0(4, 3, nums2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third assertion
int nums3[][4] = {
{100, 100, 100, 120},
{300, 450, 560, 450},
{810, 800, 390, 320},
{10, 20, 30, 40}
};
double expected3[] = {305.0, 342.5, 270.0, 232.5};
double* result3 = func0(4, 4, nums3);
for(int i = 0; i < 4; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %esi,%r13d
mov %rdx,%r12
movslq %esi,%rbp
lea 0x0(,%rbp,8),%rdi
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 1236 <func0+0x8d>
mov %rax,%rdi
mov %r12,%r8
lea -0x1(%r13),%edx
lea 0x8(%rax,%rdx,8),%r9
lea 0x0(,%rbp,4),%rsi
jmp 122c <func0+0x83>
mov %r8,%rcx
pxor %xmm0,%xmm0
mov $0x0,%edx
pxor %xmm1,%xmm1
cvtsi2sdl (%rcx),%xmm1
addsd %xmm1,%xmm0
add $0x1,%edx
add %rsi,%rcx
cmp %edx,%ebx
jne 11f9 <func0+0x50>
pxor %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rdi)
add $0x8,%rdi
add $0x4,%r8
cmp %r9,%rdi
je 1236 <func0+0x8d>
pxor %xmm0,%xmm0
test %ebx,%ebx
jg 11ed <func0+0x44>
jmp 120f <func0+0x66>
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 ebx, edi
mov r12d, esi
mov r13, rdx
movsxd rbp, esi
lea rdi, ds:0[rbp*8]
call _malloc
test r12d, r12d
jle short loc_1238
mov r8, rax
mov rdi, r13
lea edx, [r12-1]
lea r9, [r13+rdx*4+4]
lea rsi, ds:0[rbp*4]
jmp short loc_122E
loc_11EE:
mov rcx, rdi
mov edx, 0
pxor xmm0, xmm0
loc_11FA:
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rcx]
addsd xmm0, xmm1
add edx, 1
add rcx, rsi
cmp ebx, edx
jnz short loc_11FA
loc_1210:
pxor xmm1, xmm1
cvtsi2sd xmm1, ebx
divsd xmm0, xmm1
movsd qword ptr [r8], xmm0
add r8, 8
add rdi, 4
cmp rdi, r9
jz short loc_1238
loc_122E:
pxor xmm0, xmm0
test ebx, ebx
jg short loc_11EE
jmp short loc_1210
loc_1238:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(int a1, int a2, int *a3)
{
long long result; // rax
double *v6; // r8
int *v7; // rdi
int *v8; // rcx
int v9; // edx
double v10; // xmm0_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v6 = (double *)result;
v7 = a3;
do
{
v10 = 0.0;
if ( a1 > 0 )
{
v8 = v7;
v9 = 0;
v10 = 0.0;
do
{
v10 = v10 + (double)*v8;
++v9;
v8 += a2;
}
while ( a1 != v9 );
}
*v6++ = v10 / (double)a1;
++v7;
}
while ( v7 != &a3[a2 - 1 + 1] );
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV R12D,ESI
MOV R13,RDX
MOVSXD RBP,ESI
LEA RDI,[RBP*0x8]
CALL 0x001010b0
TEST R12D,R12D
JLE 0x00101238
MOV R8,RAX
MOV RDI,R13
LEA EDX,[R12 + -0x1]
LEA R9,[R13 + RDX*0x4 + 0x4]
LEA RSI,[RBP*0x4]
JMP 0x0010122e
LAB_001011ee:
MOV RCX,RDI
MOV EDX,0x0
PXOR XMM0,XMM0
LAB_001011fa:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RCX]
ADDSD XMM0,XMM1
ADD EDX,0x1
ADD RCX,RSI
CMP EBX,EDX
JNZ 0x001011fa
LAB_00101210:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBX
DIVSD XMM0,XMM1
MOVSD qword ptr [R8],XMM0
ADD R8,0x8
ADD RDI,0x4
CMP RDI,R9
JZ 0x00101238
LAB_0010122e:
PXOR XMM0,XMM0
TEST EBX,EBX
JG 0x001011ee
JMP 0x00101210
LAB_00101238:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(int param_1,int param_2,int *param_3)
{
int *piVar1;
double *pdVar2;
int *piVar3;
int iVar4;
double dVar5;
pdVar2 = (double *)malloc((long)param_2 * 8);
if (0 < param_2) {
piVar1 = param_3 + (ulong)(param_2 - 1) + 1;
do {
dVar5 = 0.0;
if (0 < param_1) {
iVar4 = 0;
dVar5 = 0.0;
piVar3 = param_3;
do {
dVar5 = dVar5 + (double)*piVar3;
iVar4 = iVar4 + 1;
piVar3 = piVar3 + param_2;
} while (param_1 != iVar4);
}
*pdVar2 = dVar5 / (double)param_1;
pdVar2 = pdVar2 + 1;
param_3 = param_3 + 1;
} while (param_3 != piVar1);
}
return;
} |
6,354 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = sum / num_tuples;
}
return result;
}
| int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second assertion
int nums2[][3] = {
{1, 1, -5},
{30, -15, 56},
{81, -60, -39},
{-10, 2, 3}
};
double expected2[] = {25.5, -18.0, 3.75};
double* result2 = func0(4, 3, nums2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third assertion
int nums3[][4] = {
{100, 100, 100, 120},
{300, 450, 560, 450},
{810, 800, 390, 320},
{10, 20, 30, 40}
};
double expected3[] = {305.0, 342.5, 270.0, 232.5};
double* result3 = func0(4, 4, nums3);
for(int i = 0; i < 4; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
movslq %esi,%rbp
push %rbx
mov %edi,%ebx
lea 0x0(,%rbp,8),%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 158c <func0+0x8c>
pxor %xmm3,%xmm3
lea -0x1(%rbp),%edx
mov %rax,%rdi
mov %r12,%r8
cvtsi2sd %ebx,%xmm3
lea 0x8(%rax,%rdx,8),%r9
pxor %xmm2,%xmm2
lea 0x0(,%rbp,4),%rsi
nopl 0x0(%rax)
mov %r8,%rcx
movapd %xmm2,%xmm0
xor %edx,%edx
test %ebx,%ebx
jle 1576 <func0+0x76>
nopl (%rax)
pxor %xmm1,%xmm1
add $0x1,%edx
cvtsi2sdl (%rcx),%xmm1
add %rsi,%rcx
addsd %xmm1,%xmm0
cmp %edx,%ebx
jne 1560 <func0+0x60>
divsd %xmm3,%xmm0
add $0x8,%rdi
add $0x4,%r8
movsd %xmm0,-0x8(%rdi)
cmp %r9,%rdi
jne 1550 <func0+0x50>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
movsxd rbp, esi
push rbx
mov ebx, edi
lea rdi, ds:0[rbp*8]
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_158D
pxor xmm3, xmm3
lea edx, [rbp-1]
mov r8, rax
mov rdi, r12
cvtsi2sd xmm3, ebx
lea r9, [r12+rdx*4+4]
pxor xmm2, xmm2
lea rsi, ds:0[rbp*4]
nop dword ptr [rax+00000000h]
loc_1550:
mov rcx, rdi
xor edx, edx
movapd xmm0, xmm2
test ebx, ebx
jle short loc_1576
nop dword ptr [rax]
loc_1560:
pxor xmm1, xmm1
add edx, 1
cvtsi2sd xmm1, dword ptr [rcx]
add rcx, rsi
addsd xmm0, xmm1
cmp ebx, edx
jnz short loc_1560
loc_1576:
divsd xmm0, xmm3
add rdi, 4
add r8, 8
movsd qword ptr [r8-8], xmm0
cmp rdi, r9
jnz short loc_1550
loc_158D:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(int a1, int a2, int *a3)
{
long long result; // rax
long long v6; // r8
int *v7; // rdi
int *v8; // rcx
int v9; // edx
double v10; // xmm0_8
double v11; // xmm1_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v6 = result;
v7 = a3;
do
{
v8 = v7;
v9 = 0;
v10 = 0.0;
if ( a1 > 0 )
{
do
{
++v9;
v11 = (double)*v8;
v8 += a2;
v10 = v10 + v11;
}
while ( a1 != v9 );
}
++v7;
v6 += 8LL;
*(double *)(v6 - 8) = v10 / (double)a1;
}
while ( v7 != &a3[a2 - 1 + 1] );
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV EBX,EDI
LEA RDI,[RBP*0x8]
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x0010158d
PXOR XMM3,XMM3
LEA EDX,[RBP + -0x1]
MOV R8,RAX
MOV RDI,R12
CVTSI2SD XMM3,EBX
LEA R9,[R12 + RDX*0x4 + 0x4]
PXOR XMM2,XMM2
LEA RSI,[RBP*0x4]
NOP dword ptr [RAX]
LAB_00101550:
MOV RCX,RDI
XOR EDX,EDX
MOVAPD XMM0,XMM2
TEST EBX,EBX
JLE 0x00101576
NOP dword ptr [RAX]
LAB_00101560:
PXOR XMM1,XMM1
ADD EDX,0x1
CVTSI2SD XMM1,dword ptr [RCX]
ADD RCX,RSI
ADDSD XMM0,XMM1
CMP EBX,EDX
JNZ 0x00101560
LAB_00101576:
DIVSD XMM0,XMM3
ADD RDI,0x4
ADD R8,0x8
MOVSD qword ptr [R8 + -0x8],XMM0
CMP RDI,R9
JNZ 0x00101550
LAB_0010158d:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(int param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
double *pdVar3;
int *piVar4;
int iVar5;
double dVar6;
pdVar3 = (double *)malloc((long)param_2 * 8);
if (0 < param_2) {
piVar1 = param_3 + (ulong)(param_2 - 1) + 1;
do {
iVar5 = 0;
dVar6 = 0.0;
piVar4 = param_3;
if (0 < param_1) {
do {
iVar5 = iVar5 + 1;
iVar2 = *piVar4;
piVar4 = piVar4 + param_2;
dVar6 = dVar6 + (double)iVar2;
} while (param_1 != iVar5);
}
param_3 = param_3 + 1;
*pdVar3 = dVar6 / (double)param_1;
pdVar3 = pdVar3 + 1;
} while (param_3 != piVar1);
}
return;
} |
6,355 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = sum / num_tuples;
}
return result;
}
| int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second assertion
int nums2[][3] = {
{1, 1, -5},
{30, -15, 56},
{81, -60, -39},
{-10, 2, 3}
};
double expected2[] = {25.5, -18.0, 3.75};
double* result2 = func0(4, 3, nums2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third assertion
int nums3[][4] = {
{100, 100, 100, 120},
{300, 450, 560, 450},
{810, 800, 390, 320},
{10, 20, 30, 40}
};
double expected3[] = {305.0, 342.5, 270.0, 232.5};
double* result3 = func0(4, 4, nums3);
for(int i = 0; i < 4; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
movslq %esi,%rbp
push %rbx
mov %edi,%ebx
lea 0x0(,%rbp,8),%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 14fc <func0+0x8c>
pxor %xmm3,%xmm3
lea -0x1(%rbp),%edx
mov %rax,%rdi
mov %r12,%r8
cvtsi2sd %ebx,%xmm3
lea 0x8(%rax,%rdx,8),%r9
pxor %xmm2,%xmm2
lea 0x0(,%rbp,4),%rsi
nopl 0x0(%rax)
mov %r8,%rcx
movapd %xmm2,%xmm0
xor %edx,%edx
test %ebx,%ebx
jle 14e6 <func0+0x76>
nopl (%rax)
pxor %xmm1,%xmm1
add $0x1,%edx
cvtsi2sdl (%rcx),%xmm1
add %rsi,%rcx
addsd %xmm1,%xmm0
cmp %edx,%ebx
jne 14d0 <func0+0x60>
divsd %xmm3,%xmm0
add $0x8,%rdi
add $0x4,%r8
movsd %xmm0,-0x8(%rdi)
cmp %r9,%rdi
jne 14c0 <func0+0x50>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
movsxd rbp, esi
push rbx
mov ebx, edi
lea rdi, ds:0[rbp*8]; size
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_14B5
pxor xmm2, xmm2
lea rsi, ds:0[rbp*4]
mov r8, rax
mov rdi, r12
cvtsi2sd xmm2, ebx
lea r9, [r12+rsi]
nop dword ptr [rax+00000000h]
loc_1478:
mov rcx, rdi
xor edx, edx
pxor xmm0, xmm0
test ebx, ebx
jle short loc_149E
nop dword ptr [rax]
loc_1488:
pxor xmm1, xmm1
add edx, 1
cvtsi2sd xmm1, dword ptr [rcx]
add rcx, rsi
addsd xmm0, xmm1
cmp ebx, edx
jnz short loc_1488
loc_149E:
divsd xmm0, xmm2
add rdi, 4
add r8, 8
movsd qword ptr [r8-8], xmm0
cmp r9, rdi
jnz short loc_1478
loc_14B5:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | double * func0(int a1, int a2, int *a3)
{
double *result; // rax
double *v6; // r8
int *v7; // rdi
int *v8; // rcx
int v9; // edx
double v10; // xmm0_8
double v11; // xmm1_8
result = (double *)malloc(8LL * a2);
if ( a2 > 0 )
{
v6 = result;
v7 = a3;
do
{
v8 = v7;
v9 = 0;
v10 = 0.0;
if ( a1 > 0 )
{
do
{
++v9;
v11 = (double)*v8;
v8 += a2;
v10 = v10 + v11;
}
while ( a1 != v9 );
}
++v7;
*v6++ = v10 / (double)a1;
}
while ( &a3[a2] != v7 );
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV EBX,EDI
LEA RDI,[RBP*0x8]
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001014b5
PXOR XMM2,XMM2
LEA RSI,[RBP*0x4]
MOV R8,RAX
MOV RDI,R12
CVTSI2SD XMM2,EBX
LEA R9,[R12 + RSI*0x1]
NOP dword ptr [RAX]
LAB_00101478:
MOV RCX,RDI
XOR EDX,EDX
PXOR XMM0,XMM0
TEST EBX,EBX
JLE 0x0010149e
NOP dword ptr [RAX]
LAB_00101488:
PXOR XMM1,XMM1
ADD EDX,0x1
CVTSI2SD XMM1,dword ptr [RCX]
ADD RCX,RSI
ADDSD XMM0,XMM1
CMP EBX,EDX
JNZ 0x00101488
LAB_0010149e:
DIVSD XMM0,XMM2
ADD RDI,0x4
ADD R8,0x8
MOVSD qword ptr [R8 + -0x8],XMM0
CMP R9,RDI
JNZ 0x00101478
LAB_001014b5:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(int param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
double *pdVar3;
int *piVar4;
int iVar5;
long lVar6;
double dVar7;
lVar6 = (long)param_2;
pdVar3 = (double *)malloc(lVar6 * 8);
if (0 < param_2) {
piVar1 = param_3 + lVar6;
do {
iVar5 = 0;
dVar7 = 0.0;
piVar4 = param_3;
if (0 < param_1) {
do {
iVar5 = iVar5 + 1;
iVar2 = *piVar4;
piVar4 = piVar4 + lVar6;
dVar7 = dVar7 + (double)iVar2;
} while (param_1 != iVar5);
}
param_3 = param_3 + 1;
*pdVar3 = dVar7 / (double)param_1;
pdVar3 = pdVar3 + 1;
} while (piVar1 != param_3);
}
return;
} |
6,356 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
int expected2[] = {5, 5, 6, 1};
func0(a2, b2, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
int a3[] = {12, 6, 7, 8};
int b3[] = {7, 8, 9, 7};
int expected3[] = {5, 6, 7, 1};
func0(a3, b3, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d6 <func0+0x6d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%esi
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rdx,%rcx
cltd
idiv %esi
mov %edx,%eax
mov %eax,(%rcx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1189 <func0+0x20>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11D8
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_20]
add rdx, rcx
mov edi, [rdx]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
lea rsi, ds:0[rcx*4]
mov rcx, [rbp+var_28]
add rcx, rsi
cdq
idiv edi
mov esi, edx
mov eax, esi
mov [rcx], eax
add [rbp+var_4], 1
loc_11D8:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_1189
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
*(_DWORD *)(4LL * (int)i + a3) = *(_DWORD *)(4LL * (int)i + a1) % *(_DWORD *)(4LL * (int)i + a2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d8
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV EDI,dword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x4]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,RSI
CDQ
IDIV EDI
MOV ESI,EDX
MOV EAX,ESI
MOV dword ptr [RCX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101189
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_c * 4) =
*(int *)(param_1 + (long)local_c * 4) % *(int *)(param_2 + (long)local_c * 4);
}
return;
} |
6,357 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
int expected2[] = {5, 5, 6, 1};
func0(a2, b2, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
int a3[] = {12, 6, 7, 8};
int b3[] = {7, 8, 9, 7};
int expected3[] = {5, 6, 7, 1};
func0(a3, b3, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
mov %rdx,%r8
test %ecx,%ecx
jle 1194 <func0+0x2b>
lea -0x1(%rcx),%r9d
mov $0x0,%ecx
mov (%rdi,%rcx,4),%eax
cltd
idivl (%rsi,%rcx,4)
mov %edx,(%r8,%rcx,4)
mov %rcx,%rax
add $0x1,%rcx
cmp %r9,%rax
jne 117d <func0+0x14>
retq
| func0:
endbr64
mov r9, rdx
test ecx, ecx
jle short locret_1192
mov ecx, ecx
mov r8d, 0
loc_117C:
mov eax, [rdi+r8*4]
cdq
idiv dword ptr [rsi+r8*4]
mov [r9+r8*4], edx
add r8, 1
cmp r8, rcx
jnz short loc_117C
locret_1192:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // r8
long long result; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
result = (unsigned int)(*(_DWORD *)(a1 + 4 * i) / *(_DWORD *)(a2 + 4 * i));
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) % *(_DWORD *)(a2 + 4 * i);
}
}
return result;
} | func0:
ENDBR64
MOV R9,RDX
TEST ECX,ECX
JLE 0x00101192
MOV ECX,ECX
MOV R8D,0x0
LAB_0010117c:
MOV EAX,dword ptr [RDI + R8*0x4]
CDQ
IDIV dword ptr [RSI + R8*0x4]
MOV dword ptr [R9 + R8*0x4],EDX
ADD R8,0x1
CMP R8,RCX
JNZ 0x0010117c
LAB_00101192:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 4) = *(int *)(param_1 + uVar1 * 4) % *(int *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;
} |
6,358 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
int expected2[] = {5, 5, 6, 1};
func0(a2, b2, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
int a3[] = {12, 6, 7, 8};
int b3[] = {7, 8, 9, 7};
int expected3[] = {5, 6, 7, 1};
func0(a3, b3, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
mov %rdx,%r8
test %ecx,%ecx
jle 116f <func0+0x2f>
lea -0x1(%rcx),%r9d
xor %ecx,%ecx
nopl 0x0(%rax)
mov (%rdi,%rcx,4),%eax
cltd
idivl (%rsi,%rcx,4)
mov %rcx,%rax
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %r9,%rax
jne 1158 <func0+0x18>
retq
| func0:
endbr64
mov r9, rdx
test ecx, ecx
jle short locret_141E
movsxd rcx, ecx
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_1408:
mov eax, [rdi+r8*4]
cdq
idiv dword ptr [rsi+r8*4]
mov [r9+r8*4], edx
add r8, 1
cmp rcx, r8
jnz short loc_1408
locret_141E:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // r8
long long result; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
result = (unsigned int)(*(_DWORD *)(a1 + 4 * i) / *(_DWORD *)(a2 + 4 * i));
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) % *(_DWORD *)(a2 + 4 * i);
}
}
return result;
} | func0:
ENDBR64
MOV R9,RDX
TEST ECX,ECX
JLE 0x0010141e
MOVSXD RCX,ECX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101408:
MOV EAX,dword ptr [RDI + R8*0x4]
CDQ
IDIV dword ptr [RSI + R8*0x4]
MOV dword ptr [R9 + R8*0x4],EDX
ADD R8,0x1
CMP RCX,R8
JNZ 0x00101408
LAB_0010141e:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) % *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
6,359 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
int expected2[] = {5, 5, 6, 1};
func0(a2, b2, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
int a3[] = {12, 6, 7, 8};
int b3[] = {7, 8, 9, 7};
int expected3[] = {5, 6, 7, 1};
func0(a3, b3, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
mov %rdx,%r8
test %ecx,%ecx
jle 116f <func0+0x2f>
lea -0x1(%rcx),%r9d
xor %ecx,%ecx
nopl 0x0(%rax)
mov (%rdi,%rcx,4),%eax
cltd
idivl (%rsi,%rcx,4)
mov %rcx,%rax
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %rax,%r9
jne 1158 <func0+0x18>
retq
| func0:
endbr64
mov r8, rdi
mov r9, rdx
test ecx, ecx
jle short locret_1175
movsxd rcx, ecx
lea rdi, ds:0[rcx*4]
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1160:
mov eax, [r8+rcx]
cdq
idiv dword ptr [rsi+rcx]
mov [r9+rcx], edx
add rcx, 4
cmp rdi, rcx
jnz short loc_1160
locret_1175:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long v5; // rdi
long long v6; // rcx
long long result; // rax
if ( a4 > 0 )
{
v5 = 4LL * a4;
v6 = 0LL;
do
{
result = (unsigned int)(*(_DWORD *)(a1 + v6) / *(_DWORD *)(a2 + v6));
*(_DWORD *)(a3 + v6) = *(_DWORD *)(a1 + v6) % *(_DWORD *)(a2 + v6);
v6 += 4LL;
}
while ( v5 != v6 );
}
return result;
} | func0:
ENDBR64
MOV R8,RDI
MOV R9,RDX
TEST ECX,ECX
JLE 0x00101175
MOVSXD RCX,ECX
LEA RDI,[RCX*0x4]
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101160:
MOV EAX,dword ptr [R8 + RCX*0x1]
CDQ
IDIV dword ptr [RSI + RCX*0x1]
MOV dword ptr [R9 + RCX*0x1],EDX
ADD RCX,0x4
CMP RDI,RCX
JNZ 0x00101160
LAB_00101175:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1) = *(int *)(param_1 + lVar1) % *(int *)(param_2 + lVar1);
lVar1 = lVar1 + 4;
} while ((long)param_4 * 4 - lVar1 != 0);
}
return;
} |
6,360 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
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
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovle -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovge -0x18(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x18(%rbp),%eax
jl 1193 <func0+0x4a>
mov -0x1c(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
cltd
idivl -0x18(%rbp)
jmp 11b4 <func0+0x6b>
cmpl $0x0,-0x1c(%rbp)
jne 11a0 <func0+0x57>
mov $0x0,%eax
jmp 11b4 <func0+0x6b>
mov -0x1c(%rbp),%eax
cmp -0x14(%rbp),%eax
jne 11af <func0+0x66>
mov $0x1,%eax
jmp 11b4 <func0+0x6b>
mov $0x2,%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]
mov [rbp+var_4], eax
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_14], eax
mov edx, [rbp+var_18]
mov eax, [rbp+var_4]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_18], eax
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_18]
jl short loc_1195
mov edx, [rbp+var_1C]
mov eax, [rbp+var_18]
add eax, edx
sub eax, 1
cdq
idiv [rbp+var_18]
jmp short loc_11B6
loc_1195:
cmp [rbp+var_1C], 0
jnz short loc_11A2
mov eax, 0
jmp short loc_11B6
loc_11A2:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_14]
jnz short loc_11B1
mov eax, 1
jmp short loc_11B6
loc_11B1:
mov eax, 2
loc_11B6:
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
int v4; // eax
int v6; // [rsp+8h] [rbp-14h]
v3 = a2;
if ( a1 <= a2 )
v3 = a1;
v6 = v3;
v4 = a1;
if ( a2 >= a1 )
v4 = a2;
if ( a3 >= v4 )
return (unsigned int)((a3 + v4 - 1) / v4);
if ( !a3 )
return 0LL;
if ( a3 == v6 )
return 1LL;
return 2LL;
} | 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]
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x4]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x00101195
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
SUB EAX,0x1
CDQ
IDIV dword ptr [RBP + -0x18]
JMP 0x001011b6
LAB_00101195:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001011a2
MOV EAX,0x0
JMP 0x001011b6
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x001011b1
MOV EAX,0x1
JMP 0x001011b6
LAB_001011b1:
MOV EAX,0x2
LAB_001011b6:
POP RBP
RET | int [16] func0(uint param_1,uint param_2,uint param_3)
{
long lVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int auVar5 [16];
uVar2 = param_2;
if ((int)param_1 <= (int)param_2) {
uVar2 = param_1;
}
uVar4 = (ulong)param_2;
if ((int)param_1 <= (int)param_2) {
param_1 = param_2;
}
if ((int)param_3 < (int)param_1) {
if (param_3 == 0) {
uVar3 = 0;
}
else if (param_3 == uVar2) {
uVar3 = 1;
}
else {
uVar3 = 2;
}
}
else {
lVar1 = (long)(int)(param_1 + param_3 + -1);
uVar3 = lVar1 / (long)(int)param_1 & 0xffffffff;
uVar4 = lVar1 % (long)(int)param_1 & 0xffffffff;
}
auVar5._8_8_ = uVar4;
auVar5._0_8_ = uVar3;
return auVar5;
} |
6,361 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %edx,%ecx
jle 114f <func0+0x26>
mov %edx,%eax
test %edx,%edx
je 114e <func0+0x25>
cmp %esi,%edi
cmovg %esi,%edi
cmp %edx,%edi
setne %al
movzbl %al,%eax
add $0x1,%eax
retq
lea -0x1(%rcx,%rdx,1),%eax
cltd
idiv %ecx
retq
| func0:
endbr64
cmp edi, esi
mov ecx, esi
cmovge ecx, edi
cmp ecx, edx
jle short loc_114F
mov eax, edx
test edx, edx
jz short locret_114E
cmp edi, esi
cmovg edi, esi
cmp edi, edx
setnz al
movzx eax, al
add eax, 1
locret_114E:
retn
loc_114F:
lea eax, [rcx+rdx-1]
cdq
idiv ecx
retn | long long func0(int a1, int a2, unsigned int a3)
{
int v3; // ecx
long long result; // rax
v3 = a2;
if ( a1 >= a2 )
v3 = a1;
if ( v3 <= (int)a3 )
return (unsigned int)((int)(v3 + a3 - 1) / v3);
result = a3;
if ( a3 )
{
if ( a1 > a2 )
a1 = a2;
return (unsigned int)(a1 != a3) + 1;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVGE ECX,EDI
CMP ECX,EDX
JLE 0x0010114f
MOV EAX,EDX
TEST EDX,EDX
JZ 0x0010114e
CMP EDI,ESI
CMOVG EDI,ESI
CMP EDI,EDX
SETNZ AL
MOVZX EAX,AL
ADD EAX,0x1
LAB_0010114e:
RET
LAB_0010114f:
LEA EAX,[RCX + RDX*0x1 + -0x1]
CDQ
IDIV ECX
RET | int1 [16] func0(int param_1,int param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
int iVar3;
int iVar4;
int1 auVar5 [16];
int1 auVar6 [16];
iVar3 = param_2;
if (param_2 <= param_1) {
iVar3 = param_1;
}
iVar4 = (int)param_3;
if (iVar4 < iVar3) {
uVar2 = param_3 & 0xffffffff;
if (iVar4 != 0) {
if (param_2 < param_1) {
param_1 = param_2;
}
uVar2 = (ulong)((param_1 != iVar4) + 1);
}
auVar5._8_8_ = param_3;
auVar5._0_8_ = uVar2;
return auVar5;
}
lVar1 = (long)(iVar3 + -1 + iVar4);
auVar6._0_8_ = lVar1 / (long)iVar3 & 0xffffffff;
auVar6._8_8_ = lVar1 % (long)iVar3 & 0xffffffff;
return auVar6;
} |
6,362 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %edx,%ecx
jle 1168 <func0+0x28>
xor %eax,%eax
test %edx,%edx
je 1164 <func0+0x24>
cmp %esi,%edi
cmovg %esi,%edi
xor %eax,%eax
cmp %edx,%edi
setne %al
add $0x1,%eax
retq
nopl (%rax)
lea -0x1(%rcx,%rdx,1),%eax
cltd
idiv %ecx
retq
| func0:
endbr64
cmp edi, esi
mov ecx, esi
cmovge ecx, edi
cmp ecx, edx
jle short loc_1168
xor eax, eax
test edx, edx
jz short locret_1164
cmp edi, esi
cmovg edi, esi
xor eax, eax
cmp edi, edx
setnz al
add eax, 1
locret_1164:
retn
loc_1168:
lea eax, [rcx+rdx-1]
cdq
idiv ecx
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
v3 = a2;
if ( a1 >= a2 )
v3 = a1;
if ( v3 <= a3 )
return (unsigned int)((v3 + a3 - 1) / v3);
result = 0LL;
if ( a3 )
{
if ( a1 > a2 )
a1 = a2;
return (unsigned int)(a1 != a3) + 1;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVGE ECX,EDI
CMP ECX,EDX
JLE 0x00101168
XOR EAX,EAX
TEST EDX,EDX
JZ 0x00101164
CMP EDI,ESI
CMOVG EDI,ESI
XOR EAX,EAX
CMP EDI,EDX
SETNZ AL
ADD EAX,0x1
LAB_00101164:
RET
LAB_00101168:
LEA EAX,[RCX + RDX*0x1 + -0x1]
CDQ
IDIV ECX
RET | int1 [16] func0(int param_1,int param_2,int8 param_3)
{
long lVar1;
ulong uVar2;
int iVar3;
int iVar4;
int1 auVar5 [16];
int1 auVar6 [16];
iVar3 = param_2;
if (param_2 <= param_1) {
iVar3 = param_1;
}
iVar4 = (int)param_3;
if (iVar4 < iVar3) {
uVar2 = 0;
if (iVar4 != 0) {
if (param_2 < param_1) {
param_1 = param_2;
}
uVar2 = (ulong)((param_1 != iVar4) + 1);
}
auVar5._8_8_ = param_3;
auVar5._0_8_ = uVar2;
return auVar5;
}
lVar1 = (long)(iVar3 + -1 + iVar4);
auVar6._0_8_ = lVar1 / (long)iVar3 & 0xffffffff;
auVar6._8_8_ = lVar1 % (long)iVar3 & 0xffffffff;
return auVar6;
} |
6,363 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %edx,%ecx
jle 1168 <func0+0x28>
xor %eax,%eax
test %edx,%edx
je 1164 <func0+0x24>
cmp %esi,%edi
cmovg %esi,%edi
xor %eax,%eax
cmp %edx,%edi
setne %al
add $0x1,%eax
retq
nopl (%rax)
lea -0x1(%rcx,%rdx,1),%eax
cltd
idiv %ecx
retq
| func0:
endbr64
cmp edi, esi
mov ecx, esi
cmovge ecx, edi
cmp ecx, edx
jle short loc_1168
xor eax, eax
test edx, edx
jz short locret_1164
cmp edi, esi
cmovg edi, esi
xor eax, eax
cmp edi, edx
setnz al
add eax, 1
locret_1164:
retn
loc_1168:
lea eax, [rcx+rdx-1]
cdq
idiv ecx
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
v3 = a2;
if ( a1 >= a2 )
v3 = a1;
if ( v3 <= a3 )
return (unsigned int)((v3 + a3 - 1) / v3);
result = 0LL;
if ( a3 )
{
if ( a1 > a2 )
a1 = a2;
return (unsigned int)(a1 != a3) + 1;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVGE ECX,EDI
CMP ECX,EDX
JLE 0x00101168
XOR EAX,EAX
TEST EDX,EDX
JZ 0x00101164
CMP EDI,ESI
CMOVG EDI,ESI
XOR EAX,EAX
CMP EDI,EDX
SETNZ AL
ADD EAX,0x1
LAB_00101164:
RET
LAB_00101168:
LEA EAX,[RCX + RDX*0x1 + -0x1]
CDQ
IDIV ECX
RET | int [16] func0(int param_1,int param_2,int8 param_3)
{
long lVar1;
ulong uVar2;
int iVar3;
int iVar4;
int auVar5 [16];
int auVar6 [16];
iVar3 = param_2;
if (param_2 <= param_1) {
iVar3 = param_1;
}
iVar4 = (int)param_3;
if (iVar4 < iVar3) {
uVar2 = 0;
if (iVar4 != 0) {
if (param_2 < param_1) {
param_1 = param_2;
}
uVar2 = (ulong)((param_1 != iVar4) + 1);
}
auVar5._8_8_ = param_3;
auVar5._0_8_ = uVar2;
return auVar5;
}
lVar1 = (long)(iVar3 + -1 + iVar4);
auVar6._0_8_ = lVar1 / (long)iVar3 & 0xffffffff;
auVar6._8_8_ = lVar1 % (long)iVar3 & 0xffffffff;
return auVar6;
} |
6,364 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(result2[0] == 3.0 && result2[1] == 0.5);
free(result2);
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
double* result3 = func0(nums1c, nums2c, 2);
assert(result3[0] == 1.8 && result3[1] == 1.7142857142857142);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1232 <func0+0x89>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm0
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm1
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
divsd %xmm1,%xmm0
movsd %xmm0,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11de <func0+0x35>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_123A
loc_11DE:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov eax, [rax]
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
divsd xmm0, xmm1
movsd qword ptr [rax], xmm0
add [rbp+var_C], 1
loc_123A:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
jl short loc_11DE
mov rax, [rbp+var_8]
leave
retn | double * func0(long long a1, long long a2, int a3)
{
int i; // [rsp+24h] [rbp-Ch]
double *v6; // [rsp+28h] [rbp-8h]
v6 = (double *)malloc(8LL * a3);
for ( i = 0; i < a3; ++i )
v6[i] = (double)*(int *)(4LL * i + a1) / (double)*(int *)(4LL * i + a2);
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010123a
LAB_001011de:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
DIVSD XMM0,XMM1
MOVSD qword ptr [RAX],XMM0
ADD dword ptr [RBP + -0xc],0x1
LAB_0010123a:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011de
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_3 << 3);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
*(double *)((long)pvVar1 + (long)local_14 * 8) =
(double)*(int *)(param_1 + (long)local_14 * 4) /
(double)*(int *)(param_2 + (long)local_14 * 4);
}
return pvVar1;
} |
6,365 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(result2[0] == 3.0 && result2[1] == 0.5);
free(result2);
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
double* result3 = func0(nums1c, nums2c, 2);
assert(result3[0] == 1.8 && result3[1] == 1.7142857142857142);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rsi,%rbp
mov %edx,%r12d
movslq %edx,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 11fd <func0+0x54>
lea -0x1(%r12),%esi
mov $0x0,%edx
pxor %xmm0,%xmm0
cvtsi2sdl (%rbx,%rdx,4),%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rdx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rax,%rdx,8)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 11d5 <func0+0x2c>
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
mov r12d, edx
movsxd rdi, edx
shl rdi, 3
call _malloc
test r12d, r12d
jle short loc_11F8
mov ecx, r12d
mov edx, 0
loc_11D3:
pxor xmm0, xmm0
cvtsi2sd xmm0, dword ptr [rbx+rdx*4]
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rbp+rdx*4+0]
divsd xmm0, xmm1
movsd qword ptr [rax+rdx*8], xmm0
add rdx, 1
cmp rdx, rcx
jnz short loc_11D3
loc_11F8:
pop rbx
pop rbp
pop r12
retn | long long func0(long long a1, long long a2, int a3)
{
long long result; // rax
long long v5; // rdx
result = malloc(8LL * a3);
if ( a3 > 0 )
{
v5 = 0LL;
do
{
*(double *)(result + 8 * v5) = (double)*(int *)(a1 + 4 * v5) / (double)*(int *)(a2 + 4 * v5);
++v5;
}
while ( v5 != a3 );
}
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RSI
MOV R12D,EDX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x001010b0
TEST R12D,R12D
JLE 0x001011f8
MOV ECX,R12D
MOV EDX,0x0
LAB_001011d3:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBX + RDX*0x4]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + RDX*0x4]
DIVSD XMM0,XMM1
MOVSD qword ptr [RAX + RDX*0x8],XMM0
ADD RDX,0x1
CMP RDX,RCX
JNZ 0x001011d3
LAB_001011f8:
POP RBX
POP RBP
POP R12
RET | void func0(long param_1,long param_2,uint param_3)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)(int)param_3 << 3);
if (0 < (int)param_3) {
uVar2 = 0;
do {
*(double *)((long)pvVar1 + uVar2 * 8) =
(double)*(int *)(param_1 + uVar2 * 4) / (double)*(int *)(param_2 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_3);
}
return;
} |
6,366 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(result2[0] == 3.0 && result2[1] == 0.5);
free(result2);
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
double* result3 = func0(nums1c, nums2c, 2);
assert(result3[0] == 1.8 && result3[1] == 1.7142857142857142);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
movslq %edx,%rdi
mov %rdi,%r12
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 13f8 <func0+0x58>
lea -0x1(%r12),%esi
xor %edx,%edx
nopl 0x0(%rax)
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
mov %rdx,%rcx
cvtsi2sdl (%rbx,%rdx,4),%xmm0
cvtsi2sdl 0x0(%rbp,%rdx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rax,%rdx,8)
add $0x1,%rdx
cmp %rsi,%rcx
jne 13d0 <func0+0x30>
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
| func0:
endbr64
push r13
push r12
movsxd r12, edx
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
lea rdi, ds:0[r12*8]
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_13F5
xor edx, edx
nop dword ptr [rax+rax+00h]
loc_13D0:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [rbx+rdx*4]
cvtsi2sd xmm1, dword ptr [rbp+rdx*4+0]
divsd xmm0, xmm1
movsd qword ptr [rax+rdx*8], xmm0
add rdx, 1
cmp r12, rdx
jnz short loc_13D0
loc_13F5:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r12
long long result; // rax
long long i; // rdx
v3 = a3;
result = malloc(8LL * a3);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
*(double *)(result + 8 * i) = (double)*(int *)(a1 + 4 * i) / (double)*(int *)(a2 + 4 * i);
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
LEA RDI,[R12*0x8]
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x001013f5
XOR EDX,EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RBX + RDX*0x4]
CVTSI2SD XMM1,dword ptr [RBP + RDX*0x4]
DIVSD XMM0,XMM1
MOVSD qword ptr [RAX + RDX*0x8],XMM0
ADD RDX,0x1
CMP R12,RDX
JNZ 0x001013d0
LAB_001013f5:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
long lVar2;
pvVar1 = malloc((long)param_3 * 8);
if (0 < param_3) {
lVar2 = 0;
do {
*(double *)((long)pvVar1 + lVar2 * 8) =
(double)*(int *)(param_1 + lVar2 * 4) / (double)*(int *)(param_2 + lVar2 * 4);
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
} |
6,367 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(result2[0] == 3.0 && result2[1] == 0.5);
free(result2);
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
double* result3 = func0(nums1c, nums2c, 2);
assert(result3[0] == 1.8 && result3[1] == 1.7142857142857142);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %edx,%rdi
push %rbx
mov %rdi,%r12
shl $0x3,%rdi
mov %rsi,%rbx
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 149b <func0+0xfb>
lea -0x1(%r12),%edx
cmp $0x2,%edx
jbe 14a0 <func0+0x100>
mov %r12d,%edx
xor %ecx,%ecx
shr $0x2,%edx
shl $0x4,%rdx
cvtdq2pd (%rbx,%rcx,1),%xmm1
cvtdq2pd 0x0(%rbp,%rcx,1),%xmm0
divpd %xmm1,%xmm0
movdqu 0x0(%rbp,%rcx,1),%xmm2
movdqu (%rbx,%rcx,1),%xmm3
pshufd $0xee,%xmm3,%xmm1
cvtdq2pd %xmm1,%xmm1
movups %xmm0,(%rax,%rcx,2)
pshufd $0xee,%xmm2,%xmm0
cvtdq2pd %xmm0,%xmm0
divpd %xmm1,%xmm0
movups %xmm0,0x10(%rax,%rcx,2)
add $0x10,%rcx
cmp %rdx,%rcx
jne 13e0 <func0+0x40>
mov %r12d,%edx
and $0xfffffffc,%edx
test $0x3,%r12b
je 149b <func0+0xfb>
movslq %edx,%rcx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rcx,4),%xmm0
cvtsi2sdl (%rbx,%rcx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rax,%rcx,8)
lea 0x1(%rdx),%ecx
cmp %ecx,%r12d
jle 149b <func0+0xfb>
movslq %ecx,%rcx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
add $0x2,%edx
cvtsi2sdl 0x0(%rbp,%rcx,4),%xmm0
cvtsi2sdl (%rbx,%rcx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rax,%rcx,8)
cmp %edx,%r12d
jle 149b <func0+0xfb>
movslq %edx,%rdx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rdx,4),%xmm0
cvtsi2sdl (%rbx,%rdx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rax,%rdx,8)
pop %rbx
pop %rbp
pop %r12
retq
xor %edx,%edx
jmp 142e <func0+0x8e>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r12
push rbp
mov rbp, rdi
movsxd rdi, edx
push rbx
mov r12, rdi
shl rdi, 3; size
mov rbx, rsi
call _malloc
mov rdx, rax
test r12d, r12d
jle loc_14A1
lea eax, [r12-1]
cmp eax, 2
jbe loc_14A9
mov ecx, r12d
xor eax, eax
shr ecx, 2
shl rcx, 4
nop dword ptr [rax+rax+00h]
loc_13D8:
cvtdq2pd xmm1, qword ptr [rbx+rax]
cvtdq2pd xmm0, qword ptr [rbp+rax+0]
divpd xmm0, xmm1
movdqu xmm2, xmmword ptr [rbp+rax+0]
movdqu xmm3, xmmword ptr [rbx+rax]
pshufd xmm1, xmm3, 0EEh
cvtdq2pd xmm1, xmm1
movups xmmword ptr [rdx+rax*2], xmm0
pshufd xmm0, xmm2, 0EEh
cvtdq2pd xmm0, xmm0
divpd xmm0, xmm1
movups xmmword ptr [rdx+rax*2+10h], xmm0
add rax, 10h
cmp rax, rcx
jnz short loc_13D8
mov ecx, r12d
and ecx, 0FFFFFFFCh
test r12b, 3
jz short loc_14A1
loc_1426:
movsxd rax, ecx
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [rbp+rax*4+0]
lea rsi, ds:0[rax*4]
cvtsi2sd xmm1, dword ptr [rbx+rax*4]
lea rdi, ds:0[rax*8]
divsd xmm0, xmm1
movsd qword ptr [rdx+rax*8], xmm0
lea eax, [rcx+1]
cmp r12d, eax
jle short loc_14A1
pxor xmm0, xmm0
pxor xmm1, xmm1
add ecx, 2
cvtsi2sd xmm0, dword ptr [rbp+rsi+4]
cvtsi2sd xmm1, dword ptr [rbx+rsi+4]
divsd xmm0, xmm1
movsd qword ptr [rdx+rdi+8], xmm0
cmp r12d, ecx
jle short loc_14A1
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [rbp+rsi+8]
cvtsi2sd xmm1, dword ptr [rbx+rsi+8]
divsd xmm0, xmm1
movsd qword ptr [rdx+rdi+10h], xmm0
loc_14A1:
pop rbx
mov rax, rdx
pop rbp
pop r12
retn
loc_14A9:
xor ecx, ecx
jmp loc_1426 | char * func0(long long a1, long long a2, int a3)
{
char *v6; // rdx
long long v7; // rax
__m128i v8; // xmm2
__m128d v9; // xmm1
int v10; // ecx
long long v11; // rsi
long long v12; // rdi
v6 = (char *)malloc(8LL * a3);
if ( a3 > 0 )
{
if ( (unsigned int)(a3 - 1) <= 2 )
{
v10 = 0;
}
else
{
v7 = 0LL;
do
{
v8 = _mm_loadu_si128((const __m128i *)(a1 + v7));
v9 = _mm_cvtepi32_pd(_mm_shuffle_epi32(_mm_loadu_si128((const __m128i *)(a2 + v7)), 238));
*(__m128d *)&v6[2 * v7] = _mm_div_pd(_mm_cvtepi32_pd(*(__m64 *)(a1 + v7)), _mm_cvtepi32_pd(*(__m64 *)(a2 + v7)));
*(__m128d *)&v6[2 * v7 + 16] = _mm_div_pd(_mm_cvtepi32_pd(_mm_shuffle_epi32(v8, 238)), v9);
v7 += 16LL;
}
while ( v7 != 16LL * ((unsigned int)a3 >> 2) );
v10 = a3 & 0x7FFFFFFC;
if ( (a3 & 3) == 0 )
return v6;
}
v11 = 4LL * v10;
v12 = 8LL * v10;
*(double *)&v6[v12] = (double)*(int *)(a1 + v11) / (double)*(int *)(a2 + v11);
if ( a3 > v10 + 1 )
{
*(double *)&v6[v12 + 8] = (double)*(int *)(a1 + v11 + 4) / (double)*(int *)(a2 + v11 + 4);
if ( a3 > v10 + 2 )
*(double *)&v6[v12 + 16] = (double)*(int *)(a1 + v11 + 8) / (double)*(int *)(a2 + v11 + 8);
}
}
return v6;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,EDX
PUSH RBX
MOV R12,RDI
SHL RDI,0x3
MOV RBX,RSI
CALL 0x001010b0
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001014a1
LEA EAX,[R12 + -0x1]
CMP EAX,0x2
JBE 0x001014a9
MOV ECX,R12D
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d8:
CVTDQ2PD XMM1,qword ptr [RBX + RAX*0x1]
CVTDQ2PD XMM0,qword ptr [RBP + RAX*0x1]
DIVPD XMM0,XMM1
MOVDQU XMM2,xmmword ptr [RBP + RAX*0x1]
MOVDQU XMM3,xmmword ptr [RBX + RAX*0x1]
PSHUFD XMM1,XMM3,0xee
CVTDQ2PD XMM1,XMM1
MOVUPS xmmword ptr [RDX + RAX*0x2],XMM0
PSHUFD XMM0,XMM2,0xee
CVTDQ2PD XMM0,XMM0
DIVPD XMM0,XMM1
MOVUPS xmmword ptr [RDX + RAX*0x2 + 0x10],XMM0
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x001013d8
MOV ECX,R12D
AND ECX,0xfffffffc
TEST R12B,0x3
JZ 0x001014a1
LAB_00101426:
MOVSXD RAX,ECX
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RBP + RAX*0x4]
LEA RSI,[RAX*0x4]
CVTSI2SD XMM1,dword ptr [RBX + RAX*0x4]
LEA RDI,[RAX*0x8]
DIVSD XMM0,XMM1
MOVSD qword ptr [RDX + RAX*0x8],XMM0
LEA EAX,[RCX + 0x1]
CMP R12D,EAX
JLE 0x001014a1
PXOR XMM0,XMM0
PXOR XMM1,XMM1
ADD ECX,0x2
CVTSI2SD XMM0,dword ptr [RBP + RSI*0x1 + 0x4]
CVTSI2SD XMM1,dword ptr [RBX + RSI*0x1 + 0x4]
DIVSD XMM0,XMM1
MOVSD qword ptr [RDX + RDI*0x1 + 0x8],XMM0
CMP R12D,ECX
JLE 0x001014a1
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RBP + RSI*0x1 + 0x8]
CVTSI2SD XMM1,dword ptr [RBX + RSI*0x1 + 0x8]
DIVSD XMM0,XMM1
MOVSD qword ptr [RDX + RDI*0x1 + 0x10],XMM0
LAB_001014a1:
POP RBX
MOV RAX,RDX
POP RBP
POP R12
RET
LAB_001014a9:
XOR ECX,ECX
JMP 0x00101426 | void * func0(long param_1,long param_2,uint param_3)
{
int iVar1;
int iVar2;
void *pvVar3;
long lVar4;
long lVar5;
uint uVar6;
ulong uVar7;
int auVar8 [16];
int auVar9 [16];
int auVar10 [16];
int auVar11 [16];
uVar7 = (ulong)(int)param_3;
pvVar3 = malloc(uVar7 << 3);
if (0 < (int)param_3) {
if (param_3 - 1 < 3) {
uVar6 = 0;
}
else {
lVar4 = 0;
do {
auVar10._0_8_ = (double)(int)*(int8 *)(param_2 + lVar4);
auVar10._8_8_ = (double)(int)((ulong)*(int8 *)(param_2 + lVar4) >> 0x20);
auVar8._0_8_ = (double)(int)*(int8 *)(param_1 + lVar4);
auVar8._8_8_ = (double)(int)((ulong)*(int8 *)(param_1 + lVar4) >> 0x20);
auVar8 = divpd(auVar8,auVar10);
iVar1 = *(int *)(param_1 + lVar4 + 8);
iVar2 = *(int *)(param_1 + lVar4 + 0xc);
auVar11._0_8_ = (double)*(int *)(param_2 + lVar4 + 8);
auVar11._8_8_ = (double)*(int *)(param_2 + lVar4 + 0xc);
*(int (*) [16])((long)pvVar3 + lVar4 * 2) = auVar8;
auVar9._0_8_ = (double)iVar1;
auVar9._8_8_ = (double)iVar2;
auVar8 = divpd(auVar9,auVar11);
*(int (*) [16])((long)pvVar3 + lVar4 * 2 + 0x10) = auVar8;
lVar4 = lVar4 + 0x10;
} while (lVar4 != (uVar7 >> 2 & 0x3fffffff) << 4);
uVar6 = param_3 & 0xfffffffc;
if ((uVar7 & 3) == 0) {
return pvVar3;
}
}
lVar5 = (long)(int)uVar6;
lVar4 = lVar5 * 4;
*(double *)((long)pvVar3 + lVar5 * 8) =
(double)*(int *)(param_1 + lVar5 * 4) / (double)*(int *)(param_2 + lVar5 * 4);
if (((int)(uVar6 + 1) < (int)param_3) &&
(*(double *)((long)pvVar3 + lVar5 * 8 + 8) =
(double)*(int *)(param_1 + 4 + lVar4) / (double)*(int *)(param_2 + 4 + lVar4),
(int)(uVar6 + 2) < (int)param_3)) {
*(double *)((long)pvVar3 + lVar5 * 8 + 0x10) =
(double)*(int *)(param_1 + 8 + lVar4) / (double)*(int *)(param_2 + 8 + lVar4);
}
}
return pvVar3;
} |
6,368 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
strcat(res, dig);
return res;
}
| int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x41c(%rbp)
movl $0x0,-0x418(%rbp)
movl $0x0,-0x414(%rbp)
jmpq 12b2 <func0+0xe9>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x414(%rbp),%edx
movslq %edx,%rcx
mov -0x428(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 1279 <func0+0xb0>
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x418(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x418(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x410(%rbp,%rax,1)
jmp 12ab <func0+0xe2>
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x41c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x41c(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2d98(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x414(%rbp)
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1211 <func0+0x48>
mov -0x418(%rbp),%eax
cltq
movb $0x0,-0x410(%rbp,%rax,1)
mov -0x41c(%rbp),%eax
cltq
lea 0x2d51(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea -0x410(%rbp),%rax
mov %rax,%rsi
lea 0x2d3c(%rip),%rdi
callq 10c0 <strcat@plt>
lea 0x2d30(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1324 <func0+0x15b>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+var_428], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_41C], 0
mov [rbp+var_418], 0
mov [rbp+var_414], 0
jmp loc_12B2
loc_1211:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_414]
movsxd rcx, edx
mov rdx, [rbp+var_428]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_1279
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
lea rcx, [rdx+rax]
mov eax, [rbp+var_418]
lea edx, [rax+1]
mov [rbp+var_418], edx
movzx edx, byte ptr [rcx]
cdqe
mov [rbp+rax+src], dl
jmp short loc_12AB
loc_1279:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
lea rcx, [rdx+rax]
mov eax, [rbp+var_41C]
lea edx, [rax+1]
mov [rbp+var_41C], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, res_1
mov [rax+rcx], dl
loc_12AB:
add [rbp+var_414], 1
loc_12B2:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_1211
mov eax, [rbp+var_418]
cdqe
mov [rbp+rax+src], 0
mov eax, [rbp+var_41C]
cdqe
lea rdx, res_1
mov byte ptr [rax+rdx], 0
lea rax, [rbp+src]
mov rsi, rax; src
lea rax, res_1
mov rdi, rax; dest
call _strcat
lea rax, res_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1327
call ___stack_chk_fail
locret_1327:
leave
retn | char * func0(long long a1)
{
int v1; // eax
int v2; // eax
int v4; // [rsp+14h] [rbp-41Ch]
int v5; // [rsp+18h] [rbp-418h]
int i; // [rsp+1Ch] [rbp-414h]
char src[1032]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v8; // [rsp+428h] [rbp-8h]
v8 = __readfsqword(0x28u);
v4 = 0;
v5 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x800) != 0 )
{
v1 = v5++;
src[v1] = *(_BYTE *)(i + a1);
}
else
{
v2 = v4++;
res_1[v2] = *(_BYTE *)(i + a1);
}
}
src[v5] = 0;
res_1[v4] = 0;
strcat(res_1, src);
return res_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x41c],0x0
MOV dword ptr [RBP + -0x418],0x0
MOV dword ptr [RBP + -0x414],0x0
JMP 0x001012b2
LAB_00101211:
CALL 0x001010d0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x414]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x428]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x00101279
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x418]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x418],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x410],DL
JMP 0x001012ab
LAB_00101279:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x41c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x41c],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_001012ab:
ADD dword ptr [RBP + -0x414],0x1
LAB_001012b2:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101211
MOV EAX,dword ptr [RBP + -0x418]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x410],0x0
MOV EAX,dword ptr [RBP + -0x41c]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[RBP + -0x410]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101327
CALL 0x00101090
LAB_00101327:
LEAVE
RET | int1 * func0(long param_1)
{
ushort **ppuVar1;
long in_FS_OFFSET;
int local_424;
int local_420;
int local_41c;
char local_418 [1032];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_424 = 0;
local_420 = 0;
for (local_41c = 0; *(char *)(param_1 + local_41c) != '\0'; local_41c = local_41c + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 + local_41c)] & 0x800) == 0) {
res_1[local_424] = *(int *)(local_41c + param_1);
local_424 = local_424 + 1;
}
else {
local_418[local_420] = *(char *)(local_41c + param_1);
local_420 = local_420 + 1;
}
}
local_418[local_420] = '\0';
res_1[local_424] = 0;
strcat(res_1,local_418);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
6,369 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
strcat(res, dig);
return res;
}
| int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x418,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
movzbl (%rdi),%ebx
test %bl,%bl
je 1220 <func0+0x77>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov $0x0,%r8d
mov $0x0,%esi
lea 0x2e52(%rip),%r9
jmp 1206 <func0+0x5d>
movslq %esi,%rdx
mov %bl,(%r9,%rdx,1)
lea 0x1(%rsi),%esi
add $0x1,%rdi
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 122b <func0+0x82>
movsbq %bl,%rdx
mov (%rax),%rcx
testb $0x8,0x1(%rcx,%rdx,2)
je 11f0 <func0+0x47>
movslq %r8d,%rdx
mov %bl,(%rsp,%rdx,1)
lea 0x1(%r8),%r8d
jmp 11fa <func0+0x51>
mov $0x0,%r8d
mov $0x0,%esi
movslq %r8d,%r8
movb $0x0,(%rsp,%r8,1)
lea 0x2e06(%rip),%rbx
movslq %esi,%rsi
movb $0x0,(%rbx,%rsi,1)
mov %rsp,%rsi
mov $0x400,%edx
mov %rbx,%rdi
callq 1080 <__strcat_chk@plt>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1271 <func0+0xc8>
mov %rbx,%rax
add $0x418,%rsp
pop %rbx
pop %rbp
retq
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 418h
mov rax, fs:28h
mov [rsp+428h+var_20], rax
xor eax, eax
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1240
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
mov r8d, 0
mov esi, 0
lea r9, res_1
jmp short loc_1226
loc_1210:
movsxd rdx, esi
mov [r9+rdx], bl
lea esi, [rsi+1]
loc_121A:
add rdi, 1
movzx ebx, byte ptr [rdi-1]
test bl, bl
jz short loc_124B
loc_1226:
movsx rdx, bl
mov rcx, [rax]
test byte ptr [rcx+rdx*2+1], 8
jz short loc_1210
movsxd rdx, r8d
mov [rsp+rdx+428h+var_428], bl
lea r8d, [r8+1]
jmp short loc_121A
loc_1240:
mov r8d, 0
mov esi, 0
loc_124B:
movsxd r8, r8d
mov [rsp+r8+428h+var_428], 0
lea rbx, res_1
movsxd rsi, esi
mov byte ptr [rbx+rsi], 0
mov rsi, rsp
mov edx, 400h
mov rdi, rbx
call ___strcat_chk
mov rax, [rsp+428h+var_20]
sub rax, fs:28h
jnz short loc_1291
mov rax, rbx
add rsp, 418h
pop rbx
pop rbp
retn
loc_1291:
call ___stack_chk_fail | _BYTE * func0(char *a1, long long a2, long long a3, long long a4, long long a5, _BYTE *a6)
{
char v6; // bl
long long *v7; // rax
char *v8; // rdi
int v9; // r8d
int v10; // esi
_BYTE v12[1032]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v13; // [rsp+408h] [rbp-20h]
v13 = __readfsqword(0x28u);
v6 = *a1;
if ( *a1 )
{
v7 = (long long *)__ctype_b_loc();
v8 = a1 + 1;
v9 = 0;
v10 = 0;
a6 = res_1;
do
{
a4 = *v7;
if ( (*(_BYTE *)(*v7 + 2LL * v6 + 1) & 8) != 0 )
v12[v9++] = v6;
else
res_1[v10++] = v6;
v6 = *v8++;
}
while ( v6 );
}
else
{
v9 = 0;
v10 = 0;
}
v12[v9] = 0;
res_1[v10] = 0;
__strcat_chk(res_1, v12, 1024LL, a4, v9, a6);
return res_1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x418
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101240
MOV RBP,RDI
CALL 0x001010d0
LEA RDI,[RBP + 0x1]
MOV R8D,0x0
MOV ESI,0x0
LEA R9,[0x104040]
JMP 0x00101226
LAB_00101210:
MOVSXD RDX,ESI
MOV byte ptr [R9 + RDX*0x1],BL
LEA ESI,[RSI + 0x1]
LAB_0010121a:
ADD RDI,0x1
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JZ 0x0010124b
LAB_00101226:
MOVSX RDX,BL
MOV RCX,qword ptr [RAX]
TEST byte ptr [RCX + RDX*0x2 + 0x1],0x8
JZ 0x00101210
MOVSXD RDX,R8D
MOV byte ptr [RSP + RDX*0x1],BL
LEA R8D,[R8 + 0x1]
JMP 0x0010121a
LAB_00101240:
MOV R8D,0x0
MOV ESI,0x0
LAB_0010124b:
MOVSXD R8,R8D
MOV byte ptr [RSP + R8*0x1],0x0
LEA RBX,[0x104040]
MOVSXD RSI,ESI
MOV byte ptr [RBX + RSI*0x1],0x0
MOV RSI,RSP
MOV EDX,0x400
MOV RDI,RBX
CALL 0x00101090
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101291
MOV RAX,RBX
ADD RSP,0x418
POP RBX
POP RBP
RET
LAB_00101291:
CALL 0x001010a0 | int1 * func0(char *param_1)
{
ushort **ppuVar1;
char cVar2;
int iVar3;
char *pcVar4;
int iVar5;
long in_FS_OFFSET;
char local_428 [1032];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar2 = *param_1;
if (cVar2 == '\0') {
iVar5 = 0;
iVar3 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
iVar5 = 0;
iVar3 = 0;
pcVar4 = param_1 + 1;
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar2 * 2 + 1) & 8) == 0) {
(&res_1)[iVar3] = cVar2;
iVar3 = iVar3 + 1;
}
else {
local_428[iVar5] = cVar2;
iVar5 = iVar5 + 1;
}
cVar2 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar2 != '\0');
}
local_428[iVar5] = '\0';
(&res_1)[iVar3] = 0;
__strcat_chk(&res_1,local_428,0x400);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return &res_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,370 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
strcat(res, dig);
return res;
}
| int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x418,%rsp
movzbl (%rdi),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
test %bl,%bl
je 1360 <func0+0xd0>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %r8d,%r8d
xor %esi,%esi
lea 0x2d6d(%rip),%r9
jmp 12ee <func0+0x5e>
nopl (%rax)
movslq %r8d,%rdx
add $0x1,%rdi
add $0x1,%r8d
mov %bl,(%rsp,%rdx,1)
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 1312 <func0+0x82>
mov (%rax),%rcx
movsbq %bl,%rdx
testb $0x8,0x1(%rcx,%rdx,2)
jne 12d8 <func0+0x48>
movslq %esi,%rdx
add $0x1,%rdi
add $0x1,%esi
mov %bl,(%r9,%rdx,1)
movzbl -0x1(%rdi),%ebx
test %bl,%bl
jne 12ee <func0+0x5e>
movslq %esi,%rsi
movslq %r8d,%r8
mov $0x400,%edx
movb $0x0,(%r9,%rsi,1)
lea 0x2d17(%rip),%rdi
mov %rsp,%rsi
movb $0x0,(%rsp,%r8,1)
callq 1080 <__strcat_chk@plt>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 136e <func0+0xde>
add $0x418,%rsp
lea 0x2ce9(%rip),%rax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
xor %esi,%esi
lea 0x2cd4(%rip),%r9
jmp 1312 <func0+0x82>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbp
push rbx
sub rsp, 418h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+428h+var_20], rax
xor eax, eax
test bl, bl
jz loc_1368
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r8d, r8d
xor esi, esi
lea r9, res_1
jmp short loc_12FE
loc_12E8:
movsxd rdx, r8d
add rdi, 1
add r8d, 1
mov [rsp+rdx+428h+var_428], bl
movzx ebx, byte ptr [rdi-1]
test bl, bl
jz short loc_1322
loc_12FE:
mov rcx, [rax]
movsx rdx, bl
test byte ptr [rcx+rdx*2+1], 8
jnz short loc_12E8
movsxd rdx, esi
add rdi, 1
add esi, 1
mov [r9+rdx], bl
movzx ebx, byte ptr [rdi-1]
test bl, bl
jnz short loc_12FE
loc_1322:
movsxd rsi, esi
movsxd r8, r8d
mov rdi, r9
mov edx, 400h
mov byte ptr [r9+rsi], 0
mov rsi, rsp
mov [rsp+r8+428h+var_428], 0
call ___strcat_chk
mov r9, rax
mov rax, [rsp+428h+var_20]
sub rax, fs:28h
jnz short loc_1376
add rsp, 418h
mov rax, r9
pop rbx
pop rbp
retn
loc_1368:
xor r8d, r8d
xor esi, esi
lea r9, res_1
jmp short loc_1322
loc_1376:
call ___stack_chk_fail | long long func0(char *a1)
{
char v1; // bl
_QWORD *v2; // rax
_BYTE *v3; // rdi
int v4; // r8d
int v5; // esi
long long v6; // rdx
long long v7; // rdx
_BYTE v9[1032]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-20h]
v1 = *a1;
v10 = __readfsqword(0x28u);
if ( v1 )
{
v2 = (_QWORD *)__ctype_b_loc();
v3 = a1 + 1;
v4 = 0;
v5 = 0;
do
{
while ( (*(_BYTE *)(*v2 + 2LL * v1 + 1) & 8) != 0 )
{
v6 = v4;
++v3;
++v4;
v9[v6] = v1;
v1 = *(v3 - 1);
if ( !v1 )
goto LABEL_6;
}
v7 = v5;
++v3;
++v5;
res_1[v7] = v1;
v1 = *(v3 - 1);
}
while ( v1 );
}
else
{
v4 = 0;
v5 = 0;
}
LABEL_6:
res_1[v5] = 0;
v9[v4] = 0;
return __strcat_chk(res_1, v9, 1024LL);
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x418
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
TEST BL,BL
JZ 0x00101368
MOV RBP,RDI
CALL 0x001010d0
LEA RDI,[RBP + 0x1]
XOR R8D,R8D
XOR ESI,ESI
LEA R9,[0x104040]
JMP 0x001012fe
LAB_001012e8:
MOVSXD RDX,R8D
ADD RDI,0x1
ADD R8D,0x1
MOV byte ptr [RSP + RDX*0x1],BL
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JZ 0x00101322
LAB_001012fe:
MOV RCX,qword ptr [RAX]
MOVSX RDX,BL
TEST byte ptr [RCX + RDX*0x2 + 0x1],0x8
JNZ 0x001012e8
MOVSXD RDX,ESI
ADD RDI,0x1
ADD ESI,0x1
MOV byte ptr [R9 + RDX*0x1],BL
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JNZ 0x001012fe
LAB_00101322:
MOVSXD RSI,ESI
MOVSXD R8,R8D
MOV RDI,R9
MOV EDX,0x400
MOV byte ptr [R9 + RSI*0x1],0x0
MOV RSI,RSP
MOV byte ptr [RSP + R8*0x1],0x0
CALL 0x00101090
MOV R9,RAX
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101376
ADD RSP,0x418
MOV RAX,R9
POP RBX
POP RBP
RET
LAB_00101368:
XOR R8D,R8D
XOR ESI,ESI
LEA R9,[0x104040]
JMP 0x00101322
LAB_00101376:
CALL 0x001010a0 | int8 func0(char *param_1)
{
ushort **ppuVar1;
int8 uVar2;
long lVar3;
char cVar4;
int iVar5;
char *pcVar6;
int iVar7;
long in_FS_OFFSET;
char local_428 [1032];
long local_20;
cVar4 = *param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar4 == '\0') {
iVar7 = 0;
iVar5 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
iVar7 = 0;
iVar5 = 0;
pcVar6 = param_1 + 1;
do {
while ((*(byte *)((long)*ppuVar1 + (long)cVar4 * 2 + 1) & 8) == 0) {
lVar3 = (long)iVar5;
iVar5 = iVar5 + 1;
(&res_1)[lVar3] = cVar4;
cVar4 = *pcVar6;
pcVar6 = pcVar6 + 1;
if (cVar4 == '\0') goto LAB_00101322;
}
lVar3 = (long)iVar7;
iVar7 = iVar7 + 1;
local_428[lVar3] = cVar4;
cVar4 = *pcVar6;
pcVar6 = pcVar6 + 1;
} while (cVar4 != '\0');
}
LAB_00101322:
(&res_1)[iVar5] = 0;
local_428[iVar7] = '\0';
uVar2 = __strcat_chk(&res_1,local_428,0x400);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,371 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
strcat(res, dig);
return res;
}
| int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x418,%rsp
movzbl (%rdi),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
test %bl,%bl
je 1328 <func0+0x98>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %ecx,%ecx
xor %edx,%edx
mov (%rax),%r8
lea 0x2d6f(%rip),%r9
nopl 0x0(%rax)
movsbq %bl,%rsi
testb $0x8,0x1(%r8,%rsi,2)
je 1305 <func0+0x75>
add $0x1,%rdi
mov %bl,(%rsp,%rcx,1)
lea 0x1(%rcx),%esi
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 1338 <func0+0xa8>
movslq %esi,%rcx
movsbq %bl,%rsi
testb $0x8,0x1(%r8,%rsi,2)
jne 12e4 <func0+0x54>
add $0x1,%rdi
mov %bl,(%r9,%rdx,1)
lea 0x1(%rdx),%r8d
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 1380 <func0+0xf0>
movslq %r8d,%rdx
mov (%rax),%r8
jmp 12d8 <func0+0x48>
nopl 0x0(%rax)
xor %esi,%esi
xor %edx,%edx
lea 0x2d0d(%rip),%r9
nopl 0x0(%rax,%rax,1)
movslq %esi,%rsi
movb $0x0,(%r9,%rdx,1)
lea 0x2cf9(%rip),%rdi
mov $0x400,%edx
movb $0x0,(%rsp,%rsi,1)
mov %rsp,%rsi
callq 1080 <__strcat_chk@plt>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1387 <func0+0xf7>
add $0x418,%rsp
lea 0x2cc7(%rip),%rax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
mov %ecx,%esi
movslq %r8d,%rdx
jmp 1338 <func0+0xa8>
callq 1090 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push rbp
push rbx
sub rsp, 418h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+428h+var_20], rax
xor eax, eax
test bl, bl
jz loc_1370
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor edx, edx
xor ecx, ecx
mov r8, [rax]
lea r9, res_1
nop dword ptr [rax]
loc_12E8:
movsx rsi, bl
test byte ptr [r8+rsi*2+1], 8
jz short loc_1350
add rdi, 1
mov [rsp+rdx+428h+var_428], bl
lea esi, [rdx+1]
movzx ebx, byte ptr [rdi-1]
movsxd rdx, esi
test bl, bl
jnz short loc_12E8
mov esi, ecx
loc_130B:
movsxd rsi, esi
mov [rsp+rdx+428h+var_428], 0
mov rdi, r9
mov edx, 400h
mov byte ptr [r9+rsi], 0
mov rsi, rsp
call ___strcat_chk
mov r9, rax
mov rax, [rsp+428h+var_20]
sub rax, fs:28h
jnz short loc_137D
add rsp, 418h
mov rax, r9
pop rbx
pop rbp
retn
loc_1350:
add rdi, 1
mov [r9+rcx], bl
lea esi, [rcx+1]
movzx ebx, byte ptr [rdi-1]
test bl, bl
jz short loc_130B
mov r8, [rax]
movsxd rcx, esi
jmp loc_12E8
loc_1370:
xor edx, edx
xor esi, esi
lea r9, res_1
jmp short loc_130B
loc_137D:
call ___stack_chk_fail | long long func0(char *a1)
{
char v1; // bl
const unsigned __int16 **v2; // rax
_BYTE *v3; // rdi
long long v4; // rdx
long long v5; // rcx
const unsigned __int16 *v6; // r8
int v7; // esi
_BYTE v9[1032]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-20h]
v1 = *a1;
v10 = __readfsqword(0x28u);
if ( v1 )
{
v2 = __ctype_b_loc();
v3 = a1 + 1;
v4 = 0LL;
v5 = 0LL;
v6 = *v2;
do
{
while ( (v6[v1] & 0x800) == 0 )
{
++v3;
res_1[v5] = v1;
v7 = v5 + 1;
v1 = *(v3 - 1);
if ( !v1 )
goto LABEL_6;
v6 = *v2;
v5 = v7;
}
++v3;
v9[v4] = v1;
v1 = *(v3 - 1);
v4 = (int)v4 + 1;
}
while ( v1 );
v7 = v5;
}
else
{
v4 = 0LL;
v7 = 0;
}
LABEL_6:
v9[v4] = 0;
res_1[v7] = 0;
return __strcat_chk(res_1, v9, 1024LL);
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x418
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
TEST BL,BL
JZ 0x00101370
MOV RBP,RDI
CALL 0x001010d0
LEA RDI,[RBP + 0x1]
XOR EDX,EDX
XOR ECX,ECX
MOV R8,qword ptr [RAX]
LEA R9,[0x104040]
NOP dword ptr [RAX]
LAB_001012e8:
MOVSX RSI,BL
TEST byte ptr [R8 + RSI*0x2 + 0x1],0x8
JZ 0x00101350
ADD RDI,0x1
MOV byte ptr [RSP + RDX*0x1],BL
LEA ESI,[RDX + 0x1]
MOVZX EBX,byte ptr [RDI + -0x1]
MOVSXD RDX,ESI
TEST BL,BL
JNZ 0x001012e8
MOV ESI,ECX
LAB_0010130b:
MOVSXD RSI,ESI
MOV byte ptr [RSP + RDX*0x1],0x0
MOV RDI,R9
MOV EDX,0x400
MOV byte ptr [R9 + RSI*0x1],0x0
MOV RSI,RSP
CALL 0x00101090
MOV R9,RAX
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010137d
ADD RSP,0x418
MOV RAX,R9
POP RBX
POP RBP
RET
LAB_00101350:
ADD RDI,0x1
MOV byte ptr [R9 + RCX*0x1],BL
LEA ESI,[RCX + 0x1]
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JZ 0x0010130b
MOV R8,qword ptr [RAX]
MOVSXD RCX,ESI
JMP 0x001012e8
LAB_00101370:
XOR EDX,EDX
XOR ESI,ESI
LEA R9,[0x104040]
JMP 0x0010130b
LAB_0010137d:
CALL 0x001010a0 | int8 func0(char *param_1)
{
ushort **ppuVar1;
int8 uVar2;
long lVar3;
long lVar4;
char cVar5;
int iVar6;
char *pcVar7;
ushort *puVar8;
long in_FS_OFFSET;
char local_428 [1032];
long local_20;
cVar5 = *param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar5 == '\0') {
lVar4 = 0;
iVar6 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
lVar4 = 0;
lVar3 = 0;
puVar8 = *ppuVar1;
pcVar7 = param_1 + 1;
do {
while (iVar6 = (int)lVar3, (*(byte *)((long)puVar8 + (long)cVar5 * 2 + 1) & 8) == 0) {
(&res_1)[lVar3] = cVar5;
iVar6 = iVar6 + 1;
cVar5 = *pcVar7;
if (cVar5 == '\0') goto LAB_0010130b;
lVar3 = (long)iVar6;
pcVar7 = pcVar7 + 1;
puVar8 = *ppuVar1;
}
local_428[lVar4] = cVar5;
cVar5 = *pcVar7;
lVar4 = (long)((int)lVar4 + 1);
pcVar7 = pcVar7 + 1;
} while (cVar5 != '\0');
}
LAB_0010130b:
local_428[lVar4] = '\0';
(&res_1)[iVar6] = 0;
uVar2 = __strcat_chk(&res_1,local_428,0x400);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
} |
6,372 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
}
}
dp[i] = 1 + mxm;
}
int max_val = dp[0];
for (int i = 1; i < n; i++) {
if (max_val < dp[i]) {
max_val = dp[i];
}
}
return max_val;
}
| int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1208 <func0+0x9f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f1 <func0+0x88>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1232 <func0+0xc9>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
mov -0x4c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
movl $0x1,(%rax,%rdx,4)
mov -0x4c(%rbp),%eax
sub $0x2,%eax
mov %eax,-0x30(%rbp)
jmpq 1331 <func0+0x1c8>
movl $0x0,-0x34(%rbp)
mov -0x30(%rbp),%eax
add $0x1,%eax
mov %eax,-0x38(%rbp)
jmpq 130e <func0+0x1a5>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%ecx
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
je 12e8 <func0+0x17f>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%ecx
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
jne 130a <func0+0x1a1>
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,-0x34(%rbp)
jge 130a <func0+0x1a1>
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,-0x34(%rbp)
addl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 127c <func0+0x113>
mov -0x34(%rbp),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
subl $0x1,-0x30(%rbp)
cmpl $0x0,-0x30(%rbp)
jns 1267 <func0+0xfe>
mov -0x20(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x3c(%rbp)
movl $0x1,-0x2c(%rbp)
jmp 1373 <func0+0x20a>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,-0x3c(%rbp)
jge 136f <func0+0x206>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,-0x3c(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 134d <func0+0x1e4>
mov -0x3c(%rbp),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 1395 <func0+0x22c>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D6:
cmp rsp, rdx
jz short loc_11ED
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11D6
loc_11ED:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1217
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1217:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov eax, [rbp+var_3C]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 1
mov eax, [rbp+var_3C]
sub eax, 2
mov [rbp+var_2C], eax
jmp loc_131A
loc_124C:
mov [rbp+var_28], 0
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_24], eax
jmp loc_12F7
loc_1261:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_2C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_38]
add rdx, rcx
mov edi, [rdx]
cdq
idiv edi
mov ecx, edx
mov eax, ecx
test eax, eax
jz short loc_12D1
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_38]
add rdx, rcx
mov edi, [rdx]
cdq
idiv edi
mov ecx, edx
mov eax, ecx
test eax, eax
jnz short loc_12F3
loc_12D1:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp [rbp+var_28], eax
jge short loc_12F3
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rbp+var_28], eax
loc_12F3:
add [rbp+var_24], 1
loc_12F7:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl loc_1261
mov eax, [rbp+var_28]
lea ecx, [rax+1]
mov rax, [rbp+var_10]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
sub [rbp+var_2C], 1
loc_131A:
cmp [rbp+var_2C], 0
jns loc_124C
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_20], eax
mov [rbp+var_1C], 1
jmp short loc_135C
loc_1336:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp [rbp+var_20], eax
jge short loc_1358
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rbp+var_20], eax
loc_1358:
add [rbp+var_1C], 1
loc_135C:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_3C]
jl short loc_1336
mov eax, [rbp+var_20]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_137E
call ___stack_chk_fail
locret_137E:
leave
retn | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[4]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+Ch] [rbp-3Ch]
long long v7; // [rsp+10h] [rbp-38h]
int i; // [rsp+1Ch] [rbp-2Ch]
int v9; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
unsigned int v11; // [rsp+28h] [rbp-20h]
int k; // [rsp+2Ch] [rbp-1Ch]
long long v13; // [rsp+30h] [rbp-18h]
unsigned int *v14; // [rsp+38h] [rbp-10h]
unsigned long long v15; // [rsp+40h] [rbp-8h]
v7 = a1;
v6 = a2;
v15 = __readfsqword(0x28u);
v13 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v5 != &v5[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v5[(v2 & 0xFFF) - 8] = *(_QWORD *)&v5[(v2 & 0xFFF) - 8];
v14 = (unsigned int *)v5;
*(_DWORD *)&v5[4 * v6 - 4] = 1;
for ( i = v6 - 2; i >= 0; --i )
{
v9 = 0;
for ( j = i + 1; j < v6; ++j )
{
if ( (!(*(_DWORD *)(4LL * j + v7) % *(_DWORD *)(4LL * i + v7))
|| !(*(_DWORD *)(4LL * i + v7) % *(_DWORD *)(4LL * j + v7)))
&& v9 < (int)v14[j] )
{
v9 = v14[j];
}
}
v14[i] = v9 + 1;
}
v11 = *v14;
for ( k = 1; k < v6; ++k )
{
if ( (int)v11 < (int)v14[k] )
v11 = v14[k];
}
return v11;
} | 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 RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d6:
CMP RSP,RDX
JZ 0x001011ed
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d6
LAB_001011ed:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101217
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101217:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x3c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x1
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x2
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0010131a
LAB_0010124c:
MOV dword ptr [RBP + -0x28],0x0
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001012f7
LAB_00101261:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV EDI,dword ptr [RDX]
CDQ
IDIV EDI
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JZ 0x001012d1
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV EDI,dword ptr [RDX]
CDQ
IDIV EDI
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JNZ 0x001012f3
LAB_001012d1:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP dword ptr [RBP + -0x28],EAX
JGE 0x001012f3
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
LAB_001012f3:
ADD dword ptr [RBP + -0x24],0x1
LAB_001012f7:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101261
MOV EAX,dword ptr [RBP + -0x28]
LEA ECX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
SUB dword ptr [RBP + -0x2c],0x1
LAB_0010131a:
CMP dword ptr [RBP + -0x2c],0x0
JNS 0x0010124c
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x1c],0x1
JMP 0x0010135c
LAB_00101336:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP dword ptr [RBP + -0x20],EAX
JGE 0x00101358
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RBP + -0x20],EAX
LAB_00101358:
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010135c:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101336
MOV EAX,dword ptr [RBP + -0x20]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010137e
CALL 0x00101060
LAB_0010137e:
LEAVE
RET | int func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
long local_40;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = param_1;
local_44 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)param_2 + -1;
uVar2 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
*(int4 *)(puVar3 + (long)(local_44 + -1) * 4 + lVar1) = 1;
for (local_34 = local_44 + -2; -1 < local_34; local_34 = local_34 + -1) {
local_30 = 0;
local_2c = local_34;
while (local_2c = local_2c + 1, local_2c < local_44) {
if (((*(int *)(local_40 + (long)local_2c * 4) % *(int *)(local_40 + (long)local_34 * 4) == 0)
|| (*(int *)(local_40 + (long)local_34 * 4) % *(int *)(local_40 + (long)local_2c * 4) == 0
)) && (local_30 < *(int *)(puVar3 + (long)local_2c * 4 + lVar1))) {
local_30 = *(int *)(puVar3 + (long)local_2c * 4 + lVar1);
}
}
*(int *)(puVar3 + (long)local_34 * 4 + lVar1) = local_30 + 1;
}
local_28 = *(int *)(puVar3 + lVar1);
for (local_24 = 1; local_24 < local_44; local_24 = local_24 + 1) {
if (local_28 < *(int *)(puVar3 + (long)local_24 * 4 + lVar1)) {
local_28 = *(int *)(puVar3 + (long)local_24 * 4 + lVar1);
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_28;
}
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,373 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
}
}
dp[i] = 1 + mxm;
}
int max_val = dp[0];
for (int i = 1; i < n; i++) {
if (max_val < dp[i]) {
max_val = dp[i];
}
}
return max_val;
}
| int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
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,%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 11c3 <func0+0x5a>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ac <func0+0x43>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d9 <func0+0x70>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r13
mov %r13,%r14
shr $0x2,%r14
and $0xfffffffffffffffc,%r13
mov %r13,%r11
lea -0x1(%rsi),%r12d
movslq %r12d,%rax
movl $0x1,0x0(%r13,%rax,4)
mov %esi,%ebx
sub $0x2,%ebx
js 1265 <func0+0xfc>
movslq %ebx,%rbx
jmp 1251 <func0+0xe8>
mov (%r11,%rcx,4),%eax
cmp %eax,%r10d
cmovl %eax,%r10d
add $0x1,%rcx
cmp %ecx,%esi
jle 123d <func0+0xd4>
mov (%rdi,%rcx,4),%r8d
mov %r8d,%eax
cltd
idiv %r9d
test %edx,%edx
je 1208 <func0+0x9f>
mov %r9d,%eax
cltd
idiv %r8d
test %edx,%edx
jne 1213 <func0+0xaa>
jmp 1208 <func0+0x9f>
mov $0x0,%r10d
add $0x1,%r10d
mov %r10d,(%r11,%rbx,4)
sub $0x1,%rbx
sub $0x1,%r12d
test %ebx,%ebx
js 1265 <func0+0xfc>
cmp %r12d,%esi
jle 1237 <func0+0xce>
mov (%rdi,%rbx,4),%r9d
movslq %r12d,%rcx
mov $0x0,%r10d
jmp 121b <func0+0xb2>
mov 0x0(,%r14,4),%edx
cmp $0x1,%esi
jle 128e <func0+0x125>
lea 0x4(%r13),%rax
lea -0x2(%rsi),%ecx
lea 0x8(%r13,%rcx,4),%rsi
mov (%rax),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x4,%rax
cmp %rsi,%rax
jne 127e <func0+0x115>
mov -0x28(%rbp),%rax
xor %fs:0x28,%rax
jne 12ac <func0+0x143>
mov %edx,%eax
lea -0x20(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov r10, rdi
mov r9d, esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11AD:
cmp rsp, rdx
jz short loc_11C4
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11AD
loc_11C4:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11DA
or [rsp+rax+30h+var_38], 0
loc_11DA:
lea r11, [rsp+30h+var_2D]
mov r13, r11
shr r13, 2
and r11, 0FFFFFFFFFFFFFFFCh
lea r12d, [r9-1]
movsxd rax, r12d
mov dword ptr [r11+rax*4], 1
mov ebx, r9d
sub ebx, 2
js short loc_1260
movsxd rbx, ebx
jmp short loc_124C
loc_1206:
mov eax, [r11+rcx*4]
cmp r8d, eax
cmovl r8d, eax
loc_1211:
add rcx, 1
cmp r9d, ecx
jle short loc_1238
loc_121A:
mov esi, [r10+rcx*4]
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_1206
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_1211
jmp short loc_1206
loc_1232:
mov r8d, 0
loc_1238:
add r8d, 1
mov [r11+rbx*4], r8d
sub rbx, 1
sub r12d, 1
test ebx, ebx
js short loc_1260
loc_124C:
cmp r9d, r12d
jle short loc_1232
mov edi, [r10+rbx*4]
movsxd rcx, r12d
mov r8d, 0
jmp short loc_121A
loc_1260:
mov edx, ds:dword_0[r13*4]
cmp r9d, 1
jle short loc_128B
lea rax, [r11+4]
lea ecx, [r9-2]
lea rsi, [r11+rcx*4+8]
loc_127B:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_127B
loc_128B:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_12A7
mov eax, edx
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_12A7:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
signed long long v3; // rax
void *v4; // rsp
int v5; // r12d
long long v6; // rbx
int v7; // r8d
long long v8; // rcx
int v9; // edi
unsigned int v10; // edx
int *v11; // rax
long long v13; // [rsp+0h] [rbp-38h]
unsigned int v14; // [rsp+8h] [rbp-30h] BYREF
int v15; // [rsp+Ch] [rbp-2Ch] BYREF
_QWORD v16[5]; // [rsp+10h] [rbp-28h] BYREF
v16[0] = __readfsqword(0x28u);
while ( &v14 != (unsigned int *)((char *)&v14 - ((4LL * a2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v3 = (4 * (_WORD)a2 + 15) & 0xFF0;
v4 = alloca(v3);
if ( ((4 * (_WORD)a2 + 15) & 0xFF0) != 0 )
*(long long *)((char *)&v13 + v3) = *(long long *)((char *)&v13 + v3);
v5 = a2 - 1;
*(&v14 + a2 - 1) = 1;
LODWORD(v6) = a2 - 2;
if ( a2 - 2 >= 0 )
{
v6 = (int)v6;
do
{
if ( a2 <= v5 )
{
v7 = 0;
}
else
{
v9 = *(_DWORD *)(a1 + 4 * v6);
v8 = v5;
v7 = 0;
do
{
if ( (!(*(_DWORD *)(a1 + 4 * v8) % v9) || !(v9 % *(_DWORD *)(a1 + 4 * v8))) && v7 < (int)*(&v14 + v8) )
v7 = *(&v14 + v8);
++v8;
}
while ( a2 > (int)v8 );
}
*(&v14 + v6--) = v7 + 1;
--v5;
}
while ( (int)v6 >= 0 );
}
v10 = v14;
if ( a2 > 1 )
{
v11 = &v15;
do
{
if ( (int)v10 < *v11 )
v10 = *v11;
++v11;
}
while ( v11 != (int *)((char *)v16 + 4 * (unsigned int)(a2 - 2)) );
}
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R10,RDI
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ad:
CMP RSP,RDX
JZ 0x001011c4
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ad
LAB_001011c4:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011da
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011da:
LEA R11,[RSP + 0x3]
MOV R13,R11
SHR R13,0x2
AND R11,-0x4
LEA R12D,[R9 + -0x1]
MOVSXD RAX,R12D
MOV dword ptr [R11 + RAX*0x4],0x1
MOV EBX,R9D
SUB EBX,0x2
JS 0x00101260
MOVSXD RBX,EBX
JMP 0x0010124c
LAB_00101206:
MOV EAX,dword ptr [R11 + RCX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
LAB_00101211:
ADD RCX,0x1
CMP R9D,ECX
JLE 0x00101238
LAB_0010121a:
MOV ESI,dword ptr [R10 + RCX*0x4]
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x00101206
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x00101211
JMP 0x00101206
LAB_00101232:
MOV R8D,0x0
LAB_00101238:
ADD R8D,0x1
MOV dword ptr [R11 + RBX*0x4],R8D
SUB RBX,0x1
SUB R12D,0x1
TEST EBX,EBX
JS 0x00101260
LAB_0010124c:
CMP R9D,R12D
JLE 0x00101232
MOV EDI,dword ptr [R10 + RBX*0x4]
MOVSXD RCX,R12D
MOV R8D,0x0
JMP 0x0010121a
LAB_00101260:
MOV EDX,dword ptr [R13*0x4]
CMP R9D,0x1
JLE 0x0010128b
LEA RAX,[R11 + 0x4]
LEA ECX,[R9 + -0x2]
LEA RSI,[R11 + RCX*0x4 + 0x8]
LAB_0010127b:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010127b
LAB_0010128b:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012a7
MOV EAX,EDX
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_001012a7:
CALL 0x00101060 | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
int *piVar5;
long lVar6;
long lVar7;
int1 *puVar8;
int iVar9;
int iVar10;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)param_2 * 4 + 0xf;
for (puVar8 = auStack_38; puVar8 != auStack_38 + -(uVar4 & 0xfffffffffffff000);
puVar8 = puVar8 + -0x1000) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar3 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
iVar10 = param_2 + -1;
*(int4 *)(puVar8 + (long)iVar10 * 4 + lVar3) = 1;
if (-1 < param_2 + -2) {
lVar7 = (long)(param_2 + -2);
do {
if (iVar10 < param_2) {
iVar2 = *(int *)(param_1 + lVar7 * 4);
lVar6 = (long)iVar10;
iVar9 = 0;
do {
iVar1 = *(int *)(param_1 + lVar6 * 4);
if (((iVar1 % iVar2 == 0) || (iVar2 % iVar1 == 0)) &&
(iVar9 < *(int *)(puVar8 + lVar6 * 4 + lVar3))) {
iVar9 = *(int *)(puVar8 + lVar6 * 4 + lVar3);
}
lVar6 = lVar6 + 1;
} while ((int)lVar6 < param_2);
}
else {
iVar9 = 0;
}
*(int *)(puVar8 + lVar7 * 4 + lVar3) = iVar9 + 1;
lVar7 = lVar7 + -1;
iVar10 = iVar10 + -1;
} while (-1 < (int)lVar7);
}
iVar10 = *(int *)(puVar8 + lVar3);
if (1 < param_2) {
piVar5 = (int *)(puVar8 + lVar3 + 4);
do {
if (iVar10 < *piVar5) {
iVar10 = *piVar5;
}
piVar5 = piVar5 + 1;
} while (piVar5 != (int *)(puVar8 + (ulong)(param_2 - 2) * 4 + lVar3 + 8));
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar8 + lVar3 + -8) = main;
__stack_chk_fail();
}
return iVar10;
} |
6,374 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
}
}
dp[i] = 1 + mxm;
}
int max_val = dp[0];
for (int i = 1; i < n; i++) {
if (max_val < dp[i]) {
max_val = dp[i];
}
}
return max_val;
}
| int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O2 | 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,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 131d <func0+0x5d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1308 <func0+0x48>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1418 <func0+0x158>
lea 0x3(%rsp),%r11
lea -0x1(%rsi),%r12d
mov %r11,%r14
movslq %r12d,%rax
lea -0x2(%rsi),%r13d
and $0xfffffffffffffffc,%r11
movl $0x1,(%r11,%rax,4)
shr $0x2,%r14
movslq %r13d,%rbx
test %r13d,%r13d
js 13b9 <func0+0xf9>
nopw 0x0(%rax,%rax,1)
cmp %r12d,%esi
jle 1410 <func0+0x150>
mov (%rdi,%rbx,4),%r9d
movslq %r12d,%rcx
xor %r10d,%r10d
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rcx,4),%r8d
mov %r8d,%eax
cltd
idiv %r9d
test %edx,%edx
je 1392 <func0+0xd2>
mov %r9d,%eax
cltd
idiv %r8d
test %edx,%edx
jne 139d <func0+0xdd>
mov (%r11,%rcx,4),%eax
cmp %eax,%r10d
cmovl %eax,%r10d
add $0x1,%rcx
cmp %ecx,%esi
jg 1378 <func0+0xb8>
add $0x1,%r10d
mov %r10d,(%r11,%rbx,4)
sub $0x1,%rbx
sub $0x1,%r12d
test %ebx,%ebx
jns 1360 <func0+0xa0>
mov 0x0(,%r14,4),%r8d
cmp $0x1,%esi
jle 13ea <func0+0x12a>
mov %r13d,%r13d
lea 0x4(%r11),%rax
lea 0x8(%r11,%r13,4),%rcx
nopw 0x0(%rax,%rax,1)
mov (%rax),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x4,%rax
cmp %rax,%rcx
jne 13d8 <func0+0x118>
mov -0x28(%rbp),%rax
xor %fs:0x28,%rax
jne 1423 <func0+0x163>
lea -0x20(%rbp),%rsp
mov %r8d,%eax
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
nopl 0x0(%rax)
mov $0x1,%r10d
jmp 13a9 <func0+0xe9>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 132f <func0+0x6f>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov r10, rdi
mov r9d, esi
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1320
loc_130B:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_130B
loc_1320:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1410
loc_1332:
lea r11, [rsp+1030h+var_102D]
lea r12d, [r9-1]
mov r14, r11
movsxd rax, r12d
lea r13d, [r9-2]
and r11, 0FFFFFFFFFFFFFFFCh
mov dword ptr [r11+rax*4], 1
shr r14, 2
movsxd rbx, r13d
test r13d, r13d
js short loc_13B6
nop dword ptr [rax]
loc_1360:
cmp r9d, r12d
jle loc_1408
mov edi, [r10+rbx*4]
movsxd rcx, r12d
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1378:
mov esi, [r10+rcx*4]
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_138E
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_1399
loc_138E:
mov eax, [r11+rcx*4]
cmp r8d, eax
cmovl r8d, eax
loc_1399:
add rcx, 1
cmp r9d, ecx
jg short loc_1378
add r8d, 1
loc_13A6:
mov [r11+rbx*4], r8d
sub rbx, 1
sub r12d, 1
test ebx, ebx
jns short loc_1360
loc_13B6:
mov r8d, ds:dword_0[r14*4]
cmp r9d, 1
jle short loc_13E2
mov r13d, r13d
lea rax, [r11+4]
lea rcx, [r11+r13*4+8]
loc_13D0:
mov edx, [rax]
cmp r8d, edx
cmovl r8d, edx
add rax, 4
cmp rax, rcx
jnz short loc_13D0
loc_13E2:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_141B
lea rsp, [rbp-20h]
mov eax, r8d
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_1408:
mov r8d, 1
jmp short loc_13A6
loc_1410:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_1332
loc_141B:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v3; // rdx
unsigned int *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
int v8; // r12d
long long v9; // rbx
int v10; // edi
long long v11; // rcx
int v12; // r8d
int v13; // r8d
unsigned int v14; // r8d
_BYTE *v15; // rax
long long v17; // [rsp+0h] [rbp-1038h]
unsigned int v18; // [rsp+8h] [rbp-1030h] BYREF
_BYTE v19[4084]; // [rsp+Ch] [rbp-102Ch] BYREF
_QWORD v20[6]; // [rsp+1008h] [rbp-30h] BYREF
v20[1] = __readfsqword(0x28u);
v3 = 4LL * a2 + 15;
v4 = (unsigned int *)((char *)v20 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( v20 != (_QWORD *)v4 )
{
while ( &v18 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(long long *)((char *)&v17 + v6) = *(long long *)((char *)&v17 + v6);
v8 = a2 - 1;
*(&v18 + a2 - 1) = 1;
v9 = a2 - 2;
if ( a2 - 2 >= 0 )
{
do
{
if ( a2 <= v8 )
{
v13 = 1;
}
else
{
v10 = *(_DWORD *)(a1 + 4 * v9);
v11 = v8;
v12 = 0;
do
{
if ( (!(*(_DWORD *)(a1 + 4 * v11) % v10) || !(v10 % *(_DWORD *)(a1 + 4 * v11)))
&& v12 < *(_DWORD *)&v19[4 * v11 - 4] )
{
v12 = *(_DWORD *)&v19[4 * v11 - 4];
}
++v11;
}
while ( a2 > (int)v11 );
v13 = v12 + 1;
}
*(_DWORD *)&v19[4 * v9-- - 4] = v13;
--v8;
}
while ( (int)v9 >= 0 );
}
v14 = v18;
if ( a2 > 1 )
{
v15 = v19;
do
{
if ( (signed int)v14 < *(_DWORD *)v15 )
v14 = *(_DWORD *)v15;
v15 += 4;
}
while ( v15 != &v19[4 * (a2 - 2) + 4] );
}
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV R10,RDI
MOV R9D,ESI
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101320
LAB_0010130b:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010130b
LAB_00101320:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101410
LAB_00101332:
LEA R11,[RSP + 0x3]
LEA R12D,[R9 + -0x1]
MOV R14,R11
MOVSXD RAX,R12D
LEA R13D,[R9 + -0x2]
AND R11,-0x4
MOV dword ptr [R11 + RAX*0x4],0x1
SHR R14,0x2
MOVSXD RBX,R13D
TEST R13D,R13D
JS 0x001013b6
NOP dword ptr [RAX]
LAB_00101360:
CMP R9D,R12D
JLE 0x00101408
MOV EDI,dword ptr [R10 + RBX*0x4]
MOVSXD RCX,R12D
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101378:
MOV ESI,dword ptr [R10 + RCX*0x4]
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x0010138e
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x00101399
LAB_0010138e:
MOV EAX,dword ptr [R11 + RCX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
LAB_00101399:
ADD RCX,0x1
CMP R9D,ECX
JG 0x00101378
ADD R8D,0x1
LAB_001013a6:
MOV dword ptr [R11 + RBX*0x4],R8D
SUB RBX,0x1
SUB R12D,0x1
TEST EBX,EBX
JNS 0x00101360
LAB_001013b6:
MOV R8D,dword ptr [R14*0x4]
CMP R9D,0x1
JLE 0x001013e2
MOV R13D,R13D
LEA RAX,[R11 + 0x4]
LEA RCX,[R11 + R13*0x4 + 0x8]
LAB_001013d0:
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001013d0
LAB_001013e2:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010141b
LEA RSP,[RBP + -0x20]
MOV EAX,R8D
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00101408:
MOV R8D,0x1
JMP 0x001013a6
LAB_00101410:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101332
LAB_0010141b:
CALL 0x00101060 | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int1 *puVar4;
int *piVar5;
long lVar6;
ulong uVar7;
uint uVar8;
long lVar9;
int1 *puVar10;
int iVar12;
int iVar13;
uint uVar14;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar11;
puVar10 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar7 = (long)param_2 * 4 + 0xf;
puVar11 = auStack_38;
puVar4 = auStack_38;
while (puVar11 != auStack_38 + -(uVar7 & 0xfffffffffffff000)) {
puVar10 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar11 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar3 = -uVar7;
if (uVar7 != 0) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
iVar13 = param_2 + -1;
uVar14 = param_2 - 2;
*(int4 *)(puVar10 + (long)iVar13 * 4 + lVar3) = 1;
lVar9 = (long)(int)uVar14;
uVar8 = uVar14;
while (-1 < (int)uVar8) {
if (iVar13 < param_2) {
iVar1 = *(int *)(param_1 + lVar9 * 4);
lVar6 = (long)iVar13;
iVar12 = 0;
do {
iVar2 = *(int *)(param_1 + lVar6 * 4);
if (((iVar2 % iVar1 == 0) || (iVar1 % iVar2 == 0)) &&
(iVar12 < *(int *)(puVar10 + lVar6 * 4 + lVar3))) {
iVar12 = *(int *)(puVar10 + lVar6 * 4 + lVar3);
}
lVar6 = lVar6 + 1;
} while ((int)lVar6 < param_2);
iVar12 = iVar12 + 1;
}
else {
iVar12 = 1;
}
*(int *)(puVar10 + lVar9 * 4 + lVar3) = iVar12;
lVar9 = lVar9 + -1;
iVar13 = iVar13 + -1;
uVar8 = (uint)lVar9;
}
iVar13 = *(int *)(puVar10 + lVar3);
if (1 < param_2) {
piVar5 = (int *)(puVar10 + lVar3 + 4);
do {
if (iVar13 < *piVar5) {
iVar13 = *piVar5;
}
piVar5 = piVar5 + 1;
} while (piVar5 != (int *)(puVar10 + (ulong)uVar14 * 4 + lVar3 + 8));
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar10 + lVar3 + -8) = _fini;
__stack_chk_fail();
}
return iVar13;
} |
6,375 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
}
}
dp[i] = 1 + mxm;
}
int max_val = dp[0];
for (int i = 1; i < n; i++) {
if (max_val < dp[i]) {
max_val = dp[i];
}
}
return max_val;
}
| int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 12ef <func0+0x5f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12da <func0+0x4a>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 149b <func0+0x20b>
lea 0x3(%rsp),%r11
lea -0x1(%rsi),%r13d
mov %r11,%r15
movslq %r13d,%rax
and $0xfffffffffffffffc,%r11
mov %r13d,%r12d
lea -0x2(%rsi),%r14d
movl $0x1,(%r11,%rax,4)
shr $0x2,%r15
movslq %r14d,%rbx
test %r14d,%r14d
js 1389 <func0+0xf9>
cmp %r12d,%esi
jle 1490 <func0+0x200>
mov (%rdi,%rbx,4),%r9d
movslq %r12d,%rcx
xor %r10d,%r10d
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rcx,4),%r8d
mov %r8d,%eax
cltd
idiv %r9d
test %edx,%edx
je 1362 <func0+0xd2>
mov %r9d,%eax
cltd
idiv %r8d
test %edx,%edx
jne 136d <func0+0xdd>
mov (%r11,%rcx,4),%eax
cmp %eax,%r10d
cmovl %eax,%r10d
add $0x1,%rcx
cmp %ecx,%esi
jg 1348 <func0+0xb8>
add $0x1,%r10d
mov %r10d,(%r11,%rbx,4)
sub $0x1,%rbx
sub $0x1,%r12d
test %ebx,%ebx
jns 1330 <func0+0xa0>
mov 0x0(,%r15,4),%eax
cmp $0x1,%esi
jle 146c <func0+0x1dc>
cmp $0x2,%r14d
jbe 14a6 <func0+0x216>
mov %r13d,%edx
movd %eax,%xmm4
mov %r11,%rax
shr $0x2,%edx
pshufd $0x0,%xmm4,%xmm2
shl $0x4,%rdx
add %r11,%rdx
nopl (%rax)
movdqu 0x4(%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 13c0 <func0+0x130>
movdqa %xmm2,%xmm0
mov %r13d,%ecx
psrldq $0x8,%xmm0
and $0xfffffffc,%ecx
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
lea 0x1(%rcx),%edx
pcmpgtd %xmm2,%xmm1
movdqa %xmm1,%xmm0
pand %xmm1,%xmm3
pandn %xmm2,%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
cmp %r13d,%ecx
je 146c <func0+0x1dc>
movslq %edx,%rcx
mov (%r11,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 146c <func0+0x1dc>
movslq %ecx,%rcx
mov (%r11,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x2,%edx
cmp %edx,%esi
jle 146c <func0+0x1dc>
movslq %edx,%rdx
mov (%r11,%rdx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 14ad <func0+0x21d>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%r10d
jmpq 1379 <func0+0xe9>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1301 <func0+0x71>
mov $0x1,%edx
jmp 143a <func0+0x1aa>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov r10, rdi
mov r9d, esi
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12F2
loc_12DD:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_12DD
loc_12F2:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_149B
loc_1304:
lea r11, [rsp+1040h+var_103D]
lea r13d, [r9-1]
mov r14d, r9d
mov r15, r11
movsxd rax, r13d
and r11, 0FFFFFFFFFFFFFFFCh
mov dword ptr [r11+rax*4], 1
shr r15, 2
sub r14d, 2
js loc_14A6
movsxd rbx, r14d
mov r12d, r13d
nop word ptr [rax+rax+00000000h]
loc_1340:
cmp r9d, r12d
jle loc_1490
mov edi, [r10+rbx*4]
mov ecx, r12d
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1358:
mov esi, [r10+rcx*4]
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_136E
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_1379
loc_136E:
mov eax, [r11+rcx*4]
cmp r8d, eax
cmovl r8d, eax
loc_1379:
add rcx, 1
cmp r9d, ecx
jg short loc_1358
add r8d, 1
loc_1386:
mov [r11+rbx*4], r8d
sub rbx, 1
sub r12d, 1
test ebx, ebx
jns short loc_1340
mov eax, ds:dword_0[r15*4]
cmp r14d, 2
jbe loc_14B0
mov edx, r13d
movd xmm3, eax
mov rax, r11
shr edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, r11
nop dword ptr [rax+00000000h]
loc_13C8:
movdqu xmm0, xmmword ptr [rax+4]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_13C8
movdqa xmm1, xmm2
mov edx, r13d
psrldq xmm1, 8
and edx, 0FFFFFFFCh
movdqa xmm0, xmm1
add edx, 1
and r13d, 3
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
jz short loc_1469
loc_143B:
movsxd rcx, edx
lea rcx, [r11+rcx*4]
mov esi, [rcx]
cmp eax, esi
cmovl eax, esi
lea esi, [rdx+1]
cmp r9d, esi
jle short loc_1469
mov esi, [rcx+4]
cmp eax, esi
cmovl eax, esi
add edx, 2
cmp r9d, edx
jle short loc_1469
mov edx, [rcx+8]
cmp eax, edx
cmovl eax, edx
loc_1469:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_14B7
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1490:
mov r8d, 1
jmp loc_1386
loc_149B:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_1304
loc_14A6:
mov eax, ds:dword_0[r15*4]
jmp short loc_1469
loc_14B0:
mov edx, 1
jmp short loc_143B
loc_14B7:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v4; // rdx
unsigned int *v5; // rcx
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned int v9; // r13d
unsigned int v10; // r14d
long long v11; // rbx
int v12; // r12d
int v13; // edi
long long v14; // rcx
signed int v15; // r8d
unsigned int v16; // r8d
long long result; // rax
unsigned int *v18; // rax
__m128i v19; // xmm2
__m128i v20; // xmm0
__m128i v21; // xmm1
__m128i v22; // xmm1
unsigned int v23; // edx
__m128i v24; // xmm0
__m128i v25; // xmm0
__m128i v26; // xmm2
__m128i v27; // xmm1
unsigned int *v28; // rcx
int v29; // esi
int v30; // edx
unsigned int v32[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v33[8]; // [rsp+1008h] [rbp-40h] BYREF
v33[1] = __readfsqword(0x28u);
v4 = 4LL * a2 + 15;
v5 = (unsigned int *)((char *)v33 - (v4 & 0xFFFFFFFFFFFFF000LL));
v6 = v4 & 0xFFF0;
if ( v33 != (_QWORD *)v5 )
{
while ( v32 != v5 )
;
}
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( v7 )
*(_QWORD *)((char *)&v32[-2] + v7) = *(_QWORD *)((char *)&v32[-2] + v7);
v9 = a2 - 1;
v32[a2 - 1] = 1;
v10 = a2 - 2;
if ( a2 - 2 < 0 )
return v32[0];
v11 = (int)v10;
v12 = a2 - 1;
do
{
if ( a2 <= v12 )
{
v16 = 1;
}
else
{
v13 = *(_DWORD *)(a1 + 4 * v11);
v14 = (unsigned int)v12;
v15 = 0;
do
{
if ( (!(*(_DWORD *)(a1 + 4 * v14) % v13) || !(v13 % *(_DWORD *)(a1 + 4 * v14))) && v15 < (int)v32[v14] )
v15 = v32[v14];
++v14;
}
while ( a2 > (int)v14 );
v16 = v15 + 1;
}
v32[v11--] = v16;
--v12;
}
while ( (int)v11 >= 0 );
result = v32[0];
if ( v10 <= 2 )
{
v23 = 1;
}
else
{
v18 = v32;
v19 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v32[0]), 0);
do
{
v20 = _mm_loadu_si128((const __m128i *)(v18 + 1));
v18 += 4;
v21 = _mm_cmpgt_epi32(v20, v19);
v19 = _mm_or_si128(_mm_andnot_si128(v21, v19), _mm_and_si128(v20, v21));
}
while ( v18 != &v32[4 * (v9 >> 2)] );
v22 = _mm_srli_si128(v19, 8);
v23 = (v9 & 0xFFFFFFFC) + 1;
v24 = _mm_cmpgt_epi32(v22, v19);
v25 = _mm_or_si128(_mm_andnot_si128(v24, v19), _mm_and_si128(v22, v24));
v26 = _mm_srli_si128(v25, 4);
v27 = _mm_cmpgt_epi32(v26, v25);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v27, v25), _mm_and_si128(v26, v27)));
if ( (v9 & 3) == 0 )
return result;
}
v28 = &v32[v23];
if ( (int)result < (int)*v28 )
result = *v28;
if ( a2 > (int)(v23 + 1) )
{
v29 = v28[1];
if ( (int)result < v29 )
result = (unsigned int)v29;
if ( a2 > (int)(v23 + 2) )
{
v30 = v28[2];
if ( (int)result < v30 )
return (unsigned int)v30;
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV R10,RDI
MOV R9D,ESI
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012f2
LAB_001012dd:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012dd
LAB_001012f2:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010149b
LAB_00101304:
LEA R11,[RSP + 0x3]
LEA R13D,[R9 + -0x1]
MOV R14D,R9D
MOV R15,R11
MOVSXD RAX,R13D
AND R11,-0x4
MOV dword ptr [R11 + RAX*0x4],0x1
SHR R15,0x2
SUB R14D,0x2
JS 0x001014a6
MOVSXD RBX,R14D
MOV R12D,R13D
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101340:
CMP R9D,R12D
JLE 0x00101490
MOV EDI,dword ptr [R10 + RBX*0x4]
MOV ECX,R12D
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101358:
MOV ESI,dword ptr [R10 + RCX*0x4]
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x0010136e
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x00101379
LAB_0010136e:
MOV EAX,dword ptr [R11 + RCX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
LAB_00101379:
ADD RCX,0x1
CMP R9D,ECX
JG 0x00101358
ADD R8D,0x1
LAB_00101386:
MOV dword ptr [R11 + RBX*0x4],R8D
SUB RBX,0x1
SUB R12D,0x1
TEST EBX,EBX
JNS 0x00101340
MOV EAX,dword ptr [R15*0x4]
CMP R14D,0x2
JBE 0x001014b0
MOV EDX,R13D
MOVD XMM3,EAX
MOV RAX,R11
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,R11
NOP dword ptr [RAX]
LAB_001013c8:
MOVDQU XMM0,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x001013c8
MOVDQA XMM1,XMM2
MOV EDX,R13D
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
MOVDQA XMM0,XMM1
ADD EDX,0x1
AND R13D,0x3
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
JZ 0x00101469
LAB_0010143b:
MOVSXD RCX,EDX
LEA RCX,[R11 + RCX*0x4]
MOV ESI,dword ptr [RCX]
CMP EAX,ESI
CMOVL EAX,ESI
LEA ESI,[RDX + 0x1]
CMP R9D,ESI
JLE 0x00101469
MOV ESI,dword ptr [RCX + 0x4]
CMP EAX,ESI
CMOVL EAX,ESI
ADD EDX,0x2
CMP R9D,EDX
JLE 0x00101469
MOV EDX,dword ptr [RCX + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_00101469:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001014b7
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101490:
MOV R8D,0x1
JMP 0x00101386
LAB_0010149b:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101304
LAB_001014a6:
MOV EAX,dword ptr [R15*0x4]
JMP 0x00101469
LAB_001014b0:
MOV EDX,0x1
JMP 0x0010143b
LAB_001014b7:
CALL 0x00101060 | uint func0(long param_1,int param_2)
{
uint *puVar1;
int iVar2;
int iVar3;
long lVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
int *puVar8;
ulong uVar9;
long lVar10;
int *puVar11;
int iVar13;
uint uVar14;
uint uVar15;
uint uVar16;
long in_FS_OFFSET;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
int auStack_48 [8];
long local_40;
int *puVar12;
puVar11 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar9 = (long)param_2 * 4 + 0xf;
puVar12 = auStack_48;
puVar8 = auStack_48;
while (puVar12 != auStack_48 + -(uVar9 & 0xfffffffffffff000)) {
puVar11 = puVar8 + -0x1000;
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
puVar12 = puVar8 + -0x1000;
puVar8 = puVar8 + -0x1000;
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar4 = -uVar9;
puVar8 = puVar11 + lVar4;
if (uVar9 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
uVar15 = param_2 - 1;
*(int4 *)(puVar11 + (long)(int)uVar15 * 4 + lVar4) = 1;
uVar16 = param_2 - 2;
if ((int)uVar16 < 0) {
uVar14 = *(uint *)(((ulong)(puVar11 + lVar4 + 3) >> 2) * 4);
}
else {
lVar10 = (long)(int)uVar16;
uVar14 = uVar15;
do {
if ((int)uVar14 < param_2) {
iVar2 = *(int *)(param_1 + lVar10 * 4);
uVar9 = (ulong)uVar14;
iVar13 = 0;
do {
iVar3 = *(int *)(param_1 + uVar9 * 4);
if (((iVar3 % iVar2 == 0) || (iVar2 % iVar3 == 0)) &&
(iVar13 < *(int *)(puVar11 + uVar9 * 4 + lVar4))) {
iVar13 = *(int *)(puVar11 + uVar9 * 4 + lVar4);
}
uVar9 = uVar9 + 1;
} while ((int)uVar9 < param_2);
iVar13 = iVar13 + 1;
}
else {
iVar13 = 1;
}
*(int *)(puVar11 + lVar10 * 4 + lVar4) = iVar13;
lVar10 = lVar10 + -1;
uVar14 = uVar14 - 1;
} while (-1 < (int)lVar10);
uVar14 = *(uint *)(((ulong)(puVar11 + lVar4 + 3) >> 2) * 4);
if (uVar16 < 3) {
iVar13 = 1;
}
else {
uVar16 = uVar14;
uVar18 = uVar14;
uVar22 = uVar14;
do {
puVar1 = (uint *)(puVar8 + 4);
puVar5 = (uint *)(puVar8 + 8);
puVar6 = (uint *)(puVar8 + 0xc);
puVar7 = (uint *)(puVar8 + 0x10);
puVar8 = puVar8 + 0x10;
uVar17 = -(uint)((int)uVar14 < (int)*puVar1);
uVar19 = -(uint)((int)uVar16 < (int)*puVar5);
uVar20 = -(uint)((int)uVar18 < (int)*puVar6);
uVar21 = -(uint)((int)uVar22 < (int)*puVar7);
uVar14 = ~uVar17 & uVar14 | *puVar1 & uVar17;
uVar16 = ~uVar19 & uVar16 | *puVar5 & uVar19;
uVar18 = ~uVar20 & uVar18 | *puVar6 & uVar20;
uVar22 = ~uVar21 & uVar22 | *puVar7 & uVar21;
} while (puVar8 != puVar11 + (ulong)(uVar15 >> 2) * 0x10 + lVar4);
iVar13 = (uVar15 & 0xfffffffc) + 1;
uVar14 = ~-(uint)((int)uVar14 < (int)uVar18) & uVar14 |
uVar18 & -(uint)((int)uVar14 < (int)uVar18);
uVar16 = ~-(uint)((int)uVar16 < (int)uVar22) & uVar16 |
uVar22 & -(uint)((int)uVar16 < (int)uVar22);
uVar18 = -(uint)((int)uVar14 < (int)uVar16);
uVar14 = ~uVar18 & uVar14 | uVar16 & uVar18;
if ((uVar15 & 3) == 0) goto LAB_00101469;
}
puVar1 = (uint *)(puVar11 + (long)iVar13 * 4 + lVar4);
if ((int)uVar14 < (int)*puVar1) {
uVar14 = *puVar1;
}
if (iVar13 + 1 < param_2) {
if ((int)uVar14 < (int)puVar1[1]) {
uVar14 = puVar1[1];
}
if ((iVar13 + 2 < param_2) && ((int)uVar14 < (int)puVar1[2])) {
uVar14 = puVar1[2];
}
}
}
LAB_00101469:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar11 + lVar4 + -8) = _fini;
__stack_chk_fail();
}
return uVar14;
} |
6,376 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremented);
res[i] = malloc(length + 1);
sprintf(res[i], "%d", incremented);
} else {
res[i] = strdup(test_list[i]);
}
}
return res;
}
| int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / sizeof(test2[0]);
int size3 = sizeof(test3) / sizeof(test3[0]);
char** res1 = func0(test1, size1, 6);
char** res2 = func0(test2, size2, 12);
char** res3 = func0(test3, size3, 33);
assert(strcmp(res1[1], "240") == 0 && strcmp(res1[3], "104") == 0 && strcmp(res1[4], "129") == 0 && strcmp(res1[6], "10") == 0);
assert(strcmp(res2[1], "368") == 0 && strcmp(res2[3], "100") == 0 && strcmp(res2[4], "181") == 0 && strcmp(res2[6], "18") == 0);
assert(strcmp(res3[1], "484") == 0 && strcmp(res3[3], "77") == 0 && strcmp(res3[4], "129") == 0 && strcmp(res3[6], "45") == 0);
// Freeing dynamically allocated memory
for (int i = 0; i < size1; ++i) {
free(res1[i]);
}
free(res1);
for (int i = 0; i < size2; ++i) {
free(res2[i]);
}
free(res2);
for (int i = 0; i < size3; ++i) {
free(res3[i]);
}
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1130 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x28(%rbp)
jmpq 13c5 <func0+0x15c>
callq 1170 <__ctype_b_loc@plt>
mov (%rax),%rdx
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
movzbl (%rax),%eax
movsbq %al,%rax
add %rax,%rax
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 1389 <func0+0x120>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1140 <atoi@plt>
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%edx
mov -0x40(%rbp),%eax
add %edx,%eax
mov %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
mov %eax,%ecx
lea 0xcef(%rip),%rdx
mov $0x0,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 1100 <snprintf@plt>
mov %eax,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
add $0x1,%eax
cltq
mov -0x28(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1130 <malloc@plt>
mov %rax,(%rbx)
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%edx
lea 0xc8e(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1150 <sprintf@plt>
jmp 13c1 <func0+0x158>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1160 <strdup@plt>
mov %rax,(%rbx)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 12a1 <func0+0x38>
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_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_28], 0
jmp loc_13CB
loc_12A1:
call ___ctype_b_loc
mov rdx, [rax]
mov eax, [rbp+var_28]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rcx
mov rax, [rax]
movzx eax, byte ptr [rax]
movsx rax, al
add rax, rax
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz loc_138F
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_24], eax
mov edx, [rbp+var_24]
mov eax, [rbp+var_40]
add eax, edx
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
mov ecx, eax
lea rax, format; "%d"
mov rdx, rax; format
mov esi, 0; maxlen
mov edi, 0; s
mov eax, 0
call _snprintf
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
add eax, 1
cdqe
mov edx, [rbp+var_28]
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 eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_20]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
jmp short loc_13C7
loc_138F:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_28]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; s
call _strdup
mov [rbx], rax
loc_13C7:
add [rbp+var_28], 1
loc_13CB:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl loc_12A1
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, int a3)
{
int i; // [rsp+18h] [rbp-28h]
int v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
_QWORD *v8; // [rsp+28h] [rbp-18h]
v8 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
if ( ((*__ctype_b_loc())[**(char **)(8LL * i + a1)] & 0x800) != 0 )
{
v6 = atoi(*(const char **)(8LL * i + a1)) + a3;
v7 = snprintf(0LL, 0LL, "%d", v6);
v8[i] = malloc(v7 + 1);
sprintf((char *)v8[i], "%d", v6);
}
else
{
v8[i] = strdup(*(const char **)(8LL * i + a1));
}
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001013cb
LAB_001012a1:
CALL 0x00101170
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOVSX RAX,AL
ADD RAX,RAX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x0010138f
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101140
MOV dword ptr [RBP + -0x24],EAX
MOV EDX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,EDX
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,EAX
LEA RAX,[0x102008]
MOV RDX,RAX
MOV ESI,0x0
MOV EDI,0x0
MOV EAX,0x0
CALL 0x00101100
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x28]
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]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101150
JMP 0x001013c7
LAB_0010138f:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101160
MOV qword ptr [RBX],RAX
LAB_001013c7:
ADD dword ptr [RBP + -0x28],0x1
LAB_001013cb:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001012a1
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
void *pvVar3;
ushort **ppuVar4;
void *pvVar5;
char *pcVar6;
int local_30;
pvVar3 = malloc((long)param_2 << 3);
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[**(char **)(param_1 + (long)local_30 * 8)] & 0x800) == 0) {
pcVar6 = strdup(*(char **)(param_1 + (long)local_30 * 8));
*(char **)((long)local_30 * 8 + (long)pvVar3) = pcVar6;
}
else {
iVar1 = atoi(*(char **)(param_1 + (long)local_30 * 8));
iVar2 = snprintf((char *)0x0,0,"%d",(ulong)(uint)(param_3 + iVar1));
pvVar5 = malloc((long)(iVar2 + 1));
*(void **)((long)local_30 * 8 + (long)pvVar3) = pvVar5;
sprintf(*(char **)((long)pvVar3 + (long)local_30 * 8),"%d",(ulong)(uint)(param_3 + iVar1));
}
}
return pvVar3;
} |
6,377 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremented);
res[i] = malloc(length + 1);
sprintf(res[i], "%d", incremented);
} else {
res[i] = strdup(test_list[i]);
}
}
return res;
}
| int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / sizeof(test2[0]);
int size3 = sizeof(test3) / sizeof(test3[0]);
char** res1 = func0(test1, size1, 6);
char** res2 = func0(test2, size2, 12);
char** res3 = func0(test3, size3, 33);
assert(strcmp(res1[1], "240") == 0 && strcmp(res1[3], "104") == 0 && strcmp(res1[4], "129") == 0 && strcmp(res1[6], "10") == 0);
assert(strcmp(res2[1], "368") == 0 && strcmp(res2[3], "100") == 0 && strcmp(res2[4], "181") == 0 && strcmp(res2[6], "18") == 0);
assert(strcmp(res3[1], "484") == 0 && strcmp(res3[3], "77") == 0 && strcmp(res3[4], "129") == 0 && strcmp(res3[6], "45") == 0);
// Freeing dynamically allocated memory
for (int i = 0; i < size1; ++i) {
free(res1[i]);
}
free(res1);
for (int i = 0; i < size2; ++i) {
free(res2[i]);
}
free(res2);
for (int i = 0; i < size3; ++i) {
free(res3[i]);
}
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r13
mov %esi,%ebx
mov %edx,0xc(%rsp)
movslq %esi,%rdi
shl $0x3,%rdi
callq 1120 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1331 <func0+0xe8>
callq 1140 <__ctype_b_loc@plt>
mov %rax,%r14
lea -0x1(%rbx),%r15d
mov $0x0,%ebx
jmp 12a7 <func0+0x5e>
callq 1130 <strdup@plt>
mov %rax,(%r12,%rbx,8)
lea 0x1(%rbx),%rax
cmp %r15,%rbx
je 1331 <func0+0xe8>
mov %rax,%rbx
mov 0x0(%r13,%rbx,8),%rdi
movsbq (%rdi),%rdx
mov (%r14),%rax
testb $0x8,0x1(%rax,%rdx,2)
je 128e <func0+0x45>
mov $0xa,%edx
mov $0x0,%esi
callq 1110 <strtol@plt>
mov 0xc(%rsp),%ecx
lea (%rcx,%rax,1),%ebp
mov %ebp,%r9d
lea 0xd2a(%rip),%r8
mov $0xffffffffffffffff,%rcx
mov $0x1,%edx
mov $0x0,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 10d0 <__snprintf_chk@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1120 <malloc@plt>
mov %rax,%rdi
mov %rax,(%r12,%rbx,8)
mov %ebp,%r8d
lea 0xcee(%rip),%rcx
mov $0xffffffffffffffff,%rdx
mov $0x1,%esi
mov $0x0,%eax
callq 1150 <__sprintf_chk@plt>
jmpq 1297 <func0+0x4e>
mov %r12,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r14, rdi
mov r12d, esi
mov [rsp+48h+var_44], edx
movsxd rdi, esi
shl rdi, 3
call _malloc
mov [rsp+48h+var_40], rax
test r12d, r12d
jle loc_135C
mov rbp, rax
call ___ctype_b_loc
mov r13, rax
mov rbx, r14
lea eax, [r12-1]
lea r15, [r14+rax*8+8]
lea r14, unk_2004
jmp short loc_12DA
loc_12C0:
call _strdup
mov [rbp+0], rax
loc_12C9:
add rbx, 8
add rbp, 8
cmp rbx, r15
jz loc_135C
loc_12DA:
mov rdi, [rbx]
movsx rdx, byte ptr [rdi]
mov rax, [r13+0]
test byte ptr [rax+rdx*2+1], 8
jz short loc_12C0
mov edx, 0Ah
mov esi, 0
call _strtol
mov ecx, [rsp+48h+var_44]
lea r12d, [rcx+rax]
mov r9d, r12d
mov r8, r14
mov rcx, 0FFFFFFFFFFFFFFFFh
mov edx, 1
mov esi, 0
mov edi, 0
mov eax, 0
call ___snprintf_chk
lea edi, [rax+1]
movsxd rdi, edi
call _malloc
mov rdi, rax
mov [rbp+0], rax
mov r8d, r12d
mov rcx, r14
mov rdx, 0FFFFFFFFFFFFFFFFh
mov esi, 1
mov eax, 0
call ___sprintf_chk
jmp loc_12C9
loc_135C:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char **a1, int a2, int a3)
{
long long v3; // rax
_QWORD *v4; // rbp
_QWORD *v5; // r13
char **v6; // rbx
long long v7; // r12
int v8; // eax
long long v9; // rax
long long v12; // [rsp+8h] [rbp-40h]
v3 = malloc(8LL * a2);
v12 = v3;
if ( a2 > 0 )
{
v4 = (_QWORD *)v3;
v5 = (_QWORD *)__ctype_b_loc();
v6 = a1;
do
{
if ( (*(_BYTE *)(*v5 + 2LL * **v6 + 1) & 8) != 0 )
{
v7 = a3 + (unsigned int)strtol(*v6, 0LL, 10LL);
v8 = __snprintf_chk(0LL, 0LL, 1LL, -1LL, &unk_2004, v7);
v9 = malloc(v8 + 1);
*v4 = v9;
__sprintf_chk(v9, 1LL, -1LL, &unk_2004, (unsigned int)v7);
}
else
{
*v4 = strdup();
}
++v6;
++v4;
}
while ( v6 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return v12;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV R12D,ESI
MOV dword ptr [RSP + 0x4],EDX
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x0010135c
MOV RBP,RAX
CALL 0x00101160
MOV R13,RAX
MOV RBX,R14
LEA EAX,[R12 + -0x1]
LEA R15,[R14 + RAX*0x8 + 0x8]
LEA R14,[0x102004]
JMP 0x001012da
LAB_001012c0:
CALL 0x00101150
MOV qword ptr [RBP],RAX
LAB_001012c9:
ADD RBX,0x8
ADD RBP,0x8
CMP RBX,R15
JZ 0x0010135c
LAB_001012da:
MOV RDI,qword ptr [RBX]
MOVSX RDX,byte ptr [RDI]
MOV RAX,qword ptr [R13]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x8
JZ 0x001012c0
MOV EDX,0xa
MOV ESI,0x0
CALL 0x00101130
MOV ECX,dword ptr [RSP + 0x4]
LEA R12D,[RCX + RAX*0x1]
MOV R9D,R12D
MOV R8,R14
MOV RCX,-0x1
MOV EDX,0x1
MOV ESI,0x0
MOV EDI,0x0
MOV EAX,0x0
CALL 0x001010e0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101140
MOV RDI,RAX
MOV qword ptr [RBP],RAX
MOV R8D,R12D
MOV RCX,R14
MOV RDX,-0x1
MOV ESI,0x1
MOV EAX,0x0
CALL 0x00101170
JMP 0x001012c9
LAB_0010135c:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int iVar2;
int8 *puVar3;
ushort **ppuVar4;
char *pcVar5;
long lVar6;
void *pvVar7;
int8 *puVar8;
int iVar9;
puVar3 = (int8 *)malloc((long)param_2 << 3);
if (0 < param_2) {
ppuVar4 = __ctype_b_loc();
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar8 = puVar3;
do {
pcVar5 = (char *)*param_1;
if ((*(byte *)((long)*ppuVar4 + (long)*pcVar5 * 2 + 1) & 8) == 0) {
pcVar5 = strdup(pcVar5);
*puVar8 = pcVar5;
}
else {
lVar6 = strtol(pcVar5,(char **)0x0,10);
iVar9 = param_3 + (int)lVar6;
iVar2 = __snprintf_chk(0,0,1,0xffffffffffffffff,&DAT_00102004,iVar9);
pvVar7 = malloc((long)(iVar2 + 1));
*puVar8 = pvVar7;
__sprintf_chk(pvVar7,1,0xffffffffffffffff,&DAT_00102004,iVar9);
}
param_1 = param_1 + 1;
puVar8 = puVar8 + 1;
} while (param_1 != puVar1);
}
return puVar3;
} |
6,378 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremented);
res[i] = malloc(length + 1);
sprintf(res[i], "%d", incremented);
} else {
res[i] = strdup(test_list[i]);
}
}
return res;
}
| int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / sizeof(test2[0]);
int size3 = sizeof(test3) / sizeof(test3[0]);
char** res1 = func0(test1, size1, 6);
char** res2 = func0(test2, size2, 12);
char** res3 = func0(test3, size3, 33);
assert(strcmp(res1[1], "240") == 0 && strcmp(res1[3], "104") == 0 && strcmp(res1[4], "129") == 0 && strcmp(res1[6], "10") == 0);
assert(strcmp(res2[1], "368") == 0 && strcmp(res2[3], "100") == 0 && strcmp(res2[4], "181") == 0 && strcmp(res2[6], "18") == 0);
assert(strcmp(res3[1], "484") == 0 && strcmp(res3[3], "77") == 0 && strcmp(res3[4], "129") == 0 && strcmp(res3[6], "45") == 0);
// Freeing dynamically allocated memory
for (int i = 0; i < size1; ++i) {
free(res1[i]);
}
free(res1);
for (int i = 0; i < size2; ++i) {
free(res2[i]);
}
free(res2);
for (int i = 0; i < size3; ++i) {
free(res3[i]);
}
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x3,%rdi
sub $0x18,%rsp
mov %edx,0xc(%rsp)
callq 1120 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 16e8 <func0+0xe8>
callq 1140 <__ctype_b_loc@plt>
lea -0x1(%rbx),%r14d
lea 0x9c1(%rip),%r13
xor %ebx,%ebx
mov %rax,%r15
jmp 16bf <func0+0xbf>
nopw 0x0(%rax,%rax,1)
mov $0xa,%edx
xor %esi,%esi
callq 1110 <strtol@plt>
mov 0xc(%rsp),%ecx
mov %r13,%r8
xor %esi,%esi
mov $0x1,%edx
xor %edi,%edi
lea (%rcx,%rax,1),%r9d
mov $0xffffffffffffffff,%rcx
xor %eax,%eax
mov %r9d,0x8(%rsp)
callq 10d0 <__snprintf_chk@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1120 <malloc@plt>
mov 0x8(%rsp),%r9d
mov %r13,%rcx
mov $0xffffffffffffffff,%rdx
mov %rax,(%r12,%rbx,8)
mov %rax,%rdi
mov $0x1,%esi
xor %eax,%eax
mov %r9d,%r8d
callq 1150 <__sprintf_chk@plt>
lea 0x1(%rbx),%rax
cmp %r14,%rbx
je 16e8 <func0+0xe8>
mov %rax,%rbx
mov 0x0(%rbp,%rbx,8),%rdi
mov (%r15),%rax
movsbq (%rdi),%rdx
testb $0x8,0x1(%rax,%rdx,2)
jne 1650 <func0+0x50>
callq 1130 <strdup@plt>
mov %rax,(%r12,%rbx,8)
lea 0x1(%rbx),%rax
cmp %r14,%rbx
jne 16bc <func0+0xbc>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov r12, rdi
shl rdi, 3
sub rsp, 18h
mov [rsp+48h+var_44], edx
call _malloc
mov [rsp+48h+var_40], rax
test r12d, r12d
jle loc_16C8
mov rbp, rax
call ___ctype_b_loc
mov r15, rax
lea eax, [r12-1]
lea r12, unk_2004
lea r13, [rbx+rax*8+8]
jmp short loc_16A1
loc_1638:
mov edx, 0Ah
xor esi, esi
add rbx, 8
add rbp, 8
call _strtol
mov ecx, [rsp+48h+var_44]
mov r8, r12
xor esi, esi
mov edx, 1
xor edi, edi
lea r14d, [rcx+rax]
mov rcx, 0FFFFFFFFFFFFFFFFh
xor eax, eax
mov r9d, r14d
call ___snprintf_chk
lea edi, [rax+1]
movsxd rdi, edi
call _malloc
mov r8d, r14d
mov rcx, r12
mov esi, 1
mov [rbp-8], rax
mov rdi, rax
mov rdx, 0FFFFFFFFFFFFFFFFh
xor eax, eax
call ___sprintf_chk
cmp r13, rbx
jz short loc_16C8
loc_16A1:
mov rdi, [rbx]
mov rax, [r15]
movsx rdx, byte ptr [rdi]
test byte ptr [rax+rdx*2+1], 8
jnz short loc_1638
call _strdup
add rbx, 8
add rbp, 8
mov [rbp-8], rax
cmp r13, rbx
jnz short loc_16A1
loc_16C8:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char **a1, int a2, int a3)
{
char **v3; // rbx
long long v4; // rax
long long v5; // rbp
_QWORD *v6; // r15
long long v7; // r13
unsigned int v8; // r14d
int v9; // eax
long long v10; // rax
char *v11; // rdi
long long v14; // [rsp+8h] [rbp-40h]
v3 = a1;
v4 = malloc(8LL * a2);
v14 = v4;
if ( a2 > 0 )
{
v5 = v4;
v6 = (_QWORD *)__ctype_b_loc();
v7 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
do
{
while ( 1 )
{
v11 = *v3;
if ( (*(_BYTE *)(*v6 + 2LL * **v3 + 1) & 8) == 0 )
break;
++v3;
v5 += 8LL;
v8 = a3 + strtol(v11, 0LL, 10LL);
v9 = __snprintf_chk(0LL, 0LL, 1LL, -1LL, &unk_2004, v8);
v10 = malloc(v9 + 1);
*(_QWORD *)(v5 - 8) = v10;
__sprintf_chk(v10, 1LL, -1LL, &unk_2004, v8);
if ( (char **)v7 == v3 )
return v14;
}
++v3;
v5 += 8LL;
*(_QWORD *)(v5 - 8) = strdup();
}
while ( (char **)v7 != v3 );
}
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV R12,RDI
SHL RDI,0x3
SUB RSP,0x18
MOV dword ptr [RSP + 0x4],EDX
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x001016c8
MOV RBP,RAX
CALL 0x00101160
MOV R15,RAX
LEA EAX,[R12 + -0x1]
LEA R12,[0x102004]
LEA R13,[RBX + RAX*0x8 + 0x8]
JMP 0x001016a1
LAB_00101638:
MOV EDX,0xa
XOR ESI,ESI
ADD RBX,0x8
ADD RBP,0x8
CALL 0x00101130
MOV ECX,dword ptr [RSP + 0x4]
MOV R8,R12
XOR ESI,ESI
MOV EDX,0x1
XOR EDI,EDI
LEA R14D,[RCX + RAX*0x1]
MOV RCX,-0x1
XOR EAX,EAX
MOV R9D,R14D
CALL 0x001010e0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101140
MOV R8D,R14D
MOV RCX,R12
MOV ESI,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RDI,RAX
MOV RDX,-0x1
XOR EAX,EAX
CALL 0x00101170
CMP R13,RBX
JZ 0x001016c8
LAB_001016a1:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [R15]
MOVSX RDX,byte ptr [RDI]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x8
JNZ 0x00101638
CALL 0x00101150
ADD RBX,0x8
ADD RBP,0x8
MOV qword ptr [RBP + -0x8],RAX
CMP R13,RBX
JNZ 0x001016a1
LAB_001016c8:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int iVar2;
int8 *puVar3;
ushort **ppuVar4;
long lVar5;
void *pvVar6;
char *pcVar7;
int8 *puVar8;
int iVar9;
puVar3 = (int8 *)malloc((long)param_2 << 3);
if (0 < param_2) {
ppuVar4 = __ctype_b_loc();
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar8 = puVar3;
do {
while (pcVar7 = (char *)*param_1, (*(byte *)((long)*ppuVar4 + (long)*pcVar7 * 2 + 1) & 8) == 0
) {
pcVar7 = strdup(pcVar7);
param_1 = param_1 + 1;
*puVar8 = pcVar7;
puVar8 = puVar8 + 1;
if (puVar1 == param_1) {
return puVar3;
}
}
param_1 = param_1 + 1;
lVar5 = strtol(pcVar7,(char **)0x0,10);
iVar9 = param_3 + (int)lVar5;
iVar2 = __snprintf_chk(0,0,1,0xffffffffffffffff,&DAT_00102004,iVar9);
pvVar6 = malloc((long)(iVar2 + 1));
*puVar8 = pvVar6;
__sprintf_chk(pvVar6,1,0xffffffffffffffff,&DAT_00102004,iVar9);
puVar8 = puVar8 + 1;
} while (puVar1 != param_1);
}
return puVar3;
} |
6,379 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremented);
res[i] = malloc(length + 1);
sprintf(res[i], "%d", incremented);
} else {
res[i] = strdup(test_list[i]);
}
}
return res;
}
| int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / sizeof(test2[0]);
int size3 = sizeof(test3) / sizeof(test3[0]);
char** res1 = func0(test1, size1, 6);
char** res2 = func0(test2, size2, 12);
char** res3 = func0(test3, size3, 33);
assert(strcmp(res1[1], "240") == 0 && strcmp(res1[3], "104") == 0 && strcmp(res1[4], "129") == 0 && strcmp(res1[6], "10") == 0);
assert(strcmp(res2[1], "368") == 0 && strcmp(res2[3], "100") == 0 && strcmp(res2[4], "181") == 0 && strcmp(res2[6], "18") == 0);
assert(strcmp(res3[1], "484") == 0 && strcmp(res3[3], "77") == 0 && strcmp(res3[4], "129") == 0 && strcmp(res3[6], "45") == 0);
// Freeing dynamically allocated memory
for (int i = 0; i < size1; ++i) {
free(res1[i]);
}
free(res1);
for (int i = 0; i < size2; ++i) {
free(res2[i]);
}
free(res2);
for (int i = 0; i < size3; ++i) {
free(res3[i]);
}
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x3,%rdi
sub $0x18,%rsp
mov %edx,0xc(%rsp)
callq 1120 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1728 <func0+0xe8>
callq 1140 <__ctype_b_loc@plt>
lea -0x1(%rbx),%r14d
lea 0x981(%rip),%r13
xor %ebx,%ebx
mov %rax,%r15
jmp 16ff <func0+0xbf>
nopw 0x0(%rax,%rax,1)
mov $0xa,%edx
xor %esi,%esi
callq 1110 <strtol@plt>
mov 0xc(%rsp),%ecx
mov %r13,%r8
xor %esi,%esi
mov $0x1,%edx
xor %edi,%edi
lea (%rcx,%rax,1),%r9d
mov $0xffffffffffffffff,%rcx
xor %eax,%eax
mov %r9d,0x8(%rsp)
callq 10d0 <__snprintf_chk@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1120 <malloc@plt>
mov 0x8(%rsp),%r9d
mov %r13,%rcx
mov $0xffffffffffffffff,%rdx
mov %rax,(%r12,%rbx,8)
mov %rax,%rdi
mov $0x1,%esi
xor %eax,%eax
mov %r9d,%r8d
callq 1150 <__sprintf_chk@plt>
lea 0x1(%rbx),%rax
cmp %r14,%rbx
je 1728 <func0+0xe8>
mov %rax,%rbx
mov 0x0(%rbp,%rbx,8),%rdi
mov (%r15),%rax
movsbq (%rdi),%rdx
testb $0x8,0x1(%rax,%rdx,2)
jne 1690 <func0+0x50>
callq 1130 <strdup@plt>
mov %rax,(%r12,%rbx,8)
lea 0x1(%rbx),%rax
cmp %r14,%rbx
jne 16fc <func0+0xbc>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
movsxd r12, esi
push rbp
mov rbp, r12
shl r12, 3
push rbx
mov rbx, rdi
mov rdi, r12; size
sub rsp, 18h
mov [rsp+48h+var_44], edx
call _malloc
mov [rsp+48h+var_40], rax
test ebp, ebp
jle loc_170B
mov r14, rax
add r12, rbx
call ___ctype_b_loc
mov rbp, r14
mov r15, rax
jmp short loc_16E0
loc_1670:
mov edx, 0Ah; base
xor esi, esi; endptr
add rbx, 8
add rbp, 8
call _strtol
mov ecx, [rsp+48h+var_44]
xor esi, esi
mov edx, 2
lea r8, unk_2004
xor edi, edi
lea r13d, [rcx+rax]
mov rcx, 0FFFFFFFFFFFFFFFFh
xor eax, eax
mov r9d, r13d
call ___snprintf_chk
lea edx, [rax+1]
movsxd r14, edx
mov rdi, r14; size
call _malloc
mov r8d, r13d
mov rdx, r14
mov esi, 2
mov [rbp-8], rax
mov rdi, rax
lea rcx, unk_2004
xor eax, eax
call ___sprintf_chk
cmp r12, rbx
jz short loc_170B
loc_16E0:
mov rdi, [rbx]; s
mov rax, [r15]
movsx rdx, byte ptr [rdi]
test byte ptr [rax+rdx*2+1], 8
jnz loc_1670
call _strdup
add rbx, 8
add rbp, 8
mov [rbp-8], rax
cmp r12, rbx
jnz short loc_16E0
loc_170B:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | void * func0(const char **a1, int a2, int a3)
{
const char **v3; // rbx
void *v4; // rax
const char **v5; // r12
_QWORD *v6; // rbp
const unsigned __int16 **v7; // r15
unsigned int v8; // r13d
size_t v9; // r14
void *v10; // rax
const char *v11; // rdi
void *v14; // [rsp+8h] [rbp-40h]
v3 = a1;
v4 = malloc(8LL * a2);
v14 = v4;
if ( a2 > 0 )
{
v5 = &a1[a2];
v6 = v4;
v7 = __ctype_b_loc();
do
{
while ( 1 )
{
v11 = *v3;
if ( ((*v7)[**v3] & 0x800) == 0 )
break;
++v3;
++v6;
v8 = a3 + strtol(v11, 0LL, 10);
v9 = (int)(__snprintf_chk(0LL, 0LL, 2LL, -1LL, &unk_2004, v8) + 1);
v10 = malloc(v9);
*(v6 - 1) = v10;
__sprintf_chk(v10, 2LL, v9, &unk_2004, v8);
if ( v5 == v3 )
return v14;
}
++v3;
*v6++ = strdup(v11);
}
while ( v5 != v3 );
}
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,R12
SHL R12,0x3
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x18
MOV dword ptr [RSP + 0x4],EDX
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
TEST EBP,EBP
JLE 0x0010170b
MOV R14,RAX
ADD R12,RBX
CALL 0x00101160
MOV RBP,R14
MOV R15,RAX
JMP 0x001016e0
LAB_00101670:
MOV EDX,0xa
XOR ESI,ESI
ADD RBX,0x8
ADD RBP,0x8
CALL 0x00101130
MOV ECX,dword ptr [RSP + 0x4]
XOR ESI,ESI
MOV EDX,0x2
LEA R8,[0x102004]
XOR EDI,EDI
LEA R13D,[RCX + RAX*0x1]
MOV RCX,-0x1
XOR EAX,EAX
MOV R9D,R13D
CALL 0x001010e0
LEA EDX,[RAX + 0x1]
MOVSXD R14,EDX
MOV RDI,R14
CALL 0x00101140
MOV R8D,R13D
MOV RDX,R14
MOV ESI,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RDI,RAX
LEA RCX,[0x102004]
XOR EAX,EAX
CALL 0x00101170
CMP R12,RBX
JZ 0x0010170b
LAB_001016e0:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [R15]
MOVSX RDX,byte ptr [RDI]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x8
JNZ 0x00101670
CALL 0x00101150
ADD RBX,0x8
ADD RBP,0x8
MOV qword ptr [RBP + -0x8],RAX
CMP R12,RBX
JNZ 0x001016e0
LAB_0010170b:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int iVar1;
int8 *puVar2;
ushort **ppuVar3;
long lVar4;
void *pvVar5;
char *pcVar6;
int8 *puVar7;
int8 *puVar8;
int iVar9;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar8 = param_1 + param_2;
ppuVar3 = __ctype_b_loc();
puVar7 = puVar2;
do {
while (pcVar6 = (char *)*param_1, (*(byte *)((long)*ppuVar3 + (long)*pcVar6 * 2 + 1) & 8) == 0
) {
pcVar6 = strdup(pcVar6);
param_1 = param_1 + 1;
*puVar7 = pcVar6;
puVar7 = puVar7 + 1;
if (puVar8 == param_1) {
return puVar2;
}
}
param_1 = param_1 + 1;
lVar4 = strtol(pcVar6,(char **)0x0,10);
iVar9 = param_3 + (int)lVar4;
iVar1 = __snprintf_chk(0,0,2,0xffffffffffffffff,&DAT_00102004,iVar9);
pvVar5 = malloc((long)(iVar1 + 1));
*puVar7 = pvVar5;
__sprintf_chk(pvVar5,2,(long)(iVar1 + 1),&DAT_00102004,iVar9);
puVar7 = puVar7 + 1;
} while (puVar8 != param_1);
}
return puVar2;
} |
6,380 | func0 |
#include <assert.h>
| float func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 = m2;
m2 = arr1[0];
break;
}
if (arr1[i] <= arr2[j]) {
m1 = m2;
m2 = arr1[i];
i++;
} else {
m1 = m2;
m2 = arr2[j];
j++;
}
}
return (m1 + m2) / 2.0;
}
| int main() {
int arr1_1[] = {1, 12, 15, 26, 38};
int arr2_1[] = {2, 13, 17, 30, 45};
int arr1_2[] = {2, 4, 8, 9};
int arr2_2[] = {7, 13, 19, 28};
int arr1_3[] = {3, 6, 14, 23, 36, 42};
int arr2_3[] = {2, 18, 27, 39, 49, 55};
assert(func0(arr1_1, arr2_1, 5) == 16.0);
assert(func0(arr1_2, arr2_2, 4) == 8.5);
assert(func0(arr1_3, arr2_3, 6) == 25.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1258 <func0+0xef>
addl $0x1,-0x4(%rbp)
mov -0x14(%rbp),%eax
cmp -0x34(%rbp),%eax
jne 11c4 <func0+0x5b>
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x30(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
jmpq 1264 <func0+0xfb>
mov -0x10(%rbp),%eax
cmp -0x34(%rbp),%eax
jne 11e0 <func0+0x77>
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
jmpq 1264 <func0+0xfb>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x30(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 1235 <func0+0xcc>
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x14(%rbp)
jmp 1258 <func0+0xef>
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x34(%rbp),%eax
cmp -0x4(%rbp),%eax
jge 11a4 <func0+0x3b>
mov -0xc(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cvtsi2sd %eax,%xmm0
movsd 0xe40(%rip),%xmm1
divsd %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0FFFFFFFFh
mov [rbp+var_4], 0
jmp loc_1258
loc_11A4:
add [rbp+var_4], 1
mov eax, [rbp+var_14]
cmp eax, [rbp+var_34]
jnz short loc_11C4
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
mov rax, [rbp+var_30]
mov eax, [rax]
mov [rbp+var_8], eax
jmp loc_1264
loc_11C4:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_34]
jnz short loc_11E0
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_8], eax
jmp loc_1264
loc_11E0:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_1235
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
add [rbp+var_14], 1
jmp short loc_1258
loc_1235:
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
add [rbp+var_10], 1
loc_1258:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4]
jge loc_11A4
loc_1264:
mov edx, [rbp+var_C]
mov eax, [rbp+var_8]
add eax, edx
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, cs:qword_2098
divsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
pop rbp
retn | float func0(int *a1, int *a2, int a3)
{
int v4; // [rsp+20h] [rbp-14h]
int v5; // [rsp+24h] [rbp-10h]
int v6; // [rsp+28h] [rbp-Ch]
int v7; // [rsp+2Ch] [rbp-8h]
int v8; // [rsp+30h] [rbp-4h]
v4 = 0;
v5 = 0;
v6 = -1;
v7 = -1;
v8 = 0;
while ( a3 >= v8 )
{
++v8;
if ( v4 == a3 )
{
v6 = v7;
v7 = *a2;
return (double)(v6 + v7) / 2.0;
}
if ( v5 == a3 )
{
v6 = v7;
v7 = *a1;
return (double)(v6 + v7) / 2.0;
}
v6 = v7;
if ( a1[v4] > a2[v5] )
v7 = a2[v5++];
else
v7 = a1[v4++];
}
return (double)(v6 + v7) / 2.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101258
LAB_001011a4:
ADD dword ptr [RBP + -0x4],0x1
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x001011c4
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101264
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x001011e0
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101264
LAB_001011e0:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x00101235
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x14],0x1
JMP 0x00101258
LAB_00101235:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x10],0x1
LAB_00101258:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4]
JGE 0x001011a4
LAB_00101264:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [0x00102098]
DIVSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
POP RBP
RET | int8 func0(int *param_1,int *param_2,int param_3)
{
double dVar1;
int local_1c;
int local_18;
int local_14;
int local_10;
int local_c;
local_1c = 0;
local_18 = 0;
local_14 = -1;
local_10 = -1;
local_c = 0;
do {
if (param_3 < local_c) {
LAB_00101264:
dVar1 = (double)(local_10 + local_14) / DAT_00102098;
return CONCAT44((int)((ulong)dVar1 >> 0x20),(float)dVar1);
}
local_c = local_c + 1;
if (local_1c == param_3) {
local_14 = local_10;
local_10 = *param_2;
goto LAB_00101264;
}
if (local_18 == param_3) {
local_14 = local_10;
local_10 = *param_1;
goto LAB_00101264;
}
if (param_2[local_18] < param_1[local_1c]) {
local_14 = local_10;
local_10 = param_2[local_18];
local_18 = local_18 + 1;
}
else {
local_14 = local_10;
local_10 = param_1[local_1c];
local_1c = local_1c + 1;
}
} while( true );
} |
6,381 | func0 |
#include <assert.h>
| float func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 = m2;
m2 = arr1[0];
break;
}
if (arr1[i] <= arr2[j]) {
m1 = m2;
m2 = arr1[i];
i++;
} else {
m1 = m2;
m2 = arr2[j];
j++;
}
}
return (m1 + m2) / 2.0;
}
| int main() {
int arr1_1[] = {1, 12, 15, 26, 38};
int arr2_1[] = {2, 13, 17, 30, 45};
int arr1_2[] = {2, 4, 8, 9};
int arr2_2[] = {7, 13, 19, 28};
int arr1_3[] = {3, 6, 14, 23, 36, 42};
int arr2_3[] = {2, 18, 27, 39, 49, 55};
assert(func0(arr1_1, arr2_1, 5) == 16.0);
assert(func0(arr1_2, arr2_2, 4) == 8.5);
assert(func0(arr1_3, arr2_3, 6) == 25.0);
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
js 11e8 <func0+0x7f>
je 118c <func0+0x23>
mov $0x1,%r9d
mov $0xffffffff,%r11d
mov $0x0,%r8d
mov $0x0,%ecx
jmp 11ce <func0+0x65>
mov $0xffffffff,%eax
mov %eax,%r11d
mov (%rsi),%eax
add %r11d,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xf0f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
mov %eax,%r11d
mov (%rdi),%eax
jmp 1196 <func0+0x2d>
add $0x1,%r8d
cmp %r9d,%edx
jl 1196 <func0+0x2d>
add $0x1,%r9d
cmp %edx,%ecx
je 1191 <func0+0x28>
cmp %edx,%r8d
je 11ae <func0+0x45>
mov %eax,%r11d
movslq %ecx,%rax
mov (%rdi,%rax,4),%r10d
movslq %r8d,%rax
mov (%rsi,%rax,4),%eax
cmp %eax,%r10d
jg 11b5 <func0+0x4c>
add $0x1,%ecx
mov %r10d,%eax
jmp 11b9 <func0+0x50>
mov $0xffffffff,%eax
mov $0xffffffff,%r11d
jmp 1196 <func0+0x2d>
| func0:
endbr64
test edx, edx
js short loc_11E9
jz short loc_118C
mov r9d, 1
mov r11d, 0FFFFFFFFh
mov r8d, 0
mov ecx, 0
jmp short loc_11CF
loc_118C:
mov eax, 0FFFFFFFFh
loc_1191:
mov r11d, eax
mov eax, [rsi]
loc_1196:
add r11d, eax
pxor xmm0, xmm0
cvtsi2sd xmm0, r11d
mulsd xmm0, cs:qword_2098
cvtsd2ss xmm0, xmm0
retn
loc_11AF:
mov r11d, eax
mov eax, [rdi]
jmp short loc_1196
loc_11B6:
add r8d, 1
loc_11BA:
cmp edx, r9d
jl short loc_1196
add r9d, 1
cmp ecx, edx
jz short loc_1191
cmp r8d, edx
jz short loc_11AF
mov r11d, eax
loc_11CF:
movsxd rax, ecx
mov r10d, [rdi+rax*4]
movsxd rax, r8d
mov eax, [rsi+rax*4]
cmp r10d, eax
jg short loc_11B6
add ecx, 1
mov eax, r10d
jmp short loc_11BA
loc_11E9:
mov eax, 0FFFFFFFFh
mov r11d, 0FFFFFFFFh
jmp short loc_1196 | float func0(int *a1, int *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v9; // r10d
if ( a3 < 0 )
{
v7 = -1;
v4 = -1;
}
else if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v9 = a1[v6];
v7 = a2[v5];
if ( v9 > v7 )
{
++v5;
}
else
{
++v6;
v7 = v9;
}
if ( a3 < v3 )
break;
++v3;
if ( v6 == a3 )
goto LABEL_5;
if ( v5 == a3 )
{
v4 = v7;
v7 = *a1;
return (double)(v7 + v4) * 0.5;
}
v4 = v7;
}
}
else
{
v7 = -1;
LABEL_5:
v4 = v7;
v7 = *a2;
}
return (double)(v7 + v4) * 0.5;
} | func0:
ENDBR64
TEST EDX,EDX
JS 0x001011e9
JZ 0x0010118c
MOV R9D,0x1
MOV R11D,0xffffffff
MOV R8D,0x0
MOV ECX,0x0
JMP 0x001011cf
LAB_0010118c:
MOV EAX,0xffffffff
LAB_00101191:
MOV R11D,EAX
MOV EAX,dword ptr [RSI]
LAB_00101196:
ADD R11D,EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,R11D
MULSD XMM0,qword ptr [0x00102098]
CVTSD2SS XMM0,XMM0
RET
LAB_001011af:
MOV R11D,EAX
MOV EAX,dword ptr [RDI]
JMP 0x00101196
LAB_001011b6:
ADD R8D,0x1
LAB_001011ba:
CMP EDX,R9D
JL 0x00101196
ADD R9D,0x1
CMP ECX,EDX
JZ 0x00101191
CMP R8D,EDX
JZ 0x001011af
MOV R11D,EAX
LAB_001011cf:
MOVSXD RAX,ECX
MOV R10D,dword ptr [RDI + RAX*0x4]
MOVSXD RAX,R8D
MOV EAX,dword ptr [RSI + RAX*0x4]
CMP R10D,EAX
JG 0x001011b6
ADD ECX,0x1
MOV EAX,R10D
JMP 0x001011ba
LAB_001011e9:
MOV EAX,0xffffffff
MOV R11D,0xffffffff
JMP 0x00101196 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
double dVar8;
if (param_3 < 0) {
iVar2 = -1;
iVar7 = -1;
}
else if (param_3 == 0) {
iVar1 = -1;
LAB_00101191:
iVar2 = *param_2;
iVar7 = iVar1;
}
else {
iVar6 = 1;
iVar5 = 0;
iVar4 = 0;
iVar7 = -1;
do {
lVar3 = (long)iVar4;
iVar1 = param_2[iVar5];
if (iVar1 < param_1[lVar3]) {
iVar5 = iVar5 + 1;
}
else {
iVar4 = iVar4 + 1;
iVar1 = param_1[lVar3];
}
iVar2 = iVar1;
if (param_3 < iVar6) goto LAB_00101196;
iVar6 = iVar6 + 1;
if (iVar4 == param_3) goto LAB_00101191;
iVar7 = iVar1;
} while (iVar5 != param_3);
iVar2 = *param_1;
}
LAB_00101196:
dVar8 = (double)(iVar7 + iVar2) * _DAT_00102098;
return CONCAT44((int)((ulong)dVar8 >> 0x20),(float)dVar8);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.