index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
4,382 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == 0) {
result[resultIndex++] = j;
}
j += i;
}
}
}
for (int i = 0; i < resultIndex - 1; i++) {
for (int j = 0; j < resultIndex - i - 1; j++) {
if (result[j] > result[j + 1]) {
int temp = result[j];
result[j] = result[j + 1];
result[j + 1] = temp;
}
}
}
return result[n - 1];
}
| int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 123d <func0+0xd>
sub $0xdd0,%rsp
xor %esi,%esi
mov $0x2ee0,%edx
mov %fs:0x28,%rax
mov %rax,0x5dc8(%rsp)
xor %eax,%eax
mov %edi,%ebx
mov %rsp,%rdi
callq 1090 <memset@plt>
mov $0x2,%ecx
xor %esi,%esi
mov %rax,%rdi
xor %eax,%eax
jmp 12a0 <func0+0x70>
nopw 0x0(%rax,%rax,1)
add $0x1,%rcx
cmp $0xbb8,%rcx
je 12f2 <func0+0xc2>
mov (%rdi,%rcx,4),%eax
test %eax,%eax
jne 1290 <func0+0x60>
lea (%rcx,%rcx,1),%eax
movl $0x1,(%rdi,%rcx,4)
cmp $0xbb7,%eax
ja 1290 <func0+0x60>
lea (%rcx,%rcx,1),%rax
nopl 0x0(%rax)
mov (%rdi,%rax,4),%edx
sub $0x1,%edx
mov %edx,(%rdi,%rax,4)
cmp $0xfffffffd,%edx
jne 12db <func0+0xab>
movslq %esi,%rdx
add $0x1,%esi
mov %eax,0x2ee0(%rsp,%rdx,4)
add %rcx,%rax
cmp $0xbb7,%eax
jle 12c0 <func0+0x90>
add $0x1,%rcx
cmp $0xbb8,%rcx
jne 129d <func0+0x6d>
sub $0x1,%esi
test %esi,%esi
jle 133b <func0+0x10b>
lea 0x2ee0(%rsp),%r9
lea 0x2ee4(%rsp),%r8
nopl 0x0(%rax)
lea -0x1(%rsi),%edx
mov %r9,%rax
mov %rdx,%rsi
lea (%r8,%rdx,4),%rdi
nopl (%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 132e <func0+0xfe>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rdi,%rax
jne 1320 <func0+0xf0>
test %esi,%esi
jne 1310 <func0+0xe0>
lea -0x1(%rbx),%eax
mov 0x5dc8(%rsp),%rbx
xor %fs:0x28,%rbx
cltq
mov 0x2ee0(%rsp,%rax,4),%eax
jne 1363 <func0+0x133>
add $0x5dd0,%rsp
pop %rbx
retq
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
lea r11, [rsp+8+var_5008]
loc_123D:
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
cmp rsp, r11
jnz short loc_123D
sub rsp, 0DD0h
xor esi, esi
mov edx, 2EE0h
mov rax, fs:28h
mov [rsp+1DD8h+arg_3FE8], rax
xor eax, eax
mov ebx, edi
mov rdi, rsp
call _memset
mov r8d, 4
mov ecx, 2
xor esi, esi
mov rdi, rax
xor eax, eax
jmp short loc_12A4
loc_1290:
add rcx, 1
add r8, 2
cmp rcx, 0BB8h
jz short loc_12E7
mov eax, [rdi+rcx*4]
loc_12A4:
test eax, eax
jnz short loc_1290
mov dword ptr [rdi+rcx*4], 1
cmp r8, 0BB7h
ja short loc_1290
mov rax, r8
nop dword ptr [rax+rax+00h]
loc_12C0:
mov edx, [rdi+rax*4]
sub edx, 1
mov [rdi+rax*4], edx
cmp edx, 0FFFFFFFDh
jnz short loc_12DB
movsxd rdx, esi
add esi, 1
mov [rsp+rdx*4+1DD8h+arg_1100], eax
loc_12DB:
add rax, rcx
cmp eax, 0BB7h
jle short loc_12C0
jmp short loc_1290
loc_12E7:
sub esi, 1
test esi, esi
jle short loc_132B
lea r9, [rsp+1DD8h+arg_1100]
lea r8, [rsp+1DD8h+arg_1104]
xchg ax, ax
loc_1300:
lea edx, [rsi-1]
mov rax, r9
mov rsi, rdx
lea rdi, [r8+rdx*4]
nop dword ptr [rax]
loc_1310:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_131E
mov [rax], ecx
mov [rax+4], edx
loc_131E:
add rax, 4
cmp rax, rdi
jnz short loc_1310
test esi, esi
jnz short loc_1300
loc_132B:
lea eax, [rbx-1]
cdqe
mov eax, [rsp+rax*4+1DD8h+arg_1100]
mov rdx, [rsp+1DD8h+arg_3FE8]
sub rdx, fs:28h
jnz short loc_1353
add rsp, 5DD0h
pop rbx
retn
loc_1353:
call ___stack_chk_fail | // positive sp value has been detected, the output may be wrong!
long long func0(int a1)
{
long long v2; // rax
unsigned long long v3; // r8
long long v4; // rcx
int v5; // esi
long long v6; // rdi
int i; // eax
unsigned long long v8; // rax
int v9; // edx
long long v10; // rdx
long long v11; // rsi
_QWORD *v12; // rax
int v13; // edx
int v14; // ecx
long long v16; // [rsp-DD0h] [rbp-5DD8h] BYREF
char v17; // [rsp+0h] [rbp-5008h] BYREF
long long v18; // [rsp+1000h] [rbp-4008h] BYREF
_QWORD v19[1503]; // [rsp+2110h] [rbp-2EF8h] BYREF
while ( &v17 != (char *)(&v18 - 2560) )
;
v19[1501] = __readfsqword(0x28u);
v2 = ((long long ( *)(long long *, _QWORD, long long))memset)(&v16, 0LL, 12000LL);
v3 = 4LL;
v4 = 2LL;
v5 = 0;
v6 = v2;
for ( i = 0; ; i = *(_DWORD *)(v6 + 4 * v4) )
{
if ( !i )
{
*(_DWORD *)(v6 + 4 * v4) = 1;
if ( v3 <= 0xBB7 )
{
v8 = v3;
do
{
v9 = *(_DWORD *)(v6 + 4 * v8) - 1;
*(_DWORD *)(v6 + 4 * v8) = v9;
if ( v9 == -3 )
{
v10 = v5++;
*((_DWORD *)v19 + v10) = v8;
}
v8 += v4;
}
while ( (int)v8 <= 2999 );
}
}
++v4;
v3 += 2LL;
if ( v4 == 3000 )
break;
}
LODWORD(v11) = v5 - 1;
if ( (int)v11 > 0 )
{
do
{
v12 = v19;
v11 = (unsigned int)(v11 - 1);
do
{
v13 = *(_DWORD *)v12;
v14 = *((_DWORD *)v12 + 1);
if ( *(_DWORD *)v12 > v14 )
{
*(_DWORD *)v12 = v14;
*((_DWORD *)v12 + 1) = v13;
}
v12 = (_QWORD *)((char *)v12 + 4);
}
while ( v12 != (_QWORD *)((char *)v19 + 4 * v11 + 4) );
}
while ( (_DWORD)v11 );
}
return *((unsigned int *)v19 + a1 - 1);
} | func0:
ENDBR64
PUSH RBX
LEA R11,[RSP + -0x5000]
LAB_0010123d:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x0010123d
SUB RSP,0xdd0
XOR ESI,ESI
MOV EDX,0x2ee0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x5dc8],RAX
XOR EAX,EAX
MOV EBX,EDI
MOV RDI,RSP
CALL 0x00101090
MOV R8D,0x4
MOV ECX,0x2
XOR ESI,ESI
MOV RDI,RAX
XOR EAX,EAX
JMP 0x001012a4
LAB_00101290:
ADD RCX,0x1
ADD R8,0x2
CMP RCX,0xbb8
JZ 0x001012e7
MOV EAX,dword ptr [RDI + RCX*0x4]
LAB_001012a4:
TEST EAX,EAX
JNZ 0x00101290
MOV dword ptr [RDI + RCX*0x4],0x1
CMP R8,0xbb7
JA 0x00101290
MOV RAX,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RAX*0x4]
SUB EDX,0x1
MOV dword ptr [RDI + RAX*0x4],EDX
CMP EDX,-0x3
JNZ 0x001012db
MOVSXD RDX,ESI
ADD ESI,0x1
MOV dword ptr [RSP + RDX*0x4 + 0x2ee0],EAX
LAB_001012db:
ADD RAX,RCX
CMP EAX,0xbb7
JLE 0x001012c0
JMP 0x00101290
LAB_001012e7:
SUB ESI,0x1
TEST ESI,ESI
JLE 0x0010132b
LEA R9,[RSP + 0x2ee0]
LEA R8,[RSP + 0x2ee4]
NOP
LAB_00101300:
LEA EDX,[RSI + -0x1]
MOV RAX,R9
MOV RSI,RDX
LEA RDI,[R8 + RDX*0x4]
NOP dword ptr [RAX]
LAB_00101310:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x0010131e
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
LAB_0010131e:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101310
TEST ESI,ESI
JNZ 0x00101300
LAB_0010132b:
LEA EAX,[RBX + -0x1]
CDQE
MOV EAX,dword ptr [RSP + RAX*0x4 + 0x2ee0]
MOV RDX,qword ptr [RSP + 0x5dc8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101353
ADD RSP,0x5dd0
POP RBX
RET
LAB_00101353:
CALL 0x00101070 | int4 func0(int param_1)
{
int1 *puVar1;
void *pvVar2;
ulong uVar3;
int *piVar4;
long lVar5;
int iVar6;
uint uVar7;
long lVar8;
int1 *puVar9;
int iVar10;
ulong uVar11;
long in_FS_OFFSET;
int1 local_5008 [20480];
puVar1 = &stack0xfffffffffffffff8;
do {
puVar9 = puVar1;
*(int8 *)(puVar9 + -0x1000) = *(int8 *)(puVar9 + -0x1000);
puVar1 = puVar9 + -0x1000;
} while (puVar9 + -0x1000 != local_5008);
*(int8 *)(puVar9 + 0x3ff8) = *(int8 *)(in_FS_OFFSET + 0x28);
*(int8 *)(puVar9 + -0x1dd8) = 0x101279;
pvVar2 = memset(puVar9 + -0x1dd0,0,12000);
uVar11 = 4;
lVar5 = 2;
iVar10 = 0;
iVar6 = 0;
while( true ) {
if ((iVar6 == 0) &&
(*(int4 *)((long)pvVar2 + lVar5 * 4) = 1, uVar3 = uVar11, uVar11 < 3000)) {
do {
iVar6 = *(int *)((long)pvVar2 + uVar3 * 4) + -1;
*(int *)((long)pvVar2 + uVar3 * 4) = iVar6;
if (iVar6 == -3) {
lVar8 = (long)iVar10;
iVar10 = iVar10 + 1;
*(int *)(puVar9 + lVar8 * 4 + 0x1110) = (int)uVar3;
}
uVar3 = uVar3 + lVar5;
} while ((int)uVar3 < 3000);
}
lVar5 = lVar5 + 1;
uVar11 = uVar11 + 2;
if (lVar5 == 3000) break;
iVar6 = *(int *)((long)pvVar2 + lVar5 * 4);
}
uVar11 = (ulong)(iVar10 - 1U);
if (0 < (int)(iVar10 - 1U)) {
do {
uVar7 = (int)uVar11 - 1;
uVar11 = (ulong)uVar7;
piVar4 = (int *)(puVar9 + 0x1110);
do {
iVar6 = *piVar4;
if (piVar4[1] < iVar6) {
*piVar4 = piVar4[1];
piVar4[1] = iVar6;
}
piVar4 = piVar4 + 1;
} while (piVar4 != (int *)(puVar9 + uVar11 * 4 + 0x1114));
} while (uVar7 != 0);
}
if (*(long *)(puVar9 + 0x3ff8) != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar9 + -0x1dd8) = _fini;
__stack_chk_fail();
}
return *(int4 *)(puVar9 + (long)(param_1 + -1) * 4 + 0x1110);
} |
4,383 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == 0) {
result[resultIndex++] = j;
}
j += i;
}
}
}
for (int i = 0; i < resultIndex - 1; i++) {
for (int j = 0; j < resultIndex - i - 1; j++) {
if (result[j] > result[j + 1]) {
int temp = result[j];
result[j] = result[j + 1];
result[j + 1] = temp;
}
}
}
return result[n - 1];
}
| int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 123d <func0+0xd>
sub $0xdd0,%rsp
xor %esi,%esi
mov $0x2ee0,%edx
mov %fs:0x28,%rax
mov %rax,0x5dc8(%rsp)
xor %eax,%eax
mov %edi,%ebx
mov %rsp,%rdi
callq 1090 <memset@plt>
mov $0x2,%ecx
xor %esi,%esi
mov %rax,%rdi
jmp 1295 <func0+0x65>
nopl (%rax)
add $0x1,%rcx
cmp $0xbb8,%rcx
je 12ea <func0+0xba>
mov (%rdi,%rcx,4),%eax
test %eax,%eax
jne 1288 <func0+0x58>
lea (%rcx,%rcx,1),%eax
movl $0x1,(%rdi,%rcx,4)
cmp $0xbb7,%eax
ja 1288 <func0+0x58>
lea (%rcx,%rcx,1),%rax
nopl 0x0(%rax)
mov (%rdi,%rax,4),%edx
sub $0x1,%edx
mov %edx,(%rdi,%rax,4)
cmp $0xfffffffd,%edx
jne 12d3 <func0+0xa3>
movslq %esi,%rdx
add $0x1,%esi
mov %eax,0x2ee0(%rsp,%rdx,4)
add %rcx,%rax
cmp $0xbb7,%eax
jle 12b8 <func0+0x88>
add $0x1,%rcx
cmp $0xbb8,%rcx
jne 1295 <func0+0x65>
sub $0x1,%esi
test %esi,%esi
jle 1333 <func0+0x103>
lea 0x2ee0(%rsp),%r9
lea 0x2ee4(%rsp),%r8
nopl 0x0(%rax)
lea -0x1(%rsi),%edx
mov %r9,%rax
mov %rdx,%rsi
lea (%r8,%rdx,4),%rdi
nopl (%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 1326 <func0+0xf6>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rdi,%rax
jne 1318 <func0+0xe8>
test %esi,%esi
jne 1308 <func0+0xd8>
lea -0x1(%rbx),%eax
mov 0x5dc8(%rsp),%rbx
xor %fs:0x28,%rbx
cltq
mov 0x2ee0(%rsp,%rax,4),%eax
jne 135b <func0+0x12b>
add $0x5dd0,%rsp
pop %rbx
retq
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
lea r11, [rsp+8+var_5008]
loc_123D:
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
cmp rsp, r11
jnz short loc_123D
sub rsp, 0DD0h
xor esi, esi; c
mov edx, 2EE0h; n
mov rax, fs:28h
mov [rsp+1DD8h+arg_3FE8], rax
xor eax, eax
mov ebx, edi
mov rdi, rsp; s
call _memset
mov r8d, 4
mov ecx, 2
xor esi, esi
mov rdi, rax
jmp short loc_12A1
loc_1290:
add rcx, 1
add r8, 2
cmp rcx, 0BB8h
jz short loc_12E7
loc_12A1:
mov eax, [rdi+rcx*4]
test eax, eax
jnz short loc_1290
mov dword ptr [rdi+rcx*4], 1
cmp r8, 0BB7h
ja short loc_1290
mov rax, r8
nop dword ptr [rax+rax+00h]
loc_12C0:
mov edx, [rdi+rax*4]
sub edx, 1
mov [rdi+rax*4], edx
cmp edx, 0FFFFFFFDh
jnz short loc_12DB
movsxd rdx, esi
add esi, 1
mov [rsp+rdx*4+1DD8h+arg_1100], eax
loc_12DB:
add rax, rcx
cmp eax, 0BB7h
jle short loc_12C0
jmp short loc_1290
loc_12E7:
cmp esi, 1
jle short loc_133F
lea r9, [rsp+1DD8h+arg_1100]
lea r8, [rsp+1DD8h+arg_1104]
nop dword ptr [rax+00h]
loc_1300:
cmp esi, 1
jle short loc_1367
lea edx, [rsi-2]
mov rax, r9
lea rdi, [r8+rdx*4]
nop
loc_1310:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd edx, xmm0
movd ecx, xmm1
cmp ecx, edx
jge short loc_132E
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_132E:
add rax, 4
cmp rax, rdi
jnz short loc_1310
sub esi, 1
cmp esi, 1
jnz short loc_1300
loc_133F:
lea eax, [rbx-1]
cdqe
mov eax, [rsp+rax*4+1DD8h+arg_1100]
mov rdx, [rsp+1DD8h+arg_3FE8]
sub rdx, fs:28h
jnz short loc_136C
add rsp, 5DD0h
pop rbx
retn
loc_1367:
sub esi, 1
jmp short loc_1300
loc_136C:
call ___stack_chk_fail | // positive sp value has been detected, the output may be wrong!
long long func0(int a1)
{
_DWORD *v2; // rax
unsigned long long v3; // r8
long long v4; // rcx
int v5; // esi
_DWORD *v6; // rdi
unsigned long long v7; // rax
int v8; // edx
long long v9; // rdx
__m128i *v10; // rax
__m128i v11; // xmm0
long long v13; // [rsp-DD0h] [rbp-5DD8h] BYREF
char v14; // [rsp+0h] [rbp-5008h] BYREF
long long v15; // [rsp+1000h] [rbp-4008h] BYREF
_QWORD v16[1503]; // [rsp+2110h] [rbp-2EF8h] BYREF
while ( &v14 != (char *)(&v15 - 2560) )
;
v16[1501] = __readfsqword(0x28u);
v2 = memset(&v13, 0, 0x2EE0uLL);
v3 = 4LL;
v4 = 2LL;
v5 = 0;
v6 = v2;
do
{
if ( !v6[v4] )
{
v6[v4] = 1;
if ( v3 <= 0xBB7 )
{
v7 = v3;
do
{
v8 = v6[v7] - 1;
v6[v7] = v8;
if ( v8 == -3 )
{
v9 = v5++;
*((_DWORD *)v16 + v9) = v7;
}
v7 += v4;
}
while ( (int)v7 <= 2999 );
}
}
++v4;
v3 += 2LL;
}
while ( v4 != 3000 );
if ( v5 > 1 )
{
do
{
while ( v5 <= 1 )
--v5;
v10 = (__m128i *)v16;
do
{
v11 = _mm_loadl_epi64(v10);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v11, 229)) < _mm_cvtsi128_si32(v11) )
v10->m128i_i64[0] = _mm_shuffle_epi32(v11, 225).m128i_u64[0];
v10 = (__m128i *)((char *)v10 + 4);
}
while ( v10 != (__m128i *)((char *)v16 + 4 * (unsigned int)(v5 - 2) + 4) );
--v5;
}
while ( v5 != 1 );
}
return *((unsigned int *)v16 + a1 - 1);
} | func0:
ENDBR64
PUSH RBX
LEA R11,[RSP + -0x5000]
LAB_0010123d:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x0010123d
SUB RSP,0xdd0
XOR ESI,ESI
MOV EDX,0x2ee0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x5dc8],RAX
XOR EAX,EAX
MOV EBX,EDI
MOV RDI,RSP
CALL 0x00101090
MOV R8D,0x4
MOV ECX,0x2
XOR ESI,ESI
MOV RDI,RAX
JMP 0x001012a1
LAB_00101290:
ADD RCX,0x1
ADD R8,0x2
CMP RCX,0xbb8
JZ 0x001012e7
LAB_001012a1:
MOV EAX,dword ptr [RDI + RCX*0x4]
TEST EAX,EAX
JNZ 0x00101290
MOV dword ptr [RDI + RCX*0x4],0x1
CMP R8,0xbb7
JA 0x00101290
MOV RAX,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RAX*0x4]
SUB EDX,0x1
MOV dword ptr [RDI + RAX*0x4],EDX
CMP EDX,-0x3
JNZ 0x001012db
MOVSXD RDX,ESI
ADD ESI,0x1
MOV dword ptr [RSP + RDX*0x4 + 0x2ee0],EAX
LAB_001012db:
ADD RAX,RCX
CMP EAX,0xbb7
JLE 0x001012c0
JMP 0x00101290
LAB_001012e7:
CMP ESI,0x1
JLE 0x0010133f
LEA R9,[RSP + 0x2ee0]
LEA R8,[RSP + 0x2ee4]
NOP dword ptr [RAX]
LAB_00101300:
CMP ESI,0x1
JLE 0x00101367
LEA EDX,[RSI + -0x2]
MOV RAX,R9
LEA RDI,[R8 + RDX*0x4]
NOP
LAB_00101310:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM1
CMP ECX,EDX
JGE 0x0010132e
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_0010132e:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101310
SUB ESI,0x1
CMP ESI,0x1
JNZ 0x00101300
LAB_0010133f:
LEA EAX,[RBX + -0x1]
CDQE
MOV EAX,dword ptr [RSP + RAX*0x4 + 0x2ee0]
MOV RDX,qword ptr [RSP + 0x5dc8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010136c
ADD RSP,0x5dd0
POP RBX
RET
LAB_00101367:
SUB ESI,0x1
JMP 0x00101300
LAB_0010136c:
CALL 0x00101070 | int4 func0(int param_1)
{
int *puVar1;
void *pvVar2;
ulong uVar3;
int8 *puVar4;
long lVar5;
int iVar6;
long lVar7;
int *puVar8;
int iVar9;
ulong uVar10;
long in_FS_OFFSET;
int iVar11;
int local_5008 [20480];
puVar1 = &stack0xfffffffffffffff8;
do {
puVar8 = puVar1;
*(int8 *)(puVar8 + -0x1000) = *(int8 *)(puVar8 + -0x1000);
puVar1 = puVar8 + -0x1000;
} while (puVar8 + -0x1000 != local_5008);
*(int8 *)(puVar8 + 0x3ff8) = *(int8 *)(in_FS_OFFSET + 0x28);
*(int8 *)(puVar8 + -0x1dd8) = 0x101279;
pvVar2 = memset(puVar8 + -0x1dd0,0,12000);
uVar10 = 4;
lVar5 = 2;
iVar9 = 0;
do {
if ((*(int *)((long)pvVar2 + lVar5 * 4) == 0) &&
(*(int4 *)((long)pvVar2 + lVar5 * 4) = 1, uVar3 = uVar10, uVar10 < 3000)) {
do {
iVar6 = *(int *)((long)pvVar2 + uVar3 * 4) + -1;
*(int *)((long)pvVar2 + uVar3 * 4) = iVar6;
if (iVar6 == -3) {
lVar7 = (long)iVar9;
iVar9 = iVar9 + 1;
*(int *)(puVar8 + lVar7 * 4 + 0x1110) = (int)uVar3;
}
uVar3 = uVar3 + lVar5;
} while ((int)uVar3 < 3000);
}
lVar5 = lVar5 + 1;
uVar10 = uVar10 + 2;
} while (lVar5 != 3000);
if (1 < iVar9) {
do {
for (; iVar9 < 2; iVar9 = iVar9 + -1) {
}
puVar4 = (int8 *)(puVar8 + 0x1110);
do {
iVar6 = (int)*puVar4;
iVar11 = (int)((ulong)*puVar4 >> 0x20);
if (iVar11 < iVar6) {
*puVar4 = CONCAT44(iVar6,iVar11);
}
puVar4 = (int8 *)((long)puVar4 + 4);
} while (puVar4 != (int8 *)(puVar8 + (ulong)(iVar9 - 2) * 4 + 0x1114));
iVar9 = iVar9 + -1;
} while (iVar9 != 1);
}
if (*(long *)(puVar8 + 0x3ff8) != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + -0x1dd8) = 0x101371;
__stack_chk_fail();
}
return *(int4 *)(puVar8 + (long)(param_1 + -1) * 4 + 0x1110);
} |
4,384 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == 0) {
sum_fact += fact;
}
}
int sum_fact2 = 0;
for (int fact = 1; fact < sum_fact; fact++) {
if (sum_fact % fact == 0) {
sum_fact2 += fact;
}
}
if (num == sum_fact2 && num != sum_fact) {
amicables_sum += num;
}
}
return amicables_sum;
}
| int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
cmpl $0x0,-0x24(%rbp)
jg 1184 <func0+0x1b>
mov $0xffffffff,%eax
jmpq 1217 <func0+0xae>
movl $0x0,-0x18(%rbp)
movl $0x2,-0x14(%rbp)
jmp 120c <func0+0xa3>
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11bb <func0+0x52>
mov -0x14(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11b7 <func0+0x4e>
mov -0xc(%rbp),%eax
add %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 11a4 <func0+0x3b>
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11ea <func0+0x81>
mov -0x10(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11e6 <func0+0x7d>
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 11d3 <func0+0x6a>
mov -0x14(%rbp),%eax
cmp -0x8(%rbp),%eax
jne 1208 <func0+0x9f>
mov -0x14(%rbp),%eax
cmp -0x10(%rbp),%eax
je 1208 <func0+0x9f>
mov -0x14(%rbp),%eax
add %eax,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 1194 <func0+0x2b>
mov -0x18(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
cmp [rbp+var_24], 0
jg short loc_1184
mov eax, 0FFFFFFFFh
jmp loc_1217
loc_1184:
mov [rbp+var_18], 0
mov [rbp+var_14], 2
jmp short loc_120C
loc_1194:
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp short loc_11BB
loc_11A4:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_C]
mov eax, edx
test eax, eax
jnz short loc_11B7
mov eax, [rbp+var_C]
add [rbp+var_10], eax
loc_11B7:
add [rbp+var_C], 1
loc_11BB:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jl short loc_11A4
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_11EA
loc_11D3:
mov eax, [rbp+var_10]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_11E6
mov eax, [rbp+var_4]
add [rbp+var_8], eax
loc_11E6:
add [rbp+var_4], 1
loc_11EA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_10]
jl short loc_11D3
mov eax, [rbp+var_14]
cmp eax, [rbp+var_8]
jnz short loc_1208
mov eax, [rbp+var_14]
cmp eax, [rbp+var_10]
jz short loc_1208
mov eax, [rbp+var_14]
add [rbp+var_18], eax
loc_1208:
add [rbp+var_14], 1
loc_120C:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jle short loc_1194
mov eax, [rbp+var_18]
loc_1217:
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-18h]
int i; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int j; // [rsp+18h] [rbp-Ch]
int v6; // [rsp+1Ch] [rbp-8h]
int k; // [rsp+20h] [rbp-4h]
if ( a1 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0;
for ( i = 2; i <= a1; ++i )
{
v4 = 0;
for ( j = 1; j < i; ++j )
{
if ( !(i % j) )
v4 += j;
}
v6 = 0;
for ( k = 1; k < v4; ++k )
{
if ( !(v4 % k) )
v6 += k;
}
if ( i == v6 && i != v4 )
v2 += i;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
CMP dword ptr [RBP + -0x24],0x0
JG 0x00101184
MOV EAX,0xffffffff
JMP 0x00101217
LAB_00101184:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x2
JMP 0x0010120c
LAB_00101194:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001011bb
LAB_001011a4:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0xc]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011b7
MOV EAX,dword ptr [RBP + -0xc]
ADD dword ptr [RBP + -0x10],EAX
LAB_001011b7:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011bb:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x001011a4
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011ea
LAB_001011d3:
MOV EAX,dword ptr [RBP + -0x10]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011e6
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011e6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ea:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x001011d3
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x00101208
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x10]
JZ 0x00101208
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x18],EAX
LAB_00101208:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010120c:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x00101194
MOV EAX,dword ptr [RBP + -0x18]
LAB_00101217:
POP RBP
RET | int func0(int param_1)
{
int local_20;
int local_1c;
int local_18;
int local_14;
int local_10;
int local_c;
if (param_1 < 1) {
local_20 = -1;
}
else {
local_20 = 0;
for (local_1c = 2; local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = 0;
for (local_14 = 1; local_14 < local_1c; local_14 = local_14 + 1) {
if (local_1c % local_14 == 0) {
local_18 = local_18 + local_14;
}
}
local_10 = 0;
for (local_c = 1; local_c < local_18; local_c = local_c + 1) {
if (local_18 % local_c == 0) {
local_10 = local_10 + local_c;
}
}
if ((local_1c == local_10) && (local_1c != local_18)) {
local_20 = local_20 + local_1c;
}
}
}
return local_20;
} |
4,385 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == 0) {
sum_fact += fact;
}
}
int sum_fact2 = 0;
for (int fact = 1; fact < sum_fact; fact++) {
if (sum_fact % fact == 0) {
sum_fact2 += fact;
}
}
if (num == sum_fact2 && num != sum_fact) {
amicables_sum += num;
}
}
return amicables_sum;
}
| int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 11fa <func0+0x91>
cmp $0x1,%edi
jle 1202 <func0+0x99>
lea 0x1(%rdi),%r11d
mov $0x2,%edi
mov $0x0,%r9d
mov $0x0,%r10d
jmp 119d <func0+0x34>
add $0x1,%edi
cmp %edi,%r11d
je 1208 <func0+0x9f>
mov $0x1,%esi
mov %r10d,%ecx
mov %r10d,%r8d
cmp $0x1,%edi
jle 11e4 <func0+0x7b>
mov %edi,%eax
cltd
idiv %esi
lea (%rcx,%rsi,1),%eax
test %edx,%edx
cmove %eax,%ecx
add $0x1,%esi
cmp %edi,%esi
jne 11ad <func0+0x44>
cmp $0x1,%ecx
jle 1195 <func0+0x2c>
mov $0x1,%esi
mov %r10d,%r8d
mov %ecx,%eax
cltd
idiv %esi
lea (%r8,%rsi,1),%eax
test %edx,%edx
cmove %eax,%r8d
add $0x1,%esi
cmp %esi,%ecx
jne 11ce <func0+0x65>
cmp %r8d,%edi
jne 1195 <func0+0x2c>
cmp %edi,%ecx
setne %dl
lea (%r9,%rdi,1),%eax
test %dl,%dl
cmovne %eax,%r9d
jmp 1195 <func0+0x2c>
mov $0xffffffff,%r9d
jmp 1208 <func0+0x9f>
mov $0x0,%r9d
mov %r9d,%eax
retq
| func0:
endbr64
test edi, edi
jle loc_1201
cmp edi, 1
jle loc_1209
lea r11d, [rdi+1]
mov edi, 2
mov r9d, 0
mov r10d, 0
jmp short loc_119D
loc_1195:
add edi, 1
cmp r11d, edi
jz short loc_120F
loc_119D:
mov esi, 1
mov ecx, r10d
cmp edi, 1
jle short loc_11F7
loc_11AA:
mov eax, edi
cdq
idiv esi
lea eax, [rcx+rsi]
test edx, edx
cmovz ecx, eax
add esi, 1
cmp esi, edi
jnz short loc_11AA
cmp ecx, 1
jle short loc_1195
mov esi, 1
mov r8d, r10d
loc_11CB:
mov eax, ecx
cdq
idiv esi
lea eax, [r8+rsi]
test edx, edx
cmovz r8d, eax
add esi, 1
cmp ecx, esi
jnz short loc_11CB
loc_11E1:
cmp edi, r8d
jnz short loc_1195
cmp esi, edi
setnz dl
lea eax, [r9+rdi]
test dl, dl
cmovnz r9d, eax
jmp short loc_1195
loc_11F7:
mov esi, 0
mov r8d, r10d
jmp short loc_11E1
loc_1201:
mov r9d, 0FFFFFFFFh
jmp short loc_120F
loc_1209:
mov r9d, 0
loc_120F:
mov eax, r9d
retn | long long func0(int a1)
{
int v1; // r11d
int v2; // edi
unsigned int v3; // r9d
int v4; // esi
int v5; // ecx
int v6; // esi
int v7; // r8d
if ( a1 <= 0 )
{
return (unsigned int)-1;
}
else
{
if ( a1 > 1 )
{
v1 = a1 + 1;
v2 = 2;
v3 = 0;
while ( 1 )
{
v4 = 1;
v5 = 0;
if ( v2 <= 1 )
{
v6 = 0;
v7 = 0;
}
else
{
do
{
if ( !(v2 % v4) )
v5 += v4;
++v4;
}
while ( v4 != v2 );
if ( v5 <= 1 )
goto LABEL_4;
v6 = 1;
v7 = 0;
do
{
if ( !(v5 % v6) )
v7 += v6;
++v6;
}
while ( v5 != v6 );
}
if ( v2 == v7 && v6 != v2 )
v3 += v2;
LABEL_4:
if ( v1 == ++v2 )
return v3;
}
}
return 0;
}
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101201
CMP EDI,0x1
JLE 0x00101209
LEA R11D,[RDI + 0x1]
MOV EDI,0x2
MOV R9D,0x0
MOV R10D,0x0
JMP 0x0010119d
LAB_00101195:
ADD EDI,0x1
CMP R11D,EDI
JZ 0x0010120f
LAB_0010119d:
MOV ESI,0x1
MOV ECX,R10D
CMP EDI,0x1
JLE 0x001011f7
LAB_001011aa:
MOV EAX,EDI
CDQ
IDIV ESI
LEA EAX,[RCX + RSI*0x1]
TEST EDX,EDX
CMOVZ ECX,EAX
ADD ESI,0x1
CMP ESI,EDI
JNZ 0x001011aa
CMP ECX,0x1
JLE 0x00101195
MOV ESI,0x1
MOV R8D,R10D
LAB_001011cb:
MOV EAX,ECX
CDQ
IDIV ESI
LEA EAX,[R8 + RSI*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
ADD ESI,0x1
CMP ECX,ESI
JNZ 0x001011cb
LAB_001011e1:
CMP EDI,R8D
JNZ 0x00101195
CMP ESI,EDI
SETNZ DL
LEA EAX,[R9 + RDI*0x1]
TEST DL,DL
CMOVNZ R9D,EAX
JMP 0x00101195
LAB_001011f7:
MOV ESI,0x0
MOV R8D,R10D
JMP 0x001011e1
LAB_00101201:
MOV R9D,0xffffffff
JMP 0x0010120f
LAB_00101209:
MOV R9D,0x0
LAB_0010120f:
MOV EAX,R9D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_1 < 1) {
iVar4 = -1;
}
else if (param_1 < 2) {
iVar4 = 0;
}
else {
iVar3 = 2;
iVar4 = 0;
do {
iVar2 = 1;
iVar5 = 0;
iVar1 = 0;
if (iVar3 < 2) {
iVar2 = 0;
LAB_001011e1:
if ((iVar3 == iVar5) && (iVar2 != iVar3)) {
iVar4 = iVar4 + iVar3;
}
}
else {
do {
if (iVar3 % iVar2 == 0) {
iVar1 = iVar1 + iVar2;
}
iVar2 = iVar2 + 1;
} while (iVar2 != iVar3);
if (1 < iVar1) {
iVar2 = 1;
iVar5 = 0;
do {
if (iVar1 % iVar2 == 0) {
iVar5 = iVar5 + iVar2;
}
iVar2 = iVar2 + 1;
} while (iVar1 != iVar2);
goto LAB_001011e1;
}
}
iVar3 = iVar3 + 1;
} while (param_1 + 1 != iVar3);
}
return iVar4;
} |
4,386 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == 0) {
sum_fact += fact;
}
}
int sum_fact2 = 0;
for (int fact = 1; fact < sum_fact; fact++) {
if (sum_fact % fact == 0) {
sum_fact2 += fact;
}
}
if (num == sum_fact2 && num != sum_fact) {
amicables_sum += num;
}
}
return amicables_sum;
}
| int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 12bd <func0+0xd>
jmpq 1220 <func0.part.0>
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
cmp edi, 1
jle short loc_129E
lea r10d, [rdi+1]
xor r9d, r9d
mov edi, 2
nop dword ptr [rax+00000000h]
loc_1238:
xor ecx, ecx
mov esi, 1
nop
loc_1240:
mov eax, edi
cdq
idiv esi
lea eax, [rcx+rsi]
test edx, edx
cmovz ecx, eax
add esi, 1
cmp esi, edi
jnz short loc_1240
cmp ecx, 1
jle short loc_1292
xor r8d, r8d
mov esi, 1
nop dword ptr [rax+00000000h]
loc_1268:
mov eax, ecx
cdq
idiv esi
lea eax, [r8+rsi]
test edx, edx
cmovz r8d, eax
add esi, 1
cmp esi, ecx
jnz short loc_1268
cmp edi, r8d
jnz short loc_1292
cmp edi, esi
lea eax, [r9+rdi]
setnz dl
test dl, dl
cmovnz r9d, eax
loc_1292:
add edi, 1
cmp edi, r10d
jnz short loc_1238
mov eax, r9d
retn
loc_129E:
xor r9d, r9d
mov eax, r9d
retn | long long func0_part_0(int a1)
{
int v1; // r10d
unsigned int v2; // r9d
int v3; // edi
int v4; // ecx
int v5; // esi
int v6; // r8d
int i; // esi
if ( a1 <= 1 )
return 0LL;
v1 = a1 + 1;
v2 = 0;
v3 = 2;
do
{
v4 = 0;
v5 = 1;
do
{
if ( !(v3 % v5) )
v4 += v5;
++v5;
}
while ( v5 != v3 );
if ( v4 > 1 )
{
v6 = 0;
for ( i = 1; i != v4; ++i )
{
if ( !(v4 % i) )
v6 += i;
}
if ( v3 == v6 && v3 != i )
v2 += v3;
}
++v3;
}
while ( v3 != v1 );
return v2;
} | func0.part.0:
CMP EDI,0x1
JLE 0x0010129e
LEA R10D,[RDI + 0x1]
XOR R9D,R9D
MOV EDI,0x2
NOP dword ptr [RAX]
LAB_00101238:
XOR ECX,ECX
MOV ESI,0x1
NOP
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV ESI
LEA EAX,[RCX + RSI*0x1]
TEST EDX,EDX
CMOVZ ECX,EAX
ADD ESI,0x1
CMP ESI,EDI
JNZ 0x00101240
CMP ECX,0x1
JLE 0x00101292
XOR R8D,R8D
MOV ESI,0x1
NOP dword ptr [RAX]
LAB_00101268:
MOV EAX,ECX
CDQ
IDIV ESI
LEA EAX,[R8 + RSI*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
ADD ESI,0x1
CMP ESI,ECX
JNZ 0x00101268
CMP EDI,R8D
JNZ 0x00101292
CMP EDI,ESI
LEA EAX,[R9 + RDI*0x1]
SETNZ DL
TEST DL,DL
CMOVNZ R9D,EAX
LAB_00101292:
ADD EDI,0x1
CMP EDI,R10D
JNZ 0x00101238
MOV EAX,R9D
RET
LAB_0010129e:
XOR R9D,R9D
MOV EAX,R9D
RET | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (1 < param_1) {
iVar5 = 0;
iVar4 = 2;
do {
iVar1 = 0;
iVar2 = 1;
do {
if (iVar4 % iVar2 == 0) {
iVar1 = iVar1 + iVar2;
}
iVar2 = iVar2 + 1;
} while (iVar2 != iVar4);
if (1 < iVar1) {
iVar2 = 0;
iVar3 = 1;
do {
if (iVar1 % iVar3 == 0) {
iVar2 = iVar2 + iVar3;
}
iVar3 = iVar3 + 1;
} while (iVar3 != iVar1);
if (iVar4 == iVar2) {
if (iVar4 != iVar3) {
iVar5 = iVar5 + iVar4;
}
}
}
iVar4 = iVar4 + 1;
} while (iVar4 != param_1 + 1);
return iVar5;
}
return 0;
} |
4,387 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == 0) {
sum_fact += fact;
}
}
int sum_fact2 = 0;
for (int fact = 1; fact < sum_fact; fact++) {
if (sum_fact % fact == 0) {
sum_fact2 += fact;
}
}
if (num == sum_fact2 && num != sum_fact) {
amicables_sum += num;
}
}
return amicables_sum;
}
| int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1345 <func0+0x95>
cmp $0x1,%edi
je 133e <func0+0x8e>
lea 0x1(%rdi),%r10d
xor %r9d,%r9d
mov $0x2,%edi
nopl (%rax)
xor %ecx,%ecx
mov $0x1,%esi
nopw 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %esi
lea (%rcx,%rsi,1),%eax
test %edx,%edx
cmove %eax,%ecx
add $0x1,%esi
cmp %esi,%edi
jne 12e0 <func0+0x30>
cmp $0x1,%ecx
jle 1332 <func0+0x82>
xor %r8d,%r8d
mov $0x1,%esi
nopl 0x0(%rax)
mov %ecx,%eax
cltd
idiv %esi
lea (%r8,%rsi,1),%eax
test %edx,%edx
cmove %eax,%r8d
add $0x1,%esi
cmp %ecx,%esi
jne 1308 <func0+0x58>
cmp %edi,%r8d
jne 1332 <func0+0x82>
cmp %esi,%edi
lea (%r9,%rdi,1),%eax
setne %dl
test %dl,%dl
cmovne %eax,%r9d
add $0x1,%edi
cmp %r10d,%edi
jne 12d0 <func0+0x20>
mov %r9d,%eax
retq
xor %r9d,%r9d
mov %r9d,%eax
retq
mov $0xffffffff,%r9d
jmp 133a <func0+0x8a>
nopl (%rax)
| func0_part_0:
cmp edi, 1
jle short loc_129E
lea r10d, [rdi+1]
xor r9d, r9d
mov edi, 2
nop dword ptr [rax+00000000h]
loc_1238:
xor ecx, ecx
mov esi, 1
nop
loc_1240:
mov eax, edi
cdq
idiv esi
lea eax, [rcx+rsi]
test edx, edx
cmovz ecx, eax
add esi, 1
cmp edi, esi
jnz short loc_1240
cmp ecx, 1
jle short loc_1292
xor r8d, r8d
mov esi, 1
nop dword ptr [rax+00000000h]
loc_1268:
mov eax, ecx
cdq
idiv esi
lea eax, [r8+rsi]
test edx, edx
cmovz r8d, eax
add esi, 1
cmp esi, ecx
jnz short loc_1268
cmp r8d, edi
jnz short loc_1292
cmp edi, esi
lea eax, [r9+rdi]
setnz dl
test dl, dl
cmovnz r9d, eax
loc_1292:
add edi, 1
cmp edi, r10d
jnz short loc_1238
mov eax, r9d
retn
loc_129E:
xor r9d, r9d
mov eax, r9d
retn | long long func0_part_0(int a1)
{
int v1; // r10d
unsigned int v2; // r9d
int v3; // edi
int v4; // ecx
int v5; // esi
int v6; // r8d
int i; // esi
if ( a1 <= 1 )
return 0LL;
v1 = a1 + 1;
v2 = 0;
v3 = 2;
do
{
v4 = 0;
v5 = 1;
do
{
if ( !(v3 % v5) )
v4 += v5;
++v5;
}
while ( v3 != v5 );
if ( v4 > 1 )
{
v6 = 0;
for ( i = 1; i != v4; ++i )
{
if ( !(v4 % i) )
v6 += i;
}
if ( v6 == v3 && v3 != i )
v2 += v3;
}
++v3;
}
while ( v3 != v1 );
return v2;
} | func0.part.0:
CMP EDI,0x1
JLE 0x0010129e
LEA R10D,[RDI + 0x1]
XOR R9D,R9D
MOV EDI,0x2
NOP dword ptr [RAX]
LAB_00101238:
XOR ECX,ECX
MOV ESI,0x1
NOP
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV ESI
LEA EAX,[RCX + RSI*0x1]
TEST EDX,EDX
CMOVZ ECX,EAX
ADD ESI,0x1
CMP EDI,ESI
JNZ 0x00101240
CMP ECX,0x1
JLE 0x00101292
XOR R8D,R8D
MOV ESI,0x1
NOP dword ptr [RAX]
LAB_00101268:
MOV EAX,ECX
CDQ
IDIV ESI
LEA EAX,[R8 + RSI*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
ADD ESI,0x1
CMP ESI,ECX
JNZ 0x00101268
CMP R8D,EDI
JNZ 0x00101292
CMP EDI,ESI
LEA EAX,[R9 + RDI*0x1]
SETNZ DL
TEST DL,DL
CMOVNZ R9D,EAX
LAB_00101292:
ADD EDI,0x1
CMP EDI,R10D
JNZ 0x00101238
MOV EAX,R9D
RET
LAB_0010129e:
XOR R9D,R9D
MOV EAX,R9D
RET | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (1 < param_1) {
iVar5 = 0;
iVar4 = 2;
do {
iVar1 = 0;
iVar2 = 1;
do {
if (iVar4 % iVar2 == 0) {
iVar1 = iVar1 + iVar2;
}
iVar2 = iVar2 + 1;
} while (iVar4 != iVar2);
if (1 < iVar1) {
iVar2 = 0;
iVar3 = 1;
do {
if (iVar1 % iVar3 == 0) {
iVar2 = iVar2 + iVar3;
}
iVar3 = iVar3 + 1;
} while (iVar3 != iVar1);
if (iVar2 == iVar4) {
if (iVar4 != iVar3) {
iVar5 = iVar5 + iVar4;
}
}
}
iVar4 = iVar4 + 1;
} while (iVar4 != param_1 + 1);
return iVar5;
}
return 0;
} |
4,388 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x28(%rbp)
movsd %xmm1,-0x30(%rbp)
movsd -0x30(%rbp),%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd -0x28(%rbp),%xmm1
movsd %xmm1,-0x10(%rbp)
movsd %xmm0,-0x8(%rbp)
movsd -0x10(%rbp),%xmm0
mov -0x8(%rbp),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1070 <atan2@plt>
movq %xmm0,%rax
mov %rax,-0x18(%rbp)
movsd -0x18(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
movsd [rbp+var_38], xmm0
movsd [rbp+var_40], xmm1
movsd xmm0, [rbp+var_40]
movsd [rbp+y], xmm0
movsd xmm1, [rbp+y]
pxor xmm0, xmm0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_38]
addsd xmm0, xmm1
movsd [rbp+x], xmm0
movsd xmm0, [rbp+y]
movsd xmm1, [rbp+x]
movsd [rbp+var_10], xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+x]
mov rax, [rbp+y]
movapd xmm1, xmm0; x
movq xmm0, rax; y
call _atan2
movq rax, xmm0
mov [rbp+var_18], rax
movsd xmm0, [rbp+var_18]
leave
retn | long long func0(double a1, double a2)
{
return atan2(a2, 0.0 * a2 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOVSD qword ptr [RBP + -0x38],XMM0
MOVSD qword ptr [RBP + -0x40],XMM1
MOVSD XMM0,qword ptr [RBP + -0x40]
MOVSD qword ptr [RBP + -0x20],XMM0
MOVSD XMM1,qword ptr [RBP + -0x20]
PXOR XMM0,XMM0
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x38]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x28],XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
MOVSD XMM1,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x10],XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x18],RAX
MOVSD XMM0,qword ptr [RBP + -0x18]
LEAVE
RET | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = atan2(param_2,param_2 * 0.0 + param_1);
return dVar1;
} |
4,389 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
movapd %xmm0,%xmm2
movapd %xmm1,%xmm0
mulsd 0xea7(%rip),%xmm1
addsd %xmm2,%xmm1
callq 1050 <atan2@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
movapd xmm2, xmm0
movapd xmm0, xmm1
mulsd xmm1, cs:qword_2008
addsd xmm1, xmm2
call _atan2
add rsp, 8
retn | double func0(double a1, double a2)
{
return atan2(a2, a2 * 0.0 + a1);
} | func0:
ENDBR64
SUB RSP,0x8
MOVAPD XMM2,XMM0
MOVAPD XMM0,XMM1
MULSD XMM1,qword ptr [0x00102008]
ADDSD XMM1,XMM2
CALL 0x00101050
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(double param_1,double param_2)
{
atan2(param_2,param_2 * _DAT_00102008 + param_1);
return;
} |
4,390 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm2
movapd %xmm1,%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd %xmm2,%xmm1
jmpq 1050 <atan2@plt>
nopl (%rax)
| func0:
endbr64
movapd xmm2, xmm0
movapd xmm0, xmm1
pxor xmm1, xmm1
mulsd xmm1, xmm0
addsd xmm1, xmm2
jmp _atan2 | double func0(double a1, double a2)
{
return atan2(a2, 0.0 * a2 + a1);
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MOVAPD XMM0,XMM1
PXOR XMM1,XMM1
MULSD XMM1,XMM0
ADDSD XMM1,XMM2
JMP 0x00101050 | void func0(double param_1,double param_2)
{
atan2(param_2,param_2 * 0.0 + param_1);
return;
} |
4,391 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm2
movapd %xmm1,%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd %xmm2,%xmm1
jmpq 1050 <atan2@plt>
nopl (%rax)
| func0:
endbr64
movapd xmm2, xmm0
movapd xmm0, xmm1; y
pxor xmm1, xmm1
mulsd xmm1, xmm0
addsd xmm1, xmm2; x
jmp _atan2 | double func0(double a1, double a2)
{
return atan2(a2, 0.0 * a2 + a1);
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MOVAPD XMM0,XMM1
PXOR XMM1,XMM1
MULSD XMM1,XMM0
ADDSD XMM1,XMM2
JMP 0x00101050 | void func0(double param_1,double param_2)
{
atan2(param_2,param_2 * 0.0 + param_1);
return;
} |
4,392 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum;
}
}
return max_sum ? max_sum : 0;
}
| int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b1 <func0+0x68>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x30,%al
jne 118a <func0+0x41>
mov $0x1,%eax
jmp 118f <func0+0x46>
mov $0xffffffff,%eax
add %eax,-0xc(%rbp)
cmpl $0x0,-0xc(%rbp)
jns 119f <func0+0x56>
movl $0x0,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jle 11ad <func0+0x64>
mov -0xc(%rbp),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 116f <func0+0x26>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11B1
loc_116F:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 30h ; '0'
jnz short loc_118A
mov eax, 1
jmp short loc_118F
loc_118A:
mov eax, 0FFFFFFFFh
loc_118F:
add [rbp+var_C], eax
cmp [rbp+var_C], 0
jns short loc_119F
mov [rbp+var_C], 0
loc_119F:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jle short loc_11AD
mov eax, [rbp+var_C]
mov [rbp+var_8], eax
loc_11AD:
add [rbp+var_4], 1
loc_11B1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_116F
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == 48 )
v2 = 1;
else
v2 = -1;
v4 += v2;
if ( v4 < 0 )
v4 = 0;
if ( v4 > v5 )
v5 = v4;
}
return (unsigned int)v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b1
LAB_0010116f:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x30
JNZ 0x0010118a
MOV EAX,0x1
JMP 0x0010118f
LAB_0010118a:
MOV EAX,0xffffffff
LAB_0010118f:
ADD dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x0
JNS 0x0010119f
MOV dword ptr [RBP + -0xc],0x0
LAB_0010119f:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JLE 0x001011ad
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011ad:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011b1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010116f
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == '0') {
iVar1 = 1;
}
else {
iVar1 = -1;
}
local_14 = local_14 + iVar1;
if (local_14 < 0) {
local_14 = 0;
}
if (local_10 < local_14) {
local_10 = local_14;
}
}
return local_10;
} |
4,393 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum;
}
}
return max_sum ? max_sum : 0;
}
| int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x47>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x1(%rdi,%rax,1),%r8
mov $0x0,%ecx
mov $0x0,%eax
mov $0x0,%edi
cmpb $0x30,(%rdx)
sete %sil
movzbl %sil,%esi
lea -0x1(%rax,%rsi,2),%eax
test %eax,%eax
cmovs %edi,%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x1,%rdx
cmp %r8,%rdx
jne 116b <func0+0x22>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 118d <func0+0x44>
| func0:
endbr64
test esi, esi
jle short loc_1190
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax+1]
mov ecx, 0
mov eax, 0
loc_1166:
cmp byte ptr [rdx], 30h ; '0'
setz sil
movzx esi, sil
lea eax, [rax+rsi*2-1]
test eax, eax
mov esi, 0
cmovs eax, esi
cmp ecx, eax
cmovl ecx, eax
add rdx, 1
cmp rdx, rdi
jnz short loc_1166
loc_118D:
mov eax, ecx
retn
loc_1190:
mov ecx, 0
jmp short loc_118D | long long func0(_BYTE *a1, int a2)
{
_BYTE *v2; // rdx
long long v3; // rdi
int v4; // ecx
int v5; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
v5 = 0;
do
{
v5 = v5 + 2 * (*v2 == 48) - 1;
if ( v5 < 0 )
v5 = 0;
if ( v4 < v5 )
v4 = v5;
++v2;
}
while ( v2 != (_BYTE *)v3 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x1 + 0x1]
MOV ECX,0x0
MOV EAX,0x0
LAB_00101166:
CMP byte ptr [RDX],0x30
SETZ SIL
MOVZX ESI,SIL
LEA EAX,[RAX + RSI*0x2 + -0x1]
TEST EAX,EAX
MOV ESI,0x0
CMOVS EAX,ESI
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x1
CMP RDX,RDI
JNZ 0x00101166
LAB_0010118d:
MOV EAX,ECX
RET
LAB_00101190:
MOV ECX,0x0
JMP 0x0010118d | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
iVar2 = 0;
do {
iVar2 = iVar2 + -1 + (uint)(*param_1 == '0') * 2;
if (iVar2 < 0) {
iVar2 = 0;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
}
return iVar3;
} |
4,394 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum;
}
}
return max_sum ? max_sum : 0;
}
| int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 12d8 <func0+0x48>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
xor %ecx,%ecx
lea 0x1(%rdi,%rax,1),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
cmpb $0x30,(%rdi)
sete %dl
lea -0x1(%rax,%rdx,2),%eax
test %eax,%eax
cmovs %ecx,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x1,%rdi
cmp %rsi,%rdi
jne 12b0 <func0+0x20>
mov %r8d,%eax
retq
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1258
lea eax, [rsi-1]
xor r8d, r8d
xor ecx, ecx
lea rdx, [rdi+rax+1]
xor eax, eax
jmp short loc_1239
loc_1220:
sub eax, 1
cmp eax, 0FFFFFFFFh
cmovz eax, ecx
cmp r8d, eax
cmovl r8d, eax
add rdi, 1
cmp rdi, rdx
jz short loc_1251
loc_1239:
cmp byte ptr [rdi], 30h ; '0'
jnz short loc_1220
add eax, 1
cmp r8d, eax
cmovl r8d, eax
add rdi, 1
cmp rdi, rdx
jnz short loc_1239
loc_1251:
mov eax, r8d
retn
loc_1258:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_BYTE *a1, int a2)
{
unsigned int v2; // r8d
long long v3; // rdx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
while ( *a1 == 48 )
{
if ( (int)v2 < ++v4 )
v2 = v4;
if ( ++a1 == (_BYTE *)v3 )
return v2;
}
if ( --v4 == -1 )
v4 = 0;
if ( (int)v2 < v4 )
v2 = v4;
++a1;
}
while ( a1 != (_BYTE *)v3 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
XOR ECX,ECX
LEA RDX,[RDI + RAX*0x1 + 0x1]
XOR EAX,EAX
JMP 0x00101239
LAB_00101220:
SUB EAX,0x1
CMP EAX,-0x1
CMOVZ EAX,ECX
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x1
CMP RDI,RDX
JZ 0x00101251
LAB_00101239:
CMP byte ptr [RDI],0x30
JNZ 0x00101220
ADD EAX,0x1
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x1
CMP RDI,RDX
JNZ 0x00101239
LAB_00101251:
MOV EAX,R8D
RET
LAB_00101258:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
iVar3 = 0;
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
while (*param_1 == '0') {
iVar2 = iVar2 + 1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
if (param_1 == pcVar1) {
return iVar3;
}
}
iVar2 = iVar2 + -1;
if (iVar2 == -1) {
iVar2 = 0;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
return iVar3;
} |
4,395 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum;
}
}
return max_sum ? max_sum : 0;
}
| int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11a0 <func0+0x60>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
xor %ecx,%ecx
lea 0x1(%rdi,%rax,1),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
cmpb $0x30,(%rdi)
je 1180 <func0+0x40>
sub $0x1,%eax
cmovs %ecx,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x1,%rdi
cmp %rdx,%rdi
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
add $0x1,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x1,%rdi
cmp %rdi,%rdx
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1190
movsxd rsi, esi
xor edx, edx
xor eax, eax
lea rcx, [rdi+rsi]
xor esi, esi
jmp short loc_1177
loc_1160:
sub eax, 1
cmp eax, 0FFFFFFFFh
cmovz eax, esi
cmp edx, eax
cmovl edx, eax
add rdi, 1
cmp rcx, rdi
jz short loc_118D
loc_1177:
cmp byte ptr [rdi], 30h ; '0'
jnz short loc_1160
add eax, 1
cmp edx, eax
cmovl edx, eax
add rdi, 1
cmp rcx, rdi
jnz short loc_1177
loc_118D:
mov eax, edx
retn
loc_1190:
xor edx, edx
mov eax, edx
retn | long long func0(_BYTE *a1, int a2)
{
unsigned int v2; // edx
int v3; // eax
_BYTE *v4; // rcx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = 0;
v4 = &a1[a2];
do
{
while ( *a1 == 48 )
{
if ( (int)v2 < ++v3 )
v2 = v3;
if ( v4 == ++a1 )
return v2;
}
if ( --v3 == -1 )
v3 = 0;
if ( (int)v2 < v3 )
v2 = v3;
++a1;
}
while ( v4 != a1 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOVSXD RSI,ESI
XOR EDX,EDX
XOR EAX,EAX
LEA RCX,[RDI + RSI*0x1]
XOR ESI,ESI
JMP 0x00101177
LAB_00101160:
SUB EAX,0x1
CMP EAX,-0x1
CMOVZ EAX,ESI
CMP EDX,EAX
CMOVL EDX,EAX
ADD RDI,0x1
CMP RCX,RDI
JZ 0x0010118d
LAB_00101177:
CMP byte ptr [RDI],0x30
JNZ 0x00101160
ADD EAX,0x1
CMP EDX,EAX
CMOVL EDX,EAX
ADD RDI,0x1
CMP RCX,RDI
JNZ 0x00101177
LAB_0010118d:
MOV EAX,EDX
RET
LAB_00101190:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
iVar3 = 0;
iVar2 = 0;
pcVar1 = param_1 + param_2;
do {
while (*param_1 == '0') {
iVar2 = iVar2 + 1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
if (pcVar1 == param_1) {
return iVar3;
}
}
iVar2 = iVar2 + -1;
if (iVar2 == -1) {
iVar2 = 0;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (pcVar1 != param_1);
return iVar3;
} |
4,396 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 118b <func0+0x42>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1187 <func0+0x3e>
mov -0x18(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1187 <func0+0x3e>
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovle -0x18(%rbp),%eax
cmp %eax,-0x4(%rbp)
jl 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_118B
loc_1167:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1187
mov eax, [rbp+var_18]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1187
mov eax, [rbp+var_4]
add [rbp+var_8], eax
loc_1187:
add [rbp+var_4], 1
loc_118B:
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
cmp edx, eax
cmovle eax, edx
cmp [rbp+var_4], eax
jl short loc_1167
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1, int a2)
{
int v2; // eax
unsigned int v4; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v4 = 0;
for ( i = 1; ; ++i )
{
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( i >= v2 )
break;
if ( !(a1 % i) && !(a2 % i) )
v4 += i;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010118b
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101187
MOV EAX,dword ptr [RBP + -0x18]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101187
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
LAB_00101187:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010118b:
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVLE EAX,EDX
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101167
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(int param_1,int param_2)
{
int iVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
local_c = 1;
while( true ) {
iVar1 = param_1;
if (param_2 <= param_1) {
iVar1 = param_2;
}
if (iVar1 <= local_c) break;
if ((param_1 % local_c == 0) && (param_2 % local_c == 0)) {
local_10 = local_10 + local_c;
}
local_c = local_c + 1;
}
return local_10;
} |
4,397 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edi,%esi
mov %edi,%r9d
cmovle %esi,%r9d
cmp $0x1,%r9d
jle 118b <func0+0x42>
mov $0x1,%ecx
mov $0x0,%r8d
jmp 1171 <func0+0x28>
add $0x1,%ecx
cmp %r9d,%ecx
je 1191 <func0+0x48>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1169 <func0+0x20>
mov %esi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cmove %eax,%r8d
jmp 1169 <func0+0x20>
mov $0x0,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp esi, edi
mov r9d, edi
cmovle r9d, esi
cmp r9d, 1
jle short loc_118B
mov ecx, 1
mov r8d, 0
jmp short loc_1171
loc_1169:
add ecx, 1
cmp ecx, r9d
jz short loc_1191
loc_1171:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1169
mov eax, esi
cdq
idiv ecx
lea eax, [r8+rcx]
test edx, edx
cmovz r8d, eax
jmp short loc_1169
loc_118B:
mov r8d, 0
loc_1191:
mov eax, r8d
retn | long long func0(int a1, int a2)
{
int v2; // r9d
int v3; // ecx
unsigned int v4; // r8d
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( v2 <= 1 )
{
return 0;
}
else
{
v3 = 1;
v4 = 0;
do
{
if ( !(a1 % v3) && !(a2 % v3) )
v4 += v3;
++v3;
}
while ( v3 != v2 );
}
return v4;
} | func0:
ENDBR64
CMP ESI,EDI
MOV R9D,EDI
CMOVLE R9D,ESI
CMP R9D,0x1
JLE 0x0010118b
MOV ECX,0x1
MOV R8D,0x0
JMP 0x00101171
LAB_00101169:
ADD ECX,0x1
CMP ECX,R9D
JZ 0x00101191
LAB_00101171:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101169
MOV EAX,ESI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
JMP 0x00101169
LAB_0010118b:
MOV R8D,0x0
LAB_00101191:
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1;
if (param_2 <= param_1) {
iVar3 = param_2;
}
if (iVar3 < 2) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
if ((param_1 % iVar1 == 0) && (param_2 % iVar1 == 0)) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (iVar1 != iVar3);
}
return iVar2;
} |
4,398 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edi,%esi
mov %edi,%r9d
cmovle %esi,%r9d
cmp $0x1,%r9d
jle 1268 <func0+0x48>
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1258 <func0+0x38>
mov %esi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cmove %eax,%r8d
add $0x1,%ecx
cmp %r9d,%ecx
jne 1240 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp esi, edi
mov r9d, edi
cmovle r9d, esi
cmp r9d, 1
jle short loc_1268
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1240:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1258
mov eax, esi
cdq
idiv ecx
lea eax, [r8+rcx]
test edx, edx
cmovz r8d, eax
loc_1258:
add ecx, 1
cmp ecx, r9d
jnz short loc_1240
mov eax, r8d
retn
loc_1268:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1, int a2)
{
int v2; // r9d
int v3; // ecx
unsigned int v4; // r8d
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( v2 <= 1 )
return 0LL;
v3 = 1;
v4 = 0;
do
{
if ( !(a1 % v3) && !(a2 % v3) )
v4 += v3;
++v3;
}
while ( v3 != v2 );
return v4;
} | func0:
ENDBR64
CMP ESI,EDI
MOV R9D,EDI
CMOVLE R9D,ESI
CMP R9D,0x1
JLE 0x00101268
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101258
MOV EAX,ESI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
LAB_00101258:
ADD ECX,0x1
CMP ECX,R9D
JNZ 0x00101240
MOV EAX,R8D
RET
LAB_00101268:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1;
if (param_2 <= param_1) {
iVar3 = param_2;
}
if (1 < iVar3) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
if (param_2 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
}
iVar1 = iVar1 + 1;
} while (iVar1 != iVar3);
return iVar2;
}
return 0;
} |
4,399 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edi,%esi
mov %edi,%r9d
cmovle %esi,%r9d
cmp $0x1,%r9d
jle 1208 <func0+0x48>
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 11f8 <func0+0x38>
mov %esi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cmove %eax,%r8d
add $0x1,%ecx
cmp %r9d,%ecx
jne 11e0 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp esi, edi
mov r9d, edi
cmovle r9d, esi
cmp r9d, 1
jle short loc_11F8
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_11D0:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_11E8
mov eax, esi
cdq
idiv ecx
lea eax, [r8+rcx]
test edx, edx
cmovz r8d, eax
loc_11E8:
add ecx, 1
cmp ecx, r9d
jnz short loc_11D0
mov eax, r8d
retn
loc_11F8:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1, int a2)
{
int v2; // r9d
int v3; // ecx
unsigned int v4; // r8d
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( v2 <= 1 )
return 0LL;
v3 = 1;
v4 = 0;
do
{
if ( !(a1 % v3) && !(a2 % v3) )
v4 += v3;
++v3;
}
while ( v3 != v2 );
return v4;
} | func0:
ENDBR64
CMP ESI,EDI
MOV R9D,EDI
CMOVLE R9D,ESI
CMP R9D,0x1
JLE 0x001011f8
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_001011d0:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001011e8
MOV EAX,ESI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
LAB_001011e8:
ADD ECX,0x1
CMP ECX,R9D
JNZ 0x001011d0
MOV EAX,R8D
RET
LAB_001011f8:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1;
if (param_2 <= param_1) {
iVar3 = param_2;
}
if (1 < iVar3) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
if (param_2 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
}
iVar1 = iVar1 + 1;
} while (iVar1 != iVar3);
return iVar2;
}
return 0;
} |
4,400 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jns 1178 <func0+0x2f>
mov -0x8(%rbp),%eax
neg %eax
mov %eax,%edx
mov -0x4(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
neg %eax
jmp 11a7 <func0+0x5e>
cmpl $0x0,-0x8(%rbp)
jne 1185 <func0+0x3c>
mov $0x0,%eax
jmp 11a7 <func0+0x5e>
cmpl $0x1,-0x8(%rbp)
jne 1190 <func0+0x47>
mov -0x4(%rbp),%eax
jmp 11a7 <func0+0x5e>
mov -0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x4(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
mov -0x4(%rbp),%edx
add %edx,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
cmp [rbp+var_8], 0
jns short loc_1178
mov eax, [rbp+var_8]
neg eax
mov edx, eax
mov eax, [rbp+var_4]
mov esi, edx
mov edi, eax
call func0
neg eax
jmp short locret_11A7
loc_1178:
cmp [rbp+var_8], 0
jnz short loc_1185
mov eax, 0
jmp short locret_11A7
loc_1185:
cmp [rbp+var_8], 1
jnz short loc_1190
mov eax, [rbp+var_4]
jmp short locret_11A7
loc_1190:
mov eax, [rbp+var_8]
lea edx, [rax-1]
mov eax, [rbp+var_4]
mov esi, edx
mov edi, eax
call func0
mov edx, [rbp+var_4]
add eax, edx
locret_11A7:
leave
retn | long long func0(unsigned int a1, int a2)
{
if ( a2 < 0 )
return (unsigned int)-func0(a1, (unsigned int)-a2);
if ( !a2 )
return 0LL;
if ( a2 == 1 )
return a1;
return a1 + (unsigned int)func0(a1, (unsigned int)(a2 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
CMP dword ptr [RBP + -0x8],0x0
JNS 0x00101178
MOV EAX,dword ptr [RBP + -0x8]
NEG EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
NEG EAX
JMP 0x001011a7
LAB_00101178:
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00101185
MOV EAX,0x0
JMP 0x001011a7
LAB_00101185:
CMP dword ptr [RBP + -0x8],0x1
JNZ 0x00101190
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x001011a7
LAB_00101190:
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x4]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
MOV EDX,dword ptr [RBP + -0x4]
ADD EAX,EDX
LAB_001011a7:
LEAVE
RET | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 < 0) {
param_1 = func0(param_1,-param_2);
param_1 = -param_1;
}
else if (param_2 == 0) {
param_1 = 0;
}
else if (param_2 != 1) {
iVar1 = func0(param_1,param_2 + -1);
param_1 = iVar1 + param_1;
}
return param_1;
} |
4,401 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
test %esi,%esi
js 1161 <func0+0x18>
mov %esi,%eax
je 115f <func0+0x16>
mov %edi,%eax
cmp $0x1,%esi
jne 116c <func0+0x23>
pop %rbx
retq
neg %esi
callq 1149 <func0>
neg %eax
jmp 115f <func0+0x16>
sub $0x1,%esi
callq 1149 <func0>
add %ebx,%eax
jmp 115f <func0+0x16>
| func0:
endbr64
push rbx
mov ebx, edi
test esi, esi
js short loc_1161
mov eax, esi
jz short loc_115F
mov eax, edi
cmp esi, 1
jnz short loc_116C
loc_115F:
pop rbx
retn
loc_1161:
neg esi
call func0
neg eax
jmp short loc_115F
loc_116C:
sub esi, 1
call func0
add eax, ebx
jmp short loc_115F | long long func0(long long a1, int a2)
{
long long result; // rax
if ( a2 < 0 )
return (unsigned int)-func0(a1, (unsigned int)-a2);
result = (unsigned int)a2;
if ( a2 )
{
result = (unsigned int)a1;
if ( a2 != 1 )
return (unsigned int)a1 + (unsigned int)func0(a1, (unsigned int)(a2 - 1));
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
TEST ESI,ESI
JS 0x00101161
MOV EAX,ESI
JZ 0x0010115f
MOV EAX,EDI
CMP ESI,0x1
JNZ 0x0010116c
LAB_0010115f:
POP RBX
RET
LAB_00101161:
NEG ESI
CALL 0x00101149
NEG EAX
JMP 0x0010115f
LAB_0010116c:
SUB ESI,0x1
CALL 0x00101149
ADD EAX,EBX
JMP 0x0010115f | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 < 0) {
iVar1 = func0(param_1,-param_2);
iVar1 = -iVar1;
}
else {
iVar1 = param_2;
if ((param_2 != 0) && (iVar1 = param_1, param_2 != 1)) {
iVar1 = func0(param_1,param_2 + -1);
iVar1 = iVar1 + param_1;
}
}
return iVar1;
} |
4,402 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
test %esi,%esi
js 12ba <func0+0x2a>
je 12c0 <func0+0x30>
mov %edi,%edx
imul %eax,%edx
add %edx,%r8d
cmp $0x1,%esi
je 12c0 <func0+0x30>
sub $0x1,%esi
test %esi,%esi
jns 12a4 <func0+0x14>
neg %esi
neg %eax
jmp 12a0 <func0+0x10>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1210:
test esi, esi
js short loc_122A
loc_1214:
jz short loc_1230
mov edx, edi
imul edx, eax
add r8d, edx
cmp esi, 1
jz short loc_1230
sub esi, 1
test esi, esi
jns short loc_1214
loc_122A:
neg esi
neg eax
jmp short loc_1210
loc_1230:
mov eax, r8d
retn | long long func0(int a1, int a2)
{
int v2; // eax
unsigned int v3; // r8d
bool v4; // zf
v2 = 1;
v3 = 0;
while ( 1 )
{
v4 = a2 == 0;
if ( a2 >= 0 )
break;
LABEL_6:
a2 = -a2;
v2 = -v2;
}
while ( !v4 )
{
v3 += v2 * a1;
if ( a2 == 1 )
break;
v4 = --a2 == 0;
if ( a2 < 0 )
goto LABEL_6;
}
return v3;
} | func0:
ENDBR64
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101210:
TEST ESI,ESI
JS 0x0010122a
LAB_00101214:
JZ 0x00101230
MOV EDX,EDI
IMUL EDX,EAX
ADD R8D,EDX
CMP ESI,0x1
JZ 0x00101230
SUB ESI,0x1
TEST ESI,ESI
JNS 0x00101214
LAB_0010122a:
NEG ESI
NEG EAX
JMP 0x00101210
LAB_00101230:
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
iVar1 = 1;
iVar2 = 0;
while( true ) {
for (; param_2 < 0; param_2 = -param_2) {
iVar1 = -iVar1;
}
if ((param_2 == 0) || (iVar2 = iVar2 + param_1 * iVar1, param_2 == 1)) break;
param_2 = param_2 + -1;
}
return iVar2;
} |
4,403 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
test %esi,%esi
js 12ba <func0+0x2a>
je 12c0 <func0+0x30>
mov %edi,%edx
imul %eax,%edx
add %edx,%r8d
cmp $0x1,%esi
je 12c0 <func0+0x30>
sub $0x1,%esi
test %esi,%esi
jns 12a4 <func0+0x14>
neg %esi
neg %eax
jmp 12a0 <func0+0x10>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov eax, esi
test esi, esi
jns short loc_1180
neg eax
mov ecx, 0FFFFFFFFh
mov edx, eax
xor eax, eax
loc_1155:
imul edi, ecx
lea ecx, [rdx-1]
test dl, 1
jnz short loc_1175
mov eax, edi
mov edx, ecx
jmp short loc_1175
loc_1170:
add eax, edi
sub edx, 2
loc_1175:
add eax, edi
cmp edx, 1
jnz short loc_1170
locret_117C:
retn
loc_1180:
jz short locret_117C
mov edx, esi
mov ecx, 1
xor eax, eax
jmp short loc_1155 | long long func0(int a1, int a2)
{
long long result; // rax
int v3; // ecx
int v4; // edx
int v5; // eax
int v6; // edi
result = (unsigned int)a2;
if ( a2 >= 0 )
{
if ( !a2 )
return result;
v4 = a2;
v3 = 1;
v5 = 0;
}
else
{
v3 = -1;
v4 = -a2;
v5 = 0;
}
v6 = v3 * a1;
if ( (v4 & 1) == 0 )
{
v5 = v6;
--v4;
}
while ( 1 )
{
result = (unsigned int)(v6 + v5);
if ( v4 == 1 )
break;
v5 = v6 + result;
v4 -= 2;
}
return result;
} | func0:
ENDBR64
MOV EAX,ESI
TEST ESI,ESI
JNS 0x00101180
NEG EAX
MOV ECX,0xffffffff
MOV EDX,EAX
XOR EAX,EAX
LAB_00101155:
IMUL EDI,ECX
LEA ECX,[RDX + -0x1]
TEST DL,0x1
JNZ 0x00101175
MOV EAX,EDI
MOV EDX,ECX
JMP 0x00101175
LAB_00101170:
ADD EAX,EDI
SUB EDX,0x2
LAB_00101175:
ADD EAX,EDI
CMP EDX,0x1
JNZ 0x00101170
LAB_0010117c:
RET
LAB_00101180:
JZ 0x0010117c
MOV EDX,ESI
MOV ECX,0x1
XOR EAX,EAX
JMP 0x00101155 | int func0(int param_1,uint param_2)
{
int iVar1;
if ((int)param_2 < 0) {
param_2 = -param_2;
iVar1 = -1;
}
else {
if (param_2 == 0) {
return 0;
}
iVar1 = 1;
}
param_1 = param_1 * iVar1;
iVar1 = 0;
if ((param_2 & 1) == 0) {
param_2 = param_2 - 1;
iVar1 = param_1;
}
for (; param_2 != 1; param_2 = param_2 - 2) {
iVar1 = iVar1 + param_1 + param_1;
}
return iVar1 + param_1;
} |
4,404 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
return word_len;
}
| int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "programming") == 0 && strcmp(result1[2], "language") == 0);
char** result2 = func0(2, test_str2, &count);
assert(count == 2 && strcmp(result2[0], "writing") == 0 && strcmp(result2[1], "program") == 0);
char** result3 = func0(5, test_str3, &count);
assert(count == 1 && strcmp(result3[0], "sorting") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x20(%rbp),%rax
lea 0xe16(%rip),%rsi
mov %rax,%rdi
callq 10d0 <strtok@plt>
mov %rax,-0x8(%rbp)
jmp 124e <func0+0x85>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1090 <strlen@plt>
mov -0x14(%rbp),%edx
movslq %edx,%rdx
cmp %rdx,%rax
jbe 1239 <func0+0x70>
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,8),%rcx
lea 0x2e0f(%rip),%rdx
mov -0x8(%rbp),%rax
mov %rax,(%rcx,%rdx,1)
lea 0xdc8(%rip),%rsi
mov $0x0,%edi
callq 10d0 <strtok@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 1200 <func0+0x37>
mov -0x28(%rbp),%rax
mov -0xc(%rbp),%edx
mov %edx,(%rax)
lea 0x2ddb(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+s], rsi
mov [rbp+var_28], rdx
mov [rbp+var_C], 0
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_8], rax
jmp short loc_1254
loc_1203:
mov rax, [rbp+var_8]
mov rdi, rax; s
call _strlen
mov edx, [rbp+var_14]
movsxd rdx, edx
cmp rdx, rax
jnb short loc_123C
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
cdqe
lea rcx, ds:0[rax*8]
lea rdx, _word_len_1
mov rax, [rbp+var_8]
mov [rcx+rdx], rax
loc_123C:
lea rax, delim; " "
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+var_8], rax
loc_1254:
cmp [rbp+var_8], 0
jnz short loc_1203
mov rax, [rbp+var_28]
mov edx, [rbp+var_C]
mov [rax], edx
lea rax, _word_len_1
leave
retn | _QWORD * func0(int a1, char *a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+24h] [rbp-Ch]
const char *i; // [rsp+28h] [rbp-8h]
v6 = 0;
for ( i = strtok(a2, " "); i; i = strtok(0LL, " ") )
{
if ( a1 < strlen(i) )
{
v3 = v6++;
word_len_1[v3] = i;
}
}
*a3 = v6;
return word_len_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101254
LAB_00101203:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101090
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
CMP RDX,RAX
JNC 0x0010123c
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RCX,[RAX*0x8]
LEA RDX,[0x104040]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX + RDX*0x1],RAX
LAB_0010123c:
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
LAB_00101254:
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x00101203
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX],EDX
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(int param_1,char *param_2,int *param_3)
{
size_t sVar1;
int local_14;
char *local_10;
local_14 = 0;
local_10 = strtok(param_2," ");
while (local_10 != (char *)0x0) {
sVar1 = strlen(local_10);
if ((ulong)(long)param_1 < sVar1) {
*(char **)(word_len_1 + (long)local_14 * 8) = local_10;
local_14 = local_14 + 1;
}
local_10 = strtok((char *)0x0," ");
}
*param_3 = local_14;
return word_len_1;
} |
4,405 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
return word_len;
}
| int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "programming") == 0 && strcmp(result1[2], "language") == 0);
char** result2 = func0(2, test_str2, &count);
assert(count == 2 && strcmp(result2[0], "writing") == 0 && strcmp(result2[1], "program") == 0);
char** result3 = func0(5, test_str3, &count);
assert(count == 1 && strcmp(result3[0], "sorting") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebp
mov %rsi,%rdi
mov %rdx,%r13
lea 0xe5e(%rip),%rsi
callq 1090 <strtok@plt>
test %rax,%rax
je 1209 <func0+0x80>
mov %rax,%rdx
mov $0x0,%ebx
lea 0x2e81(%rip),%r12
jmp 11da <func0+0x51>
lea 0xe3c(%rip),%rsi
mov $0x0,%edi
callq 1090 <strtok@plt>
mov %rax,%rdx
test %rax,%rax
je 120e <func0+0x85>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
movslq %ebp,%rcx
cmp %rcx,%rax
jbe 11c1 <func0+0x38>
movslq %ebx,%rax
mov %rdx,(%r12,%rax,8)
lea 0x1(%rbx),%ebx
jmp 11c1 <func0+0x38>
mov $0x0,%ebx
mov %ebx,0x0(%r13)
lea 0x2e27(%rip),%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12d, edi
mov rdi, rsi
mov r15, rdx
lea rsi, unk_2004
call _strtok
test rax, rax
jz short loc_123E
mov rbx, rax
mov ebp, 0
movsxd r12, r12d
lea r14, _word_len_1
lea r13, unk_2004
jmp short loc_1225
loc_1210:
mov rsi, r13
mov edi, 0
call _strtok
mov rbx, rax
test rax, rax
jz short loc_1243
loc_1225:
mov rdi, rbx
call _strlen
cmp rax, r12
jbe short loc_1210
movsxd rax, ebp
mov [r14+rax*8], rbx
lea ebp, [rbp+1]
jmp short loc_1210
loc_123E:
mov ebp, 0
loc_1243:
mov [r15], ebp
lea rax, _word_len_1
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _QWORD * func0(int a1, long long a2, _DWORD *a3)
{
long long v4; // rax
long long v5; // rbx
int v6; // ebp
v4 = strtok(a2, &unk_2004);
if ( v4 )
{
v5 = v4;
v6 = 0;
do
{
if ( strlen(v5) > (unsigned long long)a1 )
word_len_1[v6++] = v5;
v5 = strtok(0LL, &unk_2004);
}
while ( v5 );
}
else
{
v6 = 0;
}
*a3 = v6;
return word_len_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,EDI
MOV RDI,RSI
MOV R15,RDX
LEA RSI,[0x102004]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010123e
MOV RBX,RAX
MOV EBP,0x0
MOVSXD R12,R12D
LEA R14,[0x104040]
LEA R13,[0x102004]
JMP 0x00101225
LAB_00101210:
MOV RSI,R13
MOV EDI,0x0
CALL 0x001010d0
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00101243
LAB_00101225:
MOV RDI,RBX
CALL 0x00101090
CMP RAX,R12
JBE 0x00101210
MOVSXD RAX,EBP
MOV qword ptr [R14 + RAX*0x8],RBX
LEA EBP,[RBP + 0x1]
JMP 0x00101210
LAB_0010123e:
MOV EBP,0x0
LAB_00101243:
MOV dword ptr [R15],EBP
LEA RAX,[0x104040]
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int param_1,char *param_2,int *param_3)
{
char *__s;
size_t sVar1;
int iVar2;
__s = strtok(param_2," ");
if (__s == (char *)0x0) {
iVar2 = 0;
}
else {
iVar2 = 0;
do {
sVar1 = strlen(__s);
if ((ulong)(long)param_1 < sVar1) {
(&word_len_1)[iVar2] = __s;
iVar2 = iVar2 + 1;
}
__s = strtok((char *)0x0," ");
} while (__s != (char *)0x0);
}
*param_3 = iVar2;
return &word_len_1;
} |
4,406 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
return word_len;
}
| int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "programming") == 0 && strcmp(result1[2], "language") == 0);
char** result2 = func0(2, test_str2, &count);
assert(count == 2 && strcmp(result2[0], "writing") == 0 && strcmp(result2[1], "program") == 0);
char** result3 = func0(5, test_str3, &count);
assert(count == 1 && strcmp(result3[0], "sorting") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
movslq %edi,%r12
mov %rsi,%rdi
lea 0xc3a(%rip),%rsi
push %rbp
push %rbx
callq 10b0 <strtok@plt>
test %rax,%rax
je 1430 <func0+0x80>
mov %rax,%rbx
xor %ebp,%ebp
lea 0x2c5e(%rip),%r14
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdi
callq 1080 <strlen@plt>
cmp %r12,%rax
jbe 13ff <func0+0x4f>
movslq %ebp,%rax
add $0x1,%ebp
mov %rbx,(%r14,%rax,8)
lea 0xbfe(%rip),%rsi
xor %edi,%edi
callq 10b0 <strtok@plt>
mov %rax,%rbx
test %rax,%rax
jne 13e8 <func0+0x38>
pop %rbx
mov %ebp,0x0(%r13)
lea 0x2c1f(%rip),%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
xor %ebp,%ebp
jmp 1415 <func0+0x65>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r15
mov r15, rdx
push r14
push r13
lea r13, unk_2004
push r12
movsxd r12, edi
mov rdi, rsi
mov rsi, r13
push rbp
push rbx
sub rsp, 8
call _strtok
test rax, rax
jz short loc_1420
mov rbx, rax
xor ebp, ebp
lea r14, _word_len_1
nop dword ptr [rax+rax+00h]
loc_13E0:
mov rdi, rbx
call _strlen
cmp rax, r12
jbe short loc_13F7
movsxd rax, ebp
add ebp, 1
mov [r14+rax*8], rbx
loc_13F7:
mov rsi, r13
xor edi, edi
call _strtok
mov rbx, rax
test rax, rax
jnz short loc_13E0
loc_1409:
mov [r15], ebp
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1420:
xor ebp, ebp
lea r14, _word_len_1
jmp short loc_1409 | _QWORD * func0(int a1, long long a2, _DWORD *a3)
{
long long v4; // rax
long long v5; // rbx
int v6; // ebp
long long v7; // rax
v4 = strtok(a2, &unk_2004);
if ( v4 )
{
v5 = v4;
v6 = 0;
do
{
if ( strlen(v5) > (unsigned long long)a1 )
{
v7 = v6++;
word_len_1[v7] = v5;
}
v5 = strtok(0LL, &unk_2004);
}
while ( v5 );
}
else
{
v6 = 0;
}
*a3 = v6;
return word_len_1;
} | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
PUSH R13
LEA R13,[0x102004]
PUSH R12
MOVSXD R12,EDI
MOV RDI,RSI
MOV RSI,R13
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101420
MOV RBX,RAX
XOR EBP,EBP
LEA R14,[0x104040]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV RDI,RBX
CALL 0x00101090
CMP RAX,R12
JBE 0x001013f7
MOVSXD RAX,EBP
ADD EBP,0x1
MOV qword ptr [R14 + RAX*0x8],RBX
LAB_001013f7:
MOV RSI,R13
XOR EDI,EDI
CALL 0x001010d0
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x001013e0
LAB_00101409:
MOV dword ptr [R15],EBP
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101420:
XOR EBP,EBP
LEA R14,[0x104040]
JMP 0x00101409 | int8 * func0(int param_1,char *param_2,int *param_3)
{
char *__s;
size_t sVar1;
long lVar2;
int iVar3;
__s = strtok(param_2," ");
if (__s == (char *)0x0) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
sVar1 = strlen(__s);
if ((ulong)(long)param_1 < sVar1) {
lVar2 = (long)iVar3;
iVar3 = iVar3 + 1;
(&word_len_1)[lVar2] = __s;
}
__s = strtok((char *)0x0," ");
} while (__s != (char *)0x0);
}
*param_3 = iVar3;
return &word_len_1;
} |
4,407 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
return word_len;
}
| int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "programming") == 0 && strcmp(result1[2], "language") == 0);
char** result2 = func0(2, test_str2, &count);
assert(count == 2 && strcmp(result2[0], "writing") == 0 && strcmp(result2[1], "program") == 0);
char** result3 = func0(5, test_str3, &count);
assert(count == 1 && strcmp(result3[0], "sorting") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
movslq %edi,%rbp
mov %rsi,%rdi
lea 0xc37(%rip),%rsi
push %rbx
sub $0x8,%rsp
callq 10b0 <strtok@plt>
test %rax,%rax
je 1460 <func0+0xb0>
mov %rax,%rbx
xor %r14d,%r14d
lea 0x2c53(%rip),%r13
nopl (%rax)
mov %rbx,%rdi
callq 1080 <strlen@plt>
cmp %rbp,%rax
jbe 142c <func0+0x7c>
lea 0xc00(%rip),%rsi
xor %edi,%edi
mov %rbx,0x0(%r13,%r14,8)
lea 0x1(%r14),%r15d
callq 10b0 <strtok@plt>
mov %rax,%rbx
test %rax,%rax
je 1445 <func0+0x95>
mov %rbx,%rdi
movslq %r15d,%r14
callq 1080 <strlen@plt>
cmp %rbp,%rax
ja 13fd <func0+0x4d>
lea 0xbd1(%rip),%rsi
xor %edi,%edi
callq 10b0 <strtok@plt>
mov %rax,%rbx
test %rax,%rax
jne 13f0 <func0+0x40>
mov %r14d,%r15d
mov %r15d,(%r12)
add $0x8,%rsp
lea 0x2bec(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %r15d,%r15d
jmp 1445 <func0+0x95>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
lea r12, delim; " "
push rbp
movsxd rbp, edi
mov rdi, rsi; s
mov rsi, r12; delim
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdx
call _strtok
test rax, rax
jz short loc_1450
mov r15, rax
xor ebx, ebx
lea r14, _word_len_1
nop dword ptr [rax]
loc_13E0:
mov rdi, r15; s
call _strlen
cmp rbp, rax
jnb short loc_1417
loc_13ED:
mov rsi, r12; delim
xor edi, edi; s
mov [r14+rbx*8], r15
lea r13d, [rbx+1]
call _strtok
mov r15, rax
test rax, rax
jz short loc_1448
mov rdi, r15; s
movsxd rbx, r13d
call _strlen
cmp rbp, rax
jb short loc_13ED
loc_1417:
mov rsi, r12; delim
xor edi, edi; s
call _strtok
mov r15, rax
test rax, rax
jnz short loc_13E0
loc_1429:
mov rax, [rsp+48h+var_40]
mov [rax], ebx
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1448:
mov ebx, r13d
jmp short loc_1429
loc_1450:
xor ebx, ebx
lea r14, _word_len_1
jmp short loc_1429 | _QWORD * func0(int a1, char *a2, _DWORD *a3)
{
char *v3; // rax
char *v4; // r15
long long v5; // rbx
char *v6; // rax
v3 = strtok(a2, " ");
if ( v3 )
{
v4 = v3;
v5 = 0LL;
while ( a1 >= strlen(v4) )
{
LABEL_6:
v4 = strtok(0LL, " ");
if ( !v4 )
goto LABEL_7;
}
while ( 1 )
{
word_len_1[v5] = v4;
v6 = strtok(0LL, " ");
v4 = v6;
if ( !v6 )
break;
v5 = (int)v5 + 1;
if ( a1 >= strlen(v6) )
goto LABEL_6;
}
LODWORD(v5) = v5 + 1;
}
else
{
LODWORD(v5) = 0;
}
LABEL_7:
*a3 = v5;
return word_len_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
MOVSXD RBP,EDI
MOV RDI,RSI
MOV RSI,R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDX
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101450
MOV R15,RAX
XOR EBX,EBX
LEA R14,[0x104040]
NOP dword ptr [RAX]
LAB_001013e0:
MOV RDI,R15
CALL 0x00101090
CMP RBP,RAX
JNC 0x00101417
LAB_001013ed:
MOV RSI,R12
XOR EDI,EDI
MOV qword ptr [R14 + RBX*0x8],R15
LEA R13D,[RBX + 0x1]
CALL 0x001010d0
MOV R15,RAX
TEST RAX,RAX
JZ 0x00101448
MOV RDI,R15
MOVSXD RBX,R13D
CALL 0x00101090
CMP RBP,RAX
JC 0x001013ed
LAB_00101417:
MOV RSI,R12
XOR EDI,EDI
CALL 0x001010d0
MOV R15,RAX
TEST RAX,RAX
JNZ 0x001013e0
LAB_00101429:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],EBX
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101448:
MOV EBX,R13D
JMP 0x00101429
LAB_00101450:
XOR EBX,EBX
LEA R14,[0x104040]
JMP 0x00101429 | int8 * func0(int param_1,char *param_2,int4 *param_3)
{
char *__s;
ulong uVar1;
ulong uVar2;
uint uVar3;
__s = strtok(param_2," ");
if (__s == (char *)0x0) {
uVar2 = 0;
}
else {
uVar2 = 0;
do {
uVar1 = strlen(__s);
while ((ulong)(long)param_1 < uVar1) {
(&word_len_1)[uVar2] = __s;
uVar3 = (int)uVar2 + 1;
__s = strtok((char *)0x0," ");
if (__s == (char *)0x0) {
uVar2 = (ulong)uVar3;
goto LAB_00101429;
}
uVar2 = (ulong)(int)uVar3;
uVar1 = strlen(__s);
}
__s = strtok((char *)0x0," ");
} while (__s != (char *)0x0);
}
LAB_00101429:
*param_3 = (int)uVar2;
return &word_len_1;
} |
4,408 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of columns
for(int j = 0; j < size; j++) {
int sum = 0;
for(int i = 0; i < size; i++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of main diagonal
int result1 = 0;
for(int i = 0; i < size; i++) {
result1 += my_matrix[i][i];
}
sum_list[index++] = result1;
// Sum of secondary diagonal
int result2 = 0;
for(int i = size - 1; i >= 0; i--) {
result2 += my_matrix[i][i];
}
sum_list[index++] = result2;
// Check if all sums are equal
for(int k = 1; k < index; k++) {
if(sum_list[k] != sum_list[0]) {
return false;
}
}
return true;
}
| int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 7}
};
assert(func0(4, matrix1) == true);
assert(func0(3, matrix2) == true);
assert(func0(3, matrix3) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
sub $0x60,%rsp
mov %edi,-0x64(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x64(%rbp),%ecx
movslq %ecx,%rax
sub $0x1,%rax
mov %rax,-0x30(%rbp)
movslq %ecx,%rax
mov %rax,%r12
mov $0x0,%r13d
mov %rsp,%rax
mov %rax,%rdi
mov -0x64(%rbp),%eax
add $0x1,%eax
add %eax,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%esi
mov $0x0,%edx
div %rsi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rsi
sub %rdx,%rsi
mov %rsi,%rdx
cmp %rdx,%rsp
je 122b <func0+0xc2>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1214 <func0+0xab>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1255 <func0+0xec>
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,-0x48(%rbp)
movl $0x0,-0x4c(%rbp)
jmp 12d4 <func0+0x16b>
movl $0x0,-0x50(%rbp)
movl $0x0,-0x54(%rbp)
jmp 12b3 <func0+0x14a>
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
movslq %ecx,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov -0x70(%rbp),%rax
add %rax,%rdx
mov -0x54(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0x50(%rbp)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x64(%rbp),%eax
jl 1288 <func0+0x11f>
mov -0x48(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x48(%rbp)
mov -0x20(%rbp),%rdx
cltq
mov -0x50(%rbp),%esi
mov %esi,(%rdx,%rax,4)
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x64(%rbp),%eax
jl 1278 <func0+0x10f>
movl $0x0,-0x58(%rbp)
jmp 1341 <func0+0x1d8>
movl $0x0,-0x5c(%rbp)
movl $0x0,-0x60(%rbp)
jmp 1320 <func0+0x1b7>
mov -0x60(%rbp),%eax
movslq %eax,%rdx
movslq %ecx,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov -0x70(%rbp),%rax
add %rax,%rdx
mov -0x58(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0x5c(%rbp)
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x64(%rbp),%eax
jl 12f5 <func0+0x18c>
mov -0x48(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x48(%rbp)
mov -0x20(%rbp),%rdx
cltq
mov -0x5c(%rbp),%esi
mov %esi,(%rdx,%rax,4)
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x64(%rbp),%eax
jl 12e5 <func0+0x17c>
movl $0x0,-0x44(%rbp)
movl $0x0,-0x40(%rbp)
jmp 1384 <func0+0x21b>
mov -0x40(%rbp),%eax
movslq %eax,%rdx
movslq %ecx,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov -0x70(%rbp),%rax
add %rax,%rdx
mov -0x40(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0x44(%rbp)
addl $0x1,-0x40(%rbp)
mov -0x40(%rbp),%eax
cmp -0x64(%rbp),%eax
jl 1359 <func0+0x1f0>
mov -0x48(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x48(%rbp)
mov -0x20(%rbp),%rdx
cltq
mov -0x44(%rbp),%esi
mov %esi,(%rdx,%rax,4)
movl $0x0,-0x3c(%rbp)
mov -0x64(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x38(%rbp)
jmp 13de <func0+0x275>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
movslq %ecx,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov -0x70(%rbp),%rax
add %rax,%rdx
mov -0x38(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0x3c(%rbp)
subl $0x1,-0x38(%rbp)
cmpl $0x0,-0x38(%rbp)
jns 13b3 <func0+0x24a>
mov -0x48(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x48(%rbp)
mov -0x20(%rbp),%rdx
cltq
mov -0x3c(%rbp),%ecx
mov %ecx,(%rdx,%rax,4)
movl $0x1,-0x34(%rbp)
jmp 1424 <func0+0x2bb>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x20(%rbp),%rax
mov (%rax),%eax
cmp %eax,%edx
je 1420 <func0+0x2b7>
mov $0x0,%eax
jmp 1431 <func0+0x2c8>
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x48(%rbp),%eax
jl 1402 <func0+0x299>
mov $0x1,%eax
mov %rdi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 1448 <func0+0x2df>
callq 1060 <__stack_chk_fail@plt>
lea -0x10(%rbp),%rsp
pop %r12
pop %r13
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_54], edi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov ecx, [rbp+var_54]
movsxd rax, ecx
sub rax, 1
mov [rbp+var_20], rax
mov rax, rsp
mov rdi, rax
mov eax, [rbp+var_54]
add eax, 1
add eax, eax
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 rsi, rax
and rsi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rsi
loc_11E9:
cmp rsp, rdx
jz short loc_1200
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_11E9
loc_1200:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_122A
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_122A:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_50], 0
mov [rbp+var_4C], 0
jmp short loc_12A9
loc_124D:
mov [rbp+var_48], 0
mov [rbp+var_44], 0
jmp short loc_1288
loc_125D:
mov eax, [rbp+var_4C]
movsxd rdx, eax
movsxd rax, ecx
imul rax, rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_60]
add rdx, rax
mov eax, [rbp+var_44]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_48], eax
add [rbp+var_44], 1
loc_1288:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_54]
jl short loc_125D
mov eax, [rbp+var_50]
lea edx, [rax+1]
mov [rbp+var_50], edx
mov rdx, [rbp+var_10]
cdqe
mov esi, [rbp+var_48]
mov [rdx+rax*4], esi
add [rbp+var_4C], 1
loc_12A9:
mov eax, [rbp+var_4C]
cmp eax, [rbp+var_54]
jl short loc_124D
mov [rbp+var_40], 0
jmp short loc_1316
loc_12BA:
mov [rbp+var_3C], 0
mov [rbp+var_38], 0
jmp short loc_12F5
loc_12CA:
mov eax, [rbp+var_38]
movsxd rdx, eax
movsxd rax, ecx
imul rax, rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_60]
add rdx, rax
mov eax, [rbp+var_40]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_3C], eax
add [rbp+var_38], 1
loc_12F5:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_54]
jl short loc_12CA
mov eax, [rbp+var_50]
lea edx, [rax+1]
mov [rbp+var_50], edx
mov rdx, [rbp+var_10]
cdqe
mov esi, [rbp+var_3C]
mov [rdx+rax*4], esi
add [rbp+var_40], 1
loc_1316:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_54]
jl short loc_12BA
mov [rbp+var_34], 0
mov [rbp+var_30], 0
jmp short loc_1359
loc_132E:
mov eax, [rbp+var_30]
movsxd rdx, eax
movsxd rax, ecx
imul rax, rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_60]
add rdx, rax
mov eax, [rbp+var_30]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_34], eax
add [rbp+var_30], 1
loc_1359:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_54]
jl short loc_132E
mov eax, [rbp+var_50]
lea edx, [rax+1]
mov [rbp+var_50], edx
mov rdx, [rbp+var_10]
cdqe
mov esi, [rbp+var_34]
mov [rdx+rax*4], esi
mov [rbp+var_2C], 0
mov eax, [rbp+var_54]
sub eax, 1
mov [rbp+var_28], eax
jmp short loc_13B3
loc_1388:
mov eax, [rbp+var_28]
movsxd rdx, eax
movsxd rax, ecx
imul rax, rdx
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_60]
add rdx, rax
mov eax, [rbp+var_28]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_2C], eax
sub [rbp+var_28], 1
loc_13B3:
cmp [rbp+var_28], 0
jns short loc_1388
mov eax, [rbp+var_50]
lea edx, [rax+1]
mov [rbp+var_50], edx
mov rdx, [rbp+var_10]
cdqe
mov ecx, [rbp+var_2C]
mov [rdx+rax*4], ecx
mov [rbp+var_24], 1
jmp short loc_13F9
loc_13D7:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov eax, [rax]
cmp edx, eax
jz short loc_13F5
mov eax, 0
jmp short loc_1406
loc_13F5:
add [rbp+var_24], 1
loc_13F9:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_50]
jl short loc_13D7
mov eax, 1
loc_1406:
mov rsp, rdi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_141D
call ___stack_chk_fail
locret_141D:
leave
retn | long long func0(int a1, long long a2)
{
int v2; // eax
unsigned long long v3; // rax
void *v4; // rsp
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
long long v10; // [rsp+8h] [rbp-60h] BYREF
int v11; // [rsp+14h] [rbp-54h]
int v12; // [rsp+18h] [rbp-50h]
int i; // [rsp+1Ch] [rbp-4Ch]
int v14; // [rsp+20h] [rbp-48h]
int j; // [rsp+24h] [rbp-44h]
int k; // [rsp+28h] [rbp-40h]
int v17; // [rsp+2Ch] [rbp-3Ch]
int m; // [rsp+30h] [rbp-38h]
int v19; // [rsp+34h] [rbp-34h]
int n; // [rsp+38h] [rbp-30h]
int v21; // [rsp+3Ch] [rbp-2Ch]
int ii; // [rsp+40h] [rbp-28h]
int jj; // [rsp+44h] [rbp-24h]
long long v24; // [rsp+48h] [rbp-20h]
long long v25; // [rsp+50h] [rbp-18h]
long long *v26; // [rsp+58h] [rbp-10h]
unsigned long long v27; // [rsp+60h] [rbp-8h]
v11 = a1;
v10 = a2;
v27 = __readfsqword(0x28u);
v24 = a1 - 1LL;
v2 = 2 * (a1 + 1);
v25 = v2 - 1LL;
v3 = 16 * ((4LL * v2 + 15) / 0x10uLL);
while ( &v10 != (long long *)((char *)&v10 - (v3 & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = alloca(v3 & 0xFFF);
if ( (v3 & 0xFFF) != 0 )
*(long long *)((char *)&v10 + (v3 & 0xFFF) - 8) = *(long long *)((char *)&v10 + (v3 & 0xFFF) - 8);
v26 = &v10;
v12 = 0;
for ( i = 0; i < v11; ++i )
{
v14 = 0;
for ( j = 0; j < v11; ++j )
v14 += *(_DWORD *)(v10 + 4 * i * (long long)a1 + 4LL * j);
v5 = v12++;
*((_DWORD *)v26 + v5) = v14;
}
for ( k = 0; k < v11; ++k )
{
v17 = 0;
for ( m = 0; m < v11; ++m )
v17 += *(_DWORD *)(v10 + 4 * m * (long long)a1 + 4LL * k);
v6 = v12++;
*((_DWORD *)v26 + v6) = v17;
}
v19 = 0;
for ( n = 0; n < v11; ++n )
v19 += *(_DWORD *)(v10 + 4 * n * (long long)a1 + 4LL * n);
v7 = v12++;
*((_DWORD *)v26 + v7) = v19;
v21 = 0;
for ( ii = v11 - 1; ii >= 0; --ii )
v21 += *(_DWORD *)(v10 + 4 * ii * (long long)a1 + 4LL * ii);
v8 = v12++;
*((_DWORD *)v26 + v8) = v21;
for ( jj = 1; jj < v12; ++jj )
{
if ( *((_DWORD *)v26 + jj) != *(_DWORD *)v26 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x54],EDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV ECX,dword ptr [RBP + -0x54]
MOVSXD RAX,ECX
SUB RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,RSP
MOV RDI,RAX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
ADD EAX,EAX
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 RSI,RAX
AND RSI,-0x1000
MOV RDX,RSP
SUB RDX,RSI
LAB_001011e9:
CMP RSP,RDX
JZ 0x00101200
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e9
LAB_00101200:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010122a
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010122a:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x50],0x0
MOV dword ptr [RBP + -0x4c],0x0
JMP 0x001012a9
LAB_0010124d:
MOV dword ptr [RBP + -0x48],0x0
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101288
LAB_0010125d:
MOV EAX,dword ptr [RBP + -0x4c]
MOVSXD RDX,EAX
MOVSXD RAX,ECX
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x60]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x44]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x48],EAX
ADD dword ptr [RBP + -0x44],0x1
LAB_00101288:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x54]
JL 0x0010125d
MOV EAX,dword ptr [RBP + -0x50]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x50],EDX
MOV RDX,qword ptr [RBP + -0x10]
CDQE
MOV ESI,dword ptr [RBP + -0x48]
MOV dword ptr [RDX + RAX*0x4],ESI
ADD dword ptr [RBP + -0x4c],0x1
LAB_001012a9:
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,dword ptr [RBP + -0x54]
JL 0x0010124d
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101316
LAB_001012ba:
MOV dword ptr [RBP + -0x3c],0x0
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001012f5
LAB_001012ca:
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOVSXD RAX,ECX
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x60]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x40]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x3c],EAX
ADD dword ptr [RBP + -0x38],0x1
LAB_001012f5:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x54]
JL 0x001012ca
MOV EAX,dword ptr [RBP + -0x50]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x50],EDX
MOV RDX,qword ptr [RBP + -0x10]
CDQE
MOV ESI,dword ptr [RBP + -0x3c]
MOV dword ptr [RDX + RAX*0x4],ESI
ADD dword ptr [RBP + -0x40],0x1
LAB_00101316:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x54]
JL 0x001012ba
MOV dword ptr [RBP + -0x34],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00101359
LAB_0010132e:
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOVSXD RAX,ECX
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x60]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x34],EAX
ADD dword ptr [RBP + -0x30],0x1
LAB_00101359:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x54]
JL 0x0010132e
MOV EAX,dword ptr [RBP + -0x50]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x50],EDX
MOV RDX,qword ptr [RBP + -0x10]
CDQE
MOV ESI,dword ptr [RBP + -0x34]
MOV dword ptr [RDX + RAX*0x4],ESI
MOV dword ptr [RBP + -0x2c],0x0
MOV EAX,dword ptr [RBP + -0x54]
SUB EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001013b3
LAB_00101388:
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RDX,EAX
MOVSXD RAX,ECX
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x60]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x28]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x2c],EAX
SUB dword ptr [RBP + -0x28],0x1
LAB_001013b3:
CMP dword ptr [RBP + -0x28],0x0
JNS 0x00101388
MOV EAX,dword ptr [RBP + -0x50]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x50],EDX
MOV RDX,qword ptr [RBP + -0x10]
CDQE
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RDX + RAX*0x4],ECX
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001013f9
LAB_001013d7:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001013f5
MOV EAX,0x0
JMP 0x00101406
LAB_001013f5:
ADD dword ptr [RBP + -0x24],0x1
LAB_001013f9:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x50]
JL 0x001013d7
MOV EAX,0x1
LAB_00101406:
MOV RSP,RDI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010141d
CALL 0x00101060
LAB_0010141d:
LEAVE
RET | int8 func0(int param_1,long param_2)
{
int iVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
long *plVar5;
long in_FS_OFFSET;
long local_68;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
long local_28;
long local_20;
int *local_18;
long local_10;
local_5c = param_1;
local_68 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = (long)param_1 + -1;
iVar1 = (param_1 + 1) * 2;
local_20 = (long)iVar1 + -1;
uVar3 = (((long)iVar1 * 4 + 0xfU) / 0x10) * 0x10;
for (plVar5 = &local_68; plVar5 != (long *)((long)&local_68 - (uVar3 & 0xfffffffffffff000));
plVar5 = (long *)((long)plVar5 + -0x1000)) {
*(int8 *)((long)plVar5 + -8) = *(int8 *)((long)plVar5 + -8);
}
lVar2 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)((long)plVar5 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar2) =
*(int8 *)((long)plVar5 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar2);
}
local_58 = 0;
for (local_54 = 0; local_54 < local_5c; local_54 = local_54 + 1) {
local_50 = 0;
for (local_4c = 0; local_4c < local_5c; local_4c = local_4c + 1) {
local_50 = local_50 +
*(int *)((long)param_1 * (long)local_54 * 4 + local_68 + (long)local_4c * 4);
}
*(int *)((long)plVar5 + (long)local_58 * 4 + lVar2) = local_50;
local_58 = local_58 + 1;
}
for (local_48 = 0; local_48 < local_5c; local_48 = local_48 + 1) {
local_44 = 0;
for (local_40 = 0; local_40 < local_5c; local_40 = local_40 + 1) {
local_44 = local_44 +
*(int *)((long)param_1 * (long)local_40 * 4 + local_68 + (long)local_48 * 4);
}
*(int *)((long)plVar5 + (long)local_58 * 4 + lVar2) = local_44;
local_58 = local_58 + 1;
}
local_3c = 0;
for (local_38 = 0; local_38 < local_5c; local_38 = local_38 + 1) {
local_3c = local_3c +
*(int *)((long)param_1 * (long)local_38 * 4 + local_68 + (long)local_38 * 4);
}
iVar1 = local_58 + 1;
*(int *)((long)plVar5 + (long)local_58 * 4 + lVar2) = local_3c;
local_34 = 0;
local_30 = local_5c;
while (local_30 = local_30 + -1, -1 < local_30) {
local_34 = local_34 +
*(int *)((long)param_1 * (long)local_30 * 4 + local_68 + (long)local_30 * 4);
}
local_58 = local_58 + 2;
*(int *)((long)plVar5 + (long)iVar1 * 4 + lVar2) = local_34;
local_2c = 1;
do {
if (local_58 <= local_2c) {
uVar4 = 1;
LAB_00101406:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = (int *)((long)plVar5 + lVar2);
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar4;
}
if (*(int *)((long)plVar5 + (long)local_2c * 4 + lVar2) != *(int *)((long)plVar5 + lVar2)) {
uVar4 = 0;
goto LAB_00101406;
}
local_2c = local_2c + 1;
} while( true );
} |
4,409 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of columns
for(int j = 0; j < size; j++) {
int sum = 0;
for(int i = 0; i < size; i++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of main diagonal
int result1 = 0;
for(int i = 0; i < size; i++) {
result1 += my_matrix[i][i];
}
sum_list[index++] = result1;
// Sum of secondary diagonal
int result2 = 0;
for(int i = size - 1; i >= 0; i--) {
result2 += my_matrix[i][i];
}
sum_list[index++] = result2;
// Check if all sums are equal
for(int k = 1; k < index; k++) {
if(sum_list[k] != sum_list[0]) {
return false;
}
}
return true;
}
| int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 7}
};
assert(func0(4, matrix1) == true);
assert(func0(3, matrix2) == true);
assert(func0(3, matrix3) == false);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %edi,%r11
lea 0x2(%rdi,%rdi,1),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11ce <func0+0x65>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11b7 <func0+0x4e>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11e4 <func0+0x7b>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%rbx
mov %rbx,%rax
shr $0x2,%rax
mov %rax,-0x48(%rbp)
and $0xfffffffffffffffc,%rbx
test %edi,%edi
jle 1347 <func0+0x1de>
mov %rbx,%r8
lea 0x0(,%r11,4),%r9
lea -0x1(%rdi),%r13d
lea 0x0(,%r13,4),%rax
mov %r12,%r10
lea 0x4(%r12,%rax,1),%rsi
lea 0x4(%rbx,%rax,1),%r15
mov %rsi,%rcx
not %r13
shl $0x2,%r13
mov $0x0,%r14d
jmp 1245 <func0+0xdc>
mov %edx,(%r8)
add $0x4,%r8
add %r9,%rcx
cmp %r15,%r8
je 125a <func0+0xf1>
lea 0x0(%r13,%rcx,1),%rax
mov %r14d,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 124d <func0+0xe4>
jmp 1236 <func0+0xcd>
lea (%rbx,%r9,1),%r14
mov %r12,%r13
mov $0x0,%r15d
jmp 1279 <func0+0x110>
mov %ecx,(%r14)
add $0x4,%r14
add $0x4,%r13
cmp %rsi,%r13
je 1295 <func0+0x12c>
mov %r13,%rdx
mov %r15d,%ecx
mov $0x0,%eax
add (%rdx),%ecx
mov %eax,%r8d
add $0x1,%eax
add %r9,%rdx
cmp %eax,%edi
jne 1284 <func0+0x11b>
jmp 1269 <func0+0x100>
add %eax,%eax
mov %eax,%ecx
add $0x4,%r9
mov $0x0,%edx
mov $0x0,%esi
add (%r10),%esi
mov %edx,%edi
add $0x1,%edx
add %r9,%r10
cmp %edi,%r8d
jne 12a7 <func0+0x13e>
lea 0x1(%rax),%edi
cltq
mov %esi,(%rbx,%rax,4)
lea 0x1(%r11),%rdx
not %r11
lea 0x0(,%r11,4),%rsi
movslq %r8d,%rax
imul %rdx,%rax
lea (%r12,%rax,4),%rax
mov $0x0,%edx
add (%rax),%edx
add %rsi,%rax
sub $0x1,%r8d
jns 12de <func0+0x175>
movslq %edi,%rdi
mov %edx,(%rbx,%rdi,4)
test %ecx,%ecx
js 131d <func0+0x1b4>
mov -0x48(%rbp),%rax
mov 0x0(,%rax,4),%edx
lea 0x4(%rbx),%rax
mov %ecx,%ecx
lea 0x8(%rbx,%rcx,4),%rcx
cmp %edx,(%rax)
jne 1324 <func0+0x1bb>
add $0x4,%rax
cmp %rcx,%rax
jne 1309 <func0+0x1a0>
mov $0x1,%eax
jmp 1329 <func0+0x1c0>
mov $0x1,%eax
jmp 1329 <func0+0x1c0>
mov $0x0,%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1367 <func0+0x1fe>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
mov -0x48(%rbp),%rax
movl $0x0,0x0(,%rax,4)
mov $0x0,%ecx
mov $0x1,%edi
mov $0x0,%edx
jmp 12e9 <func0+0x180>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r8d, edi
mov r12, rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd r10, edi
lea eax, [rdi+rdi+2]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11B7:
cmp rsp, rdx
jz short loc_11CE
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11B7
loc_11CE:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11E4
or [rsp+rax+50h+var_58], 0
loc_11E4:
lea rbx, [rsp+50h+var_4D]
mov rax, rbx
shr rax, 2
mov [rbp+var_48], rax
and rbx, 0FFFFFFFFFFFFFFFCh
test r8d, r8d
jle loc_1342
mov rsi, rbx
lea rdi, ds:0[r10*4]
lea eax, [r8-1]
shl rax, 2
mov r9, r12
lea r11, [r12+rax+4]
lea r15, [rbx+rax+4]
mov rcx, r11
mov r13d, r8d
neg r13
shl r13, 2
mov r14d, 0
loc_1234:
lea rax, [r13+rcx+0]
mov edx, r14d
loc_123C:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_123C
mov [rsi], edx
add rsi, 4
add rcx, rdi
cmp rsi, r15
jnz short loc_1234
lea r14, [rbx+rdi]
mov r13, r12
mov r15d, 0
loc_1262:
mov rdx, r13
mov eax, 0
mov ecx, r15d
loc_126D:
add ecx, [rdx]
mov esi, eax
add eax, 1
add rdx, rdi
cmp r8d, eax
jnz short loc_126D
mov [r14], ecx
add r14, 4
add r13, 4
cmp r13, r11
jnz short loc_1262
add eax, eax
mov ecx, eax
add rdi, 4
mov edx, 0
mov r8d, 0
loc_129F:
add r8d, [r9]
mov r11d, edx
add edx, 1
add r9, rdi
cmp esi, r11d
jnz short loc_129F
lea r9d, [rax+1]
cdqe
mov [rbx+rax*4], r8d
lea rdx, [r10+1]
not r10
lea rdi, ds:0[r10*4]
movsxd rax, esi
imul rax, rdx
lea rax, [r12+rax*4]
mov edx, 0
loc_12D9:
add edx, [rax]
add rax, rdi
sub esi, 1
jns short loc_12D9
loc_12E3:
movsxd r9, r9d
mov [rbx+r9*4], edx
test ecx, ecx
js short loc_1318
mov rax, [rbp+var_48]
mov edx, ds:dword_0[rax*4]
lea rax, [rbx+4]
mov ecx, ecx
lea rcx, [rbx+rcx*4+8]
loc_1304:
cmp [rax], edx
jnz short loc_131F
add rax, 4
cmp rax, rcx
jnz short loc_1304
mov eax, 1
jmp short loc_1324
loc_1318:
mov eax, 1
jmp short loc_1324
loc_131F:
mov eax, 0
loc_1324:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1363
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1342:
mov rax, [rbp+var_48]
mov ds:dword_0[rax*4], 0
mov ecx, 0
mov r9d, 1
mov edx, 0
jmp short loc_12E3
loc_1363:
call ___stack_chk_fail | long long func0(int a1, _DWORD *a2)
{
long long v4; // r10
signed long long v5; // rax
void *v6; // rsp
_DWORD *v7; // rsi
long long v8; // rdi
long long v9; // rax
_DWORD *v10; // r9
long long v11; // r11
_BYTE *v12; // r15
_DWORD *v13; // rcx
_DWORD *v14; // rax
int v15; // edx
_DWORD *v16; // r14
_DWORD *v17; // r13
_DWORD *v18; // rdx
int v19; // eax
int v20; // ecx
int v21; // esi
int v22; // eax
int v23; // ecx
long long v24; // rdi
int v25; // edx
int v26; // r8d
int v27; // r11d
int v28; // r9d
long long v29; // rdx
long long v30; // r10
_DWORD *v31; // rax
int v32; // edx
_DWORD *v33; // rax
char *v34; // rcx
_BYTE v37[3]; // [rsp+8h] [rbp-50h] BYREF
char v38; // [rsp+Bh] [rbp-4Dh] BYREF
_BYTE v39[4]; // [rsp+Ch] [rbp-4Ch] BYREF
_QWORD v40[9]; // [rsp+10h] [rbp-48h] BYREF
v40[2] = __readfsqword(0x28u);
v4 = a1;
while ( v37 != &v37[-((4LL * (2 * a1 + 2) + 15) & 0xFFFFFFFFFFFFF000LL)] )
;
v5 = (4 * (2 * (_WORD)a1 + 2) + 15) & 0xFF0;
v6 = alloca(v5);
if ( ((4 * (2 * (_WORD)a1 + 2) + 15) & 0xFF0) != 0 )
*(_QWORD *)&v37[v5 - 8] = *(_QWORD *)&v37[v5 - 8];
v40[0] = (unsigned long long)&v38 >> 2;
if ( a1 <= 0 )
{
*(_DWORD *)(4LL * v40[0]) = 0;
v23 = 0;
v28 = 1;
v32 = 0;
}
else
{
v7 = v37;
v8 = 4LL * a1;
v9 = (unsigned int)(a1 - 1);
v10 = a2;
v11 = (long long)&a2[v9 + 1];
v12 = &v39[v9 * 4];
v13 = (_DWORD *)v11;
do
{
v14 = &v13[-a1];
v15 = 0;
do
v15 += *v14++;
while ( v14 != v13 );
*v7++ = v15;
v13 = (_DWORD *)((char *)v13 + v8);
}
while ( v7 != (_DWORD *)v12 );
v16 = &v37[v8];
v17 = a2;
do
{
v18 = v17;
v19 = 0;
v20 = 0;
do
{
v20 += *v18;
v21 = v19++;
v18 = (_DWORD *)((char *)v18 + v8);
}
while ( a1 != v19 );
*v16++ = v20;
++v17;
}
while ( v17 != (_DWORD *)v11 );
v22 = 2 * v19;
v23 = v22;
v24 = v8 + 4;
v25 = 0;
v26 = 0;
do
{
v26 += *v10;
v27 = v25++;
v10 = (_DWORD *)((char *)v10 + v24);
}
while ( v21 != v27 );
v28 = v22 + 1;
*(_DWORD *)&v37[4 * v22] = v26;
v29 = v4 + 1;
v30 = ~v4;
v31 = &a2[v29 * v21];
v32 = 0;
do
{
v32 += *v31;
v31 += v30;
--v21;
}
while ( v21 >= 0 );
}
*(_DWORD *)&v37[4 * v28] = v32;
if ( v23 < 0 )
return 1LL;
v33 = v39;
v34 = (char *)v40 + 4 * (unsigned int)v23;
while ( *v33 == *(_DWORD *)(4LL * v40[0]) )
{
if ( ++v33 == (_DWORD *)v34 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R8D,EDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD R10,EDI
LEA EAX,[RDI + RDI*0x1 + 0x2]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011b7:
CMP RSP,RDX
JZ 0x001011ce
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011b7
LAB_001011ce:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011e4
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011e4:
LEA RBX,[RSP + 0x3]
MOV RAX,RBX
SHR RAX,0x2
MOV qword ptr [RBP + -0x48],RAX
AND RBX,-0x4
TEST R8D,R8D
JLE 0x00101342
MOV RSI,RBX
LEA RDI,[R10*0x4]
LEA EAX,[R8 + -0x1]
SHL RAX,0x2
MOV R9,R12
LEA R11,[R12 + RAX*0x1 + 0x4]
LEA R15,[RBX + RAX*0x1 + 0x4]
MOV RCX,R11
MOV R13D,R8D
NEG R13
SHL R13,0x2
MOV R14D,0x0
LAB_00101234:
LEA RAX,[R13 + RCX*0x1]
MOV EDX,R14D
LAB_0010123c:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010123c
MOV dword ptr [RSI],EDX
ADD RSI,0x4
ADD RCX,RDI
CMP RSI,R15
JNZ 0x00101234
LEA R14,[RBX + RDI*0x1]
MOV R13,R12
MOV R15D,0x0
LAB_00101262:
MOV RDX,R13
MOV EAX,0x0
MOV ECX,R15D
LAB_0010126d:
ADD ECX,dword ptr [RDX]
MOV ESI,EAX
ADD EAX,0x1
ADD RDX,RDI
CMP R8D,EAX
JNZ 0x0010126d
MOV dword ptr [R14],ECX
ADD R14,0x4
ADD R13,0x4
CMP R13,R11
JNZ 0x00101262
ADD EAX,EAX
MOV ECX,EAX
ADD RDI,0x4
MOV EDX,0x0
MOV R8D,0x0
LAB_0010129f:
ADD R8D,dword ptr [R9]
MOV R11D,EDX
ADD EDX,0x1
ADD R9,RDI
CMP ESI,R11D
JNZ 0x0010129f
LEA R9D,[RAX + 0x1]
CDQE
MOV dword ptr [RBX + RAX*0x4],R8D
LEA RDX,[R10 + 0x1]
NOT R10
LEA RDI,[R10*0x4]
MOVSXD RAX,ESI
IMUL RAX,RDX
LEA RAX,[R12 + RAX*0x4]
MOV EDX,0x0
LAB_001012d9:
ADD EDX,dword ptr [RAX]
ADD RAX,RDI
SUB ESI,0x1
JNS 0x001012d9
LAB_001012e3:
MOVSXD R9,R9D
MOV dword ptr [RBX + R9*0x4],EDX
TEST ECX,ECX
JS 0x00101318
MOV RAX,qword ptr [RBP + -0x48]
MOV EDX,dword ptr [RAX*0x4]
LEA RAX,[RBX + 0x4]
MOV ECX,ECX
LEA RCX,[RBX + RCX*0x4 + 0x8]
LAB_00101304:
CMP dword ptr [RAX],EDX
JNZ 0x0010131f
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101304
MOV EAX,0x1
JMP 0x00101324
LAB_00101318:
MOV EAX,0x1
JMP 0x00101324
LAB_0010131f:
MOV EAX,0x0
LAB_00101324:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101363
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101342:
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX*0x4],0x0
MOV ECX,0x0
MOV R9D,0x1
MOV EDX,0x0
JMP 0x001012e3
LAB_00101363:
CALL 0x00101060 | int8 func0(uint param_1,int *param_2)
{
long lVar1;
uint uVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
int *piVar6;
ulong uVar7;
int iVar8;
uint uVar9;
int1 *puVar10;
uint uVar11;
int iVar12;
ulong uVar13;
long in_FS_OFFSET;
bool bVar14;
int1 auStack_58 [8];
ulong local_50;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar13 = (ulong)(int)param_1;
uVar7 = (long)(int)(param_1 * 2 + 2) * 4 + 0xf;
for (puVar10 = auStack_58; puVar10 != auStack_58 + -(uVar7 & 0xfffffffffffff000);
puVar10 = puVar10 + -0x1000) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar1 = -uVar7;
piVar4 = (int *)(puVar10 + lVar1);
if (uVar7 != 0) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
local_50 = (ulong)(puVar10 + lVar1 + 3) >> 2;
if ((int)param_1 < 1) {
*(int4 *)(local_50 * 4) = 0;
uVar7 = 0;
iVar8 = 1;
iVar12 = 0;
}
else {
piVar6 = param_2 + (ulong)(param_1 - 1) + 1;
do {
piVar3 = piVar6 + -(ulong)param_1;
iVar8 = 0;
do {
iVar8 = iVar8 + *piVar3;
piVar3 = piVar3 + 1;
} while (piVar3 != piVar6);
*piVar4 = iVar8;
piVar4 = piVar4 + 1;
piVar6 = piVar6 + uVar13;
} while (piVar4 != (int *)(puVar10 + (ulong)(param_1 - 1) * 4 + lVar1 + 4));
piVar4 = (int *)(puVar10 + uVar13 * 4 + lVar1);
piVar6 = param_2;
do {
iVar8 = 0;
piVar3 = piVar6;
uVar2 = 0;
do {
uVar11 = uVar2;
iVar8 = iVar8 + *piVar3;
uVar2 = uVar11 + 1;
piVar3 = piVar3 + uVar13;
} while (param_1 != uVar2);
*piVar4 = iVar8;
piVar4 = piVar4 + 1;
piVar6 = piVar6 + 1;
} while (piVar6 != param_2 + (ulong)(param_1 - 1) + 1);
uVar2 = uVar2 * 2;
uVar7 = (ulong)uVar2;
iVar12 = 0;
piVar4 = param_2;
uVar9 = 0;
do {
iVar12 = iVar12 + *piVar4;
piVar4 = piVar4 + uVar13 + 1;
bVar14 = uVar11 != uVar9;
uVar9 = uVar9 + 1;
} while (bVar14);
iVar8 = uVar2 + 1;
*(int *)(puVar10 + (long)(int)uVar2 * 4 + lVar1) = iVar12;
param_2 = param_2 + (long)(int)uVar11 * (uVar13 + 1);
iVar12 = 0;
do {
iVar12 = iVar12 + *param_2;
param_2 = param_2 + ~uVar13;
uVar11 = uVar11 - 1;
} while (-1 < (int)uVar11);
}
*(int *)(puVar10 + (long)iVar8 * 4 + lVar1) = iVar12;
if ((int)uVar7 < 0) {
uVar5 = 1;
}
else {
piVar4 = (int *)(puVar10 + lVar1 + 4);
do {
if (*piVar4 != *(int *)(local_50 * 4)) {
uVar5 = 0;
goto LAB_00101324;
}
piVar4 = piVar4 + 1;
} while (piVar4 != (int *)(puVar10 + uVar7 * 4 + lVar1 + 8));
uVar5 = 1;
}
LAB_00101324:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar5;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar10 + lVar1 + -8) = main;
__stack_chk_fail();
} |
4,410 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of columns
for(int j = 0; j < size; j++) {
int sum = 0;
for(int i = 0; i < size; i++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of main diagonal
int result1 = 0;
for(int i = 0; i < size; i++) {
result1 += my_matrix[i][i];
}
sum_list[index++] = result1;
// Sum of secondary diagonal
int result2 = 0;
for(int i = size - 1; i >= 0; i--) {
result2 += my_matrix[i][i];
}
sum_list[index++] = result2;
// Check if all sums are equal
for(int k = 1; k < index; k++) {
if(sum_list[k] != sum_list[0]) {
return false;
}
}
return true;
}
| int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 7}
};
assert(func0(4, matrix1) == true);
assert(func0(3, matrix2) == true);
assert(func0(3, matrix3) == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
movslq %edi,%r13
push %r12
mov %rsi,%r12
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x2(%rdi,%rdi,1),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1398 <func0+0x68>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1383 <func0+0x53>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1514 <func0+0x1e4>
lea 0x3(%rsp),%rbx
lea -0x1(%rdi),%r10d
mov %rbx,%rax
and $0xfffffffffffffffc,%rbx
shr $0x2,%rax
mov %rax,-0x48(%rbp)
test %edi,%edi
jle 151f <func0+0x1ef>
mov %r10d,%r14d
mov %rbx,%r8
lea 0x0(,%r13,4),%r9
mov %r12,%r11
lea 0x0(,%r14,4),%rax
not %r14
lea 0x4(%r12,%rax,1),%rsi
lea 0x4(%rbx,%rax,1),%r15
shl $0x2,%r14
mov %rsi,%rcx
nopw 0x0(%rax,%rax,1)
lea (%r14,%rcx,1),%rax
xor %edx,%edx
nopw %cs:0x0(%rax,%rax,1)
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1410 <func0+0xe0>
mov %edx,(%r8)
add $0x4,%r8
lea (%rax,%r9,1),%rcx
cmp %r15,%r8
jne 1400 <func0+0xd0>
lea (%rbx,%r9,1),%r15
mov %r12,%r14
nopw 0x0(%rax,%rax,1)
mov %r14,%rdx
xor %ecx,%ecx
xor %eax,%eax
mov %eax,%r8d
lea 0x1(%rax),%eax
add (%rdx),%ecx
add %r9,%rdx
cmp %eax,%edi
jne 1440 <func0+0x110>
add $0x4,%r14
mov %ecx,(%r15)
add $0x4,%r15
cmp %rsi,%r14
jne 1438 <func0+0x108>
add %edi,%edi
add $0x4,%r9
xor %eax,%eax
xor %edx,%edx
mov %edi,%ecx
nopl 0x0(%rax,%rax,1)
mov %eax,%esi
add (%r11),%edx
add $0x1,%eax
add %r9,%r11
cmp %esi,%r8d
jne 1470 <func0+0x140>
lea 0x1(%rdi),%r8d
movslq %edi,%rdi
mov %edx,(%rbx,%rdi,4)
movslq %r10d,%rax
mov %r13,%rsi
xor %edx,%edx
add $0x1,%rax
not %rsi
imul %rax,%r13
shl $0x2,%rsi
lea (%r12,%r13,4),%rax
nopl (%rax)
sub $0x1,%r10d
add -0x4(%rax),%edx
add %rsi,%rax
cmp $0xffffffff,%r10d
jne 14a8 <func0+0x178>
movslq %r8d,%r8
add $0x2,%ecx
mov %edx,(%rbx,%r8,4)
cmp $0x1,%ecx
jle 150d <func0+0x1dd>
mov -0x48(%rbp),%rax
sub $0x2,%ecx
lea 0x8(%rbx,%rcx,4),%rcx
mov 0x0(,%rax,4),%edx
lea 0x4(%rbx),%rax
jmp 14e9 <func0+0x1b9>
add $0x4,%rax
cmp %rax,%rcx
je 150d <func0+0x1dd>
cmp %edx,(%rax)
je 14e0 <func0+0x1b0>
xor %eax,%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1552 <func0+0x222>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
mov $0x1,%eax
jmp 14ef <func0+0x1bf>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 13aa <func0+0x7a>
mov -0x48(%rbp),%rax
movl $0x0,0x0(,%rax,4)
test %r10d,%r10d
jns 1545 <func0+0x215>
movl $0x0,0x4(,%rax,4)
mov $0x2,%ecx
jmp 14c7 <func0+0x197>
xor %ecx,%ecx
mov $0x1,%r8d
jmpq 148a <func0+0x15a>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
movsxd r13, edi
push r12
mov r8, r13
mov r12, rsi
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [r13+r13+2]
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_1399
loc_1384:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rcx
jnz short loc_1384
loc_1399:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1514
loc_13AB:
lea rbx, [rsp+1050h+var_104D]
lea r9d, [r8-1]
mov rax, rbx
and rbx, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov [rbp+var_48], rax
test r8d, r8d
jle loc_151F
mov eax, r9d
mov r14, 0FFFFFFFFFFFFFFFCh
mov rsi, rbx
mov r10, r12
shl rax, 2
lea rdi, ds:0[r13*4]
lea r11, [r12+rax+4]
lea r15, [rbx+rax+4]
sub r14, rax
mov rcx, r11
nop dword ptr [rax+rax+00000000h]
loc_1400:
lea rax, [r14+rcx]
xor edx, edx
nop word ptr [rax+rax+00000000h]
loc_1410:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1410
mov [rsi], edx
add rsi, 4
lea rcx, [rax+rdi]
cmp rsi, r15
jnz short loc_1400
lea r15, [rbx+rdi]
mov r14, r12
nop dword ptr [rax+00000000h]
loc_1438:
mov rdx, r14
xor eax, eax
xor ecx, ecx
nop
loc_1440:
mov esi, eax
lea eax, [rax+1]
add ecx, [rdx]
add rdx, rdi
cmp r8d, eax
jnz short loc_1440
add r14, 4
mov [r15], ecx
add r15, 4
cmp r14, r11
jnz short loc_1438
add r8d, r8d
add rdi, 4
xor eax, eax
xor edx, edx
mov ecx, r8d
nop dword ptr [rax]
loc_1470:
mov r11d, eax
add edx, [r10]
add eax, 1
add r10, rdi
cmp esi, r11d
jnz short loc_1470
lea edi, [r8+1]
movsxd r8, r8d
mov [rbx+r8*4], edx
loc_148C:
mov rsi, r13
imul r13, r13
xor edx, edx
not rsi
shl rsi, 2
lea rax, [r12+r13*4]
loc_14A0:
sub r9d, 1
add edx, [rax-4]
add rax, rsi
cmp r9d, 0FFFFFFFFh
jnz short loc_14A0
movsxd rdi, edi
add ecx, 2
mov [rbx+rdi*4], edx
cmp ecx, 1
jle short loc_150D
loc_14BE:
mov rax, [rbp+var_48]
sub ecx, 2
lea rcx, [rbx+rcx*4+8]
mov edx, ds:dword_0[rax*4]
lea rax, [rbx+4]
jmp short loc_14E9
loc_14E0:
add rax, 4
cmp rcx, rax
jz short loc_150D
loc_14E9:
cmp [rax], edx
jz short loc_14E0
xor eax, eax
loc_14EF:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1554
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_150D:
mov eax, 1
jmp short loc_14EF
loc_1514:
or [rsp+rdx+1050h+var_1058], 0
jmp loc_13AB
loc_151F:
mov rax, [rbp+var_48]
mov ds:dword_0[rax*4], 0
test r9d, r9d
jns short loc_1548
mov dword ptr ds:byte_4[rax*4], 0
mov ecx, 2
jmp loc_14BE
loc_1548:
xor ecx, ecx
mov edi, 1
jmp loc_148C
loc_1554:
call ___stack_chk_fail | long long func0(int a1, _DWORD *a2)
{
long long v2; // r13
long long v5; // rdx
long long *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
int v10; // r9d
_DWORD *v11; // rsi
_DWORD *v12; // r10
long long v13; // rax
long long v14; // rdi
long long v15; // r11
_BYTE *v16; // r15
long long v17; // r14
_DWORD *v18; // rcx
_DWORD *v19; // rax
int v20; // edx
_DWORD *v21; // r15
_DWORD *v22; // r14
_DWORD *v23; // rdx
int v24; // eax
int v25; // ecx
int v26; // esi
int v27; // r8d
long long v28; // rdi
int v29; // eax
int v30; // edx
int v31; // ecx
int v32; // r11d
int v33; // edi
int v34; // edx
_DWORD *v35; // rax
int v36; // ecx
_BYTE *v37; // rcx
_DWORD *v38; // rax
unsigned long long v40; // rax
_BYTE v42[3]; // [rsp+8h] [rbp-1050h] BYREF
char v43; // [rsp+Bh] [rbp-104Dh] BYREF
_BYTE v44[4084]; // [rsp+Ch] [rbp-104Ch] BYREF
long long v45; // [rsp+1008h] [rbp-50h] BYREF
unsigned long long v46; // [rsp+1010h] [rbp-48h]
unsigned long long v47; // [rsp+1020h] [rbp-38h]
v2 = a1;
v47 = __readfsqword(0x28u);
v5 = 4LL * (2 * a1 + 2) + 15;
v6 = (long long *)((char *)&v45 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( &v45 != v6 )
{
while ( v42 != (_BYTE *)v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)&v42[v8 - 8] = *(_QWORD *)&v42[v8 - 8];
v10 = a1 - 1;
v46 = (unsigned long long)&v43 >> 2;
if ( a1 <= 0 )
{
v40 = v46;
*(_DWORD *)(4 * v46) = 0;
if ( v10 < 0 )
{
*(_DWORD *)&byte_4[4 * v40] = 0;
v36 = 2;
goto LABEL_20;
}
v31 = 0;
v33 = 1;
}
else
{
v11 = v42;
v12 = a2;
v13 = 4LL * (unsigned int)v10;
v14 = 4LL * a1;
v15 = (long long)&a2[(unsigned long long)v13 / 4 + 1];
v16 = &v44[v13];
v17 = -4 - v13;
v18 = (_DWORD *)v15;
do
{
v19 = (_DWORD *)((char *)v18 + v17);
v20 = 0;
do
v20 += *v19++;
while ( v19 != v18 );
*v11++ = v20;
v18 = &v19[(unsigned long long)v14 / 4];
}
while ( v11 != (_DWORD *)v16 );
v21 = &v42[v14];
v22 = a2;
do
{
v23 = v22;
v24 = 0;
v25 = 0;
do
{
v26 = v24++;
v25 += *v23;
v23 = (_DWORD *)((char *)v23 + v14);
}
while ( a1 != v24 );
++v22;
*v21++ = v25;
}
while ( v22 != (_DWORD *)v15 );
v27 = 2 * a1;
v28 = v14 + 4;
v29 = 0;
v30 = 0;
v31 = v27;
do
{
v32 = v29;
v30 += *v12;
++v29;
v12 = (_DWORD *)((char *)v12 + v28);
}
while ( v26 != v32 );
v33 = v27 + 1;
*(_DWORD *)&v42[4 * v27] = v30;
}
v34 = 0;
v35 = &a2[v2 * v2];
do
{
--v10;
v34 += *(v35 - 1);
v35 += ~v2;
}
while ( v10 != -1 );
v36 = v31 + 2;
*(_DWORD *)&v42[4 * v33] = v34;
if ( v36 <= 1 )
return 1LL;
LABEL_20:
v37 = &v44[4 * (v36 - 2) + 4];
v38 = v44;
while ( *v38 == *(_DWORD *)(4 * v46) )
{
if ( v37 == (_BYTE *)++v38 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,EDI
PUSH R12
MOV R8,R13
MOV R12,RSI
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[R13 + R13*0x1 + 0x2]
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 0x00101399
LAB_00101384:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101384
LAB_00101399:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101514
LAB_001013ab:
LEA RBX,[RSP + 0x3]
LEA R9D,[R8 + -0x1]
MOV RAX,RBX
AND RBX,-0x4
SHR RAX,0x2
MOV qword ptr [RBP + -0x48],RAX
TEST R8D,R8D
JLE 0x0010151f
MOV EAX,R9D
MOV R14,-0x4
MOV RSI,RBX
MOV R10,R12
SHL RAX,0x2
LEA RDI,[R13*0x4]
LEA R11,[R12 + RAX*0x1 + 0x4]
LEA R15,[RBX + RAX*0x1 + 0x4]
SUB R14,RAX
MOV RCX,R11
NOP dword ptr [RAX + RAX*0x1]
LAB_00101400:
LEA RAX,[R14 + RCX*0x1]
XOR EDX,EDX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101410:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101410
MOV dword ptr [RSI],EDX
ADD RSI,0x4
LEA RCX,[RAX + RDI*0x1]
CMP RSI,R15
JNZ 0x00101400
LEA R15,[RBX + RDI*0x1]
MOV R14,R12
NOP dword ptr [RAX]
LAB_00101438:
MOV RDX,R14
XOR EAX,EAX
XOR ECX,ECX
NOP
LAB_00101440:
MOV ESI,EAX
LEA EAX,[RAX + 0x1]
ADD ECX,dword ptr [RDX]
ADD RDX,RDI
CMP R8D,EAX
JNZ 0x00101440
ADD R14,0x4
MOV dword ptr [R15],ECX
ADD R15,0x4
CMP R14,R11
JNZ 0x00101438
ADD R8D,R8D
ADD RDI,0x4
XOR EAX,EAX
XOR EDX,EDX
MOV ECX,R8D
NOP dword ptr [RAX]
LAB_00101470:
MOV R11D,EAX
ADD EDX,dword ptr [R10]
ADD EAX,0x1
ADD R10,RDI
CMP ESI,R11D
JNZ 0x00101470
LEA EDI,[R8 + 0x1]
MOVSXD R8,R8D
MOV dword ptr [RBX + R8*0x4],EDX
LAB_0010148c:
MOV RSI,R13
IMUL R13,R13
XOR EDX,EDX
NOT RSI
SHL RSI,0x2
LEA RAX,[R12 + R13*0x4]
LAB_001014a0:
SUB R9D,0x1
ADD EDX,dword ptr [RAX + -0x4]
ADD RAX,RSI
CMP R9D,-0x1
JNZ 0x001014a0
MOVSXD RDI,EDI
ADD ECX,0x2
MOV dword ptr [RBX + RDI*0x4],EDX
CMP ECX,0x1
JLE 0x0010150d
LAB_001014be:
MOV RAX,qword ptr [RBP + -0x48]
SUB ECX,0x2
LEA RCX,[RBX + RCX*0x4 + 0x8]
MOV EDX,dword ptr [RAX*0x4]
LEA RAX,[RBX + 0x4]
JMP 0x001014e9
LAB_001014e0:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x0010150d
LAB_001014e9:
CMP dword ptr [RAX],EDX
JZ 0x001014e0
XOR EAX,EAX
LAB_001014ef:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101554
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010150d:
MOV EAX,0x1
JMP 0x001014ef
LAB_00101514:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001013ab
LAB_0010151f:
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX*0x4],0x0
TEST R9D,R9D
JNS 0x00101548
MOV dword ptr [0x4 + RAX*0x4],0x0
MOV ECX,0x2
JMP 0x001014be
LAB_00101548:
XOR ECX,ECX
MOV EDI,0x1
JMP 0x0010148c
LAB_00101554:
CALL 0x00101060 | int8 func0(int param_1,int *param_2)
{
long lVar1;
int1 *puVar2;
int iVar3;
int *piVar4;
int *piVar5;
int8 uVar6;
int iVar7;
int *piVar8;
int iVar9;
ulong uVar10;
int1 *puVar11;
uint uVar13;
ulong uVar14;
long in_FS_OFFSET;
bool bVar15;
int1 auStack_58 [8];
ulong local_50;
long local_40;
int1 *puVar12;
uVar14 = (ulong)param_1;
puVar11 = auStack_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar10 = (long)(param_1 * 2 + 2) * 4 + 0xf;
puVar12 = auStack_58;
puVar2 = auStack_58;
while (puVar12 != auStack_58 + -(uVar10 & 0xfffffffffffff000)) {
puVar11 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar12 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar10 = (ulong)((uint)uVar10 & 0xff0);
lVar1 = -uVar10;
piVar5 = (int *)(puVar11 + lVar1);
if (uVar10 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
uVar10 = (ulong)(param_1 - 1U);
local_50 = (ulong)(puVar11 + lVar1 + 3) >> 2;
if (param_1 < 1) {
*(int4 *)(local_50 * 4) = 0;
if (-1 < (int)(param_1 - 1U)) {
param_1 = 0;
iVar9 = 1;
goto LAB_0010148c;
}
*(int4 *)(local_50 * 4 + 4) = 0;
param_1 = 2;
}
else {
piVar8 = param_2 + uVar10 + 1;
do {
piVar4 = piVar8 + (-1 - uVar10);
iVar9 = 0;
do {
iVar9 = iVar9 + *piVar4;
piVar4 = piVar4 + 1;
} while (piVar4 != piVar8);
*piVar5 = iVar9;
piVar5 = piVar5 + 1;
piVar8 = piVar4 + uVar14;
} while (piVar5 != (int *)(puVar11 + uVar10 * 4 + lVar1 + 4));
piVar5 = (int *)(puVar11 + uVar14 * 4 + lVar1);
piVar8 = param_2;
do {
iVar7 = 0;
piVar4 = piVar8;
iVar9 = 0;
do {
iVar3 = iVar9;
iVar9 = iVar3 + 1;
iVar7 = iVar7 + *piVar4;
piVar4 = piVar4 + uVar14;
} while (param_1 != iVar9);
piVar8 = piVar8 + 1;
*piVar5 = iVar7;
piVar5 = piVar5 + 1;
} while (piVar8 != param_2 + uVar10 + 1);
param_1 = param_1 * 2;
iVar7 = 0;
piVar5 = param_2;
iVar9 = 0;
do {
iVar7 = iVar7 + *piVar5;
piVar5 = piVar5 + uVar14 + 1;
bVar15 = iVar3 != iVar9;
iVar9 = iVar9 + 1;
} while (bVar15);
iVar9 = param_1 + 1;
*(int *)(puVar11 + (long)param_1 * 4 + lVar1) = iVar7;
LAB_0010148c:
iVar7 = 0;
param_2 = param_2 + uVar14 * uVar14;
do {
uVar13 = (int)uVar10 - 1;
uVar10 = (ulong)uVar13;
iVar7 = iVar7 + param_2[-1];
param_2 = param_2 + ~uVar14;
} while (uVar13 != 0xffffffff);
param_1 = param_1 + 2;
*(int *)(puVar11 + (long)iVar9 * 4 + lVar1) = iVar7;
if (param_1 < 2) goto LAB_0010150d;
}
piVar5 = (int *)(puVar11 + lVar1 + 4);
do {
if (*piVar5 != *(int *)(local_50 * 4)) {
uVar6 = 0;
goto LAB_001014ef;
}
piVar5 = piVar5 + 1;
} while ((int *)(puVar11 + (ulong)(param_1 - 2) * 4 + lVar1 + 8) != piVar5);
LAB_0010150d:
uVar6 = 1;
LAB_001014ef:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar11 + lVar1 + -8) = 0x101559;
__stack_chk_fail();
}
return uVar6;
} |
4,411 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of columns
for(int j = 0; j < size; j++) {
int sum = 0;
for(int i = 0; i < size; i++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
// Sum of main diagonal
int result1 = 0;
for(int i = 0; i < size; i++) {
result1 += my_matrix[i][i];
}
sum_list[index++] = result1;
// Sum of secondary diagonal
int result2 = 0;
for(int i = size - 1; i >= 0; i--) {
result2 += my_matrix[i][i];
}
sum_list[index++] = result2;
// Check if all sums are equal
for(int k = 1; k < index; k++) {
if(sum_list[k] != sum_list[0]) {
return false;
}
}
return true;
}
| int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 7}
};
assert(func0(4, matrix1) == true);
assert(func0(3, matrix2) == true);
assert(func0(3, matrix3) == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rsi,-0x48(%rbp)
mov %rsp,%rbx
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %edi,%rax
mov %rax,-0x50(%rbp)
lea 0x2(%rdi,%rdi,1),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 132d <func0+0x6d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1318 <func0+0x58>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1540 <func0+0x280>
lea 0x3(%rsp),%r15
lea -0x1(%rdi),%r8d
mov %r15,%rax
and $0xfffffffffffffffc,%r15
shr $0x2,%rax
mov %rax,-0x60(%rbp)
test %edi,%edi
jle 154b <func0+0x28b>
mov -0x50(%rbp),%rax
mov -0x48(%rbp),%rsi
mov %edi,%r13d
mov %edi,%ebx
shr $0x2,%r13d
mov %r15,%r9
and $0xfffffffc,%ebx
lea 0x0(,%rax,4),%rdx
mov %r8d,%eax
mov %rsi,%r11
shl $0x4,%r13
shl $0x2,%rax
mov %rax,-0x58(%rbp)
lea 0x4(%r15,%rax,1),%r14
nopl (%rax)
cmp $0x3,%r8d
jbe 1530 <func0+0x270>
lea 0x0(%r13,%rsi,1),%rcx
mov %rsi,%rax
pxor %xmm0,%xmm0
xchg %ax,%ax
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rcx,%rax
jne 13b0 <func0+0xf0>
movdqa %xmm0,%xmm1
mov %ebx,%ecx
psrldq $0x8,%xmm1
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %edi,%ebx
je 1414 <func0+0x154>
movslq %ecx,%r10
lea 0x1(%rcx),%r12d
lea (%rsi,%r10,4),%r10
add (%r10),%eax
cmp %r12d,%edi
jle 1414 <func0+0x154>
lea 0x2(%rcx),%r12d
add 0x4(%r10),%eax
cmp %r12d,%edi
jle 1414 <func0+0x154>
add $0x3,%ecx
add 0x8(%r10),%eax
cmp %ecx,%edi
jle 1414 <func0+0x154>
add 0xc(%r10),%eax
mov %eax,(%r9)
add $0x4,%r9
add %rdx,%rsi
cmp %r14,%r9
jne 1398 <func0+0xd8>
mov -0x48(%rbp),%r10
mov -0x58(%rbp),%rax
lea (%r15,%rdx,1),%rbx
lea 0x4(%r10,%rax,1),%r12
nopl 0x0(%rax,%rax,1)
mov %r10,%rcx
xor %esi,%esi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov %eax,%r9d
lea 0x1(%rax),%eax
add (%rcx),%esi
add %rdx,%rcx
cmp %eax,%edi
jne 1450 <func0+0x190>
add $0x4,%r10
mov %esi,(%rbx)
add $0x4,%rbx
cmp %r12,%r10
jne 1440 <func0+0x180>
add %edi,%edi
add $0x4,%rdx
xor %eax,%eax
xor %ecx,%ecx
mov %edi,%esi
nopw 0x0(%rax,%rax,1)
mov %eax,%r10d
add (%r11),%ecx
add $0x1,%eax
add %rdx,%r11
cmp %r10d,%r9d
jne 1480 <func0+0x1c0>
lea 0x1(%rdi),%r9d
movslq %edi,%rdi
mov %ecx,(%r15,%rdi,4)
mov -0x50(%rbp),%rbx
movslq %r8d,%rax
xor %edx,%edx
add $0x1,%rax
imul %rbx,%rax
mov %rbx,%rcx
mov -0x48(%rbp),%rbx
not %rcx
shl $0x2,%rcx
lea (%rbx,%rax,4),%rax
sub $0x1,%r8d
add -0x4(%rax),%edx
add %rcx,%rax
cmp $0xffffffff,%r8d
jne 14c0 <func0+0x200>
movslq %r9d,%r9
add $0x2,%esi
mov %edx,(%r15,%r9,4)
cmp $0x1,%esi
jle 1539 <func0+0x279>
mov -0x60(%rbp),%rax
lea -0x2(%rsi),%ecx
lea 0x8(%r15,%rcx,4),%rcx
mov 0x0(,%rax,4),%edx
lea 0x4(%r15),%rax
jmp 1509 <func0+0x249>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rcx,%rax
je 1539 <func0+0x279>
cmp %edx,(%rax)
je 1500 <func0+0x240>
xor %eax,%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 157d <func0+0x2bd>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl (%rax)
xor %eax,%eax
xor %ecx,%ecx
jmpq 13e5 <func0+0x125>
mov $0x1,%eax
jmp 150f <func0+0x24f>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 133f <func0+0x7f>
movl $0x0,0x0(,%rax,4)
test %r8d,%r8d
jns 1570 <func0+0x2b0>
movl $0x0,0x4(,%rax,4)
mov $0x2,%esi
jmpq 14df <func0+0x21f>
xor %esi,%esi
mov $0x1,%r9d
jmpq 149c <func0+0x1dc>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov r10, rsi
mov rbp, rsp
push r15
movsxd r15, edi
push r14
mov rax, r15
push r13
push r12
push rbx
sub rsp, 38h
mov rdx, fs:28h
mov [rbp+var_38], rdx
xor edx, edx
lea edx, [r15+r15+2]
mov rsi, rsp
movsxd rdx, edx
lea rdx, ds:0Fh[rdx*4]
mov rcx, rdx
and rdx, 0FFFFFFFFFFFFF000h
sub rsi, rdx
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_132B
loc_1316:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rsi
jnz short loc_1316
loc_132B:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_1533
loc_133D:
lea r9, [rsp+1060h+var_105D]
mov rdi, r9
and r9, 0FFFFFFFFFFFFFFFCh
shr rdi, 2
test eax, eax
jle loc_153E
mov r11d, eax
mov [rbp+var_48], r15
mov r14d, eax
mov r12d, eax
mov [rbp+var_50], r10
shr r11d, 2
mov rcx, r9
lea ebx, [rax-1]
mov [rbp+var_58], r10
shl r11, 4
and r14d, 0FFFFFFFCh
mov rsi, r10
lea rdx, ds:0[r15*4]
and r12d, 3
lea r13, [r9+rdx]
nop
loc_1390:
cmp ebx, 2
jbe loc_1520
lea r10, [r11+rsi]
mov r8, rsi
pxor xmm0, xmm0
nop dword ptr [rax+00h]
loc_13A8:
movdqu xmm2, xmmword ptr [r8]
add r8, 10h
paddd xmm0, xmm2
cmp r8, r10
jnz short loc_13A8
movdqa xmm1, xmm0
mov r8d, r14d
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
test r12d, r12d
jz short loc_1412
loc_13DC:
movsxd r10, r8d
lea r15d, [r8+1]
lea r10, [rsi+r10*4]
movd xmm1, dword ptr [r10]
paddd xmm0, xmm1
cmp eax, r15d
jle short loc_1412
movd xmm1, dword ptr [r10+4]
add r8d, 2
paddd xmm0, xmm1
cmp eax, r8d
jle short loc_1412
movd xmm1, dword ptr [r10+8]
paddd xmm0, xmm1
loc_1412:
movd dword ptr [rcx], xmm0
add rcx, 4
add rsi, rdx
cmp rcx, r13
jnz loc_1390
mov r10, [rbp+var_58]
mov r15, [rbp+var_48]
mov r8, [rbp+var_50]
lea r14, [r10+rdx]
mov r13, r10
nop dword ptr [rax+00000000h]
loc_1440:
mov r11, r13
xor esi, esi
xor ebx, ebx
nop word ptr [rax+rax+00000000h]
loc_1450:
mov r12d, esi
add esi, 1
add ebx, [r11]
add r11, rdx
cmp eax, esi
jnz short loc_1450
add r13, 4
mov [rcx], ebx
add rcx, 4
cmp r13, r14
jnz short loc_1440
lea ecx, [rsi+rsi]
lea r13, [r15+1]
add rdx, 4
xor eax, eax
xor r11d, r11d
nop
loc_1480:
mov ebx, eax
add r11d, [r8]
add eax, 1
add r8, rdx
cmp r12d, ebx
jnz short loc_1480
movsxd rsi, esi
movsxd rax, ecx
neg r13
xor edx, edx
imul rsi, r15
mov [r9+rax*4], r11d
lea r8d, [rcx+1]
lea r11, ds:0[r13*4]
lea rax, [r10+rsi*4-4]
nop dword ptr [rax+00h]
loc_14B8:
sub r12d, 1
add edx, [rax]
add rax, r11
cmp r12d, 0FFFFFFFFh
jnz short loc_14B8
movsxd r8, r8d
add ecx, 2
mov [r9+r8*4], edx
cmp ecx, 1
jle short loc_152C
loc_14D6:
sub ecx, 2
mov edx, ds:dword_0[rdi*4]
lea rax, [r9+4]
lea rcx, [r9+rcx*4+8]
jmp short loc_14F9
loc_14F0:
add rax, 4
cmp rcx, rax
jz short loc_152C
loc_14F9:
cmp [rax], edx
jz short loc_14F0
xor eax, eax
loc_14FF:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1551
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1520:
xor r8d, r8d
pxor xmm0, xmm0
jmp loc_13DC
loc_152C:
mov eax, 1
jmp short loc_14FF
loc_1533:
or [rsp+rcx+1060h+var_1068], 0
jmp loc_133D
loc_153E:
mov qword ptr ds:dword_0[rdi*4], 0
mov ecx, 2
jmp short loc_14D6
loc_1551:
call ___stack_chk_fail | long long func0(int a1, const __m128i *a2)
{
long long v3; // rcx
long long *v4; // rsi
__int16 v5; // cx
signed long long v6; // rcx
void *v7; // rsp
_QWORD *v8; // rcx
const __m128i *v9; // rsi
long long v10; // rdx
const __m128i *v11; // r8
__m128i v12; // xmm0
__m128i v13; // xmm2
signed int v14; // r8d
__m128i v15; // xmm0
__m128i v16; // xmm0
unsigned int *v17; // r10
const __m128i *v18; // r10
long long v19; // r15
const __m128i *v20; // r8
__int32 *v21; // r14
const __m128i *v22; // r13
const __m128i *v23; // r11
int v24; // esi
int v25; // ebx
int v26; // r12d
int v27; // ecx
long long v28; // rdx
int v29; // eax
int v30; // r11d
int v31; // ebx
int v32; // edx
int v33; // r8d
__int32 *v34; // rax
int v35; // ecx
_DWORD *v36; // rax
char *v37; // rcx
_QWORD v40[511]; // [rsp+8h] [rbp-1060h] BYREF
long long v41; // [rsp+1008h] [rbp-60h] BYREF
const __m128i *v42; // [rsp+1010h] [rbp-58h]
const __m128i *v43; // [rsp+1018h] [rbp-50h]
long long v44; // [rsp+1020h] [rbp-48h]
unsigned long long v45; // [rsp+1030h] [rbp-38h]
v45 = __readfsqword(0x28u);
v3 = 4LL * (2 * a1 + 2) + 15;
v4 = (long long *)((char *)&v41 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( &v41 != v4 )
{
while ( v40 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(_QWORD *)((char *)&v40[-1] + v6) = *(_QWORD *)((char *)&v40[-1] + v6);
if ( a1 > 0 )
{
v44 = a1;
v43 = a2;
v8 = v40;
v42 = a2;
v9 = a2;
v10 = 4LL * a1;
while ( (unsigned int)(a1 - 1) > 2 )
{
v11 = v9;
v12 = 0LL;
do
{
v13 = _mm_loadu_si128(v11++);
v12 = _mm_add_epi32(v12, v13);
}
while ( v11 != &v9[(unsigned int)a1 >> 2] );
v14 = a1 & 0xFFFFFFFC;
v15 = _mm_add_epi32(v12, _mm_srli_si128(v12, 8));
v16 = _mm_add_epi32(v15, _mm_srli_si128(v15, 4));
if ( (a1 & 3) != 0 )
goto LABEL_11;
LABEL_14:
*(_DWORD *)v8 = _mm_cvtsi128_si32(v16);
v8 = (_QWORD *)((char *)v8 + 4);
v9 = (const __m128i *)((char *)v9 + v10);
if ( v8 == (_QWORD *)((char *)v40 + 4 * a1) )
{
v18 = v42;
v19 = v44;
v20 = v43;
v21 = &v42->m128i_i32[(unsigned long long)v10 / 4];
v22 = v42;
do
{
v23 = v22;
v24 = 0;
v25 = 0;
do
{
v26 = v24++;
v25 += v23->m128i_i32[0];
v23 = (const __m128i *)((char *)v23 + v10);
}
while ( a1 != v24 );
v22 = (const __m128i *)((char *)v22 + 4);
*(_DWORD *)v8 = v25;
v8 = (_QWORD *)((char *)v8 + 4);
}
while ( v22 != (const __m128i *)v21 );
v27 = 2 * v24;
v28 = v10 + 4;
v29 = 0;
v30 = 0;
do
{
v31 = v29;
v30 += v20->m128i_i32[0];
++v29;
v20 = (const __m128i *)((char *)v20 + v28);
}
while ( v26 != v31 );
v32 = 0;
LODWORD(v40[v27 / 2u]) = v30;
v33 = v27 + 1;
v34 = &v18->m128i_i32[v19 * v24 - 1];
do
{
--v26;
v32 += *v34;
v34 += -v19 - 1;
}
while ( v26 != -1 );
v35 = v27 + 2;
*((_DWORD *)v40 + v33) = v32;
if ( v35 > 1 )
goto LABEL_24;
return 1LL;
}
}
v14 = 0;
v16 = 0LL;
LABEL_11:
v17 = (unsigned int *)v9 + v14;
v16 = _mm_add_epi32(v16, _mm_cvtsi32_si128(*v17));
if ( a1 > v14 + 1 )
{
v16 = _mm_add_epi32(v16, _mm_cvtsi32_si128(v17[1]));
if ( a1 > v14 + 2 )
v16 = _mm_add_epi32(v16, _mm_cvtsi32_si128(v17[2]));
}
goto LABEL_14;
}
v40[0] = 0LL;
v35 = 2;
LABEL_24:
v36 = (_DWORD *)v40 + 1;
v37 = (char *)&v40[1] + 4 * (unsigned int)(v35 - 2);
while ( *v36 == LODWORD(v40[0]) )
{
if ( v37 == (char *)++v36 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV R10,RSI
MOV RBP,RSP
PUSH R15
MOVSXD R15,EDI
PUSH R14
MOV RAX,R15
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RDX
XOR EDX,EDX
LEA EDX,[R15 + R15*0x1 + 0x2]
MOV RSI,RSP
MOVSXD RDX,EDX
LEA RDX,[0xf + RDX*0x4]
MOV RCX,RDX
AND RDX,-0x1000
SUB RSI,RDX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x0010132b
LAB_00101316:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x00101316
LAB_0010132b:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101533
LAB_0010133d:
LEA R9,[RSP + 0x3]
MOV RDI,R9
AND R9,-0x4
SHR RDI,0x2
TEST EAX,EAX
JLE 0x0010153e
MOV R11D,EAX
MOV qword ptr [RBP + -0x48],R15
MOV R14D,EAX
MOV R12D,EAX
MOV qword ptr [RBP + -0x50],R10
SHR R11D,0x2
MOV RCX,R9
LEA EBX,[RAX + -0x1]
MOV qword ptr [RBP + -0x58],R10
SHL R11,0x4
AND R14D,0xfffffffc
MOV RSI,R10
LEA RDX,[R15*0x4]
AND R12D,0x3
LEA R13,[R9 + RDX*0x1]
NOP
LAB_00101390:
CMP EBX,0x2
JBE 0x00101520
LEA R10,[R11 + RSI*0x1]
MOV R8,RSI
PXOR XMM0,XMM0
NOP dword ptr [RAX]
LAB_001013a8:
MOVDQU XMM2,xmmword ptr [R8]
ADD R8,0x10
PADDD XMM0,XMM2
CMP R8,R10
JNZ 0x001013a8
MOVDQA XMM1,XMM0
MOV R8D,R14D
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
TEST R12D,R12D
JZ 0x00101412
LAB_001013dc:
MOVSXD R10,R8D
LEA R15D,[R8 + 0x1]
LEA R10,[RSI + R10*0x4]
MOVD XMM1,dword ptr [R10]
PADDD XMM0,XMM1
CMP EAX,R15D
JLE 0x00101412
MOVD XMM1,dword ptr [R10 + 0x4]
ADD R8D,0x2
PADDD XMM0,XMM1
CMP EAX,R8D
JLE 0x00101412
MOVD XMM1,dword ptr [R10 + 0x8]
PADDD XMM0,XMM1
LAB_00101412:
MOVD dword ptr [RCX],XMM0
ADD RCX,0x4
ADD RSI,RDX
CMP RCX,R13
JNZ 0x00101390
MOV R10,qword ptr [RBP + -0x58]
MOV R15,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x50]
LEA R14,[R10 + RDX*0x1]
MOV R13,R10
NOP dword ptr [RAX]
LAB_00101440:
MOV R11,R13
XOR ESI,ESI
XOR EBX,EBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV R12D,ESI
ADD ESI,0x1
ADD EBX,dword ptr [R11]
ADD R11,RDX
CMP EAX,ESI
JNZ 0x00101450
ADD R13,0x4
MOV dword ptr [RCX],EBX
ADD RCX,0x4
CMP R13,R14
JNZ 0x00101440
LEA ECX,[RSI + RSI*0x1]
LEA R13,[R15 + 0x1]
ADD RDX,0x4
XOR EAX,EAX
XOR R11D,R11D
NOP
LAB_00101480:
MOV EBX,EAX
ADD R11D,dword ptr [R8]
ADD EAX,0x1
ADD R8,RDX
CMP R12D,EBX
JNZ 0x00101480
MOVSXD RSI,ESI
MOVSXD RAX,ECX
NEG R13
XOR EDX,EDX
IMUL RSI,R15
MOV dword ptr [R9 + RAX*0x4],R11D
LEA R8D,[RCX + 0x1]
LEA R11,[R13*0x4]
LEA RAX,[R10 + RSI*0x4 + -0x4]
NOP dword ptr [RAX]
LAB_001014b8:
SUB R12D,0x1
ADD EDX,dword ptr [RAX]
ADD RAX,R11
CMP R12D,-0x1
JNZ 0x001014b8
MOVSXD R8,R8D
ADD ECX,0x2
MOV dword ptr [R9 + R8*0x4],EDX
CMP ECX,0x1
JLE 0x0010152c
LAB_001014d6:
SUB ECX,0x2
MOV EDX,dword ptr [RDI*0x4]
LEA RAX,[R9 + 0x4]
LEA RCX,[R9 + RCX*0x4 + 0x8]
JMP 0x001014f9
LAB_001014f0:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x0010152c
LAB_001014f9:
CMP dword ptr [RAX],EDX
JZ 0x001014f0
XOR EAX,EAX
LAB_001014ff:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101551
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101520:
XOR R8D,R8D
PXOR XMM0,XMM0
JMP 0x001013dc
LAB_0010152c:
MOV EAX,0x1
JMP 0x001014ff
LAB_00101533:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x0010133d
LAB_0010153e:
MOV qword ptr [RDI*0x4],0x0
MOV ECX,0x2
JMP 0x001014d6
LAB_00101551:
CALL 0x00101060 | int8 func0(uint param_1,int *param_2)
{
long lVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *puVar6;
uint uVar7;
int *piVar8;
int8 uVar9;
ulong uVar10;
int *puVar11;
uint uVar13;
int *piVar14;
int *piVar15;
uint uVar16;
long lVar17;
long in_FS_OFFSET;
bool bVar18;
int iVar19;
int iVar20;
int iVar21;
int iVar22;
int auStack_68 [8];
int *local_60;
int *local_58;
long local_50;
long local_40;
int *puVar12;
lVar17 = (long)(int)param_1;
puVar11 = auStack_68;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar10 = (long)(int)(param_1 * 2 + 2) * 4 + 0xf;
puVar12 = auStack_68;
puVar6 = auStack_68;
while (puVar12 != auStack_68 + -(uVar10 & 0xfffffffffffff000)) {
puVar11 = puVar6 + -0x1000;
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
puVar12 = puVar6 + -0x1000;
puVar6 = puVar6 + -0x1000;
}
uVar10 = (ulong)((uint)uVar10 & 0xff0);
lVar1 = -uVar10;
piVar8 = (int *)(puVar11 + lVar1);
if (uVar10 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
if ((int)param_1 < 1) {
*(int8 *)(((ulong)(puVar11 + lVar1 + 3) >> 2) * 4) = 0;
iVar19 = 2;
}
else {
piVar14 = param_2;
do {
if (param_1 - 1 < 3) {
uVar13 = 0;
iVar19 = 0;
LAB_001013dc:
piVar15 = piVar14 + (int)uVar13;
iVar19 = iVar19 + *piVar15;
if (((int)(uVar13 + 1) < (int)param_1) &&
(iVar19 = iVar19 + piVar15[1], (int)(uVar13 + 2) < (int)param_1)) {
iVar19 = iVar19 + piVar15[2];
}
}
else {
iVar19 = 0;
iVar20 = 0;
iVar21 = 0;
iVar22 = 0;
piVar15 = piVar14;
do {
iVar2 = *piVar15;
piVar3 = piVar15 + 1;
piVar4 = piVar15 + 2;
piVar5 = piVar15 + 3;
piVar15 = piVar15 + 4;
iVar19 = iVar19 + iVar2;
iVar20 = iVar20 + *piVar3;
iVar21 = iVar21 + *piVar4;
iVar22 = iVar22 + *piVar5;
} while (piVar15 != piVar14 + (ulong)(param_1 >> 2) * 4);
iVar19 = iVar19 + iVar21 + iVar20 + iVar22;
uVar13 = param_1 & 0xfffffffc;
if ((param_1 & 3) != 0) goto LAB_001013dc;
}
*piVar8 = iVar19;
piVar8 = piVar8 + 1;
piVar14 = piVar14 + lVar17;
} while (piVar8 != (int *)(puVar11 + lVar17 * 4 + lVar1));
piVar14 = param_2;
do {
iVar19 = 0;
piVar15 = piVar14;
uVar13 = 0;
do {
uVar16 = uVar13;
uVar13 = uVar16 + 1;
iVar19 = iVar19 + *piVar15;
piVar15 = piVar15 + lVar17;
} while (param_1 != uVar13);
piVar14 = piVar14 + 1;
*piVar8 = iVar19;
piVar8 = piVar8 + 1;
} while (piVar14 != param_2 + lVar17);
iVar20 = uVar13 * 2;
iVar19 = 0;
piVar8 = param_2;
uVar7 = 0;
do {
iVar19 = iVar19 + *piVar8;
piVar8 = piVar8 + lVar17 + 1;
bVar18 = uVar16 != uVar7;
uVar7 = uVar7 + 1;
} while (bVar18);
iVar21 = 0;
*(int *)(puVar11 + (long)iVar20 * 4 + lVar1) = iVar19;
piVar8 = param_2 + (int)uVar13 * lVar17 + -1;
do {
uVar16 = uVar16 - 1;
iVar21 = iVar21 + *piVar8;
piVar8 = piVar8 + -(lVar17 + 1);
} while (uVar16 != 0xffffffff);
iVar19 = iVar20 + 2;
*(int *)(puVar11 + (long)(iVar20 + 1) * 4 + lVar1) = iVar21;
local_60 = param_2;
local_58 = param_2;
local_50 = lVar17;
if (iVar19 < 2) goto LAB_0010152c;
}
piVar8 = (int *)(puVar11 + lVar1 + 4);
do {
if (*piVar8 != *(int *)(((ulong)(puVar11 + lVar1 + 3) >> 2) * 4)) {
uVar9 = 0;
goto LAB_001014ff;
}
piVar8 = piVar8 + 1;
} while ((int *)(puVar11 + (ulong)(iVar19 - 2) * 4 + lVar1 + 8) != piVar8);
LAB_0010152c:
uVar9 = 1;
LAB_001014ff:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar11 + lVar1 + -8) = 0x101556;
__stack_chk_fail();
}
return uVar9;
} |
4,412 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found = 1;
break;
}
}
if(!found){
keys[unique] = num;
counts[unique] = 1;
unique++;
}
}
int max_index = 0;
for(int i = 1; i < unique; i++) {
if(counts[i] > counts[max_index]) {
max_index = i;
}
}
static int result[2];
result[0] = keys[max_index];
result[1] = counts[max_index];
return result;
}
| int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2)/sizeof(nums2[0]);
result = func0(nums2, size2);
assert(result[0]== 8 && result[1] == 2);
int nums3[] = {10,20,20,30,40,90,80,50,30,20,50,10};
int size3 = sizeof(nums3)/sizeof(nums3[0]);
result = func0(nums3, size3);
assert(result[0] == 20 && result[1] == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x68,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x48(%rbp)
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 120d <func0+0xa4>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f6 <func0+0x8d>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1237 <func0+0xce>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x38(%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 12c0 <func0+0x157>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12a9 <func0+0x140>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12ea <func0+0x181>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x30(%rbp)
movl $0x0,-0x50(%rbp)
movl $0x0,-0x54(%rbp)
jmpq 13ac <func0+0x243>
mov -0x54(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4c(%rbp)
movl $0x0,-0x58(%rbp)
movl $0x0,-0x5c(%rbp)
jmp 1375 <func0+0x20c>
mov -0x40(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,-0x4c(%rbp)
jne 1371 <func0+0x208>
mov -0x30(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea 0x1(%rax),%ecx
mov -0x30(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
movl $0x1,-0x58(%rbp)
jmp 137d <func0+0x214>
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x50(%rbp),%eax
jl 1339 <func0+0x1d0>
cmpl $0x0,-0x58(%rbp)
jne 13a8 <func0+0x23f>
mov -0x40(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov -0x4c(%rbp),%ecx
mov %ecx,(%rax,%rdx,4)
mov -0x30(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
movl $0x1,(%rax,%rdx,4)
addl $0x1,-0x50(%rbp)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 1310 <func0+0x1a7>
movl $0x0,-0x60(%rbp)
movl $0x1,-0x64(%rbp)
jmp 13f0 <func0+0x287>
mov -0x30(%rbp),%rax
mov -0x64(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x30(%rbp),%rax
mov -0x60(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jle 13ec <func0+0x283>
mov -0x64(%rbp),%eax
mov %eax,-0x60(%rbp)
addl $0x1,-0x64(%rbp)
mov -0x64(%rbp),%eax
cmp -0x50(%rbp),%eax
jl 13c8 <func0+0x25f>
mov -0x40(%rbp),%rax
mov -0x60(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,0x2c0d(%rip)
mov -0x30(%rbp),%rax
mov -0x60(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,0x2bfe(%rip)
lea 0x2bf3(%rip),%rax
mov %rsi,%rsp
mov -0x28(%rbp),%rsi
xor %fs:0x28,%rsi
je 143c <func0+0x2d3>
callq 1060 <__stack_chk_fail@plt>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_5C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D6:
cmp rsp, rdx
jz short loc_11ED
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_11D6
loc_11ED:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1217
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1217:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov eax, [rbp+var_5C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_126F:
cmp rsp, rdx
jz short loc_1286
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_126F
loc_1286:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12B0
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12B0:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_44], 0
mov [rbp+var_40], 0
jmp loc_1372
loc_12D6:
mov eax, [rbp+var_40]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
mov [rbp+var_2C], eax
mov [rbp+var_3C], 0
mov [rbp+var_38], 0
jmp short loc_133B
loc_12FF:
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp [rbp+var_2C], eax
jnz short loc_1337
mov rax, [rbp+var_10]
mov edx, [rbp+var_38]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea ecx, [rax+1]
mov rax, [rbp+var_10]
mov edx, [rbp+var_38]
movsxd rdx, edx
mov [rax+rdx*4], ecx
mov [rbp+var_3C], 1
jmp short loc_1343
loc_1337:
add [rbp+var_38], 1
loc_133B:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_44]
jl short loc_12FF
loc_1343:
cmp [rbp+var_3C], 0
jnz short loc_136E
mov rax, [rbp+var_20]
mov edx, [rbp+var_44]
movsxd rdx, edx
mov ecx, [rbp+var_2C]
mov [rax+rdx*4], ecx
mov rax, [rbp+var_10]
mov edx, [rbp+var_44]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 1
add [rbp+var_44], 1
loc_136E:
add [rbp+var_40], 1
loc_1372:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_5C]
jl loc_12D6
mov [rbp+var_34], 0
mov [rbp+var_30], 1
jmp short loc_13B6
loc_138E:
mov rax, [rbp+var_10]
mov edx, [rbp+var_30]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jle short loc_13B2
mov eax, [rbp+var_30]
mov [rbp+var_34], eax
loc_13B2:
add [rbp+var_30], 1
loc_13B6:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_44]
jl short loc_138E
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov cs:result_1, eax
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov cs:dword_401C, eax
lea rax, result_1
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1402
call ___stack_chk_fail
locret_1402:
leave
retn | int * func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
unsigned long long v4; // rax
void *v5; // rsp
_BYTE v7[4]; // [rsp+8h] [rbp-60h] BYREF
int v8; // [rsp+Ch] [rbp-5Ch]
long long v9; // [rsp+10h] [rbp-58h]
int v10; // [rsp+24h] [rbp-44h]
int i; // [rsp+28h] [rbp-40h]
int v12; // [rsp+2Ch] [rbp-3Ch]
int j; // [rsp+30h] [rbp-38h]
int v14; // [rsp+34h] [rbp-34h]
int k; // [rsp+38h] [rbp-30h]
int v16; // [rsp+3Ch] [rbp-2Ch]
long long v17; // [rsp+40h] [rbp-28h]
_BYTE *v18; // [rsp+48h] [rbp-20h]
long long v19; // [rsp+50h] [rbp-18h]
_BYTE *v20; // [rsp+58h] [rbp-10h]
unsigned long long v21; // [rsp+60h] [rbp-8h]
v9 = a1;
v8 = a2;
v21 = __readfsqword(0x28u);
v17 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v7 != &v7[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v2 & 0xFFF) - 8] = *(_QWORD *)&v7[(v2 & 0xFFF) - 8];
v18 = v7;
v19 = v8 - 1LL;
v4 = 16 * ((4LL * v8 + 15) / 0x10uLL);
while ( v7 != &v7[-(v4 & 0xFFFFFFFFFFFFF000LL)] )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v4 & 0xFFF) - 8] = *(_QWORD *)&v7[(v4 & 0xFFF) - 8];
v20 = v7;
v10 = 0;
for ( i = 0; i < v8; ++i )
{
v16 = *(_DWORD *)(4LL * i + v9);
v12 = 0;
for ( j = 0; j < v10; ++j )
{
if ( v16 == *(_DWORD *)&v18[4 * j] )
{
++*(_DWORD *)&v20[4 * j];
v12 = 1;
break;
}
}
if ( !v12 )
{
*(_DWORD *)&v18[4 * v10] = v16;
*(_DWORD *)&v20[4 * v10++] = 1;
}
}
v14 = 0;
for ( k = 1; k < v10; ++k )
{
if ( *(_DWORD *)&v20[4 * k] > *(_DWORD *)&v20[4 * v14] )
v14 = k;
}
result_1 = *(_DWORD *)&v18[4 * v14];
dword_401C = *(_DWORD *)&v20[4 * v14];
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d6:
CMP RSP,RDX
JZ 0x001011ed
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d6
LAB_001011ed:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101217
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101217:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_0010126f:
CMP RSP,RDX
JZ 0x00101286
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x0010126f
LAB_00101286:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012b0
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012b0:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101372
LAB_001012d6:
MOV EAX,dword ptr [RBP + -0x40]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV dword ptr [RBP + -0x3c],0x0
MOV dword ptr [RBP + -0x38],0x0
JMP 0x0010133b
LAB_001012ff:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP dword ptr [RBP + -0x2c],EAX
JNZ 0x00101337
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA ECX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x00101343
LAB_00101337:
ADD dword ptr [RBP + -0x38],0x1
LAB_0010133b:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x001012ff
LAB_00101343:
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x0010136e
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX + RDX*0x4],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x1
ADD dword ptr [RBP + -0x44],0x1
LAB_0010136e:
ADD dword ptr [RBP + -0x40],0x1
LAB_00101372:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x001012d6
MOV dword ptr [RBP + -0x34],0x0
MOV dword ptr [RBP + -0x30],0x1
JMP 0x001013b6
LAB_0010138e:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JLE 0x001013b2
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x34],EAX
LAB_001013b2:
ADD dword ptr [RBP + -0x30],0x1
LAB_001013b6:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x0010138e
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [0x00104018],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [0x0010401c],EAX
LEA RAX,[0x104018]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101402
CALL 0x00101060
LAB_00101402:
LEAVE
RET | int8 * func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_68 [4];
int local_64;
long local_60;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
int *local_28;
long local_20;
int *local_18;
long local_10;
local_60 = param_1;
local_64 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = (long)param_2 + -1;
uVar2 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_68; puVar3 != auStack_68 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
puVar4 = puVar3 + lVar1;
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
local_28 = puVar3 + lVar1;
local_20 = (long)local_64 + -1;
uVar2 = (((long)local_64 * 4 + 0xfU) / 0x10) * 0x10;
for (; puVar4 != puVar3 + (lVar1 - (uVar2 & 0xfffffffffffff000)); puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
local_4c = 0;
local_48 = 0;
do {
if (local_64 <= local_48) {
local_3c = 0;
for (local_38 = 1; local_38 < local_4c; local_38 = local_38 + 1) {
if (*(int *)(puVar4 + (long)local_3c * 4 + lVar1) <
*(int *)(puVar4 + (long)local_38 * 4 + lVar1)) {
local_3c = local_38;
}
}
result_1._0_4_ = *(int4 *)(local_28 + (long)local_3c * 4);
result_1._4_4_ = *(int4 *)(puVar4 + (long)local_3c * 4 + lVar1);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar4 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &result_1;
}
local_34 = *(int *)(local_60 + (long)local_48 * 4);
local_44 = 0;
for (local_40 = 0; local_40 < local_4c; local_40 = local_40 + 1) {
if (local_34 == *(int *)(local_28 + (long)local_40 * 4)) {
*(int *)(puVar4 + (long)local_40 * 4 + lVar1) =
*(int *)(puVar4 + (long)local_40 * 4 + lVar1) + 1;
local_44 = 1;
break;
}
}
if (local_44 == 0) {
*(int *)(local_28 + (long)local_4c * 4) = local_34;
*(int4 *)(puVar4 + (long)local_4c * 4 + lVar1) = 1;
local_4c = local_4c + 1;
}
local_48 = local_48 + 1;
} while( true );
} |
4,413 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found = 1;
break;
}
}
if(!found){
keys[unique] = num;
counts[unique] = 1;
unique++;
}
}
int max_index = 0;
for(int i = 1; i < unique; i++) {
if(counts[i] > counts[max_index]) {
max_index = i;
}
}
static int result[2];
result[0] = keys[max_index];
result[1] = counts[max_index];
return result;
}
| int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2)/sizeof(nums2[0]);
result = func0(nums2, size2);
assert(result[0]== 8 && result[1] == 2);
int nums3[] = {10,20,20,30,40,90,80,50,30,20,50,10};
int size3 = sizeof(nums3)/sizeof(nums3[0]);
result = func0(nums3, size3);
assert(result[0] == 20 && result[1] == 3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%rax
shl $0x2,%rax
lea 0xf(%rax),%rdx
mov %rdx,%rcx
and $0xfffffffffffffff0,%rcx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 11c2 <func0+0x59>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ab <func0+0x42>
mov %rcx,%rdx
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
je 11d9 <func0+0x70>
orq $0x0,-0x8(%rsp,%rdx,1)
mov %rsp,%r10
mov %r10,%r8
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 1210 <func0+0xa7>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f9 <func0+0x90>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1226 <func0+0xbd>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r11
mov %r11,%rbx
test %esi,%esi
jle 12f3 <func0+0x18a>
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r12
mov $0x0,%edi
mov $0x0,%r13d
jmp 1278 <func0+0x10f>
mov %rdx,%rax
cmp %ecx,(%r8,%rax,4)
je 1287 <func0+0x11e>
lea 0x1(%rax),%rdx
cmp %rsi,%rax
jne 124c <func0+0xe3>
movslq %edi,%rax
mov %ecx,(%r8,%rax,4)
movl $0x1,(%rbx,%rax,4)
add $0x1,%edi
add $0x4,%r9
cmp %r12,%r9
je 1290 <func0+0x127>
mov (%r9),%ecx
test %edi,%edi
jle 125e <func0+0xf5>
lea -0x1(%rdi),%esi
mov %r13,%rax
jmp 124f <func0+0xe6>
movslq %eax,%rdx
addl $0x1,(%rbx,%rdx,4)
jmp 126f <func0+0x106>
cmp $0x1,%edi
jle 12fa <func0+0x191>
lea -0x2(%rdi),%esi
add $0x2,%rsi
mov $0x1,%eax
mov $0x0,%edx
movslq %edx,%rcx
mov (%rbx,%rcx,4),%edi
cmp %edi,(%rbx,%rax,4)
cmovg %eax,%edx
add $0x1,%rax
cmp %rsi,%rax
jne 12a6 <func0+0x13d>
movslq %edx,%rdx
mov (%r10,%rdx,4),%eax
mov %eax,0x2d50(%rip)
mov (%r11,%rdx,4),%eax
mov %eax,0x2d4a(%rip)
mov -0x28(%rbp),%rax
xor %fs:0x28,%rax
jne 1301 <func0+0x198>
lea 0x2d30(%rip),%rax
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
mov $0x0,%edx
jmp 12bb <func0+0x152>
mov $0x0,%edx
jmp 12bb <func0+0x152>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov ecx, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
shl rax, 2
lea rdx, [rax+0Fh]
mov r8, rdx
and r8, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rsi, rsp
sub rsi, rdx
loc_11A5:
cmp rsp, rsi
jz short loc_11BC
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11A5
loc_11BC:
mov rdx, r8
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jz short loc_11D3
or [rsp+rdx+10h+var_18], 0
loc_11D3:
mov rsi, rsp
add rax, 0Fh
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov r8, rsp
sub r8, rax
loc_11ED:
cmp rsp, r8
jz short loc_1204
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11ED
loc_1204:
mov rax, rdx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_121A
or [rsp+rax+10h+var_18], 0
loc_121A:
mov r10, rsp
test ecx, ecx
jle loc_12D5
mov r9, rdi
lea eax, [rcx-1]
lea r11, [rdi+rax*4+4]
mov r8d, 0
jmp short loc_125D
loc_1238:
movsxd rdx, eax
add dword ptr [r10+rdx*4], 1
jmp short loc_1254
loc_1242:
movsxd rax, r8d
mov [rsi+rax*4], ecx
mov dword ptr [r10+rax*4], 1
add r8d, 1
loc_1254:
add r9, 4
cmp r9, r11
jz short loc_127D
loc_125D:
mov ecx, [r9]
test r8d, r8d
jle short loc_1242
mov edi, r8d
mov eax, 0
loc_126D:
cmp [rsi+rax*4], ecx
jz short loc_1238
add rax, 1
cmp rax, rdi
jnz short loc_126D
jmp short loc_1242
loc_127D:
cmp r8d, 1
jle short loc_12DC
mov r8d, r8d
mov eax, 1
mov edx, 0
loc_1290:
movsxd rcx, edx
mov edi, [r10+rcx*4]
cmp [r10+rax*4], edi
cmovg edx, eax
add rax, 1
cmp rax, r8
jnz short loc_1290
loc_12A7:
movsxd rdx, edx
mov eax, [rsi+rdx*4]
mov cs:result_1, eax
mov eax, [r10+rdx*4]
mov cs:dword_401C, eax
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_12E3
lea rax, result_1
leave
retn
loc_12D5:
mov edx, 0
jmp short loc_12A7
loc_12DC:
mov edx, 0
jmp short loc_12A7
loc_12E3:
call ___stack_chk_fail | int * func0(int *a1, int a2)
{
long long v2; // rax
signed long long v3; // rdx
void *v4; // rsp
long long v5; // rax
__int16 v6; // dx
signed long long v7; // rax
void *v8; // rsp
int *v9; // r9
int v10; // r8d
int v11; // ecx
long long v12; // rax
long long v13; // rax
int v14; // edx
_DWORD v17[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v18; // [rsp+10h] [rbp-8h]
v18 = __readfsqword(0x28u);
v2 = 4LL * a2;
while ( v17 != (_DWORD *)((char *)v17 - ((v2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v3 = ((_WORD)v2 + 15) & 0xFF0;
v4 = alloca(v3);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v17[-2] + v3) = *(_QWORD *)((char *)&v17[-2] + v3);
v5 = v2 + 15;
v6 = v5 & 0xFFF0;
while ( v17 != (_DWORD *)((char *)v17 - (v5 & 0xFFFFFFFFFFFFF000LL)) )
;
v7 = v5 & 0xFF0;
v8 = alloca(v7);
if ( (v6 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v17[-2] + v7) = *(_QWORD *)((char *)&v17[-2] + v7);
if ( a2 <= 0 )
{
v14 = 0;
}
else
{
v9 = a1;
v10 = 0;
do
{
v11 = *v9;
if ( v10 <= 0 )
{
LABEL_12:
v17[v10] = v11;
v17[v10++] = 1;
}
else
{
v12 = 0LL;
while ( v17[v12] != v11 )
{
if ( ++v12 == v10 )
goto LABEL_12;
}
++v17[(int)v12];
}
++v9;
}
while ( v9 != &a1[a2 - 1 + 1] );
if ( v10 <= 1 )
{
v14 = 0;
}
else
{
v13 = 1LL;
v14 = 0;
do
{
if ( v17[v13] > v17[v14] )
v14 = v13;
++v13;
}
while ( v13 != v10 );
}
}
result_1 = v17[v14];
dword_401C = v17[v14];
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ECX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
SHL RAX,0x2
LEA RDX,[RAX + 0xf]
MOV R8,RDX
AND R8,-0x10
AND RDX,-0x1000
MOV RSI,RSP
SUB RSI,RDX
LAB_001011a5:
CMP RSP,RSI
JZ 0x001011bc
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011a5
LAB_001011bc:
MOV RDX,R8
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JZ 0x001011d3
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
LAB_001011d3:
MOV RSI,RSP
ADD RAX,0xf
MOV RDX,RAX
AND RDX,-0x10
AND RAX,-0x1000
MOV R8,RSP
SUB R8,RAX
LAB_001011ed:
CMP RSP,R8
JZ 0x00101204
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ed
LAB_00101204:
MOV RAX,RDX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x0010121a
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_0010121a:
MOV R10,RSP
TEST ECX,ECX
JLE 0x001012d5
MOV R9,RDI
LEA EAX,[RCX + -0x1]
LEA R11,[RDI + RAX*0x4 + 0x4]
MOV R8D,0x0
JMP 0x0010125d
LAB_00101238:
MOVSXD RDX,EAX
ADD dword ptr [R10 + RDX*0x4],0x1
JMP 0x00101254
LAB_00101242:
MOVSXD RAX,R8D
MOV dword ptr [RSI + RAX*0x4],ECX
MOV dword ptr [R10 + RAX*0x4],0x1
ADD R8D,0x1
LAB_00101254:
ADD R9,0x4
CMP R9,R11
JZ 0x0010127d
LAB_0010125d:
MOV ECX,dword ptr [R9]
TEST R8D,R8D
JLE 0x00101242
MOV EDI,R8D
MOV EAX,0x0
LAB_0010126d:
CMP dword ptr [RSI + RAX*0x4],ECX
JZ 0x00101238
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x0010126d
JMP 0x00101242
LAB_0010127d:
CMP R8D,0x1
JLE 0x001012dc
MOV R8D,R8D
MOV EAX,0x1
MOV EDX,0x0
LAB_00101290:
MOVSXD RCX,EDX
MOV EDI,dword ptr [R10 + RCX*0x4]
CMP dword ptr [R10 + RAX*0x4],EDI
CMOVG EDX,EAX
ADD RAX,0x1
CMP RAX,R8
JNZ 0x00101290
LAB_001012a7:
MOVSXD RDX,EDX
MOV EAX,dword ptr [RSI + RDX*0x4]
MOV dword ptr [0x00104018],EAX
MOV EAX,dword ptr [R10 + RDX*0x4]
MOV dword ptr [0x0010401c],EAX
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012e3
LEA RAX,[0x104018]
LEAVE
RET
LAB_001012d5:
MOV EDX,0x0
JMP 0x001012a7
LAB_001012dc:
MOV EDX,0x0
JMP 0x001012a7
LAB_001012e3:
CALL 0x00101060 | int8 * func0(int *param_1,int param_2)
{
int *piVar1;
long lVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int1 *puVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)param_2 * 4 + 0xf;
for (puVar6 = auStack_18; puVar6 != auStack_18 + -(uVar4 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar2 = -uVar4;
puVar7 = puVar6 + lVar2;
if (uVar4 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar4 = (long)param_2 * 4 + 0xf;
for (; puVar7 != puVar6 + (lVar2 - (uVar4 & 0xfffffffffffff000)); puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar3 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (param_2 < 1) {
iVar8 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar4 = 0;
do {
iVar8 = (int)uVar4;
if (0 < iVar8) {
uVar5 = 0;
do {
if (*(int *)(puVar6 + uVar5 * 4 + lVar2) == *param_1) {
*(int *)(puVar7 + (long)(int)uVar5 * 4 + lVar3) =
*(int *)(puVar7 + (long)(int)uVar5 * 4 + lVar3) + 1;
goto LAB_00101254;
}
uVar5 = uVar5 + 1;
} while (uVar5 != uVar4);
}
*(int *)(puVar6 + (long)iVar8 * 4 + lVar2) = *param_1;
*(int4 *)(puVar7 + (long)iVar8 * 4 + lVar3) = 1;
uVar4 = (ulong)(iVar8 + 1);
LAB_00101254:
param_1 = param_1 + 1;
} while (param_1 != piVar1);
if ((int)uVar4 < 2) {
iVar8 = 0;
}
else {
uVar5 = 1;
iVar8 = 0;
do {
if (*(int *)(puVar7 + (long)iVar8 * 4 + lVar3) < *(int *)(puVar7 + uVar5 * 4 + lVar3)) {
iVar8 = (int)uVar5;
}
uVar5 = uVar5 + 1;
} while (uVar5 != uVar4);
}
}
result_1._0_4_ = *(int4 *)(puVar6 + (long)iVar8 * 4 + lVar2);
result_1._4_4_ = *(int4 *)(puVar7 + (long)iVar8 * 4 + lVar3);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar3 + -8) = main;
__stack_chk_fail();
}
return &result_1;
} |
4,414 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found = 1;
break;
}
}
if(!found){
keys[unique] = num;
counts[unique] = 1;
unique++;
}
}
int max_index = 0;
for(int i = 1; i < unique; i++) {
if(counts[i] > counts[max_index]) {
max_index = i;
}
}
static int result[2];
result[0] = keys[max_index];
result[1] = counts[max_index];
return result;
}
| int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2)/sizeof(nums2[0]);
result = func0(nums2, size2);
assert(result[0]== 8 && result[1] == 2);
int nums3[] = {10,20,20,30,40,90,80,50,30,20,50,10};
int size3 = sizeof(nums3)/sizeof(nums3[0]);
result = func0(nums3, size3);
assert(result[0] == 20 && result[1] == 3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movslq %esi,%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 144b <func0+0x5b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rcx,%rsp
jne 1436 <func0+0x46>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1572 <func0+0x182>
mov %rax,%rdx
mov %rsp,%rbx
and $0xfffffffffffff000,%rax
mov %rsp,%r8
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1490 <func0+0xa0>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 147b <func0+0x8b>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 15a3 <func0+0x1b3>
lea 0x3(%rsp),%r10
mov %r10,%rbx
and $0xfffffffffffffffc,%r10
shr $0x2,%rbx
test %esi,%esi
jle 1598 <func0+0x1a8>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
lea 0x4(%rdi,%rax,4),%r11
nopl (%rax)
mov (%rdi),%ecx
test %r9d,%r9d
je 1580 <func0+0x190>
lea -0x1(%r9),%esi
xor %eax,%eax
jmp 14f0 <func0+0x100>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1580 <func0+0x190>
mov %rdx,%rax
movslq %eax,%rdx
cmp %ecx,(%r8,%rax,4)
jne 14e0 <func0+0xf0>
addl $0x1,(%r10,%rdx,4)
add $0x4,%rdi
cmp %r11,%rdi
jne 14c8 <func0+0xd8>
mov 0x0(,%rbx,4),%ecx
cmp $0x1,%r9d
je 15ae <func0+0x1be>
lea -0x2(%r9),%esi
mov $0x1,%eax
xor %edi,%edi
add $0x2,%rsi
nopw 0x0(%rax,%rax,1)
mov (%r10,%rax,4),%edx
cmp %ecx,%edx
jle 153d <func0+0x14d>
mov %edx,%ecx
movslq %eax,%rdi
add $0x1,%rax
cmp %rax,%rsi
jne 1530 <func0+0x140>
mov (%r8,%rdi,4),%eax
mov %ecx,0x2acc(%rip)
mov %eax,0x2ac2(%rip)
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
jne 15b2 <func0+0x1c2>
mov -0x8(%rbp),%rbx
lea 0x2aa8(%rip),%rax
leaveq
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 145d <func0+0x6d>
nopl (%rax)
movslq %r9d,%rax
add $0x1,%r9d
mov %ecx,(%r8,%rax,4)
movl $0x1,(%r10,%rax,4)
jmpq 14fe <func0+0x10e>
mov 0x0(,%rbx,4),%ecx
xor %edi,%edi
jmp 1546 <func0+0x156>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 14a2 <func0+0xb2>
xor %edi,%edi
jmp 1546 <func0+0x156>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov r8, rdi
mov eax, esi
mov rbp, rsp
push rbx
sub rsp, 18h
mov rdx, fs:28h
mov [rbp+var_18], rdx
xor edx, edx
movsxd rdx, esi
mov rsi, rsp
lea rdx, ds:0Fh[rdx*4]
mov rdi, rdx
mov rcx, rdx
and rdi, 0FFFFFFFFFFFFF000h
and rcx, 0FFFFFFFFFFFFFFF0h
sub rsi, rdi
cmp rsp, rsi
jz short loc_144D
loc_1438:
sub rsp, 1000h
or [rsp+1020h+var_28], 0
cmp rsp, rsi
jnz short loc_1438
loc_144D:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_1561
loc_145F:
mov rcx, rdx
mov rsi, rsp
and rdx, 0FFFFFFFFFFFFF000h
mov rdi, rsp
sub rsi, rdx
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_1490
loc_147B:
sub rsp, 1000h
or [rsp+2020h+var_1028], 0
cmp rsp, rsi
jnz short loc_147B
loc_1490:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_158F
loc_14A2:
lea r10, [rsp+2020h+var_201D]
mov rbx, r10
and r10, 0FFFFFFFFFFFFFFFCh
shr rbx, 2
test eax, eax
jle loc_1584
sub eax, 1
xor r9d, r9d
lea r11, [r8+rax*4+4]
nop dword ptr [rax]
loc_14C8:
mov esi, [r8]
xor ecx, ecx
test r9d, r9d
jz loc_1570
movsxd rcx, r9d
xor eax, eax
jmp short loc_14ED
loc_14E0:
add rax, 1
cmp rax, rcx
jz loc_1570
loc_14ED:
movsxd rdx, eax
cmp [rdi+rax*4], esi
jnz short loc_14E0
add dword ptr [r10+rdx*4], 1
loc_14FA:
add r8, 4
cmp r8, r11
jnz short loc_14C8
mov ecx, ds:dword_0[rbx*4]
cmp r9d, 1
jz loc_159A
movsxd r9, r9d
mov eax, 1
xor esi, esi
xchg ax, ax
loc_1520:
mov edx, [r10+rax*4]
cmp edx, ecx
jle short loc_152D
mov ecx, edx
movsxd rsi, eax
loc_152D:
add rax, 1
cmp rax, r9
jnz short loc_1520
loc_1536:
mov eax, [rdi+rsi*4]
mov cs:dword_401C, ecx
mov cs:result_1, eax
mov rax, [rbp+var_18]
sub rax, fs:28h
jnz short loc_159E
mov rbx, [rbp+var_8]
lea rax, result_1
leave
retn
loc_1561:
or [rsp+rcx+1020h+var_1028], 0
jmp loc_145F
loc_1570:
mov [rdi+rcx*4], esi
add r9d, 1
mov dword ptr [r10+rcx*4], 1
jmp loc_14FA
loc_1584:
mov ecx, ds:dword_0[rbx*4]
xor esi, esi
jmp short loc_1536
loc_158F:
or [rsp+rcx+2020h+var_2028], 0
jmp loc_14A2
loc_159A:
xor esi, esi
jmp short loc_1536
loc_159E:
call ___stack_chk_fail | int * func0(int *a1, int a2)
{
int *v2; // r8
long long v4; // rdx
_DWORD *v5; // rsi
signed long long v6; // rcx
void *v7; // rsp
_DWORD *v8; // rsi
signed long long v9; // rcx
void *v10; // rsp
int v11; // r9d
long long v12; // r11
int v13; // esi
long long v14; // rcx
long long v15; // rax
int v16; // ecx
long long v17; // rax
long long v18; // rsi
int v19; // eax
_DWORD v22[1024]; // [rsp+8h] [rbp-2020h] BYREF
_DWORD v23[1022]; // [rsp+1008h] [rbp-1020h] BYREF
_QWORD v24[3]; // [rsp+2008h] [rbp-20h] BYREF
v2 = a1;
v24[1] = __readfsqword(0x28u);
v4 = 4LL * a2 + 15;
v5 = (_DWORD *)((char *)v24 - (v4 & 0xFFFFFFFFFFFFF000LL));
if ( v24 != (_QWORD *)v5 )
{
while ( v23 != v5 )
;
}
v6 = v4 & 0xFF0;
v7 = alloca(v6);
if ( (v4 & 0xFF0) != 0 )
*(_QWORD *)((char *)&v22[1022] + v6) = *(_QWORD *)((char *)&v22[1022] + v6);
v8 = (_DWORD *)((char *)v23 - (v4 & 0xFFFFFFFFFFFFF000LL));
if ( v23 != v8 )
{
while ( v22 != v8 )
;
}
v9 = v4 & 0xFF0;
v10 = alloca(v9);
if ( (v4 & 0xFF0) != 0 )
*(_QWORD *)((char *)&v22[-2] + v9) = *(_QWORD *)((char *)&v22[-2] + v9);
if ( a2 <= 0 )
{
v16 = v22[0];
v18 = 0LL;
}
else
{
v11 = 0;
v12 = (long long)&a1[a2 - 1 + 1];
do
{
v13 = *v2;
v14 = 0LL;
if ( v11 )
{
v14 = v11;
v15 = 0LL;
while ( v23[v15] != v13 )
{
if ( ++v15 == v11 )
goto LABEL_23;
}
++v22[(int)v15];
}
else
{
LABEL_23:
v23[v14] = v13;
++v11;
v22[v14] = 1;
}
++v2;
}
while ( v2 != (int *)v12 );
v16 = v22[0];
if ( v11 == 1 )
{
v18 = 0LL;
}
else
{
v17 = 1LL;
v18 = 0LL;
do
{
if ( v22[v17] > v16 )
{
v16 = v22[v17];
v18 = (int)v17;
}
++v17;
}
while ( v17 != v11 );
}
}
v19 = v23[v18];
dword_401C = v16;
result_1 = v19;
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV R8,RDI
MOV EAX,ESI
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RDX
XOR EDX,EDX
MOVSXD RDX,ESI
MOV RSI,RSP
LEA RDX,[0xf + RDX*0x4]
MOV RDI,RDX
MOV RCX,RDX
AND RDI,-0x1000
AND RCX,-0x10
SUB RSI,RDI
CMP RSP,RSI
JZ 0x0010144d
LAB_00101438:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x00101438
LAB_0010144d:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101561
LAB_0010145f:
MOV RCX,RDX
MOV RSI,RSP
AND RDX,-0x1000
MOV RDI,RSP
SUB RSI,RDX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x00101490
LAB_0010147b:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x0010147b
LAB_00101490:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x0010158f
LAB_001014a2:
LEA R10,[RSP + 0x3]
MOV RBX,R10
AND R10,-0x4
SHR RBX,0x2
TEST EAX,EAX
JLE 0x00101584
SUB EAX,0x1
XOR R9D,R9D
LEA R11,[R8 + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_001014c8:
MOV ESI,dword ptr [R8]
XOR ECX,ECX
TEST R9D,R9D
JZ 0x00101570
MOVSXD RCX,R9D
XOR EAX,EAX
JMP 0x001014ed
LAB_001014e0:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x00101570
LAB_001014ed:
MOVSXD RDX,EAX
CMP dword ptr [RDI + RAX*0x4],ESI
JNZ 0x001014e0
ADD dword ptr [R10 + RDX*0x4],0x1
LAB_001014fa:
ADD R8,0x4
CMP R8,R11
JNZ 0x001014c8
MOV ECX,dword ptr [RBX*0x4]
CMP R9D,0x1
JZ 0x0010159a
MOVSXD R9,R9D
MOV EAX,0x1
XOR ESI,ESI
NOP
LAB_00101520:
MOV EDX,dword ptr [R10 + RAX*0x4]
CMP EDX,ECX
JLE 0x0010152d
MOV ECX,EDX
MOVSXD RSI,EAX
LAB_0010152d:
ADD RAX,0x1
CMP RAX,R9
JNZ 0x00101520
LAB_00101536:
MOV EAX,dword ptr [RDI + RSI*0x4]
MOV dword ptr [0x0010401c],ECX
MOV dword ptr [0x00104018],EAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010159e
MOV RBX,qword ptr [RBP + -0x8]
LEA RAX,[0x104018]
LEAVE
RET
LAB_00101561:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x0010145f
LAB_00101570:
MOV dword ptr [RDI + RCX*0x4],ESI
ADD R9D,0x1
MOV dword ptr [R10 + RCX*0x4],0x1
JMP 0x001014fa
LAB_00101584:
MOV ECX,dword ptr [RBX*0x4]
XOR ESI,ESI
JMP 0x00101536
LAB_0010158f:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x001014a2
LAB_0010159a:
XOR ESI,ESI
JMP 0x00101536
LAB_0010159e:
CALL 0x00101060 | int8 * func0(int *param_1,int param_2)
{
int *piVar1;
long lVar2;
long lVar3;
int1 *puVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
int1 *puVar9;
int1 *puVar11;
int iVar13;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
int1 *puVar10;
int1 *puVar12;
puVar9 = auStack_28;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar7 = (long)param_2 * 4 + 0xf;
puVar10 = auStack_28;
puVar11 = auStack_28;
while (puVar10 != auStack_28 + -(uVar7 & 0xfffffffffffff000)) {
puVar9 = puVar11 + -0x1000;
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
puVar10 = puVar11 + -0x1000;
puVar11 = puVar11 + -0x1000;
}
uVar6 = (ulong)((uint)uVar7 & 0xff0);
lVar2 = -uVar6;
puVar11 = puVar9 + lVar2;
puVar12 = puVar9 + lVar2;
if (uVar6 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
puVar4 = puVar9 + lVar2;
while (puVar12 != puVar9 + (lVar2 - (uVar7 & 0xfffffffffffff000))) {
puVar11 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar12 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar3 = -uVar7;
if (uVar7 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
if (param_2 < 1) {
result_1._4_4_ = *(int *)(((ulong)(puVar11 + lVar3 + 3) >> 2) * 4);
lVar8 = 0;
}
else {
iVar13 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
lVar8 = 0;
if (iVar13 != 0) {
lVar8 = (long)iVar13;
lVar5 = 0;
do {
if (*(int *)(puVar9 + lVar5 * 4 + lVar2) == *param_1) {
*(int *)(puVar11 + (long)(int)lVar5 * 4 + lVar3) =
*(int *)(puVar11 + (long)(int)lVar5 * 4 + lVar3) + 1;
goto LAB_001014fa;
}
lVar5 = lVar5 + 1;
} while (lVar5 != lVar8);
}
*(int *)(puVar9 + lVar8 * 4 + lVar2) = *param_1;
iVar13 = iVar13 + 1;
*(int4 *)(puVar11 + lVar8 * 4 + lVar3) = 1;
LAB_001014fa:
param_1 = param_1 + 1;
} while (param_1 != piVar1);
result_1._4_4_ = *(int *)(((ulong)(puVar11 + lVar3 + 3) >> 2) * 4);
if (iVar13 == 1) {
lVar8 = 0;
}
else {
lVar5 = 1;
lVar8 = 0;
do {
if (result_1._4_4_ < *(int *)(puVar11 + lVar5 * 4 + lVar3)) {
lVar8 = (long)(int)lVar5;
result_1._4_4_ = *(int *)(puVar11 + lVar5 * 4 + lVar3);
}
lVar5 = lVar5 + 1;
} while (lVar5 != iVar13);
}
}
result_1._0_4_ = *(int4 *)(puVar9 + lVar8 * 4 + lVar2);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar11 + lVar3 + -8) = 0x1015a3;
__stack_chk_fail();
}
return &result_1;
} |
4,415 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found = 1;
break;
}
}
if(!found){
keys[unique] = num;
counts[unique] = 1;
unique++;
}
}
int max_index = 0;
for(int i = 1; i < unique; i++) {
if(counts[i] > counts[max_index]) {
max_index = i;
}
}
static int result[2];
result[0] = keys[max_index];
result[1] = counts[max_index];
return result;
}
| int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2)/sizeof(nums2[0]);
result = func0(nums2, size2);
assert(result[0]== 8 && result[1] == 2);
int nums3[] = {10,20,20,30,40,90,80,50,30,20,50,10};
int size3 = sizeof(nums3)/sizeof(nums3[0]);
result = func0(nums3, size3);
assert(result[0] == 20 && result[1] == 3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movslq %esi,%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 138b <func0+0x5b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rcx,%rsp
jne 1376 <func0+0x46>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14b2 <func0+0x182>
mov %rax,%rdx
mov %rsp,%rbx
and $0xfffffffffffff000,%rax
mov %rsp,%r8
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 13d0 <func0+0xa0>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 13bb <func0+0x8b>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14e3 <func0+0x1b3>
lea 0x3(%rsp),%r10
mov %r10,%rbx
and $0xfffffffffffffffc,%r10
shr $0x2,%rbx
test %esi,%esi
jle 14d8 <func0+0x1a8>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
lea 0x4(%rdi,%rax,4),%r11
nopl (%rax)
mov (%rdi),%ecx
test %r9d,%r9d
je 14c0 <func0+0x190>
lea -0x1(%r9),%esi
xor %eax,%eax
jmp 1430 <func0+0x100>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 14c0 <func0+0x190>
mov %rdx,%rax
movslq %eax,%rdx
cmp %ecx,(%r8,%rax,4)
jne 1420 <func0+0xf0>
addl $0x1,(%r10,%rdx,4)
add $0x4,%rdi
cmp %r11,%rdi
jne 1408 <func0+0xd8>
mov 0x0(,%rbx,4),%ecx
cmp $0x1,%r9d
je 14ee <func0+0x1be>
lea -0x2(%r9),%esi
mov $0x1,%eax
xor %edi,%edi
add $0x2,%rsi
nopw 0x0(%rax,%rax,1)
mov (%r10,%rax,4),%edx
cmp %ecx,%edx
jle 147d <func0+0x14d>
mov %edx,%ecx
movslq %eax,%rdi
add $0x1,%rax
cmp %rax,%rsi
jne 1470 <func0+0x140>
mov (%r8,%rdi,4),%eax
mov %ecx,0x2b8c(%rip)
mov %eax,0x2b82(%rip)
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
jne 14f2 <func0+0x1c2>
mov -0x8(%rbp),%rbx
lea 0x2b68(%rip),%rax
leaveq
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 139d <func0+0x6d>
nopl (%rax)
movslq %r9d,%rax
add $0x1,%r9d
mov %ecx,(%r8,%rax,4)
movl $0x1,(%r10,%rax,4)
jmpq 143e <func0+0x10e>
mov 0x0(,%rbx,4),%ecx
xor %edi,%edi
jmp 1486 <func0+0x156>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 13e2 <func0+0xb2>
xor %edi,%edi
jmp 1486 <func0+0x156>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r10, esi
mov r8, r10
shl r10, 2
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [r10+0Fh]
mov rcx, rsp
mov rsi, rax
mov rdx, rax
and rsi, 0FFFFFFFFFFFFF000h
and rdx, 0FFFFFFFFFFFFFFF0h
sub rcx, rsi
cmp rsp, rcx
jz short loc_138A
loc_1375:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1375
loc_138A:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1432
loc_139C:
mov rdx, rax
mov rcx, rsp
and rax, 0FFFFFFFFFFFFF000h
mov rsi, rsp
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_13CC
loc_13B7:
sub rsp, 1000h
or [rsp+2010h+var_1018], 0
cmp rsp, rcx
jnz short loc_13B7
loc_13CC:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_14C1
loc_13DE:
lea r9, [rsp+2010h+var_200D]
mov r11, r9
and r9, 0FFFFFFFFFFFFFFFCh
shr r11, 2
test r8d, r8d
jle loc_14B5
add r10, rdi
xor r8d, r8d
nop dword ptr [rax]
loc_1400:
mov edx, [rdi]
movsxd rcx, r8d
test r8d, r8d
jle short loc_1440
loc_140A:
xor eax, eax
jmp short loc_1419
loc_1410:
add rax, 1
cmp rcx, rax
jz short loc_1440
loc_1419:
cmp edx, [rsi+rax*4]
jnz short loc_1410
cdqe
add rdi, 4
add dword ptr [r9+rax*4], 1
cmp rdi, r10
jz short loc_1458
mov edx, [rdi]
jmp short loc_140A
loc_1432:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_139C
loc_1440:
add rdi, 4
mov [rsi+rcx*4], edx
add r8d, 1
mov dword ptr [r9+rcx*4], 1
cmp rdi, r10
jnz short loc_1400
loc_1458:
mov edx, ds:dword_0[r11*4]
cmp r8d, 1
jle short loc_14CC
mov r8d, r8d
mov eax, 1
xor edi, edi
loc_1470:
mov ecx, [r9+rax*4]
cmp edx, ecx
cmovl edi, eax
cmovl edx, ecx
add rax, 1
cmp r8, rax
jnz short loc_1470
loc_1485:
movsxd rdi, edi
movd xmm1, edx
movd xmm0, dword ptr [rsi+rdi*4]
punpckldq xmm0, xmm1
movq cs:result_1, xmm0
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_14D0
leave
lea rax, result_1
retn
loc_14B5:
mov edx, ds:dword_0[r11*4]
xor edi, edi
jmp short loc_1485
loc_14C1:
or [rsp+rdx+2010h+var_2018], 0
jmp loc_13DE
loc_14CC:
xor edi, edi
jmp short loc_1485
loc_14D0:
call ___stack_chk_fail | long long * func0(int *a1, int a2)
{
long long v2; // r10
_DWORD *v3; // rcx
signed long long v4; // rdx
void *v5; // rsp
_DWORD *v6; // rcx
signed long long v7; // rdx
void *v8; // rsp
int *v9; // r10
int v10; // r8d
int v11; // edx
long long v12; // rcx
long long v13; // rax
signed int v14; // edx
long long v15; // rax
int v16; // edi
_DWORD v19[1024]; // [rsp+8h] [rbp-2010h] BYREF
_DWORD v20[1022]; // [rsp+1008h] [rbp-1010h] BYREF
_QWORD v21[2]; // [rsp+2008h] [rbp-10h] BYREF
v2 = 4LL * a2;
v21[1] = __readfsqword(0x28u);
v3 = (_DWORD *)((char *)v21 - ((v2 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( v21 != (_QWORD *)v3 )
{
while ( v20 != v3 )
;
}
v4 = ((_WORD)v2 + 15) & 0xFF0;
v5 = alloca(v4);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v19[1022] + v4) = *(_QWORD *)((char *)&v19[1022] + v4);
v6 = (_DWORD *)((char *)v20 - ((v2 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( v20 != v6 )
{
while ( v19 != v6 )
;
}
v7 = ((_WORD)v2 + 15) & 0xFF0;
v8 = alloca(v7);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v19[-2] + v7) = *(_QWORD *)((char *)&v19[-2] + v7);
if ( a2 <= 0 )
{
v14 = v19[0];
v16 = 0;
}
else
{
v9 = &a1[(unsigned long long)v2 / 4];
v10 = 0;
while ( 1 )
{
v11 = *a1;
v12 = v10;
if ( v10 > 0 )
break;
LABEL_17:
++a1;
v20[v10++] = v11;
v19[v12] = 1;
if ( a1 == v9 )
goto LABEL_18;
}
while ( 1 )
{
v13 = 0LL;
while ( v11 != v20[v13] )
{
if ( v10 == ++v13 )
goto LABEL_17;
}
++a1;
++v19[(int)v13];
if ( a1 == v9 )
break;
v11 = *a1;
}
LABEL_18:
v14 = v19[0];
if ( v10 <= 1 )
{
v16 = 0;
}
else
{
v15 = 1LL;
v16 = 0;
do
{
if ( v14 < v19[v15] )
{
v16 = v15;
v14 = v19[v15];
}
++v15;
}
while ( v10 != v15 );
}
}
result_1 = _mm_unpacklo_epi32(_mm_cvtsi32_si128(v20[v16]), _mm_cvtsi32_si128(v14)).m128i_u64[0];
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOVSXD R10,ESI
MOV R8,R10
SHL R10,0x2
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[R10 + 0xf]
MOV RCX,RSP
MOV RSI,RAX
MOV RDX,RAX
AND RSI,-0x1000
AND RDX,-0x10
SUB RCX,RSI
CMP RSP,RCX
JZ 0x0010138a
LAB_00101375:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101375
LAB_0010138a:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101432
LAB_0010139c:
MOV RDX,RAX
MOV RCX,RSP
AND RAX,-0x1000
MOV RSI,RSP
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001013cc
LAB_001013b7:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001013b7
LAB_001013cc:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001014c1
LAB_001013de:
LEA R9,[RSP + 0x3]
MOV R11,R9
AND R9,-0x4
SHR R11,0x2
TEST R8D,R8D
JLE 0x001014b5
ADD R10,RDI
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101400:
MOV EDX,dword ptr [RDI]
MOVSXD RCX,R8D
TEST R8D,R8D
JLE 0x00101440
LAB_0010140a:
XOR EAX,EAX
JMP 0x00101419
LAB_00101410:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x00101440
LAB_00101419:
CMP EDX,dword ptr [RSI + RAX*0x4]
JNZ 0x00101410
CDQE
ADD RDI,0x4
ADD dword ptr [R9 + RAX*0x4],0x1
CMP RDI,R10
JZ 0x00101458
MOV EDX,dword ptr [RDI]
JMP 0x0010140a
LAB_00101432:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010139c
LAB_00101440:
ADD RDI,0x4
MOV dword ptr [RSI + RCX*0x4],EDX
ADD R8D,0x1
MOV dword ptr [R9 + RCX*0x4],0x1
CMP RDI,R10
JNZ 0x00101400
LAB_00101458:
MOV EDX,dword ptr [R11*0x4]
CMP R8D,0x1
JLE 0x001014cc
MOV R8D,R8D
MOV EAX,0x1
XOR EDI,EDI
LAB_00101470:
MOV ECX,dword ptr [R9 + RAX*0x4]
CMP EDX,ECX
CMOVL EDI,EAX
CMOVL EDX,ECX
ADD RAX,0x1
CMP R8,RAX
JNZ 0x00101470
LAB_00101485:
MOVSXD RDI,EDI
MOVD XMM1,EDX
MOVD XMM0,dword ptr [RSI + RDI*0x4]
PUNPCKLDQ XMM0,XMM1
MOVQ qword ptr [0x00104018],XMM0
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014d0
LEAVE
LEA RAX,[0x104018]
RET
LAB_001014b5:
MOV EDX,dword ptr [R11*0x4]
XOR EDI,EDI
JMP 0x00101485
LAB_001014c1:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001013de
LAB_001014cc:
XOR EDI,EDI
JMP 0x00101485
LAB_001014d0:
CALL 0x00101060 | int8 * func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
long lVar3;
int *puVar4;
long lVar5;
ulong uVar6;
long lVar7;
int iVar8;
ulong uVar9;
int *puVar10;
int *puVar12;
ulong uVar14;
int iVar15;
int *piVar16;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar11;
int *puVar13;
puVar10 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar9 = (long)param_2 * 4 + 0xf;
puVar11 = auStack_18;
puVar12 = auStack_18;
while (puVar11 != auStack_18 + -(uVar9 & 0xfffffffffffff000)) {
puVar10 = puVar12 + -0x1000;
*(int8 *)(puVar12 + -8) = *(int8 *)(puVar12 + -8);
puVar11 = puVar12 + -0x1000;
puVar12 = puVar12 + -0x1000;
}
uVar6 = (ulong)((uint)uVar9 & 0xff0);
lVar2 = -uVar6;
puVar12 = puVar10 + lVar2;
puVar13 = puVar10 + lVar2;
if (uVar6 != 0) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
puVar4 = puVar10 + lVar2;
while (puVar13 != puVar10 + (lVar2 - (uVar9 & 0xfffffffffffff000))) {
puVar12 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar13 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar3 = -uVar9;
if (uVar9 != 0) {
*(int8 *)(puVar12 + -8) = *(int8 *)(puVar12 + -8);
}
if (param_2 < 1) {
iVar8 = *(int *)(((ulong)(puVar12 + lVar3 + 3) >> 2) * 4);
iVar15 = 0;
}
else {
piVar16 = param_1 + param_2;
uVar9 = 0;
do {
iVar8 = *param_1;
iVar15 = (int)uVar9;
lVar7 = (long)iVar15;
if (0 < iVar15) {
while( true ) {
lVar5 = 0;
while (iVar8 != *(int *)(puVar10 + lVar5 * 4 + lVar2)) {
lVar5 = lVar5 + 1;
if (lVar7 == lVar5) goto LAB_00101440;
}
param_1 = param_1 + 1;
*(int *)(puVar12 + (long)(int)lVar5 * 4 + lVar3) =
*(int *)(puVar12 + (long)(int)lVar5 * 4 + lVar3) + 1;
if (param_1 == piVar16) break;
iVar8 = *param_1;
}
break;
}
LAB_00101440:
param_1 = param_1 + 1;
*(int *)(puVar10 + lVar7 * 4 + lVar2) = iVar8;
uVar9 = (ulong)(iVar15 + 1);
*(int4 *)(puVar12 + lVar7 * 4 + lVar3) = 1;
} while (param_1 != piVar16);
iVar8 = *(int *)(((ulong)(puVar12 + lVar3 + 3) >> 2) * 4);
if ((int)uVar9 < 2) {
iVar15 = 0;
}
else {
uVar6 = 1;
uVar14 = 0;
do {
iVar1 = *(int *)(puVar12 + uVar6 * 4 + lVar3);
if (iVar8 < iVar1) {
uVar14 = uVar6 & 0xffffffff;
}
iVar15 = (int)uVar14;
if (iVar8 < iVar1) {
iVar8 = iVar1;
}
uVar6 = uVar6 + 1;
} while (uVar9 != uVar6);
}
}
result_1 = CONCAT44(iVar8,*(int4 *)(puVar10 + (long)iVar15 * 4 + lVar2));
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar12 + lVar3 + -8) = 0x1014d5;
__stack_chk_fail();
}
return &result_1;
} |
4,416 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
j = 0;
int k = strlen(vowels) - 1;
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
result_string[j++] = vowels[k--];
} else {
result_string[j++] = str1[i];
}
}
result_string[j] = '\0';
return result_string;
}
| int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0x7c(%rbp)
jmp 12a9 <func0+0xe0>
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov -0x88(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x7d(%rbp)
movsbl -0x7d(%rbp),%eax
mov %eax,%esi
lea 0xd80(%rip),%rdi
callq 10b0 <strchr@plt>
test %rax,%rax
je 12a5 <func0+0xdc>
mov -0x78(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x78(%rbp)
cltq
movzbl -0x7d(%rbp),%edx
mov %dl,-0x70(%rbp,%rax,1)
addl $0x1,-0x7c(%rbp)
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov -0x88(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1265 <func0+0x9c>
mov -0x78(%rbp),%eax
cltq
movb $0x0,-0x70(%rbp,%rax,1)
movl $0x0,-0x78(%rbp)
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 1090 <strlen@plt>
sub $0x1,%eax
mov %eax,-0x74(%rbp)
movl $0x0,-0x7c(%rbp)
jmpq 1371 <func0+0x1a8>
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov -0x88(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x7e(%rbp)
movsbl -0x7e(%rbp),%eax
mov %eax,%esi
lea 0xcf6(%rip),%rdi
callq 10b0 <strchr@plt>
test %rax,%rax
je 1344 <func0+0x17b>
mov -0x74(%rbp),%edx
lea -0x1(%rdx),%eax
mov %eax,-0x74(%rbp)
mov -0x78(%rbp),%eax
lea 0x1(%rax),%ecx
mov %ecx,-0x78(%rbp)
movslq %edx,%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
cltq
lea 0x2d01(%rip),%rcx
mov %dl,(%rax,%rcx,1)
jmp 136d <func0+0x1a4>
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov -0x88(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x78(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x78(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2cd6(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x7c(%rbp)
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov -0x88(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 12ef <func0+0x126>
mov -0x78(%rbp),%eax
cltq
lea 0x2ca8(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2c9d(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 13b7 <func0+0x1ee>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_78], 0
mov qword ptr [rbp+s], 0
mov [rbp+var_68], 0
mov [rbp+var_60], 0
mov [rbp+var_58], 0
mov [rbp+var_50], 0
mov [rbp+var_48], 0
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov [rbp+var_30], 0
mov [rbp+var_28], 0
mov [rbp+var_20], 0
mov [rbp+var_18], 0
mov [rbp+var_10], 0
mov [rbp+var_7C], 0
jmp short loc_12AC
loc_1265:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, [rbp+var_88]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_7D], al
movsx eax, [rbp+var_7D]
mov esi, eax; c
lea rax, s; "aeiouAEIOU"
mov rdi, rax; s
call _strchr
test rax, rax
jz short loc_12A8
mov eax, [rbp+var_78]
lea edx, [rax+1]
mov [rbp+var_78], edx
cdqe
movzx edx, [rbp+var_7D]
mov [rbp+rax+s], dl
loc_12A8:
add [rbp+var_7C], 1
loc_12AC:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, [rbp+var_88]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1265
mov eax, [rbp+var_78]
cdqe
mov [rbp+rax+s], 0
mov [rbp+var_78], 0
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
sub eax, 1
mov [rbp+var_74], eax
mov [rbp+var_7C], 0
jmp loc_1377
loc_12F2:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, [rbp+var_88]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_7E], al
movsx eax, [rbp+var_7E]
mov esi, eax; c
lea rax, s; "aeiouAEIOU"
mov rdi, rax; s
call _strchr
test rax, rax
jz short loc_134A
mov edx, [rbp+var_74]
lea eax, [rdx-1]
mov [rbp+var_74], eax
mov eax, [rbp+var_78]
lea ecx, [rax+1]
mov [rbp+var_78], ecx
movsxd rdx, edx
movzx edx, [rbp+rdx+s]
cdqe
lea rcx, result_string_1
mov [rax+rcx], dl
jmp short loc_1373
loc_134A:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, [rbp+var_88]
lea rcx, [rdx+rax]
mov eax, [rbp+var_78]
lea edx, [rax+1]
mov [rbp+var_78], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, result_string_1
mov [rax+rcx], dl
loc_1373:
add [rbp+var_7C], 1
loc_1377:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, [rbp+var_88]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_12F2
mov eax, [rbp+var_78]
cdqe
lea rdx, result_string_1
mov byte ptr [rax+rdx], 0
lea rax, result_string_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13BD
call ___stack_chk_fail
locret_13BD:
leave
retn | _BYTE * func0(long long a1)
{
int v1; // eax
int v2; // edx
int v3; // eax
char v4; // dl
char v6; // [rsp+13h] [rbp-7Dh]
int i; // [rsp+14h] [rbp-7Ch]
int j; // [rsp+14h] [rbp-7Ch]
int v9; // [rsp+18h] [rbp-78h]
int v10; // [rsp+18h] [rbp-78h]
int v11; // [rsp+1Ch] [rbp-74h]
char s[8]; // [rsp+20h] [rbp-70h] BYREF
long long v13; // [rsp+28h] [rbp-68h]
long long v14; // [rsp+30h] [rbp-60h]
long long v15; // [rsp+38h] [rbp-58h]
long long v16; // [rsp+40h] [rbp-50h]
long long v17; // [rsp+48h] [rbp-48h]
long long v18; // [rsp+50h] [rbp-40h]
long long v19; // [rsp+58h] [rbp-38h]
long long v20; // [rsp+60h] [rbp-30h]
long long v21; // [rsp+68h] [rbp-28h]
long long v22; // [rsp+70h] [rbp-20h]
long long v23; // [rsp+78h] [rbp-18h]
int v24; // [rsp+80h] [rbp-10h]
unsigned long long v25; // [rsp+88h] [rbp-8h]
v25 = __readfsqword(0x28u);
v9 = 0;
*(_QWORD *)s = 0LL;
v13 = 0LL;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
v6 = *(_BYTE *)(i + a1);
if ( strchr("aeiouAEIOU", v6) )
{
v1 = v9++;
s[v1] = v6;
}
}
s[v9] = 0;
v10 = 0;
v11 = strlen(s) - 1;
for ( j = 0; *(_BYTE *)(j + a1); ++j )
{
if ( strchr("aeiouAEIOU", *(char *)(j + a1)) )
{
v2 = v11--;
v3 = v10++;
v4 = s[v2];
}
else
{
v3 = v10++;
v4 = *(_BYTE *)(j + a1);
}
result_string_1[v3] = v4;
}
result_string_1[v10] = 0;
return result_string_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x78],0x0
MOV qword ptr [RBP + -0x70],0x0
MOV qword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV qword ptr [RBP + -0x20],0x0
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x7c],0x0
JMP 0x001012ac
LAB_00101265:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x7d],AL
MOVSX EAX,byte ptr [RBP + -0x7d]
MOV ESI,EAX
LEA RAX,[0x102008]
MOV RDI,RAX
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001012a8
MOV EAX,dword ptr [RBP + -0x78]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x78],EDX
CDQE
MOVZX EDX,byte ptr [RBP + -0x7d]
MOV byte ptr [RBP + RAX*0x1 + -0x70],DL
LAB_001012a8:
ADD dword ptr [RBP + -0x7c],0x1
LAB_001012ac:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101265
MOV EAX,dword ptr [RBP + -0x78]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],0x0
MOV dword ptr [RBP + -0x78],0x0
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00101090
SUB EAX,0x1
MOV dword ptr [RBP + -0x74],EAX
MOV dword ptr [RBP + -0x7c],0x0
JMP 0x00101377
LAB_001012f2:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x7e],AL
MOVSX EAX,byte ptr [RBP + -0x7e]
MOV ESI,EAX
LEA RAX,[0x102008]
MOV RDI,RAX
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010134a
MOV EDX,dword ptr [RBP + -0x74]
LEA EAX,[RDX + -0x1]
MOV dword ptr [RBP + -0x74],EAX
MOV EAX,dword ptr [RBP + -0x78]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBP + -0x78],ECX
MOVSXD RDX,EDX
MOVZX EDX,byte ptr [RBP + RDX*0x1 + -0x70]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x00101373
LAB_0010134a:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x78]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x78],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00101373:
ADD dword ptr [RBP + -0x7c],0x1
LAB_00101377:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001012f2
MOV EAX,dword ptr [RBP + -0x78]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013bd
CALL 0x001010a0
LAB_001013bd:
LEAVE
RET | int1 * func0(long param_1)
{
char cVar1;
size_t sVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_84;
int local_80;
int local_7c;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = 0;
local_78[0] = '\0';
local_78[1] = '\0';
local_78[2] = '\0';
local_78[3] = '\0';
local_78[4] = '\0';
local_78[5] = '\0';
local_78[6] = '\0';
local_78[7] = '\0';
local_78[8] = '\0';
local_78[9] = '\0';
local_78[10] = '\0';
local_78[0xb] = '\0';
local_78[0xc] = '\0';
local_78[0xd] = '\0';
local_78[0xe] = '\0';
local_78[0xf] = '\0';
local_78[0x10] = '\0';
local_78[0x11] = '\0';
local_78[0x12] = '\0';
local_78[0x13] = '\0';
local_78[0x14] = '\0';
local_78[0x15] = '\0';
local_78[0x16] = '\0';
local_78[0x17] = '\0';
local_78[0x18] = '\0';
local_78[0x19] = '\0';
local_78[0x1a] = '\0';
local_78[0x1b] = '\0';
local_78[0x1c] = '\0';
local_78[0x1d] = '\0';
local_78[0x1e] = '\0';
local_78[0x1f] = '\0';
local_78[0x20] = '\0';
local_78[0x21] = '\0';
local_78[0x22] = '\0';
local_78[0x23] = '\0';
local_78[0x24] = '\0';
local_78[0x25] = '\0';
local_78[0x26] = '\0';
local_78[0x27] = '\0';
local_78[0x28] = '\0';
local_78[0x29] = '\0';
local_78[0x2a] = '\0';
local_78[0x2b] = '\0';
local_78[0x2c] = '\0';
local_78[0x2d] = '\0';
local_78[0x2e] = '\0';
local_78[0x2f] = '\0';
local_78[0x30] = '\0';
local_78[0x31] = '\0';
local_78[0x32] = '\0';
local_78[0x33] = '\0';
local_78[0x34] = '\0';
local_78[0x35] = '\0';
local_78[0x36] = '\0';
local_78[0x37] = '\0';
local_78[0x38] = '\0';
local_78[0x39] = '\0';
local_78[0x3a] = '\0';
local_78[0x3b] = '\0';
local_78[0x3c] = '\0';
local_78[0x3d] = '\0';
local_78[0x3e] = '\0';
local_78[0x3f] = '\0';
local_78[0x40] = '\0';
local_78[0x41] = '\0';
local_78[0x42] = '\0';
local_78[0x43] = '\0';
local_78[0x44] = '\0';
local_78[0x45] = '\0';
local_78[0x46] = '\0';
local_78[0x47] = '\0';
local_78[0x48] = '\0';
local_78[0x49] = '\0';
local_78[0x4a] = '\0';
local_78[0x4b] = '\0';
local_78[0x4c] = '\0';
local_78[0x4d] = '\0';
local_78[0x4e] = '\0';
local_78[0x4f] = '\0';
local_78[0x50] = '\0';
local_78[0x51] = '\0';
local_78[0x52] = '\0';
local_78[0x53] = '\0';
local_78[0x54] = '\0';
local_78[0x55] = '\0';
local_78[0x56] = '\0';
local_78[0x57] = '\0';
local_78[0x58] = '\0';
local_78[0x59] = '\0';
local_78[0x5a] = '\0';
local_78[0x5b] = '\0';
local_78[0x5c] = '\0';
local_78[0x5d] = '\0';
local_78[0x5e] = '\0';
local_78[0x5f] = '\0';
local_78[0x60] = '\0';
local_78[0x61] = '\0';
local_78[0x62] = '\0';
local_78[99] = '\0';
for (local_84 = 0; *(char *)(param_1 + local_84) != '\0'; local_84 = local_84 + 1) {
cVar1 = *(char *)(param_1 + local_84);
pcVar3 = strchr("aeiouAEIOU",(int)cVar1);
if (pcVar3 != (char *)0x0) {
local_78[local_80] = cVar1;
local_80 = local_80 + 1;
}
}
local_78[local_80] = '\0';
local_80 = 0;
sVar2 = strlen(local_78);
local_7c = (int)sVar2 + -1;
for (local_84 = 0; *(char *)(param_1 + local_84) != '\0'; local_84 = local_84 + 1) {
pcVar3 = strchr("aeiouAEIOU",(int)*(char *)(param_1 + local_84));
if (pcVar3 == (char *)0x0) {
result_string_1[local_80] = *(int *)(local_84 + param_1);
}
else {
result_string_1[local_80] = local_78[local_7c];
local_7c = local_7c + -1;
}
local_80 = local_80 + 1;
}
result_string_1[local_80] = 0;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return result_string_1;
} |
4,417 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
j = 0;
int k = strlen(vowels) - 1;
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
result_string[j++] = vowels[k--];
} else {
result_string[j++] = str1[i];
}
}
result_string[j] = '\0';
return result_string;
}
| int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
movq $0x0,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x0,0x50(%rsp)
movq $0x0,0x58(%rsp)
movl $0x0,0x60(%rsp)
movzbl (%rdi),%ebp
test %bpl,%bpl
je 12a0 <func0+0x117>
mov %rdi,%r13
lea 0x1(%rdi),%r12
mov %ebp,%ebx
mov $0x0,%r14d
lea 0xdc8(%rip),%r15
jmp 1250 <func0+0xc7>
add $0x1,%r12
movzbl -0x1(%r12),%ebx
test %bl,%bl
je 12d5 <func0+0x14c>
movsbl %bl,%esi
mov %r15,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 123e <func0+0xb5>
movslq %r14d,%rax
mov %bl,(%rsp,%rax,1)
lea 0x1(%r14),%r14d
jmp 123e <func0+0xb5>
mov %bpl,(%rbx,%r14,1)
add $0x1,%rbx
movzbl -0x1(%r13,%rbx,1),%ebp
test %bpl,%bpl
je 12a5 <func0+0x11c>
movsbl %bpl,%esi
mov %r15,%rdi
callq 1080 <strchr@plt>
mov %ebx,%ecx
test %rax,%rax
je 126c <func0+0xe3>
movslq %r12d,%rdx
movzbl (%rsp,%rdx,1),%ebp
lea -0x1(%r12),%r12d
jmp 126c <func0+0xe3>
mov $0x0,%ecx
lea 0x2d94(%rip),%rdx
movslq %ecx,%rax
movb $0x0,(%rdx,%rax,1)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 130d <func0+0x184>
mov %rdx,%rax
add $0x78,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq %r14d,%r14
movb $0x0,(%rsp,%r14,1)
mov %rsp,%rdi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x2(%rcx),%r12d
mov $0x1,%ebx
lea 0xd03(%rip),%r15
lea 0x2d37(%rip),%r14
jmpq 127f <func0+0xf6>
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+var_A8], 0
mov [rsp+0A8h+var_A0], 0
mov [rsp+0A8h+var_98], 0
mov [rsp+0A8h+var_90], 0
mov [rsp+0A8h+var_88], 0
mov [rsp+0A8h+var_80], 0
mov [rsp+0A8h+var_78], 0
mov [rsp+0A8h+var_70], 0
mov [rsp+0A8h+var_68], 0
mov [rsp+0A8h+var_60], 0
mov [rsp+0A8h+var_58], 0
mov [rsp+0A8h+var_50], 0
mov [rsp+0A8h+var_48], 0
movzx ebp, byte ptr [rdi]
test bpl, bpl
jz short loc_12DC
mov r14, rdi
lea r12, [rdi+1]
mov ebx, ebp
mov r13d, 0
lea r15, aAeiouaeiou; "aeiouAEIOU"
jmp short loc_1296
loc_127E:
movsxd rax, r13d
mov byte ptr [rsp+rax+0A8h+var_A8], bl
lea r13d, [r13+1]
loc_1288:
add r12, 1
movzx ebx, byte ptr [r12-1]
test bl, bl
jz short loc_1311
loc_1296:
movsx esi, bl
mov rdi, r15
call _strchr
test rax, rax
jnz short loc_127E
jmp short loc_1288
loc_12A8:
mov [rbx+r13], bpl
add rbx, 1
movzx ebp, byte ptr [r14+rbx-1]
test bpl, bpl
jz short loc_12E1
loc_12BB:
movsx esi, bpl
mov rdi, r15
call _strchr
mov ecx, ebx
test rax, rax
jz short loc_12A8
movsxd rdx, r12d
movzx ebp, byte ptr [rsp+rdx+0A8h+var_A8]
lea r12d, [r12-1]
jmp short loc_12A8
loc_12DC:
mov ecx, 0
loc_12E1:
lea rdx, result_string_1
movsxd rax, ecx
mov byte ptr [rdx+rax], 0
mov rax, [rsp+0A8h+var_40]
sub rax, fs:28h
jnz short loc_133A
mov rax, rdx
add rsp, 78h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1311:
movsxd r13, r13d
mov byte ptr [rsp+r13+0A8h+var_A8], 0
mov rdi, rsp
call _strlen
lea r12d, [rax-1]
mov ebx, 1
lea r15, aAeiouaeiou; "aeiouAEIOU"
lea r13, unk_403F
jmp short loc_12BB
loc_133A:
call ___stack_chk_fail | _BYTE * func0(char *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
char v6; // bp
char *v7; // r12
char v8; // bl
int v9; // r13d
long long v10; // rbx
long long v11; // rax
long long v12; // rdx
long long v13; // r8
long long v14; // r9
long long v15; // rcx
int v16; // r12d
long long v18; // [rsp+0h] [rbp-A8h] BYREF
long long v19; // [rsp+8h] [rbp-A0h]
long long v20; // [rsp+10h] [rbp-98h]
long long v21; // [rsp+18h] [rbp-90h]
long long v22; // [rsp+20h] [rbp-88h]
long long v23; // [rsp+28h] [rbp-80h]
long long v24; // [rsp+30h] [rbp-78h]
long long v25; // [rsp+38h] [rbp-70h]
long long v26; // [rsp+40h] [rbp-68h]
long long v27; // [rsp+48h] [rbp-60h]
long long v28; // [rsp+50h] [rbp-58h]
long long v29; // [rsp+58h] [rbp-50h]
int v30; // [rsp+60h] [rbp-48h]
unsigned long long v31; // [rsp+68h] [rbp-40h]
v31 = __readfsqword(0x28u);
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
v26 = 0LL;
v27 = 0LL;
v28 = 0LL;
v29 = 0LL;
v30 = 0;
v6 = *a1;
if ( *a1 )
{
v7 = a1 + 1;
v8 = *a1;
v9 = 0;
do
{
if ( strchr(
"aeiouAEIOU",
(unsigned int)v8,
a3,
a4,
a5,
a6,
v18,
v19,
v20,
v21,
v22,
v23,
v24,
v25,
v26,
v27,
v28,
v29,
v30,
v31) )
{
*((_BYTE *)&v18 + v9++) = v8;
}
v8 = *v7++;
}
while ( v8 );
*((_BYTE *)&v18 + v9) = 0;
v16 = strlen(&v18) - 1;
v10 = 1LL;
do
{
v11 = strchr(
"aeiouAEIOU",
(unsigned int)v6,
v12,
v15,
v13,
v14,
v18,
v19,
v20,
v21,
v22,
v23,
v24,
v25,
v26,
v27,
v28,
v29,
v30,
v31);
v15 = (unsigned int)v10;
if ( v11 )
{
v12 = v16;
v6 = *((_BYTE *)&v18 + v16--);
}
*((_BYTE *)&unk_403F + v10++) = v6;
v6 = a1[v10 - 1];
}
while ( v6 );
}
else
{
LODWORD(v15) = 0;
}
result_string_1[(int)v15] = 0;
return result_string_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV dword ptr [RSP + 0x60],0x0
MOVZX EBP,byte ptr [RDI]
TEST BPL,BPL
JZ 0x001012dc
MOV R14,RDI
LEA R12,[RDI + 0x1]
MOV EBX,EBP
MOV R13D,0x0
LEA R15,[0x102004]
JMP 0x00101296
LAB_0010127e:
MOVSXD RAX,R13D
MOV byte ptr [RSP + RAX*0x1],BL
LEA R13D,[R13 + 0x1]
LAB_00101288:
ADD R12,0x1
MOVZX EBX,byte ptr [R12 + -0x1]
TEST BL,BL
JZ 0x00101311
LAB_00101296:
MOVSX ESI,BL
MOV RDI,R15
CALL 0x001010b0
TEST RAX,RAX
JNZ 0x0010127e
JMP 0x00101288
LAB_001012a8:
MOV byte ptr [RBX + R13*0x1],BPL
ADD RBX,0x1
MOVZX EBP,byte ptr [R14 + RBX*0x1 + -0x1]
TEST BPL,BPL
JZ 0x001012e1
LAB_001012bb:
MOVSX ESI,BPL
MOV RDI,R15
CALL 0x001010b0
MOV ECX,EBX
TEST RAX,RAX
JZ 0x001012a8
MOVSXD RDX,R12D
MOVZX EBP,byte ptr [RSP + RDX*0x1]
LEA R12D,[R12 + -0x1]
JMP 0x001012a8
LAB_001012dc:
MOV ECX,0x0
LAB_001012e1:
LEA RDX,[0x104040]
MOVSXD RAX,ECX
MOV byte ptr [RDX + RAX*0x1],0x0
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010133a
MOV RAX,RDX
ADD RSP,0x78
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101311:
MOVSXD R13,R13D
MOV byte ptr [RSP + R13*0x1],0x0
MOV RDI,RSP
CALL 0x00101090
LEA R12D,[RAX + -0x1]
MOV EBX,0x1
LEA R15,[0x102004]
LEA R13,[0x10403f]
JMP 0x001012bb
LAB_0010133a:
CALL 0x001010a0 | int1 * func0(char *param_1)
{
char *pcVar1;
char *pcVar2;
size_t sVar3;
char cVar4;
long lVar5;
char cVar6;
int iVar7;
int iVar8;
long in_FS_OFFSET;
char local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_a8[0] = '\0';
local_a8[1] = '\0';
local_a8[2] = '\0';
local_a8[3] = '\0';
local_a8[4] = '\0';
local_a8[5] = '\0';
local_a8[6] = '\0';
local_a8[7] = '\0';
local_a8[8] = '\0';
local_a8[9] = '\0';
local_a8[10] = '\0';
local_a8[0xb] = '\0';
local_a8[0xc] = '\0';
local_a8[0xd] = '\0';
local_a8[0xe] = '\0';
local_a8[0xf] = '\0';
local_a8[0x10] = '\0';
local_a8[0x11] = '\0';
local_a8[0x12] = '\0';
local_a8[0x13] = '\0';
local_a8[0x14] = '\0';
local_a8[0x15] = '\0';
local_a8[0x16] = '\0';
local_a8[0x17] = '\0';
local_a8[0x18] = '\0';
local_a8[0x19] = '\0';
local_a8[0x1a] = '\0';
local_a8[0x1b] = '\0';
local_a8[0x1c] = '\0';
local_a8[0x1d] = '\0';
local_a8[0x1e] = '\0';
local_a8[0x1f] = '\0';
local_a8[0x20] = '\0';
local_a8[0x21] = '\0';
local_a8[0x22] = '\0';
local_a8[0x23] = '\0';
local_a8[0x24] = '\0';
local_a8[0x25] = '\0';
local_a8[0x26] = '\0';
local_a8[0x27] = '\0';
local_a8[0x28] = '\0';
local_a8[0x29] = '\0';
local_a8[0x2a] = '\0';
local_a8[0x2b] = '\0';
local_a8[0x2c] = '\0';
local_a8[0x2d] = '\0';
local_a8[0x2e] = '\0';
local_a8[0x2f] = '\0';
local_a8[0x30] = '\0';
local_a8[0x31] = '\0';
local_a8[0x32] = '\0';
local_a8[0x33] = '\0';
local_a8[0x34] = '\0';
local_a8[0x35] = '\0';
local_a8[0x36] = '\0';
local_a8[0x37] = '\0';
local_a8[0x38] = '\0';
local_a8[0x39] = '\0';
local_a8[0x3a] = '\0';
local_a8[0x3b] = '\0';
local_a8[0x3c] = '\0';
local_a8[0x3d] = '\0';
local_a8[0x3e] = '\0';
local_a8[0x3f] = '\0';
local_a8[0x40] = '\0';
local_a8[0x41] = '\0';
local_a8[0x42] = '\0';
local_a8[0x43] = '\0';
local_a8[0x44] = '\0';
local_a8[0x45] = '\0';
local_a8[0x46] = '\0';
local_a8[0x47] = '\0';
local_a8[0x48] = '\0';
local_a8[0x49] = '\0';
local_a8[0x4a] = '\0';
local_a8[0x4b] = '\0';
local_a8[0x4c] = '\0';
local_a8[0x4d] = '\0';
local_a8[0x4e] = '\0';
local_a8[0x4f] = '\0';
local_a8[0x50] = '\0';
local_a8[0x51] = '\0';
local_a8[0x52] = '\0';
local_a8[0x53] = '\0';
local_a8[0x54] = '\0';
local_a8[0x55] = '\0';
local_a8[0x56] = '\0';
local_a8[0x57] = '\0';
local_a8[0x58] = '\0';
local_a8[0x59] = '\0';
local_a8[0x5a] = '\0';
local_a8[0x5b] = '\0';
local_a8[0x5c] = '\0';
local_a8[0x5d] = '\0';
local_a8[0x5e] = '\0';
local_a8[0x5f] = '\0';
local_a8[0x60] = '\0';
local_a8[0x61] = '\0';
local_a8[0x62] = '\0';
local_a8[99] = '\0';
cVar6 = *param_1;
if (cVar6 == '\0') {
iVar8 = 0;
}
else {
iVar8 = 0;
pcVar2 = param_1 + 1;
cVar4 = cVar6;
do {
pcVar1 = strchr("aeiouAEIOU",(int)cVar4);
if (pcVar1 != (char *)0x0) {
local_a8[iVar8] = cVar4;
iVar8 = iVar8 + 1;
}
cVar4 = *pcVar2;
pcVar2 = pcVar2 + 1;
} while (cVar4 != '\0');
local_a8[iVar8] = '\0';
sVar3 = strlen(local_a8);
iVar7 = (int)sVar3 + -1;
lVar5 = 1;
do {
pcVar2 = strchr("aeiouAEIOU",(int)cVar6);
iVar8 = (int)lVar5;
if (pcVar2 != (char *)0x0) {
cVar6 = local_a8[iVar7];
iVar7 = iVar7 + -1;
}
(&DAT_0010403f)[lVar5] = cVar6;
cVar6 = param_1[lVar5];
lVar5 = lVar5 + 1;
} while (cVar6 != '\0');
}
(&result_string_1)[iVar8] = 0;
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return &result_string_1;
} |
4,418 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
j = 0;
int k = strlen(vowels) - 1;
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
result_string[j++] = vowels[k--];
} else {
result_string[j++] = str1[i];
}
}
result_string[j] = '\0';
return result_string;
}
| int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
movzbl (%rdi),%ebp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movl $0x0,0x60(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
test %bpl,%bpl
je 13d0 <func0+0x160>
mov %rdi,%r13
lea 0x1(%rdi),%r12
mov %ebp,%ebx
xor %r14d,%r14d
lea 0xd2a(%rip),%r15
nopw 0x0(%rax,%rax,1)
movsbl %bl,%esi
mov %r15,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 12fa <func0+0x8a>
movslq %r14d,%rax
add $0x1,%r14d
mov %bl,(%rsp,%rax,1)
movzbl (%r12),%ebx
add $0x1,%r12
test %bl,%bl
jne 12e0 <func0+0x70>
movslq %r14d,%r14
mov %rsp,%rsi
movb $0x0,(%rsp,%r14,1)
mov %rsi,%rax
mov (%rax),%ecx
add $0x4,%rax
lea -0x1010101(%rcx),%edx
not %ecx
and %ecx,%edx
and $0x80808080,%edx
je 1315 <func0+0xa5>
mov %edx,%ecx
mov $0x1,%ebx
lea 0x2d04(%rip),%r15
shr $0x10,%ecx
test $0x8080,%edx
lea 0xcb9(%rip),%r14
cmove %ecx,%edx
lea 0x2(%rax),%rcx
cmove %rcx,%rax
mov %edx,%edi
add %dl,%dil
sbb $0x3,%rax
sub %rsi,%rax
lea -0x1(%rax),%r12d
nopw %cs:0x0(%rax,%rax,1)
movsbl %bpl,%esi
mov %r14,%rdi
callq 1080 <strchr@plt>
movslq %ebx,%rdx
test %rax,%rax
je 138f <func0+0x11f>
movslq %r12d,%rax
sub $0x1,%r12d
movzbl (%rsp,%rax,1),%ebp
mov %bpl,(%r15,%rbx,1)
add $0x1,%rbx
movzbl -0x1(%r13,%rbx,1),%ebp
test %bpl,%bpl
jne 1370 <func0+0x100>
lea 0x2c97(%rip),%rax
movb $0x0,(%rax,%rdx,1)
mov 0x68(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13d4 <func0+0x164>
add $0x78,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
xor %edx,%edx
jmp 13a2 <func0+0x132>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
movzx ebp, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+var_48], 0
movaps [rsp+0A8h+var_A8], xmm0
movaps [rsp+0A8h+var_98], xmm0
movaps [rsp+0A8h+var_88], xmm0
movaps [rsp+0A8h+var_78], xmm0
movaps [rsp+0A8h+var_68], xmm0
movaps [rsp+0A8h+var_58], xmm0
test bpl, bpl
jz loc_13B0
mov r14, rdi
lea r12, [rdi+1]
mov ebx, ebp
xor r15d, r15d
lea r13, aAeiouaeiou; "aeiouAEIOU"
nop word ptr [rax+rax+00h]
loc_1300:
movsx esi, bl
mov rdi, r13
call _strchr
test rax, rax
jz short loc_131A
movsxd rax, r15d
add r15d, 1
mov byte ptr [rsp+rax+0A8h+var_A8], bl
loc_131A:
movzx ebx, byte ptr [r12]
add r12, 1
test bl, bl
jnz short loc_1300
movsxd r15, r15d
mov rdi, rsp
mov ebx, 1
mov byte ptr [rsp+r15+0A8h+var_A8], 0
lea r15, unk_403F
call _strlen
lea r12d, [rax-1]
nop word ptr [rax+rax+00000000h]
loc_1350:
movsx esi, bpl
mov rdi, r13
call _strchr
movsxd rdx, ebx
test rax, rax
jz short loc_136F
movsxd rax, r12d
sub r12d, 1
movzx ebp, byte ptr [rsp+rax+0A8h+var_A8]
loc_136F:
mov [r15+rbx], bpl
add rbx, 1
movzx ebp, byte ptr [r14+rbx-1]
test bpl, bpl
jnz short loc_1350
loc_1382:
lea rax, result_string_1
mov byte ptr [rax+rdx], 0
mov rdx, [rsp+0A8h+var_40]
sub rdx, fs:28h
jnz short loc_13B4
add rsp, 78h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13B0:
xor edx, edx
jmp short loc_1382
loc_13B4:
call ___stack_chk_fail | _BYTE * func0(char *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
char v6; // bp
char *v7; // r12
char v8; // bl
int v9; // r15d
long long v10; // rax
long long v11; // rbx
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
int v16; // r12d
long long v17; // rax
long long v18; // rax
_BYTE *result; // rax
__int128 v20; // [rsp+0h] [rbp-A8h] BYREF
__int128 v21; // [rsp+10h] [rbp-98h]
__int128 v22; // [rsp+20h] [rbp-88h]
__int128 v23; // [rsp+30h] [rbp-78h]
__int128 v24; // [rsp+40h] [rbp-68h]
__int128 v25; // [rsp+50h] [rbp-58h]
int v26; // [rsp+60h] [rbp-48h]
unsigned long long v27; // [rsp+68h] [rbp-40h]
v6 = *a1;
v27 = __readfsqword(0x28u);
v26 = 0;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
if ( v6 )
{
v7 = a1 + 1;
v8 = v6;
v9 = 0;
do
{
if ( strchr(
"aeiouAEIOU",
(unsigned int)v8,
a3,
a4,
a5,
a6,
v20,
*((_QWORD *)&v20 + 1),
v21,
*((_QWORD *)&v21 + 1),
v22,
*((_QWORD *)&v22 + 1),
v23,
*((_QWORD *)&v23 + 1),
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
v27) )
{
v10 = v9++;
*((_BYTE *)&v20 + v10) = v8;
}
v8 = *v7++;
}
while ( v8 );
v11 = 1LL;
*((_BYTE *)&v20 + v9) = 0;
v16 = strlen(&v20) - 1;
do
{
v17 = strchr(
"aeiouAEIOU",
(unsigned int)v6,
v12,
v13,
v14,
v15,
v20,
*((_QWORD *)&v20 + 1),
v21,
*((_QWORD *)&v21 + 1),
v22,
*((_QWORD *)&v22 + 1),
v23,
*((_QWORD *)&v23 + 1),
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
v27);
v12 = (int)v11;
if ( v17 )
{
v18 = v16--;
v6 = *((_BYTE *)&v20 + v18);
}
*((_BYTE *)&unk_403F + v11++) = v6;
v6 = a1[v11 - 1];
}
while ( v6 );
}
else
{
v12 = 0LL;
}
result = result_string_1;
result_string_1[v12] = 0;
return result;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOVZX EBP,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x60],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
TEST BPL,BPL
JZ 0x001013b0
MOV R14,RDI
LEA R12,[RDI + 0x1]
MOV EBX,EBP
XOR R15D,R15D
LEA R13,[0x102004]
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOVSX ESI,BL
MOV RDI,R13
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010131a
MOVSXD RAX,R15D
ADD R15D,0x1
MOV byte ptr [RSP + RAX*0x1],BL
LAB_0010131a:
MOVZX EBX,byte ptr [R12]
ADD R12,0x1
TEST BL,BL
JNZ 0x00101300
MOVSXD R15,R15D
MOV RDI,RSP
MOV EBX,0x1
MOV byte ptr [RSP + R15*0x1],0x0
LEA R15,[0x10403f]
CALL 0x00101090
LEA R12D,[RAX + -0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
MOVSX ESI,BPL
MOV RDI,R13
CALL 0x001010b0
MOVSXD RDX,EBX
TEST RAX,RAX
JZ 0x0010136f
MOVSXD RAX,R12D
SUB R12D,0x1
MOVZX EBP,byte ptr [RSP + RAX*0x1]
LAB_0010136f:
MOV byte ptr [R15 + RBX*0x1],BPL
ADD RBX,0x1
MOVZX EBP,byte ptr [R14 + RBX*0x1 + -0x1]
TEST BPL,BPL
JNZ 0x00101350
LAB_00101382:
LEA RAX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
MOV RDX,qword ptr [RSP + 0x68]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b4
ADD RSP,0x78
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013b0:
XOR EDX,EDX
JMP 0x00101382
LAB_001013b4:
CALL 0x001010a0 | void func0(char *param_1)
{
char *pcVar1;
long lVar2;
size_t sVar3;
long lVar4;
char cVar5;
long lVar6;
char cVar7;
char *pcVar8;
int iVar9;
long in_FS_OFFSET;
int1 local_a8 [16];
int1 local_98 [16];
int1 local_88 [16];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int4 local_48;
long local_40;
cVar7 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = 0;
local_a8 = (int1 [16])0x0;
local_98 = (int1 [16])0x0;
local_88 = (int1 [16])0x0;
local_78 = (int1 [16])0x0;
local_68 = (int1 [16])0x0;
local_58 = (int1 [16])0x0;
if (cVar7 == '\0') {
lVar2 = 0;
}
else {
pcVar8 = param_1 + 1;
iVar9 = 0;
cVar5 = cVar7;
do {
pcVar1 = strchr("aeiouAEIOU",(int)cVar5);
if (pcVar1 != (char *)0x0) {
lVar2 = (long)iVar9;
iVar9 = iVar9 + 1;
local_a8[lVar2] = cVar5;
}
cVar5 = *pcVar8;
pcVar8 = pcVar8 + 1;
} while (cVar5 != '\0');
local_a8[iVar9] = 0;
sVar3 = strlen(local_a8);
iVar9 = (int)sVar3 + -1;
lVar6 = 1;
do {
pcVar8 = strchr("aeiouAEIOU",(int)cVar7);
lVar2 = (long)(int)lVar6;
if (pcVar8 != (char *)0x0) {
lVar4 = (long)iVar9;
iVar9 = iVar9 + -1;
cVar7 = local_a8[lVar4];
}
(&DAT_0010403f)[lVar6] = cVar7;
cVar7 = param_1[lVar6];
lVar6 = lVar6 + 1;
} while (cVar7 != '\0');
}
(&result_string_1)[lVar2] = 0;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,419 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
j = 0;
int k = strlen(vowels) - 1;
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
result_string[j++] = vowels[k--];
} else {
result_string[j++] = str1[i];
}
}
result_string[j] = '\0';
return result_string;
}
| int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
movzbl (%rdi),%ebp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movl $0x0,0x60(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
test %bpl,%bpl
je 13f8 <func0+0x188>
mov %rdi,%r12
lea 0x1(%rdi),%r15
mov %ebp,%ebx
xor %r13d,%r13d
lea 0xd2a(%rip),%r14
movsbl %bl,%esi
mov %r14,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 1312 <func0+0xa2>
add $0x1,%r15
mov %bl,(%rsp,%r13,1)
lea 0x1(%r13),%eax
movzbl -0x1(%r15),%ebx
test %bl,%bl
je 1321 <func0+0xb1>
movsbl %bl,%esi
mov %r14,%rdi
movslq %eax,%r13
callq 1080 <strchr@plt>
test %rax,%rax
jne 12ea <func0+0x7a>
movzbl (%r15),%ebx
add $0x1,%r15
test %bl,%bl
jne 12da <func0+0x6a>
mov %r13d,%eax
cltq
mov %rsp,%rsi
movb $0x0,(%rsp,%rax,1)
mov %rsi,%rax
mov (%rax),%ecx
add $0x4,%rax
lea -0x1010101(%rcx),%edx
not %ecx
and %ecx,%edx
and $0x80808080,%edx
je 132d <func0+0xbd>
mov %edx,%ecx
mov $0x1,%r15d
lea 0x2ceb(%rip),%r14
shr $0x10,%ecx
test $0x8080,%edx
lea 0xca0(%rip),%r13
cmove %ecx,%edx
lea 0x2(%rax),%rcx
cmove %rcx,%rax
mov %edx,%edi
add %dl,%dil
sbb $0x3,%rax
sub %rsi,%rax
lea -0x1(%rax),%ebx
xchg %ax,%ax
movsbl %bpl,%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
movslq %r15d,%rdx
test %rax,%rax
je 13b8 <func0+0x148>
movslq %ebx,%rax
lea -0x1(%rbx),%ecx
movzbl (%rsp,%rax,1),%eax
mov %al,(%r14,%r15,1)
add $0x1,%r15
movzbl -0x1(%r12,%r15,1),%ebp
test %bpl,%bpl
je 13cb <func0+0x15b>
mov %ecx,%ebx
jmp 1380 <func0+0x110>
nopl (%rax)
mov %bpl,(%r14,%r15,1)
add $0x1,%r15
movzbl -0x1(%r12,%r15,1),%ebp
test %bpl,%bpl
jne 1380 <func0+0x110>
lea 0x2c6e(%rip),%rax
movb $0x0,(%rax,%rdx,1)
mov 0x68(%rsp),%rdi
xor %fs:0x28,%rdi
jne 13fc <func0+0x18c>
add $0x78,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %edx,%edx
jmp 13cb <func0+0x15b>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
movzx r12d, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+var_48], 0
movaps [rsp+0A8h+var_A8], xmm0
movaps [rsp+0A8h+var_98], xmm0
movaps [rsp+0A8h+var_88], xmm0
movaps [rsp+0A8h+var_78], xmm0
movaps [rsp+0A8h+var_68], xmm0
movaps [rsp+0A8h+var_58], xmm0
test r12b, r12b
jz loc_13D8
mov r14, rdi
lea r15, [rdi+1]
mov ebx, r12d
xor ebp, ebp
lea r13, s; "aeiouAEIOU"
loc_12FB:
movsx esi, bl; c
mov rdi, r13; s
call _strchr
test rax, rax
jz short loc_1331
loc_130B:
add r15, 1
mov byte ptr [rsp+rbp+0A8h+var_A8], bl
lea eax, [rbp+1]
movzx ebx, byte ptr [r15-1]
test bl, bl
jz short loc_133F
movsx esi, bl; c
mov rdi, r13; s
movsxd rbp, eax
call _strchr
test rax, rax
jnz short loc_130B
loc_1331:
movzx ebx, byte ptr [r15]
add r15, 1
test bl, bl
jnz short loc_12FB
mov eax, ebp
loc_133F:
cdqe
mov rdi, rsp; s
mov ebx, 1
mov byte ptr [rsp+rax+0A8h+var_A8], 0
lea r15, unk_403F
call _strlen
lea ebp, [rax-1]
nop dword ptr [rax+00h]
loc_1360:
movsx esi, r12b; c
mov rdi, r13; s
call _strchr
movsxd rdx, ebx
test rax, rax
jz short loc_1398
lea ecx, [rbp-1]
movsxd rbp, ebp
movzx eax, byte ptr [rsp+rbp+0A8h+var_A8]
mov [r15+rbx], al
add rbx, 1
movzx r12d, byte ptr [r14+rbx-1]
test r12b, r12b
jz short loc_13AB
mov ebp, ecx
jmp short loc_1360
loc_1398:
mov [r15+rbx], r12b
add rbx, 1
movzx r12d, byte ptr [r14+rbx-1]
test r12b, r12b
jnz short loc_1360
loc_13AB:
lea rax, result_string_1
mov byte ptr [rax+rdx], 0
mov rdx, [rsp+0A8h+var_40]
sub rdx, fs:28h
jnz short loc_13DC
add rsp, 78h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13D8:
xor edx, edx
jmp short loc_13AB
loc_13DC:
call ___stack_chk_fail | _BYTE * func0(char *a1)
{
char v1; // r12
char *v2; // r15
char v3; // bl
long long v4; // rbp
int v5; // eax
long long v6; // rbx
int v7; // ebp
char *v8; // rax
long long v9; // rdx
_BYTE *result; // rax
_OWORD v11[6]; // [rsp+0h] [rbp-A8h] BYREF
int v12; // [rsp+60h] [rbp-48h]
unsigned long long v13; // [rsp+68h] [rbp-40h]
v1 = *a1;
v13 = __readfsqword(0x28u);
v12 = 0;
memset(v11, 0, sizeof(v11));
if ( v1 )
{
v2 = a1 + 1;
v3 = v1;
v4 = 0LL;
while ( !strchr("aeiouAEIOU", v3) )
{
LABEL_6:
v3 = *v2++;
if ( !v3 )
{
v5 = v4;
goto LABEL_8;
}
}
while ( 1 )
{
++v2;
*((_BYTE *)v11 + v4) = v3;
v5 = v4 + 1;
v3 = *(v2 - 1);
if ( !v3 )
break;
v4 = v5;
if ( !strchr("aeiouAEIOU", v3) )
goto LABEL_6;
}
LABEL_8:
v6 = 1LL;
*((_BYTE *)v11 + v5) = 0;
v7 = strlen((const char *)v11) - 1;
do
{
while ( 1 )
{
v8 = strchr("aeiouAEIOU", v1);
v9 = (int)v6;
if ( !v8 )
break;
*((_BYTE *)&unk_403F + v6++) = *((_BYTE *)v11 + v7);
v1 = a1[v6 - 1];
if ( !v1 )
goto LABEL_13;
--v7;
}
*((_BYTE *)&unk_403F + v6++) = v1;
v1 = a1[v6 - 1];
}
while ( v1 );
}
else
{
v9 = 0LL;
}
LABEL_13:
result = result_string_1;
result_string_1[v9] = 0;
return result;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOVZX R12D,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x60],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
TEST R12B,R12B
JZ 0x001013d8
MOV R14,RDI
LEA R15,[RDI + 0x1]
MOV EBX,R12D
XOR EBP,EBP
LEA R13,[0x102004]
LAB_001012fb:
MOVSX ESI,BL
MOV RDI,R13
CALL 0x001010b0
TEST RAX,RAX
JZ 0x00101331
LAB_0010130b:
ADD R15,0x1
MOV byte ptr [RSP + RBP*0x1],BL
LEA EAX,[RBP + 0x1]
MOVZX EBX,byte ptr [R15 + -0x1]
TEST BL,BL
JZ 0x0010133f
MOVSX ESI,BL
MOV RDI,R13
MOVSXD RBP,EAX
CALL 0x001010b0
TEST RAX,RAX
JNZ 0x0010130b
LAB_00101331:
MOVZX EBX,byte ptr [R15]
ADD R15,0x1
TEST BL,BL
JNZ 0x001012fb
MOV EAX,EBP
LAB_0010133f:
CDQE
MOV RDI,RSP
MOV EBX,0x1
MOV byte ptr [RSP + RAX*0x1],0x0
LEA R15,[0x10403f]
CALL 0x00101090
LEA EBP,[RAX + -0x1]
NOP dword ptr [RAX]
LAB_00101360:
MOVSX ESI,R12B
MOV RDI,R13
CALL 0x001010b0
MOVSXD RDX,EBX
TEST RAX,RAX
JZ 0x00101398
LEA ECX,[RBP + -0x1]
MOVSXD RBP,EBP
MOVZX EAX,byte ptr [RSP + RBP*0x1]
MOV byte ptr [R15 + RBX*0x1],AL
ADD RBX,0x1
MOVZX R12D,byte ptr [R14 + RBX*0x1 + -0x1]
TEST R12B,R12B
JZ 0x001013ab
MOV EBP,ECX
JMP 0x00101360
LAB_00101398:
MOV byte ptr [R15 + RBX*0x1],R12B
ADD RBX,0x1
MOVZX R12D,byte ptr [R14 + RBX*0x1 + -0x1]
TEST R12B,R12B
JNZ 0x00101360
LAB_001013ab:
LEA RAX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
MOV RDX,qword ptr [RSP + 0x68]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013dc
ADD RSP,0x78
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013d8:
XOR EDX,EDX
JMP 0x001013ab
LAB_001013dc:
CALL 0x001010a0 | void func0(char *param_1)
{
int iVar1;
char *pcVar2;
size_t sVar3;
char cVar4;
long lVar5;
long lVar6;
char cVar7;
char *pcVar8;
long in_FS_OFFSET;
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
int4 local_48;
long local_40;
cVar7 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = 0;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_88 = (int [16])0x0;
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
local_58 = (int [16])0x0;
if (cVar7 == '\0') {
lVar6 = 0;
}
else {
pcVar8 = param_1 + 1;
lVar6 = 0;
cVar4 = cVar7;
do {
pcVar2 = strchr("aeiouAEIOU",(int)cVar4);
while (iVar1 = (int)lVar6, pcVar2 != (char *)0x0) {
local_a8[lVar6] = cVar4;
iVar1 = iVar1 + 1;
cVar4 = *pcVar8;
if (cVar4 == '\0') goto LAB_0010133f;
lVar6 = (long)iVar1;
pcVar2 = strchr("aeiouAEIOU",(int)cVar4);
pcVar8 = pcVar8 + 1;
}
cVar4 = *pcVar8;
pcVar8 = pcVar8 + 1;
} while (cVar4 != '\0');
LAB_0010133f:
local_a8[iVar1] = 0;
sVar3 = strlen(local_a8);
lVar5 = 1;
iVar1 = (int)sVar3 + -1;
do {
while( true ) {
pcVar8 = strchr("aeiouAEIOU",(int)cVar7);
lVar6 = (long)(int)lVar5;
if (pcVar8 == (char *)0x0) break;
(&DAT_0010403f)[lVar5] = local_a8[iVar1];
cVar7 = param_1[lVar5];
lVar5 = lVar5 + 1;
iVar1 = iVar1 + -1;
if (cVar7 == '\0') goto LAB_001013ab;
}
(&DAT_0010403f)[lVar5] = cVar7;
cVar7 = param_1[lVar5];
lVar5 = lVar5 + 1;
} while (cVar7 != '\0');
}
LAB_001013ab:
(&result_string_1)[lVar6] = 0;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,420 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov -0x8(%rbp),%rdx
mov -0x10(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1080 <strcpy@plt>
mov -0x10(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+src], rdi
mov [rbp+dest], rsi
mov rdx, [rbp+src]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+dest]
leave
retn | char * func0(const char *a1, char *a2)
{
strcpy(a2, a1);
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x10]
LEAVE
RET | char * func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return param_2;
} |
4,421 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %rsi,%rbx
mov %rdi,%rsi
mov %rbx,%rdi
callq 1070 <strcpy@plt>
pop %rbx
retq
| func0:
endbr64
push rbx
mov rbx, rsi
mov rsi, rdi
mov rdi, rbx
call _strcpy
pop rbx
retn | long long func0(long long a1, long long a2)
{
return strcpy(a2, a1);
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RSI
MOV RSI,RDI
MOV RDI,RBX
CALL 0x00101080
POP RBX
RET | void func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return;
} |
4,422 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %rsi,%r8
sub $0x8,%rsp
mov %rdi,%rsi
mov %r8,%rdi
callq 1070 <strcpy@plt>
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r8, rsi
sub rsp, 8
mov rsi, rdi
mov rdi, r8
call _strcpy
add rsp, 8
retn | long long func0(long long a1, long long a2)
{
return strcpy(a2, a1);
} | func0:
ENDBR64
MOV R8,RSI
SUB RSP,0x8
MOV RSI,RDI
MOV RDI,R8
CALL 0x00101060
ADD RSP,0x8
RET | void func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return;
} |
4,423 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov %rsi,%r8
sub $0x8,%rsp
mov %rdi,%rsi
mov %r8,%rdi
callq 1070 <strcpy@plt>
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov rdx, rsi
sub rsp, 8
mov rsi, rdi; src
mov rdi, rdx; dest
call _strcpy
add rsp, 8
retn | char * func0(char *src, char *dest)
{
return strcpy(dest, src);
} | func0:
ENDBR64
MOV RDX,RSI
SUB RSP,0x8
MOV RSI,RDI
MOV RDI,RDX
CALL 0x00101070
ADD RSP,0x8
RET | void func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return;
} |
4,424 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11bf <func0+0x56>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jns 11bb <func0+0x52>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11BF
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jns short loc_11BB
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_11BB:
add [rbp+var_4], 1
loc_11BF:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) < 0 )
v3 += *(_DWORD *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bf
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNS 0x001011bb
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011bb:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011bf:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < 0) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
}
return local_10;
} |
4,425 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1197 <func0+0x2e>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test %ecx,%ecx
cmovs %esi,%edx
add $0x4,%rax
cmp %rdi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1194 <func0+0x2b>
| func0:
endbr64
test esi, esi
jle short loc_1197
mov rax, rdi
lea edx, [rsi-1]
lea rdi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
mov ecx, [rax]
lea esi, [rdx+rcx]
test ecx, ecx
cmovs edx, esi
add rax, 4
cmp rax, rdi
jnz short loc_1181
loc_1194:
mov eax, edx
retn
loc_1197:
mov edx, 0
jmp short loc_1194 | long long func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rdi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
if ( *v2 < 0 )
v4 += *v2;
++v2;
}
while ( v2 != (int *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101197
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST ECX,ECX
CMOVS EDX,ESI
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101181
LAB_00101194:
MOV EAX,EDX
RET
LAB_00101197:
MOV EDX,0x0
JMP 0x00101194 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (*param_1 < 0) {
iVar2 = iVar2 + *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
4,426 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1390 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%edx
test %edx,%edx
lea (%rax,%rdx,1),%ecx
cmovs %ecx,%eax
add $0x4,%rdi
cmp %rsi,%rdi
jne 1378 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1390
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1378:
mov edx, [rdi]
test edx, edx
lea ecx, [rax+rdx]
cmovs eax, ecx
add rdi, 4
cmp rdi, rsi
jnz short loc_1378
retn
loc_1390:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long v2; // rsi
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
result = 0LL;
do
{
if ( *a1 < 0 )
result = (unsigned int)(result + *a1);
++a1;
}
while ( a1 != (int *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101390
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101378:
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
LEA ECX,[RAX + RDX*0x1]
CMOVS EAX,ECX
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101378
RET
LAB_00101390:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (*param_1 < 0) {
iVar2 = iVar2 + *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
4,427 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1418 <func0+0xb8>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1421 <func0+0xc1>
mov %esi,%edx
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%edx
movdqa %xmm0,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm1
movdqu (%rax),%xmm3
add $0x10,%rax
pcmpgtd %xmm2,%xmm1
pandn %xmm3,%xmm1
paddd %xmm1,%xmm0
cmp %rdx,%rax
jne 1390 <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 1420 <func0+0xc0>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
test %ecx,%ecx
lea 0x1(%rdx),%ecx
cmovs %r8d,%eax
cmp %esi,%ecx
jge 141a <func0+0xba>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
test %ecx,%ecx
lea (%rax,%rcx,1),%r8d
cmovs %r8d,%eax
add $0x2,%edx
cmp %esi,%edx
jge 141a <func0+0xba>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
lea (%rax,%rdx,1),%ecx
test %edx,%edx
cmovs %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 13d6 <func0+0x76>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1200
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1209
mov edx, esi
pxor xmm0, xmm0
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1178:
movdqu xmm3, xmmword ptr [rax]
movdqa xmm1, xmm2
add rax, 10h
pcmpgtd xmm1, xmm3
pand xmm1, xmm3
paddd xmm0, xmm1
cmp rdx, rax
jnz short loc_1178
movdqa xmm1, xmm0
mov edx, ecx
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test cl, 3
jz short locret_1208
loc_11BD:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
lea r9d, [rax+rsi]
test esi, esi
lea esi, [rdx+1]
cmovs eax, r9d
cmp ecx, esi
jle short locret_1202
mov esi, [rdi+r8+4]
test esi, esi
lea r9d, [rax+rsi]
cmovs eax, r9d
add edx, 2
cmp ecx, edx
jle short locret_1202
mov edx, [rdi+r8+8]
lea ecx, [rax+rdx]
test edx, edx
cmovs eax, ecx
retn
loc_1200:
xor eax, eax
locret_1202:
retn
locret_1208:
retn
loc_1209:
xor edx, edx
xor eax, eax
jmp short loc_11BD | long long func0(const __m128i *a1, int a2)
{
__m128i v3; // xmm0
const __m128i *v4; // rax
__m128i v5; // xmm3
signed int v6; // edx
__m128i v7; // xmm0
long long result; // rax
long long v9; // r8
int v10; // esi
int v11; // esi
int v12; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v6 = 0;
result = 0LL;
}
else
{
v3 = 0LL;
v4 = a1;
do
{
v5 = _mm_loadu_si128(v4++);
v3 = _mm_add_epi32(v3, _mm_and_si128(_mm_cmpgt_epi32((__m128i)0LL, v5), v5));
}
while ( &a1[(unsigned int)a2 >> 2] != v4 );
v6 = a2 & 0xFFFFFFFC;
v7 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v7, _mm_srli_si128(v7, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v9 = v6;
v10 = a1->m128i_i32[v9];
if ( v10 < 0 )
result = (unsigned int)(result + v10);
if ( a2 > v6 + 1 )
{
v11 = a1->m128i_i32[v9 + 1];
if ( v11 < 0 )
result = (unsigned int)(result + v11);
if ( a2 > v6 + 2 )
{
v12 = a1->m128i_i32[v9 + 2];
if ( v12 < 0 )
return (unsigned int)(result + v12);
}
}
return result;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101200
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101209
MOV EDX,ESI
PXOR XMM0,XMM0
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQA XMM1,XMM2
ADD RAX,0x10
PCMPGTD XMM1,XMM3
PAND XMM1,XMM3
PADDD XMM0,XMM1
CMP RDX,RAX
JNZ 0x00101178
MOVDQA XMM1,XMM0
MOV EDX,ECX
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x00101208
LAB_001011bd:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
LEA R9D,[RAX + RSI*0x1]
TEST ESI,ESI
LEA ESI,[RDX + 0x1]
CMOVS EAX,R9D
CMP ECX,ESI
JLE 0x00101202
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
TEST ESI,ESI
LEA R9D,[RAX + RSI*0x1]
CMOVS EAX,R9D
ADD EDX,0x2
CMP ECX,EDX
JLE 0x00101202
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
LEA ECX,[RAX + RDX*0x1]
TEST EDX,EDX
CMOVS EAX,ECX
RET
LAB_00101200:
XOR EAX,EAX
LAB_00101202:
RET
LAB_00101208:
RET
LAB_00101209:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011bd | int func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if ((int)param_2 < 1) {
iVar6 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar5 = 0;
iVar6 = 0;
}
else {
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
puVar4 = param_1;
do {
uVar5 = *puVar4;
puVar1 = puVar4 + 1;
puVar2 = puVar4 + 2;
puVar3 = puVar4 + 3;
puVar4 = puVar4 + 4;
iVar6 = iVar6 + (-(uint)((int)uVar5 < 0) & uVar5);
iVar7 = iVar7 + (-(uint)((int)*puVar1 < 0) & *puVar1);
iVar8 = iVar8 + (-(uint)((int)*puVar2 < 0) & *puVar2);
iVar9 = iVar9 + (-(uint)((int)*puVar3 < 0) & *puVar3);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != puVar4);
uVar5 = param_2 & 0xfffffffc;
iVar6 = iVar6 + iVar8 + iVar7 + iVar9;
if ((param_2 & 3) == 0) {
return iVar6;
}
}
if ((int)param_1[(int)uVar5] < 0) {
iVar6 = iVar6 + param_1[(int)uVar5];
}
if ((int)(uVar5 + 1) < (int)param_2) {
if ((int)param_1[(long)(int)uVar5 + 1] < 0) {
iVar6 = iVar6 + param_1[(long)(int)uVar5 + 1];
}
if ((int)(uVar5 + 2) < (int)param_2) {
if ((int)param_1[(long)(int)uVar5 + 2] < 0) {
iVar6 = iVar6 + param_1[(long)(int)uVar5 + 2];
}
return iVar6;
}
}
}
return iVar6;
} |
4,428 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
int arr3[3] = {1, 2, 3};
assert(func0(arr3, 3, 1)[0] == 'O' && func0(arr3, 3, 1)[1] == 'D' && func0(arr3, 3, 1)[2] == 'D');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a8 <func0+0x3f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
cmpl $0x1,-0x20(%rbp)
jne 11d2 <func0+0x69>
mov -0x8(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 11c9 <func0+0x60>
lea 0xe41(%rip),%rax
jmp 11d9 <func0+0x70>
lea 0xe3c(%rip),%rax
jmp 11d9 <func0+0x70>
lea 0xe33(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A8
loc_118B:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_11A8:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118B
cmp [rbp+var_20], 1
jnz short loc_11D2
mov eax, [rbp+var_8]
and eax, 1
test eax, eax
jnz short loc_11C9
lea rax, unk_2008
jmp short loc_11D9
loc_11C9:
lea rax, aEven; "EVEN"
jmp short loc_11D9
loc_11D2:
lea rax, aEven; "EVEN"
loc_11D9:
pop rbp
retn | const char * func0(long long a1, int a2, int a3)
{
int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
v4 += *(_DWORD *)(4LL * i + a1);
if ( a3 != 1 )
return "EVEN";
if ( (v4 & 1) != 0 )
return "EVEN";
return (const char *)&unk_2008;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a8
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
CMP dword ptr [RBP + -0x20],0x1
JNZ 0x001011d2
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011c9
LEA RAX,[0x102008]
JMP 0x001011d9
LAB_001011c9:
LEA RAX,[0x10200c]
JMP 0x001011d9
LAB_001011d2:
LEA RAX,[0x10200c]
LAB_001011d9:
POP RBP
RET | int * func0(long param_1,int param_2,int param_3)
{
int *puVar1;
uint local_10;
int local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
if (param_3 == 1) {
if ((local_10 & 1) == 0) {
puVar1 = &DAT_00102008;
}
else {
puVar1 = &DAT_0010200c;
}
}
else {
puVar1 = &DAT_0010200c;
}
return puVar1;
} |
4,429 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
int arr3[3] = {1, 2, 3};
assert(func0(arr3, 3, 1)[0] == 'O' && func0(arr3, 3, 1)[1] == 'D' && func0(arr3, 3, 1)[2] == 'D');
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1199 <func0+0x30>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rsi
mov $0x0,%ecx
add (%rax),%ecx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
lea 0xe75(%rip),%rax
cmp $0x1,%edx
je 11a0 <func0+0x37>
retq
mov $0x0,%ecx
jmp 118c <func0+0x23>
test $0x1,%cl
lea 0xe5a(%rip),%rax
lea 0xe57(%rip),%rdx
cmovne %rdx,%rax
jmp 1198 <func0+0x2f>
| func0:
endbr64
test esi, esi
jle short loc_1199
mov rax, rdi
lea ecx, [rsi-1]
lea rsi, [rdi+rcx*4+4]
mov ecx, 0
loc_1181:
add ecx, [rax]
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_118C:
lea rax, aEven; "EVEN"
cmp edx, 1
jz short loc_11A0
locret_1198:
retn
loc_1199:
mov ecx, 0
jmp short loc_118C
loc_11A0:
test cl, 1
lea rax, unk_2004
lea rdx, aEven; "EVEN"
cmovnz rax, rdx
jmp short locret_1198 | const char * func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
long long v4; // rsi
int v5; // ecx
const char *result; // rax
if ( a2 <= 0 )
{
LOBYTE(v5) = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
v5 += *v3++;
while ( v3 != (_DWORD *)v4 );
}
result = "EVEN";
if ( a3 == 1 )
{
result = (const char *)&unk_2004;
if ( (v5 & 1) != 0 )
return "EVEN";
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101199
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RSI,[RDI + RCX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
ADD ECX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_0010118c:
LEA RAX,[0x102008]
CMP EDX,0x1
JZ 0x001011a0
LAB_00101198:
RET
LAB_00101199:
MOV ECX,0x0
JMP 0x0010118c
LAB_001011a0:
TEST CL,0x1
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVNZ RAX,RDX
JMP 0x00101198 | int * func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int *puVar2;
uint uVar3;
if (param_2 < 1) {
uVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar3 = 0;
do {
uVar3 = uVar3 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
puVar2 = &DAT_00102008;
if ((param_3 == 1) && (puVar2 = &DAT_00102004, (uVar3 & 1) != 0)) {
puVar2 = &DAT_00102008;
}
return puVar2;
} |
4,430 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
int arr3[3] = {1, 2, 3};
assert(func0(arr3, 3, 1)[0] == 'O' && func0(arr3, 3, 1)[1] == 'D' && func0(arr3, 3, 1)[2] == 'D');
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
lea 0xe9a(%rip),%r8
cmp $0x1,%edx
jne 117c <func0+0x3c>
test $0x1,%al
lea 0xe91(%rip),%rax
cmove %rax,%r8
mov %r8,%rax
retq
xor %eax,%eax
jmp 1163 <func0+0x23>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1180
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
add eax, [rdi]
add rdi, 4
cmp rdi, rcx
jnz short loc_1158
loc_1163:
lea r8, aEven; "EVEN"
cmp edx, 1
jnz short loc_117C
test al, 1
lea rax, unk_2004
cmovz r8, rax
loc_117C:
mov rax, r8
retn
loc_1180:
xor eax, eax
jmp short loc_1163 | const char * func0(_DWORD *a1, int a2, int a3)
{
long long v3; // rcx
int v4; // eax
const char *v5; // r8
if ( a2 <= 0 )
{
LOBYTE(v4) = 0;
}
else
{
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 += *a1++;
while ( a1 != (_DWORD *)v3 );
}
v5 = "EVEN";
if ( a3 == 1 && (v4 & 1) == 0 )
return (const char *)&unk_2004;
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RCX
JNZ 0x00101158
LAB_00101163:
LEA R8,[0x102008]
CMP EDX,0x1
JNZ 0x0010117c
TEST AL,0x1
LEA RAX,[0x102004]
CMOVZ R8,RAX
LAB_0010117c:
MOV RAX,R8
RET
LAB_00101180:
XOR EAX,EAX
JMP 0x00101163 | int * func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
uint uVar2;
int *puVar3;
if (param_2 < 1) {
uVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = uVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
puVar3 = &DAT_00102008;
if ((param_3 == 1) && ((uVar2 & 1) == 0)) {
puVar3 = &DAT_00102004;
}
return puVar3;
} |
4,431 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
int arr3[3] = {1, 2, 3};
assert(func0(arr3, 3, 1)[0] == 'O' && func0(arr3, 3, 1)[1] == 'D' && func0(arr3, 3, 1)[2] == 'D');
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1200 <func0+0xc0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1204 <func0+0xc4>
mov %esi,%ecx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%ecx
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rcx,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 11de <func0+0x9e>
movslq %ecx,%r8
add (%rdi,%r8,4),%eax
lea 0x1(%rcx),%r8d
cmp %r8d,%esi
jle 11de <func0+0x9e>
movslq %r8d,%r8
add (%rdi,%r8,4),%eax
lea 0x2(%rcx),%r8d
cmp %r8d,%esi
jle 11de <func0+0x9e>
movslq %r8d,%r8
add $0x3,%ecx
add (%rdi,%r8,4),%eax
cmp %ecx,%esi
jle 11de <func0+0x9e>
movslq %ecx,%rcx
add (%rdi,%rcx,4),%eax
lea 0xe1f(%rip),%r8
cmp $0x1,%edx
jne 11f7 <func0+0xb7>
test $0x1,%al
lea 0xe16(%rip),%rax
cmove %rax,%r8
mov %r8,%rax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
jmp 11de <func0+0x9e>
xor %ecx,%ecx
xor %eax,%eax
jmp 11aa <func0+0x6a>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, esi
mov r8d, edx
test esi, esi
jle loc_11F0
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1209
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rax, rdx
jnz short loc_1170
movdqa xmm1, xmm0
mov edx, ecx
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test cl, 3
jz short loc_11CF
loc_11A9:
movsxd rsi, edx
lea r9, ds:0[rsi*4]
add eax, [rdi+rsi*4]
lea esi, [rdx+1]
cmp ecx, esi
jle short loc_11CF
add edx, 2
add eax, [rdi+r9+4]
cmp ecx, edx
jle short loc_11CF
add eax, [rdi+r9+8]
loc_11CF:
lea rdx, aEven; "EVEN"
cmp r8d, 1
jnz short loc_11E9
test al, 1
lea rax, unk_2004
cmovz rdx, rax
loc_11E9:
mov rax, rdx
retn
loc_11F0:
cmp edx, 1
lea rax, aEven; "EVEN"
lea rdx, unk_2004
cmovnz rdx, rax
mov rax, rdx
retn
loc_1209:
xor edx, edx
xor eax, eax
jmp short loc_11A9 | const char * func0(const __m128i *a1, int a2, int a3)
{
const __m128i *v4; // rax
__m128i v5; // xmm0
__m128i v6; // xmm2
signed int v7; // edx
__m128i v8; // xmm0
int v9; // eax
long long v10; // r9
const char *v11; // rdx
bool v13; // zf
void *v14; // rdx
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v7 = 0;
v9 = 0;
}
else
{
v4 = a1;
v5 = 0LL;
do
{
v6 = _mm_loadu_si128(v4++);
v5 = _mm_add_epi32(v5, v6);
}
while ( v4 != &a1[(unsigned int)a2 >> 2] );
v7 = a2 & 0xFFFFFFFC;
v8 = _mm_add_epi32(v5, _mm_srli_si128(v5, 8));
v9 = _mm_cvtsi128_si32(_mm_add_epi32(v8, _mm_srli_si128(v8, 4)));
if ( (a2 & 3) == 0 )
{
LABEL_9:
v11 = "EVEN";
if ( a3 == 1 && (v9 & 1) == 0 )
return (const char *)&unk_2004;
return v11;
}
}
v10 = v7;
v9 += a1->m128i_i32[v10];
if ( a2 > v7 + 1 )
{
v9 += a1->m128i_i32[v10 + 1];
if ( a2 > v7 + 2 )
v9 += a1->m128i_i32[v10 + 2];
}
goto LABEL_9;
}
v13 = a3 == 1;
v14 = &unk_2004;
if ( !v13 )
return "EVEN";
return (const char *)v14;
} | func0:
ENDBR64
MOV ECX,ESI
MOV R8D,EDX
TEST ESI,ESI
JLE 0x001011f0
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101209
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ECX
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x001011cf
LAB_001011a9:
MOVSXD RSI,EDX
LEA R9,[RSI*0x4]
ADD EAX,dword ptr [RDI + RSI*0x4]
LEA ESI,[RDX + 0x1]
CMP ECX,ESI
JLE 0x001011cf
ADD EDX,0x2
ADD EAX,dword ptr [RDI + R9*0x1 + 0x4]
CMP ECX,EDX
JLE 0x001011cf
ADD EAX,dword ptr [RDI + R9*0x1 + 0x8]
LAB_001011cf:
LEA RDX,[0x102008]
CMP R8D,0x1
JNZ 0x001011e9
TEST AL,0x1
LEA RAX,[0x102004]
CMOVZ RDX,RAX
LAB_001011e9:
MOV RAX,RDX
RET
LAB_001011f0:
CMP EDX,0x1
LEA RAX,[0x102008]
LEA RDX,[0x102004]
CMOVNZ RDX,RAX
MOV RAX,RDX
RET
LAB_00101209:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011a9 | int * func0(int *param_1,uint param_2,int param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int *puVar7;
int iVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
if ((int)param_2 < 1) {
puVar7 = &DAT_00102004;
if (param_3 != 1) {
puVar7 = &DAT_00102008;
}
return puVar7;
}
if (param_2 - 1 < 3) {
uVar6 = 0;
uVar9 = 0;
}
else {
iVar8 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar8 = iVar8 + iVar1;
iVar10 = iVar10 + *piVar2;
iVar11 = iVar11 + *piVar3;
iVar12 = iVar12 + *piVar4;
} while (piVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
uVar9 = iVar8 + iVar11 + iVar10 + iVar12;
if ((param_2 & 3) == 0) goto LAB_001011cf;
}
uVar9 = uVar9 + param_1[(int)uVar6];
if (((int)(uVar6 + 1) < (int)param_2) &&
(uVar9 = uVar9 + param_1[(long)(int)uVar6 + 1], (int)(uVar6 + 2) < (int)param_2)) {
uVar9 = uVar9 + param_1[(long)(int)uVar6 + 2];
}
LAB_001011cf:
puVar7 = &DAT_00102008;
if ((param_3 == 1) && ((uVar9 & 1) == 0)) {
puVar7 = &DAT_00102004;
}
return puVar7;
} |
4,432 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add %eax,%eax
sub $0x1,%eax
imul -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, eax
sub eax, 1
imul eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
SUB EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,433 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rdi,%rdi,1),%eax
imul %edi,%eax
retq
| func0:
endbr64
lea eax, [rdi+rdi-1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1 + -0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,434 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rdi,%rdi,1),%eax
imul %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, [rdi+rdi-1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1 + -0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,435 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rdi,%rdi,1),%eax
imul %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, [rdi+rdi-1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1 + -0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,436 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((units - 100) * 5.26);
surcharge = 45;
} else {
amount = 130 + 162.50 + 526 + ((units - 200) * 8.45);
surcharge = 75;
}
double total = amount + surcharge;
return total;
}
| int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
cmpl $0x31,-0x24(%rbp)
jg 117c <func0+0x33>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd 0xf21(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
movl $0x19,-0x14(%rbp)
jmpq 121b <func0+0xd2>
cmpl $0x64,-0x24(%rbp)
jg 11b2 <func0+0x69>
mov -0x24(%rbp),%eax
sub $0x32,%eax
cvtsi2sd %eax,%xmm1
movsd 0xefc(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xef8(%rip),%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
movl $0x23,-0x14(%rbp)
jmp 121b <func0+0xd2>
cmpl $0xc8,-0x24(%rbp)
jg 11eb <func0+0xa2>
mov -0x24(%rbp),%eax
sub $0x64,%eax
cvtsi2sd %eax,%xmm1
movsd 0xed3(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xecf(%rip),%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
movl $0x2d,-0x14(%rbp)
jmp 121b <func0+0xd2>
mov -0x24(%rbp),%eax
sub $0xc8,%eax
cvtsi2sd %eax,%xmm1
movsd 0xeb1(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xead(%rip),%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
movl $0x4b,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd -0x10(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
cmp [rbp+var_24], 31h ; '1'
jg short loc_1180
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_24]
movsd xmm0, cs:qword_2070
mulsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov [rbp+var_14], 19h
jmp loc_122B
loc_1180:
cmp [rbp+var_24], 64h ; 'd'
jg short loc_11BA
mov eax, [rbp+var_24]
sub eax, 32h ; '2'
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movsd xmm0, cs:qword_2078
mulsd xmm1, xmm0
movsd xmm0, cs:qword_2080
addsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov [rbp+var_14], 23h ; '#'
jmp short loc_122B
loc_11BA:
cmp [rbp+var_24], 0C8h
jg short loc_11F7
mov eax, [rbp+var_24]
sub eax, 64h ; 'd'
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movsd xmm0, cs:qword_2088
mulsd xmm1, xmm0
movsd xmm0, cs:qword_2090
addsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov [rbp+var_14], 2Dh ; '-'
jmp short loc_122B
loc_11F7:
mov eax, [rbp+var_24]
sub eax, 0C8h
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movsd xmm0, cs:qword_2098
mulsd xmm1, xmm0
movsd xmm0, cs:qword_20A0
addsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov [rbp+var_14], 4Bh ; 'K'
loc_122B:
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_14]
movsd xmm1, [rbp+var_10]
addsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(int a1)
{
int v2; // [rsp+10h] [rbp-14h]
double v3; // [rsp+14h] [rbp-10h]
if ( a1 > 49 )
{
if ( a1 > 100 )
{
if ( a1 > 200 )
{
v3 = (double)(a1 - 200) * 8.449999999999999 + 818.5;
v2 = 75;
}
else
{
v3 = (double)(a1 - 100) * 5.26 + 292.5;
v2 = 45;
}
}
else
{
v3 = (double)(a1 - 50) * 3.25 + 130.0;
v2 = 35;
}
}
else
{
v3 = 2.6 * (double)a1;
v2 = 25;
}
return (double)v2 + v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
CMP dword ptr [RBP + -0x24],0x31
JG 0x00101180
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x24]
MOVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x14],0x19
JMP 0x0010122b
LAB_00101180:
CMP dword ptr [RBP + -0x24],0x64
JG 0x001011ba
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x32
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [0x00102078]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102080]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x14],0x23
JMP 0x0010122b
LAB_001011ba:
CMP dword ptr [RBP + -0x24],0xc8
JG 0x001011f7
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x64
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [0x00102088]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102090]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x14],0x2d
JMP 0x0010122b
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc8
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [0x00102098]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x001020a0]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x14],0x4b
LAB_0010122b:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x14]
MOVSD XMM1,qword ptr [RBP + -0x10]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(int param_1)
{
int4 local_1c;
int8 local_18;
if (param_1 < 0x32) {
local_18 = DAT_00102070 * (double)param_1;
local_1c = 0x19;
}
else if (param_1 < 0x65) {
local_18 = DAT_00102080 + (double)(param_1 + -0x32) * DAT_00102078;
local_1c = 0x23;
}
else if (param_1 < 0xc9) {
local_18 = DAT_00102090 + (double)(param_1 + -100) * DAT_00102088;
local_1c = 0x2d;
}
else {
local_18 = DAT_001020a0 + (double)(param_1 + -200) * DAT_00102098;
local_1c = 0x4b;
}
return (double)local_1c + local_18;
} |
4,437 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((units - 100) * 5.26);
surcharge = 45;
} else {
amount = 130 + 162.50 + 526 + ((units - 200) * 8.45);
surcharge = 75;
}
double total = amount + surcharge;
return total;
}
| int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x31,%edi
jg 1154 <func0+0x2b>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xec6(%rip),%xmm0
mov $0x19,%eax
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
addsd %xmm1,%xmm0
retq
cmp $0x64,%edi
jg 117b <func0+0x52>
sub $0x32,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xea4(%rip),%xmm0
addsd 0xea4(%rip),%xmm0
mov $0x23,%eax
jmp 1147 <func0+0x1e>
cmp $0xc8,%edi
jg 11a5 <func0+0x7c>
sub $0x64,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xe8a(%rip),%xmm0
addsd 0xe8a(%rip),%xmm0
mov $0x2d,%eax
jmp 1147 <func0+0x1e>
sub $0xc8,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xe75(%rip),%xmm0
addsd 0xe75(%rip),%xmm0
mov $0x4b,%eax
jmpq 1147 <func0+0x1e>
| func0:
endbr64
cmp edi, 31h ; '1'
jg short loc_1154
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm1, cs:qword_2008
mov eax, 19h
loc_1147:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
addsd xmm0, xmm1
retn
loc_1154:
cmp edi, 64h ; 'd'
jg short loc_117B
sub edi, 32h ; '2'
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm1, cs:qword_2010
addsd xmm1, cs:qword_2018
mov eax, 23h ; '#'
jmp short loc_1147
loc_117B:
cmp edi, 0C8h
jg short loc_11A5
sub edi, 64h ; 'd'
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm1, cs:qword_2020
addsd xmm1, cs:qword_2028
mov eax, 2Dh ; '-'
jmp short loc_1147
loc_11A5:
sub edi, 0C8h
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm1, cs:qword_2030
addsd xmm1, cs:qword_2038
mov eax, 4Bh ; 'K'
jmp loc_1147 | double func0(int a1)
{
double v1; // xmm1_8
int v2; // eax
if ( a1 > 49 )
{
if ( a1 > 100 )
{
if ( a1 > 200 )
{
v1 = (double)(a1 - 200) * 8.449999999999999 + 818.5;
v2 = 75;
}
else
{
v1 = (double)(a1 - 100) * 5.26 + 292.5;
v2 = 45;
}
}
else
{
v1 = (double)(a1 - 50) * 3.25 + 130.0;
v2 = 35;
}
}
else
{
v1 = (double)a1 * 2.6;
v2 = 25;
}
return (double)v2 + v1;
} | func0:
ENDBR64
CMP EDI,0x31
JG 0x00101154
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM1,qword ptr [0x00102008]
MOV EAX,0x19
LAB_00101147:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
ADDSD XMM0,XMM1
RET
LAB_00101154:
CMP EDI,0x64
JG 0x0010117b
SUB EDI,0x32
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM1,qword ptr [0x00102010]
ADDSD XMM1,qword ptr [0x00102018]
MOV EAX,0x23
JMP 0x00101147
LAB_0010117b:
CMP EDI,0xc8
JG 0x001011a5
SUB EDI,0x64
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM1,qword ptr [0x00102020]
ADDSD XMM1,qword ptr [0x00102028]
MOV EAX,0x2d
JMP 0x00101147
LAB_001011a5:
SUB EDI,0xc8
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM1,qword ptr [0x00102030]
ADDSD XMM1,qword ptr [0x00102038]
MOV EAX,0x4b
JMP 0x00101147 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
int iVar1;
double dVar2;
if (param_1 < 0x32) {
dVar2 = (double)param_1 * _DAT_00102008;
iVar1 = 0x19;
}
else if (param_1 < 0x65) {
dVar2 = (double)(param_1 + -0x32) * _DAT_00102010 + _DAT_00102018;
iVar1 = 0x23;
}
else if (param_1 < 0xc9) {
dVar2 = (double)(param_1 + -100) * _DAT_00102020 + _DAT_00102028;
iVar1 = 0x2d;
}
else {
dVar2 = (double)(param_1 + -200) * _DAT_00102030 + _DAT_00102038;
iVar1 = 0x4b;
}
return (double)iVar1 + dVar2;
} |
4,438 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((units - 100) * 5.26);
surcharge = 45;
} else {
amount = 130 + 162.50 + 526 + ((units - 200) * 8.45);
surcharge = 75;
}
double total = amount + surcharge;
return total;
}
| int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x31,%edi
jg 1170 <func0+0x30>
pxor %xmm0,%xmm0
movsd 0xeb3(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xec7(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
cmp $0x64,%edi
jg 11a0 <func0+0x60>
sub $0x32,%edi
pxor %xmm0,%xmm0
movsd 0xe8c(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xea0(%rip),%xmm0
addsd 0xea0(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopl (%rax)
cmp $0xc8,%edi
jg 11d0 <func0+0x90>
sub $0x64,%edi
pxor %xmm0,%xmm0
movsd 0xe61(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xe7d(%rip),%xmm0
addsd 0xe7d(%rip),%xmm0
addsd %xmm1,%xmm0
retq
sub $0xc8,%edi
pxor %xmm0,%xmm0
movsd 0xe3e(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xe62(%rip),%xmm0
addsd 0xe62(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 31h ; '1'
jg short loc_1170
pxor xmm0, xmm0
movsd xmm1, cs:qword_2008
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2028
addsd xmm0, xmm1
retn
loc_1170:
cmp edi, 64h ; 'd'
jg short loc_11A0
sub edi, 32h ; '2'
pxor xmm0, xmm0
movsd xmm1, cs:qword_2010
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2030
addsd xmm0, cs:qword_2038
addsd xmm0, xmm1
retn
loc_11A0:
cmp edi, 0C8h
jg short loc_11D0
sub edi, 64h ; 'd'
pxor xmm0, xmm0
movsd xmm1, cs:qword_2018
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2040
addsd xmm0, cs:qword_2048
addsd xmm0, xmm1
retn
loc_11D0:
sub edi, 0C8h
pxor xmm0, xmm0
movsd xmm1, cs:qword_2020
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2050
addsd xmm0, cs:qword_2058
addsd xmm0, xmm1
retn | double func0(int a1)
{
if ( a1 <= 49 )
return (double)a1 * 2.6 + 25.0;
if ( a1 <= 100 )
return (double)(a1 - 50) * 3.25 + 130.0 + 35.0;
if ( a1 > 200 )
return (double)(a1 - 200) * 8.449999999999999 + 818.5 + 75.0;
return (double)(a1 - 100) * 5.26 + 292.5 + 45.0;
} | func0:
ENDBR64
CMP EDI,0x31
JG 0x00101170
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102008]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102028]
ADDSD XMM0,XMM1
RET
LAB_00101170:
CMP EDI,0x64
JG 0x001011a0
SUB EDI,0x32
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102010]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102030]
ADDSD XMM0,qword ptr [0x00102038]
ADDSD XMM0,XMM1
RET
LAB_001011a0:
CMP EDI,0xc8
JG 0x001011d0
SUB EDI,0x64
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102018]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102040]
ADDSD XMM0,qword ptr [0x00102048]
ADDSD XMM0,XMM1
RET
LAB_001011d0:
SUB EDI,0xc8
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102020]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102050]
ADDSD XMM0,qword ptr [0x00102058]
ADDSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
if (param_1 < 0x32) {
return (double)param_1 * _DAT_00102028 + DAT_00102008;
}
if (param_1 < 0x65) {
return (double)(param_1 + -0x32) * _DAT_00102030 + _DAT_00102038 + DAT_00102010;
}
if (param_1 < 0xc9) {
return (double)(param_1 + -100) * _DAT_00102040 + _DAT_00102048 + DAT_00102018;
}
return (double)(param_1 + -200) * _DAT_00102050 + _DAT_00102058 + DAT_00102020;
} |
4,439 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((units - 100) * 5.26);
surcharge = 45;
} else {
amount = 130 + 162.50 + 526 + ((units - 200) * 8.45);
surcharge = 75;
}
double total = amount + surcharge;
return total;
}
| int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x31,%edi
jg 1170 <func0+0x30>
pxor %xmm0,%xmm0
movsd 0xeb3(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xec7(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
cmp $0x64,%edi
jg 11a0 <func0+0x60>
sub $0x32,%edi
pxor %xmm0,%xmm0
movsd 0xe8c(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xea0(%rip),%xmm0
addsd 0xea0(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopl (%rax)
cmp $0xc8,%edi
jg 11d0 <func0+0x90>
sub $0x64,%edi
pxor %xmm0,%xmm0
movsd 0xe61(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xe7d(%rip),%xmm0
addsd 0xe7d(%rip),%xmm0
addsd %xmm1,%xmm0
retq
sub $0xc8,%edi
pxor %xmm0,%xmm0
movsd 0xe3e(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xe62(%rip),%xmm0
addsd 0xe62(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 31h ; '1'
jg short loc_1170
pxor xmm0, xmm0
movsd xmm1, cs:qword_2008
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2028
addsd xmm0, xmm1
retn
loc_1170:
cmp edi, 64h ; 'd'
jg short loc_11A0
sub edi, 32h ; '2'
pxor xmm0, xmm0
movsd xmm1, cs:qword_2010
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2030
addsd xmm0, cs:qword_2038
addsd xmm0, xmm1
retn
loc_11A0:
cmp edi, 0C8h
jg short loc_11D0
sub edi, 64h ; 'd'
pxor xmm0, xmm0
movsd xmm1, cs:qword_2018
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2040
addsd xmm0, cs:qword_2048
addsd xmm0, xmm1
retn
loc_11D0:
sub edi, 0C8h
pxor xmm0, xmm0
movsd xmm1, cs:qword_2020
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2050
addsd xmm0, cs:qword_2058
addsd xmm0, xmm1
retn | double func0(int a1)
{
if ( a1 <= 49 )
return (double)a1 * 2.6 + 25.0;
if ( a1 <= 100 )
return (double)(a1 - 50) * 3.25 + 130.0 + 35.0;
if ( a1 > 200 )
return (double)(a1 - 200) * 8.449999999999999 + 818.5 + 75.0;
return (double)(a1 - 100) * 5.26 + 292.5 + 45.0;
} | func0:
ENDBR64
CMP EDI,0x31
JG 0x00101170
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102008]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102028]
ADDSD XMM0,XMM1
RET
LAB_00101170:
CMP EDI,0x64
JG 0x001011a0
SUB EDI,0x32
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102010]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102030]
ADDSD XMM0,qword ptr [0x00102038]
ADDSD XMM0,XMM1
RET
LAB_001011a0:
CMP EDI,0xc8
JG 0x001011d0
SUB EDI,0x64
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102018]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102040]
ADDSD XMM0,qword ptr [0x00102048]
ADDSD XMM0,XMM1
RET
LAB_001011d0:
SUB EDI,0xc8
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102020]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102050]
ADDSD XMM0,qword ptr [0x00102058]
ADDSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
if (param_1 < 0x32) {
return (double)param_1 * _DAT_00102028 + DAT_00102008;
}
if (param_1 < 0x65) {
return (double)(param_1 + -0x32) * _DAT_00102030 + _DAT_00102038 + DAT_00102010;
}
if (param_1 < 0xc9) {
return (double)(param_1 + -100) * _DAT_00102040 + _DAT_00102048 + DAT_00102018;
}
return (double)(param_1 + -200) * _DAT_00102050 + _DAT_00102058 + DAT_00102020;
} |
4,440 | 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 ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
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
jne 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
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%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
jnz 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 xmm1, cs:qword_2078
movq xmm0, rax
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
leave
retn | double func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( !*(_DWORD *)(4LL * i + a1) )
++v3;
}
return round((double)v3 / (double)a2 * 100.0) / 100.0;
} | 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
JNZ 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 XMM1,qword ptr [0x00102078]
MOVQ XMM0,RAX
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
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;
} |
4,441 | 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 ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 11e2 <func0+0x59>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
cmpl $0x1,(%rax)
adc $0x0,%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 0xec0(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xeb3(%rip),%xmm0
add $0x8,%rsp
retq
mov $0x0,%edx
jmp 11b4 <func0+0x2b>
| func0:
endbr64
sub rsp, 8
test esi, esi
jle short loc_11E2
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_11A5:
cmp dword ptr [rax], 1
adc edx, 0
add rax, 4
cmp rax, rcx
jnz short loc_11A5
loc_11B4:
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_11E2:
mov edx, 0
jmp short loc_11B4 | 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++ == 0;
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 0x001011e2
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_001011a5:
CMP dword ptr [RAX],0x1
ADC EDX,0x0
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011a5
LAB_001011b4:
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_001011e2:
MOV EDX,0x0
JMP 0x001011b4 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 == 0);
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
dVar3 = round(((double)iVar2 / (double)param_2) * _DAT_00102070);
return dVar3 / _DAT_00102070;
} |
4,442 | 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 ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
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 $0x1,(%rdi)
adc $0x0,%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 0xcb5(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xca8(%rip),%xmm0
add $0x8,%rsp
retq
nopl (%rax)
pxor %xmm0,%xmm0
jmp 13c7 <func0+0x37>
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], 1
adc eax, 0
add rdi, 4
cmp rdx, rdi
jnz short loc_13B0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
loc_13C7:
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_13C7 | 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++ == 0;
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],0x1
ADC EAX,0x0
ADD RDI,0x4
CMP RDX,RDI
JNZ 0x001013b0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_001013c7:
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 0x001013c7 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
dVar3 = 0.0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 == 0);
param_1 = param_1 + 1;
} while (piVar1 != param_1);
dVar3 = (double)iVar2;
}
dVar3 = round((dVar3 / (double)param_2) * _DAT_00102070);
return dVar3 / _DAT_00102070;
} |
4,443 | 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 ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 1408 <func0+0xe8>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 140e <func0+0xee>
mov %esi,%edx
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%edx
movdqa %xmm0,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
add $0x10,%rax
pcmpeqd %xmm2,%xmm1
psubd %xmm1,%xmm0
cmp %rdx,%rax
jne 1358 <func0+0x38>
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 13d3 <func0+0xb3>
movslq %edx,%rcx
cmpl $0x1,(%rdi,%rcx,4)
lea 0x1(%rdx),%ecx
adc $0x0,%eax
cmp %esi,%ecx
jge 13d3 <func0+0xb3>
movslq %ecx,%rcx
cmpl $0x1,(%rdi,%rcx,4)
lea 0x2(%rdx),%ecx
adc $0x0,%eax
cmp %ecx,%esi
jle 13d3 <func0+0xb3>
movslq %ecx,%rcx
cmpl $0x1,(%rdi,%rcx,4)
adc $0x0,%eax
add $0x3,%edx
cmp %edx,%esi
jle 13d3 <func0+0xb3>
movslq %edx,%rdx
cmpl $0x1,(%rdi,%rdx,4)
adc $0x0,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xca1(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xc94(%rip),%xmm0
add $0x8,%rsp
retq
nopl 0x0(%rax)
pxor %xmm0,%xmm0
jmp 13db <func0+0xbb>
xor %edx,%edx
xor %eax,%eax
jmp 1396 <func0+0x76>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
sub rsp, 8
test esi, esi
jle loc_1400
lea eax, [rsi-1]
mov rcx, rdi
cmp eax, 2
jbe loc_1406
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 xmm1, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm1, xmm2
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_13D0
loc_139E:
movsxd rdi, edx
cmp dword ptr [rcx+rdi*4], 1
lea r8, ds:0[rdi*4]
lea edi, [rdx+1]
adc eax, 0
cmp esi, edi
jle short loc_13D0
cmp dword ptr [rcx+r8+4], 1
adc eax, 0
add edx, 2
cmp esi, edx
jle short loc_13D0
cmp dword ptr [rcx+r8+8], 1
adc eax, 0
loc_13D0:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
loc_13D8:
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_1400:
pxor xmm0, xmm0
jmp short loc_13D8
loc_1406:
xor edx, edx
xor eax, eax
jmp short loc_139E | double func0(const __m128i *a1, int a2)
{
__m128i v2; // xmm0
const __m128i *v3; // rax
__m128i v4; // xmm1
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_cmpeq_epi32(v4, (__m128i)0LL));
}
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] == 0;
if ( a2 > v5 + 1 )
{
v7 += a1->m128i_i32[v8 + 1] == 0;
if ( a2 > v5 + 2 )
v7 += a1->m128i_i32[v8 + 2] == 0;
}
}
v9 = (double)v7;
return round(v9 / (double)a2 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101400
LEA EAX,[RSI + -0x1]
MOV RCX,RDI
CMP EAX,0x2
JBE 0x00101406
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 XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
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 0x001013d0
LAB_0010139e:
MOVSXD RDI,EDX
CMP dword ptr [RCX + RDI*0x4],0x1
LEA R8,[RDI*0x4]
LEA EDI,[RDX + 0x1]
ADC EAX,0x0
CMP ESI,EDI
JLE 0x001013d0
CMP dword ptr [RCX + R8*0x1 + 0x4],0x1
ADC EAX,0x0
ADD EDX,0x2
CMP ESI,EDX
JLE 0x001013d0
CMP dword ptr [RCX + R8*0x1 + 0x8],0x1
ADC EAX,0x0
LAB_001013d0:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_001013d8:
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_00101400:
PXOR XMM0,XMM0
JMP 0x001013d8
LAB_00101406:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010139e | /* 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_001013d8;
}
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
LAB_0010139e:
iVar7 = iVar7 + (uint)(param_1[(int)uVar6] == 0);
if (((int)(uVar6 + 1) < (int)param_2) &&
(iVar7 = iVar7 + (uint)(param_1[(long)(int)uVar6 + 1] == 0), (int)(uVar6 + 2) < (int)param_2)
) {
iVar7 = iVar7 + (uint)(param_1[(long)(int)uVar6 + 2] == 0);
}
}
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_0010139e;
}
dVar8 = (double)iVar7;
LAB_001013d8:
dVar8 = round((dVar8 / (double)(int)param_2) * _DAT_00102070);
return dVar8 / _DAT_00102070;
} |
4,444 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 116e <func0+0x25>
mov $0x0,%eax
jmp 1173 <func0+0x2a>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov edx, [rbp+var_4]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_1174
mov eax, 0
jmp short loc_1179
loc_1174:
mov eax, 1
loc_1179:
pop rbp
retn | _BOOL8 func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x00101174
MOV EAX,0x0
JMP 0x00101179
LAB_00101174:
MOV EAX,0x1
LAB_00101179:
POP RBP
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,445 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
add %eax,%edi
and $0x1,%edi
sub %eax,%edi
cmp $0x1,%edi
setne %al
retq
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add edi, eax
and edi, 1
sub edi, eax
cmp edi, 1
setnz al
retn | bool func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EDI,EAX
AND EDI,0x1
SUB EDI,EAX
CMP EDI,0x1
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,446 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
add %eax,%edi
and $0x1,%edi
sub %eax,%edi
cmp $0x1,%edi
setne %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add edi, eax
and edi, 1
sub edi, eax
cmp edi, 1
setnz al
retn | bool func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EDI,EAX
AND EDI,0x1
SUB EDI,EAX
CMP EDI,0x1
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,447 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
add %eax,%edi
and $0x1,%edi
sub %eax,%edi
cmp $0x1,%edi
setne %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add edi, eax
and edi, 1
sub edi, eax
cmp edi, 1
setnz al
retn | bool func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EDI,EAX
AND EDI,0x1
SUB EDI,EAX
CMP EDI,0x1
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,448 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf3d(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 6.283 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_00102080 * param_1;
} |
4,449 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O1 | c | func0:
endbr64
mulsd 0xed3(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 6.283;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,450 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O2 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 6.283;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,451 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O3 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 6.283;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,452 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
found[elem] = true;
res[res_index++] = elem;
}
}
}
return res_index;
}
| int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i] == expected1[i]);
}
int test_list2[][MAX_SIZE] = {{1, 2, 3}, {4, 2, 3}, {7, 8}};
int sizes2[] = {3, 3, 2};
int result2[MAX_SIZE];
int len2 = func0(test_list2, sizes2, 3, result2);
int expected2[] = {1, 2, 3, 4, 7, 8};
assert(len2 == 6);
for (int i = 0; i < len2; ++i) {
assert(result2[i] == expected2[i]);
}
int test_list3[][MAX_SIZE] = {{7, 8, 9}, {10, 11, 12}, {10, 11}};
int sizes3[] = {3, 3, 2};
int result3[MAX_SIZE];
int len3 = func0(test_list3, sizes3, 3, result3);
int expected3[] = {7, 8, 9, 10, 11, 12};
assert(len3 == 6);
for (int i = 0; i < len3; ++i) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %edx,-0x94(%rbp)
mov %rcx,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x80(%rbp)
lea -0x70(%rbp),%rdx
mov $0x0,%eax
mov $0xc,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
mov %rdi,%rdx
mov %eax,(%rdx)
add $0x4,%rdx
movl $0x0,-0x7c(%rbp)
jmpq 1279 <func0+0x110>
movl $0x0,-0x78(%rbp)
jmp 1253 <func0+0xea>
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x88(%rbp),%rax
add %rax,%rdx
mov -0x78(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
mov %eax,-0x74(%rbp)
mov -0x74(%rbp),%eax
cltq
movzbl -0x70(%rbp,%rax,1),%eax
xor $0x1,%eax
test %al,%al
je 124f <func0+0xe6>
mov -0x74(%rbp),%eax
cltq
movb $0x1,-0x70(%rbp,%rax,1)
mov -0x80(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x80(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0xa0(%rbp),%rax
add %rax,%rdx
mov -0x74(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x78(%rbp)
mov -0x7c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x90(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x78(%rbp)
jl 11db <func0+0x72>
addl $0x1,-0x7c(%rbp)
mov -0x7c(%rbp),%eax
cmp -0x94(%rbp),%eax
jl 11d2 <func0+0x69>
mov -0x80(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 129f <func0+0x136>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov [rbp+var_94], edx
mov [rbp+var_A0], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_80], 0
lea rdx, [rbp+var_70]
mov eax, 0
mov ecx, 0Ch
mov rdi, rdx
rep stosq
mov rdx, rdi
mov [rdx], eax
add rdx, 4
mov [rbp+var_7C], 0
jmp loc_1279
loc_11D2:
mov [rbp+var_78], 0
jmp short loc_1253
loc_11DB:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_88]
add rdx, rax
mov eax, [rbp+var_78]
cdqe
mov eax, [rdx+rax*4]
mov [rbp+var_74], eax
mov eax, [rbp+var_74]
cdqe
movzx eax, [rbp+rax+var_70]
xor eax, 1
test al, al
jz short loc_124F
mov eax, [rbp+var_74]
cdqe
mov [rbp+rax+var_70], 1
mov eax, [rbp+var_80]
lea edx, [rax+1]
mov [rbp+var_80], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_A0]
add rdx, rax
mov eax, [rbp+var_74]
mov [rdx], eax
loc_124F:
add [rbp+var_78], 1
loc_1253:
mov eax, [rbp+var_7C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_90]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_78], eax
jl loc_11DB
add [rbp+var_7C], 1
loc_1279:
mov eax, [rbp+var_7C]
cmp eax, [rbp+var_94]
jl loc_11D2
mov eax, [rbp+var_80]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_129F
call ___stack_chk_fail
locret_129F:
leave
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
int v4; // eax
unsigned int v6; // [rsp+20h] [rbp-80h]
int i; // [rsp+24h] [rbp-7Ch]
int j; // [rsp+28h] [rbp-78h]
int v9; // [rsp+2Ch] [rbp-74h]
_BYTE v10[96]; // [rsp+30h] [rbp-70h] BYREF
int v11; // [rsp+90h] [rbp-10h]
unsigned long long v12; // [rsp+98h] [rbp-8h]
v12 = __readfsqword(0x28u);
v6 = 0;
memset(v10, 0, sizeof(v10));
v11 = 0;
for ( i = 0; i < a3; ++i )
{
for ( j = 0; j < *(_DWORD *)(4LL * i + a2); ++j )
{
v9 = *(_DWORD *)(a1 + 400LL * i + 4LL * j);
if ( v10[v9] != 1 )
{
v10[v9] = 1;
v4 = v6++;
*(_DWORD *)(a4 + 4LL * v4) = v9;
}
}
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV dword ptr [RBP + -0x94],EDX
MOV qword ptr [RBP + -0xa0],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x80],0x0
LEA RDX,[RBP + -0x70]
MOV EAX,0x0
MOV ECX,0xc
MOV RDI,RDX
STOSQ.REP RDI
MOV RDX,RDI
MOV dword ptr [RDX],EAX
ADD RDX,0x4
MOV dword ptr [RBP + -0x7c],0x0
JMP 0x00101279
LAB_001011d2:
MOV dword ptr [RBP + -0x78],0x0
JMP 0x00101253
LAB_001011db:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x78]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RBP + -0x74],EAX
MOV EAX,dword ptr [RBP + -0x74]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x70]
XOR EAX,0x1
TEST AL,AL
JZ 0x0010124f
MOV EAX,dword ptr [RBP + -0x74]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],0x1
MOV EAX,dword ptr [RBP + -0x80]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x80],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0xa0]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RDX],EAX
LAB_0010124f:
ADD dword ptr [RBP + -0x78],0x1
LAB_00101253:
MOV EAX,dword ptr [RBP + -0x7c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x90]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x78],EAX
JL 0x001011db
ADD dword ptr [RBP + -0x7c],0x1
LAB_00101279:
MOV EAX,dword ptr [RBP + -0x7c]
CMP EAX,dword ptr [RBP + -0x94]
JL 0x001011d2
MOV EAX,dword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010129f
CALL 0x00101060
LAB_0010129f:
LEAVE
RET | int func0(long param_1,long param_2,int param_3,long param_4)
{
int iVar1;
long lVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_88;
int local_84;
int local_80;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = 0;
pcVar3 = local_78;
for (lVar2 = 0xc; lVar2 != 0; lVar2 = lVar2 + -1) {
pcVar3[0] = '\0';
pcVar3[1] = '\0';
pcVar3[2] = '\0';
pcVar3[3] = '\0';
pcVar3[4] = '\0';
pcVar3[5] = '\0';
pcVar3[6] = '\0';
pcVar3[7] = '\0';
pcVar3 = pcVar3 + 8;
}
pcVar3[0] = '\0';
pcVar3[1] = '\0';
pcVar3[2] = '\0';
pcVar3[3] = '\0';
for (local_84 = 0; local_84 < param_3; local_84 = local_84 + 1) {
for (local_80 = 0; local_80 < *(int *)(param_2 + (long)local_84 * 4); local_80 = local_80 + 1) {
iVar1 = *(int *)((long)local_84 * 400 + param_1 + (long)local_80 * 4);
if (local_78[iVar1] != '\x01') {
local_78[iVar1] = '\x01';
*(int *)((long)local_88 * 4 + param_4) = iVar1;
local_88 = local_88 + 1;
}
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_88;
} |
4,453 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
found[elem] = true;
res[res_index++] = elem;
}
}
}
return res_index;
}
| int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i] == expected1[i]);
}
int test_list2[][MAX_SIZE] = {{1, 2, 3}, {4, 2, 3}, {7, 8}};
int sizes2[] = {3, 3, 2};
int result2[MAX_SIZE];
int len2 = func0(test_list2, sizes2, 3, result2);
int expected2[] = {1, 2, 3, 4, 7, 8};
assert(len2 == 6);
for (int i = 0; i < len2; ++i) {
assert(result2[i] == expected2[i]);
}
int test_list3[][MAX_SIZE] = {{7, 8, 9}, {10, 11, 12}, {10, 11}};
int sizes3[] = {3, 3, 2};
int result3[MAX_SIZE];
int len3 = func0(test_list3, sizes3, 3, result3);
int expected3[] = {7, 8, 9, 10, 11, 12};
assert(len3 == 6);
for (int i = 0; i < len3; ++i) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x70,%rsp
mov %rdi,%r11
mov %rcx,%r10
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0xc,%ecx
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %edx,%edx
jle 11f7 <func0+0x8e>
mov %rsi,%r9
lea -0x1(%rdx),%eax
lea 0x4(%rsi,%rax,4),%rbx
mov $0x0,%esi
jmp 11e4 <func0+0x7b>
add $0x1,%rax
cmp %eax,(%r8)
jle 11d4 <func0+0x6b>
mov (%rdi,%rax,4),%edx
movslq %edx,%rcx
cmpb $0x0,(%rsp,%rcx,1)
jne 11af <func0+0x46>
movb $0x1,(%rsp,%rcx,1)
movslq %esi,%rcx
mov %edx,(%r10,%rcx,4)
lea 0x1(%rsi),%esi
jmp 11af <func0+0x46>
add $0x4,%r9
add $0x190,%r11
cmp %rbx,%r9
je 11fc <func0+0x93>
mov %r9,%r8
mov %r11,%rdi
mov $0x0,%eax
cmpl $0x0,(%r9)
jg 11b8 <func0+0x4f>
jmp 11d4 <func0+0x6b>
mov $0x0,%esi
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 1214 <func0+0xab>
mov %esi,%eax
add $0x70,%rsp
pop %rbx
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 70h
mov r11, rdi
mov r10, rcx
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 0Ch
rep stosq
mov dword ptr [rdi], 0
test edx, edx
jle short loc_11F7
mov r9, rsi
lea eax, [rdx-1]
lea rbx, [rsi+rax*4+4]
mov esi, 0
jmp short loc_11E4
loc_11AF:
add rax, 1
cmp [r8], eax
jle short loc_11D4
loc_11B8:
mov edx, [rdi+rax*4]
movsxd rcx, edx
cmp [rsp+rcx+78h+var_78], 0
jnz short loc_11AF
mov [rsp+rcx+78h+var_78], 1
movsxd rcx, esi
mov [r10+rcx*4], edx
lea esi, [rsi+1]
jmp short loc_11AF
loc_11D4:
add r9, 4
add r11, 190h
cmp r9, rbx
jz short loc_11FC
loc_11E4:
mov r8, r9
mov rdi, r11
mov eax, 0
cmp dword ptr [r9], 0
jg short loc_11B8
jmp short loc_11D4
loc_11F7:
mov esi, 0
loc_11FC:
mov rax, [rsp+78h+var_10]
sub rax, fs:28h
jnz short loc_1214
mov eax, esi
add rsp, 70h
pop rbx
retn
loc_1214:
call ___stack_chk_fail | long long func0(long long a1, _DWORD *a2, int a3, long long a4)
{
_DWORD *v5; // r9
long long v6; // rbx
unsigned int v7; // esi
long long i; // rax
int v9; // edx
_BYTE v11[96]; // [rsp+0h] [rbp-78h] BYREF
int v12; // [rsp+60h] [rbp-18h]
unsigned long long v13; // [rsp+68h] [rbp-10h]
v13 = __readfsqword(0x28u);
memset(v11, 0, sizeof(v11));
v12 = 0;
if ( a3 <= 0 )
{
return 0;
}
else
{
v5 = a2;
v6 = (long long)&a2[a3 - 1 + 1];
v7 = 0;
do
{
for ( i = 0LL; *v5 > (int)i; ++i )
{
v9 = *(_DWORD *)(a1 + 4 * i);
if ( !v11[v9] )
{
v11[v9] = 1;
*(_DWORD *)(a4 + 4LL * (int)v7++) = v9;
}
}
++v5;
a1 += 400LL;
}
while ( v5 != (_DWORD *)v6 );
}
return v7;
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x70
MOV R11,RDI
MOV R10,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0xc
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST EDX,EDX
JLE 0x001011f7
MOV R9,RSI
LEA EAX,[RDX + -0x1]
LEA RBX,[RSI + RAX*0x4 + 0x4]
MOV ESI,0x0
JMP 0x001011e4
LAB_001011af:
ADD RAX,0x1
CMP dword ptr [R8],EAX
JLE 0x001011d4
LAB_001011b8:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOVSXD RCX,EDX
CMP byte ptr [RSP + RCX*0x1],0x0
JNZ 0x001011af
MOV byte ptr [RSP + RCX*0x1],0x1
MOVSXD RCX,ESI
MOV dword ptr [R10 + RCX*0x4],EDX
LEA ESI,[RSI + 0x1]
JMP 0x001011af
LAB_001011d4:
ADD R9,0x4
ADD R11,0x190
CMP R9,RBX
JZ 0x001011fc
LAB_001011e4:
MOV R8,R9
MOV RDI,R11
MOV EAX,0x0
CMP dword ptr [R9],0x0
JG 0x001011b8
JMP 0x001011d4
LAB_001011f7:
MOV ESI,0x0
LAB_001011fc:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101214
MOV EAX,ESI
ADD RSP,0x70
POP RBX
RET
LAB_00101214:
CALL 0x00101060 | int func0(long param_1,int *param_2,int param_3,long param_4)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
char *pcVar5;
long in_FS_OFFSET;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = local_78;
for (lVar3 = 0xc; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)pcVar5 = 0;
pcVar5 = (char *)((long)pcVar5 + 8);
}
*(int4 *)pcVar5 = 0;
if (param_3 < 1) {
iVar4 = 0;
}
else {
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
iVar4 = 0;
do {
lVar3 = 0;
if (0 < *param_2) {
do {
iVar2 = *(int *)(param_1 + lVar3 * 4);
if (local_78[iVar2] == '\0') {
local_78[iVar2] = '\x01';
*(int *)(param_4 + (long)iVar4 * 4) = iVar2;
iVar4 = iVar4 + 1;
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < *param_2);
}
param_2 = param_2 + 1;
param_1 = param_1 + 400;
} while (param_2 != piVar1);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar4;
} |
4,454 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
found[elem] = true;
res[res_index++] = elem;
}
}
}
return res_index;
}
| int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i] == expected1[i]);
}
int test_list2[][MAX_SIZE] = {{1, 2, 3}, {4, 2, 3}, {7, 8}};
int sizes2[] = {3, 3, 2};
int result2[MAX_SIZE];
int len2 = func0(test_list2, sizes2, 3, result2);
int expected2[] = {1, 2, 3, 4, 7, 8};
assert(len2 == 6);
for (int i = 0; i < len2; ++i) {
assert(result2[i] == expected2[i]);
}
int test_list3[][MAX_SIZE] = {{7, 8, 9}, {10, 11, 12}, {10, 11}};
int sizes3[] = {3, 3, 2};
int result3[MAX_SIZE];
int len3 = func0(test_list3, sizes3, 3, result3);
int expected3[] = {7, 8, 9, 10, 11, 12};
assert(len3 == 6);
for (int i = 0; i < len3; ++i) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
sub $0x78,%rsp
mov %rdi,%r8
mov %rcx,%r9
mov $0xc,%ecx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %edx,%edx
jle 15ac <func0+0x9c>
lea -0x1(%rdx),%eax
mov %r8,%rdi
xor %r8d,%r8d
lea 0x4(%rsi,%rax,4),%r10
nopl 0x0(%rax)
mov (%rsi),%edx
xor %eax,%eax
test %edx,%edx
jle 1584 <func0+0x74>
movslq (%rdi,%rax,4),%rcx
cmpb $0x0,(%rsp,%rcx,1)
mov %rcx,%rdx
jne 157c <func0+0x6c>
movb $0x1,(%rsp,%rcx,1)
movslq %r8d,%rcx
add $0x1,%r8d
mov %edx,(%r9,%rcx,4)
add $0x1,%rax
cmp %eax,(%rsi)
jg 1560 <func0+0x50>
add $0x4,%rsi
add $0x190,%rdi
cmp %r10,%rsi
jne 1558 <func0+0x48>
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 15b1 <func0+0xa1>
mov %r8d,%eax
add $0x78,%rsp
retq
xor %r8d,%r8d
jmp 1594 <func0+0x84>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 78h
mov r8, rdi
mov r9, rcx
mov ecx, 0Ch
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test edx, edx
jle short loc_15AC
lea eax, [rdx-1]
mov rdi, r8
xor r8d, r8d
lea r10, [rsi+rax*4+4]
nop dword ptr [rax+00000000h]
loc_1558:
mov edx, [rsi]
xor eax, eax
test edx, edx
jle short loc_1584
loc_1560:
movsxd rcx, dword ptr [rdi+rax*4]
cmp [rsp+rcx+78h+var_78], 0
mov rdx, rcx
jnz short loc_157C
mov [rsp+rcx+78h+var_78], 1
movsxd rcx, r8d
add r8d, 1
mov [r9+rcx*4], edx
loc_157C:
add rax, 1
cmp [rsi], eax
jg short loc_1560
loc_1584:
add rsi, 4
add rdi, 190h
cmp rsi, r10
jnz short loc_1558
loc_1594:
mov rax, [rsp+78h+var_10]
sub rax, fs:28h
jnz short loc_15B1
mov eax, r8d
add rsp, 78h
retn
loc_15AC:
xor r8d, r8d
jmp short loc_1594
loc_15B1:
call ___stack_chk_fail | long long func0(long long a1, _DWORD *a2, int a3, long long a4)
{
unsigned int v5; // r8d
long long v6; // r10
long long i; // rax
int v8; // edx
long long v9; // rcx
_BYTE v11[96]; // [rsp+0h] [rbp-78h] BYREF
int v12; // [rsp+60h] [rbp-18h]
unsigned long long v13; // [rsp+68h] [rbp-10h]
v13 = __readfsqword(0x28u);
memset(v11, 0, sizeof(v11));
v12 = 0;
if ( a3 <= 0 )
{
return 0;
}
else
{
v5 = 0;
v6 = (long long)&a2[a3 - 1 + 1];
do
{
for ( i = 0LL; *a2 > (int)i; ++i )
{
v8 = *(_DWORD *)(a1 + 4 * i);
if ( !v11[v8] )
{
v11[*(int *)(a1 + 4 * i)] = 1;
v9 = (int)v5++;
*(_DWORD *)(a4 + 4 * v9) = v8;
}
}
++a2;
a1 += 400LL;
}
while ( a2 != (_DWORD *)v6 );
}
return v5;
} | func0:
ENDBR64
SUB RSP,0x78
MOV R8,RDI
MOV R9,RCX
MOV ECX,0xc
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST EDX,EDX
JLE 0x001015ac
LEA EAX,[RDX + -0x1]
MOV RDI,R8
XOR R8D,R8D
LEA R10,[RSI + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101558:
MOV EDX,dword ptr [RSI]
XOR EAX,EAX
TEST EDX,EDX
JLE 0x00101584
LAB_00101560:
MOVSXD RCX,dword ptr [RDI + RAX*0x4]
CMP byte ptr [RSP + RCX*0x1],0x0
MOV RDX,RCX
JNZ 0x0010157c
MOV byte ptr [RSP + RCX*0x1],0x1
MOVSXD RCX,R8D
ADD R8D,0x1
MOV dword ptr [R9 + RCX*0x4],EDX
LAB_0010157c:
ADD RAX,0x1
CMP dword ptr [RSI],EAX
JG 0x00101560
LAB_00101584:
ADD RSI,0x4
ADD RDI,0x190
CMP RSI,R10
JNZ 0x00101558
LAB_00101594:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001015b1
MOV EAX,R8D
ADD RSP,0x78
RET
LAB_001015ac:
XOR R8D,R8D
JMP 0x00101594
LAB_001015b1:
CALL 0x00101060 | int func0(long param_1,int *param_2,int param_3,long param_4)
{
int *piVar1;
int iVar2;
long lVar3;
long lVar4;
char *pcVar5;
int iVar6;
long in_FS_OFFSET;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = local_78;
for (lVar3 = 0xc; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)pcVar5 = 0;
pcVar5 = (char *)((long)pcVar5 + 8);
}
*(int4 *)pcVar5 = 0;
if (param_3 < 1) {
iVar6 = 0;
}
else {
iVar6 = 0;
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
do {
lVar3 = 0;
if (0 < *param_2) {
do {
iVar2 = *(int *)(param_1 + lVar3 * 4);
if (local_78[iVar2] == '\0') {
local_78[iVar2] = '\x01';
lVar4 = (long)iVar6;
iVar6 = iVar6 + 1;
*(int *)(param_4 + lVar4 * 4) = iVar2;
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < *param_2);
}
param_2 = param_2 + 1;
param_1 = param_1 + 400;
} while (param_2 != piVar1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,455 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
found[elem] = true;
res[res_index++] = elem;
}
}
}
return res_index;
}
| int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i] == expected1[i]);
}
int test_list2[][MAX_SIZE] = {{1, 2, 3}, {4, 2, 3}, {7, 8}};
int sizes2[] = {3, 3, 2};
int result2[MAX_SIZE];
int len2 = func0(test_list2, sizes2, 3, result2);
int expected2[] = {1, 2, 3, 4, 7, 8};
assert(len2 == 6);
for (int i = 0; i < len2; ++i) {
assert(result2[i] == expected2[i]);
}
int test_list3[][MAX_SIZE] = {{7, 8, 9}, {10, 11, 12}, {10, 11}};
int sizes3[] = {3, 3, 2};
int result3[MAX_SIZE];
int len3 = func0(test_list3, sizes3, 3, result3);
int expected3[] = {7, 8, 9, 10, 11, 12};
assert(len3 == 6);
for (int i = 0; i < len3; ++i) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%r9
mov %rcx,%r11
mov $0xc,%ecx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %edx,%edx
jle 161f <func0+0xbf>
lea -0x1(%rdx),%eax
mov %rsi,%r10
xor %r8d,%r8d
lea 0x4(%rsi,%rax,4),%rbx
nopw %cs:0x0(%rax,%rax,1)
mov (%r10),%edi
movslq %r8d,%rsi
xor %eax,%eax
test %edi,%edi
jle 15f6 <func0+0x96>
nopl 0x0(%rax)
movslq (%r9,%rax,4),%rcx
cmpb $0x0,(%rsp,%rcx,1)
jne 15ee <func0+0x8e>
mov %ecx,(%r11,%rsi,4)
mov (%r10),%edi
add $0x1,%rax
add $0x1,%r8d
movb $0x1,(%rsp,%rcx,1)
cmp %eax,%edi
jle 15f6 <func0+0x96>
movslq (%r9,%rax,4),%rcx
movslq %r8d,%rsi
cmpb $0x0,(%rsp,%rcx,1)
je 15ca <func0+0x6a>
add $0x1,%rax
cmp %eax,%edi
jg 15c0 <func0+0x60>
add $0x4,%r10
add $0x190,%r9
cmp %rbx,%r10
jne 15b0 <func0+0x50>
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 1624 <func0+0xc4>
add $0x70,%rsp
mov %r8d,%eax
pop %rbx
retq
xor %r8d,%r8d
jmp 1606 <func0+0xa6>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
sub rsp, 78h
mov r9, rdi
mov r10, rcx
mov ecx, 0Ch
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test edx, edx
jle loc_159B
movsxd rdx, edx
lea r11, [rsi+rdx*4]
xchg ax, ax
loc_1520:
mov r8d, [rsi]
xor edx, edx
test r8d, r8d
jle short loc_1558
nop word ptr [rax+rax+00h]
loc_1530:
movsxd rdi, dword ptr [r9+rdx*4]
cmp [rsp+rdi+78h+var_78], 0
mov rcx, rdi
jnz short loc_1580
mov [rsp+rdi+78h+var_78], 1
lea edi, [rax+1]
cdqe
add rdx, 1
mov [r10+rax*4], ecx
mov r8d, [rsi]
mov eax, edi
cmp r8d, edx
jg short loc_1530
loc_1558:
add rsi, 4
add r9, 190h
cmp rsi, r11
jnz short loc_1520
loc_1568:
mov rdx, [rsp+78h+var_10]
sub rdx, fs:28h
jnz short loc_159F
add rsp, 78h
retn
loc_1580:
add rdx, 1
cmp r8d, edx
jg short loc_1530
add rsi, 4
add r9, 190h
cmp rsi, r11
jnz short loc_1520
jmp short loc_1568
loc_159B:
xor eax, eax
jmp short loc_1568
loc_159F:
call ___stack_chk_fail | long long func0(long long a1, int *a2, int a3, long long a4)
{
long long result; // rax
int *v7; // r11
int v8; // r8d
long long v9; // rdx
int v10; // ecx
_BYTE v11[96]; // [rsp+0h] [rbp-78h] BYREF
int v12; // [rsp+60h] [rbp-18h]
unsigned long long v13; // [rsp+68h] [rbp-10h]
v13 = __readfsqword(0x28u);
result = 0LL;
memset(v11, 0, sizeof(v11));
v12 = 0;
if ( a3 <= 0 )
return 0LL;
v7 = &a2[a3];
do
{
while ( 1 )
{
v8 = *a2;
v9 = 0LL;
if ( *a2 > 0 )
break;
LABEL_6:
++a2;
a1 += 400LL;
if ( a2 == v7 )
return result;
}
do
{
while ( 1 )
{
v10 = *(_DWORD *)(a1 + 4 * v9);
if ( v11[v10] )
break;
v11[*(int *)(a1 + 4 * v9++)] = 1;
*(_DWORD *)(a4 + 4LL * (int)result) = v10;
v8 = *a2;
result = (unsigned int)(result + 1);
if ( *a2 <= (int)v9 )
goto LABEL_6;
}
++v9;
}
while ( v8 > (int)v9 );
++a2;
a1 += 400LL;
}
while ( a2 != v7 );
return result;
} | func0:
ENDBR64
SUB RSP,0x78
MOV R9,RDI
MOV R10,RCX
MOV ECX,0xc
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST EDX,EDX
JLE 0x0010159b
MOVSXD RDX,EDX
LEA R11,[RSI + RDX*0x4]
NOP
LAB_00101520:
MOV R8D,dword ptr [RSI]
XOR EDX,EDX
TEST R8D,R8D
JLE 0x00101558
NOP word ptr [RAX + RAX*0x1]
LAB_00101530:
MOVSXD RDI,dword ptr [R9 + RDX*0x4]
CMP byte ptr [RSP + RDI*0x1],0x0
MOV RCX,RDI
JNZ 0x00101580
MOV byte ptr [RSP + RDI*0x1],0x1
LEA EDI,[RAX + 0x1]
CDQE
ADD RDX,0x1
MOV dword ptr [R10 + RAX*0x4],ECX
MOV R8D,dword ptr [RSI]
MOV EAX,EDI
CMP R8D,EDX
JG 0x00101530
LAB_00101558:
ADD RSI,0x4
ADD R9,0x190
CMP RSI,R11
JNZ 0x00101520
LAB_00101568:
MOV RDX,qword ptr [RSP + 0x68]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010159f
ADD RSP,0x78
RET
LAB_00101580:
ADD RDX,0x1
CMP R8D,EDX
JG 0x00101530
ADD RSI,0x4
ADD R9,0x190
CMP RSI,R11
JNZ 0x00101520
JMP 0x00101568
LAB_0010159b:
XOR EAX,EAX
JMP 0x00101568
LAB_0010159f:
CALL 0x00101060 | int func0(long param_1,int *param_2,int param_3,long param_4)
{
int *piVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
char *pcVar6;
int iVar7;
long in_FS_OFFSET;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar6 = local_78;
for (lVar4 = 0xc; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)pcVar6 = 0;
pcVar6 = (char *)((long)pcVar6 + 8);
}
*(int4 *)pcVar6 = 0;
if (param_3 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_2 + param_3;
iVar5 = 0;
do {
while( true ) {
iVar7 = *param_2;
lVar4 = 0;
iVar3 = iVar5;
if (0 < iVar7) break;
LAB_00101558:
param_2 = param_2 + 1;
param_1 = param_1 + 400;
iVar3 = iVar5;
if (param_2 == piVar1) goto LAB_00101568;
}
do {
while( true ) {
iVar2 = *(int *)(param_1 + lVar4 * 4);
if (local_78[iVar2] != '\0') break;
local_78[iVar2] = '\x01';
iVar5 = iVar3 + 1;
lVar4 = lVar4 + 1;
*(int *)(param_4 + (long)iVar3 * 4) = iVar2;
iVar7 = *param_2;
iVar3 = iVar5;
if (iVar7 <= (int)lVar4) goto LAB_00101558;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar7);
param_2 = param_2 + 1;
param_1 = param_1 + 400;
iVar5 = iVar3;
} while (param_2 != piVar1);
}
LAB_00101568:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar3;
} |
4,456 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[max_idx]) {
max_idx = i;
}
}
return max_idx;
}
| void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 12 && arr2[1] == 36 && arr2[2] == 54 && arr2[3] == 85 && arr2[4] == 98);
assert(arr3[0] == 12 && arr3[1] == 23 && arr3[2] == 32 && arr3[3] == 41 && arr3[4] == 42);
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),%eax
mov %eax,-0x8(%rbp)
jmp 12bf <func0+0x69>
mov -0x8(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 11f0 <find_max_index>
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
je 12bb <func0+0x65>
mov -0x4(%rbp),%edx
mov -0x18(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 1169 <reverse>
mov -0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 1169 <reverse>
subl $0x1,-0x8(%rbp)
cmpl $0x1,-0x8(%rbp)
jg 1271 <func0+0x1b>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
mov [rbp+var_8], eax
jmp short loc_12BF
loc_1271:
mov edx, [rbp+var_8]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call find_max_index
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
sub eax, 1
cmp [rbp+var_4], eax
jz short loc_12BB
mov edx, [rbp+var_4]
mov rax, [rbp+var_18]
mov esi, 0
mov rdi, rax
call reverse
mov eax, [rbp+var_8]
lea edx, [rax-1]
mov rax, [rbp+var_18]
mov esi, 0
mov rdi, rax
call reverse
loc_12BB:
sub [rbp+var_8], 1
loc_12BF:
cmp [rbp+var_8], 1
jg short loc_1271
nop
nop
leave
retn | long long func0(long long a1, unsigned int a2)
{
long long result; // rax
int i; // [rsp+18h] [rbp-8h]
unsigned int max_index; // [rsp+1Ch] [rbp-4h]
result = a2;
for ( i = a2; i > 1; --i )
{
max_index = find_max_index(a1, (unsigned int)i);
result = (unsigned int)(i - 1);
if ( max_index != (_DWORD)result )
{
reverse(a1, 0LL, max_index);
result = reverse(a1, 0LL, (unsigned int)(i - 1));
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012bf
LAB_00101271:
MOV EDX,dword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x001011f0
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JZ 0x001012bb
MOV EDX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101169
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101169
LAB_001012bb:
SUB dword ptr [RBP + -0x8],0x1
LAB_001012bf:
CMP dword ptr [RBP + -0x8],0x1
JG 0x00101271
NOP
NOP
LEAVE
RET | void func0(int8 param_1,int param_2)
{
int iVar1;
int4 local_10;
for (local_10 = param_2; 1 < local_10; local_10 = local_10 + -1) {
iVar1 = find_max_index(param_1,local_10);
if (iVar1 != local_10 + -1) {
reverse(param_1,0,iVar1);
reverse(param_1,0,local_10 + -1);
}
}
return;
} |
4,457 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[max_idx]) {
max_idx = i;
}
}
return max_idx;
}
| void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 12 && arr2[1] == 36 && arr2[2] == 54 && arr2[3] == 85 && arr2[4] == 98);
assert(arr3[0] == 12 && arr3[1] == 23 && arr3[2] == 32 && arr3[3] == 41 && arr3[4] == 42);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
cmp $0x1,%esi
jg 11ff <func0+0x36>
pop %rbx
pop %rbp
retq
mov %eax,%edx
mov $0x0,%esi
mov %rbp,%rdi
callq 1169 <reverse>
mov %ebx,%edx
mov $0x0,%esi
mov %rbp,%rdi
callq 1169 <reverse>
cmp $0x1,%ebx
je 11d9 <func0+0x10>
mov %ebx,%esi
mov %rbp,%rdi
callq 1190 <find_max_index>
sub $0x1,%ebx
cmp %eax,%ebx
je 11fa <func0+0x31>
jmp 11dc <func0+0x13>
| func0:
endbr64
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
cmp esi, 1
jg short loc_11DC
loc_11D4:
pop rbx
pop rbp
retn
loc_11D7:
cmp ebx, 1
jz short loc_11D4
loc_11DC:
mov esi, ebx
mov rdi, rbp
call find_max_index
sub ebx, 1
cmp ebx, eax
jz short loc_11D7
mov edx, eax
mov esi, 0
mov rdi, rbp
call reverse
mov edx, ebx
mov esi, 0
mov rdi, rbp
call reverse
jmp short loc_11D7 | void func0(long long a1, int a2)
{
unsigned int v2; // ebx
unsigned int max_index; // eax
v2 = a2;
if ( a2 > 1 )
{
do
{
max_index = find_max_index(a1, v2--);
if ( v2 != max_index )
{
reverse(a1, 0LL, max_index);
reverse(a1, 0LL, v2);
}
}
while ( v2 != 1 );
}
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
CMP ESI,0x1
JG 0x001011dc
LAB_001011d4:
POP RBX
POP RBP
RET
LAB_001011d7:
CMP EBX,0x1
JZ 0x001011d4
LAB_001011dc:
MOV ESI,EBX
MOV RDI,RBP
CALL 0x00101190
SUB EBX,0x1
CMP EBX,EAX
JZ 0x001011d7
MOV EDX,EAX
MOV ESI,0x0
MOV RDI,RBP
CALL 0x00101169
MOV EDX,EBX
MOV ESI,0x0
MOV RDI,RBP
CALL 0x00101169
JMP 0x001011d7 | void func0(int8 param_1,int param_2)
{
int iVar1;
if (1 < param_2) {
do {
iVar1 = find_max_index(param_1,param_2);
param_2 = param_2 + -1;
if (param_2 != iVar1) {
reverse(param_1,0,iVar1);
reverse(param_1,0,param_2);
}
} while (param_2 != 1);
}
return;
} |
4,458 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[max_idx]) {
max_idx = i;
}
}
return max_idx;
}
| void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 12 && arr2[1] == 36 && arr2[2] == 54 && arr2[3] == 85 && arr2[4] == 98);
assert(arr3[0] == 12 && arr3[1] == 23 && arr3[2] == 32 && arr3[3] == 41 && arr3[4] == 42);
return 0;
}
| O2 | c | func0:
endbr64
nopl 0x0(%rax)
cmp $0x1,%esi
jle 141f <func0+0x7f>
mov $0x1,%edx
xor %eax,%eax
nopl 0x0(%rax)
movslq %eax,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,(%rdi,%rdx,4)
cmovg %edx,%eax
add $0x1,%rdx
cmp %edx,%esi
jg 13b8 <func0+0x18>
sub $0x1,%esi
cmp %eax,%esi
je 13a8 <func0+0x8>
test %eax,%eax
jle 13fa <func0+0x5a>
cltq
xor %edx,%edx
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rdx,4),%ecx
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rdi,%rdx,4)
add $0x1,%rdx
mov %ecx,(%rdi,%rax,4)
sub $0x1,%rax
cmp %edx,%eax
jg 13e0 <func0+0x40>
movslq %esi,%rdx
xor %eax,%eax
mov (%rdi,%rax,4),%ecx
mov (%rdi,%rdx,4),%r8d
mov %r8d,(%rdi,%rax,4)
add $0x1,%rax
mov %ecx,(%rdi,%rdx,4)
sub $0x1,%rdx
cmp %eax,%edx
jg 1400 <func0+0x60>
cmp $0x1,%esi
jg 13ad <func0+0xd>
retq
| func0:
endbr64
nop dword ptr [rax+00h]
loc_1398:
cmp esi, 1
jle short locret_140F
loc_139D:
mov edx, 1
xor eax, eax
nop dword ptr [rax+00h]
loc_13A8:
movsxd rcx, eax
mov ecx, [rdi+rcx*4]
cmp [rdi+rdx*4], ecx
cmovg eax, edx
add rdx, 1
cmp esi, edx
jg short loc_13A8
sub esi, 1
cmp esi, eax
jz short loc_1398
test eax, eax
jle short loc_13EA
cdqe
xor edx, edx
nop dword ptr [rax+rax+00h]
loc_13D0:
mov ecx, [rdi+rdx*4]
mov r8d, [rdi+rax*4]
mov [rdi+rdx*4], r8d
add rdx, 1
mov [rdi+rax*4], ecx
sub rax, 1
cmp eax, edx
jg short loc_13D0
loc_13EA:
movsxd rdx, esi
xor eax, eax
nop
loc_13F0:
mov ecx, [rdi+rax*4]
mov r8d, [rdi+rdx*4]
mov [rdi+rax*4], r8d
add rax, 1
mov [rdi+rdx*4], ecx
sub rdx, 1
cmp edx, eax
jg short loc_13F0
cmp esi, 1
jg short loc_139D
locret_140F:
retn | void func0(long long a1, int a2)
{
long long v2; // rdx
long long v3; // rax
long long v4; // rdx
int v5; // ecx
long long v6; // rdx
long long v7; // rax
int v8; // ecx
while ( a2 > 1 )
{
while ( 1 )
{
v2 = 1LL;
LODWORD(v3) = 0;
do
{
if ( *(_DWORD *)(a1 + 4 * v2) > *(_DWORD *)(a1 + 4LL * (int)v3) )
LODWORD(v3) = v2;
++v2;
}
while ( a2 > (int)v2 );
if ( --a2 == (_DWORD)v3 )
break;
if ( (int)v3 > 0 )
{
v3 = (int)v3;
v4 = 0LL;
do
{
v5 = *(_DWORD *)(a1 + 4 * v4);
*(_DWORD *)(a1 + 4 * v4++) = *(_DWORD *)(a1 + 4 * v3);
*(_DWORD *)(a1 + 4 * v3--) = v5;
}
while ( (int)v3 > (int)v4 );
}
v6 = a2;
v7 = 0LL;
do
{
v8 = *(_DWORD *)(a1 + 4 * v7);
*(_DWORD *)(a1 + 4 * v7++) = *(_DWORD *)(a1 + 4 * v6);
*(_DWORD *)(a1 + 4 * v6--) = v8;
}
while ( (int)v6 > (int)v7 );
if ( a2 <= 1 )
return;
}
}
} | func0:
ENDBR64
NOP dword ptr [RAX]
LAB_00101398:
CMP ESI,0x1
JLE 0x0010140f
LAB_0010139d:
MOV EDX,0x1
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013a8:
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP dword ptr [RDI + RDX*0x4],ECX
CMOVG EAX,EDX
ADD RDX,0x1
CMP ESI,EDX
JG 0x001013a8
SUB ESI,0x1
CMP ESI,EAX
JZ 0x00101398
TEST EAX,EAX
JLE 0x001013ea
CDQE
XOR EDX,EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
MOV ECX,dword ptr [RDI + RDX*0x4]
MOV R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDI + RDX*0x4],R8D
ADD RDX,0x1
MOV dword ptr [RDI + RAX*0x4],ECX
SUB RAX,0x1
CMP EAX,EDX
JG 0x001013d0
LAB_001013ea:
MOVSXD RDX,ESI
XOR EAX,EAX
NOP
LAB_001013f0:
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV R8D,dword ptr [RDI + RDX*0x4]
MOV dword ptr [RDI + RAX*0x4],R8D
ADD RAX,0x1
MOV dword ptr [RDI + RDX*0x4],ECX
SUB RDX,0x1
CMP EDX,EAX
JG 0x001013f0
CMP ESI,0x1
JG 0x0010139d
LAB_0010140f:
RET | void func0(long param_1,int param_2)
{
int4 uVar1;
int iVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
long lVar6;
do {
if (param_2 < 2) {
return;
}
while( true ) {
uVar5 = 1;
uVar3 = 0;
do {
if (*(int *)(param_1 + (long)(int)uVar3 * 4) < *(int *)(param_1 + uVar5 * 4)) {
uVar3 = uVar5 & 0xffffffff;
}
uVar5 = uVar5 + 1;
} while ((int)uVar5 < param_2);
param_2 = param_2 + -1;
iVar2 = (int)uVar3;
if (param_2 == iVar2) break;
if (0 < iVar2) {
lVar4 = (long)iVar2;
lVar6 = 0;
do {
uVar1 = *(int4 *)(param_1 + lVar6 * 4);
*(int4 *)(param_1 + lVar6 * 4) = *(int4 *)(param_1 + lVar4 * 4);
lVar6 = lVar6 + 1;
*(int4 *)(param_1 + lVar4 * 4) = uVar1;
lVar4 = lVar4 + -1;
} while ((int)lVar6 < (int)lVar4);
}
lVar6 = (long)param_2;
lVar4 = 0;
do {
uVar1 = *(int4 *)(param_1 + lVar4 * 4);
*(int4 *)(param_1 + lVar4 * 4) = *(int4 *)(param_1 + lVar6 * 4);
lVar4 = lVar4 + 1;
*(int4 *)(param_1 + lVar6 * 4) = uVar1;
lVar6 = lVar6 + -1;
} while ((int)lVar4 < (int)lVar6);
if (param_2 < 2) {
return;
}
}
} while( true );
} |
4,459 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[max_idx]) {
max_idx = i;
}
}
return max_idx;
}
| void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 12 && arr2[1] == 36 && arr2[2] == 54 && arr2[3] == 85 && arr2[4] == 98);
assert(arr3[0] == 12 && arr3[1] == 23 && arr3[2] == 32 && arr3[3] == 41 && arr3[4] == 42);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1747 <func0+0x2b7>
push %r14
mov $0x4,%r10d
xor %r9d,%r9d
mov $0x1,%r11d
push %r13
push %r12
push %rbp
push %rbx
nopl 0x0(%rax)
mov (%rdi),%ecx
mov $0x1,%eax
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%edx
cmp %ecx,%edx
jle 14d4 <func0+0x44>
mov %edx,%ecx
mov %eax,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 14c8 <func0+0x38>
lea -0x1(%rsi),%ebx
cmp %r8d,%ebx
jne 14f8 <func0+0x68>
mov %r8d,%esi
cmp $0x1,%esi
jg 14b8 <func0+0x28>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl (%rax)
test %r8d,%r8d
jle 15ed <func0+0x15d>
lea -0x1(%r8),%ecx
movslq %r8d,%rax
mov %ecx,%ebp
lea 0x4(,%rax,4),%r12
shr %ebp
lea 0x1(%rbp),%edx
mov %rdx,%rbp
lea 0x0(,%rdx,4),%r13
neg %rdx
lea (%r12,%rdx,4),%rdx
cmp %rdx,%r13
jg 171f <func0+0x28f>
cmp $0x5,%ecx
jbe 171f <func0+0x28f>
mov %ebp,%ecx
mov %rdi,%rax
lea -0x10(%rdi,%r12,1),%rdx
shr $0x2,%ecx
shl $0x4,%rcx
add %rdi,%rcx
movdqu (%rdx),%xmm3
movdqu (%rax),%xmm0
add $0x10,%rax
sub $0x10,%rdx
pshufd $0x1b,%xmm3,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movups %xmm1,-0x10(%rax)
movups %xmm0,0x10(%rdx)
cmp %rax,%rcx
jne 1550 <func0+0xc0>
mov %ebp,%eax
and $0xfffffffc,%eax
sub %eax,%r8d
cmp %eax,%ebp
je 15ed <func0+0x15d>
mov %eax,%ecx
movslq %r8d,%rdx
shl $0x2,%rcx
lea (%rdi,%rdx,4),%rdx
lea (%rdi,%rcx,1),%rbp
mov (%rdx),%r13d
mov 0x0(%rbp),%r12d
mov %r13d,0x0(%rbp)
lea 0x1(%rax),%ebp
mov %r12d,(%rdx)
lea -0x1(%r8),%edx
cmp %ebp,%edx
jle 15ed <func0+0x15d>
movslq %edx,%rdx
lea 0x4(%rdi,%rcx,1),%r12
add $0x2,%eax
sub $0x2,%r8d
shl $0x2,%rdx
mov (%r12),%r13d
lea (%rdi,%rdx,1),%rbp
mov 0x0(%rbp),%r14d
mov %r14d,(%r12)
mov %r13d,0x0(%rbp)
cmp %r8d,%eax
jge 15ed <func0+0x15d>
lea 0x8(%rdi,%rcx,1),%rcx
lea -0x4(%rdi,%rdx,1),%rax
mov (%rcx),%r8d
mov (%rax),%edx
mov %edx,(%rcx)
mov %r8d,(%rax)
lea -0x2(%rsi),%edx
movslq %ebx,%rax
shr %edx
cmp $0x1,%esi
lea 0x4(,%rax,4),%r8
lea 0x1(%rdx),%ecx
lea 0x0(,%rcx,4),%rbp
mov %rcx,%rdx
cmovle %r10,%rbp
neg %rcx
cmp $0x1,%esi
lea 0x4(,%rcx,4),%rcx
cmovle %r9,%rcx
lea (%rcx,%rax,4),%rcx
cmp %rcx,%rbp
jg 16fd <func0+0x26d>
cmp $0x7,%esi
jle 16fd <func0+0x26d>
cmp $0x1,%esi
mov %edx,%esi
lea -0x10(%rdi,%r8,1),%rdx
mov %rdi,%rax
cmovle %r11d,%esi
mov %esi,%ecx
shr $0x2,%ecx
shl $0x4,%rcx
add %rdi,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rdx),%xmm2
movdqu (%rax),%xmm0
add $0x10,%rax
sub $0x10,%rdx
pshufd $0x1b,%xmm2,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movups %xmm1,-0x10(%rax)
movups %xmm0,0x10(%rdx)
cmp %rax,%rcx
jne 1660 <func0+0x1d0>
mov %esi,%eax
mov %ebx,%edx
and $0xfffffffc,%eax
sub %eax,%edx
cmp %eax,%esi
je 16f6 <func0+0x266>
mov %eax,%esi
movslq %edx,%rcx
shl $0x2,%rsi
lea (%rdi,%rcx,4),%rcx
lea (%rdi,%rsi,1),%r8
mov (%rcx),%r12d
mov (%r8),%ebp
mov %r12d,(%r8)
lea 0x1(%rax),%r8d
mov %ebp,(%rcx)
lea -0x1(%rdx),%ecx
cmp %r8d,%ecx
jle 16f6 <func0+0x266>
movslq %ecx,%rcx
lea 0x4(%rdi,%rsi,1),%rbp
sub $0x2,%edx
add $0x2,%eax
shl $0x2,%rcx
mov 0x0(%rbp),%r12d
lea (%rdi,%rcx,1),%r8
mov (%r8),%r13d
mov %r13d,0x0(%rbp)
mov %r12d,(%r8)
cmp %eax,%edx
jle 16f6 <func0+0x266>
lea 0x8(%rdi,%rsi,1),%rdx
lea -0x4(%rdi,%rcx,1),%rax
mov (%rdx),%esi
mov (%rax),%ecx
mov %ecx,(%rdx)
mov %esi,(%rax)
mov %ebx,%esi
jmpq 14e7 <func0+0x57>
xor %edx,%edx
mov (%rdi,%rdx,4),%ecx
mov (%rdi,%rax,4),%esi
mov %esi,(%rdi,%rdx,4)
add $0x1,%rdx
mov %ecx,(%rdi,%rax,4)
sub $0x1,%rax
cmp %eax,%edx
jl 1700 <func0+0x270>
mov %ebx,%esi
jmpq 14e7 <func0+0x57>
xor %edx,%edx
nopl 0x0(%rax)
mov (%rdi,%rdx,4),%ecx
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rdi,%rdx,4)
add $0x1,%rdx
mov %ecx,(%rdi,%rax,4)
sub $0x1,%rax
cmp %edx,%eax
jg 1728 <func0+0x298>
jmpq 15ed <func0+0x15d>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov rdx, rdi
cmp esi, 1
jle locret_13FC
loc_1370:
mov edi, [rdx]
mov r9d, esi
mov eax, 1
xor ecx, ecx
nop dword ptr [rax+00h]
loc_1380:
mov r8d, [rdx+rax*4]
cmp r8d, edi
cmovg ecx, eax
cmovg edi, r8d
add rax, 1
cmp r9, rax
jnz short loc_1380
sub esi, 1
cmp esi, ecx
jnz short loc_13A8
loc_139E:
cmp esi, 1
jnz short loc_1370
retn
loc_13A8:
test ecx, ecx
jle short loc_13D2
movsxd rcx, ecx
xor eax, eax
nop dword ptr [rax+00000000h]
loc_13B8:
mov edi, [rdx+rax*4]
mov r8d, [rdx+rcx*4]
mov [rdx+rax*4], r8d
add rax, 1
mov [rdx+rcx*4], edi
sub rcx, 1
cmp ecx, eax
jg short loc_13B8
loc_13D2:
movsxd rcx, esi
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13E0:
mov edi, [rdx+rax*4]
mov r8d, [rdx+rcx*4]
mov [rdx+rax*4], r8d
add rax, 1
mov [rdx+rcx*4], edi
sub rcx, 1
cmp eax, ecx
jl short loc_13E0
jmp short loc_139E
locret_13FC:
retn | void func0(int *a1, int a2)
{
int v3; // edi
long long v4; // rax
long long v5; // rcx
long long v6; // rax
int v7; // edi
long long v8; // rcx
long long v9; // rax
int v10; // edi
if ( a2 > 1 )
{
do
{
v3 = *a1;
v4 = 1LL;
LODWORD(v5) = 0;
do
{
if ( a1[v4] > v3 )
{
LODWORD(v5) = v4;
v3 = a1[v4];
}
++v4;
}
while ( a2 != v4 );
if ( --a2 != (_DWORD)v5 )
{
if ( (int)v5 > 0 )
{
v5 = (int)v5;
v6 = 0LL;
do
{
v7 = a1[v6];
a1[v6++] = a1[v5];
a1[v5--] = v7;
}
while ( (int)v5 > (int)v6 );
}
v8 = a2;
v9 = 0LL;
do
{
v10 = a1[v9];
a1[v9++] = a1[v8];
a1[v8--] = v10;
}
while ( (int)v9 < (int)v8 );
}
}
while ( a2 != 1 );
}
} | func0:
ENDBR64
MOV RDX,RDI
CMP ESI,0x1
JLE 0x001013fc
LAB_00101370:
MOV EDI,dword ptr [RDX]
MOV R9D,ESI
MOV EAX,0x1
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101380:
MOV R8D,dword ptr [RDX + RAX*0x4]
CMP R8D,EDI
CMOVG ECX,EAX
CMOVG EDI,R8D
ADD RAX,0x1
CMP R9,RAX
JNZ 0x00101380
SUB ESI,0x1
CMP ESI,ECX
JNZ 0x001013a8
LAB_0010139e:
CMP ESI,0x1
JNZ 0x00101370
RET
LAB_001013a8:
TEST ECX,ECX
JLE 0x001013d2
MOVSXD RCX,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013b8:
MOV EDI,dword ptr [RDX + RAX*0x4]
MOV R8D,dword ptr [RDX + RCX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
MOV dword ptr [RDX + RCX*0x4],EDI
SUB RCX,0x1
CMP ECX,EAX
JG 0x001013b8
LAB_001013d2:
MOVSXD RCX,ESI
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV EDI,dword ptr [RDX + RAX*0x4]
MOV R8D,dword ptr [RDX + RCX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
MOV dword ptr [RDX + RCX*0x4],EDI
SUB RCX,0x1
CMP EAX,ECX
JL 0x001013e0
JMP 0x0010139e
LAB_001013fc:
RET | void func0(int *param_1,uint param_2)
{
ulong uVar1;
long lVar2;
uint uVar3;
ulong uVar4;
long lVar5;
int iVar6;
if (1 < (int)param_2) {
do {
iVar6 = *param_1;
uVar1 = 1;
uVar4 = 0;
do {
if (iVar6 < param_1[uVar1]) {
uVar4 = uVar1 & 0xffffffff;
iVar6 = param_1[uVar1];
}
uVar1 = uVar1 + 1;
} while (param_2 != uVar1);
param_2 = param_2 - 1;
uVar3 = (uint)uVar4;
if (param_2 != uVar3) {
if (0 < (int)uVar3) {
lVar5 = (long)(int)uVar3;
lVar2 = 0;
do {
iVar6 = param_1[lVar2];
param_1[lVar2] = param_1[lVar5];
lVar2 = lVar2 + 1;
param_1[lVar5] = iVar6;
lVar5 = lVar5 + -1;
} while ((int)lVar2 < (int)lVar5);
}
lVar5 = (long)(int)param_2;
lVar2 = 0;
do {
iVar6 = param_1[lVar2];
param_1[lVar2] = param_1[lVar5];
lVar2 = lVar2 + 1;
param_1[lVar5] = iVar6;
lVar5 = lVar5 + -1;
} while ((int)lVar2 < (int)lVar5);
}
} while (param_2 != 1);
return;
}
return;
} |
4,460 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4, 2, 6, 7, 8};
int list2c[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3c[] = {2, 1, 3, 1, 2, 6, 7, 8};
assert(func0(list1a, list2a, list3a, sizeof(list1a)/sizeof(list1a[0])) == 3);
assert(func0(list1b, list2b, list3b, sizeof(list1b)/sizeof(list1b[0])) == 4);
assert(func0(list1c, list2c, list3c, sizeof(list1c)/sizeof(list1c[0])) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0xc(%rbp)
movq $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x8e>
mov -0x8(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11f2 <func0+0x89>
mov -0x8(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11f2 <func0+0x89>
addl $0x1,-0xc(%rbp)
addq $0x1,-0x8(%rbp)
mov -0x8(%rbp),%rax
cmp -0x30(%rbp),%rax
jb 1192 <func0+0x29>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11F7
loc_1192:
mov rax, [rbp+var_8]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_8]
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11F2
mov rax, [rbp+var_8]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_8]
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11F2
add [rbp+var_C], 1
loc_11F2:
add [rbp+var_8], 1
loc_11F7:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_30]
jb short loc_1192
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, unsigned long long a4)
{
unsigned int v5; // [rsp+24h] [rbp-Ch]
unsigned long long i; // [rsp+28h] [rbp-8h]
v5 = 0;
for ( i = 0LL; i < a4; ++i )
{
if ( *(_DWORD *)(4 * i + a1) == *(_DWORD *)(4 * i + a2) && *(_DWORD *)(4 * i + a2) == *(_DWORD *)(4 * i + a3) )
++v5;
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0xc],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001011f7
LAB_00101192:
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011f2
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011f2
ADD dword ptr [RBP + -0xc],0x1
LAB_001011f2:
ADD qword ptr [RBP + -0x8],0x1
LAB_001011f7:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x30]
JC 0x00101192
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,long param_2,long param_3,ulong param_4)
{
int4 local_14;
int8 local_10;
local_14 = 0;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
if ((*(int *)(param_1 + local_10 * 4) == *(int *)(param_2 + local_10 * 4)) &&
(*(int *)(param_2 + local_10 * 4) == *(int *)(param_3 + local_10 * 4))) {
local_14 = local_14 + 1;
}
}
return local_14;
} |
4,461 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4, 2, 6, 7, 8};
int list2c[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3c[] = {2, 1, 3, 1, 2, 6, 7, 8};
assert(func0(list1a, list2a, list3a, sizeof(list1a)/sizeof(list1a[0])) == 3);
assert(func0(list1b, list2b, list3b, sizeof(list1b)/sizeof(list1b[0])) == 4);
assert(func0(list1c, list2c, list3c, sizeof(list1c)/sizeof(list1c[0])) == 5);
return 0;
}
| O1 | c | func0:
endbr64
test %rcx,%rcx
je 119e <func0+0x35>
mov $0x0,%eax
mov $0x0,%r9d
jmp 1188 <func0+0x1f>
add $0x1,%rax
cmp %rax,%rcx
je 11a4 <func0+0x3b>
mov (%rsi,%rax,4),%r8d
cmp %r8d,(%rdi,%rax,4)
jne 117f <func0+0x16>
cmp (%rdx,%rax,4),%r8d
jne 117f <func0+0x16>
add $0x1,%r9d
jmp 117f <func0+0x16>
mov $0x0,%r9d
mov %r9d,%eax
retq
| func0:
endbr64
test rcx, rcx
jz short loc_119E
mov eax, 0
mov r9d, 0
jmp short loc_1188
loc_117F:
add rax, 1
cmp rcx, rax
jz short loc_11A4
loc_1188:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_117F
cmp r8d, [rdx+rax*4]
jnz short loc_117F
add r9d, 1
jmp short loc_117F
loc_119E:
mov r9d, 0
loc_11A4:
mov eax, r9d
retn | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v5; // r9d
int v6; // r8d
if ( a4 )
{
v4 = 0LL;
v5 = 0;
do
{
v6 = *(_DWORD *)(a2 + 4 * v4);
if ( *(_DWORD *)(a1 + 4 * v4) == v6 && v6 == *(_DWORD *)(a3 + 4 * v4) )
++v5;
++v4;
}
while ( a4 != v4 );
}
else
{
return 0;
}
return v5;
} | func0:
ENDBR64
TEST RCX,RCX
JZ 0x0010119e
MOV EAX,0x0
MOV R9D,0x0
JMP 0x00101188
LAB_0010117f:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x001011a4
LAB_00101188:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x0010117f
CMP R8D,dword ptr [RDX + RAX*0x4]
JNZ 0x0010117f
ADD R9D,0x1
JMP 0x0010117f
LAB_0010119e:
MOV R9D,0x0
LAB_001011a4:
MOV EAX,R9D
RET | int func0(long param_1,long param_2,long param_3,long param_4)
{
int iVar1;
long lVar2;
int iVar3;
if (param_4 == 0) {
iVar3 = 0;
}
else {
lVar2 = 0;
iVar3 = 0;
do {
iVar1 = *(int *)(param_2 + lVar2 * 4);
if ((*(int *)(param_1 + lVar2 * 4) == iVar1) && (iVar1 == *(int *)(param_3 + lVar2 * 4))) {
iVar3 = iVar3 + 1;
}
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
}
return iVar3;
} |
4,462 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4, 2, 6, 7, 8};
int list2c[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3c[] = {2, 1, 3, 1, 2, 6, 7, 8};
assert(func0(list1a, list2a, list3a, sizeof(list1a)/sizeof(list1a[0])) == 3);
assert(func0(list1b, list2b, list3b, sizeof(list1b)/sizeof(list1b[0])) == 4);
assert(func0(list1c, list2c, list3c, sizeof(list1c)/sizeof(list1c[0])) == 5);
return 0;
}
| O2 | c | func0:
endbr64
test %rcx,%rcx
je 1480 <func0+0x40>
xor %eax,%eax
xor %r9d,%r9d
jmp 1459 <func0+0x19>
add $0x1,%rax
cmp %rax,%rcx
je 1476 <func0+0x36>
mov (%rsi,%rax,4),%r8d
cmp %r8d,(%rdi,%rax,4)
jne 1450 <func0+0x10>
cmp (%rdx,%rax,4),%r8d
jne 1450 <func0+0x10>
add $0x1,%rax
add $0x1,%r9d
cmp %rax,%rcx
jne 1459 <func0+0x19>
mov %r9d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r9d,%r9d
mov %r9d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test rcx, rcx
jz short loc_1410
xor eax, eax
xor r9d, r9d
jmp short loc_13E9
loc_13E0:
add rax, 1
cmp rcx, rax
jz short loc_1406
loc_13E9:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_13E0
cmp r8d, [rdx+rax*4]
jnz short loc_13E0
add rax, 1
add r9d, 1
cmp rcx, rax
jnz short loc_13E9
loc_1406:
mov eax, r9d
retn
loc_1410:
xor r9d, r9d
mov eax, r9d
retn | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v5; // r9d
int v6; // r8d
if ( !a4 )
return 0LL;
v4 = 0LL;
v5 = 0;
do
{
while ( 1 )
{
v6 = *(_DWORD *)(a2 + 4 * v4);
if ( *(_DWORD *)(a1 + 4 * v4) == v6 && v6 == *(_DWORD *)(a3 + 4 * v4) )
break;
if ( a4 == ++v4 )
return v5;
}
++v4;
++v5;
}
while ( a4 != v4 );
return v5;
} | func0:
ENDBR64
TEST RCX,RCX
JZ 0x00101410
XOR EAX,EAX
XOR R9D,R9D
JMP 0x001013e9
LAB_001013e0:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x00101406
LAB_001013e9:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x001013e0
CMP R8D,dword ptr [RDX + RAX*0x4]
JNZ 0x001013e0
ADD RAX,0x1
ADD R9D,0x1
CMP RCX,RAX
JNZ 0x001013e9
LAB_00101406:
MOV EAX,R9D
RET
LAB_00101410:
XOR R9D,R9D
MOV EAX,R9D
RET | int func0(long param_1,long param_2,long param_3,long param_4)
{
int iVar1;
long lVar2;
int iVar3;
if (param_4 == 0) {
return 0;
}
lVar2 = 0;
iVar3 = 0;
do {
while ((iVar1 = *(int *)(param_2 + lVar2 * 4), *(int *)(param_1 + lVar2 * 4) == iVar1 &&
(iVar1 == *(int *)(param_3 + lVar2 * 4)))) {
lVar2 = lVar2 + 1;
iVar3 = iVar3 + 1;
if (param_4 == lVar2) {
return iVar3;
}
}
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
return iVar3;
} |
4,463 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4, 2, 6, 7, 8};
int list2c[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3c[] = {2, 1, 3, 1, 2, 6, 7, 8};
assert(func0(list1a, list2a, list3a, sizeof(list1a)/sizeof(list1a[0])) == 3);
assert(func0(list1b, list2b, list3b, sizeof(list1b)/sizeof(list1b[0])) == 4);
assert(func0(list1c, list2c, list3c, sizeof(list1c)/sizeof(list1c[0])) == 5);
return 0;
}
| O3 | c | func0:
endbr64
test %rcx,%rcx
je 15f0 <func0+0x40>
xor %eax,%eax
xor %r9d,%r9d
jmp 15c9 <func0+0x19>
add $0x1,%rax
cmp %rax,%rcx
je 15e6 <func0+0x36>
mov (%rsi,%rax,4),%r8d
cmp %r8d,(%rdi,%rax,4)
jne 15c0 <func0+0x10>
cmp (%rdx,%rax,4),%r8d
jne 15c0 <func0+0x10>
add $0x1,%rax
add $0x1,%r9d
cmp %rax,%rcx
jne 15c9 <func0+0x19>
mov %r9d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r9d,%r9d
mov %r9d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test rcx, rcx
jz short loc_1180
xor eax, eax
xor r9d, r9d
jmp short loc_1159
loc_1150:
add rax, 1
cmp rcx, rax
jz short loc_1176
loc_1159:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_1150
cmp r8d, [rdx+rax*4]
jnz short loc_1150
add rax, 1
add r9d, 1
cmp rcx, rax
jnz short loc_1159
loc_1176:
mov eax, r9d
retn
loc_1180:
xor r9d, r9d
mov eax, r9d
retn | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v5; // r9d
int v6; // r8d
if ( !a4 )
return 0LL;
v4 = 0LL;
v5 = 0;
do
{
while ( 1 )
{
v6 = *(_DWORD *)(a2 + 4 * v4);
if ( *(_DWORD *)(a1 + 4 * v4) == v6 && v6 == *(_DWORD *)(a3 + 4 * v4) )
break;
if ( a4 == ++v4 )
return v5;
}
++v4;
++v5;
}
while ( a4 != v4 );
return v5;
} | func0:
ENDBR64
TEST RCX,RCX
JZ 0x00101180
XOR EAX,EAX
XOR R9D,R9D
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x00101176
LAB_00101159:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x00101150
CMP R8D,dword ptr [RDX + RAX*0x4]
JNZ 0x00101150
ADD RAX,0x1
ADD R9D,0x1
CMP RCX,RAX
JNZ 0x00101159
LAB_00101176:
MOV EAX,R9D
RET
LAB_00101180:
XOR R9D,R9D
MOV EAX,R9D
RET | int func0(long param_1,long param_2,long param_3,long param_4)
{
int iVar1;
long lVar2;
int iVar3;
if (param_4 == 0) {
return 0;
}
lVar2 = 0;
iVar3 = 0;
do {
while ((iVar1 = *(int *)(param_2 + lVar2 * 4), *(int *)(param_1 + lVar2 * 4) == iVar1 &&
(iVar1 == *(int *)(param_3 + lVar2 * 4)))) {
lVar2 = lVar2 + 1;
iVar3 = iVar3 + 1;
if (param_4 == lVar2) {
return iVar3;
}
}
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
return iVar3;
} |
4,464 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
cmpl $0x0,-0x4(%rbp)
je 1164 <func0+0x1b>
mov $0x1,%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
cmp [rbp+var_4], 0
jz short loc_1164
mov eax, 1
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(int a1, unsigned int a2)
{
if ( a1 )
return 1LL;
else
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
CMP dword ptr [RBP + -0x4],0x0
JZ 0x00101164
MOV EAX,0x1
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int4 func0(int param_1,int4 param_2)
{
if (param_1 != 0) {
param_2 = 1;
}
return param_2;
} |
4,465 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
mov $0x1,%eax
cmove %esi,%eax
retq
| func0:
endbr64
test edi, edi
mov eax, 1
cmovz eax, esi
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
result = 1LL;
if ( !a1 )
return a2;
return result;
} | ||
4,466 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
mov $0x1,%eax
cmove %esi,%eax
retq
| func0:
endbr64
test edi, edi
mov eax, 1
cmovz eax, esi
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
result = 1LL;
if ( !a1 )
return a2;
return result;
} | func0:
ENDBR64
TEST EDI,EDI
MOV EAX,0x1
CMOVZ EAX,ESI
RET | int4 func0(int param_1,int4 param_2)
{
int4 uVar1;
uVar1 = 1;
if (param_1 == 0) {
uVar1 = param_2;
}
return uVar1;
} |
4,467 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
mov $0x1,%eax
cmove %esi,%eax
retq
| func0:
endbr64
test edi, edi
mov eax, 1
cmovz eax, esi
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
result = 1LL;
if ( !a1 )
return a2;
return result;
} | func0:
ENDBR64
TEST EDI,EDI
MOV EAX,0x1
CMOVZ EAX,ESI
RET | int4 func0(int param_1,int4 param_2)
{
int4 uVar1;
uVar1 = 1;
if (param_1 == 0) {
uVar1 = param_2;
}
return uVar1;
} |
4,468 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11d5 <func0+0x6c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
mov -0x1c(%rbp),%eax
sub $0x1,%eax
sub -0x4(%rbp),%eax
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x18(%rbp),%rax
add %rsi,%rax
mov (%rax),%eax
imul %ecx,%eax
sub %eax,%edx
mov %edx,%eax
add %eax,-0x8(%rbp)
subl $0x1,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 118a <func0+0x21>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_4], eax
jmp short loc_11D5
loc_118A:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
imul eax, [rbp+var_4]
mov ecx, eax
mov eax, [rbp+var_1C]
sub eax, 1
sub eax, [rbp+var_4]
mov edx, eax
mov eax, [rbp+var_4]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rsi
mov eax, [rax]
imul eax, edx
sub ecx, eax
mov edx, ecx
add [rbp+var_8], edx
sub [rbp+var_4], 1
loc_11D5:
cmp [rbp+var_4], 0
jns short loc_118A
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = a2 - 1; i >= 0; --i )
v3 += i * *(_DWORD *)(4LL * i + a1) - (a2 - 1 - i) * *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011d5
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
IMUL EAX,dword ptr [RBP + -0x4]
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RSI
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
ADD dword ptr [RBP + -0x8],EDX
SUB dword ptr [RBP + -0x4],0x1
LAB_001011d5:
CMP dword ptr [RBP + -0x4],0x0
JNS 0x0010118a
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = param_2 + -1; -1 < local_c; local_c = local_c + -1) {
local_10 = local_10 +
(*(int *)(param_1 + (long)local_c * 4) * local_c -
*(int *)(param_1 + (long)local_c * 4) * ((param_2 + -1) - local_c));
}
return local_10;
} |
4,469 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O1 | c | func0:
endbr64
mov %esi,%eax
sub $0x1,%eax
js 119c <func0+0x33>
cltq
mov $0x0,%ecx
sub $0x1,%esi
mov %esi,%edx
sub %eax,%edx
mov %eax,%r8d
sub %edx,%r8d
mov %r8d,%edx
imul (%rdi,%rax,4),%edx
add %edx,%ecx
sub $0x1,%rax
test %eax,%eax
jns 117e <func0+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1199 <func0+0x30>
| func0:
endbr64
mov eax, esi
sub eax, 1
js short loc_119A
cdqe
mov ecx, 0
sub esi, 1
loc_117E:
mov r8d, esi
sub r8d, eax
mov edx, eax
sub edx, r8d
imul edx, [rdi+rax*4]
add ecx, edx
sub rax, 1
test eax, eax
jns short loc_117E
loc_1197:
mov eax, ecx
retn
loc_119A:
mov ecx, 0
jmp short loc_1197 | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // ecx
int v4; // esi
LODWORD(v2) = a2 - 1;
if ( a2 - 1 < 0 )
{
return 0;
}
else
{
v2 = (int)v2;
v3 = 0;
v4 = a2 - 1;
do
{
v3 += *(_DWORD *)(a1 + 4 * v2) * (v2 - (v4 - v2));
--v2;
}
while ( (int)v2 >= 0 );
}
return v3;
} | func0:
ENDBR64
MOV EAX,ESI
SUB EAX,0x1
JS 0x0010119a
CDQE
MOV ECX,0x0
SUB ESI,0x1
LAB_0010117e:
MOV R8D,ESI
SUB R8D,EAX
MOV EDX,EAX
SUB EDX,R8D
IMUL EDX,dword ptr [RDI + RAX*0x4]
ADD ECX,EDX
SUB RAX,0x1
TEST EAX,EAX
JNS 0x0010117e
LAB_00101197:
MOV EAX,ECX
RET
LAB_0010119a:
MOV ECX,0x0
JMP 0x00101197 | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
if (param_2 + -1 < 0) {
iVar2 = 0;
}
else {
lVar1 = (long)(param_2 + -1);
iVar2 = 0;
do {
iVar2 = iVar2 + ((int)lVar1 * 2 - (param_2 + -1)) * *(int *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + -1;
} while (-1 < (int)lVar1);
}
return iVar2;
} |
4,470 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
js 12f0 <func0+0x30>
movslq %esi,%rax
xor %r8d,%r8d
mov %esi,%edx
mov %eax,%ecx
sub %eax,%edx
sub %edx,%ecx
mov (%rdi,%rax,4),%edx
sub $0x1,%rax
imul %ecx,%edx
add %edx,%r8d
test %eax,%eax
jns 12d0 <func0+0x10>
mov %r8d,%eax
retq
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
js short loc_12F0
movsxd rax, esi
xor r8d, r8d
nop
loc_12D0:
mov ecx, esi
mov edx, eax
sub ecx, eax
sub edx, ecx
imul edx, [rdi+rax*4]
sub rax, 1
add r8d, edx
test eax, eax
jns short loc_12D0
mov eax, r8d
retn
loc_12F0:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
int v2; // esi
long long v3; // rax
unsigned int v4; // r8d
int v5; // edx
v2 = a2 - 1;
if ( v2 < 0 )
return 0LL;
v3 = v2;
v4 = 0;
do
{
v5 = *(_DWORD *)(a1 + 4 * v3) * (v3 - (v2 - v3));
--v3;
v4 += v5;
}
while ( (int)v3 >= 0 );
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x001012f0
MOVSXD RAX,ESI
XOR R8D,R8D
NOP
LAB_001012d0:
MOV ECX,ESI
MOV EDX,EAX
SUB ECX,EAX
SUB EDX,ECX
IMUL EDX,dword ptr [RDI + RAX*0x4]
SUB RAX,0x1
ADD R8D,EDX
TEST EAX,EAX
JNS 0x001012d0
MOV EAX,R8D
RET
LAB_001012f0:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
long lVar3;
int iVar4;
param_2 = param_2 + -1;
if (-1 < param_2) {
lVar3 = (long)param_2;
iVar4 = 0;
do {
iVar2 = (int)lVar3;
lVar1 = lVar3 * 4;
lVar3 = lVar3 + -1;
iVar4 = iVar4 + (iVar2 * 2 - param_2) * *(int *)(param_1 + lVar1);
} while (-1 < (int)lVar3);
return iVar4;
}
return 0;
} |
4,471 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%ecx
sub $0x1,%ecx
js 1520 <func0+0x170>
cmp $0x3,%ecx
jbe 1529 <func0+0x179>
movslq %ecx,%rax
movd %esi,%xmm5
movd %ecx,%xmm6
mov %esi,%edx
lea -0xc(%rdi,%rax,4),%rax
shr $0x2,%edx
pshufd $0x0,%xmm5,%xmm4
movdqa 0xca6(%rip),%xmm5
shl $0x4,%rdx
pshufd $0x0,%xmm6,%xmm6
pxor %xmm3,%xmm3
mov %rax,%r10
sub %rdx,%r10
paddd 0xc7b(%rip),%xmm4
mov %r10,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm7
movdqa %xmm4,%xmm8
movdqa %xmm6,%xmm1
sub $0x10,%rax
psubd %xmm8,%xmm1
movdqa %xmm8,%xmm2
paddd %xmm5,%xmm4
pshufd $0x1b,%xmm7,%xmm0
movdqa %xmm8,%xmm7
pmuludq %xmm0,%xmm2
psrlq $0x20,%xmm7
movdqa %xmm0,%xmm9
psrlq $0x20,%xmm9
pmuludq %xmm1,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm9,%xmm7
pmuludq %xmm9,%xmm1
pshufd $0x8,%xmm2,%xmm2
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm7,%xmm7
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm7,%xmm2
punpckldq %xmm1,%xmm0
psubd %xmm0,%xmm2
paddd %xmm2,%xmm3
cmp %rdx,%rax
jne 1410 <func0+0x60>
movdqa %xmm3,%xmm0
mov %esi,%r8d
mov %ecx,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%r8d
paddd %xmm0,%xmm3
sub %r8d,%edx
movdqa %xmm3,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm3
movd %xmm3,%eax
cmp %esi,%r8d
je 1528 <func0+0x178>
mov %ecx,%r8d
movslq %edx,%r9
mov %edx,%r11d
sub %edx,%r8d
sub %r8d,%r11d
mov (%rdi,%r9,4),%r8d
imul %r11d,%r8d
add %r8d,%eax
lea -0x1(%rdx),%r8d
test %edx,%edx
je 1522 <func0+0x172>
movslq %r8d,%r9
sub %edx,%esi
sub %esi,%r8d
imul (%rdi,%r9,4),%r8d
lea -0x2(%rdx),%esi
add %r8d,%eax
cmp $0x1,%edx
je 1522 <func0+0x172>
mov %ecx,%r9d
movslq %esi,%r8
sub %esi,%r9d
sub %r9d,%esi
imul (%rdi,%r8,4),%esi
add %esi,%eax
lea -0x3(%rdx),%esi
cmp $0x2,%edx
je 1522 <func0+0x172>
movslq %esi,%rdx
sub %esi,%ecx
sub %ecx,%esi
imul (%rdi,%rdx,4),%esi
add %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
mov %ecx,%edx
xor %eax,%eax
jmp 14b8 <func0+0x108>
| func0:
endbr64
mov edx, esi
sub esi, 1
js loc_12A0
cmp esi, 2
jbe loc_12A3
movsxd rax, edx
movd xmm5, edx
movd xmm6, esi
mov r8d, edx
lea rax, [rdi+rax*4-10h]
shr r8d, 2
pshufd xmm4, xmm5, 0
movdqa xmm5, cs:xmmword_2020
shl r8, 4
pshufd xmm6, xmm6, 0
pxor xmm3, xmm3
mov rcx, rax
paddd xmm4, cs:xmmword_2010
sub rcx, r8
nop word ptr [rax+rax+00000000h]
loc_11A0:
movdqu xmm2, xmmword ptr [rax]
movdqa xmm8, xmm4
sub rax, 10h
paddd xmm4, xmm5
movdqa xmm1, xmm8
movdqa xmm7, xmm8
pshufd xmm0, xmm2, 1Bh
psrlq xmm7, 20h ; ' '
pmuludq xmm1, xmm0
movdqa xmm9, xmm0
psrlq xmm9, 20h ; ' '
pmuludq xmm7, xmm9
pshufd xmm1, xmm1, 8
movdqa xmm2, xmm1
movdqa xmm1, xmm6
psubd xmm1, xmm8
pshufd xmm7, xmm7, 8
pmuludq xmm0, xmm1
psrlq xmm1, 20h ; ' '
punpckldq xmm2, xmm7
pmuludq xmm1, xmm9
pshufd xmm0, xmm0, 8
pshufd xmm1, xmm1, 8
punpckldq xmm0, xmm1
psubd xmm2, xmm0
paddd xmm3, xmm2
cmp rcx, rax
jnz short loc_11A0
movdqa xmm0, xmm3
mov r8d, edx
psrldq xmm0, 8
and r8d, 0FFFFFFFCh
paddd xmm3, xmm0
movdqa xmm0, xmm3
psrldq xmm0, 4
paddd xmm3, xmm0
movd eax, xmm3
test dl, 3
jz short locret_12A2
mov ecx, esi
sub ecx, r8d
loc_124C:
mov r11d, esi
movsxd r10, ecx
mov r8d, ecx
sub r11d, ecx
lea r9, ds:0[r10*4]
sub r8d, r11d
imul r8d, [rdi+r10*4]
add eax, r8d
lea r8d, [rcx-1]
test ecx, ecx
jz short locret_12A2
sub edx, ecx
sub r8d, edx
imul r8d, [rdi+r9-4]
lea edx, [rcx-2]
add eax, r8d
cmp ecx, 1
jz short locret_12A2
sub esi, edx
sub edx, esi
imul edx, [rdi+r9-8]
add eax, edx
retn
loc_12A0:
xor eax, eax
locret_12A2:
retn
loc_12A3:
mov ecx, esi
xor eax, eax
jmp short loc_124C | long long func0(long long a1, signed int a2)
{
signed int v3; // esi
const __m128i *v4; // rax
__m128i si128; // xmm5
__m128i v6; // xmm6
__m128i v7; // xmm3
__m128i v8; // xmm4
__m128i v9; // xmm2
__m128i v10; // xmm8
__m128i v11; // xmm0
__m128i v12; // xmm9
__m128i v13; // xmm1
__m128i v14; // xmm3
long long result; // rax
signed int v16; // ecx
long long v17; // r9
v3 = a2 - 1;
if ( v3 < 0 )
return 0LL;
if ( (unsigned int)v3 <= 2 )
{
v16 = v3;
LODWORD(result) = 0;
}
else
{
v4 = (const __m128i *)(a1 + 4LL * a2 - 16);
si128 = _mm_load_si128((const __m128i *)&xmmword_2020);
v6 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v3), 0);
v7 = 0LL;
v8 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(a2), 0), (__m128i)xmmword_2010);
do
{
v9 = _mm_loadu_si128(v4);
v10 = v8;
--v4;
v8 = _mm_add_epi32(v8, si128);
v11 = _mm_shuffle_epi32(v9, 27);
v12 = _mm_srli_epi64(v11, 0x20u);
v13 = _mm_sub_epi32(v6, v10);
v7 = _mm_add_epi32(
v7,
_mm_sub_epi32(
_mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v10, v11), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v10, 0x20u), v12), 8)),
_mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v11, v13), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v13, 0x20u), v12), 8))));
}
while ( (const __m128i *)(a1 + 4LL * a2 - 16 - 16LL * ((unsigned int)a2 >> 2)) != v4 );
v14 = _mm_add_epi32(v7, _mm_srli_si128(v7, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v14, _mm_srli_si128(v14, 4)));
if ( (a2 & 3) == 0 )
return result;
v16 = v3 - (a2 & 0xFFFFFFFC);
}
v17 = 4LL * v16;
result = (unsigned int)(*(_DWORD *)(a1 + v17) * (v16 - (v3 - v16)) + result);
if ( v16 )
{
result = (unsigned int)(*(_DWORD *)(a1 + v17 - 4) * (v16 - 1 - (a2 - v16)) + result);
if ( v16 != 1 )
return (unsigned int)(*(_DWORD *)(a1 + v17 - 8) * (v16 - 2 - (v3 - (v16 - 2))) + result);
}
return result;
} | func0:
ENDBR64
MOV EDX,ESI
SUB ESI,0x1
JS 0x001012a0
CMP ESI,0x2
JBE 0x001012a3
MOVSXD RAX,EDX
MOVD XMM5,EDX
MOVD XMM6,ESI
MOV R8D,EDX
LEA RAX,[RDI + RAX*0x4 + -0x10]
SHR R8D,0x2
PSHUFD XMM4,XMM5,0x0
MOVDQA XMM5,xmmword ptr [0x00102020]
SHL R8,0x4
PSHUFD XMM6,XMM6,0x0
PXOR XMM3,XMM3
MOV RCX,RAX
PADDD XMM4,xmmword ptr [0x00102010]
SUB RCX,R8
NOP word ptr [RAX + RAX*0x1]
LAB_001011a0:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQA XMM8,XMM4
SUB RAX,0x10
PADDD XMM4,XMM5
MOVDQA XMM1,XMM8
MOVDQA XMM7,XMM8
PSHUFD XMM0,XMM2,0x1b
PSRLQ XMM7,0x20
PMULUDQ XMM1,XMM0
MOVDQA XMM9,XMM0
PSRLQ XMM9,0x20
PMULUDQ XMM7,XMM9
PSHUFD XMM1,XMM1,0x8
MOVDQA XMM2,XMM1
MOVDQA XMM1,XMM6
PSUBD XMM1,XMM8
PSHUFD XMM7,XMM7,0x8
PMULUDQ XMM0,XMM1
PSRLQ XMM1,0x20
PUNPCKLDQ XMM2,XMM7
PMULUDQ XMM1,XMM9
PSHUFD XMM0,XMM0,0x8
PSHUFD XMM1,XMM1,0x8
PUNPCKLDQ XMM0,XMM1
PSUBD XMM2,XMM0
PADDD XMM3,XMM2
CMP RCX,RAX
JNZ 0x001011a0
MOVDQA XMM0,XMM3
MOV R8D,EDX
PSRLDQ XMM0,0x8
AND R8D,0xfffffffc
PADDD XMM3,XMM0
MOVDQA XMM0,XMM3
PSRLDQ XMM0,0x4
PADDD XMM3,XMM0
MOVD EAX,XMM3
TEST DL,0x3
JZ 0x001012a2
MOV ECX,ESI
SUB ECX,R8D
LAB_0010124c:
MOV R11D,ESI
MOVSXD R10,ECX
MOV R8D,ECX
SUB R11D,ECX
LEA R9,[R10*0x4]
SUB R8D,R11D
IMUL R8D,dword ptr [RDI + R10*0x4]
ADD EAX,R8D
LEA R8D,[RCX + -0x1]
TEST ECX,ECX
JZ 0x001012a2
SUB EDX,ECX
SUB R8D,EDX
IMUL R8D,dword ptr [RDI + R9*0x1 + -0x4]
LEA EDX,[RCX + -0x2]
ADD EAX,R8D
CMP ECX,0x1
JZ 0x001012a2
SUB ESI,EDX
SUB EDX,ESI
IMUL EDX,dword ptr [RDI + R9*0x1 + -0x8]
ADD EAX,EDX
RET
LAB_001012a0:
XOR EAX,EAX
LAB_001012a2:
RET
LAB_001012a3:
MOV ECX,ESI
XOR EAX,EAX
JMP 0x0010124c | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(long param_1,uint param_2)
{
long lVar1;
int auVar2 [16];
uint *puVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
uint uVar7;
uint *puVar8;
uint uVar9;
int auVar10 [16];
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
uVar9 = param_2 - 1;
if ((int)uVar9 < 0) {
iVar12 = 0;
}
else {
if (uVar9 < 3) {
iVar12 = 0;
uVar7 = uVar9;
}
else {
puVar6 = (uint *)(param_1 + -0x10 + (long)(int)param_2 * 4);
iVar11 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
iVar18 = param_2 + _UNK_0010201c;
puVar8 = puVar6 + (ulong)(param_2 >> 2) * -4;
iVar12 = param_2 + _DAT_00102010;
iVar16 = param_2 + _UNK_00102014;
iVar17 = param_2 + _UNK_00102018;
do {
uVar7 = *puVar6;
puVar3 = puVar6 + 1;
uVar4 = puVar6[2];
uVar5 = puVar6[3];
auVar2._4_4_ = iVar16;
auVar2._0_4_ = iVar12;
auVar2._8_4_ = iVar17;
auVar2._12_4_ = iVar18;
puVar6 = puVar6 + -4;
iVar18 = iVar18 + _UNK_0010202c;
auVar10._4_4_ = uVar4;
auVar10._0_4_ = uVar5;
auVar10._8_4_ = *puVar3;
auVar10._12_4_ = uVar7;
iVar11 = iVar11 + (iVar12 * uVar5 - uVar5 * (uVar9 - iVar12));
iVar13 = iVar13 + (iVar16 * uVar4 - (uVar9 - iVar16) * uVar4);
iVar14 = iVar14 + ((int)((auVar2._8_8_ & 0xffffffff) * (ulong)*puVar3) -
(int)((auVar10._8_8_ & 0xffffffff) * (ulong)(uVar9 - iVar17)));
iVar15 = iVar15 + ((int)((auVar2._8_8_ >> 0x20) * (ulong)uVar7) - (uVar9 - iVar16) * uVar7);
iVar12 = iVar12 + _DAT_00102020;
iVar16 = iVar16 + _UNK_00102024;
iVar17 = iVar17 + _UNK_00102028;
} while (puVar8 != puVar6);
iVar12 = iVar11 + iVar14 + iVar13 + iVar15;
if ((param_2 & 3) == 0) {
return iVar12;
}
uVar7 = uVar9 - (param_2 & 0xfffffffc);
}
lVar1 = (long)(int)uVar7 * 4;
iVar12 = iVar12 + (uVar7 * 2 - uVar9) * *(int *)(param_1 + (long)(int)uVar7 * 4);
if (uVar7 != 0) {
iVar12 = iVar12 + ((uVar7 * 2 + -1) - param_2) * *(int *)(param_1 + -4 + lVar1);
if (uVar7 != 1) {
return iVar12 + ((uVar7 - 2) * 2 - uVar9) * *(int *)(param_1 + -8 + lVar1);
}
}
}
return iVar12;
} |
4,472 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11ff <func0+0x96>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jle 11c7 <func0+0x5e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jge 11fb <func0+0x92>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1193 <func0+0x2a>
mov -0x8(%rbp),%eax
sub -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_C], eax
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_8], eax
mov [rbp+var_4], 1
jmp short loc_11FF
loc_1193:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jle short loc_11C7
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_11C7:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_8], eax
jge short loc_11FB
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
loc_11FB:
add [rbp+var_4], 1
loc_11FF:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1193
mov eax, [rbp+var_8]
sub eax, [rbp+var_C]
pop rbp
retn | long long func0(int *a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = *a1;
v4 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v3 > a1[i] )
v3 = a1[i];
if ( v4 < a1[i] )
v4 = a1[i];
}
return (unsigned int)(v4 - v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011ff
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JLE 0x001011c7
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011c7:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x8],EAX
JGE 0x001011fb
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011fb:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ff:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101193
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int *param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = *param_1;
local_10 = *param_1;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (param_1[local_c] < local_14) {
local_14 = param_1[local_c];
}
if (local_10 < param_1[local_c]) {
local_10 = param_1[local_c];
}
}
return local_10 - local_14;
} |
4,473 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%r8d
cmp $0x1,%esi
jle 119f <func0+0x36>
lea 0x4(%rdi),%rcx
lea -0x2(%rsi),%eax
lea 0x8(%rdi,%rax,4),%rsi
mov %r8d,%eax
mov (%rcx),%edx
cmp %edx,%r8d
cmovg %edx,%r8d
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rcx
cmp %rsi,%rcx
jne 1184 <func0+0x1b>
sub %r8d,%eax
retq
mov %r8d,%eax
jmp 119b <func0+0x32>
| func0:
endbr64
mov r8d, [rdi]
cmp esi, 1
jle short loc_119F
lea rcx, [rdi+4]
lea eax, [rsi-2]
lea rsi, [rdi+rax*4+8]
mov eax, r8d
loc_1184:
mov edx, [rcx]
cmp r8d, edx
cmovg r8d, edx
cmp eax, edx
cmovl eax, edx
add rcx, 4
cmp rcx, rsi
jnz short loc_1184
loc_119B:
sub eax, r8d
retn
loc_119F:
mov eax, r8d
jmp short loc_119B | long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // rcx
long long v4; // rsi
int v5; // eax
v2 = *a1;
if ( a2 <= 1 )
{
v5 = *a1;
}
else
{
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
v5 = *a1;
do
{
if ( v2 > *v3 )
v2 = *v3;
if ( v5 < *v3 )
v5 = *v3;
++v3;
}
while ( v3 != (int *)v4 );
}
return (unsigned int)(v5 - v2);
} | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x0010119f
LEA RCX,[RDI + 0x4]
LEA EAX,[RSI + -0x2]
LEA RSI,[RDI + RAX*0x4 + 0x8]
MOV EAX,R8D
LAB_00101184:
MOV EDX,dword ptr [RCX]
CMP R8D,EDX
CMOVG R8D,EDX
CMP EAX,EDX
CMOVL EAX,EDX
ADD RCX,0x4
CMP RCX,RSI
JNZ 0x00101184
LAB_0010119b:
SUB EAX,R8D
RET
LAB_0010119f:
MOV EAX,R8D
JMP 0x0010119b | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar4 = *param_1;
iVar2 = iVar4;
if (1 < param_2) {
piVar3 = param_1 + 1;
do {
iVar1 = *piVar3;
if (iVar1 < iVar4) {
iVar4 = iVar1;
}
if (iVar2 < iVar1) {
iVar2 = iVar1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
return iVar2 - iVar4;
} |
4,474 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%r8d
cmp $0x1,%esi
jle 1180 <func0+0x40>
lea -0x2(%rsi),%eax
lea 0x4(%rdi),%rcx
lea 0x8(%rdi,%rax,4),%rsi
mov %r8d,%eax
nopl 0x0(%rax,%rax,1)
mov (%rcx),%edx
cmp %edx,%r8d
cmovg %edx,%r8d
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rcx
cmp %rsi,%rcx
jne 1160 <func0+0x20>
sub %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov r8d, [rdi]
cmp esi, 1
jle short loc_1260
lea eax, [rsi-2]
lea rcx, [rdi+4]
lea rsi, [rdi+rax*4+8]
mov eax, r8d
nop dword ptr [rax+rax+00h]
loc_1240:
mov edx, [rcx]
cmp r8d, edx
cmovg r8d, edx
cmp eax, edx
cmovl eax, edx
add rcx, 4
cmp rcx, rsi
jnz short loc_1240
sub eax, r8d
retn
loc_1260:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // rcx
long long v4; // rsi
int v5; // eax
v2 = *a1;
if ( a2 <= 1 )
return 0LL;
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
v5 = *a1;
do
{
if ( v2 > *v3 )
v2 = *v3;
if ( v5 < *v3 )
v5 = *v3;
++v3;
}
while ( v3 != (int *)v4 );
return (unsigned int)(v5 - v2);
} | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101260
LEA EAX,[RSI + -0x2]
LEA RCX,[RDI + 0x4]
LEA RSI,[RDI + RAX*0x4 + 0x8]
MOV EAX,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101240:
MOV EDX,dword ptr [RCX]
CMP R8D,EDX
CMOVG R8D,EDX
CMP EAX,EDX
CMOVL EAX,EDX
ADD RCX,0x4
CMP RCX,RSI
JNZ 0x00101240
SUB EAX,R8D
RET
LAB_00101260:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar4 = *param_1;
if (1 < param_2) {
piVar3 = param_1 + 1;
iVar2 = iVar4;
do {
iVar1 = *piVar3;
if (iVar1 < iVar4) {
iVar4 = iVar1;
}
if (iVar2 < iVar1) {
iVar2 = iVar1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 2) + 2);
return iVar2 - iVar4;
}
return 0;
} |
4,475 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%edx
cmp $0x1,%esi
jle 12a0 <func0+0x160>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%r8d
cmp $0x2,%eax
jbe 12a3 <func0+0x163>
movd %edx,%xmm5
mov %r8d,%edx
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm5,%xmm0
shl $0x4,%rdx
movdqa %xmm0,%xmm1
add %rdi,%rdx
nopl 0x0(%rax)
movdqu 0x4(%rax),%xmm3
movdqa %xmm0,%xmm2
add $0x10,%rax
pcmpgtd %xmm3,%xmm2
movdqa %xmm3,%xmm4
pand %xmm2,%xmm4
pandn %xmm0,%xmm2
movdqa %xmm2,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
por %xmm4,%xmm0
pand %xmm2,%xmm1
pandn %xmm3,%xmm2
por %xmm2,%xmm1
cmp %rdx,%rax
jne 1180 <func0+0x40>
movdqa %xmm1,%xmm2
mov %r8d,%r9d
psrldq $0x8,%xmm2
and $0xfffffffc,%r9d
movdqa %xmm2,%xmm3
lea 0x1(%r9),%ecx
pcmpgtd %xmm1,%xmm3
pand %xmm3,%xmm2
pandn %xmm1,%xmm3
por %xmm3,%xmm2
movdqa %xmm2,%xmm3
psrldq $0x4,%xmm3
movdqa %xmm3,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm3
pandn %xmm2,%xmm1
movdqa %xmm0,%xmm2
psrldq $0x8,%xmm2
por %xmm3,%xmm1
movd %xmm1,%eax
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movd %xmm0,%edx
cmp %r9d,%r8d
je 1294 <func0+0x154>
movslq %ecx,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%edx
cmovg %r8d,%edx
cmp %r8d,%eax
cmovl %r8d,%eax
lea 0x1(%rcx),%r8d
cmp %r8d,%esi
jle 1294 <func0+0x154>
movslq %r8d,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%edx
cmovg %r8d,%edx
cmp %r8d,%eax
cmovl %r8d,%eax
add $0x2,%ecx
cmp %ecx,%esi
jle 1294 <func0+0x154>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%edx
cmovg %ecx,%edx
cmp %ecx,%eax
cmovl %ecx,%eax
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
mov %edx,%eax
mov $0x1,%ecx
jmp 124a <func0+0x10a>
nopl 0x0(%rax)
| func0:
endbr64
mov edx, [rdi]
cmp esi, 1
jle loc_12A0
lea eax, [rsi-2]
lea ecx, [rsi-1]
cmp eax, 2
jbe loc_12A3
movd xmm5, edx
mov edx, ecx
mov rax, rdi
shr edx, 2
pshufd xmm0, xmm5, 0
shl rdx, 4
movdqa xmm1, xmm0
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1180:
movdqu xmm3, xmmword ptr [rax+4]
movdqa xmm2, xmm0
add rax, 10h
pcmpgtd xmm2, xmm3
movdqa xmm4, xmm3
pand xmm4, xmm2
pandn xmm2, xmm0
movdqa xmm0, xmm2
movdqa xmm2, xmm1
pcmpgtd xmm2, xmm3
por xmm0, xmm4
pand xmm1, xmm2
pandn xmm2, xmm3
por xmm1, xmm2
cmp rax, rdx
jnz short loc_1180
movdqa xmm3, xmm1
psrldq xmm3, 8
movdqa xmm2, xmm3
pcmpgtd xmm2, xmm1
pand xmm3, xmm2
pandn xmm2, xmm1
por xmm2, xmm3
movdqa xmm3, xmm2
psrldq xmm3, 4
movdqa xmm1, xmm3
pcmpgtd xmm1, xmm2
pand xmm3, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm0
psrldq xmm2, 8
por xmm1, xmm3
movd eax, xmm1
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movd edx, xmm1
test cl, 3
jz short loc_1294
and ecx, 0FFFFFFFCh
add ecx, 1
loc_1245:
movsxd r8, ecx
lea r9, ds:0[r8*4]
mov r8d, [rdi+r8*4]
cmp edx, r8d
cmovg edx, r8d
cmp eax, r8d
cmovl eax, r8d
lea r8d, [rcx+1]
cmp esi, r8d
jle short loc_1294
mov r8d, [rdi+r9+4]
cmp edx, r8d
cmovg edx, r8d
cmp eax, r8d
cmovl eax, r8d
add ecx, 2
cmp esi, ecx
jle short loc_1294
mov ecx, [rdi+r9+8]
cmp edx, ecx
cmovg edx, ecx
cmp eax, ecx
cmovl eax, ecx
loc_1294:
sub eax, edx
retn
loc_12A0:
xor eax, eax
retn
loc_12A3:
mov eax, edx
mov ecx, 1
jmp short loc_1245 | long long func0(signed int *a1, int a2)
{
signed int v2; // edx
unsigned int v3; // ecx
signed int *v4; // rax
__m128i v5; // xmm0
__m128i v6; // xmm1
__m128i v7; // xmm3
__m128i v8; // xmm2
__m128i v9; // xmm4
__m128i v10; // xmm0
__m128i v11; // xmm2
__m128i v12; // xmm3
__m128i v13; // xmm2
__m128i v14; // xmm2
__m128i v15; // xmm3
__m128i v16; // xmm1
__m128i v17; // xmm3
__m128i v18; // xmm1
__m128i v19; // xmm2
int v20; // eax
__m128i v21; // xmm1
__m128i v22; // xmm0
__m128i v23; // xmm2
__m128i v24; // xmm1
signed int v25; // ecx
long long v26; // r9
signed int v27; // r8d
signed int v28; // r8d
signed int v29; // ecx
v2 = *a1;
if ( a2 > 1 )
{
v3 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v20 = *a1;
v25 = 1;
}
else
{
v4 = a1;
v5 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v2), 0);
v6 = v5;
do
{
v7 = _mm_loadu_si128((const __m128i *)(v4 + 1));
v4 += 4;
v8 = _mm_cmpgt_epi32(v5, v7);
v9 = _mm_and_si128(v7, v8);
v10 = _mm_andnot_si128(v8, v5);
v11 = _mm_cmpgt_epi32(v6, v7);
v5 = _mm_or_si128(v10, v9);
v6 = _mm_or_si128(_mm_and_si128(v6, v11), _mm_andnot_si128(v11, v7));
}
while ( v4 != &a1[4 * (v3 >> 2)] );
v12 = _mm_srli_si128(v6, 8);
v13 = _mm_cmpgt_epi32(v12, v6);
v14 = _mm_or_si128(_mm_andnot_si128(v13, v6), _mm_and_si128(v12, v13));
v15 = _mm_srli_si128(v14, 4);
v16 = _mm_cmpgt_epi32(v15, v14);
v17 = _mm_and_si128(v15, v16);
v18 = _mm_andnot_si128(v16, v14);
v19 = _mm_srli_si128(v5, 8);
v20 = _mm_cvtsi128_si32(_mm_or_si128(v18, v17));
v21 = _mm_cmpgt_epi32(v19, v5);
v22 = _mm_or_si128(_mm_and_si128(v5, v21), _mm_andnot_si128(v21, v19));
v23 = _mm_srli_si128(v22, 4);
v24 = _mm_cmpgt_epi32(v23, v22);
v2 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v24, v23), _mm_and_si128(v22, v24)));
if ( (v3 & 3) == 0 )
return (unsigned int)(v20 - v2);
v25 = (v3 & 0xFFFFFFFC) + 1;
}
v26 = v25;
v27 = a1[v26];
if ( v2 > v27 )
v2 = a1[v25];
if ( v20 < v27 )
v20 = a1[v25];
if ( a2 > v25 + 1 )
{
v28 = a1[v26 + 1];
if ( v2 > v28 )
v2 = a1[v26 + 1];
if ( v20 < v28 )
v20 = a1[v26 + 1];
if ( a2 > v25 + 2 )
{
v29 = a1[v26 + 2];
if ( v2 > v29 )
v2 = a1[v26 + 2];
if ( v20 < v29 )
v20 = a1[v26 + 2];
}
}
return (unsigned int)(v20 - v2);
}
return 0LL;
} | func0:
ENDBR64
MOV EDX,dword ptr [RDI]
CMP ESI,0x1
JLE 0x001012a0
LEA EAX,[RSI + -0x2]
LEA ECX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001012a3
MOVD XMM5,EDX
MOV EDX,ECX
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM0,XMM5,0x0
SHL RDX,0x4
MOVDQA XMM1,XMM0
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM3,xmmword ptr [RAX + 0x4]
MOVDQA XMM2,XMM0
ADD RAX,0x10
PCMPGTD XMM2,XMM3
MOVDQA XMM4,XMM3
PAND XMM4,XMM2
PANDN XMM2,XMM0
MOVDQA XMM0,XMM2
MOVDQA XMM2,XMM1
PCMPGTD XMM2,XMM3
POR XMM0,XMM4
PAND XMM1,XMM2
PANDN XMM2,XMM3
POR XMM1,XMM2
CMP RAX,RDX
JNZ 0x00101180
MOVDQA XMM3,XMM1
PSRLDQ XMM3,0x8
MOVDQA XMM2,XMM3
PCMPGTD XMM2,XMM1
PAND XMM3,XMM2
PANDN XMM2,XMM1
POR XMM2,XMM3
MOVDQA XMM3,XMM2
PSRLDQ XMM3,0x4
MOVDQA XMM1,XMM3
PCMPGTD XMM1,XMM2
PAND XMM3,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x8
POR XMM1,XMM3
MOVD EAX,XMM1
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVD EDX,XMM1
TEST CL,0x3
JZ 0x00101294
AND ECX,0xfffffffc
ADD ECX,0x1
LAB_00101245:
MOVSXD R8,ECX
LEA R9,[R8*0x4]
MOV R8D,dword ptr [RDI + R8*0x4]
CMP EDX,R8D
CMOVG EDX,R8D
CMP EAX,R8D
CMOVL EAX,R8D
LEA R8D,[RCX + 0x1]
CMP ESI,R8D
JLE 0x00101294
MOV R8D,dword ptr [RDI + R9*0x1 + 0x4]
CMP EDX,R8D
CMOVG EDX,R8D
CMP EAX,R8D
CMOVL EAX,R8D
ADD ECX,0x2
CMP ESI,ECX
JLE 0x00101294
MOV ECX,dword ptr [RDI + R9*0x1 + 0x8]
CMP EDX,ECX
CMOVG EDX,ECX
CMP EAX,ECX
CMOVL EAX,ECX
LAB_00101294:
SUB EAX,EDX
RET
LAB_001012a0:
XOR EAX,EAX
RET
LAB_001012a3:
MOV EAX,EDX
MOV ECX,0x1
JMP 0x00101245 | int func0(uint *param_1,int param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
uint uVar7;
int iVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uVar13 = *param_1;
if (param_2 < 2) {
return 0;
}
uVar7 = param_2 - 1;
if (param_2 - 2U < 3) {
iVar8 = 1;
uVar5 = uVar13;
}
else {
puVar6 = param_1;
uVar5 = uVar13;
uVar15 = uVar13;
uVar14 = uVar13;
uVar9 = uVar13;
uVar10 = uVar13;
uVar11 = uVar13;
uVar12 = uVar13;
do {
uVar1 = puVar6[1];
uVar2 = puVar6[2];
uVar3 = puVar6[3];
uVar4 = puVar6[4];
puVar6 = puVar6 + 4;
uVar9 = ~-(uint)((int)uVar1 < (int)uVar9) & uVar9 | uVar1 & -(uint)((int)uVar1 < (int)uVar9);
uVar10 = ~-(uint)((int)uVar2 < (int)uVar10) & uVar10 |
uVar2 & -(uint)((int)uVar2 < (int)uVar10);
uVar11 = ~-(uint)((int)uVar3 < (int)uVar11) & uVar11 |
uVar3 & -(uint)((int)uVar3 < (int)uVar11);
uVar12 = ~-(uint)((int)uVar4 < (int)uVar12) & uVar12 |
uVar4 & -(uint)((int)uVar4 < (int)uVar12);
uVar13 = uVar13 & -(uint)((int)uVar1 < (int)uVar13) |
~-(uint)((int)uVar1 < (int)uVar13) & uVar1;
uVar5 = uVar5 & -(uint)((int)uVar2 < (int)uVar5) | ~-(uint)((int)uVar2 < (int)uVar5) & uVar2;
uVar15 = uVar15 & -(uint)((int)uVar3 < (int)uVar15) |
~-(uint)((int)uVar3 < (int)uVar15) & uVar3;
uVar14 = uVar14 & -(uint)((int)uVar4 < (int)uVar14) |
~-(uint)((int)uVar4 < (int)uVar14) & uVar4;
} while (puVar6 != param_1 + (ulong)(uVar7 >> 2) * 4);
uVar15 = ~-(uint)((int)uVar13 < (int)uVar15) & uVar13 |
uVar15 & -(uint)((int)uVar13 < (int)uVar15);
uVar5 = ~-(uint)((int)uVar5 < (int)uVar14) & uVar5 | uVar14 & -(uint)((int)uVar5 < (int)uVar14);
uVar13 = -(uint)((int)uVar15 < (int)uVar5);
uVar5 = ~uVar13 & uVar15 | uVar5 & uVar13;
uVar13 = uVar9 & -(uint)((int)uVar9 < (int)uVar11) | ~-(uint)((int)uVar9 < (int)uVar11) & uVar11
;
uVar15 = uVar10 & -(uint)((int)uVar10 < (int)uVar12) |
~-(uint)((int)uVar10 < (int)uVar12) & uVar12;
uVar14 = -(uint)((int)uVar13 < (int)uVar15);
uVar13 = ~uVar14 & uVar15 | uVar13 & uVar14;
if ((uVar7 & 3) == 0) goto LAB_00101294;
iVar8 = (uVar7 & 0xfffffffc) + 1;
}
uVar7 = param_1[iVar8];
if ((int)uVar7 < (int)uVar13) {
uVar13 = uVar7;
}
if ((int)uVar5 < (int)uVar7) {
uVar5 = uVar7;
}
if (iVar8 + 1 < param_2) {
uVar7 = param_1[(long)iVar8 + 1];
if ((int)uVar7 < (int)uVar13) {
uVar13 = uVar7;
}
if ((int)uVar5 < (int)uVar7) {
uVar5 = uVar7;
}
if (iVar8 + 2 < param_2) {
uVar7 = param_1[(long)iVar8 + 2];
if ((int)uVar7 < (int)uVar13) {
uVar13 = uVar7;
}
if ((int)uVar5 < (int)uVar7) {
uVar5 = uVar7;
}
}
}
LAB_00101294:
return uVar5 - uVar13;
} |
4,476 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
movzbl (%rax),%eax
movsbl %al,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax]
movsx eax, al
pop rbp
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
POP RBP
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,477 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O1 | c | func0:
endbr64
movsbl (%rdi),%eax
retq
| func0:
endbr64
movsx eax, byte ptr [rdi]
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,478 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O2 | c | func0:
endbr64
movsbl (%rdi),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsx eax, byte ptr [rdi]
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,479 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O3 | c | func0:
endbr64
movsbl (%rdi),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsx eax, byte ptr [rdi]
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,480 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int tri[3][3], int m, int n) {
for (int i = m-1; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
return tri[0][0];
}
| int main() {
int tri1[3][3] = {{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
int tri2[3][3] = {{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
int tri3[3][3] = {{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(tri1, 2, 2) == 14);
assert(func0(tri2, 2, 2) == 24);
assert(func0(tri3, 2, 2) == 53);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 12ed <func0+0x184>
movl $0x0,-0x4(%rbp)
jmpq 12dd <func0+0x174>
mov -0x8(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x8(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
add $0x1,%eax
cltq
mov (%rdx,%rax,4),%eax
cmp %eax,%ecx
jle 1262 <func0+0xf9>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%esi
mov -0x8(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
add %esi,%ecx
mov -0x4(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
jmp 12d9 <func0+0x170>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%esi
mov -0x8(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
add $0x1,%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
add %esi,%ecx
mov -0x4(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jle 1195 <func0+0x2c>
subl $0x1,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jns 1189 <func0+0x20>
mov -0x18(%rbp),%rax
mov (%rax),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp loc_12ED
loc_1189:
mov [rbp+var_4], 0
jmp loc_12DD
loc_1195:
mov eax, [rbp+var_8]
cdqe
lea rdx, [rax+1]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_8]
cdqe
lea rdx, [rax+1]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
add eax, 1
cdqe
mov eax, [rdx+rax*4]
cmp ecx, eax
jle short loc_1262
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov esi, [rdx+rax*4]
mov eax, [rbp+var_8]
cdqe
lea rdx, [rax+1]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
add ecx, esi
mov eax, [rbp+var_4]
cdqe
mov [rdx+rax*4], ecx
jmp short loc_12D9
loc_1262:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov esi, [rdx+rax*4]
mov eax, [rbp+var_8]
cdqe
lea rdx, [rax+1]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
add eax, 1
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
add ecx, esi
mov eax, [rbp+var_4]
cdqe
mov [rdx+rax*4], ecx
loc_12D9:
add [rbp+var_4], 1
loc_12DD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jle loc_1195
sub [rbp+var_8], 1
loc_12ED:
cmp [rbp+var_8], 0
jns loc_1189
mov rax, [rbp+var_18]
mov eax, [rax]
pop rbp
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // ecx
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
for ( i = a2 - 1; i >= 0; --i )
{
for ( j = 0; j <= i; ++j )
{
if ( (int)a1[3 * i + 3 + j] <= (int)a1[3 * i + 4 + j] )
v2 = a1[3 * i + 4 + j];
else
v2 = a1[3 * i + 3 + j];
a1[3 * i + j] += v2;
}
}
return *a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012ed
LAB_00101189:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012dd
LAB_00101195:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX + 0x1]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX + 0x1]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP ECX,EAX
JLE 0x00101262
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX + 0x1]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
ADD ECX,ESI
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
JMP 0x001012d9
LAB_00101262:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX + 0x1]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
ADD ECX,ESI
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
LAB_001012d9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001012dd:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JLE 0x00101195
SUB dword ptr [RBP + -0x8],0x1
LAB_001012ed:
CMP dword ptr [RBP + -0x8],0x0
JNS 0x00101189
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
POP RBP
RET | int4 func0(int4 *param_1,int param_2)
{
int local_10;
int local_c;
for (local_10 = param_2 + -1; -1 < local_10; local_10 = local_10 + -1) {
for (local_c = 0; local_c <= local_10; local_c = local_c + 1) {
if ((int)param_1[((long)local_10 + 1) * 3 + (long)(local_c + 1)] <
(int)param_1[((long)local_10 + 1) * 3 + (long)local_c]) {
param_1[(long)local_10 * 3 + (long)local_c] =
param_1[((long)local_10 + 1) * 3 + (long)local_c] +
param_1[(long)local_10 * 3 + (long)local_c];
}
else {
param_1[(long)local_10 * 3 + (long)local_c] =
param_1[((long)local_10 + 1) * 3 + (long)(local_c + 1)] +
param_1[(long)local_10 * 3 + (long)local_c];
}
}
}
return *param_1;
} |
4,481 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int tri[3][3], int m, int n) {
for (int i = m-1; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
return tri[0][0];
}
| int main() {
int tri1[3][3] = {{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
int tri2[3][3] = {{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
int tri3[3][3] = {{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(tri1, 2, 2) == 14);
assert(func0(tri2, 2, 2) == 24);
assert(func0(tri3, 2, 2) == 53);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
js 11bc <func0+0x53>
movslq %esi,%rax
lea (%rax,%rax,2),%rax
lea (%rdi,%rax,4),%r10
jmp 11aa <func0+0x41>
add %edx,(%r8,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jl 119e <func0+0x35>
mov (%r9,%rax,4),%ecx
mov 0x4(%r9,%rax,4),%edx
cmp %edx,%ecx
jle 117f <func0+0x16>
add %ecx,(%r8,%rax,4)
jmp 1183 <func0+0x1a>
sub $0x1,%esi
sub $0xc,%r10
cmp $0xffffffff,%esi
je 11bc <func0+0x53>
test %esi,%esi
js 119e <func0+0x35>
lea 0xc(%r10),%r9
mov %r10,%r8
mov $0x0,%eax
jmp 118b <func0+0x22>
mov (%rdi),%eax
retq
| func0:
endbr64
sub esi, 1
js short loc_11BC
movsxd rax, esi
lea rax, [rax+rax*2]
lea r10, [rdi+rax*4]
jmp short loc_11AA
loc_117F:
add [r8+rax*4], edx
loc_1183:
add rax, 1
cmp esi, eax
jl short loc_119E
loc_118B:
mov ecx, [r9+rax*4]
mov edx, [r9+rax*4+4]
cmp ecx, edx
jle short loc_117F
add [r8+rax*4], ecx
jmp short loc_1183
loc_119E:
sub esi, 1
sub r10, 0Ch
cmp esi, 0FFFFFFFFh
jz short loc_11BC
loc_11AA:
test esi, esi
js short loc_119E
lea r9, [r10+0Ch]
mov r8, r10
mov eax, 0
jmp short loc_118B
loc_11BC:
mov eax, [rdi]
retn | long long func0(unsigned int *a1, int a2)
{
int v2; // esi
unsigned int *v3; // r10
long long v4; // rax
signed int v5; // ecx
signed int v6; // edx
unsigned int *v7; // r9
v2 = a2 - 1;
if ( v2 >= 0 )
{
v3 = &a1[3 * v2];
do
{
if ( v2 >= 0 )
{
v7 = v3 + 3;
v4 = 0LL;
do
{
v5 = v7[v4];
v6 = v7[v4 + 1];
if ( v5 <= v6 )
v3[v4] += v6;
else
v3[v4] += v5;
++v4;
}
while ( v2 >= (int)v4 );
}
--v2;
v3 -= 3;
}
while ( v2 != -1 );
}
return *a1;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x001011bc
MOVSXD RAX,ESI
LEA RAX,[RAX + RAX*0x2]
LEA R10,[RDI + RAX*0x4]
JMP 0x001011aa
LAB_0010117f:
ADD dword ptr [R8 + RAX*0x4],EDX
LAB_00101183:
ADD RAX,0x1
CMP ESI,EAX
JL 0x0010119e
LAB_0010118b:
MOV ECX,dword ptr [R9 + RAX*0x4]
MOV EDX,dword ptr [R9 + RAX*0x4 + 0x4]
CMP ECX,EDX
JLE 0x0010117f
ADD dword ptr [R8 + RAX*0x4],ECX
JMP 0x00101183
LAB_0010119e:
SUB ESI,0x1
SUB R10,0xc
CMP ESI,-0x1
JZ 0x001011bc
LAB_001011aa:
TEST ESI,ESI
JS 0x0010119e
LEA R9,[R10 + 0xc]
MOV R8,R10
MOV EAX,0x0
JMP 0x0010118b
LAB_001011bc:
MOV EAX,dword ptr [RDI]
RET | int4 func0(int4 *param_1,int param_2)
{
long lVar1;
int4 *puVar2;
param_2 = param_2 + -1;
if (-1 < param_2) {
puVar2 = param_1 + (long)param_2 * 3;
do {
if (-1 < param_2) {
lVar1 = 0;
do {
if ((int)puVar2[lVar1 + 4] < (int)puVar2[lVar1 + 3]) {
puVar2[lVar1] = puVar2[lVar1] + puVar2[lVar1 + 3];
}
else {
puVar2[lVar1] = puVar2[lVar1] + puVar2[lVar1 + 4];
}
lVar1 = lVar1 + 1;
} while ((int)lVar1 <= param_2);
}
param_2 = param_2 + -1;
puVar2 = puVar2 + -3;
} while (param_2 != -1);
}
return *param_1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.