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,382 | 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;
}
| O2 | c | func0:
endbr64
test %edx,%edx
js 140f <func0+0xaf>
je 13d7 <func0+0x77>
mov $0x1,%r9d
mov $0xffffffff,%r11d
xor %r8d,%r8d
xor %ecx,%ecx
jmp 13a0 <func0+0x40>
nopl 0x0(%rax)
add $0x1,%ecx
cmp %r9d,%edx
jl 13bf <func0+0x5f>
add $0x1,%r9d
cmp %edx,%ecx
je 13dc <func0+0x7c>
cmp %edx,%r8d
je 13f8 <func0+0x98>
mov %eax,%r11d
movslq %ecx,%r10
mov (%rdi,%r10,4),%eax
movslq %r8d,%r10
mov (%rsi,%r10,4),%r10d
cmp %r10d,%eax
jle 1388 <func0+0x28>
add $0x1,%r8d
mov %r10d,%eax
cmp %r9d,%edx
jge 1390 <func0+0x30>
add %r11d,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xcf6(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
mov $0xffffffff,%eax
add (%rsi),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xcda(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
nopl 0x0(%rax,%rax,1)
add (%rdi),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xcbe(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
movss 0xca1(%rip),%xmm0
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
js loc_140F
jz short loc_13D6
mov r9d, 1
mov r11d, 0FFFFFFFFh
xor r8d, r8d
xor ecx, ecx
jmp short loc_13A0
loc_1388:
add ecx, 1
cmp edx, r9d
jl short loc_13BE
loc_1390:
add r9d, 1
cmp ecx, edx
jz short loc_13DB
cmp edx, r8d
jz short loc_13F8
mov r11d, eax
loc_13A0:
movsxd rax, ecx
movsxd r10, r8d
mov eax, [rdi+rax*4]
mov r10d, [rsi+r10*4]
cmp eax, r10d
jle short loc_1388
add r8d, 1
mov eax, r10d
cmp edx, r9d
jge short loc_1390
loc_13BE:
add eax, r11d
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_20A8
cvtsd2ss xmm0, xmm0
retn
loc_13D6:
mov eax, 0FFFFFFFFh
loc_13DB:
add eax, [rsi]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_20A8
cvtsd2ss xmm0, xmm0
retn
loc_13F8:
add eax, [rdi]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_20A8
cvtsd2ss xmm0, xmm0
retn
loc_140F:
movss xmm0, cs:dword_2098
retn | float func0(_DWORD *a1, _DWORD *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v8; // r10d
if ( a3 < 0 )
return -1.0;
if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v7 = a1[v6];
v8 = a2[v5];
if ( v7 <= v8 )
{
++v6;
if ( a3 < v3 )
return (double)(v4 + v7) * 0.5;
}
else
{
++v5;
v7 = v8;
if ( a3 < v3 )
return (double)(v4 + v7) * 0.5;
}
++v3;
if ( v6 == a3 )
return (double)(*a2 + v7) * 0.5;
if ( a3 == v5 )
break;
v4 = v7;
}
return (double)(*a1 + v7) * 0.5;
}
else
{
v7 = -1;
return (double)(*a2 + v7) * 0.5;
}
} | func0:
ENDBR64
TEST EDX,EDX
JS 0x0010140f
JZ 0x001013d6
MOV R9D,0x1
MOV R11D,0xffffffff
XOR R8D,R8D
XOR ECX,ECX
JMP 0x001013a0
LAB_00101388:
ADD ECX,0x1
CMP EDX,R9D
JL 0x001013be
LAB_00101390:
ADD R9D,0x1
CMP ECX,EDX
JZ 0x001013db
CMP EDX,R8D
JZ 0x001013f8
MOV R11D,EAX
LAB_001013a0:
MOVSXD RAX,ECX
MOVSXD R10,R8D
MOV EAX,dword ptr [RDI + RAX*0x4]
MOV R10D,dword ptr [RSI + R10*0x4]
CMP EAX,R10D
JLE 0x00101388
ADD R8D,0x1
MOV EAX,R10D
CMP EDX,R9D
JGE 0x00101390
LAB_001013be:
ADD EAX,R11D
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x001020a8]
CVTSD2SS XMM0,XMM0
RET
LAB_001013d6:
MOV EAX,0xffffffff
LAB_001013db:
ADD EAX,dword ptr [RSI]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x001020a8]
CVTSD2SS XMM0,XMM0
RET
LAB_001013f8:
ADD EAX,dword ptr [RDI]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x001020a8]
CVTSD2SS XMM0,XMM0
RET
LAB_0010140f:
MOVSS XMM0,dword ptr [0x00102098]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
double dVar7;
if (param_3 < 0) {
return (ulong)DAT_00102098;
}
if (param_3 == 0) {
iVar1 = -1;
}
else {
iVar5 = 1;
iVar4 = 0;
iVar3 = 0;
iVar6 = -1;
while( true ) {
lVar2 = (long)iVar3;
iVar1 = param_2[iVar4];
if (iVar1 < param_1[lVar2]) {
iVar4 = iVar4 + 1;
}
else {
iVar3 = iVar3 + 1;
iVar1 = param_1[lVar2];
}
if (param_3 < iVar5) {
dVar7 = (double)(iVar1 + iVar6) * _DAT_001020a8;
return CONCAT44((int)((ulong)dVar7 >> 0x20),(float)dVar7);
}
iVar5 = iVar5 + 1;
if (iVar3 == param_3) break;
iVar6 = iVar1;
if (param_3 == iVar4) {
dVar7 = (double)(iVar1 + *param_1) * _DAT_001020a8;
return CONCAT44((int)((ulong)dVar7 >> 0x20),(float)dVar7);
}
}
}
dVar7 = (double)(iVar1 + *param_2) * _DAT_001020a8;
return CONCAT44((int)((ulong)dVar7 >> 0x20),(float)dVar7);
} |
6,383 | 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;
}
| O3 | c | func0:
endbr64
test %edx,%edx
js 13af <func0+0xaf>
je 1377 <func0+0x77>
mov $0x1,%r9d
mov $0xffffffff,%r11d
xor %r8d,%r8d
xor %ecx,%ecx
jmp 1340 <func0+0x40>
nopl 0x0(%rax)
add $0x1,%ecx
cmp %r9d,%edx
jl 135f <func0+0x5f>
add $0x1,%r9d
cmp %edx,%ecx
je 137c <func0+0x7c>
cmp %edx,%r8d
je 1398 <func0+0x98>
mov %eax,%r11d
movslq %ecx,%r10
mov (%rdi,%r10,4),%eax
movslq %r8d,%r10
mov (%rsi,%r10,4),%r10d
cmp %r10d,%eax
jle 1328 <func0+0x28>
add $0x1,%r8d
mov %r10d,%eax
cmp %r9d,%edx
jge 1330 <func0+0x30>
add %r11d,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xd56(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
mov $0xffffffff,%eax
add (%rsi),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xd3a(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
nopl 0x0(%rax,%rax,1)
add (%rdi),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xd1e(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
retq
movss 0xd01(%rip),%xmm0
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
js loc_139F
jz short loc_1366
mov r9d, 1
mov r11d, 0FFFFFFFFh
xor r8d, r8d
xor ecx, ecx
jmp short loc_1330
loc_1318:
add ecx, 1
cmp edx, r9d
jl short loc_134E
loc_1320:
add r9d, 1
cmp ecx, edx
jz short loc_136B
cmp edx, r8d
jz short loc_1388
mov r11d, eax
loc_1330:
movsxd rax, ecx
movsxd r10, r8d
mov eax, [rdi+rax*4]
mov r10d, [rsi+r10*4]
cmp eax, r10d
jle short loc_1318
add r8d, 1
mov eax, r10d
cmp edx, r9d
jge short loc_1320
loc_134E:
add eax, r11d
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_20A8
cvtsd2ss xmm0, xmm0
retn
loc_1366:
mov eax, 0FFFFFFFFh
loc_136B:
add eax, [rsi]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_20A8
cvtsd2ss xmm0, xmm0
retn
loc_1388:
add eax, [rdi]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_20A8
cvtsd2ss xmm0, xmm0
retn
loc_139F:
movss xmm0, cs:dword_2004
retn | float func0(_DWORD *a1, _DWORD *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v8; // r10d
if ( a3 < 0 )
return -1.0;
if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v7 = a1[v6];
v8 = a2[v5];
if ( v7 <= v8 )
{
++v6;
if ( a3 < v3 )
return (double)(v4 + v7) * 0.5;
}
else
{
++v5;
v7 = v8;
if ( a3 < v3 )
return (double)(v4 + v7) * 0.5;
}
++v3;
if ( v6 == a3 )
return (double)(*a2 + v7) * 0.5;
if ( a3 == v5 )
break;
v4 = v7;
}
return (double)(*a1 + v7) * 0.5;
}
else
{
v7 = -1;
return (double)(*a2 + v7) * 0.5;
}
} | func0:
ENDBR64
TEST EDX,EDX
JS 0x0010139f
JZ 0x00101366
MOV R9D,0x1
MOV R11D,0xffffffff
XOR R8D,R8D
XOR ECX,ECX
JMP 0x00101330
LAB_00101318:
ADD ECX,0x1
CMP EDX,R9D
JL 0x0010134e
LAB_00101320:
ADD R9D,0x1
CMP ECX,EDX
JZ 0x0010136b
CMP EDX,R8D
JZ 0x00101388
MOV R11D,EAX
LAB_00101330:
MOVSXD RAX,ECX
MOVSXD R10,R8D
MOV EAX,dword ptr [RDI + RAX*0x4]
MOV R10D,dword ptr [RSI + R10*0x4]
CMP EAX,R10D
JLE 0x00101318
ADD R8D,0x1
MOV EAX,R10D
CMP EDX,R9D
JGE 0x00101320
LAB_0010134e:
ADD EAX,R11D
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x001020a8]
CVTSD2SS XMM0,XMM0
RET
LAB_00101366:
MOV EAX,0xffffffff
LAB_0010136b:
ADD EAX,dword ptr [RSI]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x001020a8]
CVTSD2SS XMM0,XMM0
RET
LAB_00101388:
ADD EAX,dword ptr [RDI]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x001020a8]
CVTSD2SS XMM0,XMM0
RET
LAB_0010139f:
MOVSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
double dVar7;
if (param_3 < 0) {
return (ulong)DAT_00102004;
}
if (param_3 == 0) {
iVar1 = -1;
}
else {
iVar5 = 1;
iVar4 = 0;
iVar3 = 0;
iVar6 = -1;
while( true ) {
lVar2 = (long)iVar3;
iVar1 = param_2[iVar4];
if (iVar1 < param_1[lVar2]) {
iVar4 = iVar4 + 1;
}
else {
iVar3 = iVar3 + 1;
iVar1 = param_1[lVar2];
}
if (param_3 < iVar5) {
dVar7 = (double)(iVar1 + iVar6) * _DAT_001020a8;
return CONCAT44((int)((ulong)dVar7 >> 0x20),(float)dVar7);
}
iVar5 = iVar5 + 1;
if (iVar3 == param_3) break;
iVar6 = iVar1;
if (param_3 == iVar4) {
dVar7 = (double)(iVar1 + *param_1) * _DAT_001020a8;
return CONCAT44((int)((ulong)dVar7 >> 0x20),(float)dVar7);
}
}
}
dVar7 = (double)(iVar1 + *param_2) * _DAT_001020a8;
return CONCAT44((int)((ulong)dVar7 >> 0x20),(float)dVar7);
} |
6,384 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h> // For pow function
| void func0(int nums[], int length, int n, int result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(nums[i], n);
}
}
| int main() {
int result1[10], result2[3], result3[2];
int arr1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int arr2[3] = {10, 20, 30};
int arr3[2] = {12, 15};
func0(arr1, 10, 2, result1);
func0(arr2, 3, 3, result2);
func0(arr3, 2, 5, result3);
assert(result1[0] == 1 && result1[1] == 4 && result1[2] == 9 && result1[3] == 16
&& result1[4] == 25 && result1[5] == 36 && result1[6] == 49 && result1[7] == 64
&& result1[8] == 81 && result1[9] == 100);
assert(result2[0] == 1000 && result2[1] == 8000 && result2[2] == 27000);
assert(result3[0] == 248832 && result3[1] == 759375);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ee <func0+0x65>
cvtsi2sdl -0x20(%rbp),%xmm1
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm0
callq 1070 <pow@plt>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
cvttsd2si %xmm0,%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ac <func0+0x23>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_4], 0
jmp short loc_1204
loc_11AC:
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_20]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movq rax, xmm2
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
cvttsd2si eax, xmm0
mov [rdx], eax
add [rbp+var_4], 1
loc_1204:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11AC
nop
nop
leave
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
*(_DWORD *)(a4 + 4LL * (int)i) = (int)pow((double)*(int *)(4LL * (int)i + a1), (double)a3);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101204
LAB_001011ac:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x20]
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]
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVQ RAX,XMM2
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
CVTTSD2SI EAX,XMM0
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101204:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ac
NOP
NOP
LEAVE
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
double dVar1;
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
dVar1 = pow((double)*(int *)(param_1 + (long)local_c * 4),(double)param_3);
*(int *)((long)local_c * 4 + param_4) = (int)dVar1;
}
return;
} |
6,385 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h> // For pow function
| void func0(int nums[], int length, int n, int result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(nums[i], n);
}
}
| int main() {
int result1[10], result2[3], result3[2];
int arr1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int arr2[3] = {10, 20, 30};
int arr3[2] = {12, 15};
func0(arr1, 10, 2, result1);
func0(arr2, 3, 3, result2);
func0(arr3, 2, 5, result3);
assert(result1[0] == 1 && result1[1] == 4 && result1[2] == 9 && result1[3] == 16
&& result1[4] == 25 && result1[5] == 36 && result1[6] == 49 && result1[7] == 64
&& result1[8] == 81 && result1[9] == 100);
assert(result2[0] == 1000 && result2[1] == 8000 && result2[2] == 27000);
assert(result3[0] == 248832 && result3[1] == 759375);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ec <func0+0x63>
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %rcx,%r12
lea -0x1(%rsi),%r13d
mov $0x0,%ebx
pxor %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm0,%xmm0
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
movsd 0x8(%rsp),%xmm1
callq 1070 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,(%r12,%rbx,4)
mov %rbx,%rax
add $0x1,%rbx
cmp %r13,%rax
jne 11b8 <func0+0x2f>
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
retq
| func0:
endbr64
test esi, esi
jle short locret_11E2
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13, rcx
mov ebp, esi
mov ebx, 0
pxor xmm2, xmm2
cvtsi2sd xmm2, edx
movq r14, xmm2
loc_11B3:
pxor xmm0, xmm0
cvtsi2sd xmm0, dword ptr [r12+rbx*4]
movq xmm1, r14
call _pow
cvttsd2si eax, xmm0
mov [r13+rbx*4+0], eax
add rbx, 1
cmp rbx, rbp
jnz short loc_11B3
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
locret_11E2:
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long v5; // rbx
double v6; // r14
long long result; // rax
if ( a2 > 0 )
{
v5 = 0LL;
v6 = (double)a3;
do
{
result = (unsigned int)(int)pow((double)*(int *)(a1 + 4 * v5), v6);
*(_DWORD *)(a4 + 4 * v5++) = result;
}
while ( v5 != a2 );
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011e2
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13,RCX
MOV EBP,ESI
MOV EBX,0x0
PXOR XMM2,XMM2
CVTSI2SD XMM2,EDX
MOVQ R14,XMM2
LAB_001011b3:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [R12 + RBX*0x4]
MOVQ XMM1,R14
CALL 0x00101070
CVTTSD2SI EAX,XMM0
MOV dword ptr [R13 + RBX*0x4],EAX
ADD RBX,0x1
CMP RBX,RBP
JNZ 0x001011b3
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001011e2:
RET | void func0(long param_1,uint param_2,int param_3,long param_4)
{
ulong uVar1;
double dVar2;
if (0 < (int)param_2) {
uVar1 = 0;
do {
dVar2 = pow((double)*(int *)(param_1 + uVar1 * 4),(double)param_3);
*(int *)(param_4 + uVar1 * 4) = (int)dVar2;
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
return;
}
return;
} |
6,386 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h> // For pow function
| void func0(int nums[], int length, int n, int result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(nums[i], n);
}
}
| int main() {
int result1[10], result2[3], result3[2];
int arr1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int arr2[3] = {10, 20, 30};
int arr3[2] = {12, 15};
func0(arr1, 10, 2, result1);
func0(arr2, 3, 3, result2);
func0(arr3, 2, 5, result3);
assert(result1[0] == 1 && result1[1] == 4 && result1[2] == 9 && result1[3] == 16
&& result1[4] == 25 && result1[5] == 36 && result1[6] == 49 && result1[7] == 64
&& result1[8] == 81 && result1[9] == 100);
assert(result2[0] == 1000 && result2[1] == 8000 && result2[2] == 27000);
assert(result3[0] == 248832 && result3[1] == 759375);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13e0 <func0+0x70>
pxor %xmm1,%xmm1
push %r13
lea -0x1(%rsi),%r13d
push %r12
cvtsi2sd %edx,%xmm1
mov %rcx,%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x18,%rsp
nopw %cs:0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
movsd %xmm1,0x8(%rsp)
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
callq 1070 <pow@plt>
movsd 0x8(%rsp),%xmm1
cvttsd2si %xmm0,%eax
mov %eax,(%r12,%rbx,4)
mov %rbx,%rax
add $0x1,%rbx
cmp %rax,%r13
jne 13a0 <func0+0x30>
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short locret_13D0
pxor xmm1, xmm1
push r13
mov r13, rcx
push r12
cvtsi2sd xmm1, edx
mov r12, rdi
push rbp
movsxd rbp, esi
push rbx
xor ebx, ebx
sub rsp, 18h
nop dword ptr [rax]
loc_1398:
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm1
cvtsi2sd xmm0, dword ptr [r12+rbx*4]
call _pow
movsd xmm1, [rsp+38h+var_30]
cvttsd2si eax, xmm0
mov [r13+rbx*4+0], eax
add rbx, 1
cmp rbp, rbx
jnz short loc_1398
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
locret_13D0:
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
double v5; // xmm1_8
long long i; // rbx
long long result; // rax
if ( a2 > 0 )
{
v5 = (double)a3;
for ( i = 0LL; i != a2; *(_DWORD *)(a4 + 4 * i++) = result )
result = (unsigned int)(int)pow((double)*(int *)(a1 + 4 * i), v5);
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013d0
PXOR XMM1,XMM1
PUSH R13
MOV R13,RCX
PUSH R12
CVTSI2SD XMM1,EDX
MOV R12,RDI
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x18
NOP dword ptr [RAX]
LAB_00101398:
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
CVTSI2SD XMM0,dword ptr [R12 + RBX*0x4]
CALL 0x00101070
MOVSD XMM1,qword ptr [RSP + 0x8]
CVTTSD2SI EAX,XMM0
MOV dword ptr [R13 + RBX*0x4],EAX
ADD RBX,0x1
CMP RBP,RBX
JNZ 0x00101398
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013d0:
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
long lVar1;
double dVar2;
if (0 < param_2) {
lVar1 = 0;
do {
dVar2 = pow((double)*(int *)(param_1 + lVar1 * 4),(double)param_3);
*(int *)(param_4 + lVar1 * 4) = (int)dVar2;
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
return;
}
return;
} |
6,387 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h> // For pow function
| void func0(int nums[], int length, int n, int result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(nums[i], n);
}
}
| int main() {
int result1[10], result2[3], result3[2];
int arr1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int arr2[3] = {10, 20, 30};
int arr3[2] = {12, 15};
func0(arr1, 10, 2, result1);
func0(arr2, 3, 3, result2);
func0(arr3, 2, 5, result3);
assert(result1[0] == 1 && result1[1] == 4 && result1[2] == 9 && result1[3] == 16
&& result1[4] == 25 && result1[5] == 36 && result1[6] == 49 && result1[7] == 64
&& result1[8] == 81 && result1[9] == 100);
assert(result2[0] == 1000 && result2[1] == 8000 && result2[2] == 27000);
assert(result3[0] == 248832 && result3[1] == 759375);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13c0 <func0+0x70>
pxor %xmm1,%xmm1
push %r13
lea -0x1(%rsi),%r13d
push %r12
cvtsi2sd %edx,%xmm1
mov %rcx,%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x18,%rsp
nopw %cs:0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
movsd %xmm1,0x8(%rsp)
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
callq 1070 <pow@plt>
movsd 0x8(%rsp),%xmm1
cvttsd2si %xmm0,%eax
mov %eax,(%r12,%rbx,4)
mov %rbx,%rax
add $0x1,%rbx
cmp %rax,%r13
jne 1380 <func0+0x30>
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short locret_13B0
pxor xmm1, xmm1
push r12
movsxd rsi, esi
push rbp
cvtsi2sd xmm1, edx; y
mov rbp, rcx
lea r12, [rdi+rsi*4]
push rbx
mov rbx, rdi
sub rsp, 10h
nop dword ptr [rax]
loc_1378:
pxor xmm0, xmm0
movsd [rsp+28h+var_20], xmm1
add rbx, 4
add rbp, 4
cvtsi2sd xmm0, dword ptr [rbx-4]; x
call _pow
movsd xmm1, [rsp+28h+var_20]
cvttsd2si eax, xmm0
mov [rbp-4], eax
cmp rbx, r12
jnz short loc_1378
add rsp, 10h
pop rbx
pop rbp
pop r12
retn
locret_13B0:
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
double v4; // xmm1_8
long long v6; // rbx
long long result; // rax
if ( a2 > 0 )
{
v4 = (double)a3;
v6 = a1;
do
{
v6 += 4LL;
a4 += 4LL;
result = (unsigned int)(int)pow((double)*(int *)(v6 - 4), v4);
*(_DWORD *)(a4 - 4) = result;
}
while ( v6 != a1 + 4LL * a2 );
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b0
PXOR XMM1,XMM1
PUSH R12
MOVSXD RSI,ESI
PUSH RBP
CVTSI2SD XMM1,EDX
MOV RBP,RCX
LEA R12,[RDI + RSI*0x4]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x10
NOP dword ptr [RAX]
LAB_00101378:
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
ADD RBX,0x4
ADD RBP,0x4
CVTSI2SD XMM0,dword ptr [RBX + -0x4]
CALL 0x00101070
MOVSD XMM1,qword ptr [RSP + 0x8]
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
CMP RBX,R12
JNZ 0x00101378
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET
LAB_001013b0:
RET | void func0(int *param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
int *piVar2;
double dVar3;
if (0 < param_2) {
piVar1 = param_1;
do {
piVar2 = piVar1 + 1;
dVar3 = pow((double)*piVar1,(double)param_3);
*param_4 = (int)dVar3;
piVar1 = piVar2;
param_4 = param_4 + 1;
} while (piVar2 != param_1 + param_2);
return;
}
return;
} |
6,388 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* string) {
static char result[100];
int i;
for(i = 0; string[i] != '\0'; i++) {
result[i] = toupper((unsigned char) string[i]);
}
result[i] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("person"), "PERSON") == 0);
assert(strcmp(func0("final"), "FINAL") == 0);
assert(strcmp(func0("Valid"), "VALID") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x48>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
mov %eax,%edi
callq 1070 <toupper@plt>
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x2e76(%rip),%rdx
mov %cl,(%rax,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11a2 <func0+0x19>
mov -0x4(%rbp),%eax
cltq
lea 0x2e4f(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2e44(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_11D1
loc_11A2:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
mov edi, eax; c
call _toupper
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
mov [rax+rdx], cl
add [rbp+var_4], 1
loc_11D1:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_11A2
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
mov byte ptr [rax+rdx], 0
lea rax, result_1
leave
retn | _BYTE * func0(long long a1)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
result_1[i] = toupper(*(unsigned __int8 *)(i + a1));
result_1[i] = 0;
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
MOV EDI,EAX
CALL 0x00101070
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],CL
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011a2
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(long param_1)
{
int iVar1;
int local_c;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
iVar1 = toupper((uint)*(byte *)(param_1 + local_c));
result_1[local_c] = (char)iVar1;
}
result_1[local_c] = 0;
return result_1;
} |
6,389 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* string) {
static char result[100];
int i;
for(i = 0; string[i] != '\0'; i++) {
result[i] = toupper((unsigned char) string[i]);
}
result[i] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("person"), "PERSON") == 0);
assert(strcmp(func0("final"), "FINAL") == 0);
assert(strcmp(func0("Valid"), "VALID") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 11be <func0+0x55>
mov %rdi,%rbp
callq 1060 <__ctype_toupper_loc@plt>
mov $0x1,%edx
lea 0x2eb1(%rip),%rsi
movzbl %bl,%ebx
mov (%rax),%rcx
mov (%rcx,%rbx,4),%ecx
mov %cl,(%rdx,%rsi,1)
mov %edx,%ecx
add $0x1,%rdx
movzbl -0x1(%rbp,%rdx,1),%ebx
test %bl,%bl
jne 118e <func0+0x25>
lea 0x2e90(%rip),%rax
movslq %ecx,%rcx
movb $0x0,(%rax,%rcx,1)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
mov $0x0,%ecx
jmp 11a9 <func0+0x40>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11DE
mov rbp, rdi
call ___ctype_toupper_loc
mov edx, 1
lea rsi, unk_403F
loc_11AE:
movzx ebx, bl
mov rcx, [rax]
mov ecx, [rcx+rbx*4]
mov [rdx+rsi], cl
mov ecx, edx
add rdx, 1
movzx ebx, byte ptr [rbp+rdx-1]
test bl, bl
jnz short loc_11AE
loc_11C9:
lea rax, result_1
movsxd rcx, ecx
mov byte ptr [rax+rcx], 0
add rsp, 8
pop rbx
pop rbp
retn
loc_11DE:
mov ecx, 0
jmp short loc_11C9 | _BYTE * func0(unsigned __int8 *a1)
{
unsigned __int8 v1; // bl
_QWORD *v2; // rax
long long v3; // rdx
int v4; // ecx
_BYTE *result; // rax
v1 = *a1;
if ( *a1 )
{
v2 = (_QWORD *)__ctype_toupper_loc();
v3 = 1LL;
do
{
*((_BYTE *)&unk_403F + v3) = *(_DWORD *)(*v2 + 4LL * v1);
v4 = v3++;
v1 = a1[v3 - 1];
}
while ( v1 );
}
else
{
v4 = 0;
}
result = result_1;
result_1[v4] = 0;
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011de
MOV RBP,RDI
CALL 0x00101070
MOV EDX,0x1
LEA RSI,[0x10403f]
LAB_001011ae:
MOVZX EBX,BL
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV byte ptr [RDX + RSI*0x1],CL
MOV ECX,EDX
ADD RDX,0x1
MOVZX EBX,byte ptr [RBP + RDX*0x1 + -0x1]
TEST BL,BL
JNZ 0x001011ae
LAB_001011c9:
LEA RAX,[0x104040]
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011de:
MOV ECX,0x0
JMP 0x001011c9 | void func0(byte *param_1)
{
__int32_t **pp_Var1;
int iVar2;
long lVar3;
byte bVar4;
bVar4 = *param_1;
if (bVar4 == 0) {
iVar2 = 0;
}
else {
pp_Var1 = __ctype_toupper_loc();
lVar3 = 1;
do {
(&DAT_0010403f)[lVar3] = (char)(*pp_Var1)[bVar4];
iVar2 = (int)lVar3;
bVar4 = param_1[lVar3];
lVar3 = lVar3 + 1;
} while (bVar4 != 0);
}
(&result_1)[iVar2] = 0;
return;
} |
6,390 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* string) {
static char result[100];
int i;
for(i = 0; string[i] != '\0'; i++) {
result[i] = toupper((unsigned char) string[i]);
}
result[i] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("person"), "PERSON") == 0);
assert(strcmp(func0("final"), "FINAL") == 0);
assert(strcmp(func0("Valid"), "VALID") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 12b0 <func0+0x60>
mov %rdi,%rbp
callq 1060 <__ctype_toupper_loc@plt>
mov $0x1,%edx
lea 0x2dca(%rip),%rsi
nopl (%rax)
mov (%rax),%rcx
movzbl %bl,%ebx
mov (%rcx,%rbx,4),%ecx
mov %cl,(%rsi,%rdx,1)
movslq %edx,%rcx
add $0x1,%rdx
movzbl -0x1(%rbp,%rdx,1),%ebx
test %bl,%bl
jne 1278 <func0+0x28>
lea 0x2da5(%rip),%rax
movb $0x0,(%rax,%rcx,1)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
xor %ecx,%ecx
jmp 1294 <func0+0x44>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_12B8
mov rbp, rdi
call ___ctype_toupper_loc
mov edx, 1
lea rsi, unk_403F
nop dword ptr [rax]
loc_1288:
mov rcx, [rax]
mov ecx, [rcx+rbx*4]
mov [rsi+rdx], cl
movsxd rcx, edx
add rdx, 1
movzx ebx, byte ptr [rbp+rdx-1]
test bl, bl
jnz short loc_1288
loc_12A1:
lea rax, result_1
mov byte ptr [rax+rcx], 0
add rsp, 8
pop rbx
pop rbp
retn
loc_12B8:
xor ecx, ecx
jmp short loc_12A1 | _BYTE * func0(unsigned __int8 *a1)
{
long long v1; // rbx
_QWORD *v2; // rax
long long v3; // rdx
long long v4; // rcx
_BYTE *result; // rax
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = (_QWORD *)__ctype_toupper_loc();
v3 = 1LL;
do
{
*((_BYTE *)&unk_403F + v3) = *(_DWORD *)(*v2 + 4 * v1);
v4 = (int)v3++;
v1 = a1[v3 - 1];
}
while ( (_BYTE)v1 );
}
else
{
v4 = 0LL;
}
result = result_1;
result_1[v4] = 0;
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001012b8
MOV RBP,RDI
CALL 0x00101070
MOV EDX,0x1
LEA RSI,[0x10403f]
NOP dword ptr [RAX]
LAB_00101288:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV byte ptr [RSI + RDX*0x1],CL
MOVSXD RCX,EDX
ADD RDX,0x1
MOVZX EBX,byte ptr [RBP + RDX*0x1 + -0x1]
TEST BL,BL
JNZ 0x00101288
LAB_001012a1:
LEA RAX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012b8:
XOR ECX,ECX
JMP 0x001012a1 | void func0(byte *param_1)
{
byte bVar1;
__int32_t **pp_Var2;
long lVar3;
long lVar4;
bVar1 = *param_1;
if (bVar1 == 0) {
lVar3 = 0;
}
else {
pp_Var2 = __ctype_toupper_loc();
lVar4 = 1;
do {
(&DAT_0010403f)[lVar4] = (char)(*pp_Var2)[bVar1];
lVar3 = (long)(int)lVar4;
bVar1 = param_1[lVar4];
lVar4 = lVar4 + 1;
} while (bVar1 != 0);
}
(&result_1)[lVar3] = 0;
return;
} |
6,391 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* string) {
static char result[100];
int i;
for(i = 0; string[i] != '\0'; i++) {
result[i] = toupper((unsigned char) string[i]);
}
result[i] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("person"), "PERSON") == 0);
assert(strcmp(func0("final"), "FINAL") == 0);
assert(strcmp(func0("Valid"), "VALID") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 12b0 <func0+0x60>
mov %rdi,%rbp
callq 1060 <__ctype_toupper_loc@plt>
mov $0x1,%edx
lea 0x2dca(%rip),%rsi
nopl (%rax)
mov (%rax),%rcx
movzbl %bl,%ebx
mov (%rcx,%rbx,4),%ecx
mov %cl,(%rsi,%rdx,1)
movslq %edx,%rcx
add $0x1,%rdx
movzbl -0x1(%rbp,%rdx,1),%ebx
test %bl,%bl
jne 1278 <func0+0x28>
lea 0x2da5(%rip),%rax
movb $0x0,(%rax,%rcx,1)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
xor %ecx,%ecx
jmp 1294 <func0+0x44>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_12C0
mov rbp, rdi
call ___ctype_toupper_loc
mov edx, 1
lea rsi, unk_403F
nop dword ptr [rax]
loc_1288:
mov rcx, [rax]
mov ecx, [rcx+rbx*4]
mov [rsi+rdx], cl
mov rcx, rdx
add rdx, 1
movzx ebx, byte ptr [rbp+rdx-1]
test bl, bl
jnz short loc_1288
loc_12A1:
lea rax, result_1
movsxd rcx, ecx
mov byte ptr [rax+rcx], 0
add rsp, 8
pop rbx
pop rbp
retn
loc_12C0:
xor ecx, ecx
jmp short loc_12A1 | _BYTE * func0(unsigned __int8 *a1)
{
long long v1; // rbx
const __int32_t **v2; // rax
long long v3; // rdx
int v4; // ecx
_BYTE *result; // rax
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = __ctype_toupper_loc();
v3 = 1LL;
do
{
*((_BYTE *)&unk_403F + v3) = (*v2)[v1];
v4 = v3++;
v1 = a1[v3 - 1];
}
while ( (_BYTE)v1 );
}
else
{
v4 = 0;
}
result = result_1;
result_1[v4] = 0;
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001012c0
MOV RBP,RDI
CALL 0x00101070
MOV EDX,0x1
LEA RSI,[0x10403f]
NOP dword ptr [RAX]
LAB_00101288:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV byte ptr [RSI + RDX*0x1],CL
MOV RCX,RDX
ADD RDX,0x1
MOVZX EBX,byte ptr [RBP + RDX*0x1 + -0x1]
TEST BL,BL
JNZ 0x00101288
LAB_001012a1:
LEA RAX,[0x104040]
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012c0:
XOR ECX,ECX
JMP 0x001012a1 | void func0(byte *param_1)
{
byte bVar1;
long lVar2;
__int32_t **pp_Var3;
long lVar4;
bVar1 = *param_1;
if (bVar1 == 0) {
lVar4 = 0;
}
else {
pp_Var3 = __ctype_toupper_loc();
lVar2 = 1;
do {
lVar4 = lVar2;
(&DAT_0010403f)[lVar4] = (char)(*pp_Var3)[bVar1];
bVar1 = param_1[lVar4];
lVar2 = lVar4 + 1;
} while (bVar1 != 0);
}
(&result_1)[(int)lVar4] = 0;
return;
} |
6,392 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int newList[], int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
// Test case 1
int array1[] = {1, 2, 3};
int size1 = sizeof(array1) / sizeof(array1[0]);
int* result1 = func0(array1, size1);
assert(result1[0] == 3);
assert(result1[1] == 2);
assert(result1[2] == 1);
// Test case 2
int array2[] = {1, 2, 3, 4, 4};
int size2 = sizeof(array2) / sizeof(array2[0]);
int* result2 = func0(array2, size2);
assert(result2[0] == 4);
assert(result2[1] == 2);
assert(result2[2] == 3);
assert(result2[3] == 4);
assert(result2[4] == 1);
// Test case 3
int array3[] = {4, 5, 6};
int size3 = sizeof(array3) / sizeof(array3[0]);
int* result3 = func0(array3, size3);
assert(result3[0] == 6);
assert(result3[1] == 5);
assert(result3[2] == 4);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_18]
mov [rax], edx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
mov rax, [rbp+var_18]
pop rbp
retn | int * func0(int *a1, int a2)
{
int v3; // [rsp+18h] [rbp-4h]
v3 = *a1;
*a1 = a1[a2 - 1];
a1[a2 - 1] = v3;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,393 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int newList[], int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
// Test case 1
int array1[] = {1, 2, 3};
int size1 = sizeof(array1) / sizeof(array1[0]);
int* result1 = func0(array1, size1);
assert(result1[0] == 3);
assert(result1[1] == 2);
assert(result1[2] == 1);
// Test case 2
int array2[] = {1, 2, 3, 4, 4};
int size2 = sizeof(array2) / sizeof(array2[0]);
int* result2 = func0(array2, size2);
assert(result2[0] == 4);
assert(result2[1] == 2);
assert(result2[2] == 3);
assert(result2[3] == 4);
assert(result2[4] == 1);
// Test case 3
int array3[] = {4, 5, 6};
int size3 = sizeof(array3) / sizeof(array3[0]);
int* result3 = func0(array3, size3);
assert(result3[0] == 6);
assert(result3[1] == 5);
assert(result3[2] == 4);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
mov (%rdi),%ecx
movslq %esi,%rsi
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
| func0:
endbr64
mov rax, rdi
mov ecx, [rdi]
movsxd rsi, esi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *result; // rax
int v3; // ecx
_DWORD *v4; // rdx
result = a1;
v3 = *a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v3;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV ECX,dword ptr [RDI]
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,394 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int newList[], int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
// Test case 1
int array1[] = {1, 2, 3};
int size1 = sizeof(array1) / sizeof(array1[0]);
int* result1 = func0(array1, size1);
assert(result1[0] == 3);
assert(result1[1] == 2);
assert(result1[2] == 1);
// Test case 2
int array2[] = {1, 2, 3, 4, 4};
int size2 = sizeof(array2) / sizeof(array2[0]);
int* result2 = func0(array2, size2);
assert(result2[0] == 4);
assert(result2[1] == 2);
assert(result2[2] == 3);
assert(result2[3] == 4);
assert(result2[4] == 1);
// Test case 3
int array3[] = {4, 5, 6};
int size3 = sizeof(array3) / sizeof(array3[0]);
int* result3 = func0(array3, size3);
assert(result3[0] == 6);
assert(result3[1] == 5);
assert(result3[2] == 4);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi),%ecx
mov %rdi,%rax
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
mov ecx, [rdi]
mov rax, rdi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // ecx
_DWORD *result; // rax
_DWORD *v4; // rdx
v2 = *a1;
result = a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v2;
return result;
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV ECX,dword ptr [RDI]
MOV RAX,RDI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,395 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int newList[], int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
// Test case 1
int array1[] = {1, 2, 3};
int size1 = sizeof(array1) / sizeof(array1[0]);
int* result1 = func0(array1, size1);
assert(result1[0] == 3);
assert(result1[1] == 2);
assert(result1[2] == 1);
// Test case 2
int array2[] = {1, 2, 3, 4, 4};
int size2 = sizeof(array2) / sizeof(array2[0]);
int* result2 = func0(array2, size2);
assert(result2[0] == 4);
assert(result2[1] == 2);
assert(result2[2] == 3);
assert(result2[3] == 4);
assert(result2[4] == 1);
// Test case 3
int array3[] = {4, 5, 6};
int size3 = sizeof(array3) / sizeof(array3[0]);
int* result3 = func0(array3, size3);
assert(result3[0] == 6);
assert(result3[1] == 5);
assert(result3[2] == 4);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi),%ecx
mov %rdi,%rax
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
mov ecx, [rdi]
mov rax, rdi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // ecx
_DWORD *result; // rax
_DWORD *v4; // rdx
v2 = *a1;
result = a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v2;
return result;
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV ECX,dword ptr [RDI]
MOV RAX,RDI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,396 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 1161 <func0+0x18>
mov $0xffffffff,%eax
jmp 1167 <func0+0x1e>
mov -0x4(%rbp),%eax
imul %eax,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jns short loc_1161
mov eax, 0FFFFFFFFh
jmp short loc_1167
loc_1161:
mov eax, [rbp+var_4]
imul eax, eax
loc_1167:
pop rbp
retn | long long func0(int a1)
{
if ( a1 >= 0 )
return (unsigned int)(a1 * a1);
else
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNS 0x00101161
MOV EAX,0xffffffff
JMP 0x00101167
LAB_00101161:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
LAB_00101167:
POP RBP
RET | int func0(int param_1)
{
if (param_1 < 0) {
param_1 = -1;
}
else {
param_1 = param_1 * param_1;
}
return param_1;
} |
6,397 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
test %edi,%edi
js 1137 <func0+0xe>
imul %edi,%eax
retq
mov $0xffffffff,%eax
retq
| func0:
endbr64
mov eax, edi
test edi, edi
js short loc_1137
imul eax, edi
retn
loc_1137:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1)
{
if ( a1 < 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JS 0x00101137
IMUL EAX,EDI
RET
LAB_00101137:
MOV EAX,0xffffffff
RET | int func0(int param_1)
{
if (-1 < param_1) {
return param_1 * param_1;
}
return -1;
} |
6,398 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
test %edi,%edi
js 114e <func0+0xe>
imul %edi,%eax
retq
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
test edi, edi
js short loc_114E
imul eax, edi
retn
loc_114E:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1)
{
if ( a1 < 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JS 0x0010114e
IMUL EAX,EDI
RET
LAB_0010114e:
MOV EAX,0xffffffff
RET | int func0(int param_1)
{
if (-1 < param_1) {
return param_1 * param_1;
}
return -1;
} |
6,399 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
test %edi,%edi
js 114e <func0+0xe>
imul %edi,%eax
retq
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
test edi, edi
js short loc_114E
imul eax, edi
retn
loc_114E:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1)
{
if ( a1 < 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JS 0x0010114e
IMUL EAX,EDI
RET
LAB_0010114e:
MOV EAX,0xffffffff
RET | int func0(int param_1)
{
if (-1 < param_1) {
return param_1 * param_1;
}
return -1;
} |
6,400 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}
| int main() {
int array1[] = {0, 1, 2, 3};
int array2[] = {0, 1, 2, 6, 9};
int array3[] = {2, 3, 5, 8, 9};
assert(func0(array1, 0, 3) == 4);
assert(func0(array2, 0, 4) == 3);
assert(func0(array3, 0, 4) == 0);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 11af <func0+0x26>
mov -0x20(%rbp),%eax
add $0x1,%eax
jmp 122b <func0+0xa2>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
je 11cf <func0+0x46>
mov -0x1c(%rbp),%eax
jmp 122b <func0+0xa2>
mov -0x1c(%rbp),%edx
mov -0x20(%rbp),%eax
add %edx,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jne 1217 <func0+0x8e>
mov -0x4(%rbp),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%edx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1189 <func0>
jmp 122b <func0+0xa2>
mov -0x4(%rbp),%edx
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1189 <func0>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jle short loc_11AF
mov eax, [rbp+var_20]
add eax, 1
jmp short locret_122B
loc_11AF:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_1C], eax
jz short loc_11CF
mov eax, [rbp+var_1C]
jmp short locret_122B
loc_11CF:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_20]
add eax, edx
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jnz short loc_1217
mov eax, [rbp+var_4]
lea ecx, [rax+1]
mov edx, [rbp+var_20]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
jmp short locret_122B
loc_1217:
mov edx, [rbp+var_4]
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
locret_122B:
leave
retn | long long func0(long long a1, unsigned int a2, unsigned int a3)
{
int v4; // [rsp+1Ch] [rbp-4h]
if ( (int)a2 > (int)a3 )
return a3 + 1;
if ( a2 != *(_DWORD *)(4LL * (int)a2 + a1) )
return a2;
v4 = (int)(a2 + a3) / 2;
if ( v4 == *(_DWORD *)(4LL * v4 + a1) )
return func0(a1, (unsigned int)(v4 + 1), a3);
else
return func0(a1, a2, (unsigned int)v4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x001011af
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
JMP 0x0010122b
LAB_001011af:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
JZ 0x001011cf
MOV EAX,dword ptr [RBP + -0x1c]
JMP 0x0010122b
LAB_001011cf:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,EDX
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JNZ 0x00101217
MOV EAX,dword ptr [RBP + -0x4]
LEA ECX,[RAX + 0x1]
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101189
JMP 0x0010122b
LAB_00101217:
MOV EDX,dword ptr [RBP + -0x4]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101189
LAB_0010122b:
LEAVE
RET | ulong func0(long param_1,uint param_2,int param_3)
{
int iVar1;
ulong uVar2;
if (param_3 < (int)param_2) {
uVar2 = (ulong)(param_3 + 1);
}
else if (param_2 == *(uint *)(param_1 + (long)(int)param_2 * 4)) {
iVar1 = (int)(param_3 + param_2) / 2;
if (iVar1 == *(int *)(param_1 + (long)iVar1 * 4)) {
uVar2 = func0(param_1,iVar1 + 1,param_3);
}
else {
uVar2 = func0(param_1,param_2,iVar1);
}
}
else {
uVar2 = (ulong)param_2;
}
return uVar2;
} |
6,401 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}
| int main() {
int array1[] = {0, 1, 2, 3};
int array2[] = {0, 1, 2, 6, 9};
int array3[] = {2, 3, 5, 8, 9};
assert(func0(array1, 0, 3) == 4);
assert(func0(array2, 0, 4) == 3);
assert(func0(array3, 0, 4) == 0);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
cmp %edx,%esi
jg 11bf <func0+0x36>
movslq %esi,%rcx
mov %esi,%eax
cmp %esi,(%rdi,%rcx,4)
jne 11cd <func0+0x44>
sub $0x8,%rsp
lea (%rsi,%rdx,1),%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
movslq %eax,%rcx
cmp %eax,(%rdi,%rcx,4)
je 11c3 <func0+0x3a>
mov %eax,%edx
callq 1189 <func0>
add $0x8,%rsp
retq
lea 0x1(%rdx),%eax
retq
lea 0x1(%rax),%esi
callq 1189 <func0>
jmp 11ba <func0+0x31>
retq
| func0:
endbr64
cmp esi, edx
jg short loc_11BF
movsxd rcx, esi
mov eax, esi
cmp [rdi+rcx*4], esi
jnz short locret_11CD
sub rsp, 8
lea ecx, [rsi+rdx]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd rcx, eax
cmp [rdi+rcx*4], eax
jz short loc_11C3
mov edx, eax
call func0
loc_11BA:
add rsp, 8
retn
loc_11BF:
lea eax, [rdx+1]
retn
loc_11C3:
lea esi, [rax+1]
call func0
jmp short loc_11BA
locret_11CD:
retn | long long func0(long long a1, long long a2, int a3)
{
long long result; // rax
int v4; // eax
if ( (int)a2 > a3 )
return (unsigned int)(a3 + 1);
result = (unsigned int)a2;
if ( *(_DWORD *)(a1 + 4LL * (int)a2) == (_DWORD)a2 )
{
v4 = ((int)a2 + a3) / 2;
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 )
return func0(a1, (unsigned int)(v4 + 1));
else
return func0(a1, a2);
}
return result;
} | func0:
ENDBR64
CMP ESI,EDX
JG 0x001011bf
MOVSXD RCX,ESI
MOV EAX,ESI
CMP dword ptr [RDI + RCX*0x4],ESI
JNZ 0x001011cd
SUB RSP,0x8
LEA ECX,[RSI + RDX*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
CMP dword ptr [RDI + RCX*0x4],EAX
JZ 0x001011c3
MOV EDX,EAX
CALL 0x00101189
LAB_001011ba:
ADD RSP,0x8
RET
LAB_001011bf:
LEA EAX,[RDX + 0x1]
RET
LAB_001011c3:
LEA ESI,[RAX + 0x1]
CALL 0x00101189
JMP 0x001011ba
LAB_001011cd:
RET | ulong func0(long param_1,ulong param_2,int param_3)
{
int iVar1;
ulong uVar2;
iVar1 = (int)param_2;
if (param_3 < iVar1) {
return (ulong)(param_3 + 1);
}
if (*(int *)(param_1 + (long)iVar1 * 4) == iVar1) {
iVar1 = (iVar1 + param_3) / 2;
if (*(int *)(param_1 + (long)iVar1 * 4) == iVar1) {
uVar2 = func0(param_1,iVar1 + 1);
}
else {
uVar2 = func0(param_1,param_2,iVar1);
}
return uVar2;
}
return param_2 & 0xffffffff;
} |
6,402 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}
| int main() {
int array1[] = {0, 1, 2, 3};
int array2[] = {0, 1, 2, 6, 9};
int array3[] = {2, 3, 5, 8, 9};
assert(func0(array1, 0, 3) == 4);
assert(func0(array2, 0, 4) == 3);
assert(func0(array3, 0, 4) == 0);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%rax
lea (%rdi,%rax,4),%r8
jmp 12fb <func0+0x2b>
nopl (%rax)
cmp %esi,(%r8)
jne 1308 <func0+0x38>
lea (%rdx,%rsi,1),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
movslq %ecx,%rax
cmp %ecx,(%rdi,%rax,4)
je 1310 <func0+0x40>
mov %ecx,%edx
cmp %esi,%edx
jge 12e0 <func0+0x10>
lea 0x1(%rdx),%eax
retq
nopl 0x0(%rax,%rax,1)
mov %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
lea 0x1(%rcx),%esi
jmp 12d4 <func0+0x4>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
loc_12D4:
movsxd rax, esi
lea r8, [rdi+rax*4]
jmp short loc_12FB
loc_12E0:
cmp [r8], esi
jnz short loc_1308
lea eax, [rdx+rsi]
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
movsxd rax, ecx
cmp [rdi+rax*4], ecx
jz short loc_1310
mov edx, ecx
loc_12FB:
cmp edx, esi
jge short loc_12E0
lea eax, [rdx+1]
retn
loc_1308:
mov eax, esi
retn
loc_1310:
lea esi, [rcx+1]
jmp short loc_12D4 | long long func0(long long a1, int a2, int a3)
{
int v3; // ecx
while ( 1 )
{
if ( a3 < a2 )
return (unsigned int)(a3 + 1);
if ( *(_DWORD *)(a1 + 4LL * a2) != a2 )
break;
v3 = (a3 + a2) / 2;
if ( *(_DWORD *)(a1 + 4LL * v3) == v3 )
a2 = v3 + 1;
else
a3 = (a3 + a2) / 2;
}
return (unsigned int)a2;
} | func0:
ENDBR64
LAB_001012d4:
MOVSXD RAX,ESI
LEA R8,[RDI + RAX*0x4]
JMP 0x001012fb
LAB_001012e0:
CMP dword ptr [R8],ESI
JNZ 0x00101308
LEA EAX,[RDX + RSI*0x1]
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
MOVSXD RAX,ECX
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x00101310
MOV EDX,ECX
LAB_001012fb:
CMP EDX,ESI
JGE 0x001012e0
LEA EAX,[RDX + 0x1]
RET
LAB_00101308:
MOV EAX,ESI
RET
LAB_00101310:
LEA ESI,[RCX + 0x1]
JMP 0x001012d4 | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
do {
iVar1 = param_3;
do {
param_3 = iVar1;
if (param_3 < param_2) {
return param_3 + 1;
}
if (*(int *)(param_1 + (long)param_2 * 4) != param_2) {
return param_2;
}
iVar1 = (param_3 + param_2) / 2;
} while (*(int *)(param_1 + (long)iVar1 * 4) != iVar1);
param_2 = iVar1 + 1;
} while( true );
} |
6,403 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}
| int main() {
int array1[] = {0, 1, 2, 3};
int array2[] = {0, 1, 2, 6, 9};
int array3[] = {2, 3, 5, 8, 9};
assert(func0(array1, 0, 3) == 4);
assert(func0(array2, 0, 4) == 3);
assert(func0(array3, 0, 4) == 0);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
movslq %esi,%rax
lea (%rdi,%rax,4),%r8
jmp 12eb <func0+0x2b>
nopl (%rax)
cmp %esi,(%r8)
jne 12f8 <func0+0x38>
lea (%rdx,%rsi,1),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
movslq %ecx,%rax
cmp %ecx,(%rdi,%rax,4)
je 1300 <func0+0x40>
mov %ecx,%edx
cmp %esi,%edx
jge 12d0 <func0+0x10>
lea 0x1(%rdx),%eax
retq
nopl 0x0(%rax,%rax,1)
mov %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
lea 0x1(%rcx),%esi
jmp 12c4 <func0+0x4>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
loc_12C4:
movsxd rax, esi
lea r8, [rdi+rax*4]
jmp short loc_12EB
loc_12D0:
cmp [r8], esi
jnz short loc_12F8
lea eax, [rdx+rsi]
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
movsxd rax, ecx
cmp [rdi+rax*4], ecx
jz short loc_1300
mov edx, ecx
loc_12EB:
cmp edx, esi
jge short loc_12D0
lea eax, [rdx+1]
retn
loc_12F8:
mov eax, esi
retn
loc_1300:
lea esi, [rcx+1]
jmp short loc_12C4 | long long func0(long long a1, int a2, int a3)
{
int v3; // ecx
while ( 1 )
{
if ( a3 < a2 )
return (unsigned int)(a3 + 1);
if ( *(_DWORD *)(a1 + 4LL * a2) != a2 )
break;
v3 = (a3 + a2) / 2;
if ( *(_DWORD *)(a1 + 4LL * v3) == v3 )
a2 = v3 + 1;
else
a3 = (a3 + a2) / 2;
}
return (unsigned int)a2;
} | func0:
ENDBR64
LAB_001012c4:
MOVSXD RAX,ESI
LEA R8,[RDI + RAX*0x4]
JMP 0x001012eb
LAB_001012d0:
CMP dword ptr [R8],ESI
JNZ 0x001012f8
LEA EAX,[RDX + RSI*0x1]
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
MOVSXD RAX,ECX
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x00101300
MOV EDX,ECX
LAB_001012eb:
CMP EDX,ESI
JGE 0x001012d0
LEA EAX,[RDX + 0x1]
RET
LAB_001012f8:
MOV EAX,ESI
RET
LAB_00101300:
LEA ESI,[RCX + 0x1]
JMP 0x001012c4 | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
do {
iVar1 = param_3;
do {
param_3 = iVar1;
if (param_3 < param_2) {
return param_3 + 1;
}
if (*(int *)(param_1 + (long)param_2 * 4) != param_2) {
return param_2;
}
iVar1 = (param_3 + param_2) / 2;
} while (*(int *)(param_1 + (long)iVar1 * 4) != iVar1);
param_2 = iVar1 + 1;
} while( true );
} |
6,404 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#define MAX 1000
| char* func0(char* string) {
char new_string[MAX];
int i, j, space_count = 0, new_length;
char *result;
i = strlen(string);
for (j = 0; j < i; j++) {
if (string[j] == ' ')
space_count++;
}
new_length = i + space_count * 2;
if (new_length > MAX) {
return "";
}
int index = new_length - 1;
new_string[new_length] = '\0';
for (j = i - 1; j >= 0; j--) {
if (string[j] == ' ') {
new_string[index] = '0';
new_string[index - 1] = '2';
new_string[index - 2] = '%';
index -= 3;
} else {
new_string[index] = string[j];
index--;
}
}
result = (char*)malloc(new_length + 1);
strcpy(result, new_string);
return result;
}
| int main() {
assert(strcmp(func0("My Name is Dawood"), "My%20Name%20is%20Dawood") == 0);
assert(strcmp(func0("I am a Programmer"), "I%20am%20a%20Programmer") == 0);
assert(strcmp(func0("I love Coding"), "I%20love%20Coding") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x420,%rsp
mov %rdi,-0x418(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x408(%rbp)
mov -0x418(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x400(%rbp)
movl $0x0,-0x40c(%rbp)
jmp 1261 <func0+0x78>
mov -0x40c(%rbp),%eax
movslq %eax,%rdx
mov -0x418(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 125a <func0+0x71>
addl $0x1,-0x408(%rbp)
addl $0x1,-0x40c(%rbp)
mov -0x40c(%rbp),%eax
cmp -0x400(%rbp),%eax
jl 1239 <func0+0x50>
mov -0x408(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0x400(%rbp),%eax
add %edx,%eax
mov %eax,-0x3fc(%rbp)
cmpl $0x3e8,-0x3fc(%rbp)
jle 129e <func0+0xb5>
lea 0xd6f(%rip),%rax
jmpq 13a4 <func0+0x1bb>
mov -0x3fc(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x404(%rbp)
mov -0x3fc(%rbp),%eax
cltq
movb $0x0,-0x3f0(%rbp,%rax,1)
mov -0x400(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x40c(%rbp)
jmpq 135d <func0+0x174>
mov -0x40c(%rbp),%eax
movslq %eax,%rdx
mov -0x418(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 132a <func0+0x141>
mov -0x404(%rbp),%eax
cltq
movb $0x30,-0x3f0(%rbp,%rax,1)
mov -0x404(%rbp),%eax
sub $0x1,%eax
cltq
movb $0x32,-0x3f0(%rbp,%rax,1)
mov -0x404(%rbp),%eax
sub $0x2,%eax
cltq
movb $0x25,-0x3f0(%rbp,%rax,1)
subl $0x3,-0x404(%rbp)
jmp 1356 <func0+0x16d>
mov -0x40c(%rbp),%eax
movslq %eax,%rdx
mov -0x418(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x404(%rbp),%eax
cltq
mov %dl,-0x3f0(%rbp,%rax,1)
subl $0x1,-0x404(%rbp)
subl $0x1,-0x40c(%rbp)
cmpl $0x0,-0x40c(%rbp)
jns 12d1 <func0+0xe8>
mov -0x3fc(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x3f8(%rbp)
lea -0x3f0(%rbp),%rdx
mov -0x3f8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10a0 <strcpy@plt>
mov -0x3f8(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 13b8 <func0+0x1cf>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 420h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_408], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_400], eax
mov [rbp+var_40C], 0
jmp short loc_1261
loc_1239:
mov eax, [rbp+var_40C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_125A
add [rbp+var_408], 1
loc_125A:
add [rbp+var_40C], 1
loc_1261:
mov eax, [rbp+var_40C]
cmp eax, [rbp+var_400]
jl short loc_1239
mov eax, [rbp+var_408]
lea edx, [rax+rax]
mov eax, [rbp+var_400]
add eax, edx
mov [rbp+var_3FC], eax
cmp [rbp+var_3FC], 3E8h
jle short loc_129E
lea rax, unk_2008
jmp loc_13A4
loc_129E:
mov eax, [rbp+var_3FC]
sub eax, 1
mov [rbp+var_404], eax
mov eax, [rbp+var_3FC]
cdqe
mov [rbp+rax+src], 0
mov eax, [rbp+var_400]
sub eax, 1
mov [rbp+var_40C], eax
jmp loc_135D
loc_12D1:
mov eax, [rbp+var_40C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_132A
mov eax, [rbp+var_404]
cdqe
mov [rbp+rax+src], 30h ; '0'
mov eax, [rbp+var_404]
sub eax, 1
cdqe
mov [rbp+rax+src], 32h ; '2'
mov eax, [rbp+var_404]
sub eax, 2
cdqe
mov [rbp+rax+src], 25h ; '%'
sub [rbp+var_404], 3
jmp short loc_1356
loc_132A:
mov eax, [rbp+var_40C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_404]
cdqe
mov [rbp+rax+src], dl
sub [rbp+var_404], 1
loc_1356:
sub [rbp+var_40C], 1
loc_135D:
cmp [rbp+var_40C], 0
jns loc_12D1
mov eax, [rbp+var_3FC]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
lea rdx, [rbp+src]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+dest]
loc_13A4:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13B8
call ___stack_chk_fail
locret_13B8:
leave
retn | char * func0(const char *a1)
{
int i; // [rsp+14h] [rbp-40Ch]
int j; // [rsp+14h] [rbp-40Ch]
int v4; // [rsp+18h] [rbp-408h]
int v5; // [rsp+1Ch] [rbp-404h]
int v6; // [rsp+20h] [rbp-400h]
int v7; // [rsp+24h] [rbp-3FCh]
char *dest; // [rsp+28h] [rbp-3F8h]
char src[1000]; // [rsp+30h] [rbp-3F0h] BYREF
unsigned long long v10; // [rsp+418h] [rbp-8h]
v10 = __readfsqword(0x28u);
v4 = 0;
v6 = strlen(a1);
for ( i = 0; i < v6; ++i )
{
if ( a1[i] == 32 )
++v4;
}
v7 = 2 * v4 + v6;
if ( v7 > 1000 )
return (char *)&unk_2008;
v5 = v7 - 1;
src[v7] = 0;
for ( j = v6 - 1; j >= 0; --j )
{
if ( a1[j] == 32 )
{
src[v5] = 48;
src[v5 - 1] = 50;
src[v5 - 2] = 37;
v5 -= 3;
}
else
{
src[v5--] = a1[j];
}
}
dest = (char *)malloc(v7 + 1);
strcpy(dest, src);
return dest;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x420
MOV qword ptr [RBP + -0x418],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x408],0x0
MOV RAX,qword ptr [RBP + -0x418]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x400],EAX
MOV dword ptr [RBP + -0x40c],0x0
JMP 0x00101261
LAB_00101239:
MOV EAX,dword ptr [RBP + -0x40c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x418]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x0010125a
ADD dword ptr [RBP + -0x408],0x1
LAB_0010125a:
ADD dword ptr [RBP + -0x40c],0x1
LAB_00101261:
MOV EAX,dword ptr [RBP + -0x40c]
CMP EAX,dword ptr [RBP + -0x400]
JL 0x00101239
MOV EAX,dword ptr [RBP + -0x408]
LEA EDX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x400]
ADD EAX,EDX
MOV dword ptr [RBP + -0x3fc],EAX
CMP dword ptr [RBP + -0x3fc],0x3e8
JLE 0x0010129e
LEA RAX,[0x102008]
JMP 0x001013a4
LAB_0010129e:
MOV EAX,dword ptr [RBP + -0x3fc]
SUB EAX,0x1
MOV dword ptr [RBP + -0x404],EAX
MOV EAX,dword ptr [RBP + -0x3fc]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x3f0],0x0
MOV EAX,dword ptr [RBP + -0x400]
SUB EAX,0x1
MOV dword ptr [RBP + -0x40c],EAX
JMP 0x0010135d
LAB_001012d1:
MOV EAX,dword ptr [RBP + -0x40c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x418]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x0010132a
MOV EAX,dword ptr [RBP + -0x404]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x3f0],0x30
MOV EAX,dword ptr [RBP + -0x404]
SUB EAX,0x1
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x3f0],0x32
MOV EAX,dword ptr [RBP + -0x404]
SUB EAX,0x2
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x3f0],0x25
SUB dword ptr [RBP + -0x404],0x3
JMP 0x00101356
LAB_0010132a:
MOV EAX,dword ptr [RBP + -0x40c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x418]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x404]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x3f0],DL
SUB dword ptr [RBP + -0x404],0x1
LAB_00101356:
SUB dword ptr [RBP + -0x40c],0x1
LAB_0010135d:
CMP dword ptr [RBP + -0x40c],0x0
JNS 0x001012d1
MOV EAX,dword ptr [RBP + -0x3fc]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x3f8],RAX
LEA RDX,[RBP + -0x3f0]
MOV RAX,qword ptr [RBP + -0x3f8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x3f8]
LAB_001013a4:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013b8
CALL 0x001010c0
LAB_001013b8:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
int iVar2;
size_t sVar3;
char *__dest;
long in_FS_OFFSET;
int local_414;
int local_410;
int local_40c;
char local_3f8 [1000];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_410 = 0;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
for (local_414 = 0; local_414 < iVar1; local_414 = local_414 + 1) {
if (param_1[local_414] == ' ') {
local_410 = local_410 + 1;
}
}
iVar2 = iVar1 + local_410 * 2;
if (iVar2 < 0x3e9) {
local_40c = iVar2 + -1;
local_3f8[iVar2] = '\0';
local_414 = iVar1;
while (local_414 = local_414 + -1, -1 < local_414) {
if (param_1[local_414] == ' ') {
local_3f8[local_40c] = '0';
local_3f8[local_40c + -1] = '2';
local_3f8[local_40c + -2] = '%';
local_40c = local_40c + -3;
}
else {
local_3f8[local_40c] = param_1[local_414];
local_40c = local_40c + -1;
}
}
__dest = (char *)malloc((long)(iVar2 + 1));
strcpy(__dest,local_3f8);
}
else {
__dest = "";
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,405 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#define MAX 1000
| char* func0(char* string) {
char new_string[MAX];
int i, j, space_count = 0, new_length;
char *result;
i = strlen(string);
for (j = 0; j < i; j++) {
if (string[j] == ' ')
space_count++;
}
new_length = i + space_count * 2;
if (new_length > MAX) {
return "";
}
int index = new_length - 1;
new_string[new_length] = '\0';
for (j = i - 1; j >= 0; j--) {
if (string[j] == ' ') {
new_string[index] = '0';
new_string[index - 1] = '2';
new_string[index - 2] = '%';
index -= 3;
} else {
new_string[index] = string[j];
index--;
}
}
result = (char*)malloc(new_length + 1);
strcpy(result, new_string);
return result;
}
| int main() {
assert(strcmp(func0("My Name is Dawood"), "My%20Name%20is%20Dawood") == 0);
assert(strcmp(func0("I am a Programmer"), "I%20am%20a%20Programmer") == 0);
assert(strcmp(func0("I love Coding"), "I%20love%20Coding") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x3f0,%rsp
mov %rdi,%r8
mov %fs:0x28,%rax
mov %rax,0x3e8(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
test %eax,%eax
jle 122b <func0+0x82>
mov %r8,%rdx
lea -0x1(%rax),%ecx
lea 0x1(%r8,%rcx,1),%rdi
mov $0x0,%ecx
cmpb $0x20,(%rdx)
sete %sil
movzbl %sil,%esi
add %esi,%ecx
add $0x1,%rdx
cmp %rdi,%rdx
jne 11f2 <func0+0x49>
lea (%rax,%rcx,2),%edi
lea 0xe03(%rip),%rbx
cmp $0x3e8,%edi
jg 124d <func0+0xa4>
lea -0x1(%rdi),%edx
movslq %edi,%rcx
movb $0x0,(%rsp,%rcx,1)
sub $0x1,%eax
cltq
jmp 127d <func0+0xd4>
movslq %eax,%rdx
movb $0x0,(%rsp,%rdx,1)
mov %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbx
mov %rsp,%rsi
mov %rax,%rdi
callq 1080 <strcpy@plt>
mov 0x3e8(%rsp),%rax
xor %fs:0x28,%rax
jne 12a7 <func0+0xfe>
mov %rbx,%rax
add $0x3f0,%rsp
pop %rbx
retq
movslq %edx,%rsi
mov %cl,(%rsp,%rsi,1)
sub $0x1,%edx
sub $0x1,%rax
test %eax,%eax
js 1234 <func0+0x8b>
movzbl (%r8,%rax,1),%ecx
cmp $0x20,%cl
jne 126c <func0+0xc3>
movslq %edx,%rcx
movb $0x30,(%rsp,%rcx,1)
lea -0x1(%rdx),%ecx
movslq %ecx,%rcx
movb $0x32,(%rsp,%rcx,1)
lea -0x2(%rdx),%ecx
movslq %ecx,%rcx
movb $0x25,(%rsp,%rcx,1)
sub $0x3,%edx
jmp 1275 <func0+0xcc>
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 3F8h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+408h+var_20], rax
xor eax, eax
call _strlen
test eax, eax
jle short loc_125E
mov rdx, rbx
lea ecx, [rax-1]
lea rdi, [rbx+rcx+1]
mov ecx, 0
loc_1225:
cmp byte ptr [rdx], 20h ; ' '
setz sil
movzx esi, sil
add ecx, esi
add rdx, 1
cmp rdx, rdi
jnz short loc_1225
lea edi, [rax+rcx*2]
lea rbp, aTmpTmpcdmuvpg1+1Ch; ""
cmp edi, 3E8h
jg short loc_1280
lea edx, [rdi-1]
movsxd rcx, edi
mov [rsp+rcx+408h+var_408], 0
sub eax, 1
cdqe
jmp short loc_12C6
loc_125E:
movsxd rdx, eax
mov [rsp+rdx+408h+var_408], 0
mov edi, eax
loc_1267:
add edi, 1
movsxd rdi, edi
call _malloc
mov rbp, rax
mov rsi, rsp
mov rdi, rax
call _strcpy
loc_1280:
mov rax, [rsp+408h+var_20]
sub rax, fs:28h
jnz short loc_12DA
mov rax, rbp
add rsp, 3F8h
pop rbx
pop rbp
retn
loc_12A0:
movsxd rcx, edx
mov [rsp+rcx+408h+var_408], 30h ; '0'
lea ecx, [rdx-1]
movsxd rcx, ecx
mov [rsp+rcx+408h+var_408], 32h ; '2'
lea ecx, [rdx-2]
movsxd rcx, ecx
mov [rsp+rcx+408h+var_408], 25h ; '%'
sub edx, 3
loc_12BE:
sub rax, 1
test eax, eax
js short loc_1267
loc_12C6:
movzx ecx, byte ptr [rbx+rax]
cmp cl, 20h ; ' '
jz short loc_12A0
movsxd rsi, edx
mov [rsp+rsi+408h+var_408], cl
sub edx, 1
jmp short loc_12BE
loc_12DA:
call ___stack_chk_fail | char * func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rdx
long long v4; // rdi
int v5; // ecx
int v6; // edi
char *v7; // rbp
int v8; // edx
long long v9; // rax
char v11; // cl
_BYTE v12[1000]; // [rsp+0h] [rbp-408h] BYREF
unsigned long long v13; // [rsp+3E8h] [rbp-20h]
v13 = __readfsqword(0x28u);
v2 = strlen();
if ( v2 <= 0 )
{
v12[v2] = 0;
v6 = v2;
LABEL_7:
v7 = (char *)malloc(v6 + 1);
strcpy(v7, v12);
return v7;
}
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
v5 += *v3++ == 32;
while ( v3 != (_BYTE *)v4 );
v6 = v2 + 2 * v5;
v7 = "";
if ( v6 <= 1000 )
{
v8 = v6 - 1;
v12[v6] = 0;
v9 = v2 - 1;
do
{
v11 = a1[v9];
if ( v11 == 32 )
{
v12[v8] = 48;
v12[v8 - 1] = 50;
v12[v8 - 2] = 37;
v8 -= 3;
}
else
{
v12[v8--] = v11;
}
--v9;
}
while ( (int)v9 >= 0 );
goto LABEL_7;
}
return v7;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x3f8
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3e8],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST EAX,EAX
JLE 0x0010125e
MOV RDX,RBX
LEA ECX,[RAX + -0x1]
LEA RDI,[RBX + RCX*0x1 + 0x1]
MOV ECX,0x0
LAB_00101225:
CMP byte ptr [RDX],0x20
SETZ SIL
MOVZX ESI,SIL
ADD ECX,ESI
ADD RDX,0x1
CMP RDX,RDI
JNZ 0x00101225
LEA EDI,[RAX + RCX*0x2]
LEA RBP,[0x10204a]
CMP EDI,0x3e8
JG 0x00101280
LEA EDX,[RDI + -0x1]
MOVSXD RCX,EDI
MOV byte ptr [RSP + RCX*0x1],0x0
SUB EAX,0x1
CDQE
JMP 0x001012c6
LAB_0010125e:
MOVSXD RDX,EAX
MOV byte ptr [RSP + RDX*0x1],0x0
MOV EDI,EAX
LAB_00101267:
ADD EDI,0x1
MOVSXD RDI,EDI
CALL 0x001010f0
MOV RBP,RAX
MOV RSI,RSP
MOV RDI,RAX
CALL 0x001010a0
LAB_00101280:
MOV RAX,qword ptr [RSP + 0x3e8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012da
MOV RAX,RBP
ADD RSP,0x3f8
POP RBX
POP RBP
RET
LAB_001012a0:
MOVSXD RCX,EDX
MOV byte ptr [RSP + RCX*0x1],0x30
LEA ECX,[RDX + -0x1]
MOVSXD RCX,ECX
MOV byte ptr [RSP + RCX*0x1],0x32
LEA ECX,[RDX + -0x2]
MOVSXD RCX,ECX
MOV byte ptr [RSP + RCX*0x1],0x25
SUB EDX,0x3
LAB_001012be:
SUB RAX,0x1
TEST EAX,EAX
JS 0x00101267
LAB_001012c6:
MOVZX ECX,byte ptr [RBX + RAX*0x1]
CMP CL,0x20
JZ 0x001012a0
MOVSXD RSI,EDX
MOV byte ptr [RSP + RSI*0x1],CL
SUB EDX,0x1
JMP 0x001012be
LAB_001012da:
CALL 0x001010c0 | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
int iVar4;
int iVar5;
char *pcVar6;
long in_FS_OFFSET;
char acStack_408 [1000];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
acStack_408[iVar1] = '\0';
}
else {
iVar4 = 0;
pcVar6 = param_1;
do {
iVar4 = iVar4 + (uint)(*pcVar6 == ' ');
pcVar6 = pcVar6 + 1;
} while (pcVar6 != param_1 + (ulong)(iVar1 - 1) + 1);
iVar4 = iVar1 + iVar4 * 2;
pcVar6 = "";
if (1000 < iVar4) goto LAB_00101280;
iVar5 = iVar4 + -1;
acStack_408[iVar4] = '\0';
lVar3 = (long)(iVar1 + -1);
do {
if (param_1[lVar3] == ' ') {
acStack_408[iVar5] = '0';
acStack_408[iVar5 + -1] = '2';
acStack_408[iVar5 + -2] = '%';
iVar5 = iVar5 + -3;
}
else {
acStack_408[iVar5] = param_1[lVar3];
iVar5 = iVar5 + -1;
}
lVar3 = lVar3 + -1;
iVar1 = iVar4;
} while (-1 < (int)lVar3);
}
pcVar6 = (char *)malloc((long)(iVar1 + 1));
strcpy(pcVar6,acStack_408);
LAB_00101280:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,406 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#define MAX 1000
| char* func0(char* string) {
char new_string[MAX];
int i, j, space_count = 0, new_length;
char *result;
i = strlen(string);
for (j = 0; j < i; j++) {
if (string[j] == ' ')
space_count++;
}
new_length = i + space_count * 2;
if (new_length > MAX) {
return "";
}
int index = new_length - 1;
new_string[new_length] = '\0';
for (j = i - 1; j >= 0; j--) {
if (string[j] == ' ') {
new_string[index] = '0';
new_string[index - 1] = '2';
new_string[index - 2] = '%';
index -= 3;
} else {
new_string[index] = string[j];
index--;
}
}
result = (char*)malloc(new_length + 1);
strcpy(result, new_string);
return result;
}
| int main() {
assert(strcmp(func0("My Name is Dawood"), "My%20Name%20is%20Dawood") == 0);
assert(strcmp(func0("I am a Programmer"), "I%20am%20a%20Programmer") == 0);
assert(strcmp(func0("I love Coding"), "I%20love%20Coding") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
sub $0x3f0,%rsp
mov %fs:0x28,%rax
mov %rax,0x3e8(%rsp)
xor %eax,%eax
callq 10a0 <strlen@plt>
test %eax,%eax
jle 13b0 <func0+0x100>
lea -0x1(%rax),%esi
mov %rbx,%rdx
mov %rsi,%rcx
lea 0x1(%rbx,%rsi,1),%rdi
xor %esi,%esi
xor %r8d,%r8d
cmpb $0x20,(%rdx)
sete %r8b
add $0x1,%rdx
add %r8d,%esi
cmp %rdx,%rdi
jne 12f0 <func0+0x40>
lea (%rax,%rsi,2),%r8d
lea 0xd04(%rip),%r9
cmp $0x3e8,%r8d
jg 138a <func0+0xda>
movslq %r8d,%rdx
lea -0x1(%r8),%eax
movb $0x0,(%rsp,%rdx,1)
movslq %ecx,%rdx
jmp 1340 <func0+0x90>
nopw 0x0(%rax,%rax,1)
cltq
sub $0x1,%rdx
mov %sil,(%rsp,%rax,1)
mov %ecx,%eax
test %edx,%edx
js 1370 <func0+0xc0>
movzbl (%rbx,%rdx,1),%esi
lea -0x1(%rax),%ecx
cmp $0x20,%sil
jne 1330 <func0+0x80>
movslq %eax,%rsi
movslq %ecx,%rcx
sub $0x1,%rdx
movb $0x30,(%rsp,%rsi,1)
movb $0x32,(%rsp,%rcx,1)
lea -0x2(%rax),%ecx
sub $0x3,%eax
movslq %ecx,%rcx
movb $0x25,(%rsp,%rcx,1)
test %edx,%edx
jns 1340 <func0+0x90>
lea 0x1(%r8),%eax
movslq %eax,%rdi
callq 10d0 <malloc@plt>
mov %rsp,%rsi
mov %rax,%rdi
callq 1090 <strcpy@plt>
mov %rax,%r9
mov 0x3e8(%rsp),%rax
xor %fs:0x28,%rax
jne 13bc <func0+0x10c>
add $0x3f0,%rsp
mov %r9,%rax
pop %rbx
retq
nopl 0x0(%rax)
movslq %eax,%rdx
mov %eax,%r8d
movb $0x0,(%rsp,%rdx,1)
jmp 1370 <func0+0xc0>
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
sub rsp, 3F0h
mov rax, fs:28h
mov [rsp+3F8h+var_10], rax
xor eax, eax
call _strlen
test eax, eax
jle loc_13B8
lea esi, [rax-1]
mov rdx, rbx
mov rcx, rsi
lea r8, [rbx+rsi+1]
xor esi, esi
nop
loc_1300:
xor edi, edi
cmp byte ptr [rdx], 20h ; ' '
setz dil
add rdx, 1
add esi, edi
cmp rdx, r8
jnz short loc_1300
lea eax, [rax+rsi*2]
lea r8, aTmpTmpo3z5abbe+1Ch; ""
cmp eax, 3E8h
jg short loc_1393
movsxd rsi, eax
lea edx, [rax-1]
movsxd rcx, ecx
mov [rsp+rsi+3F8h+var_3F8], 0
jmp short loc_1349
loc_1338:
movsxd rdx, edx
sub rcx, 1
mov [rsp+rdx+3F8h+var_3F8], r8b
mov edx, esi
test ecx, ecx
js short loc_137A
loc_1349:
movzx r8d, byte ptr [rbx+rcx]
lea esi, [rdx-1]
cmp r8b, 20h ; ' '
jnz short loc_1338
movsxd rdi, edx
movsxd rsi, esi
sub rcx, 1
mov [rsp+rdi+3F8h+var_3F8], 30h ; '0'
mov [rsp+rsi+3F8h+var_3F8], 32h ; '2'
lea esi, [rdx-2]
sub edx, 3
movsxd rsi, esi
mov [rsp+rsi+3F8h+var_3F8], 25h ; '%'
test ecx, ecx
jns short loc_1349
loc_137A:
add eax, 1
movsxd rdi, eax
call _malloc
mov rsi, rsp
mov rdi, rax
call _strcpy
mov r8, rax
loc_1393:
mov rax, [rsp+3F8h+var_10]
sub rax, fs:28h
jnz short loc_13C1
add rsp, 3F0h
mov rax, r8
pop rbx
retn
loc_13B8:
movsxd rdx, eax
mov [rsp+rdx+3F8h+var_3F8], 0
jmp short loc_137A
loc_13C1:
call ___stack_chk_fail | long long func0(_BYTE *a1, long long a2)
{
int v3; // eax
_BYTE *v4; // rdx
long long v5; // rcx
long long v6; // r8
int v7; // esi
int v8; // edi
char *v9; // r8
long long v10; // rdx
char v11; // r8
long long v12; // rax
_BYTE v14[1000]; // [rsp+0h] [rbp-3F8h] BYREF
unsigned long long v15; // [rsp+3E8h] [rbp-10h]
v15 = __readfsqword(0x28u);
v3 = strlen();
if ( v3 <= 0 )
{
v10 = v3;
v14[v3] = 0;
LABEL_9:
v12 = malloc(v3 + 1, a2, v10);
return strcpy(v12, v14);
}
v4 = a1;
v5 = (unsigned int)(v3 - 1);
v6 = (long long)&a1[v5 + 1];
v7 = 0;
do
{
v8 = *v4++ == 32;
v7 += v8;
}
while ( v4 != (_BYTE *)v6 );
v3 += 2 * v7;
v9 = "";
if ( v3 <= 1000 )
{
LODWORD(v10) = v3 - 1;
v5 = (int)v5;
v14[v3] = 0;
do
{
while ( 1 )
{
v11 = a1[v5];
a2 = (unsigned int)(v10 - 1);
if ( v11 == 32 )
break;
--v5;
v14[(int)v10] = v11;
v10 = (unsigned int)a2;
if ( (int)v5 < 0 )
goto LABEL_9;
}
--v5;
v14[(int)v10] = 48;
v14[(int)a2] = 50;
LODWORD(a2) = v10 - 2;
v10 = (unsigned int)(v10 - 3);
a2 = (int)a2;
v14[(int)a2] = 37;
}
while ( (int)v5 >= 0 );
goto LABEL_9;
}
return (long long)v9;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
SUB RSP,0x3f0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3e8],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST EAX,EAX
JLE 0x001013b8
LEA ESI,[RAX + -0x1]
MOV RDX,RBX
MOV RCX,RSI
LEA R8,[RBX + RSI*0x1 + 0x1]
XOR ESI,ESI
NOP
LAB_00101300:
XOR EDI,EDI
CMP byte ptr [RDX],0x20
SETZ DIL
ADD RDX,0x1
ADD ESI,EDI
CMP RDX,R8
JNZ 0x00101300
LEA EAX,[RAX + RSI*0x2]
LEA R8,[0x10204a]
CMP EAX,0x3e8
JG 0x00101393
MOVSXD RSI,EAX
LEA EDX,[RAX + -0x1]
MOVSXD RCX,ECX
MOV byte ptr [RSP + RSI*0x1],0x0
JMP 0x00101349
LAB_00101338:
MOVSXD RDX,EDX
SUB RCX,0x1
MOV byte ptr [RSP + RDX*0x1],R8B
MOV EDX,ESI
TEST ECX,ECX
JS 0x0010137a
LAB_00101349:
MOVZX R8D,byte ptr [RBX + RCX*0x1]
LEA ESI,[RDX + -0x1]
CMP R8B,0x20
JNZ 0x00101338
MOVSXD RDI,EDX
MOVSXD RSI,ESI
SUB RCX,0x1
MOV byte ptr [RSP + RDI*0x1],0x30
MOV byte ptr [RSP + RSI*0x1],0x32
LEA ESI,[RDX + -0x2]
SUB EDX,0x3
MOVSXD RSI,ESI
MOV byte ptr [RSP + RSI*0x1],0x25
TEST ECX,ECX
JNS 0x00101349
LAB_0010137a:
ADD EAX,0x1
MOVSXD RDI,EAX
CALL 0x001010f0
MOV RSI,RSP
MOV RDI,RAX
CALL 0x001010a0
MOV R8,RAX
LAB_00101393:
MOV RAX,qword ptr [RSP + 0x3e8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013c1
ADD RSP,0x3f0
MOV RAX,R8
POP RBX
RET
LAB_001013b8:
MOVSXD RDX,EAX
MOV byte ptr [RSP + RDX*0x1],0x0
JMP 0x0010137a
LAB_001013c1:
CALL 0x001010c0 | char * func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
long lVar4;
char *pcVar5;
uint uVar6;
int iVar7;
long in_FS_OFFSET;
char acStack_3f8 [1000];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (iVar2 < 1) {
acStack_3f8[iVar2] = '\0';
}
else {
uVar6 = iVar2 - 1;
iVar7 = 0;
pcVar5 = param_1;
do {
cVar1 = *pcVar5;
pcVar5 = pcVar5 + 1;
iVar7 = iVar7 + (uint)(cVar1 == ' ');
} while (pcVar5 != param_1 + (ulong)uVar6 + 1);
iVar2 = iVar2 + iVar7 * 2;
pcVar5 = "";
if (1000 < iVar2) goto LAB_00101393;
lVar4 = (long)(int)uVar6;
acStack_3f8[iVar2] = '\0';
iVar7 = iVar2 + -1;
do {
while( true ) {
pcVar5 = param_1 + lVar4;
if (*pcVar5 != ' ') break;
lVar4 = lVar4 + -1;
acStack_3f8[iVar7] = '0';
acStack_3f8[iVar7 + -1] = '2';
acStack_3f8[iVar7 + -2] = '%';
iVar7 = iVar7 + -3;
if ((int)lVar4 < 0) goto LAB_0010137a;
}
lVar4 = lVar4 + -1;
acStack_3f8[iVar7] = *pcVar5;
iVar7 = iVar7 + -1;
} while (-1 < (int)lVar4);
}
LAB_0010137a:
pcVar5 = (char *)malloc((long)(iVar2 + 1));
pcVar5 = strcpy(pcVar5,acStack_3f8);
LAB_00101393:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,407 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#define MAX 1000
| char* func0(char* string) {
char new_string[MAX];
int i, j, space_count = 0, new_length;
char *result;
i = strlen(string);
for (j = 0; j < i; j++) {
if (string[j] == ' ')
space_count++;
}
new_length = i + space_count * 2;
if (new_length > MAX) {
return "";
}
int index = new_length - 1;
new_string[new_length] = '\0';
for (j = i - 1; j >= 0; j--) {
if (string[j] == ' ') {
new_string[index] = '0';
new_string[index - 1] = '2';
new_string[index - 2] = '%';
index -= 3;
} else {
new_string[index] = string[j];
index--;
}
}
result = (char*)malloc(new_length + 1);
strcpy(result, new_string);
return result;
}
| int main() {
assert(strcmp(func0("My Name is Dawood"), "My%20Name%20is%20Dawood") == 0);
assert(strcmp(func0("I am a Programmer"), "I%20am%20a%20Programmer") == 0);
assert(strcmp(func0("I love Coding"), "I%20love%20Coding") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
sub $0x3f0,%rsp
mov %fs:0x28,%rax
mov %rax,0x3e8(%rsp)
xor %eax,%eax
callq 10a0 <strlen@plt>
test %eax,%eax
jle 15e8 <func0+0x338>
lea -0x1(%rax),%ecx
cmp $0xe,%ecx
jbe 15d8 <func0+0x328>
mov %eax,%esi
pxor %xmm1,%xmm1
pxor %xmm5,%xmm5
mov %rbx,%rdx
shr $0x4,%esi
movdqa 0xe8d(%rip),%xmm7
movdqa 0xe95(%rip),%xmm6
pxor %xmm4,%xmm4
shl $0x4,%rsi
add %rbx,%rsi
nopw %cs:0x0(%rax,%rax,1)
movdqu (%rdx),%xmm0
movdqa %xmm5,%xmm3
add $0x10,%rdx
pcmpeqb %xmm7,%xmm0
pand %xmm6,%xmm0
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
punpckhbw %xmm3,%xmm0
movdqa %xmm4,%xmm3
pcmpgtw %xmm2,%xmm3
movdqa %xmm2,%xmm8
punpcklwd %xmm3,%xmm8
punpckhwd %xmm3,%xmm2
movdqa %xmm0,%xmm3
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm4,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm3
punpckhwd %xmm2,%xmm0
paddd %xmm3,%xmm1
paddd %xmm0,%xmm1
cmp %rsi,%rdx
jne 1320 <func0+0x70>
movdqa %xmm1,%xmm0
mov %eax,%esi
psrldq $0x8,%xmm0
and $0xfffffff0,%esi
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%edx
test $0xf,%al
je 1538 <func0+0x288>
movslq %esi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x1(%rsi),%edi
cmp %eax,%edi
jge 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x2(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x3(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x4(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x5(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x6(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x7(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x8(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0x9(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0xa(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0xb(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0xc(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%edx
lea 0xd(%rsi),%edi
cmp %edi,%eax
jle 1538 <func0+0x288>
movslq %edi,%rdi
cmpb $0x20,(%rbx,%rdi,1)
sete %dil
add $0xe,%esi
movzbl %dil,%edi
add %edi,%edx
cmp %esi,%eax
jle 1538 <func0+0x288>
movslq %esi,%rsi
cmpb $0x20,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%edx
nopl 0x0(%rax)
lea (%rax,%rdx,2),%esi
lea 0xad3(%rip),%r8
cmp $0x3e8,%esi
jg 15b9 <func0+0x309>
movslq %esi,%rdx
lea -0x1(%rsi),%eax
movb $0x0,(%rsp,%rdx,1)
movslq %ecx,%rdx
jmp 1570 <func0+0x2c0>
nopl 0x0(%rax)
cltq
sub $0x1,%rdx
mov %dil,(%rsp,%rax,1)
mov %ecx,%eax
test %edx,%edx
js 15a0 <func0+0x2f0>
movzbl (%rbx,%rdx,1),%edi
lea -0x1(%rax),%ecx
cmp $0x20,%dil
jne 1560 <func0+0x2b0>
movslq %eax,%rdi
movslq %ecx,%rcx
sub $0x1,%rdx
movb $0x30,(%rsp,%rdi,1)
movb $0x32,(%rsp,%rcx,1)
lea -0x2(%rax),%ecx
sub $0x3,%eax
movslq %ecx,%rcx
movb $0x25,(%rsp,%rcx,1)
test %edx,%edx
jns 1570 <func0+0x2c0>
lea 0x1(%rsi),%eax
movslq %eax,%rdi
callq 10d0 <malloc@plt>
mov %rsp,%rsi
mov %rax,%rdi
callq 1090 <strcpy@plt>
mov %rax,%r8
mov 0x3e8(%rsp),%rax
xor %fs:0x28,%rax
jne 15f3 <func0+0x343>
add $0x3f0,%rsp
mov %r8,%rax
pop %rbx
retq
xor %edx,%edx
xor %esi,%esi
jmpq 13af <func0+0xff>
nopl 0x0(%rax)
movslq %eax,%rdx
mov %eax,%esi
movb $0x0,(%rsp,%rdx,1)
jmp 15a0 <func0+0x2f0>
callq 10b0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 3F8h
mov rax, fs:28h
mov [rsp+408h+var_20], rax
xor eax, eax
call _strlen
mov rsi, rax
test eax, eax
jle loc_1578
lea edi, [rax-1]
cmp edi, 0Eh
jbe loc_1620
mov edx, esi
pxor xmm1, xmm1
pxor xmm5, xmm5
mov rax, rbx
shr edx, 4
movdqa xmm6, cs:xmmword_2170
pxor xmm4, xmm4
shl rdx, 4
add rdx, rbx
nop word ptr [rax+rax+00h]
loc_1328:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm3, xmm5
add rax, 10h
pcmpeqb xmm0, xmm6
pcmpgtb xmm3, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm3
punpckhbw xmm0, xmm3
movdqa xmm3, xmm4
pcmpgtw xmm3, xmm2
movdqa xmm7, xmm2
punpcklwd xmm7, xmm3
punpckhwd xmm2, xmm3
movdqa xmm3, xmm0
psubd xmm1, xmm7
psubd xmm1, xmm2
movdqa xmm2, xmm4
pcmpgtw xmm2, xmm0
punpcklwd xmm3, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm3
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_1328
movdqa xmm0, xmm1
mov r8d, esi
psrldq xmm0, 8
and r8d, 0FFFFFFF0h
paddd xmm0, xmm1
mov edx, r8d
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
test sil, 0Fh
jz loc_14EB
loc_13C4:
mov ecx, esi
sub ecx, r8d
lea r9d, [rcx-1]
cmp r9d, 6
jbe loc_1468
movq xmm2, qword ptr cs:xmmword_2170
movq xmm1, qword ptr [rbx+r8]
pcmpeqb xmm1, xmm2
pxor xmm2, xmm2
pcmpgtb xmm2, xmm1
movdqa xmm3, xmm1
punpcklbw xmm3, xmm2
punpcklbw xmm1, xmm2
pxor xmm2, xmm2
movdqa xmm4, xmm2
movdqa xmm5, xmm3
pshufd xmm1, xmm1, 4Eh ; 'N'
pcmpgtw xmm4, xmm3
pcmpgtw xmm2, xmm1
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
psubd xmm0, xmm5
pshufd xmm3, xmm3, 4Eh ; 'N'
psubd xmm0, xmm3
movdqa xmm3, xmm1
punpcklwd xmm1, xmm2
punpcklwd xmm3, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm3
psubd xmm0, xmm1
movd r8d, xmm0
pshufd xmm6, xmm0, 0E5h
movd eax, xmm6
add eax, r8d
mov r8d, ecx
and r8d, 0FFFFFFF8h
add edx, r8d
and ecx, 7
jz loc_14EB
loc_1468:
movsxd rcx, edx
cmp byte ptr [rbx+rcx], 20h ; ' '
jz loc_15D0
loc_1475:
lea ecx, [rdx+1]
cmp esi, ecx
jle short loc_14EB
movsxd rcx, ecx
cmp byte ptr [rbx+rcx], 20h ; ' '
jz loc_15E0
loc_1489:
lea ecx, [rdx+2]
cmp ecx, esi
jge short loc_14EB
movsxd rcx, ecx
cmp byte ptr [rbx+rcx], 20h ; ' '
jz loc_15F0
loc_149D:
lea ecx, [rdx+3]
cmp esi, ecx
jle short loc_14EB
movsxd rcx, ecx
cmp byte ptr [rbx+rcx], 20h ; ' '
jz loc_1600
lea ecx, [rdx+4]
cmp esi, ecx
jle short loc_14EB
loc_14B8:
movsxd rcx, ecx
cmp byte ptr [rbx+rcx], 20h ; ' '
jnz short loc_14C4
add eax, 1
loc_14C4:
lea ecx, [rdx+5]
cmp esi, ecx
jle short loc_14EB
movsxd rcx, ecx
cmp byte ptr [rbx+rcx], 20h ; ' '
jnz short loc_14D7
add eax, 1
loc_14D7:
add edx, 6
cmp esi, edx
jle short loc_14EB
movsxd rdx, edx
cmp byte ptr [rbx+rdx], 20h ; ' '
jz loc_1618
loc_14EB:
lea edx, [rsi+rax*2]
lea rcx, file+1Dh; ""
cmp edx, 3E8h
jg loc_15A7
movsxd rax, edx
movsxd rsi, esi
lea ecx, [rdx-1]
mov rbp, rsp
mov [rsp+rax+408h+var_408], 0
lea r8, [rbx+rsi-2]
movsxd rax, edi
mov edi, edi
movzx r9d, cs:word_2180
add rax, rbx
sub r8, rdi
loc_1529:
movzx esi, byte ptr [rax]
cmp sil, 20h ; ' '
jz short loc_154E
loc_1532:
movsxd rdi, ecx
sub rax, 1
mov [rsp+rdi+408h+var_408], sil
cmp rax, r8
jz short loc_1588
movzx esi, byte ptr [rax]
sub ecx, 1
cmp sil, 20h ; ' '
jnz short loc_1532
loc_154E:
lea esi, [rcx-2]
sub rax, 1
movsxd rsi, esi
mov [rbp+rsi+0], r9w
lea esi, [rcx-3]
movsxd rcx, ecx
mov [rsp+rcx+408h+var_408], 30h ; '0'
cmp rax, r8
jz short loc_1588
mov ecx, esi
jmp short loc_1529
loc_1578:
cdqe
mov edx, esi
mov rbp, rsp
mov [rsp+rax+408h+var_408], 0
nop dword ptr [rax+rax+00h]
loc_1588:
lea ebx, [rdx+1]
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rdx, rbx
mov rsi, rbp
mov rdi, rax
call ___strcpy_chk
mov rcx, rax
loc_15A7:
mov rax, [rsp+408h+var_20]
sub rax, fs:28h
jnz short loc_1630
add rsp, 3F8h
mov rax, rcx
pop rbx
pop rbp
retn
loc_15D0:
add eax, 1
jmp loc_1475
loc_15E0:
add eax, 1
jmp loc_1489
loc_15F0:
add eax, 1
jmp loc_149D
loc_1600:
lea ecx, [rdx+4]
add eax, 1
cmp esi, ecx
jg loc_14B8
jmp loc_14EB
loc_1618:
add eax, 1
jmp loc_14EB
loc_1620:
pxor xmm0, xmm0
xor r8d, r8d
xor eax, eax
xor edx, edx
jmp loc_13C4
loc_1630:
call ___stack_chk_fail | long long func0(const char *a1, __m128i a2)
{
int v3; // eax
int v4; // esi
int v5; // edi
__m128i v6; // xmm1
const __m128i *v7; // rax
__m128i si128; // xmm6
__m128i v9; // xmm0
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; // xmm3
__m128i v15; // xmm1
__m128i v16; // xmm2
long long v17; // r8
__m128i v18; // xmm0
signed int v19; // edx
int v20; // eax
int v21; // ecx
__m128i v22; // xmm1
__m128i v23; // xmm3
__m128i v24; // xmm1
__m128i v25; // xmm3
__m128i v26; // xmm0
__m128i v27; // xmm3
int v28; // ecx
int v29; // edx
int v30; // edx
const char *v31; // rcx
int v32; // ecx
const char *v33; // rax
long long v34; // r8
char v35; // si
size_t v36; // rbx
void *v37; // rax
_BYTE v39[1000]; // [rsp+0h] [rbp-408h] BYREF
unsigned long long v40; // [rsp+3E8h] [rbp-20h]
v40 = __readfsqword(0x28u);
v3 = strlen(a1);
v4 = v3;
if ( v3 <= 0 )
{
v30 = v3;
v39[v3] = 0;
LABEL_35:
v36 = v30 + 1;
v37 = malloc(v36);
return __strcpy_chk(v37, v39, v36, *(double *)a2.m128i_i64);
}
v5 = v3 - 1;
if ( (unsigned int)(v3 - 1) <= 0xE )
{
a2 = 0LL;
v17 = 0LL;
v20 = 0;
v19 = 0;
}
else
{
v6 = 0LL;
v7 = (const __m128i *)a1;
si128 = _mm_load_si128((const __m128i *)&xmmword_2170);
do
{
v9 = _mm_loadu_si128(v7++);
v10 = _mm_cmpeq_epi8(v9, si128);
v11 = _mm_cmpgt_epi8((__m128i)0LL, v10);
v12 = _mm_unpacklo_epi8(v10, v11);
v13 = _mm_unpackhi_epi8(v10, v11);
v14 = _mm_cmpgt_epi16((__m128i)0LL, v12);
v15 = _mm_sub_epi32(_mm_sub_epi32(v6, _mm_unpacklo_epi16(v12, v14)), _mm_unpackhi_epi16(v12, v14));
v16 = _mm_cmpgt_epi16((__m128i)0LL, v13);
v6 = _mm_sub_epi32(_mm_sub_epi32(v15, _mm_unpacklo_epi16(v13, v16)), _mm_unpackhi_epi16(v13, v16));
}
while ( v7 != (const __m128i *)&a1[16 * ((unsigned int)v4 >> 4)] );
v17 = v4 & 0xFFFFFFF0;
v18 = _mm_add_epi32(_mm_srli_si128(v6, 8), v6);
v19 = v4 & 0xFFFFFFF0;
v20 = _mm_cvtsi128_si32(_mm_add_epi32(v18, _mm_srli_si128(v18, 4)));
a2 = _mm_add_epi32(v6, _mm_srli_si128(v6, 8));
if ( (v4 & 0xF) == 0 )
goto LABEL_27;
}
v21 = v4 - v17;
if ( (unsigned int)(v4 - v17 - 1) <= 6 )
goto LABEL_16;
v22 = _mm_cmpeq_epi8(_mm_loadl_epi64((const __m128i *)&a1[v17]), _mm_loadl_epi64((const __m128i *)&xmmword_2170));
v23 = _mm_unpacklo_epi8(v22, _mm_cmpgt_epi8((__m128i)0LL, v22));
v24 = _mm_shuffle_epi32(v23, 78);
v25 = _mm_unpacklo_epi16(v23, _mm_cmpgt_epi16((__m128i)0LL, v23));
v26 = _mm_sub_epi32(_mm_sub_epi32(a2, v25), _mm_shuffle_epi32(v25, 78));
v27 = _mm_unpacklo_epi16(v24, _mm_cmpgt_epi16((__m128i)0LL, v24));
a2 = _mm_sub_epi32(_mm_sub_epi32(v26, v27), _mm_shuffle_epi32(v27, 78));
v20 = _mm_cvtsi128_si32(a2) + _mm_cvtsi128_si32(_mm_shuffle_epi32(a2, 229));
v19 += v21 & 0xFFFFFFF8;
if ( (v21 & 7) != 0 )
{
LABEL_16:
if ( a1[v19] == 32 )
++v20;
if ( v4 > v19 + 1 )
{
if ( a1[v19 + 1] == 32 )
++v20;
if ( v19 + 2 < v4 )
{
if ( a1[v19 + 2] == 32 )
++v20;
if ( v4 > v19 + 3 )
{
if ( a1[v19 + 3] == 32 )
{
v28 = v19 + 4;
++v20;
if ( v4 <= v19 + 4 )
goto LABEL_27;
}
else
{
v28 = v19 + 4;
if ( v4 <= v19 + 4 )
goto LABEL_27;
}
if ( a1[v28] == 32 )
++v20;
if ( v4 > v19 + 5 )
{
if ( a1[v19 + 5] == 32 )
++v20;
v29 = v19 + 6;
if ( v4 > v29 && a1[v29] == 32 )
++v20;
}
}
}
}
}
LABEL_27:
v30 = v4 + 2 * v20;
v31 = "";
if ( v30 <= 1000 )
{
v32 = v30 - 1;
v39[v30] = 0;
v33 = &a1[v5];
v34 = (long long)&a1[v4 - 2 - v5];
while ( 1 )
{
v35 = *v33;
if ( *v33 != 32 )
break;
LABEL_32:
--v33;
*(_WORD *)&v39[v32 - 2] = 12837;
v39[v32] = 48;
if ( v33 == (const char *)v34 )
goto LABEL_35;
v32 -= 3;
}
while ( 1 )
{
--v33;
v39[v32] = v35;
if ( v33 == (const char *)v34 )
goto LABEL_35;
v35 = *v33;
--v32;
if ( *v33 == 32 )
goto LABEL_32;
}
}
return (long long)v31;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x3f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3e8],RAX
XOR EAX,EAX
CALL 0x001010a0
MOV RSI,RAX
TEST EAX,EAX
JLE 0x00101578
LEA EDI,[RAX + -0x1]
CMP EDI,0xe
JBE 0x00101620
MOV EDX,ESI
PXOR XMM1,XMM1
PXOR XMM5,XMM5
MOV RAX,RBX
SHR EDX,0x4
MOVDQA XMM6,xmmword ptr [0x00102170]
PXOR XMM4,XMM4
SHL RDX,0x4
ADD RDX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101328:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM3,XMM5
ADD RAX,0x10
PCMPEQB XMM0,XMM6
PCMPGTB XMM3,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM3
PUNPCKHBW XMM0,XMM3
MOVDQA XMM3,XMM4
PCMPGTW XMM3,XMM2
MOVDQA XMM7,XMM2
PUNPCKLWD XMM7,XMM3
PUNPCKHWD XMM2,XMM3
MOVDQA XMM3,XMM0
PSUBD XMM1,XMM7
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM4
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM3,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x00101328
MOVDQA XMM0,XMM1
MOV R8D,ESI
PSRLDQ XMM0,0x8
AND R8D,0xfffffff0
PADDD XMM0,XMM1
MOV EDX,R8D
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
TEST SIL,0xf
JZ 0x001014eb
LAB_001013c4:
MOV ECX,ESI
SUB ECX,R8D
LEA R9D,[RCX + -0x1]
CMP R9D,0x6
JBE 0x00101468
MOVQ XMM2,qword ptr [0x00102170]
MOVQ XMM1,qword ptr [RBX + R8*0x1]
PCMPEQB XMM1,XMM2
PXOR XMM2,XMM2
PCMPGTB XMM2,XMM1
MOVDQA XMM3,XMM1
PUNPCKLBW XMM3,XMM2
PUNPCKLBW XMM1,XMM2
PXOR XMM2,XMM2
MOVDQA XMM4,XMM2
MOVDQA XMM5,XMM3
PSHUFD XMM1,XMM1,0x4e
PCMPGTW XMM4,XMM3
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSUBD XMM0,XMM5
PSHUFD XMM3,XMM3,0x4e
PSUBD XMM0,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM1,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM3
PSUBD XMM0,XMM1
MOVD R8D,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EAX,XMM6
ADD EAX,R8D
MOV R8D,ECX
AND R8D,0xfffffff8
ADD EDX,R8D
AND ECX,0x7
JZ 0x001014eb
LAB_00101468:
MOVSXD RCX,EDX
CMP byte ptr [RBX + RCX*0x1],0x20
JZ 0x001015d0
LAB_00101475:
LEA ECX,[RDX + 0x1]
CMP ESI,ECX
JLE 0x001014eb
MOVSXD RCX,ECX
CMP byte ptr [RBX + RCX*0x1],0x20
JZ 0x001015e0
LAB_00101489:
LEA ECX,[RDX + 0x2]
CMP ECX,ESI
JGE 0x001014eb
MOVSXD RCX,ECX
CMP byte ptr [RBX + RCX*0x1],0x20
JZ 0x001015f0
LAB_0010149d:
LEA ECX,[RDX + 0x3]
CMP ESI,ECX
JLE 0x001014eb
MOVSXD RCX,ECX
CMP byte ptr [RBX + RCX*0x1],0x20
JZ 0x00101600
LEA ECX,[RDX + 0x4]
CMP ESI,ECX
JLE 0x001014eb
LAB_001014b8:
MOVSXD RCX,ECX
CMP byte ptr [RBX + RCX*0x1],0x20
JNZ 0x001014c4
ADD EAX,0x1
LAB_001014c4:
LEA ECX,[RDX + 0x5]
CMP ESI,ECX
JLE 0x001014eb
MOVSXD RCX,ECX
CMP byte ptr [RBX + RCX*0x1],0x20
JNZ 0x001014d7
ADD EAX,0x1
LAB_001014d7:
ADD EDX,0x6
CMP ESI,EDX
JLE 0x001014eb
MOVSXD RDX,EDX
CMP byte ptr [RBX + RDX*0x1],0x20
JZ 0x00101618
LAB_001014eb:
LEA EDX,[RSI + RAX*0x2]
LEA RCX,[0x10204b]
CMP EDX,0x3e8
JG 0x001015a7
MOVSXD RAX,EDX
MOVSXD RSI,ESI
LEA ECX,[RDX + -0x1]
MOV RBP,RSP
MOV byte ptr [RSP + RAX*0x1],0x0
LEA R8,[RBX + RSI*0x1 + -0x2]
MOVSXD RAX,EDI
MOV EDI,EDI
MOVZX R9D,word ptr [0x00102180]
ADD RAX,RBX
SUB R8,RDI
LAB_00101529:
MOVZX ESI,byte ptr [RAX]
CMP SIL,0x20
JZ 0x0010154e
LAB_00101532:
MOVSXD RDI,ECX
SUB RAX,0x1
MOV byte ptr [RSP + RDI*0x1],SIL
CMP RAX,R8
JZ 0x00101588
MOVZX ESI,byte ptr [RAX]
SUB ECX,0x1
CMP SIL,0x20
JNZ 0x00101532
LAB_0010154e:
LEA ESI,[RCX + -0x2]
SUB RAX,0x1
MOVSXD RSI,ESI
MOV word ptr [RBP + RSI*0x1],R9W
LEA ESI,[RCX + -0x3]
MOVSXD RCX,ECX
MOV byte ptr [RSP + RCX*0x1],0x30
CMP RAX,R8
JZ 0x00101588
MOV ECX,ESI
JMP 0x00101529
LAB_00101578:
CDQE
MOV EDX,ESI
MOV RBP,RSP
MOV byte ptr [RSP + RAX*0x1],0x0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101588:
LEA EBX,[RDX + 0x1]
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x001010e0
MOV RDX,RBX
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010f0
MOV RCX,RAX
LAB_001015a7:
MOV RAX,qword ptr [RSP + 0x3e8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101630
ADD RSP,0x3f8
MOV RAX,RCX
POP RBX
POP RBP
RET
LAB_001015d0:
ADD EAX,0x1
JMP 0x00101475
LAB_001015e0:
ADD EAX,0x1
JMP 0x00101489
LAB_001015f0:
ADD EAX,0x1
JMP 0x0010149d
LAB_00101600:
LEA ECX,[RDX + 0x4]
ADD EAX,0x1
CMP ESI,ECX
JG 0x001014b8
JMP 0x001014eb
LAB_00101618:
ADD EAX,0x1
JMP 0x001014eb
LAB_00101620:
PXOR XMM0,XMM0
XOR R8D,R8D
XOR EAX,EAX
XOR EDX,EDX
JMP 0x001013c4
LAB_00101630:
CALL 0x001010b0 | char * func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
char *pcVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
int auVar24 [14];
int auVar25 [12];
unkbyte10 Var26;
int auVar27 [12];
int auVar28 [14];
int auVar29 [12];
int auVar30 [16];
int auVar31 [16];
int auVar32 [16];
int auVar33 [12];
unkbyte9 Var34;
int6 uVar35;
int4 uVar36;
int2 uVar37;
uint uVar38;
size_t sVar39;
char *pcVar40;
void *pvVar41;
uint uVar42;
long lVar43;
uint uVar44;
uint uVar45;
long in_FS_OFFSET;
int4 uVar47;
int iVar48;
char cVar56;
short sVar57;
int auVar52 [12];
int iVar58;
int auVar61 [12];
short sVar75;
int iVar76;
int auVar59 [11];
int iVar80;
int iVar81;
int auVar64 [16];
int auVar71 [16];
int iVar82;
char cVar86;
char cVar87;
char cVar88;
char cVar89;
char cVar90;
char cVar91;
short sVar92;
short sVar93;
int auVar84 [16];
int auVar94 [16];
int auVar99 [16];
int auVar106 [16];
int auVar109 [16];
int auVar113 [16];
int auVar116 [16];
char acStack_408 [1000];
long local_20;
ulong uVar46;
int6 uVar49;
int8 uVar50;
int auVar51 [12];
int auVar53 [14];
int auVar55 [16];
int auVar54 [16];
int auVar65 [16];
int auVar66 [16];
int auVar72 [16];
int auVar60 [12];
int auVar67 [16];
int auVar62 [13];
int auVar68 [16];
int auVar73 [16];
int auVar63 [14];
int auVar69 [16];
int auVar70 [16];
char cVar74;
char cVar77;
char cVar78;
byte bVar79;
int auVar83 [12];
int auVar85 [16];
int auVar95 [16];
int auVar96 [16];
int auVar110 [16];
int auVar100 [16];
int auVar97 [16];
int auVar101 [16];
int auVar107 [16];
int auVar111 [16];
int auVar102 [16];
int auVar98 [16];
int auVar103 [16];
int auVar108 [16];
int auVar112 [16];
int auVar104 [16];
int auVar105 [16];
int auVar114 [16];
int auVar115 [16];
int auVar117 [16];
int auVar118 [16];
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar39 = strlen(param_1);
uVar38 = (uint)sVar39;
if ((int)uVar38 < 1) {
acStack_408[(int)uVar38] = '\0';
}
else {
uVar44 = uVar38 - 1;
if (uVar44 < 0xf) {
iVar58 = 0;
iVar76 = 0;
uVar46 = 0;
iVar48 = 0;
uVar45 = 0;
LAB_001013c4:
uVar42 = uVar38 - (int)uVar46;
if (6 < uVar42 - 1) {
uVar50 = *(int8 *)(param_1 + uVar46);
bVar1 = (char)uVar50 == (char)DAT_00102170;
auVar64[0] = -bVar1;
bVar5 = (char)((ulong)uVar50 >> 8) == DAT_00102170._1_1_;
cVar56 = -bVar5;
bVar6 = (char)((ulong)uVar50 >> 0x10) == DAT_00102170._2_1_;
bVar7 = (char)((ulong)uVar50 >> 0x18) == DAT_00102170._3_1_;
bVar8 = (char)((ulong)uVar50 >> 0x20) == DAT_00102170._4_1_;
cVar74 = -bVar8;
bVar2 = (char)((ulong)uVar50 >> 0x28) == DAT_00102170._5_1_;
cVar77 = -bVar2;
bVar3 = (char)((ulong)uVar50 >> 0x30) == DAT_00102170._6_1_;
cVar78 = -bVar3;
bVar4 = (char)((ulong)uVar50 >> 0x38) == DAT_00102170._7_1_;
bVar79 = -bVar4;
auVar65._0_9_ = CONCAT18(0xff,(ulong)bVar79 << 0x38);
auVar59._0_10_ = CONCAT19(0xff,auVar65._0_9_);
auVar59[10] = 0xff;
auVar60[0xb] = 0xff;
auVar60._0_11_ = auVar59;
auVar62[0xc] = 0xff;
auVar62._0_12_ = auVar60;
auVar63[0xd] = 0xff;
auVar63._0_13_ = auVar62;
cVar86 = -bVar5;
cVar87 = -bVar7;
cVar88 = -bVar8;
cVar89 = -bVar2;
cVar90 = -bVar3;
cVar91 = -bVar4;
auVar105[0xe] = bVar79;
auVar105._0_14_ = auVar63;
auVar105[0xf] = cVar91;
auVar104._14_2_ = auVar105._14_2_;
auVar104[0xd] = cVar90;
auVar104._0_13_ = auVar62;
auVar103._13_3_ = auVar104._13_3_;
auVar103[0xc] = cVar78;
auVar103._0_12_ = auVar60;
auVar102._12_4_ = auVar103._12_4_;
auVar102[0xb] = cVar89;
auVar102._0_11_ = auVar59;
auVar101._11_5_ = auVar102._11_5_;
auVar101[10] = cVar77;
auVar101._0_10_ = auVar59._0_10_;
auVar100._10_6_ = auVar101._10_6_;
auVar100[9] = cVar88;
auVar100._0_9_ = auVar65._0_9_;
Var26 = CONCAT91(CONCAT81((long)(CONCAT72(auVar100._9_7_,CONCAT11(cVar74,bVar79)) >> 8),
cVar87),-bVar7);
auVar29._2_10_ = Var26;
auVar29[1] = -bVar6;
auVar29[0] = -bVar6;
auVar28._2_12_ = auVar29;
auVar28[1] = cVar86;
auVar28[0] = cVar56;
auVar99._0_2_ = CONCAT11(-bVar1,auVar64[0]);
auVar99._2_14_ = auVar28;
auVar70[0xe] = bVar79;
auVar70._0_14_ = auVar63;
auVar70[0xf] = cVar91;
auVar69._14_2_ = auVar70._14_2_;
auVar69[0xd] = cVar90;
auVar69._0_13_ = auVar62;
auVar68._13_3_ = auVar69._13_3_;
auVar68[0xc] = cVar78;
auVar68._0_12_ = auVar60;
auVar67._12_4_ = auVar68._12_4_;
auVar67[0xb] = cVar89;
auVar67._0_11_ = auVar59;
auVar66._11_5_ = auVar67._11_5_;
auVar66[10] = cVar77;
auVar66._0_10_ = auVar59._0_10_;
auVar65._10_6_ = auVar66._10_6_;
auVar65[9] = cVar88;
Var34 = CONCAT72(auVar65._9_7_,CONCAT11(cVar74,bVar79));
lVar43 = (long)((unkuint9)Var34 >> 8);
auVar32._1_8_ = lVar43;
auVar32[0] = cVar87;
auVar32._9_7_ = 0;
auVar31._10_6_ = 0;
auVar31._0_10_ = SUB1610(auVar32 << 0x38,6);
auVar30._11_5_ = 0;
auVar30._0_11_ = SUB1611(auVar31 << 0x30,5);
auVar64._4_12_ = SUB1612(auVar30 << 0x28,4);
auVar64[3] = cVar86;
auVar64[2] = cVar56;
auVar64[1] = -bVar1;
iVar48 = (int)((unkuint9)Var34 >> 8);
auVar61._8_4_ = auVar64._0_4_;
auVar61._0_8_ = lVar43;
sVar92 = auVar29._0_2_;
sVar93 = (short)Var26;
sVar57 = (short)((unkuint9)Var34 >> 8);
sVar75 = auVar68._12_2_;
auVar115._0_12_ = auVar99._0_12_;
auVar115._12_2_ = sVar93;
auVar115._14_2_ = -(ushort)(sVar93 < 0);
auVar114._12_4_ = auVar115._12_4_;
auVar114._0_10_ = auVar99._0_10_;
auVar114._10_2_ = -(ushort)(sVar92 < 0);
auVar113._10_6_ = auVar114._10_6_;
auVar113._0_8_ = auVar99._0_8_;
auVar113._8_2_ = sVar92;
auVar33._4_8_ = auVar113._8_8_;
auVar33._2_2_ = -(ushort)(auVar28._0_2_ < 0);
auVar33._0_2_ = auVar28._0_2_;
auVar108._12_2_ = sVar93;
auVar108._0_12_ = auVar115._0_12_;
auVar108._14_2_ = -(ushort)(sVar93 < 0);
auVar107._12_4_ = auVar108._12_4_;
auVar107._10_2_ = -(ushort)(sVar92 < 0);
auVar107._0_10_ = auVar114._0_10_;
auVar106._10_6_ = auVar107._10_6_;
auVar106._8_2_ = sVar92;
auVar106._0_8_ = auVar113._0_8_;
auVar73._12_2_ = auVar69._14_2_;
auVar73._0_12_ = auVar61;
auVar73._14_2_ = -(ushort)(lVar43 < 0);
auVar72._12_4_ = auVar73._12_4_;
auVar72._0_10_ = auVar61._0_10_;
auVar72._10_2_ = -(ushort)(sVar75 < 0);
auVar71._10_6_ = auVar72._10_6_;
auVar71._8_2_ = sVar75;
auVar71._0_8_ = lVar43;
auVar112._12_2_ = auVar69._14_2_;
auVar112._0_12_ = auVar61;
auVar112._14_2_ = -(ushort)(lVar43 < 0);
auVar111._12_4_ = auVar112._12_4_;
auVar111._10_2_ = -(ushort)(sVar75 < 0);
auVar111._0_10_ = auVar72._0_10_;
auVar110._10_6_ = auVar111._10_6_;
auVar110._8_2_ = sVar75;
auVar110._0_8_ = lVar43;
auVar109._8_8_ = auVar110._8_8_;
auVar109._6_2_ = -(ushort)(iVar48 < 0);
auVar109._4_2_ = auVar66._10_2_;
auVar109._0_4_ = iVar48;
iVar48 = ((((iVar76 - auVar33._0_4_) - auVar107._12_4_) - auVar109._4_4_) - auVar72._12_4_)
+ ((((iVar58 - CONCAT22(-(ushort)bVar1,auVar99._0_2_)) - auVar106._8_4_) -
CONCAT22(-(ushort)(sVar57 < 0),sVar57)) - auVar71._8_4_);
uVar45 = uVar45 + (uVar42 & 0xfffffff8);
if ((uVar42 & 7) == 0) goto LAB_001014eb;
}
if (param_1[(int)uVar45] == ' ') {
iVar48 = iVar48 + 1;
}
if ((int)(uVar45 + 1) < (int)uVar38) {
if (param_1[(int)(uVar45 + 1)] == ' ') {
iVar48 = iVar48 + 1;
}
if ((int)(uVar45 + 2) < (int)uVar38) {
if (param_1[(int)(uVar45 + 2)] == ' ') {
iVar48 = iVar48 + 1;
}
if ((int)(uVar45 + 3) < (int)uVar38) {
if (param_1[(int)(uVar45 + 3)] == ' ') {
iVar48 = iVar48 + 1;
}
if ((int)(uVar45 + 4) < (int)uVar38) {
if (param_1[(int)(uVar45 + 4)] == ' ') {
iVar48 = iVar48 + 1;
}
if ((int)(uVar45 + 5) < (int)uVar38) {
if (param_1[(int)(uVar45 + 5)] == ' ') {
iVar48 = iVar48 + 1;
}
if (((int)(uVar45 + 6) < (int)uVar38) && (param_1[(int)(uVar45 + 6)] == ' ')) {
iVar48 = iVar48 + 1;
}
}
}
}
}
}
}
else {
iVar58 = 0;
iVar76 = 0;
iVar80 = 0;
iVar81 = 0;
pcVar40 = param_1;
do {
cVar56 = *pcVar40;
pcVar9 = pcVar40 + 1;
pcVar10 = pcVar40 + 2;
pcVar11 = pcVar40 + 3;
pcVar12 = pcVar40 + 4;
pcVar13 = pcVar40 + 5;
pcVar14 = pcVar40 + 6;
pcVar15 = pcVar40 + 7;
pcVar16 = pcVar40 + 8;
pcVar17 = pcVar40 + 9;
pcVar18 = pcVar40 + 10;
pcVar19 = pcVar40 + 0xb;
pcVar20 = pcVar40 + 0xc;
pcVar21 = pcVar40 + 0xd;
pcVar22 = pcVar40 + 0xe;
pcVar23 = pcVar40 + 0xf;
pcVar40 = pcVar40 + 0x10;
bVar1 = cVar56 == (char)DAT_00102170;
cVar56 = -(*pcVar15 == DAT_00102170._7_1_);
bVar5 = *pcVar16 == UNK_00102178;
bVar6 = *pcVar17 == UNK_00102179;
bVar7 = *pcVar18 == UNK_0010217a;
bVar8 = *pcVar19 == UNK_0010217b;
uVar37 = CONCAT11(-(*pcVar15 == DAT_00102170._7_1_),cVar56);
uVar36 = CONCAT31(CONCAT21(uVar37,-(*pcVar14 == DAT_00102170._6_1_)),
-(*pcVar14 == DAT_00102170._6_1_));
uVar35 = CONCAT51(CONCAT41(uVar36,-(*pcVar13 == DAT_00102170._5_1_)),
-(*pcVar13 == DAT_00102170._5_1_));
Var34 = CONCAT72(CONCAT61(uVar35,-(*pcVar12 == DAT_00102170._4_1_)),
CONCAT11(-(*pcVar12 == DAT_00102170._4_1_),cVar56));
lVar43 = (long)((unkuint9)Var34 >> 8);
Var26 = CONCAT91(CONCAT81(lVar43,-(*pcVar11 == DAT_00102170._3_1_)),
-(*pcVar11 == DAT_00102170._3_1_));
auVar25._2_10_ = Var26;
auVar25[1] = -(*pcVar10 == DAT_00102170._2_1_);
auVar25[0] = -(*pcVar10 == DAT_00102170._2_1_);
auVar24._2_12_ = auVar25;
auVar24[1] = -(*pcVar9 == DAT_00102170._1_1_);
auVar24[0] = -(*pcVar9 == DAT_00102170._1_1_);
auVar84._0_2_ = CONCAT11(-bVar1,-bVar1);
auVar84._2_14_ = auVar24;
uVar47 = CONCAT13(-bVar6,CONCAT12(-bVar6,CONCAT11(-bVar5,-bVar5)));
uVar49 = CONCAT15(-bVar7,CONCAT14(-bVar7,uVar47));
uVar50 = CONCAT17(-bVar8,CONCAT16(-bVar8,uVar49));
auVar51._0_10_ =
CONCAT19(-(*pcVar20 == UNK_0010217c),CONCAT18(-(*pcVar20 == UNK_0010217c),uVar50));
auVar51[10] = -(*pcVar21 == UNK_0010217d);
auVar51[0xb] = -(*pcVar21 == UNK_0010217d);
auVar53[0xc] = -(*pcVar22 == UNK_0010217e);
auVar53._0_12_ = auVar51;
auVar53[0xd] = -(*pcVar22 == UNK_0010217e);
auVar54[0xe] = -(*pcVar23 == UNK_0010217f);
auVar54._0_14_ = auVar53;
auVar54[0xf] = -(*pcVar23 == UNK_0010217f);
sVar57 = (short)Var26;
sVar75 = (short)((unkuint9)Var34 >> 8);
sVar92 = (short)uVar35;
sVar93 = (short)uVar36;
auVar118._0_12_ = auVar84._0_12_;
auVar118._12_2_ = sVar57;
auVar118._14_2_ = -(ushort)(sVar57 < 0);
auVar117._12_4_ = auVar118._12_4_;
auVar117._0_10_ = auVar84._0_10_;
auVar117._10_2_ = -(ushort)(auVar25._0_2_ < 0);
auVar116._10_6_ = auVar117._10_6_;
auVar116._0_8_ = auVar84._0_8_;
auVar116._8_2_ = auVar25._0_2_;
auVar27._4_8_ = auVar116._8_8_;
auVar27._2_2_ = -(ushort)(auVar24._0_2_ < 0);
auVar27._0_2_ = auVar24._0_2_;
iVar82 = CONCAT22(-(ushort)(sVar75 < 0),sVar75);
auVar83._0_8_ = CONCAT26(-(ushort)(sVar92 < 0),CONCAT24(sVar92,iVar82));
auVar83._8_2_ = sVar93;
auVar83._10_2_ = -(ushort)(sVar93 < 0);
auVar85._12_2_ = uVar37;
auVar85._0_12_ = auVar83;
auVar85._14_2_ = -(ushort)(lVar43 < 0);
sVar57 = (short)((unkuint10)auVar51._0_10_ >> 0x40);
auVar98._12_2_ = (short)((ulong)uVar50 >> 0x30);
auVar98._0_12_ = auVar51;
auVar98._14_2_ = -(ushort)bVar8;
auVar97._12_4_ = auVar98._12_4_;
auVar97._10_2_ = -(ushort)bVar7;
auVar97._0_10_ = auVar51._0_10_;
auVar96._10_6_ = auVar97._10_6_;
auVar96._8_2_ = (short)((uint6)uVar49 >> 0x20);
auVar96._0_8_ = uVar50;
auVar95._8_8_ = auVar96._8_8_;
auVar95._6_2_ = -(ushort)bVar6;
auVar95._0_6_ = uVar49;
auVar94._6_10_ = auVar95._6_10_;
auVar94._4_2_ = (short)((uint)uVar47 >> 0x10);
auVar94._0_4_ = uVar47;
iVar48 = CONCAT22(-(ushort)(sVar57 < 0),sVar57);
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);
auVar55._12_2_ = auVar54._14_2_;
auVar55._0_12_ = auVar52;
auVar55._14_2_ = -(ushort)(auVar54._14_2_ < 0);
iVar58 = (((iVar58 - CONCAT22(-(ushort)bVar1,auVar84._0_2_)) - iVar82) -
CONCAT22(-(ushort)bVar5,CONCAT11(-bVar5,-bVar5))) - iVar48;
iVar76 = (((iVar76 - auVar27._0_4_) - (int)((ulong)auVar83._0_8_ >> 0x20)) - auVar94._4_4_)
- (int)((ulong)auVar52._0_8_ >> 0x20);
iVar80 = (((iVar80 - auVar116._8_4_) - auVar83._8_4_) - auVar96._8_4_) - auVar52._8_4_;
iVar81 = (((iVar81 - auVar117._12_4_) - auVar85._12_4_) - auVar97._12_4_) - auVar55._12_4_;
} while (pcVar40 != param_1 + (sVar39 >> 4 & 0xfffffff) * 0x10);
uVar45 = uVar38 & 0xfffffff0;
uVar46 = (ulong)uVar45;
iVar48 = iVar80 + iVar58 + iVar81 + iVar76;
iVar58 = iVar58 + iVar80;
iVar76 = iVar76 + iVar81;
if ((sVar39 & 0xf) != 0) goto LAB_001013c4;
}
LAB_001014eb:
uVar45 = uVar38 + iVar48 * 2;
pcVar40 = "";
if (1000 < (int)uVar45) goto LAB_001015a7;
lVar43 = (long)(int)uVar38;
iVar48 = uVar45 - 1;
acStack_408[(int)uVar45] = '\0';
pcVar40 = param_1 + (int)uVar44;
do {
cVar56 = *pcVar40;
iVar58 = iVar48;
while (uVar38 = uVar45, cVar56 != ' ') {
pcVar40 = pcVar40 + -1;
acStack_408[iVar58] = cVar56;
if (pcVar40 == param_1 + ((lVar43 + -2) - (ulong)uVar44)) goto LAB_00101588;
iVar58 = iVar58 + -1;
cVar56 = *pcVar40;
}
pcVar40 = pcVar40 + -1;
*(int2 *)(acStack_408 + (iVar58 + -2)) = DAT_00102180;
iVar48 = iVar58 + -3;
acStack_408[iVar58] = '0';
} while (pcVar40 != param_1 + ((lVar43 + -2) - (ulong)uVar44));
}
LAB_00101588:
pvVar41 = malloc((long)(int)(uVar38 + 1));
pcVar40 = (char *)__strcpy_chk(pvVar41,acStack_408,(long)(int)(uVar38 + 1));
LAB_001015a7:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar40;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,408 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int* list, int size, int* result_size) {
static int ev_li[100];
int j = 0;
for (int i = 0; i < size; i++) {
if (list[i] % 2 == 0) {
ev_li[j++] = list[i];
}
}
*result_size = j;
return ev_li;
}
| int main() {
int size;
int test1[] = {1,2,3,4,5};
int expected1[] = {2,4};
int* result1 = func0(test1, 5, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
int test2[] = {4,5,6,7,8,0,1};
int expected2[] = {4,6,8,0};
int* result2 = func0(test2, 7, &size);
assert(size == 4);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
int test3[] = {8,12,15,19};
int expected3[] = {8,12};
int* result3 = func0(test3, 4, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1201 <func0+0x78>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11fd <func0+0x74>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
mov (%rcx),%edx
cltq
lea 0x0(,%rax,4),%rcx
lea 0x2e46(%rip),%rax
mov %edx,(%rcx,%rax,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ac <func0+0x23>
mov -0x28(%rbp),%rax
mov -0x8(%rbp),%edx
mov %edx,(%rax)
lea 0x2e27(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1201
loc_11AC:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11FD
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
mov edx, [rcx]
cdqe
lea rcx, ds:0[rax*4]
lea rax, ev_li_1
mov [rcx+rax], edx
loc_11FD:
add [rbp+var_4], 1
loc_1201:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11AC
mov rax, [rbp+var_28]
mov edx, [rbp+var_8]
mov [rax], edx
lea rax, ev_li_1
pop rbp
retn | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
{
v3 = v5++;
ev_li_1[v3] = *(_DWORD *)(4LL * i + a1);
}
}
*a3 = v5;
return ev_li_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101201
LAB_001011ac:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011fd
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOV EDX,dword ptr [RCX]
CDQE
LEA RCX,[RAX*0x4]
LEA RAX,[0x104040]
MOV dword ptr [RCX + RAX*0x1],EDX
LAB_001011fd:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ac
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x8]
MOV dword ptr [RAX],EDX
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(long param_1,int param_2,int *param_3)
{
int local_10;
int local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) {
*(int4 *)(ev_li_1 + (long)local_10 * 4) = *(int4 *)((long)local_c * 4 + param_1);
local_10 = local_10 + 1;
}
}
*param_3 = local_10;
return ev_li_1;
} |
6,409 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int* list, int size, int* result_size) {
static int ev_li[100];
int j = 0;
for (int i = 0; i < size; i++) {
if (list[i] % 2 == 0) {
ev_li[j++] = list[i];
}
}
*result_size = j;
return ev_li;
}
| int main() {
int size;
int test1[] = {1,2,3,4,5};
int expected1[] = {2,4};
int* result1 = func0(test1, 5, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
int test2[] = {4,5,6,7,8,0,1};
int expected2[] = {4,6,8,0};
int* result2 = func0(test2, 7, &size);
assert(size == 4);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
int test3[] = {8,12,15,19};
int expected3[] = {8,12};
int* result3 = func0(test3, 4, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c6 <func0+0x3d>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rdi
mov $0x0,%esi
lea 0x2e98(%rip),%r9
jmp 11b3 <func0+0x2a>
add $0x4,%rax
cmp %rdi,%rax
je 11cb <func0+0x42>
mov (%rax),%ecx
test $0x1,%cl
jne 11aa <func0+0x21>
movslq %esi,%r8
mov %ecx,(%r9,%r8,4)
lea 0x1(%rsi),%esi
jmp 11aa <func0+0x21>
mov $0x0,%esi
mov %esi,(%rdx)
lea 0x2e6c(%rip),%rax
retq
| func0:
endbr64
test esi, esi
jle short loc_11C6
mov rax, rdi
lea ecx, [rsi-1]
lea rdi, [rdi+rcx*4+4]
mov esi, 0
lea r9, ev_li_1
jmp short loc_11B3
loc_11AA:
add rax, 4
cmp rax, rdi
jz short loc_11CB
loc_11B3:
mov ecx, [rax]
test cl, 1
jnz short loc_11AA
movsxd r8, esi
mov [r9+r8*4], ecx
lea esi, [rsi+1]
jmp short loc_11AA
loc_11C6:
mov esi, 0
loc_11CB:
mov [rdx], esi
lea rax, ev_li_1
retn | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // rax
long long v4; // rdi
int v5; // esi
if ( a2 <= 0 )
{
v5 = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
{
if ( (*v3 & 1) == 0 )
ev_li_1[v5++] = *v3;
++v3;
}
while ( v3 != (_DWORD *)v4 );
}
*a3 = v5;
return ev_li_1;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c6
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RDI,[RDI + RCX*0x4 + 0x4]
MOV ESI,0x0
LEA R9,[0x104040]
JMP 0x001011b3
LAB_001011aa:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011cb
LAB_001011b3:
MOV ECX,dword ptr [RAX]
TEST CL,0x1
JNZ 0x001011aa
MOVSXD R8,ESI
MOV dword ptr [R9 + R8*0x4],ECX
LEA ESI,[RSI + 0x1]
JMP 0x001011aa
LAB_001011c6:
MOV ESI,0x0
LAB_001011cb:
MOV dword ptr [RDX],ESI
LEA RAX,[0x104040]
RET | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if ((*param_1 & 1) == 0) {
(&ev_li_1)[iVar2] = *param_1;
iVar2 = iVar2 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
*param_3 = iVar2;
return &ev_li_1;
} |
6,410 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int* list, int size, int* result_size) {
static int ev_li[100];
int j = 0;
for (int i = 0; i < size; i++) {
if (list[i] % 2 == 0) {
ev_li[j++] = list[i];
}
}
*result_size = j;
return ev_li;
}
| int main() {
int size;
int test1[] = {1,2,3,4,5};
int expected1[] = {2,4};
int* result1 = func0(test1, 5, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
int test2[] = {4,5,6,7,8,0,1};
int expected2[] = {4,6,8,0};
int* result2 = func0(test2, 7, &size);
assert(size == 4);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
int test3[] = {8,12,15,19};
int expected3[] = {8,12};
int* result3 = func0(test3, 4, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1468 <func0+0x48>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
lea 0x2c0c(%rip),%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov (%rdi),%eax
test $0x1,%al
jne 1450 <func0+0x30>
movslq %ecx,%r8
add $0x1,%ecx
mov %eax,(%r9,%r8,4)
add $0x4,%rdi
cmp %rsi,%rdi
jne 1440 <func0+0x20>
mov %ecx,(%rdx)
lea 0x2bde(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
lea 0x2bcf(%rip),%rax
mov %ecx,(%rdx)
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_13F0
lea eax, [rsi-1]
xor ecx, ecx
lea r9, ev_li_1
lea rsi, [rdi+rax*4+4]
nop dword ptr [rax+00000000h]
loc_13D0:
mov eax, [rdi]
test al, 1
jnz short loc_13E0
movsxd r8, ecx
add ecx, 1
mov [r9+r8*4], eax
loc_13E0:
add rdi, 4
cmp rdi, rsi
jnz short loc_13D0
mov [rdx], ecx
mov rax, r9
retn
loc_13F0:
xor ecx, ecx
lea r9, ev_li_1
mov [rdx], ecx
mov rax, r9
retn | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
int v3; // ecx
long long v4; // rsi
long long v5; // r8
if ( a2 <= 0 )
{
*a3 = 0;
return ev_li_1;
}
else
{
v3 = 0;
v4 = (long long)&a1[a2 - 1 + 1];
do
{
if ( (*a1 & 1) == 0 )
{
v5 = v3++;
ev_li_1[v5] = *a1;
}
++a1;
}
while ( a1 != (_DWORD *)v4 );
*a3 = v3;
return ev_li_1;
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013f0
LEA EAX,[RSI + -0x1]
XOR ECX,ECX
LEA R9,[0x104040]
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_001013d0:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JNZ 0x001013e0
MOVSXD R8,ECX
ADD ECX,0x1
MOV dword ptr [R9 + R8*0x4],EAX
LAB_001013e0:
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x001013d0
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET
LAB_001013f0:
XOR ECX,ECX
LEA R9,[0x104040]
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) == 0) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
(&ev_li_1)[lVar3] = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_3 = iVar2;
return &ev_li_1;
}
*param_3 = 0;
return &ev_li_1;
} |
6,411 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int* list, int size, int* result_size) {
static int ev_li[100];
int j = 0;
for (int i = 0; i < size; i++) {
if (list[i] % 2 == 0) {
ev_li[j++] = list[i];
}
}
*result_size = j;
return ev_li;
}
| int main() {
int size;
int test1[] = {1,2,3,4,5};
int expected1[] = {2,4};
int* result1 = func0(test1, 5, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result1[i] == expected1[i]);
}
int test2[] = {4,5,6,7,8,0,1};
int expected2[] = {4,6,8,0};
int* result2 = func0(test2, 7, &size);
assert(size == 4);
for (int i = 0; i < size; i++) {
assert(result2[i] == expected2[i]);
}
int test3[] = {8,12,15,19};
int expected3[] = {8,12};
int* result3 = func0(test3, 4, &size);
assert(size == 2);
for (int i = 0; i < size; i++) {
assert(result3[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 14a8 <func0+0x48>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
lea 0x2bcc(%rip),%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov (%rdi),%eax
test $0x1,%al
jne 1490 <func0+0x30>
movslq %ecx,%r8
add $0x1,%ecx
mov %eax,(%r9,%r8,4)
add $0x4,%rdi
cmp %rsi,%rdi
jne 1480 <func0+0x20>
mov %ecx,(%rdx)
lea 0x2b9e(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
lea 0x2b8f(%rip),%rax
mov %ecx,(%rdx)
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_11C0
movsxd rsi, esi
xor ecx, ecx
lea r9, ev_li_1
lea rsi, [rdi+rsi*4]
nop dword ptr [rax+rax+00000000h]
loc_11A0:
mov eax, [rdi]
test al, 1
jnz short loc_11B0
movsxd r8, ecx
add ecx, 1
mov [r9+r8*4], eax
loc_11B0:
add rdi, 4
cmp rdi, rsi
jnz short loc_11A0
mov [rdx], ecx
mov rax, r9
retn
loc_11C0:
xor ecx, ecx
lea r9, ev_li_1
mov [rdx], ecx
mov rax, r9
retn | __int128 * func0(_DWORD *a1, int a2, _DWORD *a3)
{
int v3; // ecx
_DWORD *v4; // rsi
long long v5; // r8
if ( a2 <= 0 )
{
*a3 = 0;
return &ev_li_1;
}
else
{
v3 = 0;
v4 = &a1[a2];
do
{
if ( (*a1 & 1) == 0 )
{
v5 = v3++;
*((_DWORD *)&ev_li_1 + v5) = *a1;
}
++a1;
}
while ( a1 != v4 );
*a3 = v3;
return &ev_li_1;
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c0
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R9,[0x104040]
LEA RSI,[RDI + RSI*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001011a0:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JNZ 0x001011b0
MOVSXD R8,ECX
ADD ECX,0x1
MOV dword ptr [R9 + R8*0x4],EAX
LAB_001011b0:
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x001011a0
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET
LAB_001011c0:
XOR ECX,ECX
LEA R9,[0x104040]
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
puVar1 = param_1 + param_2;
do {
if ((*param_1 & 1) == 0) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
(&ev_li_1)[lVar3] = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_3 = iVar2;
return &ev_li_1;
}
*param_3 = 0;
return &ev_li_1;
} |
6,412 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
void adjac(int *ele, int ele_size, int *sub, int sub_size, int ***results, int *results_size, int *cap) {
if (ele_size == 0) {
if (*results_size == *cap) {
*cap *= 2;
*results = realloc(*results, *cap * sizeof(int *));
}
(*results)[*results_size] = malloc(sub_size * sizeof(int));
for (int i = 0; i < sub_size; i++) {
(*results)[*results_size][i] = sub[i];
}
(*results_size)++;
} else {
int *new_sub = (int*)malloc((sub_size + 1) * sizeof(int));
if (sub_size > 0) {
memcpy(new_sub, sub, sub_size * sizeof(int));
}
for (int j = ele[0] - 1; j <= ele[0] + 1; j++) {
new_sub[sub_size] = j;
adjac(ele + 1, ele_size - 1, new_sub, sub_size + 1, results, results_size, cap);
}
free(new_sub);
}
}
| int **func0(int *test_tup, int size, int *result_size) {
int **results = malloc(10 * sizeof(int *));
int cap = 10;
*result_size = 0;
adjac(test_tup, size, NULL, 0, &results, result_size, &cap);
return results;
}
| int main() {
int size;
int test_tup1[] = {3, 4};
int **res1 = func0(test_tup1, 2, &size);
assert(size == 9);
int test_tup2[] = {4, 5};
int **res2 = func0(test_tup2, 2, &size);
assert(size == 9);
int test_tup3[] = {5, 6};
int **res3 = func0(test_tup3, 2, &size);
assert(size == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov $0x50,%edi
callq 10e0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0xa,-0x14(%rbp)
mov -0x38(%rbp),%rax
movl $0x0,(%rax)
mov -0x38(%rbp),%rdi
lea -0x10(%rbp),%rcx
mov -0x2c(%rbp),%esi
mov -0x28(%rbp),%rax
sub $0x8,%rsp
lea -0x14(%rbp),%rdx
push %rdx
mov %rdi,%r9
mov %rcx,%r8
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 11e9 <adjac>
add $0x10,%rsp
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1448 <func0+0x91>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edi, 50h ; 'P'; size
call _malloc
mov [rbp+var_10], rax
mov [rbp+var_14], 0Ah
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rdi, [rbp+var_38]
lea rcx, [rbp+var_10]
mov esi, [rbp+var_2C]
mov rax, [rbp+var_28]
sub rsp, 8
lea rdx, [rbp+var_14]
push rdx
mov r9, rdi
mov r8, rcx
mov ecx, 0
mov edx, 0
mov rdi, rax
call adjac
add rsp, 10h
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1448
call ___stack_chk_fail
locret_1448:
leave
retn | long long func0(int a1, int a2, _DWORD *a3)
{
int v5; // [rsp+2Ch] [rbp-14h] BYREF
_QWORD v6[2]; // [rsp+30h] [rbp-10h] BYREF
v6[1] = __readfsqword(0x28u);
v6[0] = malloc(0x50uLL);
v5 = 10;
*a3 = 0;
adjac(a1, a2, 0, 0, (unsigned int)v6, (_DWORD)a3, (long long)&v5);
return v6[0];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDI,0x50
CALL 0x001010e0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x14],0xa
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RBP + -0x38]
LEA RCX,[RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x28]
SUB RSP,0x8
LEA RDX,[RBP + -0x14]
PUSH RDX
MOV R9,RDI
MOV R8,RCX
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001011e9
ADD RSP,0x10
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101448
CALL 0x001010b0
LAB_00101448:
LEAVE
RET | void * func0(int8 param_1,int4 param_2,int4 *param_3)
{
long in_FS_OFFSET;
int4 local_1c;
void *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = malloc(0x50);
local_1c = 10;
*param_3 = 0;
adjac(param_1,param_2,0,0,&local_18,param_3,&local_1c);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_18;
} |
6,413 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
void adjac(int *ele, int ele_size, int *sub, int sub_size, int ***results, int *results_size, int *cap) {
if (ele_size == 0) {
if (*results_size == *cap) {
*cap *= 2;
*results = realloc(*results, *cap * sizeof(int *));
}
(*results)[*results_size] = malloc(sub_size * sizeof(int));
for (int i = 0; i < sub_size; i++) {
(*results)[*results_size][i] = sub[i];
}
(*results_size)++;
} else {
int *new_sub = (int*)malloc((sub_size + 1) * sizeof(int));
if (sub_size > 0) {
memcpy(new_sub, sub, sub_size * sizeof(int));
}
for (int j = ele[0] - 1; j <= ele[0] + 1; j++) {
new_sub[sub_size] = j;
adjac(ele + 1, ele_size - 1, new_sub, sub_size + 1, results, results_size, cap);
}
free(new_sub);
}
}
| int **func0(int *test_tup, int size, int *result_size) {
int **results = malloc(10 * sizeof(int *));
int cap = 10;
*result_size = 0;
adjac(test_tup, size, NULL, 0, &results, result_size, &cap);
return results;
}
| int main() {
int size;
int test_tup1[] = {3, 4};
int **res1 = func0(test_tup1, 2, &size);
assert(size == 9);
int test_tup2[] = {4, 5};
int **res2 = func0(test_tup2, 2, &size);
assert(size == 9);
int test_tup3[] = {5, 6};
int **res3 = func0(test_tup3, 2, &size);
assert(size == 9);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbp
mov %esi,%r12d
mov %rdx,%rbx
mov $0x28,%r13d
mov %fs:0x0(%r13),%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0x50,%edi
callq 10e0 <malloc@plt>
mov %rax,0x10(%rsp)
movl $0xa,0xc(%rsp)
movl $0x0,(%rbx)
sub $0x8,%rsp
lea 0x14(%rsp),%rax
push %rax
mov %rbx,%r9
lea 0x20(%rsp),%r8
mov $0x0,%ecx
mov $0x0,%edx
mov %r12d,%esi
mov %rbp,%rdi
callq 11e9 <adjac>
mov 0x20(%rsp),%rax
add $0x10,%rsp
mov 0x18(%rsp),%rcx
xor %fs:0x0(%r13),%rcx
jne 13c5 <func0+0x8d>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
mov rbp, rdi
mov r12d, esi
mov rbx, rdx
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov edi, 50h ; 'P'
call _malloc
mov [rsp+38h+var_28], rax
mov [rsp+38h+var_2C], 0Ah
mov dword ptr [rbx], 0
sub rsp, 8
lea rax, [rsp+40h+var_2C]
push rax
mov r9, rbx
lea r8, [rsp+48h+var_28]
mov ecx, 0
mov edx, 0
mov esi, r12d
mov rdi, rbp
call adjac
mov rax, [rsp+48h+var_28]
add rsp, 10h
mov rdx, [rsp+38h+var_20]
sub rdx, fs:28h
jnz short loc_13B9
add rsp, 20h
pop rbx
pop rbp
pop r12
retn
loc_13B9:
call ___stack_chk_fail | long long func0(int a1, int a2, _DWORD *a3)
{
int v5; // [rsp+Ch] [rbp-2Ch] BYREF
_QWORD v6[5]; // [rsp+10h] [rbp-28h] BYREF
v6[1] = __readfsqword(0x28u);
v6[0] = malloc(80LL);
v5 = 10;
*a3 = 0;
adjac(a1, a2, 0, 0, (unsigned int)v6, (_DWORD)a3, (long long)&v5);
return v6[0];
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RBP,RDI
MOV R12D,ESI
MOV RBX,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV EDI,0x50
CALL 0x001010e0
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0xc],0xa
MOV dword ptr [RBX],0x0
SUB RSP,0x8
LEA RAX,[RSP + 0x14]
PUSH RAX
MOV R9,RBX
LEA R8,[RSP + 0x20]
MOV ECX,0x0
MOV EDX,0x0
MOV ESI,R12D
MOV RDI,RBP
CALL 0x001011e9
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x10
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b9
ADD RSP,0x20
POP RBX
POP RBP
POP R12
RET
LAB_001013b9:
CALL 0x001010b0 | void * func0(int8 param_1,int4 param_2,int4 *param_3)
{
long in_FS_OFFSET;
int4 local_2c;
void *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = malloc(0x50);
local_2c = 10;
*param_3 = 0;
adjac(param_1,param_2,0,0,&local_28,param_3,&local_2c);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_28;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,414 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
void adjac(int *ele, int ele_size, int *sub, int sub_size, int ***results, int *results_size, int *cap) {
if (ele_size == 0) {
if (*results_size == *cap) {
*cap *= 2;
*results = realloc(*results, *cap * sizeof(int *));
}
(*results)[*results_size] = malloc(sub_size * sizeof(int));
for (int i = 0; i < sub_size; i++) {
(*results)[*results_size][i] = sub[i];
}
(*results_size)++;
} else {
int *new_sub = (int*)malloc((sub_size + 1) * sizeof(int));
if (sub_size > 0) {
memcpy(new_sub, sub, sub_size * sizeof(int));
}
for (int j = ele[0] - 1; j <= ele[0] + 1; j++) {
new_sub[sub_size] = j;
adjac(ele + 1, ele_size - 1, new_sub, sub_size + 1, results, results_size, cap);
}
free(new_sub);
}
}
| int **func0(int *test_tup, int size, int *result_size) {
int **results = malloc(10 * sizeof(int *));
int cap = 10;
*result_size = 0;
adjac(test_tup, size, NULL, 0, &results, result_size, &cap);
return results;
}
| int main() {
int size;
int test_tup1[] = {3, 4};
int **res1 = func0(test_tup1, 2, &size);
assert(size == 9);
int test_tup2[] = {4, 5};
int **res2 = func0(test_tup2, 2, &size);
assert(size == 9);
int test_tup3[] = {5, 6};
int **res3 = func0(test_tup3, 2, &size);
assert(size == 9);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
mov $0x50,%edi
push %rbx
mov %rdx,%rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10e0 <malloc@plt>
sub $0x8,%rsp
xor %ecx,%ecx
xor %edx,%edx
mov %rax,0x18(%rsp)
mov %rbx,%r9
mov %r12d,%esi
mov %rbp,%rdi
movl $0xa,0x14(%rsp)
lea 0x14(%rsp),%rax
push %rax
movl $0x0,(%rbx)
lea 0x20(%rsp),%r8
callq 1310 <adjac>
mov 0x20(%rsp),%rax
pop %rdx
pop %rcx
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1533 <func0+0x83>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10b0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12d, esi
push rbp
mov rbp, rdi
mov edi, 50h ; 'P'
push rbx
mov rbx, rdx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _malloc
sub rsp, 8
xor ecx, ecx
xor edx, edx
mov [rsp+40h+var_28], rax
mov r9, rbx
mov esi, r12d
mov rdi, rbp
mov [rsp+40h+var_2C], 0Ah
lea rax, [rsp+40h+var_2C]
push rax
mov dword ptr [rbx], 0
lea r8, [rsp+48h+var_28]
call adjac
mov rax, [rsp+48h+var_28]
pop rdx
pop rcx
mov rdx, [rsp+38h+var_20]
sub rdx, fs:28h
jnz short loc_1533
add rsp, 20h
pop rbx
pop rbp
pop r12
retn
loc_1533:
call ___stack_chk_fail | long long func0(int a1, int a2, _DWORD *a3)
{
int v5; // [rsp+Ch] [rbp-2Ch] BYREF
_QWORD v6[5]; // [rsp+10h] [rbp-28h] BYREF
v6[1] = __readfsqword(0x28u);
v6[0] = malloc(80LL);
v5 = 10;
*a3 = 0;
adjac(a1, a2, 0, 0, (unsigned int)v6, (_DWORD)a3, (long long)&v5);
return v6[0];
} | func0:
ENDBR64
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDI
MOV EDI,0x50
PUSH RBX
MOV RBX,RDX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010e0
SUB RSP,0x8
XOR ECX,ECX
XOR EDX,EDX
MOV qword ptr [RSP + 0x18],RAX
MOV R9,RBX
MOV ESI,R12D
MOV RDI,RBP
MOV dword ptr [RSP + 0x14],0xa
LEA RAX,[RSP + 0x14]
PUSH RAX
MOV dword ptr [RBX],0x0
LEA R8,[RSP + 0x20]
CALL 0x00101310
MOV RAX,qword ptr [RSP + 0x20]
POP RDX
POP RCX
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101533
ADD RSP,0x20
POP RBX
POP RBP
POP R12
RET
LAB_00101533:
CALL 0x001010b0 | void * func0(int8 param_1,int4 param_2,int4 *param_3)
{
long in_FS_OFFSET;
int4 local_2c;
void *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = malloc(0x50);
local_2c = 10;
*param_3 = 0;
adjac(param_1,param_2,0,0,&local_28,param_3,&local_2c);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_28;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,415 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
void adjac(int *ele, int ele_size, int *sub, int sub_size, int ***results, int *results_size, int *cap) {
if (ele_size == 0) {
if (*results_size == *cap) {
*cap *= 2;
*results = realloc(*results, *cap * sizeof(int *));
}
(*results)[*results_size] = malloc(sub_size * sizeof(int));
for (int i = 0; i < sub_size; i++) {
(*results)[*results_size][i] = sub[i];
}
(*results_size)++;
} else {
int *new_sub = (int*)malloc((sub_size + 1) * sizeof(int));
if (sub_size > 0) {
memcpy(new_sub, sub, sub_size * sizeof(int));
}
for (int j = ele[0] - 1; j <= ele[0] + 1; j++) {
new_sub[sub_size] = j;
adjac(ele + 1, ele_size - 1, new_sub, sub_size + 1, results, results_size, cap);
}
free(new_sub);
}
}
| int **func0(int *test_tup, int size, int *result_size) {
int **results = malloc(10 * sizeof(int *));
int cap = 10;
*result_size = 0;
adjac(test_tup, size, NULL, 0, &results, result_size, &cap);
return results;
}
| int main() {
int size;
int test_tup1[] = {3, 4};
int **res1 = func0(test_tup1, 2, &size);
assert(size == 9);
int test_tup2[] = {4, 5};
int **res2 = func0(test_tup2, 2, &size);
assert(size == 9);
int test_tup3[] = {5, 6};
int **res3 = func0(test_tup3, 2, &size);
assert(size == 9);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %esi,%r13d
push %r12
push %rbp
mov %rdi,%rbp
mov $0x50,%edi
push %rbx
mov %rdx,%rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10e0 <malloc@plt>
movl $0xa,0x2c(%rsp)
mov %rax,0x30(%rsp)
movl $0x0,(%rbx)
test %r13d,%r13d
jne 1538 <func0+0x88>
xor %edi,%edi
mov %rax,%r12
callq 10e0 <malloc@plt>
addl $0x1,(%rbx)
mov %rax,(%r12)
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1683 <func0+0x1d3>
add $0x48,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov $0x4,%edi
mov %rbx,%r15
callq 10e0 <malloc@plt>
mov %r13d,0x18(%rsp)
cmpl $0x1,0x18(%rsp)
mov %rax,(%rsp)
mov 0x0(%rbp),%eax
lea -0x1(%rax),%r12d
lea -0x2(%r13),%eax
mov %eax,0x14(%rsp)
mov (%rsp),%rax
mov %r12d,(%rax)
jne 15bc <func0+0x10c>
movslq (%r15),%r14
mov 0x30(%rsp),%r13
cmp 0x2c(%rsp),%r14d
je 1658 <func0+0x1a8>
mov $0x4,%edi
callq 10e0 <malloc@plt>
mov %rax,0x0(%r13,%r14,8)
movslq (%r15),%rax
mov 0x0(%r13,%rax,8),%rax
mov %r12d,(%rax)
lea 0x1(%r12),%eax
addl $0x1,(%r15)
cmp 0x0(%rbp),%r12d
jg 163f <func0+0x18f>
mov %eax,%r12d
mov (%rsp),%rax
cmpl $0x1,0x18(%rsp)
mov %r12d,(%rax)
je 156b <func0+0xbb>
mov $0x8,%edi
lea 0x30(%rsp),%rbx
lea 0x8(%rbp),%r14
callq 10e0 <malloc@plt>
mov %r12d,0x1c(%rsp)
mov %r12d,(%rax)
mov %rax,%r13
mov 0x4(%rbp),%eax
mov %rbx,%r12
lea -0x1(%rax),%r10d
lea 0x2c(%rsp),%rax
mov %rax,0x8(%rsp)
mov %r10d,%ebx
sub $0x8,%rsp
mov %ebx,0x4(%r13)
mov $0x2,%ecx
mov %r13,%rdx
pushq 0x10(%rsp)
mov 0x24(%rsp),%esi
mov %r15,%r9
mov %r12,%r8
mov %r14,%rdi
callq 1310 <adjac>
mov %ebx,%eax
pop %rdx
add $0x1,%ebx
pop %rcx
cmp 0x4(%rbp),%eax
jle 15f1 <func0+0x141>
mov 0x1c(%rsp),%r12d
mov %r13,%rdi
callq 10a0 <free@plt>
lea 0x1(%r12),%eax
cmp 0x0(%rbp),%r12d
jle 15ab <func0+0xfb>
mov (%rsp),%rdi
callq 10a0 <free@plt>
mov 0x30(%rsp),%r12
jmpq 150e <func0+0x5e>
nopw 0x0(%rax,%rax,1)
add %r14d,%r14d
mov %r13,%rdi
mov %r14d,0x2c(%rsp)
movslq %r14d,%r14
lea 0x0(,%r14,8),%rsi
callq 10f0 <realloc@plt>
movslq (%r15),%r14
mov %rax,0x30(%rsp)
mov %rax,%r13
jmpq 157e <func0+0xce>
callq 10b0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov r15d, esi
push r14
mov r14, rdx
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_B8], rdi
mov edi, 50h ; 'P'; size
mov [rsp+0D8h+var_CC], esi
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
call _malloc
mov dword ptr [r14], 0
mov [rsp+0D8h+ptr], rax
mov [rsp+0D8h+var_4C], 0Ah
test r15d, r15d
jnz short loc_1540
xor edi, edi; size
mov rbx, rax
call _malloc
add dword ptr [r14], 1
mov [rbx], rax
loc_1511:
mov rax, [rsp+0D8h+var_40]
sub rax, fs:28h
jnz loc_1EA5
add rsp, 0A8h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1540:
mov edi, 4; size
call _malloc
cmp [rsp+0D8h+var_CC], 1
mov rbp, [rsp+0D8h+var_B8]
mov r12, rax
mov rax, [rsp+0D8h+var_B8]
mov eax, [rax]
lea r13d, [rax-1]
mov dword ptr [rsp+0D8h+var_C8], eax
mov [r12], r13d
jnz loc_15F9
loc_1570:
movsxd rbx, dword ptr [r14]
mov r15, [rsp+0D8h+ptr]
cmp ebx, [rsp+0D8h+var_4C]
jz short loc_15CD
loc_1584:
mov edi, 4; size
call _malloc
mov [r15+rbx*8], rax
movsxd rax, dword ptr [r14]
mov rax, [r15+rax*8]
mov [rax], r13d
lea eax, [r13+1]
add dword ptr [r14], 1
cmp r13d, [rbp+0]
jg short loc_15B8
mov [r12], eax
mov r13d, eax
jmp short loc_1570
loc_15B3:
mov r12, [rsp+0D8h+var_98]
loc_15B8:
mov rdi, r12; ptr
call _free
mov rbx, [rsp+0D8h+ptr]
jmp loc_1511
loc_15CD:
add ebx, ebx
mov rdi, r15; ptr
mov [rsp+0D8h+var_4C], ebx
movsxd rbx, ebx
lea rsi, ds:0[rbx*8]; size
call _realloc
movsxd rbx, dword ptr [r14]
mov [rsp+0D8h+ptr], rax
mov r15, rax
jmp short loc_1584
loc_15F9:
mov eax, [rsp+0D8h+var_CC]
mov [rsp+0D8h+var_98], r12
sub eax, 8
mov [rsp+0D8h+var_A0], eax
mov rax, r14
mov r14d, r13d
mov r13, rax
loc_1612:
mov edi, 8; size
call _malloc
cmp [rsp+0D8h+var_CC], 2
mov [rax], r14d
mov r15, rax
mov rax, [rsp+0D8h+var_B8]
mov eax, [rax+4]
lea ecx, [rax-1]
mov dword ptr [rsp+0D8h+var_C8], eax
mov [r15+4], ecx
jnz loc_1700
mov ebp, ecx
loc_1642:
movsxd rbx, dword ptr [r13+0]
mov r12, [rsp+0D8h+ptr]
cmp ebx, [rsp+0D8h+var_4C]
jz short loc_16D0
loc_1657:
mov edi, 8; size
call _malloc
mov rcx, [rsp+0D8h+var_B8]
mov [r12+rbx*8], rax
movsxd rax, dword ptr [r13+0]
mov rax, [r12+rax*8]
mov [rax], r14d
movsxd rax, dword ptr [r13+0]
mov rax, [r12+rax*8]
mov [rax+4], ebp
lea eax, [rbp+1]
add dword ptr [r13+0], 1
cmp [rcx+4], ebp
jl short loc_16A0
mov [r15+4], eax
mov ebp, eax
jmp short loc_1642
loc_1695:
mov r13, r14
mov r14d, [rsp+0D8h+var_5C]
mov r15, rbp
loc_16A0:
mov rdi, r15; ptr
call _free
mov rcx, [rsp+0D8h+var_B8]
lea eax, [r14+1]
cmp [rcx], r14d
jl loc_15B3
mov rcx, [rsp+0D8h+var_98]
mov r14d, eax
mov [rcx], eax
jmp loc_1612
loc_16D0:
add ebx, ebx
mov rdi, r12; ptr
mov [rsp+0D8h+var_4C], ebx
movsxd rbx, ebx
lea rsi, ds:0[rbx*8]; size
call _realloc
movsxd rbx, dword ptr [r13+0]
mov [rsp+0D8h+ptr], rax
mov r12, rax
jmp loc_1657
loc_1700:
mov r12, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_5C], r14d
mov rbp, r15
mov r14, r13
mov r13d, ecx
loc_1713:
mov edi, 0Ch; size
call _malloc
mov r15, [rbp+0]
cmp [rsp+0D8h+var_CC], 3
mov rcx, rax
mov [rax], r15
mov eax, [r12+8]
lea r8d, [rax-1]
mov [rcx+8], r8d
jnz loc_1839
mov rax, r15
mov [rsp+0D8h+var_C0], rcx
sar rax, 20h
mov [rsp+0D8h+var_B0], rbp
mov ebp, r8d
mov [rsp+0D8h+var_C8], rax
mov dword ptr [rsp+0D8h+var_A8], r13d
mov r13, r14
loc_1760:
mov ebx, [r13+0]
mov r14, [rsp+0D8h+ptr]
cmp ebx, [rsp+0D8h+var_4C]
jz loc_1808
loc_1779:
mov edi, 0Ch; size
call _malloc
movsxd rdx, ebx
mov edi, dword ptr [rsp+0D8h+var_C8]
mov [r14+rdx*8], rax
movsxd rax, dword ptr [r13+0]
mov rax, [r14+rax*8]
mov [rax], r15d
movsxd rax, dword ptr [r13+0]
mov rax, [r14+rax*8]
mov [rax+4], edi
movsxd rax, dword ptr [r13+0]
mov rax, [r14+rax*8]
mov [rax+8], ebp
lea eax, [rbp+1]
add dword ptr [r13+0], 1
cmp ebp, [r12+8]
jg short loc_17D0
mov rdi, [rsp+0D8h+var_C0]
mov ebp, eax
mov [rdi+8], eax
jmp short loc_1760
loc_17D0:
mov r14, r13
mov rbp, [rsp+0D8h+var_B0]
mov rcx, [rsp+0D8h+var_C0]
mov r13d, dword ptr [rsp+0D8h+var_A8]
loc_17E2:
mov rdi, rcx; ptr
call _free
lea eax, [r13+1]
cmp r13d, [r12+4]
jg loc_1695
mov [rbp+4], eax
mov r13d, eax
jmp loc_1713
loc_1808:
lea edx, [rbx+rbx]
mov rdi, r14; ptr
mov [rsp+0D8h+var_4C], edx
movsxd rdx, edx
lea rsi, ds:0[rdx*8]; size
call _realloc
mov ebx, [r13+0]
mov [rsp+0D8h+ptr], rax
mov r14, rax
jmp loc_1779
loc_1839:
mov [rsp+0D8h+var_60], r13d
mov rbx, rcx
mov [rsp+0D8h+var_68], rbp
mov ebp, r8d
loc_1849:
mov edi, 10h; size
call _malloc
cmp [rsp+0D8h+var_CC], 4
mov r8, rax
mov rax, [rbx]
mov [r8], rax
mov eax, [rbx+8]
mov [r8+8], eax
mov eax, [r12+0Ch]
lea ecx, [rax-1]
mov [r8+0Ch], ecx
jnz loc_1961
mov dword ptr [rsp+0D8h+var_C8], ebp
mov ebp, ecx
mov [rsp+0D8h+var_C0], rbx
mov rbx, r8
loc_1888:
movsxd r15, dword ptr [r14]
mov r13, [rsp+0D8h+ptr]
cmp r15d, [rsp+0D8h+var_4C]
jz loc_1930
loc_18A1:
mov edi, 10h; size
call _malloc
mov edx, [rbx]
mov [r13+r15*8+0], rax
movsxd rax, dword ptr [r14]
mov rax, [r13+rax*8+0]
mov [rax], edx
movsxd rax, dword ptr [r14]
mov edx, [rbx+4]
mov rax, [r13+rax*8+0]
mov [rax+4], edx
movsxd rax, dword ptr [r14]
mov edx, dword ptr [rsp+0D8h+var_C8]
mov rax, [r13+rax*8+0]
mov [rax+8], edx
movsxd rax, dword ptr [r14]
mov rax, [r13+rax*8+0]
mov [rax+0Ch], ebp
lea eax, [rbp+1]
add dword ptr [r14], 1
cmp ebp, [r12+0Ch]
jg short loc_1900
mov [rbx+0Ch], eax
mov ebp, eax
jmp short loc_1888
loc_1900:
mov r8, rbx
mov rbx, [rsp+0D8h+var_C0]
mov ebp, edx
loc_190A:
mov rdi, r8; ptr
call _free
lea eax, [rbp+1]
cmp ebp, [r12+8]
jg loc_1E93
mov [rbx+8], eax
mov ebp, eax
jmp loc_1849
loc_1930:
add r15d, r15d
mov rdi, r13; ptr
mov [rsp+0D8h+var_4C], r15d
movsxd r15, r15d
lea rsi, ds:0[r15*8]; size
call _realloc
movsxd r15, dword ptr [r14]
mov [rsp+0D8h+ptr], rax
mov r13, rax
jmp loc_18A1
loc_1961:
mov [rsp+0D8h+var_70], rbx
mov r15d, ecx
mov [rsp+0D8h+var_74], ebp
mov rbp, r8
loc_1970:
mov edi, 14h; size
call _malloc
mov rsi, [rbp+0]
mov rbx, [rbp+8]
mov r8, rax
cmp [rsp+0D8h+var_CC], 5
mov [rax], rsi
mov [rax+8], rbx
mov eax, [r12+10h]
lea r9d, [rax-1]
mov [r8+10h], r9d
jnz loc_1AD0
mov r13, rsi
mov [rsp+0D8h+var_A8], rbp
sar r13, 20h
mov [rsp+0D8h+var_B0], r8
mov [rsp+0D8h+var_C8], r13
mov [rsp+0D8h+var_C0], rsi
mov [rsp+0D8h+var_9C], r15d
mov r15d, r9d
loc_19C7:
mov r13d, [r14]
mov rbp, [rsp+0D8h+ptr]
cmp r13d, [rsp+0D8h+var_4C]
jz loc_1A98
loc_19E0:
mov edi, 14h; size
call _malloc
movsxd rsi, r13d
mov edi, dword ptr [rsp+0D8h+var_C0]
mov [rbp+rsi*8+0], rax
movsxd rax, dword ptr [r14]
mov rsi, rbx
sar rsi, 20h
mov rax, [rbp+rax*8+0]
mov [rax], edi
movsxd rax, dword ptr [r14]
mov edi, dword ptr [rsp+0D8h+var_C8]
mov rax, [rbp+rax*8+0]
mov [rax+4], edi
movsxd rax, dword ptr [r14]
mov rax, [rbp+rax*8+0]
mov [rax+8], ebx
movsxd rax, dword ptr [r14]
mov rax, [rbp+rax*8+0]
mov [rax+0Ch], esi
movsxd rax, dword ptr [r14]
mov rax, [rbp+rax*8+0]
mov [rax+10h], r15d
lea eax, [r15+1]
add dword ptr [r14], 1
cmp r15d, [r12+10h]
jg short loc_1A60
mov rdi, [rsp+0D8h+var_B0]
mov r15d, eax
mov [rdi+10h], eax
jmp loc_19C7
loc_1A60:
mov rbp, [rsp+0D8h+var_A8]
mov r15d, [rsp+0D8h+var_9C]
mov r8, [rsp+0D8h+var_B0]
loc_1A6F:
mov rdi, r8; ptr
call _free
lea eax, [r15+1]
cmp r15d, [r12+0Ch]
jg loc_1E82
mov [rbp+0Ch], eax
mov r15d, eax
jmp loc_1970
loc_1A98:
lea esi, [r13+r13+0]
mov rdi, rbp; ptr
mov [rsp+0D8h+var_4C], esi
movsxd rsi, esi
shl rsi, 3; size
call _realloc
mov r13d, [r14]
mov [rsp+0D8h+ptr], rax
mov rbp, rax
jmp loc_19E0
loc_1AD0:
mov dword ptr [rsp+0D8h+var_B0], r9d
mov [rsp+0D8h+var_78], r15d
mov [rsp+0D8h+var_80], rbp
mov rbp, r8
loc_1AE2:
mov edi, 18h; size
call _malloc
movdqu xmm3, xmmword ptr [rbp+0]
cmp [rsp+0D8h+var_CC], 6
mov rdx, rax
movups xmmword ptr [rax], xmm3
mov eax, [rbp+10h]
mov [rdx+10h], eax
mov eax, [r12+14h]
lea ecx, [rax-1]
mov [rdx+14h], ecx
jnz loc_1C10
mov [rsp+0D8h+var_C8], rbp
mov r15, rdx
mov ebp, ecx
loc_1B1D:
mov r13d, [r14]
mov rbx, [rsp+0D8h+ptr]
cmp r13d, [rsp+0D8h+var_4C]
jz loc_1BE0
loc_1B36:
mov edi, 18h; size
call _malloc
movsxd rsi, r13d
mov edx, dword ptr [rsp+0D8h+var_B0]
mov [rbx+rsi*8], rax
movsxd rax, dword ptr [r14]
mov esi, [r15]
mov rax, [rbx+rax*8]
mov [rax], esi
movsxd rax, dword ptr [r14]
mov esi, [r15+4]
mov rax, [rbx+rax*8]
mov [rax+4], esi
movsxd rax, dword ptr [r14]
mov esi, [r15+8]
mov rax, [rbx+rax*8]
mov [rax+8], esi
movsxd rax, dword ptr [r14]
mov esi, [r15+0Ch]
mov rax, [rbx+rax*8]
mov [rax+0Ch], esi
movsxd rax, dword ptr [r14]
mov rax, [rbx+rax*8]
mov [rax+10h], edx
movsxd rax, dword ptr [r14]
mov rax, [rbx+rax*8]
mov [rax+14h], ebp
lea eax, [rbp+1]
add dword ptr [r14], 1
cmp ebp, [r12+14h]
jg short loc_1BB0
mov [r15+14h], eax
mov ebp, eax
jmp loc_1B1D
loc_1BB0:
mov rbp, [rsp+0D8h+var_C8]
mov rdx, r15
loc_1BB8:
mov rdi, rdx; ptr
call _free
mov edx, dword ptr [rsp+0D8h+var_B0]
lea eax, [rdx+1]
cmp edx, [r12+10h]
jg loc_1E70
mov [rbp+10h], eax
mov dword ptr [rsp+0D8h+var_B0], eax
jmp loc_1AE2
loc_1BE0:
lea esi, [r13+r13+0]
mov rdi, rbx; ptr
mov [rsp+0D8h+var_4C], esi
movsxd rsi, esi
shl rsi, 3; size
call _realloc
mov r13d, [r14]
mov [rsp+0D8h+ptr], rax
mov rbx, rax
jmp loc_1B36
loc_1C10:
mov [rsp+0D8h+var_88], rbp
mov r15, r14
mov ebx, ecx
mov r14, rdx
loc_1C1D:
mov edi, 1Ch; size
call _malloc
movdqu xmm2, xmmword ptr [r14]
cmp [rsp+0D8h+var_CC], 7
mov r13, rax
movups xmmword ptr [rax], xmm2
mov rax, [r14+10h]
mov [r13+10h], rax
mov eax, [r12+18h]
lea r8d, [rax-1]
mov [r13+18h], r8d
jnz loc_1D80
mov dword ptr [rsp+0D8h+var_C8], ebx
mov rax, r12
mov r12, r13
mov [rsp+0D8h+var_C0], r14
mov r13, rax
mov r14d, r8d
loc_1C67:
movsxd rbx, dword ptr [r15]
mov rbp, [rsp+0D8h+ptr]
cmp ebx, [rsp+0D8h+var_4C]
jz loc_1D50
loc_1C7F:
mov edi, 1Ch; size
call _malloc
mov ecx, [r12]
mov edx, dword ptr [rsp+0D8h+var_C8]
mov [rbp+rbx*8+0], rax
movsxd rax, dword ptr [r15]
mov rax, [rbp+rax*8+0]
mov [rax], ecx
movsxd rax, dword ptr [r15]
mov ecx, [r12+4]
mov rax, [rbp+rax*8+0]
mov [rax+4], ecx
movsxd rax, dword ptr [r15]
mov ecx, [r12+8]
mov rax, [rbp+rax*8+0]
mov [rax+8], ecx
movsxd rax, dword ptr [r15]
mov ecx, [r12+0Ch]
mov rax, [rbp+rax*8+0]
mov [rax+0Ch], ecx
movsxd rax, dword ptr [r15]
mov ecx, [r12+10h]
mov rax, [rbp+rax*8+0]
mov [rax+10h], ecx
movsxd rax, dword ptr [r15]
mov rax, [rbp+rax*8+0]
mov [rax+14h], edx
movsxd rax, dword ptr [r15]
mov rax, [rbp+rax*8+0]
mov [rax+18h], r14d
lea eax, [r14+1]
add dword ptr [r15], 1
cmp r14d, [r13+18h]
jg short loc_1D18
mov [r12+18h], eax
mov r14d, eax
jmp loc_1C67
loc_1D18:
mov rax, r13
mov r14, [rsp+0D8h+var_C0]
mov r13, r12
mov ebx, edx
mov r12, rax
loc_1D28:
mov rdi, r13; ptr
call _free
lea eax, [rbx+1]
cmp ebx, [r12+14h]
jg loc_1E60
mov [r14+14h], eax
mov ebx, eax
jmp loc_1C1D
loc_1D50:
add ebx, ebx
mov rdi, rbp; ptr
mov [rsp+0D8h+var_4C], ebx
movsxd rbx, ebx
lea rsi, ds:0[rbx*8]; size
call _realloc
movsxd rbx, dword ptr [r15]
mov [rsp+0D8h+ptr], rax
mov rbp, rax
jmp loc_1C7F
loc_1D80:
lea rdi, [rsp+0D8h+ptr]
mov dword ptr [rsp+0D8h+var_A8], r8d
lea rax, [r12+20h]
mov [rsp+0D8h+var_C0], rdi
lea rbp, [rsp+0D8h+var_4C]
mov [rsp+0D8h+var_90], r14
mov [rsp+0D8h+var_C8], r15
mov [rsp+0D8h+var_9C], ebx
mov rbx, rax
loc_1DB0:
mov edi, 20h ; ' '; size
call _malloc
movdqu xmm0, xmmword ptr [r13+0]
movdqu xmm1, xmmword ptr [r13+0Ch]
mov r14, rax
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+0Ch], xmm1
mov eax, [r12+1Ch]
lea r15d, [rax-1]
mov rax, r14
mov r14, r13
mov r13, rax
loc_1DE2:
sub rsp, 8
mov [r13+1Ch], r15d
mov ecx, 8
mov rdx, r13
push rbp
mov r9, [rsp+0E8h+var_C8]
mov rdi, rbx
mov r8, [rsp+0E8h+var_C0]
mov esi, [rsp+0E8h+var_A0]
call adjac
mov ecx, r15d
pop rax
add r15d, 1
pop rdx
cmp [r12+1Ch], ecx
jge short loc_1DE2
mov rax, r13
mov r13, r14
mov rdi, rax; ptr
call _free
mov edx, dword ptr [rsp+0D8h+var_A8]
lea eax, [rdx+1]
cmp edx, [r12+18h]
jg short loc_1E48
mov [r14+18h], eax
mov dword ptr [rsp+0D8h+var_A8], eax
jmp loc_1DB0
loc_1E48:
mov ebx, [rsp+0D8h+var_9C]
mov r14, [rsp+0D8h+var_90]
mov r15, [rsp+0D8h+var_C8]
jmp loc_1D28
loc_1E60:
mov rdx, r14
mov rbp, [rsp+0D8h+var_88]
mov r14, r15
jmp loc_1BB8
loc_1E70:
mov r8, rbp
mov r15d, [rsp+0D8h+var_78]
mov rbp, [rsp+0D8h+var_80]
jmp loc_1A6F
loc_1E82:
mov r8, rbp
mov rbx, [rsp+0D8h+var_70]
mov ebp, [rsp+0D8h+var_74]
jmp loc_190A
loc_1E93:
mov rbp, [rsp+0D8h+var_68]
mov r13d, [rsp+0D8h+var_60]
mov rcx, rbx
jmp loc_17E2
loc_1EA5:
call ___stack_chk_fail | _QWORD * func0(int *a1, int a2, int *a3)
{
void *v4; // rax
_QWORD *v5; // rbx
void *v6; // rax
int *v8; // r12
int v9; // r13d
long long v10; // rbx
_QWORD *v11; // r15
void *v12; // rax
int *v13; // rax
int v14; // r14d
int *v15; // r13
_DWORD *v16; // rax
_DWORD *v17; // r15
int v18; // ecx
int i; // ebp
long long v20; // rbx
_QWORD *v21; // r12
int v22; // eax
void *v23; // rax
int *v24; // r12
_DWORD *v25; // rbp
int *v26; // r14
int j; // r13d
_DWORD *v28; // rax
long long v29; // r15
int v30; // r8d
int v31; // ebp
int *v32; // r13
int v33; // ebx
_QWORD *v34; // r14
int v35; // eax
void *v36; // rcx
int v37; // r13d
void *v38; // rax
_DWORD *v39; // rbx
int k; // ebp
int *v41; // r8
int v42; // ecx
int v43; // ebp
int *m; // rbx
long long v45; // r15
_QWORD *v46; // r13
void *v47; // rax
int v48; // edx
long long *v49; // r8
int v50; // ebp
void *v51; // rax
int v52; // r15d
long long *v53; // rbp
__m128i *v54; // rax
long long v55; // rsi
long long v56; // rbx
int v57; // r9d
int n; // r15d
int v59; // r13d
_QWORD *v60; // rbp
int v61; // eax
int v62; // r15d
__m128i *v63; // r8
void *v64; // rax
const __m128i *ii; // rbp
__m128i *v66; // rdx
int v67; // ecx
__m128i *v68; // r15
int jj; // ebp
int v70; // r13d
_QWORD *v71; // rbx
__m128i *v72; // rdx
void *v73; // rax
int *v74; // r15
int v75; // ebx
const __m128i *kk; // r14
char *v77; // r13
int v78; // r8d
int *v79; // rax
char *v80; // r12
int *v81; // r13
int mm; // r14d
long long v83; // rbx
_QWORD *v84; // rbp
void *v85; // rax
int v86; // ecx
int *v87; // rax
void *v88; // rax
char *v89; // rax
__m128i v90; // xmm1
int v91; // r15d
char *v92; // r14
_DWORD *v93; // r13
int v94; // ecx
void *v95; // rax
int v97; // [rsp+10h] [rbp-C8h]
const __m128i *v98; // [rsp+10h] [rbp-C8h]
int v99; // [rsp+10h] [rbp-C8h]
int *v100; // [rsp+10h] [rbp-C8h]
_DWORD *v101; // [rsp+18h] [rbp-C0h]
_DWORD *v102; // [rsp+18h] [rbp-C0h]
const __m128i *v103; // [rsp+18h] [rbp-C0h]
_DWORD *v104; // [rsp+28h] [rbp-B0h]
__m128i *v105; // [rsp+28h] [rbp-B0h]
int v106; // [rsp+28h] [rbp-B0h]
int v107; // [rsp+30h] [rbp-A8h]
long long *v108; // [rsp+30h] [rbp-A8h]
int v109; // [rsp+30h] [rbp-A8h]
int v110; // [rsp+38h] [rbp-A0h]
int v111; // [rsp+3Ch] [rbp-9Ch]
int *v112; // [rsp+40h] [rbp-98h]
const __m128i *v113; // [rsp+48h] [rbp-90h]
const __m128i *v114; // [rsp+50h] [rbp-88h]
long long *v115; // [rsp+58h] [rbp-80h]
int v116; // [rsp+60h] [rbp-78h]
int v117; // [rsp+64h] [rbp-74h]
_DWORD *v118; // [rsp+68h] [rbp-70h]
_DWORD *v119; // [rsp+70h] [rbp-68h]
int v120; // [rsp+78h] [rbp-60h]
int v121; // [rsp+7Ch] [rbp-5Ch]
int v122; // [rsp+8Ch] [rbp-4Ch] BYREF
void *ptr[9]; // [rsp+90h] [rbp-48h] BYREF
ptr[1] = (void *)__readfsqword(0x28u);
v4 = malloc(0x50uLL);
*a3 = 0;
ptr[0] = v4;
v122 = 10;
if ( a2 )
{
v8 = (int *)malloc(4uLL);
v9 = *a1 - 1;
*v8 = v9;
if ( a2 == 1 )
{
while ( 1 )
{
v10 = *a3;
v11 = ptr[0];
if ( (_DWORD)v10 == v122 )
{
v122 = 2 * v10;
v12 = realloc(ptr[0], 16LL * (_DWORD)v10);
v10 = *a3;
ptr[0] = v12;
v11 = v12;
}
v11[v10] = malloc(4uLL);
*(_DWORD *)v11[(*a3)++] = v9;
if ( v9 > *a1 )
break;
*v8 = ++v9;
}
}
else
{
v112 = v8;
v110 = a2 - 8;
v13 = a3;
v14 = v9;
v15 = v13;
while ( 1 )
{
v16 = malloc(8uLL);
*v16 = v14;
v17 = v16;
v18 = a1[1] - 1;
v16[1] = v18;
if ( a2 == 2 )
{
for ( i = v18; ; ++i )
{
v20 = *v15;
v21 = ptr[0];
if ( (_DWORD)v20 == v122 )
{
v122 = 2 * v20;
v23 = realloc(ptr[0], 16LL * (_DWORD)v20);
v20 = *v15;
ptr[0] = v23;
v21 = v23;
}
v21[v20] = malloc(8uLL);
*(_DWORD *)v21[*v15] = v14;
*(_DWORD *)(v21[(*v15)++] + 4LL) = i;
if ( a1[1] < i )
break;
v17[1] = i + 1;
}
}
else
{
v24 = a1;
v121 = v14;
v25 = v16;
v26 = v15;
for ( j = v18; ; j = v37 + 1 )
{
v28 = malloc(0xCuLL);
v29 = *(_QWORD *)v25;
*(_QWORD *)v28 = *(_QWORD *)v25;
v30 = v24[2] - 1;
v28[2] = v30;
if ( a2 == 3 )
{
v101 = v28;
v104 = v25;
v31 = v30;
v107 = j;
v32 = v26;
while ( 1 )
{
v33 = *v32;
v34 = ptr[0];
if ( *v32 == v122 )
{
v122 = 2 * v33;
v38 = realloc(ptr[0], 16LL * v33);
v33 = *v32;
ptr[0] = v38;
v34 = v38;
}
v34[v33] = malloc(0xCuLL);
*(_QWORD *)v34[*v32] = v29;
*(_DWORD *)(v34[*v32] + 8LL) = v31;
v35 = v31 + 1;
++*v32;
if ( v31 > v24[2] )
break;
++v31;
v101[2] = v35;
}
v26 = v32;
v25 = v104;
v36 = v101;
v37 = v107;
}
else
{
v120 = j;
v39 = v28;
v119 = v25;
for ( k = v30; ; k = v50 + 1 )
{
v41 = (int *)malloc(0x10uLL);
*(_QWORD *)v41 = *(_QWORD *)v39;
v41[2] = v39[2];
v42 = v24[3] - 1;
v41[3] = v42;
if ( a2 == 4 )
{
v97 = k;
v43 = v42;
v102 = v39;
for ( m = v41; ; m[3] = ++v43 )
{
v45 = *v26;
v46 = ptr[0];
if ( (_DWORD)v45 == v122 )
{
v122 = 2 * v45;
v51 = realloc(ptr[0], 16LL * (_DWORD)v45);
v45 = *v26;
ptr[0] = v51;
v46 = v51;
}
v47 = malloc(0x10uLL);
v48 = *m;
v46[v45] = v47;
*(_DWORD *)v46[*v26] = v48;
*(_DWORD *)(v46[*v26] + 4LL) = m[1];
*(_DWORD *)(v46[*v26] + 8LL) = v97;
*(_DWORD *)(v46[(*v26)++] + 12LL) = v43;
if ( v43 > v24[3] )
break;
}
v49 = (long long *)m;
v39 = v102;
v50 = v97;
}
else
{
v118 = v39;
v52 = v42;
v117 = k;
v53 = (long long *)v41;
while ( 1 )
{
v54 = (__m128i *)malloc(0x14uLL);
v55 = *v53;
v56 = v53[1];
v54->m128i_i64[0] = *v53;
v54->m128i_i64[1] = v56;
v57 = v24[4] - 1;
v54[1].m128i_i32[0] = v57;
if ( a2 == 5 )
{
v108 = v53;
v105 = v54;
v111 = v52;
for ( n = v57; ; ++n )
{
v59 = *v26;
v60 = ptr[0];
if ( *v26 == v122 )
{
v122 = 2 * v59;
v64 = realloc(ptr[0], 16LL * v59);
v59 = *v26;
ptr[0] = v64;
v60 = v64;
}
v60[v59] = malloc(0x14uLL);
*(_QWORD *)v60[*v26] = v55;
*(_QWORD *)(v60[*v26] + 8LL) = v56;
*(_DWORD *)(v60[*v26] + 16LL) = n;
v61 = n + 1;
++*v26;
if ( n > v24[4] )
break;
v105[1].m128i_i32[0] = v61;
}
v53 = v108;
v62 = v111;
v63 = v105;
}
else
{
v106 = v57;
v116 = v52;
v115 = v53;
for ( ii = v54; ; ii[1].m128i_i32[0] = ++v106 )
{
v66 = (__m128i *)malloc(0x18uLL);
*v66 = _mm_loadu_si128(ii);
v66[1].m128i_i32[0] = ii[1].m128i_i32[0];
v67 = v24[5] - 1;
v66[1].m128i_i32[1] = v67;
if ( a2 == 6 )
{
v98 = ii;
v68 = v66;
for ( jj = v67; ; ++jj )
{
v70 = *v26;
v71 = ptr[0];
if ( *v26 == v122 )
{
v122 = 2 * v70;
v73 = realloc(ptr[0], 16LL * v70);
v70 = *v26;
ptr[0] = v73;
v71 = v73;
}
v71[v70] = malloc(0x18uLL);
*(_DWORD *)v71[*v26] = v68->m128i_i32[0];
*(_DWORD *)(v71[*v26] + 4LL) = v68->m128i_i32[1];
*(_DWORD *)(v71[*v26] + 8LL) = v68->m128i_i32[2];
*(_DWORD *)(v71[*v26] + 12LL) = v68->m128i_i32[3];
*(_DWORD *)(v71[*v26] + 16LL) = v106;
*(_DWORD *)(v71[(*v26)++] + 20LL) = jj;
if ( jj > v24[5] )
break;
v68[1].m128i_i32[1] = jj + 1;
}
ii = v98;
v72 = v68;
}
else
{
v114 = ii;
v74 = v26;
v75 = v67;
for ( kk = v66; ; kk[1].m128i_i32[1] = ++v75 )
{
v77 = (char *)malloc(0x1CuLL);
*(__m128i *)v77 = _mm_loadu_si128(kk);
*((_QWORD *)v77 + 2) = kk[1].m128i_i64[0];
v78 = v24[6] - 1;
*((_DWORD *)v77 + 6) = v78;
if ( a2 == 7 )
{
v99 = v75;
v79 = v24;
v80 = v77;
v103 = kk;
v81 = v79;
for ( mm = v78; ; ++mm )
{
v83 = *v74;
v84 = ptr[0];
if ( (_DWORD)v83 == v122 )
{
v122 = 2 * v83;
v88 = realloc(ptr[0], 16LL * (_DWORD)v83);
v83 = *v74;
ptr[0] = v88;
v84 = v88;
}
v85 = malloc(0x1CuLL);
v86 = *(_DWORD *)v80;
v84[v83] = v85;
*(_DWORD *)v84[*v74] = v86;
*(_DWORD *)(v84[*v74] + 4LL) = *((_DWORD *)v80 + 1);
*(_DWORD *)(v84[*v74] + 8LL) = *((_DWORD *)v80 + 2);
*(_DWORD *)(v84[*v74] + 12LL) = *((_DWORD *)v80 + 3);
*(_DWORD *)(v84[*v74] + 16LL) = *((_DWORD *)v80 + 4);
*(_DWORD *)(v84[*v74] + 20LL) = v99;
*(_DWORD *)(v84[(*v74)++] + 24LL) = mm;
if ( mm > v81[6] )
break;
*((_DWORD *)v80 + 6) = mm + 1;
}
v87 = v81;
kk = v103;
v77 = v80;
v75 = v99;
v24 = v87;
}
else
{
v109 = v78;
v113 = kk;
v100 = v74;
while ( 1 )
{
v89 = (char *)malloc(0x20uLL);
v90 = _mm_loadu_si128((const __m128i *)(v77 + 12));
*(__m128i *)v89 = _mm_loadu_si128((const __m128i *)v77);
*(__m128i *)(v89 + 12) = v90;
v91 = v24[7] - 1;
v92 = v77;
v93 = v89;
do
{
v93[7] = v91;
adjac(
(_DWORD)v24 + 32,
v110,
(_DWORD)v93,
8,
(unsigned int)ptr,
(_DWORD)v100,
(long long)&v122);
v94 = v91++;
}
while ( v24[7] >= v94 );
v95 = v93;
v77 = v92;
free(v95);
if ( v109 > v24[6] )
break;
*((_DWORD *)v92 + 6) = ++v109;
}
kk = v113;
v74 = v100;
}
free(v77);
if ( v75 > v24[5] )
break;
}
v72 = (__m128i *)kk;
ii = v114;
v26 = v74;
}
free(v72);
if ( v106 > v24[4] )
break;
}
v63 = (__m128i *)ii;
v62 = v116;
v53 = v115;
}
free(v63);
if ( v62 > v24[3] )
break;
*((_DWORD *)v53 + 3) = v62 + 1;
v52 = v62 + 1;
}
v49 = v53;
v39 = v118;
v50 = v117;
}
free(v49);
if ( v50 > v24[2] )
break;
v39[2] = v50 + 1;
}
v25 = v119;
v37 = v120;
v36 = v39;
}
free(v36);
if ( v37 > v24[1] )
break;
v25[1] = v37 + 1;
}
v15 = v26;
v14 = v121;
v17 = v25;
}
free(v17);
v22 = v14 + 1;
if ( *a1 < v14 )
break;
++v14;
*v112 = v22;
}
v8 = v112;
}
free(v8);
return ptr[0];
}
else
{
v5 = v4;
v6 = malloc(0LL);
++*a3;
*v5 = v6;
}
return v5;
} | func0:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
MOV R14,RDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x20],RDI
MOV EDI,0x50
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
CALL 0x001010e0
MOV dword ptr [R14],0x0
MOV qword ptr [RSP + 0x90],RAX
MOV dword ptr [RSP + 0x8c],0xa
TEST R15D,R15D
JNZ 0x00101540
XOR EDI,EDI
MOV RBX,RAX
CALL 0x001010e0
ADD dword ptr [R14],0x1
MOV qword ptr [RBX],RAX
LAB_00101511:
MOV RAX,qword ptr [RSP + 0x98]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101ea5
ADD RSP,0xa8
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101540:
MOV EDI,0x4
CALL 0x001010e0
CMP dword ptr [RSP + 0xc],0x1
MOV RBP,qword ptr [RSP + 0x20]
MOV R12,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX]
LEA R13D,[RAX + -0x1]
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [R12],R13D
JNZ 0x001015f9
LAB_00101570:
MOVSXD RBX,dword ptr [R14]
MOV R15,qword ptr [RSP + 0x90]
CMP EBX,dword ptr [RSP + 0x8c]
JZ 0x001015cd
LAB_00101584:
MOV EDI,0x4
CALL 0x001010e0
MOV qword ptr [R15 + RBX*0x8],RAX
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [R15 + RAX*0x8]
MOV dword ptr [RAX],R13D
LEA EAX,[R13 + 0x1]
ADD dword ptr [R14],0x1
CMP R13D,dword ptr [RBP]
JG 0x001015b8
MOV dword ptr [R12],EAX
MOV R13D,EAX
JMP 0x00101570
LAB_001015b3:
MOV R12,qword ptr [RSP + 0x40]
LAB_001015b8:
MOV RDI,R12
CALL 0x001010a0
MOV RBX,qword ptr [RSP + 0x90]
JMP 0x00101511
LAB_001015cd:
ADD EBX,EBX
MOV RDI,R15
MOV dword ptr [RSP + 0x8c],EBX
MOVSXD RBX,EBX
LEA RSI,[RBX*0x8]
CALL 0x001010f0
MOVSXD RBX,dword ptr [R14]
MOV qword ptr [RSP + 0x90],RAX
MOV R15,RAX
JMP 0x00101584
LAB_001015f9:
MOV EAX,dword ptr [RSP + 0xc]
MOV qword ptr [RSP + 0x40],R12
SUB EAX,0x8
MOV dword ptr [RSP + 0x38],EAX
MOV RAX,R14
MOV R14D,R13D
MOV R13,RAX
LAB_00101612:
MOV EDI,0x8
CALL 0x001010e0
CMP dword ptr [RSP + 0xc],0x2
MOV dword ptr [RAX],R14D
MOV R15,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX + 0x4]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [R15 + 0x4],ECX
JNZ 0x00101700
MOV EBP,ECX
LAB_00101642:
MOVSXD RBX,dword ptr [R13]
MOV R12,qword ptr [RSP + 0x90]
CMP EBX,dword ptr [RSP + 0x8c]
JZ 0x001016d0
LAB_00101657:
MOV EDI,0x8
CALL 0x001010e0
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [R12 + RBX*0x8],RAX
MOVSXD RAX,dword ptr [R13]
MOV RAX,qword ptr [R12 + RAX*0x8]
MOV dword ptr [RAX],R14D
MOVSXD RAX,dword ptr [R13]
MOV RAX,qword ptr [R12 + RAX*0x8]
MOV dword ptr [RAX + 0x4],EBP
LEA EAX,[RBP + 0x1]
ADD dword ptr [R13],0x1
CMP dword ptr [RCX + 0x4],EBP
JL 0x001016a0
MOV dword ptr [R15 + 0x4],EAX
MOV EBP,EAX
JMP 0x00101642
LAB_00101695:
MOV R13,R14
MOV R14D,dword ptr [RSP + 0x7c]
MOV R15,RBP
LAB_001016a0:
MOV RDI,R15
CALL 0x001010a0
MOV RCX,qword ptr [RSP + 0x20]
LEA EAX,[R14 + 0x1]
CMP dword ptr [RCX],R14D
JL 0x001015b3
MOV RCX,qword ptr [RSP + 0x40]
MOV R14D,EAX
MOV dword ptr [RCX],EAX
JMP 0x00101612
LAB_001016d0:
ADD EBX,EBX
MOV RDI,R12
MOV dword ptr [RSP + 0x8c],EBX
MOVSXD RBX,EBX
LEA RSI,[RBX*0x8]
CALL 0x001010f0
MOVSXD RBX,dword ptr [R13]
MOV qword ptr [RSP + 0x90],RAX
MOV R12,RAX
JMP 0x00101657
LAB_00101700:
MOV R12,qword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x7c],R14D
MOV RBP,R15
MOV R14,R13
MOV R13D,ECX
LAB_00101713:
MOV EDI,0xc
CALL 0x001010e0
MOV R15,qword ptr [RBP]
CMP dword ptr [RSP + 0xc],0x3
MOV RCX,RAX
MOV qword ptr [RAX],R15
MOV EAX,dword ptr [R12 + 0x8]
LEA R8D,[RAX + -0x1]
MOV dword ptr [RCX + 0x8],R8D
JNZ 0x00101839
MOV RAX,R15
MOV qword ptr [RSP + 0x18],RCX
SAR RAX,0x20
MOV qword ptr [RSP + 0x28],RBP
MOV EBP,R8D
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x30],R13D
MOV R13,R14
LAB_00101760:
MOV EBX,dword ptr [R13]
MOV R14,qword ptr [RSP + 0x90]
CMP EBX,dword ptr [RSP + 0x8c]
JZ 0x00101808
LAB_00101779:
MOV EDI,0xc
CALL 0x001010e0
MOVSXD RDX,EBX
MOV EDI,dword ptr [RSP + 0x10]
MOV qword ptr [R14 + RDX*0x8],RAX
MOVSXD RAX,dword ptr [R13]
MOV RAX,qword ptr [R14 + RAX*0x8]
MOV dword ptr [RAX],R15D
MOVSXD RAX,dword ptr [R13]
MOV RAX,qword ptr [R14 + RAX*0x8]
MOV dword ptr [RAX + 0x4],EDI
MOVSXD RAX,dword ptr [R13]
MOV RAX,qword ptr [R14 + RAX*0x8]
MOV dword ptr [RAX + 0x8],EBP
LEA EAX,[RBP + 0x1]
ADD dword ptr [R13],0x1
CMP EBP,dword ptr [R12 + 0x8]
JG 0x001017d0
MOV RDI,qword ptr [RSP + 0x18]
MOV EBP,EAX
MOV dword ptr [RDI + 0x8],EAX
JMP 0x00101760
LAB_001017d0:
MOV R14,R13
MOV RBP,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x18]
MOV R13D,dword ptr [RSP + 0x30]
LAB_001017e2:
MOV RDI,RCX
CALL 0x001010a0
LEA EAX,[R13 + 0x1]
CMP R13D,dword ptr [R12 + 0x4]
JG 0x00101695
MOV dword ptr [RBP + 0x4],EAX
MOV R13D,EAX
JMP 0x00101713
LAB_00101808:
LEA EDX,[RBX + RBX*0x1]
MOV RDI,R14
MOV dword ptr [RSP + 0x8c],EDX
MOVSXD RDX,EDX
LEA RSI,[RDX*0x8]
CALL 0x001010f0
MOV EBX,dword ptr [R13]
MOV qword ptr [RSP + 0x90],RAX
MOV R14,RAX
JMP 0x00101779
LAB_00101839:
MOV dword ptr [RSP + 0x78],R13D
MOV RBX,RCX
MOV qword ptr [RSP + 0x70],RBP
MOV EBP,R8D
LAB_00101849:
MOV EDI,0x10
CALL 0x001010e0
CMP dword ptr [RSP + 0xc],0x4
MOV R8,RAX
MOV RAX,qword ptr [RBX]
MOV qword ptr [R8],RAX
MOV EAX,dword ptr [RBX + 0x8]
MOV dword ptr [R8 + 0x8],EAX
MOV EAX,dword ptr [R12 + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R8 + 0xc],ECX
JNZ 0x00101961
MOV dword ptr [RSP + 0x10],EBP
MOV EBP,ECX
MOV qword ptr [RSP + 0x18],RBX
MOV RBX,R8
LAB_00101888:
MOVSXD R15,dword ptr [R14]
MOV R13,qword ptr [RSP + 0x90]
CMP R15D,dword ptr [RSP + 0x8c]
JZ 0x00101930
LAB_001018a1:
MOV EDI,0x10
CALL 0x001010e0
MOV EDX,dword ptr [RBX]
MOV qword ptr [R13 + R15*0x8],RAX
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [R13 + RAX*0x8]
MOV dword ptr [RAX],EDX
MOVSXD RAX,dword ptr [R14]
MOV EDX,dword ptr [RBX + 0x4]
MOV RAX,qword ptr [R13 + RAX*0x8]
MOV dword ptr [RAX + 0x4],EDX
MOVSXD RAX,dword ptr [R14]
MOV EDX,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [R13 + RAX*0x8]
MOV dword ptr [RAX + 0x8],EDX
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [R13 + RAX*0x8]
MOV dword ptr [RAX + 0xc],EBP
LEA EAX,[RBP + 0x1]
ADD dword ptr [R14],0x1
CMP EBP,dword ptr [R12 + 0xc]
JG 0x00101900
MOV dword ptr [RBX + 0xc],EAX
MOV EBP,EAX
JMP 0x00101888
LAB_00101900:
MOV R8,RBX
MOV RBX,qword ptr [RSP + 0x18]
MOV EBP,EDX
LAB_0010190a:
MOV RDI,R8
CALL 0x001010a0
LEA EAX,[RBP + 0x1]
CMP EBP,dword ptr [R12 + 0x8]
JG 0x00101e93
MOV dword ptr [RBX + 0x8],EAX
MOV EBP,EAX
JMP 0x00101849
LAB_00101930:
ADD R15D,R15D
MOV RDI,R13
MOV dword ptr [RSP + 0x8c],R15D
MOVSXD R15,R15D
LEA RSI,[R15*0x8]
CALL 0x001010f0
MOVSXD R15,dword ptr [R14]
MOV qword ptr [RSP + 0x90],RAX
MOV R13,RAX
JMP 0x001018a1
LAB_00101961:
MOV qword ptr [RSP + 0x68],RBX
MOV R15D,ECX
MOV dword ptr [RSP + 0x64],EBP
MOV RBP,R8
LAB_00101970:
MOV EDI,0x14
CALL 0x001010e0
MOV RSI,qword ptr [RBP]
MOV RBX,qword ptr [RBP + 0x8]
MOV R8,RAX
CMP dword ptr [RSP + 0xc],0x5
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RBX
MOV EAX,dword ptr [R12 + 0x10]
LEA R9D,[RAX + -0x1]
MOV dword ptr [R8 + 0x10],R9D
JNZ 0x00101ad0
MOV R13,RSI
MOV qword ptr [RSP + 0x30],RBP
SAR R13,0x20
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x10],R13
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x3c],R15D
MOV R15D,R9D
LAB_001019c7:
MOV R13D,dword ptr [R14]
MOV RBP,qword ptr [RSP + 0x90]
CMP R13D,dword ptr [RSP + 0x8c]
JZ 0x00101a98
LAB_001019e0:
MOV EDI,0x14
CALL 0x001010e0
MOVSXD RSI,R13D
MOV EDI,dword ptr [RSP + 0x18]
MOV qword ptr [RBP + RSI*0x8],RAX
MOVSXD RAX,dword ptr [R14]
MOV RSI,RBX
SAR RSI,0x20
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX],EDI
MOVSXD RAX,dword ptr [R14]
MOV EDI,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x4],EDI
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x8],EBX
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0xc],ESI
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x10],R15D
LEA EAX,[R15 + 0x1]
ADD dword ptr [R14],0x1
CMP R15D,dword ptr [R12 + 0x10]
JG 0x00101a60
MOV RDI,qword ptr [RSP + 0x28]
MOV R15D,EAX
MOV dword ptr [RDI + 0x10],EAX
JMP 0x001019c7
LAB_00101a60:
MOV RBP,qword ptr [RSP + 0x30]
MOV R15D,dword ptr [RSP + 0x3c]
MOV R8,qword ptr [RSP + 0x28]
LAB_00101a6f:
MOV RDI,R8
CALL 0x001010a0
LEA EAX,[R15 + 0x1]
CMP R15D,dword ptr [R12 + 0xc]
JG 0x00101e82
MOV dword ptr [RBP + 0xc],EAX
MOV R15D,EAX
JMP 0x00101970
LAB_00101a98:
LEA ESI,[R13 + R13*0x1]
MOV RDI,RBP
MOV dword ptr [RSP + 0x8c],ESI
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010f0
MOV R13D,dword ptr [R14]
MOV qword ptr [RSP + 0x90],RAX
MOV RBP,RAX
JMP 0x001019e0
LAB_00101ad0:
MOV dword ptr [RSP + 0x28],R9D
MOV dword ptr [RSP + 0x60],R15D
MOV qword ptr [RSP + 0x58],RBP
MOV RBP,R8
LAB_00101ae2:
MOV EDI,0x18
CALL 0x001010e0
MOVDQU XMM3,xmmword ptr [RBP]
CMP dword ptr [RSP + 0xc],0x6
MOV RDX,RAX
MOVUPS xmmword ptr [RAX],XMM3
MOV EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RDX + 0x10],EAX
MOV EAX,dword ptr [R12 + 0x14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDX + 0x14],ECX
JNZ 0x00101c10
MOV qword ptr [RSP + 0x10],RBP
MOV R15,RDX
MOV EBP,ECX
LAB_00101b1d:
MOV R13D,dword ptr [R14]
MOV RBX,qword ptr [RSP + 0x90]
CMP R13D,dword ptr [RSP + 0x8c]
JZ 0x00101be0
LAB_00101b36:
MOV EDI,0x18
CALL 0x001010e0
MOVSXD RSI,R13D
MOV EDX,dword ptr [RSP + 0x28]
MOV qword ptr [RBX + RSI*0x8],RAX
MOVSXD RAX,dword ptr [R14]
MOV ESI,dword ptr [R15]
MOV RAX,qword ptr [RBX + RAX*0x8]
MOV dword ptr [RAX],ESI
MOVSXD RAX,dword ptr [R14]
MOV ESI,dword ptr [R15 + 0x4]
MOV RAX,qword ptr [RBX + RAX*0x8]
MOV dword ptr [RAX + 0x4],ESI
MOVSXD RAX,dword ptr [R14]
MOV ESI,dword ptr [R15 + 0x8]
MOV RAX,qword ptr [RBX + RAX*0x8]
MOV dword ptr [RAX + 0x8],ESI
MOVSXD RAX,dword ptr [R14]
MOV ESI,dword ptr [R15 + 0xc]
MOV RAX,qword ptr [RBX + RAX*0x8]
MOV dword ptr [RAX + 0xc],ESI
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [RBX + RAX*0x8]
MOV dword ptr [RAX + 0x10],EDX
MOVSXD RAX,dword ptr [R14]
MOV RAX,qword ptr [RBX + RAX*0x8]
MOV dword ptr [RAX + 0x14],EBP
LEA EAX,[RBP + 0x1]
ADD dword ptr [R14],0x1
CMP EBP,dword ptr [R12 + 0x14]
JG 0x00101bb0
MOV dword ptr [R15 + 0x14],EAX
MOV EBP,EAX
JMP 0x00101b1d
LAB_00101bb0:
MOV RBP,qword ptr [RSP + 0x10]
MOV RDX,R15
LAB_00101bb8:
MOV RDI,RDX
CALL 0x001010a0
MOV EDX,dword ptr [RSP + 0x28]
LEA EAX,[RDX + 0x1]
CMP EDX,dword ptr [R12 + 0x10]
JG 0x00101e70
MOV dword ptr [RBP + 0x10],EAX
MOV dword ptr [RSP + 0x28],EAX
JMP 0x00101ae2
LAB_00101be0:
LEA ESI,[R13 + R13*0x1]
MOV RDI,RBX
MOV dword ptr [RSP + 0x8c],ESI
MOVSXD RSI,ESI
SHL RSI,0x3
CALL 0x001010f0
MOV R13D,dword ptr [R14]
MOV qword ptr [RSP + 0x90],RAX
MOV RBX,RAX
JMP 0x00101b36
LAB_00101c10:
MOV qword ptr [RSP + 0x50],RBP
MOV R15,R14
MOV EBX,ECX
MOV R14,RDX
LAB_00101c1d:
MOV EDI,0x1c
CALL 0x001010e0
MOVDQU XMM2,xmmword ptr [R14]
CMP dword ptr [RSP + 0xc],0x7
MOV R13,RAX
MOVUPS xmmword ptr [RAX],XMM2
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [R13 + 0x10],RAX
MOV EAX,dword ptr [R12 + 0x18]
LEA R8D,[RAX + -0x1]
MOV dword ptr [R13 + 0x18],R8D
JNZ 0x00101d80
MOV dword ptr [RSP + 0x10],EBX
MOV RAX,R12
MOV R12,R13
MOV qword ptr [RSP + 0x18],R14
MOV R13,RAX
MOV R14D,R8D
LAB_00101c67:
MOVSXD RBX,dword ptr [R15]
MOV RBP,qword ptr [RSP + 0x90]
CMP EBX,dword ptr [RSP + 0x8c]
JZ 0x00101d50
LAB_00101c7f:
MOV EDI,0x1c
CALL 0x001010e0
MOV ECX,dword ptr [R12]
MOV EDX,dword ptr [RSP + 0x10]
MOV qword ptr [RBP + RBX*0x8],RAX
MOVSXD RAX,dword ptr [R15]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX],ECX
MOVSXD RAX,dword ptr [R15]
MOV ECX,dword ptr [R12 + 0x4]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x4],ECX
MOVSXD RAX,dword ptr [R15]
MOV ECX,dword ptr [R12 + 0x8]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x8],ECX
MOVSXD RAX,dword ptr [R15]
MOV ECX,dword ptr [R12 + 0xc]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0xc],ECX
MOVSXD RAX,dword ptr [R15]
MOV ECX,dword ptr [R12 + 0x10]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x10],ECX
MOVSXD RAX,dword ptr [R15]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x14],EDX
MOVSXD RAX,dword ptr [R15]
MOV RAX,qword ptr [RBP + RAX*0x8]
MOV dword ptr [RAX + 0x18],R14D
LEA EAX,[R14 + 0x1]
ADD dword ptr [R15],0x1
CMP R14D,dword ptr [R13 + 0x18]
JG 0x00101d18
MOV dword ptr [R12 + 0x18],EAX
MOV R14D,EAX
JMP 0x00101c67
LAB_00101d18:
MOV RAX,R13
MOV R14,qword ptr [RSP + 0x18]
MOV R13,R12
MOV EBX,EDX
MOV R12,RAX
LAB_00101d28:
MOV RDI,R13
CALL 0x001010a0
LEA EAX,[RBX + 0x1]
CMP EBX,dword ptr [R12 + 0x14]
JG 0x00101e60
MOV dword ptr [R14 + 0x14],EAX
MOV EBX,EAX
JMP 0x00101c1d
LAB_00101d50:
ADD EBX,EBX
MOV RDI,RBP
MOV dword ptr [RSP + 0x8c],EBX
MOVSXD RBX,EBX
LEA RSI,[RBX*0x8]
CALL 0x001010f0
MOVSXD RBX,dword ptr [R15]
MOV qword ptr [RSP + 0x90],RAX
MOV RBP,RAX
JMP 0x00101c7f
LAB_00101d80:
LEA RDI,[RSP + 0x90]
MOV dword ptr [RSP + 0x30],R8D
LEA RAX,[R12 + 0x20]
MOV qword ptr [RSP + 0x18],RDI
LEA RBP,[RSP + 0x8c]
MOV qword ptr [RSP + 0x48],R14
MOV qword ptr [RSP + 0x10],R15
MOV dword ptr [RSP + 0x3c],EBX
MOV RBX,RAX
LAB_00101db0:
MOV EDI,0x20
CALL 0x001010e0
MOVDQU XMM0,xmmword ptr [R13]
MOVDQU XMM1,xmmword ptr [R13 + 0xc]
MOV R14,RAX
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0xc],XMM1
MOV EAX,dword ptr [R12 + 0x1c]
LEA R15D,[RAX + -0x1]
MOV RAX,R14
MOV R14,R13
MOV R13,RAX
LAB_00101de2:
SUB RSP,0x8
MOV dword ptr [R13 + 0x1c],R15D
MOV ECX,0x8
MOV RDX,R13
PUSH RBP
MOV R9,qword ptr [RSP + 0x20]
MOV RDI,RBX
MOV R8,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x48]
CALL 0x00101300
MOV ECX,R15D
POP RAX
ADD R15D,0x1
POP RDX
CMP dword ptr [R12 + 0x1c],ECX
JGE 0x00101de2
MOV RAX,R13
MOV R13,R14
MOV RDI,RAX
CALL 0x001010a0
MOV EDX,dword ptr [RSP + 0x30]
LEA EAX,[RDX + 0x1]
CMP EDX,dword ptr [R12 + 0x18]
JG 0x00101e48
MOV dword ptr [R14 + 0x18],EAX
MOV dword ptr [RSP + 0x30],EAX
JMP 0x00101db0
LAB_00101e48:
MOV EBX,dword ptr [RSP + 0x3c]
MOV R14,qword ptr [RSP + 0x48]
MOV R15,qword ptr [RSP + 0x10]
JMP 0x00101d28
LAB_00101e60:
MOV RDX,R14
MOV RBP,qword ptr [RSP + 0x50]
MOV R14,R15
JMP 0x00101bb8
LAB_00101e70:
MOV R8,RBP
MOV R15D,dword ptr [RSP + 0x60]
MOV RBP,qword ptr [RSP + 0x58]
JMP 0x00101a6f
LAB_00101e82:
MOV R8,RBP
MOV RBX,qword ptr [RSP + 0x68]
MOV EBP,dword ptr [RSP + 0x64]
JMP 0x0010190a
LAB_00101e93:
MOV RBP,qword ptr [RSP + 0x70]
MOV R13D,dword ptr [RSP + 0x78]
MOV RCX,RBX
JMP 0x001017e2
LAB_00101ea5:
CALL 0x001010b0 | int8 * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int4 uVar5;
int iVar6;
int8 uVar7;
int8 uVar8;
bool bVar9;
int8 uVar10;
int8 *puVar11;
void *pvVar12;
int *__ptr;
int *__ptr_00;
int8 *puVar13;
int8 *puVar14;
int8 *puVar15;
int8 *puVar16;
int8 *puVar17;
int iVar18;
int iVar19;
int iVar20;
long in_FS_OFFSET;
int4 local_c8;
int4 local_c0;
int local_4c;
int8 *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar11 = (int8 *)malloc(0x50);
*param_3 = 0;
local_4c = 10;
local_48 = puVar11;
if (param_2 == 0) {
pvVar12 = malloc(0);
*param_3 = *param_3 + 1;
*puVar11 = pvVar12;
}
else {
__ptr = (int *)malloc(4);
iVar1 = *param_1 + -1;
*__ptr = iVar1;
if (param_2 == 1) {
while( true ) {
iVar2 = *param_3;
if (iVar2 == local_4c) {
local_4c = iVar2 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c * 8);
iVar2 = *param_3;
}
puVar11 = local_48;
pvVar12 = malloc(4);
puVar11[iVar2] = pvVar12;
*(int *)puVar11[*param_3] = iVar1;
*param_3 = *param_3 + 1;
if (*param_1 < iVar1) break;
*__ptr = iVar1 + 1;
iVar1 = iVar1 + 1;
}
}
else {
while( true ) {
__ptr_00 = (int *)malloc(8);
*__ptr_00 = iVar1;
iVar2 = param_1[1] + -1;
__ptr_00[1] = iVar2;
if (param_2 == 2) {
while( true ) {
iVar3 = *param_3;
if (iVar3 == local_4c) {
local_4c = iVar3 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c * 8);
iVar3 = *param_3;
}
puVar11 = local_48;
pvVar12 = malloc(8);
puVar11[iVar3] = pvVar12;
*(int *)puVar11[*param_3] = iVar1;
*(int *)(puVar11[*param_3] + 4) = iVar2;
*param_3 = *param_3 + 1;
if (param_1[1] < iVar2) break;
__ptr_00[1] = iVar2 + 1;
iVar2 = iVar2 + 1;
}
}
else {
while( true ) {
puVar11 = (int8 *)malloc(0xc);
uVar7 = *(int8 *)__ptr_00;
*puVar11 = uVar7;
iVar3 = param_1[2] + -1;
*(int *)(puVar11 + 1) = iVar3;
if (param_2 == 3) {
while( true ) {
iVar18 = *param_3;
if (iVar18 == local_4c) {
local_4c = iVar18 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c * 8);
iVar18 = *param_3;
}
puVar13 = local_48;
pvVar12 = malloc(0xc);
local_c8 = (int4)((ulong)uVar7 >> 0x20);
puVar13[iVar18] = pvVar12;
*(int *)puVar13[*param_3] = (int)uVar7;
*(int4 *)(puVar13[*param_3] + 4) = local_c8;
*(int *)(puVar13[*param_3] + 8) = iVar3;
*param_3 = *param_3 + 1;
if (param_1[2] < iVar3) break;
*(int *)(puVar11 + 1) = iVar3 + 1;
iVar3 = iVar3 + 1;
}
}
else {
while( true ) {
puVar13 = (int8 *)malloc(0x10);
*puVar13 = *puVar11;
*(int4 *)(puVar13 + 1) = *(int4 *)(puVar11 + 1);
iVar18 = param_1[3] + -1;
*(int *)((long)puVar13 + 0xc) = iVar18;
if (param_2 == 4) {
while( true ) {
iVar4 = *param_3;
if (iVar4 == local_4c) {
local_4c = iVar4 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c * 8);
iVar4 = *param_3;
}
puVar14 = local_48;
pvVar12 = malloc(0x10);
uVar5 = *(int4 *)puVar13;
puVar14[iVar4] = pvVar12;
*(int4 *)puVar14[*param_3] = uVar5;
*(int4 *)(puVar14[*param_3] + 4) = *(int4 *)((long)puVar13 + 4);
*(int *)(puVar14[*param_3] + 8) = iVar3;
*(int *)(puVar14[*param_3] + 0xc) = iVar18;
*param_3 = *param_3 + 1;
if (param_1[3] < iVar18) break;
*(int *)((long)puVar13 + 0xc) = iVar18 + 1;
iVar18 = iVar18 + 1;
}
}
else {
while( true ) {
puVar14 = (int8 *)malloc(0x14);
uVar7 = *puVar13;
uVar8 = puVar13[1];
*puVar14 = uVar7;
puVar14[1] = uVar8;
iVar4 = param_1[4] + -1;
*(int *)(puVar14 + 2) = iVar4;
if (param_2 == 5) {
while( true ) {
iVar19 = *param_3;
if (iVar19 == local_4c) {
local_4c = iVar19 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c << 3);
iVar19 = *param_3;
}
puVar15 = local_48;
pvVar12 = malloc(0x14);
local_c0 = (int4)uVar7;
puVar15[iVar19] = pvVar12;
*(int4 *)puVar15[*param_3] = local_c0;
local_c8 = (int4)((ulong)uVar7 >> 0x20);
*(int4 *)(puVar15[*param_3] + 4) = local_c8;
*(int *)(puVar15[*param_3] + 8) = (int)uVar8;
*(int *)(puVar15[*param_3] + 0xc) = (int)((ulong)uVar8 >> 0x20);
*(int *)(puVar15[*param_3] + 0x10) = iVar4;
*param_3 = *param_3 + 1;
if (param_1[4] < iVar4) break;
*(int *)(puVar14 + 2) = iVar4 + 1;
iVar4 = iVar4 + 1;
}
}
else {
while( true ) {
puVar15 = (int8 *)malloc(0x18);
uVar7 = puVar14[1];
*puVar15 = *puVar14;
puVar15[1] = uVar7;
*(int4 *)(puVar15 + 2) = *(int4 *)(puVar14 + 2);
iVar19 = param_1[5] + -1;
*(int *)((long)puVar15 + 0x14) = iVar19;
if (param_2 == 6) {
while( true ) {
iVar20 = *param_3;
if (iVar20 == local_4c) {
local_4c = iVar20 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c << 3);
iVar20 = *param_3;
}
puVar16 = local_48;
pvVar12 = malloc(0x18);
puVar16[iVar20] = pvVar12;
*(int4 *)puVar16[*param_3] = *(int4 *)puVar15;
*(int4 *)(puVar16[*param_3] + 4) =
*(int4 *)((long)puVar15 + 4);
*(int4 *)(puVar16[*param_3] + 8) = *(int4 *)(puVar15 + 1);
*(int4 *)(puVar16[*param_3] + 0xc) =
*(int4 *)((long)puVar15 + 0xc);
*(int *)(puVar16[*param_3] + 0x10) = iVar4;
*(int *)(puVar16[*param_3] + 0x14) = iVar19;
*param_3 = *param_3 + 1;
if (param_1[5] < iVar19) break;
*(int *)((long)puVar15 + 0x14) = iVar19 + 1;
iVar19 = iVar19 + 1;
}
}
else {
while( true ) {
puVar16 = (int8 *)malloc(0x1c);
uVar7 = puVar15[1];
*puVar16 = *puVar15;
puVar16[1] = uVar7;
puVar16[2] = puVar15[2];
iVar20 = param_1[6] + -1;
*(int *)(puVar16 + 3) = iVar20;
if (param_2 == 7) {
while( true ) {
iVar6 = *param_3;
if (iVar6 == local_4c) {
local_4c = iVar6 * 2;
local_48 = (int8 *)realloc(local_48,(long)local_4c * 8);
iVar6 = *param_3;
}
puVar17 = local_48;
pvVar12 = malloc(0x1c);
uVar5 = *(int4 *)puVar16;
puVar17[iVar6] = pvVar12;
*(int4 *)puVar17[*param_3] = uVar5;
*(int4 *)(puVar17[*param_3] + 4) =
*(int4 *)((long)puVar16 + 4);
*(int4 *)(puVar17[*param_3] + 8) =
*(int4 *)(puVar16 + 1);
*(int4 *)(puVar17[*param_3] + 0xc) =
*(int4 *)((long)puVar16 + 0xc);
*(int4 *)(puVar17[*param_3] + 0x10) =
*(int4 *)(puVar16 + 2);
*(int *)(puVar17[*param_3] + 0x14) = iVar19;
*(int *)(puVar17[*param_3] + 0x18) = iVar20;
*param_3 = *param_3 + 1;
if (param_1[6] < iVar20) break;
*(int *)(puVar16 + 3) = iVar20 + 1;
iVar20 = iVar20 + 1;
}
}
else {
while( true ) {
puVar17 = (int8 *)malloc(0x20);
uVar7 = puVar16[1];
uVar8 = *(int8 *)((long)puVar16 + 0xc);
uVar10 = *(int8 *)((long)puVar16 + 0x14);
*puVar17 = *puVar16;
puVar17[1] = uVar7;
*(int8 *)((long)puVar17 + 0xc) = uVar8;
*(int8 *)((long)puVar17 + 0x14) = uVar10;
iVar6 = param_1[7] + -1;
do {
*(int *)((long)puVar17 + 0x1c) = iVar6;
adjac(param_1 + 8,param_2 + -8,puVar17,8,&local_48,param_3,
&local_4c);
bVar9 = iVar6 <= param_1[7];
iVar6 = iVar6 + 1;
} while (bVar9);
free(puVar17);
if (param_1[6] < iVar20) break;
*(int *)(puVar16 + 3) = iVar20 + 1;
iVar20 = iVar20 + 1;
}
}
free(puVar16);
if (param_1[5] < iVar19) break;
*(int *)((long)puVar15 + 0x14) = iVar19 + 1;
iVar19 = iVar19 + 1;
}
}
free(puVar15);
if (param_1[4] < iVar4) break;
*(int *)(puVar14 + 2) = iVar4 + 1;
iVar4 = iVar4 + 1;
}
}
free(puVar14);
if (param_1[3] < iVar18) break;
*(int *)((long)puVar13 + 0xc) = iVar18 + 1;
iVar18 = iVar18 + 1;
}
}
free(puVar13);
if (param_1[2] < iVar3) break;
*(int *)(puVar11 + 1) = iVar3 + 1;
iVar3 = iVar3 + 1;
}
}
free(puVar11);
if (param_1[1] < iVar2) break;
__ptr_00[1] = iVar2 + 1;
iVar2 = iVar2 + 1;
}
}
free(__ptr_00);
if (*param_1 < iVar1) break;
*__ptr = iVar1 + 1;
iVar1 = iVar1 + 1;
}
}
free(__ptr);
puVar11 = local_48;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar11;
} |
6,416 | func0 |
#include <assert.h>
#include <string.h>
| void func0(char* text) {
for (int i = 0; text[i] != '\0'; ++i) {
if (text[i] == ' ') {
text[i] = '_';
}
}
}
| int main() {
char text1[] = "Jumanji The Jungle";
char text2[] = "The Avengers";
char text3[] = "Fast and Furious";
func0(text1);
func0(text2);
func0(text3);
assert(strcmp(text1, "Jumanji_The_Jungle") == 0);
assert(strcmp(text2, "The_Avengers") == 0);
assert(strcmp(text3, "Fast_and_Furious") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c6 <func0+0x3d>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 11c2 <func0+0x39>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 119e <func0+0x15>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_11C6
loc_119E:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_11C2
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
loc_11C2:
add [rbp+var_4], 1
loc_11C6:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_119E
nop
nop
pop rbp
retn | long long func0(long long a1)
{
long long result; // rax
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = *(unsigned __int8 *)(i + a1);
if ( !(_BYTE)result )
break;
if ( *(_BYTE *)(i + a1) == 32 )
*(_BYTE *)(i + a1) = 95;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c6
LAB_0010119e:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x001011c2
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
LAB_001011c2:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010119e
NOP
NOP
POP RBP
RET | void func0(long param_1)
{
int4 local_c;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == ' ') {
*(int *)(param_1 + local_c) = 0x5f;
}
}
return;
} |
6,417 | func0 |
#include <assert.h>
#include <string.h>
| void func0(char* text) {
for (int i = 0; text[i] != '\0'; ++i) {
if (text[i] == ' ') {
text[i] = '_';
}
}
}
| int main() {
char text1[] = "Jumanji The Jungle";
char text2[] = "The Avengers";
char text3[] = "Fast and Furious";
func0(text1);
func0(text2);
func0(text3);
assert(strcmp(text1, "Jumanji_The_Jungle") == 0);
assert(strcmp(text2, "The_Avengers") == 0);
assert(strcmp(text3, "Fast_and_Furious") == 0);
return 0;
}
| O1 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
jne 1180 <func0+0x17>
retq
add $0x1,%rdi
movzbl (%rdi),%eax
test %al,%al
je 1174 <func0+0xb>
cmp $0x20,%al
jne 1175 <func0+0xc>
movb $0x5f,(%rdi)
jmp 1175 <func0+0xc>
| func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jnz short loc_11A0
locret_1194:
retn
loc_1195:
add rdi, 1
movzx eax, byte ptr [rdi]
test al, al
jz short locret_1194
loc_11A0:
cmp al, 20h ; ' '
jnz short loc_1195
mov byte ptr [rdi], 5Fh ; '_'
jmp short loc_1195 | long long func0(_BYTE *a1)
{
long long result; // rax
for ( result = (unsigned __int8)*a1; (_BYTE)result; result = (unsigned __int8)*a1 )
{
if ( (_BYTE)result == 32 )
*a1 = 95;
++a1;
}
return result;
} | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JNZ 0x001011a0
LAB_00101194:
RET
LAB_00101195:
ADD RDI,0x1
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101194
LAB_001011a0:
CMP AL,0x20
JNZ 0x00101195
MOV byte ptr [RDI],0x5f
JMP 0x00101195 | void func0(char *param_1)
{
char cVar1;
cVar1 = *param_1;
while (cVar1 != '\0') {
if (cVar1 == ' ') {
*param_1 = '_';
}
param_1 = param_1 + 1;
cVar1 = *param_1;
}
return;
} |
6,418 | func0 |
#include <assert.h>
#include <string.h>
| void func0(char* text) {
for (int i = 0; text[i] != '\0'; ++i) {
if (text[i] == ' ') {
text[i] = '_';
}
}
}
| int main() {
char text1[] = "Jumanji The Jungle";
char text2[] = "The Avengers";
char text3[] = "Fast and Furious";
func0(text1);
func0(text2);
func0(text3);
assert(strcmp(text1, "Jumanji_The_Jungle") == 0);
assert(strcmp(text2, "The_Avengers") == 0);
assert(strcmp(text3, "Fast_and_Furious") == 0);
return 0;
}
| O2 | c | func0:
endbr64
jmp 134b <func0+0x1b>
nopw %cs:0x0(%rax,%rax,1)
cmp $0x20,%al
jne 1347 <func0+0x17>
movb $0x5f,(%rdi)
add $0x1,%rdi
movzbl (%rdi),%eax
test %al,%al
jne 1340 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
jmp short loc_135B
loc_1350:
cmp al, 20h ; ' '
jnz short loc_1357
mov byte ptr [rdi], 5Fh ; '_'
loc_1357:
add rdi, 1
loc_135B:
movzx eax, byte ptr [rdi]
test al, al
jnz short loc_1350
retn | long long func0(_BYTE *a1)
{
long long result; // rax
while ( 1 )
{
result = (unsigned __int8)*a1;
if ( !(_BYTE)result )
break;
if ( (_BYTE)result == 32 )
*a1 = 95;
++a1;
}
return result;
} | func0:
ENDBR64
JMP 0x0010135b
LAB_00101350:
CMP AL,0x20
JNZ 0x00101357
MOV byte ptr [RDI],0x5f
LAB_00101357:
ADD RDI,0x1 | void func0(void)
{
FUN_0010135b();
return;
} |
6,419 | func0 |
#include <assert.h>
#include <string.h>
| void func0(char* text) {
for (int i = 0; text[i] != '\0'; ++i) {
if (text[i] == ' ') {
text[i] = '_';
}
}
}
| int main() {
char text1[] = "Jumanji The Jungle";
char text2[] = "The Avengers";
char text3[] = "Fast and Furious";
func0(text1);
func0(text2);
func0(text3);
assert(strcmp(text1, "Jumanji_The_Jungle") == 0);
assert(strcmp(text2, "The_Avengers") == 0);
assert(strcmp(text3, "Fast_and_Furious") == 0);
return 0;
}
| O3 | c | func0:
endbr64
jmp 1384 <func0+0x14>
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%rdi
movzbl (%rdi),%eax
test %al,%al
je 13a0 <func0+0x30>
cmp $0x20,%al
jne 1380 <func0+0x10>
movb $0x5f,(%rdi)
movzbl 0x1(%rdi),%eax
add $0x1,%rdi
test %al,%al
jne 138b <func0+0x1b>
retq
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
jmp short loc_1384
loc_1380:
add rdi, 1
loc_1384:
movzx eax, byte ptr [rdi]
test al, al
jz short locret_13A0
loc_138B:
cmp al, 20h ; ' '
jnz short loc_1380
mov byte ptr [rdi], 5Fh ; '_'
movzx eax, byte ptr [rdi+1]
add rdi, 1
test al, al
jnz short loc_138B
retn
locret_13A0:
retn | long long func0(_BYTE *a1)
{
long long result; // rax
while ( 1 )
{
result = (unsigned __int8)*a1;
if ( !(_BYTE)result )
break;
while ( (_BYTE)result == 32 )
{
*a1 = 95;
result = (unsigned __int8)*++a1;
if ( !(_BYTE)result )
return result;
}
++a1;
}
return result;
} | func0:
ENDBR64
JMP 0x00101384
LAB_00101380:
ADD RDI,0x1 | void func0(void)
{
FUN_00101384();
return;
} |
6,420 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int num_list[], int size, int result[]) {
int zero_count = 0;
int j = 0;
for (int i = 0; i < size; i++) {
if (num_list[i] == 0) {
zero_count++;
} else {
result[j++] = num_list[i];
}
}
for (int i = 0; i < zero_count; i++) {
result[j++] = 0;
}
}
| int main() {
int result[6];
int list1[6] = {1, 0, 2, 0, 3, 4};
func0(list1, 6, result);
int expected1[6] = {1, 2, 3, 4, 0, 0};
for (int i = 0; i < 6; i++) {
assert(result[i] == expected1[i]);
}
int result2[9];
int list2[9] = {2, 3, 2, 0, 0, 4, 0, 5, 0};
func0(list2, 9, result2);
int expected2[9] = {2, 3, 2, 4, 5, 0, 0, 0, 0};
for (int i = 0; i < 9; i++) {
assert(result2[i] == expected2[i]);
}
int result3[5];
int list3[5] = {0, 1, 0, 1, 1};
func0(list3, 5, result3);
int expected3[5] = {1, 1, 1, 0, 0};
for (int i = 0; i < 5; i++) {
assert(result3[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 120a <func0+0x81>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 11d3 <func0+0x4a>
addl $0x1,-0x10(%rbp)
jmp 1206 <func0+0x7d>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11b3 <func0+0x2a>
movl $0x0,-0x4(%rbp)
jmp 123f <func0+0xb6>
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movl $0x0,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 121b <func0+0x92>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_120A
loc_11B3:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jnz short loc_11D3
add [rbp+var_10], 1
jmp short loc_1206
loc_11D3:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1206:
add [rbp+var_8], 1
loc_120A:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_11B3
mov [rbp+var_4], 0
jmp short loc_123F
loc_121B:
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov dword ptr [rax], 0
add [rbp+var_4], 1
loc_123F:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_10]
jl short loc_121B
nop
nop
pop rbp
retn | long long func0(long long a1, int a2, long long a3)
{
int v3; // eax
int v4; // eax
long long result; // rax
int v6; // [rsp+18h] [rbp-10h]
int v7; // [rsp+1Ch] [rbp-Ch]
int i; // [rsp+20h] [rbp-8h]
unsigned int j; // [rsp+24h] [rbp-4h]
v6 = 0;
v7 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) )
{
v3 = v7++;
*(_DWORD *)(a3 + 4LL * v3) = *(_DWORD *)(4LL * i + a1);
}
else
{
++v6;
}
}
for ( j = 0; ; ++j )
{
result = j;
if ( (int)j >= v6 )
break;
v4 = v7++;
*(_DWORD *)(4LL * v4 + a3) = 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010120a
LAB_001011b3:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x001011d3
ADD dword ptr [RBP + -0x10],0x1
JMP 0x00101206
LAB_001011d3:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101206:
ADD dword ptr [RBP + -0x8],0x1
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011b3
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010123f
LAB_0010121b:
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV dword ptr [RAX],0x0
ADD dword ptr [RBP + -0x4],0x1
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x0010121b
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2,long param_3)
{
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_18 = 0;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if (*(int *)(param_1 + (long)local_10 * 4) == 0) {
local_18 = local_18 + 1;
}
else {
*(int4 *)((long)local_14 * 4 + param_3) = *(int4 *)((long)local_10 * 4 + param_1);
local_14 = local_14 + 1;
}
}
for (local_c = 0; local_c < local_18; local_c = local_c + 1) {
*(int4 *)(param_3 + (long)local_14 * 4) = 0;
local_14 = local_14 + 1;
}
return;
} |
6,421 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int num_list[], int size, int result[]) {
int zero_count = 0;
int j = 0;
for (int i = 0; i < size; i++) {
if (num_list[i] == 0) {
zero_count++;
} else {
result[j++] = num_list[i];
}
}
for (int i = 0; i < zero_count; i++) {
result[j++] = 0;
}
}
| int main() {
int result[6];
int list1[6] = {1, 0, 2, 0, 3, 4};
func0(list1, 6, result);
int expected1[6] = {1, 2, 3, 4, 0, 0};
for (int i = 0; i < 6; i++) {
assert(result[i] == expected1[i]);
}
int result2[9];
int list2[9] = {2, 3, 2, 0, 0, 4, 0, 5, 0};
func0(list2, 9, result2);
int expected2[9] = {2, 3, 2, 4, 5, 0, 0, 0, 0};
for (int i = 0; i < 9; i++) {
assert(result2[i] == expected2[i]);
}
int result3[5];
int list3[5] = {0, 1, 0, 1, 1};
func0(list3, 5, result3);
int expected3[5] = {1, 1, 1, 0, 0};
for (int i = 0; i < 5; i++) {
assert(result3[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11eb <func0+0x62>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%r8
mov $0x0,%esi
mov $0x0,%edi
jmp 11bb <func0+0x32>
movslq %esi,%r9
mov %ecx,(%rdx,%r9,4)
lea 0x1(%rsi),%esi
add $0x4,%rax
cmp %r8,%rax
je 11c6 <func0+0x3d>
mov (%rax),%ecx
test %ecx,%ecx
jne 11a8 <func0+0x1f>
add $0x1,%edi
jmp 11b2 <func0+0x29>
test %edi,%edi
jle 11eb <func0+0x62>
movslq %esi,%rsi
lea (%rdx,%rsi,4),%rax
lea -0x1(%rdi),%ecx
add %rcx,%rsi
lea 0x4(%rdx,%rsi,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 11dc <func0+0x53>
retq
| func0:
endbr64
test esi, esi
jle short locret_11EB
mov rax, rdi
lea ecx, [rsi-1]
lea r8, [rdi+rcx*4+4]
mov esi, 0
mov edi, 0
jmp short loc_11BB
loc_11A8:
movsxd r9, esi
mov [rdx+r9*4], ecx
lea esi, [rsi+1]
loc_11B2:
add rax, 4
cmp rax, r8
jz short loc_11C6
loc_11BB:
mov ecx, [rax]
test ecx, ecx
jnz short loc_11A8
add edi, 1
jmp short loc_11B2
loc_11C6:
test edi, edi
jle short locret_11EB
movsxd rsi, esi
lea rax, [rdx+rsi*4]
lea ecx, [rdi-1]
add rcx, rsi
lea rdx, [rdx+rcx*4+4]
loc_11DC:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_11DC
locret_11EB:
retn | void func0(_DWORD *a1, int a2, long long a3)
{
_DWORD *v3; // rax
long long v4; // r8
int v5; // esi
int v6; // edi
_DWORD *v7; // rax
unsigned long long v8; // rdx
if ( a2 > 0 )
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
v6 = 0;
do
{
if ( *v3 )
*(_DWORD *)(a3 + 4LL * v5++) = *v3;
else
++v6;
++v3;
}
while ( v3 != (_DWORD *)v4 );
if ( v6 > 0 )
{
v7 = (_DWORD *)(a3 + 4LL * v5);
v8 = a3 + 4 * (v5 + (unsigned long long)(unsigned int)(v6 - 1)) + 4;
do
*v7++ = 0;
while ( v7 != (_DWORD *)v8 );
}
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011eb
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA R8,[RDI + RCX*0x4 + 0x4]
MOV ESI,0x0
MOV EDI,0x0
JMP 0x001011bb
LAB_001011a8:
MOVSXD R9,ESI
MOV dword ptr [RDX + R9*0x4],ECX
LEA ESI,[RSI + 0x1]
LAB_001011b2:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001011c6
LAB_001011bb:
MOV ECX,dword ptr [RAX]
TEST ECX,ECX
JNZ 0x001011a8
ADD EDI,0x1
JMP 0x001011b2
LAB_001011c6:
TEST EDI,EDI
JLE 0x001011eb
MOVSXD RSI,ESI
LEA RAX,[RDX + RSI*0x4]
LEA ECX,[RDI + -0x1]
ADD RCX,RSI
LEA RDX,[RDX + RCX*0x4 + 0x4]
LAB_001011dc:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011dc
LAB_001011eb:
RET | void func0(int *param_1,int param_2,long param_3)
{
int *piVar1;
int4 *puVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
iVar4 = 0;
do {
if (*param_1 == 0) {
iVar4 = iVar4 + 1;
}
else {
*(int *)(param_3 + (long)iVar3 * 4) = *param_1;
iVar3 = iVar3 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
if (0 < iVar4) {
puVar2 = (int4 *)(param_3 + (long)iVar3 * 4);
do {
*puVar2 = 0;
puVar2 = puVar2 + 1;
} while (puVar2 != (int4 *)(param_3 + 4 + ((ulong)(iVar4 - 1) + (long)iVar3) * 4));
}
}
return;
} |
6,422 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int num_list[], int size, int result[]) {
int zero_count = 0;
int j = 0;
for (int i = 0; i < size; i++) {
if (num_list[i] == 0) {
zero_count++;
} else {
result[j++] = num_list[i];
}
}
for (int i = 0; i < zero_count; i++) {
result[j++] = 0;
}
}
| int main() {
int result[6];
int list1[6] = {1, 0, 2, 0, 3, 4};
func0(list1, 6, result);
int expected1[6] = {1, 2, 3, 4, 0, 0};
for (int i = 0; i < 6; i++) {
assert(result[i] == expected1[i]);
}
int result2[9];
int list2[9] = {2, 3, 2, 0, 0, 4, 0, 5, 0};
func0(list2, 9, result2);
int expected2[9] = {2, 3, 2, 4, 5, 0, 0, 0, 0};
for (int i = 0; i < 9; i++) {
assert(result2[i] == expected2[i]);
}
int result3[5];
int list3[5] = {0, 1, 0, 1, 1};
func0(list3, 5, result3);
int expected3[5] = {1, 1, 1, 0, 0};
for (int i = 0; i < 5; i++) {
assert(result3[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 147f <func0+0x6f>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
jmp 143c <func0+0x2c>
nopw %cs:0x0(%rax,%rax,1)
add $0x4,%rdi
add $0x1,%esi
cmp %r8,%rdi
je 1455 <func0+0x45>
mov (%rdi),%eax
test %eax,%eax
je 1430 <func0+0x20>
movslq %ecx,%r9
add $0x4,%rdi
add $0x1,%ecx
mov %eax,(%rdx,%r9,4)
cmp %r8,%rdi
jne 143c <func0+0x2c>
test %esi,%esi
je 147f <func0+0x6f>
movslq %ecx,%rcx
sub $0x1,%esi
lea (%rdx,%rcx,4),%rax
add %rsi,%rcx
lea 0x4(%rdx,%rcx,4),%rdx
nopl 0x0(%rax,%rax,1)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1470 <func0+0x60>
retq
| func0:
endbr64
mov r10, rdx
test esi, esi
jle short locret_1498
lea eax, [rsi-1]
xor ecx, ecx
xor esi, esi
lea r8, [rdi+rax*4+4]
jmp short loc_145C
loc_1450:
add rdi, 4
add esi, 1
cmp r8, rdi
jz short loc_1475
loc_145C:
mov eax, [rdi]
test eax, eax
jz short loc_1450
movsxd r9, ecx
add rdi, 4
add ecx, 1
mov [r10+r9*4], eax
cmp r8, rdi
jnz short loc_145C
loc_1475:
test esi, esi
jz short locret_1498
movsxd rsi, esi
movsxd rcx, ecx
lea rdx, ds:0[rsi*4]
lea rdi, [r10+rcx*4]
xor esi, esi
jmp _memset
locret_1498:
retn | void func0(int *a1, int a2, long long a3)
{
long long v3; // rax
int v4; // ecx
int v5; // esi
long long v6; // r8
int v7; // eax
long long v8; // r9
if ( a2 > 0 )
{
v3 = (unsigned int)(a2 - 1);
v4 = 0;
v5 = 0;
v6 = (long long)&a1[v3 + 1];
do
{
while ( 1 )
{
v7 = *a1;
if ( *a1 )
break;
++a1;
++v5;
if ( (int *)v6 == a1 )
goto LABEL_6;
}
v8 = v4;
++a1;
++v4;
*(_DWORD *)(a3 + 4 * v8) = v7;
}
while ( (int *)v6 != a1 );
LABEL_6:
if ( v5 )
memset(a3 + 4LL * v4, 0LL, 4LL * v5);
}
} | func0:
ENDBR64
MOV R10,RDX
TEST ESI,ESI
JLE 0x00101498
LEA EAX,[RSI + -0x1]
XOR ECX,ECX
XOR ESI,ESI
LEA R8,[RDI + RAX*0x4 + 0x4]
JMP 0x0010145c
LAB_00101450:
ADD RDI,0x4
ADD ESI,0x1
CMP R8,RDI
JZ 0x00101475
LAB_0010145c:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JZ 0x00101450
MOVSXD R9,ECX
ADD RDI,0x4
ADD ECX,0x1
MOV dword ptr [R10 + R9*0x4],EAX
CMP R8,RDI
JNZ 0x0010145c
LAB_00101475:
TEST ESI,ESI
JZ 0x00101498
MOVSXD RSI,ESI
MOVSXD RCX,ECX
LEA RDX,[RSI*0x4]
LEA RDI,[R10 + RCX*0x4]
XOR ESI,ESI
JMP 0x001010b0
LAB_00101498:
RET | void func0(int *param_1,int param_2,long param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
long lVar5;
if (0 < param_2) {
iVar3 = 0;
iVar4 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
while (iVar2 = *param_1, iVar2 != 0) {
lVar5 = (long)iVar3;
param_1 = param_1 + 1;
iVar3 = iVar3 + 1;
*(int *)(param_3 + lVar5 * 4) = iVar2;
if (piVar1 == param_1) goto LAB_00101475;
}
param_1 = param_1 + 1;
iVar4 = iVar4 + 1;
} while (piVar1 != param_1);
LAB_00101475:
if (iVar4 != 0) {
memset((void *)(param_3 + (long)iVar3 * 4),0,(long)iVar4 * 4);
return;
}
}
return;
} |
6,423 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int num_list[], int size, int result[]) {
int zero_count = 0;
int j = 0;
for (int i = 0; i < size; i++) {
if (num_list[i] == 0) {
zero_count++;
} else {
result[j++] = num_list[i];
}
}
for (int i = 0; i < zero_count; i++) {
result[j++] = 0;
}
}
| int main() {
int result[6];
int list1[6] = {1, 0, 2, 0, 3, 4};
func0(list1, 6, result);
int expected1[6] = {1, 2, 3, 4, 0, 0};
for (int i = 0; i < 6; i++) {
assert(result[i] == expected1[i]);
}
int result2[9];
int list2[9] = {2, 3, 2, 0, 0, 4, 0, 5, 0};
func0(list2, 9, result2);
int expected2[9] = {2, 3, 2, 4, 5, 0, 0, 0, 0};
for (int i = 0; i < 9; i++) {
assert(result2[i] == expected2[i]);
}
int result3[5];
int list3[5] = {0, 1, 0, 1, 1};
func0(list3, 5, result3);
int expected3[5] = {1, 1, 1, 0, 0};
for (int i = 0; i < 5; i++) {
assert(result3[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 14e8 <func0+0x68>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
jmp 14ac <func0+0x2c>
nopw %cs:0x0(%rax,%rax,1)
add $0x4,%rdi
add $0x1,%esi
cmp %rdi,%r8
je 14c5 <func0+0x45>
mov (%rdi),%eax
test %eax,%eax
je 14a0 <func0+0x20>
movslq %ecx,%r9
add $0x4,%rdi
add $0x1,%ecx
mov %eax,(%rdx,%r9,4)
cmp %rdi,%r8
jne 14ac <func0+0x2c>
test %esi,%esi
je 14e8 <func0+0x68>
lea -0x1(%rsi),%eax
movslq %ecx,%rcx
xor %esi,%esi
lea 0x4(,%rax,4),%r8
lea (%rdx,%rcx,4),%rdi
mov %r8,%rdx
jmpq 10b0 <memset@plt>
nopl (%rax)
retq
nopl 0x0(%rax)
| func0:
endbr64
mov r10, rdx
test esi, esi
jle short locret_1410
movsxd rsi, esi
xor ecx, ecx
lea r8, [rdi+rsi*4]
xor esi, esi
jmp short loc_13DC
loc_13D0:
add rdi, 4
add esi, 1
cmp r8, rdi
jz short loc_13F5
loc_13DC:
mov eax, [rdi]
test eax, eax
jz short loc_13D0
movsxd r9, ecx
add rdi, 4
add ecx, 1
mov [r10+r9*4], eax
cmp r8, rdi
jnz short loc_13DC
loc_13F5:
test esi, esi
jle short locret_1410
movsxd rcx, ecx
lea rdx, ds:0[rsi*4]; n
xor esi, esi; c
lea rdi, [r10+rcx*4]; s
jmp _memset
locret_1410:
retn | void func0(int *a1, int a2, long long a3)
{
int v3; // ecx
int *v4; // r8
long long v5; // rsi
int v6; // eax
long long v7; // r9
if ( a2 > 0 )
{
v3 = 0;
v4 = &a1[a2];
v5 = 0LL;
do
{
while ( 1 )
{
v6 = *a1;
if ( *a1 )
break;
++a1;
v5 = (unsigned int)(v5 + 1);
if ( v4 == a1 )
goto LABEL_6;
}
v7 = v3;
++a1;
++v3;
*(_DWORD *)(a3 + 4 * v7) = v6;
}
while ( v4 != a1 );
LABEL_6:
if ( (int)v5 > 0 )
memset((void *)(a3 + 4LL * v3), 0, 4 * v5);
}
} | func0:
ENDBR64
MOV R10,RDX
TEST ESI,ESI
JLE 0x00101410
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R8,[RDI + RSI*0x4]
XOR ESI,ESI
JMP 0x001013dc
LAB_001013d0:
ADD RDI,0x4
ADD ESI,0x1
CMP R8,RDI
JZ 0x001013f5
LAB_001013dc:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JZ 0x001013d0
MOVSXD R9,ECX
ADD RDI,0x4
ADD ECX,0x1
MOV dword ptr [R10 + R9*0x4],EAX
CMP R8,RDI
JNZ 0x001013dc
LAB_001013f5:
TEST ESI,ESI
JLE 0x00101410
MOVSXD RCX,ECX
LEA RDX,[RSI*0x4]
XOR ESI,ESI
LEA RDI,[R10 + RCX*0x4]
JMP 0x001010b0
LAB_00101410:
RET | void func0(int *param_1,int param_2,long param_3)
{
int *piVar1;
int iVar2;
int iVar3;
ulong uVar4;
long lVar5;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + param_2;
uVar4 = 0;
do {
while (iVar2 = *param_1, iVar2 != 0) {
lVar5 = (long)iVar3;
param_1 = param_1 + 1;
iVar3 = iVar3 + 1;
*(int *)(param_3 + lVar5 * 4) = iVar2;
if (piVar1 == param_1) goto LAB_001013f5;
}
param_1 = param_1 + 1;
uVar4 = (ulong)((int)uVar4 + 1);
} while (piVar1 != param_1);
LAB_001013f5:
if (0 < (int)uVar4) {
memset((void *)(param_3 + (long)iVar3 * 4),0,uVar4 * 4);
return;
}
}
return;
} |
6,424 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
int arr1[] = {5, 9, 7, 6};
int arr2[] = {7, 3, 5};
int arr3[] = {7, 3};
assert(func0(arr1, 4) == 47);
assert(func0(arr2, 3) == 12);
assert(func0(arr3, 2) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d4 <func0+0x6b>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11c8 <func0+0x5f>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
xor %edx,%eax
add %eax,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1193 <func0+0x2a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D4
loc_1188:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11C8
loc_1193:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
xor eax, edx
add [rbp+var_C], eax
add [rbp+var_4], 1
loc_11C8:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1193
add [rbp+var_8], 1
loc_11D4:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
v3 += *(_DWORD *)(4LL * i + a1) ^ *(_DWORD *)(4LL * j + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d4
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011c8
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
XOR EAX,EDX
ADD dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c8:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101193
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d4:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
local_14 = local_14 +
(*(uint *)(param_1 + (long)local_c * 4) ^ *(uint *)(param_1 + (long)local_10 * 4));
}
}
return local_14;
} |
6,425 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
int arr1[] = {5, 9, 7, 6};
int arr2[] = {7, 3, 5};
int arr3[] = {7, 3};
assert(func0(arr1, 4) == 47);
assert(func0(arr2, 3) == 12);
assert(func0(arr3, 2) == 4);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a7 <func0+0x3e>
lea -0x1(%rsi),%r10d
add $0x1,%r10
mov $0x1,%r9d
mov $0x0,%edx
cmp %r10,%r9
je 11ac <func0+0x43>
mov -0x4(%rdi,%r9,4),%r8d
mov %r9,%rax
mov %r8d,%ecx
xor (%rdi,%rax,4),%ecx
add %ecx,%edx
add $0x1,%rax
cmp %eax,%esi
jg 1191 <func0+0x28>
add $0x1,%r9
jmp 1184 <func0+0x1b>
mov $0x0,%edx
mov %edx,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A2
mov r10d, esi
mov r9d, 1
mov edx, 0
loc_117F:
cmp r9, r10
jz short loc_11A7
mov r8d, [rdi+r9*4-4]
mov rax, r9
loc_118C:
mov ecx, r8d
xor ecx, [rdi+rax*4]
add edx, ecx
add rax, 1
cmp esi, eax
jg short loc_118C
add r9, 1
jmp short loc_117F
loc_11A2:
mov edx, 0
loc_11A7:
mov eax, edx
retn | long long func0(long long a1, int a2)
{
long long v2; // r9
unsigned int v3; // edx
long long v4; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 1LL;
v3 = 0;
while ( v2 != a2 )
{
v4 = v2;
do
v3 += *(_DWORD *)(a1 + 4 * v4++) ^ *(_DWORD *)(a1 + 4 * v2 - 4);
while ( a2 > (int)v4 );
++v2;
}
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a2
MOV R10D,ESI
MOV R9D,0x1
MOV EDX,0x0
LAB_0010117f:
CMP R9,R10
JZ 0x001011a7
MOV R8D,dword ptr [RDI + R9*0x4 + -0x4]
MOV RAX,R9
LAB_0010118c:
MOV ECX,R8D
XOR ECX,dword ptr [RDI + RAX*0x4]
ADD EDX,ECX
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118c
ADD R9,0x1
JMP 0x0010117f
LAB_001011a2:
MOV EDX,0x0
LAB_001011a7:
MOV EAX,EDX
RET | int func0(long param_1,uint param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
if ((int)param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
for (uVar3 = 1; uVar3 != param_2; uVar3 = uVar3 + 1) {
uVar1 = uVar3;
do {
iVar2 = iVar2 + (*(uint *)(param_1 + -4 + uVar3 * 4) ^ *(uint *)(param_1 + uVar1 * 4));
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
}
}
return iVar2;
} |
6,426 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
int arr1[] = {5, 9, 7, 6};
int arr2[] = {7, 3, 5};
int arr3[] = {7, 3};
assert(func0(arr1, 4) == 47);
assert(func0(arr2, 3) == 12);
assert(func0(arr3, 2) == 4);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 12fd <func0+0x4d>
lea -0x1(%rsi),%r10d
mov $0x1,%r9d
xor %r8d,%r8d
add $0x1,%r10
cmp %r10,%r9
je 12f9 <func0+0x49>
xchg %ax,%ax
mov -0x4(%rdi,%r9,4),%ecx
mov %r9,%rax
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%edx
add $0x1,%rax
xor %ecx,%edx
add %edx,%r8d
cmp %eax,%esi
jg 12e0 <func0+0x30>
add $0x1,%r9
cmp %r10,%r9
jne 12d0 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_12CD
movsxd r10, esi
mov r9d, 1
xor r8d, r8d
cmp r9, r10
jz short loc_12C9
nop dword ptr [rax+00000000h]
loc_12A0:
mov ecx, [rdi+r9*4-4]
mov rax, r9
nop dword ptr [rax+rax+00000000h]
loc_12B0:
mov edx, [rdi+rax*4]
add rax, 1
xor edx, ecx
add r8d, edx
cmp esi, eax
jg short loc_12B0
add r9, 1
cmp r9, r10
jnz short loc_12A0
loc_12C9:
mov eax, r8d
retn
loc_12CD:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
long long v2; // r9
unsigned int i; // r8d
long long v4; // rax
int v5; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
for ( i = 0; v2 != a2; ++v2 )
{
v4 = v2;
do
{
v5 = *(_DWORD *)(a1 + 4 * v4++);
i += *(_DWORD *)(a1 + 4 * v2 - 4) ^ v5;
}
while ( a2 > (int)v4 );
}
return i;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012cd
MOVSXD R10,ESI
MOV R9D,0x1
XOR R8D,R8D
CMP R9,R10
JZ 0x001012c9
NOP dword ptr [RAX]
LAB_001012a0:
MOV ECX,dword ptr [RDI + R9*0x4 + -0x4]
MOV RAX,R9
NOP dword ptr [RAX + RAX*0x1]
LAB_001012b0:
MOV EDX,dword ptr [RDI + RAX*0x4]
ADD RAX,0x1
XOR EDX,ECX
ADD R8D,EDX
CMP ESI,EAX
JG 0x001012b0
ADD R9,0x1
CMP R9,R10
JNZ 0x001012a0
LAB_001012c9:
MOV EAX,R8D
RET
LAB_001012cd:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
long lVar4;
if (0 < param_2) {
lVar4 = 1;
iVar3 = 0;
if ((long)param_2 != 1) {
do {
lVar2 = lVar4;
do {
lVar1 = lVar2 * 4;
lVar2 = lVar2 + 1;
iVar3 = iVar3 + (*(uint *)(param_1 + lVar1) ^ *(uint *)(param_1 + -4 + lVar4 * 4));
} while ((int)lVar2 < param_2);
lVar4 = lVar4 + 1;
} while (lVar4 != param_2);
}
return iVar3;
}
return 0;
} |
6,427 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
int arr1[] = {5, 9, 7, 6};
int arr2[] = {7, 3, 5};
int arr3[] = {7, 3};
assert(func0(arr1, 4) == 47);
assert(func0(arr2, 3) == 12);
assert(func0(arr3, 2) == 4);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13ad <func0+0x10d>
cmp $0x1,%esi
je 13ad <func0+0x10d>
push %r14
lea 0x4(%rdi),%r11
xor %r8d,%r8d
mov $0x1,%ecx
push %rbp
lea -0x1(%rsi),%ebp
push %rbx
mov $0x1,%ebx
nopl (%rax)
mov %esi,%r9d
mov %ebp,%eax
mov -0x4(%r11),%r10d
sub %ecx,%r9d
cmp %ecx,%esi
cmovle %ebx,%r9d
sub %ecx,%eax
cmp $0x2,%eax
jbe 13a9 <func0+0x109>
cmp %ecx,%esi
jle 13a9 <func0+0x109>
mov %r9d,%edx
movd %r10d,%xmm3
pxor %xmm1,%xmm1
mov %r11,%rax
shr $0x2,%edx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rdx
add %r11,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
pxor %xmm2,%xmm0
paddd %xmm0,%xmm1
cmp %rdx,%rax
jne 1318 <func0+0x78>
movdqa %xmm1,%xmm0
mov %r9d,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
add %eax,%r8d
lea (%rdx,%rcx,1),%eax
cmp %edx,%r9d
je 1392 <func0+0xf2>
movslq %eax,%rdx
mov (%rdi,%rdx,4),%r14d
lea 0x0(,%rdx,4),%r9
lea 0x1(%rax),%edx
xor %r10d,%r14d
add %r14d,%r8d
cmp %edx,%esi
jle 1392 <func0+0xf2>
mov 0x4(%rdi,%r9,1),%edx
add $0x2,%eax
xor %r10d,%edx
add %edx,%r8d
cmp %eax,%esi
jle 1392 <func0+0xf2>
xor 0x8(%rdi,%r9,1),%r10d
add %r10d,%r8d
add $0x1,%ecx
add $0x4,%r11
cmp %ecx,%esi
jne 12d0 <func0+0x30>
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r14
retq
mov %ecx,%eax
jmp 135c <func0+0xbc>
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle loc_1251
mov r8d, esi
cmp esi, 1
jz loc_1251
push r14
mov r11, rdi
lea r10, [rdi+4]
mov esi, 1
push rbp
xor edi, edi
lea ebp, [r8-1]
push rbx
mov ebx, 1
nop dword ptr [rax+rax+00h]
loc_1178:
mov ecx, r8d
mov eax, ebp
mov r9d, [r10-4]
sub ecx, esi
cmp r8d, esi
cmovle ecx, ebx
sub eax, esi
cmp eax, 2
jbe loc_124D
cmp r8d, esi
jle loc_124D
mov edx, ecx
movd xmm3, r9d
pxor xmm1, xmm1
mov rax, r10
shr edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, r10
nop word ptr [rax+rax+00h]
loc_11C0:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pxor xmm0, xmm2
paddd xmm1, xmm0
cmp rdx, rax
jnz short loc_11C0
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add edi, eax
test cl, 3
jz short loc_1236
and ecx, 0FFFFFFFCh
add ecx, esi
loc_11FF:
movsxd rax, ecx
mov r14d, [r11+rax*4]
lea rdx, ds:0[rax*4]
lea eax, [rcx+1]
xor r14d, r9d
add edi, r14d
cmp r8d, eax
jle short loc_1236
mov eax, [r11+rdx+4]
add ecx, 2
xor eax, r9d
add edi, eax
cmp r8d, ecx
jle short loc_1236
xor r9d, [r11+rdx+8]
add edi, r9d
loc_1236:
add esi, 1
add r10, 4
cmp r8d, esi
jnz loc_1178
pop rbx
mov eax, edi
pop rbp
pop r14
retn
loc_124D:
mov ecx, esi
jmp short loc_11FF
loc_1251:
xor edi, edi
mov eax, edi
retn | long long func0(long long a1, int a2)
{
const __m128i *v4; // r10
int v5; // esi
unsigned int v6; // edi
unsigned int v7; // r9d
unsigned int v8; // ecx
__m128i v9; // xmm1
const __m128i *v10; // rax
__m128i v11; // xmm2
__m128i v12; // xmm0
__m128i v13; // xmm1
int v14; // ecx
long long v15; // rdx
if ( a2 > 0 && a2 != 1 )
{
v4 = (const __m128i *)(a1 + 4);
v5 = 1;
v6 = 0;
while ( 1 )
{
v7 = v4[-1].m128i_u32[3];
v8 = a2 - v5;
if ( a2 <= v5 )
v8 = 1;
if ( (unsigned int)(a2 - 1 - v5) <= 2 || a2 <= v5 )
break;
v9 = 0LL;
v10 = v4;
v11 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v7), 0);
do
{
v12 = _mm_loadu_si128(v10++);
v9 = _mm_add_epi32(v9, _mm_xor_si128(v12, v11));
}
while ( &v4[v8 >> 2] != v10 );
v13 = _mm_add_epi32(v9, _mm_srli_si128(v9, 8));
v6 += _mm_cvtsi128_si32(_mm_add_epi32(v13, _mm_srli_si128(v13, 4)));
if ( (v8 & 3) != 0 )
{
v14 = v5 + (v8 & 0xFFFFFFFC);
goto LABEL_12;
}
LABEL_15:
++v5;
v4 = (const __m128i *)((char *)v4 + 4);
if ( a2 == v5 )
return v6;
}
v14 = v5;
LABEL_12:
v15 = 4LL * v14;
v6 += v7 ^ *(_DWORD *)(a1 + v15);
if ( a2 > v14 + 1 )
{
v6 += v7 ^ *(_DWORD *)(a1 + v15 + 4);
if ( a2 > v14 + 2 )
v6 += *(_DWORD *)(a1 + v15 + 8) ^ v7;
}
goto LABEL_15;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101251
MOV R8D,ESI
CMP ESI,0x1
JZ 0x00101251
PUSH R14
MOV R11,RDI
LEA R10,[RDI + 0x4]
MOV ESI,0x1
PUSH RBP
XOR EDI,EDI
LEA EBP,[R8 + -0x1]
PUSH RBX
MOV EBX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101178:
MOV ECX,R8D
MOV EAX,EBP
MOV R9D,dword ptr [R10 + -0x4]
SUB ECX,ESI
CMP R8D,ESI
CMOVLE ECX,EBX
SUB EAX,ESI
CMP EAX,0x2
JBE 0x0010124d
CMP R8D,ESI
JLE 0x0010124d
MOV EDX,ECX
MOVD XMM3,R9D
PXOR XMM1,XMM1
MOV RAX,R10
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,R10
NOP word ptr [RAX + RAX*0x1]
LAB_001011c0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PXOR XMM0,XMM2
PADDD XMM1,XMM0
CMP RDX,RAX
JNZ 0x001011c0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD EDI,EAX
TEST CL,0x3
JZ 0x00101236
AND ECX,0xfffffffc
ADD ECX,ESI
LAB_001011ff:
MOVSXD RAX,ECX
MOV R14D,dword ptr [R11 + RAX*0x4]
LEA RDX,[RAX*0x4]
LEA EAX,[RCX + 0x1]
XOR R14D,R9D
ADD EDI,R14D
CMP R8D,EAX
JLE 0x00101236
MOV EAX,dword ptr [R11 + RDX*0x1 + 0x4]
ADD ECX,0x2
XOR EAX,R9D
ADD EDI,EAX
CMP R8D,ECX
JLE 0x00101236
XOR R9D,dword ptr [R11 + RDX*0x1 + 0x8]
ADD EDI,R9D
LAB_00101236:
ADD ESI,0x1
ADD R10,0x4
CMP R8D,ESI
JNZ 0x00101178
POP RBX
MOV EAX,EDI
POP RBP
POP R14
RET
LAB_0010124d:
MOV ECX,ESI
JMP 0x001011ff
LAB_00101251:
XOR EDI,EDI
MOV EAX,EDI
RET | int func0(long param_1,int param_2)
{
long lVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint uVar8;
int iVar9;
int iVar10;
uint *puVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
puVar11 = (uint *)(param_1 + 4);
iVar9 = 1;
iVar10 = 0;
do {
uVar2 = puVar11[-1];
uVar8 = param_2 - iVar9;
if (param_2 <= iVar9) {
uVar8 = 1;
}
iVar12 = iVar9;
if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) {
LAB_001011ff:
lVar1 = (long)iVar12 * 4;
iVar10 = iVar10 + (*(uint *)(param_1 + (long)iVar12 * 4) ^ uVar2);
if ((iVar12 + 1 < param_2) &&
(iVar10 = iVar10 + (*(uint *)(param_1 + 4 + lVar1) ^ uVar2), iVar12 + 2 < param_2)) {
iVar10 = iVar10 + (uVar2 ^ *(uint *)(param_1 + 8 + lVar1));
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
puVar7 = puVar11;
do {
uVar3 = *puVar7;
puVar4 = puVar7 + 1;
puVar5 = puVar7 + 2;
puVar6 = puVar7 + 3;
puVar7 = puVar7 + 4;
iVar12 = iVar12 + (uVar3 ^ uVar2);
iVar13 = iVar13 + (*puVar4 ^ uVar2);
iVar14 = iVar14 + (*puVar5 ^ uVar2);
iVar15 = iVar15 + (*puVar6 ^ uVar2);
} while (puVar11 + (ulong)(uVar8 >> 2) * 4 != puVar7);
iVar10 = iVar10 + iVar12 + iVar14 + iVar13 + iVar15;
if ((uVar8 & 3) != 0) {
iVar12 = (uVar8 & 0xfffffffc) + iVar9;
goto LAB_001011ff;
}
}
iVar9 = iVar9 + 1;
puVar11 = puVar11 + 1;
if (param_2 == iVar9) {
return iVar10;
}
} while( true );
} |
6,428 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1181 <func0+0x38>
mov -0x8(%rbp),%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
imul -0x4(%rbp),%eax
add %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 1
jmp short loc_1181
loc_1164:
mov eax, [rbp+var_8]
add eax, eax
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
add [rbp+var_C], eax
add [rbp+var_8], 1
loc_1181:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jle short loc_1164
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += 2 * i * 2 * i * 2 * i * 2 * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101181
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int param_1)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 1; local_10 <= param_1; local_10 = local_10 + 1) {
iVar1 = local_10 * 2;
local_14 = local_14 + iVar1 * iVar1 * iVar1 * iVar1;
}
return local_14;
} |
6,429 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1173 <func0+0x2a>
lea 0x2(%rdi,%rdi,1),%esi
mov $0x2,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %edx,%edx
add %edx,%ecx
add $0x2,%eax
cmp %esi,%eax
jne 115f <func0+0x16>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1170 <func0+0x27>
| func0:
endbr64
test edi, edi
jle short loc_1173
lea esi, [rdi+rdi+2]
mov eax, 2
mov ecx, 0
loc_115F:
mov edx, eax
imul edx, eax
imul edx, edx
add ecx, edx
add eax, 2
cmp eax, esi
jnz short loc_115F
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short loc_1170 | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 2;
v2 = 0;
do
{
v2 += v1 * v1 * v1 * v1;
v1 += 2;
}
while ( v1 != 2 * a1 + 2 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
LEA ESI,[RDI + RDI*0x1 + 0x2]
MOV EAX,0x2
MOV ECX,0x0
LAB_0010115f:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EDX
ADD ECX,EDX
ADD EAX,0x2
CMP EAX,ESI
JNZ 0x0010115f
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 2;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
} while (iVar1 != param_1 * 2 + 2);
}
return iVar2;
} |
6,430 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
lea 0x2(%rdi,%rdi,1),%ecx
mov $0x2,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add $0x2,%eax
imul %edx,%edx
add %edx,%r8d
cmp %ecx,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
lea ecx, [rdi+rdi+2]
mov eax, 2
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 2
imul edx, edx
add r8d, edx
cmp eax, ecx
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // r8d
int v3; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 2;
v2 = 0;
do
{
v3 = v1 * v1;
v1 += 2;
v2 += v3 * v3;
}
while ( v1 != 2 * a1 + 2 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ECX,[RDI + RDI*0x1 + 0x2]
MOV EAX,0x2
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
IMUL EDX,EDX
ADD R8D,EDX
CMP EAX,ECX
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 2;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar3 = iVar3 + iVar2 * iVar2;
} while (iVar1 != param_1 * 2 + 2);
return iVar3;
}
return 0;
} |
6,431 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
lea 0x2(%rdi,%rdi,1),%ecx
mov $0x2,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add $0x2,%eax
imul %edx,%edx
add %edx,%r8d
cmp %eax,%ecx
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
lea esi, [rdi+rdi+2]
mov eax, 2
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 2
imul edx, edx
add ecx, edx
cmp esi, eax
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ecx, ecx
mov eax, ecx
retn | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
int v3; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 2;
v2 = 0;
do
{
v3 = v1 * v1;
v1 += 2;
v2 += v3 * v3;
}
while ( 2 * a1 + 2 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ESI,[RDI + RDI*0x1 + 0x2]
MOV EAX,0x2
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
IMUL EDX,EDX
ADD ECX,EDX
CMP ESI,EAX
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 2;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar2 = iVar2 + iVar3 * iVar3;
} while (param_1 * 2 + 2 != iVar1);
return iVar2;
}
return 0;
} |
6,432 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int *data;
int size;
int capacity;
} MinHeap;
MinHeap* heap_init(int capacity) {
MinHeap *heap = malloc(sizeof(MinHeap));
heap->data = malloc(sizeof(int) * capacity);
heap->size = 0;
heap->capacity = capacity;
return heap;
}
void heap_push(MinHeap *heap, int value) {
if (heap->size >= heap->capacity) {
heap->capacity *= 2;
heap->data = realloc(heap->data, sizeof(int) * heap->capacity);
}
heap->data[heap->size] = value;
int i = heap->size;
heap->size++;
while (i != 0) {
int parent = (i -1)/2;
if (heap->data[parent] > heap->data[i]) {
int temp = heap->data[parent];
heap->data[parent] = heap->data[i];
heap->data[i] = temp;
i = parent;
}
else {
break;
}
}
}
int heap_pop(MinHeap *heap) {
if (heap->size == 0) {
return -1;
}
int min = heap->data[0];
heap->size--;
heap->data[0] = heap->data[heap->size];
int i = 0;
while (1) {
int left = 2*i +1;
int right = 2*i +2;
int smallest = i;
if (left < heap->size && heap->data[left] < heap->data[smallest]) {
smallest = left;
}
if (right < heap->size && heap->data[right] < heap->data[smallest]) {
smallest = right;
}
if (smallest != i) {
int temp = heap->data[i];
heap->data[i] = heap->data[smallest];
heap->data[smallest] = temp;
i = smallest;
}
else {
break;
}
}
return min;
}
void heap_free(MinHeap *heap) {
free(heap->data);
free(heap);
}
int arrays_equal(int *a1, int *a2, int size) {
for(int i=0;i<size;i++) {
if(a1[i] != a2[i]) return 0;
}
return 1;
}
| int* func0(int *array, int size) {
MinHeap *heap = heap_init(size > 0 ? size : 1);
for(int i=0;i<size;i++) {
heap_push(heap, array[i]);
}
int *sorted = malloc(sizeof(int)*size);
for(int i=0;i<size;i++) {
sorted[i] = heap_pop(heap);
}
heap_free(heap);
return sorted;
}
| int main() {
int input1[] = {1,3,5,7,9,2,4,6,8,0};
int expected1[] = {0,1,2,3,4,5,6,7,8,9};
int size1 = sizeof(input1)/sizeof(input1[0]);
int *sorted1 = func0(input1, size1);
assert(arrays_equal(sorted1, expected1, size1));
free(sorted1);
int input2[] = {25,35,22,85,14,65,75,25,58};
int expected2[] = {14,22,25,25,35,58,65,75,85};
int size2 = sizeof(input2)/sizeof(input2[0]);
int *sorted2 = func0(input2, size2);
assert(arrays_equal(sorted2, expected2, size2));
free(sorted2);
int input3[] = {7,1,9,5};
int expected3[] = {1,5,7,9};
int size3 = sizeof(input3)/sizeof(input3[0]);
int *sorted3 = func0(input3, size3);
assert(arrays_equal(sorted3, expected3, size3));
free(sorted3);
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 $0x1,%eax
cmpl $0x0,-0x3c(%rbp)
cmovg -0x3c(%rbp),%eax
mov %eax,%edi
callq 11c9 <heap_init>
mov %rax,-0x20(%rbp)
movl $0x0,-0x28(%rbp)
jmp 15df <func0+0x5d>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 121c <heap_push>
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 15b7 <func0+0x35>
mov -0x3c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10c0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmp 162c <func0+0xaa>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 136f <heap_pop>
mov %eax,(%rbx)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1605 <func0+0x83>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 14ee <heap_free>
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 eax, [rbp+var_3C]
mov edx, 1
test eax, eax
cmovle eax, edx
mov edi, eax
call heap_init
mov [rbp+var_20], rax
mov [rbp+var_28], 0
jmp short loc_15DF
loc_15B7:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_20]
mov esi, edx
mov rdi, rax
call heap_push
add [rbp+var_28], 1
loc_15DF:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl short loc_15B7
mov eax, [rbp+var_3C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
jmp short loc_162C
loc_1605:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rbx, [rdx+rax]
mov rax, [rbp+var_20]
mov rdi, rax
call heap_pop
mov [rbx], eax
add [rbp+var_24], 1
loc_162C:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl short loc_1605
mov rax, [rbp+var_20]
mov rdi, rax
call heap_free
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2)
{
unsigned int v2; // eax
int i; // [rsp+18h] [rbp-28h]
int j; // [rsp+1Ch] [rbp-24h]
long long v6; // [rsp+20h] [rbp-20h]
_DWORD *v7; // [rsp+28h] [rbp-18h]
v2 = a2;
if ( a2 <= 0 )
v2 = 1;
v6 = heap_init(v2);
for ( i = 0; i < a2; ++i )
heap_push(v6, *(unsigned int *)(4LL * i + a1));
v7 = malloc(4LL * a2);
for ( j = 0; j < a2; ++j )
v7[j] = heap_pop(v6);
heap_free(v6);
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EAX,dword ptr [RBP + -0x3c]
MOV EDX,0x1
TEST EAX,EAX
CMOVLE EAX,EDX
MOV EDI,EAX
CALL 0x001011c9
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001015df
LAB_001015b7:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x0010121c
ADD dword ptr [RBP + -0x28],0x1
LAB_001015df:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001015b7
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010162c
LAB_00101605:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RBX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x0010136f
MOV dword ptr [RBX],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_0010162c:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101605
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001014ee
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
int iVar1;
int4 uVar2;
int8 uVar3;
void *pvVar4;
int4 local_30;
int4 local_2c;
iVar1 = param_2;
if (param_2 < 1) {
iVar1 = 1;
}
uVar3 = heap_init(iVar1);
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
heap_push(uVar3,*(int4 *)(param_1 + (long)local_30 * 4));
}
pvVar4 = malloc((long)param_2 << 2);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
uVar2 = heap_pop(uVar3);
*(int4 *)((long)local_2c * 4 + (long)pvVar4) = uVar2;
}
heap_free(uVar3);
return pvVar4;
} |
6,433 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int *data;
int size;
int capacity;
} MinHeap;
MinHeap* heap_init(int capacity) {
MinHeap *heap = malloc(sizeof(MinHeap));
heap->data = malloc(sizeof(int) * capacity);
heap->size = 0;
heap->capacity = capacity;
return heap;
}
void heap_push(MinHeap *heap, int value) {
if (heap->size >= heap->capacity) {
heap->capacity *= 2;
heap->data = realloc(heap->data, sizeof(int) * heap->capacity);
}
heap->data[heap->size] = value;
int i = heap->size;
heap->size++;
while (i != 0) {
int parent = (i -1)/2;
if (heap->data[parent] > heap->data[i]) {
int temp = heap->data[parent];
heap->data[parent] = heap->data[i];
heap->data[i] = temp;
i = parent;
}
else {
break;
}
}
}
int heap_pop(MinHeap *heap) {
if (heap->size == 0) {
return -1;
}
int min = heap->data[0];
heap->size--;
heap->data[0] = heap->data[heap->size];
int i = 0;
while (1) {
int left = 2*i +1;
int right = 2*i +2;
int smallest = i;
if (left < heap->size && heap->data[left] < heap->data[smallest]) {
smallest = left;
}
if (right < heap->size && heap->data[right] < heap->data[smallest]) {
smallest = right;
}
if (smallest != i) {
int temp = heap->data[i];
heap->data[i] = heap->data[smallest];
heap->data[smallest] = temp;
i = smallest;
}
else {
break;
}
}
return min;
}
void heap_free(MinHeap *heap) {
free(heap->data);
free(heap);
}
int arrays_equal(int *a1, int *a2, int size) {
for(int i=0;i<size;i++) {
if(a1[i] != a2[i]) return 0;
}
return 1;
}
| int* func0(int *array, int size) {
MinHeap *heap = heap_init(size > 0 ? size : 1);
for(int i=0;i<size;i++) {
heap_push(heap, array[i]);
}
int *sorted = malloc(sizeof(int)*size);
for(int i=0;i<size;i++) {
sorted[i] = heap_pop(heap);
}
heap_free(heap);
return sorted;
}
| int main() {
int input1[] = {1,3,5,7,9,2,4,6,8,0};
int expected1[] = {0,1,2,3,4,5,6,7,8,9};
int size1 = sizeof(input1)/sizeof(input1[0]);
int *sorted1 = func0(input1, size1);
assert(arrays_equal(sorted1, expected1, size1));
free(sorted1);
int input2[] = {25,35,22,85,14,65,75,25,58};
int expected2[] = {14,22,25,25,35,58,65,75,85};
int size2 = sizeof(input2)/sizeof(input2[0]);
int *sorted2 = func0(input2, size2);
assert(arrays_equal(sorted2, expected2, size2));
free(sorted2);
int input3[] = {7,1,9,5};
int expected3[] = {1,5,7,9};
int size3 = sizeof(input3)/sizeof(input3[0]);
int *sorted3 = func0(input3, size3);
assert(arrays_equal(sorted3, expected3, size3));
free(sorted3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r13
mov %esi,%r12d
test %esi,%esi
mov $0x1,%edi
cmovg %esi,%edi
callq 11c9 <heap_init>
mov %rax,%rbp
test %r12d,%r12d
jle 140d <func0+0x8b>
mov %r13,%rbx
lea -0x1(%r12),%r14d
shl $0x2,%r14
lea 0x4(%r13,%r14,1),%r13
mov (%rbx),%esi
mov %rbp,%rdi
callq 1205 <heap_push>
add $0x4,%rbx
cmp %r13,%rbx
jne 13bc <func0+0x3a>
movslq %r12d,%rdi
shl $0x2,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
mov %rax,%rbx
lea 0x4(%rax,%r14,1),%r12
mov %rbp,%rdi
callq 128a <heap_pop>
mov %eax,(%rbx)
add $0x4,%rbx
cmp %r12,%rbx
jne 13e6 <func0+0x64>
mov %rbp,%rdi
callq 1330 <heap_free>
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
movslq %r12d,%rdi
shl $0x2,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
jmp 13f9 <func0+0x77>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
mov r12d, esi
test esi, esi
mov edi, 1
cmovg edi, esi
call heap_init
mov rbp, rax
test r12d, r12d
jle short loc_140A
mov rbx, r13
lea r14d, [r12-1]
shl r14, 2
lea r13, [r13+r14+4]
loc_13B9:
mov esi, [rbx]
mov rdi, rbp
call heap_push
add rbx, 4
cmp rbx, r13
jnz short loc_13B9
movsxd rdi, r12d
shl rdi, 2
call _malloc
mov r13, rax
mov rbx, rax
lea r12, [rax+r14+4]
loc_13E3:
mov rdi, rbp
call heap_pop
mov [rbx], eax
add rbx, 4
cmp rbx, r12
jnz short loc_13E3
loc_13F6:
mov rdi, rbp
call heap_free
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_140A:
movsxd rdi, r12d
shl rdi, 2
call _malloc
mov r13, rax
jmp short loc_13F6 | long long func0(unsigned int *a1, int a2)
{
long long v3; // rdi
long long v4; // rbp
unsigned int *v5; // rbx
long long v6; // r14
long long v7; // r13
long long v8; // r13
_DWORD *v9; // rbx
v3 = 1LL;
if ( a2 > 0 )
v3 = (unsigned int)a2;
v4 = heap_init(v3);
if ( a2 <= 0 )
{
v8 = malloc(4LL * a2);
}
else
{
v5 = a1;
v6 = (unsigned int)(a2 - 1);
v7 = (long long)&a1[v6 + 1];
do
heap_push(v4, *v5++);
while ( v5 != (unsigned int *)v7 );
v8 = malloc(4LL * a2);
v9 = (_DWORD *)v8;
do
*v9++ = heap_pop(v4);
while ( v9 != (_DWORD *)(v8 + v6 * 4 + 4) );
}
heap_free(v4);
return v8;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
MOV R12D,ESI
TEST ESI,ESI
MOV EDI,0x1
CMOVG EDI,ESI
CALL 0x001011c9
MOV RBP,RAX
TEST R12D,R12D
JLE 0x0010140a
MOV RBX,R13
LEA R14D,[R12 + -0x1]
SHL R14,0x2
LEA R13,[R13 + R14*0x1 + 0x4]
LAB_001013b9:
MOV ESI,dword ptr [RBX]
MOV RDI,RBP
CALL 0x00101205
ADD RBX,0x4
CMP RBX,R13
JNZ 0x001013b9
MOVSXD RDI,R12D
SHL RDI,0x2
CALL 0x001010c0
MOV R13,RAX
MOV RBX,RAX
LEA R12,[RAX + R14*0x1 + 0x4]
LAB_001013e3:
MOV RDI,RBP
CALL 0x0010128a
MOV dword ptr [RBX],EAX
ADD RBX,0x4
CMP RBX,R12
JNZ 0x001013e3
LAB_001013f6:
MOV RDI,RBP
CALL 0x00101333
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010140a:
MOVSXD RDI,R12D
SHL RDI,0x2
CALL 0x001010c0
MOV R13,RAX
JMP 0x001013f6 | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
int8 uVar2;
int4 *puVar3;
int4 *puVar4;
int iVar5;
iVar5 = 1;
if (0 < param_2) {
iVar5 = param_2;
}
uVar2 = heap_init(iVar5);
if (param_2 < 1) {
puVar3 = (int4 *)malloc((long)param_2 << 2);
}
else {
puVar3 = param_1 + (ulong)(param_2 - 1) + 1;
do {
heap_push(uVar2,*param_1);
param_1 = param_1 + 1;
} while (param_1 != puVar3);
puVar3 = (int4 *)malloc((long)param_2 << 2);
puVar4 = puVar3;
do {
uVar1 = heap_pop(uVar2);
*puVar4 = uVar1;
puVar4 = puVar4 + 1;
} while (puVar4 != puVar3 + (ulong)(param_2 - 1) + 1);
}
heap_free(uVar2);
return puVar3;
} |
6,434 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int *data;
int size;
int capacity;
} MinHeap;
MinHeap* heap_init(int capacity) {
MinHeap *heap = malloc(sizeof(MinHeap));
heap->data = malloc(sizeof(int) * capacity);
heap->size = 0;
heap->capacity = capacity;
return heap;
}
void heap_push(MinHeap *heap, int value) {
if (heap->size >= heap->capacity) {
heap->capacity *= 2;
heap->data = realloc(heap->data, sizeof(int) * heap->capacity);
}
heap->data[heap->size] = value;
int i = heap->size;
heap->size++;
while (i != 0) {
int parent = (i -1)/2;
if (heap->data[parent] > heap->data[i]) {
int temp = heap->data[parent];
heap->data[parent] = heap->data[i];
heap->data[i] = temp;
i = parent;
}
else {
break;
}
}
}
int heap_pop(MinHeap *heap) {
if (heap->size == 0) {
return -1;
}
int min = heap->data[0];
heap->size--;
heap->data[0] = heap->data[heap->size];
int i = 0;
while (1) {
int left = 2*i +1;
int right = 2*i +2;
int smallest = i;
if (left < heap->size && heap->data[left] < heap->data[smallest]) {
smallest = left;
}
if (right < heap->size && heap->data[right] < heap->data[smallest]) {
smallest = right;
}
if (smallest != i) {
int temp = heap->data[i];
heap->data[i] = heap->data[smallest];
heap->data[smallest] = temp;
i = smallest;
}
else {
break;
}
}
return min;
}
void heap_free(MinHeap *heap) {
free(heap->data);
free(heap);
}
int arrays_equal(int *a1, int *a2, int size) {
for(int i=0;i<size;i++) {
if(a1[i] != a2[i]) return 0;
}
return 1;
}
| int* func0(int *array, int size) {
MinHeap *heap = heap_init(size > 0 ? size : 1);
for(int i=0;i<size;i++) {
heap_push(heap, array[i]);
}
int *sorted = malloc(sizeof(int)*size);
for(int i=0;i<size;i++) {
sorted[i] = heap_pop(heap);
}
heap_free(heap);
return sorted;
}
| int main() {
int input1[] = {1,3,5,7,9,2,4,6,8,0};
int expected1[] = {0,1,2,3,4,5,6,7,8,9};
int size1 = sizeof(input1)/sizeof(input1[0]);
int *sorted1 = func0(input1, size1);
assert(arrays_equal(sorted1, expected1, size1));
free(sorted1);
int input2[] = {25,35,22,85,14,65,75,25,58};
int expected2[] = {14,22,25,25,35,58,65,75,85};
int size2 = sizeof(input2)/sizeof(input2[0]);
int *sorted2 = func0(input2, size2);
assert(arrays_equal(sorted2, expected2, size2));
free(sorted2);
int input3[] = {7,1,9,5};
int expected3[] = {1,5,7,9};
int size3 = sizeof(input3)/sizeof(input3[0]);
int *sorted3 = func0(input3, size3);
assert(arrays_equal(sorted3, expected3, size3));
free(sorted3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
movslq %esi,%r13
push %r12
test %r13d,%r13d
mov %r13,%r12
push %rbp
push %rbx
mov %rdi,%rbx
mov $0x1,%edi
cmovg %r13d,%edi
shl $0x2,%r13
callq 1490 <heap_init>
mov %rax,%rbp
test %r12d,%r12d
jle 1718 <func0+0xa8>
lea -0x1(%r12),%r14d
shl $0x2,%r14
lea 0x4(%rbx,%r14,1),%r12
mov (%rbx),%esi
mov %rbp,%rdi
add $0x4,%rbx
callq 14e0 <heap_push>
cmp %r12,%rbx
jne 16b0 <func0+0x40>
mov %r13,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
mov %rax,%rbx
lea 0x4(%rax,%r14,1),%r12
nopw %cs:0x0(%rax,%rax,1)
mov %rbp,%rdi
add $0x4,%rbx
callq 1570 <heap_pop>
mov %eax,-0x4(%rbx)
cmp %rbx,%r12
jne 16e0 <func0+0x70>
mov 0x0(%rbp),%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
pop %rbx
mov %r13,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
mov %r13,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r13
jmp 16f4 <func0+0x84>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
test esi, esi
push r13
mov r13d, 1
push r12
cmovg r13d, esi
mov r12d, esi
push rbp
push rbx
mov rbx, rdi
mov edi, 10h
call _malloc
movsxd rdi, r13d
mov rbp, rax
shl rdi, 2
call _malloc
mov [rbp+0Ch], r13d
movsxd r13, r12d
mov [rbp+0], rax
shl r13, 2
mov dword ptr [rbp+8], 0
test r12d, r12d
jle short loc_1738
lea r14d, [r12-1]
shl r14, 2
lea r12, [rbx+r14+4]
loc_16D0:
mov esi, [rbx]
mov rdi, rbp
add rbx, 4
call heap_push
cmp rbx, r12
jnz short loc_16D0
mov rdi, r13
call _malloc
mov r13, rax
mov rbx, rax
lea r12, [rax+r14+4]
nop word ptr [rax+rax+00000000h]
loc_1700:
mov rdi, rbp
add rbx, 4
call heap_pop
mov [rbx-4], eax
cmp rbx, r12
jnz short loc_1700
mov r14, [rbp+0]
loc_1718:
mov rdi, r14
call _free
mov rdi, rbp
call _free
pop rbx
mov rax, r13
pop rbp
pop r12
pop r13
pop r14
retn
loc_1738:
mov rdi, r13
mov r14, rax
call _malloc
mov r13, rax
jmp short loc_1718 | long long func0(unsigned int *a1, int a2)
{
int v2; // r13d
unsigned int *v3; // rbx
long long v4; // rbp
long long v5; // rax
long long v6; // r13
long long v7; // r14
long long v8; // rsi
long long v9; // r13
long long v10; // rbx
long long v11; // r14
v2 = 1;
if ( a2 > 0 )
v2 = a2;
v3 = a1;
v4 = malloc(16LL);
v5 = malloc(4LL * v2);
*(_DWORD *)(v4 + 12) = v2;
*(_QWORD *)v4 = v5;
v6 = 4LL * a2;
*(_DWORD *)(v4 + 8) = 0;
if ( a2 <= 0 )
{
v11 = v5;
v9 = malloc(4LL * a2);
}
else
{
v7 = (unsigned int)(a2 - 1);
do
{
v8 = *v3++;
heap_push(v4, v8);
}
while ( v3 != &a1[v7 + 1] );
v9 = malloc(v6);
v10 = v9;
do
{
v10 += 4LL;
*(_DWORD *)(v10 - 4) = heap_pop(v4);
}
while ( v10 != v9 + v7 * 4 + 4 );
v11 = *(_QWORD *)v4;
}
free(v11);
free(v4);
return v9;
} | func0:
ENDBR64
PUSH R14
TEST ESI,ESI
PUSH R13
MOV R13D,0x1
PUSH R12
CMOVG R13D,ESI
MOV R12D,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV EDI,0x10
CALL 0x001010c0
MOVSXD RDI,R13D
MOV RBP,RAX
SHL RDI,0x2
CALL 0x001010c0
MOV dword ptr [RBP + 0xc],R13D
MOVSXD R13,R12D
MOV qword ptr [RBP],RAX
SHL R13,0x2
MOV dword ptr [RBP + 0x8],0x0
TEST R12D,R12D
JLE 0x00101738
LEA R14D,[R12 + -0x1]
SHL R14,0x2
LEA R12,[RBX + R14*0x1 + 0x4]
LAB_001016d0:
MOV ESI,dword ptr [RBX]
MOV RDI,RBP
ADD RBX,0x4
CALL 0x001014e0
CMP RBX,R12
JNZ 0x001016d0
MOV RDI,R13
CALL 0x001010c0
MOV R13,RAX
MOV RBX,RAX
LEA R12,[RAX + R14*0x1 + 0x4]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101700:
MOV RDI,RBP
ADD RBX,0x4
CALL 0x00101570
MOV dword ptr [RBX + -0x4],EAX
CMP RBX,R12
JNZ 0x00101700
MOV R14,qword ptr [RBP]
LAB_00101718:
MOV RDI,R14
CALL 0x00101090
MOV RDI,RBP
CALL 0x00101090
POP RBX
MOV RAX,R13
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101738:
MOV RDI,R13
MOV R14,RAX
CALL 0x001010c0
MOV R13,RAX
JMP 0x00101718 | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
int8 *__ptr;
void *__ptr_00;
int4 *puVar2;
int4 *puVar3;
int4 *puVar4;
int iVar5;
iVar5 = 1;
if (0 < param_2) {
iVar5 = param_2;
}
__ptr = (int8 *)malloc(0x10);
__ptr_00 = malloc((long)iVar5 << 2);
*(int *)((long)__ptr + 0xc) = iVar5;
*__ptr = __ptr_00;
*(int4 *)(__ptr + 1) = 0;
if (param_2 < 1) {
puVar2 = (int4 *)malloc((long)param_2 << 2);
}
else {
puVar2 = param_1 + (ulong)(param_2 - 1) + 1;
do {
uVar1 = *param_1;
param_1 = param_1 + 1;
heap_push(__ptr,uVar1);
} while (param_1 != puVar2);
puVar2 = (int4 *)malloc((long)param_2 << 2);
puVar3 = puVar2;
do {
puVar4 = puVar3 + 1;
uVar1 = heap_pop(__ptr);
*puVar3 = uVar1;
puVar3 = puVar4;
} while (puVar4 != puVar2 + (ulong)(param_2 - 1) + 1);
__ptr_00 = (void *)*__ptr;
}
free(__ptr_00);
free(__ptr);
return puVar2;
} |
6,435 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int *data;
int size;
int capacity;
} MinHeap;
MinHeap* heap_init(int capacity) {
MinHeap *heap = malloc(sizeof(MinHeap));
heap->data = malloc(sizeof(int) * capacity);
heap->size = 0;
heap->capacity = capacity;
return heap;
}
void heap_push(MinHeap *heap, int value) {
if (heap->size >= heap->capacity) {
heap->capacity *= 2;
heap->data = realloc(heap->data, sizeof(int) * heap->capacity);
}
heap->data[heap->size] = value;
int i = heap->size;
heap->size++;
while (i != 0) {
int parent = (i -1)/2;
if (heap->data[parent] > heap->data[i]) {
int temp = heap->data[parent];
heap->data[parent] = heap->data[i];
heap->data[i] = temp;
i = parent;
}
else {
break;
}
}
}
int heap_pop(MinHeap *heap) {
if (heap->size == 0) {
return -1;
}
int min = heap->data[0];
heap->size--;
heap->data[0] = heap->data[heap->size];
int i = 0;
while (1) {
int left = 2*i +1;
int right = 2*i +2;
int smallest = i;
if (left < heap->size && heap->data[left] < heap->data[smallest]) {
smallest = left;
}
if (right < heap->size && heap->data[right] < heap->data[smallest]) {
smallest = right;
}
if (smallest != i) {
int temp = heap->data[i];
heap->data[i] = heap->data[smallest];
heap->data[smallest] = temp;
i = smallest;
}
else {
break;
}
}
return min;
}
void heap_free(MinHeap *heap) {
free(heap->data);
free(heap);
}
int arrays_equal(int *a1, int *a2, int size) {
for(int i=0;i<size;i++) {
if(a1[i] != a2[i]) return 0;
}
return 1;
}
| int* func0(int *array, int size) {
MinHeap *heap = heap_init(size > 0 ? size : 1);
for(int i=0;i<size;i++) {
heap_push(heap, array[i]);
}
int *sorted = malloc(sizeof(int)*size);
for(int i=0;i<size;i++) {
sorted[i] = heap_pop(heap);
}
heap_free(heap);
return sorted;
}
| int main() {
int input1[] = {1,3,5,7,9,2,4,6,8,0};
int expected1[] = {0,1,2,3,4,5,6,7,8,9};
int size1 = sizeof(input1)/sizeof(input1[0]);
int *sorted1 = func0(input1, size1);
assert(arrays_equal(sorted1, expected1, size1));
free(sorted1);
int input2[] = {25,35,22,85,14,65,75,25,58};
int expected2[] = {14,22,25,25,35,58,65,75,85};
int size2 = sizeof(input2)/sizeof(input2[0]);
int *sorted2 = func0(input2, size2);
assert(arrays_equal(sorted2, expected2, size2));
free(sorted2);
int input3[] = {7,1,9,5};
int expected3[] = {1,5,7,9};
int size3 = sizeof(input3)/sizeof(input3[0]);
int *sorted3 = func0(input3, size3);
assert(arrays_equal(sorted3, expected3, size3));
free(sorted3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
mov $0x10,%edi
push %r13
push %r12
mov $0x1,%r12d
push %rbp
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
test %esi,%esi
cmovg %esi,%r12d
callq 10c0 <malloc@plt>
movslq %r12d,%rdi
mov %rax,%rbp
shl $0x2,%rdi
callq 10c0 <malloc@plt>
mov %r12d,0xc(%rbp)
movslq %ebx,%r12
mov %rax,0x0(%rbp)
mov %rax,%r13
lea 0x0(,%r12,4),%rax
movl $0x0,0x8(%rbp)
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 17e8 <func0+0x158>
sub $0x1,%ebx
mov (%r14),%r12d
add $0x4,%r14
xor %eax,%eax
shl $0x2,%rbx
lea (%r14,%rbx,1),%r15
nopw 0x0(%rax,%rax,1)
mov %r12d,0x0(%r13,%rax,4)
mov 0x8(%rbp),%edx
lea 0x1(%rdx),%eax
mov %eax,0x8(%rbp)
test %edx,%edx
jne 1730 <func0+0xa0>
jmp 1754 <func0+0xc4>
nopl 0x0(%rax)
mov %edi,(%rsi)
mov %ecx,(%rax)
test %edx,%edx
je 1754 <func0+0xc4>
movslq %edx,%rax
lea -0x1(%rax),%ecx
lea 0x0(%r13,%rax,4),%rax
mov %ecx,%edx
mov (%rax),%edi
shr $0x1f,%edx
add %ecx,%edx
sar %edx
movslq %edx,%rcx
lea 0x0(%r13,%rcx,4),%rsi
mov (%rsi),%ecx
cmp %edi,%ecx
jg 1728 <func0+0x98>
cmp %r14,%r15
je 1790 <func0+0x100>
movslq 0x8(%rbp),%rax
mov 0xc(%rbp),%esi
mov (%r14),%r12d
cmp %esi,%eax
jl 1786 <func0+0xf6>
add %esi,%esi
mov %r13,%rdi
mov %esi,0xc(%rbp)
movslq %esi,%rsi
shl $0x2,%rsi
callq 10d0 <realloc@plt>
mov %rax,0x0(%rbp)
mov %rax,%r13
movslq 0x8(%rbp),%rax
add $0x4,%r14
jmp 1710 <func0+0x80>
nopl 0x0(%rax)
mov 0x8(%rsp),%rdi
callq 10c0 <malloc@plt>
mov %rax,%r14
mov %rax,%r12
lea 0x4(%rax,%rbx,1),%rbx
nopl (%rax)
mov %rbp,%rdi
add $0x4,%r12
callq 1580 <heap_pop>
mov %eax,-0x4(%r12)
cmp %rbx,%r12
jne 17a8 <func0+0x118>
mov 0x0(%rbp),%r13
mov %r13,%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %rax,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r14
jmp 17c2 <func0+0x132>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov edx, 1
push r14
push r13
push r12
push rbp
push rbx
mov ebx, esi
sub rsp, 28h
test esi, esi
cmovg edx, esi
mov [rsp+58h+var_58], rdi
mov edi, 10h; size
mov ebp, edx
call _malloc
movsxd rdi, ebp
shl rdi, 2; size
mov r15, rax
call _malloc
movsxd r8, ebx
mov [r15+0Ch], ebp
mov [r15], rax
mov r13, rax
lea rax, ds:0[r8*4]
mov dword ptr [r15+8], 0
mov [rsp+58h+size], rax
test ebx, ebx
jle loc_174E
mov rcx, [rsp+58h+var_58]
xor r14d, r14d
mov r9d, r14d
movsxd rbx, r14d
mov r12d, [rcx+r14*4]
cmp ebp, r14d
jle short loc_16B3
nop dword ptr [rax]
loc_1650:
lea eax, [r9+1]
mov [r13+r14*4+0], r12d
mov [r15+8], eax
test r14, r14
jnz short loc_1677
jmp short loc_1697
loc_1668:
mov [rdx], r12d
mov [rdi], esi
test eax, eax
jz short loc_1697
mov r12d, [rdx]
movsxd rbx, eax
loc_1677:
lea edx, [rbx-1]
lea rdi, [r13+rbx*4+0]
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
movsxd rdx, eax
lea rdx, [r13+rdx*4+0]
mov esi, [rdx]
cmp esi, r12d
jg short loc_1668
loc_1697:
add r14, 1
cmp r14, r8
jz short loc_16F8
mov ebp, [r15+0Ch]
mov r12d, [rcx+r14*4]
mov r9d, r14d
movsxd rbx, r14d
cmp ebp, r14d
jg short loc_1650
loc_16B3:
lea edx, [rbp+rbp+0]
mov rdi, r13; ptr
mov [rsp+58h+var_48], rcx
mov [r15+0Ch], edx
movsxd rdx, edx
lea rsi, ds:0[rdx*4]; size
mov [rsp+58h+var_50], r8
mov dword ptr [rsp+58h+var_58], r14d
call _realloc
mov rcx, [rsp+58h+var_48]
mov r8, [rsp+58h+var_50]
mov [r15], rax
mov r9d, dword ptr [rsp+58h+var_58]
mov r13, rax
jmp loc_1650
loc_16F8:
mov r14, [rsp+58h+size]
mov rdi, r14; size
call _malloc
add r14, rax
mov r12, rax
mov rbx, rax
mov rbp, r14
nop dword ptr [rax+00000000h]
loc_1718:
mov rdi, r15
add rbx, 4
call heap_pop
mov [rbx-4], eax
cmp rbp, rbx
jnz short loc_1718
loc_172C:
mov rdi, r13; ptr
call _free
mov rdi, r15; ptr
call _free
add rsp, 28h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_174E:
mov rdi, rax; size
call _malloc
mov r12, rax
jmp short loc_172C | void * func0(_DWORD *a1, int a2)
{
int v2; // edx
int v3; // ebp
_DWORD *v4; // r15
_DWORD *v5; // rax
long long v6; // r8
_DWORD *v7; // r13
_DWORD *v8; // rcx
long long v9; // r14
int v10; // r9d
long long v11; // rbx
int v12; // r12d
int v13; // eax
int *v14; // rdx
int v15; // esi
int v16; // ebp
_DWORD *v17; // rax
char *v18; // rax
char *v19; // r14
void *v20; // r12
char *v21; // rbx
long long v23; // [rsp+8h] [rbp-50h]
_DWORD *v24; // [rsp+10h] [rbp-48h]
long long size; // [rsp+18h] [rbp-40h]
v2 = 1;
if ( a2 > 0 )
v2 = a2;
v3 = v2;
v4 = malloc(0x10uLL);
v5 = malloc(4LL * v3);
v6 = a2;
v4[3] = v3;
*(_QWORD *)v4 = v5;
v7 = v5;
v4[2] = 0;
size = 4LL * a2;
if ( a2 <= 0 )
{
v20 = malloc(4LL * a2);
}
else
{
v8 = a1;
v9 = 0LL;
v10 = 0;
v11 = 0LL;
v12 = *a1;
while ( 1 )
{
v7[v9] = v12;
v4[2] = v10 + 1;
if ( v9 )
{
while ( 1 )
{
v13 = ((int)v11 - 1) / 2;
v14 = &v7[v13];
v15 = *v14;
if ( *v14 <= v12 )
break;
*v14 = v12;
v7[v11] = v15;
if ( !v13 )
break;
v12 = *v14;
v11 = v13;
}
}
if ( ++v9 == v6 )
break;
v16 = v4[3];
v12 = v8[v9];
v10 = v9;
v11 = (int)v9;
if ( v16 <= (int)v9 )
{
v24 = v8;
v4[3] = 2 * v16;
v23 = v6;
v17 = realloc(v7, 8LL * v16);
v8 = v24;
v6 = v23;
*(_QWORD *)v4 = v17;
v10 = v9;
v7 = v17;
}
}
v18 = (char *)malloc(size);
v19 = &v18[size];
v20 = v18;
v21 = v18;
do
{
v21 += 4;
*((_DWORD *)v21 - 1) = heap_pop(v4);
}
while ( v19 != v21 );
}
free(v7);
free(v4);
return v20;
} | func0:
ENDBR64
PUSH R15
MOV EDX,0x1
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x28
TEST ESI,ESI
CMOVG EDX,ESI
MOV qword ptr [RSP],RDI
MOV EDI,0x10
MOV EBP,EDX
CALL 0x001010c0
MOVSXD RDI,EBP
SHL RDI,0x2
MOV R15,RAX
CALL 0x001010c0
MOVSXD R8,EBX
MOV dword ptr [R15 + 0xc],EBP
MOV qword ptr [R15],RAX
MOV R13,RAX
LEA RAX,[R8*0x4]
MOV dword ptr [R15 + 0x8],0x0
MOV qword ptr [RSP + 0x18],RAX
TEST EBX,EBX
JLE 0x0010174e
MOV RCX,qword ptr [RSP]
XOR R14D,R14D
MOV R9D,R14D
MOVSXD RBX,R14D
MOV R12D,dword ptr [RCX + R14*0x4]
CMP EBP,R14D
JLE 0x001016b3
NOP dword ptr [RAX]
LAB_00101650:
LEA EAX,[R9 + 0x1]
MOV dword ptr [R13 + R14*0x4],R12D
MOV dword ptr [R15 + 0x8],EAX
TEST R14,R14
JNZ 0x00101677
JMP 0x00101697
LAB_00101668:
MOV dword ptr [RDX],R12D
MOV dword ptr [RDI],ESI
TEST EAX,EAX
JZ 0x00101697
MOV R12D,dword ptr [RDX]
MOVSXD RBX,EAX
LAB_00101677:
LEA EDX,[RBX + -0x1]
LEA RDI,[R13 + RBX*0x4]
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOVSXD RDX,EAX
LEA RDX,[R13 + RDX*0x4]
MOV ESI,dword ptr [RDX]
CMP ESI,R12D
JG 0x00101668
LAB_00101697:
ADD R14,0x1
CMP R14,R8
JZ 0x001016f8
MOV EBP,dword ptr [R15 + 0xc]
MOV R12D,dword ptr [RCX + R14*0x4]
MOV R9D,R14D
MOVSXD RBX,R14D
CMP EBP,R14D
JG 0x00101650
LAB_001016b3:
LEA EDX,[RBP + RBP*0x1]
MOV RDI,R13
MOV qword ptr [RSP + 0x10],RCX
MOV dword ptr [R15 + 0xc],EDX
MOVSXD RDX,EDX
LEA RSI,[RDX*0x4]
MOV qword ptr [RSP + 0x8],R8
MOV dword ptr [RSP],R14D
CALL 0x001010d0
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x8]
MOV qword ptr [R15],RAX
MOV R9D,dword ptr [RSP]
MOV R13,RAX
JMP 0x00101650
LAB_001016f8:
MOV R14,qword ptr [RSP + 0x18]
MOV RDI,R14
CALL 0x001010c0
ADD R14,RAX
MOV R12,RAX
MOV RBX,RAX
MOV RBP,R14
NOP dword ptr [RAX]
LAB_00101718:
MOV RDI,R15
ADD RBX,0x4
CALL 0x001014a0
MOV dword ptr [RBX + -0x4],EAX
CMP RBP,RBX
JNZ 0x00101718
LAB_0010172c:
MOV RDI,R13
CALL 0x00101090
MOV RDI,R15
CALL 0x00101090
ADD RSP,0x28
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010174e:
MOV RDI,RAX
CALL 0x001010c0
MOV R12,RAX
JMP 0x0010172c | int4 * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int4 uVar3;
int8 *__ptr;
void *__ptr_00;
int4 *puVar4;
int iVar5;
long lVar6;
int4 *puVar7;
int4 *puVar8;
ulong uVar9;
ulong uVar10;
int iVar11;
ulong uVar12;
iVar5 = 1;
if (0 < param_2) {
iVar5 = param_2;
}
__ptr = (int8 *)malloc(0x10);
__ptr_00 = malloc((long)iVar5 << 2);
uVar9 = (ulong)param_2;
*(int *)((long)__ptr + 0xc) = iVar5;
*__ptr = __ptr_00;
*(int4 *)(__ptr + 1) = 0;
if (param_2 < 1) {
puVar4 = (int4 *)malloc(uVar9 * 4);
}
else {
uVar10 = 0;
lVar6 = 0;
iVar11 = *param_1;
uVar12 = uVar10;
if (iVar5 < 1) goto LAB_001016b3;
LAB_00101650:
*(int *)((long)__ptr_00 + uVar12 * 4) = iVar11;
*(int *)(__ptr + 1) = (int)uVar10 + 1;
if (uVar12 != 0) {
while( true ) {
iVar2 = ((int)lVar6 + -1) / 2;
piVar1 = (int *)((long)__ptr_00 + (long)iVar2 * 4);
iVar5 = *piVar1;
if (iVar5 <= iVar11) break;
*piVar1 = iVar11;
*(int *)((long)__ptr_00 + lVar6 * 4) = iVar5;
if (iVar2 == 0) break;
iVar11 = *piVar1;
lVar6 = (long)iVar2;
}
}
uVar12 = uVar12 + 1;
if (uVar12 != uVar9) {
iVar5 = *(int *)((long)__ptr + 0xc);
iVar11 = param_1[uVar12];
uVar10 = uVar12 & 0xffffffff;
lVar6 = (long)(int)uVar12;
if (iVar5 <= (int)uVar12) {
LAB_001016b3:
*(int *)((long)__ptr + 0xc) = iVar5 * 2;
__ptr_00 = realloc(__ptr_00,(long)(iVar5 * 2) * 4);
*__ptr = __ptr_00;
uVar10 = uVar12 & 0xffffffff;
}
goto LAB_00101650;
}
puVar4 = (int4 *)malloc(uVar9 * 4);
puVar7 = puVar4;
do {
puVar8 = puVar7 + 1;
uVar3 = heap_pop(__ptr);
*puVar7 = uVar3;
puVar7 = puVar8;
} while (puVar4 + uVar9 != puVar8);
}
free(__ptr_00);
free(__ptr);
return puVar4;
} |
6,436 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (a == c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
assert(strcmp(func0(2, -5, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov -0x4(%rbp),%eax
cmp -0xc(%rbp),%eax
jne 118b <func0+0x22>
lea 0xe7f(%rip),%rax
jmp 1192 <func0+0x29>
lea 0xe7a(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov eax, [rbp+var_4]
cmp eax, [rbp+var_C]
jnz short loc_118B
lea rax, s2; "Yes"
jmp short loc_1192
loc_118B:
lea rax, aNo; "No"
loc_1192:
pop rbp
retn | const char * func0(int a1, long long a2, int a3)
{
if ( a1 == a3 )
return "Yes";
else
return "No";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x0010118b
LEA RAX,[0x102008]
JMP 0x00101192
LAB_0010118b:
LEA RAX,[0x10200c]
LAB_00101192:
POP RBP
RET | int * func0(int param_1,int8 param_2,int param_3)
{
int *puVar1;
if (param_1 == param_3) {
puVar1 = &DAT_00102008;
}
else {
puVar1 = &DAT_0010200c;
}
return puVar1;
} |
6,437 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (a == c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
assert(strcmp(func0(2, -5, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edx,%edi
lea 0xece(%rip),%rax
lea 0xecb(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
cmp edi, edx
lea rax, unk_2004
lea rdx, unk_2008
cmovnz rax, rdx
retn | void * func0(int a1, long long a2, int a3)
{
void *result; // rax
result = &unk_2004;
if ( a1 != a3 )
return &unk_2008;
return result;
} | func0:
ENDBR64
CMP EDI,EDX
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVNZ RAX,RDX
RET | int * func0(int param_1,int8 param_2,int param_3)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_1 != param_3) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
6,438 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (a == c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
assert(strcmp(func0(2, -5, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edx,%edi
lea 0xeb7(%rip),%rax
lea 0xeb4(%rip),%rdx
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, edx
lea rax, unk_2004
lea rdx, unk_2008
cmovnz rax, rdx
retn | void * func0(int a1, long long a2, int a3)
{
void *result; // rax
result = &unk_2004;
if ( a1 != a3 )
return &unk_2008;
return result;
} | func0:
ENDBR64
CMP EDI,EDX
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVNZ RAX,RDX
RET | int * func0(int param_1,int8 param_2,int param_3)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_1 != param_3) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
6,439 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (a == c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
assert(strcmp(func0(2, -5, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edx,%edi
lea 0xeb7(%rip),%rax
lea 0xeb4(%rip),%rdx
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, edx
lea rax, unk_2008
lea rdx, unk_2004
cmovz rax, rdx
retn | void * func0(int a1, long long a2, int a3)
{
void *result; // rax
result = &unk_2008;
if ( a1 == a3 )
return &unk_2004;
return result;
} | func0:
ENDBR64
CMP EDI,EDX
LEA RAX,[0x102008]
LEA RDX,[0x102004]
CMOVZ RAX,RDX
RET | int * func0(int param_1,int8 param_2,int param_3)
{
int *puVar1;
puVar1 = &DAT_00102008;
if (param_1 == param_3) {
puVar1 = &DAT_00102004;
}
return puVar1;
} |
6,440 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int actual_cost, int sale_amount) {
if(sale_amount == actual_cost){
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jne 1166 <func0+0x1d>
mov $0x1,%eax
jmp 116b <func0+0x22>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jnz short loc_1166
mov eax, 1
jmp short loc_116B
loc_1166:
mov eax, 0
loc_116B:
pop rbp
retn | _BOOL8 func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x00101166
MOV EAX,0x1
JMP 0x0010116b
LAB_00101166:
MOV EAX,0x0
LAB_0010116b:
POP RBP
RET | bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
6,441 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int actual_cost, int sale_amount) {
if(sale_amount == actual_cost){
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edi,%esi
sete %al
retq
| func0:
endbr64
cmp esi, edi
setz al
retn | bool func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
CMP ESI,EDI
SETZ AL
RET | bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
6,442 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int actual_cost, int sale_amount) {
if(sale_amount == actual_cost){
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edi,%esi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, edi
setz al
retn | bool func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
CMP ESI,EDI
SETZ AL
RET | bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
6,443 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int actual_cost, int sale_amount) {
if(sale_amount == actual_cost){
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edi,%esi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, edi
setz al
retn | bool func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
CMP ESI,EDI
SETZ AL
RET | bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
6,444 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215*t - 11.37*pow(v, 0.16) + 0.3965*t*pow(v, 0.16);
return (int)(round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm1
movsd 0xee0(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xedc(%rip),%xmm0
addsd %xmm0,%xmm1
movsd %xmm1,-0x20(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xece(%rip),%xmm1
callq 1080 <pow@plt>
movsd 0xec9(%rip),%xmm1
mulsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
subsd %xmm0,%xmm1
movsd %xmm1,-0x20(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm1
movsd 0xeb2(%rip),%xmm0
movapd %xmm1,%xmm2
mulsd %xmm0,%xmm2
movsd %xmm2,-0x28(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xe88(%rip),%xmm1
callq 1080 <pow@plt>
mulsd -0x28(%rbp),%xmm0
addsd -0x20(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
mov -0x8(%rbp),%rax
movq %rax,%xmm0
callq 1070 <round@plt>
cvttsd2si %xmm0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2070
mulsd xmm1, xmm0
movsd xmm0, cs:qword_2078
addsd xmm1, xmm0
movsd [rbp+var_20], xmm1
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_14]
movq rax, xmm3
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, cs:qword_2088
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_20]
subsd xmm1, xmm0
movsd [rbp+var_20], xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2090
movapd xmm2, xmm1
mulsd xmm2, xmm0
movsd [rbp+var_28], xmm2
pxor xmm4, xmm4
cvtsi2sd xmm4, [rbp+var_14]
movq rax, xmm4
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
mulsd xmm0, [rbp+var_28]
addsd xmm0, [rbp+var_20]
movsd [rbp+x], xmm0
mov rax, [rbp+x]
movq xmm0, rax; x
call _round
cvttsd2si eax, xmm0
leave
retn | long long func0(int a1, int a2)
{
double v3; // [rsp+10h] [rbp-20h]
double x; // [rsp+28h] [rbp-8h]
v3 = (double)a2 * 0.6215000000000001 + 13.12 - pow((double)a1, 0.16) * 11.37;
x = pow((double)a1, 0.16) * ((double)a2 * 0.3965) + v3;
return (unsigned int)(int)round(x);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102070]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102078]
ADDSD XMM1,XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x14]
MOVQ RAX,XMM3
MOVSD XMM0,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101080
MOVSD XMM1,qword ptr [0x00102088]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x20]
SUBSD XMM1,XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102090]
MOVAPD XMM2,XMM1
MULSD XMM2,XMM0
MOVSD qword ptr [RBP + -0x28],XMM2
PXOR XMM4,XMM4
CVTSI2SD XMM4,dword ptr [RBP + -0x14]
MOVQ RAX,XMM4
MOVSD XMM0,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101080
MULSD XMM0,qword ptr [RBP + -0x28]
ADDSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
LEAVE
RET | int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
dVar3 = (double)param_2 * DAT_00102070 + DAT_00102078;
dVar1 = pow((double)param_1,DAT_00102080);
dVar1 = dVar1 * DAT_00102088;
dVar4 = (double)param_2 * DAT_00102090;
dVar2 = pow((double)param_1,DAT_00102080);
dVar1 = round(dVar2 * dVar4 + (dVar3 - dVar1));
return (int)dVar1;
} |
6,445 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215*t - 11.37*pow(v, 0.16) + 0.3965*t*pow(v, 0.16);
return (int)(round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x28,%rsp
pxor %xmm4,%xmm4
cvtsi2sd %esi,%xmm4
movsd %xmm4,0x8(%rsp)
pxor %xmm6,%xmm6
cvtsi2sd %edi,%xmm6
mov 0xeda(%rip),%rax
movq %rax,%xmm1
movsd %xmm6,0x10(%rsp)
movapd %xmm6,%xmm0
callq 1080 <pow@plt>
movsd %xmm0,0x18(%rsp)
mov 0xeb9(%rip),%rax
movq %rax,%xmm1
movsd 0x10(%rsp),%xmm0
callq 1080 <pow@plt>
movapd %xmm0,%xmm3
movsd 0x8(%rsp),%xmm4
movapd %xmm4,%xmm5
mulsd 0xe9b(%rip),%xmm5
movapd %xmm5,%xmm0
addsd 0xe97(%rip),%xmm0
movsd 0x18(%rsp),%xmm2
mulsd 0xe91(%rip),%xmm2
subsd %xmm2,%xmm0
mulsd 0xe8d(%rip),%xmm4
movapd %xmm4,%xmm1
mulsd %xmm3,%xmm1
addsd %xmm1,%xmm0
callq 1070 <round@plt>
cvttsd2si %xmm0,%eax
add $0x28,%rsp
retq
| func0:
endbr64
push r14
push rbx
sub rsp, 18h
pxor xmm3, xmm3
cvtsi2sd xmm3, esi
movsd [rsp+28h+var_20], xmm3
pxor xmm4, xmm4
cvtsi2sd xmm4, edi
movq r14, xmm4
mov rax, cs:qword_2068
movq xmm1, rax
movapd xmm0, xmm4
call _pow
movq rbx, xmm0
mov rax, cs:qword_2068
movq xmm1, rax
movq xmm0, r14
call _pow
movapd xmm2, xmm0
movsd xmm3, [rsp+28h+var_20]
movapd xmm0, xmm3
mulsd xmm0, cs:qword_2070
addsd xmm0, cs:qword_2078
movq xmm1, rbx
mulsd xmm1, cs:qword_2080
subsd xmm0, xmm1
mulsd xmm3, cs:qword_2088
movapd xmm1, xmm3
mulsd xmm1, xmm2
addsd xmm0, xmm1
call _round
cvttsd2si eax, xmm0
add rsp, 18h
pop rbx
pop r14
retn | long long func0(int a1, int a2)
{
double v2; // rbx
double v3; // xmm2_8
v2 = pow((double)a1, 0.16);
v3 = pow((double)a1, 0.16);
return (unsigned int)(int)round((double)a2 * 0.6215000000000001 + 13.12 - v2 * 11.37 + (double)a2 * 0.3965 * v3);
} | func0:
ENDBR64
PUSH R14
PUSH RBX
SUB RSP,0x18
PXOR XMM3,XMM3
CVTSI2SD XMM3,ESI
MOVSD qword ptr [RSP + 0x8],XMM3
PXOR XMM4,XMM4
CVTSI2SD XMM4,EDI
MOVQ R14,XMM4
MOV RAX,qword ptr [0x00102068]
MOVQ XMM1,RAX
MOVAPD XMM0,XMM4
CALL 0x00101080
MOVQ RBX,XMM0
MOV RAX,qword ptr [0x00102068]
MOVQ XMM1,RAX
MOVQ XMM0,R14
CALL 0x00101080
MOVAPD XMM2,XMM0
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM0,XMM3
MULSD XMM0,qword ptr [0x00102070]
ADDSD XMM0,qword ptr [0x00102078]
MOVQ XMM1,RBX
MULSD XMM1,qword ptr [0x00102080]
SUBSD XMM0,XMM1
MULSD XMM3,qword ptr [0x00102088]
MOVAPD XMM1,XMM3
MULSD XMM1,XMM2
ADDSD XMM0,XMM1
CALL 0x00101070
CVTTSD2SI EAX,XMM0
ADD RSP,0x18
POP RBX
POP R14
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow((double)param_1,DAT_00102068);
dVar2 = pow((double)param_1,DAT_00102068);
dVar1 = round((((double)param_2 * _DAT_00102070 + _DAT_00102078) - dVar1 * _DAT_00102080) +
(double)param_2 * _DAT_00102088 * dVar2);
return (int)dVar1;
} |
6,446 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215*t - 11.37*pow(v, 0.16) + 0.3965*t*pow(v, 0.16);
return (int)(round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm4,%xmm4
pxor %xmm2,%xmm2
sub $0x28,%rsp
movsd 0xe30(%rip),%xmm1
cvtsi2sd %edi,%xmm4
cvtsi2sd %esi,%xmm2
movapd %xmm4,%xmm0
movsd %xmm4,0x10(%rsp)
movsd %xmm2,0x18(%rsp)
callq 1080 <pow@plt>
mov 0xe0c(%rip),%rax
movsd 0x10(%rsp),%xmm4
movsd %xmm0,0x8(%rsp)
movq %rax,%xmm1
movapd %xmm4,%xmm0
callq 1080 <pow@plt>
movsd 0x18(%rsp),%xmm2
movsd 0x8(%rsp),%xmm3
mulsd 0xdf6(%rip),%xmm3
movapd %xmm0,%xmm1
movsd 0xdda(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd 0xde6(%rip),%xmm2
addsd 0xdce(%rip),%xmm0
subsd %xmm3,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
callq 1070 <round@plt>
add $0x28,%rsp
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
pxor xmm4, xmm4
pxor xmm2, xmm2
sub rsp, 28h
movsd xmm1, cs:qword_2068
cvtsi2sd xmm4, edi
cvtsi2sd xmm2, esi
movapd xmm0, xmm4
movsd [rsp+28h+var_18], xmm4
movsd [rsp+28h+var_10], xmm2
call _pow
mov rax, cs:qword_2068
movsd xmm4, [rsp+28h+var_18]
movsd [rsp+28h+var_20], xmm0
movq xmm1, rax
movapd xmm0, xmm4
call _pow
movsd xmm2, [rsp+28h+var_10]
movsd xmm3, [rsp+28h+var_20]
mulsd xmm3, cs:qword_2080
movapd xmm4, xmm0
movsd xmm0, cs:qword_2070
mulsd xmm0, xmm2
mulsd xmm2, cs:qword_2088
addsd xmm0, cs:qword_2078
subsd xmm0, xmm3
mulsd xmm2, xmm4
addsd xmm0, xmm2
call _round
add rsp, 28h
cvttsd2si eax, xmm0
retn | long long func0(int a1, int a2)
{
double v2; // xmm4_8
double v4; // [rsp+8h] [rbp-20h]
v4 = pow((double)a1, 0.16);
v2 = pow((double)a1, 0.16);
return (unsigned int)(int)round(0.6215000000000001 * (double)a2 + 13.12 - v4 * 11.37 + (double)a2 * 0.3965 * v2);
} | func0:
ENDBR64
PXOR XMM4,XMM4
PXOR XMM2,XMM2
SUB RSP,0x28
MOVSD XMM1,qword ptr [0x00102068]
CVTSI2SD XMM4,EDI
CVTSI2SD XMM2,ESI
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x10],XMM4
MOVSD qword ptr [RSP + 0x18],XMM2
CALL 0x00101080
MOV RAX,qword ptr [0x00102068]
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVQ XMM1,RAX
MOVAPD XMM0,XMM4
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x18]
MOVSD XMM3,qword ptr [RSP + 0x8]
MULSD XMM3,qword ptr [0x00102080]
MOVAPD XMM4,XMM0
MOVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,XMM2
MULSD XMM2,qword ptr [0x00102088]
ADDSD XMM0,qword ptr [0x00102078]
SUBSD XMM0,XMM3
MULSD XMM2,XMM4
ADDSD XMM0,XMM2
CALL 0x00101070
ADD RSP,0x28
CVTTSD2SI EAX,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow((double)param_1,DAT_00102068);
dVar2 = pow((double)param_1,DAT_00102068);
dVar1 = round(((DAT_00102070 * (double)param_2 + _DAT_00102078) - dVar1 * _DAT_00102080) +
(double)param_2 * _DAT_00102088 * dVar2);
return (int)dVar1;
} |
6,447 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215*t - 11.37*pow(v, 0.16) + 0.3965*t*pow(v, 0.16);
return (int)(round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm4,%xmm4
pxor %xmm2,%xmm2
sub $0x28,%rsp
movsd 0xe30(%rip),%xmm1
cvtsi2sd %edi,%xmm4
cvtsi2sd %esi,%xmm2
movapd %xmm4,%xmm0
movsd %xmm4,0x10(%rsp)
movsd %xmm2,0x18(%rsp)
callq 1080 <pow@plt>
mov 0xe0c(%rip),%rax
movsd 0x10(%rsp),%xmm4
movsd %xmm0,0x8(%rsp)
movq %rax,%xmm1
movapd %xmm4,%xmm0
callq 1080 <pow@plt>
movsd 0x18(%rsp),%xmm2
movsd 0x8(%rsp),%xmm3
mulsd 0xdf6(%rip),%xmm3
movapd %xmm0,%xmm1
movsd 0xdda(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd 0xde6(%rip),%xmm2
addsd 0xdce(%rip),%xmm0
subsd %xmm3,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
callq 1070 <round@plt>
add $0x28,%rsp
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
pxor xmm4, xmm4
pxor xmm2, xmm2
sub rsp, 28h
movsd xmm1, cs:y; y
cvtsi2sd xmm4, edi
cvtsi2sd xmm2, esi
movapd xmm0, xmm4; x
movsd [rsp+28h+x], xmm4
movsd [rsp+28h+var_10], xmm2
call _pow
movsd xmm4, [rsp+28h+x]
movsd xmm1, cs:y; y
movsd [rsp+28h+var_20], xmm0
movapd xmm0, xmm4; x
call _pow
movsd xmm2, [rsp+28h+var_10]
movsd xmm3, [rsp+28h+var_20]
movapd xmm4, xmm0
movsd xmm0, cs:qword_2070
movsd xmm1, cs:qword_2080
mulsd xmm0, xmm2
mulsd xmm2, cs:qword_2088
addsd xmm0, cs:qword_2078
mulsd xmm1, xmm3
mulsd xmm2, xmm4
subsd xmm0, xmm1
addsd xmm0, xmm2; x
call _round
add rsp, 28h
cvttsd2si eax, xmm0
retn | long long func0(int a1, int a2)
{
double v2; // xmm4_8
double v4; // [rsp+8h] [rbp-20h]
v4 = pow((double)a1, 0.16);
v2 = pow((double)a1, 0.16);
return (unsigned int)(int)round(0.6215000000000001 * (double)a2 + 13.12 - 11.37 * v4 + (double)a2 * 0.3965 * v2);
} | func0:
ENDBR64
PXOR XMM4,XMM4
PXOR XMM2,XMM2
SUB RSP,0x28
MOVSD XMM1,qword ptr [0x00102068]
CVTSI2SD XMM4,EDI
CVTSI2SD XMM2,ESI
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x10],XMM4
MOVSD qword ptr [RSP + 0x18],XMM2
CALL 0x00101080
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD XMM1,qword ptr [0x00102068]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM4
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x18]
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM4,XMM0
MOVSD XMM0,qword ptr [0x00102070]
MOVSD XMM1,qword ptr [0x00102080]
MULSD XMM0,XMM2
MULSD XMM2,qword ptr [0x00102088]
ADDSD XMM0,qword ptr [0x00102078]
MULSD XMM1,XMM3
MULSD XMM2,XMM4
SUBSD XMM0,XMM1
ADDSD XMM0,XMM2
CALL 0x00101070
ADD RSP,0x28
CVTTSD2SI EAX,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow((double)param_1,DAT_00102068);
dVar2 = pow((double)param_1,DAT_00102068);
dVar1 = round(((DAT_00102070 * (double)param_2 + _DAT_00102078) - DAT_00102080 * dVar1) +
(double)param_2 * _DAT_00102088 * dVar2);
return (int)dVar1;
} |
6,448 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(char *sample_names[], int length) {
int i, j, valid;
int total_length = 0;
for (i = 0; i < length; i++) {
char *name = sample_names[i];
if (isupper(name[0])) {
valid = 1;
for (j = 1; name[j] != '\0'; j++) {
if (!islower(name[j])) {
valid = 0;
break;
}
}
if (valid)
total_length += strlen(name);
}
}
return total_length;
}
| int main() {
char *names1[] = {"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"};
assert(func0(names1, 6) == 16);
char *names2[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
assert(func0(names2, 6) == 10);
char *names3[] = {"abcd", "Python", "abba", "aba"};
assert(func0(names3, 4) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1294 <func0+0xeb>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rdx
mov -0x8(%rbp),%rax
movzbl (%rax),%eax
movsbq %al,%rax
add %rax,%rax
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 1290 <func0+0xe7>
movl $0x1,-0x10(%rbp)
movl $0x1,-0x14(%rbp)
jmp 1260 <func0+0xb7>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
jne 125c <func0+0xb3>
movl $0x0,-0x10(%rbp)
jmp 1274 <func0+0xcb>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1222 <func0+0x79>
cmpl $0x0,-0x10(%rbp)
je 1290 <func0+0xe7>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,%edx
mov -0xc(%rbp),%eax
add %edx,%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11cf <func0+0x26>
mov -0xc(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_C], 0
mov [rbp+var_18], 0
jmp loc_1294
loc_11CF:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov [rbp+s], rax
call ___ctype_b_loc
mov rdx, [rax]
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
movsx rax, al
add rax, rax
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_1290
mov [rbp+var_10], 1
mov [rbp+var_14], 1
jmp short loc_1260
loc_1222:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jnz short loc_125C
mov [rbp+var_10], 0
jmp short loc_1274
loc_125C:
add [rbp+var_14], 1
loc_1260:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1222
loc_1274:
cmp [rbp+var_10], 0
jz short loc_1290
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_C]
add eax, edx
mov [rbp+var_C], eax
loc_1290:
add [rbp+var_18], 1
loc_1294:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl loc_11CF
mov eax, [rbp+var_C]
leave
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v5; // [rsp+20h] [rbp-10h]
unsigned int v6; // [rsp+24h] [rbp-Ch]
char *s; // [rsp+28h] [rbp-8h]
v6 = 0;
for ( i = 0; i < a2; ++i )
{
s = *(char **)(8LL * i + a1);
if ( ((*__ctype_b_loc())[*s] & 0x100) != 0 )
{
v5 = 1;
for ( j = 1; s[j]; ++j )
{
if ( ((*__ctype_b_loc())[s[j]] & 0x200) == 0 )
{
v5 = 0;
break;
}
}
if ( v5 )
v6 += strlen(s);
}
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101294
LAB_001011cf:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
CALL 0x001010b0
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
MOVSX RAX,AL
ADD RAX,RAX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x00101290
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0x14],0x1
JMP 0x00101260
LAB_00101222:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JNZ 0x0010125c
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101274
LAB_0010125c:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101260:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101222
LAB_00101274:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x00101290
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101080
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
LAB_00101290:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101294:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011cf
MOV EAX,dword ptr [RBP + -0xc]
LEAVE
RET | int func0(long param_1,int param_2)
{
char *__s;
bool bVar1;
ushort **ppuVar2;
size_t sVar3;
int local_20;
int local_1c;
int local_14;
local_14 = 0;
local_20 = 0;
do {
if (param_2 <= local_20) {
return local_14;
}
__s = *(char **)(param_1 + (long)local_20 * 8);
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[*__s] & 0x100) != 0) {
bVar1 = true;
for (local_1c = 1; __s[local_1c] != '\0'; local_1c = local_1c + 1) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[__s[local_1c]] & 0x200) == 0) {
bVar1 = false;
break;
}
}
if (bVar1) {
sVar3 = strlen(__s);
local_14 = local_14 + (int)sVar3;
}
}
local_20 = local_20 + 1;
} while( true );
} |
6,449 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(char *sample_names[], int length) {
int i, j, valid;
int total_length = 0;
for (i = 0; i < length; i++) {
char *name = sample_names[i];
if (isupper(name[0])) {
valid = 1;
for (j = 1; name[j] != '\0'; j++) {
if (!islower(name[j])) {
valid = 0;
break;
}
}
if (valid)
total_length += strlen(name);
}
}
return total_length;
}
| int main() {
char *names1[] = {"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"};
assert(func0(names1, 6) == 16);
char *names2[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
assert(func0(names2, 6) == 10);
char *names3[] = {"abcd", "Python", "abba", "aba"};
assert(func0(names3, 4) == 6);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c3 <func0+0x3a>
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%r9
mov %rbp,%r8
lea -0x1(%rbx),%eax
lea 0x8(%rbp,%rax,8),%r10
mov $0x0,%r11d
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
jmp 11e3 <func0+0x5a>
mov $0x0,%r11d
mov %r11d,%eax
retq
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%r11,%rcx,1),%r11d
add $0x8,%r8
cmp %r10,%r8
je 1218 <func0+0x8f>
mov (%r8),%rdi
movsbq (%rdi),%rdx
testb $0x1,0x1(%r9,%rdx,2)
je 11da <func0+0x51>
movzbl 0x1(%rdi),%edx
test %dl,%dl
je 11cd <func0+0x44>
lea 0x2(%rdi),%rsi
movsbq %dl,%rdx
testb $0x2,0x1(%r9,%rdx,2)
je 11da <func0+0x51>
add $0x1,%rsi
movzbl -0x1(%rsi),%edx
test %dl,%dl
jne 11fe <func0+0x75>
jmp 11cd <func0+0x44>
mov %r11d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_11DE
mov r13, rdi
mov r12d, esi
call ___ctype_b_loc
mov rbp, [rax]
mov rbx, r13
lea eax, [r12-1]
lea r12, [r13+rax*8+8]
mov r13d, 0
jmp short loc_1203
loc_11DE:
mov r13d, 0
loc_11E4:
mov eax, r13d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11F2:
call _strlen
add r13d, eax
loc_11FA:
add rbx, 8
cmp rbx, r12
jz short loc_11E4
loc_1203:
mov rdi, [rbx]
movsx rax, byte ptr [rdi]
test byte ptr [rbp+rax*2+1], 1
jz short loc_11FA
movzx eax, byte ptr [rdi+1]
test al, al
jz short loc_11F2
lea rdx, [rdi+2]
loc_121D:
movsx rax, al
test byte ptr [rbp+rax*2+1], 2
jz short loc_11FA
add rdx, 1
movzx eax, byte ptr [rdx-1]
test al, al
jnz short loc_121D
jmp short loc_11F2 | long long func0(char **a1, int a2)
{
long long v2; // rbp
char **v3; // rbx
long long v4; // r12
unsigned int v5; // r13d
char *v7; // rdi
char v8; // al
char *v9; // rdx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = *(_QWORD *)__ctype_b_loc();
v3 = a1;
v4 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
v5 = 0;
do
{
v7 = *v3;
if ( (*(_BYTE *)(v2 + 2LL * **v3 + 1) & 1) != 0 )
{
v8 = v7[1];
if ( v8 )
{
v9 = v7 + 2;
while ( (*(_BYTE *)(v2 + 2LL * v8 + 1) & 2) != 0 )
{
v8 = *v9++;
if ( !v8 )
goto LABEL_5;
}
}
else
{
LABEL_5:
v5 += strlen();
}
}
++v3;
}
while ( v3 != (char **)v4 );
}
return v5;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001011de
MOV R13,RDI
MOV R12D,ESI
CALL 0x001010b0
MOV RBP,qword ptr [RAX]
MOV RBX,R13
LEA EAX,[R12 + -0x1]
LEA R12,[R13 + RAX*0x8 + 0x8]
MOV R13D,0x0
JMP 0x00101203
LAB_001011de:
MOV R13D,0x0
LAB_001011e4:
MOV EAX,R13D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011f2:
CALL 0x00101080
ADD R13D,EAX
LAB_001011fa:
ADD RBX,0x8
CMP RBX,R12
JZ 0x001011e4
LAB_00101203:
MOV RDI,qword ptr [RBX]
MOVSX RAX,byte ptr [RDI]
TEST byte ptr [RBP + RAX*0x2 + 0x1],0x1
JZ 0x001011fa
MOVZX EAX,byte ptr [RDI + 0x1]
TEST AL,AL
JZ 0x001011f2
LEA RDX,[RDI + 0x2]
LAB_0010121d:
MOVSX RAX,AL
TEST byte ptr [RBP + RAX*0x2 + 0x1],0x2
JZ 0x001011fa
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX + -0x1]
TEST AL,AL
JNZ 0x0010121d
JMP 0x001011f2 | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
ushort *puVar2;
char *__s;
char cVar3;
ushort **ppuVar4;
size_t sVar5;
char *pcVar6;
int iVar7;
if (param_2 < 1) {
iVar7 = 0;
}
else {
ppuVar4 = __ctype_b_loc();
puVar2 = *ppuVar4;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar7 = 0;
do {
__s = (char *)*param_1;
if ((*(byte *)((long)puVar2 + (long)*__s * 2 + 1) & 1) != 0) {
cVar3 = __s[1];
if (cVar3 != '\0') {
pcVar6 = __s + 2;
do {
if ((*(byte *)((long)puVar2 + (long)cVar3 * 2 + 1) & 2) == 0) goto LAB_001011fa;
cVar3 = *pcVar6;
pcVar6 = pcVar6 + 1;
} while (cVar3 != '\0');
}
sVar5 = strlen(__s);
iVar7 = iVar7 + (int)sVar5;
}
LAB_001011fa:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar7;
} |
6,450 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(char *sample_names[], int length) {
int i, j, valid;
int total_length = 0;
for (i = 0; i < length; i++) {
char *name = sample_names[i];
if (isupper(name[0])) {
valid = 1;
for (j = 1; name[j] != '\0'; j++) {
if (!islower(name[j])) {
valid = 0;
break;
}
}
if (valid)
total_length += strlen(name);
}
}
return total_length;
}
| int main() {
char *names1[] = {"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"};
assert(func0(names1, 6) == 16);
char *names2[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
assert(func0(names2, 6) == 10);
char *names3[] = {"abcd", "Python", "abba", "aba"};
assert(func0(names3, 4) == 6);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 13da <func0+0x8a>
mov %esi,%r12d
mov %rdi,%rbx
xor %r13d,%r13d
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rbp
lea -0x1(%r12),%eax
lea 0x8(%rbx,%rax,8),%r12
jmp 1389 <func0+0x39>
add $0x8,%rbx
cmp %rbx,%r12
je 13cc <func0+0x7c>
mov (%rbx),%rdi
movsbq (%rdi),%rax
testb $0x1,0x1(%rbp,%rax,2)
je 1380 <func0+0x30>
movsbq 0x1(%rdi),%rax
test %al,%al
je 13bb <func0+0x6b>
lea 0x2(%rdi),%rdx
nopl 0x0(%rax)
testb $0x2,0x1(%rbp,%rax,2)
je 1380 <func0+0x30>
movsbq (%rdx),%rax
add $0x1,%rdx
test %al,%al
jne 13a8 <func0+0x58>
callq 1080 <strlen@plt>
add $0x8,%rbx
add %eax,%r13d
cmp %rbx,%r12
jne 1389 <func0+0x39>
add $0x8,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
add $0x8,%rsp
xor %r13d,%r13d
pop %rbx
mov %r13d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_13DA
mov r12d, esi
mov rbx, rdi
xor r13d, r13d
call ___ctype_b_loc
mov rbp, [rax]
lea eax, [r12-1]
lea r12, [rbx+rax*8+8]
jmp short loc_1389
loc_1380:
add rbx, 8
cmp r12, rbx
jz short loc_13CC
loc_1389:
mov rdi, [rbx]
movsx rax, byte ptr [rdi]
test byte ptr [rbp+rax*2+1], 1
jz short loc_1380
movsx rax, byte ptr [rdi+1]
test al, al
jz short loc_13BB
lea rdx, [rdi+2]
nop dword ptr [rax+00h]
loc_13A8:
test byte ptr [rbp+rax*2+1], 2
jz short loc_1380
movsx rax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_13A8
loc_13BB:
call _strlen
add rbx, 8
add r13d, eax
cmp r12, rbx
jnz short loc_1389
loc_13CC:
add rsp, 8
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13DA:
add rsp, 8
xor r13d, r13d
pop rbx
mov eax, r13d
pop rbp
pop r12
pop r13
retn | long long func0(char **a1, long long a2)
{
char **v2; // rbx
unsigned int v3; // r13d
char *v4; // rdx
long long v5; // rbp
long long v6; // r12
char *v7; // rdi
long long v8; // rax
if ( (int)a2 > 0 )
{
v2 = a1;
v3 = 0;
v5 = *(_QWORD *)__ctype_b_loc();
v6 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
while ( 1 )
{
while ( 1 )
{
v7 = *v2;
if ( (*(_BYTE *)(v5 + 2LL * **v2 + 1) & 1) != 0 )
break;
LABEL_3:
if ( (char **)v6 == ++v2 )
return v3;
}
v8 = v7[1];
if ( (_BYTE)v8 )
{
v4 = v7 + 2;
while ( (*(_BYTE *)(v5 + 2 * v8 + 1) & 2) != 0 )
{
v8 = *v4++;
if ( !(_BYTE)v8 )
goto LABEL_9;
}
goto LABEL_3;
}
LABEL_9:
++v2;
v3 += strlen(v7, a2, v4);
if ( (char **)v6 == v2 )
return v3;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001013da
MOV R12D,ESI
MOV RBX,RDI
XOR R13D,R13D
CALL 0x001010b0
MOV RBP,qword ptr [RAX]
LEA EAX,[R12 + -0x1]
LEA R12,[RBX + RAX*0x8 + 0x8]
JMP 0x00101389
LAB_00101380:
ADD RBX,0x8
CMP R12,RBX
JZ 0x001013cc
LAB_00101389:
MOV RDI,qword ptr [RBX]
MOVSX RAX,byte ptr [RDI]
TEST byte ptr [RBP + RAX*0x2 + 0x1],0x1
JZ 0x00101380
MOVSX RAX,byte ptr [RDI + 0x1]
TEST AL,AL
JZ 0x001013bb
LEA RDX,[RDI + 0x2]
NOP dword ptr [RAX]
LAB_001013a8:
TEST byte ptr [RBP + RAX*0x2 + 0x1],0x2
JZ 0x00101380
MOVSX RAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x001013a8
LAB_001013bb:
CALL 0x00101080
ADD RBX,0x8
ADD R13D,EAX
CMP R12,RBX
JNZ 0x00101389
LAB_001013cc:
ADD RSP,0x8
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013da:
ADD RSP,0x8
XOR R13D,R13D
POP RBX
MOV EAX,R13D
POP RBP
POP R12
POP R13
RET | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char cVar2;
ushort *puVar3;
char *__s;
ushort **ppuVar4;
size_t sVar5;
char *pcVar6;
int iVar7;
if (param_2 < 1) {
return 0;
}
iVar7 = 0;
ppuVar4 = __ctype_b_loc();
puVar3 = *ppuVar4;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
while (__s = (char *)*param_1, (*(byte *)((long)puVar3 + (long)*__s * 2 + 1) & 1) == 0) {
LAB_00101380:
param_1 = param_1 + 1;
if (puVar1 == param_1) {
return iVar7;
}
}
cVar2 = __s[1];
if (cVar2 != '\0') {
pcVar6 = __s + 2;
do {
if ((*(byte *)((long)puVar3 + (long)cVar2 * 2 + 1) & 2) == 0) goto LAB_00101380;
cVar2 = *pcVar6;
pcVar6 = pcVar6 + 1;
} while (cVar2 != '\0');
}
sVar5 = strlen(__s);
param_1 = param_1 + 1;
iVar7 = iVar7 + (int)sVar5;
if (puVar1 == param_1) {
return iVar7;
}
} while( true );
} |
6,451 | func0 | #include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(char *sample_names[], int length) {
int i, j, valid;
int total_length = 0;
for (i = 0; i < length; i++) {
char *name = sample_names[i];
if (isupper(name[0])) {
valid = 1;
for (j = 1; name[j] != '\0'; j++) {
if (!islower(name[j])) {
valid = 0;
break;
}
}
if (valid)
total_length += strlen(name);
}
}
return total_length;
}
| int main() {
char *names1[] = {"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"};
assert(func0(names1, 6) == 16);
char *names2[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
assert(func0(names2, 6) == 10);
char *names3[] = {"abcd", "Python", "abba", "aba"};
assert(func0(names3, 4) == 6);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 140a <func0+0x8a>
mov %esi,%r12d
mov %rdi,%rbx
xor %r13d,%r13d
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rbp
lea -0x1(%r12),%eax
lea 0x8(%rbx,%rax,8),%r12
jmp 13b9 <func0+0x39>
add $0x8,%rbx
cmp %rbx,%r12
je 13fc <func0+0x7c>
mov (%rbx),%rdi
movsbq (%rdi),%rax
testb $0x1,0x1(%rbp,%rax,2)
je 13b0 <func0+0x30>
movsbq 0x1(%rdi),%rax
test %al,%al
je 13eb <func0+0x6b>
lea 0x2(%rdi),%rdx
nopl 0x0(%rax)
testb $0x2,0x1(%rbp,%rax,2)
je 13b0 <func0+0x30>
movsbq (%rdx),%rax
add $0x1,%rdx
test %al,%al
jne 13d8 <func0+0x58>
callq 1080 <strlen@plt>
add $0x8,%rbx
add %eax,%r13d
cmp %rbx,%r12
jne 13b9 <func0+0x39>
add $0x8,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
add $0x8,%rsp
xor %r13d,%r13d
pop %rbx
mov %r13d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
push rbx
sub rsp, 8
test r12d, r12d
jle short loc_143A
mov rbx, rdi
xor r13d, r13d
call ___ctype_b_loc
lea r12, [rbx+r12*8]
mov rbp, [rax]
jmp short loc_13E9
loc_13E0:
add rbx, 8
cmp r12, rbx
jz short loc_142C
loc_13E9:
mov rdi, [rbx]; s
movsx rax, byte ptr [rdi]
test byte ptr [rbp+rax*2+1], 1
jz short loc_13E0
movsx rax, byte ptr [rdi+1]
test al, al
jz short loc_141B
lea rdx, [rdi+2]
nop dword ptr [rax+00h]
loc_1408:
test byte ptr [rbp+rax*2+1], 2
jz short loc_13E0
movsx rax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_1408
loc_141B:
call _strlen
add rbx, 8
add r13d, eax
cmp r12, rbx
jnz short loc_13E9
loc_142C:
add rsp, 8
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
retn
loc_143A:
add rsp, 8
xor r13d, r13d
pop rbx
mov eax, r13d
pop rbp
pop r12
pop r13
retn | long long func0(char **a1, int a2)
{
char **v2; // rbx
unsigned int v3; // r13d
char **v4; // r12
const unsigned __int16 *v5; // rbp
char *v6; // rdi
long long v7; // rax
char *v8; // rdx
if ( a2 > 0 )
{
v2 = a1;
v3 = 0;
v4 = &a1[a2];
v5 = *__ctype_b_loc();
while ( 1 )
{
while ( 1 )
{
v6 = *v2;
if ( (v5[**v2] & 0x100) != 0 )
break;
LABEL_3:
if ( v4 == ++v2 )
return v3;
}
v7 = v6[1];
if ( (_BYTE)v7 )
{
v8 = v6 + 2;
while ( (v5[v7] & 0x200) != 0 )
{
v7 = *v8++;
if ( !(_BYTE)v7 )
goto LABEL_9;
}
goto LABEL_3;
}
LABEL_9:
++v2;
v3 += strlen(v6);
if ( v4 == v2 )
return v3;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST R12D,R12D
JLE 0x0010143a
MOV RBX,RDI
XOR R13D,R13D
CALL 0x001010b0
LEA R12,[RBX + R12*0x8]
MOV RBP,qword ptr [RAX]
JMP 0x001013e9
LAB_001013e0:
ADD RBX,0x8
CMP R12,RBX
JZ 0x0010142c
LAB_001013e9:
MOV RDI,qword ptr [RBX]
MOVSX RAX,byte ptr [RDI]
TEST byte ptr [RBP + RAX*0x2 + 0x1],0x1
JZ 0x001013e0
MOVSX RAX,byte ptr [RDI + 0x1]
TEST AL,AL
JZ 0x0010141b
LEA RDX,[RDI + 0x2]
NOP dword ptr [RAX]
LAB_00101408:
TEST byte ptr [RBP + RAX*0x2 + 0x1],0x2
JZ 0x001013e0
MOVSX RAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x00101408
LAB_0010141b:
CALL 0x00101080
ADD RBX,0x8
ADD R13D,EAX
CMP R12,RBX
JNZ 0x001013e9
LAB_0010142c:
ADD RSP,0x8
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010143a:
ADD RSP,0x8
XOR R13D,R13D
POP RBX
MOV EAX,R13D
POP RBP
POP R12
POP R13
RET | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char cVar2;
ushort *puVar3;
char *__s;
ushort **ppuVar4;
size_t sVar5;
char *pcVar6;
int iVar7;
if (param_2 < 1) {
return 0;
}
iVar7 = 0;
ppuVar4 = __ctype_b_loc();
puVar1 = param_1 + param_2;
puVar3 = *ppuVar4;
do {
while (__s = (char *)*param_1, (*(byte *)((long)puVar3 + (long)*__s * 2 + 1) & 1) == 0) {
LAB_001013e0:
param_1 = param_1 + 1;
if (puVar1 == param_1) {
return iVar7;
}
}
cVar2 = __s[1];
if (cVar2 != '\0') {
pcVar6 = __s + 2;
do {
if ((*(byte *)((long)puVar3 + (long)cVar2 * 2 + 1) & 2) == 0) goto LAB_001013e0;
cVar2 = *pcVar6;
pcVar6 = pcVar6 + 1;
} while (cVar2 != '\0');
}
sVar5 = strlen(__s);
param_1 = param_1 + 1;
iVar7 = iVar7 + (int)sVar5;
if (puVar1 == param_1) {
return iVar7;
}
} while( true );
} |
6,452 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char* item) {
regex_t regex;
regmatch_t matches[2];
char *result = (char*)malloc(strlen(item) + 1);
strcpy(result, item);
if (regcomp(®ex, " ?\\([^)]+\\)", REG_EXTENDED) == 0) {
while (regexec(®ex, result, 2, matches, 0) == 0) {
int start = matches[0].rm_so;
int end = matches[0].rm_eo;
memmove(&result[start], &result[end], strlen(result) - end + 1);
}
regfree(®ex);
}
return result;
}
| int main() {
char result[256];
strcpy(result, func0("python (chrome)"));
assert(strcmp(result, "python") == 0);
strcpy(result, func0("string(.abc)"));
assert(strcmp(result, "string") == 0);
strcpy(result, func0("alpha(num)"));
assert(strcmp(result, "alpha") == 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
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 1100 <strlen@plt>
add $0x1,%rax
mov %rax,%rdi
callq 1150 <malloc@plt>
mov %rax,-0x68(%rbp)
mov -0x78(%rbp),%rdx
mov -0x68(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10e0 <strcpy@plt>
lea -0x60(%rbp),%rax
mov $0x1,%edx
lea 0xd41(%rip),%rsi
mov %rax,%rdi
callq 1130 <regcomp@plt>
test %eax,%eax
jne 1351 <func0+0xe8>
jmp 131f <func0+0xb6>
mov -0x20(%rbp),%eax
mov %eax,-0x70(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x6c(%rbp)
mov -0x68(%rbp),%rax
mov %rax,%rdi
callq 1100 <strlen@plt>
mov -0x6c(%rbp),%edx
movslq %edx,%rdx
sub %rdx,%rax
lea 0x1(%rax),%rdx
mov -0x6c(%rbp),%eax
movslq %eax,%rcx
mov -0x68(%rbp),%rax
add %rax,%rcx
mov -0x70(%rbp),%eax
movslq %eax,%rsi
mov -0x68(%rbp),%rax
add %rsi,%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1170 <memmove@plt>
lea -0x20(%rbp),%rdx
mov -0x68(%rbp),%rsi
lea -0x60(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x2,%edx
mov %rax,%rdi
callq 1160 <regexec@plt>
test %eax,%eax
je 12d5 <func0+0x6c>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 10f0 <regfree@plt>
mov -0x68(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1369 <func0+0x100>
callq 1110 <__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 rax, [rbp+s]
mov rdi, rax; s
call _strlen
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
mov rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
lea rax, [rbp+preg]
mov edx, 1; cflags
lea rcx, pattern; " ?\\([^)]+\\)"
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
test eax, eax
jnz loc_135A
jmp short loc_1328
loc_12DC:
mov eax, [rbp+pmatch.rm_so]
mov [rbp+var_70], eax
mov eax, [rbp+pmatch.rm_eo]
mov [rbp+var_6C], eax
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov eax, [rbp+var_6C]
cdqe
sub rdx, rax
add rdx, 1; n
mov eax, [rbp+var_6C]
movsxd rcx, eax
mov rax, [rbp+dest]
add rcx, rax
mov eax, [rbp+var_70]
movsxd rsi, eax
mov rax, [rbp+dest]
add rax, rsi
mov rsi, rcx; src
mov rdi, rax; dest
call _memmove
loc_1328:
lea rdx, [rbp+pmatch]
mov rsi, [rbp+dest]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 2; nmatch
mov rdi, rax; preg
call _regexec
test eax, eax
jz short loc_12DC
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
loc_135A:
mov rax, [rbp+dest]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1372
call ___stack_chk_fail
locret_1372:
leave
retn | char * func0(const char *a1)
{
size_t v1; // rax
size_t v2; // rax
regmatch_t v4; // [rsp+10h] [rbp-70h]
char *dest; // [rsp+18h] [rbp-68h]
regex_t preg; // [rsp+20h] [rbp-60h] BYREF
regmatch_t pmatch; // [rsp+60h] [rbp-20h] BYREF
unsigned long long v8; // [rsp+78h] [rbp-8h]
v8 = __readfsqword(0x28u);
v1 = strlen(a1);
dest = (char *)malloc(v1 + 1);
strcpy(dest, a1);
if ( !regcomp(&preg, " ?\\([^)]+\\)", 1) )
{
while ( !regexec(&preg, dest, 2uLL, &pmatch, 0) )
{
v4 = pmatch;
v2 = strlen(dest);
memmove(&dest[v4.rm_so], &dest[v4.rm_eo], v2 - v4.rm_eo + 1);
}
regfree(&preg);
}
return dest;
} | 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 RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x00101100
ADD RAX,0x1
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBP + -0x68],RAX
MOV RDX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010e0
LEA RAX,[RBP + -0x60]
MOV EDX,0x1
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101130
TEST EAX,EAX
JNZ 0x0010135a
JMP 0x00101328
LAB_001012dc:
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x70],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x6c],EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x00101100
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x6c]
CDQE
SUB RDX,RAX
ADD RDX,0x1
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RCX,RAX
MOV EAX,dword ptr [RBP + -0x70]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RSI
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101170
LAB_00101328:
LEA RDX,[RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x60]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x2
MOV RDI,RAX
CALL 0x00101160
TEST EAX,EAX
JZ 0x001012dc
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x001010f0
LAB_0010135a:
MOV RAX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101372
CALL 0x00101110
LAB_00101372:
LEAVE
RET | char * func0(char *param_1)
{
regoff_t rVar1;
regoff_t rVar2;
int iVar3;
size_t sVar4;
char *__dest;
long in_FS_OFFSET;
regex_t local_68;
regmatch_t local_28 [3];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar4 = strlen(param_1);
__dest = (char *)malloc(sVar4 + 1);
strcpy(__dest,param_1);
iVar3 = regcomp(&local_68," ?\\([^)]+\\)",1);
if (iVar3 == 0) {
while (iVar3 = regexec(&local_68,__dest,2,local_28,0), rVar2 = local_28[0].rm_eo,
rVar1 = local_28[0].rm_so, iVar3 == 0) {
sVar4 = strlen(__dest);
memmove(__dest + rVar1,__dest + rVar2,(sVar4 - (long)rVar2) + 1);
}
regfree(&local_68);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,453 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char* item) {
regex_t regex;
regmatch_t matches[2];
char *result = (char*)malloc(strlen(item) + 1);
strcpy(result, item);
if (regcomp(®ex, " ?\\([^)]+\\)", REG_EXTENDED) == 0) {
while (regexec(®ex, result, 2, matches, 0) == 0) {
int start = matches[0].rm_so;
int end = matches[0].rm_eo;
memmove(&result[start], &result[end], strlen(result) - end + 1);
}
regfree(®ex);
}
return result;
}
| int main() {
char result[256];
strcpy(result, func0("python (chrome)"));
assert(strcmp(result, "python") == 0);
strcpy(result, func0("string(.abc)"));
assert(strcmp(result, "string") == 0);
strcpy(result, func0("alpha(num)"));
assert(strcmp(result, "alpha") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
callq 1120 <malloc@plt>
mov %rax,%rbx
mov %rbp,%rsi
mov %rax,%rdi
callq 10d0 <strcpy@plt>
mov %rsp,%rdi
mov $0x1,%edx
lea 0xd6d(%rip),%rsi
callq 1110 <regcomp@plt>
lea 0x40(%rsp),%rbp
test %eax,%eax
jne 12fb <func0+0xb2>
mov %rsp,%rdi
mov $0x0,%r8d
mov %rbp,%rcx
mov $0x2,%edx
mov %rbx,%rsi
callq 1130 <regexec@plt>
test %eax,%eax
jne 12f3 <func0+0xaa>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
movslq 0x44(%rsp),%rsi
mov %rcx,%rdx
sub %rsi,%rdx
add %rbx,%rsi
movslq 0x40(%rsp),%rdi
add %rbx,%rdi
callq 1150 <memmove@plt>
jmp 12a5 <func0+0x5c>
mov %rsp,%rdi
callq 10e0 <regfree@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1315 <func0+0xcc>
mov %rbx,%rax
add $0x68,%rsp
pop %rbx
pop %rbp
retq
callq 10f0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 68h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+78h+var_20], rax
xor eax, eax
call _strlen
lea rdi, [rax+1]
call _malloc
mov rbx, rax
mov rsi, rbp
mov rdi, rax
call _strcpy
mov rdi, rsp
mov edx, 1
lea rsi, asc_2004; " ?\\([^)]+\\)"
call _regcomp
lea rbp, [rsp+78h+var_38]
test eax, eax
jz short loc_131D
loc_12DF:
mov rax, [rsp+78h+var_20]
sub rax, fs:28h
jnz short loc_1344
mov rax, rbx
add rsp, 68h
pop rbx
pop rbp
retn
loc_12F9:
mov rdi, rbx
call _strlen
movsxd rsi, [rsp+78h+var_34]
sub rax, rsi
lea rdx, [rax+1]
add rsi, rbx
movsxd rdi, dword ptr [rsp+78h+var_38]
add rdi, rbx
call _memmove
loc_131D:
mov rdi, rsp
mov r8d, 0
mov rcx, rbp
mov edx, 2
mov rsi, rbx
call _regexec
test eax, eax
jz short loc_12F9
mov rdi, rsp
call _regfree
jmp short loc_12DF
loc_1344:
call ___stack_chk_fail | long long func0(long long a1)
{
long long v1; // rax
long long v2; // rbx
long long v4; // rax
_BYTE v5[64]; // [rsp+0h] [rbp-78h] BYREF
int v6; // [rsp+40h] [rbp-38h] BYREF
int v7; // [rsp+44h] [rbp-34h]
unsigned long long v8; // [rsp+58h] [rbp-20h]
v8 = __readfsqword(0x28u);
v1 = ((long long (*)(void))strlen)();
v2 = malloc(v1 + 1);
strcpy(v2, a1);
if ( !(unsigned int)regcomp(v5, " ?\\([^)]+\\)", 1LL) )
{
while ( !(unsigned int)regexec(v5, v2, 2LL, &v6, 0LL) )
{
v4 = strlen(v2);
memmove(v2 + v6, v2 + v7, v4 - v7 + 1);
}
regfree(v5);
}
return v2;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101110
LEA RDI,[RAX + 0x1]
CALL 0x00101160
MOV RBX,RAX
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010f0
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
CALL 0x00101140
LEA RBP,[RSP + 0x40]
TEST EAX,EAX
JZ 0x0010131d
LAB_001012df:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101344
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP RBP
RET
LAB_001012f9:
MOV RDI,RBX
CALL 0x00101110
MOVSXD RSI,dword ptr [RSP + 0x44]
SUB RAX,RSI
LEA RDX,[RAX + 0x1]
ADD RSI,RBX
MOVSXD RDI,dword ptr [RSP + 0x40]
ADD RDI,RBX
CALL 0x00101190
LAB_0010131d:
MOV RDI,RSP
MOV R8D,0x0
MOV RCX,RBP
MOV EDX,0x2
MOV RSI,RBX
CALL 0x00101170
TEST EAX,EAX
JZ 0x001012f9
MOV RDI,RSP
CALL 0x00101100
JMP 0x001012df
LAB_00101344:
CALL 0x00101120 | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *__dest;
long in_FS_OFFSET;
regex_t rStack_78;
regmatch_t local_38 [3];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
__dest = (char *)malloc(sVar2 + 1);
strcpy(__dest,param_1);
iVar1 = regcomp(&rStack_78," ?\\([^)]+\\)",1);
if (iVar1 == 0) {
while( true ) {
iVar1 = regexec(&rStack_78,__dest,2,local_38,0);
if (iVar1 != 0) break;
sVar2 = strlen(__dest);
memmove(__dest + local_38[0].rm_so,__dest + local_38[0].rm_eo,
(sVar2 - (long)local_38[0].rm_eo) + 1);
}
regfree(&rStack_78);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,454 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char* item) {
regex_t regex;
regmatch_t matches[2];
char *result = (char*)malloc(strlen(item) + 1);
strcpy(result, item);
if (regcomp(®ex, " ?\\([^)]+\\)", REG_EXTENDED) == 0) {
while (regexec(®ex, result, 2, matches, 0) == 0) {
int start = matches[0].rm_so;
int end = matches[0].rm_eo;
memmove(&result[start], &result[end], strlen(result) - end + 1);
}
regfree(®ex);
}
return result;
}
| int main() {
char result[256];
strcpy(result, func0("python (chrome)"));
assert(strcmp(result, "python") == 0);
strcpy(result, func0("string(.abc)"));
assert(strcmp(result, "string") == 0);
strcpy(result, func0("alpha(num)"));
assert(strcmp(result, "alpha") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
lea 0x1(%rax),%r13
mov %r13,%rdi
callq 1140 <malloc@plt>
mov %rbp,%rsi
mov %r13,%rdx
mov %rsp,%rbp
mov %rax,%rdi
mov %rax,%r12
callq 1130 <memcpy@plt>
mov $0x1,%edx
lea 0xbf2(%rip),%rsi
mov %rbp,%rdi
callq 1120 <regcomp@plt>
test %eax,%eax
jne 14ab <func0+0xeb>
lea 0x40(%rsp),%r13
mov $0x1,%ebx
jmp 1489 <func0+0xc9>
xchg %ax,%ax
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 1433 <func0+0x73>
mov %eax,%ecx
movslq 0x40(%rsp),%rdi
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
movslq 0x44(%rsp),%rsi
mov %rbx,%rax
sbb $0x3,%rdx
add %r12,%rdi
sub %rsi,%rax
sub %r12,%rdx
add %r12,%rsi
add %rax,%rdx
callq 1170 <memmove@plt>
xor %r8d,%r8d
mov %r13,%rcx
mov $0x2,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 1150 <regexec@plt>
test %eax,%eax
je 1430 <func0+0x70>
mov %rbp,%rdi
callq 10e0 <regfree@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 14c9 <func0+0x109>
add $0x68,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1100 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
call _strlen
lea r13, [rax+1]
mov rdi, r13
call _malloc
mov rsi, rbp
mov rdx, r13
mov rbp, rsp
mov rdi, rax
mov r12, rax
call _memcpy
mov edx, 1
lea rsi, asc_2004; " ?\\([^)]+\\)"
mov rdi, rbp
call _regcomp
test eax, eax
jnz short loc_1488
lea rbx, [rsp+88h+var_48]
mov r13d, 1
jmp short loc_1466
loc_1440:
mov rdi, r12
call _strlen
movsxd rsi, [rsp+88h+var_44]
movsxd rdi, [rsp+88h+var_48]
mov rdx, r13
sub rdx, rsi
add rdi, r12
add rsi, r12
add rdx, rax
call _memmove
loc_1466:
xor r8d, r8d
mov rcx, rbx
mov edx, 2
mov rsi, r12
mov rdi, rbp
call _regexec
test eax, eax
jz short loc_1440
mov rdi, rbp
call _regfree
loc_1488:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_14A6
add rsp, 68h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_14A6:
call ___stack_chk_fail | long long func0(long long a1)
{
long long v1; // r13
long long v2; // r12
long long v3; // rax
_BYTE v5[64]; // [rsp+0h] [rbp-88h] BYREF
int v6; // [rsp+40h] [rbp-48h] BYREF
int v7; // [rsp+44h] [rbp-44h]
unsigned long long v8; // [rsp+58h] [rbp-30h]
v8 = __readfsqword(0x28u);
v1 = ((long long (*)(void))strlen)() + 1;
v2 = malloc(v1);
memcpy(v2, a1, v1);
if ( !(unsigned int)regcomp(v5, " ?\\([^)]+\\)", 1LL) )
{
while ( !(unsigned int)regexec(v5, v2, 2LL, &v6, 0LL) )
{
v3 = strlen(v2);
memmove(v2 + v6, v2 + v7, v3 + 1LL - v7);
}
regfree(v5);
}
return v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101100
LEA R13,[RAX + 0x1]
MOV RDI,R13
CALL 0x00101160
MOV RSI,RBP
MOV RDX,R13
MOV RBP,RSP
MOV RDI,RAX
MOV R12,RAX
CALL 0x00101150
MOV EDX,0x1
LEA RSI,[0x102004]
MOV RDI,RBP
CALL 0x00101130
TEST EAX,EAX
JNZ 0x00101488
LEA RBX,[RSP + 0x40]
MOV R13D,0x1
JMP 0x00101466
LAB_00101440:
MOV RDI,R12
CALL 0x00101100
MOVSXD RSI,dword ptr [RSP + 0x44]
MOVSXD RDI,dword ptr [RSP + 0x40]
MOV RDX,R13
SUB RDX,RSI
ADD RDI,R12
ADD RSI,R12
ADD RDX,RAX
CALL 0x00101190
LAB_00101466:
XOR R8D,R8D
MOV RCX,RBX
MOV EDX,0x2
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101170
TEST EAX,EAX
JZ 0x00101440
MOV RDI,RBP
CALL 0x001010f0
LAB_00101488:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014a6
ADD RSP,0x68
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001014a6:
CALL 0x00101110 | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *__string;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_48 [3];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
__string = (char *)malloc(sVar2 + 1);
memcpy(__string,param_1,sVar2 + 1);
iVar1 = regcomp(&rStack_88," ?\\([^)]+\\)",1);
if (iVar1 == 0) {
while( true ) {
iVar1 = regexec(&rStack_88,__string,2,local_48,0);
if (iVar1 != 0) break;
sVar2 = strlen(__string);
memmove(__string + local_48[0].rm_so,__string + local_48[0].rm_eo,
(1 - (long)local_48[0].rm_eo) + sVar2);
}
regfree(&rStack_88);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return __string;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,455 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char* item) {
regex_t regex;
regmatch_t matches[2];
char *result = (char*)malloc(strlen(item) + 1);
strcpy(result, item);
if (regcomp(®ex, " ?\\([^)]+\\)", REG_EXTENDED) == 0) {
while (regexec(®ex, result, 2, matches, 0) == 0) {
int start = matches[0].rm_so;
int end = matches[0].rm_eo;
memmove(&result[start], &result[end], strlen(result) - end + 1);
}
regfree(®ex);
}
return result;
}
| int main() {
char result[256];
strcpy(result, func0("python (chrome)"));
assert(strcmp(result, "python") == 0);
strcpy(result, func0("string(.abc)"));
assert(strcmp(result, "string") == 0);
strcpy(result, func0("alpha(num)"));
assert(strcmp(result, "alpha") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
lea 0x1(%rax),%r13
mov %r13,%rdi
callq 1140 <malloc@plt>
mov %rbp,%rsi
mov %r13,%rdx
mov %rsp,%rbp
mov %rax,%rdi
mov %rax,%r12
callq 1130 <memcpy@plt>
mov $0x1,%edx
lea 0xbf2(%rip),%rsi
mov %rbp,%rdi
callq 1120 <regcomp@plt>
test %eax,%eax
jne 14ab <func0+0xeb>
lea 0x40(%rsp),%r13
mov $0x1,%ebx
jmp 1489 <func0+0xc9>
xchg %ax,%ax
mov %r12,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 1433 <func0+0x73>
mov %eax,%ecx
movslq 0x40(%rsp),%rdi
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%esi
add %al,%sil
movslq 0x44(%rsp),%rsi
mov %rbx,%rax
sbb $0x3,%rdx
add %r12,%rdi
sub %rsi,%rax
sub %r12,%rdx
add %r12,%rsi
add %rax,%rdx
callq 1170 <memmove@plt>
xor %r8d,%r8d
mov %r13,%rcx
mov $0x2,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 1150 <regexec@plt>
test %eax,%eax
je 1430 <func0+0x70>
mov %rbp,%rdi
callq 10e0 <regfree@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 14c9 <func0+0x109>
add $0x68,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1100 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 60h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
call _strlen
lea rbp, [rax+1]
mov rdi, rbp; size
call _malloc
mov rsi, r12
mov rdx, rbp
mov rcx, rbp
mov rdi, rax
mov r12, rsp
mov rbx, rax
call ___memcpy_chk
mov edx, 1; cflags
lea rsi, pattern; " ?\\([^)]+\\)"
mov rdi, r12; preg
call _regcomp
test eax, eax
jnz short loc_1495
lea r13, [rsp+88h+pmatch]
mov r14d, 1
jmp short loc_1473
loc_1440:
mov rdi, rbx; s
call _strlen
movsxd rdi, [rsp+88h+pmatch.rm_so]
movsxd rsi, [rsp+88h+pmatch.rm_eo]
mov rdx, r14
cmp rbp, rdi
mov rcx, rdi
cmovnb rcx, rbp
sub rdx, rsi
add rsi, rbx
add rdx, rax
sub rcx, rdi
add rdi, rbx
call ___memmove_chk
loc_1473:
xor r8d, r8d; eflags
mov rcx, r13; pmatch
mov edx, 2; nmatch
mov rsi, rbx; string
mov rdi, r12; preg
call _regexec
test eax, eax
jz short loc_1440
mov rdi, r12; preg
call _regfree
loc_1495:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_14B5
add rsp, 60h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_14B5:
call ___stack_chk_fail | const char * func0(const char *a1)
{
size_t v1; // rbp
const char *v2; // rbx
size_t v3; // rax
size_t rm_so; // rcx
regex_t v6; // [rsp+0h] [rbp-88h] BYREF
regmatch_t pmatch; // [rsp+40h] [rbp-48h] BYREF
unsigned long long v8; // [rsp+58h] [rbp-30h]
v8 = __readfsqword(0x28u);
v1 = strlen(a1) + 1;
v2 = (const char *)malloc(v1);
__memcpy_chk(v2, a1, v1, v1);
if ( !regcomp(&v6, " ?\\([^)]+\\)", 1) )
{
while ( !regexec(&v6, v2, 2uLL, &pmatch, 0) )
{
v3 = strlen(v2);
rm_so = pmatch.rm_so;
if ( v1 >= pmatch.rm_so )
rm_so = v1;
__memmove_chk(&v2[pmatch.rm_so], &v2[pmatch.rm_eo], v3 + 1LL - pmatch.rm_eo, rm_so - pmatch.rm_so);
}
regfree(&v6);
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101100
LEA RBP,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101170
MOV RSI,R12
MOV RDX,RBP
MOV RCX,RBP
MOV RDI,RAX
MOV R12,RSP
MOV RBX,RAX
CALL 0x00101160
MOV EDX,0x1
LEA RSI,[0x102004]
MOV RDI,R12
CALL 0x00101130
TEST EAX,EAX
JNZ 0x00101495
LEA R13,[RSP + 0x40]
MOV R14D,0x1
JMP 0x00101473
LAB_00101440:
MOV RDI,RBX
CALL 0x00101100
MOVSXD RDI,dword ptr [RSP + 0x40]
MOVSXD RSI,dword ptr [RSP + 0x44]
MOV RDX,R14
CMP RBP,RDI
MOV RCX,RDI
CMOVNC RCX,RBP
SUB RDX,RSI
ADD RSI,RBX
ADD RDX,RAX
SUB RCX,RDI
ADD RDI,RBX
CALL 0x00101150
LAB_00101473:
XOR R8D,R8D
MOV RCX,R13
MOV EDX,0x2
MOV RSI,RBX
MOV RDI,R12
CALL 0x00101180
TEST EAX,EAX
JZ 0x00101440
MOV RDI,R12
CALL 0x001010f0
LAB_00101495:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014b5
ADD RSP,0x60
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001014b5:
CALL 0x00101110 | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *__string;
size_t sVar3;
ulong uVar4;
ulong uVar5;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_48 [3];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
sVar2 = sVar2 + 1;
__string = (char *)malloc(sVar2);
__memcpy_chk(__string,param_1,sVar2,sVar2);
iVar1 = regcomp(&rStack_88," ?\\([^)]+\\)",1);
if (iVar1 == 0) {
while( true ) {
iVar1 = regexec(&rStack_88,__string,2,local_48,0);
if (iVar1 != 0) break;
sVar3 = strlen(__string);
uVar5 = (ulong)local_48[0].rm_so;
uVar4 = uVar5;
if (uVar5 <= sVar2) {
uVar4 = sVar2;
}
__memmove_chk(__string + uVar5,__string + local_48[0].rm_eo,
(1 - (long)local_48[0].rm_eo) + sVar3,uVar4 - uVar5);
}
regfree(&rStack_88);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return __string;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,456 | func0 | #include <assert.h>
| int func0(int n) {
return (int)(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%edx
mov %edx,%eax
shl $0x3,%eax
sub %edx,%eax
sub $0x5,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov edx, [rbp+var_4]
mov eax, edx
shl eax, 3
sub eax, edx
sub eax, 5
imul eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SHL EAX,0x3
SUB EAX,EDX
SUB EAX,0x5
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
POP RBP
RET | int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
6,457 | func0 | #include <assert.h>
| int func0(int n) {
return (int)(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
lea 0x0(,%rdi,8),%edi
mov %edi,%edx
sub %eax,%edx
lea -0x5(%rdx),%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
| func0:
endbr64
mov eax, edi
lea edi, ds:0[rdi*8]
sub edi, eax
sub edi, 5
imul edi, eax
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDI,[RDI*0x8]
SUB EDI,EAX
SUB EDI,0x5
IMUL EDI,EAX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
RET | int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
6,458 | func0 | #include <assert.h>
| int func0(int n) {
return (int)(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
lea 0x0(,%rdi,8),%edi
mov %edi,%edx
sub %eax,%edx
lea -0x5(%rdx),%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
lea edi, ds:0[rdi*8]
sub edi, eax
sub edi, 5
imul edi, eax
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDI,[RDI*0x8]
SUB EDI,EAX
SUB EDI,0x5
IMUL EDI,EAX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
RET | int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
6,459 | func0 | #include <assert.h>
| int func0(int n) {
return (int)(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
lea 0x0(,%rdi,8),%edi
mov %edi,%edx
sub %eax,%edx
lea -0x5(%rdx),%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
lea edi, ds:0[rdi*8]
sub edi, eax
sub edi, 5
imul edi, eax
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDI,[RDI*0x8]
SUB EDI,EAX
SUB EDI,0x5
IMUL EDI,EAX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
RET | int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
6,460 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef struct {
int first;
int second;
} Pair;
typedef Pair* Sublist;
int compare_pairs(const void *a, const void *b) {
Pair pa = *(Pair*)a;
Pair pb = *(Pair*)b;
if (pa.first != pb.first) return (pa.first - pb.first);
return (pa.second - pb.second);
}
Sublist sorted_sublist(Sublist sub, int len) {
qsort(sub, len, sizeof(Pair), compare_pairs);
return sub;
}
int sublist_length(Sublist sub) {
int len = 0;
while (sub[len].first != 0 && sub[len].second != 0) len++;
return len;
}
bool are_sublists_equal(Sublist a, Sublist b) {
int len_a = sublist_length(a);
int len_b = sublist_length(b);
if (len_a != len_b) return false;
qsort(a, len_a, sizeof(Pair), compare_pairs);
qsort(b, len_b, sizeof(Pair), compare_pairs);
for (int i = 0; i < len_a; i++) {
if (a[i].first != b[i].first || a[i].second != b[i].second) {
return false;
}
}
return true;
}
| void func0(Sublist *test_list, int num_lists, Sublist *result, int *result_size) {
int added = 0;
for (int i = 0; i < num_lists; i++) {
Sublist current = sorted_sublist(test_list[i], sublist_length(test_list[i]));
bool found = false;
for (int j = 0; j < added; j++) {
if (are_sublists_equal(result[j], current)) {
found = true;
break;
}
}
if (!found) {
result[added++] = current;
}
}
*result_size = added;
}
| int main() {
Pair list1[] = {{4, 5}, {3, 2}, {0, 0}};
Pair list2[] = {{2, 2}, {4, 6}, {0, 0}};
Pair list3[] = {{3, 2}, {4, 5}, {0, 0}};
Sublist test_list1[] = {list1, list2, list3};
Sublist result1[3];
int result1_size = 0;
func0(test_list1, 3, result1, &result1_size);
assert(result1_size == 2);
Pair list4[] = {{5, 6}, {4, 3}, {0, 0}};
Pair list5[] = {{3, 3}, {5, 7}, {0, 0}};
Pair list6[] = {{4, 3}, {5, 6}, {0, 0}};
Sublist test_list2[] = {list4, list5, list6};
Sublist result2[3];
int result2_size = 0;
func0(test_list2, 3, result2, &result2_size);
assert(result2_size == 2);
Pair list7[] = {{6, 7}, {5, 4}, {0, 0}};
Pair list8[] = {{4, 4}, {6, 8}, {0, 0}};
Pair list9[] = {{5, 4}, {6, 7}, {0, 0}};
Sublist test_list3[] = {list7, list8, list9};
Sublist result3[3];
int result3_size = 0;
func0(test_list3, 3, result3, &result3_size);
assert(result3_size == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %rcx,-0x40(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 144d <func0+0xed>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1208 <sublist_length>
mov %eax,%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %edx,%esi
mov %rax,%rdi
callq 11d1 <sorted_sublist>
mov %rax,-0x8(%rbp)
movb $0x0,-0x15(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1415 <func0+0xb5>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x8(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 125b <are_sublists_equal>
test %al,%al
je 1411 <func0+0xb1>
movb $0x1,-0x15(%rbp)
jmp 141d <func0+0xbd>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 13e1 <func0+0x81>
movzbl -0x15(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 1449 <func0+0xe9>
mov -0x14(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x14(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%rax
mov %rax,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 138e <func0+0x2e>
mov -0x40(%rbp),%rax
mov -0x14(%rbp),%edx
mov %edx,(%rax)
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp loc_1452
loc_1393:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdi, rax
call sublist_length
mov edx, eax
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov rax, [rax]
mov esi, edx
mov rdi, rax
call sorted_sublist
mov [rbp+var_8], rax
mov [rbp+var_15], 0
mov [rbp+var_C], 0
jmp short loc_141A
loc_13E6:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+var_8]
mov rsi, rdx
mov rdi, rax
call are_sublists_equal
test al, al
jz short loc_1416
mov [rbp+var_15], 1
jmp short loc_1422
loc_1416:
add [rbp+var_C], 1
loc_141A:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jl short loc_13E6
loc_1422:
movzx eax, [rbp+var_15]
xor eax, 1
test al, al
jz short loc_144E
mov eax, [rbp+var_14]
lea edx, [rax+1]
mov [rbp+var_14], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rdx, rax
mov rax, [rbp+var_8]
mov [rdx], rax
loc_144E:
add [rbp+var_10], 1
loc_1452:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl loc_1393
mov rax, [rbp+var_40]
mov edx, [rbp+var_14]
mov [rax], edx
nop
leave
retn | _DWORD * func0(long long a1, int a2, long long a3, _DWORD *a4)
{
unsigned int v4; // eax
int v5; // eax
_DWORD *result; // rax
char v9; // [rsp+2Bh] [rbp-15h]
int v10; // [rsp+2Ch] [rbp-14h]
int i; // [rsp+30h] [rbp-10h]
int j; // [rsp+34h] [rbp-Ch]
long long v13; // [rsp+38h] [rbp-8h]
v10 = 0;
for ( i = 0; i < a2; ++i )
{
v4 = sublist_length(*(_QWORD *)(8LL * i + a1));
v13 = sorted_sublist(*(_QWORD *)(8LL * i + a1), v4);
v9 = 0;
for ( j = 0; j < v10; ++j )
{
if ( (unsigned __int8)are_sublists_equal(*(_QWORD *)(8LL * j + a3), v13) )
{
v9 = 1;
break;
}
}
if ( v9 != 1 )
{
v5 = v10++;
*(_QWORD *)(a3 + 8LL * v5) = v13;
}
}
result = a4;
*a4 = v10;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101452
LAB_00101393:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101207
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x001011cd
MOV qword ptr [RBP + -0x8],RAX
MOV byte ptr [RBP + -0x15],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010141a
LAB_001013e6:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010125a
TEST AL,AL
JZ 0x00101416
MOV byte ptr [RBP + -0x15],0x1
JMP 0x00101422
LAB_00101416:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010141a:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x001013e6
LAB_00101422:
MOVZX EAX,byte ptr [RBP + -0x15]
XOR EAX,0x1
TEST AL,AL
JZ 0x0010144e
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x14],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RDX],RAX
LAB_0010144e:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101452:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101393
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX],EDX
NOP
LEAVE
RET | void func0(long param_1,int param_2,long param_3,int *param_4)
{
bool bVar1;
char cVar2;
int4 uVar3;
int8 uVar4;
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
local_18 = 0;
do {
if (param_2 <= local_18) {
*param_4 = local_1c;
return;
}
uVar3 = sublist_length(*(int8 *)(param_1 + (long)local_18 * 8));
uVar4 = sorted_sublist(*(int8 *)(param_1 + (long)local_18 * 8),uVar3);
bVar1 = false;
for (local_14 = 0; local_14 < local_1c; local_14 = local_14 + 1) {
cVar2 = are_sublists_equal(*(int8 *)(param_3 + (long)local_14 * 8),uVar4);
if (cVar2 != '\0') {
bVar1 = true;
break;
}
}
if (!bVar1) {
*(int8 *)((long)local_1c * 8 + param_3) = uVar4;
local_1c = local_1c + 1;
}
local_18 = local_18 + 1;
} while( true );
} |
6,461 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef struct {
int first;
int second;
} Pair;
typedef Pair* Sublist;
int compare_pairs(const void *a, const void *b) {
Pair pa = *(Pair*)a;
Pair pb = *(Pair*)b;
if (pa.first != pb.first) return (pa.first - pb.first);
return (pa.second - pb.second);
}
Sublist sorted_sublist(Sublist sub, int len) {
qsort(sub, len, sizeof(Pair), compare_pairs);
return sub;
}
int sublist_length(Sublist sub) {
int len = 0;
while (sub[len].first != 0 && sub[len].second != 0) len++;
return len;
}
bool are_sublists_equal(Sublist a, Sublist b) {
int len_a = sublist_length(a);
int len_b = sublist_length(b);
if (len_a != len_b) return false;
qsort(a, len_a, sizeof(Pair), compare_pairs);
qsort(b, len_b, sizeof(Pair), compare_pairs);
for (int i = 0; i < len_a; i++) {
if (a[i].first != b[i].first || a[i].second != b[i].second) {
return false;
}
}
return true;
}
| void func0(Sublist *test_list, int num_lists, Sublist *result, int *result_size) {
int added = 0;
for (int i = 0; i < num_lists; i++) {
Sublist current = sorted_sublist(test_list[i], sublist_length(test_list[i]));
bool found = false;
for (int j = 0; j < added; j++) {
if (are_sublists_equal(result[j], current)) {
found = true;
break;
}
}
if (!found) {
result[added++] = current;
}
}
*result_size = added;
}
| int main() {
Pair list1[] = {{4, 5}, {3, 2}, {0, 0}};
Pair list2[] = {{2, 2}, {4, 6}, {0, 0}};
Pair list3[] = {{3, 2}, {4, 5}, {0, 0}};
Sublist test_list1[] = {list1, list2, list3};
Sublist result1[3];
int result1_size = 0;
func0(test_list1, 3, result1, &result1_size);
assert(result1_size == 2);
Pair list4[] = {{5, 6}, {4, 3}, {0, 0}};
Pair list5[] = {{3, 3}, {5, 7}, {0, 0}};
Pair list6[] = {{4, 3}, {5, 6}, {0, 0}};
Sublist test_list2[] = {list4, list5, list6};
Sublist result2[3];
int result2_size = 0;
func0(test_list2, 3, result2, &result2_size);
assert(result2_size == 2);
Pair list7[] = {{6, 7}, {5, 4}, {0, 0}};
Pair list8[] = {{4, 4}, {6, 8}, {0, 0}};
Pair list9[] = {{5, 4}, {6, 7}, {0, 0}};
Sublist test_list3[] = {list7, list8, list9};
Sublist result3[3];
int result3_size = 0;
func0(test_list3, 3, result3, &result3_size);
assert(result3_size == 2);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rcx,0x18(%rsp)
test %esi,%esi
jle 12e0 <func0+0x3f>
mov %rdx,%r15
mov %rdi,%r13
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x8(%rsp)
mov $0x0,%r14d
lea 0x8(%rdx),%rax
mov %rax,0x10(%rsp)
jmp 1313 <func0+0x72>
mov $0x0,%r14d
mov 0x18(%rsp),%rax
mov %r14d,(%rax)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq %r14d,%rax
mov %rbp,(%r15,%rax,8)
lea 0x1(%r14),%r14d
add $0x8,%r13
cmp 0x8(%rsp),%r13
je 12e6 <func0+0x45>
mov 0x0(%r13),%rbx
mov %rbx,%rdi
callq 11c2 <sublist_length>
mov %eax,%esi
mov %rbx,%rdi
callq 11a1 <sorted_sublist>
mov %rax,%rbp
test %r14d,%r14d
jle 12fd <func0+0x5c>
mov %r15,%rbx
lea -0x1(%r14),%eax
mov 0x10(%rsp),%rdx
lea (%rdx,%rax,8),%r12
mov %rbp,%rsi
mov (%rbx),%rdi
callq 11e9 <are_sublists_equal>
test %al,%al
jne 1308 <func0+0x67>
add $0x8,%rbx
cmp %r12,%rbx
jne 1341 <func0+0xa0>
jmp 12fd <func0+0x5c>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], rcx
test esi, esi
jle short loc_12D9
mov r15, rdx
mov r13, rdi
lea eax, [rsi-1]
lea rax, [rdi+rax*8+8]
mov [rsp+58h+var_50], rax
mov r14d, 0
lea rax, [rdx+8]
mov [rsp+58h+var_48], rax
jmp short loc_130C
loc_12D9:
mov r14d, 0
loc_12DF:
mov rax, [rsp+58h+var_40]
mov [rax], r14d
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12F6:
movsxd rax, r14d
mov [r15+rax*8], rbp
lea r14d, [r14+1]
loc_1301:
add r13, 8
cmp r13, [rsp+58h+var_50]
jz short loc_12DF
loc_130C:
mov rbx, [r13+0]
mov rdi, rbx
call sublist_length
mov esi, eax
mov rdi, rbx
call sorted_sublist
mov rbp, rax
test r14d, r14d
jle short loc_12F6
mov rbx, r15
lea eax, [r14-1]
mov rdx, [rsp+58h+var_48]
lea r12, [rdx+rax*8]
loc_133A:
mov rsi, rbp
mov rdi, [rbx]
call are_sublists_equal
test al, al
jnz short loc_1301
add rbx, 8
cmp rbx, r12
jnz short loc_133A
jmp short loc_12F6 | int * func0(_QWORD *a1, int a2, _QWORD *a3, int *a4)
{
_QWORD *v5; // r13
int v6; // r14d
int *result; // rax
long long v8; // rbx
unsigned int v9; // eax
long long v10; // rbp
_QWORD *v11; // rbx
_QWORD *v12; // [rsp+10h] [rbp-48h]
if ( a2 <= 0 )
{
v6 = 0;
}
else
{
v5 = a1;
v6 = 0;
v12 = a3 + 1;
do
{
v8 = *v5;
v9 = sublist_length(*v5);
v10 = sorted_sublist(v8, v9);
if ( v6 <= 0 )
{
LABEL_5:
a3[v6++] = v10;
}
else
{
v11 = a3;
while ( !(unsigned __int8)are_sublists_equal(*v11, v10) )
{
if ( ++v11 == &v12[v6 - 1] )
goto LABEL_5;
}
}
++v5;
}
while ( v5 != &a1[(unsigned int)(a2 - 1) + 1] );
}
result = a4;
*a4 = v6;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RCX
TEST ESI,ESI
JLE 0x001012d9
MOV R15,RDX
MOV R13,RDI
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV R14D,0x0
LEA RAX,[RDX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0010130c
LAB_001012d9:
MOV R14D,0x0
LAB_001012df:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R14D
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012f6:
MOVSXD RAX,R14D
MOV qword ptr [R15 + RAX*0x8],RBP
LEA R14D,[R14 + 0x1]
LAB_00101301:
ADD R13,0x8
CMP R13,qword ptr [RSP + 0x8]
JZ 0x001012df
LAB_0010130c:
MOV RBX,qword ptr [R13]
MOV RDI,RBX
CALL 0x001011c0
MOV ESI,EAX
MOV RDI,RBX
CALL 0x0010119f
MOV RBP,RAX
TEST R14D,R14D
JLE 0x001012f6
MOV RBX,R15
LEA EAX,[R14 + -0x1]
MOV RDX,qword ptr [RSP + 0x10]
LEA R12,[RDX + RAX*0x8]
LAB_0010133a:
MOV RSI,RBP
MOV RDI,qword ptr [RBX]
CALL 0x001011e7
TEST AL,AL
JNZ 0x00101301
ADD RBX,0x8
CMP RBX,R12
JNZ 0x0010133a
JMP 0x001012f6 | void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
char cVar2;
int4 uVar3;
int8 uVar4;
int8 *puVar5;
int iVar6;
if (param_2 < 1) {
iVar6 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar6 = 0;
do {
uVar4 = *param_1;
uVar3 = sublist_length(uVar4);
uVar4 = sorted_sublist(uVar4,uVar3);
if (0 < iVar6) {
puVar5 = param_3;
do {
cVar2 = are_sublists_equal(*puVar5,uVar4);
if (cVar2 != '\0') goto LAB_00101301;
puVar5 = puVar5 + 1;
} while (puVar5 != param_3 + (ulong)(iVar6 - 1) + 1);
}
param_3[iVar6] = uVar4;
iVar6 = iVar6 + 1;
LAB_00101301:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
*param_4 = iVar6;
return;
} |
6,462 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef struct {
int first;
int second;
} Pair;
typedef Pair* Sublist;
int compare_pairs(const void *a, const void *b) {
Pair pa = *(Pair*)a;
Pair pb = *(Pair*)b;
if (pa.first != pb.first) return (pa.first - pb.first);
return (pa.second - pb.second);
}
Sublist sorted_sublist(Sublist sub, int len) {
qsort(sub, len, sizeof(Pair), compare_pairs);
return sub;
}
int sublist_length(Sublist sub) {
int len = 0;
while (sub[len].first != 0 && sub[len].second != 0) len++;
return len;
}
bool are_sublists_equal(Sublist a, Sublist b) {
int len_a = sublist_length(a);
int len_b = sublist_length(b);
if (len_a != len_b) return false;
qsort(a, len_a, sizeof(Pair), compare_pairs);
qsort(b, len_b, sizeof(Pair), compare_pairs);
for (int i = 0; i < len_a; i++) {
if (a[i].first != b[i].first || a[i].second != b[i].second) {
return false;
}
}
return true;
}
| void func0(Sublist *test_list, int num_lists, Sublist *result, int *result_size) {
int added = 0;
for (int i = 0; i < num_lists; i++) {
Sublist current = sorted_sublist(test_list[i], sublist_length(test_list[i]));
bool found = false;
for (int j = 0; j < added; j++) {
if (are_sublists_equal(result[j], current)) {
found = true;
break;
}
}
if (!found) {
result[added++] = current;
}
}
*result_size = added;
}
| int main() {
Pair list1[] = {{4, 5}, {3, 2}, {0, 0}};
Pair list2[] = {{2, 2}, {4, 6}, {0, 0}};
Pair list3[] = {{3, 2}, {4, 5}, {0, 0}};
Sublist test_list1[] = {list1, list2, list3};
Sublist result1[3];
int result1_size = 0;
func0(test_list1, 3, result1, &result1_size);
assert(result1_size == 2);
Pair list4[] = {{5, 6}, {4, 3}, {0, 0}};
Pair list5[] = {{3, 3}, {5, 7}, {0, 0}};
Pair list6[] = {{4, 3}, {5, 6}, {0, 0}};
Sublist test_list2[] = {list4, list5, list6};
Sublist result2[3];
int result2_size = 0;
func0(test_list2, 3, result2, &result2_size);
assert(result2_size == 2);
Pair list7[] = {{6, 7}, {5, 4}, {0, 0}};
Pair list8[] = {{4, 4}, {6, 8}, {0, 0}};
Pair list9[] = {{5, 4}, {6, 7}, {0, 0}};
Sublist test_list3[] = {list7, list8, list9};
Sublist result3[3];
int result3_size = 0;
func0(test_list3, 3, result3, &result3_size);
assert(result3_size == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rcx,0x18(%rsp)
test %esi,%esi
jle 1755 <func0+0xf5>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rdi,%rbp
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x8(%rsp)
lea 0x8(%rdx),%rax
mov %rax,0x10(%rsp)
xchg %ax,%ax
mov 0x0(%rbp),%r14
xor %esi,%esi
mov (%r14),%ecx
test %ecx,%ecx
jne 16bc <func0+0x5c>
jmp 16c5 <func0+0x65>
add $0x1,%rsi
mov (%r14,%rsi,8),%edx
test %edx,%edx
je 16c5 <func0+0x65>
mov 0x4(%r14,%rsi,8),%eax
test %eax,%eax
jne 16b0 <func0+0x50>
lea -0x22c(%rip),%rcx
mov $0x8,%edx
mov %r14,%rdi
callq 1070 <qsort@plt>
test %r12d,%r12d
je 1738 <func0+0xd8>
mov 0x10(%rsp),%rdx
lea -0x1(%r12),%eax
mov %r13,%r15
lea (%rdx,%rax,8),%rbx
jmp 1701 <func0+0xa1>
nopl 0x0(%rax)
add $0x8,%r15
cmp %rbx,%r15
je 1738 <func0+0xd8>
mov (%r15),%rdi
mov %r14,%rsi
callq 1520 <are_sublists_equal>
test %al,%al
je 16f8 <func0+0x98>
add $0x8,%rbp
cmp 0x8(%rsp),%rbp
jne 16a0 <func0+0x40>
mov 0x18(%rsp),%rax
mov %r12d,(%rax)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
movslq %r12d,%rax
add $0x8,%rbp
add $0x1,%r12d
mov %r14,0x0(%r13,%rax,8)
cmp 0x8(%rsp),%rbp
jne 16a0 <func0+0x40>
jmp 171b <func0+0xbb>
xor %r12d,%r12d
jmp 171b <func0+0xbb>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], rdx
mov [rsp+58h+var_40], rcx
test esi, esi
jle loc_1760
lea eax, [rsi-1]
mov rbp, rdi
lea r14, compare_pairs
xor r12d, r12d
lea rax, [rdi+rax*8+8]
mov [rsp+58h+var_50], rax
lea rax, [rdx+8]
mov [rsp+58h+var_48], rax
nop word ptr [rax+rax+00000000h]
loc_16B0:
mov r15, [rbp+0]
xor esi, esi
mov ecx, [r15]
test ecx, ecx
jnz short loc_16CC
jmp short loc_16D5
loc_16C0:
add rsi, 1
mov edx, [r15+rsi*8]
test edx, edx
jz short loc_16D5
loc_16CC:
mov eax, [r15+rsi*8+4]
test eax, eax
jnz short loc_16C0
loc_16D5:
mov rcx, r14
mov edx, 8
mov rdi, r15
call _qsort
test r12d, r12d
jz short loc_1740
mov rdx, [rsp+58h+var_48]
lea eax, [r12-1]
mov r13, [rsp+58h+var_58]
lea rbx, [rdx+rax*8]
jmp short loc_1709
loc_1700:
add r13, 8
cmp rbx, r13
jz short loc_1740
loc_1709:
mov rdi, [r13+0]
mov rsi, r15
call are_sublists_equal
test al, al
jz short loc_1700
add rbp, 8
cmp rbp, [rsp+58h+var_50]
jnz short loc_16B0
loc_1724:
mov rax, [rsp+58h+var_40]
mov [rax], r12d
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1740:
mov rcx, [rsp+58h+var_58]
movsxd rax, r12d
add rbp, 8
add r12d, 1
mov [rcx+rax*8], r15
cmp rbp, [rsp+58h+var_50]
jnz loc_16B0
jmp short loc_1724
loc_1760:
xor r12d, r12d
jmp short loc_1724 | _DWORD * func0(_QWORD *a1, int a2, _QWORD *a3, _DWORD *a4)
{
_QWORD *v4; // rbp
int v5; // r12d
_DWORD *v6; // r15
long long v7; // rsi
_QWORD *v8; // r13
_DWORD *result; // rax
long long v10; // rax
long long v12; // [rsp+8h] [rbp-50h]
_QWORD *v13; // [rsp+10h] [rbp-48h]
if ( a2 <= 0 )
{
v5 = 0;
}
else
{
v4 = a1;
v5 = 0;
v12 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
v13 = a3 + 1;
do
{
while ( 1 )
{
v6 = (_DWORD *)*v4;
v7 = 0LL;
if ( *(_DWORD *)*v4 )
{
do
{
if ( !v6[2 * v7 + 1] )
break;
++v7;
}
while ( v6[2 * v7] );
}
qsort(*v4, v7, 8LL, compare_pairs);
if ( v5 )
break;
LABEL_13:
v10 = v5;
++v4;
++v5;
a3[v10] = v6;
if ( v4 == (_QWORD *)v12 )
goto LABEL_12;
}
v8 = a3;
while ( !(unsigned __int8)are_sublists_equal(*v8, v6) )
{
if ( &v13[v5 - 1] == ++v8 )
goto LABEL_13;
}
++v4;
}
while ( v4 != (_QWORD *)v12 );
}
LABEL_12:
result = a4;
*a4 = v5;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x18],RCX
TEST ESI,ESI
JLE 0x00101760
LEA EAX,[RSI + -0x1]
MOV RBP,RDI
LEA R14,[0x1014a0]
XOR R12D,R12D
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[RDX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001016b0:
MOV R15,qword ptr [RBP]
XOR ESI,ESI
MOV ECX,dword ptr [R15]
TEST ECX,ECX
JNZ 0x001016cc
JMP 0x001016d5
LAB_001016c0:
ADD RSI,0x1
MOV EDX,dword ptr [R15 + RSI*0x8]
TEST EDX,EDX
JZ 0x001016d5
LAB_001016cc:
MOV EAX,dword ptr [R15 + RSI*0x8 + 0x4]
TEST EAX,EAX
JNZ 0x001016c0
LAB_001016d5:
MOV RCX,R14
MOV EDX,0x8
MOV RDI,R15
CALL 0x00101070
TEST R12D,R12D
JZ 0x00101740
MOV RDX,qword ptr [RSP + 0x10]
LEA EAX,[R12 + -0x1]
MOV R13,qword ptr [RSP]
LEA RBX,[RDX + RAX*0x8]
JMP 0x00101709
LAB_00101700:
ADD R13,0x8
CMP RBX,R13
JZ 0x00101740
LAB_00101709:
MOV RDI,qword ptr [R13]
MOV RSI,R15
CALL 0x00101520
TEST AL,AL
JZ 0x00101700
ADD RBP,0x8
CMP RBP,qword ptr [RSP + 0x8]
JNZ 0x001016b0
LAB_00101724:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R12D
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101740:
MOV RCX,qword ptr [RSP]
MOVSXD RAX,R12D
ADD RBP,0x8
ADD R12D,0x1
MOV qword ptr [RCX + RAX*0x8],R15
CMP RBP,qword ptr [RSP + 0x8]
JNZ 0x001016b0
JMP 0x00101724
LAB_00101760:
XOR R12D,R12D
JMP 0x00101724 | void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
int iVar2;
int *__base;
char cVar3;
long lVar4;
size_t __nmemb;
int iVar5;
int8 *puVar6;
if (param_2 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
LAB_001016b0:
do {
__base = (int *)*param_1;
__nmemb = 0;
iVar2 = *__base;
while ((iVar2 != 0 && (__base[__nmemb * 2 + 1] != 0))) {
__nmemb = __nmemb + 1;
iVar2 = __base[__nmemb * 2];
}
qsort(__base,__nmemb,8,compare_pairs);
if (iVar5 != 0) {
puVar6 = param_3;
do {
cVar3 = are_sublists_equal(*puVar6);
if (cVar3 != '\0') {
param_1 = param_1 + 1;
if (param_1 == puVar1) goto LAB_00101724;
goto LAB_001016b0;
}
puVar6 = puVar6 + 1;
} while (param_3 + (ulong)(iVar5 - 1) + 1 != puVar6);
}
lVar4 = (long)iVar5;
param_1 = param_1 + 1;
iVar5 = iVar5 + 1;
param_3[lVar4] = __base;
} while (param_1 != puVar1);
}
LAB_00101724:
*param_4 = iVar5;
return;
} |
6,463 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef struct {
int first;
int second;
} Pair;
typedef Pair* Sublist;
int compare_pairs(const void *a, const void *b) {
Pair pa = *(Pair*)a;
Pair pb = *(Pair*)b;
if (pa.first != pb.first) return (pa.first - pb.first);
return (pa.second - pb.second);
}
Sublist sorted_sublist(Sublist sub, int len) {
qsort(sub, len, sizeof(Pair), compare_pairs);
return sub;
}
int sublist_length(Sublist sub) {
int len = 0;
while (sub[len].first != 0 && sub[len].second != 0) len++;
return len;
}
bool are_sublists_equal(Sublist a, Sublist b) {
int len_a = sublist_length(a);
int len_b = sublist_length(b);
if (len_a != len_b) return false;
qsort(a, len_a, sizeof(Pair), compare_pairs);
qsort(b, len_b, sizeof(Pair), compare_pairs);
for (int i = 0; i < len_a; i++) {
if (a[i].first != b[i].first || a[i].second != b[i].second) {
return false;
}
}
return true;
}
| void func0(Sublist *test_list, int num_lists, Sublist *result, int *result_size) {
int added = 0;
for (int i = 0; i < num_lists; i++) {
Sublist current = sorted_sublist(test_list[i], sublist_length(test_list[i]));
bool found = false;
for (int j = 0; j < added; j++) {
if (are_sublists_equal(result[j], current)) {
found = true;
break;
}
}
if (!found) {
result[added++] = current;
}
}
*result_size = added;
}
| int main() {
Pair list1[] = {{4, 5}, {3, 2}, {0, 0}};
Pair list2[] = {{2, 2}, {4, 6}, {0, 0}};
Pair list3[] = {{3, 2}, {4, 5}, {0, 0}};
Sublist test_list1[] = {list1, list2, list3};
Sublist result1[3];
int result1_size = 0;
func0(test_list1, 3, result1, &result1_size);
assert(result1_size == 2);
Pair list4[] = {{5, 6}, {4, 3}, {0, 0}};
Pair list5[] = {{3, 3}, {5, 7}, {0, 0}};
Pair list6[] = {{4, 3}, {5, 6}, {0, 0}};
Sublist test_list2[] = {list4, list5, list6};
Sublist result2[3];
int result2_size = 0;
func0(test_list2, 3, result2, &result2_size);
assert(result2_size == 2);
Pair list7[] = {{6, 7}, {5, 4}, {0, 0}};
Pair list8[] = {{4, 4}, {6, 8}, {0, 0}};
Pair list9[] = {{5, 4}, {6, 7}, {0, 0}};
Sublist test_list3[] = {list7, list8, list9};
Sublist result3[3];
int result3_size = 0;
func0(test_list3, 3, result3, &result3_size);
assert(result3_size == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rcx,0x18(%rsp)
test %esi,%esi
jle 16f5 <func0+0xf5>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rdi,%rbp
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x8(%rsp)
lea 0x8(%rdx),%rax
mov %rax,0x10(%rsp)
xchg %ax,%ax
mov 0x0(%rbp),%r14
xor %esi,%esi
mov (%r14),%ecx
test %ecx,%ecx
jne 165c <func0+0x5c>
jmp 1665 <func0+0x65>
add $0x1,%rsi
mov (%r14,%rsi,8),%edx
test %edx,%edx
je 1665 <func0+0x65>
mov 0x4(%r14,%rsi,8),%eax
test %eax,%eax
jne 1650 <func0+0x50>
lea -0x22c(%rip),%rcx
mov $0x8,%edx
mov %r14,%rdi
callq 1070 <qsort@plt>
test %r12d,%r12d
je 16d8 <func0+0xd8>
mov 0x10(%rsp),%rdx
lea -0x1(%r12),%eax
mov %r13,%r15
lea (%rdx,%rax,8),%rbx
jmp 16a1 <func0+0xa1>
nopl 0x0(%rax)
add $0x8,%r15
cmp %r15,%rbx
je 16d8 <func0+0xd8>
mov (%r15),%rdi
mov %r14,%rsi
callq 14c0 <are_sublists_equal>
test %al,%al
je 1698 <func0+0x98>
add $0x8,%rbp
cmp 0x8(%rsp),%rbp
jne 1640 <func0+0x40>
mov 0x18(%rsp),%rax
mov %r12d,(%rax)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
movslq %r12d,%rax
add $0x8,%rbp
add $0x1,%r12d
mov %r14,0x0(%r13,%rax,8)
cmp 0x8(%rsp),%rbp
jne 1640 <func0+0x40>
jmp 16bb <func0+0xbb>
xor %r12d,%r12d
jmp 16bb <func0+0xbb>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], rdx
mov [rsp+58h+var_40], rcx
test esi, esi
jle loc_1731
movsxd rsi, esi
mov rbp, rdi
xor r12d, r12d
lea rax, [rdi+rsi*8]
mov [rsp+58h+var_48], rax
nop word ptr [rax+rax+00000000h]
loc_1670:
mov r15, [rbp+0]
xor esi, esi
mov ecx, [r15]
test ecx, ecx
jnz short loc_168C
jmp short loc_1695
loc_1680:
add rsi, 1; nmemb
mov edx, [r15+rsi*8]
test edx, edx
jz short loc_1695
loc_168C:
mov eax, [r15+rsi*8+4]
test eax, eax
jnz short loc_1680
loc_1695:
lea rcx, compare_pairs; compar
mov edx, 8; size
mov rdi, r15; base
movsxd r14, r12d
call _qsort
test r12d, r12d
jle short loc_1710
mov rax, [rsp+58h+var_50]
movsxd r14, r12d
mov r13, rax
lea rbx, [rax+r14*8]
jmp short loc_16D1
loc_16C8:
add r13, 8
cmp rbx, r13
jz short loc_1710
loc_16D1:
mov rdi, [r13+0]; base
mov rsi, r15; void *
call are_sublists_equal
test al, al
jz short loc_16C8
mov rax, [rsp+58h+var_48]
add rbp, 8
cmp rbp, rax
jnz short loc_1670
loc_16EF:
mov rax, [rsp+58h+var_40]
mov [rax], r12d
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1710:
mov rax, [rsp+58h+var_50]
add rbp, 8
add r12d, 1
mov [rax+r14*8], r15
mov rax, [rsp+58h+var_48]
cmp rbp, rax
jnz loc_1670
jmp short loc_16EF
loc_1731:
xor r12d, r12d
jmp short loc_16EF | int * func0(void **a1, int a2, void **a3, int *a4)
{
void **v4; // rbp
int v5; // r12d
_DWORD *v6; // r15
size_t v7; // rsi
long long v8; // r14
void **v9; // r13
int *result; // rax
void **v12; // [rsp+10h] [rbp-48h]
if ( a2 <= 0 )
{
v5 = 0;
}
else
{
v4 = a1;
v5 = 0;
v12 = &a1[a2];
do
{
while ( 1 )
{
v6 = *v4;
v7 = 0LL;
if ( *(_DWORD *)*v4 )
{
do
{
if ( !v6[2 * v7 + 1] )
break;
++v7;
}
while ( v6[2 * v7] );
}
v8 = v5;
qsort(*v4, v7, 8uLL, compare_pairs);
if ( v5 > 0 )
break;
LABEL_13:
++v4;
++v5;
a3[v8] = v6;
if ( v4 == v12 )
goto LABEL_12;
}
v8 = v5;
v9 = a3;
while ( !(unsigned __int8)are_sublists_equal(*v9, v6) )
{
if ( &a3[v5] == ++v9 )
goto LABEL_13;
}
++v4;
}
while ( v4 != v12 );
}
LABEL_12:
result = a4;
*a4 = v5;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x18],RCX
TEST ESI,ESI
JLE 0x00101731
MOVSXD RSI,ESI
MOV RBP,RDI
XOR R12D,R12D
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP + 0x10],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101670:
MOV R15,qword ptr [RBP]
XOR ESI,ESI
MOV ECX,dword ptr [R15]
TEST ECX,ECX
JNZ 0x0010168c
JMP 0x00101695
LAB_00101680:
ADD RSI,0x1
MOV EDX,dword ptr [R15 + RSI*0x8]
TEST EDX,EDX
JZ 0x00101695
LAB_0010168c:
MOV EAX,dword ptr [R15 + RSI*0x8 + 0x4]
TEST EAX,EAX
JNZ 0x00101680
LAB_00101695:
LEA RCX,[0x101450]
MOV EDX,0x8
MOV RDI,R15
MOVSXD R14,R12D
CALL 0x00101070
TEST R12D,R12D
JLE 0x00101710
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD R14,R12D
MOV R13,RAX
LEA RBX,[RAX + R14*0x8]
JMP 0x001016d1
LAB_001016c8:
ADD R13,0x8
CMP RBX,R13
JZ 0x00101710
LAB_001016d1:
MOV RDI,qword ptr [R13]
MOV RSI,R15
CALL 0x001014d0
TEST AL,AL
JZ 0x001016c8
MOV RAX,qword ptr [RSP + 0x10]
ADD RBP,0x8
CMP RBP,RAX
JNZ 0x00101670
LAB_001016ef:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R12D
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101710:
MOV RAX,qword ptr [RSP + 0x8]
ADD RBP,0x8
ADD R12D,0x1
MOV qword ptr [RAX + R14*0x8],R15
MOV RAX,qword ptr [RSP + 0x10]
CMP RBP,RAX
JNZ 0x00101670
JMP 0x001016ef
LAB_00101731:
XOR R12D,R12D
JMP 0x001016ef | void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
int iVar2;
int *__base;
char cVar3;
size_t __nmemb;
int iVar4;
int8 *puVar5;
long lVar6;
if (param_2 < 1) {
iVar4 = 0;
}
else {
iVar4 = 0;
puVar1 = param_1 + param_2;
LAB_00101670:
do {
__base = (int *)*param_1;
__nmemb = 0;
iVar2 = *__base;
while ((iVar2 != 0 && (__base[__nmemb * 2 + 1] != 0))) {
__nmemb = __nmemb + 1;
iVar2 = __base[__nmemb * 2];
}
qsort(__base,__nmemb,8,compare_pairs);
if (0 < iVar4) {
puVar5 = param_3;
do {
cVar3 = are_sublists_equal(*puVar5);
if (cVar3 != '\0') {
param_1 = param_1 + 1;
if (param_1 == puVar1) goto LAB_001016ef;
goto LAB_00101670;
}
puVar5 = puVar5 + 1;
} while (param_3 + iVar4 != puVar5);
}
lVar6 = (long)iVar4;
param_1 = param_1 + 1;
iVar4 = iVar4 + 1;
param_3[lVar6] = __base;
} while (param_1 != puVar1);
}
LAB_001016ef:
*param_4 = iVar4;
return;
} |
6,464 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "\\Bz\\B";
int reti;
// Compile regular expression
reti = regcomp(®ex, pattern, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
// Execute regular expression
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else if (reti == REG_NOMATCH) {
return "Not matched!";
} else {
char msgbuf[100];
regerror(reti, ®ex, msgbuf, sizeof(msgbuf));
fprintf(stderr, "Regex match failed: %s\n", msgbuf);
return "Regex execution error";
}
// Free compiled regular expression
regfree(®ex);
}
| int main() {
assert(strcmp(func0("pythonzabc."), "Found a match!") == 0);
assert(strcmp(func0("xyzabc."), "Found a match!") == 0);
assert(strcmp(func0(" lang ."), "Not matched!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %rdi,-0xc8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdb3(%rip),%rax
mov %rax,-0xb8(%rbp)
mov -0xb8(%rbp),%rcx
lea -0xb0(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10e0 <regcomp@plt>
mov %eax,-0xbc(%rbp)
cmpl $0x0,-0xbc(%rbp)
je 12b5 <func0+0x8c>
mov 0x2d90(%rip),%rax
mov %rax,%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xd6a(%rip),%rdi
callq 1130 <fwrite@plt>
lea 0xd77(%rip),%rax
jmpq 1348 <func0+0x11f>
mov -0xc8(%rbp),%rsi
lea -0xb0(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 1120 <regexec@plt>
mov %eax,-0xbc(%rbp)
cmpl $0x0,-0xbc(%rbp)
jne 12f3 <func0+0xca>
lea 0xd4e(%rip),%rax
jmp 1348 <func0+0x11f>
cmpl $0x1,-0xbc(%rbp)
jne 1305 <func0+0xdc>
lea 0xd4b(%rip),%rax
jmp 1348 <func0+0x11f>
lea -0x70(%rbp),%rdx
lea -0xb0(%rbp),%rsi
mov -0xbc(%rbp),%eax
mov $0x64,%ecx
mov %eax,%edi
callq 1110 <regerror@plt>
mov 0x2cf7(%rip),%rax
lea -0x70(%rbp),%rdx
lea 0xd27(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1100 <fprintf@plt>
lea 0xd2b(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 135c <func0+0x133>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aBzB; "\\Bz\\B"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov [rbp+errcode], eax
cmp [rbp+errcode], 0
jz short loc_12B8
mov rax, cs:__bss_start
mov rcx, rax; s
mov edx, 18h; n
mov esi, 1; size
lea rax, aCouldNotCompil; "Could not compile regex\n"
mov rdi, rax; ptr
call _fwrite
lea rax, aRegexCompilati; "Regex compilation error"
jmp loc_134E
loc_12B8:
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+errcode], eax
cmp [rbp+errcode], 0
jnz short loc_12F6
lea rax, s2; "Found a match!"
jmp short loc_134E
loc_12F6:
cmp [rbp+errcode], 1
jnz short loc_1308
lea rax, aNotMatched; "Not matched!"
jmp short loc_134E
loc_1308:
lea rdx, [rbp+errbuf]; errbuf
lea rsi, [rbp+preg]; preg
mov eax, [rbp+errcode]
mov ecx, 64h ; 'd'; errbuf_size
mov edi, eax; errcode
call _regerror
mov rax, cs:__bss_start
lea rdx, [rbp+errbuf]
lea rcx, format; "Regex match failed: %s\n"
mov rsi, rcx; format
mov rdi, rax; stream
mov eax, 0
call _fprintf
lea rax, aRegexExecution; "Regex execution error"
loc_134E:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1362
call ___stack_chk_fail
locret_1362:
leave
retn | const char * func0(const char *a1)
{
int errcode; // [rsp+14h] [rbp-BCh]
regex_t preg; // [rsp+20h] [rbp-B0h] BYREF
char errbuf[104]; // [rsp+60h] [rbp-70h] BYREF
unsigned long long v5; // [rsp+C8h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( regcomp(&preg, "\\Bz\\B", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return "Regex compilation error";
}
else
{
errcode = regexec(&preg, a1, 0LL, 0LL, 0);
if ( errcode )
{
if ( errcode == 1 )
{
return "Not matched!";
}
else
{
regerror(errcode, &preg, errbuf, 0x64uLL);
fprintf(_bss_start, "Regex match failed: %s\n", errbuf);
return "Regex execution error";
}
}
else
{
return "Found a match!";
}
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xc8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0xb8],RAX
MOV RCX,qword ptr [RBP + -0xb8]
LEA RAX,[RBP + -0xb0]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010e0
MOV dword ptr [RBP + -0xbc],EAX
CMP dword ptr [RBP + -0xbc],0x0
JZ 0x001012b8
MOV RAX,qword ptr [0x00104020]
MOV RCX,RAX
MOV EDX,0x18
MOV ESI,0x1
LEA RAX,[0x10200e]
MOV RDI,RAX
CALL 0x00101130
LEA RAX,[0x102027]
JMP 0x0010134e
LAB_001012b8:
MOV RSI,qword ptr [RBP + -0xc8]
LEA RAX,[RBP + -0xb0]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x00101120
MOV dword ptr [RBP + -0xbc],EAX
CMP dword ptr [RBP + -0xbc],0x0
JNZ 0x001012f6
LEA RAX,[0x10203f]
JMP 0x0010134e
LAB_001012f6:
CMP dword ptr [RBP + -0xbc],0x1
JNZ 0x00101308
LEA RAX,[0x10204e]
JMP 0x0010134e
LAB_00101308:
LEA RDX,[RBP + -0x70]
LEA RSI,[RBP + -0xb0]
MOV EAX,dword ptr [RBP + -0xbc]
MOV ECX,0x64
MOV EDI,EAX
CALL 0x00101110
MOV RAX,qword ptr [0x00104020]
LEA RDX,[RBP + -0x70]
LEA RCX,[0x10205b]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101100
LEA RAX,[0x102073]
LAB_0010134e:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101362
CALL 0x001010c0
LAB_00101362:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_b8;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_b8,"\\Bz\\B",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_b8,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
pcVar2 = "Found a match!";
}
else if (iVar1 == 1) {
pcVar2 = "Not matched!";
}
else {
regerror(iVar1,&local_b8,local_78,100);
fprintf(stderr,"Regex match failed: %s\n",local_78);
pcVar2 = "Regex execution error";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Regex compilation error";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
6,465 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "\\Bz\\B";
int reti;
// Compile regular expression
reti = regcomp(®ex, pattern, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
// Execute regular expression
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else if (reti == REG_NOMATCH) {
return "Not matched!";
} else {
char msgbuf[100];
regerror(reti, ®ex, msgbuf, sizeof(msgbuf));
fprintf(stderr, "Regex match failed: %s\n", msgbuf);
return "Regex execution error";
}
// Free compiled regular expression
regfree(®ex);
}
| int main() {
assert(strcmp(func0("pythonzabc."), "Found a match!") == 0);
assert(strcmp(func0("xyzabc."), "Found a match!") == 0);
assert(strcmp(func0(" lang ."), "Not matched!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0xb0,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe14(%rip),%rsi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 12b5 <func0+0xac>
mov %rsp,%rdi
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
callq 10f0 <regexec@plt>
mov %eax,%edi
lea 0xdcb(%rip),%rax
test %edi,%edi
je 12d9 <func0+0xd0>
lea 0xdcf(%rip),%rax
cmp $0x1,%edi
je 12d9 <func0+0xd0>
lea 0x40(%rsp),%rbx
mov %rsp,%rsi
mov $0x64,%ecx
mov %rbx,%rdx
callq 10e0 <regerror@plt>
mov %rbx,%rcx
lea 0xdd7(%rip),%rdx
mov $0x1,%esi
mov 0x2d7e(%rip),%rdi
mov $0x0,%eax
callq 1110 <__fprintf_chk@plt>
lea 0xd69(%rip),%rax
jmp 12d9 <func0+0xd0>
mov 0x2d64(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xd87(%rip),%rdi
callq 1100 <fwrite@plt>
lea 0xd2b(%rip),%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12f5 <func0+0xec>
add $0xb0,%rsp
pop %rbx
retq
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 0B0h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+0B8h+var_10], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aBzB; "\\Bz\\B"
call _regcomp
test eax, eax
jnz short loc_12D5
mov rdi, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
call _regexec
mov edi, eax
lea rax, aFoundAMatch; "Found a match!"
test edi, edi
jz short loc_12F9
lea rax, aNotMatched; "Not matched!"
cmp edi, 1
jz short loc_12F9
lea rbx, [rsp+0B8h+var_78]
mov rsi, rsp
mov ecx, 64h ; 'd'
mov rdx, rbx
call _regerror
mov rcx, rbx
lea rdx, aRegexMatchFail; "Regex match failed: %s\n"
mov esi, 1
mov rdi, cs:stderr@GLIBC_2_2_5
mov eax, 0
call ___fprintf_chk
lea rax, aRegexExecution; "Regex execution error"
jmp short loc_12F9
loc_12D5:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 18h
mov esi, 1
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
lea rax, aRegexCompilati; "Regex compilation error"
loc_12F9:
mov rdx, [rsp+0B8h+var_10]
sub rdx, fs:28h
jnz short loc_1315
add rsp, 0B0h
pop rbx
retn
loc_1315:
call ___stack_chk_fail | const char * func0(long long a1)
{
long long v1; // rdi
const char *result; // rax
_BYTE v3[64]; // [rsp+0h] [rbp-B8h] BYREF
char v4[104]; // [rsp+40h] [rbp-78h] BYREF
unsigned long long v5; // [rsp+A8h] [rbp-10h]
v5 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "\\Bz\\B", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Regex compilation error";
}
else
{
v1 = (unsigned int)regexec(v3, a1, 0LL, 0LL, 0LL);
result = "Found a match!";
if ( (_DWORD)v1 )
{
result = "Not matched!";
if ( (_DWORD)v1 != 1 )
{
regerror(v1, v3, v4, 100LL);
__fprintf_chk(stderr, 1LL, "Regex match failed: %s\n", v4);
return "Regex execution error";
}
}
}
return result;
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0xb0
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x10204e]
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x001012d5
MOV RDI,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
CALL 0x00101110
MOV EDI,EAX
LEA RAX,[0x10201c]
TEST EDI,EDI
JZ 0x001012f9
LEA RAX,[0x10202b]
CMP EDI,0x1
JZ 0x001012f9
LEA RBX,[RSP + 0x40]
MOV RSI,RSP
MOV ECX,0x64
MOV RDX,RBX
CALL 0x00101100
MOV RCX,RBX
LEA RDX,[0x10206d]
MOV ESI,0x1
MOV RDI,qword ptr [0x00104020]
MOV EAX,0x0
CALL 0x00101130
LEA RAX,[0x102038]
JMP 0x001012f9
LAB_001012d5:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102054]
CALL 0x00101120
LEA RAX,[0x102004]
LAB_001012f9:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101315
ADD RSP,0xb0
POP RBX
RET
LAB_00101315:
CALL 0x001010c0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_b8;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_b8,"\\Bz\\B",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_b8,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Found a match!";
if ((iVar1 != 0) && (pcVar2 = "Not matched!", iVar1 != 1)) {
regerror(iVar1,&rStack_b8,local_78,100);
__fprintf_chk(stderr,1,"Regex match failed: %s\n",local_78);
pcVar2 = "Regex execution error";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Regex compilation error";
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,466 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "\\Bz\\B";
int reti;
// Compile regular expression
reti = regcomp(®ex, pattern, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
// Execute regular expression
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else if (reti == REG_NOMATCH) {
return "Not matched!";
} else {
char msgbuf[100];
regerror(reti, ®ex, msgbuf, sizeof(msgbuf));
fprintf(stderr, "Regex match failed: %s\n", msgbuf);
return "Regex execution error";
}
// Free compiled regular expression
regfree(®ex);
}
| int main() {
assert(strcmp(func0("pythonzabc."), "Found a match!") == 0);
assert(strcmp(func0("xyzabc."), "Found a match!") == 0);
assert(strcmp(func0(" lang ."), "Not matched!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov $0x1,%edx
lea 0xd4c(%rip),%rsi
push %r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 13c0 <func0+0xd0>
mov %r12,%rdi
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %rbp,%rsi
callq 10f0 <regexec@plt>
mov %eax,%edi
lea 0xce2(%rip),%rax
test %edi,%edi
je 1399 <func0+0xa9>
lea 0xce6(%rip),%rax
cmp $0x1,%edi
je 1399 <func0+0xa9>
lea 0x40(%rsp),%r13
mov $0x64,%ecx
mov %r12,%rsi
mov %r13,%rdx
callq 10e0 <regerror@plt>
mov %r13,%rcx
mov $0x1,%esi
xor %eax,%eax
mov 0x2c9a(%rip),%rdi
lea 0xce0(%rip),%rdx
callq 1110 <__fprintf_chk@plt>
lea 0xc83(%rip),%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13e6 <func0+0xf6>
add $0xb0,%rsp
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
mov 0x2c59(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xc7c(%rip),%rdi
callq 1100 <fwrite@plt>
lea 0xc20(%rip),%rax
jmp 1399 <func0+0xa9>
callq 10b0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov edx, 1
lea rsi, aBzB; "\\Bz\\B"
push r12
push rbp
mov rbp, rdi
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test eax, eax
jnz loc_13D0
mov rdi, r12
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rsi, rbp
call _regexec
mov edi, eax
lea rax, aFoundAMatch; "Found a match!"
test edi, edi
jz short loc_13A9
lea rax, aNotMatched; "Not matched!"
cmp edi, 1
jz short loc_13A9
lea r13, [rsp+0C8h+var_88]
mov ecx, 64h ; 'd'
mov rsi, r12
mov rdx, r13
call _regerror
mov rcx, r13
mov esi, 1
xor eax, eax
mov rdi, cs:stderr@GLIBC_2_2_5
lea rdx, aRegexMatchFail; "Regex match failed: %s\n"
call ___fprintf_chk
lea rax, aRegexExecution; "Regex execution error"
loc_13A9:
mov rdx, [rsp+0C8h+var_20]
sub rdx, fs:28h
jnz short loc_13F6
add rsp, 0B0h
pop rbp
pop r12
pop r13
retn
loc_13D0:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 18h
mov esi, 1
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
lea rax, aRegexCompilati; "Regex compilation error"
jmp short loc_13A9
loc_13F6:
call ___stack_chk_fail | const char * func0(long long a1)
{
long long v1; // rdi
const char *result; // rax
_BYTE v3[64]; // [rsp+0h] [rbp-C8h] BYREF
char v4[104]; // [rsp+40h] [rbp-88h] BYREF
unsigned long long v5; // [rsp+A8h] [rbp-20h]
v5 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "\\Bz\\B", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Regex compilation error";
}
else
{
v1 = (unsigned int)regexec(v3, a1, 0LL, 0LL, 0LL);
result = "Found a match!";
if ( (_DWORD)v1 )
{
result = "Not matched!";
if ( (_DWORD)v1 != 1 )
{
regerror(v1, v3, v4, 100LL);
__fprintf_chk(stderr, 1LL, "Regex match failed: %s\n", v4);
return "Regex execution error";
}
}
}
return result;
} | func0:
ENDBR64
PUSH R13
MOV EDX,0x1
LEA RSI,[0x10204e]
PUSH R12
PUSH RBP
MOV RBP,RDI
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x001013d0
MOV RDI,R12
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBP
CALL 0x00101110
MOV EDI,EAX
LEA RAX,[0x10201c]
TEST EDI,EDI
JZ 0x001013a9
LEA RAX,[0x10202b]
CMP EDI,0x1
JZ 0x001013a9
LEA R13,[RSP + 0x40]
MOV ECX,0x64
MOV RSI,R12
MOV RDX,R13
CALL 0x00101100
MOV RCX,R13
MOV ESI,0x1
XOR EAX,EAX
MOV RDI,qword ptr [0x00104020]
LEA RDX,[0x10206d]
CALL 0x00101130
LEA RAX,[0x102038]
LAB_001013a9:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013f6
ADD RSP,0xb0
POP RBP
POP R12
POP R13
RET
LAB_001013d0:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102054]
CALL 0x00101120
LEA RAX,[0x102004]
JMP 0x001013a9
LAB_001013f6:
CALL 0x001010c0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,"\\Bz\\B",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Found a match!";
if ((iVar1 != 0) && (pcVar2 = "Not matched!", iVar1 != 1)) {
regerror(iVar1,&rStack_c8,local_88,100);
__fprintf_chk(stderr,1,"Regex match failed: %s\n",local_88);
pcVar2 = "Regex execution error";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Regex compilation error";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,467 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "\\Bz\\B";
int reti;
// Compile regular expression
reti = regcomp(®ex, pattern, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
// Execute regular expression
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else if (reti == REG_NOMATCH) {
return "Not matched!";
} else {
char msgbuf[100];
regerror(reti, ®ex, msgbuf, sizeof(msgbuf));
fprintf(stderr, "Regex match failed: %s\n", msgbuf);
return "Regex execution error";
}
// Free compiled regular expression
regfree(®ex);
}
| int main() {
assert(strcmp(func0("pythonzabc."), "Found a match!") == 0);
assert(strcmp(func0("xyzabc."), "Found a match!") == 0);
assert(strcmp(func0(" lang ."), "Not matched!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov $0x1,%edx
lea 0xd4c(%rip),%rsi
push %r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 13c0 <func0+0xd0>
mov %r12,%rdi
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %rbp,%rsi
callq 10f0 <regexec@plt>
mov %eax,%edi
lea 0xce2(%rip),%rax
test %edi,%edi
je 1399 <func0+0xa9>
lea 0xce6(%rip),%rax
cmp $0x1,%edi
je 1399 <func0+0xa9>
lea 0x40(%rsp),%r13
mov $0x64,%ecx
mov %r12,%rsi
mov %r13,%rdx
callq 10e0 <regerror@plt>
mov %r13,%rcx
mov $0x1,%esi
xor %eax,%eax
mov 0x2c9a(%rip),%rdi
lea 0xce0(%rip),%rdx
callq 1110 <__fprintf_chk@plt>
lea 0xc83(%rip),%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13e6 <func0+0xf6>
add $0xb0,%rsp
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
mov 0x2c59(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xc7c(%rip),%rdi
callq 1100 <fwrite@plt>
lea 0xc20(%rip),%rax
jmp 1399 <func0+0xa9>
callq 10b0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "\\Bz\\B"
push rbx
mov rbx, rdi
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+var_sA8], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz loc_13C8
mov rdi, rbp; preg
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbx; string
call _regexec
mov edi, eax; errcode
lea rax, s2; "Found a match!"
test edi, edi
jz short loc_13A6
lea rax, aNotMatched; "Not matched!"
cmp edi, 1
jz short loc_13A6
lea rbx, [rsp+errbuf]
mov ecx, 64h ; 'd'; errbuf_size
mov rsi, rbp; preg
mov rdx, rbx; errbuf
call _regerror
mov rcx, rbx
mov esi, 2
xor eax, eax
mov rdi, cs:__bss_start
lea rdx, aRegexMatchFail; "Regex match failed: %s\n"
call ___fprintf_chk
lea rax, aRegexExecution; "Regex execution error"
loc_13A6:
mov rdx, [rsp+var_sA8]
sub rdx, fs:28h
jnz short loc_13EE
add rsp, 0B8h
pop rbx
pop rbp
retn
loc_13C8:
mov rcx, cs:__bss_start; s
mov edx, 18h; n
mov esi, 1; size
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
lea rax, aRegexCompilati; "Regex compilation error"
jmp short loc_13A6
loc_13EE:
call ___stack_chk_fail | const char * func0(char *string)
{
int v1; // edi
const char *result; // rax
regex_t vars0; // [rsp+0h] [rbp+0h] BYREF
char errbuf[104]; // [rsp+40h] [rbp+40h] BYREF
unsigned long long varsA8; // [rsp+A8h] [rbp+A8h]
varsA8 = __readfsqword(0x28u);
if ( regcomp(&vars0, "\\Bz\\B", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return "Regex compilation error";
}
else
{
v1 = regexec(&vars0, string, 0LL, 0LL, 0);
result = "Found a match!";
if ( v1 )
{
result = "Not matched!";
if ( v1 != 1 )
{
regerror(v1, &vars0, errbuf, 0x64uLL);
__fprintf_chk(_bss_start, 2LL, "Regex match failed: %s\n", errbuf);
return "Regex execution error";
}
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x10204e]
PUSH RBX
MOV RBX,RDI
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x001013c8
MOV RDI,RBP
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBX
CALL 0x00101110
MOV EDI,EAX
LEA RAX,[0x10201c]
TEST EDI,EDI
JZ 0x001013a6
LEA RAX,[0x10202b]
CMP EDI,0x1
JZ 0x001013a6
LEA RBX,[RSP + 0x40]
MOV ECX,0x64
MOV RSI,RBP
MOV RDX,RBX
CALL 0x00101100
MOV RCX,RBX
MOV ESI,0x2
XOR EAX,EAX
MOV RDI,qword ptr [0x00104020]
LEA RDX,[0x10206d]
CALL 0x00101130
LEA RAX,[0x102038]
LAB_001013a6:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013ee
ADD RSP,0xb8
POP RBX
POP RBP
RET
LAB_001013c8:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102054]
CALL 0x00101120
LEA RAX,[0x102004]
JMP 0x001013a6
LAB_001013ee:
CALL 0x001010c0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,"\\Bz\\B",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Found a match!";
if ((iVar1 != 0) && (pcVar2 = "Not matched!", iVar1 != 1)) {
regerror(iVar1,&rStack_c8,local_88,100);
__fprintf_chk(stderr,2,"Regex match failed: %s\n",local_88);
pcVar2 = "Regex execution error";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Regex compilation error";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,468 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int input[], int n, int k, int output[]) {
int i, j;
for (i = 0, j = k - 1; i < k; i++, j--) {
output[i] = input[j];
}
for (i = k; i < n; i++) {
output[i] = input[i];
}
}
| int main() {
int output1[6], output2[4], output3[5];
int arr1[] = {1, 2, 3, 4, 5, 6};
int arr2[] = {4, 5, 6, 7};
int arr3[] = {9, 8, 7, 6, 5};
func0(arr1, 6, 4, output1);
assert(output1[0] == 4 && output1[1] == 3 && output1[2] == 2 && output1[3] == 1 && output1[4] == 5 && output1[5] == 6);
func0(arr2, 4, 2, output2);
assert(output2[0] == 5 && output2[1] == 4 && output2[2] == 6 && output2[3] == 7);
func0(arr3, 5, 3, output3);
assert(output3[0] == 7 && output3[1] == 8 && output3[2] == 9 && output3[3] == 6 && output3[4] == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x20(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11c6 <func0+0x5d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
subl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 1191 <func0+0x28>
mov -0x20(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 1207 <func0+0x9e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11d6 <func0+0x6d>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_8], 0
mov eax, [rbp+var_20]
sub eax, 1
mov [rbp+var_4], eax
jmp short loc_11C6
loc_1191:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_8], 1
sub [rbp+var_4], 1
loc_11C6:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
jl short loc_1191
mov eax, [rbp+var_20]
mov [rbp+var_8], eax
jmp short loc_1207
loc_11D6:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_8], 1
loc_1207:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_11D6
nop
nop
pop rbp
retn | long long func0(long long a1, int a2, signed int a3, long long a4)
{
long long result; // rax
int v5; // [rsp+20h] [rbp-8h]
unsigned int i; // [rsp+20h] [rbp-8h]
int v7; // [rsp+24h] [rbp-4h]
v5 = 0;
v7 = a3 - 1;
while ( v5 < a3 )
*(_DWORD *)(4LL * v5++ + a4) = *(_DWORD *)(4LL * v7-- + a1);
for ( i = a3; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
*(_DWORD *)(4LL * (int)i + a4) = *(_DWORD *)(4LL * (int)i + 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
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011c6
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x8],0x1
SUB dword ptr [RBP + -0x4],0x1
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101191
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101207
LAB_001011d6:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_00101207:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011d6
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
int iVar1;
int4 local_10;
int4 local_c;
local_c = param_3 + -1;
for (local_10 = 0; iVar1 = param_3, local_10 < param_3; local_10 = local_10 + 1) {
*(int4 *)(param_4 + (long)local_10 * 4) = *(int4 *)(param_1 + (long)local_c * 4);
local_c = local_c + -1;
}
while (local_10 = iVar1, local_10 < param_2) {
*(int4 *)(param_4 + (long)local_10 * 4) = *(int4 *)(param_1 + (long)local_10 * 4);
iVar1 = local_10 + 1;
}
return;
} |
6,469 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int input[], int n, int k, int output[]) {
int i, j;
for (i = 0, j = k - 1; i < k; i++, j--) {
output[i] = input[j];
}
for (i = k; i < n; i++) {
output[i] = input[i];
}
}
| int main() {
int output1[6], output2[4], output3[5];
int arr1[] = {1, 2, 3, 4, 5, 6};
int arr2[] = {4, 5, 6, 7};
int arr3[] = {9, 8, 7, 6, 5};
func0(arr1, 6, 4, output1);
assert(output1[0] == 4 && output1[1] == 3 && output1[2] == 2 && output1[3] == 1 && output1[4] == 5 && output1[5] == 6);
func0(arr2, 4, 2, output2);
assert(output2[0] == 5 && output2[1] == 4 && output2[2] == 6 && output2[3] == 7);
func0(arr3, 5, 3, output3);
assert(output3[0] == 7 && output3[1] == 8 && output3[2] == 9 && output3[3] == 6 && output3[4] == 5);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rdx),%eax
test %edx,%edx
jle 1199 <func0+0x30>
cltq
lea (%rdi,%rax,4),%r8
mov %rcx,%rax
lea -0x1(%rdx),%r9d
lea 0x4(%rcx,%r9,4),%r10
mov (%r8),%r9d
mov %r9d,(%rax)
sub $0x4,%r8
add $0x4,%rax
cmp %r10,%rax
jne 1186 <func0+0x1d>
cmp %esi,%edx
jge 11ae <func0+0x45>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%eax
mov %eax,(%rcx,%rdx,4)
add $0x1,%rdx
cmp %edx,%esi
jg 11a0 <func0+0x37>
retq
| func0:
endbr64
mov r9, rdi
mov r8d, esi
lea eax, [rdx-1]
test edx, edx
jle short loc_119C
cdqe
lea rsi, [rdi+rax*4]
mov rax, rcx
lea edi, [rdx-1]
lea r10, [rcx+rdi*4+4]
loc_118B:
mov edi, [rsi]
mov [rax], edi
sub rsi, 4
add rax, 4
cmp rax, r10
jnz short loc_118B
loc_119C:
cmp edx, r8d
jge short locret_11B4
movsxd rdx, edx
loc_11A4:
mov eax, [r9+rdx*4]
mov [rcx+rdx*4], eax
add rdx, 1
cmp r8d, edx
jg short loc_11A4
locret_11B4:
retn | unsigned long long func0(long long a1, int a2, long long a3, _DWORD *a4)
{
unsigned long long result; // rax
_DWORD *v6; // rsi
result = (unsigned int)(a3 - 1);
if ( (int)a3 > 0 )
{
v6 = (_DWORD *)(a1 + 4LL * (int)result);
result = (unsigned long long)a4;
do
{
*(_DWORD *)result = *v6--;
result += 4LL;
}
while ( (_DWORD *)result != &a4[(unsigned int)(a3 - 1) + 1] );
}
if ( (int)a3 < a2 )
{
a3 = (int)a3;
do
{
result = *(unsigned int *)(a1 + 4 * a3);
a4[a3++] = result;
}
while ( a2 > (int)a3 );
}
return result;
} | func0:
ENDBR64
MOV R9,RDI
MOV R8D,ESI
LEA EAX,[RDX + -0x1]
TEST EDX,EDX
JLE 0x0010119c
CDQE
LEA RSI,[RDI + RAX*0x4]
MOV RAX,RCX
LEA EDI,[RDX + -0x1]
LEA R10,[RCX + RDI*0x4 + 0x4]
LAB_0010118b:
MOV EDI,dword ptr [RSI]
MOV dword ptr [RAX],EDI
SUB RSI,0x4
ADD RAX,0x4
CMP RAX,R10
JNZ 0x0010118b
LAB_0010119c:
CMP EDX,R8D
JGE 0x001011b4
MOVSXD RDX,EDX
LAB_001011a4:
MOV EAX,dword ptr [R9 + RDX*0x4]
MOV dword ptr [RCX + RDX*0x4],EAX
ADD RDX,0x1
CMP R8D,EDX
JG 0x001011a4
LAB_001011b4:
RET | void func0(long param_1,int param_2,int param_3,int4 *param_4)
{
int4 *puVar1;
long lVar2;
int4 *puVar3;
if (0 < param_3) {
puVar3 = (int4 *)(param_1 + (long)(param_3 + -1) * 4);
puVar1 = param_4;
do {
*puVar1 = *puVar3;
puVar3 = puVar3 + -1;
puVar1 = puVar1 + 1;
} while (puVar1 != param_4 + (ulong)(param_3 - 1) + 1);
}
if (param_3 < param_2) {
lVar2 = (long)param_3;
do {
param_4[lVar2] = *(int4 *)(param_1 + lVar2 * 4);
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_2);
}
return;
} |
6,470 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int input[], int n, int k, int output[]) {
int i, j;
for (i = 0, j = k - 1; i < k; i++, j--) {
output[i] = input[j];
}
for (i = k; i < n; i++) {
output[i] = input[i];
}
}
| int main() {
int output1[6], output2[4], output3[5];
int arr1[] = {1, 2, 3, 4, 5, 6};
int arr2[] = {4, 5, 6, 7};
int arr3[] = {9, 8, 7, 6, 5};
func0(arr1, 6, 4, output1);
assert(output1[0] == 4 && output1[1] == 3 && output1[2] == 2 && output1[3] == 1 && output1[4] == 5 && output1[5] == 6);
func0(arr2, 4, 2, output2);
assert(output2[0] == 5 && output2[1] == 4 && output2[2] == 6 && output2[3] == 7);
func0(arr3, 5, 3, output3);
assert(output3[0] == 7 && output3[1] == 8 && output3[2] == 9 && output3[3] == 6 && output3[4] == 5);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rdx),%r9d
test %edx,%edx
jle 1174 <func0+0x34>
movslq %r9d,%rax
mov %r9d,%r9d
lea (%rdi,%rax,4),%r8
lea 0x4(%rcx,%r9,4),%r10
mov %rcx,%rax
xchg %ax,%ax
mov (%r8),%r9d
add $0x4,%rax
sub $0x4,%r8
mov %r9d,-0x4(%rax)
cmp %r10,%rax
jne 1160 <func0+0x20>
cmp %esi,%edx
jge 118e <func0+0x4e>
movslq %edx,%rdx
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rdx,4),%eax
mov %eax,(%rcx,%rdx,4)
add $0x1,%rdx
cmp %edx,%esi
jg 1180 <func0+0x40>
retq
| func0:
endbr64
mov r9, rdi
mov r8d, esi
lea edi, [rdx-1]
test edx, edx
jle short loc_13AA
movsxd rax, edi
mov edi, edi
lea rsi, [r9+rax*4]
lea r10, [rcx+rdi*4+4]
mov rax, rcx
nop word ptr [rax+rax+00h]
loc_1398:
mov edi, [rsi]
add rax, 4
sub rsi, 4
mov [rax-4], edi
cmp rax, r10
jnz short loc_1398
loc_13AA:
cmp edx, r8d
jge short locret_13C8
movsxd rdx, edx
nop word ptr [rax+rax+00h]
loc_13B8:
mov eax, [r9+rdx*4]
mov [rcx+rdx*4], eax
add rdx, 1
cmp r8d, edx
jg short loc_13B8
locret_13C8:
retn | void func0(long long a1, int a2, long long a3, long long a4)
{
unsigned int v6; // edi
int *v7; // rsi
long long v8; // r10
long long v9; // rax
int v10; // edi
v6 = a3 - 1;
if ( (int)a3 > 0 )
{
v7 = (int *)(a1 + 4LL * (int)v6);
v8 = a4 + 4LL * v6 + 4;
v9 = a4;
do
{
v10 = *v7;
v9 += 4LL;
--v7;
*(_DWORD *)(v9 - 4) = v10;
}
while ( v9 != v8 );
}
if ( (int)a3 < a2 )
{
a3 = (int)a3;
do
{
*(_DWORD *)(a4 + 4 * a3) = *(_DWORD *)(a1 + 4 * a3);
++a3;
}
while ( a2 > (int)a3 );
}
} | func0:
ENDBR64
MOV R9,RDI
MOV R8D,ESI
LEA EDI,[RDX + -0x1]
TEST EDX,EDX
JLE 0x001013aa
MOVSXD RAX,EDI
MOV EDI,EDI
LEA RSI,[R9 + RAX*0x4]
LEA R10,[RCX + RDI*0x4 + 0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_00101398:
MOV EDI,dword ptr [RSI]
ADD RAX,0x4
SUB RSI,0x4
MOV dword ptr [RAX + -0x4],EDI
CMP RAX,R10
JNZ 0x00101398
LAB_001013aa:
CMP EDX,R8D
JGE 0x001013c8
MOVSXD RDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV EAX,dword ptr [R9 + RDX*0x4]
MOV dword ptr [RCX + RDX*0x4],EAX
ADD RDX,0x1
CMP R8D,EDX
JG 0x001013b8
LAB_001013c8:
RET | void func0(long param_1,int param_2,int param_3,int4 *param_4)
{
int4 uVar1;
int4 *puVar2;
int4 *puVar3;
long lVar4;
int4 *puVar5;
if (0 < param_3) {
puVar5 = (int4 *)(param_1 + (long)(int)(param_3 - 1U) * 4);
puVar2 = param_4;
do {
uVar1 = *puVar5;
puVar3 = puVar2 + 1;
puVar5 = puVar5 + -1;
*puVar2 = uVar1;
puVar2 = puVar3;
} while (puVar3 != param_4 + (ulong)(param_3 - 1U) + 1);
}
if (param_3 < param_2) {
lVar4 = (long)param_3;
do {
param_4[lVar4] = *(int4 *)(param_1 + lVar4 * 4);
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_2);
}
return;
} |
6,471 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int input[], int n, int k, int output[]) {
int i, j;
for (i = 0, j = k - 1; i < k; i++, j--) {
output[i] = input[j];
}
for (i = k; i < n; i++) {
output[i] = input[i];
}
}
| int main() {
int output1[6], output2[4], output3[5];
int arr1[] = {1, 2, 3, 4, 5, 6};
int arr2[] = {4, 5, 6, 7};
int arr3[] = {9, 8, 7, 6, 5};
func0(arr1, 6, 4, output1);
assert(output1[0] == 4 && output1[1] == 3 && output1[2] == 2 && output1[3] == 1 && output1[4] == 5 && output1[5] == 6);
func0(arr2, 4, 2, output2);
assert(output2[0] == 5 && output2[1] == 4 && output2[2] == 6 && output2[3] == 7);
func0(arr3, 5, 3, output3);
assert(output3[0] == 7 && output3[1] == 8 && output3[2] == 9 && output3[3] == 6 && output3[4] == 5);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rdx),%r9d
test %edx,%edx
jle 1222 <func0+0xe2>
movslq %r9d,%rax
movslq %edx,%r8
lea (%rcx,%r8,4),%r11
lea 0x4(,%rax,4),%r10
neg %r8
shl $0x2,%rax
lea 0x4(%rax,%r8,4),%r8
add %rdi,%r8
cmp %r8,%r11
lea (%rdi,%r10,1),%r8
setbe %r11b
cmp %r8,%rcx
setae %r8b
or %r8b,%r11b
je 12e0 <func0+0x1a0>
cmp $0x3,%r9d
jbe 12e0 <func0+0x1a0>
lea -0x10(%rdi,%r10,1),%rax
mov %edx,%r10d
mov %rcx,%r8
shr $0x2,%r10d
mov %rax,%r11
shl $0x4,%r10
sub %r10,%r11
mov %r11,%r10
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
sub $0x10,%rax
add $0x10,%r8
pshufd $0x1b,%xmm1,%xmm0
movups %xmm0,-0x10(%r8)
cmp %r10,%rax
jne 11b8 <func0+0x78>
mov %edx,%eax
and $0xfffffffc,%eax
sub %eax,%r9d
cmp %eax,%edx
je 1222 <func0+0xe2>
movslq %r9d,%r8
sub $0x1,%r9d
mov (%rdi,%r8,4),%r10d
mov %eax,%r8d
mov %r10d,(%rcx,%r8,4)
lea 0x1(%rax),%r8d
cmp %r8d,%edx
jle 1222 <func0+0xe2>
movslq %r9d,%r9
movslq %r8d,%r8
add $0x2,%eax
lea 0x0(,%r9,4),%r10
mov (%rdi,%r9,4),%r9d
mov %r9d,(%rcx,%r8,4)
cmp %eax,%edx
jle 1222 <func0+0xe2>
mov -0x4(%rdi,%r10,1),%r8d
cltq
mov %r8d,(%rcx,%rax,4)
cmp %esi,%edx
jge 12de <func0+0x19e>
movslq %edx,%rax
lea 0x10(,%rax,4),%r8
lea 0x0(,%rax,4),%r9
lea (%rdi,%r8,1),%r11
lea (%rcx,%r9,1),%r10
add %rdi,%r9
cmp %r11,%r10
setae %r11b
add %rcx,%r8
cmp %r8,%r9
setae %r8b
or %r8b,%r11b
je 12d0 <func0+0x190>
lea -0x1(%rsi),%r8d
sub %edx,%r8d
cmp $0x3,%r8d
jbe 12d0 <func0+0x190>
mov %esi,%r11d
xor %eax,%eax
sub %edx,%r11d
mov %r11d,%r8d
shr $0x2,%r8d
shl $0x4,%r8
xchg %ax,%ax
movdqu (%r9,%rax,1),%xmm2
movups %xmm2,(%r10,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 1280 <func0+0x140>
mov %r11d,%eax
and $0xfffffffc,%eax
add %eax,%edx
cmp %eax,%r11d
je 12de <func0+0x19e>
movslq %edx,%rax
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rcx,%rax,4)
lea 0x1(%rdx),%eax
cmp %esi,%eax
jge 12de <func0+0x19e>
cltq
add $0x2,%edx
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rcx,%rax,4)
cmp %esi,%edx
jge 12de <func0+0x19e>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%eax
mov %eax,(%rcx,%rdx,4)
retq
xchg %ax,%ax
mov (%rdi,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 12d0 <func0+0x190>
retq
mov %r9d,%r9d
add %rdi,%rax
mov %rcx,%r8
lea 0x4(%rcx,%r9,4),%r10
xchg %ax,%ax
mov (%rax),%r9d
add $0x4,%r8
sub $0x4,%rax
mov %r9d,-0x4(%r8)
cmp %r10,%r8
jne 12f0 <func0+0x1b0>
jmpq 1222 <func0+0xe2>
nopl 0x0(%rax)
| func0:
endbr64
mov r8d, esi
mov esi, edx
test edx, edx
jle short loc_11A4
sub edx, 1
cmp edx, 2
jbe short loc_1176
movsxd rax, esi
shl rax, 2
lea r9, [rcx+rax]
cmp rdi, r9
jnb loc_1270
lea r9, [rdi+rax]
cmp rcx, r9
jnb loc_1270
loc_1176:
movsxd rdx, edx
mov rax, rcx
lea r9, ds:0[rdx*4]
lea rdx, [rdi+r9]
lea r10, [rcx+r9+4]
nop dword ptr [rax]
loc_1190:
mov r9d, [rdx]
add rax, 4
sub rdx, 4
mov [rax-4], r9d
cmp rax, r10
jnz short loc_1190
loc_11A4:
cmp esi, r8d
jge locret_1311
loc_11AD:
mov r11d, r8d
sub r11d, esi
lea eax, [r11-1]
cmp eax, 2
jbe loc_1318
movsxd rax, esi
push rbx
lea rdx, ds:0[rax*4]
lea r10, [rcx+rdx]
lea rbx, [rdi+rdx+4]
mov r9, r10
sub r9, rbx
cmp r9, 8
ja short loc_1200
nop dword ptr [rax+00000000h]
loc_11E8:
mov edx, [rdi+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp r8d, eax
jg short loc_11E8
loc_11F7:
pop rbx
retn
loc_1200:
mov r9d, r11d
add rdx, rdi
xor eax, eax
shr r9d, 2
shl r9, 4
loc_1210:
movdqu xmm2, xmmword ptr [rdx+rax]
movups xmmword ptr [r10+rax], xmm2
add rax, 10h
cmp r9, rax
jnz short loc_1210
mov eax, r11d
and eax, 0FFFFFFFCh
add eax, esi
and r11d, 3
jz short loc_11F7
movsxd rdx, eax
mov esi, [rdi+rdx*4]
mov [rcx+rdx*4], esi
lea edx, [rax+1]
cmp edx, r8d
jge short loc_11F7
movsxd rdx, edx
add eax, 2
mov r9d, [rdi+rdx*4]
lea rsi, ds:0[rdx*4]
mov [rcx+rdx*4], r9d
cmp r8d, eax
jle short loc_11F7
mov eax, [rdi+rsi+4]
mov [rcx+rsi+4], eax
pop rbx
retn
loc_1270:
mov r11d, esi
lea rax, [rdi+rax-10h]
mov r9, rcx
shr r11d, 2
mov r10, rax
shl r11, 4
sub r10, r11
nop dword ptr [rax+00000000h]
loc_1290:
movdqu xmm1, xmmword ptr [rax]
sub rax, 10h
add r9, 10h
pshufd xmm0, xmm1, 1Bh
movups xmmword ptr [r9-10h], xmm0
cmp rax, r10
jnz short loc_1290
mov eax, esi
and eax, 0FFFFFFFCh
sub edx, eax
cmp esi, eax
jz loc_11A4
movsxd r11, edx
mov r9d, eax
sub edx, 1
mov r11d, [rdi+r11*4]
lea r10, ds:0[r9*4]
mov [rcx+r9*4], r11d
lea r9d, [rax+1]
cmp esi, r9d
jle loc_11A4
movsxd rdx, edx
add eax, 2
lea r9, ds:0[rdx*4]
mov edx, [rdi+rdx*4]
mov [rcx+r10+4], edx
cmp esi, eax
jle loc_11A4
mov eax, [rdi+r9-4]
mov [rcx+r10+8], eax
cmp esi, r8d
jl loc_11AD
locret_1311:
retn
loc_1318:
movsxd rax, esi
nop dword ptr [rax+rax+00h]
loc_1320:
mov edx, [rdi+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp r8d, eax
jg short loc_1320
retn | void func0(unsigned long long a1, int a2, int a3, unsigned long long a4)
{
unsigned int v6; // edx
long long v7; // rax
unsigned long long v8; // rax
long long v9; // r9
int *v10; // rdx
long long v11; // r10
int v12; // r9d
unsigned int v13; // r11d
long long v14; // rax
long long v15; // rdx
unsigned long long v16; // r10
unsigned long long v17; // rdx
long long v18; // rax
signed int v19; // eax
int v20; // edx
const __m128i *v21; // rax
unsigned long long v22; // r9
const __m128i *v23; // r10
__m128i v24; // xmm1
unsigned int v25; // eax
signed int v26; // edx
long long v27; // r11
int v28; // edx
long long v29; // r10
long long v30; // r9
long long v31; // rax
if ( a3 > 0 )
{
v6 = a3 - 1;
if ( v6 > 2 && ((v7 = 4LL * a3, a1 >= a4 + v7) || a4 >= a1 + v7) )
{
v21 = (const __m128i *)(a1 + v7 - 16);
v22 = a4;
v23 = &v21[-((unsigned int)a3 >> 2)];
do
{
v24 = _mm_loadu_si128(v21--);
v22 += 16LL;
*(__m128i *)(v22 - 16) = _mm_shuffle_epi32(v24, 27);
}
while ( v21 != v23 );
v25 = a3 & 0xFFFFFFFC;
v26 = v6 - (a3 & 0xFFFFFFFC);
if ( a3 != (a3 & 0xFFFFFFFC) )
{
v27 = v26;
v28 = v26 - 1;
v29 = 4LL * v25;
*(_DWORD *)(a4 + v29) = *(_DWORD *)(a1 + 4 * v27);
if ( a3 > (int)(v25 + 1) )
{
v30 = 4LL * v28;
*(_DWORD *)(a4 + v29 + 4) = *(_DWORD *)(a1 + v30);
if ( a3 > (int)(v25 + 2) )
{
*(_DWORD *)(a4 + v29 + 8) = *(_DWORD *)(a1 + v30 - 4);
if ( a3 >= a2 )
return;
goto LABEL_8;
}
}
}
}
else
{
v8 = a4;
v9 = 4LL * (int)v6;
v10 = (int *)(a1 + v9);
v11 = a4 + v9 + 4;
do
{
v12 = *v10;
v8 += 4LL;
--v10;
*(_DWORD *)(v8 - 4) = v12;
}
while ( v8 != v11 );
}
}
if ( a3 >= a2 )
return;
LABEL_8:
v13 = a2 - a3;
if ( (unsigned int)(a2 - a3 - 1) <= 2 )
{
v31 = a3;
do
{
*(_DWORD *)(a4 + 4 * v31) = *(_DWORD *)(a1 + 4 * v31);
++v31;
}
while ( a2 > (int)v31 );
}
else
{
v14 = a3;
v15 = 4LL * a3;
v16 = a4 + v15;
if ( a4 - (a1 + 4) > 8 )
{
v17 = a1 + v15;
v18 = 0LL;
do
{
*(__m128i *)(v16 + v18) = _mm_loadu_si128((const __m128i *)(v17 + v18));
v18 += 16LL;
}
while ( 16LL * (v13 >> 2) != v18 );
v19 = a3 + (v13 & 0xFFFFFFFC);
if ( (v13 & 3) != 0 )
{
*(_DWORD *)(a4 + 4LL * v19) = *(_DWORD *)(a1 + 4LL * v19);
v20 = v19 + 1;
if ( v19 + 1 < a2 )
{
*(_DWORD *)(a4 + 4LL * v20) = *(_DWORD *)(a1 + 4LL * v20);
if ( a2 > v19 + 2 )
*(_DWORD *)(a4 + 4LL * v20 + 4) = *(_DWORD *)(a1 + 4LL * v20 + 4);
}
}
}
else
{
do
{
*(_DWORD *)(a4 + 4 * v14) = *(_DWORD *)(a1 + 4 * v14);
++v14;
}
while ( a2 > (int)v14 );
}
}
} | func0:
ENDBR64
MOV R8D,ESI
MOV ESI,EDX
TEST EDX,EDX
JLE 0x001011a4
SUB EDX,0x1
CMP EDX,0x2
JBE 0x00101176
MOVSXD RAX,ESI
SHL RAX,0x2
LEA R9,[RCX + RAX*0x1]
CMP RDI,R9
JNC 0x00101270
LEA R9,[RDI + RAX*0x1]
CMP RCX,R9
JNC 0x00101270
LAB_00101176:
MOVSXD RDX,EDX
MOV RAX,RCX
LEA R9,[RDX*0x4]
LEA RDX,[RDI + R9*0x1]
LEA R10,[RCX + R9*0x1 + 0x4]
NOP dword ptr [RAX]
LAB_00101190:
MOV R9D,dword ptr [RDX]
ADD RAX,0x4
SUB RDX,0x4
MOV dword ptr [RAX + -0x4],R9D
CMP RAX,R10
JNZ 0x00101190
LAB_001011a4:
CMP ESI,R8D
JGE 0x00101311
LAB_001011ad:
MOV R11D,R8D
SUB R11D,ESI
LEA EAX,[R11 + -0x1]
CMP EAX,0x2
JBE 0x00101318
MOVSXD RAX,ESI
PUSH RBX
LEA RDX,[RAX*0x4]
LEA R10,[RCX + RDX*0x1]
LEA RBX,[RDI + RDX*0x1 + 0x4]
MOV R9,R10
SUB R9,RBX
CMP R9,0x8
JA 0x00101200
NOP dword ptr [RAX]
LAB_001011e8:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP R8D,EAX
JG 0x001011e8
LAB_001011f7:
POP RBX
RET
LAB_00101200:
MOV R9D,R11D
ADD RDX,RDI
XOR EAX,EAX
SHR R9D,0x2
SHL R9,0x4
LAB_00101210:
MOVDQU XMM2,xmmword ptr [RDX + RAX*0x1]
MOVUPS xmmword ptr [R10 + RAX*0x1],XMM2
ADD RAX,0x10
CMP R9,RAX
JNZ 0x00101210
MOV EAX,R11D
AND EAX,0xfffffffc
ADD EAX,ESI
AND R11D,0x3
JZ 0x001011f7
MOVSXD RDX,EAX
MOV ESI,dword ptr [RDI + RDX*0x4]
MOV dword ptr [RCX + RDX*0x4],ESI
LEA EDX,[RAX + 0x1]
CMP EDX,R8D
JGE 0x001011f7
MOVSXD RDX,EDX
ADD EAX,0x2
MOV R9D,dword ptr [RDI + RDX*0x4]
LEA RSI,[RDX*0x4]
MOV dword ptr [RCX + RDX*0x4],R9D
CMP R8D,EAX
JLE 0x001011f7
MOV EAX,dword ptr [RDI + RSI*0x1 + 0x4]
MOV dword ptr [RCX + RSI*0x1 + 0x4],EAX
POP RBX
RET
LAB_00101270:
MOV R11D,ESI
LEA RAX,[RDI + RAX*0x1 + -0x10]
MOV R9,RCX
SHR R11D,0x2
MOV R10,RAX
SHL R11,0x4
SUB R10,R11
NOP dword ptr [RAX]
LAB_00101290:
MOVDQU XMM1,xmmword ptr [RAX]
SUB RAX,0x10
ADD R9,0x10
PSHUFD XMM0,XMM1,0x1b
MOVUPS xmmword ptr [R9 + -0x10],XMM0
CMP RAX,R10
JNZ 0x00101290
MOV EAX,ESI
AND EAX,0xfffffffc
SUB EDX,EAX
CMP ESI,EAX
JZ 0x001011a4
MOVSXD R11,EDX
MOV R9D,EAX
SUB EDX,0x1
MOV R11D,dword ptr [RDI + R11*0x4]
LEA R10,[R9*0x4]
MOV dword ptr [RCX + R9*0x4],R11D
LEA R9D,[RAX + 0x1]
CMP ESI,R9D
JLE 0x001011a4
MOVSXD RDX,EDX
ADD EAX,0x2
LEA R9,[RDX*0x4]
MOV EDX,dword ptr [RDI + RDX*0x4]
MOV dword ptr [RCX + R10*0x1 + 0x4],EDX
CMP ESI,EAX
JLE 0x001011a4
MOV EAX,dword ptr [RDI + R9*0x1 + -0x4]
MOV dword ptr [RCX + R10*0x1 + 0x8],EAX
CMP ESI,R8D
JL 0x001011ad
LAB_00101311:
RET
LAB_00101318:
MOVSXD RAX,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101320:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP R8D,EAX
JG 0x00101320
RET | void func0(int4 *param_1,int param_2,uint param_3,int4 *param_4)
{
int iVar1;
int8 *puVar2;
int8 *puVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 *puVar7;
int8 uVar8;
int iVar9;
uint uVar10;
int4 *puVar11;
int4 *puVar12;
long lVar13;
int4 *puVar14;
long lVar15;
uint uVar16;
if (0 < (int)param_3) {
uVar16 = param_3 - 1;
if ((uVar16 < 3) || ((param_1 < param_4 + (int)param_3 && (param_4 < param_1 + (int)param_3))))
{
puVar14 = param_1 + (int)uVar16;
puVar11 = param_4;
do {
uVar4 = *puVar14;
puVar12 = puVar11 + 1;
puVar14 = puVar14 + -1;
*puVar11 = uVar4;
puVar11 = puVar12;
} while (puVar12 != param_4 + (long)(int)uVar16 + 1);
}
else {
puVar14 = param_1 + (long)(int)param_3 + -4;
puVar12 = puVar14 + (ulong)(param_3 >> 2) * -4;
puVar11 = param_4;
do {
uVar4 = *puVar14;
uVar5 = puVar14[1];
uVar6 = puVar14[2];
puVar7 = puVar14 + 3;
puVar14 = puVar14 + -4;
*puVar11 = *puVar7;
puVar11[1] = uVar6;
puVar11[2] = uVar5;
puVar11[3] = uVar4;
puVar11 = puVar11 + 4;
} while (puVar14 != puVar12);
uVar10 = param_3 & 0xfffffffc;
if (param_3 != uVar10) {
param_4[uVar10] = param_1[(int)(uVar16 - uVar10)];
if ((int)(uVar10 + 1) < (int)param_3) {
lVar15 = (long)(int)((uVar16 - uVar10) + -1);
param_4[(ulong)uVar10 + 1] = param_1[lVar15];
if ((int)(uVar10 + 2) < (int)param_3) {
param_4[(ulong)uVar10 + 2] = param_1[lVar15 + -1];
}
}
}
}
}
if ((int)param_3 < param_2) {
uVar16 = param_2 - param_3;
if (uVar16 - 1 < 3) {
lVar15 = (long)(int)param_3;
do {
param_4[lVar15] = param_1[lVar15];
lVar15 = lVar15 + 1;
} while ((int)lVar15 < param_2);
return;
}
lVar13 = (long)(int)param_3;
lVar15 = lVar13 * 4;
if ((ulong)((long)param_4 + (lVar15 - (long)(param_1 + lVar13 + 1))) < 9) {
do {
param_4[lVar13] = param_1[lVar13];
lVar13 = lVar13 + 1;
} while ((int)lVar13 < param_2);
}
else {
lVar13 = 0;
do {
puVar2 = (int8 *)((long)param_1 + lVar13 + lVar15);
uVar8 = puVar2[1];
puVar3 = (int8 *)((long)param_4 + lVar13 + lVar15);
*puVar3 = *puVar2;
puVar3[1] = uVar8;
lVar13 = lVar13 + 0x10;
} while ((ulong)(uVar16 >> 2) << 4 != lVar13);
iVar9 = (uVar16 & 0xfffffffc) + param_3;
if ((uVar16 & 3) != 0) {
param_4[iVar9] = param_1[iVar9];
iVar1 = iVar9 + 1;
if (iVar1 < param_2) {
param_4[iVar1] = param_1[iVar1];
if (iVar9 + 2 < param_2) {
param_4[(long)iVar1 + 1] = param_1[(long)iVar1 + 1];
return;
}
}
}
}
return;
}
return;
} |
6,472 | func0 | #include <assert.h>
int get_product(int val[], int n) {
int res = 1;
for (int i = 0; i < n; i++) {
res *= val[i];
}
return res;
}
| int func0(int test_list[][3], int rows, int K) {
int temp[rows];
for (int i = 0; i < rows; i++) {
temp[i] = test_list[i][K];
}
return get_product(temp, rows);
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
assert(func0(test_list1, 3, 2) == 665);
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
assert(func0(test_list2, 3, 1) == 280);
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list3, 3, 0) == 210);
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 %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rcx
sub %rdx,%rcx
mov %rcx,%rdx
cmp %rdx,%rsp
je 125b <func0+0xa3>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1244 <func0+0x8c>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1285 <func0+0xcd>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 12d7 <func0+0x11f>
mov -0x2c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov -0x40(%rbp),%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 12a1 <func0+0xe9>
mov -0x3c(%rbp),%edx
mov -0x20(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1169 <get_product>
mov %rbx,%rsp
mov -0x18(%rbp),%rsi
xor %fs:0x28,%rsi
je 1307 <func0+0x14f>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
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 rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov esi, 10h
mov edx, 0
div rsi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_1229:
cmp rsp, rdx
jz short loc_1240
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_1229
loc_1240:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_126A
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_126A:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_2C], 0
jmp short loc_12BC
loc_1286:
mov eax, [rbp+var_2C]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_38]
add rdx, rax
mov eax, [rbp+var_40]
cdqe
mov ecx, [rdx+rax*4]
mov rax, [rbp+var_20]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_2C], 1
loc_12BC:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_3C]
jl short loc_1286
mov edx, [rbp+var_3C]
mov rax, [rbp+var_20]
mov esi, edx
mov rdi, rax
call get_product
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_12EC
call ___stack_chk_fail
loc_12EC:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, unsigned int a2, int a3)
{
unsigned long long v3; // rax
void *v4; // rsp
int v6; // [rsp+8h] [rbp-40h] BYREF
unsigned int v7; // [rsp+Ch] [rbp-3Ch]
long long v8; // [rsp+10h] [rbp-38h]
int i; // [rsp+1Ch] [rbp-2Ch]
long long v10; // [rsp+20h] [rbp-28h]
int *v11; // [rsp+28h] [rbp-20h]
unsigned long long v12; // [rsp+30h] [rbp-18h]
v8 = a1;
v7 = a2;
v6 = a3;
v12 = __readfsqword(0x28u);
v10 = (int)a2 - 1LL;
v3 = 16 * ((4LL * (int)a2 + 15) / 0x10uLL);
while ( &v6 != (int *)((char *)&v6 - (v3 & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = alloca(v3 & 0xFFF);
if ( (v3 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v6 + (v3 & 0xFFF) - 8) = *(_QWORD *)((char *)&v6 + (v3 & 0xFFF) - 8);
v11 = &v6;
for ( i = 0; i < (int)v7; ++i )
v11[i] = *(_DWORD *)(v8 + 12LL * i + 4LL * v6);
return get_product(v11, v7);
} | 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 RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV ESI,0x10
MOV EDX,0x0
DIV RSI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_00101229:
CMP RSP,RDX
JZ 0x00101240
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101229
LAB_00101240:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010126a
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010126a:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001012bc
LAB_00101286:
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x40]
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x2c],0x1
LAB_001012bc:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101286
MOV EDX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101169
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012ec
CALL 0x00101060
LAB_001012ec:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void func0(long param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
int *piVar4;
long in_FS_OFFSET;
int local_48;
int local_44;
long local_40;
int local_34;
long local_30;
int *local_28;
long local_20;
local_40 = param_1;
local_44 = param_2;
local_48 = param_3;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = (long)param_2 + -1;
uVar3 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (piVar4 = &local_48; piVar4 != (int *)((long)&local_48 - (uVar3 & 0xfffffffffffff000));
piVar4 = (int *)((long)piVar4 + -0x1000)) {
*(int8 *)((long)piVar4 + -8) = *(int8 *)((long)piVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
iVar2 = local_44;
for (local_34 = 0; local_34 < local_44; local_34 = local_34 + 1) {
*(int4 *)((long)piVar4 + (long)local_34 * 4 + lVar1) =
*(int4 *)((long)local_34 * 0xc + local_40 + (long)local_48 * 4);
}
local_28 = (int *)((long)piVar4 + lVar1);
*(int8 *)((long)piVar4 + lVar1 + -8) = 0x1012d5;
get_product((long)piVar4 + lVar1,iVar2);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
} |
6,473 | func0 | #include <assert.h>
int get_product(int val[], int n) {
int res = 1;
for (int i = 0; i < n; i++) {
res *= val[i];
}
return res;
}
| int func0(int test_list[][3], int rows, int K) {
int temp[rows];
for (int i = 0; i < rows; i++) {
temp[i] = test_list[i][K];
}
return get_product(temp, rows);
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
assert(func0(test_list1, 3, 2) == 665);
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
assert(func0(test_list2, 3, 1) == 280);
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list3, 3, 0) == 210);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
and $0xfffffffffffffff0,%rcx
and $0xfffffffffffff000,%rax
mov %rsp,%r9
sub %rax,%r9
mov %r9,%rax
cmp %rax,%rsp
je 11ea <func0+0x53>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11d3 <func0+0x3c>
mov %rcx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1200 <func0+0x69>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r8
test %esi,%esi
jle 122a <func0+0x93>
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rdx
mov %r8,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%r8,%rcx,4),%rdi
mov (%rdx),%ecx
mov %ecx,(%rax)
add $0xc,%rdx
add $0x4,%rax
cmp %rdi,%rax
jne 1219 <func0+0x82>
mov %r8,%rdi
callq 1169 <get_product>
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 1243 <func0+0xac>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r9, rdi
mov edi, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rsi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rax
loc_11D5:
cmp rsp, rcx
jz short loc_11EC
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11D5
loc_11EC:
mov rax, rsi
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1202
or [rsp+rax+10h+var_18], 0
loc_1202:
mov r8, rsp
test edi, edi
jle short loc_122A
movsxd rdx, edx
lea rdx, [r9+rdx*4]
mov rax, r8
mov ecx, edi
lea rsi, [r8+rcx*4]
loc_1219:
mov ecx, [rdx]
mov [rax], ecx
add rdx, 0Ch
add rax, 4
cmp rax, rsi
jnz short loc_1219
loc_122A:
mov esi, edi
mov rdi, r8
call get_product
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1245
leave
retn
loc_1245:
call ___stack_chk_fail | long long func0(long long a1, int a2, int a3)
{
long long v5; // rax
__int16 v6; // si
signed long long v7; // rax
void *v8; // rsp
_DWORD *v9; // rdx
_DWORD *v10; // rax
_DWORD v13[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v14; // [rsp+10h] [rbp-8h]
v14 = __readfsqword(0x28u);
v5 = 4LL * a2 + 15;
v6 = (4 * a2 + 15) & 0xFFF0;
while ( v13 != (_DWORD *)((char *)v13 - (v5 & 0xFFFFFFFFFFFFF000LL)) )
;
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( (v6 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v13[-2] + v7) = *(_QWORD *)((char *)&v13[-2] + v7);
if ( a2 > 0 )
{
v9 = (_DWORD *)(a1 + 4LL * a3);
v10 = v13;
do
{
*v10 = *v9;
v9 += 3;
++v10;
}
while ( v10 != &v13[a2] );
}
return get_product(v13, (unsigned int)a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9,RDI
MOV EDI,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
AND RSI,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001011d5:
CMP RSP,RCX
JZ 0x001011ec
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d5
LAB_001011ec:
MOV RAX,RSI
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101202
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101202:
MOV R8,RSP
TEST EDI,EDI
JLE 0x0010122a
MOVSXD RDX,EDX
LEA RDX,[R9 + RDX*0x4]
MOV RAX,R8
MOV ECX,EDI
LEA RSI,[R8 + RCX*0x4]
LAB_00101219:
MOV ECX,dword ptr [RDX]
MOV dword ptr [RAX],ECX
ADD RDX,0xc
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101219
LAB_0010122a:
MOV ESI,EDI
MOV RDI,R8
CALL 0x00101169
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101245
LEAVE
RET
LAB_00101245:
CALL 0x00101060 | void func0(long param_1,uint param_2,int param_3)
{
long lVar1;
ulong uVar2;
int4 *puVar3;
int4 *puVar4;
int1 *puVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = (long)(int)param_2 * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 + -(uVar2 & 0xfffffffffffff000);
puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
uVar2 = (ulong)((uint)uVar2 & 0xff0);
lVar1 = -uVar2;
puVar3 = (int4 *)(puVar5 + lVar1);
if (uVar2 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
if (0 < (int)param_2) {
puVar4 = (int4 *)(param_1 + (long)param_3 * 4);
do {
*puVar3 = *puVar4;
puVar4 = puVar4 + 3;
puVar3 = puVar3 + 1;
} while (puVar3 != (int4 *)(puVar5 + (ulong)param_2 * 4 + lVar1));
}
*(int8 *)(puVar5 + lVar1 + -8) = 0x101234;
get_product((long)puVar5 + lVar1,param_2);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar5 + lVar1 + -8) = main;
__stack_chk_fail();
} |
6,474 | func0 | #include <assert.h>
int get_product(int val[], int n) {
int res = 1;
for (int i = 0; i < n; i++) {
res *= val[i];
}
return res;
}
| int func0(int test_list[][3], int rows, int K) {
int temp[rows];
for (int i = 0; i < rows; i++) {
temp[i] = test_list[i][K];
}
return get_product(temp, rows);
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
assert(func0(test_list1, 3, 2) == 665);
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
assert(func0(test_list2, 3, 1) == 280);
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list3, 3, 0) == 210);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%r9
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
and $0xfffffffffffff000,%rax
sub %rax,%r9
and $0xfffffffffffffff0,%rcx
mov %r9,%rax
cmp %rax,%rsp
je 11e6 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 11d1 <func0+0x41>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 1258 <func0+0xc8>
mov %rsp,%rax
test %esi,%esi
jle 1260 <func0+0xd0>
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rcx
lea -0x1(%rsi),%edx
lea 0x4(%rax,%rdx,4),%rsi
mov %rax,%rdx
nopl (%rax)
mov (%rcx),%edi
add $0x4,%rdx
add $0xc,%rcx
mov %edi,-0x4(%rdx)
cmp %rsi,%rdx
jne 1210 <func0+0x80>
mov $0x1,%r8d
nopl 0x0(%rax,%rax,1)
imul (%rax),%r8d
add $0x4,%rax
cmp %rsi,%rax
jne 1230 <func0+0xa0>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 1268 <func0+0xd8>
leaveq
mov %r8d,%eax
retq
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rcx,1)
jmp 11f4 <func0+0x64>
mov $0x1,%r8d
jmp 123d <func0+0xad>
callq 1050 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push rbp
mov rcx, rdi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
mov r8, rsp
lea rax, ds:0Fh[rax*4]
mov rdi, rax
and rax, 0FFFFFFFFFFFFF000h
sub r8, rax
and rdi, 0FFFFFFFFFFFFFFF0h
cmp rsp, r8
jz short loc_13B6
loc_13A1:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, r8
jnz short loc_13A1
loc_13B6:
and edi, 0FFFh
sub rsp, rdi
test rdi, rdi
jnz short loc_1428
loc_13C4:
mov rax, rsp
test esi, esi
jle short loc_1430
movsxd rdx, edx
mov esi, esi
lea rcx, [rcx+rdx*4]
lea rsi, [rax+rsi*4]
mov rdx, rax
nop dword ptr [rax+rax+00h]
loc_13E0:
mov edi, [rcx]
add rdx, 4
add rcx, 0Ch
mov [rdx-4], edi
cmp rdx, rsi
jnz short loc_13E0
mov r8d, 1
nop dword ptr [rax+rax+00000000h]
loc_1400:
imul r8d, [rax]
add rax, 4
cmp rax, rsi
jnz short loc_1400
loc_140D:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_1438
leave
mov eax, r8d
retn
loc_1428:
or [rsp+rdi+1010h+var_1018], 0
jmp short loc_13C4
loc_1430:
mov r8d, 1
jmp short loc_140D
loc_1438:
call ___stack_chk_fail | long long func0(long long a1, int a2, int a3)
{
long long v4; // rdi
_DWORD *v5; // r8
__int16 v6; // di
signed long long v7; // rdi
void *v8; // rsp
_DWORD *v9; // rax
int *v10; // rcx
_DWORD *v11; // rsi
_DWORD *v12; // rdx
int v13; // edi
unsigned int v14; // r8d
_DWORD v17[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v18[2]; // [rsp+1008h] [rbp-10h] BYREF
v18[1] = __readfsqword(0x28u);
v4 = 4LL * a2 + 15;
v5 = (_DWORD *)((char *)v18 - (v4 & 0xFFFFFFFFFFFFF000LL));
v6 = v4 & 0xFFF0;
if ( v18 != (_QWORD *)v5 )
{
while ( v17 != v5 )
;
}
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( v7 )
*(_QWORD *)((char *)&v17[-2] + v7) = *(_QWORD *)((char *)&v17[-2] + v7);
v9 = v17;
if ( a2 <= 0 )
{
return 1;
}
else
{
v10 = (int *)(a1 + 4LL * a3);
v11 = &v17[a2];
v12 = v17;
do
{
v13 = *v10;
++v12;
v10 += 3;
*(v12 - 1) = v13;
}
while ( v12 != v11 );
v14 = 1;
do
v14 *= *v9++;
while ( v9 != v11 );
}
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV RCX,RDI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV R8,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDI,RAX
AND RAX,-0x1000
SUB R8,RAX
AND RDI,-0x10
CMP RSP,R8
JZ 0x001013b6
LAB_001013a1:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,R8
JNZ 0x001013a1
LAB_001013b6:
AND EDI,0xfff
SUB RSP,RDI
TEST RDI,RDI
JNZ 0x00101428
LAB_001013c4:
MOV RAX,RSP
TEST ESI,ESI
JLE 0x00101430
MOVSXD RDX,EDX
MOV ESI,ESI
LEA RCX,[RCX + RDX*0x4]
LEA RSI,[RAX + RSI*0x4]
MOV RDX,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV EDI,dword ptr [RCX]
ADD RDX,0x4
ADD RCX,0xc
MOV dword ptr [RDX + -0x4],EDI
CMP RDX,RSI
JNZ 0x001013e0
MOV R8D,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101400:
IMUL R8D,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101400
LAB_0010140d:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101438
LEAVE
MOV EAX,R8D
RET
LAB_00101428:
OR qword ptr [RSP + RDI*0x1 + -0x8],0x0
JMP 0x001013c4
LAB_00101430:
MOV R8D,0x1
JMP 0x0010140d
LAB_00101438:
CALL 0x00101060 | int func0(long param_1,uint param_2,int param_3)
{
long lVar1;
int1 *puVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int1 *puVar7;
ulong uVar9;
int iVar10;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar9 = (long)(int)param_2 * 4 + 0xf;
puVar8 = auStack_18;
puVar2 = auStack_18;
while (puVar8 != auStack_18 + -(uVar9 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar1 = -uVar9;
piVar3 = (int *)(puVar7 + lVar1);
if (uVar9 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if ((int)param_2 < 1) {
iVar10 = 1;
}
else {
piVar4 = (int *)(param_1 + (long)param_3 * 4);
piVar5 = (int *)(puVar7 + lVar1);
do {
iVar10 = *piVar4;
piVar6 = piVar5 + 1;
piVar4 = piVar4 + 3;
*piVar5 = iVar10;
piVar5 = piVar6;
} while (piVar6 != (int *)(puVar7 + (ulong)param_2 * 4 + lVar1));
iVar10 = 1;
do {
iVar10 = iVar10 * *piVar3;
piVar3 = piVar3 + 1;
} while (piVar3 != (int *)(puVar7 + (ulong)param_2 * 4 + lVar1));
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x10143d;
__stack_chk_fail();
}
return iVar10;
} |
6,475 | func0 | #include <assert.h>
int get_product(int val[], int n) {
int res = 1;
for (int i = 0; i < n; i++) {
res *= val[i];
}
return res;
}
| int func0(int test_list[][3], int rows, int K) {
int temp[rows];
for (int i = 0; i < rows; i++) {
temp[i] = test_list[i][K];
}
return get_product(temp, rows);
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
assert(func0(test_list1, 3, 2) == 665);
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
assert(func0(test_list2, 3, 1) == 280);
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list3, 3, 0) == 210);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%r11
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
and $0xfffffffffffff000,%rax
sub %rax,%r11
and $0xfffffffffffffff0,%rcx
mov %r11,%rax
cmp %rax,%rsp
je 1296 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1281 <func0+0x41>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 1420 <func0+0x1e0>
mov %rsp,%rcx
test %esi,%esi
jle 142b <func0+0x1eb>
lea -0x1(%rsi),%r10d
cmp $0x2,%r10d
jbe 1433 <func0+0x1f3>
mov %esi,%r8d
movslq %edx,%r9
mov %rcx,%rdx
shr $0x2,%r8d
lea (%rdi,%r9,4),%rax
shl $0x4,%r8
add %rcx,%r8
nopl 0x0(%rax)
movd 0x18(%rax),%xmm1
movd 0x24(%rax),%xmm3
add $0x10,%rdx
add $0x30,%rax
movd -0x30(%rax),%xmm0
movd -0x24(%rax),%xmm4
punpckldq %xmm3,%xmm1
punpckldq %xmm4,%xmm0
punpcklqdq %xmm1,%xmm0
movups %xmm0,-0x10(%rdx)
cmp %r8,%rdx
jne 12e0 <func0+0xa0>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 1353 <func0+0x113>
movslq %eax,%rdx
lea (%rdi,%r9,4),%rdi
lea (%rdx,%rdx,2),%r8
lea (%rdi,%r8,4),%rdi
mov (%rdi),%r8d
mov %r8d,(%rcx,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%esi
jle 1353 <func0+0x113>
mov 0xc(%rdi),%r8d
movslq %edx,%rdx
add $0x2,%eax
mov %r8d,(%rcx,%rdx,4)
cmp %eax,%esi
jle 1353 <func0+0x113>
mov 0x18(%rdi),%edx
cltq
mov %edx,(%rcx,%rax,4)
cmp $0x1c,%r10d
jbe 143d <func0+0x1fd>
mov %esi,%edx
movdqa 0xca9(%rip),%xmm1
mov %rcx,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rcx,%rdx
nopl 0x0(%rax)
movdqu (%rax),%xmm2
movdqu (%rax),%xmm0
add $0x10,%rax
pmuludq %xmm1,%xmm2
psrlq $0x20,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm1,%xmm0
pshufd $0x8,%xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
cmp %rdx,%rax
jne 1378 <func0+0x138>
movdqa %xmm1,%xmm2
movdqa %xmm1,%xmm0
mov %esi,%eax
psrldq $0x8,%xmm2
psrlq $0x20,%xmm1
and $0xfffffffc,%eax
pmuludq %xmm2,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
pmuludq %xmm1,%xmm0
movd %xmm0,%r8d
test $0x3,%sil
je 1405 <func0+0x1c5>
cltq
nopl (%rax)
imul (%rcx,%rax,4),%r8d
add $0x1,%rax
cmp %eax,%esi
jg 13f8 <func0+0x1b8>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 1447 <func0+0x207>
leaveq
mov %r8d,%eax
retq
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rcx,1)
jmpq 12a8 <func0+0x68>
mov $0x1,%r8d
jmp 1405 <func0+0x1c5>
xor %eax,%eax
movslq %edx,%r9
jmpq 131c <func0+0xdc>
mov $0x1,%r8d
xor %eax,%eax
jmp 13f3 <func0+0x1b3>
callq 1050 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov r9, rdi
mov ecx, esi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
mov rdi, rsp
lea rax, ds:0Fh[rax*4]
mov rsi, rax
and rax, 0FFFFFFFFFFFFF000h
sub rdi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdi
jz short loc_12C8
loc_12B3:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rdi
jnz short loc_12B3
loc_12C8:
and esi, 0FFFh
sub rsp, rsi
test rsi, rsi
jnz loc_1488
loc_12DA:
mov rdi, rsp
test ecx, ecx
jle loc_1493
lea r10d, [rcx-1]
cmp r10d, 3
jbe loc_149A
mov esi, r10d
movsxd r8, edx
mov rdx, rdi
shr esi, 2
lea rax, [r9+r8*4]
shl rsi, 4
add rsi, rdi
nop word ptr [rax+rax+00h]
loc_1310:
movdqu xmm3, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
add rdx, 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 ; '$'
movups xmmword ptr [rdx-10h], xmm0
cmp rdx, rsi
jnz short loc_1310
mov eax, r10d
and eax, 0FFFFFFFCh
loc_1349:
movsxd rdx, eax
lea rsi, [rdx+rdx*2]
lea rdx, [rdi+rdx*4]
lea rsi, [r9+rsi*4]
lea rsi, [rsi+r8*4]
mov r8d, [rsi]
mov [rdx], r8d
lea r8d, [rax+1]
cmp ecx, r8d
jle short loc_1391
mov r8d, [rsi+0Ch]
mov [rdx+4], r8d
lea r8d, [rax+2]
cmp ecx, r8d
jle short loc_1391
mov r8d, [rsi+18h]
add eax, 3
mov [rdx+8], r8d
cmp ecx, eax
jle short loc_1391
mov eax, [rsi+24h]
mov [rdx+0Ch], eax
loc_1391:
cmp r10d, 1Ah
jbe loc_14A4
mov edx, ecx
movdqa xmm1, cs:xmmword_2010
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_13B8:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pmuludq xmm2, xmm1
psrlq xmm0, 20h ; ' '
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm1
pshufd xmm1, xmm2, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
cmp rax, rdx
jnz short loc_13B8
movdqa xmm0, xmm1
psrldq xmm0, 8
movdqa xmm2, xmm0
psrlq xmm0, 20h ; ' '
pmuludq xmm2, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm1
pshufd xmm1, xmm2, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
pmuludq xmm0, xmm1
movd edx, xmm0
test cl, 3
jz short loc_1471
mov eax, ecx
and eax, 0FFFFFFFCh
loc_1431:
cdqe
mov rsi, rax
imul edx, [rdi+rax*4]
add rax, 1
not rsi
add esi, ecx
and esi, 1
cmp ecx, eax
jle short loc_1471
test esi, esi
jz short loc_1460
imul edx, [rdi+rax*4]
add rax, 1
cmp ecx, eax
jle short loc_1471
nop word ptr [rax+rax+00h]
loc_1460:
imul edx, [rdi+rax*4]
imul edx, [rdi+rax*4+4]
add rax, 2
cmp ecx, eax
jg short loc_1460
loc_1471:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_14AD
leave
mov eax, edx
retn
loc_1488:
or [rsp+rsi+1010h+var_1018], 0
jmp loc_12DA
loc_1493:
mov edx, 1
jmp short loc_1471
loc_149A:
xor eax, eax
movsxd r8, edx
jmp loc_1349
loc_14A4:
mov edx, 1
xor eax, eax
jmp short loc_1431
loc_14AD:
call ___stack_chk_fail | long long func0(long long a1, int a2, int a3)
{
long long v5; // rsi
_DWORD *v6; // rdi
__int16 v7; // si
signed long long v8; // rsi
void *v9; // rsp
unsigned int v10; // r10d
long long v11; // r8
__m128 *v12; // rdx
const __m128i *v13; // rax
__m128 v14; // xmm3
__m128 v15; // xmm1
__m128 v16; // xmm0
signed int v17; // eax
_DWORD *v18; // rdx
_DWORD *v19; // rsi
__m128i si128; // xmm1
const __m128i *v21; // rax
__m128i v22; // xmm2
__m128i v23; // xmm2
__m128i v24; // xmm1
unsigned int v25; // edx
int v26; // eax
char v27; // si
long long v28; // rax
int v29; // esi
_DWORD v32[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v33[2]; // [rsp+1008h] [rbp-10h] BYREF
v33[1] = __readfsqword(0x28u);
v5 = 4LL * a2 + 15;
v6 = (_DWORD *)((char *)v33 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( v33 != (_QWORD *)v6 )
{
while ( v32 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v32[-2] + v8) = *(_QWORD *)((char *)&v32[-2] + v8);
if ( a2 <= 0 )
return 1;
v10 = a2 - 1;
if ( (unsigned int)(a2 - 1) <= 3 )
{
v17 = 0;
v11 = a3;
}
else
{
v11 = a3;
v12 = (__m128 *)v32;
v13 = (const __m128i *)(a1 + 4 * v11);
do
{
v14 = (__m128)_mm_loadu_si128(v13);
v15 = (__m128)_mm_loadu_si128(v13 + 1);
++v12;
v13 += 3;
v16 = _mm_shuffle_ps(v14, _mm_shuffle_ps(v15, v14, 10), 140);
v12[-1] = _mm_shuffle_ps(v16, _mm_shuffle_ps((__m128)_mm_loadu_si128(v13 - 1), v16, 165), 36);
}
while ( v12 != (__m128 *)&v32[4 * (v10 >> 2)] );
v17 = v10 & 0xFFFFFFFC;
}
v18 = &v32[v17];
v19 = (_DWORD *)(a1 + 12LL * v17 + 4 * v11);
*v18 = *v19;
if ( a2 > v17 + 1 )
{
v18[1] = v19[3];
if ( a2 > v17 + 2 )
{
v18[2] = v19[6];
if ( a2 > v17 + 3 )
v18[3] = v19[9];
}
}
if ( v10 <= 0x1A )
{
v25 = 1;
v26 = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v21 = (const __m128i *)v32;
do
{
v22 = _mm_loadu_si128(v21++);
si128 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v22, si128), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v22, 0x20u), _mm_srli_epi64(si128, 0x20u)), 8));
}
while ( v21 != (const __m128i *)&v32[4 * ((unsigned int)a2 >> 2)] );
v23 = _mm_srli_si128(si128, 8);
v24 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v23, si128), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v23, 0x20u), _mm_srli_epi64(si128, 0x20u)), 8));
v25 = _mm_cvtsi128_si32(_mm_mul_epu32(_mm_srli_si128(v24, 4), v24));
if ( (a2 & 3) == 0 )
return v25;
v26 = a2 & 0x7FFFFFFC;
}
v27 = v26;
v25 *= v32[v26];
v28 = v26 + 1LL;
v29 = ((_BYTE)a2 + ~v27) & 1;
if ( a2 > (int)v28 )
{
if ( !v29 || (v25 *= v32[v28], ++v28, a2 > (int)v28) )
{
do
{
v25 *= v32[v28 + 1] * v32[v28];
v28 += 2LL;
}
while ( a2 > (int)v28 );
}
}
return v25;
} | func0:
ENDBR64
PUSH RBP
MOV R9,RDI
MOV ECX,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RDI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
AND RAX,-0x1000
SUB RDI,RAX
AND RSI,-0x10
CMP RSP,RDI
JZ 0x001012c8
LAB_001012b3:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDI
JNZ 0x001012b3
LAB_001012c8:
AND ESI,0xfff
SUB RSP,RSI
TEST RSI,RSI
JNZ 0x00101488
LAB_001012da:
MOV RDI,RSP
TEST ECX,ECX
JLE 0x00101493
LEA R10D,[RCX + -0x1]
CMP R10D,0x3
JBE 0x0010149a
MOV ESI,R10D
MOVSXD R8,EDX
MOV RDX,RDI
SHR ESI,0x2
LEA RAX,[R9 + R8*0x4]
SHL RSI,0x4
ADD RSI,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101310:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
ADD RDX,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
MOVUPS xmmword ptr [RDX + -0x10],XMM0
CMP RDX,RSI
JNZ 0x00101310
MOV EAX,R10D
AND EAX,0xfffffffc
LAB_00101349:
MOVSXD RDX,EAX
LEA RSI,[RDX + RDX*0x2]
LEA RDX,[RDI + RDX*0x4]
LEA RSI,[R9 + RSI*0x4]
LEA RSI,[RSI + R8*0x4]
MOV R8D,dword ptr [RSI]
MOV dword ptr [RDX],R8D
LEA R8D,[RAX + 0x1]
CMP ECX,R8D
JLE 0x00101391
MOV R8D,dword ptr [RSI + 0xc]
MOV dword ptr [RDX + 0x4],R8D
LEA R8D,[RAX + 0x2]
CMP ECX,R8D
JLE 0x00101391
MOV R8D,dword ptr [RSI + 0x18]
ADD EAX,0x3
MOV dword ptr [RDX + 0x8],R8D
CMP ECX,EAX
JLE 0x00101391
MOV EAX,dword ptr [RSI + 0x24]
MOV dword ptr [RDX + 0xc],EAX
LAB_00101391:
CMP R10D,0x1a
JBE 0x001014a4
MOV EDX,ECX
MOVDQA XMM1,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PMULUDQ XMM2,XMM1
PSRLQ XMM0,0x20
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM1
PSHUFD XMM1,XMM2,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
CMP RAX,RDX
JNZ 0x001013b8
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
MOVDQA XMM2,XMM0
PSRLQ XMM0,0x20
PMULUDQ XMM2,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM1
PSHUFD XMM1,XMM2,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PMULUDQ XMM0,XMM1
MOVD EDX,XMM0
TEST CL,0x3
JZ 0x00101471
MOV EAX,ECX
AND EAX,0xfffffffc
LAB_00101431:
CDQE
MOV RSI,RAX
IMUL EDX,dword ptr [RDI + RAX*0x4]
ADD RAX,0x1
NOT RSI
ADD ESI,ECX
AND ESI,0x1
CMP ECX,EAX
JLE 0x00101471
TEST ESI,ESI
JZ 0x00101460
IMUL EDX,dword ptr [RDI + RAX*0x4]
ADD RAX,0x1
CMP ECX,EAX
JLE 0x00101471
NOP word ptr [RAX + RAX*0x1]
LAB_00101460:
IMUL EDX,dword ptr [RDI + RAX*0x4]
IMUL EDX,dword ptr [RDI + RAX*0x4 + 0x4]
ADD RAX,0x2
CMP ECX,EAX
JG 0x00101460
LAB_00101471:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014ad
LEAVE
MOV EAX,EDX
RET
LAB_00101488:
OR qword ptr [RSP + RSI*0x1 + -0x8],0x0
JMP 0x001012da
LAB_00101493:
MOV EDX,0x1
JMP 0x00101471
LAB_0010149a:
XOR EAX,EAX
MOVSXD R8,EDX
JMP 0x00101349
LAB_001014a4:
MOV EDX,0x1
XOR EAX,EAX
JMP 0x00101431
LAB_001014ad:
CALL 0x00101050 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong func0(long param_1,ulong param_2,int param_3)
{
long lVar1;
int4 uVar2;
ulong *puVar3;
ulong *puVar4;
int *puVar5;
uint uVar6;
int4 *puVar7;
ulong *puVar8;
long lVar9;
long lVar10;
int iVar11;
int4 *puVar12;
int4 *puVar13;
ulong uVar14;
int *puVar15;
uint uVar17;
uint uVar18;
long in_FS_OFFSET;
ulong uVar19;
ulong uVar20;
int auVar21 [16];
int4 uVar22;
ulong uVar23;
int4 uVar24;
int auStack_18 [8];
long local_10;
int *puVar16;
uVar17 = (uint)param_2;
puVar15 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar14 = (long)(int)uVar17 * 4 + 0xf;
puVar16 = auStack_18;
puVar5 = auStack_18;
while (puVar16 != auStack_18 + -(uVar14 & 0xfffffffffffff000)) {
puVar15 = puVar5 + -0x1000;
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
puVar16 = puVar5 + -0x1000;
puVar5 = puVar5 + -0x1000;
}
uVar14 = (ulong)((uint)uVar14 & 0xff0);
lVar1 = -uVar14;
puVar8 = (ulong *)(puVar15 + lVar1);
if (uVar14 != 0) {
*(int8 *)(puVar15 + -8) = *(int8 *)(puVar15 + -8);
}
if ((int)uVar17 < 1) {
uVar14 = 1;
}
else {
uVar18 = uVar17 - 1;
if (uVar18 < 4) {
uVar6 = 0;
}
else {
puVar7 = (int4 *)(param_1 + (long)param_3 * 4);
puVar12 = (int4 *)(puVar15 + lVar1);
do {
uVar22 = puVar7[3];
uVar24 = puVar7[6];
puVar13 = puVar12 + 4;
uVar2 = puVar7[9];
*puVar12 = *puVar7;
puVar12[1] = uVar22;
puVar12[2] = uVar24;
puVar12[3] = uVar2;
puVar7 = puVar7 + 0xc;
puVar12 = puVar13;
} while (puVar13 != (int4 *)(puVar15 + (ulong)(uVar18 >> 2) * 0x10 + lVar1));
uVar6 = uVar18 & 0xfffffffc;
}
puVar7 = (int4 *)(puVar15 + (long)(int)uVar6 * 4 + lVar1);
puVar12 = (int4 *)(param_1 + (long)(int)uVar6 * 0xc + (long)param_3 * 4);
*puVar7 = *puVar12;
if ((((int)(uVar6 + 1) < (int)uVar17) &&
(puVar7[1] = puVar12[3], (int)(uVar6 + 2) < (int)uVar17)) &&
(puVar7[2] = puVar12[6], (int)(uVar6 + 3) < (int)uVar17)) {
puVar7[3] = puVar12[9];
}
if (uVar18 < 0x1b) {
iVar11 = 1;
uVar18 = 0;
}
else {
uVar14 = _DAT_00102010;
uVar20 = _UNK_00102018;
do {
uVar23 = *puVar8;
puVar4 = puVar8 + 1;
uVar19 = *puVar8;
puVar3 = puVar8 + 1;
puVar8 = puVar8 + 2;
uVar23 = (uVar23 & 0xffffffff) * (uVar14 & 0xffffffff);
uVar19 = (uVar19 >> 0x20) * (uVar14 >> 0x20);
uVar22 = (int4)uVar23;
uVar24 = (int4)((*puVar4 & 0xffffffff) * (uVar20 & 0xffffffff));
auVar21._4_4_ = uVar24;
auVar21._0_4_ = uVar22;
auVar21._8_4_ = uVar24;
auVar21._12_4_ = (int)((*puVar3 >> 0x20) * (uVar20 >> 0x20));
uVar20 = auVar21._8_8_;
uVar14 = CONCAT44((int)uVar19,uVar22);
} while (puVar8 != (ulong *)(puVar15 + (param_2 >> 2 & 0x3fffffff) * 0x10 + lVar1));
uVar20 = ((uVar20 >> 0x20) * (uVar19 & 0xffffffff) & 0xffffffff) *
((uVar20 & 0xffffffff) * (uVar23 & 0xffffffff) & 0xffffffff);
uVar14 = uVar20 & 0xffffffff;
iVar11 = (int)uVar20;
if ((param_2 & 3) == 0) goto LAB_00101471;
uVar18 = uVar17 & 0xfffffffc;
}
lVar9 = (long)(int)uVar18;
uVar14 = (ulong)(uint)(iVar11 * *(int *)(puVar15 + lVar9 * 4 + lVar1));
lVar10 = lVar9 + 1;
if ((int)lVar10 < (int)uVar17) {
if ((~uVar18 + uVar17 & 1) != 0) {
uVar14 = (ulong)(uint)(iVar11 * *(int *)(puVar15 + lVar9 * 4 + lVar1) *
*(int *)(puVar15 + lVar10 * 4 + lVar1));
lVar10 = lVar9 + 2;
if ((int)uVar17 <= (int)lVar10) goto LAB_00101471;
}
do {
uVar14 = (ulong)(uint)((int)uVar14 * *(int *)(puVar15 + lVar10 * 4 + lVar1) *
*(int *)(puVar15 + lVar10 * 4 + lVar1 + 4));
lVar10 = lVar10 + 2;
} while ((int)lVar10 < (int)uVar17);
}
}
LAB_00101471:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar14;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar15 + lVar1 + -8) = 0x1014b2;
__stack_chk_fail();
} |
6,476 | func0 | #include <assert.h>
#include <math.h>
| int func0(int N, int K) {
int No = 0;
No = (N - K + 1);
No = pow(No, 3);
return No;
}
| int main() {
assert(func0(2, 1) == 8);
assert(func0(5, 2) == 64);
assert(func0(1, 1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm0
movsd 0xee5(%rip),%xmm1
callq 1060 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_4], 0
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
add eax, 1
mov [rbp+var_4], eax
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_4]
movq rax, xmm2
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
leave
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)pow((double)(a1 - a2 + 1), 3.0);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x4]
MOVQ RAX,XMM2
MOVSD XMM0,qword ptr [0x00102060]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
LEAVE
RET | int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)((param_1 - param_2) + 1),DAT_00102060);
return (int)dVar1;
} |
6,477 | func0 | #include <assert.h>
#include <math.h>
| int func0(int N, int K) {
int No = 0;
No = (N - K + 1);
No = pow(No, 3);
return No;
}
| int main() {
assert(func0(2, 1) == 8);
assert(func0(5, 2) == 64);
assert(func0(1, 1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
sub %esi,%edi
add $0x1,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd 0xefa(%rip),%xmm1
callq 1060 <pow@plt>
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
sub edi, esi
add edi, 1
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
movsd xmm1, cs:qword_2060
call _pow
cvttsd2si eax, xmm0
add rsp, 8
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)pow((double)(a1 - a2 + 1), 3.0);
} | func0:
ENDBR64
SUB RSP,0x8
SUB EDI,ESI
ADD EDI,0x1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD XMM1,qword ptr [0x00102060]
CALL 0x00101060
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET | int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)((param_1 - param_2) + 1),DAT_00102060);
return (int)dVar1;
} |
6,478 | func0 | #include <assert.h>
#include <math.h>
| int func0(int N, int K) {
int No = 0;
No = (N - K + 1);
No = pow(No, 3);
return No;
}
| int main() {
assert(func0(2, 1) == 8);
assert(func0(5, 2) == 64);
assert(func0(1, 1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
sub %esi,%edi
pxor %xmm0,%xmm0
sub $0x8,%rsp
movsd 0xe92(%rip),%xmm1
add $0x1,%edi
cvtsi2sd %edi,%xmm0
callq 1050 <pow@plt>
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub edi, esi
pxor xmm0, xmm0
sub rsp, 8
movsd xmm1, cs:qword_2008
add edi, 1
cvtsi2sd xmm0, edi
call _pow
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)pow((double)(a1 - a2 + 1), 3.0);
} | func0:
ENDBR64
SUB EDI,ESI
PXOR XMM0,XMM0
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102008]
ADD EDI,0x1
CVTSI2SD XMM0,EDI
CALL 0x00101050
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)((param_1 - param_2) + 1),DAT_00102008);
return (int)dVar1;
} |
6,479 | func0 | #include <assert.h>
#include <math.h>
| int func0(int N, int K) {
int No = 0;
No = (N - K + 1);
No = pow(No, 3);
return No;
}
| int main() {
assert(func0(2, 1) == 8);
assert(func0(5, 2) == 64);
assert(func0(1, 1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
sub %esi,%edi
pxor %xmm0,%xmm0
sub $0x8,%rsp
movsd 0xe92(%rip),%xmm1
add $0x1,%edi
cvtsi2sd %edi,%xmm0
callq 1050 <pow@plt>
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub edi, esi
pxor xmm0, xmm0
sub rsp, 8
movsd xmm1, cs:y; y
add edi, 1
cvtsi2sd xmm0, edi; x
call _pow
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)pow((double)(a1 - a2 + 1), 3.0);
} | func0:
ENDBR64
SUB EDI,ESI
PXOR XMM0,XMM0
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102008]
ADD EDI,0x1
CVTSI2SD XMM0,EDI
CALL 0x00101050
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)((param_1 - param_2) + 1),DAT_00102008);
return (int)dVar1;
} |
6,480 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int len = strlen(text);
char** result = malloc(len * sizeof(char*));
if (result == NULL) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
int current_word = 0;
int start = 0;
for (int i = 1; i <= len; i++) {
if (isupper(text[i]) || text[i] == '\0') {
int word_length = i - start;
result[current_word] = malloc(word_length+1);
if (result[current_word] == NULL) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
memcpy(result[current_word], text + start, word_length);
result[current_word][word_length] = '\0';
start = i;
current_word++;
}
}
*count = current_word;
return result;
}
| int main() {
int count = 0;
char** result;
result = func0("PythonProgramLanguage", &count);
assert(count == 3);
assert(strcmp(result[0], "Python") == 0);
assert(strcmp(result[1], "Program") == 0);
assert(strcmp(result[2], "Language") == 0);
for (int i = 0; i < count; i++) free(result[i]);
free(result);
result = func0("PythonProgram", &count);
assert(count == 2);
assert(strcmp(result[0], "Python") == 0);
assert(strcmp(result[1], "Program") == 0);
for (int i = 0; i < count; i++) free(result[i]);
free(result);
result = func0("ProgrammingLanguage", &count);
assert(count == 2);
assert(strcmp(result[0], "Programming") == 0);
assert(strcmp(result[1], "Language") == 0);
for (int i = 0; i < count; i++) free(result[i]);
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1140 <malloc@plt>
mov %rax,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 12bf <func0+0x56>
lea 0xd58(%rip),%rdi
callq 1150 <perror@plt>
mov $0x1,%edi
callq 1160 <exit@plt>
movl $0x0,-0x2c(%rbp)
movl $0x0,-0x28(%rbp)
movl $0x1,-0x24(%rbp)
jmpq 13eb <func0+0x182>
callq 1170 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
jne 1322 <func0+0xb9>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 13e7 <func0+0x17e>
mov -0x24(%rbp),%eax
sub -0x28(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
add $0x1,%eax
cltq
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1140 <malloc@plt>
mov %rax,(%rbx)
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
test %rax,%rax
jne 1386 <func0+0x11d>
lea 0xc91(%rip),%rdi
callq 1150 <perror@plt>
mov $0x1,%edi
callq 1160 <exit@plt>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%eax
movslq %eax,%rcx
mov -0x38(%rbp),%rax
add %rax,%rcx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rsi
mov -0x18(%rbp),%rax
add %rsi,%rax
mov (%rax),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1130 <memcpy@plt>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movb $0x0,(%rax)
mov -0x24(%rbp),%eax
mov %eax,-0x28(%rbp)
addl $0x1,-0x2c(%rbp)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 12d9 <func0+0x70>
mov -0x40(%rbp),%rax
mov -0x2c(%rbp),%edx
mov %edx,(%rax)
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+s], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_12C2
lea rax, s; "Failed to allocate memory"
mov rdi, rax; s
call _perror
mov edi, 1; status
call _exit
loc_12C2:
mov [rbp+var_2C], 0
mov [rbp+var_28], 0
mov [rbp+var_24], 1
jmp loc_13F1
loc_12DC:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jnz short loc_1325
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_13ED
loc_1325:
mov eax, [rbp+var_24]
sub eax, [rbp+var_28]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
add eax, 1
cdqe
mov edx, [rbp+var_2C]
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_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
test rax, rax
jnz short loc_138C
lea rax, s; "Failed to allocate memory"
mov rdi, rax; s
call _perror
mov edi, 1; status
call _exit
loc_138C:
mov eax, [rbp+var_1C]
movsxd rdx, eax; n
mov eax, [rbp+var_28]
movsxd rcx, eax
mov rax, [rbp+s]
add rcx, rax
mov eax, [rbp+var_2C]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rsi
mov rax, [rax]
mov rsi, rcx; src
mov rdi, rax; dest
call _memcpy
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
mov byte ptr [rax], 0
mov eax, [rbp+var_24]
mov [rbp+var_28], eax
add [rbp+var_2C], 1
loc_13ED:
add [rbp+var_24], 1
loc_13F1:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_20]
jle loc_12DC
mov rax, [rbp+var_40]
mov edx, [rbp+var_2C]
mov [rax], edx
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(const char *a1, _DWORD *a2)
{
int v3; // [rsp+14h] [rbp-2Ch]
int v4; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
int v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
_QWORD *v8; // [rsp+28h] [rbp-18h]
v6 = strlen(a1);
v8 = malloc(8LL * v6);
if ( !v8 )
{
perror("Failed to allocate memory");
exit(1);
}
v3 = 0;
v4 = 0;
for ( i = 1; i <= v6; ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 0x100) != 0 || !a1[i] )
{
v7 = i - v4;
v8[v3] = malloc(i - v4 + 1);
if ( !v8[v3] )
{
perror("Failed to allocate memory");
exit(1);
}
memcpy((void *)v8[v3], &a1[v4], v7);
*(_BYTE *)(v8[v3] + v7) = 0;
v4 = i;
++v3;
}
}
*a2 = v3;
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101140
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001012c2
LEA RAX,[0x102008]
MOV RDI,RAX
CALL 0x00101150
MOV EDI,0x1
CALL 0x00101160
LAB_001012c2:
MOV dword ptr [RBP + -0x2c],0x0
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001013f1
LAB_001012dc:
CALL 0x00101170
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JNZ 0x00101325
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001013ed
LAB_00101325:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101140
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JNZ 0x0010138c
LEA RAX,[0x102008]
MOV RDI,RAX
CALL 0x00101150
MOV EDI,0x1
CALL 0x00101160
LAB_0010138c:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RCX,RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RSI,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RSI
MOV RAX,qword ptr [RAX]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101130
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x28],EAX
ADD dword ptr [RBP + -0x2c],0x1
LAB_001013ed:
ADD dword ptr [RBP + -0x24],0x1
LAB_001013f1:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x001012dc
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
ushort **ppuVar4;
void *pvVar5;
int local_34;
int local_30;
int local_2c;
sVar2 = strlen(param_1);
pvVar3 = malloc((long)(int)sVar2 << 3);
if (pvVar3 == (void *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
local_34 = 0;
local_30 = 0;
local_2c = 1;
do {
if ((int)sVar2 < local_2c) {
*param_2 = local_34;
return pvVar3;
}
ppuVar4 = __ctype_b_loc();
if ((((*ppuVar4)[param_1[local_2c]] & 0x100) != 0) || (param_1[local_2c] == '\0')) {
iVar1 = local_2c - local_30;
pvVar5 = malloc((long)(iVar1 + 1));
*(void **)((long)local_34 * 8 + (long)pvVar3) = pvVar5;
if (*(long *)((long)pvVar3 + (long)local_34 * 8) == 0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
memcpy(*(void **)((long)pvVar3 + (long)local_34 * 8),param_1 + local_30,(long)iVar1);
*(int *)((long)iVar1 + *(long *)((long)pvVar3 + (long)local_34 * 8)) = 0;
local_30 = local_2c;
local_34 = local_34 + 1;
}
local_2c = local_2c + 1;
} while( true );
} |
6,481 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int len = strlen(text);
char** result = malloc(len * sizeof(char*));
if (result == NULL) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
int current_word = 0;
int start = 0;
for (int i = 1; i <= len; i++) {
if (isupper(text[i]) || text[i] == '\0') {
int word_length = i - start;
result[current_word] = malloc(word_length+1);
if (result[current_word] == NULL) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
memcpy(result[current_word], text + start, word_length);
result[current_word][word_length] = '\0';
start = i;
current_word++;
}
}
*count = current_word;
return result;
}
| int main() {
int count = 0;
char** result;
result = func0("PythonProgramLanguage", &count);
assert(count == 3);
assert(strcmp(result[0], "Python") == 0);
assert(strcmp(result[1], "Program") == 0);
assert(strcmp(result[2], "Language") == 0);
for (int i = 0; i < count; i++) free(result[i]);
free(result);
result = func0("PythonProgram", &count);
assert(count == 2);
assert(strcmp(result[0], "Python") == 0);
assert(strcmp(result[1], "Program") == 0);
for (int i = 0; i < count; i++) free(result[i]);
free(result);
result = func0("ProgrammingLanguage", &count);
assert(count == 2);
assert(strcmp(result[0], "Programming") == 0);
assert(strcmp(result[1], "Language") == 0);
for (int i = 0; i < count; i++) free(result[i]);
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r14
mov %rsi,0x18(%rsp)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
mov %ebx,0xc(%rsp)
movslq %ebx,%rdi
shl $0x3,%rdi
callq 1100 <malloc@plt>
mov %rax,0x10(%rsp)
test %rax,%rax
je 129d <func0+0x74>
mov $0x0,%r13d
test %ebx,%ebx
jle 1343 <func0+0x11a>
callq 1130 <__ctype_b_loc@plt>
mov %rax,%r15
mov $0x1,%ebx
movl $0x0,0x8(%rsp)
mov $0x0,%r13d
jmp 1310 <func0+0xe7>
lea 0xd60(%rip),%rdi
callq 1110 <perror@plt>
mov $0x1,%edi
callq 1120 <exit@plt>
mov 0x4(%rsp),%r12d
sub 0x8(%rsp),%r12d
lea 0x1(%r12),%edi
movslq %edi,%rdi
callq 1100 <malloc@plt>
mov %rax,%rbp
movslq %r13d,%rax
mov 0x10(%rsp),%rcx
mov %rbp,(%rcx,%rax,8)
test %rbp,%rbp
je 132d <func0+0x104>
movslq %r12d,%r12
movslq 0x8(%rsp),%rsi
add %r14,%rsi
mov %r12,%rdx
mov %rbp,%rdi
callq 10f0 <memcpy@plt>
movb $0x0,0x0(%rbp,%r12,1)
add $0x1,%r13d
mov 0x4(%rsp),%eax
mov %eax,0x8(%rsp)
add $0x1,%rbx
cmp %ebx,0xc(%rsp)
jl 1343 <func0+0x11a>
mov %ebx,0x4(%rsp)
movzbl (%r14,%rbx,1),%eax
movsbq %al,%rcx
mov (%r15),%rdx
testb $0x1,0x1(%rdx,%rcx,2)
jne 12b3 <func0+0x8a>
test %al,%al
jne 1306 <func0+0xdd>
jmp 12b3 <func0+0x8a>
lea 0xcd0(%rip),%rdi
callq 1110 <perror@plt>
mov $0x1,%edi
callq 1120 <exit@plt>
mov 0x18(%rsp),%rax
mov %r13d,(%rax)
mov 0x10(%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], rdi
mov [rsp+58h+var_40], rsi
call _strlen
mov rbx, rax
mov [rsp+58h+var_4C], eax
movsxd rdi, eax
shl rdi, 3
call _malloc
mov [rsp+58h+var_48], rax
test rax, rax
jz short loc_12D1
mov r14d, 0
test ebx, ebx
jle loc_1375
call ___ctype_b_loc
mov r15, rax
mov ebx, 1
mov [rsp+58h+var_50], 0
mov r14d, 0
jmp short loc_1340
loc_12D1:
lea rdi, aFailedToAlloca; "Failed to allocate memory"
call _perror
mov edi, 1
call _exit
loc_12E7:
mov r12d, r13d
sub r12d, [rsp+58h+var_50]
lea edi, [r12+1]
movsxd rdi, edi
call _malloc
mov rbp, rax
movsxd rax, r14d
mov rcx, [rsp+58h+var_48]
mov [rcx+rax*8], rbp
test rbp, rbp
jz short loc_135F
movsxd r12, r12d
movsxd rsi, [rsp+58h+var_50]
add rsi, [rsp+58h+var_58]
mov rdx, r12
mov rdi, rbp
call _memcpy
mov byte ptr [rbp+r12+0], 0
add r14d, 1
mov [rsp+58h+var_50], r13d
loc_1336:
add rbx, 1
cmp [rsp+58h+var_4C], ebx
jl short loc_1375
loc_1340:
mov r13d, ebx
mov rax, [rsp+58h+var_58]
movzx eax, byte ptr [rax+rbx]
movsx rcx, al
mov rdx, [r15]
test byte ptr [rdx+rcx*2+1], 1
jnz short loc_12E7
test al, al
jnz short loc_1336
jmp short loc_12E7
loc_135F:
lea rdi, aFailedToAlloca; "Failed to allocate memory"
call _perror
mov edi, 1
call _exit
loc_1375:
mov rax, [rsp+58h+var_40]
mov [rax], r14d
mov rax, [rsp+58h+var_48]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, _DWORD *a2)
{
int v2; // ebx
int v3; // r14d
_QWORD *v4; // r15
long long v5; // rbx
int v6; // r12d
long long v7; // rbp
char v8; // al
int v10; // [rsp+8h] [rbp-50h]
int v11; // [rsp+Ch] [rbp-4Ch]
long long v12; // [rsp+10h] [rbp-48h]
v2 = strlen();
v11 = v2;
v12 = malloc(8LL * v2);
if ( !v12 )
{
perror("Failed to allocate memory");
exit(1LL);
}
v3 = 0;
if ( v2 > 0 )
{
v4 = (_QWORD *)__ctype_b_loc();
v5 = 1LL;
v10 = 0;
v3 = 0;
do
{
v8 = *(_BYTE *)(a1 + v5);
if ( (*(_BYTE *)(*v4 + 2LL * v8 + 1) & 1) != 0 || !v8 )
{
v6 = v5 - v10;
v7 = malloc((int)v5 - v10 + 1);
*(_QWORD *)(v12 + 8LL * v3) = v7;
if ( !v7 )
{
perror("Failed to allocate memory");
exit(1LL);
}
memcpy(v7, a1 + v10, v6);
*(_BYTE *)(v7 + v6) = 0;
++v3;
v10 = v5;
}
++v5;
}
while ( v11 >= (int)v5 );
}
*a2 = v3;
return v12;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x18],RSI
CALL 0x001010f0
MOV RBX,RAX
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00101140
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x001012d1
MOV R14D,0x0
TEST EBX,EBX
JLE 0x00101375
CALL 0x00101170
MOV R15,RAX
MOV EBX,0x1
MOV dword ptr [RSP + 0x8],0x0
MOV R14D,0x0
JMP 0x00101340
LAB_001012d1:
LEA RDI,[0x102004]
CALL 0x00101150
MOV EDI,0x1
CALL 0x00101160
LAB_001012e7:
MOV R12D,R13D
SUB R12D,dword ptr [RSP + 0x8]
LEA EDI,[R12 + 0x1]
MOVSXD RDI,EDI
CALL 0x00101140
MOV RBP,RAX
MOVSXD RAX,R14D
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX + RAX*0x8],RBP
TEST RBP,RBP
JZ 0x0010135f
MOVSXD R12,R12D
MOVSXD RSI,dword ptr [RSP + 0x8]
ADD RSI,qword ptr [RSP]
MOV RDX,R12
MOV RDI,RBP
CALL 0x00101130
MOV byte ptr [RBP + R12*0x1],0x0
ADD R14D,0x1
MOV dword ptr [RSP + 0x8],R13D
LAB_00101336:
ADD RBX,0x1
CMP dword ptr [RSP + 0xc],EBX
JL 0x00101375
LAB_00101340:
MOV R13D,EBX
MOV RAX,qword ptr [RSP]
MOVZX EAX,byte ptr [RAX + RBX*0x1]
MOVSX RCX,AL
MOV RDX,qword ptr [R15]
TEST byte ptr [RDX + RCX*0x2 + 0x1],0x1
JNZ 0x001012e7
TEST AL,AL
JNZ 0x00101336
JMP 0x001012e7
LAB_0010135f:
LEA RDI,[0x102004]
CALL 0x00101150
MOV EDI,0x1
CALL 0x00101160
LAB_00101375:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R14D
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
ushort **ppuVar4;
void *__dest;
long lVar5;
int iVar6;
int iVar7;
int local_50;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pvVar3 = malloc((long)iVar1 << 3);
if (pvVar3 == (void *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
iVar7 = 0;
if (0 < iVar1) {
ppuVar4 = __ctype_b_loc();
lVar5 = 1;
local_50 = 0;
iVar7 = 0;
do {
if (((*(byte *)((long)*ppuVar4 + (long)param_1[lVar5] * 2 + 1) & 1) != 0) ||
(param_1[lVar5] == '\0')) {
iVar6 = (int)lVar5 - local_50;
__dest = malloc((long)(iVar6 + 1));
*(void **)((long)pvVar3 + (long)iVar7 * 8) = __dest;
if (__dest == (void *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
memcpy(__dest,param_1 + local_50,(long)iVar6);
*(int1 *)((long)__dest + (long)iVar6) = 0;
iVar7 = iVar7 + 1;
local_50 = (int)lVar5;
}
lVar5 = lVar5 + 1;
} while ((int)lVar5 <= iVar1);
}
*param_2 = iVar7;
return pvVar3;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.