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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
5,982 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int lis[n+1];
int lds[n+1];
int i, j, maximum;
for (i = 0; i <= n; i++) {
lis[i] = 1;
}
for (i = 1; i < n; i++) {
for (j = 0; j < i; j++) {
if (arr[i] > arr[j] && lis[i] < lis[j] + 1) {
lis[i] = lis[j] + 1;
}
}
}
for (i = 0; i <= n; i++) {
lds[i] = 1;
}
for (i = n-2; i >= 0; i--) {
for (j = n-1; j > i; j--) {
if (arr[i] > arr[j] && lds[i] < lds[j] + 1) {
lds[i] = lds[j] + 1;
}
}
}
maximum = lis[0] + lds[0] - 1;
for (i = 1; i < n; i++) {
if ((lis[i] + lds[i] - 1) > maximum) {
maximum = lis[i] + lds[i] - 1;
}
}
return maximum;
}
| int main() {
int arr1[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
int arr2[] = {1, 11, 2, 10, 4, 5, 2, 1};
int arr3[] = {80, 60, 30, 40, 20, 10};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])) == 7);
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])) == 6);
assert(func0(arr3, sizeof(arr3)/sizeof(arr3[0])) == 5);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
mov %rax,%rdx
and $0xfffffffffffff000,%rcx
and $0xfffffffffffffff0,%rdx
sub %rcx,%rbx
mov %rbx,%rcx
cmp %rcx,%rsp
je 13b3 <func0+0x63>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rcx,%rsp
jne 139e <func0+0x4e>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 155a <func0+0x20a>
mov %rax,%rdx
mov %rsp,%rbx
and $0xfffffffffffff000,%rax
lea 0x3(%rsp),%r9
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %r9,%r10
mov %rbx,%rax
and $0xfffffffffffffffc,%r9
shr $0x2,%r10
cmp %rax,%rsp
je 1405 <func0+0xb5>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 13f0 <func0+0xa0>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1565 <func0+0x215>
lea 0x3(%rsp),%r8
mov %r8,%r11
and $0xfffffffffffffffc,%r8
shr $0x2,%r11
test %esi,%esi
js 14a8 <func0+0x158>
movslq %esi,%rdx
mov %r9,%rax
lea 0x4(%r9,%rdx,4),%rdx
nopw %cs:0x0(%rax,%rax,1)
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1440 <func0+0xf0>
cmp $0x1,%esi
jle 148f <func0+0x13f>
mov $0x1,%edx
nopl 0x0(%rax)
mov (%rdi,%rdx,4),%ebx
xor %eax,%eax
nopl (%rax)
cmp (%rdi,%rax,4),%ebx
jle 147e <func0+0x12e>
mov (%r9,%rax,4),%ecx
cmp (%r9,%rdx,4),%ecx
jl 147e <func0+0x12e>
add $0x1,%ecx
mov %ecx,(%r9,%rdx,4)
add $0x1,%rax
cmp %rax,%rdx
jne 1468 <func0+0x118>
add $0x1,%rdx
cmp %edx,%esi
jg 1460 <func0+0x110>
xor %eax,%eax
nopl 0x0(%rax)
movl $0x1,(%r8,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jge 1498 <func0+0x148>
lea -0x2(%rsi),%r13d
lea -0x1(%rsi),%r14d
movslq %r13d,%rcx
test %r13d,%r13d
js 14f7 <func0+0x1a7>
nopl 0x0(%rax,%rax,1)
mov %ecx,%ebx
cmp %r14d,%ecx
jge 14ef <func0+0x19f>
mov (%rdi,%rcx,4),%r12d
movslq %r14d,%rax
xchg %ax,%ax
cmp (%rdi,%rax,4),%r12d
jle 14e7 <func0+0x197>
mov (%r8,%rax,4),%edx
cmp (%r8,%rcx,4),%edx
jl 14e7 <func0+0x197>
add $0x1,%edx
mov %edx,(%r8,%rcx,4)
sub $0x1,%rax
cmp %eax,%ebx
jl 14d0 <func0+0x180>
sub $0x1,%rcx
test %ecx,%ecx
jns 14c0 <func0+0x170>
mov 0x0(,%r11,4),%eax
mov %r13d,%ecx
add 0x0(,%r10,4),%eax
mov $0x1,%edx
mov %eax,%r10d
add $0x2,%rcx
sub $0x1,%r10d
cmp $0x1,%esi
jle 153b <func0+0x1eb>
mov (%r8,%rdx,4),%eax
add (%r9,%rdx,4),%eax
sub $0x1,%eax
cmp %eax,%r10d
cmovl %eax,%r10d
add $0x1,%rdx
cmp %rcx,%rdx
jne 1520 <func0+0x1d0>
mov -0x28(%rbp),%rax
xor %fs:0x28,%rax
jne 1570 <func0+0x220>
lea -0x20(%rbp),%rsp
mov %r10d,%eax
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 13c5 <func0+0x75>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1417 <func0+0xc7>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rdx, rdi
mov r9d, esi
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [rsi+1]
mov rsi, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdi, rax
mov rcx, rax
and rdi, 0FFFFFFFFFFFFF000h
and rcx, 0FFFFFFFFFFFFFFF0h
sub rsi, rdi
cmp rsp, rsi
jz short loc_13B4
loc_139F:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rsi
jnz short loc_139F
loc_13B4:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_1547
loc_13C6:
lea r8, [rsp+1030h+var_102D]
mov rcx, rax
mov rsi, rsp
and rax, 0FFFFFFFFFFFFF000h
mov r10, r8
sub rsi, rax
and r8, 0FFFFFFFFFFFFFFFCh
and rcx, 0FFFFFFFFFFFFFFF0h
shr r10, 2
cmp rsp, rsi
jz short loc_1403
loc_13EE:
sub rsp, 1000h
or [rsp+2030h+var_1038], 0
cmp rsp, rsi
jnz short loc_13EE
loc_1403:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_1552
loc_1415:
lea rdi, [rsp+2030h+var_202D]
mov r11, rdi
and rdi, 0FFFFFFFFFFFFFFFCh
shr r11, 2
test r9d, r9d
js short loc_14A0
movsxd rcx, r9d
mov rax, r8
lea rcx, [r8+rcx*4+4]
nop dword ptr [rax]
loc_1438:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rcx
jnz short loc_1438
cmp r9d, 1
jle short loc_1488
mov ecx, 1
nop word ptr [rax+rax+00h]
loc_1458:
mov ebx, [rdx+rcx*4]
xor eax, eax
nop dword ptr [rax]
loc_1460:
cmp ebx, [rdx+rax*4]
jle short loc_1476
mov esi, [r8+rax*4]
cmp esi, [r8+rcx*4]
jl short loc_1476
add esi, 1
mov [r8+rcx*4], esi
loc_1476:
add rax, 1
cmp rcx, rax
jnz short loc_1460
add rcx, 1
cmp r9d, ecx
jg short loc_1458
loc_1488:
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1490:
mov dword ptr [rdi+rax*4], 1
add rax, 1
cmp r9d, eax
jge short loc_1490
loc_14A0:
lea eax, [r9-2]
lea r13d, [r9-1]
movsxd rsi, eax
test eax, eax
js short loc_14E4
nop
loc_14B0:
mov ebx, esi
cmp esi, r13d
jge short loc_14DC
mov r12d, [rdx+rsi*4]
movsxd rax, r13d
xchg ax, ax
loc_14C0:
cmp r12d, [rdx+rax*4]
jle short loc_14D4
mov ecx, [rdi+rax*4]
cmp ecx, [rdi+rsi*4]
jl short loc_14D4
add ecx, 1
mov [rdi+rsi*4], ecx
loc_14D4:
sub rax, 1
cmp ebx, eax
jl short loc_14C0
loc_14DC:
sub rsi, 1
test esi, esi
jns short loc_14B0
loc_14E4:
mov eax, ds:dword_0[r11*4]
movsxd rcx, r9d
add eax, ds:dword_0[r10*4]
mov edx, 1
mov r10d, eax
sub r10d, 1
cmp r9d, 1
jle short loc_152A
nop dword ptr [rax+00000000h]
loc_1510:
mov eax, [rdi+rdx*4]
add eax, [r8+rdx*4]
sub eax, 1
cmp r10d, eax
cmovl r10d, eax
add rdx, 1
cmp rdx, rcx
jnz short loc_1510
loc_152A:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_155D
lea rsp, [rbp-18h]
mov eax, r10d
pop rbx
pop r12
pop r13
pop rbp
retn
loc_1547:
or [rsp+rcx+1030h+var_1038], 0
jmp loc_13C6
loc_1552:
or [rsp+rcx+2030h+var_2038], 0
jmp loc_1415
loc_155D:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v3; // rax
_DWORD *v4; // rsi
signed long long v5; // rcx
void *v6; // rsp
_DWORD *v7; // rsi
signed long long v8; // rcx
void *v9; // rsp
_DWORD *v10; // rax
long long v11; // rcx
int v12; // ebx
long long v13; // rax
int v14; // esi
long long v15; // rax
int v16; // r13d
long long v17; // rsi
int v18; // r12d
long long v19; // rax
int v20; // ecx
long long v21; // rdx
int v22; // r10d
_DWORD v25[1024]; // [rsp+8h] [rbp-2030h] BYREF
_DWORD v26[1022]; // [rsp+1008h] [rbp-1030h] BYREF
_QWORD v27[6]; // [rsp+2008h] [rbp-30h] BYREF
v27[1] = __readfsqword(0x28u);
v3 = 4LL * (a2 + 1) + 15;
v4 = (_DWORD *)((char *)v27 - (v3 & 0xFFFFFFFFFFFFF000LL));
if ( v27 != (_QWORD *)v4 )
{
while ( v26 != v4 )
;
}
v5 = v3 & 0xFF0;
v6 = alloca(v5);
if ( (v3 & 0xFF0) != 0 )
*(_QWORD *)((char *)&v25[1022] + v5) = *(_QWORD *)((char *)&v25[1022] + v5);
v7 = (_DWORD *)((char *)v26 - (v3 & 0xFFFFFFFFFFFFF000LL));
if ( v26 != v7 )
{
while ( v25 != v7 )
;
}
v8 = v3 & 0xFF0;
v9 = alloca(v8);
if ( (v3 & 0xFF0) != 0 )
*(_QWORD *)((char *)&v25[-2] + v8) = *(_QWORD *)((char *)&v25[-2] + v8);
if ( a2 >= 0 )
{
v10 = v26;
do
*v10++ = 1;
while ( v10 != &v26[a2 + 1] );
if ( a2 > 1 )
{
v11 = 1LL;
do
{
v12 = *(_DWORD *)(a1 + 4 * v11);
v13 = 0LL;
do
{
if ( v12 > *(_DWORD *)(a1 + 4 * v13) )
{
v14 = v26[v13];
if ( v14 >= v26[v11] )
v26[v11] = v14 + 1;
}
++v13;
}
while ( v11 != v13 );
++v11;
}
while ( a2 > (int)v11 );
}
v15 = 0LL;
do
v25[v15++] = 1;
while ( a2 >= (int)v15 );
}
v16 = a2 - 1;
v17 = a2 - 2;
if ( a2 - 2 >= 0 )
{
do
{
if ( (int)v17 < v16 )
{
v18 = *(_DWORD *)(a1 + 4 * v17);
v19 = v16;
do
{
if ( v18 > *(_DWORD *)(a1 + 4 * v19) )
{
v20 = v25[v19];
if ( v20 >= v25[v17] )
v25[v17] = v20 + 1;
}
--v19;
}
while ( (int)v17 < (int)v19 );
}
--v17;
}
while ( (int)v17 >= 0 );
}
v21 = 1LL;
v22 = v26[0] + v25[0] - 1;
if ( a2 > 1 )
{
do
{
if ( v22 < v26[v21] + v25[v21] - 1 )
v22 = v26[v21] + v25[v21] - 1;
++v21;
}
while ( v21 != a2 );
}
return (unsigned int)v22;
} | func0:
ENDBR64
PUSH RBP
MOV RDX,RDI
MOV R9D,ESI
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[RSI + 0x1]
MOV RSI,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDI,RAX
MOV RCX,RAX
AND RDI,-0x1000
AND RCX,-0x10
SUB RSI,RDI
CMP RSP,RSI
JZ 0x001013b4
LAB_0010139f:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x0010139f
LAB_001013b4:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101547
LAB_001013c6:
LEA R8,[RSP + 0x3]
MOV RCX,RAX
MOV RSI,RSP
AND RAX,-0x1000
MOV R10,R8
SUB RSI,RAX
AND R8,-0x4
AND RCX,-0x10
SHR R10,0x2
CMP RSP,RSI
JZ 0x00101403
LAB_001013ee:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001013ee
LAB_00101403:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101552
LAB_00101415:
LEA RDI,[RSP + 0x3]
MOV R11,RDI
AND RDI,-0x4
SHR R11,0x2
TEST R9D,R9D
JS 0x001014a0
MOVSXD RCX,R9D
MOV RAX,R8
LEA RCX,[R8 + RCX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101438:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101438
CMP R9D,0x1
JLE 0x00101488
MOV ECX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101458:
MOV EBX,dword ptr [RDX + RCX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101460:
CMP EBX,dword ptr [RDX + RAX*0x4]
JLE 0x00101476
MOV ESI,dword ptr [R8 + RAX*0x4]
CMP ESI,dword ptr [R8 + RCX*0x4]
JL 0x00101476
ADD ESI,0x1
MOV dword ptr [R8 + RCX*0x4],ESI
LAB_00101476:
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101460
ADD RCX,0x1
CMP R9D,ECX
JG 0x00101458
LAB_00101488:
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101490:
MOV dword ptr [RDI + RAX*0x4],0x1
ADD RAX,0x1
CMP R9D,EAX
JGE 0x00101490
LAB_001014a0:
LEA EAX,[R9 + -0x2]
LEA R13D,[R9 + -0x1]
MOVSXD RSI,EAX
TEST EAX,EAX
JS 0x001014e4
NOP
LAB_001014b0:
MOV EBX,ESI
CMP ESI,R13D
JGE 0x001014dc
MOV R12D,dword ptr [RDX + RSI*0x4]
MOVSXD RAX,R13D
NOP
LAB_001014c0:
CMP R12D,dword ptr [RDX + RAX*0x4]
JLE 0x001014d4
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP ECX,dword ptr [RDI + RSI*0x4]
JL 0x001014d4
ADD ECX,0x1
MOV dword ptr [RDI + RSI*0x4],ECX
LAB_001014d4:
SUB RAX,0x1
CMP EBX,EAX
JL 0x001014c0
LAB_001014dc:
SUB RSI,0x1
TEST ESI,ESI
JNS 0x001014b0
LAB_001014e4:
MOV EAX,dword ptr [R11*0x4]
MOVSXD RCX,R9D
ADD EAX,dword ptr [R10*0x4]
MOV EDX,0x1
MOV R10D,EAX
SUB R10D,0x1
CMP R9D,0x1
JLE 0x0010152a
NOP dword ptr [RAX]
LAB_00101510:
MOV EAX,dword ptr [RDI + RDX*0x4]
ADD EAX,dword ptr [R8 + RDX*0x4]
SUB EAX,0x1
CMP R10D,EAX
CMOVL R10D,EAX
ADD RDX,0x1
CMP RDX,RCX
JNZ 0x00101510
LAB_0010152a:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010155d
LEA RSP,[RBP + -0x18]
MOV EAX,R10D
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_00101547:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x001013c6
LAB_00101552:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x00101415
LAB_0010155d:
CALL 0x00101080 | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int1 *puVar3;
int iVar4;
int iVar5;
int4 *puVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
int1 *puVar11;
int1 *puVar13;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar12;
int1 *puVar14;
puVar11 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar9 = (long)(param_2 + 1) * 4 + 0xf;
puVar12 = auStack_38;
puVar13 = auStack_38;
while (puVar12 != auStack_38 + -(uVar9 & 0xfffffffffffff000)) {
puVar11 = puVar13 + -0x1000;
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
puVar12 = puVar13 + -0x1000;
puVar13 = puVar13 + -0x1000;
}
uVar8 = (ulong)((uint)uVar9 & 0xff0);
lVar1 = -uVar8;
puVar6 = (int4 *)(puVar11 + lVar1);
puVar13 = puVar11 + lVar1;
puVar14 = puVar11 + lVar1;
if (uVar8 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
puVar3 = puVar11 + lVar1;
while (puVar14 != puVar11 + (lVar1 - (uVar9 & 0xfffffffffffff000))) {
puVar13 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar14 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar2 = -uVar9;
if (uVar9 != 0) {
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
}
if (-1 < param_2) {
do {
*puVar6 = 1;
puVar6 = puVar6 + 1;
} while (puVar6 != (int4 *)(puVar11 + (long)param_2 * 4 + lVar1 + 4));
if (1 < param_2) {
lVar10 = 1;
do {
iVar4 = *(int *)(param_1 + lVar10 * 4);
lVar7 = 0;
do {
if ((*(int *)(param_1 + lVar7 * 4) < iVar4) &&
(*(int *)(puVar11 + lVar10 * 4 + lVar1) <= *(int *)(puVar11 + lVar7 * 4 + lVar1))) {
*(int *)(puVar11 + lVar10 * 4 + lVar1) = *(int *)(puVar11 + lVar7 * 4 + lVar1) + 1;
}
lVar7 = lVar7 + 1;
} while (lVar10 != lVar7);
lVar10 = lVar10 + 1;
} while ((int)lVar10 < param_2);
}
lVar10 = 0;
do {
*(int4 *)(puVar13 + lVar10 * 4 + lVar2) = 1;
lVar10 = lVar10 + 1;
} while ((int)lVar10 <= param_2);
}
iVar4 = param_2 + -2;
lVar10 = (long)iVar4;
while (-1 < iVar4) {
if ((int)lVar10 < param_2 + -1) {
iVar4 = *(int *)(param_1 + lVar10 * 4);
lVar7 = (long)(param_2 + -1);
do {
if ((*(int *)(param_1 + lVar7 * 4) < iVar4) &&
(*(int *)(puVar13 + lVar10 * 4 + lVar2) <= *(int *)(puVar13 + lVar7 * 4 + lVar2))) {
*(int *)(puVar13 + lVar10 * 4 + lVar2) = *(int *)(puVar13 + lVar7 * 4 + lVar2) + 1;
}
lVar7 = lVar7 + -1;
} while ((int)lVar10 < (int)lVar7);
}
lVar10 = lVar10 + -1;
iVar4 = (int)lVar10;
}
lVar10 = 1;
iVar4 = *(int *)(puVar13 + lVar2) + *(int *)(puVar11 + lVar1) + -1;
if (1 < param_2) {
do {
iVar5 = *(int *)(puVar13 + lVar10 * 4 + lVar2) + *(int *)(puVar11 + lVar10 * 4 + lVar1) + -1;
if (iVar4 < iVar5) {
iVar4 = iVar5;
}
lVar10 = lVar10 + 1;
} while (lVar10 != param_2);
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar13 + lVar2 + -8) = 0x101562;
__stack_chk_fail();
}
return iVar4;
} |
5,983 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int lis[n+1];
int lds[n+1];
int i, j, maximum;
for (i = 0; i <= n; i++) {
lis[i] = 1;
}
for (i = 1; i < n; i++) {
for (j = 0; j < i; j++) {
if (arr[i] > arr[j] && lis[i] < lis[j] + 1) {
lis[i] = lis[j] + 1;
}
}
}
for (i = 0; i <= n; i++) {
lds[i] = 1;
}
for (i = n-2; i >= 0; i--) {
for (j = n-1; j > i; j--) {
if (arr[i] > arr[j] && lds[i] < lds[j] + 1) {
lds[i] = lds[j] + 1;
}
}
}
maximum = lis[0] + lds[0] - 1;
for (i = 1; i < n; i++) {
if ((lis[i] + lds[i] - 1) > maximum) {
maximum = lis[i] + lds[i] - 1;
}
}
return maximum;
}
| int main() {
int arr1[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
int arr2[] = {1, 11, 2, 10, 4, 5, 2, 1};
int arr3[] = {80, 60, 30, 40, 20, 10};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])) == 7);
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])) == 6);
assert(func0(arr3, sizeof(arr3)/sizeof(arr3[0])) == 5);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
lea 0x1(%rsi),%r12d
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %r12d,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
mov %rax,%rdx
and $0xfffffffffffff000,%rcx
and $0xfffffffffffffff0,%rdx
sub %rcx,%rbx
mov %rbx,%rcx
cmp %rcx,%rsp
je 1343 <func0+0x63>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rcx,%rsp
jne 132e <func0+0x4e>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 166e <func0+0x38e>
mov %rax,%rdx
mov %rsp,%rbx
and $0xfffffffffffff000,%rax
lea 0x3(%rsp),%r8
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %r8,%r10
mov %rbx,%rax
and $0xfffffffffffffffc,%r8
shr $0x2,%r10
cmp %rax,%rsp
je 1395 <func0+0xb5>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1380 <func0+0xa0>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 16e8 <func0+0x408>
lea 0x3(%rsp),%r9
mov %r9,%r11
and $0xfffffffffffffffc,%r9
shr $0x2,%r11
test %esi,%esi
js 1693 <func0+0x3b3>
cmp $0x2,%esi
jle 16b2 <func0+0x3d2>
mov %r12d,%edx
movdqa 0xd1d(%rip),%xmm0
mov %r8,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %r8,%rdx
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 13e0 <func0+0x100>
mov %r12d,%eax
and $0xfffffffc,%eax
test $0x3,%r12b
je 142a <func0+0x14a>
movslq %eax,%rdx
add $0x1,%eax
movl $0x1,(%r8,%rdx,4)
cmp %eax,%esi
jl 142a <func0+0x14a>
movslq %eax,%rdx
add $0x1,%eax
movl $0x1,(%r8,%rdx,4)
cmp %eax,%esi
jl 16d3 <func0+0x3f3>
cltq
movl $0x1,(%r8,%rax,4)
mov $0x1,%edx
mov (%rdi,%rdx,4),%ebx
xor %eax,%eax
nopl (%rax)
cmp (%rdi,%rax,4),%ebx
jle 144e <func0+0x16e>
mov (%r8,%rax,4),%ecx
cmp (%r8,%rdx,4),%ecx
jl 144e <func0+0x16e>
add $0x1,%ecx
mov %ecx,(%r8,%rdx,4)
add $0x1,%rax
cmp %rdx,%rax
jne 1438 <func0+0x158>
add $0x1,%rdx
cmp %edx,%esi
jg 1430 <func0+0x150>
cmp $0x2,%esi
jle 16cc <func0+0x3ec>
mov %r12d,%edx
movdqa 0xc7d(%rip),%xmm0
mov %r9,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %r9,%rdx
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 1480 <func0+0x1a0>
mov %r12d,%eax
and $0xfffffffc,%eax
and $0x3,%r12d
je 1693 <func0+0x3b3>
movslq %eax,%rdx
movl $0x1,(%r9,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%esi
jl 1693 <func0+0x3b3>
movslq %edx,%rdx
add $0x2,%eax
movl $0x1,(%r9,%rdx,4)
cmp %esi,%eax
jg 1693 <func0+0x3b3>
cltq
lea -0x2(%rsi),%r12d
movl $0x1,(%r9,%rax,4)
mov %r12d,%edx
lea -0x1(%rsi),%r13d
cmp %r13d,%r12d
jge 1680 <func0+0x3a0>
nopw %cs:0x0(%rax,%rax,1)
movslq %edx,%rdx
movslq %r13d,%r13
nopw %cs:0x0(%rax,%rax,1)
mov (%rdi,%rdx,4),%ebx
mov %r13,%rax
nopw %cs:0x0(%rax,%rax,1)
cmp %ebx,(%rdi,%rax,4)
jge 1526 <func0+0x246>
mov (%r9,%rax,4),%ecx
cmp %ecx,(%r9,%rdx,4)
jg 1526 <func0+0x246>
add $0x1,%ecx
mov %ecx,(%r9,%rdx,4)
sub $0x1,%rax
cmp %edx,%eax
jg 1510 <func0+0x230>
sub $0x1,%rdx
test %edx,%edx
jns 1500 <func0+0x220>
mov 0x0(,%r11,4),%eax
add 0x0(,%r10,4),%eax
sub $0x1,%eax
cmp $0x1,%esi
jle 1650 <func0+0x370>
lea -0x1(%rsi),%ecx
cmp $0x2,%r12d
jbe 16a8 <func0+0x3c8>
mov %ecx,%edx
movd %eax,%xmm5
pcmpeqd %xmm3,%xmm3
mov $0x4,%eax
shr $0x2,%edx
pshufd $0x0,%xmm5,%xmm2
shl $0x4,%rdx
add $0x4,%rdx
xchg %ax,%ax
movdqu (%r9,%rax,1),%xmm0
movdqu (%r8,%rax,1),%xmm4
add $0x10,%rax
paddd %xmm4,%xmm0
paddd %xmm3,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 1580 <func0+0x2a0>
movdqa %xmm2,%xmm0
mov %ecx,%edi
psrldq $0x8,%xmm0
and $0xfffffffc,%edi
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
lea 0x1(%rdi),%edx
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm3
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm0
por %xmm3,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%eax
cmp %ecx,%edi
je 1650 <func0+0x370>
movslq %edx,%rdi
mov (%r8,%rdi,4),%ecx
add (%r9,%rdi,4),%ecx
sub $0x1,%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 1650 <func0+0x370>
movslq %ecx,%rdi
mov (%r9,%rdi,4),%ecx
add (%r8,%rdi,4),%ecx
sub $0x1,%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x2,%edx
cmp %esi,%edx
jge 1650 <func0+0x370>
movslq %edx,%rdx
mov (%r8,%rdx,4),%ecx
add (%r9,%rdx,4),%ecx
mov %ecx,%edx
sub $0x1,%edx
cmp %edx,%eax
cmovl %edx,%eax
mov -0x28(%rbp),%rsi
xor %fs:0x28,%rsi
jne 16f3 <func0+0x413>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1355 <func0+0x75>
nopl 0x0(%rax)
lea -0x1(%r12),%edx
test %r12d,%r12d
jne 14f0 <func0+0x210>
jmpq 1536 <func0+0x256>
lea -0x2(%rsi),%r12d
mov %r12d,%edx
test %r12d,%r12d
jns 14d9 <func0+0x1f9>
jmpq 1536 <func0+0x256>
mov $0x1,%edx
jmpq 1607 <func0+0x327>
movl $0x1,0x0(,%r10,4)
test %esi,%esi
je 16cc <func0+0x3ec>
mov $0x1,%eax
jmpq 140a <func0+0x12a>
xor %eax,%eax
jmpq 149c <func0+0x1bc>
cmp $0x1,%esi
jg 142a <func0+0x14a>
jmpq 145f <func0+0x17f>
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 13a7 <func0+0xc7>
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov r10d, esi
mov rbp, rsp
push r14
push r13
push r12
push rbx
lea ebx, [rsi+1]
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, ebx
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rsi, rax
mov rdx, rax
and rsi, 0FFFFFFFFFFFFF000h
and rdx, 0FFFFFFFFFFFFFFF0h
sub rcx, rsi
cmp rsp, rcx
jz short loc_1344
loc_132F:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_132F
loc_1344:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1676
loc_1356:
lea rsi, [rsp+1030h+var_102D]
mov rdx, rax
mov rcx, rsp
and rax, 0FFFFFFFFFFFFF000h
mov r12, rsi
sub rcx, rax
and rsi, 0FFFFFFFFFFFFFFFCh
and rdx, 0FFFFFFFFFFFFFFF0h
shr r12, 2
cmp rsp, rcx
jz short loc_1393
loc_137E:
sub rsp, 1000h
or [rsp+2030h+var_1038], 0
cmp rsp, rcx
jnz short loc_137E
loc_1393:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1711
loc_13A5:
lea r9, [rsp+2030h+var_202D]
mov r11, r9
and r9, 0FFFFFFFFFFFFFFFCh
shr r11, 2
test r10d, r10d
js loc_1681
cmp r10d, 2
jbe loc_1696
mov edx, ebx
movdqa xmm0, cs:xmmword_20D0
mov rax, rsi
shr edx, 2
shl rdx, 4
lea rcx, [rsi+rdx]
and edx, 10h
jz short loc_13F8
lea rax, [rsi+10h]
movups xmmword ptr [rsi], xmm0
cmp rax, rcx
jz short loc_1408
nop dword ptr [rax+00000000h]
loc_13F8:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rax, rcx
jnz short loc_13F8
loc_1408:
mov eax, ebx
and eax, 0FFFFFFFCh
test bl, 3
jz short loc_143A
movsxd rdx, eax
lea rdx, [rsi+rdx*4]
mov dword ptr [rdx], 1
cmp r10d, eax
jle short loc_143A
add eax, 2
mov dword ptr [rdx+4], 1
cmp r10d, eax
jl short loc_143A
loc_1433:
mov dword ptr [rdx+8], 1
loc_143A:
mov r13d, r10d
mov edx, 4
shl r13, 2
nop word ptr [rax+rax+00000000h]
loc_1450:
mov r8d, [rdi+rdx]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_1460:
cmp r8d, [rdi+rax]
jle short loc_1474
mov ecx, [rsi+rax]
cmp ecx, [rsi+rdx]
jl short loc_1474
add ecx, 1
mov [rsi+rdx], ecx
loc_1474:
add rax, 4
cmp rax, rdx
jnz short loc_1460
add rdx, 4
cmp rdx, r13
jnz short loc_1450
loc_1486:
cmp r10d, 2
jbe loc_16CF
mov edx, ebx
movdqa xmm0, cs:xmmword_20D0
mov rax, r9
shr edx, 2
shl rdx, 4
lea rcx, [r9+rdx]
and edx, 10h
jz short loc_14C0
lea rax, [r9+10h]
movups xmmword ptr [r9], xmm0
cmp rcx, rax
jz short loc_14D0
nop word ptr [rax+rax+00h]
loc_14C0:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rcx, rax
jnz short loc_14C0
loc_14D0:
mov eax, ebx
and eax, 0FFFFFFFCh
and ebx, 3
jz short loc_1502
movsxd rdx, eax
lea rdx, [r9+rdx*4]
mov dword ptr [rdx], 1
cmp r10d, eax
jle short loc_1502
add eax, 2
mov dword ptr [rdx+4], 1
cmp r10d, eax
jl short loc_1502
loc_14FB:
mov dword ptr [rdx+8], 1
loc_1502:
lea r13d, [r10-2]
lea r8d, [r10-1]
mov r12d, ds:dword_0[r12*4]
movsxd rax, r13d
movsxd r14, r8d
nop dword ptr [rax+rax+00000000h]
loc_1520:
mov ebx, [rdi+rax*4]
mov rdx, r14
nop word ptr [rax+rax+00000000h]
loc_1530:
cmp [rdi+rdx*4], ebx
jge short loc_1546
mov ecx, [r9+rdx*4]
cmp [r9+rax*4], ecx
jg short loc_1546
add ecx, 1
mov [r9+rax*4], ecx
loc_1546:
sub rdx, 1
cmp eax, edx
jl short loc_1530
sub rax, 1
test eax, eax
jns short loc_1520
add r12d, ds:dword_0[r11*4]
lea eax, [r12-1]
cmp r13d, 2
jbe loc_16C5
mov edx, r8d
movd xmm5, eax
pcmpeqd xmm3, xmm3
mov eax, 4
shr edx, 2
pshufd xmm2, xmm5, 0
shl rdx, 4
add rdx, 4
nop dword ptr [rax]
loc_1590:
movdqu xmm0, xmmword ptr [r9+rax]
movdqu xmm4, xmmword ptr [rsi+rax]
add rax, 10h
paddd xmm0, xmm4
paddd xmm0, xmm3
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rdx, rax
jnz short loc_1590
movdqa xmm1, xmm2
mov ecx, r8d
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
movdqa xmm0, xmm1
add ecx, 1
and r8d, 3
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
jz short loc_1656
loc_1611:
movsxd rdx, ecx
shl rdx, 2
add rsi, rdx
add rdx, r9
mov edi, [rsi]
add edi, [rdx]
sub edi, 1
cmp eax, edi
cmovl eax, edi
lea edi, [rcx+1]
cmp r10d, edi
jle short loc_1656
mov edi, [rdx+4]
add edi, [rsi+4]
sub edi, 1
cmp eax, edi
cmovl eax, edi
add ecx, 2
cmp r10d, ecx
jle short loc_1656
mov edx, [rdx+8]
add edx, [rsi+8]
sub edx, 1
cmp eax, edx
cmovl eax, edx
loc_1656:
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz loc_172A
lea rsp, [rbp-20h]
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_1676:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_1356
loc_1681:
mov eax, ds:dword_0[r12*4]
add eax, ds:dword_0[r11*4]
sub eax, 1
jmp short loc_1656
loc_1696:
mov ds:dword_0[r12*4], 1
test r10d, r10d
jz short loc_171C
mov dword ptr ds:byte_4[r12*4], 1
cmp r10d, 2
jnz loc_1486
mov rdx, rsi
jmp loc_1433
loc_16C5:
mov ecx, 1
jmp loc_1611
loc_16CF:
mov ds:dword_0[r11*4], 1
test r10d, r10d
jz short loc_16F9
mov dword ptr ds:byte_4[r11*4], 1
mov rdx, r9
cmp r10d, 2
jz loc_14FB
loc_16F9:
mov eax, ds:dword_0[r12*4]
add eax, ds:dword_0[r11*4]
sub eax, 1
jmp loc_1656
loc_1711:
or [rsp+rdx+2030h+var_2038], 0
jmp loc_13A5
loc_171C:
mov ds:dword_0[r11*4], 1
jmp short loc_16F9
loc_172A:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
unsigned int v3; // ebx
long long v4; // rax
__m128i *v5; // rcx
signed long long v6; // rdx
void *v7; // rsp
__m128i *v8; // rcx
signed long long v9; // rdx
void *v10; // rsp
__m128i si128; // xmm0
__m128i *v12; // rax
long long v13; // rdx
__m128i *v14; // rcx
signed int v15; // eax
__m128i *v16; // rdx
long long v17; // rdx
int v18; // r8d
unsigned long long v19; // rax
__int32 v20; // ecx
__m128i v21; // xmm0
__m128i *v22; // rax
long long v23; // rdx
__m128i *v24; // rcx
signed int v25; // eax
__m128i *v26; // rdx
int v27; // r8d
__int32 v28; // r12d
long long v29; // rax
int v30; // ebx
long long v31; // rdx
__int32 v32; // ecx
long long result; // rax
__m128i v34; // xmm5
long long v35; // rax
__m128i v36; // xmm2
__m128i v37; // xmm0
__m128i v38; // xmm4
__m128i v39; // xmm0
__m128i v40; // xmm1
__m128i v41; // xmm1
signed int v42; // ecx
__m128i v43; // xmm0
__m128i v44; // xmm0
__m128i v45; // xmm2
__m128i v46; // xmm1
long long v47; // rdx
__int32 *v48; // rsi
__int32 *v49; // rdx
int v50; // edi
int v51; // edi
int v52; // edx
long long v53; // [rsp+0h] [rbp-2038h]
__m128i v54; // [rsp+8h] [rbp-2030h] BYREF
_BYTE v55[4080]; // [rsp+18h] [rbp-2020h] BYREF
__m128i v56; // [rsp+1008h] [rbp-1030h] BYREF
_BYTE v57[4072]; // [rsp+1018h] [rbp-1020h] BYREF
_QWORD v58[6]; // [rsp+2008h] [rbp-30h] BYREF
v3 = a2 + 1;
v58[1] = __readfsqword(0x28u);
v4 = 4LL * (a2 + 1) + 15;
v5 = (__m128i *)((char *)v58 - (v4 & 0xFFFFFFFFFFFFF000LL));
if ( v58 != (_QWORD *)v5 )
{
while ( &v56 != v5 )
;
}
v6 = (4 * ((_WORD)a2 + 1) + 15) & 0xFF0;
v7 = alloca(v6);
if ( ((4 * ((_WORD)a2 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)&v55[v6 + 4072] = *(_QWORD *)&v55[v6 + 4072];
v8 = (__m128i *)((char *)&v56 - (v4 & 0xFFFFFFFFFFFFF000LL));
if ( &v56 != v8 )
{
while ( &v54 != v8 )
;
}
v9 = (4 * (_WORD)v3 + 15) & 0xFF0;
v10 = alloca(v9);
if ( ((4 * (_WORD)v3 + 15) & 0xFF0) != 0 )
*(long long *)((char *)&v53 + v9) = *(long long *)((char *)&v53 + v9);
if ( a2 < 0 )
return (unsigned int)(v54.m128i_i32[0] + v56.m128i_i32[0] - 1);
if ( (unsigned int)a2 > 2 )
{
si128 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v12 = &v56;
v13 = 16LL * (v3 >> 2);
v14 = (__m128i *)((char *)&v56 + v13);
if ( (v13 & 0x10) == 0 || (v12 = (__m128i *)v57, v56 = si128, v57 != (_BYTE *)v14) )
{
do
{
*v12 = si128;
v12 += 2;
v12[-1] = si128;
}
while ( v12 != v14 );
}
v15 = v3 & 0xFFFFFFFC;
if ( (v3 & 3) == 0 )
goto LABEL_18;
v16 = (__m128i *)((char *)&v56 + 4 * v15);
v16->m128i_i32[0] = 1;
if ( a2 <= v15 )
goto LABEL_18;
v16->m128i_i32[1] = 1;
if ( a2 < v15 + 2 )
goto LABEL_18;
goto LABEL_17;
}
v56.m128i_i32[0] = 1;
if ( !a2 )
{
v54.m128i_i32[0] = 1;
return (unsigned int)(v54.m128i_i32[0] + v56.m128i_i32[0] - 1);
}
v56.m128i_i32[1] = 1;
if ( a2 == 2 )
{
v16 = &v56;
LABEL_17:
v16->m128i_i32[2] = 1;
LABEL_18:
v17 = 4LL;
do
{
v18 = *(_DWORD *)(a1 + v17);
v19 = 0LL;
do
{
if ( v18 > *(_DWORD *)(a1 + v19) )
{
v20 = v56.m128i_i32[v19 / 4];
if ( v20 >= v56.m128i_i32[(unsigned long long)v17 / 4] )
v56.m128i_i32[(unsigned long long)v17 / 4] = v20 + 1;
}
v19 += 4LL;
}
while ( v19 != v17 );
v17 += 4LL;
}
while ( v17 != 4LL * (unsigned int)a2 );
}
if ( (unsigned int)a2 <= 2 )
{
v54.m128i_i32[0] = 1;
v54.m128i_i32[1] = 1;
v26 = &v54;
if ( a2 == 2 )
{
LABEL_32:
v26->m128i_i32[2] = 1;
goto LABEL_33;
}
return (unsigned int)(v54.m128i_i32[0] + v56.m128i_i32[0] - 1);
}
v21 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v22 = &v54;
v23 = 16LL * (v3 >> 2);
v24 = (__m128i *)((char *)&v54 + v23);
if ( (v23 & 0x10) == 0 || (v22 = (__m128i *)v55, v54 = v21, v24 != (__m128i *)v55) )
{
do
{
*v22 = v21;
v22 += 2;
v22[-1] = v21;
}
while ( v24 != v22 );
}
v25 = v3 & 0xFFFFFFFC;
if ( (v3 & 3) != 0 )
{
v26 = (__m128i *)((char *)&v54 + 4 * v25);
v26->m128i_i32[0] = 1;
if ( a2 > v25 )
{
v26->m128i_i32[1] = 1;
if ( a2 >= v25 + 2 )
goto LABEL_32;
}
}
LABEL_33:
v27 = a2 - 1;
v28 = v56.m128i_i32[0];
v29 = a2 - 2;
do
{
v30 = *(_DWORD *)(a1 + 4 * v29);
v31 = v27;
do
{
if ( *(_DWORD *)(a1 + 4 * v31) < v30 )
{
v32 = v54.m128i_i32[v31];
if ( v54.m128i_i32[v29] <= v32 )
v54.m128i_i32[v29] = v32 + 1;
}
--v31;
}
while ( (int)v29 < (int)v31 );
--v29;
}
while ( (int)v29 >= 0 );
result = (unsigned int)(v54.m128i_i32[0] + v28 - 1);
if ( (unsigned int)(a2 - 2) <= 2 )
{
v42 = 1;
}
else
{
v34 = _mm_cvtsi32_si128(result);
v35 = 4LL;
v36 = _mm_shuffle_epi32(v34, 0);
do
{
v37 = _mm_loadu_si128((__m128i *)((char *)&v54 + v35));
v38 = _mm_loadu_si128((__m128i *)((char *)&v56 + v35));
v35 += 16LL;
v39 = _mm_add_epi32(_mm_add_epi32(v37, v38), (__m128i)-1LL);
v40 = _mm_cmpgt_epi32(v39, v36);
v36 = _mm_or_si128(_mm_andnot_si128(v40, v36), _mm_and_si128(v39, v40));
}
while ( 16LL * ((unsigned int)v27 >> 2) + 4 != v35 );
v41 = _mm_srli_si128(v36, 8);
v42 = (v27 & 0xFFFFFFFC) + 1;
v43 = _mm_cmpgt_epi32(v41, v36);
v44 = _mm_or_si128(_mm_andnot_si128(v43, v36), _mm_and_si128(v41, v43));
v45 = _mm_srli_si128(v44, 4);
v46 = _mm_cmpgt_epi32(v45, v44);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v46, v44), _mm_and_si128(v45, v46)));
if ( (v27 & 3) == 0 )
return result;
}
v47 = v42;
v48 = &v56.m128i_i32[v47];
v49 = &v54.m128i_i32[v47];
v50 = *v49 + *v48 - 1;
if ( (int)result < v50 )
result = (unsigned int)v50;
if ( a2 > v42 + 1 )
{
v51 = v48[1] + v49[1] - 1;
if ( (int)result < v51 )
result = (unsigned int)v51;
if ( a2 > v42 + 2 )
{
v52 = v48[2] + v49[2] - 1;
if ( (int)result < v52 )
return (unsigned int)v52;
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV R10D,ESI
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
LEA EBX,[RSI + 0x1]
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,EBX
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
MOV RDX,RAX
AND RSI,-0x1000
AND RDX,-0x10
SUB RCX,RSI
CMP RSP,RCX
JZ 0x00101344
LAB_0010132f:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010132f
LAB_00101344:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101676
LAB_00101356:
LEA RSI,[RSP + 0x3]
MOV RDX,RAX
MOV RCX,RSP
AND RAX,-0x1000
MOV R12,RSI
SUB RCX,RAX
AND RSI,-0x4
AND RDX,-0x10
SHR R12,0x2
CMP RSP,RCX
JZ 0x00101393
LAB_0010137e:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010137e
LAB_00101393:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101711
LAB_001013a5:
LEA R9,[RSP + 0x3]
MOV R11,R9
AND R9,-0x4
SHR R11,0x2
TEST R10D,R10D
JS 0x00101681
CMP R10D,0x2
JBE 0x00101696
MOV EDX,EBX
MOVDQA XMM0,xmmword ptr [0x001020d0]
MOV RAX,RSI
SHR EDX,0x2
SHL RDX,0x4
LEA RCX,[RSI + RDX*0x1]
AND EDX,0x10
JZ 0x001013f8
LEA RAX,[RSI + 0x10]
MOVUPS xmmword ptr [RSI],XMM0
CMP RAX,RCX
JZ 0x00101408
NOP dword ptr [RAX]
LAB_001013f8:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RCX
JNZ 0x001013f8
LAB_00101408:
MOV EAX,EBX
AND EAX,0xfffffffc
TEST BL,0x3
JZ 0x0010143a
MOVSXD RDX,EAX
LEA RDX,[RSI + RDX*0x4]
MOV dword ptr [RDX],0x1
CMP R10D,EAX
JLE 0x0010143a
ADD EAX,0x2
MOV dword ptr [RDX + 0x4],0x1
CMP R10D,EAX
JL 0x0010143a
LAB_00101433:
MOV dword ptr [RDX + 0x8],0x1
LAB_0010143a:
MOV R13D,R10D
MOV EDX,0x4
SHL R13,0x2
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101450:
MOV R8D,dword ptr [RDI + RDX*0x1]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101460:
CMP R8D,dword ptr [RDI + RAX*0x1]
JLE 0x00101474
MOV ECX,dword ptr [RSI + RAX*0x1]
CMP ECX,dword ptr [RSI + RDX*0x1]
JL 0x00101474
ADD ECX,0x1
MOV dword ptr [RSI + RDX*0x1],ECX
LAB_00101474:
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101460
ADD RDX,0x4
CMP RDX,R13
JNZ 0x00101450
LAB_00101486:
CMP R10D,0x2
JBE 0x001016cf
MOV EDX,EBX
MOVDQA XMM0,xmmword ptr [0x001020d0]
MOV RAX,R9
SHR EDX,0x2
SHL RDX,0x4
LEA RCX,[R9 + RDX*0x1]
AND EDX,0x10
JZ 0x001014c0
LEA RAX,[R9 + 0x10]
MOVUPS xmmword ptr [R9],XMM0
CMP RCX,RAX
JZ 0x001014d0
NOP word ptr [RAX + RAX*0x1]
LAB_001014c0:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RCX,RAX
JNZ 0x001014c0
LAB_001014d0:
MOV EAX,EBX
AND EAX,0xfffffffc
AND EBX,0x3
JZ 0x00101502
MOVSXD RDX,EAX
LEA RDX,[R9 + RDX*0x4]
MOV dword ptr [RDX],0x1
CMP R10D,EAX
JLE 0x00101502
ADD EAX,0x2
MOV dword ptr [RDX + 0x4],0x1
CMP R10D,EAX
JL 0x00101502
LAB_001014fb:
MOV dword ptr [RDX + 0x8],0x1
LAB_00101502:
LEA R13D,[R10 + -0x2]
LEA R8D,[R10 + -0x1]
MOV R12D,dword ptr [R12*0x4]
MOVSXD RAX,R13D
MOVSXD R14,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
MOV EBX,dword ptr [RDI + RAX*0x4]
MOV RDX,R14
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101530:
CMP dword ptr [RDI + RDX*0x4],EBX
JGE 0x00101546
MOV ECX,dword ptr [R9 + RDX*0x4]
CMP dword ptr [R9 + RAX*0x4],ECX
JG 0x00101546
ADD ECX,0x1
MOV dword ptr [R9 + RAX*0x4],ECX
LAB_00101546:
SUB RDX,0x1
CMP EAX,EDX
JL 0x00101530
SUB RAX,0x1
TEST EAX,EAX
JNS 0x00101520
ADD R12D,dword ptr [R11*0x4]
LEA EAX,[R12 + -0x1]
CMP R13D,0x2
JBE 0x001016c5
MOV EDX,R8D
MOVD XMM5,EAX
PCMPEQD XMM3,XMM3
MOV EAX,0x4
SHR EDX,0x2
PSHUFD XMM2,XMM5,0x0
SHL RDX,0x4
ADD RDX,0x4
NOP dword ptr [RAX]
LAB_00101590:
MOVDQU XMM0,xmmword ptr [R9 + RAX*0x1]
MOVDQU XMM4,xmmword ptr [RSI + RAX*0x1]
ADD RAX,0x10
PADDD XMM0,XMM4
PADDD XMM0,XMM3
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RDX,RAX
JNZ 0x00101590
MOVDQA XMM1,XMM2
MOV ECX,R8D
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
MOVDQA XMM0,XMM1
ADD ECX,0x1
AND R8D,0x3
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
JZ 0x00101656
LAB_00101611:
MOVSXD RDX,ECX
SHL RDX,0x2
ADD RSI,RDX
ADD RDX,R9
MOV EDI,dword ptr [RSI]
ADD EDI,dword ptr [RDX]
SUB EDI,0x1
CMP EAX,EDI
CMOVL EAX,EDI
LEA EDI,[RCX + 0x1]
CMP R10D,EDI
JLE 0x00101656
MOV EDI,dword ptr [RDX + 0x4]
ADD EDI,dword ptr [RSI + 0x4]
SUB EDI,0x1
CMP EAX,EDI
CMOVL EAX,EDI
ADD ECX,0x2
CMP R10D,ECX
JLE 0x00101656
MOV EDX,dword ptr [RDX + 0x8]
ADD EDX,dword ptr [RSI + 0x8]
SUB EDX,0x1
CMP EAX,EDX
CMOVL EAX,EDX
LAB_00101656:
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010172a
LEA RSP,[RBP + -0x20]
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00101676:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101356
LAB_00101681:
MOV EAX,dword ptr [R12*0x4]
ADD EAX,dword ptr [R11*0x4]
SUB EAX,0x1
JMP 0x00101656
LAB_00101696:
MOV dword ptr [R12*0x4],0x1
TEST R10D,R10D
JZ 0x0010171c
MOV dword ptr [0x4 + R12*0x4],0x1
CMP R10D,0x2
JNZ 0x00101486
MOV RDX,RSI
JMP 0x00101433
LAB_001016c5:
MOV ECX,0x1
JMP 0x00101611
LAB_001016cf:
MOV dword ptr [R11*0x4],0x1
TEST R10D,R10D
JZ 0x001016f9
MOV dword ptr [0x4 + R11*0x4],0x1
MOV RDX,R9
CMP R10D,0x2
JZ 0x001014fb
LAB_001016f9:
MOV EAX,dword ptr [R12*0x4]
ADD EAX,dword ptr [R11*0x4]
SUB EAX,0x1
JMP 0x00101656
LAB_00101711:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001013a5
LAB_0010171c:
MOV dword ptr [R11*0x4],0x1
JMP 0x001016f9
LAB_0010172a:
CALL 0x00101080 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(long param_1,uint param_2)
{
int iVar1;
long lVar2;
long lVar3;
int *puVar4;
int8 uVar5;
int8 uVar6;
uint uVar7;
uint uVar8;
int8 *puVar9;
long lVar10;
int8 *puVar11;
int iVar12;
ulong uVar13;
int4 *puVar14;
long lVar15;
int4 *puVar16;
int *piVar17;
int *puVar18;
int *puVar20;
int *piVar22;
ulong uVar23;
ulong uVar24;
long in_FS_OFFSET;
uint uVar25;
uint uVar26;
uint uVar27;
uint uVar28;
uint uVar29;
uint uVar30;
uint uVar31;
uint uVar32;
uint uVar33;
uint uVar34;
uint uVar35;
int auStack_38 [8];
long local_30;
int *puVar19;
int *puVar21;
uVar6 = _UNK_001020d8;
uVar5 = _DAT_001020d0;
uVar8 = param_2 + 1;
puVar18 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar23 = (long)(int)uVar8 * 4 + 0xf;
puVar19 = auStack_38;
puVar20 = auStack_38;
while (puVar19 != auStack_38 + -(uVar23 & 0xfffffffffffff000)) {
puVar18 = puVar20 + -0x1000;
*(int8 *)(puVar20 + -8) = *(int8 *)(puVar20 + -8);
puVar19 = puVar20 + -0x1000;
puVar20 = puVar20 + -0x1000;
}
uVar24 = (ulong)((uint)uVar23 & 0xff0);
lVar2 = -uVar24;
puVar9 = (int8 *)(puVar18 + lVar2);
puVar14 = (int4 *)(puVar18 + lVar2);
puVar20 = puVar18 + lVar2;
puVar21 = puVar18 + lVar2;
if (uVar24 != 0) {
*(int8 *)(puVar18 + -8) = *(int8 *)(puVar18 + -8);
}
uVar24 = (ulong)(puVar18 + lVar2 + 3) >> 2;
puVar4 = puVar18 + lVar2;
while (puVar21 != puVar18 + (lVar2 - (uVar23 & 0xfffffffffffff000))) {
puVar20 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar21 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar23 = (ulong)((uint)uVar23 & 0xff0);
lVar3 = -uVar23;
puVar11 = (int8 *)(puVar20 + lVar3);
puVar16 = (int4 *)(puVar20 + lVar3);
if (uVar23 != 0) {
*(int8 *)(puVar20 + -8) = *(int8 *)(puVar20 + -8);
}
uVar23 = (ulong)(puVar20 + lVar3 + 3) >> 2;
if ((int)param_2 < 0) {
uVar8 = (*(int *)(uVar24 * 4) + *(int *)(uVar23 * 4)) - 1;
goto LAB_00101656;
}
if (param_2 < 3) {
*(int4 *)(uVar24 * 4) = 1;
if (param_2 != 0) {
*(int4 *)(uVar24 * 4 + 4) = 1;
if (param_2 == 2) goto LAB_00101433;
goto LAB_00101486;
}
*(int4 *)(uVar23 * 4) = 1;
LAB_001016f9:
uVar8 = (*(int *)(uVar24 * 4) + *(int *)(uVar23 * 4)) - 1;
}
else {
uVar13 = (ulong)(uVar8 >> 2) * 0x10;
if ((uVar13 & 0x10) == 0) goto LAB_001013f8;
*(int8 *)(puVar18 + lVar2) = _DAT_001020d0;
*(int8 *)(puVar18 + lVar2 + 8) = uVar6;
for (puVar9 = (int8 *)(puVar18 + lVar2 + 0x10);
puVar9 != (int8 *)(puVar18 + uVar13 + lVar2); puVar9 = puVar9 + 4) {
LAB_001013f8:
*puVar9 = uVar5;
puVar9[1] = uVar6;
puVar9[2] = uVar5;
puVar9[3] = uVar6;
}
uVar7 = uVar8 & 0xfffffffc;
if ((uVar8 & 3) != 0) {
puVar14 = (int4 *)(puVar18 + (long)(int)uVar7 * 4 + lVar2);
*puVar14 = 1;
if (((int)uVar7 < (int)param_2) && (puVar14[1] = 1, (int)(uVar7 + 2) <= (int)param_2)) {
LAB_00101433:
puVar14[2] = 1;
}
}
lVar15 = 4;
do {
iVar12 = *(int *)(param_1 + lVar15);
lVar10 = 0;
do {
if ((*(int *)(param_1 + lVar10) < iVar12) &&
(*(int *)(puVar18 + lVar15 + lVar2) <= *(int *)(puVar18 + lVar10 + lVar2))) {
*(int *)(puVar18 + lVar15 + lVar2) = *(int *)(puVar18 + lVar10 + lVar2) + 1;
}
lVar10 = lVar10 + 4;
} while (lVar10 != lVar15);
lVar15 = lVar15 + 4;
} while (lVar15 != (ulong)param_2 << 2);
LAB_00101486:
uVar6 = _UNK_001020d8;
uVar5 = _DAT_001020d0;
if (param_2 < 3) {
*(int4 *)(uVar23 * 4) = 1;
if ((param_2 == 0) || (*(int4 *)(uVar23 * 4 + 4) = 1, param_2 != 2)) goto LAB_001016f9;
LAB_001014fb:
puVar16[2] = 1;
}
else {
uVar13 = (ulong)(uVar8 >> 2) * 0x10;
if ((uVar13 & 0x10) == 0) goto LAB_001014c0;
*(int8 *)(puVar20 + lVar3) = _DAT_001020d0;
*(int8 *)(puVar20 + lVar3 + 8) = uVar6;
for (puVar11 = (int8 *)(puVar20 + lVar3 + 0x10);
(int8 *)(puVar20 + uVar13 + lVar3) != puVar11; puVar11 = puVar11 + 4) {
LAB_001014c0:
*puVar11 = uVar5;
puVar11[1] = uVar6;
puVar11[2] = uVar5;
puVar11[3] = uVar6;
}
uVar7 = uVar8 & 0xfffffffc;
if ((uVar8 & 3) != 0) {
puVar16 = (int4 *)(puVar20 + (long)(int)uVar7 * 4 + lVar3);
*puVar16 = 1;
if (((int)uVar7 < (int)param_2) && (puVar16[1] = 1, (int)(uVar7 + 2) <= (int)param_2))
goto LAB_001014fb;
}
}
uVar7 = param_2 - 1;
iVar12 = *(int *)(uVar24 * 4);
lVar15 = (long)(int)(param_2 - 2);
do {
iVar1 = *(int *)(param_1 + lVar15 * 4);
lVar10 = (long)(int)uVar7;
do {
if ((*(int *)(param_1 + lVar10 * 4) < iVar1) &&
(*(int *)(puVar20 + lVar15 * 4 + lVar3) <= *(int *)(puVar20 + lVar10 * 4 + lVar3))) {
*(int *)(puVar20 + lVar15 * 4 + lVar3) = *(int *)(puVar20 + lVar10 * 4 + lVar3) + 1;
}
lVar10 = lVar10 + -1;
} while ((int)lVar15 < (int)lVar10);
lVar15 = lVar15 + -1;
} while (-1 < (int)lVar15);
uVar8 = (iVar12 + *(int *)(uVar23 * 4)) - 1;
if (param_2 - 2 < 3) {
iVar12 = 1;
}
else {
lVar15 = 4;
uVar34 = uVar8;
uVar30 = uVar8;
uVar35 = uVar8;
do {
piVar17 = (int *)(puVar20 + lVar15 + lVar3);
piVar22 = (int *)(puVar18 + lVar15 + lVar2);
lVar15 = lVar15 + 0x10;
uVar25 = (*piVar17 + *piVar22) - 1;
uVar26 = (piVar17[1] + piVar22[1]) - 1;
uVar27 = (piVar17[2] + piVar22[2]) - 1;
uVar28 = (piVar17[3] + piVar22[3]) - 1;
uVar29 = -(uint)((int)uVar8 < (int)uVar25);
uVar31 = -(uint)((int)uVar34 < (int)uVar26);
uVar32 = -(uint)((int)uVar30 < (int)uVar27);
uVar33 = -(uint)((int)uVar35 < (int)uVar28);
uVar8 = ~uVar29 & uVar8 | uVar25 & uVar29;
uVar34 = ~uVar31 & uVar34 | uVar26 & uVar31;
uVar30 = ~uVar32 & uVar30 | uVar27 & uVar32;
uVar35 = ~uVar33 & uVar35 | uVar28 & uVar33;
} while ((ulong)(uVar7 >> 2) * 0x10 + 4 != lVar15);
iVar12 = (uVar7 & 0xfffffffc) + 1;
uVar8 = ~-(uint)((int)uVar8 < (int)uVar30) & uVar8 |
uVar30 & -(uint)((int)uVar8 < (int)uVar30);
uVar34 = ~-(uint)((int)uVar34 < (int)uVar35) & uVar34 |
uVar35 & -(uint)((int)uVar34 < (int)uVar35);
uVar30 = -(uint)((int)uVar8 < (int)uVar34);
uVar8 = ~uVar30 & uVar8 | uVar34 & uVar30;
if ((uVar7 & 3) == 0) goto LAB_00101656;
}
piVar22 = (int *)(puVar18 + (long)iVar12 * 4 + lVar2);
piVar17 = (int *)(puVar20 + (long)iVar12 * 4 + lVar3);
uVar7 = (*piVar22 + *piVar17) - 1;
if ((int)uVar8 < (int)uVar7) {
uVar8 = uVar7;
}
if (iVar12 + 1 < (int)param_2) {
uVar7 = (piVar17[1] + piVar22[1]) - 1;
if ((int)uVar8 < (int)uVar7) {
uVar8 = uVar7;
}
if ((iVar12 + 2 < (int)param_2) &&
(uVar7 = (piVar17[2] + piVar22[2]) - 1, (int)uVar8 < (int)uVar7)) {
uVar8 = uVar7;
}
}
}
LAB_00101656:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar20 + lVar3 + -8) = 0x10172f;
__stack_chk_fail();
}
return uVar8;
} |
5,984 | func0 |
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <string.h>
| char *func0(const char *str1) {
static char result[200];
int has_upper = 0, has_lower = 0, has_digit = 0, is_valid = 1;
int length = strlen(str1);
for (int i = 0; i < length; i++) {
if (isupper(str1[i])) {
has_upper = 1;
}
if (islower(str1[i])) {
has_lower = 1;
}
if (isdigit(str1[i])) {
has_digit = 1;
}
}
result[0] = '\0';
if (!has_upper) {
strcat(result, "String must have 1 upper case character,");
}
if (!has_lower) {
strcat(result, "String must have 1 lower case character,");
}
if (!has_digit) {
strcat(result, "String must have 1 number,");
}
if (length < 8) {
strcat(result, "String length should be atleast 8,");
}
if (has_upper && has_lower && has_digit && length >= 8) {
strcpy(result, "Valid string.");
} else {
// Remove the last comma
int lastIdx = strlen(result) - 1;
if (result[lastIdx] == ',') {
result[lastIdx] = '\0';
}
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "String must have 1 upper case character,String must have 1 number,String length should be atleast 8") == 0);
assert(strcmp(func0("123python"), "String must have 1 upper case character") == 0);
assert(strcmp(func0("123Python"), "Valid string.") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x1,-0xc(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 129c <func0+0xf3>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 1228 <func0+0x7f>
movl $0x1,-0x1c(%rbp)
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 1260 <func0+0xb7>
movl $0x1,-0x18(%rbp)
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 1298 <func0+0xef>
movl $0x1,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 11f0 <func0+0x47>
movb $0x0,0x2d91(%rip)
cmpl $0x0,-0x1c(%rbp)
jne 132d <func0+0x184>
lea 0x2d84(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2d5f(%rip),%rax
add %rdx,%rax
movabs $0x6d20676e69727453,%rsi
movabs $0x6576616820747375,%rdi
mov %rsi,(%rax)
mov %rdi,0x8(%rax)
movabs $0x7265707075203120,%rsi
movabs $0x6863206573616320,%rdi
mov %rsi,0x10(%rax)
mov %rdi,0x18(%rax)
movabs $0x2c72657463617261,%rsi
mov %rsi,0x20(%rax)
movb $0x0,0x28(%rax)
cmpl $0x0,-0x18(%rbp)
jne 13ab <func0+0x202>
lea 0x2d06(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2ce1(%rip),%rax
add %rdx,%rax
movabs $0x6d20676e69727453,%rsi
movabs $0x6576616820747375,%rdi
mov %rsi,(%rax)
mov %rdi,0x8(%rax)
movabs $0x7265776f6c203120,%rsi
movabs $0x6863206573616320,%rdi
mov %rsi,0x10(%rax)
mov %rdi,0x18(%rax)
movabs $0x2c72657463617261,%rsi
mov %rsi,0x20(%rax)
movb $0x0,0x28(%rax)
cmpl $0x0,-0x14(%rbp)
jne 1413 <func0+0x26a>
lea 0x2c88(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2c63(%rip),%rax
add %rdx,%rax
movabs $0x6d20676e69727453,%rsi
movabs $0x6576616820747375,%rdi
mov %rsi,(%rax)
mov %rdi,0x8(%rax)
movabs $0x65626d756e203120,%rsi
mov %rsi,0x10(%rax)
movw $0x2c72,0x18(%rax)
movb $0x0,0x1a(%rax)
cmpl $0x7,-0x8(%rbp)
jg 1489 <func0+0x2e0>
lea 0x2c20(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2bfb(%rip),%rax
add %rdx,%rax
movabs $0x6c20676e69727453,%rsi
movabs $0x6873206874676e65,%rdi
mov %rsi,(%rax)
mov %rdi,0x8(%rax)
movabs $0x20656220646c756f,%rsi
movabs $0x20747361656c7461,%rdi
mov %rsi,0x10(%rax)
mov %rdi,0x18(%rax)
movw $0x2c38,0x20(%rax)
movb $0x0,0x22(%rax)
cmpl $0x0,-0x1c(%rbp)
je 14c7 <func0+0x31e>
cmpl $0x0,-0x18(%rbp)
je 14c7 <func0+0x31e>
cmpl $0x0,-0x14(%rbp)
je 14c7 <func0+0x31e>
cmpl $0x7,-0x8(%rbp)
jle 14c7 <func0+0x31e>
movabs $0x74732064696c6156,%rax
mov %rax,0x2b8e(%rip)
movl $0x676e6972,0x2b8c(%rip)
movw $0x2e,0x2b87(%rip)
jmp 14fd <func0+0x354>
lea 0x2b72(%rip),%rdi
callq 1080 <strlen@plt>
sub $0x1,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x2b5b(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
cmp $0x2c,%al
jne 14fd <func0+0x354>
mov -0x4(%rbp),%eax
cltq
lea 0x2b47(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2b3c(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_C], 1
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov [rbp+var_10], 0
jmp loc_129C
loc_11F0:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_1228
mov [rbp+var_1C], 1
loc_1228:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_10]
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
jz short loc_1260
mov [rbp+var_18], 1
loc_1260:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_10]
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, 800h
test eax, eax
jz short loc_1298
mov [rbp+var_14], 1
loc_1298:
add [rbp+var_10], 1
loc_129C:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_8]
jl loc_11F0
mov byte ptr cs:result_1, 0
cmp [rbp+var_1C], 0
jnz short loc_1324
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov rsi, 6D20676E69727453h
mov rdi, 6576616820747375h
mov [rax], rsi
mov [rax+8], rdi
mov rsi, 7265707075203120h
mov rdi, 6863206573616320h
mov [rax+10h], rsi
mov [rax+18h], rdi
mov rsi, 6168632065736163h
mov rdi, 2C726574636172h
mov [rax+19h], rsi
mov [rax+21h], rdi
loc_1324:
cmp [rbp+var_18], 0
jnz short loc_1399
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov rsi, 6D20676E69727453h
mov rdi, 6576616820747375h
mov [rax], rsi
mov [rax+8], rdi
mov rsi, 7265776F6C203120h
mov rdi, 6863206573616320h
mov [rax+10h], rsi
mov [rax+18h], rdi
mov rsi, 6168632065736163h
mov rdi, 2C726574636172h
mov [rax+19h], rsi
mov [rax+21h], rdi
loc_1399:
cmp [rbp+var_14], 0
jnz short loc_13F2
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov rsi, 6D20676E69727453h
mov rdi, 6576616820747375h
mov [rax], rsi
mov [rax+8], rdi
mov rsi, 2031206576616820h
mov rdi, 2C7265626D756Eh
mov [rax+0Bh], rsi
mov [rax+13h], rdi
loc_13F2:
cmp [rbp+var_8], 7
jg short loc_1452
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov rsi, 6C20676E69727453h
mov rdi, 6873206874676E65h
mov [rax], rsi
mov [rax+8], rdi
mov rsi, 20656220646C756Fh
mov rdi, 20747361656C7461h
mov [rax+10h], rsi
mov [rax+18h], rdi
mov dword ptr [rax+1Fh], 2C3820h
loc_1452:
cmp [rbp+var_1C], 0
jz short loc_148E
cmp [rbp+var_18], 0
jz short loc_148E
cmp [rbp+var_14], 0
jz short loc_148E
cmp [rbp+var_8], 7
jle short loc_148E
mov rax, 74732064696C6156h
mov cs:result_1, rax
mov rax, 2E676E69727473h
mov cs:result_1+6, rax
jmp short loc_14C7
loc_148E:
lea rax, result_1
mov rdi, rax; s
call _strlen
sub eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
movzx eax, byte ptr [rax+rdx]
cmp al, 2Ch ; ','
jnz short loc_14C7
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
mov byte ptr [rax+rdx], 0
loc_14C7:
lea rax, result_1
leave
retn | char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-1Ch]
int v3; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v6; // [rsp+28h] [rbp-8h]
int v7; // [rsp+2Ch] [rbp-4h]
v2 = 0;
v3 = 0;
v4 = 0;
v6 = strlen(a1);
for ( i = 0; i < v6; ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 0x100) != 0 )
v2 = 1;
if ( ((*__ctype_b_loc())[a1[i]] & 0x200) != 0 )
v3 = 1;
if ( ((*__ctype_b_loc())[a1[i]] & 0x800) != 0 )
v4 = 1;
}
result_1[0] = 0;
if ( !v2 )
strcpy(&result_1[strlen(result_1)], "String must have 1 upper case character,");
if ( !v3 )
strcpy(&result_1[strlen(result_1)], "String must have 1 lower case character,");
if ( !v4 )
strcpy(&result_1[strlen(result_1)], "String must have 1 number,");
if ( v6 <= 7 )
strcpy(&result_1[strlen(result_1)], "String length should be atleast 8,");
if ( v2 && v3 && v4 && v6 > 7 )
{
strcpy(result_1, "Valid string.");
}
else
{
v7 = strlen(result_1) - 1;
if ( result_1[v7] == 44 )
result_1[v7] = 0;
}
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0xc],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010129c
LAB_001011f0:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x00101228
MOV dword ptr [RBP + -0x1c],0x1
LAB_00101228:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x00101260
MOV dword ptr [RBP + -0x18],0x1
LAB_00101260:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x00101298
MOV dword ptr [RBP + -0x14],0x1
LAB_00101298:
ADD dword ptr [RBP + -0x10],0x1
LAB_0010129c:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001011f0
MOV byte ptr [0x00104040],0x0
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00101324
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101080
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV RSI,0x6d20676e69727453
MOV RDI,0x6576616820747375
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RDI
MOV RSI,0x7265707075203120
MOV RDI,0x6863206573616320
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],RDI
MOV RSI,0x6168632065736163
MOV RDI,0x2c726574636172
MOV qword ptr [RAX + 0x19],RSI
MOV qword ptr [RAX + 0x21],RDI
LAB_00101324:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00101399
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101080
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV RSI,0x6d20676e69727453
MOV RDI,0x6576616820747375
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RDI
MOV RSI,0x7265776f6c203120
MOV RDI,0x6863206573616320
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],RDI
MOV RSI,0x6168632065736163
MOV RDI,0x2c726574636172
MOV qword ptr [RAX + 0x19],RSI
MOV qword ptr [RAX + 0x21],RDI
LAB_00101399:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001013f2
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101080
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV RSI,0x6d20676e69727453
MOV RDI,0x6576616820747375
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RDI
MOV RSI,0x2031206576616820
MOV RDI,0x2c7265626d756e
MOV qword ptr [RAX + 0xb],RSI
MOV qword ptr [RAX + 0x13],RDI
LAB_001013f2:
CMP dword ptr [RBP + -0x8],0x7
JG 0x00101452
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101080
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV RSI,0x6c20676e69727453
MOV RDI,0x6873206874676e65
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RDI
MOV RSI,0x20656220646c756f
MOV RDI,0x20747361656c7461
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],RDI
MOV dword ptr [RAX + 0x1f],0x2c3820
LAB_00101452:
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0010148e
CMP dword ptr [RBP + -0x18],0x0
JZ 0x0010148e
CMP dword ptr [RBP + -0x14],0x0
JZ 0x0010148e
CMP dword ptr [RBP + -0x8],0x7
JLE 0x0010148e
MOV RAX,0x74732064696c6156
MOV qword ptr [0x00104040],RAX
MOV RAX,0x2e676e69727473
MOV qword ptr [0x00104046],RAX
JMP 0x001014c7
LAB_0010148e:
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101080
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
CMP AL,0x2c
JNZ 0x001014c7
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LAB_001014c7:
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
int iVar4;
size_t sVar5;
ushort **ppuVar6;
int local_18;
bVar1 = false;
bVar2 = false;
bVar3 = false;
sVar5 = strlen(param_1);
iVar4 = (int)sVar5;
for (local_18 = 0; local_18 < iVar4; local_18 = local_18 + 1) {
ppuVar6 = __ctype_b_loc();
if (((*ppuVar6)[param_1[local_18]] & 0x100) != 0) {
bVar1 = true;
}
ppuVar6 = __ctype_b_loc();
if (((*ppuVar6)[param_1[local_18]] & 0x200) != 0) {
bVar2 = true;
}
ppuVar6 = __ctype_b_loc();
if (((*ppuVar6)[param_1[local_18]] & 0x800) != 0) {
bVar3 = true;
}
}
result_1[0] = 0;
if (!bVar1) {
sVar5 = strlen(result_1);
*(int8 *)(result_1 + sVar5) = 0x6d20676e69727453;
*(int8 *)(result_1 + sVar5 + 8) = 0x6576616820747375;
*(int8 *)(result_1 + sVar5 + 0x10) = 0x7265707075203120;
*(int8 *)(result_1 + sVar5 + 0x18) = 0x6863206573616320;
*(int8 *)(result_1 + sVar5 + 0x19) = 0x6168632065736163;
*(int8 *)(result_1 + sVar5 + 0x21) = 0x2c726574636172;
}
if (!bVar2) {
sVar5 = strlen(result_1);
*(int8 *)(result_1 + sVar5) = 0x6d20676e69727453;
*(int8 *)(result_1 + sVar5 + 8) = 0x6576616820747375;
*(int8 *)(result_1 + sVar5 + 0x10) = 0x7265776f6c203120;
*(int8 *)(result_1 + sVar5 + 0x18) = 0x6863206573616320;
*(int8 *)(result_1 + sVar5 + 0x19) = 0x6168632065736163;
*(int8 *)(result_1 + sVar5 + 0x21) = 0x2c726574636172;
}
if (!bVar3) {
sVar5 = strlen(result_1);
*(int8 *)(result_1 + sVar5) = 0x6d20676e69727453;
*(int8 *)(result_1 + sVar5 + 8) = 0x6576616820747375;
*(int8 *)(result_1 + sVar5 + 0xb) = 0x2031206576616820;
*(int8 *)(result_1 + sVar5 + 0x13) = 0x2c7265626d756e;
}
if (iVar4 < 8) {
sVar5 = strlen(result_1);
*(int8 *)(result_1 + sVar5) = 0x6c20676e69727453;
*(int8 *)(result_1 + sVar5 + 8) = 0x6873206874676e65;
*(int8 *)(result_1 + sVar5 + 0x10) = 0x20656220646c756f;
*(int8 *)(result_1 + sVar5 + 0x18) = 0x20747361656c7461;
*(int4 *)(result_1 + sVar5 + 0x1f) = 0x2c3820;
}
if ((((bVar1) && (bVar2)) && (bVar3)) && (7 < iVar4)) {
result_1[0] = 0x56;
result_1._1_5_ = 0x2064696c61;
result_1._6_2_ = 0x7473;
result_1._8_6_ = 0x2e676e6972;
}
else {
sVar5 = strlen(result_1);
iVar4 = (int)sVar5 + -1;
if (result_1[iVar4] == ',') {
result_1[iVar4] = 0;
}
}
return result_1;
} |
5,985 | func0 |
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <string.h>
| char *func0(const char *str1) {
static char result[200];
int has_upper = 0, has_lower = 0, has_digit = 0, is_valid = 1;
int length = strlen(str1);
for (int i = 0; i < length; i++) {
if (isupper(str1[i])) {
has_upper = 1;
}
if (islower(str1[i])) {
has_lower = 1;
}
if (isdigit(str1[i])) {
has_digit = 1;
}
}
result[0] = '\0';
if (!has_upper) {
strcat(result, "String must have 1 upper case character,");
}
if (!has_lower) {
strcat(result, "String must have 1 lower case character,");
}
if (!has_digit) {
strcat(result, "String must have 1 number,");
}
if (length < 8) {
strcat(result, "String length should be atleast 8,");
}
if (has_upper && has_lower && has_digit && length >= 8) {
strcpy(result, "Valid string.");
} else {
// Remove the last comma
int lastIdx = strlen(result) - 1;
if (result[lastIdx] == ',') {
result[lastIdx] = '\0';
}
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "String must have 1 upper case character,String must have 1 number,String length should be atleast 8") == 0);
assert(strcmp(func0("123python"), "String must have 1 upper case character") == 0);
assert(strcmp(func0("123Python"), "Valid string.") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r13
test %r13d,%r13d
jle 12e1 <func0+0x158>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rdi
mov %rbx,%rax
lea -0x1(%r13),%edx
lea 0x1(%rbx,%rdx,1),%rsi
mov $0x0,%r12d
mov $0x0,%ebp
mov $0x0,%ebx
mov $0x1,%ecx
movsbq (%rax),%rdx
movzwl (%rdi,%rdx,2),%edx
test $0x1,%dh
cmovne %ecx,%ebx
test $0x2,%dh
cmovne %ecx,%ebp
test $0x8,%dh
cmovne %ecx,%r12d
add $0x1,%rax
cmp %rsi,%rax
jne 11e1 <func0+0x58>
movb $0x0,0x2e34(%rip)
test %ebx,%ebx
je 12f8 <func0+0x16f>
test %ebp,%ebp
je 1256 <func0+0xcd>
test %r12d,%r12d
je 1270 <func0+0xe7>
cmp $0x7,%r13d
jle 128a <func0+0x101>
test %ebx,%ebx
je 12a2 <func0+0x119>
test %ebp,%ebp
je 12a2 <func0+0x119>
test %r12d,%r12d
je 12a2 <func0+0x119>
movabs $0x74732064696c6156,%rax
mov %rax,0x2dff(%rip)
movl $0x676e6972,0x2dfd(%rip)
movw $0x2e,0x2df8(%rip)
jmp 12c9 <func0+0x140>
mov $0xc8,%edx
lea 0xdd6(%rip),%rsi
lea 0x2dd7(%rip),%rdi
callq 1070 <__strcat_chk@plt>
jmp 1218 <func0+0x8f>
mov $0xc8,%edx
lea 0xfed(%rip),%rsi
lea 0x2dbd(%rip),%rdi
callq 1070 <__strcat_chk@plt>
jmp 121d <func0+0x94>
mov $0xc8,%edx
lea 0xdd2(%rip),%rsi
lea 0x2da3(%rip),%rdi
callq 1070 <__strcat_chk@plt>
lea 0x2d97(%rip),%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x2,%ecx
movslq %ecx,%rax
cmpb $0x2c,(%rdx,%rax,1)
je 12db <func0+0x152>
lea 0x2d70(%rip),%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
movb $0x0,(%rdx,%rax,1)
jmp 12c9 <func0+0x140>
movb $0x0,0x2d58(%rip)
mov $0x0,%r12d
mov $0x0,%ebp
mov $0x0,%ebx
mov $0xc8,%edx
lea 0xd04(%rip),%rsi
lea 0x2d35(%rip),%rdi
callq 1070 <__strcat_chk@plt>
jmpq 1214 <func0+0x8b>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
call _strlen
mov r13, rax
test eax, eax
jle loc_1307
call ___ctype_b_loc
mov rdi, [rax]
mov rax, rbx
lea edx, [r13-1]
lea rsi, [rbx+rdx+1]
mov r12d, 0
mov ebp, 0
mov ebx, 0
mov ecx, 1
loc_1213:
movsx rdx, byte ptr [rax]
movzx edx, word ptr [rdi+rdx*2]
test dh, 1
cmovnz ebx, ecx
test dh, 2
cmovnz ebp, ecx
test dh, 8
cmovnz r12d, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1213
mov byte ptr cs:result_1, 0
test ebx, ebx
jz loc_1319
loc_1246:
test ebp, ebp
jz short loc_1288
loc_124A:
test r12d, r12d
jz short loc_12A2
loc_124F:
cmp r13d, 7
jle short loc_12BC
test ebx, ebx
jz short loc_12D4
test ebp, ebp
jz short loc_12D4
test r12d, r12d
jz short loc_12D4
mov rax, 74732064696C6156h
mov cs:result_1, rax
mov cs:dword_4048, 676E6972h
mov cs:word_404C, 2Eh ; '.'
jmp short loc_12EF
loc_1288:
mov edx, 0C8h
lea rsi, aStringMustHave; "String must have 1 lower case character"...
lea rdi, result_1
call ___strcat_chk
jmp short loc_124A
loc_12A2:
mov edx, 0C8h
lea rsi, aStringMustHave_0; "String must have 1 number,"
lea rdi, result_1
call ___strcat_chk
jmp short loc_124F
loc_12BC:
mov edx, 0C8h
lea rsi, aStringLengthSh; "String length should be atleast 8,"
lea rdi, result_1
call ___strcat_chk
loc_12D4:
lea rbx, result_1
mov rdi, rbx
call _strlen
sub eax, 1
movsxd rdx, eax
cmp byte ptr [rbx+rdx], 2Ch ; ','
jz short loc_1301
loc_12EF:
lea rax, result_1
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1301:
mov byte ptr [rbx+rdx], 0
jmp short loc_12EF
loc_1307:
mov byte ptr cs:result_1, 0
mov r12d, 0
mov ebp, 0
loc_1319:
mov edx, 0C8h
lea rsi, aStringMustHave_1; "String must have 1 upper case character"...
lea rdi, result_1
call ___strcat_chk
mov ebx, 0
jmp loc_1246 | long long * func0(const char *a1)
{
long long v2; // rcx
int v3; // r13d
long long v4; // rdi
const char *v5; // rax
const char *v6; // rsi
int v7; // r12d
int v8; // ebp
int v9; // ebx
long long v10; // rdx
long long v11; // rdx
v3 = ((long long (*)(void))strlen)();
if ( v3 <= 0 )
{
LOBYTE(result_1) = 0;
v7 = 0;
v8 = 0;
LABEL_25:
v6 = "String must have 1 upper case character,";
__strcat_chk(&result_1, "String must have 1 upper case character,", 200LL, v2);
v9 = 0;
goto LABEL_11;
}
v4 = *(_QWORD *)__ctype_b_loc();
v5 = a1;
v6 = &a1[v3 - 1 + 1];
v7 = 0;
v8 = 0;
v9 = 0;
v2 = 1LL;
do
{
v10 = *(unsigned __int16 *)(v4 + 2LL * *v5);
if ( (v10 & 0x100) != 0 )
v9 = 1;
if ( (v10 & 0x200) != 0 )
v8 = 1;
if ( (v10 & 0x800) != 0 )
v7 = 1;
++v5;
}
while ( v5 != v6 );
LOBYTE(result_1) = 0;
if ( !v9 )
goto LABEL_25;
LABEL_11:
if ( !v8 )
{
v6 = "String must have 1 lower case character,";
__strcat_chk(&result_1, "String must have 1 lower case character,", 200LL, v2);
}
if ( !v7 )
{
v6 = "String must have 1 number,";
__strcat_chk(&result_1, "String must have 1 number,", 200LL, v2);
}
if ( v3 <= 7 )
{
v6 = "String length should be atleast 8,";
__strcat_chk(&result_1, "String length should be atleast 8,", 200LL, v2);
}
else if ( v9 && v8 && v7 )
{
strcpy((char *)&result_1, "Valid string.");
return &result_1;
}
v11 = (int)(strlen(&result_1, v6, v10, v2) - 1);
if ( *((_BYTE *)&result_1 + v11) == 44 )
*((_BYTE *)&result_1 + v11) = 0;
return &result_1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
CALL 0x001010a0
MOV R13,RAX
TEST EAX,EAX
JLE 0x00101307
CALL 0x001010d0
MOV RDI,qword ptr [RAX]
MOV RAX,RBX
LEA EDX,[R13 + -0x1]
LEA RSI,[RBX + RDX*0x1 + 0x1]
MOV R12D,0x0
MOV EBP,0x0
MOV EBX,0x0
MOV ECX,0x1
LAB_00101213:
MOVSX RDX,byte ptr [RAX]
MOVZX EDX,word ptr [RDI + RDX*0x2]
TEST DH,0x1
CMOVNZ EBX,ECX
TEST DH,0x2
CMOVNZ EBP,ECX
TEST DH,0x8
CMOVNZ R12D,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101213
MOV byte ptr [0x00104040],0x0
TEST EBX,EBX
JZ 0x00101319
LAB_00101246:
TEST EBP,EBP
JZ 0x00101288
LAB_0010124a:
TEST R12D,R12D
JZ 0x001012a2
LAB_0010124f:
CMP R13D,0x7
JLE 0x001012bc
TEST EBX,EBX
JZ 0x001012d4
TEST EBP,EBP
JZ 0x001012d4
TEST R12D,R12D
JZ 0x001012d4
MOV RAX,0x74732064696c6156
MOV qword ptr [0x00104040],RAX
MOV dword ptr [0x00104048],0x676e6972
MOV word ptr [0x0010404c],0x2e
JMP 0x001012ef
LAB_00101288:
MOV EDX,0xc8
LEA RSI,[0x102038]
LEA RDI,[0x104040]
CALL 0x00101090
JMP 0x0010124a
LAB_001012a2:
MOV EDX,0xc8
LEA RSI,[0x102229]
LEA RDI,[0x104040]
CALL 0x00101090
JMP 0x0010124f
LAB_001012bc:
MOV EDX,0xc8
LEA RSI,[0x102068]
LEA RDI,[0x104040]
CALL 0x00101090
LAB_001012d4:
LEA RBX,[0x104040]
MOV RDI,RBX
CALL 0x001010a0
SUB EAX,0x1
MOVSXD RDX,EAX
CMP byte ptr [RBX + RDX*0x1],0x2c
JZ 0x00101301
LAB_001012ef:
LEA RAX,[0x104040]
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101301:
MOV byte ptr [RBX + RDX*0x1],0x0
JMP 0x001012ef
LAB_00101307:
MOV byte ptr [0x00104040],0x0
MOV R12D,0x0
MOV EBP,0x0
LAB_00101319:
MOV EDX,0xc8
LEA RSI,[0x102008]
LEA RDI,[0x104040]
CALL 0x00101090
MOV EBX,0x0
JMP 0x00101246 | int1 * func0(char *param_1)
{
char *pcVar1;
ushort uVar2;
bool bVar3;
bool bVar4;
bool bVar5;
int iVar6;
size_t sVar7;
ushort **ppuVar8;
sVar7 = strlen(param_1);
iVar6 = (int)sVar7;
if (iVar6 < 1) {
result_1._0_8_ = result_1._0_8_ & 0xffffffffffffff00;
bVar5 = false;
bVar4 = false;
}
else {
ppuVar8 = __ctype_b_loc();
pcVar1 = param_1 + (ulong)(iVar6 - 1) + 1;
bVar5 = false;
bVar4 = false;
bVar3 = false;
do {
uVar2 = (*ppuVar8)[*param_1];
if ((uVar2 & 0x100) != 0) {
bVar3 = true;
}
if ((uVar2 & 0x200) != 0) {
bVar4 = true;
}
if ((uVar2 & 0x800) != 0) {
bVar5 = true;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
result_1._0_8_ = result_1._0_8_ & 0xffffffffffffff00;
if (bVar3) goto LAB_00101246;
}
__strcat_chk(result_1,"String must have 1 upper case character,",200);
bVar3 = false;
LAB_00101246:
if (!bVar4) {
__strcat_chk(result_1,"String must have 1 lower case character,",200);
}
if (!bVar5) {
__strcat_chk(result_1,"String must have 1 number,",200);
}
if (iVar6 < 8) {
__strcat_chk(result_1,"String length should be atleast 8,",200);
}
else if (((bVar3) && (bVar4)) && (bVar5)) {
result_1._0_8_ = 0x74732064696c6156;
result_1._8_4_ = 0x676e6972;
result_1._12_2_ = 0x2e;
return result_1;
}
sVar7 = strlen(result_1);
iVar6 = (int)sVar7 + -1;
if (result_1[iVar6] == ',') {
result_1[iVar6] = 0;
}
return result_1;
} |
5,986 | func0 |
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <string.h>
| char *func0(const char *str1) {
static char result[200];
int has_upper = 0, has_lower = 0, has_digit = 0, is_valid = 1;
int length = strlen(str1);
for (int i = 0; i < length; i++) {
if (isupper(str1[i])) {
has_upper = 1;
}
if (islower(str1[i])) {
has_lower = 1;
}
if (isdigit(str1[i])) {
has_digit = 1;
}
}
result[0] = '\0';
if (!has_upper) {
strcat(result, "String must have 1 upper case character,");
}
if (!has_lower) {
strcat(result, "String must have 1 lower case character,");
}
if (!has_digit) {
strcat(result, "String must have 1 number,");
}
if (length < 8) {
strcat(result, "String length should be atleast 8,");
}
if (has_upper && has_lower && has_digit && length >= 8) {
strcpy(result, "Valid string.");
} else {
// Remove the last comma
int lastIdx = strlen(result) - 1;
if (result[lastIdx] == ',') {
result[lastIdx] = '\0';
}
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "String must have 1 upper case character,String must have 1 number,String length should be atleast 8") == 0);
assert(strcmp(func0("123python"), "String must have 1 upper case character") == 0);
assert(strcmp(func0("123Python"), "Valid string.") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1090 <strlen@plt>
mov %rax,%r13
test %eax,%eax
jle 13b8 <func0+0x128>
callq 10b0 <__ctype_b_loc@plt>
xor %r12d,%r12d
mov %rbx,%rdi
xor %ebp,%ebp
mov (%rax),%rsi
lea -0x1(%r13),%eax
mov $0x1,%edx
lea 0x1(%rbx,%rax,1),%rcx
xor %ebx,%ebx
nopl 0x0(%rax)
movsbq (%rdi),%rax
movzwl (%rsi,%rax,2),%eax
test $0x1,%ah
cmovne %edx,%ebx
test $0x2,%ah
cmovne %edx,%ebp
test $0x8,%ah
cmovne %edx,%r12d
add $0x1,%rdi
cmp %rdi,%rcx
jne 12d8 <func0+0x48>
movb $0x0,0x2d3d(%rip)
test %ebx,%ebx
je 1460 <func0+0x1d0>
test %ebp,%ebp
je 1440 <func0+0x1b0>
test %r12d,%r12d
je 140a <func0+0x17a>
cmp $0x7,%r13d
jle 1398 <func0+0x108>
test %ebx,%ebp
je 132f <func0+0x9f>
test %r12d,%r12d
jne 1480 <func0+0x1f0>
lea 0x2d0a(%rip),%rsi
mov %rsi,%rdi
mov %rsi,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 133c <func0+0xac>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%ebx
add %al,%bl
sbb $0x3,%rdx
sub %rsi,%rdx
sub $0x1,%edx
movslq %edx,%rdx
cmpb $0x2c,(%rdi,%rdx,1)
je 1430 <func0+0x1a0>
add $0x8,%rsp
lea 0x2cb2(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl (%rax)
mov $0xc8,%edx
lea 0xcc4(%rip),%rsi
lea 0x2c95(%rip),%rdi
callq 1080 <__strcat_chk@plt>
jmpq 132f <func0+0x9f>
nopl (%rax)
mov $0xc8,%edx
lea 0xc44(%rip),%rsi
xor %ebx,%ebx
xor %ebp,%ebp
movdqa 0xee0(%rip),%xmm0
lea 0x2c69(%rip),%rdi
movabs $0x2c72657463617261,%rax
movb $0x0,0x2c80(%rip)
mov %rax,0x2c71(%rip)
movaps %xmm0,0x2c4a(%rip)
movdqa 0xec2(%rip),%xmm0
movaps %xmm0,0x2c4b(%rip)
callq 1080 <__strcat_chk@plt>
mov $0xc8,%edx
lea 0xe53(%rip),%rsi
lea 0x2c23(%rip),%rdi
xor %r12d,%r12d
callq 1080 <__strcat_chk@plt>
jmpq 131c <func0+0x8c>
nopw 0x0(%rax,%rax,1)
movb $0x0,(%rdi,%rdx,1)
jmpq 1383 <func0+0xf3>
nopl 0x0(%rax)
mov $0xc8,%edx
lea 0xbbc(%rip),%rsi
lea 0x2bed(%rip),%rdi
callq 1080 <__strcat_chk@plt>
jmpq 1313 <func0+0x83>
nopl (%rax)
mov $0xc8,%edx
lea 0xbcc(%rip),%rsi
lea 0x2bcd(%rip),%rdi
callq 1080 <__strcat_chk@plt>
jmpq 130b <func0+0x7b>
nopl (%rax)
movabs $0x74732064696c6156,%rax
movl $0x676e6972,0x2bb4(%rip)
mov %rax,0x2ba5(%rip)
mov $0x2e,%eax
mov %ax,0x2ba5(%rip)
jmpq 1383 <func0+0xf3>
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov r13, rax
test eax, eax
jle loc_13C0
call ___ctype_b_loc
xor r12d, r12d
mov rdi, rbx
xor ebp, ebp
mov rsi, [rax]
lea eax, [r13-1]
mov edx, 1
lea rcx, [rbx+rax+1]
xor ebx, ebx
nop
loc_12E0:
movsx rax, byte ptr [rdi]
movzx eax, word ptr [rsi+rax*2]
test ah, 1
cmovnz ebp, edx
test ah, 2
cmovnz ebx, edx
test ah, 8
cmovnz r12d, edx
add rdi, 1
cmp rcx, rdi
jnz short loc_12E0
mov byte ptr cs:result_1, 0
lea r14, result_1
test ebp, ebp
jz loc_1458
loc_131A:
test ebx, ebx
jz loc_1438
loc_1322:
test r12d, r12d
jz loc_1415
loc_132B:
cmp r13d, 7
jle short loc_13A0
test ebp, ebx
jnz short loc_1360
loc_1335:
mov rdi, r14
call _strlen
sub eax, 1
cdqe
cmp byte ptr [r14+rax], 2Ch ; ','
jnz short loc_134E
mov byte ptr [r14+rax], 0
loc_134E:
pop rbx
mov rax, r14
pop rbp
pop r12
pop r13
pop r14
retn
loc_1360:
test r12d, r12d
jz short loc_1335
mov rax, 74732064696C6156h
pop rbx
pop rbp
mov dword ptr cs:result_1+8, 676E6972h
mov qword ptr cs:result_1, rax
mov eax, 2Eh ; '.'
pop r12
mov word ptr cs:result_1+0Ch, ax
pop r13
mov rax, r14
pop r14
retn
loc_13A0:
mov edx, 0C8h
lea rsi, aStringLengthSh; "String length should be atleast 8,"
mov rdi, r14
call ___strcat_chk
jmp loc_1335
loc_13C0:
lea r14, result_1
mov edx, 0C8h
xor ebx, ebx
xor ebp, ebp
movdqa xmm0, cs:xmmword_2290
lea rsi, aStringMustHave_1; "String must have 1 lower case character"...
mov rdi, r14
mov rax, 2C72657463617261h
mov cs:qword_4060, rax
movaps cs:result_1, xmm0
movdqa xmm0, cs:xmmword_22A0
mov cs:byte_4068, 0
movaps cs:xmmword_4050, xmm0
call ___strcat_chk
loc_1415:
mov edx, 0C8h
lea rsi, aStringMustHave_2; "String must have 1 number,"
mov rdi, r14
xor r12d, r12d
call ___strcat_chk
jmp loc_132B
loc_1438:
mov edx, 0C8h
lea rsi, aStringMustHave_1; "String must have 1 lower case character"...
mov rdi, r14
call ___strcat_chk
jmp loc_1322
loc_1458:
mov edx, 0C8h
lea rsi, aStringMustHave_3; "String must have 1 upper case character"...
mov rdi, r14
call ___strcat_chk
jmp loc_131A | __int128 * func0(char *a1)
{
int v1; // r13d
int v2; // r12d
int v3; // ebp
const char *v4; // rsi
long long v5; // rdx
long long v6; // rcx
int v7; // ebx
__int16 v8; // ax
long long v9; // rax
v1 = ((long long (*)(void))strlen)();
if ( v1 <= 0 )
{
v7 = 0;
v3 = 0;
strcpy((char *)&qword_4060, "aracter,");
result_1 = (__int128)_mm_load_si128((const __m128i *)&xmmword_2290);
xmmword_4050 = (__int128)_mm_load_si128((const __m128i *)&xmmword_22A0);
__strcat_chk(&result_1, "String must have 1 lower case character,", 200LL);
LABEL_24:
v4 = "String must have 1 number,";
v2 = 0;
__strcat_chk(&result_1, "String must have 1 number,", 200LL);
goto LABEL_15;
}
v2 = 0;
v3 = 0;
v4 = *(const char **)__ctype_b_loc();
v5 = 1LL;
v6 = (long long)&a1[v1 - 1 + 1];
v7 = 0;
do
{
v8 = *(_WORD *)&v4[2 * *a1];
if ( (v8 & 0x100) != 0 )
v3 = 1;
if ( (v8 & 0x200) != 0 )
v7 = 1;
if ( (v8 & 0x800) != 0 )
v2 = 1;
++a1;
}
while ( (char *)v6 != a1 );
LOBYTE(result_1) = 0;
if ( !v3 )
{
v4 = "String must have 1 upper case character,";
__strcat_chk(&result_1, "String must have 1 upper case character,", 200LL);
}
if ( !v7 )
{
v4 = "String must have 1 lower case character,";
__strcat_chk(&result_1, "String must have 1 lower case character,", 200LL);
}
if ( !v2 )
goto LABEL_24;
LABEL_15:
if ( v1 <= 7 )
{
v4 = "String length should be atleast 8,";
__strcat_chk(&result_1, "String length should be atleast 8,", 200LL);
}
else if ( (v7 & v3) != 0 && v2 )
{
strcpy((char *)&result_1, "Valid string.");
return &result_1;
}
v9 = (int)(strlen(&result_1, v4, v5) - 1);
if ( *((_BYTE *)&result_1 + v9) == 44 )
*((_BYTE *)&result_1 + v9) = 0;
return &result_1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x001010a0
MOV R13,RAX
TEST EAX,EAX
JLE 0x001013c0
CALL 0x001010d0
XOR R12D,R12D
MOV RDI,RBX
XOR EBP,EBP
MOV RSI,qword ptr [RAX]
LEA EAX,[R13 + -0x1]
MOV EDX,0x1
LEA RCX,[RBX + RAX*0x1 + 0x1]
XOR EBX,EBX
NOP
LAB_001012e0:
MOVSX RAX,byte ptr [RDI]
MOVZX EAX,word ptr [RSI + RAX*0x2]
TEST AH,0x1
CMOVNZ EBP,EDX
TEST AH,0x2
CMOVNZ EBX,EDX
TEST AH,0x8
CMOVNZ R12D,EDX
ADD RDI,0x1
CMP RCX,RDI
JNZ 0x001012e0
MOV byte ptr [0x00104040],0x0
LEA R14,[0x104040]
TEST EBP,EBP
JZ 0x00101458
LAB_0010131a:
TEST EBX,EBX
JZ 0x00101438
LAB_00101322:
TEST R12D,R12D
JZ 0x00101415
LAB_0010132b:
CMP R13D,0x7
JLE 0x001013a0
TEST EBP,EBX
JNZ 0x00101360
LAB_00101335:
MOV RDI,R14
CALL 0x001010a0
SUB EAX,0x1
CDQE
CMP byte ptr [R14 + RAX*0x1],0x2c
JNZ 0x0010134e
MOV byte ptr [R14 + RAX*0x1],0x0
LAB_0010134e:
POP RBX
MOV RAX,R14
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101360:
TEST R12D,R12D
JZ 0x00101335
MOV RAX,0x74732064696c6156
POP RBX
POP RBP
MOV dword ptr [0x00104048],0x676e6972
MOV qword ptr [0x00104040],RAX
MOV EAX,0x2e
POP R12
MOV word ptr [0x0010404c],AX
POP R13
MOV RAX,R14
POP R14
RET
LAB_001013a0:
MOV EDX,0xc8
LEA RSI,[0x102068]
MOV RDI,R14
CALL 0x00101090
JMP 0x00101335
LAB_001013c0:
LEA R14,[0x104040]
MOV EDX,0xc8
XOR EBX,EBX
XOR EBP,EBP
MOVDQA XMM0,xmmword ptr [0x00102290]
LEA RSI,[0x102008]
MOV RDI,R14
MOV RAX,0x2c72657463617261
MOV qword ptr [0x00104060],RAX
MOVAPS xmmword ptr [0x00104040],XMM0
MOVDQA XMM0,xmmword ptr [0x001022a0]
MOV byte ptr [0x00104068],0x0
MOVAPS xmmword ptr [0x00104050],XMM0
CALL 0x00101090
LAB_00101415:
MOV EDX,0xc8
LEA RSI,[0x102229]
MOV RDI,R14
XOR R12D,R12D
CALL 0x00101090
JMP 0x0010132b
LAB_00101438:
MOV EDX,0xc8
LEA RSI,[0x102008]
MOV RDI,R14
CALL 0x00101090
JMP 0x00101322
LAB_00101458:
MOV EDX,0xc8
LEA RSI,[0x102038]
MOV RDI,R14
CALL 0x00101090
JMP 0x0010131a | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(char *param_1)
{
char *pcVar1;
ushort uVar2;
bool bVar3;
bool bVar4;
bool bVar5;
int iVar6;
size_t sVar7;
ushort **ppuVar8;
sVar7 = strlen(param_1);
iVar6 = (int)sVar7;
if (iVar6 < 1) {
bVar4 = false;
bVar3 = false;
result_1._32_8_ = 0x2c72657463617261;
result_1._0_8_ = _DAT_00102290;
result_1._8_8_ = _UNK_00102298;
result_1[0x28] = 0;
result_1._16_8_ = _DAT_001022a0;
result_1._24_8_ = _UNK_001022a8;
__strcat_chk(result_1,"String must have 1 lower case character,",200);
}
else {
ppuVar8 = __ctype_b_loc();
bVar5 = false;
bVar3 = false;
pcVar1 = param_1 + (ulong)(iVar6 - 1) + 1;
bVar4 = false;
do {
uVar2 = (*ppuVar8)[*param_1];
if ((uVar2 & 0x100) != 0) {
bVar3 = true;
}
if ((uVar2 & 0x200) != 0) {
bVar4 = true;
}
if ((uVar2 & 0x800) != 0) {
bVar5 = true;
}
param_1 = param_1 + 1;
} while (pcVar1 != param_1);
result_1._0_8_ = result_1._0_8_ & 0xffffffffffffff00;
if (!bVar3) {
__strcat_chk(result_1,"String must have 1 upper case character,",200);
}
if (!bVar4) {
__strcat_chk(result_1,"String must have 1 lower case character,",200);
}
if (bVar5) goto LAB_0010132b;
}
bVar5 = false;
__strcat_chk(result_1,"String must have 1 number,",200);
LAB_0010132b:
if (iVar6 < 8) {
__strcat_chk(result_1,"String length should be atleast 8,",200);
}
else if (((bool)(bVar3 & bVar4)) && (bVar5)) {
result_1._0_8_ = 0x74732064696c6156;
result_1._8_6_ = 0x2e676e6972;
return result_1;
}
sVar7 = strlen(result_1);
iVar6 = (int)sVar7 + -1;
if (result_1[iVar6] == ',') {
result_1[iVar6] = 0;
}
return result_1;
} |
5,987 | func0 |
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <string.h>
| char *func0(const char *str1) {
static char result[200];
int has_upper = 0, has_lower = 0, has_digit = 0, is_valid = 1;
int length = strlen(str1);
for (int i = 0; i < length; i++) {
if (isupper(str1[i])) {
has_upper = 1;
}
if (islower(str1[i])) {
has_lower = 1;
}
if (isdigit(str1[i])) {
has_digit = 1;
}
}
result[0] = '\0';
if (!has_upper) {
strcat(result, "String must have 1 upper case character,");
}
if (!has_lower) {
strcat(result, "String must have 1 lower case character,");
}
if (!has_digit) {
strcat(result, "String must have 1 number,");
}
if (length < 8) {
strcat(result, "String length should be atleast 8,");
}
if (has_upper && has_lower && has_digit && length >= 8) {
strcpy(result, "Valid string.");
} else {
// Remove the last comma
int lastIdx = strlen(result) - 1;
if (result[lastIdx] == ',') {
result[lastIdx] = '\0';
}
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "String must have 1 upper case character,String must have 1 number,String length should be atleast 8") == 0);
assert(strcmp(func0("123python"), "String must have 1 upper case character") == 0);
assert(strcmp(func0("123Python"), "Valid string.") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1090 <strlen@plt>
mov %rax,%r13
test %eax,%eax
jle 13b8 <func0+0x128>
callq 10b0 <__ctype_b_loc@plt>
xor %r12d,%r12d
mov %rbx,%rdi
xor %ebp,%ebp
mov (%rax),%rsi
lea -0x1(%r13),%eax
mov $0x1,%edx
lea 0x1(%rbx,%rax,1),%rcx
xor %ebx,%ebx
nopl 0x0(%rax)
movsbq (%rdi),%rax
movzwl (%rsi,%rax,2),%eax
test $0x1,%ah
cmovne %edx,%ebx
test $0x2,%ah
cmovne %edx,%ebp
test $0x8,%ah
cmovne %edx,%r12d
add $0x1,%rdi
cmp %rdi,%rcx
jne 12d8 <func0+0x48>
movb $0x0,0x2d3d(%rip)
test %ebx,%ebx
je 1460 <func0+0x1d0>
test %ebp,%ebp
je 1440 <func0+0x1b0>
test %r12d,%r12d
je 140a <func0+0x17a>
cmp $0x7,%r13d
jle 1398 <func0+0x108>
test %ebx,%ebp
je 132f <func0+0x9f>
test %r12d,%r12d
jne 1480 <func0+0x1f0>
lea 0x2d0a(%rip),%rsi
mov %rsi,%rdi
mov %rsi,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 133c <func0+0xac>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%ebx
add %al,%bl
sbb $0x3,%rdx
sub %rsi,%rdx
sub $0x1,%edx
movslq %edx,%rdx
cmpb $0x2c,(%rdi,%rdx,1)
je 1430 <func0+0x1a0>
add $0x8,%rsp
lea 0x2cb2(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl (%rax)
mov $0xc8,%edx
lea 0xcc4(%rip),%rsi
lea 0x2c95(%rip),%rdi
callq 1080 <__strcat_chk@plt>
jmpq 132f <func0+0x9f>
nopl (%rax)
mov $0xc8,%edx
lea 0xc44(%rip),%rsi
xor %ebp,%ebp
xor %ebx,%ebx
movdqa 0xee0(%rip),%xmm0
lea 0x2c69(%rip),%rdi
movabs $0x2c72657463617261,%rax
movb $0x0,0x2c80(%rip)
mov %rax,0x2c71(%rip)
movaps %xmm0,0x2c4a(%rip)
movdqa 0xec2(%rip),%xmm0
movaps %xmm0,0x2c4b(%rip)
callq 1080 <__strcat_chk@plt>
mov $0xc8,%edx
lea 0xe53(%rip),%rsi
lea 0x2c23(%rip),%rdi
xor %r12d,%r12d
callq 1080 <__strcat_chk@plt>
jmpq 131c <func0+0x8c>
nopw 0x0(%rax,%rax,1)
movb $0x0,(%rdi,%rdx,1)
jmpq 1383 <func0+0xf3>
nopl 0x0(%rax)
mov $0xc8,%edx
lea 0xbbc(%rip),%rsi
lea 0x2bed(%rip),%rdi
callq 1080 <__strcat_chk@plt>
jmpq 1313 <func0+0x83>
nopl (%rax)
mov $0xc8,%edx
lea 0xbcc(%rip),%rsi
lea 0x2bcd(%rip),%rdi
callq 1080 <__strcat_chk@plt>
jmpq 130b <func0+0x7b>
nopl (%rax)
movabs $0x74732064696c6156,%rax
movl $0x676e6972,0x2bb4(%rip)
mov %rax,0x2ba5(%rip)
mov $0x2e,%eax
mov %ax,0x2ba5(%rip)
jmpq 1383 <func0+0xf3>
nopl 0x0(%rax)
| func0:
endbr64
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle loc_13D0
mov r12, rax
xor ebp, ebp
call ___ctype_b_loc
mov rdi, rbx
xor ecx, ecx
mov edx, 1
mov r8, [rax]
lea eax, [r12-1]
lea rsi, [rbx+rax+1]
xor ebx, ebx
nop dword ptr [rax+00000000h]
loc_12E8:
movsx rax, byte ptr [rdi]
movzx eax, word ptr [r8+rax*2]
test ah, 1
cmovnz ecx, edx
test ah, 2
cmovnz ebp, edx
test ah, 8
cmovnz ebx, edx
add rdi, 1
cmp rsi, rdi
jnz short loc_12E8
mov byte ptr cs:result_1, 0
lea r13, result_1
test ecx, ecx
jz short loc_1368
test ebp, ebp
jz short loc_1380
test ebx, ebx
jz loc_1458
cmp r12d, 7
jle loc_1439
mov rax, 74732064696C6156h
mov qword ptr cs:result_1, rax
mov rax, 2E676E69727473h
mov qword ptr cs:result_1+6, rax
loc_1356:
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1368:
mov edx, 0C8h
lea rsi, aStringMustHave_1; "String must have 1 upper case character"...
mov rdi, r13
call ___strcat_chk
test ebp, ebp
jnz short loc_1394
loc_1380:
mov edx, 0C8h
lea rsi, aStringMustHave_2; "String must have 1 lower case character"...
mov rdi, r13
call ___strcat_chk
loc_1394:
test ebx, ebx
jz loc_1458
cmp r12d, 7
jle loc_1439
loc_13A6:
mov rdi, r13; s
call _strlen
sub eax, 1
cdqe
cmp byte ptr [r13+rax+0], 2Ch ; ','
jnz short loc_1356
mov byte ptr [r13+rax+0], 0
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13D0:
movdqa xmm0, cs:xmmword_2290
movdqa xmm1, cs:xmmword_22A0
mov rax, 2C72657463617261h
lea r13, result_1
mov cs:qword_4060, rax
movaps cs:xmmword_4090, xmm0
movaps cs:result_1, xmm0
movaps cs:xmmword_4050, xmm1
movdqa xmm1, cs:xmmword_22B0
movups cs:xmmword_4068, xmm0
movdqa xmm0, cs:xmmword_22C0
mov cs:qword_4088, rax
movups cs:xmmword_4078, xmm1
movups cs:xmmword_4090+0Bh, xmm0
loc_1439:
mov edx, 0C8h
lea rsi, aStringLengthSh; "String length should be atleast 8,"
mov rdi, r13
call ___strcat_chk
jmp loc_13A6
loc_1458:
mov edx, 0C8h
lea rsi, aStringMustHave_3; "String must have 1 number,"
mov rdi, r13
call ___strcat_chk
cmp r12d, 7
jg loc_13A6
jmp short loc_1439 | char * func0(const char *a1)
{
int v1; // eax
int v2; // r12d
int v3; // ebp
const unsigned __int16 **v4; // rax
int v5; // ecx
const unsigned __int16 *v6; // r8
long long v7; // rsi
int v8; // ebx
unsigned __int16 v9; // ax
long long v11; // rax
v1 = strlen(a1);
if ( v1 <= 0 )
{
qword_4060 = 0x2C72657463617261LL;
xmmword_4090 = (__int128)_mm_load_si128((const __m128i *)&xmmword_2290);
*(_OWORD *)result_1 = xmmword_4090;
xmmword_4050 = (__int128)_mm_load_si128((const __m128i *)&xmmword_22A0);
xmmword_4068 = xmmword_4090;
qword_4088 = 0x2C72657463617261LL;
xmmword_4078 = (__int128)_mm_load_si128((const __m128i *)&xmmword_22B0);
*(__int128 *)((char *)&xmmword_4090 + 11) = (__int128)_mm_load_si128((const __m128i *)&xmmword_22C0);
LABEL_23:
__strcat_chk(result_1, "String length should be atleast 8,", 200LL);
goto LABEL_20;
}
v2 = v1;
v3 = 0;
v4 = __ctype_b_loc();
v5 = 0;
v6 = *v4;
v7 = (long long)&a1[v2 - 1 + 1];
v8 = 0;
do
{
v9 = v6[*a1];
if ( (v9 & 0x100) != 0 )
v5 = 1;
if ( (v9 & 0x200) != 0 )
v3 = 1;
if ( (v9 & 0x800) != 0 )
v8 = 1;
++a1;
}
while ( (const char *)v7 != a1 );
result_1[0] = 0;
if ( !v5 )
{
__strcat_chk(result_1, "String must have 1 upper case character,", 200LL);
if ( v3 )
goto LABEL_18;
goto LABEL_17;
}
if ( !v3 )
{
LABEL_17:
__strcat_chk(result_1, "String must have 1 lower case character,", 200LL);
LABEL_18:
if ( v8 )
{
if ( v2 > 7 )
goto LABEL_20;
goto LABEL_23;
}
goto LABEL_24;
}
if ( v8 )
{
if ( v2 > 7 )
{
strcpy(result_1, "Valid string.");
return result_1;
}
goto LABEL_23;
}
LABEL_24:
__strcat_chk(result_1, "String must have 1 number,", 200LL);
if ( v2 <= 7 )
goto LABEL_23;
LABEL_20:
v11 = (int)(strlen(result_1) - 1);
if ( result_1[v11] != 44 )
return result_1;
result_1[v11] = 0;
return result_1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x001010a0
TEST EAX,EAX
JLE 0x001013d0
MOV R12,RAX
XOR EBP,EBP
CALL 0x001010d0
MOV RDI,RBX
XOR ECX,ECX
MOV EDX,0x1
MOV R8,qword ptr [RAX]
LEA EAX,[R12 + -0x1]
LEA RSI,[RBX + RAX*0x1 + 0x1]
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_001012e8:
MOVSX RAX,byte ptr [RDI]
MOVZX EAX,word ptr [R8 + RAX*0x2]
TEST AH,0x1
CMOVNZ ECX,EDX
TEST AH,0x2
CMOVNZ EBP,EDX
TEST AH,0x8
CMOVNZ EBX,EDX
ADD RDI,0x1
CMP RSI,RDI
JNZ 0x001012e8
MOV byte ptr [0x00104040],0x0
LEA R13,[0x104040]
TEST ECX,ECX
JZ 0x00101368
TEST EBP,EBP
JZ 0x00101380
TEST EBX,EBX
JZ 0x00101458
CMP R12D,0x7
JLE 0x00101439
MOV RAX,0x74732064696c6156
MOV qword ptr [0x00104040],RAX
MOV RAX,0x2e676e69727473
MOV qword ptr [0x00104046],RAX
LAB_00101356:
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101368:
MOV EDX,0xc8
LEA RSI,[0x102060]
MOV RDI,R13
CALL 0x00101090
TEST EBP,EBP
JNZ 0x00101394
LAB_00101380:
MOV EDX,0xc8
LEA RSI,[0x102090]
MOV RDI,R13
CALL 0x00101090
LAB_00101394:
TEST EBX,EBX
JZ 0x00101458
CMP R12D,0x7
JLE 0x00101439
LAB_001013a6:
MOV RDI,R13
CALL 0x001010a0
SUB EAX,0x1
CDQE
CMP byte ptr [R13 + RAX*0x1],0x2c
JNZ 0x00101356
MOV byte ptr [R13 + RAX*0x1],0x0
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013d0:
MOVDQA XMM0,xmmword ptr [0x00102290]
MOVDQA XMM1,xmmword ptr [0x001022a0]
MOV RAX,0x2c72657463617261
LEA R13,[0x104040]
MOV qword ptr [0x00104060],RAX
MOVAPS xmmword ptr [0x00104090],XMM0
MOVAPS xmmword ptr [0x00104040],XMM0
MOVAPS xmmword ptr [0x00104050],XMM1
MOVDQA XMM1,xmmword ptr [0x001022b0]
MOVUPS xmmword ptr [0x00104068],XMM0
MOVDQA XMM0,xmmword ptr [0x001022c0]
MOV qword ptr [0x00104088],RAX
MOVUPS xmmword ptr [0x00104078],XMM1
MOVUPS xmmword ptr [0x0010409b],XMM0
LAB_00101439:
MOV EDX,0xc8
LEA RSI,[0x1020c0]
MOV RDI,R13
CALL 0x00101090
JMP 0x001013a6
LAB_00101458:
MOV EDX,0xc8
LEA RSI,[0x102004]
MOV RDI,R13
CALL 0x00101090
CMP R12D,0x7
JG 0x001013a6
JMP 0x00101439 | |
5,988 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int max = 0;
int msis[n];
for (int i = 0; i < n; i++) {
msis[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && msis[i] < msis[j] + arr[i]) {
msis[i] = msis[j] + arr[i];
}
}
}
for (int i = 0; i < n; i++) {
if (max < msis[i]) {
max = msis[i];
}
}
return max;
}
| int main() {
int arr1[] = {1, 101, 2, 3, 100, 4, 5};
int arr2[] = {3, 4, 5, 10};
int arr3[] = {10, 5, 4, 3};
assert(func0(arr1, 7) == 106);
assert(func0(arr2, 4) == 22);
assert(func0(arr3, 4) == 10);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rdi
movl $0x0,-0x30(%rbp)
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 122f <func0+0xa6>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1218 <func0+0x8f>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1259 <func0+0xd0>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x34(%rbp)
jmp 129c <func0+0x113>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1275 <func0+0xec>
movl $0x1,-0x38(%rbp)
jmpq 1369 <func0+0x1e0>
movl $0x0,-0x3c(%rbp)
jmpq 1359 <func0+0x1d0>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x3c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1355 <func0+0x1cc>
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%rax
mov -0x3c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x48(%rbp),%rax
add %rsi,%rax
mov (%rax),%eax
add %edx,%eax
cmp %eax,%ecx
jge 1355 <func0+0x1cc>
mov -0x20(%rbp),%rax
mov -0x3c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
lea (%rdx,%rax,1),%ecx
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 12bc <func0+0x133>
addl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 12b0 <func0+0x127>
movl $0x0,-0x2c(%rbp)
jmp 13a4 <func0+0x21b>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,-0x30(%rbp)
jge 13a0 <func0+0x217>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,-0x30(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 137e <func0+0x1f5>
mov -0x30(%rbp),%eax
mov %rdi,%rsp
mov -0x18(%rbp),%rsi
xor %fs:0x28,%rsi
je 13c6 <func0+0x23d>
callq 1080 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rdi, rax
mov [rbp+var_2C], 0
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov esi, 10h
mov edx, 0
div rsi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11FD:
cmp rsp, rdx
jz short loc_1214
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11FD
loc_1214:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_123E
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_123E:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_28], 0
jmp short loc_1281
loc_125A:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov ecx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_28]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_28], 1
loc_1281:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl short loc_125A
mov [rbp+var_24], 1
jmp loc_134E
loc_1295:
mov [rbp+var_20], 0
jmp loc_133E
loc_12A1:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_20]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_133A
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov eax, [rbp+var_24]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rsi
mov eax, [rax]
add eax, edx
cmp ecx, eax
jge short loc_133A
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov eax, [rbp+var_24]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
lea ecx, [rdx+rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov [rax+rdx*4], ecx
loc_133A:
add [rbp+var_20], 1
loc_133E:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jl loc_12A1
add [rbp+var_24], 1
loc_134E:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl loc_1295
mov [rbp+var_1C], 0
jmp short loc_1389
loc_1363:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp [rbp+var_2C], eax
jge short loc_1385
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rbp+var_2C], eax
loc_1385:
add [rbp+var_1C], 1
loc_1389:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_3C]
jl short loc_1363
mov eax, [rbp+var_2C]
mov rsp, rdi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13AB
call ___stack_chk_fail
locret_13AB:
leave
retn | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[4]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+Ch] [rbp-3Ch]
long long v7; // [rsp+10h] [rbp-38h]
unsigned int v8; // [rsp+1Ch] [rbp-2Ch]
int i; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
int k; // [rsp+28h] [rbp-20h]
int m; // [rsp+2Ch] [rbp-1Ch]
long long v13; // [rsp+30h] [rbp-18h]
_BYTE *v14; // [rsp+38h] [rbp-10h]
unsigned long long v15; // [rsp+40h] [rbp-8h]
v7 = a1;
v6 = a2;
v15 = __readfsqword(0x28u);
v8 = 0;
v13 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v5 != &v5[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v5[(v2 & 0xFFF) - 8] = *(_QWORD *)&v5[(v2 & 0xFFF) - 8];
v14 = v5;
for ( i = 0; i < v6; ++i )
*(_DWORD *)&v14[4 * i] = *(_DWORD *)(4LL * i + v7);
for ( j = 1; j < v6; ++j )
{
for ( k = 0; k < j; ++k )
{
if ( *(_DWORD *)(4LL * j + v7) > *(_DWORD *)(4LL * k + v7)
&& *(_DWORD *)&v14[4 * j] < *(_DWORD *)&v14[4 * k] + *(_DWORD *)(4LL * j + v7) )
{
*(_DWORD *)&v14[4 * j] = *(_DWORD *)&v14[4 * k] + *(_DWORD *)(4LL * j + v7);
}
}
}
for ( m = 0; m < v6; ++m )
{
if ( (signed int)v8 < *(_DWORD *)&v14[4 * m] )
v8 = *(_DWORD *)&v14[4 * m];
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RDI,RAX
MOV dword ptr [RBP + -0x2c],0x0
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV ESI,0x10
MOV EDX,0x0
DIV RSI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011fd:
CMP RSP,RDX
JZ 0x00101214
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011fd
LAB_00101214:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010123e
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010123e:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101281
LAB_0010125a:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x28],0x1
LAB_00101281:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010125a
MOV dword ptr [RBP + -0x24],0x1
JMP 0x0010134e
LAB_00101295:
MOV dword ptr [RBP + -0x20],0x0
JMP 0x0010133e
LAB_001012a1:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010133a
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RSI
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
CMP ECX,EAX
JGE 0x0010133a
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
LEA ECX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_0010133a:
ADD dword ptr [RBP + -0x20],0x1
LAB_0010133e:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001012a1
ADD dword ptr [RBP + -0x24],0x1
LAB_0010134e:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101295
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101389
LAB_00101363:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP dword ptr [RBP + -0x2c],EAX
JGE 0x00101385
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RBP + -0x2c],EAX
LAB_00101385:
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101389:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101363
MOV EAX,dword ptr [RBP + -0x2c]
MOV RSP,RDI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013ab
CALL 0x00101080
LAB_001013ab:
LEAVE
RET | int func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
long local_40;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = param_1;
local_44 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_34 = 0;
local_20 = (long)param_2 + -1;
uVar2 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_30 = 0; local_30 < local_44; local_30 = local_30 + 1) {
*(int4 *)(puVar3 + (long)local_30 * 4 + lVar1) =
*(int4 *)(local_40 + (long)local_30 * 4);
}
for (local_2c = 1; local_2c < local_44; local_2c = local_2c + 1) {
for (local_28 = 0; local_28 < local_2c; local_28 = local_28 + 1) {
if (*(int *)(local_40 + (long)local_28 * 4) < *(int *)(local_40 + (long)local_2c * 4)) {
if (*(int *)(puVar3 + (long)local_2c * 4 + lVar1) <
*(int *)(local_40 + (long)local_2c * 4) + *(int *)(puVar3 + (long)local_28 * 4 + lVar1))
{
*(int *)(puVar3 + (long)local_2c * 4 + lVar1) =
*(int *)(puVar3 + (long)local_28 * 4 + lVar1) +
*(int *)(local_40 + (long)local_2c * 4);
}
}
}
}
for (local_24 = 0; local_24 < local_44; local_24 = local_24 + 1) {
if (local_34 < *(int *)(puVar3 + (long)local_24 * 4 + lVar1)) {
local_34 = *(int *)(puVar3 + (long)local_24 * 4 + lVar1);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_34;
} |
5,989 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int max = 0;
int msis[n];
for (int i = 0; i < n; i++) {
msis[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && msis[i] < msis[j] + arr[i]) {
msis[i] = msis[j] + arr[i];
}
}
}
for (int i = 0; i < n; i++) {
if (max < msis[i]) {
max = msis[i];
}
}
return max;
}
| int main() {
int arr1[] = {1, 101, 2, 3, 100, 4, 5};
int arr2[] = {3, 4, 5, 10};
int arr3[] = {10, 5, 4, 3};
assert(func0(arr1, 7) == 106);
assert(func0(arr2, 4) == 22);
assert(func0(arr3, 4) == 10);
printf("All tests passed!\n");
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,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%rsp
je 11dc <func0+0x53>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11c5 <func0+0x3c>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f2 <func0+0x69>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r8
mov %r8,%r9
shr $0x2,%r9
and $0xfffffffffffffffc,%r8
test %esi,%esi
jle 1221 <func0+0x98>
lea -0x1(%rsi),%ecx
mov $0x0,%eax
mov (%rdi,%rax,4),%edx
mov %edx,(%r8,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 120e <func0+0x85>
cmp $0x1,%esi
jle 126d <func0+0xe4>
lea -0x2(%rsi),%r10d
add $0x2,%r10
mov $0x1,%edx
jmp 125f <func0+0xd6>
add $0x1,%rax
cmp %rdx,%rax
je 1256 <func0+0xcd>
cmp (%rdi,%rax,4),%ecx
jle 1235 <func0+0xac>
mov %ecx,%r9d
add (%r8,%rax,4),%r9d
cmp %r9d,(%r8,%rdx,4)
jge 1235 <func0+0xac>
mov %r9d,(%r8,%rdx,4)
jmp 1235 <func0+0xac>
add $0x1,%rdx
cmp %r10,%rdx
je 1276 <func0+0xed>
test %edx,%edx
jle 1256 <func0+0xcd>
mov (%rdi,%rdx,4),%ecx
mov $0x0,%eax
jmp 123e <func0+0xb5>
je 12a4 <func0+0x11b>
mov $0x0,%edx
jmp 1291 <func0+0x108>
mov $0x0,%eax
mov $0x0,%edx
mov (%r8,%rax,4),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x1,%rax
cmp %eax,%esi
jg 1280 <func0+0xf7>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 12bd <func0+0x134>
mov %edx,%eax
leaveq
retq
cmpl $0x0,0x0(,%r9,4)
mov $0x0,%edx
cmovns 0x0(,%r9,4),%edx
jmp 1291 <func0+0x108>
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r9d, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C5:
cmp rsp, rdx
jz short loc_11DC
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11C5
loc_11DC:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11F2
or [rsp+rax+10h+var_18], 0
loc_11F2:
lea rsi, [rsp+10h+var_D]
mov r8, rsi
shr r8, 2
and rsi, 0FFFFFFFFFFFFFFFCh
test r9d, r9d
jle short loc_121E
mov ecx, r9d
mov eax, 0
loc_120F:
mov edx, [rdi+rax*4]
mov [rsi+rax*4], edx
add rax, 1
cmp rax, rcx
jnz short loc_120F
loc_121E:
cmp r9d, 1
jle short loc_1266
mov r10d, r9d
mov edx, 1
jmp short loc_1258
loc_122E:
add rax, 1
cmp rax, rdx
jz short loc_124F
loc_1237:
cmp ecx, [rdi+rax*4]
jle short loc_122E
mov r8d, ecx
add r8d, [rsi+rax*4]
cmp [rsi+rdx*4], r8d
jge short loc_122E
mov [rsi+rdx*4], r8d
jmp short loc_122E
loc_124F:
add rdx, 1
cmp rdx, r10
jz short loc_126F
loc_1258:
test edx, edx
jle short loc_124F
mov ecx, [rdi+rdx*4]
mov eax, 0
jmp short loc_1237
loc_1266:
jz short loc_129D
mov edx, 0
jmp short loc_128A
loc_126F:
mov eax, 0
mov edx, 0
loc_1279:
mov ecx, [rsi+rax*4]
cmp edx, ecx
cmovl edx, ecx
add rax, 1
cmp r9d, eax
jg short loc_1279
loc_128A:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_12B1
mov eax, edx
leave
retn
loc_129D:
mov edx, ds:dword_0[r8*4]
test edx, edx
mov eax, 0
cmovs edx, eax
jmp short loc_128A
loc_12B1:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
signed long long v2; // rax
void *v3; // rsp
long long i; // rax
long long j; // rdx
long long v6; // rax
int v7; // r8d
int v8; // ecx
unsigned int v9; // edx
long long v10; // rax
_DWORD v13[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v14; // [rsp+10h] [rbp-8h]
v14 = __readfsqword(0x28u);
while ( v13 != (_DWORD *)((char *)v13 - ((4LL * a2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v2 = (4 * (_WORD)a2 + 15) & 0xFF0;
v3 = alloca(v2);
if ( ((4 * (_WORD)a2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v13[-2] + v2) = *(_QWORD *)((char *)&v13[-2] + v2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
v13[i] = *(_DWORD *)(a1 + 4 * i);
}
if ( a2 <= 1 )
{
if ( a2 == 1 )
{
v9 = v13[0];
if ( v13[0] < 0 )
return 0;
}
else
{
return 0;
}
}
else
{
for ( j = 1LL; j != a2; ++j )
{
if ( (int)j > 0 )
{
v8 = *(_DWORD *)(a1 + 4 * j);
v6 = 0LL;
do
{
if ( v8 > *(_DWORD *)(a1 + 4 * v6) )
{
v7 = v13[v6] + v8;
if ( v13[j] < v7 )
v13[j] = v7;
}
++v6;
}
while ( v6 != j );
}
}
v10 = 0LL;
v9 = 0;
do
{
if ( (signed int)v9 < v13[v10] )
v9 = v13[v10];
++v10;
}
while ( a2 > (int)v10 );
}
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9D,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 RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c5:
CMP RSP,RDX
JZ 0x001011dc
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011c5
LAB_001011dc:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011f2
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011f2:
LEA RSI,[RSP + 0x3]
MOV R8,RSI
SHR R8,0x2
AND RSI,-0x4
TEST R9D,R9D
JLE 0x0010121e
MOV ECX,R9D
MOV EAX,0x0
LAB_0010120f:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x0010120f
LAB_0010121e:
CMP R9D,0x1
JLE 0x00101266
MOV R10D,R9D
MOV EDX,0x1
JMP 0x00101258
LAB_0010122e:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x0010124f
LAB_00101237:
CMP ECX,dword ptr [RDI + RAX*0x4]
JLE 0x0010122e
MOV R8D,ECX
ADD R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RSI + RDX*0x4],R8D
JGE 0x0010122e
MOV dword ptr [RSI + RDX*0x4],R8D
JMP 0x0010122e
LAB_0010124f:
ADD RDX,0x1
CMP RDX,R10
JZ 0x0010126f
LAB_00101258:
TEST EDX,EDX
JLE 0x0010124f
MOV ECX,dword ptr [RDI + RDX*0x4]
MOV EAX,0x0
JMP 0x00101237
LAB_00101266:
JZ 0x0010129d
MOV EDX,0x0
JMP 0x0010128a
LAB_0010126f:
MOV EAX,0x0
MOV EDX,0x0
LAB_00101279:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x1
CMP R9D,EAX
JG 0x00101279
LAB_0010128a:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012b1
MOV EAX,EDX
LEAVE
RET
LAB_0010129d:
MOV EDX,dword ptr [R8*0x4]
TEST EDX,EDX
MOV EAX,0x0
CMOVS EDX,EAX
JMP 0x0010128a
LAB_001012b1:
CALL 0x00101080 | int func0(long param_1,uint param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
int iVar5;
int1 *puVar6;
int iVar7;
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 (puVar6 = auStack_18; puVar6 != auStack_18 + -(uVar2 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar2 = (ulong)((uint)uVar2 & 0xff0);
lVar1 = -uVar2;
if (uVar2 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (0 < (int)param_2) {
uVar2 = 0;
do {
*(int4 *)(puVar6 + uVar2 * 4 + lVar1) = *(int4 *)(param_1 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
if ((int)param_2 < 2) {
if (param_2 == 1) {
iVar5 = *(int *)(puVar6 + lVar1);
if (*(int *)(puVar6 + lVar1) < 0) {
iVar5 = 0;
}
}
else {
iVar5 = 0;
}
}
else {
uVar2 = 1;
do {
if (0 < (int)uVar2) {
iVar5 = *(int *)(param_1 + uVar2 * 4);
uVar3 = 0;
do {
if ((*(int *)(param_1 + uVar3 * 4) < iVar5) &&
(iVar7 = iVar5 + *(int *)(puVar6 + uVar3 * 4 + lVar1),
*(int *)(puVar6 + uVar2 * 4 + lVar1) < iVar7)) {
*(int *)(puVar6 + uVar2 * 4 + lVar1) = iVar7;
}
uVar3 = uVar3 + 1;
} while (uVar3 != uVar2);
}
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
lVar4 = 0;
iVar5 = 0;
do {
if (iVar5 < *(int *)(puVar6 + lVar4 * 4 + lVar1)) {
iVar5 = *(int *)(puVar6 + lVar4 * 4 + lVar1);
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < (int)param_2);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar1 + -8) = main;
__stack_chk_fail();
}
return iVar5;
} |
5,990 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int max = 0;
int msis[n];
for (int i = 0; i < n; i++) {
msis[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && msis[i] < msis[j] + arr[i]) {
msis[i] = msis[j] + arr[i];
}
}
}
for (int i = 0; i < n; i++) {
if (max < msis[i]) {
max = msis[i];
}
}
return max;
}
| int main() {
int arr1[] = {1, 101, 2, 3, 100, 4, 5};
int arr2[] = {3, 4, 5, 10};
int arr3[] = {10, 5, 4, 3};
assert(func0(arr1, 7) == 106);
assert(func0(arr2, 4) == 22);
assert(func0(arr3, 4) == 10);
printf("All tests passed!\n");
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,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1336 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1321 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13ef <func0+0x10f>
lea 0x3(%rsp),%r8
mov %r8,%r10
and $0xfffffffffffffffc,%r8
shr $0x2,%r10
test %esi,%esi
jle 13fa <func0+0x11a>
lea -0x1(%rsi),%ecx
xor %eax,%eax
nopl (%rax)
mov (%rdi,%rax,4),%edx
mov %edx,(%r8,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rcx
jne 1368 <func0+0x88>
cmp $0x1,%esi
jle 13fa <func0+0x11a>
lea -0x2(%rsi),%r10d
mov $0x1,%edx
add $0x2,%r10
nopl (%rax)
mov (%rdi,%rdx,4),%ecx
xor %eax,%eax
nopl (%rax)
cmp (%rdi,%rax,4),%ecx
jle 13ae <func0+0xce>
mov (%r8,%rax,4),%r9d
add %ecx,%r9d
cmp %r9d,(%r8,%rdx,4)
jge 13ae <func0+0xce>
mov %r9d,(%r8,%rdx,4)
add $0x1,%rax
cmp %rax,%rdx
jne 1398 <func0+0xb8>
add $0x1,%rdx
cmp %r10,%rdx
jne 1390 <func0+0xb0>
xor %eax,%eax
xor %r9d,%r9d
nopl (%rax)
mov (%r8,%rax,4),%edx
cmp %edx,%r9d
cmovl %edx,%r9d
add $0x1,%rax
cmp %eax,%esi
jg 13c8 <func0+0xe8>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 141e <func0+0x13e>
leaveq
mov %r9d,%eax
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1348 <func0+0x68>
cmp $0x1,%esi
je 1404 <func0+0x124>
xor %r9d,%r9d
jmp 13db <func0+0xfb>
cmpl $0x0,0x0(,%r10,4)
mov $0x0,%r9d
cmovns 0x0(,%r10,4),%r9d
jmp 13db <func0+0xfb>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
movsxd r13, esi
push r12
mov r12, r13
push rbx
mov rbx, rdi
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea rax, ds:0Fh[r13*4]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1350
loc_133B:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_133B
loc_1350:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_140A
loc_1362:
lea rdi, [rsp+1030h+var_102D]
mov r14, rdi
and rdi, 0FFFFFFFFFFFFFFFCh
shr r14, 2
test r12d, r12d
jle loc_1415
lea rdx, ds:0[r13*4]
mov rsi, rbx
call _memcpy
mov rdi, rax
cmp r12d, 1
jle loc_1415
mov edx, 1
nop dword ptr [rax]
loc_13A0:
mov ecx, [rbx+rdx*4]
xor eax, eax
nop dword ptr [rax]
loc_13A8:
cmp ecx, [rbx+rax*4]
jle short loc_13BA
mov esi, [rdi+rax*4]
add esi, ecx
cmp [rdi+rdx*4], esi
jge short loc_13BA
mov [rdi+rdx*4], esi
loc_13BA:
add rax, 1
cmp rax, rdx
jnz short loc_13A8
lea rdx, [rax+1]
cmp r13, rdx
jnz short loc_13A0
xor eax, eax
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_13D8:
mov edx, [rdi+rax*4]
cmp r8d, edx
cmovl r8d, edx
add rax, 1
cmp r12d, eax
jg short loc_13D8
loc_13EB:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_1433
lea rsp, [rbp-20h]
mov eax, r8d
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_140A:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_1362
loc_1415:
cmp r12d, 1
jz short loc_1420
xor r8d, r8d
jmp short loc_13EB
loc_1420:
mov r8d, ds:dword_0[r14*4]
xor eax, eax
test r8d, r8d
cmovs r8d, eax
jmp short loc_13EB
loc_1433:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v2; // r13
long long v5; // rdx
_DWORD *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
long long v10; // rdi
long long v11; // rdx
int v12; // ecx
long long v13; // rax
int v14; // esi
long long v15; // rax
unsigned int v16; // r8d
_DWORD v19[1022]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v20[6]; // [rsp+1008h] [rbp-30h] BYREF
v2 = a2;
v20[1] = __readfsqword(0x28u);
v5 = 4LL * a2 + 15;
v6 = (_DWORD *)((char *)v20 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( v20 != (_QWORD *)v6 )
{
while ( v19 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v19[-2] + v8) = *(_QWORD *)((char *)&v19[-2] + v8);
if ( a2 <= 0 || (v10 = memcpy(v19, a1, 4LL * a2), a2 <= 1) )
{
if ( a2 == 1 )
{
v16 = v19[0];
if ( v19[0] < 0 )
return 0;
}
else
{
return 0;
}
}
else
{
v11 = 1LL;
do
{
v12 = *(_DWORD *)(a1 + 4 * v11);
v13 = 0LL;
do
{
if ( v12 > *(_DWORD *)(a1 + 4 * v13) )
{
v14 = v12 + *(_DWORD *)(v10 + 4 * v13);
if ( *(_DWORD *)(v10 + 4 * v11) < v14 )
*(_DWORD *)(v10 + 4 * v11) = v14;
}
++v13;
}
while ( v13 != v11 );
v11 = v13 + 1;
}
while ( v2 != v13 + 1 );
v15 = 0LL;
v16 = 0;
do
{
if ( (signed int)v16 < *(_DWORD *)(v10 + 4 * v15) )
v16 = *(_DWORD *)(v10 + 4 * v15);
++v15;
}
while ( a2 > (int)v15 );
}
return v16;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R12,R13
PUSH RBX
MOV RBX,RDI
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[0xf + R13*0x4]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101350
LAB_0010133b:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010133b
LAB_00101350:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010140a
LAB_00101362:
LEA RDI,[RSP + 0x3]
MOV R14,RDI
AND RDI,-0x4
SHR R14,0x2
TEST R12D,R12D
JLE 0x00101415
LEA RDX,[R13*0x4]
MOV RSI,RBX
CALL 0x001010b0
MOV RDI,RAX
CMP R12D,0x1
JLE 0x00101415
MOV EDX,0x1
NOP dword ptr [RAX]
LAB_001013a0:
MOV ECX,dword ptr [RBX + RDX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013a8:
CMP ECX,dword ptr [RBX + RAX*0x4]
JLE 0x001013ba
MOV ESI,dword ptr [RDI + RAX*0x4]
ADD ESI,ECX
CMP dword ptr [RDI + RDX*0x4],ESI
JGE 0x001013ba
MOV dword ptr [RDI + RDX*0x4],ESI
LAB_001013ba:
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001013a8
LEA RDX,[RAX + 0x1]
CMP R13,RDX
JNZ 0x001013a0
XOR EAX,EAX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001013d8:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0x1
CMP R12D,EAX
JG 0x001013d8
LAB_001013eb:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101433
LEA RSP,[RBP + -0x20]
MOV EAX,R8D
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_0010140a:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101362
LAB_00101415:
CMP R12D,0x1
JZ 0x00101420
XOR R8D,R8D
JMP 0x001013eb
LAB_00101420:
MOV R8D,dword ptr [R14*0x4]
XOR EAX,EAX
TEST R8D,R8D
CMOVS R8D,EAX
JMP 0x001013eb
LAB_00101433:
CALL 0x00101090 | int func0(void *param_1,int param_2)
{
long lVar1;
int1 *puVar2;
long lVar3;
void *pvVar4;
long lVar5;
ulong uVar6;
long lVar7;
int1 *puVar8;
int iVar10;
int iVar11;
long lVar12;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar9;
lVar12 = (long)param_2;
puVar8 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = lVar12 * 4 + 0xf;
puVar9 = auStack_38;
puVar2 = auStack_38;
while (puVar9 != auStack_38 + -(uVar6 & 0xfffffffffffff000)) {
puVar8 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar9 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar1 = -uVar6;
if (uVar6 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (0 < param_2) {
*(int8 *)(puVar8 + lVar1 + -8) = 0x10138b;
pvVar4 = memcpy(puVar8 + lVar1,param_1,lVar12 * 4);
if (1 < param_2) {
lVar7 = 1;
do {
iVar11 = *(int *)((long)param_1 + lVar7 * 4);
lVar3 = 0;
do {
lVar5 = lVar3;
if ((*(int *)((long)param_1 + lVar5 * 4) < iVar11) &&
(iVar10 = *(int *)((long)pvVar4 + lVar5 * 4) + iVar11,
*(int *)((long)pvVar4 + lVar7 * 4) < iVar10)) {
*(int *)((long)pvVar4 + lVar7 * 4) = iVar10;
}
lVar3 = lVar5 + 1;
} while (lVar5 + 1 != lVar7);
lVar7 = lVar5 + 2;
} while (lVar12 != lVar7);
lVar12 = 0;
iVar11 = 0;
do {
iVar10 = *(int *)((long)pvVar4 + lVar12 * 4);
if (iVar11 < iVar10) {
iVar11 = iVar10;
}
lVar12 = lVar12 + 1;
} while ((int)lVar12 < param_2);
goto LAB_001013eb;
}
}
if (param_2 == 1) {
iVar11 = *(int *)(puVar8 + lVar1);
if (*(int *)(puVar8 + lVar1) < 0) {
iVar11 = 0;
}
}
else {
iVar11 = 0;
}
LAB_001013eb:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar11;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar8 + lVar1 + -8) = _fini;
__stack_chk_fail();
} |
5,991 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int max = 0;
int msis[n];
for (int i = 0; i < n; i++) {
msis[i] = arr[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && msis[i] < msis[j] + arr[i]) {
msis[i] = msis[j] + arr[i];
}
}
}
for (int i = 0; i < n; i++) {
if (max < msis[i]) {
max = msis[i];
}
}
return max;
}
| int main() {
int arr1[] = {1, 101, 2, 3, 100, 4, 5};
int arr2[] = {3, 4, 5, 10};
int arr3[] = {10, 5, 4, 3};
assert(func0(arr1, 7) == 106);
assert(func0(arr2, 4) == 22);
assert(func0(arr3, 4) == 10);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
mov %esi,%r13d
push %r12
mov %rdi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1331 <func0+0x61>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 131c <func0+0x4c>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14a8 <func0+0x1d8>
lea 0x3(%rsp),%rdi
mov %rdi,%rbx
and $0xfffffffffffffffc,%rdi
shr $0x2,%rbx
test %r13d,%r13d
jle 14b3 <func0+0x1e3>
lea -0x1(%r13),%eax
mov %r12,%rsi
lea 0x4(,%rax,4),%rdx
callq 10b0 <memcpy@plt>
mov %rax,%rdi
cmp $0x1,%r13d
jle 14b3 <func0+0x1e3>
lea -0x2(%r13),%r8d
mov $0x1,%edx
add $0x2,%r8
nopw 0x0(%rax,%rax,1)
mov (%r12,%rdx,4),%ecx
xor %eax,%eax
nopw %cs:0x0(%rax,%rax,1)
cmp (%r12,%rax,4),%ecx
jle 13b3 <func0+0xe3>
mov (%rdi,%rax,4),%esi
add %ecx,%esi
cmp %esi,(%rdi,%rdx,4)
jge 13b3 <func0+0xe3>
mov %esi,(%rdi,%rdx,4)
add $0x1,%rax
cmp %rdx,%rax
jne 13a0 <func0+0xd0>
lea 0x1(%rax),%rdx
cmp %r8,%rdx
jne 1390 <func0+0xc0>
test %r13d,%r13d
mov $0x1,%ecx
cmovg %r13d,%ecx
cmp $0x3,%r13d
jle 14bd <func0+0x1ed>
mov %ecx,%edx
pxor %xmm2,%xmm2
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
xchg %ax,%ax
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 13f0 <func0+0x120>
movdqa %xmm2,%xmm1
mov %ecx,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
and $0x3,%ecx
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
je 148e <func0+0x1be>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%r13d
jle 148e <func0+0x1be>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%r13d
jle 148e <func0+0x1be>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
mov -0x28(%rbp),%rbx
xor %fs:0x28,%rbx
jne 14f1 <func0+0x221>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1343 <func0+0x73>
cmp $0x1,%r13d
je 14da <func0+0x20a>
xor %eax,%eax
jmp 148e <func0+0x1be>
mov 0x0(,%rbx,4),%eax
mov $0x1,%edx
test %eax,%eax
mov $0x0,%eax
cmovns 0x0(,%rbx,4),%eax
jmp 1470 <func0+0x1a0>
cmpl $0x0,0x0(,%rbx,4)
mov $0x0,%eax
cmovns 0x0(,%rbx,4),%eax
jmp 148e <func0+0x1be>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
mov r14d, esi
push r13
mov r13, rdi
push r12
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1332
loc_131D:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rcx
jnz short loc_131D
loc_1332:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_14A6
loc_1344:
lea rdi, [rsp+1050h+var_104D]
mov rax, rdi
and rdi, 0FFFFFFFFFFFFFFFCh; dest
shr rax, 2
mov r15, rdi
mov [rbp+var_48], rax
test r14d, r14d
jle loc_14B1
mov r8d, r14d
mov rsi, r13; src
lea ebx, [r14-1]
lea r12, ds:0[r8*4]
mov rdx, r12; n
call _memcpy
mov rdi, r15
cmp r14d, 1
jz loc_14C9
mov edx, 4
loc_1390:
mov ecx, [r13+rdx+0]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13A0:
cmp ecx, [r13+rax+0]
jle short loc_13B4
mov esi, [rdi+rax]
add esi, ecx
cmp [rdi+rdx], esi
jge short loc_13B4
mov [rdi+rdx], esi
loc_13B4:
add rax, 4
cmp rax, rdx
jnz short loc_13A0
lea rdx, [rax+4]
cmp rdx, r12
jnz short loc_1390
cmp ebx, 2
jbe loc_14B5
mov edx, r14d
mov rax, rdi
pxor xmm2, xmm2
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+rax+00h]
loc_13E8:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rdx, rax
jnz short loc_13E8
movdqa xmm0, xmm2
mov edx, r14d
psrldq xmm0, 8
and edx, 0FFFFFFFCh
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
test r14b, 3
jz short loc_1488
movsxd rcx, edx
lea r15, [rdi+rcx*4]
mov ecx, [r15]
cmp eax, ecx
cmovl eax, ecx
lea ecx, [rdx+1]
cmp r14d, ecx
jle short loc_1488
loc_146E:
mov ecx, [r15+4]
cmp eax, ecx
cmovl eax, ecx
add edx, 2
cmp r14d, edx
jle short loc_1488
mov edx, [r15+8]
cmp eax, edx
cmovl eax, edx
loc_1488:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_14DD
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_14A6:
or [rsp+rdx+1050h+var_1058], 0
jmp loc_1344
loc_14B1:
xor eax, eax
jmp short loc_1488
loc_14B5:
mov rax, [rbp+var_48]
xor edx, edx
mov eax, ds:dword_0[rax*4]
test eax, eax
cmovs eax, edx
jmp short loc_146E
loc_14C9:
mov rax, [rbp+var_48]
xor edx, edx
mov eax, ds:dword_0[rax*4]
test eax, eax
cmovs eax, edx
jmp short loc_1488
loc_14DD:
call ___stack_chk_fail | long long func0(char *src, int a2)
{
long long v3; // rdx
long long *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
int *v8; // r15
unsigned int v9; // ebx
size_t v10; // r12
long long v11; // rdx
int v12; // ecx
long long v13; // rax
int v14; // esi
const __m128i *v15; // rax
__m128i v16; // xmm2
__m128i v17; // xmm0
__m128i v18; // xmm1
__m128i v19; // xmm0
unsigned int v20; // edx
__m128i v21; // xmm1
__m128i v22; // xmm1
__m128i v23; // xmm2
__m128i v24; // xmm0
long long result; // rax
int v26; // ecx
int v27; // edx
_BYTE v29[3]; // [rsp+8h] [rbp-1050h] BYREF
char v30; // [rsp+Bh] [rbp-104Dh] BYREF
long long v31; // [rsp+1008h] [rbp-50h] BYREF
unsigned long long v32; // [rsp+1010h] [rbp-48h]
unsigned long long v33; // [rsp+1020h] [rbp-38h]
v33 = __readfsqword(0x28u);
v3 = 4LL * a2 + 15;
v4 = (long long *)((char *)&v31 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( &v31 != v4 )
{
while ( v29 != (_BYTE *)v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(_QWORD *)&v29[v6 - 8] = *(_QWORD *)&v29[v6 - 8];
v8 = (int *)v29;
v32 = (unsigned long long)&v30 >> 2;
if ( a2 <= 0 )
return 0LL;
v9 = a2 - 1;
v10 = 4LL * (unsigned int)a2;
memcpy(v29, src, v10);
if ( a2 == 1 )
{
result = *(unsigned int *)(4 * v32);
if ( (int)result < 0 )
return 0LL;
}
else
{
v11 = 4LL;
do
{
v12 = *(_DWORD *)&src[v11];
v13 = 0LL;
do
{
if ( v12 > *(_DWORD *)&src[v13] )
{
v14 = v12 + *(_DWORD *)&v29[v13];
if ( *(_DWORD *)&v29[v11] < v14 )
*(_DWORD *)&v29[v11] = v14;
}
v13 += 4LL;
}
while ( v13 != v11 );
v11 = v13 + 4;
}
while ( v13 + 4 != v10 );
if ( v9 <= 2 )
{
v20 = 0;
result = *(unsigned int *)(4 * v32);
if ( (int)result < 0 )
result = 0LL;
goto LABEL_21;
}
v15 = (const __m128i *)v29;
v16 = 0LL;
do
{
v17 = _mm_loadu_si128(v15++);
v18 = _mm_cmpgt_epi32(v17, v16);
v16 = _mm_or_si128(_mm_andnot_si128(v18, v16), _mm_and_si128(v17, v18));
}
while ( &v29[16 * ((unsigned int)a2 >> 2)] != (_BYTE *)v15 );
v19 = _mm_srli_si128(v16, 8);
v20 = a2 & 0xFFFFFFFC;
v21 = _mm_cmpgt_epi32(v19, v16);
v22 = _mm_or_si128(_mm_andnot_si128(v21, v16), _mm_and_si128(v19, v21));
v23 = _mm_srli_si128(v22, 4);
v24 = _mm_cmpgt_epi32(v23, v22);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v24, v22), _mm_and_si128(v23, v24)));
if ( (a2 & 3) != 0 )
{
v8 = (int *)&v29[4 * v20];
if ( (int)result < *v8 )
result = (unsigned int)*v8;
if ( a2 > (int)(v20 + 1) )
{
LABEL_21:
v26 = v8[1];
if ( (int)result < v26 )
result = (unsigned int)v26;
if ( a2 > (int)(v20 + 2) )
{
v27 = v8[2];
if ( (int)result < v27 )
return (unsigned int)v27;
}
}
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101332
LAB_0010131d:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010131d
LAB_00101332:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001014a6
LAB_00101344:
LEA RDI,[RSP + 0x3]
MOV RAX,RDI
AND RDI,-0x4
SHR RAX,0x2
MOV R15,RDI
MOV qword ptr [RBP + -0x48],RAX
TEST R14D,R14D
JLE 0x001014b1
MOV R8D,R14D
MOV RSI,R13
LEA EBX,[R14 + -0x1]
LEA R12,[R8*0x4]
MOV RDX,R12
CALL 0x001010b0
MOV RDI,R15
CMP R14D,0x1
JZ 0x001014c9
MOV EDX,0x4
LAB_00101390:
MOV ECX,dword ptr [R13 + RDX*0x1]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001013a0:
CMP ECX,dword ptr [R13 + RAX*0x1]
JLE 0x001013b4
MOV ESI,dword ptr [RDI + RAX*0x1]
ADD ESI,ECX
CMP dword ptr [RDI + RDX*0x1],ESI
JGE 0x001013b4
MOV dword ptr [RDI + RDX*0x1],ESI
LAB_001013b4:
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001013a0
LEA RDX,[RAX + 0x4]
CMP RDX,R12
JNZ 0x00101390
CMP EBX,0x2
JBE 0x001014b5
MOV EDX,R14D
MOV RAX,RDI
PXOR XMM2,XMM2
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e8:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RDX,RAX
JNZ 0x001013e8
MOVDQA XMM0,XMM2
MOV EDX,R14D
PSRLDQ XMM0,0x8
AND EDX,0xfffffffc
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
TEST R14B,0x3
JZ 0x00101488
MOVSXD RCX,EDX
LEA R15,[RDI + RCX*0x4]
MOV ECX,dword ptr [R15]
CMP EAX,ECX
CMOVL EAX,ECX
LEA ECX,[RDX + 0x1]
CMP R14D,ECX
JLE 0x00101488
LAB_0010146e:
MOV ECX,dword ptr [R15 + 0x4]
CMP EAX,ECX
CMOVL EAX,ECX
ADD EDX,0x2
CMP R14D,EDX
JLE 0x00101488
MOV EDX,dword ptr [R15 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_00101488:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001014dd
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001014a6:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101344
LAB_001014b1:
XOR EAX,EAX
JMP 0x00101488
LAB_001014b5:
MOV RAX,qword ptr [RBP + -0x48]
XOR EDX,EDX
MOV EAX,dword ptr [RAX*0x4]
TEST EAX,EAX
CMOVS EAX,EDX
JMP 0x0010146e
LAB_001014c9:
MOV RAX,qword ptr [RBP + -0x48]
XOR EDX,EDX
MOV EAX,dword ptr [RAX*0x4]
TEST EAX,EAX
CMOVS EAX,EDX
JMP 0x00101488
LAB_001014dd:
CALL 0x00101090 | uint func0(void *param_1,uint param_2)
{
int iVar1;
long lVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
int *puVar6;
size_t sVar7;
size_t sVar8;
uint *puVar9;
uint uVar10;
ulong uVar11;
size_t sVar12;
int *puVar13;
int iVar15;
long in_FS_OFFSET;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
int auStack_58 [8];
ulong local_50;
long local_40;
int *puVar14;
puVar13 = auStack_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar11 = (long)(int)param_2 * 4 + 0xf;
puVar14 = auStack_58;
puVar6 = auStack_58;
while (puVar14 != auStack_58 + -(uVar11 & 0xfffffffffffff000)) {
puVar13 = puVar6 + -0x1000;
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
puVar14 = puVar6 + -0x1000;
puVar6 = puVar6 + -0x1000;
}
uVar11 = (ulong)((uint)uVar11 & 0xff0);
lVar2 = -uVar11;
puVar9 = (uint *)(puVar13 + lVar2);
if (uVar11 != 0) {
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
}
local_50 = (ulong)(puVar13 + lVar2 + 3) >> 2;
if ((int)param_2 < 1) {
uVar16 = 0;
}
else {
*(int8 *)(puVar13 + lVar2 + -8) = 0x10137e;
memcpy(puVar13 + lVar2,param_1,(ulong)param_2 * 4);
if (param_2 == 1) {
uVar16 = *(uint *)(local_50 * 4);
if ((int)*(uint *)(local_50 * 4) < 0) {
uVar16 = 0;
}
}
else {
sVar12 = 4;
do {
iVar1 = *(int *)((long)param_1 + sVar12);
sVar7 = 0;
do {
sVar8 = sVar7;
if ((*(int *)((long)param_1 + sVar8) < iVar1) &&
(iVar15 = *(int *)(puVar13 + sVar8 + lVar2) + iVar1,
*(int *)(puVar13 + sVar12 + lVar2) < iVar15)) {
*(int *)(puVar13 + sVar12 + lVar2) = iVar15;
}
sVar7 = sVar8 + 4;
} while (sVar8 + 4 != sVar12);
sVar12 = sVar8 + 8;
} while (sVar12 != (ulong)param_2 * 4);
if (param_2 - 1 < 3) {
uVar10 = 0;
uVar16 = *(uint *)(local_50 * 4);
puVar9 = (uint *)(puVar13 + lVar2);
if ((int)uVar16 < 0) {
uVar16 = 0;
puVar9 = (uint *)(puVar13 + lVar2);
}
}
else {
uVar16 = 0;
uVar21 = 0;
uVar22 = 0;
uVar23 = 0;
do {
uVar10 = *puVar9;
puVar3 = puVar9 + 1;
puVar4 = puVar9 + 2;
puVar5 = puVar9 + 3;
puVar9 = puVar9 + 4;
uVar17 = -(uint)((int)uVar16 < (int)uVar10);
uVar18 = -(uint)((int)uVar21 < (int)*puVar3);
uVar19 = -(uint)((int)uVar22 < (int)*puVar4);
uVar20 = -(uint)((int)uVar23 < (int)*puVar5);
uVar16 = ~uVar17 & uVar16 | uVar10 & uVar17;
uVar21 = ~uVar18 & uVar21 | *puVar3 & uVar18;
uVar22 = ~uVar19 & uVar22 | *puVar4 & uVar19;
uVar23 = ~uVar20 & uVar23 | *puVar5 & uVar20;
} while ((uint *)(puVar13 + (ulong)(param_2 >> 2) * 0x10 + lVar2) != puVar9);
uVar10 = param_2 & 0xfffffffc;
uVar22 = ~-(uint)((int)uVar16 < (int)uVar22) & uVar16 |
uVar22 & -(uint)((int)uVar16 < (int)uVar22);
uVar21 = ~-(uint)((int)uVar21 < (int)uVar23) & uVar21 |
uVar23 & -(uint)((int)uVar21 < (int)uVar23);
uVar16 = -(uint)((int)uVar22 < (int)uVar21);
uVar16 = ~uVar16 & uVar22 | uVar21 & uVar16;
if ((param_2 & 3) == 0) goto LAB_00101488;
uVar21 = *(uint *)(puVar13 + (long)(int)uVar10 * 4 + lVar2);
if ((int)uVar16 < (int)uVar21) {
uVar16 = uVar21;
}
puVar9 = (uint *)(puVar13 + (long)(int)uVar10 * 4 + lVar2);
if ((int)param_2 <= (int)(uVar10 + 1)) goto LAB_00101488;
}
if ((int)uVar16 < (int)puVar9[1]) {
uVar16 = puVar9[1];
}
if (((int)(uVar10 + 2) < (int)param_2) && ((int)uVar16 < (int)puVar9[2])) {
uVar16 = puVar9[2];
}
}
}
LAB_00101488:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar16;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar13 + lVar2 + -8) = 0x1014e2;
__stack_chk_fail();
} |
5,992 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int line1[], int line2[]) {
return line1[0] * line2[1] == line1[1] * line2[0];
}
| int main() {
int line1[] = {2, 3, 4};
int line2[] = {2, 3, 8};
assert(func0(line1, line2) == true);
int line3[] = {2, 3, 4};
int line4[] = {4, -3, 8};
assert(func0(line3, line4) == false);
int line5[] = {3, 3};
int line6[] = {5, 5};
assert(func0(line5, line6) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x10(%rbp),%rax
add $0x4,%rax
mov (%rax),%eax
imul %eax,%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%ecx
mov -0x10(%rbp),%rax
mov (%rax),%eax
imul %ecx,%eax
cmp %eax,%edx
sete %al
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov edx, [rax]
mov rax, [rbp+var_10]
add rax, 4
mov eax, [rax]
mov ecx, edx
imul ecx, eax
mov rax, [rbp+var_8]
add rax, 4
mov edx, [rax]
mov rax, [rbp+var_10]
mov eax, [rax]
imul eax, edx
cmp ecx, eax
setz al
pop rbp
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
return a2[1] * *a1 == a1[1] * *a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x4
MOV EAX,dword ptr [RAX]
MOV ECX,EDX
IMUL ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
CMP ECX,EAX
SETZ AL
POP RBP
RET | int4 func0(int *param_1,int *param_2)
{
return CONCAT31((int3)((uint)(*param_2 * param_1[1]) >> 8),
*param_1 * param_2[1] == *param_2 * param_1[1]);
} |
5,993 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int line1[], int line2[]) {
return line1[0] * line2[1] == line1[1] * line2[0];
}
| int main() {
int line1[] = {2, 3, 4};
int line2[] = {2, 3, 8};
assert(func0(line1, line2) == true);
int line3[] = {2, 3, 4};
int line4[] = {4, -3, 8};
assert(func0(line3, line4) == false);
int line5[] = {3, 3};
int line6[] = {5, 5};
assert(func0(line5, line6) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%edx
imul 0x4(%rsi),%edx
mov 0x4(%rdi),%eax
imul (%rsi),%eax
cmp %eax,%edx
sete %al
retq
| func0:
endbr64
mov edx, [rdi]
imul edx, [rsi+4]
mov eax, [rdi+4]
imul eax, [rsi]
cmp edx, eax
setz al
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
return a2[1] * *a1 == *a2 * a1[1];
} | func0:
ENDBR64
MOV EDX,dword ptr [RDI]
IMUL EDX,dword ptr [RSI + 0x4]
MOV EAX,dword ptr [RDI + 0x4]
IMUL EAX,dword ptr [RSI]
CMP EDX,EAX
SETZ AL
RET | int4 func0(int *param_1,int *param_2)
{
return CONCAT31((int3)((uint)(param_1[1] * *param_2) >> 8),
*param_1 * param_2[1] == param_1[1] * *param_2);
} |
5,994 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int line1[], int line2[]) {
return line1[0] * line2[1] == line1[1] * line2[0];
}
| int main() {
int line1[] = {2, 3, 4};
int line2[] = {2, 3, 8};
assert(func0(line1, line2) == true);
int line3[] = {2, 3, 4};
int line4[] = {4, -3, 8};
assert(func0(line3, line4) == false);
int line5[] = {3, 3};
int line6[] = {5, 5};
assert(func0(line5, line6) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%edx
mov 0x4(%rdi),%eax
imul 0x4(%rsi),%edx
imul (%rsi),%eax
cmp %eax,%edx
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov edx, [rdi]
mov eax, [rdi+4]
imul edx, [rsi+4]
imul eax, [rsi]
cmp edx, eax
setz al
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
return a2[1] * *a1 == *a2 * a1[1];
} | func0:
ENDBR64
MOV EDX,dword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x4]
IMUL EDX,dword ptr [RSI + 0x4]
IMUL EAX,dword ptr [RSI]
CMP EDX,EAX
SETZ AL
RET | int4 func0(int *param_1,int *param_2)
{
return CONCAT31((int3)((uint)(param_1[1] * *param_2) >> 8),
*param_1 * param_2[1] == param_1[1] * *param_2);
} |
5,995 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int line1[], int line2[]) {
return line1[0] * line2[1] == line1[1] * line2[0];
}
| int main() {
int line1[] = {2, 3, 4};
int line2[] = {2, 3, 8};
assert(func0(line1, line2) == true);
int line3[] = {2, 3, 4};
int line4[] = {4, -3, 8};
assert(func0(line3, line4) == false);
int line5[] = {3, 3};
int line6[] = {5, 5};
assert(func0(line5, line6) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%edx
mov 0x4(%rdi),%eax
imul 0x4(%rsi),%edx
imul (%rsi),%eax
cmp %eax,%edx
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov edx, [rdi]
mov eax, [rdi+4]
imul edx, [rsi+4]
imul eax, [rsi]
cmp edx, eax
setz al
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
return a2[1] * *a1 == *a2 * a1[1];
} | func0:
ENDBR64
MOV EDX,dword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x4]
IMUL EDX,dword ptr [RSI + 0x4]
IMUL EAX,dword ptr [RSI]
CMP EDX,EAX
SETZ AL
RET | int4 func0(int *param_1,int *param_2)
{
return CONCAT31((int3)((uint)(param_1[1] * *param_2) >> 8),
*param_1 * param_2[1] == param_1[1] * *param_2);
} |
5,996 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(const char* str1) {
size_t len = strlen(str1);
char* result = malloc(len + 1);
if (!result) return NULL;
if (len > 0) {
result[0] = toupper(str1[0]);
for (size_t i = 1; i < len; i++) {
result[i] = tolower(str1[i]);
}
result[len - 1] = toupper(result[len - 1]);
result[len] = '\0';
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "PythoN") == 0);
assert(strcmp(func0("bigdata"), "BigdatA") == 0);
assert(strcmp(func0("Hadoop"), "HadooP") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
add $0x1,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 122e <func0+0x45>
mov $0x0,%eax
jmpq 12d7 <func0+0xee>
cmpq $0x0,-0x10(%rbp)
je 12d3 <func0+0xea>
mov -0x28(%rbp),%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10a0 <toupper@plt>
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %dl,(%rax)
movq $0x1,-0x18(%rbp)
jmp 128a <func0+0xa1>
mov -0x28(%rbp),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10e0 <tolower@plt>
mov %eax,%ecx
mov -0x8(%rbp),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
cmp -0x10(%rbp),%rax
jb 125c <func0+0x73>
mov -0x10(%rbp),%rax
lea -0x1(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10a0 <toupper@plt>
mov %eax,%ecx
mov -0x10(%rbp),%rax
lea -0x1(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
mov -0x8(%rbp),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_122E
mov eax, 0
jmp locret_12D7
loc_122E:
cmp [rbp+var_10], 0
jz loc_12D3
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _toupper
mov edx, eax
mov rax, [rbp+var_8]
mov [rax], dl
mov [rbp+var_18], 1
jmp short loc_128A
loc_125C:
mov rdx, [rbp+s]
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _tolower
mov ecx, eax
mov rdx, [rbp+var_8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, ecx
mov [rax], dl
add [rbp+var_18], 1
loc_128A:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
jb short loc_125C
mov rax, [rbp+var_10]
lea rdx, [rax-1]
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _toupper
mov ecx, eax
mov rax, [rbp+var_10]
lea rdx, [rax-1]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, ecx
mov [rax], dl
mov rdx, [rbp+var_8]
mov rax, [rbp+var_10]
add rax, rdx
mov byte ptr [rax], 0
loc_12D3:
mov rax, [rbp+var_8]
locret_12D7:
leave
retn | _BYTE * func0(const char *a1)
{
unsigned long long i; // [rsp+18h] [rbp-18h]
size_t v3; // [rsp+20h] [rbp-10h]
_BYTE *v4; // [rsp+28h] [rbp-8h]
v3 = strlen(a1);
v4 = malloc(v3 + 1);
if ( !v4 )
return 0LL;
if ( v3 )
{
*v4 = toupper(*a1);
for ( i = 1LL; i < v3; ++i )
v4[i] = tolower(a1[i]);
v4[v3 - 1] = toupper((char)v4[v3 - 1]);
v4[v3] = 0;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010122e
MOV EAX,0x0
JMP 0x001012d7
LAB_0010122e:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001012d3
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010a0
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],DL
MOV qword ptr [RBP + -0x18],0x1
JMP 0x0010128a
LAB_0010125c:
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010e0
MOV ECX,EAX
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
ADD qword ptr [RBP + -0x18],0x1
LAB_0010128a:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
JC 0x0010125c
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010a0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
LAB_001012d3:
MOV RAX,qword ptr [RBP + -0x8]
LAB_001012d7:
LEAVE
RET | int * func0(char *param_1)
{
int iVar1;
size_t sVar2;
int *puVar3;
ulong local_20;
sVar2 = strlen(param_1);
puVar3 = (int *)malloc(sVar2 + 1);
if (puVar3 == (int *)0x0) {
puVar3 = (int *)0x0;
}
else if (sVar2 != 0) {
iVar1 = toupper((int)*param_1);
*puVar3 = (char)iVar1;
for (local_20 = 1; local_20 < sVar2; local_20 = local_20 + 1) {
iVar1 = tolower((int)param_1[local_20]);
puVar3[local_20] = (char)iVar1;
}
iVar1 = toupper((int)(char)puVar3[sVar2 - 1]);
puVar3[sVar2 - 1] = (char)iVar1;
puVar3[sVar2] = 0;
}
return puVar3;
} |
5,997 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(const char* str1) {
size_t len = strlen(str1);
char* result = malloc(len + 1);
if (!result) return NULL;
if (len > 0) {
result[0] = toupper(str1[0]);
for (size_t i = 1; i < len; i++) {
result[i] = tolower(str1[i]);
}
result[len - 1] = toupper(result[len - 1]);
result[len] = '\0';
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "PythoN") == 0);
assert(strcmp(func0("bigdata"), "BigdatA") == 0);
assert(strcmp(func0("Hadoop"), "HadooP") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%r12
lea -0x1(%rcx),%r13
mov %rcx,%rdi
callq 10a0 <malloc@plt>
mov %rax,%rbx
test %rax,%rax
je 1235 <func0+0x8c>
test %r13,%r13
je 1235 <func0+0x8c>
callq 1080 <__ctype_toupper_loc@plt>
mov (%rax),%r14
movsbq 0x0(%rbp),%rax
mov (%r14,%rax,4),%eax
mov %al,(%rbx)
cmp $0x1,%r13
jbe 1220 <func0+0x77>
callq 10b0 <__ctype_tolower_loc@plt>
mov (%rax),%rcx
mov $0x1,%edx
movsbq 0x0(%rbp,%rdx,1),%rax
mov (%rcx,%rax,4),%eax
mov %al,(%rbx,%rdx,1)
add $0x1,%rdx
cmp %r13,%rdx
jne 120b <func0+0x62>
lea -0x1(%rbx,%r13,1),%rax
movsbq (%rax),%rdx
mov (%r14,%rdx,4),%edx
mov %dl,(%rax)
movb $0x0,-0x1(%rbx,%r12,1)
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
call _strlen
mov rbp, rax
lea rdi, [rax+1]
call _malloc
mov rbx, rax
test rax, rax
jz short loc_1267
test rbp, rbp
jz short loc_1267
call ___ctype_toupper_loc
mov r13, [rax]
movsx rax, byte ptr [r12]
mov eax, [r13+rax*4+0]
mov [rbx], al
cmp rbp, 1
jbe short loc_1253
call ___ctype_tolower_loc
mov rcx, [rax]
mov eax, 1
loc_123F:
movsx rdx, byte ptr [r12+rax]
mov edx, [rcx+rdx*4]
mov [rbx+rax], dl
add rax, 1
cmp rax, rbp
jnz short loc_123F
loc_1253:
lea rax, [rbx+rbp-1]
movsx rdx, byte ptr [rax]
mov edx, [r13+rdx*4+0]
mov [rax], dl
mov byte ptr [rbx+rbp], 0
loc_1267:
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(char *a1)
{
unsigned long long v1; // rbp
_BYTE *v2; // rbx
long long *v3; // rax
long long v4; // r13
long long v5; // rcx
long long i; // rax
v1 = strlen();
v2 = (_BYTE *)malloc(v1 + 1);
if ( v2 && v1 )
{
v3 = (long long *)__ctype_toupper_loc();
v4 = *v3;
*v2 = *(_DWORD *)(*v3 + 4LL * *a1);
if ( v1 > 1 )
{
v5 = *(_QWORD *)__ctype_tolower_loc();
for ( i = 1LL; i != v1; ++i )
v2[i] = *(_DWORD *)(v5 + 4LL * a1[i]);
}
*(_WORD *)&v2[v1 - 1] = (unsigned __int8)*(_DWORD *)(v4 + 4LL * (char)v2[v1 - 1]);
}
return v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
CALL 0x001010b0
MOV RBP,RAX
LEA RDI,[RAX + 0x1]
CALL 0x001010e0
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00101267
TEST RBP,RBP
JZ 0x00101267
CALL 0x001010a0
MOV R13,qword ptr [RAX]
MOVSX RAX,byte ptr [R12]
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV byte ptr [RBX],AL
CMP RBP,0x1
JBE 0x00101253
CALL 0x001010f0
MOV RCX,qword ptr [RAX]
MOV EAX,0x1
LAB_0010123f:
MOVSX RDX,byte ptr [R12 + RAX*0x1]
MOV EDX,dword ptr [RCX + RDX*0x4]
MOV byte ptr [RBX + RAX*0x1],DL
ADD RAX,0x1
CMP RAX,RBP
JNZ 0x0010123f
LAB_00101253:
LEA RAX,[RBX + RBP*0x1 + -0x1]
MOVSX RDX,byte ptr [RAX]
MOV EDX,dword ptr [R13 + RDX*0x4]
MOV byte ptr [RAX],DL
MOV byte ptr [RBX + RBP*0x1],0x0
LAB_00101267:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
__int32_t *p_Var1;
__int32_t *p_Var2;
size_t sVar3;
int1 *puVar4;
__int32_t **pp_Var5;
size_t sVar6;
sVar3 = strlen(param_1);
puVar4 = (int1 *)malloc(sVar3 + 1);
if ((puVar4 != (int1 *)0x0) && (sVar3 != 0)) {
pp_Var5 = __ctype_toupper_loc();
p_Var1 = *pp_Var5;
*puVar4 = (char)p_Var1[*param_1];
if (1 < sVar3) {
pp_Var5 = __ctype_tolower_loc();
p_Var2 = *pp_Var5;
sVar6 = 1;
do {
puVar4[sVar6] = (char)p_Var2[param_1[sVar6]];
sVar6 = sVar6 + 1;
} while (sVar6 != sVar3);
}
puVar4[sVar3 - 1] = (char)p_Var1[(char)puVar4[sVar3 - 1]];
puVar4[sVar3] = 0;
}
return puVar4;
} |
5,998 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(const char* str1) {
size_t len = strlen(str1);
char* result = malloc(len + 1);
if (!result) return NULL;
if (len > 0) {
result[0] = toupper(str1[0]);
for (size_t i = 1; i < len; i++) {
result[i] = tolower(str1[i]);
}
result[len - 1] = toupper(result[len - 1]);
result[len] = '\0';
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "PythoN") == 0);
assert(strcmp(func0("bigdata"), "BigdatA") == 0);
assert(strcmp(func0("Hadoop"), "HadooP") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 10a0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbx
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 133b <func0+0x8b>
test %rbx,%rbx
je 133b <func0+0x8b>
callq 1090 <__ctype_toupper_loc@plt>
mov (%rax),%r13
movsbq 0x0(%rbp),%rax
mov 0x0(%r13,%rax,4),%eax
mov %al,(%r12)
cmp $0x1,%rbx
je 1326 <func0+0x76>
callq 10d0 <__ctype_tolower_loc@plt>
mov (%rax),%rcx
mov $0x1,%eax
nopl 0x0(%rax,%rax,1)
movsbq 0x0(%rbp,%rax,1),%rdx
mov (%rcx,%rdx,4),%edx
mov %dl,(%r12,%rax,1)
add $0x1,%rax
cmp %rbx,%rax
jne 1310 <func0+0x60>
lea -0x1(%r12,%rbx,1),%rax
movsbq (%rax),%rdx
mov 0x0(%r13,%rdx,4),%edx
mov %dl,(%rax)
movb $0x0,(%r12,%rbx,1)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
| func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea rdi, [rax+1]
mov rbx, rax
call _malloc
mov r12, rax
test rax, rax
jz short loc_134B
test rbx, rbx
jz short loc_134B
call ___ctype_toupper_loc
mov r13, [rax]
movsx rax, byte ptr [rbp+0]
mov eax, [r13+rax*4+0]
mov [r12], al
cmp rbx, 1
jz short loc_1336
call ___ctype_tolower_loc
mov rcx, [rax]
mov eax, 1
nop dword ptr [rax+rax+00000000h]
loc_1320:
movsx rdx, byte ptr [rbp+rax+0]
mov edx, [rcx+rdx*4]
mov [r12+rax], dl
add rax, 1
cmp rax, rbx
jnz short loc_1320
loc_1336:
lea rax, [r12+rbx-1]
movsx rdx, byte ptr [rax]
mov edx, [r13+rdx*4+0]
mov [rax], dl
mov byte ptr [r12+rbx], 0
loc_134B:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(char *a1)
{
long long v1; // rbx
_BYTE *v2; // r12
long long *v3; // rax
long long v4; // r13
long long v5; // rcx
long long i; // rax
v1 = strlen();
v2 = (_BYTE *)malloc(v1 + 1);
if ( v2 && v1 )
{
v3 = (long long *)__ctype_toupper_loc();
v4 = *v3;
*v2 = *(_DWORD *)(*v3 + 4LL * *a1);
if ( v1 != 1 )
{
v5 = *(_QWORD *)__ctype_tolower_loc();
for ( i = 1LL; i != v1; ++i )
v2[i] = *(_DWORD *)(v5 + 4LL * a1[i]);
}
*(_WORD *)&v2[v1 - 1] = (unsigned __int8)*(_DWORD *)(v4 + 4LL * (char)v2[v1 - 1]);
}
return v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x001010b0
LEA RDI,[RAX + 0x1]
MOV RBX,RAX
CALL 0x001010e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x0010134b
TEST RBX,RBX
JZ 0x0010134b
CALL 0x001010a0
MOV R13,qword ptr [RAX]
MOVSX RAX,byte ptr [RBP]
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV byte ptr [R12],AL
CMP RBX,0x1
JZ 0x00101336
CALL 0x001010f0
MOV RCX,qword ptr [RAX]
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101320:
MOVSX RDX,byte ptr [RBP + RAX*0x1]
MOV EDX,dword ptr [RCX + RDX*0x4]
MOV byte ptr [R12 + RAX*0x1],DL
ADD RAX,0x1
CMP RAX,RBX
JNZ 0x00101320
LAB_00101336:
LEA RAX,[R12 + RBX*0x1 + -0x1]
MOVSX RDX,byte ptr [RAX]
MOV EDX,dword ptr [R13 + RDX*0x4]
MOV byte ptr [RAX],DL
MOV byte ptr [R12 + RBX*0x1],0x0
LAB_0010134b:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
__int32_t *p_Var1;
__int32_t *p_Var2;
size_t sVar3;
int1 *puVar4;
__int32_t **pp_Var5;
size_t sVar6;
sVar3 = strlen(param_1);
puVar4 = (int1 *)malloc(sVar3 + 1);
if ((puVar4 != (int1 *)0x0) && (sVar3 != 0)) {
pp_Var5 = __ctype_toupper_loc();
p_Var1 = *pp_Var5;
*puVar4 = (char)p_Var1[*param_1];
if (sVar3 != 1) {
pp_Var5 = __ctype_tolower_loc();
p_Var2 = *pp_Var5;
sVar6 = 1;
do {
puVar4[sVar6] = (char)p_Var2[param_1[sVar6]];
sVar6 = sVar6 + 1;
} while (sVar6 != sVar3);
}
puVar4[sVar3 - 1] = (char)p_Var1[(char)puVar4[sVar3 - 1]];
puVar4[sVar3] = 0;
}
return puVar4;
} |
5,999 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(const char* str1) {
size_t len = strlen(str1);
char* result = malloc(len + 1);
if (!result) return NULL;
if (len > 0) {
result[0] = toupper(str1[0]);
for (size_t i = 1; i < len; i++) {
result[i] = tolower(str1[i]);
}
result[len - 1] = toupper(result[len - 1]);
result[len] = '\0';
}
return result;
}
| int main() {
assert(strcmp(func0("python"), "PythoN") == 0);
assert(strcmp(func0("bigdata"), "BigdatA") == 0);
assert(strcmp(func0("Hadoop"), "HadooP") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 10a0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbx
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 133b <func0+0x8b>
test %rbx,%rbx
je 133b <func0+0x8b>
callq 1090 <__ctype_toupper_loc@plt>
mov (%rax),%r13
movsbq 0x0(%rbp),%rax
mov 0x0(%r13,%rax,4),%eax
mov %al,(%r12)
cmp $0x1,%rbx
je 1326 <func0+0x76>
callq 10d0 <__ctype_tolower_loc@plt>
mov (%rax),%rcx
mov $0x1,%eax
nopl 0x0(%rax,%rax,1)
movsbq 0x0(%rbp,%rax,1),%rdx
mov (%rcx,%rdx,4),%edx
mov %dl,(%r12,%rax,1)
add $0x1,%rax
cmp %rbx,%rax
jne 1310 <func0+0x60>
lea -0x1(%r12,%rbx,1),%rax
movsbq (%rax),%rdx
mov 0x0(%r13,%rdx,4),%edx
mov %dl,(%rax)
movb $0x0,(%r12,%rbx,1)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
| func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
call _strlen
lea rdi, [rax+1]; size
mov rbx, rax
call _malloc
mov rbp, rax
test rbx, rbx
jz short loc_134A
test rax, rax
jz short loc_134A
call ___ctype_toupper_loc
mov r13, [rax]
movsx rax, byte ptr [r12]
mov eax, [r13+rax*4+0]
mov [rbp+0], al
cmp rbx, 1
jz short loc_1335
call ___ctype_tolower_loc
mov rcx, [rax]
mov eax, 1
nop word ptr [rax+rax+00000000h]
loc_1320:
movsx rdx, byte ptr [r12+rax]
mov edx, [rcx+rdx*4]
mov [rbp+rax+0], dl
add rax, 1
cmp rax, rbx
jnz short loc_1320
loc_1335:
lea rax, [rbp+rbx-1]
movsx rdx, byte ptr [rax]
mov edx, [r13+rdx*4+0]
mov [rax], dl
mov byte ptr [rbp+rbx+0], 0
loc_134A:
add rsp, 8
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(const char *a1)
{
size_t v1; // rbx
_BYTE *v2; // rax
_BYTE *v3; // rbp
const __int32_t **v4; // rax
const __int32_t *v5; // r13
const __int32_t *v6; // rcx
long long i; // rax
v1 = strlen(a1);
v2 = malloc(v1 + 1);
v3 = v2;
if ( v1 && v2 )
{
v4 = __ctype_toupper_loc();
v5 = *v4;
*v3 = (*v4)[*a1];
if ( v1 != 1 )
{
v6 = *__ctype_tolower_loc();
for ( i = 1LL; i != v1; ++i )
v3[i] = v6[a1[i]];
}
*(_WORD *)&v3[v1 - 1] = (unsigned __int8)v5[(char)v3[v1 - 1]];
}
return v3;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x001010b0
LEA RDI,[RAX + 0x1]
MOV RBX,RAX
CALL 0x001010e0
MOV RBP,RAX
TEST RBX,RBX
JZ 0x0010134a
TEST RAX,RAX
JZ 0x0010134a
CALL 0x001010a0
MOV R13,qword ptr [RAX]
MOVSX RAX,byte ptr [R12]
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV byte ptr [RBP],AL
CMP RBX,0x1
JZ 0x00101335
CALL 0x001010f0
MOV RCX,qword ptr [RAX]
MOV EAX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101320:
MOVSX RDX,byte ptr [R12 + RAX*0x1]
MOV EDX,dword ptr [RCX + RDX*0x4]
MOV byte ptr [RBP + RAX*0x1],DL
ADD RAX,0x1
CMP RAX,RBX
JNZ 0x00101320
LAB_00101335:
LEA RAX,[RBP + RBX*0x1 + -0x1]
MOVSX RDX,byte ptr [RAX]
MOV EDX,dword ptr [R13 + RDX*0x4]
MOV byte ptr [RAX],DL
MOV byte ptr [RBP + RBX*0x1],0x0
LAB_0010134a:
ADD RSP,0x8
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
RET | int * func0(char *param_1)
{
__int32_t *p_Var1;
__int32_t *p_Var2;
size_t sVar3;
int *puVar4;
__int32_t **pp_Var5;
size_t sVar6;
sVar3 = strlen(param_1);
puVar4 = (int *)malloc(sVar3 + 1);
if ((sVar3 != 0) && (puVar4 != (int *)0x0)) {
pp_Var5 = __ctype_toupper_loc();
p_Var1 = *pp_Var5;
*puVar4 = (char)p_Var1[*param_1];
if (sVar3 != 1) {
pp_Var5 = __ctype_tolower_loc();
p_Var2 = *pp_Var5;
sVar6 = 1;
do {
puVar4[sVar6] = (char)p_Var2[param_1[sVar6]];
sVar6 = sVar6 + 1;
} while (sVar6 != sVar3);
}
puVar4[sVar3 - 1] = (char)p_Var1[(char)puVar4[sVar3 - 1]];
puVar4[sVar3] = 0;
}
return puVar4;
} |
6,000 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 7, -1, 5};
int arr2[] = {1, 5, 7, -1};
int arr3[] = {1, 1, 1, 1};
assert(func0(arr1, 5, 6) == 3);
assert(func0(arr2, 4, 6) == 2);
assert(func0(arr3, 4, 2) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11dd <func0+0x74>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11d1 <func0+0x68>
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
add %edx,%eax
cmp %eax,-0x20(%rbp)
jne 11cd <func0+0x64>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1196 <func0+0x2d>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
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_20], edx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11DD
loc_118B:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11D1
loc_1196:
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]
add eax, edx
cmp [rbp+var_20], eax
jnz short loc_11CD
add [rbp+var_C], 1
loc_11CD:
add [rbp+var_4], 1
loc_11D1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1196
add [rbp+var_8], 1
loc_11DD:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_118B
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a3 == *(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4LL * j + a1) )
++v4;
}
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011dd
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011d1
LAB_00101196:
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]
ADD EAX,EDX
CMP dword ptr [RBP + -0x20],EAX
JNZ 0x001011cd
ADD dword ptr [RBP + -0xc],0x1
LAB_001011cd:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101196
ADD dword ptr [RBP + -0x8],0x1
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
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) {
if (param_3 == *(int *)(param_1 + (long)local_c * 4) + *(int *)(param_1 + (long)local_10 * 4))
{
local_14 = local_14 + 1;
}
}
}
return local_14;
} |
6,001 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 7, -1, 5};
int arr2[] = {1, 5, 7, -1};
int arr3[] = {1, 1, 1, 1};
assert(func0(arr1, 5, 6) == 3);
assert(func0(arr2, 4, 6) == 2);
assert(func0(arr3, 4, 2) == 6);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11b4 <func0+0x4b>
lea -0x1(%rsi),%r11d
add $0x1,%r11
mov $0x1,%r10d
mov $0x0,%ecx
cmp %r11,%r10
je 11b9 <func0+0x50>
mov -0x4(%rdi,%r10,4),%r9d
mov %r10,%rax
mov %r9d,%r8d
add (%rdi,%rax,4),%r8d
cmp %edx,%r8d
sete %r8b
movzbl %r8b,%r8d
add %r8d,%ecx
add $0x1,%rax
cmp %eax,%esi
jg 1191 <func0+0x28>
add $0x1,%r10
jmp 1184 <func0+0x1b>
mov $0x0,%ecx
mov %ecx,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11AF
mov r11d, esi
mov r10d, 1
mov ecx, 0
loc_117F:
cmp r10, r11
jz short loc_11B4
mov r9d, [rdi+r10*4-4]
mov rax, r10
loc_118C:
mov r8d, r9d
add r8d, [rdi+rax*4]
cmp r8d, edx
setz r8b
movzx r8d, r8b
add ecx, r8d
add rax, 1
cmp esi, eax
jg short loc_118C
add r10, 1
jmp short loc_117F
loc_11AF:
mov ecx, 0
loc_11B4:
mov eax, ecx
retn | long long func0(long long a1, int a2, int a3)
{
long long v3; // r10
unsigned int v4; // ecx
long long v5; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = 1LL;
v4 = 0;
while ( v3 != a2 )
{
v5 = v3;
do
v4 += *(_DWORD *)(a1 + 4 * v5++) + *(_DWORD *)(a1 + 4 * v3 - 4) == a3;
while ( a2 > (int)v5 );
++v3;
}
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011af
MOV R11D,ESI
MOV R10D,0x1
MOV ECX,0x0
LAB_0010117f:
CMP R10,R11
JZ 0x001011b4
MOV R9D,dword ptr [RDI + R10*0x4 + -0x4]
MOV RAX,R10
LAB_0010118c:
MOV R8D,R9D
ADD R8D,dword ptr [RDI + RAX*0x4]
CMP R8D,EDX
SETZ R8B
MOVZX R8D,R8B
ADD ECX,R8D
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118c
ADD R10,0x1
JMP 0x0010117f
LAB_001011af:
MOV ECX,0x0
LAB_001011b4:
MOV EAX,ECX
RET | int func0(long param_1,uint param_2,int param_3)
{
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)(*(int *)(param_1 + -4 + uVar3 * 4) + *(int *)(param_1 + uVar1 * 4) ==
param_3);
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
}
}
return iVar2;
} |
6,002 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 7, -1, 5};
int arr2[] = {1, 5, 7, -1};
int arr3[] = {1, 1, 1, 1};
assert(func0(arr1, 5, 6) == 3);
assert(func0(arr2, 4, 6) == 2);
assert(func0(arr3, 4, 2) == 6);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1386 <func0+0x56>
lea -0x1(%rsi),%r11d
mov $0x1,%r10d
xor %r8d,%r8d
add $0x1,%r11
cmp %r11,%r10
je 1382 <func0+0x52>
xchg %ax,%ax
mov -0x4(%rdi,%r10,4),%r9d
mov %r10,%rax
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%ecx
add %r9d,%ecx
cmp %edx,%ecx
sete %cl
add $0x1,%rax
movzbl %cl,%ecx
add %ecx,%r8d
cmp %eax,%esi
jg 1360 <func0+0x30>
add $0x1,%r10
cmp %r11,%r10
jne 1350 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_12E6
movsxd r11, esi
mov r10d, 1
xor r8d, r8d
cmp r10, r11
jz short loc_12E2
nop dword ptr [rax+00000000h]
loc_12B0:
mov r9d, [rdi+r10*4-4]
mov rax, r10
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov ecx, [rdi+rax*4]
add ecx, r9d
cmp ecx, edx
setz cl
add rax, 1
movzx ecx, cl
add r8d, ecx
cmp esi, eax
jg short loc_12C0
add r10, 1
cmp r10, r11
jnz short loc_12B0
loc_12E2:
mov eax, r8d
retn
loc_12E6:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2, int a3)
{
long long v3; // r10
unsigned int i; // r8d
long long v5; // rax
bool v6; // cl
if ( a2 <= 0 )
return 0LL;
v3 = 1LL;
for ( i = 0; v3 != a2; ++v3 )
{
v5 = v3;
do
{
v6 = *(_DWORD *)(a1 + 4 * v3 - 4) + *(_DWORD *)(a1 + 4 * v5++) == a3;
i += v6;
}
while ( a2 > (int)v5 );
}
return i;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012e6
MOVSXD R11,ESI
MOV R10D,0x1
XOR R8D,R8D
CMP R10,R11
JZ 0x001012e2
NOP dword ptr [RAX]
LAB_001012b0:
MOV R9D,dword ptr [RDI + R10*0x4 + -0x4]
MOV RAX,R10
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV ECX,dword ptr [RDI + RAX*0x4]
ADD ECX,R9D
CMP ECX,EDX
SETZ CL
ADD RAX,0x1
MOVZX ECX,CL
ADD R8D,ECX
CMP ESI,EAX
JG 0x001012c0
ADD R10,0x1
CMP R10,R11
JNZ 0x001012b0
LAB_001012e2:
MOV EAX,R8D
RET
LAB_001012e6:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2,int param_3)
{
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)(*(int *)(param_1 + lVar1) + *(int *)(param_1 + -4 + lVar4 * 4) ==
param_3);
} while ((int)lVar2 < param_2);
lVar4 = lVar4 + 1;
} while (lVar4 != param_2);
}
return iVar3;
}
return 0;
} |
6,003 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 7, -1, 5};
int arr2[] = {1, 5, 7, -1};
int arr3[] = {1, 1, 1, 1};
assert(func0(arr1, 5, 6) == 3);
assert(func0(arr2, 4, 6) == 2);
assert(func0(arr3, 4, 2) == 6);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1481 <func0+0x171>
cmp $0x1,%esi
je 1481 <func0+0x171>
push %r14
xor %r9d,%r9d
mov $0x1,%r8d
push %r12
lea -0x1(%rsi),%r12d
push %rbp
mov $0x1,%ebp
push %rbx
mov %rdi,%rbx
mov %edx,%edi
movd %edi,%xmm5
lea 0x4(%rbx),%rdx
pshufd $0x0,%xmm5,%xmm3
mov %esi,%r10d
mov %r12d,%eax
mov -0x4(%rdx),%r11d
sub %r8d,%r10d
cmp %r8d,%esi
cmovle %ebp,%r10d
sub %r8d,%eax
cmp $0x3,%eax
jbe 1479 <func0+0x169>
cmp %r8d,%esi
jle 1479 <func0+0x169>
mov %r10d,%ecx
movd %r11d,%xmm4
pxor %xmm1,%xmm1
mov %rdx,%rax
shr $0x2,%ecx
pshufd $0x0,%xmm4,%xmm2
shl $0x4,%rcx
add %rdx,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
paddd %xmm2,%xmm0
pcmpeqd %xmm3,%xmm0
psubd %xmm0,%xmm1
cmp %rax,%rcx
jne 13a0 <func0+0x90>
movdqa %xmm1,%xmm0
mov %r10d,%ecx
psrldq $0x8,%xmm0
and $0xfffffffc,%ecx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
add %eax,%r9d
lea (%rcx,%r8,1),%eax
cmp %ecx,%r10d
je 145e <func0+0x14e>
movslq %eax,%r10
mov (%rbx,%r10,4),%r14d
lea 0x0(,%r10,4),%rcx
add %r11d,%r14d
cmp %r14d,%edi
sete %r10b
movzbl %r10b,%r10d
add %r10d,%r9d
lea 0x1(%rax),%r10d
cmp %r10d,%esi
jle 145e <func0+0x14e>
mov 0x4(%rbx,%rcx,1),%r10d
add %r11d,%r10d
cmp %r10d,%edi
sete %r10b
movzbl %r10b,%r10d
add %r10d,%r9d
lea 0x2(%rax),%r10d
cmp %r10d,%esi
jle 145e <func0+0x14e>
mov 0x8(%rbx,%rcx,1),%r10d
add %r11d,%r10d
cmp %r10d,%edi
sete %r10b
add $0x3,%eax
movzbl %r10b,%r10d
add %r10d,%r9d
cmp %eax,%esi
jle 145e <func0+0x14e>
add 0xc(%rbx,%rcx,1),%r11d
xor %eax,%eax
cmp %r11d,%edi
sete %al
add %eax,%r9d
add $0x1,%r8d
add $0x4,%rdx
cmp %r8d,%esi
jne 1350 <func0+0x40>
pop %rbx
mov %r9d,%eax
pop %rbp
pop %r12
pop %r14
retq
mov %r8d,%eax
jmpq 13e9 <func0+0xd9>
xor %r9d,%r9d
mov %r9d,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle loc_1280
push r14
push r12
push rbp
push rbx
mov rbx, rdi
mov edi, esi
xor esi, esi
cmp edi, 1
jz loc_1273
movd xmm5, edx
mov r11d, edx
lea r10, [rbx+4]
xor esi, esi
mov ecx, 1
lea r12d, [rdi-1]
mov ebp, 1
pshufd xmm3, xmm5, 0
nop word ptr [rax+rax+00h]
loc_1188:
mov r8d, edi
mov eax, r12d
mov r9d, [r10-4]
sub r8d, ecx
cmp edi, ecx
cmovle r8d, ebp
sub eax, ecx
cmp eax, 2
jbe loc_127C
cmp edi, ecx
jle loc_127C
mov edx, r8d
movd xmm4, r9d
pxor xmm1, xmm1
mov rax, r10
shr edx, 2
pshufd xmm2, xmm4, 0
shl rdx, 4
add rdx, r10
nop dword ptr [rax+00h]
loc_11D0:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
pcmpeqd xmm0, xmm3
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_11D0
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add esi, eax
mov eax, r8d
and eax, 0FFFFFFFCh
add eax, ecx
and r8d, 3
jz short loc_1264
loc_1217:
movsxd rdx, eax
mov r14d, [rbx+rdx*4]
lea r8, ds:0[rdx*4]
add r14d, r9d
cmp r11d, r14d
setz dl
movzx edx, dl
add esi, edx
lea edx, [rax+1]
cmp edi, edx
jle short loc_1264
mov edx, [rbx+r8+4]
add edx, r9d
cmp r11d, edx
setz dl
add eax, 2
movzx edx, dl
add esi, edx
cmp edi, eax
jle short loc_1264
add r9d, [rbx+r8+8]
xor eax, eax
cmp r11d, r9d
setz al
add esi, eax
loc_1264:
add ecx, 1
add r10, 4
cmp edi, ecx
jnz loc_1188
loc_1273:
pop rbx
mov eax, esi
pop rbp
pop r12
pop r14
retn
loc_127C:
mov eax, ecx
jmp short loc_1217
loc_1280:
xor eax, eax
retn | long long func0(long long a1, int a2, unsigned int a3)
{
unsigned int v5; // esi
const __m128i *v6; // r10
int v7; // ecx
__m128i v8; // xmm3
unsigned int v9; // r9d
unsigned int v10; // r8d
__m128i v11; // xmm1
const __m128i *v12; // rax
__m128i v13; // xmm2
__m128i v14; // xmm0
__m128i v15; // xmm1
int v16; // eax
long long v17; // r8
if ( a2 <= 0 )
return 0LL;
v5 = 0;
if ( a2 != 1 )
{
v6 = (const __m128i *)(a1 + 4);
v5 = 0;
v7 = 1;
v8 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a3), 0);
while ( 1 )
{
v9 = v6[-1].m128i_u32[3];
v10 = a2 - v7;
if ( a2 <= v7 )
v10 = 1;
if ( (unsigned int)(a2 - 1 - v7) <= 2 || a2 <= v7 )
break;
v11 = 0LL;
v12 = v6;
v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v9), 0);
do
{
v14 = _mm_loadu_si128(v12++);
v11 = _mm_sub_epi32(v11, _mm_cmpeq_epi32(_mm_add_epi32(v14, v13), v8));
}
while ( v12 != &v6[v10 >> 2] );
v15 = _mm_add_epi32(v11, _mm_srli_si128(v11, 8));
v5 += _mm_cvtsi128_si32(_mm_add_epi32(v15, _mm_srli_si128(v15, 4)));
v16 = v7 + (v10 & 0xFFFFFFFC);
if ( (v10 & 3) != 0 )
goto LABEL_11;
LABEL_14:
++v7;
v6 = (const __m128i *)((char *)v6 + 4);
if ( a2 == v7 )
return v5;
}
v16 = v7;
LABEL_11:
v17 = 4LL * v16;
v5 += a3 == v9 + *(_DWORD *)(a1 + v17);
if ( a2 > v16 + 1 )
{
v5 += a3 == v9 + *(_DWORD *)(a1 + v17 + 4);
if ( a2 > v16 + 2 )
v5 += a3 == *(_DWORD *)(a1 + v17 + 8) + v9;
}
goto LABEL_14;
}
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101280
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV EDI,ESI
XOR ESI,ESI
CMP EDI,0x1
JZ 0x00101273
MOVD XMM5,EDX
MOV R11D,EDX
LEA R10,[RBX + 0x4]
XOR ESI,ESI
MOV ECX,0x1
LEA R12D,[RDI + -0x1]
MOV EBP,0x1
PSHUFD XMM3,XMM5,0x0
NOP word ptr [RAX + RAX*0x1]
LAB_00101188:
MOV R8D,EDI
MOV EAX,R12D
MOV R9D,dword ptr [R10 + -0x4]
SUB R8D,ECX
CMP EDI,ECX
CMOVLE R8D,EBP
SUB EAX,ECX
CMP EAX,0x2
JBE 0x0010127c
CMP EDI,ECX
JLE 0x0010127c
MOV EDX,R8D
MOVD XMM4,R9D
PXOR XMM1,XMM1
MOV RAX,R10
SHR EDX,0x2
PSHUFD XMM2,XMM4,0x0
SHL RDX,0x4
ADD RDX,R10
NOP dword ptr [RAX]
LAB_001011d0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
PCMPEQD XMM0,XMM3
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x001011d0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD ESI,EAX
MOV EAX,R8D
AND EAX,0xfffffffc
ADD EAX,ECX
AND R8D,0x3
JZ 0x00101264
LAB_00101217:
MOVSXD RDX,EAX
MOV R14D,dword ptr [RBX + RDX*0x4]
LEA R8,[RDX*0x4]
ADD R14D,R9D
CMP R11D,R14D
SETZ DL
MOVZX EDX,DL
ADD ESI,EDX
LEA EDX,[RAX + 0x1]
CMP EDI,EDX
JLE 0x00101264
MOV EDX,dword ptr [RBX + R8*0x1 + 0x4]
ADD EDX,R9D
CMP R11D,EDX
SETZ DL
ADD EAX,0x2
MOVZX EDX,DL
ADD ESI,EDX
CMP EDI,EAX
JLE 0x00101264
ADD R9D,dword ptr [RBX + R8*0x1 + 0x8]
XOR EAX,EAX
CMP R11D,R9D
SETZ AL
ADD ESI,EAX
LAB_00101264:
ADD ECX,0x1
ADD R10,0x4
CMP EDI,ECX
JNZ 0x00101188
LAB_00101273:
POP RBX
MOV EAX,ESI
POP RBP
POP R12
POP R14
RET
LAB_0010127c:
MOV EAX,ECX
JMP 0x00101217
LAB_00101280:
XOR EAX,EAX
RET | int func0(long param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
uint uVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int iVar10;
int *piVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if (param_2 < 1) {
return 0;
}
iVar10 = 0;
if (param_2 != 1) {
piVar11 = (int *)(param_1 + 4);
iVar10 = 0;
iVar9 = 1;
do {
iVar2 = piVar11[-1];
uVar3 = param_2 - iVar9;
if (param_2 <= iVar9) {
uVar3 = 1;
}
iVar12 = iVar9;
if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) {
LAB_00101217:
lVar1 = (long)iVar12 * 4;
iVar10 = iVar10 + (uint)(param_3 == *(int *)(param_1 + (long)iVar12 * 4) + iVar2);
if ((iVar12 + 1 < param_2) &&
(iVar10 = iVar10 + (uint)(param_3 == *(int *)(param_1 + 4 + lVar1) + iVar2),
iVar12 + 2 < param_2)) {
iVar10 = iVar10 + (uint)(param_3 == iVar2 + *(int *)(param_1 + 8 + lVar1));
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
piVar8 = piVar11;
do {
iVar4 = *piVar8;
piVar5 = piVar8 + 1;
piVar6 = piVar8 + 2;
piVar7 = piVar8 + 3;
piVar8 = piVar8 + 4;
iVar12 = iVar12 + (uint)(iVar4 + iVar2 == param_3);
iVar13 = iVar13 + (uint)(*piVar5 + iVar2 == param_3);
iVar14 = iVar14 + (uint)(*piVar6 + iVar2 == param_3);
iVar15 = iVar15 + (uint)(*piVar7 + iVar2 == param_3);
} while (piVar8 != piVar11 + (ulong)(uVar3 >> 2) * 4);
iVar10 = iVar10 + iVar12 + iVar14 + iVar13 + iVar15;
iVar12 = (uVar3 & 0xfffffffc) + iVar9;
if ((uVar3 & 3) != 0) goto LAB_00101217;
}
iVar9 = iVar9 + 1;
piVar11 = piVar11 + 1;
} while (param_2 != iVar9);
}
return iVar10;
} |
6,004 | func0 | #include <assert.h>
#include <string.h>
typedef struct {
int length;
int *list;
} MinResult;
| MinResult func0(int **list1, int size) {
int min_length = 1000000; // large initial value
int *min_list = NULL;
for (int i = 0; i < size; i++) {
int list_length = 0;
while(list1[i][list_length] != -1) { // using -1 as termination signal for each sublist
list_length++;
}
if (list_length < min_length) {
min_length = list_length;
min_list = list1[i];
}
}
MinResult result;
result.length = min_length;
result.list = min_list;
return result;
}
| int main() {
int list1[5][4] = {{0, -1}, {1, 3, -1}, {5, 7, -1}, {9, 11, -1}, {13, 15, 17, -1}};
int *plist1[5] = {list1[0], list1[1], list1[2], list1[3], list1[4]};
MinResult res1 = func0(plist1, 5);
assert(res1.length == 1 && res1.list[0] == 0);
int list2[3][5] = {{1, -1}, {5, 7, -1}, {10, 12, 14, 15, -1}};
int *plist2[3] = {list2[0], list2[1], list2[2]};
MinResult res2 = func0(plist2, 3);
assert(res2.length == 1 && res2.list[0] == 1);
int list3[2][4] = {{5, -1}, {15, 20, 25, -1}};
int *plist3[2] = {list3[0], list3[1]};
MinResult res3 = func0(plist3, 2);
assert(res3.length == 1 && res3.list[0] == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
mov %rdi,-0x40(%rbp)
mov %esi,-0x44(%rbp)
movl $0xf4240,-0x2c(%rbp)
movq $0x0,-0x20(%rbp)
movl $0x0,-0x28(%rbp)
jmp 11f6 <func0+0x8d>
movl $0x0,-0x24(%rbp)
jmp 119e <func0+0x35>
addl $0x1,-0x24(%rbp)
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp $0xffffffff,%eax
jne 119a <func0+0x31>
mov -0x24(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 11f2 <func0+0x89>
mov -0x24(%rbp),%eax
mov %eax,-0x2c(%rbp)
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x20(%rbp)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1191 <func0+0x28>
mov -0x2c(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x20(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov -0x10(%rbp),%rdx
mov %rax,%rcx
mov %rdx,%rbx
mov %ecx,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_34], 0F4240h
mov [rbp+var_28], 0
mov [rbp+var_30], 0
jmp short loc_11F6
loc_1191:
mov [rbp+var_2C], 0
jmp short loc_119E
loc_119A:
add [rbp+var_2C], 1
loc_119E:
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_2C]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp eax, 0FFFFFFFFh
jnz short loc_119A
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_34]
jge short loc_11F2
mov eax, [rbp+var_2C]
mov [rbp+var_34], eax
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov rax, [rax]
mov [rbp+var_28], rax
loc_11F2:
add [rbp+var_30], 1
loc_11F6:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_4C]
jl short loc_1191
mov eax, [rbp+var_34]
mov dword ptr [rbp+var_20], eax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
mov rsi, rax
mov rdi, rdx
mov rcx, rax
mov rbx, rdx
mov eax, esi
mov rdx, rbx
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+18h] [rbp-34h]
int i; // [rsp+1Ch] [rbp-30h]
int j; // [rsp+20h] [rbp-2Ch]
v3 = 1000000;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; *(_DWORD *)(4LL * j + *(_QWORD *)(8LL * i + a1)) != -1; ++j )
;
if ( j < v3 )
v3 = j;
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV dword ptr [RBP + -0x34],0xf4240
MOV qword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001011f6
LAB_00101191:
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0010119e
LAB_0010119a:
ADD dword ptr [RBP + -0x2c],0x1
LAB_0010119e:
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,-0x1
JNZ 0x0010119a
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x34]
JGE 0x001011f2
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
LAB_001011f2:
ADD dword ptr [RBP + -0x30],0x1
LAB_001011f6:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101191
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,RAX
MOV RDI,RDX
MOV RCX,RAX
MOV RBX,RDX
MOV EAX,ESI
MOV RDX,RBX
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(long param_1,int param_2)
{
int auVar1 [16];
int4 local_3c;
int4 local_38;
int4 local_34;
int8 local_30;
local_3c = 1000000;
local_30 = 0;
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
local_34 = 0;
while (*(int *)(*(long *)(param_1 + (long)local_38 * 8) + (long)(int)local_34 * 4) != -1) {
local_34 = local_34 + 1;
}
if ((int)local_34 < (int)local_3c) {
local_3c = local_34;
local_30 = *(int8 *)(param_1 + (long)local_38 * 8);
}
}
auVar1._4_4_ = 0;
auVar1._0_4_ = local_3c;
auVar1._8_8_ = local_30;
return auVar1;
} |
6,005 | func0 | #include <assert.h>
#include <string.h>
typedef struct {
int length;
int *list;
} MinResult;
| MinResult func0(int **list1, int size) {
int min_length = 1000000; // large initial value
int *min_list = NULL;
for (int i = 0; i < size; i++) {
int list_length = 0;
while(list1[i][list_length] != -1) { // using -1 as termination signal for each sublist
list_length++;
}
if (list_length < min_length) {
min_length = list_length;
min_list = list1[i];
}
}
MinResult result;
result.length = min_length;
result.list = min_list;
return result;
}
| int main() {
int list1[5][4] = {{0, -1}, {1, 3, -1}, {5, 7, -1}, {9, 11, -1}, {13, 15, 17, -1}};
int *plist1[5] = {list1[0], list1[1], list1[2], list1[3], list1[4]};
MinResult res1 = func0(plist1, 5);
assert(res1.length == 1 && res1.list[0] == 0);
int list2[3][5] = {{1, -1}, {5, 7, -1}, {10, 12, 14, 15, -1}};
int *plist2[3] = {list2[0], list2[1], list2[2]};
MinResult res2 = func0(plist2, 3);
assert(res2.length == 1 && res2.list[0] == 1);
int list3[2][4] = {{5, -1}, {15, 20, 25, -1}};
int *plist3[2] = {list3[0], list3[1]};
MinResult res3 = func0(plist3, 2);
assert(res3.length == 1 && res3.list[0] == 5);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c0 <func0+0x57>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdi
mov $0x0,%r9d
mov $0xf4240,%esi
mov $0x0,%r10d
jmp 1198 <func0+0x2f>
add $0x8,%r8
cmp %rdi,%r8
je 11cb <func0+0x62>
mov (%r8),%rdx
mov $0x1,%eax
mov %r10d,%ecx
cmpl $0xffffffff,(%rdx)
je 11b5 <func0+0x4c>
mov %eax,%ecx
add $0x1,%rax
cmpl $0xffffffff,-0x4(%rdx,%rax,4)
jne 11a8 <func0+0x3f>
cmp %ecx,%esi
jle 118f <func0+0x26>
mov %rdx,%r9
mov %ecx,%esi
jmp 118f <func0+0x26>
mov $0x0,%r9d
mov $0xf4240,%esi
mov %esi,%eax
mov %r9,%rdx
retq
| func0:
endbr64
test esi, esi
jle short loc_11C0
mov r8, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*8+8]
mov r9d, 0
mov eax, 0F4240h
mov r10d, 0
jmp short loc_1198
loc_118F:
add r8, 8
cmp r8, rdi
jz short loc_11CB
loc_1198:
mov rcx, [r8]
mov edx, 1
mov esi, r10d
cmp dword ptr [rcx], 0FFFFFFFFh
jz short loc_11B5
loc_11A8:
mov esi, edx
add rdx, 1
cmp dword ptr [rcx+rdx*4-4], 0FFFFFFFFh
jnz short loc_11A8
loc_11B5:
cmp eax, esi
jle short loc_118F
mov r9, rcx
mov eax, esi
jmp short loc_118F
loc_11C0:
mov r9d, 0
mov eax, 0F4240h
loc_11CB:
mov rdx, r9
retn | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // r8
long long v3; // rdi
long long result; // rax
long long v5; // rdx
int v6; // esi
if ( a2 <= 0 )
return 1000000LL;
v2 = a1;
v3 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
result = 1000000LL;
do
{
v5 = 1LL;
v6 = 0;
if ( *(_DWORD *)*v2 != -1 )
{
do
v6 = v5++;
while ( *(_DWORD *)(*v2 + 4 * v5 - 4) != -1 );
}
if ( (int)result > v6 )
result = (unsigned int)v6;
++v2;
}
while ( v2 != (_QWORD *)v3 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c0
MOV R8,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x8 + 0x8]
MOV R9D,0x0
MOV EAX,0xf4240
MOV R10D,0x0
JMP 0x00101198
LAB_0010118f:
ADD R8,0x8
CMP R8,RDI
JZ 0x001011cb
LAB_00101198:
MOV RCX,qword ptr [R8]
MOV EDX,0x1
MOV ESI,R10D
CMP dword ptr [RCX],-0x1
JZ 0x001011b5
LAB_001011a8:
MOV ESI,EDX
ADD RDX,0x1
CMP dword ptr [RCX + RDX*0x4 + -0x4],-0x1
JNZ 0x001011a8
LAB_001011b5:
CMP EAX,ESI
JLE 0x0010118f
MOV R9,RCX
MOV EAX,ESI
JMP 0x0010118f
LAB_001011c0:
MOV R9D,0x0
MOV EAX,0xf4240
LAB_001011cb:
MOV RDX,R9
RET | int1 [16] func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int *piVar3;
long lVar4;
ulong uVar5;
uint uVar6;
int *piVar7;
int1 auVar8 [16];
if (param_2 < 1) {
piVar7 = (int *)0x0;
uVar5 = 1000000;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
piVar7 = (int *)0x0;
uVar5 = 1000000;
do {
piVar3 = (int *)*param_1;
uVar6 = 0;
iVar2 = *piVar3;
lVar4 = 1;
while (iVar2 != -1) {
uVar6 = (uint)lVar4;
iVar2 = piVar3[lVar4];
lVar4 = lVar4 + 1;
}
if ((int)uVar6 < (int)uVar5) {
uVar5 = (ulong)uVar6;
piVar7 = piVar3;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
auVar8._8_8_ = piVar7;
auVar8._0_8_ = uVar5;
return auVar8;
} |
6,006 | func0 | #include <assert.h>
#include <string.h>
typedef struct {
int length;
int *list;
} MinResult;
| MinResult func0(int **list1, int size) {
int min_length = 1000000; // large initial value
int *min_list = NULL;
for (int i = 0; i < size; i++) {
int list_length = 0;
while(list1[i][list_length] != -1) { // using -1 as termination signal for each sublist
list_length++;
}
if (list_length < min_length) {
min_length = list_length;
min_list = list1[i];
}
}
MinResult result;
result.length = min_length;
result.list = min_list;
return result;
}
| int main() {
int list1[5][4] = {{0, -1}, {1, 3, -1}, {5, 7, -1}, {9, 11, -1}, {13, 15, 17, -1}};
int *plist1[5] = {list1[0], list1[1], list1[2], list1[3], list1[4]};
MinResult res1 = func0(plist1, 5);
assert(res1.length == 1 && res1.list[0] == 0);
int list2[3][5] = {{1, -1}, {5, 7, -1}, {10, 12, 14, 15, -1}};
int *plist2[3] = {list2[0], list2[1], list2[2]};
MinResult res2 = func0(plist2, 3);
assert(res2.length == 1 && res2.list[0] == 1);
int list3[2][4] = {{5, -1}, {15, 20, 25, -1}};
int *plist3[2] = {list3[0], list3[1]};
MinResult res3 = func0(plist3, 2);
assert(res3.length == 1 && res3.list[0] == 5);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1475 <func0+0x55>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
mov $0xf4240,%esi
lea 0x8(%rdi,%rax,8),%r8
nopl 0x0(%rax,%rax,1)
mov (%rdi),%rdx
xor %ecx,%ecx
mov $0x1,%eax
cmpl $0xffffffff,(%rdx)
je 145d <func0+0x3d>
mov %eax,%ecx
add $0x1,%rax
cmpl $0xffffffff,-0x4(%rdx,%rax,4)
jne 1450 <func0+0x30>
cmp %ecx,%esi
jle 1466 <func0+0x46>
mov %rdx,%r9
mov %ecx,%esi
add $0x8,%rdi
cmp %r8,%rdi
jne 1440 <func0+0x20>
mov %r9,%rdx
mov %esi,%eax
retq
xor %r9d,%r9d
mov $0xf4240,%esi
mov %r9,%rdx
mov %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1483
lea eax, [rsi-1]
xor r9d, r9d
lea r8, [rdi+rax*8+8]
mov eax, 0F4240h
nop dword ptr [rax+rax+00000000h]
loc_1450:
mov rcx, [rdi]
xor esi, esi
mov edx, 1
cmp dword ptr [rcx], 0FFFFFFFFh
jz short loc_146D
nop
loc_1460:
mov esi, edx
add rdx, 1
cmp dword ptr [rcx+rdx*4-4], 0FFFFFFFFh
jnz short loc_1460
loc_146D:
cmp eax, esi
jle short loc_1476
mov r9, rcx
mov eax, esi
loc_1476:
add rdi, 8
cmp rdi, r8
jnz short loc_1450
mov rdx, r9
retn
loc_1483:
xor r9d, r9d
mov eax, 0F4240h
mov rdx, r9
retn | long long func0(_QWORD *a1, int a2)
{
long long v2; // r8
long long result; // rax
int v4; // esi
long long v5; // rdx
if ( a2 <= 0 )
return 1000000LL;
v2 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
result = 1000000LL;
do
{
v4 = 0;
v5 = 1LL;
if ( *(_DWORD *)*a1 != -1 )
{
do
v4 = v5++;
while ( *(_DWORD *)(*a1 + 4 * v5 - 4) != -1 );
}
if ( (int)result > v4 )
result = (unsigned int)v4;
++a1;
}
while ( a1 != (_QWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101483
LEA EAX,[RSI + -0x1]
XOR R9D,R9D
LEA R8,[RDI + RAX*0x8 + 0x8]
MOV EAX,0xf4240
NOP dword ptr [RAX + RAX*0x1]
LAB_00101450:
MOV RCX,qword ptr [RDI]
XOR ESI,ESI
MOV EDX,0x1
CMP dword ptr [RCX],-0x1
JZ 0x0010146d
NOP
LAB_00101460:
MOV ESI,EDX
ADD RDX,0x1
CMP dword ptr [RCX + RDX*0x4 + -0x4],-0x1
JNZ 0x00101460
LAB_0010146d:
CMP EAX,ESI
JLE 0x00101476
MOV R9,RCX
MOV EAX,ESI
LAB_00101476:
ADD RDI,0x8
CMP RDI,R8
JNZ 0x00101450
MOV RDX,R9
RET
LAB_00101483:
XOR R9D,R9D
MOV EAX,0xf4240
MOV RDX,R9
RET | int1 [16] func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int *piVar3;
long lVar4;
ulong uVar5;
uint uVar6;
int *piVar7;
int1 auVar8 [16];
if (param_2 < 1) {
return ZEXT816(1000000);
}
piVar7 = (int *)0x0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar5 = 1000000;
do {
piVar3 = (int *)*param_1;
uVar6 = 0;
iVar2 = *piVar3;
lVar4 = 1;
while (iVar2 != -1) {
uVar6 = (uint)lVar4;
iVar2 = piVar3[lVar4];
lVar4 = lVar4 + 1;
}
if ((int)uVar6 < (int)uVar5) {
uVar5 = (ulong)uVar6;
piVar7 = piVar3;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
auVar8._8_8_ = piVar7;
auVar8._0_8_ = uVar5;
return auVar8;
} |
6,007 | func0 | #include <assert.h>
#include <string.h>
typedef struct {
int length;
int *list;
} MinResult;
| MinResult func0(int **list1, int size) {
int min_length = 1000000; // large initial value
int *min_list = NULL;
for (int i = 0; i < size; i++) {
int list_length = 0;
while(list1[i][list_length] != -1) { // using -1 as termination signal for each sublist
list_length++;
}
if (list_length < min_length) {
min_length = list_length;
min_list = list1[i];
}
}
MinResult result;
result.length = min_length;
result.list = min_list;
return result;
}
| int main() {
int list1[5][4] = {{0, -1}, {1, 3, -1}, {5, 7, -1}, {9, 11, -1}, {13, 15, 17, -1}};
int *plist1[5] = {list1[0], list1[1], list1[2], list1[3], list1[4]};
MinResult res1 = func0(plist1, 5);
assert(res1.length == 1 && res1.list[0] == 0);
int list2[3][5] = {{1, -1}, {5, 7, -1}, {10, 12, 14, 15, -1}};
int *plist2[3] = {list2[0], list2[1], list2[2]};
MinResult res2 = func0(plist2, 3);
assert(res2.length == 1 && res2.list[0] == 1);
int list3[2][4] = {{5, -1}, {15, 20, 25, -1}};
int *plist3[2] = {list3[0], list3[1]};
MinResult res3 = func0(plist3, 2);
assert(res3.length == 1 && res3.list[0] == 5);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1475 <func0+0x55>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
mov $0xf4240,%esi
lea 0x8(%rdi,%rax,8),%r8
nopl 0x0(%rax,%rax,1)
mov (%rdi),%rdx
xor %ecx,%ecx
mov $0x1,%eax
cmpl $0xffffffff,(%rdx)
je 145d <func0+0x3d>
mov %eax,%ecx
add $0x1,%rax
cmpl $0xffffffff,-0x4(%rdx,%rax,4)
jne 1450 <func0+0x30>
cmp %ecx,%esi
jle 1466 <func0+0x46>
mov %rdx,%r9
mov %ecx,%esi
add $0x8,%rdi
cmp %r8,%rdi
jne 1440 <func0+0x20>
mov %r9,%rdx
mov %esi,%eax
retq
xor %r9d,%r9d
mov $0xf4240,%esi
mov %r9,%rdx
mov %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1474
movsxd rsi, esi
xor r9d, r9d
mov eax, 0F4240h
lea r8, [rdi+rsi*8]
nop word ptr [rax+rax+00000000h]
loc_1440:
mov rsi, [rdi]
xor ecx, ecx
mov edx, 1
cmp dword ptr [rsi], 0FFFFFFFFh
jz short loc_145E
nop
loc_1450:
mov rcx, rdx
add rdx, 1
cmp dword ptr [rsi+rdx*4-4], 0FFFFFFFFh
jnz short loc_1450
loc_145E:
cmp eax, ecx
jle short loc_1467
mov r9, rsi
mov eax, ecx
loc_1467:
add rdi, 8
cmp r8, rdi
jnz short loc_1440
mov rdx, r9
retn
loc_1474:
xor r9d, r9d
mov eax, 0F4240h
mov rdx, r9
retn | long long func0(_QWORD *a1, int a2)
{
long long result; // rax
_QWORD *v3; // r8
int v4; // ecx
long long v5; // rdx
if ( a2 <= 0 )
return 1000000LL;
result = 1000000LL;
v3 = &a1[a2];
do
{
v4 = 0;
v5 = 1LL;
if ( *(_DWORD *)*a1 != -1 )
{
do
v4 = v5++;
while ( *(_DWORD *)(*a1 + 4 * v5 - 4) != -1 );
}
if ( (int)result > v4 )
result = (unsigned int)v4;
++a1;
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101474
MOVSXD RSI,ESI
XOR R9D,R9D
MOV EAX,0xf4240
LEA R8,[RDI + RSI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101440:
MOV RSI,qword ptr [RDI]
XOR ECX,ECX
MOV EDX,0x1
CMP dword ptr [RSI],-0x1
JZ 0x0010145e
NOP
LAB_00101450:
MOV RCX,RDX
ADD RDX,0x1
CMP dword ptr [RSI + RDX*0x4 + -0x4],-0x1
JNZ 0x00101450
LAB_0010145e:
CMP EAX,ECX
JLE 0x00101467
MOV R9,RSI
MOV EAX,ECX
LAB_00101467:
ADD RDI,0x8
CMP R8,RDI
JNZ 0x00101440
MOV RDX,R9
RET
LAB_00101474:
XOR R9D,R9D
MOV EAX,0xf4240
MOV RDX,R9
RET | int [16] func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int *piVar8;
int auVar9 [16];
if (param_2 < 1) {
return ZEXT816(1000000);
}
piVar8 = (int *)0x0;
uVar7 = 1000000;
puVar1 = param_1 + param_2;
do {
piVar3 = (int *)*param_1;
iVar2 = *piVar3;
uVar6 = 1;
uVar5 = 0;
while (uVar4 = uVar6, iVar2 != -1) {
uVar6 = uVar4 + 1;
uVar5 = uVar4;
iVar2 = piVar3[uVar4];
}
if ((int)uVar5 < (int)uVar7) {
uVar7 = uVar5 & 0xffffffff;
piVar8 = piVar3;
}
param_1 = param_1 + 1;
} while (puVar1 != param_1);
auVar9._8_8_ = piVar8;
auVar9._0_8_ = uVar7;
return auVar9;
} |
6,008 | func0 |
#include <assert.h>
| int func0(int n) {
int dp[n + 1];
dp[0] = 2;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 31);
assert(func0(2) == 5);
assert(func0(4) == 17);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x34(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1207 <func0+0x9e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f0 <func0+0x87>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1231 <func0+0xc8>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
movl $0x2,(%rax)
mov -0x20(%rbp),%rax
movl $0x1,0x4(%rax)
movl $0x2,-0x2c(%rbp)
jmp 1297 <func0+0x12e>
mov -0x2c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x2c(%rbp),%eax
lea -0x2(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %eax,%eax
add %eax,%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 -0x34(%rbp),%eax
jle 1262 <func0+0xf9>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 12c3 <func0+0x15a>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_24]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D5:
cmp rsp, rdx
jz short loc_11EC
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11D5
loc_11EC:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1216
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1216:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov dword ptr [rax], 2
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1
mov [rbp+var_1C], 2
jmp short loc_127C
loc_1247:
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_1C]
lea edx, [rax-2]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, eax
add ecx, eax
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
add [rbp+var_1C], 1
loc_127C:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jle short loc_1247
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12A8
call ___stack_chk_fail
locret_12A8:
leave
retn | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
_DWORD v4[3]; // [rsp+8h] [rbp-30h] BYREF
int v5; // [rsp+14h] [rbp-24h]
int i; // [rsp+1Ch] [rbp-1Ch]
long long v7; // [rsp+20h] [rbp-18h]
_DWORD *v8; // [rsp+28h] [rbp-10h]
unsigned long long v9; // [rsp+30h] [rbp-8h]
v5 = a1;
v9 = __readfsqword(0x28u);
v7 = a1 + 1 - 1LL;
v1 = 16 * ((4LL * (a1 + 1) + 15) / 0x10uLL);
while ( v4 != (_DWORD *)((char *)v4 - (v1 & 0xFFFFFFFFFFFFF000LL)) )
;
v2 = alloca(v1 & 0xFFF);
if ( (v1 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v4[-2] + (v1 & 0xFFF)) = *(_QWORD *)((char *)&v4[-2] + (v1 & 0xFFF));
v8 = v4;
v4[0] = 2;
v4[1] = 1;
for ( i = 2; i <= v5; ++i )
v8[i] = 2 * v8[i - 2] + v8[i - 1];
return (unsigned int)v8[v5];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d5:
CMP RSP,RDX
JZ 0x001011ec
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d5
LAB_001011ec:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101216
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101216:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1
MOV dword ptr [RBP + -0x1c],0x2
JMP 0x0010127c
LAB_00101247:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x2]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,EAX
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010127c:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x00101247
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012a8
CALL 0x00101060
LAB_001012a8:
LEAVE
RET | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_38 [12];
int local_2c;
int local_24;
long local_20;
int *local_18;
long local_10;
local_2c = param_1;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_1 + 1) + -1;
uVar2 = (((long)(param_1 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_38; puVar3 != auStack_38 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
*(int4 *)(puVar3 + lVar1) = 2;
*(int4 *)(puVar3 + lVar1 + 4) = 1;
for (local_24 = 2; local_24 <= local_2c; local_24 = local_24 + 1) {
*(int *)(puVar3 + (long)local_24 * 4 + lVar1) =
*(int *)(puVar3 + (long)(local_24 + -1) * 4 + lVar1) +
*(int *)(puVar3 + (long)(local_24 + -2) * 4 + lVar1) * 2;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar3 + (long)local_2c * 4 + lVar1);
} |
6,009 | func0 |
#include <assert.h>
| int func0(int n) {
int dp[n + 1];
dp[0] = 2;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 31);
assert(func0(2) == 5);
assert(func0(4) == 17);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 11be <func0+0x55>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a7 <func0+0x3e>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d4 <func0+0x6b>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r8
mov %r8,%rax
shr $0x2,%rax
and $0xfffffffffffffffc,%r8
movl $0x2,0x0(,%rax,4)
movl $0x1,0x4(,%rax,4)
cmp $0x1,%edi
jle 121e <func0+0xb5>
mov %r8,%rax
lea -0x2(%rdi),%edx
lea 0x4(%r8,%rdx,4),%rsi
mov (%rax),%ecx
mov 0x4(%rax),%edx
lea (%rdx,%rcx,2),%edx
mov %edx,0x8(%rax)
add $0x4,%rax
cmp %rsi,%rax
jne 120a <func0+0xa1>
movslq %edi,%rdi
mov (%r8,%rdi,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 1236 <func0+0xcd>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A4:
cmp rsp, rdx
jz short loc_11BB
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11A4
loc_11BB:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D1
or [rsp+rax+10h+var_18], 0
loc_11D1:
lea r8, [rsp+10h+var_D]
mov rax, r8
shr rax, 2
and r8, 0FFFFFFFFFFFFFFFCh
mov ds:dword_0[rax*4], 2
mov dword ptr ds:byte_4[rax*4], 1
cmp edi, 1
jle short loc_121A
mov rax, r8
lea edx, [rdi-1]
lea rsi, [r8+rdx*4]
loc_1206:
mov ecx, [rax]
mov edx, [rax+4]
lea edx, [rdx+rcx*2]
mov [rax+8], edx
add rax, 4
cmp rax, rsi
jnz short loc_1206
loc_121A:
movsxd rdi, edi
mov eax, [r8+rdi*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1232
leave
retn
loc_1232:
call ___stack_chk_fail | long long func0(int a1)
{
signed long long v1; // rax
void *v2; // rsp
unsigned long long v3; // rax
_BYTE *v4; // rax
_BYTE v7[3]; // [rsp+8h] [rbp-10h] BYREF
char v8; // [rsp+Bh] [rbp-Dh] BYREF
unsigned long long v9; // [rsp+10h] [rbp-8h]
v9 = __readfsqword(0x28u);
while ( v7 != &v7[-((4LL * (a1 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)] )
;
v1 = (4 * ((_WORD)a1 + 1) + 15) & 0xFF0;
v2 = alloca(v1);
if ( ((4 * ((_WORD)a1 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)&v7[v1 - 8] = *(_QWORD *)&v7[v1 - 8];
v3 = (unsigned long long)&v8 >> 2;
*(_DWORD *)(4 * v3) = 2;
*(_DWORD *)&byte_4[4 * v3] = 1;
if ( a1 > 1 )
{
v4 = v7;
do
{
*((_DWORD *)v4 + 2) = *((_DWORD *)v4 + 1) + 2 * *(_DWORD *)v4;
v4 += 4;
}
while ( v4 != &v7[4 * (a1 - 1)] );
}
return *(unsigned int *)&v7[4 * a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a4:
CMP RSP,RDX
JZ 0x001011bb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011a4
LAB_001011bb:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d1
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d1:
LEA R8,[RSP + 0x3]
MOV RAX,R8
SHR RAX,0x2
AND R8,-0x4
MOV dword ptr [RAX*0x4],0x2
MOV dword ptr [0x4 + RAX*0x4],0x1
CMP EDI,0x1
JLE 0x0010121a
MOV RAX,R8
LEA EDX,[RDI + -0x1]
LEA RSI,[R8 + RDX*0x4]
LAB_00101206:
MOV ECX,dword ptr [RAX]
MOV EDX,dword ptr [RAX + 0x4]
LEA EDX,[RDX + RCX*0x2]
MOV dword ptr [RAX + 0x8],EDX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101206
LAB_0010121a:
MOVSXD RDI,EDI
MOV EAX,dword ptr [R8 + RDI*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101232
LEAVE
RET
LAB_00101232:
CALL 0x00101060 | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *piVar3;
int1 *puVar4;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = (long)(param_1 + 1) * 4 + 0xf;
for (puVar4 = auStack_18; puVar4 != auStack_18 + -(uVar2 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
uVar2 = (ulong)((uint)uVar2 & 0xff0);
lVar1 = -uVar2;
piVar3 = (int *)(puVar4 + lVar1);
if (uVar2 != 0) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
*(int4 *)(((ulong)(puVar4 + lVar1 + 3) >> 2) * 4) = 2;
*(int4 *)(((ulong)(puVar4 + lVar1 + 3) >> 2) * 4 + 4) = 1;
if (1 < param_1) {
do {
piVar3[2] = piVar3[1] + *piVar3 * 2;
piVar3 = piVar3 + 1;
} while (piVar3 != (int *)(puVar4 + (ulong)(param_1 - 1) * 4 + lVar1));
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar4 + (long)param_1 * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar4 + lVar1 + -8) = main;
__stack_chk_fail();
} |
6,010 | func0 |
#include <assert.h>
| int func0(int n) {
int dp[n + 1];
dp[0] = 2;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 31);
assert(func0(2) == 5);
assert(func0(4) == 17);
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
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 1268 <func0+0x58>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1253 <func0+0x43>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 12e8 <func0+0xd8>
movabs $0x100000002,%rsi
lea 0x3(%rsp),%r8
mov %r8,%rax
and $0xfffffffffffffffc,%r8
shr $0x2,%rax
mov %rsi,0x0(,%rax,4)
cmp $0x1,%edi
jle 12c9 <func0+0xb9>
lea -0x2(%rdi),%edx
lea 0x8(%r8),%rax
mov $0x2,%ecx
lea 0x8(%r8,%rdx,4),%rsi
mov $0x1,%edx
jmp 12bf <func0+0xaf>
nopl (%rax)
mov -0x4(%rax),%ecx
add $0x4,%rax
lea (%rdx,%rcx,2),%edx
mov %edx,(%rax)
cmp %rsi,%rax
jne 12b8 <func0+0xa8>
movslq %edi,%rdi
mov (%r8,%rdi,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 12f0 <func0+0xe0>
leaveq
retq
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rdx,1)
jmp 1276 <func0+0x66>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1265
loc_1250:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1250
loc_1265:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz short loc_12E8
loc_1273:
mov rsi, 100000002h
lea r8, [rsp+1010h+var_100D]
mov rax, r8
and r8, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov qword ptr ds:dword_0[rax*4], rsi
cmp edi, 1
jle short loc_12C9
lea edx, [rdi-2]
lea rax, [r8+8]
mov ecx, 2
lea rsi, [r8+rdx*4+8]
mov edx, 1
jmp short loc_12BF
loc_12B8:
mov ecx, [rax-4]
add rax, 4
loc_12BF:
lea edx, [rdx+rcx*2]
mov [rax], edx
cmp rax, rsi
jnz short loc_12B8
loc_12C9:
movsxd rdi, edi
mov eax, [r8+rdi*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_12F0
leave
retn
loc_12E8:
or [rsp+rdx+1010h+var_1018], 0
jmp short loc_1273
loc_12F0:
call ___stack_chk_fail | long long func0(int a1)
{
long long v1; // rdx
long long *v2; // rcx
__int16 v3; // dx
signed long long v4; // rdx
void *v5; // rsp
long long *v6; // rax
int v7; // ecx
int v8; // edx
long long v10; // [rsp+0h] [rbp-1018h]
long long v11; // [rsp+8h] [rbp-1010h] BYREF
long long v12; // [rsp+10h] [rbp-1008h] BYREF
_QWORD v13[2]; // [rsp+1008h] [rbp-10h] BYREF
v13[1] = __readfsqword(0x28u);
v1 = 4LL * (a1 + 1) + 15;
v2 = (_QWORD *)((char *)v13 - (v1 & 0xFFFFFFFFFFFFF000LL));
v3 = v1 & 0xFFF0;
if ( v13 != v2 )
{
while ( &v11 != v2 )
;
}
v4 = v3 & 0xFFF;
v5 = alloca(v4);
if ( v4 )
*(long long *)((char *)&v10 + v4) = *(long long *)((char *)&v10 + v4);
v11 = 0x100000002LL;
if ( a1 > 1 )
{
v6 = &v12;
v7 = 2;
v8 = 1;
while ( 1 )
{
v8 += 2 * v7;
*(_DWORD *)v6 = v8;
if ( v6 == (long long *)((char *)&v11 + 4 * (unsigned int)(a1 - 2) + 8) )
break;
v7 = *((_DWORD *)v6 - 1);
v6 = (long long *)((char *)v6 + 4);
}
}
return *((unsigned int *)&v11 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101265
LAB_00101250:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101250
LAB_00101265:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001012e8
LAB_00101273:
MOV RSI,0x100000002
LEA R8,[RSP + 0x3]
MOV RAX,R8
AND R8,-0x4
SHR RAX,0x2
MOV qword ptr [RAX*0x4],RSI
CMP EDI,0x1
JLE 0x001012c9
LEA EDX,[RDI + -0x2]
LEA RAX,[R8 + 0x8]
MOV ECX,0x2
LEA RSI,[R8 + RDX*0x4 + 0x8]
MOV EDX,0x1
JMP 0x001012bf
LAB_001012b8:
MOV ECX,dword ptr [RAX + -0x4]
ADD RAX,0x4
LAB_001012bf:
LEA EDX,[RDX + RCX*0x2]
MOV dword ptr [RAX],EDX
CMP RAX,RSI
JNZ 0x001012b8
LAB_001012c9:
MOVSXD RDI,EDI
MOV EAX,dword ptr [R8 + RDI*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012f0
LEAVE
RET
LAB_001012e8:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101273
LAB_001012f0:
CALL 0x00101060 | int4 func0(int param_1)
{
long lVar1;
int1 *puVar2;
int *piVar3;
int iVar4;
int iVar5;
ulong uVar6;
int1 *puVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(param_1 + 1) * 4 + 0xf;
puVar8 = auStack_18;
puVar2 = auStack_18;
while (puVar8 != auStack_18 + -(uVar6 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar1 = -uVar6;
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
*(int8 *)(puVar7 + lVar1) = 0x100000002;
if (1 < param_1) {
piVar3 = (int *)(puVar7 + lVar1 + 8);
iVar4 = 2;
iVar5 = 1;
while( true ) {
iVar5 = iVar5 + iVar4 * 2;
*piVar3 = iVar5;
if (piVar3 == (int *)(puVar7 + (ulong)(param_1 - 2) * 4 + lVar1 + 8)) break;
iVar4 = piVar3[-1];
piVar3 = piVar3 + 1;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x1012f5;
__stack_chk_fail();
}
return *(int4 *)(puVar7 + (long)param_1 * 4 + lVar1);
} |
6,011 | func0 |
#include <assert.h>
| int func0(int n) {
int dp[n + 1];
dp[0] = 2;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 31);
assert(func0(2) == 5);
assert(func0(4) == 17);
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
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 11e8 <func0+0x58>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 11d3 <func0+0x43>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1298 <func0+0x108>
movabs $0x100000002,%rsi
lea 0x3(%rsp),%rdx
mov %rdx,%rax
and $0xfffffffffffffffc,%rdx
shr $0x2,%rax
mov %rsi,0x0(,%rax,4)
cmp $0x1,%edi
jle 127e <func0+0xee>
cmp $0x3,%edi
jle 12a3 <func0+0x113>
mov 0x0(,%rax,4),%r8d
mov 0x4(,%rax,4),%esi
lea -0x4(%rdi),%eax
mov $0x4,%ecx
shr %eax
lea 0x6(%rax,%rax,1),%r9
lea (%rsi,%r8,2),%r8d
movslq %ecx,%rax
lea (%r8,%rsi,2),%esi
mov %r8d,-0x8(%rdx,%rcx,4)
mov %esi,-0x4(%rdx,%rcx,4)
add $0x2,%rcx
cmp %rcx,%r9
jne 1244 <func0+0xb4>
nopl 0x0(%rax)
mov -0x8(%rdx,%rax,4),%esi
mov -0x4(%rdx,%rax,4),%ecx
lea (%rcx,%rsi,2),%ecx
mov %ecx,(%rdx,%rax,4)
add $0x1,%rax
cmp %eax,%edi
jge 1268 <func0+0xd8>
movslq %edi,%rdi
mov (%rdx,%rdi,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 12aa <func0+0x11a>
leaveq
retq
nopl (%rax)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 11fa <func0+0x6a>
mov $0x2,%eax
jmp 1268 <func0+0xd8>
callq 1050 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
movsxd rcx, edi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rcx+1]
mov rsi, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_11B8
loc_11A3:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rsi
jnz short loc_11A3
loc_11B8:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1260
loc_11CA:
lea rdx, [rsp+1010h+var_100D]
mov rsi, cs:qword_2008
mov rax, rdx
and rdx, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov qword ptr ds:dword_0[rax*4], rsi
cmp ecx, 1
jle short loc_1246
cmp ecx, 3
jle short loc_126B
lea eax, [rcx-4]
mov esi, 4
mov r8d, 1
mov edi, 2
shr eax, 1
lea r9d, [rax+3]
add r9, r9
loc_120F:
lea edi, [r8+rdi*2]
mov rax, rsi
lea r8d, [rdi+r8*2]
mov [rdx+rsi*4-8], edi
mov [rdx+rsi*4-4], r8d
add rsi, 2
cmp r9, rsi
jnz short loc_120F
loc_122C:
cdqe
xchg ax, ax
loc_1230:
mov edi, [rdx+rax*4-8]
mov esi, [rdx+rax*4-4]
lea esi, [rsi+rdi*2]
mov [rdx+rax*4], esi
add rax, 1
cmp ecx, eax
jge short loc_1230
loc_1246:
mov eax, [rdx+rcx*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1272
leave
retn
loc_1260:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_11CA
loc_126B:
mov eax, 2
jmp short loc_122C
loc_1272:
call ___stack_chk_fail | long long func0(int a1)
{
long long v1; // rcx
long long v2; // rdx
_QWORD *v3; // rsi
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long v7; // rsi
int v8; // r8d
int v9; // edi
long long v10; // rax
_QWORD v13[511]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v14[2]; // [rsp+1008h] [rbp-10h] BYREF
v1 = a1;
v14[1] = __readfsqword(0x28u);
v2 = 4LL * (a1 + 1) + 15;
v3 = (_QWORD *)((char *)v14 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( v14 != v3 )
{
while ( v13 != v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(_QWORD *)((char *)&v13[-1] + v5) = *(_QWORD *)((char *)&v13[-1] + v5);
v13[0] = 0x100000002LL;
if ( a1 > 1 )
{
if ( a1 <= 3 )
{
LODWORD(v10) = 2;
}
else
{
v7 = 2LL;
v8 = 1;
v9 = 2;
do
{
v9 = v8 + 2 * v9;
LODWORD(v10) = v7 * 2;
v8 = v9 + 2 * v8;
LODWORD(v13[v7 - 1]) = v9;
HIDWORD(v13[v7++ - 1]) = v8;
}
while ( ((unsigned int)(v1 - 4) >> 1) + 3 != v7 );
}
v10 = (int)v10;
do
{
*((_DWORD *)v13 + v10) = *((_DWORD *)v13 + v10 - 1) + 2 * *((_DWORD *)&v13[-1] + v10);
++v10;
}
while ( (int)v1 >= (int)v10 );
}
return *((unsigned int *)v13 + v1);
} | func0:
ENDBR64
PUSH RBP
MOVSXD RCX,EDI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RCX + 0x1]
MOV RSI,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x001011b8
LAB_001011a3:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001011a3
LAB_001011b8:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101260
LAB_001011ca:
LEA RDX,[RSP + 0x3]
MOV RSI,qword ptr [0x00102008]
MOV RAX,RDX
AND RDX,-0x4
SHR RAX,0x2
MOV qword ptr [RAX*0x4],RSI
CMP ECX,0x1
JLE 0x00101246
CMP ECX,0x3
JLE 0x0010126b
LEA EAX,[RCX + -0x4]
MOV ESI,0x4
MOV R8D,0x1
MOV EDI,0x2
SHR EAX,0x1
LEA R9D,[RAX + 0x3]
ADD R9,R9
LAB_0010120f:
LEA EDI,[R8 + RDI*0x2]
MOV RAX,RSI
LEA R8D,[RDI + R8*0x2]
MOV dword ptr [RDX + RSI*0x4 + -0x8],EDI
MOV dword ptr [RDX + RSI*0x4 + -0x4],R8D
ADD RSI,0x2
CMP R9,RSI
JNZ 0x0010120f
LAB_0010122c:
CDQE
NOP
LAB_00101230:
MOV EDI,dword ptr [RDX + RAX*0x4 + -0x8]
MOV ESI,dword ptr [RDX + RAX*0x4 + -0x4]
LEA ESI,[RSI + RDI*0x2]
MOV dword ptr [RDX + RAX*0x4],ESI
ADD RAX,0x1
CMP ECX,EAX
JGE 0x00101230
LAB_00101246:
MOV EAX,dword ptr [RDX + RCX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101272
LEAVE
RET
LAB_00101260:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001011ca
LAB_0010126b:
MOV EAX,0x2
JMP 0x0010122c
LAB_00101272:
CALL 0x00101050 | int4 func0(int param_1)
{
long lVar1;
int *puVar2;
int iVar3;
ulong uVar4;
int *puVar5;
long lVar7;
int iVar8;
int iVar9;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar6;
puVar5 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(param_1 + 1) * 4 + 0xf;
puVar6 = auStack_18;
puVar2 = auStack_18;
while (puVar6 != auStack_18 + -(uVar4 & 0xfffffffffffff000)) {
puVar5 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar6 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
*(int8 *)(puVar5 + lVar1) = DAT_00102008;
if (1 < param_1) {
if (param_1 < 4) {
iVar3 = 2;
}
else {
lVar7 = 4;
iVar9 = 1;
iVar8 = 2;
do {
iVar8 = iVar9 + iVar8 * 2;
iVar3 = (int)lVar7;
iVar9 = iVar8 + iVar9 * 2;
*(int *)(puVar5 + lVar7 * 4 + lVar1 + -8) = iVar8;
*(int *)(puVar5 + lVar7 * 4 + lVar1 + -4) = iVar9;
lVar7 = lVar7 + 2;
} while ((ulong)((param_1 - 4U >> 1) + 3) * 2 != lVar7);
}
lVar7 = (long)iVar3;
do {
*(int *)(puVar5 + lVar7 * 4 + lVar1) =
*(int *)(puVar5 + lVar7 * 4 + lVar1 + -4) + *(int *)(puVar5 + lVar7 * 4 + lVar1 + -8) * 2
;
lVar7 = lVar7 + 1;
} while ((int)lVar7 <= param_1);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar5 + lVar1 + -8) = 0x101277;
__stack_chk_fail();
}
return *(int4 *)(puVar5 + (long)param_1 * 4 + lVar1);
} |
6,012 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] < 0)
n1++;
}
double result = ((double)n1)/n;
// Round to two decimal places
return round(result * 100) / 100;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.31);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.31);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.44);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11ce <func0+0x45>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jns 11ca <func0+0x41>
addl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ac <func0+0x23>
cvtsi2sdl -0x10(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm1
movsd 0xe9a(%rip),%xmm0
mulsd %xmm1,%xmm0
callq 1070 <round@plt>
movsd 0xe89(%rip),%xmm1
divsd %xmm1,%xmm0
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_10], 0
mov [rbp+var_C], 0
jmp short loc_11CE
loc_11AC:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jns short loc_11CA
add [rbp+var_10], 1
loc_11CA:
add [rbp+var_C], 1
loc_11CE:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11AC
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_10]
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_1C]
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm1, [rbp+var_8]
movsd xmm0, cs:qword_2078
mulsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _round
movq rax, xmm0
movsd xmm0, cs:qword_2078
movq xmm1, rax
divsd xmm1, xmm0
movapd xmm0, xmm1
leave
retn | __int128 __usercall func0@<xmm0>(long long a1@<rdi>, int a2@<esi>)
{
double v2; // rax
__int128 v3; // xmm1
int v5; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) < 0 )
++v5;
}
v2 = round((double)v5 / (double)a2 * 100.0);
v3 = *(unsigned long long *)&v2;
*(double *)&v3 = v2 / 100.0;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011ce
LAB_001011ac:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNS 0x001011ca
ADD dword ptr [RBP + -0x10],0x1
LAB_001011ca:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011ce:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ac
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x10]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x1c]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM1,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00102078]
MULSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOVSD XMM0,qword ptr [0x00102078]
MOVQ XMM1,RAX
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
LEAVE
RET | double func0(long param_1,int param_2)
{
double dVar1;
int4 local_18;
int4 local_14;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) < 0) {
local_18 = local_18 + 1;
}
}
dVar1 = round(((double)local_18 / (double)param_2) * DAT_00102078);
return dVar1 / DAT_00102078;
} |
6,013 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] < 0)
n1++;
}
double result = ((double)n1)/n;
// Round to two decimal places
return round(result * 100) / 100;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.31);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.31);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.44);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 11e5 <func0+0x5c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
cmpl $0x80000000,(%rax)
sbb $0xffffffff,%edx
add $0x4,%rax
cmp %rcx,%rax
jne 11a5 <func0+0x1c>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xebd(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xeb0(%rip),%xmm0
add $0x8,%rsp
retq
mov $0x0,%edx
jmp 11b7 <func0+0x2e>
| func0:
endbr64
sub rsp, 8
test esi, esi
jle short loc_11E5
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_11A5:
cmp dword ptr [rax], 80000000h
sbb edx, 0FFFFFFFFh
add rax, 4
cmp rax, rcx
jnz short loc_11A5
loc_11B7:
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2070
call _round
divsd xmm0, cs:qword_2070
add rsp, 8
retn
loc_11E5:
mov edx, 0
jmp short loc_11B7 | double func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
int v3; // edx
if ( a2 <= 0 )
{
v3 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 -= (*v2++ < 0x80000000) - 1;
while ( v2 != &a1[a2 - 1 + 1] );
}
return round((double)v3 / (double)a2 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001011e5
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_001011a5:
CMP dword ptr [RAX],0x80000000
SBB EDX,-0x1
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011a5
LAB_001011b7:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102070]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102070]
ADD RSP,0x8
RET
LAB_001011e5:
MOV EDX,0x0
JMP 0x001011b7 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(uint *param_1,int param_2)
{
uint *puVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = (iVar2 + 1) - (uint)(*param_1 < 0x80000000);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
dVar3 = round(((double)iVar2 / (double)param_2) * _DAT_00102070);
return dVar3 / _DAT_00102070;
} |
6,014 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] < 0)
n1++;
}
double result = ((double)n1)/n;
// Round to two decimal places
return round(result * 100) / 100;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.31);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.31);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.44);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 13f0 <func0+0x60>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw %cs:0x0(%rax,%rax,1)
cmpl $0x80000000,(%rdi)
sbb $0xffffffff,%eax
add $0x4,%rdi
cmp %rdi,%rdx
jne 13b0 <func0+0x20>
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xcb2(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xca5(%rip),%xmm0
add $0x8,%rsp
retq
pxor %xmm0,%xmm0
jmp 13ca <func0+0x3a>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 8
test esi, esi
jle short loc_13F0
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13B0:
cmp dword ptr [rdi], 80000000h
sbb eax, 0FFFFFFFFh
add rdi, 4
cmp rdx, rdi
jnz short loc_13B0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
loc_13CA:
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2070
call _round
divsd xmm0, cs:qword_2070
add rsp, 8
retn
loc_13F0:
pxor xmm0, xmm0
jmp short loc_13CA | double func0(_DWORD *a1, int a2)
{
long long v2; // rdx
int v3; // eax
double v4; // xmm0_8
if ( a2 <= 0 )
{
v4 = 0.0;
}
else
{
v2 = (long long)&a1[a2 - 1 + 1];
v3 = 0;
do
v3 -= (*a1++ < 0x80000000) - 1;
while ( (_DWORD *)v2 != a1 );
v4 = (double)v3;
}
return round(v4 / (double)a2 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001013f0
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013b0:
CMP dword ptr [RDI],0x80000000
SBB EAX,-0x1
ADD RDI,0x4
CMP RDX,RDI
JNZ 0x001013b0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_001013ca:
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102070]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102070]
ADD RSP,0x8
RET
LAB_001013f0:
PXOR XMM0,XMM0
JMP 0x001013ca | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(uint *param_1,int param_2)
{
uint *puVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
dVar3 = 0.0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = (iVar2 + 1) - (uint)(*param_1 < 0x80000000);
param_1 = param_1 + 1;
} while (puVar1 != param_1);
dVar3 = (double)iVar2;
}
dVar3 = round((dVar3 / (double)param_2) * _DAT_00102070);
return dVar3 / _DAT_00102070;
} |
6,015 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] < 0)
n1++;
}
double result = ((double)n1)/n;
// Round to two decimal places
return round(result * 100) / 100;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.31);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.31);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.44);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 1410 <func0+0xf0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1416 <func0+0xf6>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm1
add $0x10,%rax
psrad $0x1f,%xmm1
psubd %xmm1,%xmm0
cmp %rdx,%rax
jne 1350 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 13d8 <func0+0xb8>
movslq %edx,%rcx
cmpl $0x80000000,(%rdi,%rcx,4)
lea 0x1(%rdx),%ecx
sbb $0xffffffff,%eax
cmp %esi,%ecx
jge 13d8 <func0+0xb8>
movslq %ecx,%rcx
cmpl $0x80000000,(%rdi,%rcx,4)
lea 0x2(%rdx),%ecx
sbb $0xffffffff,%eax
cmp %ecx,%esi
jle 13d8 <func0+0xb8>
movslq %ecx,%rcx
cmpl $0x80000000,(%rdi,%rcx,4)
sbb $0xffffffff,%eax
add $0x3,%edx
cmp %edx,%esi
jle 13d8 <func0+0xb8>
movslq %edx,%rdx
cmpl $0x80000000,(%rdi,%rdx,4)
sbb $0xffffffff,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xc9c(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xc8f(%rip),%xmm0
add $0x8,%rsp
retq
nopw %cs:0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
jmp 13e0 <func0+0xc0>
xor %edx,%edx
xor %eax,%eax
jmpq 138f <func0+0x6f>
| func0:
endbr64
sub rsp, 8
test esi, esi
jle loc_1410
lea eax, [rsi-1]
mov rcx, rdi
cmp eax, 2
jbe loc_1416
mov edx, esi
pxor xmm0, xmm0
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm0
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00000000h]
loc_1360:
movdqu xmm3, xmmword ptr [rax]
movdqa xmm1, xmm2
add rax, 10h
pcmpgtd xmm1, xmm3
psubd xmm0, xmm1
cmp rax, rdx
jnz short loc_1360
movdqa xmm1, xmm0
mov edx, esi
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short loc_13DD
loc_13A2:
movsxd rdi, edx
cmp dword ptr [rcx+rdi*4], 80000000h
lea r8, ds:0[rdi*4]
lea edi, [rdx+1]
sbb eax, 0FFFFFFFFh
cmp esi, edi
jle short loc_13DD
cmp dword ptr [rcx+r8+4], 80000000h
sbb eax, 0FFFFFFFFh
add edx, 2
cmp esi, edx
jle short loc_13DD
cmp dword ptr [rcx+r8+8], 80000000h
sbb eax, 0FFFFFFFFh
loc_13DD:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
loc_13E5:
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2070; x
call _round
divsd xmm0, cs:qword_2070
add rsp, 8
retn
loc_1410:
pxor xmm0, xmm0
jmp short loc_13E5
loc_1416:
xor edx, edx
xor eax, eax
jmp short loc_13A2 | double func0(const __m128i *a1, int a2)
{
__m128i v2; // xmm0
const __m128i *v3; // rax
__m128i v4; // xmm3
int v5; // edx
__m128i v6; // xmm0
int v7; // eax
long long v8; // r8
double v9; // xmm0_8
if ( a2 <= 0 )
{
v9 = 0.0;
return round(v9 / (double)a2 * 100.0) / 100.0;
}
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
v7 = 0;
goto LABEL_6;
}
v2 = 0LL;
v3 = a1;
do
{
v4 = _mm_loadu_si128(v3++);
v2 = _mm_sub_epi32(v2, _mm_cmpgt_epi32((__m128i)0LL, v4));
}
while ( v3 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_add_epi32(v2, _mm_srli_si128(v2, 8));
v7 = _mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a2 & 3) != 0 )
{
LABEL_6:
v8 = v5;
v7 -= (a1->m128i_i32[v8] < 0x80000000) - 1;
if ( a2 > v5 + 1 )
{
v7 -= (a1->m128i_i32[v8 + 1] < 0x80000000) - 1;
if ( a2 > v5 + 2 )
v7 -= (a1->m128i_i32[v8 + 2] < 0x80000000) - 1;
}
}
v9 = (double)v7;
return round(v9 / (double)a2 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101410
LEA EAX,[RSI + -0x1]
MOV RCX,RDI
CMP EAX,0x2
JBE 0x00101416
MOV EDX,ESI
PXOR XMM0,XMM0
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM0
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101360:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQA XMM1,XMM2
ADD RAX,0x10
PCMPGTD XMM1,XMM3
PSUBD XMM0,XMM1
CMP RAX,RDX
JNZ 0x00101360
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x001013dd
LAB_001013a2:
MOVSXD RDI,EDX
CMP dword ptr [RCX + RDI*0x4],0x80000000
LEA R8,[RDI*0x4]
LEA EDI,[RDX + 0x1]
SBB EAX,-0x1
CMP ESI,EDI
JLE 0x001013dd
CMP dword ptr [RCX + R8*0x1 + 0x4],0x80000000
SBB EAX,-0x1
ADD EDX,0x2
CMP ESI,EDX
JLE 0x001013dd
CMP dword ptr [RCX + R8*0x1 + 0x8],0x80000000
SBB EAX,-0x1
LAB_001013dd:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_001013e5:
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102070]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102070]
ADD RSP,0x8
RET
LAB_00101410:
PXOR XMM0,XMM0
JMP 0x001013e5
LAB_00101416:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001013a2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar9;
double dVar8;
int iVar10;
int iVar11;
if ((int)param_2 < 1) {
dVar8 = 0.0;
goto LAB_001013e5;
}
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
LAB_001013a2:
iVar7 = (iVar7 + 1) - (uint)((uint)param_1[(int)uVar6] < 0x80000000);
if (((int)(uVar6 + 1) < (int)param_2) &&
(iVar7 = (iVar7 + 1) - (uint)((uint)param_1[(long)(int)uVar6 + 1] < 0x80000000),
(int)(uVar6 + 2) < (int)param_2)) {
iVar7 = (iVar7 + 1) - (uint)((uint)param_1[(long)(int)uVar6 + 2] < 0x80000000);
}
}
else {
iVar7 = 0;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar7 = iVar7 + (uint)(iVar1 < 0);
iVar9 = iVar9 + (uint)(*piVar2 < 0);
iVar10 = iVar10 + (uint)(*piVar3 < 0);
iVar11 = iVar11 + (uint)(*piVar4 < 0);
} while (piVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar10 + iVar9 + iVar11;
if ((param_2 & 3) != 0) goto LAB_001013a2;
}
dVar8 = (double)iVar7;
LAB_001013e5:
dVar8 = round((dVar8 / (double)(int)param_2) * _DAT_00102070);
return dVar8 / _DAT_00102070;
} |
6,016 | func0 | #include <assert.h>
#include <limits.h>
| int func0(int coins[], int m, int V) {
if (V == 0) {
return 0;
}
int res = INT_MAX;
for (int i = 0; i < m; i++) {
if (coins[i] <= V) {
int sub_res = func0(coins, m, V - coins[i]);
if (sub_res != INT_MAX && sub_res + 1 < res) {
res = sub_res + 1;
}
}
}
return res;
}
| int main() {
assert(func0((int[]){9, 6, 5, 1}, 4, 11) == 2);
assert(func0((int[]){4, 5, 6, 7, 8, 9}, 6, 9) == 1);
assert(func0((int[]){1, 2, 3}, 3, 4) == 2);
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)
cmpl $0x0,-0x20(%rbp)
jne 118f <func0+0x26>
mov $0x0,%eax
jmpq 1215 <func0+0xac>
movl $0x7fffffff,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 120a <func0+0xa1>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jl 1206 <func0+0x9d>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x20(%rbp),%edx
sub %eax,%edx
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <func0>
mov %eax,-0x4(%rbp)
cmpl $0x7fffffff,-0x4(%rbp)
je 1206 <func0+0x9d>
mov -0x4(%rbp),%eax
add $0x1,%eax
cmp %eax,-0xc(%rbp)
jle 1206 <func0+0x9d>
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119f <func0+0x36>
mov -0xc(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
cmp [rbp+var_20], 0
jnz short loc_118F
mov eax, 0
jmp locret_1215
loc_118F:
mov [rbp+var_C], 7FFFFFFFh
mov [rbp+var_8], 0
jmp short loc_120A
loc_119F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jl short loc_1206
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_20]
sub edx, eax
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
mov [rbp+var_4], eax
cmp [rbp+var_4], 7FFFFFFFh
jz short loc_1206
mov eax, [rbp+var_4]
add eax, 1
cmp [rbp+var_C], eax
jle short loc_1206
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_C], eax
loc_1206:
add [rbp+var_8], 1
loc_120A:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_119F
mov eax, [rbp+var_C]
locret_1215:
leave
retn | long long func0(long long a1, unsigned int a2, int a3)
{
int v5; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
if ( !a3 )
return 0LL;
v5 = 0x7FFFFFFF;
for ( i = 0; i < (int)a2; ++i )
{
if ( a3 >= *(_DWORD *)(4LL * i + a1) )
{
v7 = func0(a1, a2, (unsigned int)(a3 - *(_DWORD *)(4LL * i + a1)));
if ( v7 != 0x7FFFFFFF && v5 > v7 + 1 )
v5 = v7 + 1;
}
}
return (unsigned int)v5;
} | 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
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x0010118f
MOV EAX,0x0
JMP 0x00101215
LAB_0010118f:
MOV dword ptr [RBP + -0xc],0x7fffffff
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010120a
LAB_0010119f:
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]
CMP dword ptr [RBP + -0x20],EAX
JL 0x00101206
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
SUB EDX,EAX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x7fffffff
JZ 0x00101206
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP dword ptr [RBP + -0xc],EAX
JLE 0x00101206
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_00101206:
ADD dword ptr [RBP + -0x8],0x1
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119f
MOV EAX,dword ptr [RBP + -0xc]
LAB_00101215:
LEAVE
RET | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int local_14;
int local_10;
if (param_3 == 0) {
local_14 = 0;
}
else {
local_14 = 0x7fffffff;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if (((*(int *)(param_1 + (long)local_10 * 4) <= param_3) &&
(iVar1 = func0(param_1,param_2,param_3 - *(int *)(param_1 + (long)local_10 * 4)),
iVar1 != 0x7fffffff)) && (iVar1 + 1 < local_14)) {
local_14 = iVar1 + 1;
}
}
}
return local_14;
} |
6,017 | func0 | #include <assert.h>
#include <limits.h>
| int func0(int coins[], int m, int V) {
if (V == 0) {
return 0;
}
int res = INT_MAX;
for (int i = 0; i < m; i++) {
if (coins[i] <= V) {
int sub_res = func0(coins, m, V - coins[i]);
if (sub_res != INT_MAX && sub_res + 1 < res) {
res = sub_res + 1;
}
}
}
return res;
}
| int main() {
assert(func0((int[]){9, 6, 5, 1}, 4, 11) == 2);
assert(func0((int[]){4, 5, 6, 7, 8, 9}, 6, 9) == 1);
assert(func0((int[]){1, 2, 3}, 3, 4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%r14d
test %edx,%edx
je 11d2 <func0+0x69>
mov %rdi,%r13
mov %esi,%r12d
mov %edx,%ebp
mov $0x7fffffff,%r14d
test %esi,%esi
jle 11d2 <func0+0x69>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r15
jmp 11b4 <func0+0x4b>
add $0x1,%eax
cmp %eax,%r14d
cmovg %eax,%r14d
add $0x4,%rbx
cmp %r15,%rbx
je 11d2 <func0+0x69>
mov (%rbx),%eax
cmp %ebp,%eax
jg 11ab <func0+0x42>
mov %ebp,%edx
sub %eax,%edx
mov %r12d,%esi
mov %r13,%rdi
callq 1169 <func0>
cmp $0x7fffffff,%eax
jne 11a1 <func0+0x38>
jmp 11ab <func0+0x42>
mov %r14d,%eax
add $0x8,%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, 8
mov r12d, edx
test edx, edx
jz short loc_11D4
mov r14, rdi
mov r13d, esi
mov ebp, edx
mov r12d, 7FFFFFFFh
test esi, esi
jle short loc_11D4
mov rbx, rdi
lea eax, [rsi-1]
lea r15, [rdi+rax*4+4]
jmp short loc_11AA
loc_11A1:
add rbx, 4
cmp rbx, r15
jz short loc_11D4
loc_11AA:
mov eax, [rbx]
cmp eax, ebp
jg short loc_11A1
mov edx, ebp
sub edx, eax
mov esi, r13d
mov rdi, r14
call func0
lea edx, [rax+1]
cmp r12d, edx
cmovle edx, r12d
cmp eax, 7FFFFFFFh
cmovnz r12d, edx
jmp short loc_11A1
loc_11D4:
mov eax, r12d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int *a1, int a2, int a3)
{
int v3; // r12d
int *v5; // rbx
int v6; // eax
int v7; // edx
v3 = a3;
if ( a3 )
{
v3 = 0x7FFFFFFF;
if ( a2 > 0 )
{
v5 = a1;
do
{
if ( *v5 <= a3 )
{
v6 = func0(a1, (unsigned int)a2, (unsigned int)(a3 - *v5));
v7 = v6 + 1;
if ( v3 <= v6 + 1 )
v7 = v3;
if ( v6 != 0x7FFFFFFF )
v3 = v7;
}
++v5;
}
while ( v5 != &a1[a2 - 1 + 1] );
}
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,EDX
TEST EDX,EDX
JZ 0x001011d4
MOV R14,RDI
MOV R13D,ESI
MOV EBP,EDX
MOV R12D,0x7fffffff
TEST ESI,ESI
JLE 0x001011d4
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R15,[RDI + RAX*0x4 + 0x4]
JMP 0x001011aa
LAB_001011a1:
ADD RBX,0x4
CMP RBX,R15
JZ 0x001011d4
LAB_001011aa:
MOV EAX,dword ptr [RBX]
CMP EAX,EBP
JG 0x001011a1
MOV EDX,EBP
SUB EDX,EAX
MOV ESI,R13D
MOV RDI,R14
CALL 0x00101169
LEA EDX,[RAX + 0x1]
CMP R12D,EDX
CMOVLE EDX,R12D
CMP EAX,0x7fffffff
CMOVNZ R12D,EDX
JMP 0x001011a1
LAB_001011d4:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar4 = param_3;
if ((param_3 != 0) && (iVar4 = 0x7fffffff, 0 < param_2)) {
piVar3 = param_1;
do {
if (*piVar3 <= param_3) {
iVar1 = func0(param_1,param_2,param_3 - *piVar3);
iVar2 = iVar1 + 1;
if (iVar4 <= iVar1 + 1) {
iVar2 = iVar4;
}
if (iVar1 != 0x7fffffff) {
iVar4 = iVar2;
}
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 1) + 1);
}
return iVar4;
} |
6,018 | func0 | #include <assert.h>
#include <limits.h>
| int func0(int coins[], int m, int V) {
if (V == 0) {
return 0;
}
int res = INT_MAX;
for (int i = 0; i < m; i++) {
if (coins[i] <= V) {
int sub_res = func0(coins, m, V - coins[i]);
if (sub_res != INT_MAX && sub_res + 1 < res) {
res = sub_res + 1;
}
}
}
return res;
}
| int main() {
assert(func0((int[]){9, 6, 5, 1}, 4, 11) == 2);
assert(func0((int[]){4, 5, 6, 7, 8, 9}, 6, 9) == 1);
assert(func0((int[]){1, 2, 3}, 3, 4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
je 12d0 <func0+0x10>
jmp 12e0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0_part_0:
push r15
push r14
mov r14d, 7FFFFFFFh
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_12EA
lea eax, [rsi-1]
mov r15, rdi
mov r12d, esi
mov ebp, edx
mov rbx, rdi
lea r13, [rdi+rax*4+4]
loc_12DB:
mov eax, [rbx]
cmp eax, ebp
jle short loc_1300
loc_12E1:
add rbx, 4
cmp rbx, r13
jnz short loc_12DB
loc_12EA:
add rsp, 8
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1300:
mov edx, ebp
sub edx, eax
jz short loc_1328
mov esi, r12d
mov rdi, r15
call func0_part_0
cmp eax, 7FFFFFFFh
jz short loc_12E1
add eax, 1
loc_131B:
cmp r14d, eax
cmovg r14d, eax
jmp short loc_12E1
loc_1328:
mov eax, 1
jmp short loc_131B | long long func0_part_0(int *a1, int a2, int a3)
{
int v3; // r14d
int *i; // rbx
int v6; // eax
int v8; // eax
int v9; // eax
v3 = 0x7FFFFFFF;
if ( a2 > 0 )
{
for ( i = a1; i != &a1[a2 - 1 + 1]; ++i )
{
v6 = *i;
if ( *i <= a3 )
{
if ( a3 == v6 )
{
v9 = 1;
LABEL_9:
if ( v3 > v9 )
v3 = v9;
continue;
}
v8 = func0_part_0(a1, (unsigned int)a2, (unsigned int)(a3 - v6));
if ( v8 != 0x7FFFFFFF )
{
v9 = v8 + 1;
goto LABEL_9;
}
}
}
}
return (unsigned int)v3;
} | func0.part.0:
PUSH R15
PUSH R14
MOV R14D,0x7fffffff
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001012ea
LEA EAX,[RSI + -0x1]
MOV R15,RDI
MOV R12D,ESI
MOV EBP,EDX
MOV RBX,RDI
LEA R13,[RDI + RAX*0x4 + 0x4]
LAB_001012db:
MOV EAX,dword ptr [RBX]
CMP EAX,EBP
JLE 0x00101300
LAB_001012e1:
ADD RBX,0x4
CMP RBX,R13
JNZ 0x001012db
LAB_001012ea:
ADD RSP,0x8
MOV EAX,R14D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101300:
MOV EDX,EBP
SUB EDX,EAX
JZ 0x00101328
MOV ESI,R12D
MOV RDI,R15
CALL 0x001012b0
CMP EAX,0x7fffffff
JZ 0x001012e1
ADD EAX,0x1
LAB_0010131b:
CMP R14D,EAX
CMOVG R14D,EAX
JMP 0x001012e1
LAB_00101328:
MOV EAX,0x1
JMP 0x0010131b | int func0_part_0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
int iVar3;
iVar3 = 0x7fffffff;
if (0 < param_2) {
piVar2 = param_1;
do {
if (*piVar2 <= param_3) {
if (param_3 == *piVar2) {
iVar1 = 1;
}
else {
iVar1 = func0_part_0(param_1,param_2);
if (iVar1 == 0x7fffffff) goto LAB_001012e1;
iVar1 = iVar1 + 1;
}
if (iVar1 < iVar3) {
iVar3 = iVar1;
}
}
LAB_001012e1:
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
}
return iVar3;
} |
6,019 | func0 | #include <assert.h>
#include <limits.h>
| int func0(int coins[], int m, int V) {
if (V == 0) {
return 0;
}
int res = INT_MAX;
for (int i = 0; i < m; i++) {
if (coins[i] <= V) {
int sub_res = func0(coins, m, V - coins[i]);
if (sub_res != INT_MAX && sub_res + 1 < res) {
res = sub_res + 1;
}
}
}
return res;
}
| int main() {
assert(func0((int[]){9, 6, 5, 1}, 4, 11) == 2);
assert(func0((int[]){4, 5, 6, 7, 8, 9}, 6, 9) == 1);
assert(func0((int[]){1, 2, 3}, 3, 4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
test %edx,%edx
je 1351 <func0+0x41>
mov $0x7fffffff,%r15d
test %esi,%esi
jle 1351 <func0+0x41>
lea -0x1(%rsi),%eax
mov %edx,%r14d
mov %rdi,%rcx
lea 0x4(%rdi,%rax,4),%r9
mov (%rcx),%eax
cmp %eax,%r14d
jge 1368 <func0+0x58>
add $0x4,%rcx
cmp %r9,%rcx
jne 1341 <func0+0x31>
add $0x28,%rsp
mov %r15d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov %r14d,%r12d
sub %eax,%r12d
je 1470 <func0+0x160>
mov %rcx,0x8(%rsp)
mov %rdi,%r8
mov $0x7fffffff,%r13d
mov %r14d,0x18(%rsp)
mov (%r8),%eax
cmp %eax,%r12d
jge 13c0 <func0+0xb0>
add $0x4,%r8
cmp %r9,%r8
jne 1387 <func0+0x77>
mov 0x8(%rsp),%rcx
mov 0x18(%rsp),%r14d
lea 0x1(%r13),%eax
cmp $0x7fffffff,%r13d
je 1348 <func0+0x38>
cmp %eax,%r15d
cmovg %eax,%r15d
jmp 1348 <func0+0x38>
nopl 0x0(%rax,%rax,1)
mov %r12d,%r11d
sub %eax,%r11d
je 13f0 <func0+0xe0>
mov %rdi,%rcx
mov $0x7fffffff,%r14d
mov (%rcx),%eax
cmp %eax,%r11d
jge 1400 <func0+0xf0>
add $0x4,%rcx
cmp %r9,%rcx
jne 13d1 <func0+0xc1>
lea 0x1(%r14),%eax
cmp $0x7fffffff,%r14d
je 138f <func0+0x7f>
jmp 13f5 <func0+0xe5>
mov $0x1,%eax
cmp %eax,%r13d
cmovg %eax,%r13d
jmp 138f <func0+0x7f>
xchg %ax,%ax
mov %r11d,%ebp
sub %eax,%ebp
je 1488 <func0+0x178>
mov %rdi,%r10
mov $0x7fffffff,%ebx
mov (%r10),%eax
cmp %eax,%ebp
jge 1440 <func0+0x130>
add $0x4,%r10
cmp %r9,%r10
jne 1413 <func0+0x103>
cmp $0x7fffffff,%ebx
je 13d8 <func0+0xc8>
add $0x1,%ebx
cmp %ebx,%r14d
cmovg %ebx,%r14d
jmp 13d8 <func0+0xc8>
nopw 0x0(%rax,%rax,1)
mov %ebp,%edx
sub %eax,%edx
je 1490 <func0+0x180>
mov %esi,0x1c(%rsp)
mov %rdi,0x10(%rsp)
callq 1290 <func0.part.0>
mov 0x10(%rsp),%rdi
mov 0x1c(%rsp),%esi
cmp $0x7fffffff,%eax
je 141a <func0+0x10a>
add $0x1,%eax
cmp %eax,%ebx
cmovg %eax,%ebx
jmp 141a <func0+0x10a>
xchg %ax,%ax
mov $0x1,%eax
cmp %eax,%r15d
cmovg %eax,%r15d
jmpq 1348 <func0+0x38>
nopl 0x0(%rax)
mov $0x1,%ebx
jmp 142e <func0+0x11e>
mov $0x1,%eax
jmp 1467 <func0+0x157>
nopw 0x0(%rax,%rax,1)
| func0_part_0:
push r15
push r14
push r13
mov r13d, 7FFFFFFFh
push r12
push rbp
push rbx
sub rsp, 58h
test esi, esi
jle short loc_12CE
movsxd rax, esi
mov r12d, edx
mov r14d, r13d
mov rbx, rdi
lea rdx, [rdi+rax*4]
mov r13, rdx
loc_12BB:
mov eax, [rbx]
cmp eax, r12d
jle short loc_12E0
loc_12C2:
add rbx, 4
cmp rbx, r13
jnz short loc_12BB
mov r13d, r14d
loc_12CE:
add rsp, 58h
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12E0:
mov r15d, r12d
sub r15d, eax
jz loc_14D8
mov [rsp+88h+var_80], rbx
mov ecx, 7FFFFFFFh
mov rbp, rdi
mov r8d, r14d
mov [rsp+88h+var_74], r12d
mov r12d, ecx
loc_1304:
mov eax, [rbp+0]
cmp r15d, eax
jge short loc_1340
loc_130C:
add rbp, 4
cmp rbp, r13
jnz short loc_1304
mov ecx, r12d
mov rbx, [rsp+88h+var_80]
mov r12d, [rsp+88h+var_74]
mov r14d, r8d
cmp ecx, 7FFFFFFFh
jz short loc_12C2
add ecx, 1
loc_1330:
cmp r14d, ecx
cmovg r14d, ecx
jmp short loc_12C2
loc_1340:
mov r14d, r15d
sub r14d, eax
jz loc_14E8
mov [rsp+88h+var_70], r15d
mov rcx, rbp
mov eax, 7FFFFFFFh
mov ebp, r14d
mov [rsp+88h+var_6C], r12d
mov rbx, rdi
mov r9d, eax
mov r14, rcx
loc_136A:
mov eax, [rbx]
cmp ebp, eax
jge short loc_13A0
loc_1370:
add rbx, 4
cmp rbx, r13
jnz short loc_136A
mov r15d, [rsp+88h+var_70]
mov r12d, [rsp+88h+var_6C]
mov rbp, r14
mov eax, r9d
cmp r9d, 7FFFFFFFh
jz loc_130C
add eax, 1
jmp loc_14ED
loc_13A0:
mov r12d, ebp
sub r12d, eax
jz short loc_13F8
mov [rsp+88h+var_58], r9d
mov rcx, r14
mov r9, rbx
mov r15, rdi
mov r11d, 7FFFFFFFh
mov r14d, ebp
mov ebx, r12d
mov r10, r13
loc_13C5:
mov eax, [r15]
cmp ebx, eax
jge short loc_1410
loc_13CC:
add r15, 4
cmp r15, r10
jnz short loc_13C5
mov ebp, r14d
mov rbx, r9
mov r14, rcx
mov r9d, [rsp+88h+var_58]
mov r13, r10
cmp r11d, 7FFFFFFFh
jz short loc_1370
add r11d, 1
jmp short loc_13FE
loc_13F8:
mov r11d, 1
loc_13FE:
cmp r9d, r11d
cmovg r9d, r11d
jmp loc_1370
loc_1410:
mov ebp, ebx
sub ebp, eax
jz loc_1500
mov [rsp+88h+var_68], r15
xor r12d, r12d
mov r15d, ebx
mov r13d, 7FFFFFFFh
mov rbx, rcx
loc_142E:
mov eax, [rdi+r12*4]
cmp ebp, eax
jge short loc_1470
loc_1436:
add r12, 1
cmp esi, r12d
jg short loc_142E
mov rcx, rbx
mov ebx, r15d
mov r15, [rsp+88h+var_68]
cmp r13d, 7FFFFFFFh
jz loc_13CC
add r13d, 1
loc_145B:
cmp r11d, r13d
cmovg r11d, r13d
jmp loc_13CC
loc_1470:
mov edx, ebp
sub edx, eax
jz loc_1510
mov [rsp+88h+var_3C], r8d
mov [rsp+88h+var_48], r10
mov [rsp+88h+var_40], r11d
mov [rsp+88h+var_50], r9
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_60], rdi
call func0_part_0
mov rdi, [rsp+88h+var_60]
mov esi, [rsp+88h+var_54]
cmp eax, 7FFFFFFFh
mov r9, [rsp+88h+var_50]
mov r11d, [rsp+88h+var_40]
mov r10, [rsp+88h+var_48]
mov r8d, [rsp+88h+var_3C]
jz loc_1436
add eax, 1
loc_14C7:
cmp r13d, eax
cmovg r13d, eax
jmp loc_1436
loc_14D8:
mov ecx, 1
jmp loc_1330
loc_14E8:
mov eax, 1
loc_14ED:
cmp r12d, eax
cmovg r12d, eax
jmp loc_130C
loc_1500:
mov r13d, 1
jmp loc_145B
loc_1510:
mov eax, 1
jmp short loc_14C7 | long long func0_part_0(_DWORD *a1, long long a2, int a3)
{
unsigned int v3; // r13d
int v5; // r14d
_DWORD *v6; // rbx
_DWORD *v7; // r13
int v8; // eax
int v10; // r15d
_DWORD *v11; // rbp
int v12; // r8d
int v13; // r12d
int v14; // eax
int v15; // ecx
int v16; // ecx
_DWORD *v17; // rcx
int v18; // ebp
_DWORD *v19; // rbx
int v20; // r9d
_DWORD *v21; // r14
int v22; // eax
int v23; // eax
_DWORD *v24; // rcx
_DWORD *v25; // r9
_DWORD *v26; // r15
int v27; // r11d
int v28; // r14d
int v29; // ebx
_DWORD *v30; // r10
int v31; // eax
int v32; // r11d
int v33; // ebp
long long v34; // r12
int v35; // r15d
int v36; // r13d
_DWORD *v37; // rbx
int v38; // eax
int v39; // r13d
int v40; // eax
int v41; // eax
_DWORD *v42; // [rsp+8h] [rbp-80h]
int v43; // [rsp+14h] [rbp-74h]
int v44; // [rsp+18h] [rbp-70h]
int v45; // [rsp+1Ch] [rbp-6Ch]
_DWORD *v46; // [rsp+20h] [rbp-68h]
int v47; // [rsp+30h] [rbp-58h]
_DWORD *v48; // [rsp+38h] [rbp-50h]
_DWORD *v49; // [rsp+40h] [rbp-48h]
int v50; // [rsp+48h] [rbp-40h]
int v51; // [rsp+4Ch] [rbp-3Ch]
v3 = 0x7FFFFFFF;
if ( (int)a2 > 0 )
{
v5 = 0x7FFFFFFF;
v6 = a1;
v7 = &a1[(int)a2];
while ( 1 )
{
v8 = *v6;
if ( *v6 > a3 )
goto LABEL_4;
v10 = a3 - v8;
if ( a3 == v8 )
{
v16 = 1;
goto LABEL_13;
}
v42 = v6;
v11 = a1;
v12 = v5;
v43 = a3;
v13 = 0x7FFFFFFF;
do
{
v14 = *v11;
if ( v10 < *v11 )
goto LABEL_10;
if ( v10 == v14 )
{
v23 = 1;
goto LABEL_49;
}
v44 = v10;
v17 = v11;
v18 = v10 - v14;
v45 = v13;
v19 = a1;
v20 = 0x7FFFFFFF;
v21 = v17;
do
{
v22 = *v19;
if ( v18 < *v19 )
goto LABEL_19;
if ( v18 == v22 )
{
v32 = 1;
goto LABEL_29;
}
v47 = v20;
v24 = v21;
v25 = v19;
v26 = a1;
v27 = 0x7FFFFFFF;
v28 = v18;
v29 = v18 - v22;
v30 = v7;
do
{
v31 = *v26;
if ( v29 < *v26 )
goto LABEL_25;
v33 = v29 - v31;
if ( v29 == v31 )
{
v39 = 1;
goto LABEL_38;
}
v46 = v26;
v34 = 0LL;
v35 = v29;
v36 = 0x7FFFFFFF;
v37 = v24;
do
{
v38 = a1[v34];
if ( v33 < v38 )
goto LABEL_35;
if ( v33 == v38 )
{
v41 = 1;
}
else
{
v51 = v12;
v49 = v30;
v50 = v27;
v48 = v25;
v40 = func0_part_0(a1, a2, (unsigned int)(v33 - v38));
a2 = (unsigned int)a2;
v25 = v48;
v27 = v50;
v30 = v49;
v12 = v51;
if ( v40 == 0x7FFFFFFF )
goto LABEL_35;
v41 = v40 + 1;
}
if ( v36 > v41 )
v36 = v41;
LABEL_35:
++v34;
}
while ( (int)a2 > (int)v34 );
v24 = v37;
v29 = v35;
v26 = v46;
if ( v36 != 0x7FFFFFFF )
{
v39 = v36 + 1;
LABEL_38:
if ( v27 > v39 )
v27 = v39;
}
LABEL_25:
++v26;
}
while ( v26 != v30 );
v18 = v28;
v19 = v25;
v21 = v24;
v20 = v47;
v7 = v30;
if ( v27 != 0x7FFFFFFF )
{
v32 = v27 + 1;
LABEL_29:
if ( v20 > v32 )
v20 = v32;
}
LABEL_19:
++v19;
}
while ( v19 != v7 );
v10 = v44;
v13 = v45;
v11 = v21;
if ( v20 != 0x7FFFFFFF )
{
v23 = v20 + 1;
LABEL_49:
if ( v13 > v23 )
v13 = v23;
}
LABEL_10:
++v11;
}
while ( v11 != v7 );
v15 = v13;
v6 = v42;
a3 = v43;
v5 = v12;
if ( v15 != 0x7FFFFFFF )
{
v16 = v15 + 1;
LABEL_13:
if ( v5 > v16 )
v5 = v16;
}
LABEL_4:
if ( ++v6 == v7 )
return (unsigned int)v5;
}
}
return v3;
} | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
MOV R13D,0x7fffffff
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
TEST ESI,ESI
JLE 0x001012ce
MOVSXD RAX,ESI
MOV R12D,EDX
MOV R14D,R13D
MOV RBX,RDI
LEA RDX,[RDI + RAX*0x4]
MOV R13,RDX
LAB_001012bb:
MOV EAX,dword ptr [RBX]
CMP EAX,R12D
JLE 0x001012e0
LAB_001012c2:
ADD RBX,0x4
CMP RBX,R13
JNZ 0x001012bb
MOV R13D,R14D
LAB_001012ce:
ADD RSP,0x58
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012e0:
MOV R15D,R12D
SUB R15D,EAX
JZ 0x001014d8
MOV qword ptr [RSP + 0x8],RBX
MOV ECX,0x7fffffff
MOV RBP,RDI
MOV R8D,R14D
MOV dword ptr [RSP + 0x14],R12D
MOV R12D,ECX
LAB_00101304:
MOV EAX,dword ptr [RBP]
CMP R15D,EAX
JGE 0x00101340
LAB_0010130c:
ADD RBP,0x4
CMP RBP,R13
JNZ 0x00101304
MOV ECX,R12D
MOV RBX,qword ptr [RSP + 0x8]
MOV R12D,dword ptr [RSP + 0x14]
MOV R14D,R8D
CMP ECX,0x7fffffff
JZ 0x001012c2
ADD ECX,0x1
LAB_00101330:
CMP R14D,ECX
CMOVG R14D,ECX
JMP 0x001012c2
LAB_00101340:
MOV R14D,R15D
SUB R14D,EAX
JZ 0x001014e8
MOV dword ptr [RSP + 0x18],R15D
MOV RCX,RBP
MOV EAX,0x7fffffff
MOV EBP,R14D
MOV dword ptr [RSP + 0x1c],R12D
MOV RBX,RDI
MOV R9D,EAX
MOV R14,RCX
LAB_0010136a:
MOV EAX,dword ptr [RBX]
CMP EBP,EAX
JGE 0x001013a0
LAB_00101370:
ADD RBX,0x4
CMP RBX,R13
JNZ 0x0010136a
MOV R15D,dword ptr [RSP + 0x18]
MOV R12D,dword ptr [RSP + 0x1c]
MOV RBP,R14
MOV EAX,R9D
CMP R9D,0x7fffffff
JZ 0x0010130c
ADD EAX,0x1
JMP 0x001014ed
LAB_001013a0:
MOV R12D,EBP
SUB R12D,EAX
JZ 0x001013f8
MOV dword ptr [RSP + 0x30],R9D
MOV RCX,R14
MOV R9,RBX
MOV R15,RDI
MOV R11D,0x7fffffff
MOV R14D,EBP
MOV EBX,R12D
MOV R10,R13
LAB_001013c5:
MOV EAX,dword ptr [R15]
CMP EBX,EAX
JGE 0x00101410
LAB_001013cc:
ADD R15,0x4
CMP R15,R10
JNZ 0x001013c5
MOV EBP,R14D
MOV RBX,R9
MOV R14,RCX
MOV R9D,dword ptr [RSP + 0x30]
MOV R13,R10
CMP R11D,0x7fffffff
JZ 0x00101370
ADD R11D,0x1
JMP 0x001013fe
LAB_001013f8:
MOV R11D,0x1
LAB_001013fe:
CMP R9D,R11D
CMOVG R9D,R11D
JMP 0x00101370
LAB_00101410:
MOV EBP,EBX
SUB EBP,EAX
JZ 0x00101500
MOV qword ptr [RSP + 0x20],R15
XOR R12D,R12D
MOV R15D,EBX
MOV R13D,0x7fffffff
MOV RBX,RCX
LAB_0010142e:
MOV EAX,dword ptr [RDI + R12*0x4]
CMP EBP,EAX
JGE 0x00101470
LAB_00101436:
ADD R12,0x1
CMP ESI,R12D
JG 0x0010142e
MOV RCX,RBX
MOV EBX,R15D
MOV R15,qword ptr [RSP + 0x20]
CMP R13D,0x7fffffff
JZ 0x001013cc
ADD R13D,0x1
LAB_0010145b:
CMP R11D,R13D
CMOVG R11D,R13D
JMP 0x001013cc
LAB_00101470:
MOV EDX,EBP
SUB EDX,EAX
JZ 0x00101510
MOV dword ptr [RSP + 0x4c],R8D
MOV qword ptr [RSP + 0x40],R10
MOV dword ptr [RSP + 0x48],R11D
MOV qword ptr [RSP + 0x38],R9
MOV dword ptr [RSP + 0x34],ESI
MOV qword ptr [RSP + 0x28],RDI
CALL 0x00101290
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x34]
CMP EAX,0x7fffffff
MOV R9,qword ptr [RSP + 0x38]
MOV R11D,dword ptr [RSP + 0x48]
MOV R10,qword ptr [RSP + 0x40]
MOV R8D,dword ptr [RSP + 0x4c]
JZ 0x00101436
ADD EAX,0x1
LAB_001014c7:
CMP R13D,EAX
CMOVG R13D,EAX
JMP 0x00101436
LAB_001014d8:
MOV ECX,0x1
JMP 0x00101330
LAB_001014e8:
MOV EAX,0x1
LAB_001014ed:
CMP R12D,EAX
CMOVG R12D,EAX
JMP 0x0010130c
LAB_00101500:
MOV R13D,0x1
JMP 0x0010145b
LAB_00101510:
MOV EAX,0x1
JMP 0x001014c7 | int func0_part_0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
bool bVar3;
int iVar4;
int iVar5;
int iVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int iVar10;
int iVar11;
int iVar12;
long lVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int *piVar19;
iVar14 = 0x7fffffff;
if (0 < param_2) {
iVar14 = 0x7fffffff;
piVar1 = param_1 + param_2;
piVar7 = param_1;
do {
if (*piVar7 <= param_3) {
iVar18 = param_3 - *piVar7;
if (iVar18 == 0) {
iVar6 = 1;
}
else {
iVar6 = 0x7fffffff;
piVar9 = param_1;
do {
if (*piVar9 <= iVar18) {
iVar17 = iVar18 - *piVar9;
if (iVar17 == 0) {
iVar4 = 1;
}
else {
iVar4 = 0x7fffffff;
piVar8 = param_1;
do {
if (*piVar8 <= iVar17) {
iVar12 = iVar17 - *piVar8;
if (iVar12 == 0) {
iVar10 = 1;
}
else {
iVar11 = 0x7fffffff;
iVar10 = 0x7fffffff;
piVar19 = param_1;
do {
iVar2 = *piVar19;
if (iVar2 <= iVar12) {
if (iVar12 == iVar2) {
iVar16 = 1;
}
else {
lVar13 = 0;
iVar15 = 0x7fffffff;
iVar16 = 0x7fffffff;
do {
if (param_1[lVar13] <= iVar12 - iVar2) {
if (iVar12 - iVar2 == param_1[lVar13]) {
iVar5 = 1;
}
else {
iVar5 = func0_part_0();
iVar11 = iVar10;
if (iVar5 == 0x7fffffff) goto LAB_00101436;
iVar5 = iVar5 + 1;
}
bVar3 = iVar5 < iVar16;
iVar16 = iVar15;
if (bVar3) {
iVar16 = iVar5;
iVar15 = iVar5;
}
}
LAB_00101436:
lVar13 = lVar13 + 1;
} while ((int)lVar13 < param_2);
if (iVar16 == 0x7fffffff) goto LAB_001013cc;
iVar16 = iVar16 + 1;
}
bVar3 = iVar16 < iVar10;
iVar10 = iVar11;
if (bVar3) {
iVar10 = iVar16;
iVar11 = iVar16;
}
}
LAB_001013cc:
piVar19 = piVar19 + 1;
} while (piVar19 != piVar1);
if (iVar10 == 0x7fffffff) goto LAB_00101370;
iVar10 = iVar10 + 1;
}
if (iVar10 < iVar4) {
iVar4 = iVar10;
}
}
LAB_00101370:
piVar8 = piVar8 + 1;
} while (piVar8 != piVar1);
if (iVar4 == 0x7fffffff) goto LAB_0010130c;
iVar4 = iVar4 + 1;
}
if (iVar4 < iVar6) {
iVar6 = iVar4;
}
}
LAB_0010130c:
piVar9 = piVar9 + 1;
} while (piVar9 != piVar1);
if (iVar6 == 0x7fffffff) goto LAB_001012c2;
iVar6 = iVar6 + 1;
}
if (iVar6 < iVar14) {
iVar14 = iVar6;
}
}
LAB_001012c2:
piVar7 = piVar7 + 1;
} while (piVar7 != piVar1);
}
return iVar14;
} |
6,020 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int compare_chars(const void* a, const void* b) {
char arg1 = *(const char*)a;
char arg2 = *(const char*)b;
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
}
| int func0(char *str1, char *str2) {
int n1 = strlen(str1);
int n2 = strlen(str2);
if (n1 != n2) {
return 0;
}
qsort(str1, n1, sizeof(char), compare_chars);
qsort(str2, n2, sizeof(char), compare_chars);
for (int i = 0; i < n1; i++) {
if (str1[i] != str2[i]) {
return 0;
}
}
return 1;
}
| int main() {
char str1[] = "abc";
char str2[] = "cba";
char str3[] = "test";
char str4[] = "ttew";
char str5[] = "xxyz";
char str6[] = "yxzx";
assert(func0(str1, str2) == 1);
assert(func0(str3, str4) == 0);
assert(func0(str5, str6) == 1);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
je 1258 <func0+0x44>
mov $0x0,%eax
jmpq 12d9 <func0+0xc5>
mov -0x8(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0xa0(%rip),%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x4(%rbp),%eax
movslq %eax,%rsi
mov -0x20(%rbp),%rax
lea -0xbe(%rip),%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
movl $0x0,-0xc(%rbp)
jmp 12cc <func0+0xb8>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xc(%rbp),%eax
movslq %eax,%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 12c8 <func0+0xb4>
mov $0x0,%eax
jmp 12d9 <func0+0xc5>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 129d <func0+0x89>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+var_20]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jz short loc_1258
mov eax, 0
jmp locret_12DF
loc_1258:
mov eax, [rbp+var_8]
movsxd rsi, eax; nmemb
mov rax, [rbp+s]
lea rdx, compare_chars
mov rcx, rdx; compar
mov edx, 1; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_4]
movsxd rsi, eax; nmemb
mov rax, [rbp+var_20]
lea rdx, compare_chars
mov rcx, rdx; compar
mov edx, 1; size
mov rdi, rax; base
call _qsort
mov [rbp+var_C], 0
jmp short loc_12D2
loc_12A3:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_C]
movsxd rcx, eax
mov rax, [rbp+var_20]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_12CE
mov eax, 0
jmp short locret_12DF
loc_12CE:
add [rbp+var_C], 1
loc_12D2:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jl short loc_12A3
mov eax, 1
locret_12DF:
leave
retn | long long func0(char *a1, char *a2)
{
int i; // [rsp+14h] [rbp-Ch]
int v4; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v4 = strlen(a1);
v5 = strlen(a2);
if ( v4 != v5 )
return 0LL;
qsort(a1, v4, 1uLL, compare_chars);
qsort(a2, v5, 1uLL, compare_chars);
for ( i = 0; i < v4; ++i )
{
if ( a1[i] != a2[i] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JZ 0x00101258
MOV EAX,0x0
JMP 0x001012df
LAB_00101258:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012d2
LAB_001012a3:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x001012ce
MOV EAX,0x0
JMP 0x001012df
LAB_001012ce:
ADD dword ptr [RBP + -0xc],0x1
LAB_001012d2:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001012a3
MOV EAX,0x1
LAB_001012df:
LEAVE
RET | int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
int8 uVar3;
int local_14;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
sVar2 = strlen(param_2);
if (iVar1 == (int)sVar2) {
qsort(param_1,(long)iVar1,1,compare_chars);
qsort(param_2,(long)(int)sVar2,1,compare_chars);
for (local_14 = 0; local_14 < iVar1; local_14 = local_14 + 1) {
if (param_1[local_14] != param_2[local_14]) {
return 0;
}
}
uVar3 = 1;
}
else {
uVar3 = 0;
}
return uVar3;
} |
6,021 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int compare_chars(const void* a, const void* b) {
char arg1 = *(const char*)a;
char arg2 = *(const char*)b;
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
}
| int func0(char *str1, char *str2) {
int n1 = strlen(str1);
int n2 = strlen(str2);
if (n1 != n2) {
return 0;
}
qsort(str1, n1, sizeof(char), compare_chars);
qsort(str2, n2, sizeof(char), compare_chars);
for (int i = 0; i < n1; i++) {
if (str1[i] != str2[i]) {
return 0;
}
}
return 1;
}
| int main() {
char str1[] = "abc";
char str2[] = "cba";
char str3[] = "test";
char str4[] = "ttew";
char str5[] = "xxyz";
char str6[] = "yxzx";
assert(func0(str1, str2) == 1);
assert(func0(str3, str4) == 0);
assert(func0(str5, str6) == 1);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r13
mov %rbx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rbx
mov $0x0,%eax
cmp %ebx,%r13d
je 1213 <func0+0x50>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %rsi,%r12
movslq %r13d,%rsi
lea -0x77(%rip),%rcx
mov $0x1,%edx
mov %rbp,%rdi
callq 1090 <qsort@plt>
movslq %ebx,%rsi
lea -0x8e(%rip),%rcx
mov $0x1,%edx
mov %r12,%rdi
callq 1090 <qsort@plt>
test %r13d,%r13d
jle 1272 <func0+0xaf>
lea -0x1(%r13),%ecx
mov $0x0,%eax
jmp 1257 <func0+0x94>
mov %rdx,%rax
movzbl (%r12,%rax,1),%ebx
cmp %bl,0x0(%rbp,%rax,1)
jne 1279 <func0+0xb6>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 1254 <func0+0x91>
mov $0x1,%eax
jmp 1208 <func0+0x45>
mov $0x1,%eax
jmp 1208 <func0+0x45>
mov $0x0,%eax
jmp 1208 <func0+0x45>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
call _strlen
mov r13, rax
mov rdi, rbp
call _strlen
mov r12, rax
mov eax, 0
cmp r13d, r12d
jz short loc_121B
loc_1212:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_121B:
movsxd rsi, r13d
lea r14, compare_chars
mov rcx, r14
mov edx, 1
mov rdi, rbx
call _qsort
movsxd rsi, r12d
mov rcx, r14
mov edx, 1
mov rdi, rbp
call _qsort
test r13d, r13d
jle short loc_1276
lea ecx, [r13-1]
mov eax, 0
jmp short loc_125B
loc_1258:
mov rax, rdx
loc_125B:
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jnz short loc_127D
lea rdx, [rax+1]
cmp rax, rcx
jnz short loc_1258
mov eax, 1
jmp short loc_1212
loc_1276:
mov eax, 1
jmp short loc_1212
loc_127D:
mov eax, 0
jmp short loc_1212 | long long func0(long long a1, long long a2)
{
int v2; // r13d
int v3; // r12d
long long result; // rax
long long i; // rax
v2 = ((long long (*)(void))strlen)();
v3 = strlen(a2);
result = 0LL;
if ( v2 == v3 )
{
qsort(a1, v2, 1LL, compare_chars);
qsort(a2, v3, 1LL, compare_chars);
if ( v2 <= 0 )
{
return 1LL;
}
else
{
for ( i = 0LL; *(_BYTE *)(a1 + i) == *(_BYTE *)(a2 + i); ++i )
{
if ( i == v2 - 1 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RSI
CALL 0x001010b0
MOV R13,RAX
MOV RDI,RBP
CALL 0x001010b0
MOV R12,RAX
MOV EAX,0x0
CMP R13D,R12D
JZ 0x0010121b
LAB_00101212:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010121b:
MOVSXD RSI,R13D
LEA R14,[0x1011c9]
MOV RCX,R14
MOV EDX,0x1
MOV RDI,RBX
CALL 0x001010a0
MOVSXD RSI,R12D
MOV RCX,R14
MOV EDX,0x1
MOV RDI,RBP
CALL 0x001010a0
TEST R13D,R13D
JLE 0x00101276
LEA ECX,[R13 + -0x1]
MOV EAX,0x0
JMP 0x0010125b
LAB_00101258:
MOV RAX,RDX
LAB_0010125b:
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JNZ 0x0010127d
LEA RDX,[RAX + 0x1]
CMP RAX,RCX
JNZ 0x00101258
MOV EAX,0x1
JMP 0x00101212
LAB_00101276:
MOV EAX,0x1
JMP 0x00101212
LAB_0010127d:
MOV EAX,0x0
JMP 0x00101212 | int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
int8 uVar3;
ulong uVar4;
int iVar5;
bool bVar6;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
uVar3 = 0;
iVar5 = (int)sVar1;
if (iVar5 == (int)sVar2) {
qsort(param_1,(long)iVar5,1,compare_chars);
qsort(param_2,(long)(int)sVar2,1,compare_chars);
if (iVar5 < 1) {
uVar3 = 1;
}
else {
uVar4 = 0;
do {
if (param_1[uVar4] != param_2[uVar4]) {
return 0;
}
bVar6 = uVar4 != iVar5 - 1;
uVar4 = uVar4 + 1;
} while (bVar6);
uVar3 = 1;
}
}
return uVar3;
} |
6,022 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int compare_chars(const void* a, const void* b) {
char arg1 = *(const char*)a;
char arg2 = *(const char*)b;
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
}
| int func0(char *str1, char *str2) {
int n1 = strlen(str1);
int n2 = strlen(str2);
if (n1 != n2) {
return 0;
}
qsort(str1, n1, sizeof(char), compare_chars);
qsort(str2, n2, sizeof(char), compare_chars);
for (int i = 0; i < n1; i++) {
if (str1[i] != str2[i]) {
return 0;
}
}
return 1;
}
| int main() {
char str1[] = "abc";
char str2[] = "cba";
char str3[] = "test";
char str4[] = "ttew";
char str5[] = "xxyz";
char str6[] = "yxzx";
assert(func0(str1, str2) == 1);
assert(func0(str3, str4) == 0);
assert(func0(str5, str6) == 1);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10b0 <strlen@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10b0 <strlen@plt>
cmp %eax,%r12d
je 1350 <func0+0x40>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
movslq %r12d,%r13
lea -0x6a(%rip),%rcx
mov $0x1,%edx
mov %rbx,%rdi
mov %r13,%rsi
callq 10a0 <qsort@plt>
mov $0x1,%edx
mov %r13,%rsi
mov %rbp,%rdi
lea -0x8c(%rip),%rcx
callq 10a0 <qsort@plt>
test %r12d,%r12d
jle 13b0 <func0+0xa0>
lea -0x1(%r12),%ecx
xor %eax,%eax
jmp 139c <func0+0x8c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 13b0 <func0+0xa0>
mov %rdx,%rax
movzbl 0x0(%rbp,%rax,1),%esi
cmp %sil,(%rbx,%rax,1)
je 1390 <func0+0x80>
jmp 1339 <func0+0x29>
nopl 0x0(%rax)
add $0x8,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbp
mov r12, rax
call _strlen
cmp r12d, eax
jz short loc_1348
loc_1337:
pop rbx
xor eax, eax
pop rbp
pop r12
pop r13
pop r14
retn
loc_1348:
movsxd r13, r12d
lea r14, compare_chars
mov edx, 1
mov rdi, rbx
mov rcx, r14
mov rsi, r13
call _qsort
mov rcx, r14
mov edx, 1
mov rsi, r13
mov rdi, rbp
call _qsort
test r12d, r12d
jle short loc_13B0
lea ecx, [r12-1]
xor eax, eax
jmp short loc_139C
loc_1390:
lea rdx, [rax+1]
cmp rax, rcx
jz short loc_13B0
mov rax, rdx
loc_139C:
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jz short loc_1390
jmp short loc_1337
loc_13B0:
pop rbx
mov eax, 1
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2)
{
int v2; // r12d
long long i; // rax
v2 = ((long long (*)(void))strlen)();
if ( v2 != (unsigned int)strlen(a2) )
return 0LL;
qsort(a1, v2, 1LL, compare_chars);
qsort(a2, v2, 1LL, compare_chars);
if ( v2 > 0 )
{
for ( i = 0LL; *(_BYTE *)(a1 + i) == *(_BYTE *)(a2 + i); ++i )
{
if ( i == v2 - 1 )
return 1LL;
}
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
CALL 0x001010b0
MOV RDI,RBP
MOV R12,RAX
CALL 0x001010b0
CMP R12D,EAX
JZ 0x00101348
LAB_00101337:
POP RBX
XOR EAX,EAX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101348:
MOVSXD R13,R12D
LEA R14,[0x1012f0]
MOV EDX,0x1
MOV RDI,RBX
MOV RCX,R14
MOV RSI,R13
CALL 0x001010a0
MOV RCX,R14
MOV EDX,0x1
MOV RSI,R13
MOV RDI,RBP
CALL 0x001010a0
TEST R12D,R12D
JLE 0x001013b0
LEA ECX,[R12 + -0x1]
XOR EAX,EAX
JMP 0x0010139c
LAB_00101390:
LEA RDX,[RAX + 0x1]
CMP RAX,RCX
JZ 0x001013b0
MOV RAX,RDX
LAB_0010139c:
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JZ 0x00101390
JMP 0x00101337
LAB_001013b0:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
POP R13
POP R14
RET | int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
bool bVar5;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
iVar4 = (int)sVar1;
if (iVar4 != (int)sVar2) {
return 0;
}
qsort(param_1,(long)iVar4,1,compare_chars);
qsort(param_2,(long)iVar4,1,compare_chars);
if (0 < iVar4) {
uVar3 = 0;
do {
if (param_1[uVar3] != param_2[uVar3]) {
return 0;
}
bVar5 = uVar3 != iVar4 - 1;
uVar3 = uVar3 + 1;
} while (bVar5);
}
return 1;
} |
6,023 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int compare_chars(const void* a, const void* b) {
char arg1 = *(const char*)a;
char arg2 = *(const char*)b;
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
}
| int func0(char *str1, char *str2) {
int n1 = strlen(str1);
int n2 = strlen(str2);
if (n1 != n2) {
return 0;
}
qsort(str1, n1, sizeof(char), compare_chars);
qsort(str2, n2, sizeof(char), compare_chars);
for (int i = 0; i < n1; i++) {
if (str1[i] != str2[i]) {
return 0;
}
}
return 1;
}
| int main() {
char str1[] = "abc";
char str2[] = "cba";
char str3[] = "test";
char str4[] = "ttew";
char str5[] = "xxyz";
char str6[] = "yxzx";
assert(func0(str1, str2) == 1);
assert(func0(str3, str4) == 0);
assert(func0(str5, str6) == 1);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10b0 <strlen@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10b0 <strlen@plt>
cmp %eax,%r12d
je 1350 <func0+0x40>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
movslq %r12d,%r13
lea -0x6a(%rip),%rcx
mov $0x1,%edx
mov %rbx,%rdi
mov %r13,%rsi
callq 10a0 <qsort@plt>
mov $0x1,%edx
mov %r13,%rsi
mov %rbp,%rdi
lea -0x8c(%rip),%rcx
callq 10a0 <qsort@plt>
test %r12d,%r12d
jle 13b0 <func0+0xa0>
lea -0x1(%r12),%ecx
xor %eax,%eax
jmp 139c <func0+0x8c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 13b0 <func0+0xa0>
mov %rdx,%rax
movzbl 0x0(%rbp,%rax,1),%esi
cmp %sil,(%rbx,%rax,1)
je 1390 <func0+0x80>
jmp 1339 <func0+0x29>
nopl 0x0(%rax)
add $0x8,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbp; s
mov r12, rax
call _strlen
cmp r12d, eax
jz short loc_1348
loc_1337:
pop rbx
xor eax, eax
pop rbp
pop r12
pop r13
pop r14
retn
loc_1348:
movsxd r13, r12d
lea r14, compare_chars
mov edx, 1; size
mov rdi, rbx; base
mov rcx, r14; compar
mov rsi, r13; nmemb
call _qsort
mov rcx, r14; compar
mov edx, 1; size
mov rsi, r13; nmemb
mov rdi, rbp; base
call _qsort
test r12d, r12d
jle short loc_13B0
lea ecx, [r12-1]
xor eax, eax
jmp short loc_139C
loc_1390:
lea rdx, [rax+1]
cmp rax, rcx
jz short loc_13B0
mov rax, rdx
loc_139C:
movzx esi, byte ptr [rbp+rax+0]
cmp [rbx+rax], sil
jz short loc_1390
jmp short loc_1337
loc_13B0:
pop rbx
mov eax, 1
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(char *base, char *a2)
{
int v2; // r12d
long long i; // rax
v2 = strlen(base);
if ( v2 != (unsigned int)strlen(a2) )
return 0LL;
qsort(base, v2, 1uLL, compare_chars);
qsort(a2, v2, 1uLL, compare_chars);
if ( v2 > 0 )
{
for ( i = 0LL; base[i] == a2[i]; ++i )
{
if ( i == v2 - 1 )
return 1LL;
}
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
CALL 0x001010b0
MOV RDI,RBP
MOV R12,RAX
CALL 0x001010b0
CMP R12D,EAX
JZ 0x00101348
LAB_00101337:
POP RBX
XOR EAX,EAX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101348:
MOVSXD R13,R12D
LEA R14,[0x1012f0]
MOV EDX,0x1
MOV RDI,RBX
MOV RCX,R14
MOV RSI,R13
CALL 0x001010a0
MOV RCX,R14
MOV EDX,0x1
MOV RSI,R13
MOV RDI,RBP
CALL 0x001010a0
TEST R12D,R12D
JLE 0x001013b0
LEA ECX,[R12 + -0x1]
XOR EAX,EAX
JMP 0x0010139c
LAB_00101390:
LEA RDX,[RAX + 0x1]
CMP RAX,RCX
JZ 0x001013b0
MOV RAX,RDX
LAB_0010139c:
MOVZX ESI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],SIL
JZ 0x00101390
JMP 0x00101337
LAB_001013b0:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
POP R13
POP R14
RET | int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
bool bVar5;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
iVar4 = (int)sVar1;
if (iVar4 != (int)sVar2) {
return 0;
}
qsort(param_1,(long)iVar4,1,compare_chars);
qsort(param_2,(long)iVar4,1,compare_chars);
if (0 < iVar4) {
uVar3 = 0;
do {
if (param_1[uVar3] != param_2[uVar3]) {
return 0;
}
bVar5 = uVar3 != iVar4 - 1;
uVar3 = uVar3 + 1;
} while (bVar5);
}
return 1;
} |
6,024 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum {
INT_TYPE,
FLOAT_TYPE,
STRING_TYPE
} DataType;
typedef struct {
DataType type;
union {
int i;
float f;
char* s;
} data;
} Element;
typedef struct {
Element* elements;
int size;
} ElementArray;
ElementArray remove_datatype(Element* test_tuple, int size, DataType data_type) {
Element* res = malloc(size * sizeof(Element));
int count = 0;
for(int i = 0; i < size; i++) {
if(test_tuple[i].type != data_type){
res[count++] = test_tuple[i];
}
}
ElementArray result;
result.elements = res;
result.size = count;
return result;
}
| int func0(ElementArray a, ElementArray b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.elements[i].type != b.elements[i].type) return 0;
switch(a.elements[i].type){
case INT_TYPE:
if(a.elements[i].data.i != b.elements[i].data.i) return 0;
break;
case FLOAT_TYPE:
if(a.elements[i].data.f != b.elements[i].data.f) return 0;
break;
case STRING_TYPE:
if(strcmp(a.elements[i].data.s, b.elements[i].data.s) != 0) return 0;
break;
}
}
return 1;
}
| int main() {
// Test case 1
Element test1[] = {
{INT_TYPE, .data.i = 4},
{INT_TYPE, .data.i = 5},
{INT_TYPE, .data.i = 4},
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
Element expected1[] = {
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
ElementArray result1 = remove_datatype(test1, 5, INT_TYPE);
ElementArray expectedArray1;
expectedArray1.elements = expected1;
expectedArray1.size = 2;
assert(func0(result1, expectedArray1));
// Test case 2
Element test2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9},
{STRING_TYPE, .data.s = "SR"}
};
Element expected2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9}
};
ElementArray result2 = remove_datatype(test2, 4, STRING_TYPE);
ElementArray expectedArray2;
expectedArray2.elements = expected2;
expectedArray2.size = 3;
assert(func0(result2, expectedArray2));
// Test case 3
Element test3[] = {
{INT_TYPE, .data.i = 7},
{FLOAT_TYPE, .data.f = 1.1},
{INT_TYPE, .data.i = 2},
{FLOAT_TYPE, .data.f = 2.2}
};
Element expected3[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 2}
};
ElementArray result3 = remove_datatype(test3, 4, FLOAT_TYPE);
ElementArray expectedArray3;
expectedArray3.elements = expected3;
expectedArray3.size = 2;
assert(func0(result3, expectedArray3));
// Free allocated memory
free(result1.elements);
free(result2.elements);
free(result3.elements);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rsi,%rax
mov %rdi,%r8
mov %r8,%rsi
mov %r9,%rdi
mov %rax,%rdi
mov %rsi,-0x20(%rbp)
mov %rdi,-0x18(%rbp)
mov %rdx,-0x30(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x18(%rbp),%edx
mov -0x28(%rbp),%eax
cmp %eax,%edx
je 12bd <func0+0x3f>
mov $0x0,%eax
jmpq 1402 <func0+0x184>
movl $0x0,-0x4(%rbp)
jmpq 13f1 <func0+0x173>
mov -0x20(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x30(%rbp),%rax
mov -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl $0x4,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 12fd <func0+0x7f>
mov $0x0,%eax
jmpq 1402 <func0+0x184>
mov -0x20(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp $0x2,%eax
je 13a9 <func0+0x12b>
cmp $0x2,%eax
ja 13ed <func0+0x16f>
test %eax,%eax
je 1330 <func0+0xb2>
cmp $0x1,%eax
je 136a <func0+0xec>
jmpq 13ed <func0+0x16f>
mov -0x20(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
mov 0x8(%rax),%edx
mov -0x30(%rbp),%rax
mov -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl $0x4,%rcx
add %rcx,%rax
mov 0x8(%rax),%eax
cmp %eax,%edx
je 13e9 <func0+0x16b>
mov $0x0,%eax
jmpq 1402 <func0+0x184>
mov -0x20(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
movss 0x8(%rax),%xmm0
mov -0x30(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
movss 0x8(%rax),%xmm1
ucomiss %xmm1,%xmm0
jp 13a2 <func0+0x124>
ucomiss %xmm1,%xmm0
jne 13a2 <func0+0x124>
jmp 13ed <func0+0x16f>
mov $0x0,%eax
jmp 1402 <func0+0x184>
mov -0x30(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
add %rdx,%rax
mov 0x8(%rax),%rdx
mov -0x20(%rbp),%rax
mov -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl $0x4,%rcx
add %rcx,%rax
mov 0x8(%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
je 13ec <func0+0x16e>
mov $0x0,%eax
jmp 1402 <func0+0x184>
jmp 13ed <func0+0x16f>
addl $0x1,-0x4(%rbp)
mov -0x18(%rbp),%eax
cmp %eax,-0x4(%rbp)
jl 12c9 <func0+0x4b>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, rdi
mov r8, rsi
mov rsi, rax
mov rdi, rdx
mov rdi, r8
mov [rbp+var_20], rsi
mov [rbp+var_18], rdi
mov [rbp+var_30], rdx
mov [rbp+var_28], rcx
mov edx, dword ptr [rbp+var_18]
mov eax, dword ptr [rbp+var_28]
cmp edx, eax
jz short loc_12BD
mov eax, 0
jmp locret_1403
loc_12BD:
mov [rbp+var_4], 0
jmp loc_13F2
loc_12C9:
mov rax, [rbp+var_20]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_30]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_12FD
mov eax, 0
jmp locret_1403
loc_12FD:
mov rax, [rbp+var_20]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov eax, [rax]
cmp eax, 2
jz loc_13A7
cmp eax, 2
ja loc_13EE
test eax, eax
jz short loc_1330
cmp eax, 1
jz short loc_136A
jmp loc_13EE
loc_1330:
mov rax, [rbp+var_20]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov edx, [rax+8]
mov rax, [rbp+var_30]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax+8]
cmp edx, eax
jz loc_13E7
mov eax, 0
jmp locret_1403
loc_136A:
mov rax, [rbp+var_20]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
movss xmm0, dword ptr [rax+8]
mov rax, [rbp+var_30]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
movss xmm1, dword ptr [rax+8]
ucomiss xmm0, xmm1
jp short loc_13A0
ucomiss xmm0, xmm1
jz short loc_13EA
loc_13A0:
mov eax, 0
jmp short locret_1403
loc_13A7:
mov rax, [rbp+var_30]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov rdx, [rax+8]
mov rax, [rbp+var_20]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_13ED
mov eax, 0
jmp short locret_1403
loc_13E7:
nop
jmp short loc_13EE
loc_13EA:
nop
jmp short loc_13EE
loc_13ED:
nop
loc_13EE:
add [rbp+var_4], 1
loc_13F2:
mov eax, dword ptr [rbp+var_18]
cmp [rbp+var_4], eax
jl loc_12C9
mov eax, 1
locret_1403:
leave
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
unsigned int v5; // eax
int i; // [rsp+2Ch] [rbp-4h]
if ( a2 != a4 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(16LL * i + a1) != *(_DWORD *)(16LL * i + a3) )
return 0LL;
v5 = *(_DWORD *)(16LL * i + a1);
if ( v5 == 2 )
{
if ( strcmp(*(const char **)(16LL * i + a1 + 8), *(const char **)(16LL * i + a3 + 8)) )
return 0LL;
}
else if ( v5 <= 2 )
{
if ( v5 )
{
if ( *(float *)(16LL * i + a1 + 8) != *(float *)(16LL * i + a3 + 8) )
return 0LL;
}
else if ( *(_DWORD *)(16LL * i + a1 + 8) != *(_DWORD *)(16LL * i + a3 + 8) )
{
return 0LL;
}
}
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,RDI
MOV R8,RSI
MOV RSI,RAX
MOV RDI,RDX
MOV RDI,R8
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x30],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x28]
CMP EDX,EAX
JZ 0x001012bd
MOV EAX,0x0
JMP 0x00101403
LAB_001012bd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001013f2
LAB_001012c9:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001012fd
MOV EAX,0x0
JMP 0x00101403
LAB_001012fd:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0x2
JZ 0x001013a7
CMP EAX,0x2
JA 0x001013ee
TEST EAX,EAX
JZ 0x00101330
CMP EAX,0x1
JZ 0x0010136a
JMP 0x001013ee
LAB_00101330:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
CMP EDX,EAX
JZ 0x001013e7
MOV EAX,0x0
JMP 0x00101403
LAB_0010136a:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOVSS XMM1,dword ptr [RAX + 0x8]
UCOMISS XMM0,XMM1
JP 0x001013a0
UCOMISS XMM0,XMM1
JZ 0x001013ea
LAB_001013a0:
MOV EAX,0x0
JMP 0x00101403
LAB_001013a7:
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010c0
TEST EAX,EAX
JZ 0x001013ed
MOV EAX,0x0
JMP 0x00101403
LAB_001013e7:
NOP
JMP 0x001013ee
LAB_001013ea:
NOP
JMP 0x001013ee
LAB_001013ed:
NOP
LAB_001013ee:
ADD dword ptr [RBP + -0x4],0x1
LAB_001013f2:
MOV EAX,dword ptr [RBP + -0x18]
CMP dword ptr [RBP + -0x4],EAX
JL 0x001012c9
MOV EAX,0x1
LAB_00101403:
LEAVE
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
uint uVar1;
int iVar2;
int8 uVar3;
int local_c;
if (param_2 == param_4) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 0x10) != *(int *)(param_3 + (long)local_c * 0x10)) {
return 0;
}
uVar1 = *(uint *)(param_1 + (long)local_c * 0x10);
if (uVar1 == 2) {
iVar2 = strcmp(*(char **)(param_1 + (long)local_c * 0x10 + 8),
*(char **)(param_3 + (long)local_c * 0x10 + 8));
if (iVar2 != 0) {
return 0;
}
}
else if (uVar1 < 3) {
if (uVar1 == 0) {
if (*(int *)(param_1 + (long)local_c * 0x10 + 8) !=
*(int *)(param_3 + (long)local_c * 0x10 + 8)) {
return 0;
}
}
else if ((uVar1 == 1) &&
(*(float *)(param_1 + (long)local_c * 0x10 + 8) !=
*(float *)(param_3 + (long)local_c * 0x10 + 8))) {
return 0;
}
}
}
uVar3 = 1;
}
else {
uVar3 = 0;
}
return uVar3;
} |
6,025 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum {
INT_TYPE,
FLOAT_TYPE,
STRING_TYPE
} DataType;
typedef struct {
DataType type;
union {
int i;
float f;
char* s;
} data;
} Element;
typedef struct {
Element* elements;
int size;
} ElementArray;
ElementArray remove_datatype(Element* test_tuple, int size, DataType data_type) {
Element* res = malloc(size * sizeof(Element));
int count = 0;
for(int i = 0; i < size; i++) {
if(test_tuple[i].type != data_type){
res[count++] = test_tuple[i];
}
}
ElementArray result;
result.elements = res;
result.size = count;
return result;
}
| int func0(ElementArray a, ElementArray b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.elements[i].type != b.elements[i].type) return 0;
switch(a.elements[i].type){
case INT_TYPE:
if(a.elements[i].data.i != b.elements[i].data.i) return 0;
break;
case FLOAT_TYPE:
if(a.elements[i].data.f != b.elements[i].data.f) return 0;
break;
case STRING_TYPE:
if(strcmp(a.elements[i].data.s, b.elements[i].data.s) != 0) return 0;
break;
}
}
return 1;
}
| int main() {
// Test case 1
Element test1[] = {
{INT_TYPE, .data.i = 4},
{INT_TYPE, .data.i = 5},
{INT_TYPE, .data.i = 4},
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
Element expected1[] = {
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
ElementArray result1 = remove_datatype(test1, 5, INT_TYPE);
ElementArray expectedArray1;
expectedArray1.elements = expected1;
expectedArray1.size = 2;
assert(func0(result1, expectedArray1));
// Test case 2
Element test2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9},
{STRING_TYPE, .data.s = "SR"}
};
Element expected2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9}
};
ElementArray result2 = remove_datatype(test2, 4, STRING_TYPE);
ElementArray expectedArray2;
expectedArray2.elements = expected2;
expectedArray2.size = 3;
assert(func0(result2, expectedArray2));
// Test case 3
Element test3[] = {
{INT_TYPE, .data.i = 7},
{FLOAT_TYPE, .data.f = 1.1},
{INT_TYPE, .data.i = 2},
{FLOAT_TYPE, .data.f = 2.2}
};
Element expected3[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 2}
};
ElementArray result3 = remove_datatype(test3, 4, FLOAT_TYPE);
ElementArray expectedArray3;
expectedArray3.elements = expected3;
expectedArray3.size = 2;
assert(func0(result3, expectedArray3));
// Free allocated memory
free(result1.elements);
free(result2.elements);
free(result3.elements);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%esi
jne 12cc <func0+0xa1>
test %esi,%esi
jle 12b5 <func0+0x8a>
push %r12
push %rbp
push %rbx
lea 0x8(%rdi),%rbx
lea 0x8(%rdx),%rbp
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x18(%rdi,%rax,1),%r12
jmp 1273 <func0+0x48>
movss (%rbx),%xmm0
ucomiss 0x0(%rbp),%xmm0
jp 12c5 <func0+0x9a>
jne 12c5 <func0+0x9a>
add $0x10,%rbx
add $0x10,%rbp
cmp %r12,%rbx
je 12ae <func0+0x83>
mov -0x8(%rbx),%eax
cmp -0x8(%rbp),%eax
jne 12bb <func0+0x90>
cmp $0x1,%eax
je 125a <func0+0x2f>
cmp $0x2,%eax
je 1297 <func0+0x6c>
test %eax,%eax
jne 1266 <func0+0x3b>
mov 0x0(%rbp),%eax
cmp %eax,(%rbx)
je 1266 <func0+0x3b>
mov $0x0,%eax
jmp 12c0 <func0+0x95>
mov 0x0(%rbp),%rsi
mov (%rbx),%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
je 1266 <func0+0x3b>
mov $0x0,%eax
jmp 12c0 <func0+0x95>
mov $0x1,%eax
jmp 12c0 <func0+0x95>
mov $0x1,%eax
retq
mov $0x0,%eax
pop %rbx
pop %rbp
pop %r12
retq
mov $0x0,%eax
jmp 12c0 <func0+0x95>
retq
| func0:
endbr64
mov eax, 0
cmp esi, ecx
jnz locret_12CC
test esi, esi
jle short loc_12B5
push r12
push rbp
push rbx
lea rbx, [rdi+8]
lea rbp, [rdx+8]
lea eax, [rsi-1]
shl rax, 4
lea r12, [rdi+rax+18h]
jmp short loc_1273
loc_125A:
movss xmm0, dword ptr [rbx]
ucomiss xmm0, dword ptr [rbp+0]
jp short loc_12C5
jnz short loc_12C5
loc_1266:
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jz short loc_12AE
loc_1273:
mov eax, [rbx-8]
cmp eax, [rbp-8]
jnz short loc_12BB
cmp eax, 1
jz short loc_125A
cmp eax, 2
jz short loc_1297
test eax, eax
jnz short loc_1266
mov eax, [rbp+0]
cmp [rbx], eax
jz short loc_1266
mov eax, 0
jmp short loc_12C0
loc_1297:
mov rsi, [rbp+0]
mov rdi, [rbx]
call _strcmp
test eax, eax
jz short loc_1266
mov eax, 0
jmp short loc_12C0
loc_12AE:
mov eax, 1
jmp short loc_12C0
loc_12B5:
mov eax, 1
retn
loc_12BB:
mov eax, 0
loc_12C0:
pop rbx
pop rbp
pop r12
retn
loc_12C5:
mov eax, 0
jmp short loc_12C0
locret_12CC:
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
_QWORD *v5; // rbx
_QWORD *i; // rbp
int v7; // eax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
return 1LL;
v5 = (_QWORD *)(a1 + 8);
for ( i = (_QWORD *)(a3 + 8); ; i += 2 )
{
v7 = *((_DWORD *)v5 - 2);
if ( v7 != *((_DWORD *)i - 2) )
return 0LL;
if ( v7 == 1 )
{
if ( *(float *)v5 != *(float *)i )
return 0LL;
}
else if ( v7 == 2 )
{
if ( (unsigned int)strcmp(*v5, *i) )
return 0LL;
}
else if ( !v7 && *(_DWORD *)v5 != *(_DWORD *)i )
{
return 0LL;
}
v5 += 2;
if ( v5 == (_QWORD *)(a1 + 16LL * (unsigned int)(a2 - 1) + 24) )
return 1LL;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,ECX
JNZ 0x001012cc
TEST ESI,ESI
JLE 0x001012b5
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[RDI + 0x8]
LEA RBP,[RDX + 0x8]
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA R12,[RDI + RAX*0x1 + 0x18]
JMP 0x00101273
LAB_0010125a:
MOVSS XMM0,dword ptr [RBX]
UCOMISS XMM0,dword ptr [RBP]
JP 0x001012c5
JNZ 0x001012c5
LAB_00101266:
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JZ 0x001012ae
LAB_00101273:
MOV EAX,dword ptr [RBX + -0x8]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x001012bb
CMP EAX,0x1
JZ 0x0010125a
CMP EAX,0x2
JZ 0x00101297
TEST EAX,EAX
JNZ 0x00101266
MOV EAX,dword ptr [RBP]
CMP dword ptr [RBX],EAX
JZ 0x00101266
MOV EAX,0x0
JMP 0x001012c0
LAB_00101297:
MOV RSI,qword ptr [RBP]
MOV RDI,qword ptr [RBX]
CALL 0x001010c0
TEST EAX,EAX
JZ 0x00101266
MOV EAX,0x0
JMP 0x001012c0
LAB_001012ae:
MOV EAX,0x1
JMP 0x001012c0
LAB_001012b5:
MOV EAX,0x1
RET
LAB_001012bb:
MOV EAX,0x0
LAB_001012c0:
POP RBX
POP RBP
POP R12
RET
LAB_001012c5:
MOV EAX,0x0
JMP 0x001012c0
LAB_001012cc:
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
float fVar1;
int iVar2;
float *pfVar3;
float *pfVar4;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
pfVar3 = (float *)(param_1 + 8);
pfVar4 = (float *)(param_3 + 8);
do {
fVar1 = pfVar3[-2];
if (fVar1 != pfVar4[-2]) {
return 0;
}
if (fVar1 == 1.4013e-45) {
if (*pfVar3 != *pfVar4) {
return 0;
}
}
else if (fVar1 == 2.8026e-45) {
iVar2 = strcmp(*(char **)pfVar3,*(char **)pfVar4);
if (iVar2 != 0) {
return 0;
}
}
else if ((fVar1 == 0.0) && (*pfVar3 != *pfVar4)) {
return 0;
}
pfVar3 = pfVar3 + 4;
pfVar4 = pfVar4 + 4;
if (pfVar3 == (float *)(param_1 + 0x18 + (ulong)(param_2 - 1) * 0x10)) {
return 1;
}
} while( true );
}
return 1;
} |
6,026 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum {
INT_TYPE,
FLOAT_TYPE,
STRING_TYPE
} DataType;
typedef struct {
DataType type;
union {
int i;
float f;
char* s;
} data;
} Element;
typedef struct {
Element* elements;
int size;
} ElementArray;
ElementArray remove_datatype(Element* test_tuple, int size, DataType data_type) {
Element* res = malloc(size * sizeof(Element));
int count = 0;
for(int i = 0; i < size; i++) {
if(test_tuple[i].type != data_type){
res[count++] = test_tuple[i];
}
}
ElementArray result;
result.elements = res;
result.size = count;
return result;
}
| int func0(ElementArray a, ElementArray b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.elements[i].type != b.elements[i].type) return 0;
switch(a.elements[i].type){
case INT_TYPE:
if(a.elements[i].data.i != b.elements[i].data.i) return 0;
break;
case FLOAT_TYPE:
if(a.elements[i].data.f != b.elements[i].data.f) return 0;
break;
case STRING_TYPE:
if(strcmp(a.elements[i].data.s, b.elements[i].data.s) != 0) return 0;
break;
}
}
return 1;
}
| int main() {
// Test case 1
Element test1[] = {
{INT_TYPE, .data.i = 4},
{INT_TYPE, .data.i = 5},
{INT_TYPE, .data.i = 4},
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
Element expected1[] = {
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
ElementArray result1 = remove_datatype(test1, 5, INT_TYPE);
ElementArray expectedArray1;
expectedArray1.elements = expected1;
expectedArray1.size = 2;
assert(func0(result1, expectedArray1));
// Test case 2
Element test2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9},
{STRING_TYPE, .data.s = "SR"}
};
Element expected2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9}
};
ElementArray result2 = remove_datatype(test2, 4, STRING_TYPE);
ElementArray expectedArray2;
expectedArray2.elements = expected2;
expectedArray2.size = 3;
assert(func0(result2, expectedArray2));
// Test case 3
Element test3[] = {
{INT_TYPE, .data.i = 7},
{FLOAT_TYPE, .data.f = 1.1},
{INT_TYPE, .data.i = 2},
{FLOAT_TYPE, .data.f = 2.2}
};
Element expected3[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 2}
};
ElementArray result3 = remove_datatype(test3, 4, FLOAT_TYPE);
ElementArray expectedArray3;
expectedArray3.elements = expected3;
expectedArray3.size = 2;
assert(func0(result3, expectedArray3));
// Free allocated memory
free(result1.elements);
free(result2.elements);
free(result3.elements);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
je 1560 <func0+0x10>
retq
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 15f9 <func0+0xa9>
lea -0x1(%rsi),%eax
push %r12
shl $0x4,%rax
push %rbp
lea 0x8(%rdx),%rbp
push %rbx
lea 0x18(%rdi,%rax,1),%r12
lea 0x8(%rdi),%rbx
jmp 1599 <func0+0x49>
nopw 0x0(%rax,%rax,1)
test %eax,%eax
je 15f0 <func0+0xa0>
add $0x10,%rbx
add $0x10,%rbp
cmp %r12,%rbx
je 15e1 <func0+0x91>
mov -0x8(%rbx),%eax
cmp -0x8(%rbp),%eax
jne 15bb <func0+0x6b>
cmp $0x1,%eax
je 15c8 <func0+0x78>
cmp $0x2,%eax
jne 1588 <func0+0x38>
mov 0x0(%rbp),%rsi
mov (%rbx),%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
je 158c <func0+0x3c>
pop %rbx
xor %eax,%eax
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
movss (%rbx),%xmm0
ucomiss 0x0(%rbp),%xmm0
jp 15bb <func0+0x6b>
jne 15bb <func0+0x6b>
add $0x10,%rbx
add $0x10,%rbp
cmp %r12,%rbx
jne 1599 <func0+0x49>
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%eax
cmp %eax,(%rbx)
je 158c <func0+0x3c>
jmp 15bb <func0+0x6b>
mov $0x1,%eax
retq
| func0:
endbr64
xor eax, eax
cmp esi, ecx
jz short loc_1550
retn
loc_1550:
test esi, esi
jle loc_15E9
lea eax, [rsi-1]
push r12
shl rax, 4
push rbp
lea rbp, [rdx+8]
push rbx
lea r12, [rdi+rax+18h]
lea rbx, [rdi+8]
jmp short loc_1589
loc_1578:
test eax, eax
jz short loc_15E0
loc_157C:
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jz short loc_15D1
loc_1589:
mov eax, [rbx-8]
cmp eax, [rbp-8]
jnz short loc_15AB
cmp eax, 1
jz short loc_15B8
cmp eax, 2
jnz short loc_1578
mov rsi, [rbp+0]
mov rdi, [rbx]
call _strcmp
test eax, eax
jz short loc_157C
loc_15AB:
pop rbx
xor eax, eax
pop rbp
pop r12
retn
loc_15B8:
movss xmm0, dword ptr [rbx]
ucomiss xmm0, dword ptr [rbp+0]
jp short loc_15AB
jnz short loc_15AB
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jnz short loc_1589
loc_15D1:
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_15E0:
mov eax, [rbp+0]
cmp [rbx], eax
jz short loc_157C
jmp short loc_15AB
loc_15E9:
mov eax, 1
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
_QWORD *v5; // rbp
long long v6; // r12
_QWORD *v7; // rbx
int v8; // eax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (_QWORD *)(a3 + 8);
v6 = a1 + 16LL * (unsigned int)(a2 - 1) + 24;
v7 = (_QWORD *)(a1 + 8);
do
{
while ( 1 )
{
v8 = *((_DWORD *)v7 - 2);
if ( v8 != *((_DWORD *)v5 - 2) )
return 0LL;
if ( v8 == 1 )
break;
if ( v8 == 2 )
{
if ( (unsigned int)strcmp(*v7, *v5) )
return 0LL;
}
else if ( !v8 && *(_DWORD *)v7 != *(_DWORD *)v5 )
{
return 0LL;
}
v7 += 2;
v5 += 2;
if ( v7 == (_QWORD *)v6 )
return 1LL;
}
if ( *(float *)v7 != *(float *)v5 )
return 0LL;
v7 += 2;
v5 += 2;
}
while ( v7 != (_QWORD *)v6 );
return 1LL;
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP ESI,ECX
JZ 0x00101550
RET
LAB_00101550:
TEST ESI,ESI
JLE 0x001015e9
LEA EAX,[RSI + -0x1]
PUSH R12
SHL RAX,0x4
PUSH RBP
LEA RBP,[RDX + 0x8]
PUSH RBX
LEA R12,[RDI + RAX*0x1 + 0x18]
LEA RBX,[RDI + 0x8]
JMP 0x00101589
LAB_00101578:
TEST EAX,EAX
JZ 0x001015e0
LAB_0010157c:
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JZ 0x001015d1
LAB_00101589:
MOV EAX,dword ptr [RBX + -0x8]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x001015ab
CMP EAX,0x1
JZ 0x001015b8
CMP EAX,0x2
JNZ 0x00101578
MOV RSI,qword ptr [RBP]
MOV RDI,qword ptr [RBX]
CALL 0x001010c0
TEST EAX,EAX
JZ 0x0010157c
LAB_001015ab:
POP RBX
XOR EAX,EAX
POP RBP
POP R12
RET
LAB_001015b8:
MOVSS XMM0,dword ptr [RBX]
UCOMISS XMM0,dword ptr [RBP]
JP 0x001015ab
JNZ 0x001015ab
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JNZ 0x00101589
LAB_001015d1:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_001015e0:
MOV EAX,dword ptr [RBP]
CMP dword ptr [RBX],EAX
JZ 0x0010157c
JMP 0x001015ab
LAB_001015e9:
MOV EAX,0x1
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
float fVar1;
int iVar2;
float *pfVar3;
float *pfVar4;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
pfVar4 = (float *)(param_3 + 8);
pfVar3 = (float *)(param_1 + 8);
do {
fVar1 = pfVar3[-2];
if (fVar1 != pfVar4[-2]) {
return 0;
}
if (fVar1 == 1.4013e-45) {
if (*pfVar3 != *pfVar4) {
return 0;
}
}
else if (fVar1 == 2.8026e-45) {
iVar2 = strcmp(*(char **)pfVar3,*(char **)pfVar4);
if (iVar2 != 0) {
return 0;
}
}
else if ((fVar1 == 0.0) && (*pfVar3 != *pfVar4)) {
return 0;
}
pfVar4 = pfVar4 + 4;
pfVar3 = pfVar3 + 4;
if (pfVar3 == (float *)(param_1 + 0x18 + (ulong)(param_2 - 1) * 0x10)) {
return 1;
}
} while( true );
}
return 1;
} |
6,027 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum {
INT_TYPE,
FLOAT_TYPE,
STRING_TYPE
} DataType;
typedef struct {
DataType type;
union {
int i;
float f;
char* s;
} data;
} Element;
typedef struct {
Element* elements;
int size;
} ElementArray;
ElementArray remove_datatype(Element* test_tuple, int size, DataType data_type) {
Element* res = malloc(size * sizeof(Element));
int count = 0;
for(int i = 0; i < size; i++) {
if(test_tuple[i].type != data_type){
res[count++] = test_tuple[i];
}
}
ElementArray result;
result.elements = res;
result.size = count;
return result;
}
| int func0(ElementArray a, ElementArray b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.elements[i].type != b.elements[i].type) return 0;
switch(a.elements[i].type){
case INT_TYPE:
if(a.elements[i].data.i != b.elements[i].data.i) return 0;
break;
case FLOAT_TYPE:
if(a.elements[i].data.f != b.elements[i].data.f) return 0;
break;
case STRING_TYPE:
if(strcmp(a.elements[i].data.s, b.elements[i].data.s) != 0) return 0;
break;
}
}
return 1;
}
| int main() {
// Test case 1
Element test1[] = {
{INT_TYPE, .data.i = 4},
{INT_TYPE, .data.i = 5},
{INT_TYPE, .data.i = 4},
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
Element expected1[] = {
{FLOAT_TYPE, .data.f = 7.7},
{FLOAT_TYPE, .data.f = 1.2}
};
ElementArray result1 = remove_datatype(test1, 5, INT_TYPE);
ElementArray expectedArray1;
expectedArray1.elements = expected1;
expectedArray1.size = 2;
assert(func0(result1, expectedArray1));
// Test case 2
Element test2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9},
{STRING_TYPE, .data.s = "SR"}
};
Element expected2[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 8},
{INT_TYPE, .data.i = 9}
};
ElementArray result2 = remove_datatype(test2, 4, STRING_TYPE);
ElementArray expectedArray2;
expectedArray2.elements = expected2;
expectedArray2.size = 3;
assert(func0(result2, expectedArray2));
// Test case 3
Element test3[] = {
{INT_TYPE, .data.i = 7},
{FLOAT_TYPE, .data.f = 1.1},
{INT_TYPE, .data.i = 2},
{FLOAT_TYPE, .data.f = 2.2}
};
Element expected3[] = {
{INT_TYPE, .data.i = 7},
{INT_TYPE, .data.i = 2}
};
ElementArray result3 = remove_datatype(test3, 4, FLOAT_TYPE);
ElementArray expectedArray3;
expectedArray3.elements = expected3;
expectedArray3.size = 2;
assert(func0(result3, expectedArray3));
// Free allocated memory
free(result1.elements);
free(result2.elements);
free(result3.elements);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
je 1560 <func0+0x10>
retq
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 15f9 <func0+0xa9>
lea -0x1(%rsi),%eax
push %r12
shl $0x4,%rax
push %rbp
lea 0x8(%rdx),%rbp
push %rbx
lea 0x18(%rdi,%rax,1),%r12
lea 0x8(%rdi),%rbx
jmp 1599 <func0+0x49>
nopw 0x0(%rax,%rax,1)
test %eax,%eax
je 15f0 <func0+0xa0>
add $0x10,%rbx
add $0x10,%rbp
cmp %r12,%rbx
je 15e1 <func0+0x91>
mov -0x8(%rbx),%eax
cmp -0x8(%rbp),%eax
jne 15bb <func0+0x6b>
cmp $0x1,%eax
je 15c8 <func0+0x78>
cmp $0x2,%eax
jne 1588 <func0+0x38>
mov 0x0(%rbp),%rsi
mov (%rbx),%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
je 158c <func0+0x3c>
pop %rbx
xor %eax,%eax
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
movss (%rbx),%xmm0
ucomiss 0x0(%rbp),%xmm0
jp 15bb <func0+0x6b>
jne 15bb <func0+0x6b>
add $0x10,%rbx
add $0x10,%rbp
cmp %r12,%rbx
jne 1599 <func0+0x49>
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%eax
cmp %eax,(%rbx)
je 158c <func0+0x3c>
jmp 15bb <func0+0x6b>
mov $0x1,%eax
retq
| func0:
endbr64
xor eax, eax
cmp esi, ecx
jz short loc_1560
retn
loc_1560:
test esi, esi
jle loc_15EC
movsxd rsi, esi
push r12
shl rsi, 4
push rbp
lea rbp, [rdx+8]
push rbx
lea r12, [rsi+rdi]
mov rbx, rdi
jmp short loc_1599
loc_1580:
test eax, eax
jnz short loc_158C
mov eax, [rbp+0]
cmp [rbx+8], eax
jnz short loc_15BB
loc_158C:
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jz short loc_15E2
loc_1599:
mov eax, [rbx]
cmp eax, [rbp-8]
jnz short loc_15BB
cmp eax, 1
jz short loc_15C8
cmp eax, 2
jnz short loc_1580
mov rsi, [rbp+0]; s2
mov rdi, [rbx+8]; s1
call _strcmp
test eax, eax
jz short loc_158C
loc_15BB:
pop rbx
xor eax, eax
pop rbp
pop r12
retn
loc_15C8:
movss xmm0, dword ptr [rbx+8]
ucomiss xmm0, dword ptr [rbp+0]
jp short loc_15BB
jnz short loc_15BB
add rbx, 10h
add rbp, 10h
cmp rbx, r12
jnz short loc_1599
loc_15E2:
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_15EC:
mov eax, 1
retn | long long func0(const char **a1, int a2, long long a3, int a4)
{
long long result; // rax
const char **v5; // rbp
int *v6; // r12
const char **v7; // rbx
int v8; // eax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (const char **)(a3 + 8);
v6 = (int *)&a1[2 * a2];
v7 = a1;
do
{
while ( 1 )
{
v8 = *(_DWORD *)v7;
if ( *(_DWORD *)v7 != *((_DWORD *)v5 - 2) )
return 0LL;
if ( v8 == 1 )
break;
if ( v8 == 2 )
{
if ( strcmp(v7[1], *v5) )
return 0LL;
}
else if ( !v8 && *((_DWORD *)v7 + 2) != *(_DWORD *)v5 )
{
return 0LL;
}
v7 += 2;
v5 += 2;
if ( v7 == (const char **)v6 )
return 1LL;
}
if ( *((float *)v7 + 2) != *(float *)v5 )
return 0LL;
v7 += 2;
v5 += 2;
}
while ( v7 != (const char **)v6 );
return 1LL;
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP ESI,ECX
JZ 0x00101560
RET
LAB_00101560:
TEST ESI,ESI
JLE 0x001015ec
MOVSXD RSI,ESI
PUSH R12
SHL RSI,0x4
PUSH RBP
LEA RBP,[RDX + 0x8]
PUSH RBX
LEA R12,[RSI + RDI*0x1]
MOV RBX,RDI
JMP 0x00101599
LAB_00101580:
TEST EAX,EAX
JNZ 0x0010158c
MOV EAX,dword ptr [RBP]
CMP dword ptr [RBX + 0x8],EAX
JNZ 0x001015bb
LAB_0010158c:
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JZ 0x001015e2
LAB_00101599:
MOV EAX,dword ptr [RBX]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x001015bb
CMP EAX,0x1
JZ 0x001015c8
CMP EAX,0x2
JNZ 0x00101580
MOV RSI,qword ptr [RBP]
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x001010c0
TEST EAX,EAX
JZ 0x0010158c
LAB_001015bb:
POP RBX
XOR EAX,EAX
POP RBP
POP R12
RET
LAB_001015c8:
MOVSS XMM0,dword ptr [RBX + 0x8]
UCOMISS XMM0,dword ptr [RBP]
JP 0x001015bb
JNZ 0x001015bb
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JNZ 0x00101599
LAB_001015e2:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_001015ec:
MOV EAX,0x1
RET | int8 func0(float *param_1,int param_2,long param_3,int param_4)
{
float *pfVar1;
float fVar2;
int iVar3;
float *pfVar4;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
pfVar4 = (float *)(param_3 + 8);
pfVar1 = param_1 + (long)param_2 * 4;
do {
fVar2 = *param_1;
if (fVar2 != pfVar4[-2]) {
return 0;
}
if (fVar2 == 1.4013e-45) {
if (param_1[2] != *pfVar4) {
return 0;
}
}
else if (fVar2 == 2.8026e-45) {
iVar3 = strcmp(*(char **)(param_1 + 2),*(char **)pfVar4);
if (iVar3 != 0) {
return 0;
}
}
else if ((fVar2 == 0.0) && (param_1[2] != *pfVar4)) {
return 0;
}
pfVar4 = pfVar4 + 4;
param_1 = param_1 + 4;
if (param_1 == pfVar1) {
return 1;
}
} while( true );
}
return 1;
} |
6,028 | func0 |
#include <regex.h>
#include <stdio.h>
#include <assert.h>
| int func0(const char *pattern, const char *text, int *start, int *end) {
regex_t regex;
regmatch_t match;
int status;
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return -1; // Compilation error
}
status = regexec(®ex, text, 1, &match, 0);
regfree(®ex);
if (status != 0) {
return -1; // Match error
}
*start = match.rm_so;
*end = match.rm_eo;
return 0;
}
| int main() {
int start, end;
assert(func0("python", "python programming language", &start, &end) == 0 && start == 0 && end == 6);
assert(func0("programming", "python programming language", &start, &end) == 0 && start == 7 && end == 18);
assert(func0("language", "python programming language", &start, &end) == 0 && start == 19 && end == 27);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %rdx,-0x78(%rbp)
mov %rcx,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x68(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
je 1217 <func0+0x4e>
mov $0xffffffff,%eax
jmp 126c <func0+0xa3>
lea -0x58(%rbp),%rdx
mov -0x70(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x5c(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1090 <regfree@plt>
cmpl $0x0,-0x5c(%rbp)
je 1255 <func0+0x8c>
mov $0xffffffff,%eax
jmp 126c <func0+0xa3>
mov -0x58(%rbp),%edx
mov -0x78(%rbp),%rax
mov %edx,(%rax)
mov -0x54(%rbp),%edx
mov -0x80(%rbp),%rax
mov %edx,(%rax)
mov $0x0,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1280 <func0+0xb7>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+pattern], rdi
mov [rbp+string], rsi
mov [rbp+var_78], rdx
mov [rbp+var_80], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
test eax, eax
jz short loc_1217
mov eax, 0FFFFFFFFh
jmp short loc_126C
loc_1217:
lea rdx, [rbp+pmatch]
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 1; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_5C], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_5C], 0
jz short loc_1255
mov eax, 0FFFFFFFFh
jmp short loc_126C
loc_1255:
mov edx, [rbp+pmatch.rm_so]
mov rax, [rbp+var_78]
mov [rax], edx
mov edx, [rbp+pmatch.rm_eo]
mov rax, [rbp+var_80]
mov [rax], edx
mov eax, 0
loc_126C:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1280
call ___stack_chk_fail
locret_1280:
leave
retn | long long func0(const char *a1, const char *a2, regoff_t *a3, regoff_t *a4)
{
int v7; // [rsp+24h] [rbp-5Ch]
regmatch_t pmatch; // [rsp+28h] [rbp-58h] BYREF
regex_t preg; // [rsp+30h] [rbp-50h] BYREF
unsigned long long v10; // [rsp+78h] [rbp-8h]
v10 = __readfsqword(0x28u);
if ( regcomp(&preg, a1, 1) )
return 0xFFFFFFFFLL;
v7 = regexec(&preg, a2, 1uLL, &pmatch, 0);
regfree(&preg);
if ( v7 )
return 0xFFFFFFFFLL;
*a3 = pmatch.rm_so;
*a4 = pmatch.rm_eo;
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RBP + -0x80],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RCX,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
TEST EAX,EAX
JZ 0x00101217
MOV EAX,0xffffffff
JMP 0x0010126c
LAB_00101217:
LEA RDX,[RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x70]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101090
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x00101255
MOV EAX,0xffffffff
JMP 0x0010126c
LAB_00101255:
MOV EDX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x78]
MOV dword ptr [RAX],EDX
MOV EDX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RAX],EDX
MOV EAX,0x0
LAB_0010126c:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101280
CALL 0x001010a0
LAB_00101280:
LEAVE
RET | int8 func0(char *param_1,char *param_2,regoff_t *param_3,regoff_t *param_4)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
regmatch_t local_60;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,param_1,1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_2,1,&local_60,0);
regfree(&local_58);
if (iVar1 == 0) {
*param_3 = local_60.rm_so;
*param_4 = local_60.rm_eo;
uVar2 = 0;
}
else {
uVar2 = 0xffffffff;
}
}
else {
uVar2 = 0xffffffff;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
} |
6,029 | func0 |
#include <regex.h>
#include <stdio.h>
#include <assert.h>
| int func0(const char *pattern, const char *text, int *start, int *end) {
regex_t regex;
regmatch_t match;
int status;
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return -1; // Compilation error
}
status = regexec(®ex, text, 1, &match, 0);
regfree(®ex);
if (status != 0) {
return -1; // Match error
}
*start = match.rm_so;
*end = match.rm_eo;
return 0;
}
| int main() {
int start, end;
assert(func0("python", "python programming language", &start, &end) == 0 && start == 0 && end == 6);
assert(func0("programming", "python programming language", &start, &end) == 0 && start == 7 && end == 18);
assert(func0("language", "python programming language", &start, &end) == 0 && start == 19 && end == 27);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rsi,%rbx
mov %rdx,%r12
mov %rcx,%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
mov $0x1,%edx
mov %rdi,%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
jne 1263 <func0+0x9a>
lea 0x8(%rsp),%rcx
lea 0x10(%rsp),%r13
mov $0x0,%r8d
mov $0x1,%edx
mov %rbx,%rsi
mov %r13,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %r13,%rdi
callq 1090 <regfree@plt>
test %ebx,%ebx
jne 126a <func0+0xa1>
mov 0x8(%rsp),%eax
mov %eax,(%r12)
mov 0xc(%rsp),%eax
mov %eax,0x0(%rbp)
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1271 <func0+0xa8>
mov %ebx,%eax
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0xffffffff,%ebx
jmp 1246 <func0+0x7d>
mov $0xffffffff,%ebx
jmp 1246 <func0+0x7d>
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rbx, rsi
mov r12, rdx
mov rbp, rcx
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rax, [rsp+88h+var_78]
mov edx, 1
mov rsi, rdi
mov rdi, rax
call _regcomp
test eax, eax
jnz short loc_1263
lea rcx, [rsp+88h+var_80]
lea r13, [rsp+88h+var_78]
mov r8d, 0
mov edx, 1
mov rsi, rbx
mov rdi, r13
call _regexec
mov ebx, eax
mov rdi, r13
call _regfree
test ebx, ebx
jnz short loc_126A
mov eax, [rsp+88h+var_80]
mov [r12], eax
mov eax, [rsp+88h+var_7C]
mov [rbp+0], eax
loc_1246:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_1271
mov eax, ebx
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1263:
mov ebx, 0FFFFFFFFh
jmp short loc_1246
loc_126A:
mov ebx, 0FFFFFFFFh
jmp short loc_1246
loc_1271:
call ___stack_chk_fail | long long func0(long long a1, long long a2, _DWORD *a3, _DWORD *a4)
{
unsigned int v6; // ebx
_DWORD v8[2]; // [rsp+8h] [rbp-80h] BYREF
_BYTE v9[72]; // [rsp+10h] [rbp-78h] BYREF
unsigned long long v10; // [rsp+58h] [rbp-30h]
v10 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v9, a1, 1LL) )
{
return (unsigned int)-1;
}
else
{
v6 = regexec(v9, a2, 1LL, v8, 0LL);
regfree(v9);
if ( v6 )
{
return (unsigned int)-1;
}
else
{
*a3 = v8[0];
*a4 = v8[1];
}
}
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RBX,RSI
MOV R12,RDX
MOV RBP,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x10]
MOV EDX,0x1
MOV RSI,RDI
MOV RDI,RAX
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x00101263
LEA RCX,[RSP + 0x8]
LEA R13,[RSP + 0x10]
MOV R8D,0x0
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,R13
CALL 0x001010d0
MOV EBX,EAX
MOV RDI,R13
CALL 0x00101090
TEST EBX,EBX
JNZ 0x0010126a
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [R12],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RBP],EAX
LAB_00101246:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101271
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101263:
MOV EBX,0xffffffff
JMP 0x00101246
LAB_0010126a:
MOV EBX,0xffffffff
JMP 0x00101246
LAB_00101271:
CALL 0x001010a0 | int4 func0(char *param_1,char *param_2,regoff_t *param_3,regoff_t *param_4)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
regmatch_t local_80;
regex_t local_78;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_78,param_1,1);
if (iVar1 == 0) {
iVar1 = regexec(&local_78,param_2,1,&local_80,0);
regfree(&local_78);
if (iVar1 == 0) {
*param_3 = local_80.rm_so;
*param_4 = local_80.rm_eo;
uVar2 = 0;
}
else {
uVar2 = 0xffffffff;
}
}
else {
uVar2 = 0xffffffff;
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,030 | func0 |
#include <regex.h>
#include <stdio.h>
#include <assert.h>
| int func0(const char *pattern, const char *text, int *start, int *end) {
regex_t regex;
regmatch_t match;
int status;
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return -1; // Compilation error
}
status = regexec(®ex, text, 1, &match, 0);
regfree(®ex);
if (status != 0) {
return -1; // Match error
}
*start = match.rm_so;
*end = match.rm_eo;
return 0;
}
| int main() {
int start, end;
assert(func0("python", "python programming language", &start, &end) == 0 && start == 0 && end == 6);
assert(func0("programming", "python programming language", &start, &end) == 0 && start == 7 && end == 18);
assert(func0("language", "python programming language", &start, &end) == 0 && start == 19 && end == 27);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
mov %rdi,%rsi
push %rbp
mov %rdx,%rbp
mov $0x1,%edx
push %rbx
mov %rcx,%rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%r13
mov %r13,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
jne 1398 <func0+0x98>
xor %r8d,%r8d
mov %r12,%rsi
mov %r13,%rdi
mov $0x1,%edx
lea 0x8(%rsp),%rcx
callq 10d0 <regexec@plt>
mov %r13,%rdi
mov %eax,%r12d
callq 1090 <regfree@plt>
test %r12d,%r12d
jne 1398 <func0+0x98>
mov 0x8(%rsp),%eax
mov %eax,0x0(%rbp)
mov 0xc(%rsp),%eax
mov %eax,(%rbx)
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 13a0 <func0+0xa0>
add $0x68,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r12d
jmp 1375 <func0+0x75>
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
mov r12, rsi
mov rsi, rdi
push rbp
mov rbp, rdx
mov edx, 1
push rbx
mov rbx, rcx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea r13, [rsp+88h+var_78]
mov rdi, r13
call _regcomp
test eax, eax
jnz short loc_1398
xor r8d, r8d
mov rsi, r12
mov rdi, r13
mov edx, 1
lea rcx, [rsp+88h+var_80]
call _regexec
mov rdi, r13
mov r12d, eax
call _regfree
test r12d, r12d
jnz short loc_1398
mov eax, [rsp+88h+var_80]
mov [rbp+0], eax
mov eax, [rsp+88h+var_7C]
mov [rbx], eax
loc_1375:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_13A0
add rsp, 68h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1398:
mov r12d, 0FFFFFFFFh
jmp short loc_1375
loc_13A0:
call ___stack_chk_fail | long long func0(long long a1, long long a2, _DWORD *a3, _DWORD *a4)
{
unsigned int v6; // r12d
_DWORD v8[2]; // [rsp+8h] [rbp-80h] BYREF
_BYTE v9[72]; // [rsp+10h] [rbp-78h] BYREF
unsigned long long v10; // [rsp+58h] [rbp-30h]
v10 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v9, a1, 1LL) )
return (unsigned int)-1;
v6 = regexec(v9, a2, 1LL, v8, 0LL);
regfree(v9);
if ( v6 )
{
return (unsigned int)-1;
}
else
{
*a3 = v8[0];
*a4 = v8[1];
}
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RSI
MOV RSI,RDI
PUSH RBP
MOV RBP,RDX
MOV EDX,0x1
PUSH RBX
MOV RBX,RCX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x10]
MOV RDI,R13
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x00101398
XOR R8D,R8D
MOV RSI,R12
MOV RDI,R13
MOV EDX,0x1
LEA RCX,[RSP + 0x8]
CALL 0x001010d0
MOV RDI,R13
MOV R12D,EAX
CALL 0x00101090
TEST R12D,R12D
JNZ 0x00101398
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RBP],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RBX],EAX
LAB_00101375:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013a0
ADD RSP,0x68
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101398:
MOV R12D,0xffffffff
JMP 0x00101375
LAB_001013a0:
CALL 0x001010a0 | int4 func0(char *param_1,char *param_2,regoff_t *param_3,regoff_t *param_4)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
regmatch_t local_80;
regex_t local_78;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_78,param_1,1);
if (iVar1 == 0) {
iVar1 = regexec(&local_78,param_2,1,&local_80,0);
regfree(&local_78);
if (iVar1 == 0) {
*param_3 = local_80.rm_so;
*param_4 = local_80.rm_eo;
uVar2 = 0;
goto LAB_00101375;
}
}
uVar2 = 0xffffffff;
LAB_00101375:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,031 | func0 |
#include <regex.h>
#include <stdio.h>
#include <assert.h>
| int func0(const char *pattern, const char *text, int *start, int *end) {
regex_t regex;
regmatch_t match;
int status;
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return -1; // Compilation error
}
status = regexec(®ex, text, 1, &match, 0);
regfree(®ex);
if (status != 0) {
return -1; // Match error
}
*start = match.rm_so;
*end = match.rm_eo;
return 0;
}
| int main() {
int start, end;
assert(func0("python", "python programming language", &start, &end) == 0 && start == 0 && end == 6);
assert(func0("programming", "python programming language", &start, &end) == 0 && start == 7 && end == 18);
assert(func0("language", "python programming language", &start, &end) == 0 && start == 19 && end == 27);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
mov %rdi,%rsi
push %rbp
mov %rdx,%rbp
mov $0x1,%edx
push %rbx
mov %rcx,%rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%r13
mov %r13,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
jne 1398 <func0+0x98>
xor %r8d,%r8d
mov %r12,%rsi
mov %r13,%rdi
mov $0x1,%edx
lea 0x8(%rsp),%rcx
callq 10d0 <regexec@plt>
mov %r13,%rdi
mov %eax,%r12d
callq 1090 <regfree@plt>
test %r12d,%r12d
jne 1398 <func0+0x98>
mov 0x8(%rsp),%eax
mov %eax,0x0(%rbp)
mov 0xc(%rsp),%eax
mov %eax,(%rbx)
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 13a0 <func0+0xa0>
add $0x68,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r12d
jmp 1375 <func0+0x75>
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
mov r12, rdx
mov edx, 1; cflags
push rbp
mov rbp, rcx
push rbx
mov rbx, rsi
mov rsi, rdi; pattern
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea r13, [rsp+88h+preg]
mov rdi, r13; preg
call _regcomp
test eax, eax
jnz short loc_1388
xor r8d, r8d; eflags
mov rsi, rbx; string
mov rdi, r13; preg
mov edx, 1; nmatch
lea rcx, [rsp+88h+pmatch]; pmatch
call _regexec
mov rdi, r13; preg
mov ebx, eax
call _regfree
test ebx, ebx
jnz short loc_1388
mov eax, [rsp+88h+pmatch.rm_so]
mov [r12], eax
mov eax, [rsp+88h+pmatch.rm_eo]
mov [rbp+0], eax
loc_1365:
mov rax, [rsp+88h+var_30]
sub rax, fs:28h
jnz short loc_138F
add rsp, 68h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1388:
mov ebx, 0FFFFFFFFh
jmp short loc_1365
loc_138F:
call ___stack_chk_fail | long long func0(char *pattern, char *string, regoff_t *a3, regoff_t *a4)
{
unsigned int v6; // ebx
regmatch_t pmatch; // [rsp+8h] [rbp-80h] BYREF
regex_t preg; // [rsp+10h] [rbp-78h] BYREF
unsigned long long v10; // [rsp+58h] [rbp-30h]
v10 = __readfsqword(0x28u);
if ( regcomp(&preg, pattern, 1) )
return (unsigned int)-1;
v6 = regexec(&preg, string, 1uLL, &pmatch, 0);
regfree(&preg);
if ( v6 )
{
return (unsigned int)-1;
}
else
{
*a3 = pmatch.rm_so;
*a4 = pmatch.rm_eo;
}
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
MOV EDX,0x1
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV RBX,RSI
MOV RSI,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x10]
MOV RDI,R13
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x00101388
XOR R8D,R8D
MOV RSI,RBX
MOV RDI,R13
MOV EDX,0x1
LEA RCX,[RSP + 0x8]
CALL 0x001010d0
MOV RDI,R13
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
JNZ 0x00101388
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [R12],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RBP],EAX
LAB_00101365:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010138f
ADD RSP,0x68
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101388:
MOV EBX,0xffffffff
JMP 0x00101365
LAB_0010138f:
CALL 0x001010a0 | int4 func0(char *param_1,char *param_2,regoff_t *param_3,regoff_t *param_4)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
regmatch_t local_80;
regex_t local_78;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_78,param_1,1);
if (iVar1 == 0) {
iVar1 = regexec(&local_78,param_2,1,&local_80,0);
regfree(&local_78);
if (iVar1 == 0) {
*param_3 = local_80.rm_so;
*param_4 = local_80.rm_eo;
uVar2 = 0;
goto LAB_00101365;
}
}
uVar2 = 0xffffffff;
LAB_00101365:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,032 | func0 |
#include <assert.h>
| double func0(double r) {
return 3.1415 * r * r;
}
| int main() {
assert(func0(10) == 314.15000000000003);
assert(func0(5) == 78.53750000000001);
assert(func0(4) == 50.264);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm1
movsd 0xf3d(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_8], xmm0
movsd xmm1, [rbp+var_8]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm1
mulsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 3.1415 * a1 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM1,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_00102080 * param_1 * param_1;
} |
6,033 | func0 |
#include <assert.h>
| double func0(double r) {
return 3.1415 * r * r;
}
| int main() {
assert(func0(10) == 314.15000000000003);
assert(func0(5) == 78.53750000000001);
assert(func0(4) == 50.264);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm1
mulsd 0xecf(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
movapd xmm1, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return a1 * 3.1415 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008 * param_1;
} |
6,034 | func0 |
#include <assert.h>
| double func0(double r) {
return 3.1415 * r * r;
}
| int main() {
assert(func0(10) == 314.15000000000003);
assert(func0(5) == 78.53750000000001);
assert(func0(4) == 50.264);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm1
movsd 0xeb8(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
movapd xmm1, xmm0
movsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return 3.1415 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return DAT_00102008 * param_1 * param_1;
} |
6,035 | func0 |
#include <assert.h>
| double func0(double r) {
return 3.1415 * r * r;
}
| int main() {
assert(func0(10) == 314.15000000000003);
assert(func0(5) == 78.53750000000001);
assert(func0(4) == 50.264);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm1
movsd 0xeb8(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
movapd xmm1, xmm0
movsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return 3.1415 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return DAT_00102008 * param_1 * param_1;
} |
6,036 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int* input_list, int list_size, int n, int* output_list, int* output_size) {
int j = 0;
for (int i = 0; i < list_size; i += n) {
output_list[j++] = input_list[i];
}
*output_size = j;
}
| int main() {
int output_list[5];
int output_size;
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int expected1[] = {1, 3, 5, 7, 9};
func0(list1, 9, 2, output_list, &output_size);
assert(output_size == 5);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected1[i]);
}
int list2[] = {10, 15, 19, 17, 16, 18};
int expected2[] = {10, 17};
func0(list2, 6, 3, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected2[i]);
}
int list3[] = {14, 16, 19, 15, 17};
int expected3[] = {14, 17};
func0(list3, 5, 4, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[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 %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov %r8,-0x30(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ec <func0+0x63>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x20(%rbp),%eax
add %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11b3 <func0+0x2a>
mov -0x30(%rbp),%rax
mov -0x8(%rbp),%edx
mov %edx,(%rax)
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_30], r8
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11EC
loc_11B3:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov eax, [rbp+var_20]
add [rbp+var_4], eax
loc_11EC:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11B3
mov rax, [rbp+var_30]
mov edx, [rbp+var_8]
mov [rax], edx
nop
pop rbp
retn | _DWORD * func0(long long a1, int a2, int a3, long long a4, _DWORD *a5)
{
int v5; // eax
_DWORD *result; // rax
int v7; // [rsp+28h] [rbp-8h]
int i; // [rsp+2Ch] [rbp-4h]
v7 = 0;
for ( i = 0; i < a2; i += a3 )
{
v5 = v7++;
*(_DWORD *)(a4 + 4LL * v5) = *(_DWORD *)(4LL * i + a1);
}
result = a5;
*a5 = v7;
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 qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ec
LAB_001011b3:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD dword ptr [RBP + -0x4],EAX
LAB_001011ec:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011b3
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x8]
MOV dword ptr [RAX],EDX
NOP
POP RBP
RET | void func0(long param_1,int param_2,int param_3,long param_4,int *param_5)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + param_3) {
*(int4 *)((long)local_10 * 4 + param_4) = *(int4 *)((long)local_c * 4 + param_1);
local_10 = local_10 + 1;
}
*param_5 = local_10;
return;
} |
6,037 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int* input_list, int list_size, int n, int* output_list, int* output_size) {
int j = 0;
for (int i = 0; i < list_size; i += n) {
output_list[j++] = input_list[i];
}
*output_size = j;
}
| int main() {
int output_list[5];
int output_size;
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int expected1[] = {1, 3, 5, 7, 9};
func0(list1, 9, 2, output_list, &output_size);
assert(output_size == 5);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected1[i]);
}
int list2[] = {10, 15, 19, 17, 16, 18};
int expected2[] = {10, 17};
func0(list2, 6, 3, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected2[i]);
}
int list3[] = {14, 16, 19, 15, 17};
int expected3[] = {14, 17};
func0(list3, 5, 4, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
test %esi,%esi
jle 11c2 <func0+0x39>
movslq %edx,%r11
shl $0x2,%r11
mov $0x1,%eax
mov $0x0,%r9d
mov %eax,%ebx
mov (%rdi),%r10d
mov %r10d,-0x4(%rcx,%rax,4)
add %edx,%r9d
add $0x1,%rax
add %r11,%rdi
cmp %r9d,%esi
jg 11a4 <func0+0x1b>
mov %ebx,(%r8)
pop %rbx
retq
mov $0x0,%ebx
jmp 11bd <func0+0x34>
| func0:
endbr64
push rbx
test esi, esi
jle short loc_11C5
mov r9d, esi
mov r10d, edx
movsxd r11, edx
shl r11, 2
mov eax, 1
mov edx, 0
loc_11A9:
mov ebx, eax
mov esi, [rdi]
mov [rcx+rax*4-4], esi
add edx, r10d
add rax, 1
add rdi, r11
cmp r9d, edx
jg short loc_11A9
loc_11C0:
mov [r8], ebx
pop rbx
retn
loc_11C5:
mov ebx, 0
jmp short loc_11C0 | void func0(_DWORD *a1, int a2, int a3, long long a4, _DWORD *a5)
{
long long v6; // r11
long long v7; // rax
int v8; // edx
int v9; // ebx
if ( a2 <= 0 )
{
v9 = 0;
}
else
{
v6 = 4LL * a3;
v7 = 1LL;
v8 = 0;
do
{
v9 = v7;
*(_DWORD *)(a4 + 4 * v7 - 4) = *a1;
v8 += a3;
++v7;
a1 = (_DWORD *)((char *)a1 + v6);
}
while ( a2 > v8 );
}
*a5 = v9;
} | func0:
ENDBR64
PUSH RBX
TEST ESI,ESI
JLE 0x001011c5
MOV R9D,ESI
MOV R10D,EDX
MOVSXD R11,EDX
SHL R11,0x2
MOV EAX,0x1
MOV EDX,0x0
LAB_001011a9:
MOV EBX,EAX
MOV ESI,dword ptr [RDI]
MOV dword ptr [RCX + RAX*0x4 + -0x4],ESI
ADD EDX,R10D
ADD RAX,0x1
ADD RDI,R11
CMP R9D,EDX
JG 0x001011a9
LAB_001011c0:
MOV dword ptr [R8],EBX
POP RBX
RET
LAB_001011c5:
MOV EBX,0x0
JMP 0x001011c0 | void func0(int4 *param_1,int param_2,int param_3,long param_4,int4 *param_5)
{
long lVar1;
int iVar2;
int4 uVar3;
if (param_2 < 1) {
uVar3 = 0;
}
else {
lVar1 = 1;
iVar2 = 0;
do {
uVar3 = (int4)lVar1;
*(int4 *)(param_4 + -4 + lVar1 * 4) = *param_1;
iVar2 = iVar2 + param_3;
lVar1 = lVar1 + 1;
param_1 = param_1 + param_3;
} while (iVar2 < param_2);
}
*param_5 = uVar3;
return;
} |
6,038 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int* input_list, int list_size, int n, int* output_list, int* output_size) {
int j = 0;
for (int i = 0; i < list_size; i += n) {
output_list[j++] = input_list[i];
}
*output_size = j;
}
| int main() {
int output_list[5];
int output_size;
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int expected1[] = {1, 3, 5, 7, 9};
func0(list1, 9, 2, output_list, &output_size);
assert(output_size == 5);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected1[i]);
}
int list2[] = {10, 15, 19, 17, 16, 18};
int expected2[] = {10, 17};
func0(list2, 6, 3, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected2[i]);
}
int list3[] = {14, 16, 19, 15, 17};
int expected3[] = {14, 17};
func0(list3, 5, 4, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
test %esi,%esi
jle 1280 <func0+0x40>
movslq %edx,%r11
mov $0x1,%eax
xor %r9d,%r9d
shl $0x2,%r11
nopl 0x0(%rax,%rax,1)
mov (%rdi),%r10d
add %edx,%r9d
mov %eax,%ebx
add %r11,%rdi
mov %r10d,-0x4(%rcx,%rax,4)
add $0x1,%rax
cmp %r9d,%esi
jg 1260 <func0+0x20>
mov %ebx,(%r8)
pop %rbx
retq
xchg %ax,%ax
xor %ebx,%ebx
mov %ebx,(%r8)
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
test esi, esi
jle short loc_12E0
movsxd r11, edx
mov r10d, edx
mov r9d, esi
mov eax, 1
shl r11, 2
xor edx, edx
nop dword ptr [rax]
loc_12C0:
mov esi, [rdi]
add edx, r10d
mov ebx, eax
add rdi, r11
mov [rcx+rax*4-4], esi
add rax, 1
cmp r9d, edx
jg short loc_12C0
mov [r8], ebx
pop rbx
retn
loc_12E0:
xor ebx, ebx
mov [r8], ebx
pop rbx
retn | void func0(int *a1, int a2, int a3, long long a4, _DWORD *a5)
{
long long v7; // rax
long long v8; // r11
int v9; // edx
int v10; // esi
int v11; // ebx
if ( a2 <= 0 )
{
*a5 = 0;
}
else
{
v7 = 1LL;
v8 = 4LL * a3;
v9 = 0;
do
{
v10 = *a1;
v9 += a3;
v11 = v7;
a1 = (int *)((char *)a1 + v8);
*(_DWORD *)(a4 + 4 * v7++ - 4) = v10;
}
while ( a2 > v9 );
*a5 = v11;
}
} | func0:
ENDBR64
PUSH RBX
TEST ESI,ESI
JLE 0x001012e0
MOVSXD R11,EDX
MOV R10D,EDX
MOV R9D,ESI
MOV EAX,0x1
SHL R11,0x2
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001012c0:
MOV ESI,dword ptr [RDI]
ADD EDX,R10D
MOV EBX,EAX
ADD RDI,R11
MOV dword ptr [RCX + RAX*0x4 + -0x4],ESI
ADD RAX,0x1
CMP R9D,EDX
JG 0x001012c0
MOV dword ptr [R8],EBX
POP RBX
RET
LAB_001012e0:
XOR EBX,EBX
MOV dword ptr [R8],EBX
POP RBX
RET | void func0(int4 *param_1,int param_2,int param_3,long param_4,int4 *param_5)
{
int4 uVar1;
long lVar2;
long lVar3;
int iVar4;
if (0 < param_2) {
iVar4 = 0;
lVar2 = 1;
do {
lVar3 = lVar2;
uVar1 = *param_1;
iVar4 = iVar4 + param_3;
param_1 = param_1 + param_3;
*(int4 *)(param_4 + -4 + lVar3 * 4) = uVar1;
lVar2 = lVar3 + 1;
} while (iVar4 < param_2);
*param_5 = (int)lVar3;
return;
}
*param_5 = 0;
return;
} |
6,039 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int* input_list, int list_size, int n, int* output_list, int* output_size) {
int j = 0;
for (int i = 0; i < list_size; i += n) {
output_list[j++] = input_list[i];
}
*output_size = j;
}
| int main() {
int output_list[5];
int output_size;
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int expected1[] = {1, 3, 5, 7, 9};
func0(list1, 9, 2, output_list, &output_size);
assert(output_size == 5);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected1[i]);
}
int list2[] = {10, 15, 19, 17, 16, 18};
int expected2[] = {10, 17};
func0(list2, 6, 3, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected2[i]);
}
int list3[] = {14, 16, 19, 15, 17};
int expected3[] = {14, 17};
func0(list3, 5, 4, output_list, &output_size);
assert(output_size == 2);
for (int i = 0; i < output_size; i++) {
assert(output_list[i] == expected3[i]);
}
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1350 <func0+0x130>
cmp $0x1,%edx
jne 12e0 <func0+0xc0>
lea 0xf(%rdi),%rdx
lea -0x1(%rsi),%eax
sub %rcx,%rdx
cmp $0x1e,%rdx
jbe 1320 <func0+0x100>
cmp $0x3,%eax
jbe 1320 <func0+0x100>
mov %esi,%edx
movdqa 0xe34(%rip),%xmm1
xor %eax,%eax
movdqa 0xe3a(%rip),%xmm3
shr $0x2,%edx
movdqa 0xe3f(%rip),%xmm2
shl $0x4,%rdx
nopl (%rax)
movdqu (%rdi,%rax,1),%xmm4
movdqa %xmm1,%xmm0
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
movups %xmm4,(%rcx,%rax,1)
add $0x10,%rax
cmp %rdx,%rax
jne 1278 <func0+0x58>
pshufd $0xff,%xmm0,%xmm0
mov %esi,%edx
movd %xmm0,%eax
and $0xfffffffc,%edx
test $0x3,%sil
je 12da <func0+0xba>
mov %edx,%r9d
lea 0x1(%rdx),%eax
mov (%rdi,%r9,4),%r10d
mov %r10d,(%rcx,%r9,4)
cmp %eax,%esi
jle 12da <func0+0xba>
movslq %eax,%r9
lea 0x2(%rdx),%eax
mov (%rdi,%r9,4),%r10d
mov %r10d,(%rcx,%r9,4)
cmp %eax,%esi
jle 12da <func0+0xba>
movslq %eax,%rsi
lea 0x3(%rdx),%eax
mov (%rdi,%rsi,4),%edx
mov %edx,(%rcx,%rsi,4)
mov %eax,(%r8)
retq
xchg %ax,%ax
push %rbx
movslq %edx,%rbx
mov $0x1,%r9d
xor %r10d,%r10d
shl $0x2,%rbx
nopl 0x0(%rax)
mov (%rdi),%r11d
add %edx,%r10d
mov %r9d,%eax
add %rbx,%rdi
mov %r11d,-0x4(%rcx,%r9,4)
add $0x1,%r9
cmp %r10d,%esi
jg 12f8 <func0+0xd8>
mov %eax,(%r8)
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
lea 0x2(%rax),%rsi
mov $0x1,%edx
nopl 0x0(%rax)
mov -0x4(%rdi,%rdx,4),%r9d
mov %edx,%eax
mov %r9d,-0x4(%rcx,%rdx,4)
add $0x1,%rdx
cmp %rsi,%rdx
jne 1330 <func0+0x110>
mov %eax,(%r8)
retq
nopl 0x0(%rax)
xor %eax,%eax
mov %eax,(%r8)
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, esi
mov r10, rcx
mov esi, edx
test r9d, r9d
jle loc_1290
cmp edx, 1
jnz loc_1258
lea eax, [r9-1]
cmp eax, 3
jbe short loc_11A7
lea rdx, [rdi+4]
mov rax, rcx
sub rax, rdx
cmp rax, 8
ja short loc_11D0
loc_11A7:
movsxd rcx, r9d
mov eax, 1
nop
loc_11B0:
mov edx, [rdi+rax*4-4]
mov [r10+rax*4-4], edx
mov rdx, rax
add rax, 1
cmp rdx, rcx
jnz short loc_11B0
mov eax, r9d
loc_11C8:
mov [r8], eax
retn
loc_11D0:
mov edx, r9d
movdqa xmm1, cs:xmmword_2020
movdqa xmm2, cs:xmmword_2030
xor eax, eax
shr edx, 2
shl rdx, 4
nop dword ptr [rax+00h]
loc_11F0:
movdqu xmm3, xmmword ptr [rdi+rax]
movdqa xmm0, xmm1
paddd xmm1, xmm2
movups xmmword ptr [r10+rax], xmm3
add rax, 10h
cmp rdx, rax
jnz short loc_11F0
mov edx, r9d
and edx, 0FFFFFFFCh
test r9b, 3
jz short loc_1296
mov esi, edx
lea eax, [rdx+1]
mov r11d, [rdi+rsi*4]
lea rcx, ds:0[rsi*4]
mov [r10+rsi*4], r11d
cmp eax, r9d
jge short loc_11C8
mov esi, [rdi+rcx+4]
lea eax, [rdx+2]
mov [r10+rcx+4], esi
cmp r9d, eax
jle short loc_11C8
lea eax, [rdx+3]
mov edx, [rdi+rcx+8]
mov [r10+rcx+8], edx
mov [r8], eax
retn
loc_1258:
movsxd r11, edx
xor ecx, ecx
mov edx, 1
shl r11, 2
nop word ptr [rax+rax+00000000h]
loc_1270:
mov eax, [rdi]
add ecx, esi
add rdi, r11
mov [r10+rdx*4-4], eax
mov rax, rdx
add rdx, 1
cmp r9d, ecx
jg short loc_1270
mov [r8], eax
retn
loc_1290:
xor eax, eax
mov [r8], eax
retn
loc_1296:
paddd xmm0, cs:xmmword_2040
pshufd xmm0, xmm0, 0FFh
movd eax, xmm0
jmp loc_11C8 | long long func0(int *a1, int a2, int a3, long long a4, _DWORD *a5)
{
long long v8; // rax
long long v9; // rdx
long long result; // rax
__m128i si128; // xmm1
__m128i v12; // xmm2
long long v13; // rax
__m128i v14; // xmm0
unsigned int v15; // edx
long long v16; // rcx
long long v17; // r11
int v18; // ecx
long long v19; // rdx
long long v20; // r11
int v21; // eax
if ( a2 <= 0 )
{
result = 0LL;
*a5 = 0;
}
else if ( a3 == 1 )
{
if ( (unsigned int)(a2 - 1) <= 3 || (unsigned long long)(a4 - (_QWORD)(a1 + 1)) <= 8 )
{
v8 = 1LL;
do
{
*(_DWORD *)(a4 + 4 * v8 - 4) = a1[v8 - 1];
v9 = v8++;
}
while ( v9 != a2 );
result = (unsigned int)a2;
goto LABEL_8;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2020);
v12 = _mm_load_si128((const __m128i *)&xmmword_2030);
v13 = 0LL;
do
{
v14 = si128;
si128 = _mm_add_epi32(si128, v12);
*(__m128i *)(a4 + v13 * 4) = _mm_loadu_si128((const __m128i *)&a1[v13]);
v13 += 4LL;
}
while ( 4LL * ((unsigned int)a2 >> 2) != v13 );
v15 = a2 & 0x7FFFFFFC;
if ( (a2 & 3) == 0 )
{
result = (unsigned int)_mm_cvtsi128_si32(_mm_shuffle_epi32(_mm_add_epi32(v14, (__m128i)xmmword_2040), 255));
LABEL_8:
*a5 = result;
return result;
}
result = v15 + 1;
v16 = v15;
*(_DWORD *)(a4 + v16 * 4) = a1[v16];
if ( (int)result >= a2 )
goto LABEL_8;
result = v15 + 2;
*(_DWORD *)(a4 + v16 * 4 + 4) = a1[v16 + 1];
if ( a2 <= (int)result )
goto LABEL_8;
result = v15 + 3;
*(_DWORD *)(a4 + v16 * 4 + 8) = a1[v16 + 2];
*a5 = result;
}
else
{
v17 = a3;
v18 = 0;
v19 = 1LL;
v20 = 4 * v17;
do
{
v21 = *a1;
v18 += a3;
a1 = (int *)((char *)a1 + v20);
*(_DWORD *)(a4 + 4 * v19 - 4) = v21;
result = v19++;
}
while ( a2 > v18 );
*a5 = result;
}
return result;
} | func0:
ENDBR64
MOV R9D,ESI
MOV R10,RCX
MOV ESI,EDX
TEST R9D,R9D
JLE 0x00101290
CMP EDX,0x1
JNZ 0x00101258
LEA EAX,[R9 + -0x1]
CMP EAX,0x3
JBE 0x001011a7
LEA RDX,[RDI + 0x4]
MOV RAX,RCX
SUB RAX,RDX
CMP RAX,0x8
JA 0x001011d0
LAB_001011a7:
MOVSXD RCX,R9D
MOV EAX,0x1
NOP
LAB_001011b0:
MOV EDX,dword ptr [RDI + RAX*0x4 + -0x4]
MOV dword ptr [R10 + RAX*0x4 + -0x4],EDX
MOV RDX,RAX
ADD RAX,0x1
CMP RDX,RCX
JNZ 0x001011b0
MOV EAX,R9D
LAB_001011c8:
MOV dword ptr [R8],EAX
RET
LAB_001011d0:
MOV EDX,R9D
MOVDQA XMM1,xmmword ptr [0x00102020]
MOVDQA XMM2,xmmword ptr [0x00102030]
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP dword ptr [RAX]
LAB_001011f0:
MOVDQU XMM3,xmmword ptr [RDI + RAX*0x1]
MOVDQA XMM0,XMM1
PADDD XMM1,XMM2
MOVUPS xmmword ptr [R10 + RAX*0x1],XMM3
ADD RAX,0x10
CMP RDX,RAX
JNZ 0x001011f0
MOV EDX,R9D
AND EDX,0xfffffffc
TEST R9B,0x3
JZ 0x00101296
MOV ESI,EDX
LEA EAX,[RDX + 0x1]
MOV R11D,dword ptr [RDI + RSI*0x4]
LEA RCX,[RSI*0x4]
MOV dword ptr [R10 + RSI*0x4],R11D
CMP EAX,R9D
JGE 0x001011c8
MOV ESI,dword ptr [RDI + RCX*0x1 + 0x4]
LEA EAX,[RDX + 0x2]
MOV dword ptr [R10 + RCX*0x1 + 0x4],ESI
CMP R9D,EAX
JLE 0x001011c8
LEA EAX,[RDX + 0x3]
MOV EDX,dword ptr [RDI + RCX*0x1 + 0x8]
MOV dword ptr [R10 + RCX*0x1 + 0x8],EDX
MOV dword ptr [R8],EAX
RET
LAB_00101258:
MOVSXD R11,EDX
XOR ECX,ECX
MOV EDX,0x1
SHL R11,0x2
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101270:
MOV EAX,dword ptr [RDI]
ADD ECX,ESI
ADD RDI,R11
MOV dword ptr [R10 + RDX*0x4 + -0x4],EAX
MOV RAX,RDX
ADD RDX,0x1
CMP R9D,ECX
JG 0x00101270
MOV dword ptr [R8],EAX
RET
LAB_00101290:
XOR EAX,EAX
MOV dword ptr [R8],EAX
RET
LAB_00101296:
PADDD XMM0,xmmword ptr [0x00102040]
PSHUFD XMM0,XMM0,0xff
MOVD EAX,XMM0
JMP 0x001011c8 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int4 *param_1,uint param_2,int param_3,long param_4,uint *param_5)
{
int4 uVar1;
int8 uVar2;
int iVar3;
uint uVar4;
long lVar5;
int iVar6;
uint uVar7;
long lVar8;
ulong uVar9;
bool bVar10;
int iVar11;
iVar6 = _UNK_0010203c;
if ((int)param_2 < 1) {
*param_5 = 0;
return;
}
if (param_3 != 1) {
iVar6 = 0;
lVar5 = 1;
do {
lVar8 = lVar5;
uVar1 = *param_1;
iVar6 = iVar6 + param_3;
param_1 = param_1 + param_3;
*(int4 *)(param_4 + -4 + lVar8 * 4) = uVar1;
lVar5 = lVar8 + 1;
} while (iVar6 < (int)param_2);
*param_5 = (uint)lVar8;
return;
}
if ((param_2 - 1 < 4) || ((ulong)(param_4 - (long)(param_1 + 1)) < 9)) {
lVar5 = 1;
do {
*(int4 *)(param_4 + -4 + lVar5 * 4) = param_1[lVar5 + -1];
bVar10 = lVar5 != (int)param_2;
lVar5 = lVar5 + 1;
uVar4 = param_2;
} while (bVar10);
}
else {
lVar5 = 0;
iVar3 = _UNK_0010202c;
do {
iVar11 = iVar3;
uVar2 = ((int8 *)((long)param_1 + lVar5))[1];
*(int8 *)(param_4 + lVar5) = *(int8 *)((long)param_1 + lVar5);
((int8 *)(param_4 + lVar5))[1] = uVar2;
lVar5 = lVar5 + 0x10;
iVar3 = iVar11 + iVar6;
} while ((ulong)(param_2 >> 2) << 4 != lVar5);
uVar7 = param_2 & 0xfffffffc;
if ((param_2 & 3) == 0) {
uVar4 = iVar11 + _UNK_0010204c;
}
else {
uVar9 = (ulong)uVar7;
*(int4 *)(param_4 + uVar9 * 4) = param_1[uVar9];
uVar4 = uVar7 + 1;
if ((int)(uVar7 + 1) < (int)param_2) {
*(int4 *)(param_4 + 4 + uVar9 * 4) = param_1[uVar9 + 1];
uVar4 = uVar7 + 2;
if ((int)(uVar7 + 2) < (int)param_2) {
*(int4 *)(param_4 + 8 + uVar9 * 4) = param_1[uVar9 + 2];
*param_5 = uVar7 + 3;
return;
}
}
}
}
*param_5 = uVar4;
return;
} |
6,040 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *str1) {
char *words[100];
int word_count = 0;
char *word = strtok(str1, " ");
while (word != NULL) {
for (int i = 0; i < word_count; i++) {
if (strcmp(words[i], word) == 0) {
return word;
}
}
words[word_count++] = word;
word = strtok(NULL, " ");
}
return "None";
}
| int main() {
char str1[] = "ab ca bc ab";
char str2[] = "ab ca bc";
char str3[] = "ab ca bc ca ab bc";
assert(strcmp(func0(str1), "ab") == 0);
assert(strcmp(func0(str2), "None") == 0);
assert(strcmp(func0(str3), "ca") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x350,%rsp
mov %rdi,-0x348(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x340(%rbp)
mov -0x348(%rbp),%rax
lea 0xe22(%rip),%rsi
mov %rax,%rdi
callq 10b0 <strtok@plt>
mov %rax,-0x338(%rbp)
jmpq 1282 <func0+0xd9>
movl $0x0,-0x33c(%rbp)
jmp 123c <func0+0x93>
mov -0x33c(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rax
mov -0x338(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10a0 <strcmp@plt>
test %eax,%eax
jne 1235 <func0+0x8c>
mov -0x338(%rbp),%rax
jmp 1297 <func0+0xee>
addl $0x1,-0x33c(%rbp)
mov -0x33c(%rbp),%eax
cmp -0x340(%rbp),%eax
jl 1206 <func0+0x5d>
mov -0x340(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x340(%rbp)
cltq
mov -0x338(%rbp),%rdx
mov %rdx,-0x330(%rbp,%rax,8)
lea 0xd97(%rip),%rsi
mov $0x0,%edi
callq 10b0 <strtok@plt>
mov %rax,-0x338(%rbp)
cmpq $0x0,-0x338(%rbp)
jne 11fa <func0+0x51>
lea 0xd73(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 12ab <func0+0x102>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 350h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_340], 0
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+s2], rax
jmp loc_1288
loc_11FD:
mov [rbp+var_33C], 0
jmp short loc_123F
loc_1209:
mov eax, [rbp+var_33C]
cdqe
mov rax, [rbp+rax*8+s1]
mov rdx, [rbp+s2]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1238
mov rax, [rbp+s2]
jmp short loc_129D
loc_1238:
add [rbp+var_33C], 1
loc_123F:
mov eax, [rbp+var_33C]
cmp eax, [rbp+var_340]
jl short loc_1209
mov eax, [rbp+var_340]
lea edx, [rax+1]
mov [rbp+var_340], edx
cdqe
mov rdx, [rbp+s2]
mov [rbp+rax*8+s1], rdx
lea rax, delim; " "
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+s2], rax
loc_1288:
cmp [rbp+s2], 0
jnz loc_11FD
lea rax, aNone; "None"
loc_129D:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12B1
call ___stack_chk_fail
locret_12B1:
leave
retn | const char * func0(char *a1)
{
int v2; // eax
int v3; // [rsp+10h] [rbp-340h]
int i; // [rsp+14h] [rbp-33Ch]
const char *s2; // [rsp+18h] [rbp-338h]
char *s1[102]; // [rsp+20h] [rbp-330h]
s1[101] = (char *)__readfsqword(0x28u);
v3 = 0;
for ( s2 = strtok(a1, " "); s2; s2 = strtok(0LL, " ") )
{
for ( i = 0; i < v3; ++i )
{
if ( !strcmp(s1[i], s2) )
return s2;
}
v2 = v3++;
s1[v2] = (char *)s2;
}
return "None";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x350
MOV qword ptr [RBP + -0x348],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x340],0x0
MOV RAX,qword ptr [RBP + -0x348]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x338],RAX
JMP 0x00101288
LAB_001011fd:
MOV dword ptr [RBP + -0x33c],0x0
JMP 0x0010123f
LAB_00101209:
MOV EAX,dword ptr [RBP + -0x33c]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x330]
MOV RDX,qword ptr [RBP + -0x338]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010a0
TEST EAX,EAX
JNZ 0x00101238
MOV RAX,qword ptr [RBP + -0x338]
JMP 0x0010129d
LAB_00101238:
ADD dword ptr [RBP + -0x33c],0x1
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0x33c]
CMP EAX,dword ptr [RBP + -0x340]
JL 0x00101209
MOV EAX,dword ptr [RBP + -0x340]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x340],EDX
CDQE
MOV RDX,qword ptr [RBP + -0x338]
MOV qword ptr [RBP + RAX*0x8 + -0x330],RDX
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x001010b0
MOV qword ptr [RBP + -0x338],RAX
LAB_00101288:
CMP qword ptr [RBP + -0x338],0x0
JNZ 0x001011fd
LEA RAX,[0x10200a]
LAB_0010129d:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012b1
CALL 0x00101080
LAB_001012b1:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
int local_348;
int local_344;
char *local_340;
int8 auStack_338 [101];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_348 = 0;
local_340 = strtok(param_1," ");
while (local_340 != (char *)0x0) {
for (local_344 = 0; local_344 < local_348; local_344 = local_344 + 1) {
iVar1 = strcmp((char *)auStack_338[local_344],local_340);
if (iVar1 == 0) goto LAB_0010129d;
}
auStack_338[local_348] = local_340;
local_340 = strtok((char *)0x0," ");
local_348 = local_348 + 1;
}
local_340 = "None";
LAB_0010129d:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_340;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,041 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *str1) {
char *words[100];
int word_count = 0;
char *word = strtok(str1, " ");
while (word != NULL) {
for (int i = 0; i < word_count; i++) {
if (strcmp(words[i], word) == 0) {
return word;
}
}
words[word_count++] = word;
word = strtok(NULL, " ");
}
return "None";
}
| int main() {
char str1[] = "ab ca bc ab";
char str2[] = "ab ca bc";
char str3[] = "ab ca bc ca ab bc";
assert(strcmp(func0(str1), "ab") == 0);
assert(strcmp(func0(str2), "None") == 0);
assert(strcmp(func0(str3), "ca") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x338,%rsp
mov %fs:0x28,%rax
mov %rax,0x328(%rsp)
xor %eax,%eax
lea 0xe31(%rip),%rsi
callq 10b0 <strtok@plt>
lea 0xe20(%rip),%rbp
test %rax,%rax
je 124c <func0+0xa3>
mov %rax,%rbp
mov %rsp,%r14
lea 0x8(%rsp),%r12
mov $0x1,%r13d
lea 0xe08(%rip),%r15
mov %rbp,-0x8(%r12)
mov %r15,%rsi
mov $0x0,%edi
callq 10b0 <strtok@plt>
mov %rax,%rbp
test %rax,%rax
je 1245 <func0+0x9c>
test %r13d,%r13d
jle 123b <func0+0x92>
mov %r14,%rbx
mov %rbp,%rsi
mov (%rbx),%rdi
callq 10a0 <strcmp@plt>
test %eax,%eax
je 124c <func0+0xa3>
add $0x8,%rbx
cmp %r12,%rbx
jne 1223 <func0+0x7a>
add $0x1,%r13d
add $0x8,%r12
jmp 1201 <func0+0x58>
lea 0xdb8(%rip),%rbp
mov 0x328(%rsp),%rax
xor %fs:0x28,%rax
jne 1274 <func0+0xcb>
mov %rbp,%rax
add $0x338,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 338h
mov rax, fs:28h
mov [rsp+368h+var_40], rax
xor eax, eax
lea rsi, asc_2009; " "
call _strtok
lea rbp, aNone; "None"
test rax, rax
jz short loc_124C
mov rbp, rax
mov r14, rsp
lea r12, [rsp+368h+var_360]
mov r13d, 1
lea r15, asc_2009; " "
loc_1201:
mov [r12-8], rbp
mov rsi, r15
mov edi, 0
call _strtok
mov rbp, rax
test rax, rax
jz short loc_1245
test r13d, r13d
jle short loc_123B
mov rbx, r14
loc_1223:
mov rsi, rbp
mov rdi, [rbx]
call _strcmp
test eax, eax
jz short loc_124C
add rbx, 8
cmp rbx, r12
jnz short loc_1223
loc_123B:
add r13d, 1
add r12, 8
jmp short loc_1201
loc_1245:
lea rbp, aNone; "None"
loc_124C:
mov rax, [rsp+368h+var_40]
sub rax, fs:28h
jnz short loc_1274
mov rax, rbp
add rsp, 338h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1274:
call ___stack_chk_fail | const char * func0(long long a1)
{
long long v1; // rax
const char *v2; // rbp
char *v3; // r12
int i; // r13d
long long *v5; // rbx
long long v7; // [rsp+0h] [rbp-368h] BYREF
char v8; // [rsp+8h] [rbp-360h] BYREF
unsigned long long v9; // [rsp+328h] [rbp-40h]
v9 = __readfsqword(0x28u);
v1 = strtok(a1, " ");
v2 = "None";
if ( v1 )
{
v2 = (const char *)v1;
v3 = &v8;
for ( i = 1; ; ++i )
{
*((_QWORD *)v3 - 1) = v2;
v2 = (const char *)strtok(0LL, " ");
if ( !v2 )
return "None";
if ( i > 0 )
break;
LABEL_8:
v3 += 8;
}
v5 = &v7;
while ( (unsigned int)strcmp(*v5, v2) )
{
if ( ++v5 == (long long *)v3 )
goto LABEL_8;
}
}
return v2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x338
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x328],RAX
XOR EAX,EAX
LEA RSI,[0x102009]
CALL 0x001010b0
LEA RBP,[0x102004]
TEST RAX,RAX
JZ 0x0010124c
MOV RBP,RAX
MOV R14,RSP
LEA R12,[RSP + 0x8]
MOV R13D,0x1
LEA R15,[0x102009]
LAB_00101201:
MOV qword ptr [R12 + -0x8],RBP
MOV RSI,R15
MOV EDI,0x0
CALL 0x001010b0
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101245
TEST R13D,R13D
JLE 0x0010123b
MOV RBX,R14
LAB_00101223:
MOV RSI,RBP
MOV RDI,qword ptr [RBX]
CALL 0x001010a0
TEST EAX,EAX
JZ 0x0010124c
ADD RBX,0x8
CMP RBX,R12
JNZ 0x00101223
LAB_0010123b:
ADD R13D,0x1
ADD R12,0x8
JMP 0x00101201
LAB_00101245:
LEA RBP,[0x102004]
LAB_0010124c:
MOV RAX,qword ptr [RSP + 0x328]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101274
MOV RAX,RBP
ADD RSP,0x338
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101274:
CALL 0x00101080 | char * func0(char *param_1)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
int8 *puVar4;
char *__s2;
int iVar5;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = strtok(param_1," ");
__s2 = "None";
if (pcVar3 != (char *)0x0) {
iVar5 = 1;
__s2 = pcVar3;
puVar1 = local_368;
while( true ) {
*puVar1 = __s2;
__s2 = strtok((char *)0x0," ");
if (__s2 == (char *)0x0) break;
puVar4 = local_368;
if (0 < iVar5) {
do {
iVar2 = strcmp((char *)*puVar4,__s2);
if (iVar2 == 0) goto LAB_0010124c;
puVar4 = puVar4 + 1;
} while (puVar4 != puVar1 + 1);
}
iVar5 = iVar5 + 1;
puVar1 = puVar1 + 1;
}
__s2 = "None";
}
LAB_0010124c:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s2;
} |
6,042 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *str1) {
char *words[100];
int word_count = 0;
char *word = strtok(str1, " ");
while (word != NULL) {
for (int i = 0; i < word_count; i++) {
if (strcmp(words[i], word) == 0) {
return word;
}
}
words[word_count++] = word;
word = strtok(NULL, " ");
}
return "None";
}
| int main() {
char str1[] = "ab ca bc ab";
char str2[] = "ab ca bc";
char str3[] = "ab ca bc ca ab bc";
assert(strcmp(func0(str1), "ab") == 0);
assert(strcmp(func0(str2), "None") == 0);
assert(strcmp(func0(str3), "ca") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
lea 0xd1c(%rip),%rsi
push %r13
push %r12
push %rbp
push %rbx
sub $0x330,%rsp
mov %fs:0x28,%rax
mov %rax,0x328(%rsp)
xor %eax,%eax
callq 10b0 <strtok@plt>
test %rax,%rax
je 1396 <func0+0xb6>
mov %rax,%r12
mov %rsp,%r14
lea 0x8(%rsp),%rbp
lea 0xce0(%rip),%r13
mov %r13,%rsi
xor %edi,%edi
mov %r12,-0x8(%rbp)
callq 10b0 <strtok@plt>
mov %rax,%r12
test %rax,%rax
je 1396 <func0+0xb6>
mov %r14,%rbx
jmp 1351 <func0+0x71>
nopl 0x0(%rax)
add $0x8,%rbx
cmp %rbp,%rbx
je 1390 <func0+0xb0>
mov (%rbx),%rdi
mov %r12,%rsi
callq 10a0 <strcmp@plt>
test %eax,%eax
jne 1348 <func0+0x68>
mov 0x328(%rsp),%rax
xor %fs:0x28,%rax
jne 139f <func0+0xbf>
add $0x330,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x8,%rbp
jmp 1329 <func0+0x49>
lea 0xc67(%rip),%r12
jmp 1360 <func0+0x80>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r14
push r13
lea r13, asc_2009; " "
push r12
mov rsi, r13
push rbp
push rbx
sub rsp, 330h
mov rax, fs:28h
mov [rsp+358h+var_30], rax
xor eax, eax
call _strtok
test rax, rax
jz short loc_1376
mov r12, rax
mov r14, rsp
lea rbp, [rsp+358h+var_350]
loc_1315:
mov rsi, r13
xor edi, edi
mov [rbp-8], r12
call _strtok
mov r12, rax
test rax, rax
jz short loc_1376
mov rbx, r14
jmp short loc_1339
loc_1330:
add rbx, 8
cmp rbx, rbp
jz short loc_1370
loc_1339:
mov rdi, [rbx]
mov rsi, r12
call _strcmp
test eax, eax
jnz short loc_1330
loc_1348:
mov rax, [rsp+358h+var_30]
sub rax, fs:28h
jnz short loc_137F
add rsp, 330h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1370:
add rbp, 8
jmp short loc_1315
loc_1376:
lea r12, aNone; "None"
jmp short loc_1348
loc_137F:
call ___stack_chk_fail | const char * func0(long long a1)
{
long long v1; // rax
long long v2; // r12
char *v3; // rbp
long long *v4; // rbx
long long v6; // [rsp+0h] [rbp-358h] BYREF
char v7; // [rsp+8h] [rbp-350h] BYREF
unsigned long long v8; // [rsp+328h] [rbp-30h]
v8 = __readfsqword(0x28u);
v1 = strtok(a1, " ");
if ( !v1 )
return "None";
v2 = v1;
v3 = &v7;
LABEL_3:
*((_QWORD *)v3 - 1) = v2;
v2 = strtok(0LL, " ");
if ( !v2 )
return "None";
v4 = &v6;
while ( (unsigned int)strcmp(*v4, v2) )
{
if ( ++v4 == (long long *)v3 )
{
v3 += 8;
goto LABEL_3;
}
}
return (const char *)v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
LEA R13,[0x102009]
PUSH R12
MOV RSI,R13
PUSH RBP
PUSH RBX
SUB RSP,0x330
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x328],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST RAX,RAX
JZ 0x00101376
MOV R12,RAX
MOV R14,RSP
LEA RBP,[RSP + 0x8]
LAB_00101315:
MOV RSI,R13
XOR EDI,EDI
MOV qword ptr [RBP + -0x8],R12
CALL 0x001010b0
MOV R12,RAX
TEST RAX,RAX
JZ 0x00101376
MOV RBX,R14
JMP 0x00101339
LAB_00101330:
ADD RBX,0x8
CMP RBX,RBP
JZ 0x00101370
LAB_00101339:
MOV RDI,qword ptr [RBX]
MOV RSI,R12
CALL 0x001010a0
TEST EAX,EAX
JNZ 0x00101330
LAB_00101348:
MOV RAX,qword ptr [RSP + 0x328]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010137f
ADD RSP,0x330
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101370:
ADD RBP,0x8
JMP 0x00101315
LAB_00101376:
LEA R12,[0x102004]
JMP 0x00101348
LAB_0010137f:
CALL 0x00101080 | char * func0(char *param_1)
{
int8 *puVar1;
int iVar2;
char *__s2;
int8 *puVar3;
int8 *puVar4;
long in_FS_OFFSET;
int8 local_358 [101];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__s2 = strtok(param_1," ");
puVar1 = local_358;
if (__s2 != (char *)0x0) {
while( true ) {
puVar4 = puVar1 + 1;
*puVar1 = __s2;
__s2 = strtok((char *)0x0," ");
puVar3 = local_358;
if (__s2 == (char *)0x0) break;
do {
iVar2 = strcmp((char *)*puVar3,__s2);
if (iVar2 == 0) goto LAB_00101348;
puVar3 = puVar3 + 1;
puVar1 = puVar4;
} while (puVar3 != puVar4);
}
}
__s2 = "None";
LAB_00101348:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s2;
} |
6,043 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *str1) {
char *words[100];
int word_count = 0;
char *word = strtok(str1, " ");
while (word != NULL) {
for (int i = 0; i < word_count; i++) {
if (strcmp(words[i], word) == 0) {
return word;
}
}
words[word_count++] = word;
word = strtok(NULL, " ");
}
return "None";
}
| int main() {
char str1[] = "ab ca bc ab";
char str2[] = "ab ca bc";
char str3[] = "ab ca bc ca ab bc";
assert(strcmp(func0(str1), "ab") == 0);
assert(strcmp(func0(str2), "None") == 0);
assert(strcmp(func0(str3), "ca") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
lea 0xd1c(%rip),%rsi
push %r13
push %r12
push %rbp
push %rbx
sub $0x330,%rsp
mov %fs:0x28,%rax
mov %rax,0x328(%rsp)
xor %eax,%eax
callq 10b0 <strtok@plt>
test %rax,%rax
je 1396 <func0+0xb6>
mov %rax,%r12
mov %rsp,%r14
lea 0x8(%rsp),%rbp
lea 0xce0(%rip),%r13
mov %r13,%rsi
xor %edi,%edi
mov %r12,-0x8(%rbp)
callq 10b0 <strtok@plt>
mov %rax,%r12
test %rax,%rax
je 1396 <func0+0xb6>
mov %r14,%rbx
jmp 1351 <func0+0x71>
nopl 0x0(%rax)
add $0x8,%rbx
cmp %rbp,%rbx
je 1390 <func0+0xb0>
mov (%rbx),%rdi
mov %r12,%rsi
callq 10a0 <strcmp@plt>
test %eax,%eax
jne 1348 <func0+0x68>
mov 0x328(%rsp),%rax
xor %fs:0x28,%rax
jne 139f <func0+0xbf>
add $0x330,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x8,%rbp
jmp 1329 <func0+0x49>
lea 0xc67(%rip),%r12
jmp 1360 <func0+0x80>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r15
push r14
lea r14, delim; " "
push r13
mov rsi, r14; delim
push r12
push rbp
push rbx
sub rsp, 338h
mov rax, fs:28h
mov [rsp+368h+var_40], rax
xor eax, eax
call _strtok
test rax, rax
jz short loc_1383
mov r15, rsp
mov rbp, rax
mov r13, r15
loc_1315:
mov [r13+0], rbp
mov rsi, r14; delim
xor edi, edi; s
mov r12, r13
add r13, 8
call _strtok
mov rbp, rax
test rax, rax
jz short loc_1383
mov rbx, r15
jmp short loc_134C
loc_1340:
lea rax, [rbx+8]
cmp rbx, r12
jz short loc_1315
mov rbx, rax
loc_134C:
mov rdi, [rbx]; s1
mov rsi, rbp; s2
call _strcmp
test eax, eax
jnz short loc_1340
loc_135B:
mov rax, [rsp+368h+var_40]
sub rax, fs:28h
jnz short loc_138C
add rsp, 338h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1383:
lea rbp, s2; "None"
jmp short loc_135B
loc_138C:
call ___stack_chk_fail | const char * func0(char *a1)
{
char *v1; // rax
char *v2; // rbp
char **v3; // r13
const char **v4; // r12
const char **i; // rbx
_QWORD v7[109]; // [rsp+0h] [rbp-368h] BYREF
v7[101] = __readfsqword(0x28u);
v1 = strtok(a1, " ");
if ( !v1 )
return "None";
v2 = v1;
v3 = (char **)v7;
LABEL_3:
*v3 = v2;
v4 = (const char **)v3++;
v2 = strtok(0LL, " ");
if ( !v2 )
return "None";
for ( i = (const char **)v7; strcmp(*i, v2); ++i )
{
if ( i == v4 )
goto LABEL_3;
}
return v2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
LEA R14,[0x102009]
PUSH R13
MOV RSI,R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x338
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x328],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST RAX,RAX
JZ 0x00101383
MOV R15,RSP
MOV RBP,RAX
MOV R13,R15
LAB_00101315:
MOV qword ptr [R13],RBP
MOV RSI,R14
XOR EDI,EDI
MOV R12,R13
ADD R13,0x8
CALL 0x001010b0
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101383
MOV RBX,R15
JMP 0x0010134c
LAB_00101340:
LEA RAX,[RBX + 0x8]
CMP RBX,R12
JZ 0x00101315
MOV RBX,RAX
LAB_0010134c:
MOV RDI,qword ptr [RBX]
MOV RSI,RBP
CALL 0x001010a0
TEST EAX,EAX
JNZ 0x00101340
LAB_0010135b:
MOV RAX,qword ptr [RSP + 0x328]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010138c
ADD RSP,0x338
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101383:
LEA RBP,[0x102004]
JMP 0x0010135b
LAB_0010138c:
CALL 0x00101080 | char * func0(char *param_1)
{
int8 *puVar1;
int iVar2;
char *__s2;
int8 *puVar3;
int8 *puVar4;
long in_FS_OFFSET;
bool bVar5;
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s2 = strtok(param_1," ");
puVar1 = local_368;
if (__s2 != (char *)0x0) {
while( true ) {
puVar4 = puVar1;
*puVar4 = __s2;
__s2 = strtok((char *)0x0," ");
puVar3 = local_368;
if (__s2 == (char *)0x0) break;
do {
iVar2 = strcmp((char *)*puVar3,__s2);
if (iVar2 == 0) goto LAB_0010135b;
bVar5 = puVar3 != puVar4;
puVar3 = puVar3 + 1;
puVar1 = puVar4 + 1;
} while (bVar5);
}
}
__s2 = "None";
LAB_0010135b:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s2;
} |
6,044 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include<ctype.h>
typedef struct {
char values[100];
int length;
} tuple;
| tuple func0(const char *str1) {
tuple result;
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (!isspace(str1[i])) {
result.values[j++] = str1[i];
}
}
result.length = j;
return result;
}
| int main() {
tuple result;
result = func0("python 3.0");
char expected1[] = {'p', 'y', 't', 'h', 'o', 'n', '3', '.', '0'};
int length1 = sizeof(expected1);
assert(result.length == length1);
for (int i = 0; i < length1; i++) {
assert(result.values[i] == expected1[i]);
}
result = func0("bigdata");
char expected2[] = {'b', 'i', 'g', 'd', 'a', 't', 'a'};
int length2 = sizeof(expected2);
assert(result.length == length2);
for (int i = 0; i < length2; i++) {
assert(result.values[i] == expected2[i]);
}
result = func0("language");
char expected3[] = {'l', 'a', 'n', 'g', 'u', 'a', 'g','e'};
int length3 = sizeof(expected3);
assert(result.length == length3);
for (int i = 0; i < length3; i++) {
assert(result.values[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x88(%rbp)
movl $0x0,-0x84(%rbp)
jmp 1236 <func0+0xad>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x84(%rbp),%edx
movslq %edx,%rcx
mov -0xa0(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
jne 122f <func0+0xa6>
mov -0x84(%rbp),%eax
movslq %eax,%rdx
mov -0xa0(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x88(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x88(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x80(%rbp,%rax,1)
addl $0x1,-0x84(%rbp)
mov -0x84(%rbp),%eax
movslq %eax,%rdx
mov -0xa0(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11cc <func0+0x43>
mov -0x88(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x98(%rbp),%rax
mov -0x80(%rbp),%rcx
mov -0x78(%rbp),%rbx
mov %rcx,(%rax)
mov %rbx,0x8(%rax)
mov -0x70(%rbp),%rcx
mov -0x68(%rbp),%rbx
mov %rcx,0x10(%rax)
mov %rbx,0x18(%rax)
mov -0x60(%rbp),%rcx
mov -0x58(%rbp),%rbx
mov %rcx,0x20(%rax)
mov %rbx,0x28(%rax)
mov -0x50(%rbp),%rcx
mov -0x48(%rbp),%rbx
mov %rcx,0x30(%rax)
mov %rbx,0x38(%rax)
mov -0x40(%rbp),%rcx
mov -0x38(%rbp),%rbx
mov %rcx,0x40(%rax)
mov %rbx,0x48(%rax)
mov -0x30(%rbp),%rcx
mov -0x28(%rbp),%rbx
mov %rcx,0x50(%rax)
mov %rbx,0x58(%rax)
mov -0x20(%rbp),%rdx
mov %rdx,0x60(%rax)
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 12df <func0+0x156>
callq 1070 <__stack_chk_fail@plt>
mov -0x98(%rbp),%rax
add $0x98,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_88], 0
mov [rbp+var_84], 0
jmp short loc_1236
loc_11CC:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_84]
movsxd rcx, edx
mov rdx, [rbp+var_A0]
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, 2000h
test eax, eax
jnz short loc_122F
mov eax, [rbp+var_84]
movsxd rdx, eax
mov rax, [rbp+var_A0]
lea rcx, [rdx+rax]
mov eax, [rbp+var_88]
lea edx, [rax+1]
mov [rbp+var_88], edx
movzx edx, byte ptr [rcx]
cdqe
mov byte ptr [rbp+rax+var_80], dl
loc_122F:
add [rbp+var_84], 1
loc_1236:
mov eax, [rbp+var_84]
movsxd rdx, eax
mov rax, [rbp+var_A0]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11CC
mov eax, [rbp+var_88]
mov [rbp+var_1C], eax
mov rax, [rbp+var_98]
mov rcx, [rbp+var_80]
mov rbx, [rbp+var_78]
mov [rax], rcx
mov [rax+8], rbx
mov rcx, [rbp+var_70]
mov rbx, [rbp+var_68]
mov [rax+10h], rcx
mov [rax+18h], rbx
mov rcx, [rbp+var_60]
mov rbx, [rbp+var_58]
mov [rax+20h], rcx
mov [rax+28h], rbx
mov rcx, [rbp+var_50]
mov rbx, [rbp+var_48]
mov [rax+30h], rcx
mov [rax+38h], rbx
mov rcx, [rbp+var_40]
mov rbx, [rbp+var_38]
mov [rax+40h], rcx
mov [rax+48h], rbx
mov rcx, [rbp+var_30]
mov rbx, [rbp+var_28]
mov [rax+50h], rcx
mov [rax+58h], rbx
mov rdx, [rbp-20h]
mov [rax+60h], rdx
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_12DF
call ___stack_chk_fail
loc_12DF:
mov rax, [rbp+var_98]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(_QWORD *a1, long long a2)
{
int v2; // eax
long long v3; // rbx
long long v4; // rbx
long long v5; // rbx
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
int v10; // [rsp+18h] [rbp-88h]
int i; // [rsp+1Ch] [rbp-84h]
_QWORD v12[12]; // [rsp+20h] [rbp-80h]
long long v13; // [rsp+80h] [rbp-20h]
unsigned long long v14; // [rsp+88h] [rbp-18h]
v14 = __readfsqword(0x28u);
v10 = 0;
for ( i = 0; *(_BYTE *)(i + a2); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)(i + a2)] & 0x2000) == 0 )
{
v2 = v10++;
*((_BYTE *)v12 + v2) = *(_BYTE *)(i + a2);
}
}
HIDWORD(v13) = v10;
v3 = v12[1];
*a1 = v12[0];
a1[1] = v3;
v4 = v12[3];
a1[2] = v12[2];
a1[3] = v4;
v5 = v12[5];
a1[4] = v12[4];
a1[5] = v5;
v6 = v12[7];
a1[6] = v12[6];
a1[7] = v6;
v7 = v12[9];
a1[8] = v12[8];
a1[9] = v7;
v8 = v12[11];
a1[10] = v12[10];
a1[11] = v8;
a1[12] = v13;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x88],0x0
MOV dword ptr [RBP + -0x84],0x0
JMP 0x00101236
LAB_001011cc:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x84]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0xa0]
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,0x2000
TEST EAX,EAX
JNZ 0x0010122f
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa0]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x88]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x88],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x80],DL
LAB_0010122f:
ADD dword ptr [RBP + -0x84],0x1
LAB_00101236:
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa0]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011cc
MOV EAX,dword ptr [RBP + -0x88]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0x80]
MOV RBX,qword ptr [RBP + -0x78]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],RBX
MOV RCX,qword ptr [RBP + -0x70]
MOV RBX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RAX + 0x18],RBX
MOV RCX,qword ptr [RBP + -0x60]
MOV RBX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RAX + 0x28],RBX
MOV RCX,qword ptr [RBP + -0x50]
MOV RBX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x30],RCX
MOV qword ptr [RAX + 0x38],RBX
MOV RCX,qword ptr [RBP + -0x40]
MOV RBX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x40],RCX
MOV qword ptr [RAX + 0x48],RBX
MOV RCX,qword ptr [RBP + -0x30]
MOV RBX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x50],RCX
MOV qword ptr [RAX + 0x58],RBX
MOV RDX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x60],RDX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001012df
CALL 0x00101070
LAB_001012df:
MOV RAX,qword ptr [RBP + -0x98]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int8 * func0(int8 *param_1,long param_2)
{
ushort **ppuVar1;
long in_FS_OFFSET;
int local_90;
int local_8c;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int4 local_28;
int iStack_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_90 = 0;
for (local_8c = 0; *(char *)(param_2 + local_8c) != '\0'; local_8c = local_8c + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_2 + local_8c)] & 0x2000) == 0) {
*(int *)((long)&local_88 + (long)local_90) = *(int *)(local_8c + param_2);
local_90 = local_90 + 1;
}
}
iStack_24 = local_90;
*param_1 = local_88;
param_1[1] = local_80;
param_1[2] = local_78;
param_1[3] = local_70;
param_1[4] = local_68;
param_1[5] = local_60;
param_1[6] = local_58;
param_1[7] = local_50;
param_1[8] = local_48;
param_1[9] = local_40;
param_1[10] = local_38;
param_1[0xb] = local_30;
param_1[0xc] = CONCAT44(local_90,local_28);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
6,045 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include<ctype.h>
typedef struct {
char values[100];
int length;
} tuple;
| tuple func0(const char *str1) {
tuple result;
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (!isspace(str1[i])) {
result.values[j++] = str1[i];
}
}
result.length = j;
return result;
}
| int main() {
tuple result;
result = func0("python 3.0");
char expected1[] = {'p', 'y', 't', 'h', 'o', 'n', '3', '.', '0'};
int length1 = sizeof(expected1);
assert(result.length == length1);
for (int i = 0; i < length1; i++) {
assert(result.values[i] == expected1[i]);
}
result = func0("bigdata");
char expected2[] = {'b', 'i', 'g', 'd', 'a', 't', 'a'};
int length2 = sizeof(expected2);
assert(result.length == length2);
for (int i = 0; i < length2; i++) {
assert(result.values[i] == expected2[i]);
}
result = func0("language");
char expected3[] = {'l', 'a', 'n', 'g', 'u', 'a', 'g','e'};
int length3 = sizeof(expected3);
assert(result.length == length3);
for (int i = 0; i < length3; i++) {
assert(result.values[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movzbl (%rsi),%ebx
test %bl,%bl
je 11e7 <func0+0x5e>
mov %rsi,%rbp
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rcx
lea 0x1(%rbp),%rsi
mov $0x0,%edx
jmp 11d1 <func0+0x48>
add $0x1,%rsi
movzbl -0x1(%rsi),%ebx
test %bl,%bl
je 11ec <func0+0x63>
movsbq %bl,%rax
testb $0x20,0x1(%rcx,%rax,2)
jne 11c5 <func0+0x3c>
movslq %edx,%rax
mov %bl,(%rsp,%rax,1)
lea 0x1(%rdx),%edx
jmp 11c5 <func0+0x3c>
mov $0x0,%edx
mov %edx,0x64(%rsp)
movdqa (%rsp),%xmm0
movups %xmm0,(%r12)
movdqa 0x10(%rsp),%xmm1
movups %xmm1,0x10(%r12)
movdqa 0x20(%rsp),%xmm2
movups %xmm2,0x20(%r12)
movdqa 0x30(%rsp),%xmm3
movups %xmm3,0x30(%r12)
movdqa 0x40(%rsp),%xmm4
movups %xmm4,0x40(%r12)
movdqa 0x50(%rsp),%xmm5
movups %xmm5,0x50(%r12)
mov 0x60(%rsp),%rax
mov %rax,0x60(%r12)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 125c <func0+0xd3>
mov %r12,%rax
add $0x70,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 70h
mov r12, rdi
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
movzx ebx, byte ptr [rsi]
test bl, bl
jz short loc_11E7
mov rbp, rsi
call ___ctype_b_loc
mov rcx, [rax]
lea rsi, [rbp+1]
mov edx, 0
jmp short loc_11D1
loc_11C5:
add rsi, 1
movzx ebx, byte ptr [rsi-1]
test bl, bl
jz short loc_11EC
loc_11D1:
movsx rax, bl
test byte ptr [rcx+rax*2+1], 20h
jnz short loc_11C5
movsxd rax, edx
mov byte ptr [rsp+rax+88h+var_88], bl
lea edx, [rdx+1]
jmp short loc_11C5
loc_11E7:
mov edx, 0
loc_11EC:
mov [rsp+88h+var_24], edx
movdqa xmm0, [rsp+88h+var_88]
movups xmmword ptr [r12], xmm0
movdqa xmm1, [rsp+88h+var_78]
movups xmmword ptr [r12+10h], xmm1
movdqa xmm2, [rsp+88h+var_68]
movups xmmword ptr [r12+20h], xmm2
movdqa xmm3, [rsp+88h+var_58]
movups xmmword ptr [r12+30h], xmm3
movdqa xmm4, [rsp+88h+var_48]
movups xmmword ptr [r12+40h], xmm4
movdqa xmm5, [rsp+88h+var_38]
movups xmmword ptr [r12+50h], xmm5
mov rax, [rsp+60h]
mov [r12+60h], rax
mov rax, [rsp+88h+var_20]
sub rax, fs:28h
jnz short loc_125C
mov rax, r12
add rsp, 70h
pop rbx
pop rbp
pop r12
retn
loc_125C:
call ___stack_chk_fail | __m128i * func0(__m128i *a1, __int8 *a2)
{
__int8 v2; // bl
long long v3; // rcx
__int8 *v4; // rsi
int v5; // edx
__m128i v7; // [rsp+0h] [rbp-88h] BYREF
__m128i v8; // [rsp+10h] [rbp-78h] BYREF
__m128i v9; // [rsp+20h] [rbp-68h] BYREF
__m128i v10; // [rsp+30h] [rbp-58h] BYREF
__m128i v11; // [rsp+40h] [rbp-48h] BYREF
__m128i v12; // [rsp+50h] [rbp-38h] BYREF
long long v13; // [rsp+60h] [rbp-28h]
unsigned long long v14; // [rsp+68h] [rbp-20h]
v14 = __readfsqword(0x28u);
v2 = *a2;
if ( *a2 )
{
v3 = *(_QWORD *)__ctype_b_loc();
v4 = a2 + 1;
v5 = 0;
do
{
if ( (*(_BYTE *)(v3 + 2LL * v2 + 1) & 0x20) == 0 )
v7.m128i_i8[v5++] = v2;
v2 = *v4++;
}
while ( v2 );
}
else
{
v5 = 0;
}
HIDWORD(v13) = v5;
*a1 = _mm_load_si128(&v7);
a1[1] = _mm_load_si128(&v8);
a1[2] = _mm_load_si128(&v9);
a1[3] = _mm_load_si128(&v10);
a1[4] = _mm_load_si128(&v11);
a1[5] = _mm_load_si128(&v12);
a1[6].m128i_i64[0] = v13;
return a1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOVZX EBX,byte ptr [RSI]
TEST BL,BL
JZ 0x001011e7
MOV RBP,RSI
CALL 0x00101090
MOV RCX,qword ptr [RAX]
LEA RSI,[RBP + 0x1]
MOV EDX,0x0
JMP 0x001011d1
LAB_001011c5:
ADD RSI,0x1
MOVZX EBX,byte ptr [RSI + -0x1]
TEST BL,BL
JZ 0x001011ec
LAB_001011d1:
MOVSX RAX,BL
TEST byte ptr [RCX + RAX*0x2 + 0x1],0x20
JNZ 0x001011c5
MOVSXD RAX,EDX
MOV byte ptr [RSP + RAX*0x1],BL
LEA EDX,[RDX + 0x1]
JMP 0x001011c5
LAB_001011e7:
MOV EDX,0x0
LAB_001011ec:
MOV dword ptr [RSP + 0x64],EDX
MOVDQA XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [R12],XMM0
MOVDQA XMM1,xmmword ptr [RSP + 0x10]
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOVDQA XMM2,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [R12 + 0x20],XMM2
MOVDQA XMM3,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [R12 + 0x30],XMM3
MOVDQA XMM4,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [R12 + 0x40],XMM4
MOVDQA XMM5,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [R12 + 0x50],XMM5
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [R12 + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010125c
MOV RAX,R12
ADD RSP,0x70
POP RBX
POP RBP
POP R12
RET
LAB_0010125c:
CALL 0x00101070 | int8 * func0(int8 *param_1,char *param_2)
{
ushort *puVar1;
ushort **ppuVar2;
char cVar3;
char *pcVar4;
long in_FS_OFFSET;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
int4 local_28;
int iStack_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar3 = *param_2;
if (cVar3 == '\0') {
iStack_24 = 0;
}
else {
ppuVar2 = __ctype_b_loc();
puVar1 = *ppuVar2;
iStack_24 = 0;
pcVar4 = param_2 + 1;
do {
if ((*(byte *)((long)puVar1 + (long)cVar3 * 2 + 1) & 0x20) == 0) {
*(char *)((long)&local_88 + (long)iStack_24) = cVar3;
iStack_24 = iStack_24 + 1;
}
cVar3 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar3 != '\0');
}
*param_1 = local_88;
param_1[1] = uStack_80;
param_1[2] = local_78;
param_1[3] = uStack_70;
param_1[4] = local_68;
param_1[5] = uStack_60;
param_1[6] = local_58;
param_1[7] = uStack_50;
param_1[8] = local_48;
param_1[9] = uStack_40;
param_1[10] = local_38;
param_1[0xb] = uStack_30;
param_1[0xc] = CONCAT44(iStack_24,local_28);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,046 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include<ctype.h>
typedef struct {
char values[100];
int length;
} tuple;
| tuple func0(const char *str1) {
tuple result;
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (!isspace(str1[i])) {
result.values[j++] = str1[i];
}
}
result.length = j;
return result;
}
| int main() {
tuple result;
result = func0("python 3.0");
char expected1[] = {'p', 'y', 't', 'h', 'o', 'n', '3', '.', '0'};
int length1 = sizeof(expected1);
assert(result.length == length1);
for (int i = 0; i < length1; i++) {
assert(result.values[i] == expected1[i]);
}
result = func0("bigdata");
char expected2[] = {'b', 'i', 'g', 'd', 'a', 't', 'a'};
int length2 = sizeof(expected2);
assert(result.length == length2);
for (int i = 0; i < length2; i++) {
assert(result.values[i] == expected2[i]);
}
result = func0("language");
char expected3[] = {'l', 'a', 'n', 'g', 'u', 'a', 'g','e'};
int length3 = sizeof(expected3);
assert(result.length == length3);
for (int i = 0; i < length3; i++) {
assert(result.values[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x70,%rsp
movzbl (%rsi),%ebx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
test %bl,%bl
je 1460 <func0+0xd0>
mov %rsi,%rbp
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rsi
xor %edx,%edx
mov (%rax),%rcx
nopl 0x0(%rax,%rax,1)
movsbq %bl,%rax
testb $0x20,0x1(%rcx,%rax,2)
jne 13e4 <func0+0x54>
movslq %edx,%rax
add $0x1,%edx
mov %bl,(%rsp,%rax,1)
movzbl (%rsi),%ebx
add $0x1,%rsi
test %bl,%bl
jne 13d0 <func0+0x40>
movdqa (%rsp),%xmm0
movdqa 0x10(%rsp),%xmm1
mov %edx,0x64(%rsp)
mov 0x60(%rsp),%rax
movdqa 0x20(%rsp),%xmm2
movdqa 0x30(%rsp),%xmm3
movdqa 0x40(%rsp),%xmm4
movups %xmm0,(%r12)
mov %rax,0x60(%r12)
movdqa 0x50(%rsp),%xmm5
movups %xmm1,0x10(%r12)
movups %xmm2,0x20(%r12)
movups %xmm3,0x30(%r12)
movups %xmm4,0x40(%r12)
movups %xmm5,0x50(%r12)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 1464 <func0+0xd4>
add $0x70,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
xor %edx,%edx
jmp 13ef <func0+0x5f>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 70h
movzx ebx, byte ptr [rsi]
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
test bl, bl
jz loc_1460
mov rbp, rsi
call ___ctype_b_loc
lea rsi, [rbp+1]
xor edx, edx
mov rcx, [rax]
nop dword ptr [rax+rax+00h]
loc_13D0:
movsx rax, bl
test byte ptr [rcx+rax*2+1], 20h
jnz short loc_13E4
movsxd rax, edx
add edx, 1
mov byte ptr [rsp+rax+88h+var_88], bl
loc_13E4:
movzx ebx, byte ptr [rsi]
add rsi, 1
test bl, bl
jnz short loc_13D0
loc_13EF:
movdqa xmm0, [rsp+88h+var_88]
movdqa xmm1, [rsp+88h+var_78]
mov [rsp+88h+var_24], edx
mov rax, [rsp+60h]
movdqa xmm2, [rsp+88h+var_68]
movdqa xmm3, [rsp+88h+var_58]
movdqa xmm4, [rsp+88h+var_48]
movups xmmword ptr [r12], xmm0
movdqa xmm5, [rsp+88h+var_38]
mov [r12+60h], rax
movups xmmword ptr [r12+10h], xmm1
movups xmmword ptr [r12+20h], xmm2
movups xmmword ptr [r12+30h], xmm3
movups xmmword ptr [r12+40h], xmm4
movups xmmword ptr [r12+50h], xmm5
mov rax, [rsp+88h+var_20]
sub rax, fs:28h
jnz short loc_1464
add rsp, 70h
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_1460:
xor edx, edx
jmp short loc_13EF
loc_1464:
call ___stack_chk_fail | __m128i * func0(__m128i *a1, __int8 *a2)
{
__int8 v2; // bl
long long *v3; // rax
__int8 *v4; // rsi
int v5; // edx
long long v6; // rcx
long long v7; // rax
__m128i v8; // xmm0
__m128i v9; // xmm1
long long v10; // rax
__m128i v11; // xmm2
__m128i v12; // xmm3
__m128i v13; // xmm4
__m128i v14; // xmm5
__m128i v16; // [rsp+0h] [rbp-88h] BYREF
__m128i v17; // [rsp+10h] [rbp-78h] BYREF
__m128i v18; // [rsp+20h] [rbp-68h] BYREF
__m128i v19; // [rsp+30h] [rbp-58h] BYREF
__m128i v20; // [rsp+40h] [rbp-48h] BYREF
__m128i v21; // [rsp+50h] [rbp-38h] BYREF
long long v22; // [rsp+60h] [rbp-28h]
unsigned long long v23; // [rsp+68h] [rbp-20h]
v2 = *a2;
v23 = __readfsqword(0x28u);
if ( v2 )
{
v3 = (long long *)__ctype_b_loc();
v4 = a2 + 1;
v5 = 0;
v6 = *v3;
do
{
if ( (*(_BYTE *)(v6 + 2LL * v2 + 1) & 0x20) == 0 )
{
v7 = v5++;
v16.m128i_i8[v7] = v2;
}
v2 = *v4++;
}
while ( v2 );
}
else
{
v5 = 0;
}
v8 = _mm_load_si128(&v16);
v9 = _mm_load_si128(&v17);
HIDWORD(v22) = v5;
v10 = v22;
v11 = _mm_load_si128(&v18);
v12 = _mm_load_si128(&v19);
v13 = _mm_load_si128(&v20);
*a1 = v8;
v14 = _mm_load_si128(&v21);
a1[6].m128i_i64[0] = v10;
a1[1] = v9;
a1[2] = v11;
a1[3] = v12;
a1[4] = v13;
a1[5] = v14;
return a1;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOVZX EBX,byte ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
TEST BL,BL
JZ 0x00101460
MOV RBP,RSI
CALL 0x00101090
LEA RSI,[RBP + 0x1]
XOR EDX,EDX
MOV RCX,qword ptr [RAX]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
MOVSX RAX,BL
TEST byte ptr [RCX + RAX*0x2 + 0x1],0x20
JNZ 0x001013e4
MOVSXD RAX,EDX
ADD EDX,0x1
MOV byte ptr [RSP + RAX*0x1],BL
LAB_001013e4:
MOVZX EBX,byte ptr [RSI]
ADD RSI,0x1
TEST BL,BL
JNZ 0x001013d0
LAB_001013ef:
MOVDQA XMM0,xmmword ptr [RSP]
MOVDQA XMM1,xmmword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x64],EDX
MOV RAX,qword ptr [RSP + 0x60]
MOVDQA XMM2,xmmword ptr [RSP + 0x20]
MOVDQA XMM3,xmmword ptr [RSP + 0x30]
MOVDQA XMM4,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [R12],XMM0
MOVDQA XMM5,xmmword ptr [RSP + 0x50]
MOV qword ptr [R12 + 0x60],RAX
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOVUPS xmmword ptr [R12 + 0x20],XMM2
MOVUPS xmmword ptr [R12 + 0x30],XMM3
MOVUPS xmmword ptr [R12 + 0x40],XMM4
MOVUPS xmmword ptr [R12 + 0x50],XMM5
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101464
ADD RSP,0x70
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_00101460:
XOR EDX,EDX
JMP 0x001013ef
LAB_00101464:
CALL 0x00101070 | int8 * func0(int8 *param_1,char *param_2)
{
ushort *puVar1;
ushort **ppuVar2;
long lVar3;
char cVar4;
long in_FS_OFFSET;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
int4 local_28;
int iStack_24;
long local_20;
cVar4 = *param_2;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar4 == '\0') {
iStack_24 = 0;
}
else {
ppuVar2 = __ctype_b_loc();
param_2 = param_2 + 1;
iStack_24 = 0;
puVar1 = *ppuVar2;
do {
if ((*(byte *)((long)puVar1 + (long)cVar4 * 2 + 1) & 0x20) == 0) {
lVar3 = (long)iStack_24;
iStack_24 = iStack_24 + 1;
*(char *)((long)&local_88 + lVar3) = cVar4;
}
cVar4 = *param_2;
param_2 = param_2 + 1;
} while (cVar4 != '\0');
}
*param_1 = local_88;
param_1[1] = uStack_80;
param_1[0xc] = CONCAT44(iStack_24,local_28);
param_1[2] = local_78;
param_1[3] = uStack_70;
param_1[4] = local_68;
param_1[5] = uStack_60;
param_1[6] = local_58;
param_1[7] = uStack_50;
param_1[8] = local_48;
param_1[9] = uStack_40;
param_1[10] = local_38;
param_1[0xb] = uStack_30;
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,047 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include<ctype.h>
typedef struct {
char values[100];
int length;
} tuple;
| tuple func0(const char *str1) {
tuple result;
int j = 0;
for (int i = 0; str1[i] != '\0'; i++) {
if (!isspace(str1[i])) {
result.values[j++] = str1[i];
}
}
result.length = j;
return result;
}
| int main() {
tuple result;
result = func0("python 3.0");
char expected1[] = {'p', 'y', 't', 'h', 'o', 'n', '3', '.', '0'};
int length1 = sizeof(expected1);
assert(result.length == length1);
for (int i = 0; i < length1; i++) {
assert(result.values[i] == expected1[i]);
}
result = func0("bigdata");
char expected2[] = {'b', 'i', 'g', 'd', 'a', 't', 'a'};
int length2 = sizeof(expected2);
assert(result.length == length2);
for (int i = 0; i < length2; i++) {
assert(result.values[i] == expected2[i]);
}
result = func0("language");
char expected3[] = {'l', 'a', 'n', 'g', 'u', 'a', 'g','e'};
int length3 = sizeof(expected3);
assert(result.length == length3);
for (int i = 0; i < length3; i++) {
assert(result.values[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x70,%rsp
movzbl (%rsi),%ebx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
test %bl,%bl
je 1550 <func0+0xf0>
mov %rsi,%rbp
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rsi
mov (%rax),%rcx
xor %eax,%eax
nopl 0x0(%rax,%rax,1)
movsbq %bl,%rdx
testb $0x20,0x1(%rcx,%rdx,2)
jne 14cb <func0+0x6b>
add $0x1,%rsi
mov %bl,(%rsp,%rax,1)
lea 0x1(%rax),%edx
movzbl -0x1(%rsi),%ebx
test %bl,%bl
je 14d8 <func0+0x78>
movslq %edx,%rax
movsbq %bl,%rdx
testb $0x20,0x1(%rcx,%rdx,2)
je 14ab <func0+0x4b>
movzbl (%rsi),%ebx
add $0x1,%rsi
test %bl,%bl
jne 14a0 <func0+0x40>
mov %eax,%edx
movdqa (%rsp),%xmm0
movdqa 0x10(%rsp),%xmm1
mov %edx,0x64(%rsp)
mov 0x60(%rsp),%rax
movdqa 0x20(%rsp),%xmm2
movdqa 0x30(%rsp),%xmm3
movdqa 0x40(%rsp),%xmm4
movups %xmm0,(%r12)
mov %rax,0x60(%r12)
movdqa 0x50(%rsp),%xmm5
movups %xmm1,0x10(%r12)
movups %xmm2,0x20(%r12)
movups %xmm3,0x30(%r12)
movups %xmm4,0x40(%r12)
movups %xmm5,0x50(%r12)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 1554 <func0+0xf4>
add $0x70,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
jmp 14d8 <func0+0x78>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 70h
movzx ebx, byte ptr [rsi]
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
test bl, bl
jz loc_14B8
mov rbp, rsi
call ___ctype_b_loc
lea rsi, [rbp+1]
mov rcx, [rax]
xor eax, eax
nop dword ptr [rax+rax+00h]
loc_1400:
movsx rdx, bl
test byte ptr [rcx+rdx*2+1], 20h
jnz short loc_142F
loc_140B:
add rsi, 1
mov byte ptr [rsp+rax+88h+var_88], bl
lea edx, [rax+1]
movzx ebx, byte ptr [rsi-1]
test bl, bl
jz loc_14B0
movsxd rax, edx
movsx rdx, bl
test byte ptr [rcx+rdx*2+1], 20h
jz short loc_140B
loc_142F:
movzx ebx, byte ptr [rsi]
add rsi, 1
test bl, bl
jnz short loc_1400
loc_143A:
movdqa xmm0, [rsp+88h+var_88]
movdqa xmm1, [rsp+88h+var_78]
mov [rsp+88h+var_24], eax
mov rax, [rsp+60h]
movdqa xmm2, [rsp+88h+var_68]
movdqa xmm3, [rsp+88h+var_58]
movdqa xmm4, [rsp+88h+var_48]
movups xmmword ptr [r12], xmm0
movdqa xmm5, [rsp+88h+var_38]
mov [r12+60h], rax
movups xmmword ptr [r12+10h], xmm1
movups xmmword ptr [r12+20h], xmm2
movups xmmword ptr [r12+30h], xmm3
movups xmmword ptr [r12+40h], xmm4
movups xmmword ptr [r12+50h], xmm5
mov rax, [rsp+88h+var_20]
sub rax, fs:28h
jnz short loc_14BF
add rsp, 70h
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_14B0:
mov eax, edx
jmp short loc_143A
loc_14B8:
xor eax, eax
jmp loc_143A
loc_14BF:
call ___stack_chk_fail | __m128i * func0(__m128i *a1, __int8 *a2)
{
__int8 v2; // bl
__int8 *v3; // rsi
const unsigned __int16 *v4; // rcx
long long v5; // rax
__m128i v6; // xmm0
__m128i v7; // xmm1
long long v8; // rax
__m128i v9; // xmm2
__m128i v10; // xmm3
__m128i v11; // xmm4
__m128i v12; // xmm5
__m128i v14; // [rsp+0h] [rbp-88h] BYREF
__m128i v15; // [rsp+10h] [rbp-78h] BYREF
__m128i v16; // [rsp+20h] [rbp-68h] BYREF
__m128i v17; // [rsp+30h] [rbp-58h] BYREF
__m128i v18; // [rsp+40h] [rbp-48h] BYREF
__m128i v19; // [rsp+50h] [rbp-38h] BYREF
long long v20; // [rsp+60h] [rbp-28h]
unsigned long long v21; // [rsp+68h] [rbp-20h]
v2 = *a2;
v21 = __readfsqword(0x28u);
if ( v2 )
{
v3 = a2 + 1;
v4 = *__ctype_b_loc();
v5 = 0LL;
while ( (v4[v2] & 0x2000) != 0 )
{
LABEL_6:
v2 = *v3++;
if ( !v2 )
goto LABEL_7;
}
while ( 1 )
{
++v3;
v14.m128i_i8[v5] = v2;
v2 = *(v3 - 1);
if ( !v2 )
break;
v5 = (int)v5 + 1;
if ( (v4[v2] & 0x2000) != 0 )
goto LABEL_6;
}
LODWORD(v5) = v5 + 1;
}
else
{
LODWORD(v5) = 0;
}
LABEL_7:
v6 = _mm_load_si128(&v14);
v7 = _mm_load_si128(&v15);
HIDWORD(v20) = v5;
v8 = v20;
v9 = _mm_load_si128(&v16);
v10 = _mm_load_si128(&v17);
v11 = _mm_load_si128(&v18);
*a1 = v6;
v12 = _mm_load_si128(&v19);
a1[6].m128i_i64[0] = v8;
a1[1] = v7;
a1[2] = v9;
a1[3] = v10;
a1[4] = v11;
a1[5] = v12;
return a1;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOVZX EBX,byte ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
TEST BL,BL
JZ 0x001014b8
MOV RBP,RSI
CALL 0x00101090
LEA RSI,[RBP + 0x1]
MOV RCX,qword ptr [RAX]
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101400:
MOVSX RDX,BL
TEST byte ptr [RCX + RDX*0x2 + 0x1],0x20
JNZ 0x0010142f
LAB_0010140b:
ADD RSI,0x1
MOV byte ptr [RSP + RAX*0x1],BL
LEA EDX,[RAX + 0x1]
MOVZX EBX,byte ptr [RSI + -0x1]
TEST BL,BL
JZ 0x001014b0
MOVSXD RAX,EDX
MOVSX RDX,BL
TEST byte ptr [RCX + RDX*0x2 + 0x1],0x20
JZ 0x0010140b
LAB_0010142f:
MOVZX EBX,byte ptr [RSI]
ADD RSI,0x1
TEST BL,BL
JNZ 0x00101400
LAB_0010143a:
MOVDQA XMM0,xmmword ptr [RSP]
MOVDQA XMM1,xmmword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x64],EAX
MOV RAX,qword ptr [RSP + 0x60]
MOVDQA XMM2,xmmword ptr [RSP + 0x20]
MOVDQA XMM3,xmmword ptr [RSP + 0x30]
MOVDQA XMM4,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [R12],XMM0
MOVDQA XMM5,xmmword ptr [RSP + 0x50]
MOV qword ptr [R12 + 0x60],RAX
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOVUPS xmmword ptr [R12 + 0x20],XMM2
MOVUPS xmmword ptr [R12 + 0x30],XMM3
MOVUPS xmmword ptr [R12 + 0x40],XMM4
MOVUPS xmmword ptr [R12 + 0x50],XMM5
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014bf
ADD RSP,0x70
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_001014b0:
MOV EAX,EDX
JMP 0x0010143a
LAB_001014b8:
XOR EAX,EAX
JMP 0x0010143a
LAB_001014bf:
CALL 0x00101070 | int8 * func0(int8 *param_1,char *param_2)
{
byte bVar1;
ushort *puVar2;
ushort **ppuVar3;
ulong uVar4;
uint uVar5;
char cVar6;
long in_FS_OFFSET;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
int4 local_28;
int4 uStack_24;
long local_20;
cVar6 = *param_2;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar6 == '\0') {
uVar4 = 0;
}
else {
ppuVar3 = __ctype_b_loc();
param_2 = param_2 + 1;
puVar2 = *ppuVar3;
uVar4 = 0;
do {
bVar1 = *(byte *)((long)puVar2 + (long)cVar6 * 2 + 1);
while ((bVar1 & 0x20) == 0) {
*(char *)((long)&local_88 + uVar4) = cVar6;
uVar5 = (int)uVar4 + 1;
uVar4 = (ulong)uVar5;
cVar6 = *param_2;
if (cVar6 == '\0') goto LAB_0010143a;
uVar4 = (ulong)(int)uVar5;
param_2 = param_2 + 1;
bVar1 = *(byte *)((long)puVar2 + (long)cVar6 * 2 + 1);
}
cVar6 = *param_2;
param_2 = param_2 + 1;
} while (cVar6 != '\0');
}
LAB_0010143a:
uStack_24 = (int4)uVar4;
*param_1 = local_88;
param_1[1] = uStack_80;
param_1[0xc] = CONCAT44(uStack_24,local_28);
param_1[2] = local_78;
param_1[3] = uStack_70;
param_1[4] = local_68;
param_1[5] = uStack_60;
param_1[6] = local_58;
param_1[7] = uStack_50;
param_1[8] = local_48;
param_1[9] = uStack_40;
param_1[10] = local_38;
param_1[0xb] = uStack_30;
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,048 | func0 | #include <assert.h>
#include <math.h>
| double* func0(int bases_num[], int index[], int length, double result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(bases_num[i], index[i]);
}
return result;
}
| int main() {
int bases_num1[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double expected1[] = {10, 400, 27000, 2560000, 312500000, 46656000000, 8235430000000, 1677721600000000, 387420489000000000, 100000000000000000000.0};
double result1[10];
func0(bases_num1, index1, 10, result1);
for (int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
int bases_num2[] = {1, 2, 3, 4, 5, 6, 7};
int index2[] = {10, 20, 30, 40, 50, 60, 70};
double expected2[] = {1, 1048576, 205891132094649.0, 1208925819614629174706176.0, 88817841970012523233890533447265625.0, 48873677980689257489322752273774603865660850176.0, 143503601609868434285603076356671071740077383739246066639249.0};
double result2[7];
func0(bases_num2, index2, 7, result2);
for (int i = 0; i < 7; i++) {
assert(result2[i] == expected2[i]);
}
int bases_num3[] = {4, 8, 12, 16, 20, 24, 28};
int index3[] = {3, 6, 9, 12, 15, 18, 21};
double expected3[] = {64, 262144, 5159780352.0, 281474976710656.0, 32768000000000000000.0, 6979147079584381377970176.0, 2456510688823056210273111113728.0};
double result3[7];
func0(bases_num3, index3, 7, result3);
for (int i = 0; i < 7; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %rcx,-0x40(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1208 <func0+0x7f>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm1
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm0
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x40(%rbp),%rax
lea (%rdx,%rax,1),%rbx
callq 1070 <pow@plt>
movq %xmm0,%rax
mov %rax,(%rbx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 11ae <func0+0x25>
mov -0x40(%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_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_40], rcx
mov [rbp+var_14], 0
jmp short loc_121F
loc_11AE:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov eax, [rax]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movq rax, xmm2
mov edx, [rbp+var_14]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_40]
lea rbx, [rcx+rdx]
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
mov [rbx], rax
add [rbp+var_14], 1
loc_121F:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_34]
jl short loc_11AE
mov rax, [rbp+var_40]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-14h]
for ( i = 0; i < a3; ++i )
*(double *)(8LL * i + a4) = pow((double)*(int *)(4LL * i + a1), (double)*(int *)(4LL * i + a2));
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010121f
LAB_001011ae:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVQ RAX,XMM2
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x40]
LEA RBX,[RCX + RDX*0x1]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOV qword ptr [RBX],RAX
ADD dword ptr [RBP + -0x14],0x1
LAB_0010121f:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x001011ae
MOV RAX,qword ptr [RBP + -0x40]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | long func0(long param_1,long param_2,int param_3,long param_4)
{
double dVar1;
int4 local_1c;
for (local_1c = 0; local_1c < param_3; local_1c = local_1c + 1) {
dVar1 = pow((double)*(int *)(param_1 + (long)local_1c * 4),
(double)*(int *)(param_2 + (long)local_1c * 4));
*(double *)((long)local_1c * 8 + param_4) = dVar1;
}
return param_4;
} |
6,049 | func0 | #include <assert.h>
#include <math.h>
| double* func0(int bases_num[], int index[], int length, double result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(bases_num[i], index[i]);
}
return result;
}
| int main() {
int bases_num1[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double expected1[] = {10, 400, 27000, 2560000, 312500000, 46656000000, 8235430000000, 1677721600000000, 387420489000000000, 100000000000000000000.0};
double result1[10];
func0(bases_num1, index1, 10, result1);
for (int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
int bases_num2[] = {1, 2, 3, 4, 5, 6, 7};
int index2[] = {10, 20, 30, 40, 50, 60, 70};
double expected2[] = {1, 1048576, 205891132094649.0, 1208925819614629174706176.0, 88817841970012523233890533447265625.0, 48873677980689257489322752273774603865660850176.0, 143503601609868434285603076356671071740077383739246066639249.0};
double result2[7];
func0(bases_num2, index2, 7, result2);
for (int i = 0; i < 7; i++) {
assert(result2[i] == expected2[i]);
}
int bases_num3[] = {4, 8, 12, 16, 20, 24, 28};
int index3[] = {3, 6, 9, 12, 15, 18, 21};
double expected3[] = {64, 262144, 5159780352.0, 281474976710656.0, 32768000000000000000.0, 6979147079584381377970176.0, 2456510688823056210273111113728.0};
double result3[7];
func0(bases_num3, index3, 7, result3);
for (int i = 0; i < 7; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rcx,%rbp
test %edx,%edx
jle 11d7 <func0+0x4e>
mov %rdi,%r12
mov %rsi,%r13
lea -0x1(%rdx),%r14d
mov $0x0,%ebx
pxor %xmm0,%xmm0
cvtsi2sdl (%r12,%rbx,4),%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%r13,%rbx,4),%xmm1
callq 1070 <pow@plt>
movsd %xmm0,0x0(%rbp,%rbx,8)
mov %rbx,%rax
add $0x1,%rbx
cmp %r14,%rax
jne 11ab <func0+0x22>
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rcx
test edx, edx
jle short loc_11D2
mov r13, rdi
mov r14, rsi
mov ebp, edx
mov ebx, 0
loc_11A9:
pxor xmm0, xmm0
cvtsi2sd xmm0, dword ptr [r13+rbx*4+0]
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [r14+rbx*4]
call _pow
movsd qword ptr [r12+rbx*8], xmm0
add rbx, 1
cmp rbx, rbp
jnz short loc_11A9
loc_11D2:
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long v5; // rbp
long long i; // rbx
if ( a3 > 0 )
{
v5 = (unsigned int)a3;
for ( i = 0LL; i != v5; ++i )
*(double *)(a4 + 8 * i) = pow((double)*(int *)(a1 + 4 * i), (double)*(int *)(a2 + 4 * i));
}
return a4;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RCX
TEST EDX,EDX
JLE 0x001011d2
MOV R13,RDI
MOV R14,RSI
MOV EBP,EDX
MOV EBX,0x0
LAB_001011a9:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [R13 + RBX*0x4]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [R14 + RBX*0x4]
CALL 0x00101070
MOVSD qword ptr [R12 + RBX*0x8],XMM0
ADD RBX,0x1
CMP RBX,RBP
JNZ 0x001011a9
LAB_001011d2:
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | long func0(long param_1,long param_2,uint param_3,long param_4)
{
ulong uVar1;
double dVar2;
if (0 < (int)param_3) {
uVar1 = 0;
do {
dVar2 = pow((double)*(int *)(param_1 + uVar1 * 4),(double)*(int *)(param_2 + uVar1 * 4));
*(double *)(param_4 + uVar1 * 8) = dVar2;
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return param_4;
} |
6,050 | func0 | #include <assert.h>
#include <math.h>
| double* func0(int bases_num[], int index[], int length, double result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(bases_num[i], index[i]);
}
return result;
}
| int main() {
int bases_num1[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double expected1[] = {10, 400, 27000, 2560000, 312500000, 46656000000, 8235430000000, 1677721600000000, 387420489000000000, 100000000000000000000.0};
double result1[10];
func0(bases_num1, index1, 10, result1);
for (int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
int bases_num2[] = {1, 2, 3, 4, 5, 6, 7};
int index2[] = {10, 20, 30, 40, 50, 60, 70};
double expected2[] = {1, 1048576, 205891132094649.0, 1208925819614629174706176.0, 88817841970012523233890533447265625.0, 48873677980689257489322752273774603865660850176.0, 143503601609868434285603076356671071740077383739246066639249.0};
double result2[7];
func0(bases_num2, index2, 7, result2);
for (int i = 0; i < 7; i++) {
assert(result2[i] == expected2[i]);
}
int bases_num3[] = {4, 8, 12, 16, 20, 24, 28};
int index3[] = {3, 6, 9, 12, 15, 18, 21};
double expected3[] = {64, 262144, 5159780352.0, 281474976710656.0, 32768000000000000000.0, 6979147079584381377970176.0, 2456510688823056210273111113728.0};
double result3[7];
func0(bases_num3, index3, 7, result3);
for (int i = 0; i < 7; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
test %edx,%edx
jle 163c <func0+0x4c>
mov %rdi,%rbp
mov %rsi,%r13
lea -0x1(%rdx),%r14d
xor %ebx,%ebx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
cvtsi2sdl 0x0(%r13,%rbx,4),%xmm1
callq 1070 <pow@plt>
mov %rbx,%rax
movsd %xmm0,(%r12,%rbx,8)
add $0x1,%rbx
cmp %r14,%rax
jne 1610 <func0+0x20>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
mov r12, rcx
push rbp
push rbx
test edx, edx
jle short loc_1639
mov r13, rdi
mov r14, rsi
movsxd rbp, edx
xor ebx, ebx
xchg ax, ax
loc_1610:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [r13+rbx*4+0]
cvtsi2sd xmm1, dword ptr [r14+rbx*4]
call _pow
movsd qword ptr [r12+rbx*8], xmm0
add rbx, 1
cmp rbp, rbx
jnz short loc_1610
loc_1639:
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long v5; // rbp
long long i; // rbx
if ( a3 > 0 )
{
v5 = a3;
for ( i = 0LL; i != v5; ++i )
*(double *)(a4 + 8 * i) = pow((double)*(int *)(a1 + 4 * i), (double)*(int *)(a2 + 4 * i));
}
return a4;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST EDX,EDX
JLE 0x00101639
MOV R13,RDI
MOV R14,RSI
MOVSXD RBP,EDX
XOR EBX,EBX
NOP
LAB_00101610:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [R13 + RBX*0x4]
CVTSI2SD XMM1,dword ptr [R14 + RBX*0x4]
CALL 0x00101070
MOVSD qword ptr [R12 + RBX*0x8],XMM0
ADD RBX,0x1
CMP RBP,RBX
JNZ 0x00101610
LAB_00101639:
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
POP R14
RET | long func0(long param_1,long param_2,int param_3,long param_4)
{
long lVar1;
double dVar2;
if (0 < param_3) {
lVar1 = 0;
do {
dVar2 = pow((double)*(int *)(param_1 + lVar1 * 4),(double)*(int *)(param_2 + lVar1 * 4));
*(double *)(param_4 + lVar1 * 8) = dVar2;
lVar1 = lVar1 + 1;
} while (param_3 != lVar1);
}
return param_4;
} |
6,051 | func0 | #include <assert.h>
#include <math.h>
| double* func0(int bases_num[], int index[], int length, double result[]) {
for(int i = 0; i < length; i++) {
result[i] = pow(bases_num[i], index[i]);
}
return result;
}
| int main() {
int bases_num1[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double expected1[] = {10, 400, 27000, 2560000, 312500000, 46656000000, 8235430000000, 1677721600000000, 387420489000000000, 100000000000000000000.0};
double result1[10];
func0(bases_num1, index1, 10, result1);
for (int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
int bases_num2[] = {1, 2, 3, 4, 5, 6, 7};
int index2[] = {10, 20, 30, 40, 50, 60, 70};
double expected2[] = {1, 1048576, 205891132094649.0, 1208925819614629174706176.0, 88817841970012523233890533447265625.0, 48873677980689257489322752273774603865660850176.0, 143503601609868434285603076356671071740077383739246066639249.0};
double result2[7];
func0(bases_num2, index2, 7, result2);
for (int i = 0; i < 7; i++) {
assert(result2[i] == expected2[i]);
}
int bases_num3[] = {4, 8, 12, 16, 20, 24, 28};
int index3[] = {3, 6, 9, 12, 15, 18, 21};
double expected3[] = {64, 262144, 5159780352.0, 281474976710656.0, 32768000000000000000.0, 6979147079584381377970176.0, 2456510688823056210273111113728.0};
double result3[7];
func0(bases_num3, index3, 7, result3);
for (int i = 0; i < 7; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
test %edx,%edx
jle 174c <func0+0x4c>
mov %rdi,%rbp
mov %rsi,%r13
lea -0x1(%rdx),%r14d
xor %ebx,%ebx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
cvtsi2sdl 0x0(%r13,%rbx,4),%xmm1
callq 1070 <pow@plt>
mov %rbx,%rax
movsd %xmm0,(%r12,%rbx,8)
add $0x1,%rbx
cmp %r14,%rax
jne 1720 <func0+0x20>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
mov r12, rcx
push rbp
push rbx
test edx, edx
jle short loc_1659
movsxd rdx, edx
mov r13, rdi
mov r14, rsi
xor ebx, ebx
lea rbp, ds:0[rdx*4]
nop word ptr [rax+rax+00000000h]
loc_1630:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [r13+rbx+0]; x
cvtsi2sd xmm1, dword ptr [r14+rbx]; y
call _pow
movsd qword ptr [r12+rbx*2], xmm0
add rbx, 4
cmp rbp, rbx
jnz short loc_1630
loc_1659:
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // rbp
if ( a3 > 0 )
{
v5 = 0LL;
v6 = 4LL * a3;
do
{
*(double *)(a4 + 2 * v5) = pow((double)*(int *)(a1 + v5), (double)*(int *)(a2 + v5));
v5 += 4LL;
}
while ( v6 != v5 );
}
return a4;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST EDX,EDX
JLE 0x00101659
MOVSXD RDX,EDX
MOV R13,RDI
MOV R14,RSI
XOR EBX,EBX
LEA RBP,[RDX*0x4]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101630:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [R13 + RBX*0x1]
CVTSI2SD XMM1,dword ptr [R14 + RBX*0x1]
CALL 0x00101070
MOVSD qword ptr [R12 + RBX*0x2],XMM0
ADD RBX,0x4
CMP RBP,RBX
JNZ 0x00101630
LAB_00101659:
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
POP R14
RET | long func0(long param_1,long param_2,int param_3,long param_4)
{
long lVar1;
double dVar2;
if (0 < param_3) {
lVar1 = 0;
do {
dVar2 = pow((double)*(int *)(param_1 + lVar1),(double)*(int *)(param_2 + lVar1));
*(double *)(param_4 + lVar1 * 2) = dVar2;
lVar1 = lVar1 + 4;
} while ((long)param_3 * 4 - lVar1 != 0);
}
return param_4;
} |
6,052 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sortArray(int *arr, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
| int func0(int *arr, int n) {
sortArray(arr, n);
int count = 0, max_count = 0, min_count = n;
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) {
count++;
continue;
} else {
max_count = (max_count > count) ? max_count : count;
min_count = (min_count < count) ? min_count : count;
count = 0;
}
}
return max_count - min_count;
}
| int main() {
int arr1[10] = {1, 1, 2, 2, 7, 8, 4, 5, 1, 4};
int arr2[9] = {1, 7, 9, 2, 3, 3, 1, 3, 3};
int arr3[4] = {1, 2, 1, 2};
assert(func0(arr1, 10) == 2);
assert(func0(arr2, 9) == 3);
assert(func0(arr3, 4) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1169 <sortArray>
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 12f8 <func0+0xa0>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 12d3 <func0+0x7b>
addl $0x1,-0x10(%rbp)
jmp 12f4 <func0+0x9c>
mov -0xc(%rbp),%eax
cmp %eax,-0x10(%rbp)
cmovge -0x10(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x8(%rbp),%eax
cmp %eax,-0x10(%rbp)
cmovle -0x10(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 1299 <func0+0x41>
mov -0xc(%rbp),%eax
sub -0x8(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov edx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call sortArray
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_1C]
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_12FA
loc_1299:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_12D3
add [rbp+var_10], 1
jmp short loc_12F6
loc_12D3:
mov edx, [rbp+var_C]
mov eax, [rbp+var_10]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_C], eax
mov edx, [rbp+var_8]
mov eax, [rbp+var_10]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_8], eax
mov [rbp+var_10], 0
loc_12F6:
add [rbp+var_4], 1
loc_12FA:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_1299
mov eax, [rbp+var_C]
sub eax, [rbp+var_8]
leave
retn | long long func0(long long a1, unsigned int a2)
{
int v2; // eax
int v3; // eax
int v5; // [rsp+10h] [rbp-10h]
int v6; // [rsp+14h] [rbp-Ch]
signed int v7; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
sortArray(a1, a2);
v5 = 0;
v6 = 0;
v7 = a2;
for ( i = 0; i < (int)(a2 - 1); ++i )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4 * (i + 1LL) + a1) )
{
++v5;
}
else
{
v2 = v5;
if ( v6 >= v5 )
v2 = v6;
v6 = v2;
v3 = v5;
if ( v7 <= v5 )
v3 = v7;
v7 = v3;
v5 = 0;
}
}
return (unsigned int)(v6 - v7);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101169
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012fa
LAB_00101299:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001012d3
ADD dword ptr [RBP + -0x10],0x1
JMP 0x001012f6
LAB_001012d3:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x10]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x10]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x10],0x0
LAB_001012f6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001012fa:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101299
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x8]
LEAVE
RET | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
sortArray(param_1,param_2);
local_18 = 0;
local_14 = 0;
local_10 = param_2;
for (local_c = 0; local_c < param_2 + -1; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) == *(int *)(param_1 + ((long)local_c + 1) * 4)) {
local_18 = local_18 + 1;
}
else {
iVar1 = local_18;
if (local_18 <= local_14) {
iVar1 = local_14;
}
iVar2 = local_18;
if (local_10 <= local_18) {
iVar2 = local_10;
}
local_18 = 0;
local_14 = iVar1;
local_10 = iVar2;
}
}
return local_14 - local_10;
} |
6,053 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sortArray(int *arr, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
| int func0(int *arr, int n) {
sortArray(arr, n);
int count = 0, max_count = 0, min_count = n;
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) {
count++;
continue;
} else {
max_count = (max_count > count) ? max_count : count;
min_count = (min_count < count) ? min_count : count;
count = 0;
}
}
return max_count - min_count;
}
| int main() {
int arr1[10] = {1, 1, 2, 2, 7, 8, 4, 5, 1, 4};
int arr2[9] = {1, 7, 9, 2, 3, 3, 1, 3, 3};
int arr3[4] = {1, 2, 1, 2};
assert(func0(arr1, 10) == 2);
assert(func0(arr2, 9) == 3);
assert(func0(arr3, 4) == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
callq 1169 <sortArray>
cmp $0x1,%ebx
jle 11fe <func0+0x50>
mov %rbp,%rdx
lea -0x2(%rbx),%eax
lea 0x4(%rbp,%rax,4),%rsi
mov $0x0,%eax
mov $0x0,%ecx
jmp 11e6 <func0+0x38>
add $0x1,%ecx
add $0x4,%rdx
cmp %rsi,%rdx
je 1203 <func0+0x55>
mov 0x4(%rdx),%edi
cmp %edi,(%rdx)
je 11da <func0+0x2c>
cmp %ecx,%eax
cmovl %ecx,%eax
cmp %ecx,%ebx
cmovg %ecx,%ebx
mov $0x0,%ecx
jmp 11dd <func0+0x2f>
mov $0x0,%eax
sub %ebx,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
call sortArray
cmp ebx, 1
jle short loc_11FE
mov rdx, rbp
lea eax, [rbx-2]
lea rsi, [rbp+rax*4+4]
mov eax, 0
mov ecx, 0
jmp short loc_11E6
loc_11DA:
add ecx, 1
loc_11DD:
add rdx, 4
cmp rdx, rsi
jz short loc_1203
loc_11E6:
mov edi, [rdx+4]
cmp [rdx], edi
jz short loc_11DA
cmp eax, ecx
cmovl eax, ecx
cmp ebx, ecx
cmovg ebx, ecx
mov ecx, 0
jmp short loc_11DD
loc_11FE:
mov eax, 0
loc_1203:
sub eax, ebx
pop rbx
pop rbp
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // ebx
_DWORD *v3; // rdx
long long v4; // rsi
int v5; // eax
int v6; // ecx
v2 = a2;
sortArray();
if ( a2 <= 1 )
{
v5 = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 2 + 1];
v5 = 0;
v6 = 0;
do
{
if ( *v3 == v3[1] )
{
++v6;
}
else
{
if ( v5 < v6 )
v5 = v6;
if ( v2 > v6 )
v2 = v6;
v6 = 0;
}
++v3;
}
while ( v3 != (_DWORD *)v4 );
}
return (unsigned int)(v5 - v2);
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
CALL 0x00101169
CMP EBX,0x1
JLE 0x001011fe
MOV RDX,RBP
LEA EAX,[RBX + -0x2]
LEA RSI,[RBP + RAX*0x4 + 0x4]
MOV EAX,0x0
MOV ECX,0x0
JMP 0x001011e6
LAB_001011da:
ADD ECX,0x1
LAB_001011dd:
ADD RDX,0x4
CMP RDX,RSI
JZ 0x00101203
LAB_001011e6:
MOV EDI,dword ptr [RDX + 0x4]
CMP dword ptr [RDX],EDI
JZ 0x001011da
CMP EAX,ECX
CMOVL EAX,ECX
CMP EBX,ECX
CMOVG EBX,ECX
MOV ECX,0x0
JMP 0x001011dd
LAB_001011fe:
MOV EAX,0x0
LAB_00101203:
SUB EAX,EBX
POP RBX
POP RBP
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
sortArray();
if (param_2 < 2) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
iVar2 = 0;
iVar3 = 0;
do {
if (*param_1 == param_1[1]) {
iVar3 = iVar3 + 1;
}
else {
if (iVar2 < iVar3) {
iVar2 = iVar3;
}
if (iVar3 < param_2) {
param_2 = iVar3;
}
iVar3 = 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2 - param_2;
} |
6,054 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sortArray(int *arr, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
| int func0(int *arr, int n) {
sortArray(arr, n);
int count = 0, max_count = 0, min_count = n;
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) {
count++;
continue;
} else {
max_count = (max_count > count) ? max_count : count;
min_count = (min_count < count) ? min_count : count;
count = 0;
}
}
return max_count - min_count;
}
| int main() {
int arr1[10] = {1, 1, 2, 2, 7, 8, 4, 5, 1, 4};
int arr2[9] = {1, 7, 9, 2, 3, 3, 1, 3, 3};
int arr3[4] = {1, 2, 1, 2};
assert(func0(arr1, 10) == 2);
assert(func0(arr2, 9) == 3);
assert(func0(arr3, 4) == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%r10d
callq 12e0 <sortArray>
cmp $0x1,%r10d
jle 1380 <func0+0x60>
lea -0x2(%r10),%eax
xor %edx,%edx
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
jmp 135f <func0+0x3f>
nopl 0x0(%rax)
cmp %edx,%eax
cmovl %edx,%eax
cmp %edx,%r10d
cmovg %edx,%r10d
add $0x4,%rdi
xor %edx,%edx
cmp %rcx,%rdi
je 1372 <func0+0x52>
mov 0x4(%rdi),%esi
cmp %esi,(%rdi)
jne 1348 <func0+0x28>
add $0x4,%rdi
add $0x1,%edx
cmp %rcx,%rdi
jne 135f <func0+0x3f>
sub %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xor %eax,%eax
sub %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r10d, esi
call sortArray
cmp r10d, 1
jle short loc_1380
lea eax, [r10-2]
xor edx, edx
lea rcx, [rdi+rax*4+4]
xor eax, eax
jmp short loc_135F
loc_1348:
cmp eax, edx
cmovl eax, edx
cmp r10d, edx
cmovg r10d, edx
add rdi, 4
xor edx, edx
cmp rdi, rcx
jz short loc_1372
loc_135F:
mov esi, [rdi+4]
cmp [rdi], esi
jnz short loc_1348
add rdi, 4
add edx, 1
cmp rdi, rcx
jnz short loc_135F
loc_1372:
sub eax, r10d
retn
loc_1380:
xor eax, eax
sub eax, r10d
retn | long long func0(_DWORD *a1)
{
int v1; // r10d
int v2; // edx
long long v3; // rcx
int v4; // eax
sortArray();
if ( v1 <= 1 )
return (unsigned int)-v1;
v2 = 0;
v3 = (long long)&a1[v1 - 2 + 1];
v4 = 0;
do
{
while ( *a1 == a1[1] )
{
++a1;
++v2;
if ( a1 == (_DWORD *)v3 )
return (unsigned int)(v4 - v1);
}
if ( v4 < v2 )
v4 = v2;
if ( v1 > v2 )
v1 = v2;
++a1;
v2 = 0;
}
while ( a1 != (_DWORD *)v3 );
return (unsigned int)(v4 - v1);
} | func0:
ENDBR64
MOV R10D,ESI
CALL 0x001012e0
CMP R10D,0x1
JLE 0x00101380
LEA EAX,[R10 + -0x2]
XOR EDX,EDX
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
JMP 0x0010135f
LAB_00101348:
CMP EAX,EDX
CMOVL EAX,EDX
CMP R10D,EDX
CMOVG R10D,EDX
ADD RDI,0x4
XOR EDX,EDX
CMP RDI,RCX
JZ 0x00101372
LAB_0010135f:
MOV ESI,dword ptr [RDI + 0x4]
CMP dword ptr [RDI],ESI
JNZ 0x00101348
ADD RDI,0x4
ADD EDX,0x1
CMP RDI,RCX
JNZ 0x0010135f
LAB_00101372:
SUB EAX,R10D
RET
LAB_00101380:
XOR EAX,EAX
SUB EAX,R10D
RET | int func0(int *param_1,ulong param_2)
{
int *piVar1;
uint uVar2;
uint uVar3;
int iVar4;
param_2 = param_2 & 0xffffffff;
sortArray();
iVar4 = (int)param_2;
if (iVar4 < 2) {
return -iVar4;
}
uVar3 = 0;
piVar1 = param_1 + (ulong)(iVar4 - 2) + 1;
uVar2 = 0;
do {
while (iVar4 = (int)param_2, *param_1 == param_1[1]) {
param_1 = param_1 + 1;
uVar3 = uVar3 + 1;
if (param_1 == piVar1) goto LAB_00101372;
}
if ((int)uVar2 < (int)uVar3) {
uVar2 = uVar3;
}
param_2 = param_2 & 0xffffffff;
if ((int)uVar3 < iVar4) {
param_2 = (ulong)uVar3;
}
iVar4 = (int)param_2;
param_1 = param_1 + 1;
uVar3 = 0;
} while (param_1 != piVar1);
LAB_00101372:
return uVar2 - iVar4;
} |
6,055 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sortArray(int *arr, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
| int func0(int *arr, int n) {
sortArray(arr, n);
int count = 0, max_count = 0, min_count = n;
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) {
count++;
continue;
} else {
max_count = (max_count > count) ? max_count : count;
min_count = (min_count < count) ? min_count : count;
count = 0;
}
}
return max_count - min_count;
}
| int main() {
int arr1[10] = {1, 1, 2, 2, 7, 8, 4, 5, 1, 4};
int arr2[9] = {1, 7, 9, 2, 3, 3, 1, 3, 3};
int arr3[4] = {1, 2, 1, 2};
assert(func0(arr1, 10) == 2);
assert(func0(arr2, 9) == 3);
assert(func0(arr3, 4) == 0);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%edx
test %edx,%edx
jle 1380 <func0+0xa0>
lea 0x4(%rdi),%rcx
nopl 0x0(%rax,%rax,1)
lea -0x1(%rdx),%r8d
mov %rdi,%rax
mov %r8,%rdx
lea (%rcx,%r8,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 1323 <func0+0x43>
mov %r9d,(%rax)
mov %r8d,0x4(%rax)
add $0x4,%rax
cmp %rax,%r10
jne 1310 <func0+0x30>
test %edx,%edx
jne 12f8 <func0+0x18>
lea -0x2(%rsi),%eax
mov %rcx,%rdx
mov (%rdi),%r8d
xor %ecx,%ecx
lea 0x8(%rdi,%rax,4),%r9
xor %eax,%eax
jmp 135d <func0+0x7d>
nopl 0x0(%rax)
cmp %ecx,%eax
cmovl %ecx,%eax
cmp %ecx,%esi
cmovg %ecx,%esi
add $0x4,%rdx
xor %ecx,%ecx
cmp %rdx,%r9
je 1374 <func0+0x94>
mov %r8d,%edi
mov (%rdx),%r8d
cmp %edi,%r8d
jne 1348 <func0+0x68>
add $0x4,%rdx
add $0x1,%ecx
cmp %rdx,%r9
jne 135d <func0+0x7d>
sub %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
sub %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rsi-1]
mov r8, rdi
mov edi, esi
test eax, eax
jle loc_13AE
cdqe
lea r10d, [rdi-2]
shl rax, 2
shl r10, 2
lea r9, [r8+rax-4]
lea rsi, [rax+r8]
sub r9, r10
xchg ax, ax
loc_1330:
mov rax, r8
nop dword ptr [rax+rax+00h]
loc_1338:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_1356
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_1356:
add rax, 4
cmp rax, rsi
jnz short loc_1338
lea rsi, [rax-4]
cmp rsi, r9
jnz short loc_1330
mov esi, [r8]
lea rcx, [r8+4]
lea r9, [r8+r10+8]
xor eax, eax
xor edx, edx
jmp short loc_1395
loc_1380:
cmp eax, edx
cmovl eax, edx
cmp edi, edx
cmovg edi, edx
add rcx, 4
xor edx, edx
cmp rcx, r9
jz short loc_13AB
loc_1395:
mov r8d, esi
mov esi, [rcx]
cmp esi, r8d
jnz short loc_1380
add rcx, 4
add edx, 1
cmp rcx, r9
jnz short loc_1395
loc_13AB:
sub eax, edi
retn
loc_13AE:
xor eax, eax
sub eax, edi
retn | long long func0(__m128i *a1, int a2)
{
int v3; // edi
long long v4; // r10
__m128i *v5; // rsi
__m128i *v6; // r9
__m128i *v7; // rax
__m128i v8; // xmm0
__int32 v9; // esi
__int32 *v10; // rcx
long long v11; // r9
int v12; // eax
int v13; // edx
__int32 v14; // r8d
v3 = a2;
if ( a2 - 1 <= 0 )
return (unsigned int)-a2;
v4 = 4LL * (unsigned int)(a2 - 2);
v5 = (__m128i *)((char *)a1 + 4 * a2 - 4);
v6 = (__m128i *)((char *)v5->m128i_u64 - v4 - 4);
do
{
v7 = a1;
do
{
v8 = _mm_loadl_epi64(v7);
if ( _mm_cvtsi128_si32(v8) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v8, 229)) )
v7->m128i_i64[0] = _mm_shuffle_epi32(v8, 225).m128i_u64[0];
v7 = (__m128i *)((char *)v7 + 4);
}
while ( v7 != v5 );
v5 = (__m128i *)((char *)v7 - 4);
}
while ( (__m128i *)((char *)&v7[-1].m128i_u64[1] + 4) != v6 );
v9 = a1->m128i_i32[0];
v10 = &a1->m128i_i32[1];
v11 = (long long)&a1->m128i_i64[1] + v4;
v12 = 0;
v13 = 0;
do
{
while ( 1 )
{
v14 = v9;
v9 = *v10;
if ( *v10 != v14 )
break;
++v10;
++v13;
if ( v10 == (__int32 *)v11 )
return (unsigned int)(v12 - v3);
}
if ( v12 < v13 )
v12 = v13;
if ( v3 > v13 )
v3 = v13;
++v10;
v13 = 0;
}
while ( v10 != (__int32 *)v11 );
return (unsigned int)(v12 - v3);
} | func0:
ENDBR64
LEA EAX,[RSI + -0x1]
MOV R8,RDI
MOV EDI,ESI
TEST EAX,EAX
JLE 0x001013ae
CDQE
LEA R10D,[RDI + -0x2]
SHL RAX,0x2
SHL R10,0x2
LEA R9,[R8 + RAX*0x1 + -0x4]
LEA RSI,[RAX + R8*0x1]
SUB R9,R10
NOP
LAB_00101330:
MOV RAX,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_00101338:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x00101356
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_00101356:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101338
LEA RSI,[RAX + -0x4]
CMP RSI,R9
JNZ 0x00101330
MOV ESI,dword ptr [R8]
LEA RCX,[R8 + 0x4]
LEA R9,[R8 + R10*0x1 + 0x8]
XOR EAX,EAX
XOR EDX,EDX
JMP 0x00101395
LAB_00101380:
CMP EAX,EDX
CMOVL EAX,EDX
CMP EDI,EDX
CMOVG EDI,EDX
ADD RCX,0x4
XOR EDX,EDX
CMP RCX,R9
JZ 0x001013ab
LAB_00101395:
MOV R8D,ESI
MOV ESI,dword ptr [RCX]
CMP ESI,R8D
JNZ 0x00101380
ADD RCX,0x4
ADD EDX,0x1
CMP RCX,R9
JNZ 0x00101395
LAB_001013ab:
SUB EAX,EDI
RET
LAB_001013ae:
XOR EAX,EAX
SUB EAX,EDI
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int iVar5;
int *piVar6;
uint uVar7;
int iVar8;
iVar2 = param_2 + -1;
if (iVar2 < 1) {
return -param_2;
}
uVar7 = param_2 - 2;
piVar4 = param_1;
piVar6 = param_1 + iVar2;
do {
piVar3 = piVar4;
iVar8 = (int)*(int8 *)piVar3;
iVar5 = (int)((ulong)*(int8 *)piVar3 >> 0x20);
if (iVar5 < iVar8) {
*(ulong *)piVar3 = CONCAT44(iVar8,iVar5);
}
piVar4 = piVar3 + 1;
} while ((piVar3 + 1 != piVar6) ||
(piVar4 = param_1, piVar6 = piVar3, piVar3 != param_1 + (long)iVar2 + (-1 - (ulong)uVar7))
);
piVar4 = param_1 + 1;
iVar2 = 0;
iVar5 = 0;
iVar8 = *param_1;
do {
while (iVar1 = *piVar4, iVar1 == iVar8) {
piVar4 = piVar4 + 1;
iVar5 = iVar5 + 1;
iVar8 = iVar1;
if (piVar4 == param_1 + (ulong)uVar7 + 2) goto LAB_001013ab;
}
if (iVar2 < iVar5) {
iVar2 = iVar5;
}
if (iVar5 < param_2) {
param_2 = iVar5;
}
piVar4 = piVar4 + 1;
iVar5 = 0;
iVar8 = iVar1;
} while (piVar4 != param_1 + (ulong)uVar7 + 2);
LAB_001013ab:
return iVar2 - param_2;
} |
6,056 | func0 |
#include <math.h>
#include <assert.h>
double get_sum(int n) {
double sum = 0;
int i = 1;
while (i <= (int)(sqrt(n))) {
if (n % i == 0) {
if (n / i == i) {
sum = sum + i;
} else {
sum = sum + i;
sum = sum + (n / i);
}
}
i = i + 1;
}
sum = sum - n;
return sum;
}
| int func0(int n) {
if (get_sum(n) > n) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(12) == 1);
assert(func0(15) == 0);
assert(func0(18) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
mov %eax,%edi
callq 1169 <get_sum>
cvtsi2sdl -0x4(%rbp),%xmm1
comisd %xmm1,%xmm0
jbe 1240 <func0+0x2b>
mov $0x1,%eax
jmp 1245 <func0+0x30>
mov $0x0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
mov edi, eax
call get_sum
movq rax, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_4]
movq xmm1, rax
comisd xmm1, xmm0
jbe short loc_1270
mov eax, 1
jmp short locret_1275
loc_1270:
mov eax, 0
locret_1275:
leave
retn | _BOOL8 func0(int a1)
{
return get_sum((unsigned int)a1) > (double)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
MOV EDI,EAX
CALL 0x00101169
MOVQ RAX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x4]
MOVQ XMM1,RAX
COMISD XMM1,XMM0
JBE 0x00101270
MOV EAX,0x1
JMP 0x00101275
LAB_00101270:
MOV EAX,0x0
LAB_00101275:
LEAVE
RET | bool func0(int param_1)
{
double dVar1;
dVar1 = (double)get_sum(param_1);
return (double)param_1 < dVar1;
} |
6,057 | func0 |
#include <math.h>
#include <assert.h>
double get_sum(int n) {
double sum = 0;
int i = 1;
while (i <= (int)(sqrt(n))) {
if (n % i == 0) {
if (n / i == i) {
sum = sum + i;
} else {
sum = sum + i;
sum = sum + (n / i);
}
}
i = i + 1;
}
sum = sum - n;
return sum;
}
| int func0(int n) {
if (get_sum(n) > n) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(12) == 1);
assert(func0(15) == 0);
assert(func0(18) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
callq 1169 <get_sum>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
comisd %xmm0,%xmm1
seta %al
movzbl %al,%eax
pop %rbx
retq
| func0:
endbr64
push rbx
mov ebx, edi
call get_sum
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
comisd xmm1, xmm0
setnbe al
movzx eax, al
pop rbx
retn | _BOOL8 func0(int a1)
{
return get_sum() > (double)a1;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
CALL 0x00101169
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
COMISD XMM1,XMM0
SETA AL
MOVZX EAX,AL
POP RBX
RET | bool func0(int param_1)
{
double dVar1;
dVar1 = (double)get_sum();
return (double)param_1 < dVar1;
} |
6,058 | func0 |
#include <math.h>
#include <assert.h>
double get_sum(int n) {
double sum = 0;
int i = 1;
while (i <= (int)(sqrt(n))) {
if (n % i == 0) {
if (n / i == i) {
sum = sum + i;
} else {
sum = sum + i;
sum = sum + (n / i);
}
}
i = i + 1;
}
sum = sum - n;
return sum;
}
| int func0(int n) {
if (get_sum(n) > n) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(12) == 1);
assert(func0(15) == 0);
assert(func0(18) == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
callq 1220 <get_sum>
xor %eax,%eax
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
comisd %xmm0,%xmm1
seta %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbx
mov ebx, edi
call get_sum
xor eax, eax
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pop rbx
comisd xmm1, xmm0
setnbe al
retn | _BOOL8 func0(int a1)
{
return get_sum() > (double)a1;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
CALL 0x00101220
XOR EAX,EAX
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
POP RBX
COMISD XMM1,XMM0
SETA AL
RET | bool func0(int param_1)
{
double dVar1;
dVar1 = (double)get_sum();
return (double)param_1 < dVar1;
} |
6,059 | func0 |
#include <math.h>
#include <assert.h>
double get_sum(int n) {
double sum = 0;
int i = 1;
while (i <= (int)(sqrt(n))) {
if (n % i == 0) {
if (n / i == i) {
sum = sum + i;
} else {
sum = sum + i;
sum = sum + (n / i);
}
}
i = i + 1;
}
sum = sum - n;
return sum;
}
| int func0(int n) {
if (get_sum(n) > n) {
return 1;
} else {
return 0;
}
}
| int main() {
assert(func0(12) == 1);
assert(func0(15) == 0);
assert(func0(18) == 1);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm2,%xmm2
push %rbp
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm2
push %rbx
sub $0x28,%rsp
movapd %xmm2,%xmm0
ucomisd %xmm2,%xmm1
sqrtsd %xmm0,%xmm0
cvttsd2si %xmm0,%ebx
ja 1378 <func0+0x78>
lea 0x1(%rbx),%esi
mov $0x1,%ecx
test %ebx,%ebx
jle 1364 <func0+0x64>
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 135d <func0+0x5d>
pxor %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
addsd %xmm0,%xmm1
cmp %ecx,%eax
je 135d <func0+0x5d>
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd %xmm0,%xmm1
add $0x1,%ecx
cmp %esi,%ecx
jne 1338 <func0+0x38>
subsd %xmm2,%xmm1
xor %eax,%eax
comisd %xmm2,%xmm1
seta %al
add $0x28,%rsp
pop %rbx
pop %rbp
retq
mov $0x1,%ebp
jmp 13ab <func0+0xab>
mov 0x1c(%rsp),%edi
mov %edi,%eax
cltd
idiv %ebp
test %edx,%edx
jne 13a8 <func0+0xa8>
pxor %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
addsd %xmm0,%xmm1
cmp %eax,%ebp
je 13a8 <func0+0xa8>
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd %xmm0,%xmm1
add $0x1,%ebp
movapd %xmm2,%xmm0
movsd %xmm1,0x10(%rsp)
movsd %xmm2,0x8(%rsp)
mov %edi,0x1c(%rsp)
callq 1070 <sqrt@plt>
cmp %ebx,%ebp
movsd 0x8(%rsp),%xmm2
movsd 0x10(%rsp),%xmm1
jle 137f <func0+0x7f>
jmp 1364 <func0+0x64>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm2, xmm2
pxor xmm0, xmm0
cvtsi2sd xmm2, edi
ucomisd xmm0, xmm2
ja short loc_136A
movapd xmm0, xmm2
pxor xmm1, xmm1
mov ecx, 1
sqrtsd xmm0, xmm0
cvttsd2si esi, xmm0
test esi, esi
jle short loc_135C
nop
loc_1330:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1355
pxor xmm0, xmm0
cvtsi2sd xmm0, ecx
addsd xmm1, xmm0
cmp ecx, eax
jz short loc_1355
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
addsd xmm1, xmm0
loc_1355:
add ecx, 1
cmp esi, ecx
jge short loc_1330
loc_135C:
subsd xmm1, xmm2
xor eax, eax
comisd xmm1, xmm2
setnbe al
retn
loc_136A:
push rbx
pxor xmm1, xmm1
mov ebx, 1
sub rsp, 20h
jmp short loc_13A6
loc_137A:
mov edi, [rsp+28h+var_C]
mov eax, edi
cdq
idiv ebx
test edx, edx
jnz short loc_13A3
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
addsd xmm1, xmm0
cmp ebx, eax
jz short loc_13A3
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
addsd xmm1, xmm0
loc_13A3:
add ebx, 1
loc_13A6:
movapd xmm0, xmm2; x
movsd [rsp+28h+var_18], xmm1
movsd [rsp+28h+var_20], xmm2
mov [rsp+28h+var_C], edi
call _sqrt
movsd xmm2, [rsp+28h+var_20]
movsd xmm1, [rsp+28h+var_18]
cvttsd2si eax, xmm0
cmp ebx, eax
jle short loc_137A
subsd xmm1, xmm2
xor eax, eax
comisd xmm1, xmm2
setnbe al
add rsp, 20h
pop rbx
retn | _BOOL8 func0(int a1)
{
double v1; // xmm2_8
double v2; // xmm1_8
int v3; // ecx
int v4; // esi
int v5; // eax
double v7; // xmm1_8
int i; // ebx
int v9; // eax
v1 = (double)a1;
if ( (double)a1 < 0.0 )
{
v7 = 0.0;
for ( i = 1; i <= (int)sqrt(v1); ++i )
{
v9 = a1 / i;
if ( !(a1 % i) )
{
v7 = v7 + (double)i;
if ( i != v9 )
v7 = v7 + (double)v9;
}
}
return v7 - v1 > v1;
}
else
{
v2 = 0.0;
v3 = 1;
v4 = (int)sqrt(v1);
if ( v4 > 0 )
{
do
{
v5 = a1 / v3;
if ( !(a1 % v3) )
{
v2 = v2 + (double)v3;
if ( v3 != v5 )
v2 = v2 + (double)v5;
}
++v3;
}
while ( v4 >= v3 );
}
return v2 - v1 > v1;
}
} | func0:
ENDBR64
PXOR XMM2,XMM2
PXOR XMM0,XMM0
CVTSI2SD XMM2,EDI
UCOMISD XMM0,XMM2
JA 0x0010136a
MOVAPD XMM0,XMM2
PXOR XMM1,XMM1
MOV ECX,0x1
SQRTSD XMM0,XMM0
CVTTSD2SI ESI,XMM0
TEST ESI,ESI
JLE 0x0010135c
NOP
LAB_00101330:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101355
PXOR XMM0,XMM0
CVTSI2SD XMM0,ECX
ADDSD XMM1,XMM0
CMP ECX,EAX
JZ 0x00101355
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
ADDSD XMM1,XMM0
LAB_00101355:
ADD ECX,0x1
CMP ESI,ECX
JGE 0x00101330
LAB_0010135c:
SUBSD XMM1,XMM2
XOR EAX,EAX
COMISD XMM1,XMM2
SETA AL
RET
LAB_0010136a:
PUSH RBX
PXOR XMM1,XMM1
MOV EBX,0x1
SUB RSP,0x20
JMP 0x001013a6
LAB_0010137a:
MOV EDI,dword ptr [RSP + 0x1c]
MOV EAX,EDI
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x001013a3
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
ADDSD XMM1,XMM0
CMP EBX,EAX
JZ 0x001013a3
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
ADDSD XMM1,XMM0
LAB_001013a3:
ADD EBX,0x1
LAB_001013a6:
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x10],XMM1
MOVSD qword ptr [RSP + 0x8],XMM2
MOV dword ptr [RSP + 0x1c],EDI
CALL 0x00101070
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP + 0x10]
CVTTSD2SI EAX,XMM0
CMP EBX,EAX
JLE 0x0010137a
SUBSD XMM1,XMM2
XOR EAX,EAX
COMISD XMM1,XMM2
SETA AL
ADD RSP,0x20
POP RBX
RET | bool func0(int param_1)
{
int iVar1;
double dVar2;
double dVar3;
double __x;
__x = (double)param_1;
if (0.0 <= __x) {
dVar2 = 0.0;
iVar1 = 1;
dVar3 = 0.0;
if (0 < (int)SQRT(__x)) {
do {
dVar2 = dVar3;
if (param_1 % iVar1 == 0) {
dVar2 = dVar3 + (double)iVar1;
if (iVar1 != param_1 / iVar1) {
dVar2 = dVar2 + (double)(param_1 / iVar1);
}
}
iVar1 = iVar1 + 1;
dVar3 = dVar2;
} while (iVar1 <= (int)SQRT(__x));
}
return __x < dVar2 - __x;
}
dVar3 = 0.0;
iVar1 = 1;
while( true ) {
dVar2 = sqrt(__x);
if ((int)dVar2 < iVar1) break;
if ((param_1 % iVar1 == 0) && (dVar3 = dVar3 + (double)iVar1, iVar1 != param_1 / iVar1)) {
dVar3 = dVar3 + (double)(param_1 / iVar1);
}
iVar1 = iVar1 + 1;
}
return __x < dVar3 - __x;
} |
6,060 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* text) {
static char result[100];
strcpy(result, text);
for (int i = 0; result[i] != '\0'; i++) {
if (result[i] == ' ' || result[i] == ',' || result[i] == '.')
result[i] = ':';
}
return result;
}
| int main() {
assert(strcmp(func0("Boult Curve Wireless Neckband"), "Boult:Curve:Wireless:Neckband") == 0);
assert(strcmp(func0("Stereo Sound Sweatproof"), "Stereo:Sound:Sweatproof") == 0);
assert(strcmp(func0("Probass Curve Audio"), "Probass:Curve:Audio") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rsi
lea 0x2e99(%rip),%rdi
callq 1070 <strcpy@plt>
movl $0x0,-0x4(%rbp)
jmp 1205 <func0+0x7c>
mov -0x4(%rbp),%eax
cltq
lea 0x2e7f(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
cmp $0x20,%al
je 11f1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x2e6b(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
cmp $0x2c,%al
je 11f1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x2e57(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
cmp $0x2e,%al
jne 1201 <func0+0x78>
mov -0x4(%rbp),%eax
cltq
lea 0x2e43(%rip),%rdx
movb $0x3a,(%rax,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x2e2f(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
test %al,%al
jne 11b5 <func0+0x2c>
lea 0x2e20(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+src], rdi
mov rax, [rbp+src]
mov rsi, rax; src
lea rax, result_1
mov rdi, rax; dest
call _strcpy
mov [rbp+var_4], 0
jmp short loc_1208
loc_11B8:
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
movzx eax, byte ptr [rax+rdx]
cmp al, 20h ; ' '
jz short loc_11F4
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
movzx eax, byte ptr [rax+rdx]
cmp al, 2Ch ; ','
jz short loc_11F4
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
movzx eax, byte ptr [rax+rdx]
cmp al, 2Eh ; '.'
jnz short loc_1204
loc_11F4:
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
mov byte ptr [rax+rdx], 3Ah ; ':'
loc_1204:
add [rbp+var_4], 1
loc_1208:
mov eax, [rbp+var_4]
cdqe
lea rdx, result_1
movzx eax, byte ptr [rax+rdx]
test al, al
jnz short loc_11B8
lea rax, result_1
leave
retn | char * func0(const char *a1)
{
int i; // [rsp+1Ch] [rbp-4h]
strcpy(result_1, a1);
for ( i = 0; result_1[i]; ++i )
{
if ( result_1[i] == 32 || result_1[i] == 44 || result_1[i] == 46 )
result_1[i] = 58;
}
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101208
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
CMP AL,0x20
JZ 0x001011f4
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
CMP AL,0x2c
JZ 0x001011f4
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
CMP AL,0x2e
JNZ 0x00101204
LAB_001011f4:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x3a
LAB_00101204:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101208:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
TEST AL,AL
JNZ 0x001011b8
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(char *param_1)
{
int local_c;
strcpy(result_1,param_1);
for (local_c = 0; result_1[local_c] != '\0'; local_c = local_c + 1) {
if (((result_1[local_c] == ' ') || (result_1[local_c] == ',')) || (result_1[local_c] == '.')) {
result_1[local_c] = 0x3a;
}
}
return result_1;
} |
6,061 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* text) {
static char result[100];
strcpy(result, text);
for (int i = 0; result[i] != '\0'; i++) {
if (result[i] == ' ' || result[i] == ',' || result[i] == '.')
result[i] = ':';
}
return result;
}
| int main() {
assert(strcmp(func0("Boult Curve Wireless Neckband"), "Boult:Curve:Wireless:Neckband") == 0);
assert(strcmp(func0("Stereo Sound Sweatproof"), "Stereo:Sound:Sweatproof") == 0);
assert(strcmp(func0("Probass Curve Audio"), "Probass:Curve:Audio") == 0);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
mov %rdi,%rsi
mov $0x64,%edx
lea 0x2ec0(%rip),%rdi
callq 1070 <__strcpy_chk@plt>
movzbl 0x2eb4(%rip),%eax
test %al,%al
je 11b7 <func0+0x4e>
lea 0x2ea9(%rip),%rdx
jmp 11a7 <func0+0x3e>
movb $0x3a,(%rdx)
add $0x1,%rdx
movzbl (%rdx),%eax
test %al,%al
je 11b7 <func0+0x4e>
mov %eax,%ecx
and $0xfffffffd,%ecx
cmp $0x2c,%cl
je 1199 <func0+0x30>
cmp $0x20,%al
je 1199 <func0+0x30>
jmp 119c <func0+0x33>
lea 0x2e82(%rip),%rax
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
mov rsi, rdi
mov edx, 64h ; 'd'
lea rdi, result_1
call ___strcpy_chk
movzx eax, cs:result_1
test al, al
jz short loc_11DD
lea rdx, result_1
mov rcx, 500100000000h
jmp short loc_11D1
loc_11C3:
mov byte ptr [rdx], 3Ah ; ':'
loc_11C6:
add rdx, 1
movzx eax, byte ptr [rdx]
test al, al
jz short loc_11DD
loc_11D1:
cmp al, 2Eh ; '.'
ja short loc_11C6
bt rcx, rax
jnb short loc_11C6
jmp short loc_11C3
loc_11DD:
lea rax, result_1
add rsp, 8
retn | char * func0(long long a1)
{
unsigned long long v1; // rax
char *v2; // rdx
long long v3; // rcx
__strcpy_chk(&result_1, a1, 100LL);
v1 = (unsigned __int8)result_1;
if ( result_1 )
{
v2 = &result_1;
v3 = 0x500100000000LL;
do
{
if ( (unsigned __int8)v1 <= 0x2Eu && _bittest64(&v3, v1) )
*v2 = 58;
v1 = (unsigned __int8)*++v2;
}
while ( (_BYTE)v1 );
}
return &result_1;
} | func0:
ENDBR64
SUB RSP,0x8
MOV RSI,RDI
MOV EDX,0x64
LEA RDI,[0x104040]
CALL 0x00101090
MOVZX EAX,byte ptr [0x00104040]
TEST AL,AL
JZ 0x001011dd
LEA RDX,[0x104040]
MOV RCX,0x500100000000
JMP 0x001011d1
LAB_001011c3:
MOV byte ptr [RDX],0x3a
LAB_001011c6:
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JZ 0x001011dd
LAB_001011d1:
CMP AL,0x2e
JA 0x001011c6
BT RCX,RAX
JNC 0x001011c6
JMP 0x001011c3
LAB_001011dd:
LEA RAX,[0x104040]
ADD RSP,0x8
RET | int1 * func0(int8 param_1)
{
byte bVar1;
byte *pbVar2;
__strcpy_chk(&result_1,param_1,100);
if (result_1 != 0) {
pbVar2 = &result_1;
bVar1 = result_1;
do {
if ((bVar1 < 0x2f) && ((0x500100000000U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) {
*pbVar2 = 0x3a;
}
pbVar2 = pbVar2 + 1;
bVar1 = *pbVar2;
} while (bVar1 != 0);
}
return &result_1;
} |
6,062 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* text) {
static char result[100];
strcpy(result, text);
for (int i = 0; result[i] != '\0'; i++) {
if (result[i] == ' ' || result[i] == ',' || result[i] == '.')
result[i] = ':';
}
return result;
}
| int main() {
assert(strcmp(func0("Boult Curve Wireless Neckband"), "Boult:Curve:Wireless:Neckband") == 0);
assert(strcmp(func0("Stereo Sound Sweatproof"), "Stereo:Sound:Sweatproof") == 0);
assert(strcmp(func0("Probass Curve Audio"), "Probass:Curve:Audio") == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %rdi,%rsi
sub $0x8,%rsp
mov $0x64,%edx
lea 0x2dd9(%rip),%rdi
callq 1070 <__strcpy_chk@plt>
movzbl 0x2dcd(%rip),%eax
test %al,%al
je 129d <func0+0x4d>
lea 0x2dc2(%rip),%rdx
xchg %ax,%ax
mov %eax,%ecx
and $0xfffffffd,%ecx
cmp $0x2c,%cl
je 128e <func0+0x3e>
cmp $0x20,%al
jne 1291 <func0+0x41>
movb $0x3a,(%rdx)
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1280 <func0+0x30>
lea 0x2d9c(%rip),%rax
add $0x8,%rsp
retq
nopl 0x0(%rax)
| func0:
endbr64
lea r8, result_1
mov rsi, rdi
sub rsp, 8
mov edx, 64h ; 'd'
mov rdi, r8
call ___strcpy_chk
mov r8, rax
movzx eax, cs:result_1
test al, al
jz short loc_12B9
mov rcx, 500100000000h
mov rdx, r8
nop word ptr [rax+rax+00h]
loc_12A0:
cmp al, 2Eh ; '.'
ja short loc_12AD
bt rcx, rax
jnb short loc_12AD
mov byte ptr [rdx], 3Ah ; ':'
loc_12AD:
movzx eax, byte ptr [rdx+1]
add rdx, 1
test al, al
jnz short loc_12A0
loc_12B9:
mov rax, r8
add rsp, 8
retn | long long func0(long long a1)
{
long long v1; // r8
unsigned long long v2; // rax
long long v3; // rcx
_BYTE *v4; // rdx
v1 = __strcpy_chk(&result_1, a1, 100LL);
v2 = (unsigned __int8)result_1;
if ( result_1 )
{
v3 = 0x500100000000LL;
v4 = (_BYTE *)v1;
do
{
if ( (unsigned __int8)v2 <= 0x2Eu && _bittest64(&v3, v2) )
*v4 = 58;
v2 = (unsigned __int8)*++v4;
}
while ( (_BYTE)v2 );
}
return v1;
} | func0:
ENDBR64
LEA R8,[0x104040]
MOV RSI,RDI
SUB RSP,0x8
MOV EDX,0x64
MOV RDI,R8
CALL 0x00101090
MOV R8,RAX
MOVZX EAX,byte ptr [0x00104040]
TEST AL,AL
JZ 0x001012b9
MOV RCX,0x500100000000
MOV RDX,R8
NOP word ptr [RAX + RAX*0x1]
LAB_001012a0:
CMP AL,0x2e
JA 0x001012ad
BT RCX,RAX
JNC 0x001012ad
MOV byte ptr [RDX],0x3a
LAB_001012ad:
MOVZX EAX,byte ptr [RDX + 0x1]
ADD RDX,0x1
TEST AL,AL
JNZ 0x001012a0
LAB_001012b9:
MOV RAX,R8
ADD RSP,0x8
RET | int1 * func0(int8 param_1)
{
byte *pbVar1;
byte bVar2;
int1 *puVar3;
int1 *puVar4;
puVar3 = (int1 *)__strcpy_chk(&result_1,param_1,100);
puVar4 = puVar3;
bVar2 = result_1;
while (bVar2 != 0) {
if ((bVar2 < 0x2f) && ((0x500100000000U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) {
*puVar4 = 0x3a;
}
pbVar1 = puVar4 + 1;
puVar4 = puVar4 + 1;
bVar2 = *pbVar1;
}
return puVar3;
} |
6,063 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* text) {
static char result[100];
strcpy(result, text);
for (int i = 0; result[i] != '\0'; i++) {
if (result[i] == ' ' || result[i] == ',' || result[i] == '.')
result[i] = ':';
}
return result;
}
| int main() {
assert(strcmp(func0("Boult Curve Wireless Neckband"), "Boult:Curve:Wireless:Neckband") == 0);
assert(strcmp(func0("Stereo Sound Sweatproof"), "Stereo:Sound:Sweatproof") == 0);
assert(strcmp(func0("Probass Curve Audio"), "Probass:Curve:Audio") == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov %rdi,%rsi
sub $0x8,%rsp
mov $0x64,%edx
lea 0x2dd9(%rip),%rdi
callq 1070 <__strcpy_chk@plt>
movzbl 0x2dcd(%rip),%eax
test %al,%al
je 129a <func0+0x4a>
lea 0x2dc2(%rip),%rdx
xchg %ax,%ax
mov %eax,%ecx
and $0xfffffffd,%ecx
cmp $0x2c,%cl
je 12b0 <func0+0x60>
cmp $0x20,%al
je 12b0 <func0+0x60>
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1280 <func0+0x30>
lea 0x2d9f(%rip),%rax
add $0x8,%rsp
retq
nopw %cs:0x0(%rax,%rax,1)
movb $0x3a,(%rdx)
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1280 <func0+0x30>
lea 0x2d7a(%rip),%rax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov rsi, rdi
sub rsp, 8
mov edx, 64h ; 'd'
lea rdi, result_1
call ___strcpy_chk
mov rdi, rax
movzx eax, cs:result_1
test al, al
jz short loc_12B9
mov rcx, 500100000000h
mov rdx, rdi
nop word ptr [rax+rax+00000000h]
loc_12A0:
cmp al, 2Eh ; '.'
ja short loc_12AD
bt rcx, rax
jnb short loc_12AD
mov byte ptr [rdx], 3Ah ; ':'
loc_12AD:
movzx eax, byte ptr [rdx+1]
add rdx, 1
test al, al
jnz short loc_12A0
loc_12B9:
mov rax, rdi
add rsp, 8
retn | long long func0(long long a1)
{
long long v1; // rdi
unsigned long long v2; // rax
long long v3; // rcx
_BYTE *v4; // rdx
v1 = __strcpy_chk(&result_1, a1, 100LL);
v2 = (unsigned __int8)result_1;
if ( result_1 )
{
v3 = 0x500100000000LL;
v4 = (_BYTE *)v1;
do
{
if ( (unsigned __int8)v2 <= 0x2Eu && _bittest64(&v3, v2) )
*v4 = 58;
v2 = (unsigned __int8)*++v4;
}
while ( (_BYTE)v2 );
}
return v1;
} | func0:
ENDBR64
MOV RSI,RDI
SUB RSP,0x8
MOV EDX,0x64
LEA RDI,[0x104040]
CALL 0x00101090
MOV RDI,RAX
MOVZX EAX,byte ptr [0x00104040]
TEST AL,AL
JZ 0x001012b9
MOV RCX,0x500100000000
MOV RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_001012a0:
CMP AL,0x2e
JA 0x001012ad
BT RCX,RAX
JNC 0x001012ad
MOV byte ptr [RDX],0x3a
LAB_001012ad:
MOVZX EAX,byte ptr [RDX + 0x1]
ADD RDX,0x1
TEST AL,AL
JNZ 0x001012a0
LAB_001012b9:
MOV RAX,RDI
ADD RSP,0x8
RET | int * func0(int8 param_1)
{
byte *pbVar1;
byte bVar2;
int *puVar3;
int *puVar4;
puVar3 = (int *)__strcpy_chk(&result_1,param_1,100);
puVar4 = puVar3;
bVar2 = result_1;
while (bVar2 != 0) {
if ((bVar2 < 0x2f) && ((0x500100000000U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) {
*puVar4 = 0x3a;
}
pbVar1 = puVar4 + 1;
puVar4 = puVar4 + 1;
bVar2 = *pbVar1;
}
return puVar3;
} |
6,064 | func0 |
#include <assert.h>
| int func0(long long num1, long long num2) {
long long number = num1 + num2;
int count = 0;
while (number > 0) {
number = number / 10;
count = count + 1;
}
return count;
}
| int main() {
assert(func0(9875, 10) == 4);
assert(func0(98759853034, 100) == 11);
assert(func0(1234567, 500) == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 119e <func0+0x55>
mov -0x8(%rbp),%rcx
movabs $0x6666666666666667,%rdx
mov %rcx,%rax
imul %rdx
sar $0x2,%rdx
mov %rcx,%rax
sar $0x3f,%rax
sub %rax,%rdx
mov %rdx,%rax
mov %rax,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
cmpq $0x0,-0x8(%rbp)
jg 1171 <func0+0x28>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rdx, [rbp+var_18]
mov rax, [rbp+var_20]
add rax, rdx
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_119E
loc_1171:
mov rcx, [rbp+var_8]
mov rdx, 6666666666666667h
mov rax, rcx
imul rdx
mov rax, rdx
sar rax, 2
sar rcx, 3Fh
mov rdx, rcx
sub rax, rdx
mov [rbp+var_8], rax
add [rbp+var_C], 1
loc_119E:
cmp [rbp+var_8], 0
jg short loc_1171
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, long long a2)
{
unsigned int v3; // [rsp+14h] [rbp-Ch]
long long v4; // [rsp+18h] [rbp-8h]
v4 = a1 + a2;
v3 = 0;
while ( v4 > 0 )
{
v4 /= 10LL;
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010119e
LAB_00101171:
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,0x6666666666666667
MOV RAX,RCX
IMUL RDX
MOV RAX,RDX
SAR RAX,0x2
SAR RCX,0x3f
MOV RDX,RCX
SUB RAX,RDX
MOV qword ptr [RBP + -0x8],RAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010119e:
CMP qword ptr [RBP + -0x8],0x0
JG 0x00101171
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,long param_2)
{
int4 local_14;
int8 local_10;
local_14 = 0;
for (local_10 = param_2 + param_1; 0 < local_10; local_10 = local_10 / 10) {
local_14 = local_14 + 1;
}
return local_14;
} |
6,065 | func0 |
#include <assert.h>
| int func0(long long num1, long long num2) {
long long number = num1 + num2;
int count = 0;
while (number > 0) {
number = number / 10;
count = count + 1;
}
return count;
}
| int main() {
assert(func0(9875, 10) == 4);
assert(func0(98759853034, 100) == 11);
assert(func0(1234567, 500) == 7);
return 0;
}
| O1 | c | func0:
endbr64
add %rdi,%rsi
test %rsi,%rsi
jle 1167 <func0+0x3e>
mov $0x0,%ecx
movabs $0x6666666666666667,%r8
mov %rsi,%rdi
mov %rsi,%rax
imul %r8
sar $0x2,%rdx
sar $0x3f,%rsi
sub %rsi,%rdx
mov %rdx,%rsi
add $0x1,%ecx
cmp $0x9,%rdi
jg 1144 <func0+0x1b>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1164 <func0+0x3b>
| func0:
endbr64
add rdi, rsi
test rdi, rdi
jle short loc_116A
mov ecx, 0
mov r8, 6666666666666667h
loc_1144:
mov rsi, rdi
mov rax, rdi
imul r8
sar rdx, 2
mov rax, rdi
sar rax, 3Fh
sub rdx, rax
mov rdi, rdx
add ecx, 1
cmp rsi, 9
jg short loc_1144
loc_1167:
mov eax, ecx
retn
loc_116A:
mov ecx, 0
jmp short loc_1167 | long long func0(long long a1, long long a2)
{
long long v2; // rdi
unsigned int v3; // ecx
long long v4; // rsi
v2 = a2 + a1;
if ( v2 <= 0 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = v2;
v2 /= 10LL;
++v3;
}
while ( v4 > 9 );
}
return v3;
} | func0:
ENDBR64
ADD RDI,RSI
TEST RDI,RDI
JLE 0x0010116a
MOV ECX,0x0
MOV R8,0x6666666666666667
LAB_00101144:
MOV RSI,RDI
MOV RAX,RDI
IMUL R8
SAR RDX,0x2
MOV RAX,RDI
SAR RAX,0x3f
SUB RDX,RAX
MOV RDI,RDX
ADD ECX,0x1
CMP RSI,0x9
JG 0x00101144
LAB_00101167:
MOV EAX,ECX
RET
LAB_0010116a:
MOV ECX,0x0
JMP 0x00101167 | int func0(long param_1,long param_2)
{
bool bVar1;
int iVar2;
long lVar3;
if (param_1 + param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
lVar3 = param_1 + param_2;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < lVar3;
lVar3 = lVar3 / 10;
} while (bVar1);
}
return iVar2;
} |
6,066 | func0 |
#include <assert.h>
| int func0(long long num1, long long num2) {
long long number = num1 + num2;
int count = 0;
while (number > 0) {
number = number / 10;
count = count + 1;
}
return count;
}
| int main() {
assert(func0(9875, 10) == 4);
assert(func0(98759853034, 100) == 11);
assert(func0(1234567, 500) == 7);
return 0;
}
| O2 | c | func0:
endbr64
lea (%rdi,%rsi,1),%rdx
xor %r8d,%r8d
test %rdx,%rdx
jle 1177 <func0+0x37>
movabs $0xcccccccccccccccd,%rsi
nopw 0x0(%rax,%rax,1)
mov %rdx,%rax
mov %rdx,%rcx
add $0x1,%r8d
mul %rsi
shr $0x3,%rdx
cmp $0x9,%rcx
jg 1160 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea rdx, [rdi+rsi]
xor r8d, r8d
test rdx, rdx
jle short loc_1177
mov rsi, 0CCCCCCCCCCCCCCCDh
nop word ptr [rax+rax+00h]
loc_1160:
mov rax, rdx
mov rcx, rdx
add r8d, 1
mul rsi
shr rdx, 3
cmp rcx, 9
jg short loc_1160
loc_1177:
mov eax, r8d
retn | long long func0(long long a1, long long a2)
{
unsigned long long v2; // rdx
unsigned int v3; // r8d
long long v4; // rcx
v2 = a1 + a2;
v3 = 0;
if ( a1 + a2 > 0 )
{
do
{
v4 = v2;
++v3;
v2 /= 0xAuLL;
}
while ( v4 > 9 );
}
return v3;
} | func0:
ENDBR64
LEA RDX,[RDI + RSI*0x1]
XOR R8D,R8D
TEST RDX,RDX
JLE 0x00101177
MOV RSI,-0x3333333333333333
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
MOV RAX,RDX
MOV RCX,RDX
ADD R8D,0x1
MUL RSI
SHR RDX,0x3
CMP RCX,0x9
JG 0x00101160
LAB_00101177:
MOV EAX,R8D
RET | int func0(long param_1,long param_2)
{
bool bVar1;
ulong uVar2;
int iVar3;
uVar2 = param_1 + param_2;
iVar3 = 0;
if (0 < (long)uVar2) {
do {
iVar3 = iVar3 + 1;
bVar1 = 9 < (long)uVar2;
uVar2 = uVar2 / 10;
} while (bVar1);
}
return iVar3;
} |
6,067 | func0 |
#include <assert.h>
| int func0(long long num1, long long num2) {
long long number = num1 + num2;
int count = 0;
while (number > 0) {
number = number / 10;
count = count + 1;
}
return count;
}
| int main() {
assert(func0(9875, 10) == 4);
assert(func0(98759853034, 100) == 11);
assert(func0(1234567, 500) == 7);
return 0;
}
| O3 | c | func0:
endbr64
lea (%rdi,%rsi,1),%rdx
xor %r8d,%r8d
test %rdx,%rdx
jle 1177 <func0+0x37>
movabs $0xcccccccccccccccd,%rsi
nopw 0x0(%rax,%rax,1)
mov %rdx,%rax
mov %rdx,%rcx
add $0x1,%r8d
mul %rsi
shr $0x3,%rdx
cmp $0x9,%rcx
jg 1160 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea rdx, [rdi+rsi]
xor esi, esi
test rdx, rdx
jle short loc_1176
mov rdi, 0CCCCCCCCCCCCCCCDh
nop dword ptr [rax+00000000h]
loc_1160:
mov rax, rdx
mov rcx, rdx
add esi, 1
mul rdi
shr rdx, 3
cmp rcx, 9
jg short loc_1160
loc_1176:
mov eax, esi
retn | long long func0(long long a1, long long a2)
{
long long v2; // rdx
unsigned int v3; // esi
long long v4; // rcx
v2 = a1 + a2;
v3 = 0;
if ( v2 > 0 )
{
do
{
v4 = v2;
++v3;
v2 /= 0xAuLL;
}
while ( v4 > 9 );
}
return v3;
} | func0:
ENDBR64
LEA RDX,[RDI + RSI*0x1]
XOR ESI,ESI
TEST RDX,RDX
JLE 0x00101176
MOV RDI,-0x3333333333333333
NOP dword ptr [RAX]
LAB_00101160:
MOV RAX,RDX
MOV RCX,RDX
ADD ESI,0x1
MUL RDI
SHR RDX,0x3
CMP RCX,0x9
JG 0x00101160
LAB_00101176:
MOV EAX,ESI
RET | int func0(long param_1,long param_2)
{
bool bVar1;
ulong uVar2;
int iVar3;
uVar2 = param_1 + param_2;
iVar3 = 0;
if (0 < (long)uVar2) {
do {
iVar3 = iVar3 + 1;
bVar1 = 9 < (long)uVar2;
uVar2 = uVar2 / 10;
} while (bVar1);
}
return iVar3;
} |
6,068 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* test_list[], int size) {
static char res[1000];
strcpy(res, ""); // initialize result string
for(int i = 0; i < size; i++) {
strcat(res, test_list[i]); // append string to result
strcat(res, " "); // append space after each tuple element
}
res[strlen(res) - 1] = '\0'; // remove the last space
return res;
}
| int main() {
char* list1[] = {"1", "4", "6", "5", "8", "2", "9", "1", "10"};
assert(strcmp(func0(list1, 9), "1 4 6 5 8 2 9 1 10") == 0);
char* list2[] = {"2", "3", "4", "6", "9", "3", "2", "2", "11"};
assert(strcmp(func0(list2, 9), "2 3 4 6 9 3 2 2 11") == 0);
char* list3[] = {"14", "21", "9", "24", "19", "12", "29", "23", "17"};
assert(strcmp(func0(list3, 9), "14 21 9 24 19 12 29 23 17") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movb $0x0,0x2e5d(%rip)
movl $0x0,-0x4(%rbp)
jmp 124a <func0+0x81>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rsi
lea 0x2e33(%rip),%rdi
callq 10d0 <strcat@plt>
lea 0x2e27(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2e02(%rip),%rax
add %rdx,%rax
movw $0x20,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ec <func0+0x23>
lea 0x2de7(%rip),%rdi
callq 1090 <strlen@plt>
lea -0x1(%rax),%rdx
lea 0x2dd7(%rip),%rax
movb $0x0,(%rdx,%rax,1)
lea 0x2dcc(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov cs:res_1, 0
mov [rbp+var_4], 0
jmp short loc_123A
loc_11EC:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rsi, rax; src
lea rax, res_1
mov rdi, rax; dest
call _strcat
lea rax, res_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, res_1
add rax, rdx
mov word ptr [rax], 20h ; ' '
add [rbp+var_4], 1
loc_123A:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11EC
lea rax, res_1
mov rdi, rax; s
call _strlen
lea rdx, [rax-1]
lea rax, res_1
mov byte ptr [rdx+rax], 0
lea rax, res_1
leave
retn | char * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-4h]
res_1[0] = 0;
for ( i = 0; i < a2; ++i )
{
strcat(res_1, *(const char **)(8LL * i + a1));
*(_WORD *)&res_1[strlen(res_1)] = 32;
}
res_1[strlen(res_1) - 1] = 0;
return res_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV byte ptr [0x00104040],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010123a
LAB_001011ec:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010d0
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101090
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x20
ADD dword ptr [RBP + -0x4],0x1
LAB_0010123a:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ec
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101090
LEA RDX,[RAX + -0x1]
LEA RAX,[0x104040]
MOV byte ptr [RDX + RAX*0x1],0x0
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
int local_c;
res_1[0] = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
strcat(res_1,*(char **)(param_1 + (long)local_c * 8));
sVar1 = strlen(res_1);
*(int2 *)(res_1 + sVar1) = 0x20;
}
sVar1 = strlen(res_1);
(&DAT_0010403f)[sVar1] = 0;
return res_1;
} |
6,069 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* test_list[], int size) {
static char res[1000];
strcpy(res, ""); // initialize result string
for(int i = 0; i < size; i++) {
strcat(res, test_list[i]); // append string to result
strcat(res, " "); // append space after each tuple element
}
res[strlen(res) - 1] = '\0'; // remove the last space
return res;
}
| int main() {
char* list1[] = {"1", "4", "6", "5", "8", "2", "9", "1", "10"};
assert(strcmp(func0(list1, 9), "1 4 6 5 8 2 9 1 10") == 0);
char* list2[] = {"2", "3", "4", "6", "9", "3", "2", "2", "11"};
assert(strcmp(func0(list2, 9), "2 3 4 6 9 3 2 2 11") == 0);
char* list3[] = {"14", "21", "9", "24", "19", "12", "29", "23", "17"};
assert(strcmp(func0(list3, 9), "14 21 9 24 19 12 29 23 17") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
movb $0x0,0x2ea8(%rip)
test %esi,%esi
jle 11db <func0+0x52>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r12
lea 0x2e92(%rip),%rbp
mov $0x3e8,%edx
mov (%rbx),%rsi
mov %rbp,%rdi
callq 1070 <__strcat_chk@plt>
mov $0x3e8,%edx
lea 0xe3a(%rip),%rsi
mov %rbp,%rdi
callq 1070 <__strcat_chk@plt>
add $0x8,%rbx
cmp %r12,%rbx
jne 11ae <func0+0x25>
lea 0x2e5e(%rip),%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
movb $0x0,-0x2(%rdx,%rcx,1)
mov %rdx,%rax
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov cs:res_1, 0
test esi, esi
jle short loc_1224
mov rbx, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*8+8]
lea rbp, res_1
lea r12, a658; " 658"
loc_11FB:
mov edx, 3E8h
mov rsi, [rbx]
mov rdi, rbp
call ___strcat_chk
mov edx, 3E8h
mov rsi, r12
mov rdi, rbp
call ___strcat_chk
add rbx, 8
cmp rbx, r13
jnz short loc_11FB
loc_1224:
lea rbx, res_1
mov rdi, rbx
call _strlen
mov byte ptr [rbx+rax-1], 0
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | char * func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
res_1[0] = 0;
if ( a2 > 0 )
{
v2 = a1;
do
{
__strcat_chk(res_1, *v2, 1000LL);
__strcat_chk(res_1, a658, 1000LL);
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
}
res_1[strlen(res_1) - 1] = 0;
return res_1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV byte ptr [0x00104040],0x0
TEST ESI,ESI
JLE 0x00101224
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x8 + 0x8]
LEA RBP,[0x104040]
LEA R12,[0x102004]
LAB_001011fb:
MOV EDX,0x3e8
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x00101090
MOV EDX,0x3e8
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101090
ADD RBX,0x8
CMP RBX,R13
JNZ 0x001011fb
LAB_00101224:
LEA RBX,[0x104040]
MOV RDI,RBX
CALL 0x001010a0
MOV byte ptr [RBX + RAX*0x1 + -0x1],0x0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
size_t sVar2;
res_1[0] = 0;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
__strcat_chk(res_1,*param_1,1000);
__strcat_chk(res_1,&DAT_00102004,1000);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
sVar2 = strlen(res_1);
(&DAT_0010403f)[sVar2] = 0;
return res_1;
} |
6,070 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* test_list[], int size) {
static char res[1000];
strcpy(res, ""); // initialize result string
for(int i = 0; i < size; i++) {
strcat(res, test_list[i]); // append string to result
strcat(res, " "); // append space after each tuple element
}
res[strlen(res) - 1] = '\0'; // remove the last space
return res;
}
| int main() {
char* list1[] = {"1", "4", "6", "5", "8", "2", "9", "1", "10"};
assert(strcmp(func0(list1, 9), "1 4 6 5 8 2 9 1 10") == 0);
char* list2[] = {"2", "3", "4", "6", "9", "3", "2", "2", "11"};
assert(strcmp(func0(list2, 9), "2 3 4 6 9 3 2 2 11") == 0);
char* list3[] = {"14", "21", "9", "24", "19", "12", "29", "23", "17"};
assert(strcmp(func0(list3, 9), "14 21 9 24 19 12 29 23 17") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
movb $0x0,0x2c23(%rip)
push %rbp
push %rbx
test %esi,%esi
jle 14ad <func0+0x9d>
lea -0x1(%rsi),%eax
mov %rdi,%r12
lea 0x2ff4(%rip),%rbx
lea 0x8(%rdi,%rax,8),%rbp
nopl 0x0(%rax)
lea 0x2bf9(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1447 <func0+0x37>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%esi
add %al,%sil
mov (%r12),%rsi
sbb $0x3,%rdi
add $0x8,%r12
callq 10b0 <__stpcpy_chk@plt>
mov %rbx,%rcx
mov $0x2,%edx
lea 0xb67(%rip),%rsi
mov %rax,%rdi
sub %rax,%rcx
callq 10a0 <__memcpy_chk@plt>
cmp %rbp,%r12
jne 1440 <func0+0x30>
lea 0x2b8c(%rip),%rsi
mov %rsi,%rdi
mov %rsi,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 14ba <func0+0xaa>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%ebx
add %al,%bl
lea 0x2b4f(%rip),%rax
sbb $0x3,%rdx
sub %rsi,%rdx
movb $0x0,-0x1(%rdi,%rdx,1)
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r14
mov cs:res_1, 0
push r13
push r12
lea r12, res_1
push rbp
push rbx
test esi, esi
jle short loc_14A9
lea eax, [rsi-1]
mov rbx, rdi
lea r13, [r12+3E8h]
lea r14, [rdi+rax*8+8]
lea rbp, a658; " 658"
nop dword ptr [rax+rax+00000000h]
loc_1470:
mov rdi, r12
add rbx, 8
call _strlen
mov rsi, [rbx-8]
mov edx, 3E8h
lea rdi, [r12+rax]
call ___stpcpy_chk
mov rcx, r13
mov edx, 2
mov rsi, rbp
mov rdi, rax
sub rcx, rax
call ___memcpy_chk
cmp rbx, r14
jnz short loc_1470
loc_14A9:
mov rdi, r12
call _strlen
pop rbx
pop rbp
mov byte ptr [r12+rax-1], 0
mov rax, r12
pop r12
pop r13
pop r14
retn | char * func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rax
res_1[0] = 0;
if ( a2 > 0 )
{
v2 = a1;
do
{
v2 += 8LL;
v3 = strlen(res_1);
v4 = __stpcpy_chk(&res_1[v3], *(_QWORD *)(v2 - 8), 1000LL);
__memcpy_chk(v4, a658, 2LL, &res_1[-v4 + 1000]);
}
while ( v2 != a1 + 8LL * (unsigned int)(a2 - 1) + 8 );
}
res_1[strlen(res_1) - 1] = 0;
return res_1;
} | func0:
ENDBR64
PUSH R14
MOV byte ptr [0x00104040],0x0
PUSH R13
PUSH R12
LEA R12,[0x104040]
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001014a9
LEA EAX,[RSI + -0x1]
MOV RBX,RDI
LEA R13,[R12 + 0x3e8]
LEA R14,[RDI + RAX*0x8 + 0x8]
LEA RBP,[0x102004]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101470:
MOV RDI,R12
ADD RBX,0x8
CALL 0x001010a0
MOV RSI,qword ptr [RBX + -0x8]
MOV EDX,0x3e8
LEA RDI,[R12 + RAX*0x1]
CALL 0x001010f0
MOV RCX,R13
MOV EDX,0x2
MOV RSI,RBP
MOV RDI,RAX
SUB RCX,RAX
CALL 0x001010e0
CMP RBX,R14
JNZ 0x00101470
LAB_001014a9:
MOV RDI,R12
CALL 0x001010a0
POP RBX
POP RBP
MOV byte ptr [R12 + RAX*0x1 + -0x1],0x0
MOV RAX,R12
POP R12
POP R13
POP R14
RET | int1 * func0(int8 *param_1,int param_2)
{
size_t sVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
res_1[0] = 0;
if (0 < param_2) {
puVar3 = param_1;
do {
puVar4 = puVar3 + 1;
sVar1 = strlen(res_1);
lVar2 = __stpcpy_chk(res_1 + sVar1,*puVar3,1000);
__memcpy_chk(lVar2,&DAT_00102004,2,(long)&_end - lVar2);
puVar3 = puVar4;
} while (puVar4 != param_1 + (ulong)(param_2 - 1) + 1);
}
sVar1 = strlen(res_1);
(&DAT_0010403f)[sVar1] = 0;
return res_1;
} |
6,071 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* test_list[], int size) {
static char res[1000];
strcpy(res, ""); // initialize result string
for(int i = 0; i < size; i++) {
strcat(res, test_list[i]); // append string to result
strcat(res, " "); // append space after each tuple element
}
res[strlen(res) - 1] = '\0'; // remove the last space
return res;
}
| int main() {
char* list1[] = {"1", "4", "6", "5", "8", "2", "9", "1", "10"};
assert(strcmp(func0(list1, 9), "1 4 6 5 8 2 9 1 10") == 0);
char* list2[] = {"2", "3", "4", "6", "9", "3", "2", "2", "11"};
assert(strcmp(func0(list2, 9), "2 3 4 6 9 3 2 2 11") == 0);
char* list3[] = {"14", "21", "9", "24", "19", "12", "29", "23", "17"};
assert(strcmp(func0(list3, 9), "14 21 9 24 19 12 29 23 17") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
movb $0x0,0x2be3(%rip)
push %rbp
push %rbx
test %esi,%esi
jle 14ed <func0+0x9d>
lea -0x1(%rsi),%eax
mov %rdi,%r12
lea 0x2fb4(%rip),%rbx
lea 0x8(%rdi,%rax,8),%rbp
nopl 0x0(%rax)
lea 0x2bb9(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1487 <func0+0x37>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%esi
add %al,%sil
mov (%r12),%rsi
sbb $0x3,%rdi
add $0x8,%r12
callq 10b0 <__stpcpy_chk@plt>
mov %rbx,%rcx
mov $0x2,%edx
lea 0xb27(%rip),%rsi
mov %rax,%rdi
sub %rax,%rcx
callq 10a0 <__memcpy_chk@plt>
cmp %r12,%rbp
jne 1480 <func0+0x30>
lea 0x2b4c(%rip),%rsi
mov %rsi,%rdi
mov %rsi,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 14fa <func0+0xaa>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%ebx
add %al,%bl
lea 0x2b0f(%rip),%rax
sbb $0x3,%rdx
sub %rsi,%rdx
movb $0x0,-0x1(%rdi,%rdx,1)
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
lea rbx, res_1
mov cs:res_1, 0
test esi, esi
jle short loc_1539
movsxd rsi, esi
mov r14, rdi
lea r12, [rbx+3E8h]
lea r13, [rdi+rsi*8]
lea rbp, unk_2004
nop word ptr [rax+rax+00000000h]
loc_1500:
mov rdi, rbx; s
add r14, 8
call _strlen
mov rsi, [r14-8]
mov edx, 3E8h
lea rdi, [rbx+rax]
call ___stpcpy_chk
mov rcx, r12
mov edx, 2
mov rsi, rbp
mov rdi, rax
sub rcx, rax
call ___memcpy_chk
cmp r13, r14
jnz short loc_1500
loc_1539:
mov rdi, rbx; s
call _strlen
mov byte ptr [rbx+rax-1], 0
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | char * func0(long long a1, int a2)
{
long long v2; // r14
size_t v3; // rax
long long v4; // rax
res_1[0] = 0;
if ( a2 > 0 )
{
v2 = a1;
do
{
v2 += 8LL;
v3 = strlen(res_1);
v4 = __stpcpy_chk(&res_1[v3], *(_QWORD *)(v2 - 8), 1000LL);
__memcpy_chk(v4, &unk_2004, 2LL, &res_1[-v4 + 1000]);
}
while ( a1 + 8LL * a2 != v2 );
}
res_1[strlen(res_1) - 1] = 0;
return res_1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x104040]
MOV byte ptr [0x00104040],0x0
TEST ESI,ESI
JLE 0x00101539
MOVSXD RSI,ESI
MOV R14,RDI
LEA R12,[RBX + 0x3e8]
LEA R13,[RDI + RSI*0x8]
LEA RBP,[0x102004]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101500:
MOV RDI,RBX
ADD R14,0x8
CALL 0x001010a0
MOV RSI,qword ptr [R14 + -0x8]
MOV EDX,0x3e8
LEA RDI,[RBX + RAX*0x1]
CALL 0x001010f0
MOV RCX,R12
MOV EDX,0x2
MOV RSI,RBP
MOV RDI,RAX
SUB RCX,RAX
CALL 0x001010e0
CMP R13,R14
JNZ 0x00101500
LAB_00101539:
MOV RDI,RBX
CALL 0x001010a0
MOV byte ptr [RBX + RAX*0x1 + -0x1],0x0
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int1 * func0(int8 *param_1,int param_2)
{
size_t sVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
res_1[0] = 0;
if (0 < param_2) {
puVar3 = param_1;
do {
puVar4 = puVar3 + 1;
sVar1 = strlen(res_1);
lVar2 = __stpcpy_chk(res_1 + sVar1,*puVar3,1000);
__memcpy_chk(lVar2,&DAT_00102004,2,(long)&_end - lVar2);
puVar3 = puVar4;
} while (param_1 + param_2 != puVar4);
}
sVar1 = strlen(res_1);
(&DAT_0010403f)[sVar1] = 0;
return res_1;
} |
6,072 | func0 |
#include <assert.h>
int take_L_and_F_set_bits(int n) {
n = n | n >> 1;
n = n | n >> 2;
n = n | n >> 4;
n = n | n >> 8;
n = n | n >> 16;
return ((n + 1) >> 1) + 1;
}
| int func0(int n) {
if (n == 1) {
return 0;
}
return n ^ take_L_and_F_set_bits(n);
}
| int main() {
assert(func0(10) == 3);
assert(func0(15) == 6);
assert(func0(20) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x8,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jne 11a9 <func0+0x1c>
mov $0x0,%eax
jmp 11b6 <func0+0x29>
mov -0x4(%rbp),%eax
mov %eax,%edi
callq 1149 <take_L_and_F_set_bits>
xor -0x4(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 8
mov [rbp+var_4], edi
cmp [rbp+var_4], 1
jnz short loc_11A9
mov eax, 0
jmp short locret_11B6
loc_11A9:
mov eax, [rbp+var_4]
mov edi, eax
call take_L_and_F_set_bits
xor eax, [rbp+var_4]
locret_11B6:
leave
retn | long long func0(unsigned int a1)
{
if ( a1 == 1 )
return 0LL;
else
return a1 ^ (unsigned int)take_L_and_F_set_bits(a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x8
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x1
JNZ 0x001011a9
MOV EAX,0x0
JMP 0x001011b6
LAB_001011a9:
MOV EAX,dword ptr [RBP + -0x4]
MOV EDI,EAX
CALL 0x00101149
XOR EAX,dword ptr [RBP + -0x4]
LAB_001011b6:
LEAVE
RET | uint func0(uint param_1)
{
uint uVar1;
if (param_1 == 1) {
uVar1 = 0;
}
else {
uVar1 = take_L_and_F_set_bits(param_1);
uVar1 = uVar1 ^ param_1;
}
return uVar1;
} |
6,073 | func0 |
#include <assert.h>
int take_L_and_F_set_bits(int n) {
n = n | n >> 1;
n = n | n >> 2;
n = n | n >> 4;
n = n | n >> 8;
n = n | n >> 16;
return ((n + 1) >> 1) + 1;
}
| int func0(int n) {
if (n == 1) {
return 0;
}
return n ^ take_L_and_F_set_bits(n);
}
| int main() {
assert(func0(10) == 3);
assert(func0(15) == 6);
assert(func0(20) == 5);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp $0x1,%edi
je 1192 <func0+0x1a>
push %rbx
mov %edi,%ebx
callq 1149 <take_L_and_F_set_bits>
xor %ebx,%eax
pop %rbx
retq
retq
| func0:
endbr64
mov eax, 0
cmp edi, 1
jz short locret_1192
push rbx
mov ebx, edi
call take_L_and_F_set_bits
xor eax, ebx
pop rbx
retn
locret_1192:
retn | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 != 1 )
return a1 ^ (unsigned int)take_L_and_F_set_bits();
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0x1
JZ 0x00101192
PUSH RBX
MOV EBX,EDI
CALL 0x00101149
XOR EAX,EBX
POP RBX
RET
LAB_00101192:
RET | uint func0(uint param_1)
{
uint uVar1;
if (param_1 != 1) {
uVar1 = take_L_and_F_set_bits();
return uVar1 ^ param_1;
}
return 0;
} |
6,074 | func0 |
#include <assert.h>
int take_L_and_F_set_bits(int n) {
n = n | n >> 1;
n = n | n >> 2;
n = n | n >> 4;
n = n | n >> 8;
n = n | n >> 16;
return ((n + 1) >> 1) + 1;
}
| int func0(int n) {
if (n == 1) {
return 0;
}
return n ^ take_L_and_F_set_bits(n);
}
| int main() {
assert(func0(10) == 3);
assert(func0(15) == 6);
assert(func0(20) == 5);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
cmp $0x1,%edi
je 11a7 <func0+0x37>
mov %edi,%eax
sar %eax
or %edi,%eax
mov %eax,%edx
sar $0x2,%edx
or %edx,%eax
mov %eax,%edx
sar $0x4,%edx
or %edx,%eax
mov %eax,%edx
sar $0x8,%edx
or %edx,%eax
mov %eax,%edx
sar $0x10,%edx
or %edx,%eax
add $0x1,%eax
sar %eax
add $0x1,%eax
xor %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp edi, 1
jz short locret_11A7
mov eax, edi
sar eax, 1
or eax, edi
mov edx, eax
sar edx, 2
or eax, edx
mov edx, eax
sar edx, 4
or eax, edx
mov edx, eax
sar edx, 8
or eax, edx
mov edx, eax
sar edx, 10h
or eax, edx
add eax, 1
sar eax, 1
add eax, 1
xor eax, edi
locret_11A7:
retn | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 != 1 )
return a1 ^ (unsigned int)((((((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16) | ((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1))
+ 1) >> 1)
+ 1);
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x1
JZ 0x001011a7
MOV EAX,EDI
SAR EAX,0x1
OR EAX,EDI
MOV EDX,EAX
SAR EDX,0x2
OR EAX,EDX
MOV EDX,EAX
SAR EDX,0x4
OR EAX,EDX
MOV EDX,EAX
SAR EDX,0x8
OR EAX,EDX
MOV EDX,EAX
SAR EDX,0x10
OR EAX,EDX
ADD EAX,0x1
SAR EAX,0x1
ADD EAX,0x1
XOR EAX,EDI
LAB_001011a7:
RET | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 0;
if (param_1 != 1) {
uVar1 = (int)param_1 >> 1 | param_1;
uVar1 = uVar1 | (int)uVar1 >> 2;
uVar1 = uVar1 | (int)uVar1 >> 4;
uVar1 = uVar1 | (int)uVar1 >> 8;
uVar1 = ((int)((uVar1 | (int)uVar1 >> 0x10) + 1) >> 1) + 1U ^ param_1;
}
return uVar1;
} |
6,075 | func0 |
#include <assert.h>
int take_L_and_F_set_bits(int n) {
n = n | n >> 1;
n = n | n >> 2;
n = n | n >> 4;
n = n | n >> 8;
n = n | n >> 16;
return ((n + 1) >> 1) + 1;
}
| int func0(int n) {
if (n == 1) {
return 0;
}
return n ^ take_L_and_F_set_bits(n);
}
| int main() {
assert(func0(10) == 3);
assert(func0(15) == 6);
assert(func0(20) == 5);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp $0x1,%edi
je 11a7 <func0+0x37>
mov %edi,%eax
sar %eax
or %edi,%eax
mov %eax,%edx
sar $0x2,%edx
or %edx,%eax
mov %eax,%edx
sar $0x4,%edx
or %edx,%eax
mov %eax,%edx
sar $0x8,%edx
or %edx,%eax
mov %eax,%edx
sar $0x10,%edx
or %edx,%eax
add $0x1,%eax
sar %eax
add $0x1,%eax
xor %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp edi, 1
jz short locret_11A7
mov eax, edi
sar eax, 1
or eax, edi
mov edx, eax
sar edx, 2
or eax, edx
mov edx, eax
sar edx, 4
or eax, edx
mov edx, eax
sar edx, 8
or eax, edx
mov edx, eax
sar edx, 10h
or eax, edx
add eax, 1
sar eax, 1
add eax, 1
xor eax, edi
locret_11A7:
retn | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 != 1 )
return a1 ^ (unsigned int)((((((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16) | ((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1))
+ 1) >> 1)
+ 1);
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x1
JZ 0x001011a7
MOV EAX,EDI
SAR EAX,0x1
OR EAX,EDI
MOV EDX,EAX
SAR EDX,0x2
OR EAX,EDX
MOV EDX,EAX
SAR EDX,0x4
OR EAX,EDX
MOV EDX,EAX
SAR EDX,0x8
OR EAX,EDX
MOV EDX,EAX
SAR EDX,0x10
OR EAX,EDX
ADD EAX,0x1
SAR EAX,0x1
ADD EAX,0x1
XOR EAX,EDI
LAB_001011a7:
RET | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 0;
if (param_1 != 1) {
uVar1 = (int)param_1 >> 1 | param_1;
uVar1 = uVar1 | (int)uVar1 >> 2;
uVar1 = uVar1 | (int)uVar1 >> 4;
uVar1 = uVar1 | (int)uVar1 >> 8;
uVar1 = ((int)((uVar1 | (int)uVar1 >> 0x10) + 1) >> 1) + 1U ^ param_1;
}
return uVar1;
} |
6,076 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int flag = -1;
int length = strlen(string);
for (int i = 0; i < length; i++) {
if (string[i] == c) {
flag = i;
}
}
if (flag == -1) {
return -1; // Return -1 to indicate no occurrence
} else {
return flag + 1;
}
}
| int main() {
assert(func0("hello world", 'l') == 10);
assert(func0("language", 'g') == 7);
assert(func0("little", 'y') == -1); // -1 indicates None in Python
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,%eax
mov %al,-0x1c(%rbp)
movl $0xffffffff,-0xc(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11bc <func0+0x53>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x1c(%rbp)
jne 11b8 <func0+0x4f>
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 119d <func0+0x34>
cmpl $0xffffffff,-0xc(%rbp)
jne 11d1 <func0+0x68>
mov $0xffffffff,%eax
jmp 11d7 <func0+0x6e>
mov -0xc(%rbp),%eax
add $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov eax, esi
mov [rbp+var_1C], al
mov [rbp+var_C], 0FFFFFFFFh
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11BC
loc_119D:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_1C], al
jnz short loc_11B8
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
loc_11B8:
add [rbp+var_8], 1
loc_11BC:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_119D
cmp [rbp+var_C], 0FFFFFFFFh
jnz short loc_11D1
mov eax, 0FFFFFFFFh
jmp short locret_11D7
loc_11D1:
mov eax, [rbp+var_C]
add eax, 1
locret_11D7:
leave
retn | long long func0(const char *a1, char a2)
{
int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v3 = -1;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( a2 == a1[i] )
v3 = i;
}
if ( v3 == -1 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(v3 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x1c],AL
MOV dword ptr [RBP + -0xc],0xffffffff
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011bc
LAB_0010119d:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x1c],AL
JNZ 0x001011b8
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011b8:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011bc:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x0010119d
CMP dword ptr [RBP + -0xc],-0x1
JNZ 0x001011d1
MOV EAX,0xffffffff
JMP 0x001011d7
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
LAB_001011d7:
LEAVE
RET | int func0(char *param_1,char param_2)
{
size_t sVar1;
int local_14;
int local_10;
local_14 = -1;
sVar1 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar1; local_10 = local_10 + 1) {
if (param_2 == param_1[local_10]) {
local_14 = local_10;
}
}
if (local_14 == -1) {
local_14 = -1;
}
else {
local_14 = local_14 + 1;
}
return local_14;
} |
6,077 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int flag = -1;
int length = strlen(string);
for (int i = 0; i < length; i++) {
if (string[i] == c) {
flag = i;
}
}
if (flag == -1) {
return -1; // Return -1 to indicate no occurrence
} else {
return flag + 1;
}
}
| int main() {
assert(func0("hello world", 'l') == 10);
assert(func0("language", 'g') == 7);
assert(func0("little", 'y') == -1); // -1 indicates None in Python
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 1196 <func0+0x4d>
lea -0x1(%rcx),%edi
mov $0x0,%eax
mov $0xffffffff,%edx
jmp 117b <func0+0x32>
mov %rcx,%rax
cmp %sil,(%r8,%rax,1)
cmove %eax,%edx
lea 0x1(%rax),%rcx
cmp %rdi,%rax
jne 1178 <func0+0x2f>
cmp $0xffffffff,%edx
je 1193 <func0+0x4a>
add $0x1,%edx
mov %edx,%eax
retq
mov $0xffffffff,%edx
jmp 1193 <func0+0x4a>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
call _strlen
test eax, eax
jle short loc_11B4
lea esi, [rax-1]
mov eax, 0
mov edx, 0FFFFFFFFh
jmp short loc_1193
loc_1190:
mov rax, rcx
loc_1193:
cmp [rbx+rax], bpl
cmovz edx, eax
lea rcx, [rax+1]
cmp rax, rsi
jnz short loc_1190
cmp edx, 0FFFFFFFFh
jz short loc_11AB
add edx, 1
loc_11AB:
mov eax, edx
add rsp, 8
pop rbx
pop rbp
retn
loc_11B4:
mov edx, 0FFFFFFFFh
jmp short loc_11AB | long long func0(long long a1, char a2)
{
int v3; // eax
long long v4; // rsi
long long v5; // rax
unsigned int v6; // edx
v3 = strlen();
if ( v3 <= 0 )
{
return (unsigned int)-1;
}
else
{
v4 = (unsigned int)(v3 - 1);
v5 = 0LL;
v6 = -1;
while ( 1 )
{
if ( *(_BYTE *)(a1 + v5) == a2 )
v6 = v5;
if ( v5 == v4 )
break;
++v5;
}
if ( v6 != -1 )
++v6;
}
return v6;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011b4
LEA ESI,[RAX + -0x1]
MOV EAX,0x0
MOV EDX,0xffffffff
JMP 0x00101193
LAB_00101190:
MOV RAX,RCX
LAB_00101193:
CMP byte ptr [RBX + RAX*0x1],BPL
CMOVZ EDX,EAX
LEA RCX,[RAX + 0x1]
CMP RAX,RSI
JNZ 0x00101190
CMP EDX,-0x1
JZ 0x001011ab
ADD EDX,0x1
LAB_001011ab:
MOV EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011b4:
MOV EDX,0xffffffff
JMP 0x001011ab | ulong func0(char *param_1,char param_2)
{
size_t sVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
uVar3 = 0xffffffff;
}
else {
uVar3 = 0xffffffff;
uVar2 = 0;
do {
if (param_1[uVar2] == param_2) {
uVar3 = uVar2 & 0xffffffff;
}
bVar4 = uVar2 != (int)sVar1 - 1;
uVar2 = uVar2 + 1;
} while (bVar4);
if ((int)uVar3 != -1) {
uVar3 = (ulong)((int)uVar3 + 1);
}
}
return uVar3;
} |
6,078 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int flag = -1;
int length = strlen(string);
for (int i = 0; i < length; i++) {
if (string[i] == c) {
flag = i;
}
}
if (flag == -1) {
return -1; // Return -1 to indicate no occurrence
} else {
return flag + 1;
}
}
| int main() {
assert(func0("hello world", 'l') == 10);
assert(func0("language", 'g') == 7);
assert(func0("little", 'y') == -1); // -1 indicates None in Python
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 1270 <func0+0x50>
lea -0x1(%rax),%ecx
mov $0xffffffff,%r8d
xor %eax,%eax
jmp 124b <func0+0x2b>
nopl (%rax)
mov %rdx,%rax
cmp %bpl,(%rbx,%rax,1)
lea 0x1(%rax),%rdx
cmove %eax,%r8d
cmp %rcx,%rax
jne 1248 <func0+0x28>
cmp $0xffffffff,%r8d
je 1266 <func0+0x46>
add $0x1,%r8d
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
add $0x8,%rsp
mov $0xffffffff,%r8d
mov %r8d,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1270
lea ecx, [rax-1]
mov r8d, 0FFFFFFFFh
xor eax, eax
jmp short loc_124B
loc_1248:
mov rax, rdx
loc_124B:
cmp [rbx+rax], bpl
lea rdx, [rax+1]
cmovz r8d, eax
cmp rax, rcx
jnz short loc_1248
cmp r8d, 0FFFFFFFFh
jz short loc_1266
add r8d, 1
loc_1266:
add rsp, 8
mov eax, r8d
pop rbx
pop rbp
retn
loc_1270:
add rsp, 8
mov r8d, 0FFFFFFFFh
mov eax, r8d
pop rbx
pop rbp
retn | long long func0(long long a1, char a2)
{
int v2; // eax
long long v3; // rcx
unsigned int v4; // r8d
long long i; // rax
v2 = strlen();
if ( v2 <= 0 )
return 0xFFFFFFFFLL;
v3 = (unsigned int)(v2 - 1);
v4 = -1;
for ( i = 0LL; ; ++i )
{
if ( *(_BYTE *)(a1 + i) == a2 )
v4 = i;
if ( i == v3 )
break;
}
if ( v4 != -1 )
++v4;
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101270
LEA ECX,[RAX + -0x1]
MOV R8D,0xffffffff
XOR EAX,EAX
JMP 0x0010124b
LAB_00101248:
MOV RAX,RDX
LAB_0010124b:
CMP byte ptr [RBX + RAX*0x1],BPL
LEA RDX,[RAX + 0x1]
CMOVZ R8D,EAX
CMP RAX,RCX
JNZ 0x00101248
CMP R8D,-0x1
JZ 0x00101266
ADD R8D,0x1
LAB_00101266:
ADD RSP,0x8
MOV EAX,R8D
POP RBX
POP RBP
RET
LAB_00101270:
ADD RSP,0x8
MOV R8D,0xffffffff
MOV EAX,R8D
POP RBX
POP RBP
RET | ulong func0(char *param_1,char param_2)
{
size_t sVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
return 0xffffffff;
}
uVar3 = 0xffffffff;
uVar2 = 0;
do {
if (param_1[uVar2] == param_2) {
uVar3 = uVar2 & 0xffffffff;
}
bVar4 = uVar2 != (int)sVar1 - 1;
uVar2 = uVar2 + 1;
} while (bVar4);
if ((int)uVar3 != -1) {
uVar3 = (ulong)((int)uVar3 + 1);
}
return uVar3;
} |
6,079 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int flag = -1;
int length = strlen(string);
for (int i = 0; i < length; i++) {
if (string[i] == c) {
flag = i;
}
}
if (flag == -1) {
return -1; // Return -1 to indicate no occurrence
} else {
return flag + 1;
}
}
| int main() {
assert(func0("hello world", 'l') == 10);
assert(func0("language", 'g') == 7);
assert(func0("little", 'y') == -1); // -1 indicates None in Python
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 1270 <func0+0x50>
lea -0x1(%rax),%ecx
mov $0xffffffff,%r8d
xor %eax,%eax
jmp 124b <func0+0x2b>
nopl (%rax)
mov %rdx,%rax
cmp (%rbx,%rax,1),%bpl
lea 0x1(%rax),%rdx
cmove %eax,%r8d
cmp %rax,%rcx
jne 1248 <func0+0x28>
cmp $0xffffffff,%r8d
je 1266 <func0+0x46>
add $0x1,%r8d
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
add $0x8,%rsp
mov $0xffffffff,%r8d
mov %r8d,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1270
lea esi, [rax-1]
mov edx, 0FFFFFFFFh
xor eax, eax
jmp short loc_124B
loc_1248:
mov rax, rcx
loc_124B:
cmp bpl, [rbx+rax]
lea rcx, [rax+1]
cmovz edx, eax
cmp rsi, rax
jnz short loc_1248
cmp edx, 0FFFFFFFFh
jz short loc_1263
add edx, 1
loc_1263:
add rsp, 8
mov eax, edx
pop rbx
pop rbp
retn
loc_1270:
add rsp, 8
mov edx, 0FFFFFFFFh
mov eax, edx
pop rbx
pop rbp
retn | long long func0(const char *a1, char a2)
{
int v3; // eax
long long v4; // rsi
unsigned int v5; // edx
long long i; // rax
v3 = strlen(a1);
if ( v3 <= 0 )
return 0xFFFFFFFFLL;
v4 = (unsigned int)(v3 - 1);
v5 = -1;
for ( i = 0LL; ; ++i )
{
if ( a2 == a1[i] )
v5 = i;
if ( v4 == i )
break;
}
if ( v5 != -1 )
++v5;
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101270
LEA ESI,[RAX + -0x1]
MOV EDX,0xffffffff
XOR EAX,EAX
JMP 0x0010124b
LAB_00101248:
MOV RAX,RCX
LAB_0010124b:
CMP BPL,byte ptr [RBX + RAX*0x1]
LEA RCX,[RAX + 0x1]
CMOVZ EDX,EAX
CMP RSI,RAX
JNZ 0x00101248
CMP EDX,-0x1
JZ 0x00101263
ADD EDX,0x1
LAB_00101263:
ADD RSP,0x8
MOV EAX,EDX
POP RBX
POP RBP
RET
LAB_00101270:
ADD RSP,0x8
MOV EDX,0xffffffff
MOV EAX,EDX
POP RBX
POP RBP
RET | ulong func0(char *param_1,char param_2)
{
size_t sVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
return 0xffffffff;
}
uVar3 = 0xffffffff;
uVar2 = 0;
do {
if (param_2 == param_1[uVar2]) {
uVar3 = uVar2 & 0xffffffff;
}
bVar4 = (int)sVar1 - 1 != uVar2;
uVar2 = uVar2 + 1;
} while (bVar4);
if ((int)uVar3 != -1) {
uVar3 = (ulong)((int)uVar3 + 1);
}
return uVar3;
} |
6,080 | func0 | #include <assert.h>
| int func0(int n) {
int i = 1;
int sum = 0;
while (n / i > 0) {
sum = sum + n / i;
i = i * 2;
}
return sum;
}
| int main() {
assert(func0(4) == 7);
assert(func0(2) == 3);
assert(func0(5) == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1171 <func0+0x28>
mov -0x14(%rbp),%eax
cltd
idivl -0x8(%rbp)
add %eax,-0x4(%rbp)
shll -0x8(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x8(%rbp)
test %eax,%eax
jg 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1171
loc_1164:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_8]
add [rbp+var_4], eax
shl [rbp+var_8], 1
loc_1171:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_8]
test eax, eax
jg short loc_1164
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-8h]
unsigned int v3; // [rsp+10h] [rbp-4h]
v2 = 1;
v3 = 0;
while ( a1 / v2 > 0 )
{
v3 += a1 / v2;
v2 *= 2;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101171
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x8]
ADD dword ptr [RBP + -0x4],EAX
SHL dword ptr [RBP + -0x8],0x1
LAB_00101171:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x8]
TEST EAX,EAX
JG 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_c = 0;
for (local_10 = 1; 0 < param_1 / local_10; local_10 = local_10 << 1) {
local_c = local_c + param_1 / local_10;
}
return local_c;
} |
6,081 | func0 | #include <assert.h>
| int func0(int n) {
int i = 1;
int sum = 0;
while (n / i > 0) {
sum = sum + n / i;
i = i * 2;
}
return sum;
}
| int main() {
assert(func0(4) == 7);
assert(func0(2) == 3);
assert(func0(5) == 8);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 116f <func0+0x26>
mov %edi,%edx
mov $0x0,%esi
mov $0x1,%ecx
add %edx,%esi
add %ecx,%ecx
mov %edi,%eax
cltd
idiv %ecx
mov %eax,%edx
test %eax,%eax
jg 115d <func0+0x14>
mov %esi,%eax
retq
mov $0x0,%esi
jmp 116c <func0+0x23>
| func0:
endbr64
test edi, edi
jle short loc_116F
mov edx, edi
mov esi, 0
mov ecx, 1
loc_115D:
add esi, edx
add ecx, ecx
mov eax, edi
cdq
idiv ecx
mov edx, eax
test eax, eax
jg short loc_115D
loc_116C:
mov eax, esi
retn
loc_116F:
mov esi, 0
jmp short loc_116C | long long func0(int a1)
{
int v1; // edx
unsigned int v2; // esi
int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1;
v2 = 0;
v3 = 1;
do
{
v2 += v1;
v3 *= 2;
v1 = a1 / v3;
}
while ( a1 / v3 > 0 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010116f
MOV EDX,EDI
MOV ESI,0x0
MOV ECX,0x1
LAB_0010115d:
ADD ESI,EDX
ADD ECX,ECX
MOV EAX,EDI
CDQ
IDIV ECX
MOV EDX,EAX
TEST EAX,EAX
JG 0x0010115d
LAB_0010116c:
MOV EAX,ESI
RET
LAB_0010116f:
MOV ESI,0x0
JMP 0x0010116c | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
iVar3 = 0;
}
else {
iVar3 = 0;
iVar2 = 1;
iVar1 = param_1;
do {
iVar3 = iVar3 + iVar1;
iVar2 = iVar2 * 2;
iVar1 = param_1 / iVar2;
} while (0 < iVar1);
}
return iVar3;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.