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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
3,982 | func0 |
#include <assert.h>
#include <stdbool.h>
| int func0(int nums[], int length) {
bool exists[1001] = {false}; // Assuming numbers are within 1 to 1000
int no_duplicate = -1;
for (int i = 0; i < length; i++) {
if (exists[nums[i]]) {
return nums[i];
} else {
exists[nums[i]] = true;
}
}
return no_duplicate;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4, 5};
int arr2[] = {1, 2, 3, 4};
int arr3[] = {1, 1, 2, 3, 3, 2, 2};
assert(func0(arr1, 6) == 4);
assert(func0(arr2, 4) == -1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x408,%rsp
mov %rdi,%rdx
mov $0x7d,%ecx
mov %fs:0x28,%rax
mov %rax,0x3f8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movb $0x0,(%rdi)
test %esi,%esi
jle 1330 <func0+0x80>
lea -0x1(%rsi),%eax
mov %rdx,%rdi
lea 0x4(%rdx,%rax,4),%rdx
jmp 12fd <func0+0x4d>
add $0x4,%rdi
movb $0x1,(%rsp,%rax,1)
cmp %rdx,%rdi
je 1330 <func0+0x80>
movslq (%rdi),%rax
cmpb $0x0,(%rsp,%rax,1)
mov %rax,%r8
je 12f0 <func0+0x40>
mov 0x3f8(%rsp),%rax
xor %fs:0x28,%rax
jne 1338 <func0+0x88>
mov %r8d,%eax
add $0x408,%rsp
retq
nopw 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
jmp 1309 <func0+0x59>
callq 1060 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
sub rsp, 408h
mov rdx, rdi
mov ecx, 7Dh ; '}'
mov rax, fs:28h
mov [rsp+408h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov byte ptr [rdi], 0
test esi, esi
jle short loc_1330
lea eax, [rsi-1]
mov rdi, rdx
lea rdx, [rdx+rax*4+4]
jmp short loc_12FD
loc_12F0:
add rdi, 4
mov [rsp+rax+408h+var_408], 1
cmp rdi, rdx
jz short loc_1330
loc_12FD:
movsxd rax, dword ptr [rdi]
cmp [rsp+rax+408h+var_408], 0
mov r8, rax
jz short loc_12F0
loc_1309:
mov rax, [rsp+408h+var_10]
sub rax, fs:28h
jnz short loc_1338
mov eax, r8d
add rsp, 408h
retn
loc_1330:
mov r8d, 0FFFFFFFFh
jmp short loc_1309
loc_1338:
call ___stack_chk_fail | long long func0(int *a1, int a2)
{
long long v2; // rdx
long long v3; // rax
unsigned int v4; // r8d
_BYTE v6[1016]; // [rsp+0h] [rbp-408h] BYREF
unsigned long long v7; // [rsp+3F8h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 1001);
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
v3 = *a1;
v4 = *a1;
if ( v6[v3] )
break;
++a1;
v6[v3] = 1;
if ( a1 == (int *)v2 )
return (unsigned int)-1;
}
}
return v4;
} | func0:
ENDBR64
SUB RSP,0x408
MOV RDX,RDI
MOV ECX,0x7d
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3f8],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV byte ptr [RDI],0x0
TEST ESI,ESI
JLE 0x00101330
LEA EAX,[RSI + -0x1]
MOV RDI,RDX
LEA RDX,[RDX + RAX*0x4 + 0x4]
JMP 0x001012fd
LAB_001012f0:
ADD RDI,0x4
MOV byte ptr [RSP + RAX*0x1],0x1
CMP RDI,RDX
JZ 0x00101330
LAB_001012fd:
MOVSXD RAX,dword ptr [RDI]
CMP byte ptr [RSP + RAX*0x1],0x0
MOV R8,RAX
JZ 0x001012f0
LAB_00101309:
MOV RAX,qword ptr [RSP + 0x3f8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101338
MOV EAX,R8D
ADD RSP,0x408
RET
LAB_00101330:
MOV R8D,0xffffffff
JMP 0x00101309
LAB_00101338:
CALL 0x00101060 | ulong func0(int *param_1,int param_2)
{
int *piVar1;
ulong uVar2;
long lVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_408 [1016];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar4 = local_408;
for (lVar3 = 0x7d; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)pcVar4 = 0;
pcVar4 = (char *)((long)pcVar4 + 8);
}
*pcVar4 = 0;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
uVar2 = (ulong)*param_1;
if (local_408[uVar2] != '\0') goto LAB_00101309;
param_1 = param_1 + 1;
local_408[uVar2] = '\x01';
} while (param_1 != piVar1);
}
uVar2 = 0xffffffff;
LAB_00101309:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
3,983 | func0 |
#include <assert.h>
#include <stdbool.h>
| int func0(int nums[], int length) {
bool exists[1001] = {false}; // Assuming numbers are within 1 to 1000
int no_duplicate = -1;
for (int i = 0; i < length; i++) {
if (exists[nums[i]]) {
return nums[i];
} else {
exists[nums[i]] = true;
}
}
return no_duplicate;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4, 5};
int arr2[] = {1, 2, 3, 4};
int arr3[] = {1, 1, 2, 3, 3, 2, 2};
assert(func0(arr1, 6) == 4);
assert(func0(arr2, 4) == -1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x408,%rsp
mov %rdi,%rdx
mov $0x7d,%ecx
mov %fs:0x28,%rax
mov %rax,0x3f8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movb $0x0,(%rdi)
test %esi,%esi
jle 1300 <func0+0x80>
lea -0x1(%rsi),%eax
mov %rdx,%rdi
lea 0x4(%rdx,%rax,4),%rdx
jmp 12cd <func0+0x4d>
add $0x4,%rdi
movb $0x1,(%rsp,%rax,1)
cmp %rdx,%rdi
je 1300 <func0+0x80>
movslq (%rdi),%rax
cmpb $0x0,(%rsp,%rax,1)
mov %rax,%r8
je 12c0 <func0+0x40>
mov 0x3f8(%rsp),%rax
xor %fs:0x28,%rax
jne 1308 <func0+0x88>
mov %r8d,%eax
add $0x408,%rsp
retq
nopw 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
jmp 12d9 <func0+0x59>
callq 1060 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
sub rsp, 408h
mov rdx, rdi
mov ecx, 7Dh ; '}'
mov rax, fs:28h
mov [rsp+408h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov byte ptr [rdi], 0
test esi, esi
jle short loc_1300
movsxd rsi, esi
mov rdi, rdx
lea rcx, [rdx+rsi*4]
jmp short loc_12CD
loc_12C0:
add rdi, 4
mov [rsp+rax+408h+var_408], 1
cmp rdi, rcx
jz short loc_1300
loc_12CD:
movsxd rax, dword ptr [rdi]
cmp [rsp+rax+408h+var_408], 0
mov rdx, rax
jz short loc_12C0
loc_12D9:
mov rax, [rsp+408h+var_10]
sub rax, fs:28h
jnz short loc_1307
mov eax, edx
add rsp, 408h
retn
loc_1300:
mov edx, 0FFFFFFFFh
jmp short loc_12D9
loc_1307:
call ___stack_chk_fail | long long func0(int *a1, int a2)
{
int *v2; // rcx
long long v3; // rax
unsigned int v4; // edx
_BYTE v6[1016]; // [rsp+0h] [rbp-408h] BYREF
unsigned long long v7; // [rsp+3F8h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 1001);
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = &a1[a2];
while ( 1 )
{
v3 = *a1;
v4 = *a1;
if ( v6[v3] )
break;
++a1;
v6[v3] = 1;
if ( a1 == v2 )
return (unsigned int)-1;
}
}
return v4;
} | func0:
ENDBR64
SUB RSP,0x408
MOV RDX,RDI
MOV ECX,0x7d
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3f8],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV byte ptr [RDI],0x0
TEST ESI,ESI
JLE 0x00101300
MOVSXD RSI,ESI
MOV RDI,RDX
LEA RCX,[RDX + RSI*0x4]
JMP 0x001012cd
LAB_001012c0:
ADD RDI,0x4
MOV byte ptr [RSP + RAX*0x1],0x1
CMP RDI,RCX
JZ 0x00101300
LAB_001012cd:
MOVSXD RAX,dword ptr [RDI]
CMP byte ptr [RSP + RAX*0x1],0x0
MOV RDX,RAX
JZ 0x001012c0
LAB_001012d9:
MOV RAX,qword ptr [RSP + 0x3f8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101307
MOV EAX,EDX
ADD RSP,0x408
RET
LAB_00101300:
MOV EDX,0xffffffff
JMP 0x001012d9
LAB_00101307:
CALL 0x00101060 | ulong func0(int *param_1,int param_2)
{
int *piVar1;
ulong uVar2;
long lVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_408 [1016];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar4 = local_408;
for (lVar3 = 0x7d; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)pcVar4 = 0;
pcVar4 = (char *)((long)pcVar4 + 8);
}
*pcVar4 = 0;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
uVar2 = (ulong)*param_1;
if (local_408[uVar2] != '\0') goto LAB_001012d9;
param_1 = param_1 + 1;
local_408[uVar2] = '\x01';
} while (param_1 != piVar1);
}
uVar2 = 0xffffffff;
LAB_001012d9:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
3,984 | func0 | #include <assert.h>
#include <stddef.h>
| int func0(int list1[][3], size_t rows) {
int maxi = -100000;
for (size_t i = 0; i < rows; i++) {
int sum = 0;
for (size_t j = 0; j < 3; j++) {
sum += list1[i][j];
}
if (sum > maxi) {
maxi = sum;
}
}
return maxi;
}
| int main() {
int data1[][3] = {{1, 2, 3}, {4, 5, 6}, {10, 11, 12}, {7, 8, 9}};
assert(func0(data1, 4) == 33);
int data2[][3] = {{0, 1, 1}, {1, 1, 2}, {3, 2, 1}};
assert(func0(data2, 3) == 6);
int data3[][3] = {{0, 1, 3}, {1, 2, 1}, {9, 8, 2}, {0, 1, 0}, {6, 4, 8}};
assert(func0(data3, 5) == 19);
int data4[][3] = {{0, -1, -1}, {-1, -1, -2}, {-3, -2, -1}};
assert(func0(data4, 3) == -2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0xfffe7960,-0x18(%rbp)
movq $0x0,-0x10(%rbp)
jmp 11df <func0+0x76>
movl $0x0,-0x14(%rbp)
movq $0x0,-0x8(%rbp)
jmp 11c5 <func0+0x5c>
mov -0x10(%rbp),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%rax
mov (%rdx,%rax,4),%eax
add %eax,-0x14(%rbp)
addq $0x1,-0x8(%rbp)
cmpq $0x2,-0x8(%rbp)
jbe 119b <func0+0x32>
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 11da <func0+0x71>
mov -0x14(%rbp),%eax
mov %eax,-0x18(%rbp)
addq $0x1,-0x10(%rbp)
mov -0x10(%rbp),%rax
cmp -0x30(%rbp),%rax
jb 118a <func0+0x21>
mov -0x18(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_18], 0FFFE7960h
mov [rbp+var_10], 0
jmp short loc_11DF
loc_118A:
mov [rbp+var_14], 0
mov [rbp+var_8], 0
jmp short loc_11C5
loc_119B:
mov rdx, [rbp+var_10]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rdx, rax
mov rax, [rbp+var_8]
mov eax, [rdx+rax*4]
add [rbp+var_14], eax
add [rbp+var_8], 1
loc_11C5:
cmp [rbp+var_8], 2
jbe short loc_119B
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jle short loc_11DA
mov eax, [rbp+var_14]
mov [rbp+var_18], eax
loc_11DA:
add [rbp+var_10], 1
loc_11DF:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jb short loc_118A
mov eax, [rbp+var_18]
pop rbp
retn | long long func0(long long a1, unsigned long long a2)
{
int v3; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
unsigned long long i; // [rsp+20h] [rbp-10h]
unsigned long long j; // [rsp+28h] [rbp-8h]
v3 = -100000;
for ( i = 0LL; i < a2; ++i )
{
v4 = 0;
for ( j = 0LL; j <= 2; ++j )
v4 += *(_DWORD *)(a1 + 12 * i + 4 * j);
if ( v4 > v3 )
v3 = v4;
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x18],0xfffe7960
MOV qword ptr [RBP + -0x10],0x0
JMP 0x001011df
LAB_0010118a:
MOV dword ptr [RBP + -0x14],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001011c5
LAB_0010119b:
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x14],EAX
ADD qword ptr [RBP + -0x8],0x1
LAB_001011c5:
CMP qword ptr [RBP + -0x8],0x2
JBE 0x0010119b
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x001011da
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x18],EAX
LAB_001011da:
ADD qword ptr [RBP + -0x10],0x1
LAB_001011df:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JC 0x0010118a
MOV EAX,dword ptr [RBP + -0x18]
POP RBP
RET | int func0(long param_1,ulong param_2)
{
int4 local_20;
int4 local_1c;
int8 local_18;
int8 local_10;
local_20 = -100000;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
local_1c = 0;
for (local_10 = 0; local_10 < 3; local_10 = local_10 + 1) {
local_1c = local_1c + *(int *)(local_18 * 0xc + param_1 + local_10 * 4);
}
if (local_20 < local_1c) {
local_20 = local_1c;
}
}
return local_20;
} |
3,985 | func0 | #include <assert.h>
#include <stddef.h>
| int func0(int list1[][3], size_t rows) {
int maxi = -100000;
for (size_t i = 0; i < rows; i++) {
int sum = 0;
for (size_t j = 0; j < 3; j++) {
sum += list1[i][j];
}
if (sum > maxi) {
maxi = sum;
}
}
return maxi;
}
| int main() {
int data1[][3] = {{1, 2, 3}, {4, 5, 6}, {10, 11, 12}, {7, 8, 9}};
assert(func0(data1, 4) == 33);
int data2[][3] = {{0, 1, 1}, {1, 1, 2}, {3, 2, 1}};
assert(func0(data2, 3) == 6);
int data3[][3] = {{0, 1, 3}, {1, 2, 1}, {9, 8, 2}, {0, 1, 0}, {6, 4, 8}};
assert(func0(data3, 5) == 19);
int data4[][3] = {{0, -1, -1}, {-1, -1, -2}, {-3, -2, -1}};
assert(func0(data4, 3) == -2);
return 0;
}
| O1 | c | func0:
endbr64
test %rsi,%rsi
je 119b <func0+0x32>
mov %rdi,%rdx
lea (%rsi,%rsi,2),%rax
lea (%rdi,%rax,4),%rsi
mov $0xfffe7960,%ecx
mov 0x4(%rdx),%eax
add (%rdx),%eax
add 0x8(%rdx),%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0xc,%rdx
cmp %rsi,%rdx
jne 1182 <func0+0x19>
mov %ecx,%eax
retq
mov $0xfffe7960,%ecx
jmp 1198 <func0+0x2f>
| func0:
endbr64
test rsi, rsi
jz short loc_119B
mov rdx, rdi
lea rax, [rsi+rsi*2]
lea rsi, [rdi+rax*4]
mov ecx, 0FFFE7960h
loc_1182:
mov eax, [rdx+4]
add eax, [rdx]
add eax, [rdx+8]
cmp ecx, eax
cmovl ecx, eax
add rdx, 0Ch
cmp rdx, rsi
jnz short loc_1182
loc_1198:
mov eax, ecx
retn
loc_119B:
mov ecx, 0FFFE7960h
jmp short loc_1198 | long long func0(_DWORD *a1, long long a2)
{
_DWORD *v2; // rdx
_DWORD *v3; // rsi
int v4; // ecx
if ( a2 )
{
v2 = a1;
v3 = &a1[3 * a2];
v4 = -100000;
do
{
if ( v4 < v2[2] + *v2 + v2[1] )
v4 = v2[2] + *v2 + v2[1];
v2 += 3;
}
while ( v2 != v3 );
}
else
{
return (unsigned int)-100000;
}
return (unsigned int)v4;
} | func0:
ENDBR64
TEST RSI,RSI
JZ 0x0010119b
MOV RDX,RDI
LEA RAX,[RSI + RSI*0x2]
LEA RSI,[RDI + RAX*0x4]
MOV ECX,0xfffe7960
LAB_00101182:
MOV EAX,dword ptr [RDX + 0x4]
ADD EAX,dword ptr [RDX]
ADD EAX,dword ptr [RDX + 0x8]
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0xc
CMP RDX,RSI
JNZ 0x00101182
LAB_00101198:
MOV EAX,ECX
RET
LAB_0010119b:
MOV ECX,0xfffe7960
JMP 0x00101198 | int func0(int *param_1,long param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 == 0) {
iVar3 = -100000;
}
else {
piVar1 = param_1 + param_2 * 3;
iVar3 = -100000;
do {
iVar2 = param_1[1] + *param_1 + param_1[2];
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 3;
} while (param_1 != piVar1);
}
return iVar3;
} |
3,986 | func0 | #include <assert.h>
#include <stddef.h>
| int func0(int list1[][3], size_t rows) {
int maxi = -100000;
for (size_t i = 0; i < rows; i++) {
int sum = 0;
for (size_t j = 0; j < 3; j++) {
sum += list1[i][j];
}
if (sum > maxi) {
maxi = sum;
}
}
return maxi;
}
| int main() {
int data1[][3] = {{1, 2, 3}, {4, 5, 6}, {10, 11, 12}, {7, 8, 9}};
assert(func0(data1, 4) == 33);
int data2[][3] = {{0, 1, 1}, {1, 1, 2}, {3, 2, 1}};
assert(func0(data2, 3) == 6);
int data3[][3] = {{0, 1, 3}, {1, 2, 1}, {9, 8, 2}, {0, 1, 0}, {6, 4, 8}};
assert(func0(data3, 5) == 19);
int data4[][3] = {{0, -1, -1}, {-1, -1, -2}, {-3, -2, -1}};
assert(func0(data4, 3) == -2);
return 0;
}
| O2 | c | func0:
endbr64
test %rsi,%rsi
je 133c <func0+0x3c>
lea (%rsi,%rsi,2),%rax
mov $0xfffe7960,%r8d
lea (%rdi,%rax,4),%rdx
nopw 0x0(%rax,%rax,1)
mov 0x4(%rdi),%eax
add (%rdi),%eax
add 0x8(%rdi),%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0xc,%rdi
cmp %rdx,%rdi
jne 1320 <func0+0x20>
mov %r8d,%eax
retq
mov $0xfffe7960,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test rsi, rsi
jz short loc_140C
lea rax, [rsi+rsi*2]
mov r8d, 0FFFE7960h
lea rdx, [rdi+rax*4]
nop word ptr [rax+rax+00000000h]
loc_13F0:
mov eax, [rdi+4]
add eax, [rdi]
add eax, [rdi+8]
cmp r8d, eax
cmovl r8d, eax
add rdi, 0Ch
cmp rdi, rdx
jnz short loc_13F0
mov eax, r8d
retn
loc_140C:
mov r8d, 0FFFE7960h
mov eax, r8d
retn | long long func0(_DWORD *a1, long long a2)
{
int v2; // r8d
_DWORD *v3; // rdx
if ( !a2 )
return 4294867296LL;
v2 = -100000;
v3 = &a1[3 * a2];
do
{
if ( v2 < a1[2] + *a1 + a1[1] )
v2 = a1[2] + *a1 + a1[1];
a1 += 3;
}
while ( a1 != v3 );
return (unsigned int)v2;
} | func0:
ENDBR64
TEST RSI,RSI
JZ 0x0010140c
LEA RAX,[RSI + RSI*0x2]
MOV R8D,0xfffe7960
LEA RDX,[RDI + RAX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV EAX,dword ptr [RDI + 0x4]
ADD EAX,dword ptr [RDI]
ADD EAX,dword ptr [RDI + 0x8]
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0xc
CMP RDI,RDX
JNZ 0x001013f0
MOV EAX,R8D
RET
LAB_0010140c:
MOV R8D,0xfffe7960
MOV EAX,R8D
RET | int func0(int *param_1,long param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 != 0) {
iVar3 = -100000;
piVar1 = param_1 + param_2 * 3;
do {
iVar2 = param_1[1] + *param_1 + param_1[2];
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 3;
} while (param_1 != piVar1);
return iVar3;
}
return -100000;
} |
3,987 | func0 | #include <assert.h>
#include <stddef.h>
| int func0(int list1[][3], size_t rows) {
int maxi = -100000;
for (size_t i = 0; i < rows; i++) {
int sum = 0;
for (size_t j = 0; j < 3; j++) {
sum += list1[i][j];
}
if (sum > maxi) {
maxi = sum;
}
}
return maxi;
}
| int main() {
int data1[][3] = {{1, 2, 3}, {4, 5, 6}, {10, 11, 12}, {7, 8, 9}};
assert(func0(data1, 4) == 33);
int data2[][3] = {{0, 1, 1}, {1, 1, 2}, {3, 2, 1}};
assert(func0(data2, 3) == 6);
int data3[][3] = {{0, 1, 3}, {1, 2, 1}, {9, 8, 2}, {0, 1, 0}, {6, 4, 8}};
assert(func0(data3, 5) == 19);
int data4[][3] = {{0, -1, -1}, {-1, -1, -2}, {-3, -2, -1}};
assert(func0(data4, 3) == -2);
return 0;
}
| O3 | c | func0:
endbr64
test %rsi,%rsi
je 131c <func0+0x3c>
lea (%rsi,%rsi,2),%rax
mov $0xfffe7960,%r8d
lea (%rdi,%rax,4),%rdx
nopw 0x0(%rax,%rax,1)
mov 0x4(%rdi),%eax
add (%rdi),%eax
add 0x8(%rdi),%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0xc,%rdi
cmp %rdi,%rdx
jne 1300 <func0+0x20>
mov %r8d,%eax
retq
mov $0xfffe7960,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov rcx, rsi
test rsi, rsi
jz loc_1298
lea rax, [rsi-1]
cmp rax, 2
jbe loc_129F
mov rdx, rsi
movdqa xmm4, cs:xmmword_2010
mov rax, rdi
shr rdx, 2
lea rdx, [rdx+rdx*2]
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+rax+00h]
loc_1180:
movdqu xmm3, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
add rax, 30h ; '0'
movdqu xmm5, xmmword ptr [rax-10h]
movdqa xmm2, xmm1
movdqa xmm0, xmm3
shufps xmm2, xmm3, 0Ah
shufps xmm0, xmm2, 8Ch
movdqa xmm2, xmm5
movdqa xmm6, xmm5
shufps xmm2, xmm0, 0A5h
shufps xmm0, xmm2, 24h ; '$'
movdqa xmm2, xmm3
shufps xmm2, xmm1, 0C1h
pshufd xmm2, xmm2, 78h ; 'x'
shufps xmm1, xmm3, 0A5h
shufps xmm1, xmm3, 2
shufps xmm6, xmm2, 0AAh
shufps xmm2, xmm6, 24h ; '$'
paddd xmm0, xmm2
shufps xmm1, xmm5, 0C4h
paddd xmm0, xmm1
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm4
pand xmm0, xmm1
pandn xmm1, xmm4
movdqa xmm4, xmm1
por xmm4, xmm0
cmp rax, rdx
jnz short loc_1180
movdqa xmm1, xmm4
mov rsi, rcx
psrldq xmm1, 8
and rsi, 0FFFFFFFFFFFFFFFCh
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm4
pand xmm1, xmm0
pandn xmm0, xmm4
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
test cl, 3
jz short locret_129E
loc_1242:
lea r8, [rsi+rsi*2]
shl r8, 2
lea r9, [rdi+r8]
mov edx, [r9+4]
add edx, [r9]
add edx, [r9+8]
cmp eax, edx
cmovl eax, edx
lea rdx, [rsi+1]
cmp rdx, rcx
jnb short locret_129D
lea r9, [rdi+r8+0Ch]
mov edx, [r9+4]
add edx, [r9]
add edx, [r9+8]
cmp eax, edx
cmovl eax, edx
add rsi, 2
cmp rsi, rcx
jnb short locret_129D
lea rcx, [rdi+r8+18h]
mov edx, [rcx]
add edx, [rcx+4]
add edx, [rcx+8]
cmp eax, edx
cmovl eax, edx
retn
loc_1298:
mov eax, 0FFFE7960h
locret_129D:
retn
locret_129E:
retn
loc_129F:
xor esi, esi
mov eax, 0FFFE7960h
jmp short loc_1242 | long long func0(const __m128i *a1, unsigned long long a2)
{
__m128i si128; // xmm4
const __m128i *v4; // rax
__m128 v5; // xmm3
__m128 v6; // xmm1
__m128 v7; // xmm5
__m128 v8; // xmm0
__m128 v9; // xmm2
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm1
unsigned long long v13; // rsi
__m128i v14; // xmm0
__m128i v15; // xmm0
__m128i v16; // xmm2
__m128i v17; // xmm1
long long result; // rax
long long v19; // r8
int v20; // edx
int v21; // edx
int v22; // edx
if ( !a2 )
return 4294867296LL;
if ( a2 - 1 <= 2 )
{
v13 = 0LL;
result = 4294867296LL;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = a1;
do
{
v5 = (__m128)_mm_loadu_si128(v4);
v6 = (__m128)_mm_loadu_si128(v4 + 1);
v4 += 3;
v7 = (__m128)_mm_loadu_si128(v4 - 1);
v8 = _mm_shuffle_ps(v5, _mm_shuffle_ps(v6, v5, 10), 140);
v9 = (__m128)_mm_shuffle_epi32((__m128i)_mm_shuffle_ps(v5, v6, 193), 120);
v10 = _mm_add_epi32(
_mm_add_epi32(
(__m128i)_mm_shuffle_ps(v8, _mm_shuffle_ps(v7, v8, 165), 36),
(__m128i)_mm_shuffle_ps(v9, _mm_shuffle_ps(v7, v9, 170), 36)),
(__m128i)_mm_shuffle_ps(_mm_shuffle_ps(_mm_shuffle_ps(v6, v5, 165), v5, 2), v7, 196));
v11 = _mm_cmpgt_epi32(v10, si128);
si128 = _mm_or_si128(_mm_andnot_si128(v11, si128), _mm_and_si128(v10, v11));
}
while ( v4 != &a1[3 * (a2 >> 2)] );
v12 = _mm_srli_si128(si128, 8);
v13 = a2 & 0xFFFFFFFFFFFFFFFCLL;
v14 = _mm_cmpgt_epi32(v12, si128);
v15 = _mm_or_si128(_mm_andnot_si128(v14, si128), _mm_and_si128(v12, v14));
v16 = _mm_srli_si128(v15, 4);
v17 = _mm_cmpgt_epi32(v16, v15);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v17, v15), _mm_and_si128(v16, v17)));
if ( (a2 & 3) == 0 )
return result;
}
v19 = 3 * v13;
v20 = a1->m128i_i32[3 * v13 + 2] + a1->m128i_i32[3 * v13] + a1->m128i_i32[3 * v13 + 1];
if ( (int)result < v20 )
result = (unsigned int)v20;
if ( v13 + 1 < a2 )
{
v21 = a1[1].m128i_i32[v19 + 1] + a1->m128i_i32[v19 + 3] + a1[1].m128i_i32[v19];
if ( (int)result < v21 )
result = (unsigned int)v21;
if ( v13 + 2 < a2 )
{
v22 = a1[2].m128i_i32[v19] + a1[1].m128i_i32[v19 + 3] + a1[1].m128i_i32[v19 + 2];
if ( (int)result < v22 )
return (unsigned int)v22;
}
}
return result;
} | func0:
ENDBR64
MOV RCX,RSI
TEST RSI,RSI
JZ 0x00101298
LEA RAX,[RSI + -0x1]
CMP RAX,0x2
JBE 0x0010129f
MOV RDX,RSI
MOVDQA XMM4,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR RDX,0x2
LEA RDX,[RDX + RDX*0x2]
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
ADD RAX,0x30
MOVDQU XMM5,xmmword ptr [RAX + -0x10]
MOVDQA XMM2,XMM1
MOVDQA XMM0,XMM3
SHUFPS XMM2,XMM3,0xa
SHUFPS XMM0,XMM2,0x8c
MOVDQA XMM2,XMM5
MOVDQA XMM6,XMM5
SHUFPS XMM2,XMM0,0xa5
SHUFPS XMM0,XMM2,0x24
MOVDQA XMM2,XMM3
SHUFPS XMM2,XMM1,0xc1
PSHUFD XMM2,XMM2,0x78
SHUFPS XMM1,XMM3,0xa5
SHUFPS XMM1,XMM3,0x2
SHUFPS XMM6,XMM2,0xaa
SHUFPS XMM2,XMM6,0x24
PADDD XMM0,XMM2
SHUFPS XMM1,XMM5,0xc4
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM4
PAND XMM0,XMM1
PANDN XMM1,XMM4
MOVDQA XMM4,XMM1
POR XMM4,XMM0
CMP RAX,RDX
JNZ 0x00101180
MOVDQA XMM1,XMM4
MOV RSI,RCX
PSRLDQ XMM1,0x8
AND RSI,-0x4
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM4
PAND XMM1,XMM0
PANDN XMM0,XMM4
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
TEST CL,0x3
JZ 0x0010129e
LAB_00101242:
LEA R8,[RSI + RSI*0x2]
SHL R8,0x2
LEA R9,[RDI + R8*0x1]
MOV EDX,dword ptr [R9 + 0x4]
ADD EDX,dword ptr [R9]
ADD EDX,dword ptr [R9 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LEA RDX,[RSI + 0x1]
CMP RDX,RCX
JNC 0x0010129d
LEA R9,[RDI + R8*0x1 + 0xc]
MOV EDX,dword ptr [R9 + 0x4]
ADD EDX,dword ptr [R9]
ADD EDX,dword ptr [R9 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
ADD RSI,0x2
CMP RSI,RCX
JNC 0x0010129d
LEA RCX,[RDI + R8*0x1 + 0x18]
MOV EDX,dword ptr [RCX]
ADD EDX,dword ptr [RCX + 0x4]
ADD EDX,dword ptr [RCX + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
RET
LAB_00101298:
MOV EAX,0xfffe7960
LAB_0010129d:
RET
LAB_0010129e:
RET
LAB_0010129f:
XOR ESI,ESI
MOV EAX,0xfffe7960
JMP 0x00101242 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(int *param_1,ulong param_2)
{
uint uVar1;
int *piVar2;
int *piVar3;
uint uVar4;
ulong uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
if (param_2 == 0) {
uVar1 = 0xfffe7960;
}
else {
if (param_2 - 1 < 3) {
uVar5 = 0;
uVar1 = 0xfffe7960;
}
else {
piVar2 = param_1;
uVar1 = _DAT_00102010;
uVar4 = _UNK_00102014;
uVar11 = _UNK_00102018;
uVar15 = _UNK_0010201c;
do {
piVar3 = piVar2 + 0xc;
uVar6 = *piVar2 + piVar2[1] + piVar2[2];
uVar7 = piVar2[3] + piVar2[4] + piVar2[5];
uVar8 = piVar2[6] + piVar2[7] + piVar2[8];
uVar9 = piVar2[9] + piVar2[10] + piVar2[0xb];
uVar10 = -(uint)((int)uVar1 < (int)uVar6);
uVar12 = -(uint)((int)uVar4 < (int)uVar7);
uVar13 = -(uint)((int)uVar11 < (int)uVar8);
uVar14 = -(uint)((int)uVar15 < (int)uVar9);
uVar1 = ~uVar10 & uVar1 | uVar6 & uVar10;
uVar4 = ~uVar12 & uVar4 | uVar7 & uVar12;
uVar11 = ~uVar13 & uVar11 | uVar8 & uVar13;
uVar15 = ~uVar14 & uVar15 | uVar9 & uVar14;
piVar2 = piVar3;
} while (piVar3 != param_1 + (param_2 >> 2) * 0xc);
uVar5 = param_2 & 0xfffffffffffffffc;
uVar1 = ~-(uint)((int)uVar1 < (int)uVar11) & uVar1 |
uVar11 & -(uint)((int)uVar1 < (int)uVar11);
uVar4 = ~-(uint)((int)uVar4 < (int)uVar15) & uVar4 |
uVar15 & -(uint)((int)uVar4 < (int)uVar15);
uVar11 = -(uint)((int)uVar1 < (int)uVar4);
uVar1 = ~uVar11 & uVar1 | uVar4 & uVar11;
if ((param_2 & 3) == 0) {
return uVar1;
}
}
piVar2 = param_1 + uVar5 * 3;
uVar4 = piVar2[1] + *piVar2 + piVar2[2];
if ((int)uVar1 < (int)uVar4) {
uVar1 = uVar4;
}
if (uVar5 + 1 < param_2) {
piVar2 = param_1 + uVar5 * 3 + 3;
uVar4 = piVar2[1] + *piVar2 + piVar2[2];
if ((int)uVar1 < (int)uVar4) {
uVar1 = uVar4;
}
if (uVar5 + 2 < param_2) {
param_1 = param_1 + uVar5 * 3 + 6;
uVar4 = *param_1 + param_1[1] + param_1[2];
if ((int)uVar1 < (int)uVar4) {
uVar1 = uVar4;
}
return uVar1;
}
}
}
return uVar1;
} |
3,988 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int binary) {
int binary1 = binary;
int decimal = 0;
int i = 0;
while(binary != 0) {
int dec = binary % 10;
decimal += dec * (int)pow(2, i);
binary /= 10;
i++;
}
return decimal;
}
| int main() {
assert(func0(100) == 4);
assert(func0(1011) == 11);
assert(func0(1101101) == 109);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1202 <func0+0x99>
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
mov 0xeb9(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
cvttsd2si %xmm0,%eax
imul -0x4(%rbp),%eax
add %eax,-0x10(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x14(%rbp)
addl $0x1,-0xc(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 118e <func0+0x25>
mov -0x10(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_1204
loc_118E:
mov edx, [rbp+var_14]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_4], edx
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_C]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
imul eax, [rbp+var_4]
add [rbp+var_10], eax
mov eax, [rbp+var_14]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_14], eax
add [rbp+var_C], 1
loc_1204:
cmp [rbp+var_14], 0
jnz short loc_118E
mov eax, [rbp+var_10]
leave
retn | long long func0(int a1)
{
unsigned int v3; // [rsp+10h] [rbp-10h]
int v4; // [rsp+14h] [rbp-Ch]
v3 = 0;
v4 = 0;
while ( a1 )
{
v3 += a1 % 10 * (int)pow(2.0, (double)v4);
a1 /= 10;
++v4;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101204
LAB_0010118e:
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [0x00102068]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
CVTTSD2SI EAX,XMM0
IMUL EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_00101204:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010118e
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | int func0(int param_1)
{
double dVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
local_18 = 0;
local_14 = 0;
for (local_1c = param_1; local_1c != 0; local_1c = local_1c / 10) {
dVar1 = pow(DAT_00102068,(double)local_14);
local_18 = local_18 + (int)dVar1 * (local_1c % 10);
local_14 = local_14 + 1;
}
return local_18;
} |
3,989 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int binary) {
int binary1 = binary;
int decimal = 0;
int i = 0;
while(binary != 0) {
int dec = binary % 10;
decimal += dec * (int)pow(2, i);
binary /= 10;
i++;
}
return decimal;
}
| int main() {
assert(func0(100) == 4);
assert(func0(1011) == 11);
assert(func0(1101101) == 109);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %edi,%ebx
test %edi,%edi
je 11d2 <func0+0x69>
mov $0x0,%ebp
mov $0x0,%r12d
pxor %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mov 0xeef(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
cvttsd2si %xmm0,%edx
movslq %ebx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %ebx,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%ebx
imul %edx,%ebx
add %ebx,%r12d
mov %eax,%ebx
add $0x1,%ebp
test %eax,%eax
jne 1182 <func0+0x19>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
mov %edi,%r12d
jmp 11ca <func0+0x61>
| func0:
endbr64
push r12
push rbp
push rbx
mov ebx, edi
test edi, edi
jz short loc_11D2
mov ebp, 0
mov r12d, 0
loc_1182:
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
mov rax, cs:qword_2060
movq xmm0, rax
call _pow
cvttsd2si edx, xmm0
movsxd rax, ebx
imul rax, 66666667h
sar rax, 22h
mov ecx, ebx
sar ecx, 1Fh
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
sub ebx, ecx
imul ebx, edx
add r12d, ebx
mov ebx, eax
add ebp, 1
test eax, eax
jnz short loc_1182
loc_11CA:
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_11D2:
mov r12d, edi
jmp short loc_11CA | long long func0(int a1)
{
int v1; // ebx
int v2; // ebp
unsigned int v3; // r12d
v1 = a1;
if ( a1 )
{
v2 = 0;
v3 = 0;
do
{
v3 += (int)pow(2.0, (double)v2) * (v1 % 10);
v1 /= 10;
++v2;
}
while ( v1 );
}
else
{
return 0;
}
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
TEST EDI,EDI
JZ 0x001011d2
MOV EBP,0x0
MOV R12D,0x0
LAB_00101182:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
MOV RAX,qword ptr [0x00102060]
MOVQ XMM0,RAX
CALL 0x00101060
CVTTSD2SI EDX,XMM0
MOVSXD RAX,EBX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EBX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EBX,ECX
IMUL EBX,EDX
ADD R12D,EBX
MOV EBX,EAX
ADD EBP,0x1
TEST EAX,EAX
JNZ 0x00101182
LAB_001011ca:
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_001011d2:
MOV R12D,EDI
JMP 0x001011ca | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
if (param_1 == 0) {
iVar3 = 0;
}
else {
iVar2 = 0;
iVar3 = 0;
do {
dVar4 = pow(DAT_00102060,(double)iVar2);
iVar1 = param_1 / 10;
iVar3 = iVar3 + (param_1 % 10) * (int)dVar4;
iVar2 = iVar2 + 1;
param_1 = iVar1;
} while (iVar1 != 0);
}
return iVar3;
} |
3,990 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int binary) {
int binary1 = binary;
int decimal = 0;
int i = 0;
while(binary != 0) {
int dec = binary % 10;
decimal += dec * (int)pow(2, i);
binary /= 10;
i++;
}
return decimal;
}
| int main() {
assert(func0(100) == 4);
assert(func0(1011) == 11);
assert(func0(1101101) == 109);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
test %edi,%edi
je 1280 <func0+0x70>
mov %edi,%ebx
xor %ebp,%ebp
xor %r12d,%r12d
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
mov 0xe4d(%rip),%rax
cvtsi2sd %ebp,%xmm1
add $0x1,%ebp
movq %rax,%xmm0
callq 1060 <pow@plt>
movslq %ebx,%rax
mov %ebx,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
cvttsd2si %xmm0,%edi
sar $0x22,%rax
sub %edx,%eax
lea (%rax,%rax,4),%edx
add %edx,%edx
sub %edx,%ebx
imul %edi,%ebx
add %ebx,%r12d
mov %eax,%ebx
test %eax,%eax
jne 1228 <func0+0x18>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
pop %rbx
pop %rbp
mov %r12d,%eax
pop %r12
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
test edi, edi
jz short loc_1280
mov ebx, edi
xor ebp, ebp
xor r12d, r12d
nop dword ptr [rax+rax+00h]
loc_1228:
pxor xmm1, xmm1
mov rax, cs:qword_2060
cvtsi2sd xmm1, ebp
add ebp, 1
movq xmm0, rax
call _pow
movsxd rax, ebx
mov ecx, ebx
imul rax, 66666667h
sar ecx, 1Fh
cvttsd2si edx, xmm0
sar rax, 22h
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
sub ebx, ecx
imul edx, ebx
mov ebx, eax
add r12d, edx
test eax, eax
jnz short loc_1228
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1280:
xor r12d, r12d
pop rbx
pop rbp
mov eax, r12d
pop r12
retn | long long func0(int a1)
{
int v1; // ebx
int v2; // ebp
unsigned int v3; // r12d
double v4; // xmm1_8
int v5; // edx
if ( !a1 )
return 0LL;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
v4 = (double)v2++;
v5 = v1 % 10 * (int)pow(2.0, v4);
v1 /= 10;
v3 += v5;
}
while ( v1 );
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST EDI,EDI
JZ 0x00101280
MOV EBX,EDI
XOR EBP,EBP
XOR R12D,R12D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101228:
PXOR XMM1,XMM1
MOV RAX,qword ptr [0x00102060]
CVTSI2SD XMM1,EBP
ADD EBP,0x1
MOVQ XMM0,RAX
CALL 0x00101060
MOVSXD RAX,EBX
MOV ECX,EBX
IMUL RAX,RAX,0x66666667
SAR ECX,0x1f
CVTTSD2SI EDX,XMM0
SAR RAX,0x22
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EBX,ECX
IMUL EDX,EBX
MOV EBX,EAX
ADD R12D,EDX
TEST EAX,EAX
JNZ 0x00101228
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101280:
XOR R12D,R12D
POP RBX
POP RBP
MOV EAX,R12D
POP R12
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
if (param_1 != 0) {
iVar2 = 0;
iVar3 = 0;
do {
dVar4 = (double)iVar2;
iVar2 = iVar2 + 1;
dVar4 = pow(DAT_00102060,dVar4);
iVar1 = param_1 / 10;
iVar3 = iVar3 + (int)dVar4 * (param_1 % 10);
param_1 = iVar1;
} while (iVar1 != 0);
return iVar3;
}
return 0;
} |
3,991 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int binary) {
int binary1 = binary;
int decimal = 0;
int i = 0;
while(binary != 0) {
int dec = binary % 10;
decimal += dec * (int)pow(2, i);
binary /= 10;
i++;
}
return decimal;
}
| int main() {
assert(func0(100) == 4);
assert(func0(1011) == 11);
assert(func0(1101101) == 109);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
test %edi,%edi
je 1280 <func0+0x70>
mov %edi,%ebx
xor %ebp,%ebp
xor %r12d,%r12d
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
mov 0xe4d(%rip),%rax
cvtsi2sd %ebp,%xmm1
add $0x1,%ebp
movq %rax,%xmm0
callq 1060 <pow@plt>
movslq %ebx,%rax
mov %ebx,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
cvttsd2si %xmm0,%edi
sar $0x22,%rax
sub %edx,%eax
lea (%rax,%rax,4),%edx
add %edx,%edx
sub %edx,%ebx
imul %edi,%ebx
add %ebx,%r12d
mov %eax,%ebx
test %eax,%eax
jne 1228 <func0+0x18>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
pop %rbx
pop %rbp
mov %r12d,%eax
pop %r12
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
test edi, edi
jz short loc_1278
mov ebx, edi
xor r12d, r12d
xor ebp, ebp
nop dword ptr [rax+rax+00h]
loc_1228:
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, r12d; y
add r12d, 1
call _pow
movsxd rax, ebx
mov ecx, ebx
imul rax, 66666667h
sar ecx, 1Fh
cvttsd2si edx, xmm0
sar rax, 22h
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
sub ebx, ecx
imul edx, ebx
mov ebx, eax
add ebp, edx
test eax, eax
jnz short loc_1228
mov eax, ebp
pop rbx
pop rbp
pop r12
retn
loc_1278:
xor ebp, ebp
pop rbx
mov eax, ebp
pop rbp
pop r12
retn | long long func0(int a1)
{
int v1; // ebx
int v2; // r12d
unsigned int v3; // ebp
double v4; // xmm1_8
int v5; // edx
if ( !a1 )
return 0LL;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
v4 = (double)v2++;
v5 = v1 % 10 * (int)pow(2.0, v4);
v1 /= 10;
v3 += v5;
}
while ( v1 );
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST EDI,EDI
JZ 0x00101278
MOV EBX,EDI
XOR R12D,R12D
XOR EBP,EBP
NOP dword ptr [RAX + RAX*0x1]
LAB_00101228:
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102060]
CVTSI2SD XMM1,R12D
ADD R12D,0x1
CALL 0x00101060
MOVSXD RAX,EBX
MOV ECX,EBX
IMUL RAX,RAX,0x66666667
SAR ECX,0x1f
CVTTSD2SI EDX,XMM0
SAR RAX,0x22
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EBX,ECX
IMUL EDX,EBX
MOV EBX,EAX
ADD EBP,EDX
TEST EAX,EAX
JNZ 0x00101228
MOV EAX,EBP
POP RBX
POP RBP
POP R12
RET
LAB_00101278:
XOR EBP,EBP
POP RBX
MOV EAX,EBP
POP RBP
POP R12
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
if (param_1 != 0) {
iVar3 = 0;
iVar2 = 0;
do {
dVar4 = (double)iVar3;
iVar3 = iVar3 + 1;
dVar4 = pow(DAT_00102060,dVar4);
iVar1 = param_1 / 10;
iVar2 = iVar2 + (int)dVar4 * (param_1 % 10);
param_1 = iVar1;
} while (iVar1 != 0);
return iVar2;
}
return 0;
} |
3,992 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int i, j, temp, prod = 1;
// Simple insertion sort
for (i = 1; i < n; i++) {
temp = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > temp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
for (i = 0; i < n; i++) {
if (i == 0 || arr[i - 1] != arr[i]) {
prod *= arr[i];
}
}
return prod;
}
| int main() {
int arr1[] = {1, 1, 2, 3};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 4, 5, 6};
int arr4[] = {1, 1, 4, 5, 6, 5, 7, 1, 1, 3, 4};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 5) == 6);
assert(func0(arr3, 5) == 120);
assert(func0(arr4, 11) == 2520);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x1,-0x10(%rbp)
jmpq 1226 <func0+0xbd>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x10(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmp 11e4 <func0+0x7b>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
subl $0x1,-0xc(%rbp)
cmpl $0x0,-0xc(%rbp)
js 1205 <func0+0x9c>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jl 11af <func0+0x46>
mov -0xc(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
movl $0x0,-0x10(%rbp)
jmp 1294 <func0+0x12b>
cmpl $0x0,-0x10(%rbp)
je 1271 <func0+0x108>
mov -0x10(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 1290 <func0+0x127>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x8(%rbp),%edx
imul %edx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 123b <func0+0xd2>
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], 1
mov [rbp+var_10], 1
jmp loc_1226
loc_118B:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_10]
sub eax, 1
mov [rbp+var_C], eax
jmp short loc_11E4
loc_11AF:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
add rdx, 1
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
sub [rbp+var_C], 1
loc_11E4:
cmp [rbp+var_C], 0
js short loc_1205
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jl short loc_11AF
loc_1205:
mov eax, [rbp+var_C]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
add [rbp+var_10], 1
loc_1226:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jl loc_118B
mov [rbp+var_10], 0
jmp short loc_1294
loc_123B:
cmp [rbp+var_10], 0
jz short loc_1271
mov eax, [rbp+var_10]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1290
loc_1271:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_8]
imul eax, edx
mov [rbp+var_8], eax
loc_1290:
add [rbp+var_10], 1
loc_1294:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jl short loc_123B
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+Ch] [rbp-10h]
int k; // [rsp+Ch] [rbp-10h]
int j; // [rsp+10h] [rbp-Ch]
unsigned int v6; // [rsp+14h] [rbp-8h]
int v7; // [rsp+18h] [rbp-4h]
v6 = 1;
for ( i = 1; i < a2; ++i )
{
v7 = *(_DWORD *)(4LL * i + a1);
for ( j = i - 1; j >= 0 && v7 < *(_DWORD *)(4LL * j + a1); --j )
*(_DWORD *)(4 * (j + 1LL) + a1) = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(a1 + 4 * (j + 1LL)) = v7;
}
for ( k = 0; k < a2; ++k )
{
if ( !k || *(_DWORD *)(4LL * k - 4 + a1) != *(_DWORD *)(4LL * k + a1) )
v6 *= *(_DWORD *)(4LL * k + a1);
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x10],0x1
JMP 0x00101226
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001011e4
LAB_001011af:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
ADD RDX,0x1
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
SUB dword ptr [RBP + -0xc],0x1
LAB_001011e4:
CMP dword ptr [RBP + -0xc],0x0
JS 0x00101205
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]
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011af
LAB_00101205:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x10],0x1
LAB_00101226:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101294
LAB_0010123b:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x00101271
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101290
LAB_00101271:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_00101290:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101294:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010123b
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_10 = 1;
for (local_18 = 1; local_18 < param_2; local_18 = local_18 + 1) {
iVar1 = *(int *)(param_1 + (long)local_18 * 4);
local_14 = local_18;
while ((local_14 = local_14 + -1, -1 < local_14 &&
(iVar1 < *(int *)(param_1 + (long)local_14 * 4)))) {
*(int4 *)(param_1 + ((long)local_14 + 1) * 4) =
*(int4 *)(param_1 + (long)local_14 * 4);
}
*(int *)(((long)local_14 + 1) * 4 + param_1) = iVar1;
}
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
if ((local_18 == 0) ||
(*(int *)(param_1 + (long)local_18 * 4 + -4) != *(int *)(param_1 + (long)local_18 * 4))) {
local_10 = *(int *)(param_1 + (long)local_18 * 4) * local_10;
}
}
return local_10;
} |
3,993 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int i, j, temp, prod = 1;
// Simple insertion sort
for (i = 1; i < n; i++) {
temp = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > temp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
for (i = 0; i < n; i++) {
if (i == 0 || arr[i - 1] != arr[i]) {
prod *= arr[i];
}
}
return prod;
}
| int main() {
int arr1[] = {1, 1, 2, 3};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 4, 5, 6};
int arr4[] = {1, 1, 4, 5, 6, 5, 7, 1, 1, 3, 4};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 5) == 6);
assert(func0(arr3, 5) == 120);
assert(func0(arr4, 11) == 2520);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11c0 <func0+0x57>
mov %rdi,%r10
lea -0x2(%rsi),%r11d
mov $0x0,%r9d
jmp 1199 <func0+0x30>
movslq %edx,%rdx
mov %r8d,0x4(%rdi,%rdx,4)
lea 0x1(%r9),%rax
add $0x4,%r10
cmp %r11,%r9
je 11ca <func0+0x61>
mov %rax,%r9
mov 0x4(%r10),%r8d
mov %r9d,%edx
mov %r10,%rax
test %r9d,%r9d
js 1181 <func0+0x18>
mov (%rax),%ecx
cmp %r8d,%ecx
jle 1181 <func0+0x18>
mov %ecx,0x4(%rax)
sub $0x1,%edx
sub $0x4,%rax
cmp $0xffffffff,%edx
jne 11a8 <func0+0x3f>
jmp 1181 <func0+0x18>
je 11ca <func0+0x61>
mov $0x1,%edx
mov %edx,%eax
retq
mov $0x0,%eax
mov $0x1,%edx
jmp 11e2 <func0+0x79>
imul (%rdi,%rax,4),%edx
add $0x1,%rax
cmp %eax,%esi
jle 11c7 <func0+0x5e>
test %eax,%eax
je 11d6 <func0+0x6d>
mov (%rdi,%rax,4),%ecx
cmp %ecx,-0x4(%rdi,%rax,4)
jne 11d6 <func0+0x6d>
jmp 11da <func0+0x71>
| func0:
endbr64
cmp esi, 1
jle short loc_11BD
mov r10, rdi
lea r11d, [rsi-1]
mov r9d, 0
jmp short loc_1196
loc_1181:
movsxd rdx, edx
mov [rdi+rdx*4+4], r8d
add r9, 1
add r10, 4
cmp r9, r11
jz short loc_11C7
loc_1196:
mov r8d, [r10+4]
mov edx, r9d
mov rax, r10
test r9d, r9d
js short loc_1181
loc_11A5:
mov ecx, [rax]
cmp ecx, r8d
jle short loc_1181
mov [rax+4], ecx
sub edx, 1
sub rax, 4
cmp edx, 0FFFFFFFFh
jnz short loc_11A5
jmp short loc_1181
loc_11BD:
jz short loc_11C7
mov edx, 1
loc_11C4:
mov eax, edx
retn
loc_11C7:
mov eax, 0
mov edx, 1
jmp short loc_11DF
loc_11D3:
imul edx, [rdi+rax*4]
loc_11D7:
add rax, 1
cmp esi, eax
jle short loc_11C4
loc_11DF:
test eax, eax
jz short loc_11D3
mov ecx, [rdi+rax*4]
cmp [rdi+rax*4-4], ecx
jnz short loc_11D3
jmp short loc_11D7 | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r10
long long v3; // r9
int v4; // r8d
int v5; // edx
_DWORD *v6; // rax
unsigned int v7; // edx
long long v9; // rax
if ( a2 <= 1 )
{
if ( a2 != 1 )
return 1;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = v2[1];
v5 = v3;
v6 = v2;
if ( (int)v3 >= 0 )
{
do
{
if ( *v6 <= v4 )
break;
v6[1] = *v6;
--v5;
--v6;
}
while ( v5 != -1 );
}
a1[v5 + 1] = v4;
++v3;
++v2;
}
while ( v3 != a2 - 1 );
}
v9 = 0LL;
v7 = 1;
do
{
if ( !(_DWORD)v9 || a1[v9 - 1] != a1[v9] )
v7 *= a1[v9];
++v9;
}
while ( a2 > (int)v9 );
return v7;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011bd
MOV R10,RDI
LEA R11D,[RSI + -0x1]
MOV R9D,0x0
JMP 0x00101196
LAB_00101181:
MOVSXD RDX,EDX
MOV dword ptr [RDI + RDX*0x4 + 0x4],R8D
ADD R9,0x1
ADD R10,0x4
CMP R9,R11
JZ 0x001011c7
LAB_00101196:
MOV R8D,dword ptr [R10 + 0x4]
MOV EDX,R9D
MOV RAX,R10
TEST R9D,R9D
JS 0x00101181
LAB_001011a5:
MOV ECX,dword ptr [RAX]
CMP ECX,R8D
JLE 0x00101181
MOV dword ptr [RAX + 0x4],ECX
SUB EDX,0x1
SUB RAX,0x4
CMP EDX,-0x1
JNZ 0x001011a5
JMP 0x00101181
LAB_001011bd:
JZ 0x001011c7
MOV EDX,0x1
LAB_001011c4:
MOV EAX,EDX
RET
LAB_001011c7:
MOV EAX,0x0
MOV EDX,0x1
JMP 0x001011df
LAB_001011d3:
IMUL EDX,dword ptr [RDI + RAX*0x4]
LAB_001011d7:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x001011c4
LAB_001011df:
TEST EAX,EAX
JZ 0x001011d3
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4 + -0x4],ECX
JNZ 0x001011d3
JMP 0x001011d7 | int func0(int *param_1,int param_2)
{
int *piVar1;
long lVar2;
int iVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int *piVar7;
if (param_2 < 2) {
if (param_2 != 1) {
return 1;
}
}
else {
uVar6 = 0;
piVar7 = param_1;
do {
iVar3 = piVar7[1];
iVar5 = (int)uVar6;
uVar4 = uVar6 & 0xffffffff;
piVar1 = piVar7;
if (-1 < iVar5) {
do {
iVar5 = (int)uVar4;
if (*piVar1 <= iVar3) goto LAB_00101181;
piVar1[1] = *piVar1;
uVar4 = (ulong)(iVar5 - 1U);
piVar1 = piVar1 + -1;
} while (iVar5 - 1U != 0xffffffff);
iVar5 = -1;
}
LAB_00101181:
param_1[(long)iVar5 + 1] = iVar3;
uVar6 = uVar6 + 1;
piVar7 = piVar7 + 1;
} while (uVar6 != param_2 - 1);
}
lVar2 = 0;
iVar3 = 1;
do {
if (((int)lVar2 == 0) || (param_1[lVar2 + -1] != param_1[lVar2])) {
iVar3 = iVar3 * param_1[lVar2];
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_2);
return iVar3;
} |
3,994 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int i, j, temp, prod = 1;
// Simple insertion sort
for (i = 1; i < n; i++) {
temp = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > temp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
for (i = 0; i < n; i++) {
if (i == 0 || arr[i - 1] != arr[i]) {
prod *= arr[i];
}
}
return prod;
}
| int main() {
int arr1[] = {1, 1, 2, 3};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 4, 5, 6};
int arr4[] = {1, 1, 4, 5, 6, 5, 7, 1, 1, 3, 4};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 5) == 6);
assert(func0(arr3, 5) == 120);
assert(func0(arr4, 11) == 2520);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
cmp $0x1,%esi
jle 13c0 <func0+0xa0>
lea 0x4(%rdi),%r10
lea -0x2(%rsi),%ebx
xor %r11d,%r11d
nopl 0x0(%rax,%rax,1)
lea 0x0(,%r11,4),%rax
lea -0x4(%r10),%r8
mov (%r10),%r9d
sub %rax,%r8
mov %r10,%rax
nopl (%rax)
mov -0x4(%rax),%edx
mov %rax,%rcx
cmp %r9d,%edx
jle 1371 <func0+0x51>
mov %edx,(%rax)
lea -0x4(%rcx),%rax
cmp %rax,%r8
jne 1358 <func0+0x38>
mov %rdi,%rcx
mov %r9d,(%rcx)
lea 0x1(%r11),%rax
add $0x4,%r10
cmp %rbx,%r11
je 1390 <func0+0x70>
mov %rax,%r11
jmp 1340 <func0+0x20>
nopw %cs:0x0(%rax,%rax,1)
xor %eax,%eax
mov $0x1,%r8d
nopl 0x0(%rax,%rax,1)
test %rax,%rax
je 13ae <func0+0x8e>
mov (%rdi,%rax,4),%ebx
cmp %ebx,-0x4(%rdi,%rax,4)
je 13b3 <func0+0x93>
imul (%rdi,%rax,4),%r8d
add $0x1,%rax
cmp %eax,%esi
jg 13a0 <func0+0x80>
mov %r8d,%eax
pop %rbx
retq
je 1390 <func0+0x70>
mov $0x1,%r8d
pop %rbx
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
cmp esi, 1
jle short loc_139C
lea r10d, [rsi-1]
xor r9d, r9d
loc_1330:
mov r8d, [rdi+r9*4+4]
mov rax, r9
nop dword ptr [rax+rax+00000000h]
loc_1340:
mov edx, [rdi+rax*4]
mov ecx, eax
cmp edx, r8d
jle short loc_1390
mov [rdi+rax*4+4], edx
sub rax, 1
cmp eax, 0FFFFFFFFh
jnz short loc_1340
mov rax, rdi
loc_135A:
add r9, 1
mov [rax], r8d
cmp r10, r9
jnz short loc_1330
loc_1366:
xor eax, eax
mov r8d, 1
xchg ax, ax
loc_1370:
test rax, rax
jz short loc_137E
mov ecx, [rdi+rax*4]
cmp [rdi+rax*4-4], ecx
jz short loc_1383
loc_137E:
imul r8d, [rdi+rax*4]
loc_1383:
add rax, 1
cmp esi, eax
jg short loc_1370
mov eax, r8d
retn
loc_1390:
add ecx, 1
movsxd rcx, ecx
lea rax, [rdi+rcx*4]
jmp short loc_135A
loc_139C:
jz short loc_1366
mov r8d, 1
mov eax, r8d
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // r9
int v3; // r8d
long long v4; // rax
int v5; // edx
_DWORD *v6; // rax
long long v7; // rax
unsigned int v8; // r8d
if ( a2 <= 1 )
{
if ( a2 != 1 )
return 1LL;
}
else
{
v2 = 0LL;
do
{
v3 = a1[v2 + 1];
v4 = v2;
while ( 1 )
{
v5 = a1[v4];
if ( v5 <= v3 )
break;
a1[v4-- + 1] = v5;
if ( (_DWORD)v4 == -1 )
{
v6 = a1;
goto LABEL_7;
}
}
v6 = &a1[(int)v4 + 1];
LABEL_7:
++v2;
*v6 = v3;
}
while ( a2 - 1 != v2 );
}
v7 = 0LL;
v8 = 1;
do
{
if ( !v7 || a1[v7 - 1] != a1[v7] )
v8 *= a1[v7];
++v7;
}
while ( a2 > (int)v7 );
return v8;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010139c
LEA R10D,[RSI + -0x1]
XOR R9D,R9D
LAB_00101330:
MOV R8D,dword ptr [RDI + R9*0x4 + 0x4]
MOV RAX,R9
NOP dword ptr [RAX + RAX*0x1]
LAB_00101340:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV ECX,EAX
CMP EDX,R8D
JLE 0x00101390
MOV dword ptr [RDI + RAX*0x4 + 0x4],EDX
SUB RAX,0x1
CMP EAX,-0x1
JNZ 0x00101340
MOV RAX,RDI
LAB_0010135a:
ADD R9,0x1
MOV dword ptr [RAX],R8D
CMP R10,R9
JNZ 0x00101330
LAB_00101366:
XOR EAX,EAX
MOV R8D,0x1
NOP
LAB_00101370:
TEST RAX,RAX
JZ 0x0010137e
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4 + -0x4],ECX
JZ 0x00101383
LAB_0010137e:
IMUL R8D,dword ptr [RDI + RAX*0x4]
LAB_00101383:
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101370
MOV EAX,R8D
RET
LAB_00101390:
ADD ECX,0x1
MOVSXD RCX,ECX
LEA RAX,[RDI + RCX*0x4]
JMP 0x0010135a
LAB_0010139c:
JZ 0x00101366
MOV R8D,0x1
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
ulong uVar1;
int *piVar2;
long lVar3;
int iVar4;
ulong uVar5;
if (param_2 < 2) {
if (param_2 != 1) {
return 1;
}
}
else {
uVar5 = 0;
do {
iVar4 = param_1[uVar5 + 1];
uVar1 = uVar5;
do {
if (param_1[uVar1] <= iVar4) {
piVar2 = param_1 + ((int)uVar1 + 1);
break;
}
param_1[uVar1 + 1] = param_1[uVar1];
uVar1 = uVar1 - 1;
piVar2 = param_1;
} while ((int)uVar1 != -1);
uVar5 = uVar5 + 1;
*piVar2 = iVar4;
} while (param_2 - 1 != uVar5);
}
lVar3 = 0;
iVar4 = 1;
do {
if ((lVar3 == 0) || (param_1[lVar3 + -1] != param_1[lVar3])) {
iVar4 = iVar4 * param_1[lVar3];
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < param_2);
return iVar4;
} |
3,995 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int i, j, temp, prod = 1;
// Simple insertion sort
for (i = 1; i < n; i++) {
temp = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > temp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
for (i = 0; i < n; i++) {
if (i == 0 || arr[i - 1] != arr[i]) {
prod *= arr[i];
}
}
return prod;
}
| int main() {
int arr1[] = {1, 1, 2, 3};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 4, 5, 6};
int arr4[] = {1, 1, 4, 5, 6, 5, 7, 1, 1, 3, 4};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 5) == 6);
assert(func0(arr3, 5) == 120);
assert(func0(arr4, 11) == 2520);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
cmp $0x1,%esi
jle 1380 <func0+0xa0>
lea 0x4(%rdi),%r10
lea -0x2(%rsi),%ebx
xor %r11d,%r11d
nopl 0x0(%rax,%rax,1)
lea 0x0(,%r11,4),%rax
lea -0x4(%r10),%r8
mov (%r10),%r9d
sub %rax,%r8
mov %r10,%rax
nopl (%rax)
mov -0x4(%rax),%edx
mov %rax,%rcx
cmp %r9d,%edx
jle 1331 <func0+0x51>
mov %edx,(%rax)
lea -0x4(%rcx),%rax
cmp %r8,%rax
jne 1318 <func0+0x38>
mov %rdi,%rcx
mov %r9d,(%rcx)
lea 0x1(%r11),%rax
add $0x4,%r10
cmp %rbx,%r11
je 1350 <func0+0x70>
mov %rax,%r11
jmp 1300 <func0+0x20>
nopw %cs:0x0(%rax,%rax,1)
xor %eax,%eax
mov $0x1,%r8d
nopl 0x0(%rax,%rax,1)
test %rax,%rax
je 136e <func0+0x8e>
mov (%rdi,%rax,4),%ebx
cmp %ebx,-0x4(%rdi,%rax,4)
je 1373 <func0+0x93>
imul (%rdi,%rax,4),%r8d
add $0x1,%rax
cmp %eax,%esi
jg 1360 <func0+0x80>
mov %r8d,%eax
pop %rbx
retq
je 1350 <func0+0x70>
mov $0x1,%r8d
pop %rbx
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
lea r9d, [rsi-1]
xor r8d, r8d
cmp esi, 1
jle short loc_1365
loc_12F0:
mov ecx, [rdi+r8*4+4]
mov rax, r8
jmp short loc_130D
loc_1300:
mov [rdi+rax*4+4], edx
sub rax, 1
cmp eax, 0FFFFFFFFh
jz short loc_1360
loc_130D:
mov edx, [rdi+rax*4]
cmp edx, ecx
jg short loc_1300
add eax, 1
cdqe
lea rax, [rdi+rax*4]
loc_131D:
add r8, 1
mov [rax], ecx
cmp r9, r8
jnz short loc_12F0
loc_1328:
movsxd rdx, esi
xor eax, eax
mov ecx, 1
nop word ptr [rax+rax+00h]
loc_1338:
test rax, rax
jz short loc_1346
mov esi, [rdi+rax*4]
cmp [rdi+rax*4-4], esi
jz short loc_134A
loc_1346:
imul ecx, [rdi+rax*4]
loc_134A:
add rax, 1
cmp rax, rdx
jnz short loc_1338
mov eax, ecx
retn
loc_1360:
mov rax, rdi
jmp short loc_131D
loc_1365:
jz short loc_1328
mov ecx, 1
mov eax, ecx
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // r8
int v3; // ecx
long long v4; // rax
int v5; // edx
_DWORD *v6; // rax
long long v7; // rax
unsigned int v8; // ecx
v2 = 0LL;
if ( a2 <= 1 )
{
if ( a2 != 1 )
return 1LL;
}
else
{
do
{
v3 = a1[v2 + 1];
v4 = v2;
do
{
v5 = a1[v4];
if ( v5 <= v3 )
{
v6 = &a1[(int)v4 + 1];
goto LABEL_6;
}
a1[v4-- + 1] = v5;
}
while ( (_DWORD)v4 != -1 );
v6 = a1;
LABEL_6:
++v2;
*v6 = v3;
}
while ( a2 - 1 != v2 );
}
v7 = 0LL;
v8 = 1;
do
{
if ( !v7 || a1[v7 - 1] != a1[v7] )
v8 *= a1[v7];
++v7;
}
while ( v7 != a2 );
return v8;
} | func0:
ENDBR64
LEA R9D,[RSI + -0x1]
XOR R8D,R8D
CMP ESI,0x1
JLE 0x00101365
LAB_001012f0:
MOV ECX,dword ptr [RDI + R8*0x4 + 0x4]
MOV RAX,R8
JMP 0x0010130d
LAB_00101300:
MOV dword ptr [RDI + RAX*0x4 + 0x4],EDX
SUB RAX,0x1
CMP EAX,-0x1
JZ 0x00101360
LAB_0010130d:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,ECX
JG 0x00101300
ADD EAX,0x1
CDQE
LEA RAX,[RDI + RAX*0x4]
LAB_0010131d:
ADD R8,0x1
MOV dword ptr [RAX],ECX
CMP R9,R8
JNZ 0x001012f0
LAB_00101328:
MOVSXD RDX,ESI
XOR EAX,EAX
MOV ECX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101338:
TEST RAX,RAX
JZ 0x00101346
MOV ESI,dword ptr [RDI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4 + -0x4],ESI
JZ 0x0010134a
LAB_00101346:
IMUL ECX,dword ptr [RDI + RAX*0x4]
LAB_0010134a:
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101338
MOV EAX,ECX
RET
LAB_00101360:
MOV RAX,RDI
JMP 0x0010131d
LAB_00101365:
JZ 0x00101328
MOV ECX,0x1
MOV EAX,ECX
RET | int func0(int *param_1,int param_2)
{
ulong uVar1;
int *piVar2;
long lVar3;
int iVar4;
ulong uVar5;
uVar5 = 0;
if (param_2 < 2) {
if (param_2 != 1) {
return 1;
}
}
else {
do {
iVar4 = param_1[uVar5 + 1];
uVar1 = uVar5;
do {
if (param_1[uVar1] <= iVar4) {
piVar2 = param_1 + ((int)uVar1 + 1);
break;
}
param_1[uVar1 + 1] = param_1[uVar1];
uVar1 = uVar1 - 1;
piVar2 = param_1;
} while ((int)uVar1 != -1);
uVar5 = uVar5 + 1;
*piVar2 = iVar4;
} while (param_2 - 1 != uVar5);
}
lVar3 = 0;
iVar4 = 1;
do {
if ((lVar3 == 0) || (param_1[lVar3 + -1] != param_1[lVar3])) {
iVar4 = iVar4 * param_1[lVar3];
}
lVar3 = lVar3 + 1;
} while (lVar3 != param_2);
return iVar4;
} |
3,996 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int** test_list, size_t* lengths, size_t num_tuples, int K) {
int res = 1;
for (size_t i = 0; i < num_tuples && res; i++) {
for (size_t j = 0; j < lengths[i] && res; j++) {
if (test_list[i][j] != K) {
res = 0;
}
}
}
return res;
}
| int main() {
// First test case
int tuple1_1[] = {4, 4};
int tuple1_2[] = {4, 4, 4};
int tuple1_3[] = {4, 4};
int tuple1_4[] = {4, 4, 4, 4};
int tuple1_5[] = {4};
int* test_list1[] = {tuple1_1, tuple1_2, tuple1_3, tuple1_4, tuple1_5};
size_t lengths1[] = {2, 3, 2, 4, 1};
assert(func0(test_list1, lengths1, 5, 4) == 1);
// Second test case
int tuple2_1[] = {7, 7, 7};
int tuple2_2[] = {7, 7};
int* test_list2[] = {tuple2_1, tuple2_2};
size_t lengths2[] = {3, 2};
assert(func0(test_list2, lengths2, 2, 7) == 1);
// Third test case
int tuple3_1[] = {9, 9};
int tuple3_2[] = {9, 9, 9, 9};
int* test_list3[] = {tuple3_1, tuple3_2};
size_t lengths3[] = {2, 4};
assert(func0(test_list3, lengths3, 2, 7) == 0);
// Fourth test case
int tuple4_1[] = {4, 4};
int tuple4_2[] = {4, 4, 4};
int tuple4_3[] = {4, 4};
int tuple4_4[] = {4, 4, 6, 4};
int tuple4_5[] = {4};
int* test_list4[] = {tuple4_1, tuple4_2, tuple4_3, tuple4_4, tuple4_5};
size_t lengths4[] = {2, 3, 2, 4, 1};
assert(func0(test_list4, lengths4, 5, 4) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
mov %ecx,-0x3c(%rbp)
movl $0x1,-0x14(%rbp)
movq $0x0,-0x10(%rbp)
jmp 11f6 <func0+0x8d>
movq $0x0,-0x8(%rbp)
jmp 11cf <func0+0x66>
mov -0x10(%rbp),%rax
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x8(%rbp),%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x3c(%rbp)
je 11ca <func0+0x61>
movl $0x0,-0x14(%rbp)
addq $0x1,-0x8(%rbp)
mov -0x10(%rbp),%rax
lea 0x0(,%rax,8),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
cmp %rax,-0x8(%rbp)
jae 11f1 <func0+0x88>
cmpl $0x0,-0x14(%rbp)
jne 119b <func0+0x32>
addq $0x1,-0x10(%rbp)
mov -0x10(%rbp),%rax
cmp -0x38(%rbp),%rax
jae 1206 <func0+0x9d>
cmpl $0x0,-0x14(%rbp)
jne 1191 <func0+0x28>
mov -0x14(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_3C], ecx
mov [rbp+var_14], 1
mov [rbp+var_10], 0
jmp short loc_11F6
loc_1191:
mov [rbp+var_8], 0
jmp short loc_11CF
loc_119B:
mov rax, [rbp+var_10]
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+var_8]
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_3C], eax
jz short loc_11CA
mov [rbp+var_14], 0
loc_11CA:
add [rbp+var_8], 1
loc_11CF:
mov rax, [rbp+var_10]
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_30]
add rax, rdx
mov rax, [rax]
cmp [rbp+var_8], rax
jnb short loc_11F1
cmp [rbp+var_14], 0
jnz short loc_119B
loc_11F1:
add [rbp+var_10], 1
loc_11F6:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_1206
cmp [rbp+var_14], 0
jnz short loc_1191
loc_1206:
mov eax, [rbp+var_14]
pop rbp
retn | long long func0(long long a1, long long a2, unsigned long long a3, int a4)
{
unsigned int v5; // [rsp+28h] [rbp-14h]
unsigned long long i; // [rsp+2Ch] [rbp-10h]
unsigned long long j; // [rsp+34h] [rbp-8h]
v5 = 1;
for ( i = 0LL; i < a3 && v5; ++i )
{
for ( j = 0LL; j < *(_QWORD *)(8 * i + a2) && v5; ++j )
{
if ( a4 != *(_DWORD *)(4 * j + *(_QWORD *)(8 * i + a1)) )
v5 = 0;
}
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x3c],ECX
MOV dword ptr [RBP + -0x14],0x1
MOV qword ptr [RBP + -0x10],0x0
JMP 0x001011f6
LAB_00101191:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001011cf
LAB_0010119b:
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x8]
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x3c],EAX
JZ 0x001011ca
MOV dword ptr [RBP + -0x14],0x0
LAB_001011ca:
ADD qword ptr [RBP + -0x8],0x1
LAB_001011cf:
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
CMP qword ptr [RBP + -0x8],RAX
JNC 0x001011f1
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010119b
LAB_001011f1:
ADD qword ptr [RBP + -0x10],0x1
LAB_001011f6:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00101206
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101191
LAB_00101206:
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET | int func0(long param_1,long param_2,ulong param_3,int param_4)
{
int4 local_1c;
int8 local_18;
int8 local_10;
local_1c = 1;
local_18 = 0;
while ((local_18 < param_3 && (local_1c != 0))) {
local_10 = 0;
while ((local_10 < *(ulong *)(param_2 + local_18 * 8) && (local_1c != 0))) {
if (param_4 != *(int *)(*(long *)(param_1 + local_18 * 8) + local_10 * 4)) {
local_1c = 0;
}
local_10 = local_10 + 1;
}
local_18 = local_18 + 1;
}
return local_1c;
} |
3,997 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int** test_list, size_t* lengths, size_t num_tuples, int K) {
int res = 1;
for (size_t i = 0; i < num_tuples && res; i++) {
for (size_t j = 0; j < lengths[i] && res; j++) {
if (test_list[i][j] != K) {
res = 0;
}
}
}
return res;
}
| int main() {
// First test case
int tuple1_1[] = {4, 4};
int tuple1_2[] = {4, 4, 4};
int tuple1_3[] = {4, 4};
int tuple1_4[] = {4, 4, 4, 4};
int tuple1_5[] = {4};
int* test_list1[] = {tuple1_1, tuple1_2, tuple1_3, tuple1_4, tuple1_5};
size_t lengths1[] = {2, 3, 2, 4, 1};
assert(func0(test_list1, lengths1, 5, 4) == 1);
// Second test case
int tuple2_1[] = {7, 7, 7};
int tuple2_2[] = {7, 7};
int* test_list2[] = {tuple2_1, tuple2_2};
size_t lengths2[] = {3, 2};
assert(func0(test_list2, lengths2, 2, 7) == 1);
// Third test case
int tuple3_1[] = {9, 9};
int tuple3_2[] = {9, 9, 9, 9};
int* test_list3[] = {tuple3_1, tuple3_2};
size_t lengths3[] = {2, 4};
assert(func0(test_list3, lengths3, 2, 7) == 0);
// Fourth test case
int tuple4_1[] = {4, 4};
int tuple4_2[] = {4, 4, 4};
int tuple4_3[] = {4, 4};
int tuple4_4[] = {4, 4, 6, 4};
int tuple4_5[] = {4};
int* test_list4[] = {tuple4_1, tuple4_2, tuple4_3, tuple4_4, tuple4_5};
size_t lengths4[] = {2, 3, 2, 4, 1};
assert(func0(test_list4, lengths4, 5, 4) == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%r10d
test %rdx,%rdx
jne 119c <func0+0x33>
mov $0x1,%eax
retq
add $0x1,%rax
cmp %r8,%rax
jae 1193 <func0+0x2a>
cmp %ecx,(%r9,%rax,4)
je 117e <func0+0x15>
mov $0x0,%eax
retq
add $0x1,%r10
cmp %r10,%rdx
jbe 11b0 <func0+0x47>
mov (%rsi,%r10,8),%r8
test %r8,%r8
je 1193 <func0+0x2a>
mov (%rdi,%r10,8),%r9
mov $0x0,%eax
jmp 1187 <func0+0x1e>
mov $0x1,%eax
retq
| func0:
endbr64
mov r10d, 0
test rdx, rdx
jnz short loc_119C
mov eax, 1
retn
loc_117E:
add rax, 1
cmp rax, r8
jnb short loc_1193
loc_1187:
cmp [r9+rax*4], ecx
jz short loc_117E
mov eax, 0
retn
loc_1193:
add r10, 1
cmp rdx, r10
jbe short loc_11B0
loc_119C:
mov r8, [rsi+r10*8]
test r8, r8
jz short loc_1193
mov r9, [rdi+r10*8]
mov eax, 0
jmp short loc_1187
loc_11B0:
mov eax, 1
retn | long long func0(long long a1, long long a2, unsigned long long a3, int a4)
{
long long v4; // r10
long long v6; // rax
unsigned long long v7; // r8
v4 = 0LL;
if ( !a3 )
return 1LL;
while ( 1 )
{
v7 = *(_QWORD *)(a2 + 8 * v4);
if ( v7 )
break;
LABEL_6:
if ( a3 <= ++v4 )
return 1LL;
}
v6 = 0LL;
while ( *(_DWORD *)(*(_QWORD *)(a1 + 8 * v4) + 4 * v6) == a4 )
{
if ( ++v6 >= v7 )
goto LABEL_6;
}
return 0LL;
} | func0:
ENDBR64
MOV R10D,0x0
TEST RDX,RDX
JNZ 0x0010119c
MOV EAX,0x1
RET
LAB_0010117e:
ADD RAX,0x1
CMP RAX,R8
JNC 0x00101193
LAB_00101187:
CMP dword ptr [R9 + RAX*0x4],ECX
JZ 0x0010117e
MOV EAX,0x0
RET
LAB_00101193:
ADD R10,0x1
CMP RDX,R10
JBE 0x001011b0
LAB_0010119c:
MOV R8,qword ptr [RSI + R10*0x8]
TEST R8,R8
JZ 0x00101193
MOV R9,qword ptr [RDI + R10*0x8]
MOV EAX,0x0
JMP 0x00101187
LAB_001011b0:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,ulong param_3,int param_4)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
uVar3 = 0;
if (param_3 == 0) {
return 1;
}
do {
uVar1 = *(ulong *)(param_2 + uVar3 * 8);
if (uVar1 != 0) {
uVar2 = 0;
do {
if (*(int *)(*(long *)(param_1 + uVar3 * 8) + uVar2 * 4) != param_4) {
return 0;
}
uVar2 = uVar2 + 1;
} while (uVar2 < uVar1);
}
uVar3 = uVar3 + 1;
} while (uVar3 < param_3);
return 1;
} |
3,998 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int** test_list, size_t* lengths, size_t num_tuples, int K) {
int res = 1;
for (size_t i = 0; i < num_tuples && res; i++) {
for (size_t j = 0; j < lengths[i] && res; j++) {
if (test_list[i][j] != K) {
res = 0;
}
}
}
return res;
}
| int main() {
// First test case
int tuple1_1[] = {4, 4};
int tuple1_2[] = {4, 4, 4};
int tuple1_3[] = {4, 4};
int tuple1_4[] = {4, 4, 4, 4};
int tuple1_5[] = {4};
int* test_list1[] = {tuple1_1, tuple1_2, tuple1_3, tuple1_4, tuple1_5};
size_t lengths1[] = {2, 3, 2, 4, 1};
assert(func0(test_list1, lengths1, 5, 4) == 1);
// Second test case
int tuple2_1[] = {7, 7, 7};
int tuple2_2[] = {7, 7};
int* test_list2[] = {tuple2_1, tuple2_2};
size_t lengths2[] = {3, 2};
assert(func0(test_list2, lengths2, 2, 7) == 1);
// Third test case
int tuple3_1[] = {9, 9};
int tuple3_2[] = {9, 9, 9, 9};
int* test_list3[] = {tuple3_1, tuple3_2};
size_t lengths3[] = {2, 4};
assert(func0(test_list3, lengths3, 2, 7) == 0);
// Fourth test case
int tuple4_1[] = {4, 4};
int tuple4_2[] = {4, 4, 4};
int tuple4_3[] = {4, 4};
int tuple4_4[] = {4, 4, 6, 4};
int tuple4_5[] = {4};
int* test_list4[] = {tuple4_1, tuple4_2, tuple4_3, tuple4_4, tuple4_5};
size_t lengths4[] = {2, 3, 2, 4, 1};
assert(func0(test_list4, lengths4, 5, 4) == 0);
return 0;
}
| O2 | c | func0:
endbr64
xor %r10d,%r10d
test %rdx,%rdx
je 1512 <func0+0x42>
nopl 0x0(%rax)
mov (%rsi,%r10,8),%r9
test %r9,%r9
je 1509 <func0+0x39>
mov (%rdi,%r10,8),%r8
xor %eax,%eax
cmp %ecx,(%r8,%rax,4)
je 1500 <func0+0x30>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %r9,%rax
jne 14ef <func0+0x1f>
add $0x1,%r10
cmp %r10,%rdx
jne 14e0 <func0+0x10>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor r10d, r10d
test rdx, rdx
jz short loc_1512
nop dword ptr [rax+00h]
loc_14E0:
mov r9, [rsi+r10*8]
test r9, r9
jz short loc_1509
mov r8, [rdi+r10*8]
xor eax, eax
loc_14EF:
cmp [r8+rax*4], ecx
jz short loc_1500
xor eax, eax
retn
loc_1500:
add rax, 1
cmp rax, r9
jnz short loc_14EF
loc_1509:
add r10, 1
cmp rdx, r10
jnz short loc_14E0
loc_1512:
mov eax, 1
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // r10
long long v5; // r9
long long v6; // rax
v4 = 0LL;
if ( !a3 )
return 1LL;
while ( 1 )
{
v5 = *(_QWORD *)(a2 + 8 * v4);
if ( v5 )
break;
LABEL_7:
if ( a3 == ++v4 )
return 1LL;
}
v6 = 0LL;
while ( *(_DWORD *)(*(_QWORD *)(a1 + 8 * v4) + 4 * v6) == a4 )
{
if ( ++v6 == v5 )
goto LABEL_7;
}
return 0LL;
} | func0:
ENDBR64
XOR R10D,R10D
TEST RDX,RDX
JZ 0x00101512
NOP dword ptr [RAX]
LAB_001014e0:
MOV R9,qword ptr [RSI + R10*0x8]
TEST R9,R9
JZ 0x00101509
MOV R8,qword ptr [RDI + R10*0x8]
XOR EAX,EAX
LAB_001014ef:
CMP dword ptr [R8 + RAX*0x4],ECX
JZ 0x00101500
XOR EAX,EAX
RET
LAB_00101500:
ADD RAX,0x1
CMP RAX,R9
JNZ 0x001014ef
LAB_00101509:
ADD R10,0x1
CMP RDX,R10
JNZ 0x001014e0
LAB_00101512:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
long lVar2;
long lVar3;
lVar3 = 0;
if (param_3 != 0) {
do {
lVar1 = *(long *)(param_2 + lVar3 * 8);
if (lVar1 != 0) {
lVar2 = 0;
do {
if (*(int *)(*(long *)(param_1 + lVar3 * 8) + lVar2 * 4) != param_4) {
return 0;
}
lVar2 = lVar2 + 1;
} while (lVar2 != lVar1);
}
lVar3 = lVar3 + 1;
} while (param_3 != lVar3);
}
return 1;
} |
3,999 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int** test_list, size_t* lengths, size_t num_tuples, int K) {
int res = 1;
for (size_t i = 0; i < num_tuples && res; i++) {
for (size_t j = 0; j < lengths[i] && res; j++) {
if (test_list[i][j] != K) {
res = 0;
}
}
}
return res;
}
| int main() {
// First test case
int tuple1_1[] = {4, 4};
int tuple1_2[] = {4, 4, 4};
int tuple1_3[] = {4, 4};
int tuple1_4[] = {4, 4, 4, 4};
int tuple1_5[] = {4};
int* test_list1[] = {tuple1_1, tuple1_2, tuple1_3, tuple1_4, tuple1_5};
size_t lengths1[] = {2, 3, 2, 4, 1};
assert(func0(test_list1, lengths1, 5, 4) == 1);
// Second test case
int tuple2_1[] = {7, 7, 7};
int tuple2_2[] = {7, 7};
int* test_list2[] = {tuple2_1, tuple2_2};
size_t lengths2[] = {3, 2};
assert(func0(test_list2, lengths2, 2, 7) == 1);
// Third test case
int tuple3_1[] = {9, 9};
int tuple3_2[] = {9, 9, 9, 9};
int* test_list3[] = {tuple3_1, tuple3_2};
size_t lengths3[] = {2, 4};
assert(func0(test_list3, lengths3, 2, 7) == 0);
// Fourth test case
int tuple4_1[] = {4, 4};
int tuple4_2[] = {4, 4, 4};
int tuple4_3[] = {4, 4};
int tuple4_4[] = {4, 4, 6, 4};
int tuple4_5[] = {4};
int* test_list4[] = {tuple4_1, tuple4_2, tuple4_3, tuple4_4, tuple4_5};
size_t lengths4[] = {2, 3, 2, 4, 1};
assert(func0(test_list4, lengths4, 5, 4) == 0);
return 0;
}
| O3 | c | func0:
endbr64
xor %r10d,%r10d
test %rdx,%rdx
je 14e2 <func0+0x42>
nopl 0x0(%rax)
mov (%rsi,%r10,8),%r9
test %r9,%r9
je 14d9 <func0+0x39>
mov (%rdi,%r10,8),%r8
xor %eax,%eax
cmp %ecx,(%r8,%rax,4)
je 14d0 <func0+0x30>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %r9,%rax
jne 14bf <func0+0x1f>
add $0x1,%r10
cmp %r10,%rdx
jne 14b0 <func0+0x10>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r11, rdi
xor r10d, r10d
mov edi, 1
test rdx, rdx
jz short loc_153A
nop dword ptr [rax+00h]
loc_14E8:
mov r8, [rsi+r10*8]
mov eax, 1
mov edi, 1
test r8, r8
jz short loc_1526
mov r9, [r11+r10*8]
xor eax, eax
jmp short loc_150C
loc_1508:
cmp edi, ecx
jnz short loc_1538
loc_150C:
mov edi, [r9+rax*4]
add rax, 1
cmp rax, r8
jnz short loc_1508
cmp edi, ecx
setz dil
setz al
movzx edi, dil
loc_1526:
add r10, 1
cmp r10, rdx
jnb short loc_153A
test al, al
jnz short loc_14E8
jmp short loc_153A
loc_1538:
xor edi, edi
loc_153A:
mov eax, edi
retn | _BOOL8 func0(long long a1, long long a2, unsigned long long a3, int a4)
{
long long v5; // r10
_BOOL4 v6; // edi
long long v7; // r8
bool v8; // al
long long v9; // rax
int v10; // edi
v5 = 0LL;
v6 = 1;
if ( a3 )
{
while ( 1 )
{
v7 = *(_QWORD *)(a2 + 8 * v5);
v8 = 1;
v6 = 1;
if ( v7 )
break;
LABEL_7:
if ( ++v5 >= a3 || !v8 )
return v6;
}
v9 = 0LL;
do
{
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8 * v5) + 4 * v9++);
if ( v9 == v7 )
{
v8 = v10 == a4;
v6 = v10 == a4;
goto LABEL_7;
}
}
while ( v10 == a4 );
return 0;
}
return v6;
} | func0:
ENDBR64
MOV R11,RDI
XOR R10D,R10D
MOV EDI,0x1
TEST RDX,RDX
JZ 0x0010153a
NOP dword ptr [RAX]
LAB_001014e8:
MOV R8,qword ptr [RSI + R10*0x8]
MOV EAX,0x1
MOV EDI,0x1
TEST R8,R8
JZ 0x00101526
MOV R9,qword ptr [R11 + R10*0x8]
XOR EAX,EAX
JMP 0x0010150c
LAB_00101508:
CMP EDI,ECX
JNZ 0x00101538
LAB_0010150c:
MOV EDI,dword ptr [R9 + RAX*0x4]
ADD RAX,0x1
CMP RAX,R8
JNZ 0x00101508
CMP EDI,ECX
SETZ DIL
SETZ AL
MOVZX EDI,DIL
LAB_00101526:
ADD R10,0x1
CMP R10,RDX
JNC 0x0010153a
TEST AL,AL
JNZ 0x001014e8
JMP 0x0010153a
LAB_00101538:
XOR EDI,EDI
LAB_0010153a:
MOV EAX,EDI
RET | bool func0(long param_1,long param_2,ulong param_3,int param_4)
{
int iVar1;
long lVar2;
long lVar3;
ulong uVar4;
bool bVar5;
uVar4 = 0;
bVar5 = true;
if (param_3 != 0) {
do {
lVar2 = *(long *)(param_2 + uVar4 * 8);
bVar5 = true;
if (lVar2 != 0) {
lVar3 = 0;
while( true ) {
iVar1 = *(int *)(*(long *)(param_1 + uVar4 * 8) + lVar3 * 4);
lVar3 = lVar3 + 1;
if (lVar3 == lVar2) break;
if (iVar1 != param_4) {
return false;
}
}
bVar5 = iVar1 == param_4;
}
uVar4 = uVar4 + 1;
} while ((uVar4 < param_3) && (bVar5));
}
return bVar5;
} |
4,000 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#define MAX_STRINGS 3
#define MAX_LENGTH 100
| void func0(char input[][MAX_LENGTH], char output[][MAX_LENGTH], int n) {
for(int i = 0; i < n; i++) {
int j = 0, k = 0;
while(input[i][j] != '\0') {
if(!isdigit((unsigned char)input[i][j])) {
output[i][k++] = input[i][j];
}
j++;
}
output[i][k] = '\0';
}
}
| int main() {
char input1[MAX_STRINGS][MAX_LENGTH] = {"4words", "3letters", "4digits"};
char expected1[MAX_STRINGS][MAX_LENGTH] = {"words", "letters", "digits"};
char output1[MAX_STRINGS][MAX_LENGTH];
func0(input1, output1, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
char input2[MAX_STRINGS][MAX_LENGTH] = {"28Jan", "12Jan", "11Jan"};
char expected2[MAX_STRINGS][MAX_LENGTH] = {"Jan", "Jan", "Jan"};
char output2[MAX_STRINGS][MAX_LENGTH];
func0(input2, output2, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
char input3[MAX_STRINGS][MAX_LENGTH] = {"wonder1", "wonder2", "wonder3"};
char expected3[MAX_STRINGS][MAX_LENGTH] = {"wonder", "wonder", "wonder"};
char output3[MAX_STRINGS][MAX_LENGTH];
func0(input3, output3, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1311 <func0+0x168>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 12a1 <func0+0xf8>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rcx
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%eax
cltq
movzbl (%rdx,%rax,1),%eax
movzbl %al,%eax
add %rax,%rax
add %rcx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
jne 129d <func0+0xf4>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rsi
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4(%rbp)
mov -0x8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rsi,%rdx,1),%edx
cltq
mov %dl,(%rcx,%rax,1)
addl $0x1,-0x8(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%eax
cltq
movzbl (%rdx,%rax,1),%eax
test %al,%al
jne 11df <func0+0x36>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
movb $0x0,(%rdx,%rax,1)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11cc <func0+0x23>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_C], 0
jmp loc_1311
loc_11CC:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_12A1
loc_11DF:
call ___ctype_b_loc
mov rcx, [rax]
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_8]
cdqe
movzx eax, byte ptr [rdx+rax]
movzx eax, al
add rax, rax
add rax, rcx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jnz short loc_129D
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
lea rsi, [rdx+rax]
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_20]
lea rcx, [rdx+rax]
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov [rbp+var_4], edx
mov edx, [rbp+var_8]
movsxd rdx, edx
movzx edx, byte ptr [rsi+rdx]
cdqe
mov [rcx+rax], dl
loc_129D:
add [rbp+var_8], 1
loc_12A1:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_8]
cdqe
movzx eax, byte ptr [rdx+rax]
test al, al
jnz loc_11DF
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_20]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov byte ptr [rdx+rax], 0
add [rbp+var_C], 1
loc_1311:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
jl loc_11CC
nop
nop
leave
retn | long long func0(long long a1, long long a2, int a3)
{
int v3; // eax
long long result; // rax
unsigned int i; // [rsp+24h] [rbp-Ch]
int v7; // [rsp+28h] [rbp-8h]
int v8; // [rsp+2Ch] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
v7 = 0;
v8 = 0;
while ( *(_BYTE *)(a1 + 100LL * (int)i + v7) )
{
if ( ((*__ctype_b_loc())[*(unsigned __int8 *)(a1 + 100LL * (int)i + v7)] & 0x800) == 0 )
{
v3 = v8++;
*(_BYTE *)(100LL * (int)i + a2 + v3) = *(_BYTE *)(100LL * (int)i + a1 + v7);
}
++v7;
}
*(_BYTE *)(a2 + 100LL * (int)i + v8) = 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101311
LAB_001011cc:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012a1
LAB_001011df:
CALL 0x001010b0
MOV RCX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
MOVZX EAX,AL
ADD RAX,RAX
ADD RAX,RCX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JNZ 0x0010129d
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RSI,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4],EDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
MOVZX EDX,byte ptr [RSI + RDX*0x1]
CDQE
MOV byte ptr [RCX + RAX*0x1],DL
LAB_0010129d:
ADD dword ptr [RBP + -0x8],0x1
LAB_001012a1:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
TEST AL,AL
JNZ 0x001011df
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x0
ADD dword ptr [RBP + -0xc],0x1
LAB_00101311:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011cc
NOP
NOP
LEAVE
RET | void func0(long param_1,long param_2,int param_3)
{
ushort **ppuVar1;
int local_14;
int local_10;
int local_c;
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
local_c = 0;
for (local_10 = 0; *(char *)((long)local_14 * 100 + param_1 + (long)local_10) != '\0';
local_10 = local_10 + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(byte *)((long)local_14 * 100 + param_1 + (long)local_10)] & 0x800) == 0) {
*(int *)((long)local_14 * 100 + param_2 + (long)local_c) =
*(int *)((long)local_14 * 100 + param_1 + (long)local_10);
local_c = local_c + 1;
}
}
*(int *)((long)local_14 * 100 + param_2 + (long)local_c) = 0;
}
return;
} |
4,001 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#define MAX_STRINGS 3
#define MAX_LENGTH 100
| void func0(char input[][MAX_LENGTH], char output[][MAX_LENGTH], int n) {
for(int i = 0; i < n; i++) {
int j = 0, k = 0;
while(input[i][j] != '\0') {
if(!isdigit((unsigned char)input[i][j])) {
output[i][k++] = input[i][j];
}
j++;
}
output[i][k] = '\0';
}
}
| int main() {
char input1[MAX_STRINGS][MAX_LENGTH] = {"4words", "3letters", "4digits"};
char expected1[MAX_STRINGS][MAX_LENGTH] = {"words", "letters", "digits"};
char output1[MAX_STRINGS][MAX_LENGTH];
func0(input1, output1, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
char input2[MAX_STRINGS][MAX_LENGTH] = {"28Jan", "12Jan", "11Jan"};
char expected2[MAX_STRINGS][MAX_LENGTH] = {"Jan", "Jan", "Jan"};
char output2[MAX_STRINGS][MAX_LENGTH];
func0(input2, output2, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
char input3[MAX_STRINGS][MAX_LENGTH] = {"wonder1", "wonder2", "wonder3"};
char expected3[MAX_STRINGS][MAX_LENGTH] = {"wonder", "wonder", "wonder"};
char output3[MAX_STRINGS][MAX_LENGTH];
func0(input3, output3, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 1239 <func0+0x90>
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rsi,%rbp
lea 0x1(%rdi),%r12
lea -0x1(%rdx),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x64(%rsi,%rax,4),%r13
mov $0x0,%r14d
jmp 1216 <func0+0x6d>
add $0x1,%rcx
movzbl -0x1(%rcx),%ebx
test %bl,%bl
je 1201 <func0+0x58>
movzbl %bl,%edx
mov (%rax),%rsi
testb $0x8,0x1(%rsi,%rdx,2)
jne 11dc <func0+0x33>
movslq %edi,%rdx
mov %bl,0x0(%rbp,%rdx,1)
lea 0x1(%rdi),%edi
jmp 11dc <func0+0x33>
movslq %edi,%rdi
movb $0x0,0x0(%rbp,%rdi,1)
add $0x64,%rbp
add $0x64,%r12
cmp %r13,%rbp
je 1230 <func0+0x87>
movzbl -0x1(%r12),%ebx
mov %r14d,%edi
test %bl,%bl
je 1201 <func0+0x58>
callq 10b0 <__ctype_b_loc@plt>
mov %r12,%rcx
mov %r14d,%edi
jmp 11e8 <func0+0x3f>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
retq
| func0:
endbr64
test edx, edx
jle locret_1239
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rsi
lea r12, [rdi+1]
lea eax, [rdx-1]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea r13, [rsi+rax*4+64h]
mov r14d, 0
jmp short loc_1216
loc_11DC:
add rcx, 1
movzx ebx, byte ptr [rcx-1]
test bl, bl
jz short loc_1201
loc_11E8:
movzx edx, bl
mov rsi, [rax]
test byte ptr [rsi+rdx*2+1], 8
jnz short loc_11DC
movsxd rdx, edi
mov [rbp+rdx+0], bl
lea edi, [rdi+1]
jmp short loc_11DC
loc_1201:
movsxd rdi, edi
mov byte ptr [rbp+rdi+0], 0
add rbp, 64h ; 'd'
add r12, 64h ; 'd'
cmp rbp, r13
jz short loc_1230
loc_1216:
movzx ebx, byte ptr [r12-1]
mov edi, r14d
test bl, bl
jz short loc_1201
call ___ctype_b_loc
mov rcx, r12
mov edi, r14d
jmp short loc_11E8
loc_1230:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
locret_1239:
retn | void func0(long long a1, long long a2, int a3)
{
long long v3; // rbp
unsigned __int8 *v4; // r12
long long v5; // r13
unsigned __int8 *v6; // rcx
unsigned __int8 v7; // bl
int v8; // edi
_QWORD *v9; // rax
if ( a3 > 0 )
{
v3 = a2;
v4 = (unsigned __int8 *)(a1 + 1);
v5 = a2 + 100LL * (unsigned int)(a3 - 1) + 100;
do
{
v7 = *(v4 - 1);
v8 = 0;
if ( v7 )
{
v9 = (_QWORD *)__ctype_b_loc(0LL);
v6 = v4;
v8 = 0;
do
{
if ( (*(_BYTE *)(*v9 + 2LL * v7 + 1) & 8) == 0 )
*(_BYTE *)(v3 + v8++) = v7;
v7 = *v6++;
}
while ( v7 );
}
*(_BYTE *)(v3 + v8) = 0;
v3 += 100LL;
v4 += 100;
}
while ( v3 != v5 );
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101239
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RSI
LEA R12,[RDI + 0x1]
LEA EAX,[RDX + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA R13,[RSI + RAX*0x4 + 0x64]
MOV R14D,0x0
JMP 0x00101216
LAB_001011dc:
ADD RCX,0x1
MOVZX EBX,byte ptr [RCX + -0x1]
TEST BL,BL
JZ 0x00101201
LAB_001011e8:
MOVZX EDX,BL
MOV RSI,qword ptr [RAX]
TEST byte ptr [RSI + RDX*0x2 + 0x1],0x8
JNZ 0x001011dc
MOVSXD RDX,EDI
MOV byte ptr [RBP + RDX*0x1],BL
LEA EDI,[RDI + 0x1]
JMP 0x001011dc
LAB_00101201:
MOVSXD RDI,EDI
MOV byte ptr [RBP + RDI*0x1],0x0
ADD RBP,0x64
ADD R12,0x64
CMP RBP,R13
JZ 0x00101230
LAB_00101216:
MOVZX EBX,byte ptr [R12 + -0x1]
MOV EDI,R14D
TEST BL,BL
JZ 0x00101201
CALL 0x001010b0
MOV RCX,R12
MOV EDI,R14D
JMP 0x001011e8
LAB_00101230:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101239:
RET | void func0(long param_1,long param_2,int param_3)
{
long lVar1;
ushort **ppuVar2;
byte *pbVar3;
byte bVar4;
byte *pbVar5;
int iVar6;
if (0 < param_3) {
pbVar5 = (byte *)(param_1 + 1);
lVar1 = param_2 + 100;
do {
bVar4 = pbVar5[-1];
iVar6 = 0;
if (bVar4 != 0) {
ppuVar2 = __ctype_b_loc();
pbVar3 = pbVar5;
do {
if ((*(byte *)((long)*ppuVar2 + (ulong)bVar4 * 2 + 1) & 8) == 0) {
*(byte *)(param_2 + iVar6) = bVar4;
iVar6 = iVar6 + 1;
}
bVar4 = *pbVar3;
pbVar3 = pbVar3 + 1;
} while (bVar4 != 0);
}
*(int1 *)(param_2 + iVar6) = 0;
param_2 = param_2 + 100;
pbVar5 = pbVar5 + 100;
} while (param_2 != lVar1 + (ulong)(param_3 - 1) * 100);
return;
}
return;
} |
4,002 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#define MAX_STRINGS 3
#define MAX_LENGTH 100
| void func0(char input[][MAX_LENGTH], char output[][MAX_LENGTH], int n) {
for(int i = 0; i < n; i++) {
int j = 0, k = 0;
while(input[i][j] != '\0') {
if(!isdigit((unsigned char)input[i][j])) {
output[i][k++] = input[i][j];
}
j++;
}
output[i][k] = '\0';
}
}
| int main() {
char input1[MAX_STRINGS][MAX_LENGTH] = {"4words", "3letters", "4digits"};
char expected1[MAX_STRINGS][MAX_LENGTH] = {"words", "letters", "digits"};
char output1[MAX_STRINGS][MAX_LENGTH];
func0(input1, output1, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
char input2[MAX_STRINGS][MAX_LENGTH] = {"28Jan", "12Jan", "11Jan"};
char expected2[MAX_STRINGS][MAX_LENGTH] = {"Jan", "Jan", "Jan"};
char output2[MAX_STRINGS][MAX_LENGTH];
func0(input2, output2, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
char input3[MAX_STRINGS][MAX_LENGTH] = {"wonder1", "wonder2", "wonder3"};
char expected3[MAX_STRINGS][MAX_LENGTH] = {"wonder", "wonder", "wonder"};
char output3[MAX_STRINGS][MAX_LENGTH];
func0(input3, output3, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 14bb <func0+0x8b>
push %r13
lea -0x1(%rdx),%eax
lea 0x1(%rdi),%r13
push %r12
lea (%rax,%rax,4),%rax
mov %rsi,%r12
push %rbp
lea (%rax,%rax,4),%rax
push %rbx
lea 0x65(%rdi,%rax,4),%rbp
sub $0x8,%rsp
nopl (%rax)
movzbl -0x1(%r13),%ebx
xor %edi,%edi
test %bl,%bl
je 149a <func0+0x6a>
callq 10b0 <__ctype_b_loc@plt>
mov %r13,%rcx
xor %edi,%edi
nopl (%rax)
mov (%rax),%rsi
movzbl %bl,%edx
testb $0x8,0x1(%rsi,%rdx,2)
jne 148f <func0+0x5f>
movslq %edi,%rdx
add $0x1,%edi
mov %bl,(%r12,%rdx,1)
movzbl (%rcx),%ebx
add $0x1,%rcx
test %bl,%bl
jne 1478 <func0+0x48>
movslq %edi,%rdi
add $0x64,%r13
add $0x64,%r12
movb $0x0,-0x64(%r12,%rdi,1)
cmp %rbp,%r13
jne 1460 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
retq
nopl 0x0(%rax)
| func0:
endbr64
test edx, edx
jle locret_145B
push r13
lea eax, [rdx-1]
lea r13, [rdi+1]
push r12
lea rax, [rax+rax*4]
mov r12, rsi
push rbp
lea rax, [rax+rax*4]
push rbx
lea rbp, [rdi+rax*4+65h]
sub rsp, 8
nop dword ptr [rax]
loc_1400:
movzx ebx, byte ptr [r13-1]
xor edi, edi
test bl, bl
jz short loc_143A
call ___ctype_b_loc
mov rcx, r13
xor edi, edi
nop dword ptr [rax]
loc_1418:
mov rsi, [rax]
movzx edx, bl
test byte ptr [rsi+rdx*2+1], 8
jnz short loc_142F
movsxd rdx, edi
add edi, 1
mov [r12+rdx], bl
loc_142F:
movzx ebx, byte ptr [rcx]
add rcx, 1
test bl, bl
jnz short loc_1418
loc_143A:
movsxd rdi, edi
add r13, 64h ; 'd'
add r12, 64h ; 'd'
mov byte ptr [r12+rdi-64h], 0
cmp rbp, r13
jnz short loc_1400
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
locret_145B:
retn | void func0(long long a1, long long a2, int a3)
{
unsigned __int8 *v3; // r13
long long v5; // rbp
unsigned __int8 v6; // bl
int v7; // edi
_QWORD *v8; // rax
unsigned __int8 *v9; // rcx
long long v10; // rdx
if ( a3 > 0 )
{
v3 = (unsigned __int8 *)(a1 + 1);
v5 = a1 + 100LL * (unsigned int)(a3 - 1) + 101;
do
{
v6 = *(v3 - 1);
v7 = 0;
if ( v6 )
{
v8 = (_QWORD *)__ctype_b_loc(0LL);
v9 = v3;
v7 = 0;
do
{
if ( (*(_BYTE *)(*v8 + 2LL * v6 + 1) & 8) == 0 )
{
v10 = v7++;
*(_BYTE *)(a2 + v10) = v6;
}
v6 = *v9++;
}
while ( v6 );
}
v3 += 100;
a2 += 100LL;
*(_BYTE *)(a2 + v7 - 100) = 0;
}
while ( (unsigned __int8 *)v5 != v3 );
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010145b
PUSH R13
LEA EAX,[RDX + -0x1]
LEA R13,[RDI + 0x1]
PUSH R12
LEA RAX,[RAX + RAX*0x4]
MOV R12,RSI
PUSH RBP
LEA RAX,[RAX + RAX*0x4]
PUSH RBX
LEA RBP,[RDI + RAX*0x4 + 0x65]
SUB RSP,0x8
NOP dword ptr [RAX]
LAB_00101400:
MOVZX EBX,byte ptr [R13 + -0x1]
XOR EDI,EDI
TEST BL,BL
JZ 0x0010143a
CALL 0x001010b0
MOV RCX,R13
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_00101418:
MOV RSI,qword ptr [RAX]
MOVZX EDX,BL
TEST byte ptr [RSI + RDX*0x2 + 0x1],0x8
JNZ 0x0010142f
MOVSXD RDX,EDI
ADD EDI,0x1
MOV byte ptr [R12 + RDX*0x1],BL
LAB_0010142f:
MOVZX EBX,byte ptr [RCX]
ADD RCX,0x1
TEST BL,BL
JNZ 0x00101418
LAB_0010143a:
MOVSXD RDI,EDI
ADD R13,0x64
ADD R12,0x64
MOV byte ptr [R12 + RDI*0x1 + -0x64],0x0
CMP RBP,R13
JNZ 0x00101400
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010145b:
RET | void func0(long param_1,long param_2,int param_3)
{
ushort **ppuVar1;
byte *pbVar2;
long lVar3;
byte bVar4;
int iVar5;
byte *pbVar6;
if (0 < param_3) {
pbVar6 = (byte *)(param_1 + 1);
do {
bVar4 = pbVar6[-1];
iVar5 = 0;
if (bVar4 != 0) {
ppuVar1 = __ctype_b_loc();
iVar5 = 0;
pbVar2 = pbVar6;
do {
if ((*(byte *)((long)*ppuVar1 + (ulong)bVar4 * 2 + 1) & 8) == 0) {
lVar3 = (long)iVar5;
iVar5 = iVar5 + 1;
*(byte *)(param_2 + lVar3) = bVar4;
}
bVar4 = *pbVar2;
pbVar2 = pbVar2 + 1;
} while (bVar4 != 0);
}
pbVar6 = pbVar6 + 100;
*(int1 *)(param_2 + iVar5) = 0;
param_2 = param_2 + 100;
} while ((byte *)(param_1 + 0x65 + (ulong)(param_3 - 1) * 100) != pbVar6);
return;
}
return;
} |
4,003 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#define MAX_STRINGS 3
#define MAX_LENGTH 100
| void func0(char input[][MAX_LENGTH], char output[][MAX_LENGTH], int n) {
for(int i = 0; i < n; i++) {
int j = 0, k = 0;
while(input[i][j] != '\0') {
if(!isdigit((unsigned char)input[i][j])) {
output[i][k++] = input[i][j];
}
j++;
}
output[i][k] = '\0';
}
}
| int main() {
char input1[MAX_STRINGS][MAX_LENGTH] = {"4words", "3letters", "4digits"};
char expected1[MAX_STRINGS][MAX_LENGTH] = {"words", "letters", "digits"};
char output1[MAX_STRINGS][MAX_LENGTH];
func0(input1, output1, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output1[i], expected1[i]) == 0);
}
char input2[MAX_STRINGS][MAX_LENGTH] = {"28Jan", "12Jan", "11Jan"};
char expected2[MAX_STRINGS][MAX_LENGTH] = {"Jan", "Jan", "Jan"};
char output2[MAX_STRINGS][MAX_LENGTH];
func0(input2, output2, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output2[i], expected2[i]) == 0);
}
char input3[MAX_STRINGS][MAX_LENGTH] = {"wonder1", "wonder2", "wonder3"};
char expected3[MAX_STRINGS][MAX_LENGTH] = {"wonder", "wonder", "wonder"};
char output3[MAX_STRINGS][MAX_LENGTH];
func0(input3, output3, MAX_STRINGS);
for(int i = 0; i < MAX_STRINGS; i++) {
assert(strcmp(output3[i], expected3[i]) == 0);
}
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 14db <func0+0xab>
push %r13
lea -0x1(%rdx),%eax
lea 0x1(%rdi),%r13
push %r12
lea (%rax,%rax,4),%rax
mov %rsi,%r12
push %rbp
lea (%rax,%rax,4),%rax
push %rbx
lea 0x65(%rdi,%rax,4),%rbp
sub $0x8,%rsp
nopl (%rax)
movzbl -0x1(%r13),%ebx
xor %esi,%esi
test %bl,%bl
je 14ba <func0+0x8a>
callq 10b0 <__ctype_b_loc@plt>
mov %r13,%rdx
xor %ecx,%ecx
mov (%rax),%rdi
nopl 0x0(%rax,%rax,1)
movzbl %bl,%esi
testb $0x8,0x1(%rdi,%rsi,2)
jne 14ad <func0+0x7d>
add $0x1,%rdx
mov %bl,(%r12,%rcx,1)
lea 0x1(%rcx),%esi
movzbl -0x1(%rdx),%ebx
test %bl,%bl
je 14ba <func0+0x8a>
mov (%rax),%rdi
movslq %esi,%rcx
movzbl %bl,%esi
testb $0x8,0x1(%rdi,%rsi,2)
je 148a <func0+0x5a>
movzbl (%rdx),%ebx
add $0x1,%rdx
test %bl,%bl
jne 1480 <func0+0x50>
mov %ecx,%esi
movslq %esi,%rsi
add $0x64,%r13
add $0x64,%r12
movb $0x0,-0x64(%r12,%rsi,1)
cmp %r13,%rbp
jne 1460 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
retq
nopl 0x0(%rax)
| func0:
endbr64
test edx, edx
jle locret_14CB
push r13
movsxd rdx, edx
lea r13, [rdi+1]
push r12
lea rax, [rdx+rdx*4]
mov r12, rsi
push rbp
lea rax, [rax+rax*4]
push rbx
lea rbp, [rsi+rax*4]
sub rsp, 8
nop dword ptr [rax+00h]
loc_1460:
movzx ebx, byte ptr [r13-1]
xor ecx, ecx
test bl, bl
jz short loc_14AE
call ___ctype_b_loc
mov rdx, r13
xor ecx, ecx
jmp short loc_1496
loc_1480:
add rdx, 1
mov [r12+rcx], bl
lea esi, [rcx+1]
movzx ebx, byte ptr [rdx-1]
movsxd rcx, esi
test bl, bl
jz short loc_14AE
loc_1496:
mov rdi, [rax]
loc_1499:
movzx esi, bl
test byte ptr [rdi+rsi*2+1], 8
jz short loc_1480
movzx ebx, byte ptr [rdx]
add rdx, 1
test bl, bl
jnz short loc_1499
loc_14AE:
mov byte ptr [r12+rcx], 0
add r12, 64h ; 'd'
add r13, 64h ; 'd'
cmp rbp, r12
jnz short loc_1460
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
locret_14CB:
retn | void func0(long long a1, long long a2, int a3)
{
unsigned __int8 *v3; // r13
long long v4; // r12
long long v5; // rbp
unsigned __int8 v6; // bl
long long v7; // rcx
const unsigned __int16 **v8; // rax
unsigned __int8 *v9; // rdx
if ( a3 > 0 )
{
v3 = (unsigned __int8 *)(a1 + 1);
v4 = a2;
v5 = a2 + 100LL * a3;
do
{
v6 = *(v3 - 1);
v7 = 0LL;
if ( v6 )
{
v8 = __ctype_b_loc();
v9 = v3;
v7 = 0LL;
do
{
while ( ((*v8)[v6] & 0x800) == 0 )
{
++v9;
*(_BYTE *)(v4 + v7) = v6;
v6 = *(v9 - 1);
v7 = (int)v7 + 1;
if ( !v6 )
goto LABEL_8;
}
v6 = *v9++;
}
while ( v6 );
}
LABEL_8:
*(_BYTE *)(v4 + v7) = 0;
v4 += 100LL;
v3 += 100;
}
while ( v5 != v4 );
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001014cb
PUSH R13
MOVSXD RDX,EDX
LEA R13,[RDI + 0x1]
PUSH R12
LEA RAX,[RDX + RDX*0x4]
MOV R12,RSI
PUSH RBP
LEA RAX,[RAX + RAX*0x4]
PUSH RBX
LEA RBP,[RSI + RAX*0x4]
SUB RSP,0x8
NOP dword ptr [RAX]
LAB_00101460:
MOVZX EBX,byte ptr [R13 + -0x1]
XOR ECX,ECX
TEST BL,BL
JZ 0x001014ae
CALL 0x001010b0
MOV RDX,R13
XOR ECX,ECX
JMP 0x00101496
LAB_00101480:
ADD RDX,0x1
MOV byte ptr [R12 + RCX*0x1],BL
LEA ESI,[RCX + 0x1]
MOVZX EBX,byte ptr [RDX + -0x1]
MOVSXD RCX,ESI
TEST BL,BL
JZ 0x001014ae
LAB_00101496:
MOV RDI,qword ptr [RAX]
LAB_00101499:
MOVZX ESI,BL
TEST byte ptr [RDI + RSI*0x2 + 0x1],0x8
JZ 0x00101480
MOVZX EBX,byte ptr [RDX]
ADD RDX,0x1
TEST BL,BL
JNZ 0x00101499
LAB_001014ae:
MOV byte ptr [R12 + RCX*0x1],0x0
ADD R12,0x64
ADD R13,0x64
CMP RBP,R12
JNZ 0x00101460
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001014cb:
RET | void func0(long param_1,long param_2,int param_3)
{
long lVar1;
ushort **ppuVar2;
long lVar3;
byte *pbVar4;
byte bVar5;
byte *pbVar6;
if (param_3 < 1) {
return;
}
pbVar6 = (byte *)(param_1 + 1);
lVar1 = param_2 + (long)param_3 * 100;
do {
bVar5 = pbVar6[-1];
lVar3 = 0;
if (bVar5 != 0) {
ppuVar2 = __ctype_b_loc();
lVar3 = 0;
pbVar4 = pbVar6;
do {
while ((*(byte *)((long)*ppuVar2 + (ulong)bVar5 * 2 + 1) & 8) != 0) {
bVar5 = *pbVar4;
pbVar4 = pbVar4 + 1;
if (bVar5 == 0) goto LAB_001014ae;
}
*(byte *)(param_2 + lVar3) = bVar5;
bVar5 = *pbVar4;
lVar3 = (long)((int)lVar3 + 1);
pbVar4 = pbVar4 + 1;
} while (bVar5 != 0);
}
LAB_001014ae:
*(int *)(param_2 + lVar3) = 0;
param_2 = param_2 + 100;
pbVar6 = pbVar6 + 100;
if (lVar1 == param_2) {
return;
}
} while( true );
} |
4,004 | func0 | #include <assert.h>
| int func0(int n, int k) {
if (k > n)
return 0;
if (k == 0 || k == n)
return 1;
return func0(n-1, k-1) + func0(n-1, k);
}
| int main() {
assert(func0(5, 2) == 10);
assert(func0(4, 3) == 4);
assert(func0(3, 2) == 3);
assert(func0(14, 6) == 3003);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 116b <func0+0x22>
mov $0x0,%eax
jmp 11ab <func0+0x62>
cmpl $0x0,-0x18(%rbp)
je 1179 <func0+0x30>
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jne 1180 <func0+0x37>
mov $0x1,%eax
jmp 11ab <func0+0x62>
mov -0x18(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
mov %eax,%ebx
mov -0x14(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%eax
mov %eax,%esi
mov %edx,%edi
callq 1149 <func0>
add %ebx,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jle short loc_116B
mov eax, 0
jmp short loc_11AB
loc_116B:
cmp [rbp+var_18], 0
jz short loc_1179
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jnz short loc_1180
loc_1179:
mov eax, 1
jmp short loc_11AB
loc_1180:
mov eax, [rbp+var_18]
lea edx, [rax-1]
mov eax, [rbp+var_14]
sub eax, 1
mov esi, edx
mov edi, eax
call func0
mov ebx, eax
mov eax, [rbp+var_14]
lea edx, [rax-1]
mov eax, [rbp+var_18]
mov esi, eax
mov edi, edx
call func0
add eax, ebx
loc_11AB:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1, unsigned int a2)
{
int v3; // ebx
if ( (int)a2 > a1 )
return 0LL;
if ( !a2 || a2 == a1 )
return 1LL;
v3 = func0((unsigned int)(a1 - 1), a2 - 1);
return v3 + (unsigned int)func0((unsigned int)(a1 - 1), a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x0010116b
MOV EAX,0x0
JMP 0x001011ab
LAB_0010116b:
CMP dword ptr [RBP + -0x18],0x0
JZ 0x00101179
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x00101180
LAB_00101179:
MOV EAX,0x1
JMP 0x001011ab
LAB_00101180:
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x18]
MOV ESI,EAX
MOV EDI,EDX
CALL 0x00101149
ADD EAX,EBX
LAB_001011ab:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < param_2) {
iVar2 = 0;
}
else if ((param_2 == 0) || (param_2 == param_1)) {
iVar2 = 1;
}
else {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar2 = iVar2 + iVar1;
}
return iVar2;
} |
4,005 | func0 | #include <assert.h>
| int func0(int n, int k) {
if (k > n)
return 0;
if (k == 0 || k == n)
return 1;
return func0(n-1, k-1) + func0(n-1, k);
}
| int main() {
assert(func0(5, 2) == 10);
assert(func0(4, 3) == 4);
assert(func0(3, 2) == 3);
assert(func0(14, 6) == 3003);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %edi,%esi
jg 118c <func0+0x43>
push %r12
push %rbp
push %rbx
mov %esi,%ebx
test %esi,%esi
je 1182 <func0+0x39>
cmp %edi,%esi
je 1182 <func0+0x39>
lea -0x1(%rdi),%ebp
lea -0x1(%rsi),%esi
mov %ebp,%edi
callq 1149 <func0>
mov %eax,%r12d
mov %ebx,%esi
mov %ebp,%edi
callq 1149 <func0>
add %r12d,%eax
jmp 1187 <func0+0x3e>
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
retq
retq
| func0:
endbr64
mov eax, 0
cmp esi, edi
jg short locret_118C
push r12
push rbp
push rbx
mov ebx, esi
test esi, esi
jz short loc_1182
cmp esi, edi
jz short loc_1182
lea ebp, [rdi-1]
lea esi, [rsi-1]
mov edi, ebp
call func0
mov r12d, eax
mov esi, ebx
mov edi, ebp
call func0
add eax, r12d
jmp short loc_1187
loc_1182:
mov eax, 1
loc_1187:
pop rbx
pop rbp
pop r12
retn
locret_118C:
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
result = 0LL;
if ( (int)a2 <= a1 )
{
if ( !a2 || a2 == a1 )
{
return 1LL;
}
else
{
v3 = func0((unsigned int)(a1 - 1), a2 - 1);
return v3 + (unsigned int)func0((unsigned int)(a1 - 1), a2);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,EDI
JG 0x0010118c
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
TEST ESI,ESI
JZ 0x00101182
CMP ESI,EDI
JZ 0x00101182
LEA EBP,[RDI + -0x1]
LEA ESI,[RSI + -0x1]
MOV EDI,EBP
CALL 0x00101149
MOV R12D,EAX
MOV ESI,EBX
MOV EDI,EBP
CALL 0x00101149
ADD EAX,R12D
JMP 0x00101187
LAB_00101182:
MOV EAX,0x1
LAB_00101187:
POP RBX
POP RBP
POP R12
RET
LAB_0010118c:
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_2 <= param_1) {
if ((param_2 == 0) || (param_2 == param_1)) {
iVar2 = 1;
}
else {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar2 = iVar2 + iVar1;
}
return iVar2;
}
return 0;
} |
4,006 | func0 | #include <assert.h>
| int func0(int n, int k) {
if (k > n)
return 0;
if (k == 0 || k == n)
return 1;
return func0(n-1, k-1) + func0(n-1, k);
}
| int main() {
assert(func0(5, 2) == 10);
assert(func0(4, 3) == 4);
assert(func0(3, 2) == 3);
assert(func0(14, 6) == 3003);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
cmp %esi,%edi
jl 1290 <func0+0x50>
je 12a8 <func0+0x68>
mov %esi,%ebp
test %esi,%esi
je 12a8 <func0+0x68>
mov %edi,%ebx
lea -0x1(%rsi),%r13d
xor %r12d,%r12d
sub $0x1,%ebx
mov %r13d,%esi
mov %ebx,%edi
callq 1240 <func0>
add %eax,%r12d
cmp %ebp,%ebx
jl 127d <func0+0x3d>
jne 1263 <func0+0x23>
add $0x1,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %r12d,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
mov $0x1,%r12d
jmp 127d <func0+0x3d>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_84], edi
cmp edi, esi
jl loc_16CC
mov r11d, esi
test esi, esi
jz loc_16D4
cmp edi, esi
jz loc_16D4
xor r10d, r10d
mov r9d, r11d
lea esi, [rsi-9]
mov r11d, r10d
loc_127D:
mov edx, [rsp+98h+var_84]
mov eax, edx
sub edx, 1
mov [rsp+98h+var_84], edx
cmp r9d, eax
jg loc_1585
jz loc_16C3
cmp r9d, 1
lea ecx, [r9-2]
mov [rsp+98h+var_60], edx
setz al
mov [rsp+98h+var_5C], ecx
xor r10d, r10d
test al, al
jnz loc_16C3
mov [rsp+98h+var_50], r11d
mov r11d, r10d
mov r10d, r9d
loc_12C2:
mov edi, [rsp+98h+var_60]
mov eax, [rsp+98h+var_5C]
mov [rsp+98h+var_3C], edi
sub edi, 1
mov [rsp+98h+var_60], edi
cmp edi, eax
jl loc_1564
jz loc_16BA
test eax, eax
lea ecx, [r10-3]
mov [rsp+98h+var_90], edi
setz al
mov [rsp+98h+var_58], ecx
xor r8d, r8d
test al, al
jnz loc_16BA
mov [rsp+98h+var_4C], r11d
mov r11d, r8d
mov r8d, r10d
loc_130A:
sub [rsp+98h+var_90], 1
mov eax, [rsp+98h+var_58]
mov r9d, [rsp+98h+var_90]
cmp r9d, eax
jl loc_1540
jz loc_16B1
test eax, eax
lea edx, [r8-4]
setz al
mov [rsp+98h+var_54], edx
xor r10d, r10d
test al, al
jnz loc_16B1
mov [rsp+98h+var_48], r11d
mov r11d, r8d
loc_1347:
mov eax, [rsp+98h+var_54]
sub r9d, 1
cmp r9d, eax
jl loc_1522
test eax, eax
jz loc_16A8
cmp r9d, eax
lea ecx, [r11-5]
mov [rsp+98h+var_8C], r9d
setz al
mov [rsp+98h+var_88], ecx
xor r8d, r8d
test al, al
jnz loc_16A8
mov [rsp+98h+var_44], r9d
mov [rsp+98h+var_40], r10d
loc_1388:
sub [rsp+98h+var_8C], 1
mov eax, [rsp+98h+var_88]
mov r14d, [rsp+98h+var_8C]
cmp r14d, eax
jl loc_14FF
jz loc_168E
test eax, eax
lea r9d, [r11-6]
lea ecx, [r11-7]
setz al
xor r12d, r12d
test al, al
jnz loc_168E
loc_13BD:
sub r14d, 1
cmp r14d, r9d
jl loc_14E9
jz loc_1668
mov r13d, r14d
xor ebx, ebx
lea r10d, [r11-8]
test r9d, r9d
jz loc_1668
mov edx, r14d
mov r14d, ecx
mov ecx, r12d
loc_13EB:
sub r13d, 1
cmp r13d, r14d
jl loc_14CC
jz loc_1660
mov r12d, r13d
xor ebp, ebp
test r14d, r14d
jz loc_1660
mov eax, r10d
mov r13d, edx
mov r10d, ebx
mov edx, r12d
mov ebx, eax
loc_141A:
sub r12d, 1
cmp r12d, ebx
jl loc_14A9
jz loc_16A0
mov edi, r12d
xor r15d, r15d
test ebx, ebx
jz loc_16A0
mov [rsp+98h+var_80], ebp
mov ebp, edx
mov [rsp+98h+var_7C], r14d
mov r14d, ecx
loc_1449:
sub edi, 1
mov [rsp+98h+var_64], r11d
mov [rsp+98h+var_68], r8d
mov [rsp+98h+var_6C], r9d
mov [rsp+98h+var_70], r10d
mov [rsp+98h+var_74], esi
mov [rsp+98h+var_78], edi
call func0
mov edi, [rsp+98h+var_78]
mov esi, [rsp+98h+var_74]
add r15d, eax
mov r10d, [rsp+98h+var_70]
mov r9d, [rsp+98h+var_6C]
cmp edi, ebx
mov r8d, [rsp+98h+var_68]
mov r11d, [rsp+98h+var_64]
jl loc_1678
jnz short loc_1449
mov edx, ebp
mov ebp, [rsp+98h+var_80]
mov ecx, r14d
mov r14d, [rsp+98h+var_7C]
lea ebp, [r15+rbp+1]
loc_14A9:
cmp r12d, r14d
jl loc_15B0
jnz loc_141A
mov edi, edx
mov eax, ebx
mov ebx, r10d
mov edx, r13d
mov r10d, eax
mov r13d, edi
lea ebx, [rbx+rbp+1]
loc_14CC:
cmp r13d, r9d
jl loc_15CB
loc_14D5:
jnz loc_13EB
mov r12d, ecx
mov ecx, r14d
mov r14d, edx
lea r12d, [r12+rbx+1]
loc_14E9:
cmp r14d, [rsp+98h+var_88]
jl loc_15E2
loc_14F4:
jnz loc_13BD
lea r8d, [r12+r8+1]
loc_14FF:
mov edx, [rsp+98h+var_54]
cmp [rsp+98h+var_8C], edx
jl loc_15F3
loc_150D:
jnz loc_1388
mov r10d, [rsp+98h+var_40]
mov r9d, [rsp+98h+var_44]
lea r10d, [r10+r8+1]
loc_1522:
cmp r9d, [rsp+98h+var_58]
jl loc_160B
loc_152D:
jnz loc_1347
mov r8d, r11d
mov r11d, [rsp+98h+var_48]
lea r11d, [r11+r10+1]
loc_1540:
mov ecx, [rsp+98h+var_5C]
cmp [rsp+98h+var_90], ecx
jl loc_1624
loc_154E:
jnz loc_130A
mov r10d, r8d
mov r8d, r11d
mov r11d, [rsp+98h+var_4C]
lea r11d, [r11+r8+1]
loc_1564:
cmp r10d, [rsp+98h+var_3C]
jg loc_163D
loc_156F:
jnz loc_12C2
mov r9d, r10d
mov r10d, r11d
mov r11d, [rsp+98h+var_50]
lea r11d, [r10+r11+1]
loc_1585:
cmp [rsp+98h+var_84], r9d
jl loc_1656
loc_1590:
jnz loc_127D
mov r10d, r11d
add r10d, 1
loc_159D:
add rsp, 68h
mov eax, r10d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B0:
mov edi, edx
mov eax, ebx
mov edx, r13d
mov ebx, r10d
mov r13d, edi
mov r10d, eax
add ebx, ebp
cmp r13d, r9d
jge loc_14D5
loc_15CB:
mov r12d, ecx
mov ecx, r14d
mov r14d, edx
add r12d, ebx
cmp r14d, [rsp+98h+var_88]
jge loc_14F4
loc_15E2:
mov edx, [rsp+98h+var_54]
add r8d, r12d
cmp [rsp+98h+var_8C], edx
jge loc_150D
loc_15F3:
mov r10d, [rsp+98h+var_40]
mov r9d, [rsp+98h+var_44]
add r10d, r8d
cmp r9d, [rsp+98h+var_58]
jge loc_152D
loc_160B:
mov r8d, r11d
mov r11d, [rsp+98h+var_48]
mov ecx, [rsp+98h+var_5C]
add r11d, r10d
cmp [rsp+98h+var_90], ecx
jge loc_154E
loc_1624:
mov r10d, r8d
mov r8d, r11d
mov r11d, [rsp+98h+var_4C]
add r11d, r8d
cmp r10d, [rsp+98h+var_3C]
jle loc_156F
loc_163D:
mov r9d, r10d
mov r10d, r11d
mov r11d, [rsp+98h+var_50]
add r11d, r10d
cmp [rsp+98h+var_84], r9d
jge loc_1590
loc_1656:
mov r10d, r11d
jmp loc_159D
loc_1660:
add ebx, 1
jmp loc_14CC
loc_1668:
add r12d, 1
jmp loc_14E9
loc_1678:
mov edx, ebp
mov ebp, [rsp+98h+var_80]
mov ecx, r14d
mov r14d, [rsp+98h+var_7C]
add ebp, r15d
jmp loc_14A9
loc_168E:
add r8d, 1
jmp loc_14FF
loc_16A0:
add ebp, 1
jmp loc_14A9
loc_16A8:
add r10d, 1
jmp loc_1522
loc_16B1:
add r11d, 1
jmp loc_1540
loc_16BA:
add r11d, 1
jmp loc_1564
loc_16C3:
add r11d, 1
jmp loc_1585
loc_16CC:
xor r10d, r10d
jmp loc_159D
loc_16D4:
mov r10d, 1
jmp loc_159D | long long func0(int a1, int a2)
{
int v2; // r9d
unsigned int v3; // r11d
int v4; // eax
int v5; // edx
int v6; // r11d
int v7; // r10d
int v8; // edi
int v9; // r11d
int v10; // r8d
int v11; // r9d
int v12; // r10d
int v13; // r11d
int v14; // r8d
int v15; // r14d
int v16; // r9d
int v17; // ecx
int v18; // r12d
int v19; // r13d
int v20; // ebx
int v21; // r10d
int v22; // edx
int v23; // r14d
int v24; // ecx
int v25; // r12d
int v26; // ebp
int v27; // eax
int v28; // r13d
int v29; // r10d
int v30; // edx
int v31; // ebx
int v32; // edi
int v33; // r15d
int v34; // ebp
int v35; // r14d
int v36; // edi
int v37; // eax
int v38; // ebx
bool v39; // zf
int v40; // r12d
bool v41; // zf
bool v42; // zf
bool v43; // zf
bool v44; // zf
bool v45; // zf
bool v46; // zf
int v49; // edi
int v50; // eax
int v51; // ebx
int v52; // r12d
int v53; // [rsp+8h] [rbp-90h]
int v54; // [rsp+Ch] [rbp-8Ch]
int v55; // [rsp+10h] [rbp-88h]
int v56; // [rsp+14h] [rbp-84h]
int v57; // [rsp+18h] [rbp-80h]
int v58; // [rsp+1Ch] [rbp-7Ch]
int v59; // [rsp+20h] [rbp-78h]
int v60; // [rsp+28h] [rbp-70h]
int v61; // [rsp+2Ch] [rbp-6Ch]
int v62; // [rsp+30h] [rbp-68h]
int v63; // [rsp+34h] [rbp-64h]
int v64; // [rsp+38h] [rbp-60h]
int v65; // [rsp+3Ch] [rbp-5Ch]
int v66; // [rsp+40h] [rbp-58h]
int v67; // [rsp+44h] [rbp-54h]
unsigned int v68; // [rsp+48h] [rbp-50h]
int v69; // [rsp+4Ch] [rbp-4Ch]
int v70; // [rsp+50h] [rbp-48h]
int v71; // [rsp+54h] [rbp-44h]
int v72; // [rsp+58h] [rbp-40h]
int v73; // [rsp+5Ch] [rbp-3Ch]
v56 = a1;
if ( a1 < a2 )
return 0;
if ( !a2 || a1 == a2 )
return 1;
v2 = a2;
v3 = 0;
do
{
v4 = v56;
v5 = --v56;
if ( v2 > v4 )
goto LABEL_60;
if ( v2 == v4 || (v64 = v5, v65 = v2 - 2, v2 == 1) )
{
++v3;
LABEL_60:
v46 = v56 == v2;
if ( v56 < v2 )
return v3;
continue;
}
v68 = v3;
v6 = 0;
v7 = v2;
while ( 2 )
{
v73 = v64;
v8 = v64 - 1;
v64 = v8;
if ( v8 < v65 )
goto LABEL_57;
if ( v8 == v65 || (v53 = v8, v66 = v7 - 3, !v65) )
{
++v6;
LABEL_57:
v45 = v7 == v73;
if ( v7 > v73 )
break;
goto LABEL_58;
}
v69 = v6;
v9 = 0;
v10 = v7;
while ( 2 )
{
v11 = --v53;
if ( v53 < v66 )
goto LABEL_54;
if ( v53 == v66 || (v67 = v10 - 4, v12 = 0, !v66) )
{
++v9;
LABEL_54:
v44 = v53 == v65;
if ( v53 < v65 )
break;
goto LABEL_55;
}
v70 = v9;
v13 = v10;
while ( 2 )
{
if ( --v11 < v67 )
goto LABEL_51;
if ( !v67 || (v54 = v11, v55 = v13 - 5, v14 = 0, v11 == v67) )
{
++v12;
LABEL_51:
v43 = v11 == v66;
if ( v11 < v66 )
break;
goto LABEL_52;
}
v71 = v11;
v72 = v12;
while ( 2 )
{
v15 = --v54;
if ( v54 < v55 )
goto LABEL_48;
if ( v54 == v55 || (v16 = v13 - 6, v17 = v13 - 7, v18 = 0, !v55) )
{
++v14;
LABEL_48:
v42 = v54 == v67;
if ( v54 < v67 )
break;
goto LABEL_49;
}
while ( 2 )
{
if ( --v15 < v16 )
goto LABEL_45;
if ( v15 == v16 || (v19 = v15, v20 = 0, v21 = v13 - 8, !v16) )
{
++v18;
LABEL_45:
v41 = v15 == v55;
if ( v15 < v55 )
break;
goto LABEL_46;
}
v22 = v15;
v23 = v17;
v24 = v18;
while ( 1 )
{
if ( --v19 < v23 )
goto LABEL_42;
if ( v19 != v23 )
{
v25 = v19;
v26 = 0;
if ( v23 )
break;
}
++v20;
LABEL_42:
v39 = v19 == v16;
if ( v19 < v16 )
goto LABEL_65;
LABEL_43:
if ( v39 )
{
v40 = v24;
v17 = v23;
v15 = v22;
v18 = v40 + v20 + 1;
goto LABEL_45;
}
}
v27 = v21;
v28 = v22;
v29 = v20;
v30 = v25;
v31 = v27;
while ( 1 )
{
if ( --v25 >= v31 )
{
if ( v25 == v31 || (v32 = v25, v33 = 0, !v31) )
{
++v26;
}
else
{
v57 = v26;
v34 = v30;
v58 = v23;
v35 = v24;
while ( 1 )
{
v63 = v13;
v62 = v14;
v61 = v16;
v60 = v29;
v59 = v32 - 1;
v32 = v59;
v33 += func0();
v29 = v60;
v16 = v61;
v14 = v62;
v13 = v63;
if ( v59 < v31 )
break;
if ( v59 == v31 )
{
v30 = v34;
v24 = v35;
v23 = v58;
v26 = v33 + v57 + 1;
goto LABEL_39;
}
}
v30 = v34;
v24 = v35;
v23 = v58;
v26 = v33 + v57;
}
}
LABEL_39:
if ( v25 < v23 )
break;
if ( v25 == v23 )
{
v36 = v30;
v37 = v31;
v38 = v29;
v22 = v28;
v21 = v37;
v19 = v36;
v20 = v38 + v26 + 1;
goto LABEL_42;
}
}
v49 = v30;
v50 = v31;
v22 = v28;
v51 = v29;
v19 = v49;
v21 = v50;
v20 = v26 + v51;
v39 = v49 == v16;
if ( v49 >= v16 )
goto LABEL_43;
LABEL_65:
v52 = v24;
v17 = v23;
v15 = v22;
v18 = v20 + v52;
v41 = v22 == v55;
if ( v22 >= v55 )
{
LABEL_46:
if ( v41 )
{
v14 += v18 + 1;
goto LABEL_48;
}
continue;
}
break;
}
v14 += v18;
v42 = v54 == v67;
if ( v54 >= v67 )
{
LABEL_49:
if ( v42 )
{
v11 = v71;
v12 = v72 + v14 + 1;
goto LABEL_51;
}
continue;
}
break;
}
v11 = v71;
v12 = v14 + v72;
v43 = v71 == v66;
if ( v71 >= v66 )
{
LABEL_52:
if ( v43 )
{
v10 = v13;
v9 = v70 + v12 + 1;
goto LABEL_54;
}
continue;
}
break;
}
v10 = v13;
v9 = v12 + v70;
v44 = v53 == v65;
if ( v53 >= v65 )
{
LABEL_55:
if ( v44 )
{
v7 = v10;
v6 = v69 + v9 + 1;
goto LABEL_57;
}
continue;
}
break;
}
v7 = v10;
v6 = v9 + v69;
v45 = v10 == v73;
if ( v10 <= v73 )
{
LABEL_58:
if ( v45 )
{
v2 = v7;
v3 = v6 + v68 + 1;
goto LABEL_60;
}
continue;
}
break;
}
v2 = v7;
v3 = v6 + v68;
v46 = v56 == v7;
if ( v56 < v7 )
return v3;
}
while ( !v46 );
return v3 + 1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RSP + 0x14],EDI
CMP EDI,ESI
JL 0x001016cc
MOV R11D,ESI
TEST ESI,ESI
JZ 0x001016d4
CMP EDI,ESI
JZ 0x001016d4
XOR R10D,R10D
MOV R9D,R11D
LEA ESI,[RSI + -0x9]
MOV R11D,R10D
LAB_0010127d:
MOV EDX,dword ptr [RSP + 0x14]
MOV EAX,EDX
SUB EDX,0x1
MOV dword ptr [RSP + 0x14],EDX
CMP R9D,EAX
JG 0x00101585
JZ 0x001016c3
CMP R9D,0x1
LEA ECX,[R9 + -0x2]
MOV dword ptr [RSP + 0x38],EDX
SETZ AL
MOV dword ptr [RSP + 0x3c],ECX
XOR R10D,R10D
TEST AL,AL
JNZ 0x001016c3
MOV dword ptr [RSP + 0x48],R11D
MOV R11D,R10D
MOV R10D,R9D
LAB_001012c2:
MOV EDI,dword ptr [RSP + 0x38]
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x5c],EDI
SUB EDI,0x1
MOV dword ptr [RSP + 0x38],EDI
CMP EDI,EAX
JL 0x00101564
JZ 0x001016ba
TEST EAX,EAX
LEA ECX,[R10 + -0x3]
MOV dword ptr [RSP + 0x8],EDI
SETZ AL
MOV dword ptr [RSP + 0x40],ECX
XOR R8D,R8D
TEST AL,AL
JNZ 0x001016ba
MOV dword ptr [RSP + 0x4c],R11D
MOV R11D,R8D
MOV R8D,R10D
LAB_0010130a:
SUB dword ptr [RSP + 0x8],0x1
MOV EAX,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x8]
CMP R9D,EAX
JL 0x00101540
JZ 0x001016b1
TEST EAX,EAX
LEA EDX,[R8 + -0x4]
SETZ AL
MOV dword ptr [RSP + 0x44],EDX
XOR R10D,R10D
TEST AL,AL
JNZ 0x001016b1
MOV dword ptr [RSP + 0x50],R11D
MOV R11D,R8D
LAB_00101347:
MOV EAX,dword ptr [RSP + 0x44]
SUB R9D,0x1
CMP R9D,EAX
JL 0x00101522
TEST EAX,EAX
JZ 0x001016a8
CMP R9D,EAX
LEA ECX,[R11 + -0x5]
MOV dword ptr [RSP + 0xc],R9D
SETZ AL
MOV dword ptr [RSP + 0x10],ECX
XOR R8D,R8D
TEST AL,AL
JNZ 0x001016a8
MOV dword ptr [RSP + 0x54],R9D
MOV dword ptr [RSP + 0x58],R10D
LAB_00101388:
SUB dword ptr [RSP + 0xc],0x1
MOV EAX,dword ptr [RSP + 0x10]
MOV R14D,dword ptr [RSP + 0xc]
CMP R14D,EAX
JL 0x001014ff
JZ 0x0010168e
TEST EAX,EAX
LEA R9D,[R11 + -0x6]
LEA ECX,[R11 + -0x7]
SETZ AL
XOR R12D,R12D
TEST AL,AL
JNZ 0x0010168e
LAB_001013bd:
SUB R14D,0x1
CMP R14D,R9D
JL 0x001014e9
JZ 0x00101668
MOV R13D,R14D
XOR EBX,EBX
LEA R10D,[R11 + -0x8]
TEST R9D,R9D
JZ 0x00101668
MOV EDX,R14D
MOV R14D,ECX
MOV ECX,R12D
LAB_001013eb:
SUB R13D,0x1
CMP R13D,R14D
JL 0x001014cc
JZ 0x00101660
MOV R12D,R13D
XOR EBP,EBP
TEST R14D,R14D
JZ 0x00101660
MOV EAX,R10D
MOV R13D,EDX
MOV R10D,EBX
MOV EDX,R12D
MOV EBX,EAX
LAB_0010141a:
SUB R12D,0x1
CMP R12D,EBX
JL 0x001014a9
JZ 0x001016a0
MOV EDI,R12D
XOR R15D,R15D
TEST EBX,EBX
JZ 0x001016a0
MOV dword ptr [RSP + 0x18],EBP
MOV EBP,EDX
MOV dword ptr [RSP + 0x1c],R14D
MOV R14D,ECX
LAB_00101449:
SUB EDI,0x1
MOV dword ptr [RSP + 0x34],R11D
MOV dword ptr [RSP + 0x30],R8D
MOV dword ptr [RSP + 0x2c],R9D
MOV dword ptr [RSP + 0x28],R10D
MOV dword ptr [RSP + 0x24],ESI
MOV dword ptr [RSP + 0x20],EDI
CALL 0x00101240
MOV EDI,dword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x24]
ADD R15D,EAX
MOV R10D,dword ptr [RSP + 0x28]
MOV R9D,dword ptr [RSP + 0x2c]
CMP EDI,EBX
MOV R8D,dword ptr [RSP + 0x30]
MOV R11D,dword ptr [RSP + 0x34]
JL 0x00101678
JNZ 0x00101449
MOV EDX,EBP
MOV EBP,dword ptr [RSP + 0x18]
MOV ECX,R14D
MOV R14D,dword ptr [RSP + 0x1c]
LEA EBP,[R15 + RBP*0x1 + 0x1]
LAB_001014a9:
CMP R12D,R14D
JL 0x001015b0
JNZ 0x0010141a
MOV EDI,EDX
MOV EAX,EBX
MOV EBX,R10D
MOV EDX,R13D
MOV R10D,EAX
MOV R13D,EDI
LEA EBX,[RBX + RBP*0x1 + 0x1]
LAB_001014cc:
CMP R13D,R9D
JL 0x001015cb
LAB_001014d5:
JNZ 0x001013eb
MOV R12D,ECX
MOV ECX,R14D
MOV R14D,EDX
LEA R12D,[R12 + RBX*0x1 + 0x1]
LAB_001014e9:
CMP R14D,dword ptr [RSP + 0x10]
JL 0x001015e2
LAB_001014f4:
JNZ 0x001013bd
LEA R8D,[R12 + R8*0x1 + 0x1]
LAB_001014ff:
MOV EDX,dword ptr [RSP + 0x44]
CMP dword ptr [RSP + 0xc],EDX
JL 0x001015f3
LAB_0010150d:
JNZ 0x00101388
MOV R10D,dword ptr [RSP + 0x58]
MOV R9D,dword ptr [RSP + 0x54]
LEA R10D,[R10 + R8*0x1 + 0x1]
LAB_00101522:
CMP R9D,dword ptr [RSP + 0x40]
JL 0x0010160b
LAB_0010152d:
JNZ 0x00101347
MOV R8D,R11D
MOV R11D,dword ptr [RSP + 0x50]
LEA R11D,[R11 + R10*0x1 + 0x1]
LAB_00101540:
MOV ECX,dword ptr [RSP + 0x3c]
CMP dword ptr [RSP + 0x8],ECX
JL 0x00101624
LAB_0010154e:
JNZ 0x0010130a
MOV R10D,R8D
MOV R8D,R11D
MOV R11D,dword ptr [RSP + 0x4c]
LEA R11D,[R11 + R8*0x1 + 0x1]
LAB_00101564:
CMP R10D,dword ptr [RSP + 0x5c]
JG 0x0010163d
LAB_0010156f:
JNZ 0x001012c2
MOV R9D,R10D
MOV R10D,R11D
MOV R11D,dword ptr [RSP + 0x48]
LEA R11D,[R10 + R11*0x1 + 0x1]
LAB_00101585:
CMP dword ptr [RSP + 0x14],R9D
JL 0x00101656
LAB_00101590:
JNZ 0x0010127d
MOV R10D,R11D
ADD R10D,0x1
LAB_0010159d:
ADD RSP,0x68
MOV EAX,R10D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b0:
MOV EDI,EDX
MOV EAX,EBX
MOV EDX,R13D
MOV EBX,R10D
MOV R13D,EDI
MOV R10D,EAX
ADD EBX,EBP
CMP R13D,R9D
JGE 0x001014d5
LAB_001015cb:
MOV R12D,ECX
MOV ECX,R14D
MOV R14D,EDX
ADD R12D,EBX
CMP R14D,dword ptr [RSP + 0x10]
JGE 0x001014f4
LAB_001015e2:
MOV EDX,dword ptr [RSP + 0x44]
ADD R8D,R12D
CMP dword ptr [RSP + 0xc],EDX
JGE 0x0010150d
LAB_001015f3:
MOV R10D,dword ptr [RSP + 0x58]
MOV R9D,dword ptr [RSP + 0x54]
ADD R10D,R8D
CMP R9D,dword ptr [RSP + 0x40]
JGE 0x0010152d
LAB_0010160b:
MOV R8D,R11D
MOV R11D,dword ptr [RSP + 0x50]
MOV ECX,dword ptr [RSP + 0x3c]
ADD R11D,R10D
CMP dword ptr [RSP + 0x8],ECX
JGE 0x0010154e
LAB_00101624:
MOV R10D,R8D
MOV R8D,R11D
MOV R11D,dword ptr [RSP + 0x4c]
ADD R11D,R8D
CMP R10D,dword ptr [RSP + 0x5c]
JLE 0x0010156f
LAB_0010163d:
MOV R9D,R10D
MOV R10D,R11D
MOV R11D,dword ptr [RSP + 0x48]
ADD R11D,R10D
CMP dword ptr [RSP + 0x14],R9D
JGE 0x00101590
LAB_00101656:
MOV R10D,R11D
JMP 0x0010159d
LAB_00101660:
ADD EBX,0x1
JMP 0x001014cc
LAB_00101668:
ADD R12D,0x1
JMP 0x001014e9
LAB_00101678:
MOV EDX,EBP
MOV EBP,dword ptr [RSP + 0x18]
MOV ECX,R14D
MOV R14D,dword ptr [RSP + 0x1c]
ADD EBP,R15D
JMP 0x001014a9
LAB_0010168e:
ADD R8D,0x1
JMP 0x001014ff
LAB_001016a0:
ADD EBP,0x1
JMP 0x001014a9
LAB_001016a8:
ADD R10D,0x1
JMP 0x00101522
LAB_001016b1:
ADD R11D,0x1
JMP 0x00101540
LAB_001016ba:
ADD R11D,0x1
JMP 0x00101564
LAB_001016c3:
ADD R11D,0x1
JMP 0x00101585
LAB_001016cc:
XOR R10D,R10D
JMP 0x0010159d
LAB_001016d4:
MOV R10D,0x1
JMP 0x0010159d | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int iVar21;
int iVar22;
int iVar23;
int iVar24;
bool bVar25;
int local_90;
int local_8c;
int local_84;
int local_60;
if (param_1 < param_2) {
iVar18 = 0;
}
else if ((param_2 == 0) || (param_1 == param_2)) {
iVar18 = 1;
}
else {
iVar18 = 0;
local_84 = param_1;
do {
iVar6 = local_84 + -1;
if (param_2 == local_84 || param_2 < local_84) {
if (param_2 != local_84) {
iVar2 = param_2 + -2;
iVar15 = 0;
local_60 = iVar6;
if (param_2 != 1) {
do {
iVar10 = local_60 + -1;
if (iVar2 <= iVar10) {
if ((iVar10 == iVar2) || (iVar3 = param_2 + -3, param_2 == 2)) {
iVar15 = iVar15 + 1;
}
else {
iVar19 = 0;
local_90 = iVar10;
do {
local_90 = local_90 + -1;
if (iVar3 <= local_90) {
if (local_90 != iVar3) {
iVar7 = param_2 + -4;
iVar17 = 0;
iVar13 = local_90;
if (param_2 != 3) {
do {
iVar13 = iVar13 + -1;
if (iVar7 <= iVar13) {
if (param_2 != 4) {
iVar4 = param_2 + -5;
iVar12 = 0;
local_8c = iVar13;
if (iVar13 != iVar7) {
do {
local_8c = local_8c + -1;
if (iVar4 <= local_8c) {
if (local_8c != iVar4) {
iVar14 = param_2 + -6;
iVar5 = param_2 + -7;
iVar21 = 0;
iVar23 = local_8c;
if (param_2 != 5) {
do {
iVar23 = iVar23 + -1;
if (iVar14 <= iVar23) {
if (iVar23 != iVar14) {
iVar8 = 0;
iVar16 = param_2 + -8;
iVar22 = iVar23;
if (param_2 != 6) {
do {
iVar22 = iVar22 + -1;
if (iVar5 <= iVar22) {
if ((iVar22 == iVar5) ||
(iVar9 = 0, iVar20 = iVar22, param_2 == 7))
{
iVar8 = iVar8 + 1;
}
else {
do {
iVar20 = iVar20 + -1;
if (iVar16 <= iVar20) {
if ((iVar20 == iVar16) ||
(iVar24 = 0, iVar11 = iVar20,
param_2 == 8)) {
iVar9 = iVar9 + 1;
}
else {
do {
iVar11 = iVar11 + -1;
iVar1 = func0();
iVar24 = iVar24 + iVar1;
if (iVar11 < iVar16) {
iVar9 = iVar9 + iVar24;
goto LAB_001014a9;
}
} while (iVar11 != iVar16);
iVar9 = iVar24 + 1 + iVar9;
}
}
LAB_001014a9:
if (iVar20 < iVar5) {
iVar8 = iVar8 + iVar9;
goto joined_r0x001015c5;
}
} while (iVar20 != iVar5);
iVar8 = iVar8 + 1 + iVar9;
}
}
joined_r0x001015c5:
if (iVar22 < iVar14) {
iVar21 = iVar21 + iVar8;
goto joined_r0x001014ee;
}
} while (iVar22 != iVar14);
iVar21 = iVar21 + 1 + iVar8;
goto joined_r0x001014ee;
}
}
iVar21 = iVar21 + 1;
}
joined_r0x001014ee:
if (iVar23 < iVar4) {
iVar12 = iVar12 + iVar21;
goto joined_r0x001015ed;
}
} while (iVar23 != iVar4);
iVar12 = iVar21 + 1 + iVar12;
goto joined_r0x001015ed;
}
}
iVar12 = iVar12 + 1;
}
joined_r0x001015ed:
if (local_8c < iVar7) {
iVar17 = iVar17 + iVar12;
goto joined_r0x00101605;
}
} while (local_8c != iVar7);
iVar17 = iVar17 + 1 + iVar12;
goto joined_r0x00101605;
}
}
iVar17 = iVar17 + 1;
}
joined_r0x00101605:
if (iVar13 < iVar3) {
iVar19 = iVar19 + iVar17;
goto joined_r0x0010161e;
}
} while (iVar13 != iVar3);
iVar19 = iVar19 + 1 + iVar17;
goto joined_r0x0010161e;
}
}
iVar19 = iVar19 + 1;
}
joined_r0x0010161e:
if (local_90 < iVar2) {
iVar15 = iVar15 + iVar19;
goto joined_r0x00101637;
}
} while (local_90 != iVar2);
iVar15 = iVar15 + 1 + iVar19;
}
}
joined_r0x00101637:
if (local_60 < param_2) {
iVar18 = iVar18 + iVar15;
goto joined_r0x00101650;
}
bVar25 = param_2 != local_60;
local_60 = iVar10;
} while (bVar25);
iVar18 = iVar15 + 1 + iVar18;
goto joined_r0x00101650;
}
}
iVar18 = iVar18 + 1;
}
joined_r0x00101650:
if (iVar6 < param_2) {
return iVar18;
}
local_84 = iVar6;
} while (iVar6 != param_2);
iVar18 = iVar18 + 1;
}
return iVar18;
} |
4,007 | func0 | #include <assert.h>
| int func0(int n, int k) {
if (k > n)
return 0;
if (k == 0 || k == n)
return 1;
return func0(n-1, k-1) + func0(n-1, k);
}
| int main() {
assert(func0(5, 2) == 10);
assert(func0(4, 3) == 4);
assert(func0(3, 2) == 3);
assert(func0(14, 6) == 3003);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
cmp %esi,%edi
jl 1290 <func0+0x50>
je 12a8 <func0+0x68>
mov %esi,%ebp
test %esi,%esi
je 12a8 <func0+0x68>
mov %edi,%ebx
lea -0x1(%rsi),%r13d
xor %r12d,%r12d
sub $0x1,%ebx
mov %r13d,%esi
mov %ebx,%edi
callq 1240 <func0>
add %eax,%r12d
cmp %ebp,%ebx
jl 127d <func0+0x3d>
jne 1263 <func0+0x23>
add $0x1,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %r12d,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
mov $0x1,%r12d
jmp 127d <func0+0x3d>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
cmp edi, esi
jl loc_16CB
mov r9d, esi
test esi, esi
jz loc_16D2
cmp edi, esi
jz loc_16D2
lea eax, [rsi-9]
xor ebp, ebp
mov ebx, edi
mov [rsp+98h+var_6C], eax
loc_1278:
mov eax, ebx
sub ebx, 1
cmp r9d, eax
jg loc_158C
jz loc_16C3
cmp r9d, 1
lea edx, [r9-2]
setz cl
xor r14d, r14d
test cl, cl
jnz loc_16C3
mov [rsp+98h+var_68], ebp
mov r13d, edx
mov ebp, ebx
loc_12AB:
mov ecx, ebp
sub ebp, 1
cmp ebp, r13d
jl loc_1574
jz loc_16BA
test r13d, r13d
lea eax, [r9-3]
mov r15d, ebp
setz sil
xor r12d, r12d
test sil, sil
jnz loc_16BA
mov [rsp+98h+var_64], ecx
mov [rsp+98h+var_5C], ebx
mov [rsp+98h+var_60], r14d
mov r14d, eax
loc_12E9:
sub r15d, 1
cmp r15d, r14d
jl loc_1553
test r14d, r14d
jz loc_16B1
cmp r15d, r14d
lea ecx, [r9-4]
setz r10b
xor ebx, ebx
test r10b, r10b
jnz loc_16B1
mov [rsp+98h+var_50], r12d
mov eax, r9d
mov [rsp+98h+var_58], ebp
mov ebp, r15d
mov [rsp+98h+var_54], r15d
mov r15d, r14d
mov [rsp+98h+var_4C], r13d
mov r13d, ecx
loc_1334:
sub ebp, 1
cmp ebp, r13d
jl loc_1526
test r13d, r13d
jz loc_16A9
cmp ebp, r13d
lea ecx, [rax-5]
setz r14b
xor r12d, r12d
test r14b, r14b
jnz loc_16A9
mov [rsp+98h+var_48], ebp
mov edx, eax
mov [rsp+98h+var_44], ebx
mov [rsp+98h+var_40], r15d
mov [rsp+98h+var_88], r13d
mov r13d, r12d
loc_1376:
sub ebp, 1
cmp ebp, ecx
jl loc_14F8
test ecx, ecx
jz loc_1694
cmp ebp, ecx
lea r12d, [rdx-6]
lea eax, [rdx-7]
setz sil
xor r14d, r14d
test sil, sil
jnz loc_1694
mov [rsp+98h+var_3C], ebp
mov edi, r13d
mov r13d, r12d
loc_13AC:
sub ebp, 1
cmp ebp, r13d
jl loc_14E1
test r13d, r13d
jz loc_166A
mov r12d, ebp
xor ebx, ebx
lea r9d, [rdx-8]
cmp ebp, r13d
jz loc_166A
mov esi, ebp
mov ebp, r13d
loc_13D8:
sub r12d, 1
cmp r12d, eax
jl loc_14C8
test eax, eax
jz loc_1662
xor r15d, r15d
cmp r12d, eax
jz loc_1662
mov [rsp+98h+var_8C], r14d
mov r11d, ebp
mov r10d, ebx
mov ebp, r12d
mov [rsp+98h+var_90], eax
mov eax, r12d
mov r12d, r9d
loc_1411:
sub ebp, 1
cmp ebp, r12d
jl loc_149F
test r12d, r12d
jz loc_16A0
mov r13d, ebp
xor ebx, ebx
cmp ebp, r12d
jz loc_16A0
mov [rsp+98h+var_84], r15d
mov r14d, ebp
mov r15d, r10d
mov ebp, eax
mov [rsp+98h+var_80], edi
mov edi, r13d
mov r13d, esi
loc_144B:
mov esi, [rsp+98h+var_6C]
sub edi, 1
mov [rsp+98h+var_70], edx
mov [rsp+98h+var_74], r11d
mov [rsp+98h+var_78], ecx
mov [rsp+98h+var_7C], edi
call func0
mov edi, [rsp+98h+var_7C]
mov ecx, [rsp+98h+var_78]
add ebx, eax
mov r11d, [rsp+98h+var_74]
mov edx, [rsp+98h+var_70]
cmp edi, r12d
jl loc_1678
jnz short loc_144B
mov r10d, r15d
mov r15d, [rsp+98h+var_84]
mov edi, [rsp+98h+var_80]
mov eax, ebp
mov esi, r13d
mov ebp, r14d
lea r15d, [rbx+r15+1]
loc_149F:
mov ebx, [rsp+98h+var_90]
cmp ebp, ebx
jl loc_15B0
jnz loc_1411
mov r9d, r12d
mov r14d, [rsp+98h+var_8C]
mov r12d, eax
mov eax, [rsp+98h+var_90]
mov ebp, r11d
lea ebx, [r10+r15+1]
loc_14C8:
cmp r12d, ebp
jl loc_15D1
loc_14D1:
jnz loc_13D8
mov r13d, ebp
lea r14d, [r14+rbx+1]
mov ebp, esi
loc_14E1:
cmp ebp, ecx
jl loc_15E1
loc_14E9:
jnz loc_13AC
mov ebp, [rsp+98h+var_3C]
lea r13d, [r14+rdi+1]
loc_14F8:
mov eax, [rsp+98h+var_88]
cmp ebp, eax
jl loc_15F7
loc_1504:
jnz loc_1376
mov ebx, [rsp+98h+var_44]
mov r12d, r13d
mov ebp, [rsp+98h+var_48]
mov eax, edx
mov r15d, [rsp+98h+var_40]
mov r13d, [rsp+98h+var_88]
lea ebx, [rbx+r12+1]
loc_1526:
cmp ebp, r15d
jl loc_1618
loc_152F:
jnz loc_1334
mov r12d, [rsp+98h+var_50]
mov r14d, r15d
mov ebp, [rsp+98h+var_58]
mov r9d, eax
mov r13d, [rsp+98h+var_4C]
mov r15d, [rsp+98h+var_54]
lea r12d, [r12+rbx+1]
loc_1553:
cmp r15d, r13d
jl loc_163D
loc_155C:
jnz loc_12E9
mov r14d, [rsp+98h+var_60]
mov ecx, [rsp+98h+var_64]
mov ebx, [rsp+98h+var_5C]
lea r14d, [r14+r12+1]
loc_1574:
cmp r9d, ecx
jg loc_1656
loc_157D:
jnz loc_12AB
mov ebp, [rsp+98h+var_68]
lea ebp, [r14+rbp+1]
loc_158C:
cmp ebx, r9d
jl short loc_159A
jnz loc_1278
add ebp, 1
loc_159A:
add rsp, 68h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B0:
mov ebx, r10d
mov r9d, r12d
mov ebp, r11d
mov r12d, eax
mov r14d, [rsp+98h+var_8C]
mov eax, [rsp+98h+var_90]
add ebx, r15d
cmp r12d, ebp
jge loc_14D1
loc_15D1:
mov r13d, ebp
mov ebp, esi
add r14d, ebx
cmp ebp, ecx
jge loc_14E9
loc_15E1:
mov ebp, [rsp+98h+var_3C]
mov eax, [rsp+98h+var_88]
mov r13d, edi
add r13d, r14d
cmp ebp, eax
jge loc_1504
loc_15F7:
mov ebx, [rsp+98h+var_44]
mov ebp, [rsp+98h+var_48]
mov r12d, r13d
mov r13d, eax
mov r15d, [rsp+98h+var_40]
mov eax, edx
add ebx, r12d
cmp ebp, r15d
jge loc_152F
loc_1618:
mov r12d, [rsp+98h+var_50]
mov r14d, r15d
mov r13d, [rsp+98h+var_4C]
mov r9d, eax
mov r15d, [rsp+98h+var_54]
mov ebp, [rsp+98h+var_58]
add r12d, ebx
cmp r15d, r13d
jge loc_155C
loc_163D:
mov r14d, [rsp+98h+var_60]
mov ecx, [rsp+98h+var_64]
mov ebx, [rsp+98h+var_5C]
add r14d, r12d
cmp r9d, ecx
jle loc_157D
loc_1656:
mov ebp, [rsp+98h+var_68]
add ebp, r14d
jmp loc_158C
loc_1662:
add ebx, 1
jmp loc_14C8
loc_166A:
add r14d, 1
jmp loc_14E1
loc_1678:
mov r10d, r15d
mov r15d, [rsp+98h+var_84]
mov eax, ebp
mov edi, [rsp+98h+var_80]
mov esi, r13d
mov ebp, r14d
add r15d, ebx
jmp loc_149F
loc_1694:
add r13d, 1
jmp loc_14F8
loc_16A0:
add r15d, 1
jmp loc_149F
loc_16A9:
add ebx, 1
jmp loc_1526
loc_16B1:
add r12d, 1
jmp loc_1553
loc_16BA:
add r14d, 1
jmp loc_1574
loc_16C3:
add ebp, 1
jmp loc_158C
loc_16CB:
xor ebp, ebp
jmp loc_159A
loc_16D2:
mov ebp, 1
jmp loc_159A | long long func0(int a1, int a2)
{
int v2; // r9d
unsigned int v3; // ebp
int v4; // ebx
int v5; // eax
int v6; // r14d
int v7; // r13d
int v8; // ebp
int v9; // ecx
int v10; // r15d
int v11; // r12d
int v12; // r14d
int v13; // ebx
int v14; // eax
int v15; // ebp
int v16; // r15d
int v17; // r13d
int v18; // ecx
int v19; // edx
int v20; // r13d
int v21; // eax
int v22; // r14d
int v23; // edi
int v24; // r13d
int v25; // r12d
int v26; // ebx
int v27; // r9d
int v28; // esi
int v29; // ebp
int v30; // r15d
int v31; // r11d
int v32; // r10d
int v33; // ebp
int v34; // eax
int v35; // r12d
int v36; // r13d
int v37; // ebx
int v38; // r14d
int v39; // r15d
int v40; // ebp
long long v41; // rdi
int v42; // eax
bool v43; // zf
bool v44; // zf
int v45; // eax
bool v46; // zf
int v47; // r12d
bool v48; // zf
bool v49; // zf
bool v50; // zf
int v52; // r12d
int v53; // [rsp+8h] [rbp-90h]
int v54; // [rsp+Ch] [rbp-8Ch]
int v55; // [rsp+10h] [rbp-88h]
int v56; // [rsp+14h] [rbp-84h]
int v57; // [rsp+18h] [rbp-80h]
int v58; // [rsp+20h] [rbp-78h]
int v59; // [rsp+24h] [rbp-74h]
int v60; // [rsp+28h] [rbp-70h]
unsigned int v61; // [rsp+2Ch] [rbp-6Ch]
unsigned int v62; // [rsp+30h] [rbp-68h]
int v63; // [rsp+34h] [rbp-64h]
int v64; // [rsp+38h] [rbp-60h]
int v65; // [rsp+3Ch] [rbp-5Ch]
int v66; // [rsp+40h] [rbp-58h]
int v67; // [rsp+44h] [rbp-54h]
int v68; // [rsp+48h] [rbp-50h]
int v69; // [rsp+4Ch] [rbp-4Ch]
int v70; // [rsp+50h] [rbp-48h]
int v71; // [rsp+54h] [rbp-44h]
int v72; // [rsp+58h] [rbp-40h]
int v73; // [rsp+5Ch] [rbp-3Ch]
if ( a1 < a2 )
return 0;
v2 = a2;
if ( !a2 || a1 == a2 )
return 1;
v3 = 0;
v4 = a1;
v61 = a2 - 9;
do
{
v5 = v4--;
if ( v2 > v5 )
goto LABEL_61;
if ( v2 != v5 )
{
v6 = 0;
if ( v2 != 1 )
{
v62 = v3;
v7 = v2 - 2;
v8 = v4;
while ( 1 )
{
v9 = v8--;
if ( v8 < v7 )
goto LABEL_58;
if ( v8 == v7 || (v10 = v8, v11 = 0, !v7) )
{
++v6;
LABEL_58:
v50 = v2 == v9;
if ( v2 > v9 )
goto LABEL_71;
goto LABEL_59;
}
v63 = v9;
v65 = v4;
v64 = v6;
v12 = v2 - 3;
while ( 1 )
{
if ( --v10 < v12 )
goto LABEL_55;
if ( !v12 || (v13 = 0, v10 == v12) )
{
++v11;
LABEL_55:
v49 = v10 == v7;
if ( v10 < v7 )
break;
goto LABEL_56;
}
v68 = v11;
v14 = v2;
v66 = v8;
v15 = v10;
v67 = v10;
v16 = v12;
v69 = v7;
v17 = v2 - 4;
while ( 1 )
{
if ( --v15 < v17 )
goto LABEL_52;
if ( !v17 || (v18 = v14 - 5, v15 == v17) )
{
++v13;
LABEL_52:
v48 = v15 == v16;
if ( v15 < v16 )
break;
goto LABEL_53;
}
v70 = v15;
v19 = v14;
v71 = v13;
v72 = v16;
v55 = v17;
v20 = 0;
while ( 1 )
{
if ( --v15 < v18 )
goto LABEL_49;
if ( !v18 || (v21 = v19 - 7, v22 = 0, v15 == v18) )
{
++v20;
LABEL_49:
v45 = v55;
v46 = v15 == v55;
if ( v15 < v55 )
break;
goto LABEL_50;
}
v73 = v15;
v23 = v20;
v24 = v19 - 6;
while ( 1 )
{
if ( --v15 < v24 )
goto LABEL_46;
if ( !v24 || (v25 = v15, v26 = 0, v27 = v19 - 8, v15 == v24) )
{
++v22;
LABEL_46:
v44 = v15 == v18;
if ( v15 < v18 )
break;
goto LABEL_47;
}
v28 = v15;
v29 = v24;
while ( 1 )
{
if ( --v25 < v21 )
goto LABEL_43;
if ( v21 )
{
v30 = 0;
if ( v25 != v21 )
break;
}
++v26;
LABEL_43:
v43 = v25 == v29;
if ( v25 < v29 )
goto LABEL_66;
LABEL_44:
if ( v43 )
{
v24 = v29;
v22 += v26 + 1;
v15 = v28;
goto LABEL_46;
}
}
v54 = v22;
v31 = v29;
v32 = v26;
v33 = v25;
v53 = v21;
v34 = v25;
v35 = v27;
while ( 1 )
{
if ( --v33 >= v35 )
{
if ( !v35 || (v36 = v33, v37 = 0, v33 == v35) )
{
++v30;
}
else
{
v56 = v30;
v38 = v33;
v39 = v32;
v40 = v34;
v57 = v23;
LODWORD(v41) = v36;
while ( 1 )
{
v41 = (unsigned int)(v41 - 1);
v60 = v19;
v59 = v31;
v58 = v18;
v42 = func0(v41, v61);
v18 = v58;
v37 += v42;
v31 = v59;
v19 = v60;
if ( (int)v41 < v35 )
break;
if ( (_DWORD)v41 == v35 )
{
v32 = v39;
v23 = v57;
v34 = v40;
v33 = v38;
v30 = v37 + v56 + 1;
goto LABEL_40;
}
}
v32 = v39;
v34 = v40;
v23 = v57;
v33 = v38;
v30 = v37 + v56;
}
}
LABEL_40:
if ( v33 < v53 )
break;
if ( v33 == v53 )
{
v27 = v35;
v22 = v54;
v25 = v34;
v21 = v53;
v29 = v31;
v26 = v32 + v30 + 1;
goto LABEL_43;
}
}
v27 = v35;
v29 = v31;
v25 = v34;
v22 = v54;
v21 = v53;
v26 = v30 + v32;
v43 = v25 == v31;
if ( v25 >= v31 )
goto LABEL_44;
LABEL_66:
v24 = v29;
v15 = v28;
v22 += v26;
v44 = v28 == v18;
if ( v28 < v18 )
break;
LABEL_47:
if ( v44 )
{
v15 = v73;
v20 = v22 + v23 + 1;
goto LABEL_49;
}
}
v15 = v73;
v45 = v55;
v20 = v22 + v23;
v46 = v73 == v55;
if ( v73 < v55 )
break;
LABEL_50:
if ( v46 )
{
v47 = v20;
v15 = v70;
v14 = v19;
v16 = v72;
v17 = v55;
v13 = v71 + v47 + 1;
goto LABEL_52;
}
}
v15 = v70;
v52 = v20;
v17 = v45;
v16 = v72;
v14 = v19;
v13 = v52 + v71;
v48 = v70 == v72;
if ( v70 < v72 )
break;
LABEL_53:
if ( v48 )
{
v12 = v16;
v8 = v66;
v2 = v14;
v7 = v69;
v10 = v67;
v11 = v68 + v13 + 1;
goto LABEL_55;
}
}
v12 = v16;
v7 = v69;
v2 = v14;
v10 = v67;
v8 = v66;
v11 = v13 + v68;
v49 = v67 == v69;
if ( v67 < v69 )
break;
LABEL_56:
if ( v49 )
{
v9 = v63;
v4 = v65;
v6 = v64 + v11 + 1;
goto LABEL_58;
}
}
v4 = v65;
v6 = v11 + v64;
v50 = v2 == v63;
if ( v2 > v63 )
{
LABEL_71:
v3 = v6 + v62;
goto LABEL_61;
}
LABEL_59:
if ( v50 )
{
v3 = v6 + v62 + 1;
goto LABEL_61;
}
}
}
}
++v3;
LABEL_61:
if ( v4 < v2 )
return v3;
}
while ( v4 != v2 );
return ++v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
CMP EDI,ESI
JL 0x001016cb
MOV R9D,ESI
TEST ESI,ESI
JZ 0x001016d2
CMP EDI,ESI
JZ 0x001016d2
LEA EAX,[RSI + -0x9]
XOR EBP,EBP
MOV EBX,EDI
MOV dword ptr [RSP + 0x2c],EAX
LAB_00101278:
MOV EAX,EBX
SUB EBX,0x1
CMP R9D,EAX
JG 0x0010158c
JZ 0x001016c3
CMP R9D,0x1
LEA EDX,[R9 + -0x2]
SETZ CL
XOR R14D,R14D
TEST CL,CL
JNZ 0x001016c3
MOV dword ptr [RSP + 0x30],EBP
MOV R13D,EDX
MOV EBP,EBX
LAB_001012ab:
MOV ECX,EBP
SUB EBP,0x1
CMP EBP,R13D
JL 0x00101574
JZ 0x001016ba
TEST R13D,R13D
LEA EAX,[R9 + -0x3]
MOV R15D,EBP
SETZ SIL
XOR R12D,R12D
TEST SIL,SIL
JNZ 0x001016ba
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x3c],EBX
MOV dword ptr [RSP + 0x38],R14D
MOV R14D,EAX
LAB_001012e9:
SUB R15D,0x1
CMP R15D,R14D
JL 0x00101553
TEST R14D,R14D
JZ 0x001016b1
CMP R15D,R14D
LEA ECX,[R9 + -0x4]
SETZ R10B
XOR EBX,EBX
TEST R10B,R10B
JNZ 0x001016b1
MOV dword ptr [RSP + 0x48],R12D
MOV EAX,R9D
MOV dword ptr [RSP + 0x40],EBP
MOV EBP,R15D
MOV dword ptr [RSP + 0x44],R15D
MOV R15D,R14D
MOV dword ptr [RSP + 0x4c],R13D
MOV R13D,ECX
LAB_00101334:
SUB EBP,0x1
CMP EBP,R13D
JL 0x00101526
TEST R13D,R13D
JZ 0x001016a9
CMP EBP,R13D
LEA ECX,[RAX + -0x5]
SETZ R14B
XOR R12D,R12D
TEST R14B,R14B
JNZ 0x001016a9
MOV dword ptr [RSP + 0x50],EBP
MOV EDX,EAX
MOV dword ptr [RSP + 0x54],EBX
MOV dword ptr [RSP + 0x58],R15D
MOV dword ptr [RSP + 0x10],R13D
MOV R13D,R12D
LAB_00101376:
SUB EBP,0x1
CMP EBP,ECX
JL 0x001014f8
TEST ECX,ECX
JZ 0x00101694
CMP EBP,ECX
LEA R12D,[RDX + -0x6]
LEA EAX,[RDX + -0x7]
SETZ SIL
XOR R14D,R14D
TEST SIL,SIL
JNZ 0x00101694
MOV dword ptr [RSP + 0x5c],EBP
MOV EDI,R13D
MOV R13D,R12D
LAB_001013ac:
SUB EBP,0x1
CMP EBP,R13D
JL 0x001014e1
TEST R13D,R13D
JZ 0x0010166a
MOV R12D,EBP
XOR EBX,EBX
LEA R9D,[RDX + -0x8]
CMP EBP,R13D
JZ 0x0010166a
MOV ESI,EBP
MOV EBP,R13D
LAB_001013d8:
SUB R12D,0x1
CMP R12D,EAX
JL 0x001014c8
TEST EAX,EAX
JZ 0x00101662
XOR R15D,R15D
CMP R12D,EAX
JZ 0x00101662
MOV dword ptr [RSP + 0xc],R14D
MOV R11D,EBP
MOV R10D,EBX
MOV EBP,R12D
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,R12D
MOV R12D,R9D
LAB_00101411:
SUB EBP,0x1
CMP EBP,R12D
JL 0x0010149f
TEST R12D,R12D
JZ 0x001016a0
MOV R13D,EBP
XOR EBX,EBX
CMP EBP,R12D
JZ 0x001016a0
MOV dword ptr [RSP + 0x14],R15D
MOV R14D,EBP
MOV R15D,R10D
MOV EBP,EAX
MOV dword ptr [RSP + 0x18],EDI
MOV EDI,R13D
MOV R13D,ESI
LAB_0010144b:
MOV ESI,dword ptr [RSP + 0x2c]
SUB EDI,0x1
MOV dword ptr [RSP + 0x28],EDX
MOV dword ptr [RSP + 0x24],R11D
MOV dword ptr [RSP + 0x20],ECX
MOV dword ptr [RSP + 0x1c],EDI
CALL 0x00101240
MOV EDI,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x20]
ADD EBX,EAX
MOV R11D,dword ptr [RSP + 0x24]
MOV EDX,dword ptr [RSP + 0x28]
CMP EDI,R12D
JL 0x00101678
JNZ 0x0010144b
MOV R10D,R15D
MOV R15D,dword ptr [RSP + 0x14]
MOV EDI,dword ptr [RSP + 0x18]
MOV EAX,EBP
MOV ESI,R13D
MOV EBP,R14D
LEA R15D,[RBX + R15*0x1 + 0x1]
LAB_0010149f:
MOV EBX,dword ptr [RSP + 0x8]
CMP EBP,EBX
JL 0x001015b0
JNZ 0x00101411
MOV R9D,R12D
MOV R14D,dword ptr [RSP + 0xc]
MOV R12D,EAX
MOV EAX,dword ptr [RSP + 0x8]
MOV EBP,R11D
LEA EBX,[R10 + R15*0x1 + 0x1]
LAB_001014c8:
CMP R12D,EBP
JL 0x001015d1
LAB_001014d1:
JNZ 0x001013d8
MOV R13D,EBP
LEA R14D,[R14 + RBX*0x1 + 0x1]
MOV EBP,ESI
LAB_001014e1:
CMP EBP,ECX
JL 0x001015e1
LAB_001014e9:
JNZ 0x001013ac
MOV EBP,dword ptr [RSP + 0x5c]
LEA R13D,[R14 + RDI*0x1 + 0x1]
LAB_001014f8:
MOV EAX,dword ptr [RSP + 0x10]
CMP EBP,EAX
JL 0x001015f7
LAB_00101504:
JNZ 0x00101376
MOV EBX,dword ptr [RSP + 0x54]
MOV R12D,R13D
MOV EBP,dword ptr [RSP + 0x50]
MOV EAX,EDX
MOV R15D,dword ptr [RSP + 0x58]
MOV R13D,dword ptr [RSP + 0x10]
LEA EBX,[RBX + R12*0x1 + 0x1]
LAB_00101526:
CMP EBP,R15D
JL 0x00101618
LAB_0010152f:
JNZ 0x00101334
MOV R12D,dword ptr [RSP + 0x48]
MOV R14D,R15D
MOV EBP,dword ptr [RSP + 0x40]
MOV R9D,EAX
MOV R13D,dword ptr [RSP + 0x4c]
MOV R15D,dword ptr [RSP + 0x44]
LEA R12D,[R12 + RBX*0x1 + 0x1]
LAB_00101553:
CMP R15D,R13D
JL 0x0010163d
LAB_0010155c:
JNZ 0x001012e9
MOV R14D,dword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x34]
MOV EBX,dword ptr [RSP + 0x3c]
LEA R14D,[R14 + R12*0x1 + 0x1]
LAB_00101574:
CMP R9D,ECX
JG 0x00101656
LAB_0010157d:
JNZ 0x001012ab
MOV EBP,dword ptr [RSP + 0x30]
LEA EBP,[R14 + RBP*0x1 + 0x1]
LAB_0010158c:
CMP EBX,R9D
JL 0x0010159a
JNZ 0x00101278
ADD EBP,0x1
LAB_0010159a:
ADD RSP,0x68
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b0:
MOV EBX,R10D
MOV R9D,R12D
MOV EBP,R11D
MOV R12D,EAX
MOV R14D,dword ptr [RSP + 0xc]
MOV EAX,dword ptr [RSP + 0x8]
ADD EBX,R15D
CMP R12D,EBP
JGE 0x001014d1
LAB_001015d1:
MOV R13D,EBP
MOV EBP,ESI
ADD R14D,EBX
CMP EBP,ECX
JGE 0x001014e9
LAB_001015e1:
MOV EBP,dword ptr [RSP + 0x5c]
MOV EAX,dword ptr [RSP + 0x10]
MOV R13D,EDI
ADD R13D,R14D
CMP EBP,EAX
JGE 0x00101504
LAB_001015f7:
MOV EBX,dword ptr [RSP + 0x54]
MOV EBP,dword ptr [RSP + 0x50]
MOV R12D,R13D
MOV R13D,EAX
MOV R15D,dword ptr [RSP + 0x58]
MOV EAX,EDX
ADD EBX,R12D
CMP EBP,R15D
JGE 0x0010152f
LAB_00101618:
MOV R12D,dword ptr [RSP + 0x48]
MOV R14D,R15D
MOV R13D,dword ptr [RSP + 0x4c]
MOV R9D,EAX
MOV R15D,dword ptr [RSP + 0x44]
MOV EBP,dword ptr [RSP + 0x40]
ADD R12D,EBX
CMP R15D,R13D
JGE 0x0010155c
LAB_0010163d:
MOV R14D,dword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x34]
MOV EBX,dword ptr [RSP + 0x3c]
ADD R14D,R12D
CMP R9D,ECX
JLE 0x0010157d
LAB_00101656:
MOV EBP,dword ptr [RSP + 0x30]
ADD EBP,R14D
JMP 0x0010158c
LAB_00101662:
ADD EBX,0x1
JMP 0x001014c8
LAB_0010166a:
ADD R14D,0x1
JMP 0x001014e1
LAB_00101678:
MOV R10D,R15D
MOV R15D,dword ptr [RSP + 0x14]
MOV EAX,EBP
MOV EDI,dword ptr [RSP + 0x18]
MOV ESI,R13D
MOV EBP,R14D
ADD R15D,EBX
JMP 0x0010149f
LAB_00101694:
ADD R13D,0x1
JMP 0x001014f8
LAB_001016a0:
ADD R15D,0x1
JMP 0x0010149f
LAB_001016a9:
ADD EBX,0x1
JMP 0x00101526
LAB_001016b1:
ADD R12D,0x1
JMP 0x00101553
LAB_001016ba:
ADD R14D,0x1
JMP 0x00101574
LAB_001016c3:
ADD EBP,0x1
JMP 0x0010158c
LAB_001016cb:
XOR EBP,EBP
JMP 0x0010159a
LAB_001016d2:
MOV EBP,0x1
JMP 0x0010159a | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int iVar21;
int iVar22;
int iVar23;
int iVar24;
int iVar25;
int iVar26;
int iVar27;
bool bVar28;
if (param_1 < param_2) {
iVar17 = 0;
}
else if ((param_2 == 0) || (param_1 == param_2)) {
iVar17 = 1;
}
else {
iVar17 = 0;
do {
iVar7 = param_1 + -1;
if (param_2 == param_1 || param_2 < param_1) {
if (param_2 != param_1) {
iVar6 = param_2 + -2;
iVar25 = 0;
iVar11 = iVar7;
if (param_2 != 1) {
do {
iVar12 = iVar11 + -1;
if (iVar6 <= iVar12) {
if (iVar12 != iVar6) {
iVar1 = param_2 + -3;
iVar22 = 0;
iVar26 = iVar12;
if (param_2 != 2) {
do {
iVar26 = iVar26 + -1;
if (iVar1 <= iVar26) {
if (param_2 != 3) {
iVar4 = param_2 + -4;
iVar10 = 0;
iVar13 = iVar26;
if (iVar26 != iVar1) {
do {
iVar13 = iVar13 + -1;
if (iVar4 <= iVar13) {
if (param_2 != 4) {
iVar5 = param_2 + -5;
iVar23 = 0;
iVar14 = iVar13;
if (iVar13 != iVar4) {
do {
iVar14 = iVar14 + -1;
if (iVar5 <= iVar14) {
if (param_2 != 5) {
iVar20 = param_2 + -6;
iVar2 = param_2 + -7;
iVar24 = 0;
iVar15 = iVar14;
if (iVar14 != iVar5) {
do {
iVar15 = iVar15 + -1;
if (iVar20 <= iVar15) {
if (param_2 != 6) {
iVar9 = 0;
iVar19 = param_2 + -8;
iVar21 = iVar15;
if (iVar15 != iVar20) {
do {
iVar21 = iVar21 + -1;
if (iVar2 <= iVar21) {
if ((param_2 == 7) ||
(iVar27 = 0, iVar16 = iVar21,
iVar21 == iVar2)) {
iVar9 = iVar9 + 1;
}
else {
do {
iVar16 = iVar16 + -1;
if (iVar19 <= iVar16) {
if ((param_2 == 8) ||
(iVar8 = 0, iVar18 = iVar16,
iVar16 == iVar19)) {
iVar27 = iVar27 + 1;
}
else {
do {
iVar18 = iVar18 + -1;
iVar3 = func0(iVar18,param_2 + -9)
;
iVar8 = iVar8 + iVar3;
if (iVar18 < iVar19) {
iVar27 = iVar27 + iVar8;
goto LAB_0010149f;
}
} while (iVar18 != iVar19);
iVar27 = iVar8 + 1 + iVar27;
}
}
LAB_0010149f:
if (iVar16 < iVar2) {
iVar9 = iVar9 + iVar27;
goto joined_r0x001015cb;
}
} while (iVar16 != iVar2);
iVar9 = iVar9 + 1 + iVar27;
}
}
joined_r0x001015cb:
if (iVar21 < iVar20) {
iVar24 = iVar24 + iVar9;
goto joined_r0x001014e3;
}
} while (iVar21 != iVar20);
iVar24 = iVar24 + 1 + iVar9;
goto joined_r0x001014e3;
}
}
iVar24 = iVar24 + 1;
}
joined_r0x001014e3:
if (iVar15 < iVar5) {
iVar23 = iVar23 + iVar24;
goto joined_r0x001015f1;
}
} while (iVar15 != iVar5);
iVar23 = iVar24 + 1 + iVar23;
goto joined_r0x001015f1;
}
}
iVar23 = iVar23 + 1;
}
joined_r0x001015f1:
if (iVar14 < iVar4) {
iVar10 = iVar10 + iVar23;
goto joined_r0x00101612;
}
} while (iVar14 != iVar4);
iVar10 = iVar10 + 1 + iVar23;
goto joined_r0x00101612;
}
}
iVar10 = iVar10 + 1;
}
joined_r0x00101612:
if (iVar13 < iVar1) {
iVar22 = iVar22 + iVar10;
goto joined_r0x00101637;
}
} while (iVar13 != iVar1);
iVar22 = iVar22 + 1 + iVar10;
goto joined_r0x00101637;
}
}
iVar22 = iVar22 + 1;
}
joined_r0x00101637:
if (iVar26 < iVar6) {
iVar25 = iVar25 + iVar22;
goto joined_r0x00101650;
}
} while (iVar26 != iVar6);
iVar25 = iVar25 + 1 + iVar22;
goto joined_r0x00101650;
}
}
iVar25 = iVar25 + 1;
}
joined_r0x00101650:
if (iVar11 < param_2) {
iVar17 = iVar17 + iVar25;
goto LAB_0010158c;
}
bVar28 = param_2 != iVar11;
iVar11 = iVar12;
} while (bVar28);
iVar17 = iVar25 + 1 + iVar17;
goto LAB_0010158c;
}
}
iVar17 = iVar17 + 1;
}
LAB_0010158c:
if (iVar7 < param_2) {
return iVar17;
}
param_1 = iVar7;
} while (iVar7 != param_2);
iVar17 = iVar17 + 1;
}
return iVar17;
} |
4,008 | func0 |
#include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int array1[] = {1, 2, 3, 1, 2, 3, 1};
assert(func0(array1, 7) == 1);
int array2[] = {1, 2, 3, 2, 3, 1, 3};
assert(func0(array2, 7) == 3);
int array3[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
assert(func0(array3, 13) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11f7 <func0+0x8e>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c9 <func0+0x60>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11c5 <func0+0x5c>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1191 <func0+0x28>
mov -0x8(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11f3 <func0+0x8a>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 1204 <func0+0x9b>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0xffffffff,%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
jmp short loc_11F7
loc_1181:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C9
loc_1191:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11C5
add [rbp+var_8], 1
loc_11C5:
add [rbp+var_4], 1
loc_11C9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1191
mov eax, [rbp+var_8]
and eax, 1
test eax, eax
jz short loc_11F3
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp short loc_1204
loc_11F3:
add [rbp+var_C], 1
loc_11F7:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0FFFFFFFFh
loc_1204:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
char v4; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
v4 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
++v4;
}
if ( (v4 & 1) != 0 )
return *(unsigned int *)(4LL * i + a1);
}
return 0xFFFFFFFFLL;
} | 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
JMP 0x001011f7
LAB_00101181:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c9
LAB_00101191:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011c5
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101191
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011f3
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]
JMP 0x00101204
LAB_001011f3:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0xffffffff
LAB_00101204:
POP RBP
RET | int4 func0(long param_1,int param_2)
{
byte bVar1;
int local_14;
int local_c;
local_14 = 0;
while( true ) {
if (param_2 <= local_14) {
return 0xffffffff;
}
bVar1 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) == *(int *)(param_1 + (long)local_c * 4)) {
bVar1 = bVar1 + 1;
}
}
if ((bool)(bVar1 & 1)) break;
local_14 = local_14 + 1;
}
return *(int4 *)(param_1 + (long)local_14 * 4);
} |
4,009 | func0 |
#include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int array1[] = {1, 2, 3, 1, 2, 3, 1};
assert(func0(array1, 7) == 1);
int array2[] = {1, 2, 3, 2, 3, 1, 3};
assert(func0(array2, 7) == 3);
int array3[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
assert(func0(array3, 13) == 5);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c4 <func0+0x5b>
push %rbx
lea -0x1(%rsi),%r11d
mov %rdi,%rbx
lea 0x4(%rdi,%r11,4),%r8
mov $0x0,%r9d
jmp 1197 <func0+0x2e>
test $0x1,%dl
jne 11bb <func0+0x52>
lea 0x1(%r9),%rax
cmp %r11,%r9
je 11ca <func0+0x61>
mov %rax,%r9
mov %r9d,%r10d
mov (%rdi,%r9,4),%esi
mov %rbx,%rax
mov $0x0,%edx
cmp (%rax),%esi
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %r8,%rax
jne 11a6 <func0+0x3d>
jmp 1186 <func0+0x1d>
movslq %r10d,%r10
mov (%rdi,%r10,4),%eax
pop %rbx
retq
mov $0xffffffff,%eax
retq
mov $0xffffffff,%eax
jmp 11c2 <func0+0x59>
| func0:
endbr64
test esi, esi
jle short loc_11BE
mov r11d, esi
lea eax, [rsi-1]
lea r8, [rdi+rax*4+4]
mov r9d, 0
jmp short loc_1192
loc_1184:
test dl, 1
jnz short loc_11B6
add r9, 1
cmp r9, r11
jz short loc_11C4
loc_1192:
mov r10d, r9d
mov esi, [rdi+r9*4]
mov rax, rdi
mov edx, 0
loc_11A1:
cmp esi, [rax]
setz cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, r8
jnz short loc_11A1
jmp short loc_1184
loc_11B6:
movsxd r10, r10d
mov eax, [rdi+r10*4]
retn
loc_11BE:
mov eax, 0FFFFFFFFh
retn
loc_11C4:
mov eax, 0FFFFFFFFh
retn | long long func0(_DWORD *a1, int a2)
{
long long i; // r9
_DWORD *v3; // rax
char v4; // dl
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
for ( i = 0LL; i != a2; ++i )
{
v3 = a1;
v4 = 0;
do
v4 += a1[i] == *v3++;
while ( v3 != &a1[a2 - 1 + 1] );
if ( (v4 & 1) != 0 )
return (unsigned int)a1[(int)i];
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011be
MOV R11D,ESI
LEA EAX,[RSI + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV R9D,0x0
JMP 0x00101192
LAB_00101184:
TEST DL,0x1
JNZ 0x001011b6
ADD R9,0x1
CMP R9,R11
JZ 0x001011c4
LAB_00101192:
MOV R10D,R9D
MOV ESI,dword ptr [RDI + R9*0x4]
MOV RAX,RDI
MOV EDX,0x0
LAB_001011a1:
CMP ESI,dword ptr [RAX]
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x001011a1
JMP 0x00101184
LAB_001011b6:
MOVSXD R10,R10D
MOV EAX,dword ptr [RDI + R10*0x4]
RET
LAB_001011be:
MOV EAX,0xffffffff
RET
LAB_001011c4:
MOV EAX,0xffffffff
RET | int func0(int *param_1,uint param_2)
{
int *piVar1;
bool bVar2;
ulong uVar3;
if ((int)param_2 < 1) {
return -1;
}
uVar3 = 0;
while( true ) {
bVar2 = false;
piVar1 = param_1;
do {
bVar2 = (bool)(bVar2 ^ param_1[uVar3] == *piVar1);
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(param_2 - 1) + 1);
if (bVar2) break;
uVar3 = uVar3 + 1;
if (uVar3 == param_2) {
return -1;
}
}
return param_1[(int)uVar3];
} |
4,010 | func0 |
#include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int array1[] = {1, 2, 3, 1, 2, 3, 1};
assert(func0(array1, 7) == 1);
int array2[] = {1, 2, 3, 2, 3, 1, 3};
assert(func0(array2, 7) == 3);
int array3[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
assert(func0(array3, 13) == 5);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1331 <func0+0x41>
lea -0x1(%rsi),%eax
mov %rdi,%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax,%rax,1)
mov (%r9),%r8d
mov %rdi,%rax
xor %edx,%edx
xor %ecx,%ecx
cmp (%rax),%r8d
sete %cl
add $0x4,%rax
add %ecx,%edx
cmp %rsi,%rax
jne 1310 <func0+0x20>
and $0x1,%edx
jne 1337 <func0+0x47>
add $0x4,%r9
cmp %rax,%r9
jne 1308 <func0+0x18>
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1331
lea eax, [rsi-1]
mov r9, rdi
lea rsi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1308:
mov r8d, [r9]
mov rax, rdi
xor edx, edx
loc_1310:
xor ecx, ecx
cmp r8d, [rax]
setz cl
add rax, 4
add edx, ecx
cmp rax, rsi
jnz short loc_1310
and edx, 1
jnz short loc_1337
add r9, 4
cmp r9, rax
jnz short loc_1308
loc_1331:
mov r8d, 0FFFFFFFFh
loc_1337:
mov eax, r8d
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // r9
long long v3; // rsi
unsigned int v4; // r8d
unsigned int *v5; // rax
char v6; // dl
char v7; // cl
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
v4 = *v2;
v5 = a1;
v6 = 0;
do
{
v7 = v4 == *v5++;
v6 += v7;
}
while ( v5 != (unsigned int *)v3 );
if ( (v6 & 1) != 0 )
break;
if ( ++v2 == v5 )
return (unsigned int)-1;
}
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101331
LEA EAX,[RSI + -0x1]
MOV R9,RDI
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101308:
MOV R8D,dword ptr [R9]
MOV RAX,RDI
XOR EDX,EDX
LAB_00101310:
XOR ECX,ECX
CMP R8D,dword ptr [RAX]
SETZ CL
ADD RAX,0x4
ADD EDX,ECX
CMP RAX,RSI
JNZ 0x00101310
AND EDX,0x1
JNZ 0x00101337
ADD R9,0x4
CMP R9,RAX
JNZ 0x00101308
LAB_00101331:
MOV R8D,0xffffffff
LAB_00101337:
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
bool bVar3;
int *piVar4;
if (0 < param_2) {
piVar4 = param_1;
do {
bVar3 = false;
piVar2 = param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
bVar3 = (bool)(bVar3 ^ *piVar4 == iVar1);
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
if (bVar3) {
return *piVar4;
}
piVar4 = piVar4 + 1;
} while (piVar4 != piVar2);
}
return -1;
} |
4,011 | func0 |
#include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int array1[] = {1, 2, 3, 1, 2, 3, 1};
assert(func0(array1, 7) == 1);
int array2[] = {1, 2, 3, 2, 3, 1, 3};
assert(func0(array2, 7) == 3);
int array3[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
assert(func0(array3, 13) == 5);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13c6 <func0+0x106>
mov %esi,%edx
push %r12
lea -0x1(%rsi),%eax
mov %rdi,%r9
shr $0x2,%edx
push %rbp
lea 0x4(%rdi,%rax,4),%r12
mov %rax,%rbp
push %rbx
shl $0x4,%rdx
mov %esi,%ebx
add %rdi,%rdx
and $0xfffffffc,%ebx
mov (%r9),%r8d
cmp $0x3,%ebp
jbe 13c0 <func0+0x100>
movd %r8d,%xmm3
mov %rdi,%rax
pxor %xmm1,%xmm1
pshufd $0x0,%xmm3,%xmm2
nopl (%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
pcmpeqd %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rax,%rdx
jne 1310 <func0+0x50>
movdqa %xmm1,%xmm0
mov %ebx,%ecx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
cmp %esi,%ebx
je 13a0 <func0+0xe0>
movslq %ecx,%r11
cmp (%rdi,%r11,4),%r8d
lea 0x0(,%r11,4),%r10
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x1(%rcx),%r11d
cmp %esi,%r11d
jge 13a0 <func0+0xe0>
cmp 0x4(%rdi,%r10,1),%r8d
jne 1376 <func0+0xb6>
add $0x1,%eax
lea 0x2(%rcx),%r11d
cmp %r11d,%esi
jle 13a0 <func0+0xe0>
cmp 0x8(%rdi,%r10,1),%r8d
jne 1389 <func0+0xc9>
add $0x1,%eax
add $0x3,%ecx
cmp %ecx,%esi
jle 13a0 <func0+0xe0>
cmp 0xc(%rdi,%r10,1),%r8d
jne 13a0 <func0+0xe0>
add $0x1,%eax
nopw 0x0(%rax,%rax,1)
test $0x1,%al
jne 13b7 <func0+0xf7>
add $0x4,%r9
cmp %r12,%r9
jne 12f0 <func0+0x30>
mov $0xffffffff,%r8d
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r12
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 1349 <func0+0x89>
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test esi, esi
jle loc_13B6
mov edx, esi
push r12
movsxd rax, esi
mov r12d, esi
shr edx, 2
push rbp
mov r8, rdi
mov r9d, esi
shl rdx, 4
push rbx
lea r11d, [rsi-1]
lea rbx, [rdi+rax*4]
add rdx, rdi
and r12d, 0FFFFFFFCh
nop dword ptr [rax+00h]
loc_12F8:
mov esi, [rdi]
cmp r11d, 2
jbe loc_13B0
movd xmm3, esi
mov rax, r8
pxor xmm0, xmm0
pshufd xmm2, xmm3, 0
nop dword ptr [rax+00h]
loc_1318:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm1, xmm2
psubd xmm0, xmm1
cmp rdx, rax
jnz short loc_1318
movdqa xmm1, xmm0
mov ecx, r12d
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
cmp r9d, r12d
jz short loc_138C
loc_1353:
movsxd r10, ecx
lea rbp, ds:0[r10*4]
cmp esi, [r8+r10*4]
jnz short loc_1367
add eax, 1
loc_1367:
lea r10d, [rcx+1]
cmp r9d, r10d
jle short loc_138C
cmp esi, [r8+rbp+4]
jnz short loc_137A
add eax, 1
loc_137A:
add ecx, 2
cmp r9d, ecx
jle short loc_138C
cmp esi, [r8+rbp+8]
jnz short loc_138C
add eax, 1
loc_138C:
test al, 1
jnz short loc_13A2
add rdi, 4
cmp rbx, rdi
jnz loc_12F8
mov esi, 0FFFFFFFFh
loc_13A2:
pop rbx
mov eax, esi
pop rbp
pop r12
retn
loc_13B0:
xor ecx, ecx
xor eax, eax
jmp short loc_1353
loc_13B6:
mov eax, 0FFFFFFFFh
retn | long long func0(unsigned int *a1, int a2)
{
const __m128i *v2; // r8
unsigned int v4; // r11d
unsigned int *v5; // rbx
const __m128i *v6; // rdx
unsigned int v7; // r12d
unsigned int v8; // esi
const __m128i *v9; // rax
__m128i v10; // xmm0
__m128i v11; // xmm2
__m128i v12; // xmm1
signed int v13; // ecx
__m128i v14; // xmm0
char v15; // al
long long v16; // rbp
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = (const __m128i *)a1;
v4 = a2 - 1;
v5 = &a1[a2];
v6 = (const __m128i *)&a1[4 * ((unsigned int)a2 >> 2)];
v7 = a2 & 0xFFFFFFFC;
do
{
v8 = *a1;
if ( v4 <= 2 )
{
v13 = 0;
v15 = 0;
}
else
{
v9 = v2;
v10 = 0LL;
v11 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v8), 0);
do
{
v12 = _mm_loadu_si128(v9++);
v10 = _mm_sub_epi32(v10, _mm_cmpeq_epi32(v12, v11));
}
while ( v6 != v9 );
v13 = v7;
v14 = _mm_add_epi32(v10, _mm_srli_si128(v10, 8));
v15 = _mm_cvtsi128_si32(_mm_add_epi32(v14, _mm_srli_si128(v14, 4)));
if ( a2 == v7 )
goto LABEL_15;
}
v16 = v13;
if ( v8 == v2->m128i_i32[v16] )
++v15;
if ( a2 > v13 + 1 )
{
if ( v8 == v2->m128i_i32[v16 + 1] )
++v15;
if ( a2 > v13 + 2 && v8 == v2->m128i_i32[v16 + 2] )
++v15;
}
LABEL_15:
if ( (v15 & 1) != 0 )
return v8;
++a1;
}
while ( v5 != a1 );
return (unsigned int)-1;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b6
MOV EDX,ESI
PUSH R12
MOVSXD RAX,ESI
MOV R12D,ESI
SHR EDX,0x2
PUSH RBP
MOV R8,RDI
MOV R9D,ESI
SHL RDX,0x4
PUSH RBX
LEA R11D,[RSI + -0x1]
LEA RBX,[RDI + RAX*0x4]
ADD RDX,RDI
AND R12D,0xfffffffc
NOP dword ptr [RAX]
LAB_001012f8:
MOV ESI,dword ptr [RDI]
CMP R11D,0x2
JBE 0x001013b0
MOVD XMM3,ESI
MOV RAX,R8
PXOR XMM0,XMM0
PSHUFD XMM2,XMM3,0x0
NOP dword ptr [RAX]
LAB_00101318:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RDX,RAX
JNZ 0x00101318
MOVDQA XMM1,XMM0
MOV ECX,R12D
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
CMP R9D,R12D
JZ 0x0010138c
LAB_00101353:
MOVSXD R10,ECX
LEA RBP,[R10*0x4]
CMP ESI,dword ptr [R8 + R10*0x4]
JNZ 0x00101367
ADD EAX,0x1
LAB_00101367:
LEA R10D,[RCX + 0x1]
CMP R9D,R10D
JLE 0x0010138c
CMP ESI,dword ptr [R8 + RBP*0x1 + 0x4]
JNZ 0x0010137a
ADD EAX,0x1
LAB_0010137a:
ADD ECX,0x2
CMP R9D,ECX
JLE 0x0010138c
CMP ESI,dword ptr [R8 + RBP*0x1 + 0x8]
JNZ 0x0010138c
ADD EAX,0x1
LAB_0010138c:
TEST AL,0x1
JNZ 0x001013a2
ADD RDI,0x4
CMP RBX,RDI
JNZ 0x001012f8
MOV ESI,0xffffffff
LAB_001013a2:
POP RBX
MOV EAX,ESI
POP RBP
POP R12
RET
LAB_001013b0:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x00101353
LAB_001013b6:
MOV EAX,0xffffffff
RET | int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
bool bVar6;
int *piVar7;
uint uVar8;
int *piVar9;
byte bVar10;
byte bVar11;
byte bVar12;
byte bVar13;
if ((int)param_2 < 1) {
return -1;
}
piVar9 = param_1;
do {
iVar1 = *piVar9;
if (param_2 - 1 < 3) {
uVar8 = 0;
bVar6 = false;
LAB_00101353:
if (iVar1 == param_1[(int)uVar8]) {
bVar6 = (bool)(bVar6 ^ 1);
}
if ((int)(uVar8 + 1) < (int)param_2) {
if (iVar1 == param_1[(long)(int)uVar8 + 1]) {
bVar6 = (bool)(bVar6 ^ 1);
}
if (((int)(uVar8 + 2) < (int)param_2) && (iVar1 == param_1[(long)(int)uVar8 + 2])) {
bVar6 = (bool)(bVar6 ^ 1);
}
}
}
else {
bVar10 = 0;
bVar11 = 0;
bVar12 = 0;
bVar13 = 0;
piVar7 = param_1;
do {
iVar2 = *piVar7;
piVar3 = piVar7 + 1;
piVar4 = piVar7 + 2;
piVar5 = piVar7 + 3;
piVar7 = piVar7 + 4;
bVar10 = bVar10 ^ iVar2 == iVar1;
bVar11 = bVar11 ^ *piVar3 == iVar1;
bVar12 = bVar12 ^ *piVar4 == iVar1;
bVar13 = bVar13 ^ *piVar5 == iVar1;
} while (param_1 + (ulong)(param_2 >> 2) * 4 != piVar7);
bVar6 = (bool)(bVar10 ^ bVar12 ^ bVar11 ^ bVar13);
uVar8 = param_2 & 0xfffffffc;
if (param_2 != (param_2 & 0xfffffffc)) goto LAB_00101353;
}
if (bVar6) {
return iVar1;
}
piVar9 = piVar9 + 1;
if (param_1 + (int)param_2 == piVar9) {
return -1;
}
} while( true );
} |
4,012 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
int check_Equality(char *s, int start, int length) {
return (s[start] == s[start + length - 1]);
}
| int func0(char *s) {
int result = 0;
int n = strlen(s);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= n - i; j++) {
if (check_Equality(s, i, j)) {
result++;
}
}
}
return result;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("abcda") == 6);
assert(func0("ab") == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1214 <func0+0x67>
movl $0x1,-0x8(%rbp)
jmp 1205 <func0+0x58>
mov -0x8(%rbp),%edx
mov -0xc(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <check_Equality>
test %eax,%eax
je 1201 <func0+0x54>
addl $0x1,-0x10(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp),%eax
sub -0xc(%rbp),%eax
cmp %eax,-0x8(%rbp)
jle 11e5 <func0+0x38>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11dc <func0+0x2f>
mov -0x10(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_10], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_C], 0
jmp short loc_1214
loc_11DC:
mov [rbp+var_8], 1
jmp short loc_1205
loc_11E5:
mov edx, [rbp+var_8]
mov ecx, [rbp+var_C]
mov rax, [rbp+s]
mov esi, ecx
mov rdi, rax
call check_Equality
test eax, eax
jz short loc_1201
add [rbp+var_10], 1
loc_1201:
add [rbp+var_8], 1
loc_1205:
mov eax, [rbp+var_4]
sub eax, [rbp+var_C]
cmp [rbp+var_8], eax
jle short loc_11E5
add [rbp+var_C], 1
loc_1214:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_4]
jl short loc_11DC
mov eax, [rbp+var_10]
leave
retn | long long func0(const char *a1)
{
unsigned int v2; // [rsp+10h] [rbp-10h]
unsigned int i; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v2 = 0;
v5 = strlen(a1);
for ( i = 0; (int)i < v5; ++i )
{
for ( j = 1; j <= (int)(v5 - i); ++j )
{
if ( (unsigned int)check_Equality(a1, i, (unsigned int)j) )
++v2;
}
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101214
LAB_001011dc:
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101205
LAB_001011e5:
MOV EDX,dword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
TEST EAX,EAX
JZ 0x00101201
ADD dword ptr [RBP + -0x10],0x1
LAB_00101201:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101205:
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,dword ptr [RBP + -0xc]
CMP dword ptr [RBP + -0x8],EAX
JLE 0x001011e5
ADD dword ptr [RBP + -0xc],0x1
LAB_00101214:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011dc
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
sVar2 = strlen(param_1);
for (local_14 = 0; local_14 < (int)sVar2; local_14 = local_14 + 1) {
for (local_10 = 1; local_10 <= (int)sVar2 - local_14; local_10 = local_10 + 1) {
iVar1 = check_Equality(param_1,local_14,local_10);
if (iVar1 != 0) {
local_18 = local_18 + 1;
}
}
}
return local_18;
} |
4,013 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
int check_Equality(char *s, int start, int length) {
return (s[start] == s[start + length - 1]);
}
| int func0(char *s) {
int result = 0;
int n = strlen(s);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= n - i; j++) {
if (check_Equality(s, i, j)) {
result++;
}
}
}
return result;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("abcda") == 6);
assert(func0("ab") == 2);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%r15
test %r15d,%r15d
jle 11db <func0+0x77>
add $0x1,%r15d
mov %r15d,%r12d
mov $0x0,%ebp
jmp 11c5 <func0+0x61>
mov %ebx,%edx
mov %r13d,%esi
mov %r14,%rdi
callq 1149 <check_Equality>
cmp $0x1,%eax
sbb $0xffffffff,%ebp
add $0x1,%ebx
cmp %r12d,%ebx
jne 11a0 <func0+0x3c>
sub $0x1,%r12d
cmp $0x1,%r12d
je 11e0 <func0+0x7c>
mov %r15d,%r13d
sub %r12d,%r13d
lea -0x1(%r12),%eax
mov $0x1,%ebx
test %eax,%eax
jg 11a0 <func0+0x3c>
jmp 11bb <func0+0x57>
mov $0x0,%ebp
mov %ebp,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
call _strlen
test eax, eax
jle short loc_11EB
lea r15d, [rax+1]
mov r12d, r15d
mov ebp, 0
jmp short loc_11D5
loc_11B0:
mov edx, ebx
mov esi, r13d
mov rdi, r14
call check_Equality
cmp eax, 1
sbb ebp, 0FFFFFFFFh
add ebx, 1
cmp ebx, r12d
jnz short loc_11B0
loc_11CB:
sub r12d, 1
cmp r12d, 1
jz short loc_11F0
loc_11D5:
mov r13d, r15d
sub r13d, r12d
lea eax, [r12-1]
mov ebx, 1
test eax, eax
jg short loc_11B0
jmp short loc_11CB
loc_11EB:
mov ebp, 0
loc_11F0:
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1)
{
int v1; // eax
int v2; // r15d
int v3; // r12d
unsigned int v4; // ebp
unsigned int v5; // ebx
v1 = strlen();
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = v1 + 1;
v3 = v1 + 1;
v4 = 0;
do
{
v5 = 1;
if ( v3 - 1 > 0 )
{
do
v4 -= ((unsigned int)check_Equality(a1, (unsigned int)(v2 - v3), v5++) == 0) - 1;
while ( v5 != v3 );
}
--v3;
}
while ( v3 != 1 );
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011eb
LEA R15D,[RAX + 0x1]
MOV R12D,R15D
MOV EBP,0x0
JMP 0x001011d5
LAB_001011b0:
MOV EDX,EBX
MOV ESI,R13D
MOV RDI,R14
CALL 0x00101169
CMP EAX,0x1
SBB EBP,-0x1
ADD EBX,0x1
CMP EBX,R12D
JNZ 0x001011b0
LAB_001011cb:
SUB R12D,0x1
CMP R12D,0x1
JZ 0x001011f0
LAB_001011d5:
MOV R13D,R15D
SUB R13D,R12D
LEA EAX,[R12 + -0x1]
MOV EBX,0x1
TEST EAX,EAX
JG 0x001011b0
JMP 0x001011cb
LAB_001011eb:
MOV EBP,0x0
LAB_001011f0:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
iVar4 = 0;
}
else {
iVar6 = (int)sVar2 + 1;
iVar4 = 0;
iVar5 = iVar6;
do {
iVar3 = 1;
if (0 < iVar5 + -1) {
do {
iVar1 = check_Equality(param_1,iVar6 - iVar5,iVar3);
iVar4 = (iVar4 + 1) - (uint)(iVar1 == 0);
iVar3 = iVar3 + 1;
} while (iVar3 != iVar5);
}
iVar5 = iVar5 + -1;
} while (iVar5 != 1);
}
return iVar4;
} |
4,014 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
int check_Equality(char *s, int start, int length) {
return (s[start] == s[start + length - 1]);
}
| int func0(char *s) {
int result = 0;
int n = strlen(s);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= n - i; j++) {
if (check_Equality(s, i, j)) {
result++;
}
}
}
return result;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("abcda") == 6);
assert(func0("ab") == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %eax,%eax
jle 1292 <func0+0x62>
mov %eax,%r10d
mov %rbx,%rdi
xor %r9d,%r9d
xor %r8d,%r8d
lea -0x1(%rax),%r11d
nopl 0x0(%rax)
mov %r11d,%ecx
movzbl (%rdi),%esi
mov %rdi,%rax
add $0x1,%rdi
sub %r9d,%ecx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
cmp (%rax),%sil
sete %dl
add $0x1,%rax
add %edx,%r8d
cmp %rcx,%rax
jne 1270 <func0+0x40>
add $0x1,%r9d
cmp %r9d,%r10d
jne 1258 <func0+0x28>
mov %r8d,%eax
pop %rbx
retq
xor %r8d,%r8d
pop %rbx
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_1292
mov r10d, eax
mov rdi, rbx
xor r9d, r9d
xor r8d, r8d
lea r11d, [rax-1]
nop dword ptr [rax+00000000h]
loc_1258:
mov ecx, r11d
movzx esi, byte ptr [rdi]
mov rax, rdi
add rdi, 1
sub ecx, r9d
add rcx, rdi
nop dword ptr [rax+rax+00h]
loc_1270:
xor edx, edx
cmp sil, [rax]
setz dl
add rax, 1
add r8d, edx
cmp rcx, rax
jnz short loc_1270
add r9d, 1
cmp r10d, r9d
jnz short loc_1258
mov eax, r8d
pop rbx
retn
loc_1292:
xor r8d, r8d
pop rbx
mov eax, r8d
retn | long long func0(char *a1)
{
int v1; // eax
int v2; // r10d
int v3; // r9d
unsigned int v4; // r8d
int v5; // r11d
char v6; // si
char *v7; // rax
int v8; // edx
v1 = strlen();
if ( v1 <= 0 )
return 0LL;
v2 = v1;
v3 = 0;
v4 = 0;
v5 = v1 - 1;
do
{
v6 = *a1;
v7 = a1++;
do
{
v8 = v6 == *v7++;
v4 += v8;
}
while ( &a1[v5 - v3] != v7 );
++v3;
}
while ( v2 != v3 );
return v4;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101292
MOV R10D,EAX
MOV RDI,RBX
XOR R9D,R9D
XOR R8D,R8D
LEA R11D,[RAX + -0x1]
NOP dword ptr [RAX]
LAB_00101258:
MOV ECX,R11D
MOVZX ESI,byte ptr [RDI]
MOV RAX,RDI
ADD RDI,0x1
SUB ECX,R9D
ADD RCX,RDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101270:
XOR EDX,EDX
CMP SIL,byte ptr [RAX]
SETZ DL
ADD RAX,0x1
ADD R8D,EDX
CMP RCX,RAX
JNZ 0x00101270
ADD R9D,0x1
CMP R10D,R9D
JNZ 0x00101258
MOV EAX,R8D
POP RBX
RET
LAB_00101292:
XOR R8D,R8D
POP RBX
MOV EAX,R8D
RET | int func0(char *param_1)
{
char cVar1;
char cVar2;
int iVar3;
size_t sVar4;
char *pcVar5;
int iVar6;
int iVar7;
sVar4 = strlen(param_1);
iVar3 = (int)sVar4;
if (0 < iVar3) {
iVar7 = 0;
iVar6 = 0;
do {
cVar2 = *param_1;
pcVar5 = param_1 + 1;
do {
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar6 = iVar6 + (uint)(cVar2 == cVar1);
} while (pcVar5 + (uint)((iVar3 + -1) - iVar7) != param_1);
iVar7 = iVar7 + 1;
param_1 = pcVar5;
} while (iVar3 != iVar7);
return iVar6;
}
return 0;
} |
4,015 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
int check_Equality(char *s, int start, int length) {
return (s[start] == s[start + length - 1]);
}
| int func0(char *s) {
int result = 0;
int n = strlen(s);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= n - i; j++) {
if (check_Equality(s, i, j)) {
result++;
}
}
}
return result;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("abcda") == 6);
assert(func0("ab") == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 14ea <func0+0x2ba>
movdqa 0xe3e(%rip),%xmm5
mov %rax,%rdx
mov %eax,%r11d
mov %eax,%ebp
mov %rbx,%rdi
xor %esi,%esi
pxor %xmm4,%xmm4
xor %r9d,%r9d
pxor %xmm3,%xmm3
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdx),%r10d
movzbl (%rdi),%r8d
cmp $0xe,%r10d
jbe 14e0 <func0+0x2b0>
movd %r8d,%xmm7
mov %edx,%ecx
pxor %xmm1,%xmm1
mov %rdi,%rax
punpcklbw %xmm7,%xmm7
shr $0x4,%ecx
punpcklwd %xmm7,%xmm7
shl $0x4,%rcx
pshufd $0x0,%xmm7,%xmm7
add %rdi,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm4,%xmm6
add $0x10,%rax
pcmpeqb %xmm7,%xmm0
pand %xmm5,%xmm0
pcmpgtb %xmm0,%xmm6
movdqa %xmm0,%xmm2
punpcklbw %xmm6,%xmm2
punpckhbw %xmm6,%xmm0
movdqa %xmm3,%xmm6
pcmpgtw %xmm2,%xmm6
movdqa %xmm2,%xmm8
punpcklwd %xmm6,%xmm8
punpckhwd %xmm6,%xmm2
movdqa %xmm0,%xmm6
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm3,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm6
punpckhwd %xmm2,%xmm0
paddd %xmm6,%xmm1
paddd %xmm0,%xmm1
cmp %rax,%rcx
jne 12b0 <func0+0x80>
movdqa %xmm1,%xmm0
mov %edx,%ecx
psrldq $0x8,%xmm0
and $0xfffffff0,%ecx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
add %eax,%r9d
lea 0x1(%rcx),%eax
cmp %ecx,%edx
je 14c0 <func0+0x290>
lea (%rsi,%rax,1),%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 1356 <func0+0x126>
add $0x1,%r9d
lea 0x1(%rax),%ecx
cmp %edx,%ecx
jg 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 1371 <func0+0x141>
add $0x1,%r9d
lea 0x2(%rax),%ecx
cmp %edx,%ecx
jg 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 138c <func0+0x15c>
add $0x1,%r9d
lea 0x3(%rax),%ecx
cmp %edx,%ecx
jg 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 13a7 <func0+0x177>
add $0x1,%r9d
lea 0x4(%rax),%ecx
cmp %edx,%ecx
jg 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 13c2 <func0+0x192>
add $0x1,%r9d
lea 0x5(%rax),%ecx
cmp %edx,%ecx
jg 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 13dd <func0+0x1ad>
add $0x1,%r9d
lea 0x6(%rax),%ecx
cmp %edx,%ecx
jg 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 13f8 <func0+0x1c8>
add $0x1,%r9d
lea 0x7(%rax),%ecx
cmp %ecx,%edx
jl 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 1413 <func0+0x1e3>
add $0x1,%r9d
lea 0x8(%rax),%ecx
cmp %ecx,%edx
jl 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 142e <func0+0x1fe>
add $0x1,%r9d
lea 0x9(%rax),%ecx
cmp %ecx,%edx
jl 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 1449 <func0+0x219>
add $0x1,%r9d
lea 0xa(%rax),%ecx
cmp %ecx,%edx
jl 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 1460 <func0+0x230>
add $0x1,%r9d
lea 0xb(%rax),%ecx
cmp %ecx,%edx
jl 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 1477 <func0+0x247>
add $0x1,%r9d
lea 0xc(%rax),%ecx
cmp %ecx,%edx
jl 14c0 <func0+0x290>
add %esi,%ecx
movslq %ecx,%rcx
cmp -0x1(%rbx,%rcx,1),%r8b
jne 148e <func0+0x25e>
add $0x1,%r9d
mov %ebp,%ecx
lea 0xd(%rax),%edx
sub %esi,%ecx
cmp %ecx,%edx
jg 14c0 <func0+0x290>
add %esi,%edx
movslq %edx,%rdx
cmp -0x1(%rbx,%rdx,1),%r8b
jne 14a9 <func0+0x279>
add $0x1,%r9d
add $0xe,%eax
cmp %eax,%ecx
jl 14c0 <func0+0x290>
add %esi,%eax
cltq
cmp -0x1(%rbx,%rax,1),%r8b
jne 14c0 <func0+0x290>
add $0x1,%r9d
add $0x1,%esi
add $0x1,%rdi
mov %r10d,%edx
cmp %esi,%r11d
jne 1270 <func0+0x40>
add $0x8,%rsp
mov %r9d,%eax
pop %rbx
pop %rbp
retq
nopl (%rax)
mov $0x1,%eax
jmpq 1345 <func0+0x115>
add $0x8,%rsp
xor %r9d,%r9d
mov %r9d,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle loc_151D
mov rcx, rax
mov r10, rbx
xor r11d, r11d
xor edi, edi
pxor xmm6, xmm6
pxor xmm5, xmm5
pxor xmm4, xmm4
pxor xmm3, xmm3
nop word ptr [rax+rax+00000000h]
loc_1270:
lea r8d, [rcx-1]
movzx edx, byte ptr [r10]
mov esi, r11d
cmp r8d, 0Eh
jbe loc_14E0
movd xmm8, edx
mov r9d, ecx
pxor xmm1, xmm1
mov rax, r10
punpcklbw xmm8, xmm8
shr r9d, 4
punpcklwd xmm8, xmm8
shl r9, 4
pshufd xmm8, xmm8, 0
add r9, r10
nop
loc_12B0:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm7, xmm4
add rax, 10h
pcmpeqb xmm0, xmm8
pcmpgtb xmm7, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm7
punpckhbw xmm0, xmm7
movdqa xmm7, xmm3
pcmpgtw xmm7, xmm2
movdqa xmm9, xmm2
punpcklwd xmm9, xmm7
punpckhwd xmm2, xmm7
movdqa xmm7, xmm0
psubd xmm1, xmm9
psubd xmm1, xmm2
movdqa xmm2, xmm3
pcmpgtw xmm2, xmm0
punpcklwd xmm7, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm7
psubd xmm1, xmm0
cmp r9, rax
jnz short loc_12B0
movdqa xmm0, xmm1
mov ebp, ecx
psrldq xmm0, 8
and ebp, 0FFFFFFF0h
paddd xmm0, xmm1
lea r14d, [rbp+1]
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
lea r12d, [rax+rdi]
test cl, 0Fh
jz loc_1510
mov r9d, ecx
sub r9d, ebp
lea r13d, [r9-1]
cmp r13d, 6
jbe loc_1508
loc_1366:
lea r12, [rbx+r11]
movdqa xmm7, xmm6
movq xmm2, qword ptr [r12+rbp]
movzx ebp, dl
mov eax, ebp
mov ah, al
mov ebp, eax
movd xmm1, ebp
pshuflw xmm1, xmm1, 0
pcmpeqb xmm2, xmm1
pcmpgtb xmm7, xmm2
movdqa xmm1, xmm2
punpcklbw xmm1, xmm7
punpcklbw xmm2, xmm7
movdqa xmm7, xmm5
pcmpgtw xmm7, xmm1
movdqa xmm8, xmm1
pshufd xmm2, xmm2, 4Eh ; 'N'
punpcklwd xmm8, xmm7
punpcklwd xmm1, xmm7
movdqa xmm7, xmm2
psubd xmm0, xmm8
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm1
movdqa xmm1, xmm5
pcmpgtw xmm1, xmm2
punpcklwd xmm7, xmm1
punpcklwd xmm2, xmm1
psubd xmm0, xmm7
pshufd xmm2, xmm2, 4Eh ; 'N'
psubd xmm0, xmm2
movd r12d, xmm0
pshufd xmm1, xmm0, 0E5h
movd ebp, xmm1
add ebp, r12d
add edi, ebp
mov ebp, r9d
and ebp, 0FFFFFFF8h
add r14d, ebp
and r9d, 7
jz loc_14D0
loc_140A:
lea r9d, [rsi+r14]
movsxd r9, r9d
cmp dl, [rbx+r9-1]
jnz short loc_141B
add edi, 1
loc_141B:
lea r9d, [r14+1]
cmp ecx, r9d
jl loc_14D0
add r9d, esi
movsxd r9, r9d
cmp dl, [rbx+r9-1]
jnz short loc_1438
add edi, 1
loc_1438:
lea r9d, [r14+2]
cmp ecx, r9d
jl short loc_14B8
add r9d, esi
movsxd r9, r9d
cmp dl, [rbx+r9-1]
jnz short loc_1451
add edi, 1
loc_1451:
lea r9d, [r14+3]
cmp ecx, r9d
jl short loc_14B8
add r9d, esi
movsxd r9, r9d
cmp dl, [rbx+r9-1]
jnz short loc_146A
add edi, 1
loc_146A:
lea r9d, [r14+4]
cmp ecx, r9d
jl short loc_14B8
add r9d, esi
movsxd r9, r9d
cmp dl, [rbx+r9-1]
jnz short loc_1483
add edi, 1
loc_1483:
lea r9d, [r14+5]
cmp ecx, r9d
jl short loc_14B8
add r9d, esi
movsxd r9, r9d
cmp dl, [rbx+r9-1]
jnz short loc_149C
add edi, 1
loc_149C:
lea eax, [r14+6]
cmp ecx, eax
jl short loc_14B8
add esi, eax
movsxd rsi, esi
cmp dl, [rbx+rsi-1]
jnz short loc_14B8
add edi, 1
nop word ptr [rax+rax+00h]
loc_14B8:
add r11, 1
add r10, 1
loc_14C0:
mov ecx, r8d
jmp loc_1270
loc_14D0:
test r8d, r8d
jnz short loc_14B8
pop rbx
mov eax, edi
pop rbp
pop r12
pop r13
pop r14
retn
loc_14E0:
xor ebp, ebp
mov r9d, ecx
mov r12d, edi
mov r14d, 1
sub r9d, ebp
pxor xmm0, xmm0
lea r13d, [r9-1]
cmp r13d, 6
ja loc_1366
nop dword ptr [rax+rax+00h]
loc_1508:
mov edi, r12d
jmp loc_140A
loc_1510:
add r11, 1
add r10, 1
mov edi, r12d
jmp short loc_14C0
loc_151D:
xor edi, edi
pop rbx
pop rbp
mov eax, edi
pop r12
pop r13
pop r14
retn | long long func0(const char *a1)
{
int v2; // eax
int v3; // ecx
const __m128i *v4; // r10
long long v5; // r11
unsigned int v6; // edi
unsigned int v7; // edx
__m128i v8; // xmm8
__m128i v9; // xmm1
const __m128i *v10; // rax
__m128i v11; // xmm8
__m128i v12; // xmm8
__m128i v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm7
__m128i v16; // xmm2
__m128i v17; // xmm0
__m128i v18; // xmm7
__m128i v19; // xmm1
__m128i v20; // xmm2
long long v21; // rbp
__m128i v22; // xmm0
int v23; // r14d
int v24; // eax
__m128i v25; // xmm0
unsigned int v26; // r12d
int v27; // r9d
unsigned int v28; // eax
__m128i v29; // xmm2
__m128i v30; // xmm1
__m128i v31; // xmm2
__m128i v32; // xmm1
__m128i v33; // xmm2
__m128i v34; // xmm0
v2 = strlen(a1);
if ( v2 > 0 )
{
v3 = v2;
v4 = (const __m128i *)a1;
v5 = 0LL;
v6 = 0;
while ( 1 )
{
v7 = v4->m128i_u8[0];
if ( (unsigned int)(v3 - 1) <= 0xE )
break;
v8 = _mm_cvtsi32_si128(v7);
v9 = 0LL;
v10 = v4;
v11 = _mm_unpacklo_epi8(v8, v8);
v12 = _mm_shuffle_epi32(_mm_unpacklo_epi16(v11, v11), 0);
do
{
v13 = _mm_loadu_si128(v10++);
v14 = _mm_cmpeq_epi8(v13, v12);
v15 = _mm_cmpgt_epi8((__m128i)0LL, v14);
v16 = _mm_unpacklo_epi8(v14, v15);
v17 = _mm_unpackhi_epi8(v14, v15);
v18 = _mm_cmpgt_epi16((__m128i)0LL, v16);
v19 = _mm_sub_epi32(_mm_sub_epi32(v9, _mm_unpacklo_epi16(v16, v18)), _mm_unpackhi_epi16(v16, v18));
v20 = _mm_cmpgt_epi16((__m128i)0LL, v17);
v9 = _mm_sub_epi32(_mm_sub_epi32(v19, _mm_unpacklo_epi16(v17, v20)), _mm_unpackhi_epi16(v17, v20));
}
while ( &v4[(unsigned int)v3 >> 4] != v10 );
v21 = v3 & 0xFFFFFFF0;
v22 = _mm_add_epi32(_mm_srli_si128(v9, 8), v9);
v23 = v21 + 1;
v24 = _mm_cvtsi128_si32(_mm_add_epi32(v22, _mm_srli_si128(v22, 4)));
v25 = _mm_add_epi32(v9, _mm_srli_si128(v9, 8));
v26 = v24 + v6;
if ( (v3 & 0xF) != 0 )
{
v27 = v3 - v21;
if ( (unsigned int)(v3 - v21 - 1) > 6 )
goto LABEL_8;
LABEL_34:
v6 = v26;
goto LABEL_9;
}
++v5;
v4 = (const __m128i *)((char *)v4 + 1);
v6 += v24;
LABEL_30:
--v3;
}
v21 = 0LL;
v26 = v6;
v23 = 1;
v27 = v3;
v25 = 0LL;
if ( (unsigned int)(v3 - 1) <= 6 )
goto LABEL_34;
LABEL_8:
v28 = (unsigned __int8)v7;
BYTE1(v28) = v4->m128i_i8[0];
v29 = _mm_cmpeq_epi8(
_mm_loadl_epi64((const __m128i *)&a1[v5 + v21]),
_mm_shufflelo_epi16(_mm_cvtsi32_si128(v28), 0));
v30 = _mm_unpacklo_epi8(v29, _mm_cmpgt_epi8((__m128i)0LL, v29));
v31 = _mm_shuffle_epi32(v30, 78);
v32 = _mm_unpacklo_epi16(v30, _mm_cmpgt_epi16((__m128i)0LL, v30));
v33 = _mm_unpacklo_epi16(v31, _mm_cmpgt_epi16((__m128i)0LL, v31));
v34 = _mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(_mm_sub_epi32(v25, v32), _mm_shuffle_epi32(v32, 78)), v33),
_mm_shuffle_epi32(v33, 78));
v6 += _mm_cvtsi128_si32(v34) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v34, 229));
v23 += v27 & 0xFFFFFFF8;
if ( (v27 & 7) != 0 )
{
LABEL_9:
if ( (_BYTE)v7 == a1[(int)v5 - 1 + v23] )
++v6;
if ( v3 >= v23 + 1 )
{
if ( (_BYTE)v7 == a1[(int)v5 + v23] )
++v6;
if ( v3 >= v23 + 2 )
{
if ( (_BYTE)v7 == a1[(int)v5 + 1 + v23] )
++v6;
if ( v3 >= v23 + 3 )
{
if ( (_BYTE)v7 == a1[(int)v5 + 2 + v23] )
++v6;
if ( v3 >= v23 + 4 )
{
if ( (_BYTE)v7 == a1[(int)v5 + 3 + v23] )
++v6;
if ( v3 >= v23 + 5 )
{
if ( (_BYTE)v7 == a1[(int)v5 + 4 + v23] )
++v6;
if ( v3 >= v23 + 6 && (_BYTE)v7 == a1[v23 + 5 + (int)v5] )
++v6;
}
}
}
}
LABEL_29:
++v5;
v4 = (const __m128i *)((char *)v4 + 1);
goto LABEL_30;
}
}
if ( v3 == 1 )
return v6;
goto LABEL_29;
}
return 0LL;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x0010151d
MOV RCX,RAX
MOV R10,RBX
XOR R11D,R11D
XOR EDI,EDI
PXOR XMM6,XMM6
PXOR XMM5,XMM5
PXOR XMM4,XMM4
PXOR XMM3,XMM3
NOP word ptr [RAX + RAX*0x1]
LAB_00101270:
LEA R8D,[RCX + -0x1]
MOVZX EDX,byte ptr [R10]
MOV ESI,R11D
CMP R8D,0xe
JBE 0x001014e0
MOVD XMM8,EDX
MOV R9D,ECX
PXOR XMM1,XMM1
MOV RAX,R10
PUNPCKLBW XMM8,XMM8
SHR R9D,0x4
PUNPCKLWD XMM8,XMM8
SHL R9,0x4
PSHUFD XMM8,XMM8,0x0
ADD R9,R10
NOP
LAB_001012b0:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM7,XMM4
ADD RAX,0x10
PCMPEQB XMM0,XMM8
PCMPGTB XMM7,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM7
PUNPCKHBW XMM0,XMM7
MOVDQA XMM7,XMM3
PCMPGTW XMM7,XMM2
MOVDQA XMM9,XMM2
PUNPCKLWD XMM9,XMM7
PUNPCKHWD XMM2,XMM7
MOVDQA XMM7,XMM0
PSUBD XMM1,XMM9
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM3
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM7,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM7
PSUBD XMM1,XMM0
CMP R9,RAX
JNZ 0x001012b0
MOVDQA XMM0,XMM1
MOV EBP,ECX
PSRLDQ XMM0,0x8
AND EBP,0xfffffff0
PADDD XMM0,XMM1
LEA R14D,[RBP + 0x1]
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
LEA R12D,[RAX + RDI*0x1]
TEST CL,0xf
JZ 0x00101510
MOV R9D,ECX
SUB R9D,EBP
LEA R13D,[R9 + -0x1]
CMP R13D,0x6
JBE 0x00101508
LAB_00101366:
LEA R12,[RBX + R11*0x1]
MOVDQA XMM7,XMM6
MOVQ XMM2,qword ptr [R12 + RBP*0x1]
MOVZX EBP,DL
MOV EAX,EBP
MOV AH,AL
MOV EBP,EAX
MOVD XMM1,EBP
PSHUFLW XMM1,XMM1,0x0
PCMPEQB XMM2,XMM1
PCMPGTB XMM7,XMM2
MOVDQA XMM1,XMM2
PUNPCKLBW XMM1,XMM7
PUNPCKLBW XMM2,XMM7
MOVDQA XMM7,XMM5
PCMPGTW XMM7,XMM1
MOVDQA XMM8,XMM1
PSHUFD XMM2,XMM2,0x4e
PUNPCKLWD XMM8,XMM7
PUNPCKLWD XMM1,XMM7
MOVDQA XMM7,XMM2
PSUBD XMM0,XMM8
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM1
MOVDQA XMM1,XMM5
PCMPGTW XMM1,XMM2
PUNPCKLWD XMM7,XMM1
PUNPCKLWD XMM2,XMM1
PSUBD XMM0,XMM7
PSHUFD XMM2,XMM2,0x4e
PSUBD XMM0,XMM2
MOVD R12D,XMM0
PSHUFD XMM1,XMM0,0xe5
MOVD EBP,XMM1
ADD EBP,R12D
ADD EDI,EBP
MOV EBP,R9D
AND EBP,0xfffffff8
ADD R14D,EBP
AND R9D,0x7
JZ 0x001014d0
LAB_0010140a:
LEA R9D,[RSI + R14*0x1]
MOVSXD R9,R9D
CMP DL,byte ptr [RBX + R9*0x1 + -0x1]
JNZ 0x0010141b
ADD EDI,0x1
LAB_0010141b:
LEA R9D,[R14 + 0x1]
CMP ECX,R9D
JL 0x001014d0
ADD R9D,ESI
MOVSXD R9,R9D
CMP DL,byte ptr [RBX + R9*0x1 + -0x1]
JNZ 0x00101438
ADD EDI,0x1
LAB_00101438:
LEA R9D,[R14 + 0x2]
CMP ECX,R9D
JL 0x001014b8
ADD R9D,ESI
MOVSXD R9,R9D
CMP DL,byte ptr [RBX + R9*0x1 + -0x1]
JNZ 0x00101451
ADD EDI,0x1
LAB_00101451:
LEA R9D,[R14 + 0x3]
CMP ECX,R9D
JL 0x001014b8
ADD R9D,ESI
MOVSXD R9,R9D
CMP DL,byte ptr [RBX + R9*0x1 + -0x1]
JNZ 0x0010146a
ADD EDI,0x1
LAB_0010146a:
LEA R9D,[R14 + 0x4]
CMP ECX,R9D
JL 0x001014b8
ADD R9D,ESI
MOVSXD R9,R9D
CMP DL,byte ptr [RBX + R9*0x1 + -0x1]
JNZ 0x00101483
ADD EDI,0x1
LAB_00101483:
LEA R9D,[R14 + 0x5]
CMP ECX,R9D
JL 0x001014b8
ADD R9D,ESI
MOVSXD R9,R9D
CMP DL,byte ptr [RBX + R9*0x1 + -0x1]
JNZ 0x0010149c
ADD EDI,0x1
LAB_0010149c:
LEA EAX,[R14 + 0x6]
CMP ECX,EAX
JL 0x001014b8
ADD ESI,EAX
MOVSXD RSI,ESI
CMP DL,byte ptr [RBX + RSI*0x1 + -0x1]
JNZ 0x001014b8
ADD EDI,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001014b8:
ADD R11,0x1
ADD R10,0x1
LAB_001014c0:
MOV ECX,R8D
JMP 0x00101270
LAB_001014d0:
TEST R8D,R8D
JNZ 0x001014b8
POP RBX
MOV EAX,EDI
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001014e0:
XOR EBP,EBP
MOV R9D,ECX
MOV R12D,EDI
MOV R14D,0x1
SUB R9D,EBP
PXOR XMM0,XMM0
LEA R13D,[R9 + -0x1]
CMP R13D,0x6
JA 0x00101366
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOV EDI,R12D
JMP 0x0010140a
LAB_00101510:
ADD R11,0x1
ADD R10,0x1
MOV EDI,R12D
JMP 0x001014c0
LAB_0010151d:
XOR EDI,EDI
POP RBX
POP RBP
MOV EAX,EDI
POP R12
POP R13
POP R14
RET | int func0(char *param_1)
{
char cVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
uint uVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
char *pcVar24;
char *pcVar25;
int auVar26 [14];
int auVar27 [12];
unkbyte10 Var28;
int auVar29 [12];
int auVar30 [14];
int auVar31 [12];
int auVar32 [16];
int auVar33 [16];
int auVar34 [16];
int auVar35 [12];
unkbyte9 Var36;
int6 uVar37;
int4 uVar38;
int2 uVar39;
size_t sVar40;
char *pcVar41;
uint uVar42;
int iVar44;
uint uVar45;
char *pcVar46;
long lVar47;
int iVar48;
int4 uVar49;
int iVar50;
int iVar57;
char cVar58;
short sVar59;
int auVar54 [12];
int iVar60;
int iVar66;
int iVar68;
int iVar69;
int auVar61 [16];
int auVar62 [16];
short sVar67;
int auVar63 [16];
short sVar83;
int auVar70 [12];
int auVar71 [12];
char cVar78;
char cVar79;
char cVar80;
char cVar81;
short sVar84;
int auVar72 [16];
int auVar74 [16];
int auVar75 [16];
char cVar94;
char cVar95;
char cVar96;
char cVar97;
char cVar98;
char cVar99;
int auVar85 [16];
int auVar90 [16];
int auVar100 [16];
int auVar103 [16];
ulong uVar43;
int6 uVar51;
int8 uVar52;
int auVar53 [12];
int auVar55 [14];
int auVar56 [16];
int auVar64 [16];
int auVar65 [16];
int auVar76 [16];
int auVar73 [16];
int auVar77 [16];
long lVar82;
int auVar86 [16];
int auVar87 [16];
int auVar91 [16];
int auVar88 [16];
int auVar92 [16];
int auVar89 [16];
int auVar93 [16];
int auVar101 [16];
int auVar102 [16];
int auVar104 [16];
int auVar105 [16];
sVar40 = strlen(param_1);
if ((int)sVar40 < 1) {
return 0;
}
lVar47 = 0;
iVar44 = 0;
pcVar46 = param_1;
do {
uVar10 = (uint)sVar40;
uVar45 = uVar10 - 1;
cVar1 = *pcVar46;
if (uVar45 < 0xf) {
uVar43 = 0;
iVar48 = 1;
iVar50 = 0;
iVar57 = 0;
uVar42 = uVar10;
iVar60 = iVar44;
joined_r0x001014fd:
if (uVar42 - 1 < 7) {
LAB_0010140a:
iVar44 = (int)lVar47;
if (cVar1 == param_1[(long)(iVar44 + iVar48) + -1]) {
iVar60 = iVar60 + 1;
}
if (iVar48 + 1 <= (int)uVar10) {
if (cVar1 == param_1[(long)(iVar48 + 1 + iVar44) + -1]) {
iVar60 = iVar60 + 1;
}
if (iVar48 + 2 <= (int)uVar10) {
if (cVar1 == param_1[(long)(iVar48 + 2 + iVar44) + -1]) {
iVar60 = iVar60 + 1;
}
if (iVar48 + 3 <= (int)uVar10) {
if (cVar1 == param_1[(long)(iVar48 + 3 + iVar44) + -1]) {
iVar60 = iVar60 + 1;
}
if (iVar48 + 4 <= (int)uVar10) {
if (cVar1 == param_1[(long)(iVar48 + 4 + iVar44) + -1]) {
iVar60 = iVar60 + 1;
}
if (iVar48 + 5 <= (int)uVar10) {
if (cVar1 == param_1[(long)(iVar48 + 5 + iVar44) + -1]) {
iVar60 = iVar60 + 1;
}
if ((iVar48 + 6 <= (int)uVar10) &&
(cVar1 == param_1[(long)(iVar44 + iVar48 + 6) + -1])) {
iVar60 = iVar60 + 1;
}
}
}
}
}
goto LAB_001014c0;
}
}
else {
uVar52 = *(int8 *)(param_1 + uVar43 + lVar47);
auVar61 = pshuflw(ZEXT216(CONCAT11(cVar1,cVar1)),ZEXT216(CONCAT11(cVar1,cVar1)),0);
bVar2 = (char)uVar52 == auVar61[0];
auVar74[0] = -bVar2;
bVar6 = (char)((ulong)uVar52 >> 8) == auVar61[1];
cVar58 = -bVar6;
bVar7 = (char)((ulong)uVar52 >> 0x10) == auVar61[2];
bVar8 = (char)((ulong)uVar52 >> 0x18) == auVar61[3];
bVar9 = (char)((ulong)uVar52 >> 0x20) == auVar61[4];
cVar78 = -bVar9;
bVar3 = (char)((ulong)uVar52 >> 0x28) == auVar61[5];
cVar79 = -bVar3;
bVar4 = (char)((ulong)uVar52 >> 0x30) == auVar61[6];
cVar80 = -bVar4;
bVar5 = (char)((ulong)uVar52 >> 0x38) == auVar61[7];
cVar81 = -bVar5;
cVar94 = -bVar6;
cVar95 = -bVar8;
cVar96 = -bVar9;
cVar97 = -bVar3;
cVar98 = -bVar4;
cVar99 = -bVar5;
Var28 = CONCAT91(CONCAT81((long)(CONCAT72(CONCAT61(CONCAT51(CONCAT41(CONCAT31(CONCAT21(
CONCAT11(cVar99,cVar81),cVar98),cVar80),cVar97),
cVar79),cVar96),CONCAT11(cVar78,cVar81)) >> 8),
cVar95),-bVar8);
auVar31._2_10_ = Var28;
auVar31[1] = -bVar7;
auVar31[0] = -bVar7;
auVar30._2_12_ = auVar31;
auVar30[1] = cVar94;
auVar30[0] = cVar58;
auVar62._0_2_ = CONCAT11(-bVar2,auVar74[0]);
auVar62._2_14_ = auVar30;
uVar39 = CONCAT11(cVar99,cVar81);
uVar38 = CONCAT31(CONCAT21(uVar39,cVar98),cVar80);
uVar37 = CONCAT51(CONCAT41(uVar38,cVar97),cVar79);
Var36 = CONCAT72(CONCAT61(uVar37,cVar96),CONCAT11(cVar78,cVar81));
lVar82 = (long)((unkuint9)Var36 >> 8);
auVar34._1_8_ = lVar82;
auVar34[0] = cVar95;
auVar34._9_7_ = 0;
auVar33._10_6_ = 0;
auVar33._0_10_ = SUB1610(auVar34 << 0x38,6);
auVar32._11_5_ = 0;
auVar32._0_11_ = SUB1611(auVar33 << 0x30,5);
auVar74._4_12_ = SUB1612(auVar32 << 0x28,4);
auVar74[3] = cVar94;
auVar74[2] = cVar58;
auVar74[1] = -bVar2;
sVar59 = auVar31._0_2_;
sVar67 = (short)Var28;
iVar60 = (int)((unkuint9)Var36 >> 8);
auVar71._8_4_ = auVar74._0_4_;
auVar71._0_8_ = lVar82;
auVar102._0_12_ = auVar62._0_12_;
auVar102._12_2_ = sVar67;
auVar102._14_2_ = -(ushort)(sVar67 < 0);
auVar101._12_4_ = auVar102._12_4_;
auVar101._0_10_ = auVar62._0_10_;
auVar101._10_2_ = -(ushort)(sVar59 < 0);
auVar100._10_6_ = auVar101._10_6_;
auVar100._0_8_ = auVar62._0_8_;
auVar100._8_2_ = sVar59;
auVar35._4_8_ = auVar100._8_8_;
auVar35._2_2_ = -(ushort)(auVar30._0_2_ < 0);
auVar35._0_2_ = auVar30._0_2_;
auVar65._12_2_ = sVar67;
auVar65._0_12_ = auVar102._0_12_;
auVar65._14_2_ = -(ushort)(sVar67 < 0);
auVar64._12_4_ = auVar65._12_4_;
auVar64._10_2_ = -(ushort)(sVar59 < 0);
auVar64._0_10_ = auVar101._0_10_;
auVar63._10_6_ = auVar64._10_6_;
auVar63._8_2_ = sVar59;
auVar63._0_8_ = auVar100._0_8_;
sVar59 = (short)((unkuint9)Var36 >> 8);
sVar67 = (short)uVar38;
auVar93._12_2_ = uVar39;
auVar93._0_12_ = auVar71;
auVar93._14_2_ = -(ushort)(lVar82 < 0);
auVar92._12_4_ = auVar93._12_4_;
auVar92._0_10_ = auVar71._0_10_;
auVar92._10_2_ = -(ushort)(sVar67 < 0);
auVar91._10_6_ = auVar92._10_6_;
auVar91._8_2_ = sVar67;
auVar91._0_8_ = lVar82;
auVar90._8_8_ = auVar91._8_8_;
auVar90._6_2_ = -(ushort)(iVar60 < 0);
auVar90._4_2_ = (short)uVar37;
auVar90._0_4_ = iVar60;
auVar77._12_2_ = uVar39;
auVar77._0_12_ = auVar71;
auVar77._14_2_ = -(ushort)(lVar82 < 0);
auVar76._12_4_ = auVar77._12_4_;
auVar76._10_2_ = -(ushort)(sVar67 < 0);
auVar76._0_10_ = auVar92._0_10_;
auVar75._10_6_ = auVar76._10_6_;
auVar75._8_2_ = sVar67;
auVar75._0_8_ = lVar82;
iVar60 = iVar44 + ((((iVar57 - auVar35._0_4_) - auVar64._12_4_) - auVar90._4_4_) -
auVar76._12_4_) +
((((iVar50 - CONCAT22(-(ushort)bVar2,auVar62._0_2_)) - auVar63._8_4_) -
CONCAT22(-(ushort)(sVar59 < 0),sVar59)) - auVar75._8_4_);
iVar48 = iVar48 + (uVar42 & 0xfffffff8);
if ((uVar42 & 7) != 0) goto LAB_0010140a;
}
if (uVar45 == 0) {
return iVar60;
}
}
else {
iVar60 = 0;
iVar66 = 0;
iVar68 = 0;
iVar69 = 0;
pcVar41 = pcVar46;
do {
cVar58 = *pcVar41;
pcVar11 = pcVar41 + 1;
pcVar12 = pcVar41 + 2;
pcVar13 = pcVar41 + 3;
pcVar14 = pcVar41 + 4;
pcVar15 = pcVar41 + 5;
pcVar16 = pcVar41 + 6;
pcVar17 = pcVar41 + 7;
pcVar18 = pcVar41 + 8;
pcVar19 = pcVar41 + 9;
pcVar20 = pcVar41 + 10;
pcVar21 = pcVar41 + 0xb;
pcVar22 = pcVar41 + 0xc;
pcVar23 = pcVar41 + 0xd;
pcVar24 = pcVar41 + 0xe;
pcVar25 = pcVar41 + 0xf;
pcVar41 = pcVar41 + 0x10;
bVar2 = cVar58 == cVar1;
cVar58 = -(*pcVar17 == cVar1);
bVar6 = *pcVar18 == cVar1;
bVar7 = *pcVar19 == cVar1;
bVar8 = *pcVar20 == cVar1;
bVar9 = *pcVar21 == cVar1;
uVar39 = CONCAT11(-(*pcVar17 == cVar1),cVar58);
uVar38 = CONCAT31(CONCAT21(uVar39,-(*pcVar16 == cVar1)),-(*pcVar16 == cVar1));
uVar37 = CONCAT51(CONCAT41(uVar38,-(*pcVar15 == cVar1)),-(*pcVar15 == cVar1));
Var36 = CONCAT72(CONCAT61(uVar37,-(*pcVar14 == cVar1)),CONCAT11(-(*pcVar14 == cVar1),cVar58)
);
lVar82 = (long)((unkuint9)Var36 >> 8);
Var28 = CONCAT91(CONCAT81(lVar82,-(*pcVar13 == cVar1)),-(*pcVar13 == cVar1));
auVar27._2_10_ = Var28;
auVar27[1] = -(*pcVar12 == cVar1);
auVar27[0] = -(*pcVar12 == cVar1);
auVar26._2_12_ = auVar27;
auVar26[1] = -(*pcVar11 == cVar1);
auVar26[0] = -(*pcVar11 == cVar1);
auVar72._0_2_ = CONCAT11(-bVar2,-bVar2);
auVar72._2_14_ = auVar26;
uVar49 = CONCAT13(-bVar7,CONCAT12(-bVar7,CONCAT11(-bVar6,-bVar6)));
uVar51 = CONCAT15(-bVar8,CONCAT14(-bVar8,uVar49));
uVar52 = CONCAT17(-bVar9,CONCAT16(-bVar9,uVar51));
auVar53._0_10_ = CONCAT19(-(*pcVar22 == cVar1),CONCAT18(-(*pcVar22 == cVar1),uVar52));
auVar53[10] = -(*pcVar23 == cVar1);
auVar53[0xb] = -(*pcVar23 == cVar1);
auVar55[0xc] = -(*pcVar24 == cVar1);
auVar55._0_12_ = auVar53;
auVar55[0xd] = -(*pcVar24 == cVar1);
auVar61[0xe] = -(*pcVar25 == cVar1);
auVar61._0_14_ = auVar55;
auVar61[0xf] = -(*pcVar25 == cVar1);
sVar59 = (short)Var28;
sVar67 = (short)((unkuint9)Var36 >> 8);
sVar83 = (short)uVar37;
sVar84 = (short)uVar38;
auVar105._0_12_ = auVar72._0_12_;
auVar105._12_2_ = sVar59;
auVar105._14_2_ = -(ushort)(sVar59 < 0);
auVar104._12_4_ = auVar105._12_4_;
auVar104._0_10_ = auVar72._0_10_;
auVar104._10_2_ = -(ushort)(auVar27._0_2_ < 0);
auVar103._10_6_ = auVar104._10_6_;
auVar103._0_8_ = auVar72._0_8_;
auVar103._8_2_ = auVar27._0_2_;
auVar29._4_8_ = auVar103._8_8_;
auVar29._2_2_ = -(ushort)(auVar26._0_2_ < 0);
auVar29._0_2_ = auVar26._0_2_;
iVar50 = CONCAT22(-(ushort)(sVar67 < 0),sVar67);
auVar70._0_8_ = CONCAT26(-(ushort)(sVar83 < 0),CONCAT24(sVar83,iVar50));
auVar70._8_2_ = sVar84;
auVar70._10_2_ = -(ushort)(sVar84 < 0);
auVar73._12_2_ = uVar39;
auVar73._0_12_ = auVar70;
auVar73._14_2_ = -(ushort)(lVar82 < 0);
sVar59 = (short)((unkuint10)auVar53._0_10_ >> 0x40);
auVar89._12_2_ = (short)((ulong)uVar52 >> 0x30);
auVar89._0_12_ = auVar53;
auVar89._14_2_ = -(ushort)bVar9;
auVar88._12_4_ = auVar89._12_4_;
auVar88._10_2_ = -(ushort)bVar8;
auVar88._0_10_ = auVar53._0_10_;
auVar87._10_6_ = auVar88._10_6_;
auVar87._8_2_ = (short)((uint6)uVar51 >> 0x20);
auVar87._0_8_ = uVar52;
auVar86._8_8_ = auVar87._8_8_;
auVar86._6_2_ = -(ushort)bVar7;
auVar86._0_6_ = uVar51;
auVar85._6_10_ = auVar86._6_10_;
auVar85._4_2_ = (short)((uint)uVar49 >> 0x10);
auVar85._0_4_ = uVar49;
iVar48 = CONCAT22(-(ushort)(sVar59 < 0),sVar59);
auVar54._0_8_ = CONCAT26(-(ushort)(auVar53._10_2_ < 0),CONCAT24(auVar53._10_2_,iVar48));
auVar54._8_2_ = auVar55._12_2_;
auVar54._10_2_ = -(ushort)(auVar55._12_2_ < 0);
auVar56._12_2_ = auVar61._14_2_;
auVar56._0_12_ = auVar54;
auVar56._14_2_ = -(ushort)(auVar61._14_2_ < 0);
iVar60 = (((iVar60 - CONCAT22(-(ushort)bVar2,auVar72._0_2_)) - iVar50) -
CONCAT22(-(ushort)bVar6,CONCAT11(-bVar6,-bVar6))) - iVar48;
iVar66 = (((iVar66 - auVar29._0_4_) - (int)((ulong)auVar70._0_8_ >> 0x20)) - auVar85._4_4_)
- (int)((ulong)auVar54._0_8_ >> 0x20);
iVar68 = (((iVar68 - auVar103._8_4_) - auVar70._8_4_) - auVar87._8_4_) - auVar54._8_4_;
iVar69 = (((iVar69 - auVar104._12_4_) - auVar73._12_4_) - auVar88._12_4_) - auVar56._12_4_;
} while (pcVar46 + (sVar40 >> 4 & 0xfffffff) * 0x10 != pcVar41);
uVar42 = uVar10 & 0xfffffff0;
uVar43 = (ulong)uVar42;
iVar48 = uVar42 + 1;
iVar50 = iVar60 + iVar68;
iVar57 = iVar66 + iVar69;
iVar60 = iVar68 + iVar60 + iVar69 + iVar66 + iVar44;
if ((sVar40 & 0xf) != 0) {
uVar42 = uVar10 - uVar42;
goto joined_r0x001014fd;
}
}
LAB_001014c0:
iVar44 = iVar60;
lVar47 = lVar47 + 1;
pcVar46 = pcVar46 + 1;
sVar40 = (size_t)uVar45;
} while( true );
} |
4,016 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int key;
int count;
} Element;
int compare(const void* a, const void* b) {
Element* ea = (Element*)a;
Element* eb = (Element*)b;
if (eb->count != ea->count)
return eb->count - ea->count;
return ea->key - eb->key;
}
| int* func0(int** nums, int numsSize, int* numsColSizes, int k, int* returnSize) {
// Find the maximum possible key to size the frequency array
int max_key = 0;
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
if(nums[i][j] > max_key)
max_key = nums[i][j];
}
}
// Frequency array
int* freq = (int*)calloc(max_key + 1, sizeof(int));
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
freq[nums[i][j]] += 1;
}
}
// Collect elements with their counts
Element* elements = (Element*)malloc((max_key + 1) * sizeof(Element));
int count = 0;
for(int i = 0; i <= max_key; i++) {
if(freq[i] > 0) {
elements[count].key = i;
elements[count].count = freq[i];
count++;
}
}
// Sort the elements
qsort(elements, count, sizeof(Element), compare);
// Prepare the result
int* result = (int*)malloc(k * sizeof(int));
for(int i = 0; i < k; i++) {
result[i] = elements[i].key;
}
*returnSize = k;
free(freq);
free(elements);
return result;
}
| int main() {
// First test case
int row0[] = {1, 2, 6};
int row1[] = {1, 3, 4, 5, 7, 8};
int row2[] = {1, 3, 5, 6, 8, 9};
int row3[] = {2, 5, 7, 11};
int row4[] = {1, 4, 7, 8, 12};
int* nums1[] = {row0, row1, row2, row3, row4};
int numsColSizes1[] = {3, 6, 6, 4, 5};
int returnSize1;
int* res1 = func0(nums1, 5, numsColSizes1, 3, &returnSize1);
int expected1[] = {1, 5, 7};
for(int i = 0; i < 3; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Second test case
int returnSize2;
int* res2 = func0(nums1, 5, numsColSizes1, 1, &returnSize2);
int expected2[] = {1};
for(int i = 0; i < 1; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Third test case
int returnSize3;
int* res3 = func0(nums1, 5, numsColSizes1, 5, &returnSize3);
int expected3[] = {1, 5, 7, 8, 2};
for(int i = 0; i < 5; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %rdx,-0x58(%rbp)
mov %ecx,-0x50(%rbp)
mov %r8,-0x60(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
jmpq 12f2 <func0+0xb1>
movl $0x0,-0x30(%rbp)
jmp 12d3 <func0+0x92>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x38(%rbp)
jge 12cf <func0+0x8e>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x38(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x30(%rbp)
jl 127b <func0+0x3a>
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1272 <func0+0x31>
mov -0x38(%rbp),%eax
add $0x1,%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10e0 <calloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x2c(%rbp)
jmpq 13c8 <func0+0x187>
movl $0x0,-0x28(%rbp)
jmp 13a5 <func0+0x164>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x28(%rbp)
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x28(%rbp)
jl 132c <func0+0xeb>
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1323 <func0+0xe2>
mov -0x38(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1465 <func0+0x224>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 1461 <func0+0x220>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
mov %eax,(%rdx)
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x10(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,0x4(%rdx)
addl $0x1,-0x24(%rbp)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x38(%rbp),%eax
jle 13fc <func0+0x1bb>
mov -0x24(%rbp),%eax
movslq %eax,%rsi
mov -0x10(%rbp),%rax
lea -0x295(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
callq 10b0 <qsort@plt>
mov -0x50(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 14da <func0+0x299>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x50(%rbp),%eax
jl 14a9 <func0+0x268>
mov -0x60(%rbp),%rax
mov -0x50(%rbp),%edx
mov %edx,(%rax)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_58], rdx
mov [rbp+var_50], ecx
mov [rbp+var_60], r8
mov [rbp+var_38], 0
mov [rbp+var_34], 0
jmp loc_12F2
loc_1272:
mov [rbp+var_30], 0
jmp short loc_12D3
loc_127B:
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_30]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_38], eax
jge short loc_12CF
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_30]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_38], eax
loc_12CF:
add [rbp+var_30], 1
loc_12D3:
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_30], eax
jl short loc_127B
add [rbp+var_34], 1
loc_12F2:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4C]
jl loc_1272
mov eax, [rbp+var_38]
add eax, 1
cdqe
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbp+ptr], rax
mov [rbp+var_2C], 0
jmp loc_13C8
loc_1323:
mov [rbp+var_28], 0
jmp short loc_13A5
loc_132C:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_28]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_2C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_28]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov eax, [rax]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
add edx, 1
mov [rax], edx
add [rbp+var_28], 1
loc_13A5:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_28], eax
jl loc_132C
add [rbp+var_2C], 1
loc_13C8:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_4C]
jl loc_1323
mov eax, [rbp+var_38]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+base], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp short loc_1465
loc_13FC:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_1461
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rdx, rax
mov eax, [rbp+var_20]
mov [rdx], eax
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+base]
add rdx, rcx
mov eax, [rax]
mov [rdx+4], eax
add [rbp+var_24], 1
loc_1461:
add [rbp+var_20], 1
loc_1465:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_38]
jle short loc_13FC
mov eax, [rbp+var_24]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 8; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_50]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_1C], 0
jmp short loc_14DD
loc_14AC:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_1C], 1
loc_14DD:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_50]
jl short loc_14AC
mov rax, [rbp+var_60]
mov edx, [rbp+var_50]
mov [rax], edx
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+base]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v9; // [rsp+28h] [rbp-38h]
int i; // [rsp+2Ch] [rbp-34h]
int j; // [rsp+30h] [rbp-30h]
int k; // [rsp+34h] [rbp-2Ch]
int m; // [rsp+38h] [rbp-28h]
int v14; // [rsp+3Ch] [rbp-24h]
int n; // [rsp+40h] [rbp-20h]
int ii; // [rsp+44h] [rbp-1Ch]
_DWORD *ptr; // [rsp+48h] [rbp-18h]
_DWORD *base; // [rsp+50h] [rbp-10h]
_DWORD *v19; // [rsp+58h] [rbp-8h]
v9 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < *(_DWORD *)(4LL * i + a3); ++j )
{
if ( v9 < *(_DWORD *)(4LL * j + *(_QWORD *)(8LL * i + a1)) )
v9 = *(_DWORD *)(4LL * j + *(_QWORD *)(8LL * i + a1));
}
}
ptr = calloc(v9 + 1, 4uLL);
for ( k = 0; k < a2; ++k )
{
for ( m = 0; m < *(_DWORD *)(4LL * k + a3); ++m )
++ptr[*(int *)(4LL * m + *(_QWORD *)(8LL * k + a1))];
}
base = malloc(8LL * (v9 + 1));
v14 = 0;
for ( n = 0; n <= v9; ++n )
{
if ( (int)ptr[n] > 0 )
{
base[2 * v14] = n;
base[2 * v14++ + 1] = ptr[n];
}
}
qsort(base, v14, 8uLL, compare);
v19 = malloc(4LL * a4);
for ( ii = 0; ii < a4; ++ii )
v19[ii] = base[2 * ii];
*a5 = a4;
free(ptr);
free(base);
return v19;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV qword ptr [RBP + -0x58],RDX
MOV dword ptr [RBP + -0x50],ECX
MOV qword ptr [RBP + -0x60],R8
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0x0
JMP 0x001012f2
LAB_00101272:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001012d3
LAB_0010127b:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x38],EAX
JGE 0x001012cf
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
LAB_001012cf:
ADD dword ptr [RBP + -0x30],0x1
LAB_001012d3:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x30],EAX
JL 0x0010127b
ADD dword ptr [RBP + -0x34],0x1
LAB_001012f2:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101272
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001013c8
LAB_00101323:
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001013a5
LAB_0010132c:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x28]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
ADD EDX,0x1
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x28],0x1
LAB_001013a5:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x28],EAX
JL 0x0010132c
ADD dword ptr [RBP + -0x2c],0x1
LAB_001013c8:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101323
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101465
LAB_001013fc:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x00101461
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX + 0x4],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_00101461:
ADD dword ptr [RBP + -0x20],0x1
LAB_00101465:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x38]
JLE 0x001013fc
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[0x1011e9]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0x50]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001014dd
LAB_001014ac:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x1c],0x1
LAB_001014dd:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x50]
JL 0x001014ac
MOV RAX,qword ptr [RBP + -0x60]
MOV EDX,dword ptr [RBP + -0x50]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
void *__ptr;
void *__base;
void *pvVar1;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
local_40 = 0;
for (local_3c = 0; local_3c < param_2; local_3c = local_3c + 1) {
for (local_38 = 0; local_38 < *(int *)(param_3 + (long)local_3c * 4); local_38 = local_38 + 1) {
if (local_40 < *(int *)(*(long *)(param_1 + (long)local_3c * 8) + (long)local_38 * 4)) {
local_40 = *(int *)(*(long *)(param_1 + (long)local_3c * 8) + (long)local_38 * 4);
}
}
}
__ptr = calloc((long)(local_40 + 1),4);
for (local_34 = 0; local_34 < param_2; local_34 = local_34 + 1) {
for (local_30 = 0; local_30 < *(int *)(param_3 + (long)local_34 * 4); local_30 = local_30 + 1) {
*(int *)((long)__ptr +
(long)*(int *)(*(long *)(param_1 + (long)local_34 * 8) + (long)local_30 * 4) * 4) =
*(int *)((long)__ptr +
(long)*(int *)(*(long *)(param_1 + (long)local_34 * 8) + (long)local_30 * 4) * 4)
+ 1;
}
}
__base = malloc((long)(local_40 + 1) << 3);
local_2c = 0;
for (local_28 = 0; local_28 <= local_40; local_28 = local_28 + 1) {
if (0 < *(int *)((long)__ptr + (long)local_28 * 4)) {
*(int *)((long)local_2c * 8 + (long)__base) = local_28;
*(int4 *)((long)__base + (long)local_2c * 8 + 4) =
*(int4 *)((long)__ptr + (long)local_28 * 4);
local_2c = local_2c + 1;
}
}
qsort(__base,(long)local_2c,8,compare);
pvVar1 = malloc((long)param_4 << 2);
for (local_24 = 0; local_24 < param_4; local_24 = local_24 + 1) {
*(int4 *)((long)pvVar1 + (long)local_24 * 4) =
*(int4 *)((long)__base + (long)local_24 * 8);
}
*param_5 = param_4;
free(__ptr);
free(__base);
return pvVar1;
} |
4,017 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int key;
int count;
} Element;
int compare(const void* a, const void* b) {
Element* ea = (Element*)a;
Element* eb = (Element*)b;
if (eb->count != ea->count)
return eb->count - ea->count;
return ea->key - eb->key;
}
| int* func0(int** nums, int numsSize, int* numsColSizes, int k, int* returnSize) {
// Find the maximum possible key to size the frequency array
int max_key = 0;
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
if(nums[i][j] > max_key)
max_key = nums[i][j];
}
}
// Frequency array
int* freq = (int*)calloc(max_key + 1, sizeof(int));
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
freq[nums[i][j]] += 1;
}
}
// Collect elements with their counts
Element* elements = (Element*)malloc((max_key + 1) * sizeof(Element));
int count = 0;
for(int i = 0; i <= max_key; i++) {
if(freq[i] > 0) {
elements[count].key = i;
elements[count].count = freq[i];
count++;
}
}
// Sort the elements
qsort(elements, count, sizeof(Element), compare);
// Prepare the result
int* result = (int*)malloc(k * sizeof(int));
for(int i = 0; i < k; i++) {
result[i] = elements[i].key;
}
*returnSize = k;
free(freq);
free(elements);
return result;
}
| int main() {
// First test case
int row0[] = {1, 2, 6};
int row1[] = {1, 3, 4, 5, 7, 8};
int row2[] = {1, 3, 5, 6, 8, 9};
int row3[] = {2, 5, 7, 11};
int row4[] = {1, 4, 7, 8, 12};
int* nums1[] = {row0, row1, row2, row3, row4};
int numsColSizes1[] = {3, 6, 6, 4, 5};
int returnSize1;
int* res1 = func0(nums1, 5, numsColSizes1, 3, &returnSize1);
int expected1[] = {1, 5, 7};
for(int i = 0; i < 3; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Second test case
int returnSize2;
int* res2 = func0(nums1, 5, numsColSizes1, 1, &returnSize2);
int expected2[] = {1};
for(int i = 0; i < 1; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Third test case
int returnSize3;
int* res3 = func0(nums1, 5, numsColSizes1, 5, &returnSize3);
int expected3[] = {1, 5, 7, 8, 2};
for(int i = 0; i < 5; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %ecx,%r15d
mov %r8,(%rsp)
test %esi,%esi
jle 1382 <func0+0x183>
mov %rdi,%r13
mov %rdx,%r12
lea -0x1(%rsi),%r14d
mov $0x0,%esi
mov $0x0,%ebx
jmp 1263 <func0+0x64>
mov 0x0(%r13,%rsi,8),%rax
lea -0x1(%rdx),%edx
lea 0x4(%rax,%rdx,4),%rcx
mov (%rax),%edx
cmp %edx,%ebx
cmovl %edx,%ebx
add $0x4,%rax
cmp %rcx,%rax
jne 1243 <func0+0x44>
lea 0x1(%rsi),%rax
cmp %r14,%rsi
je 135e <func0+0x15f>
mov %rax,%rsi
mov (%r12,%rsi,4),%edx
test %edx,%edx
jg 1236 <func0+0x37>
jmp 1253 <func0+0x54>
mov 0x0(%r13,%rsi,8),%rax
lea -0x1(%rdx),%edx
lea 0x4(%rax,%rdx,4),%rcx
movslq (%rax),%rdx
addl $0x1,0x0(%rbp,%rdx,4)
add $0x4,%rax
cmp %rax,%rcx
jne 127a <func0+0x7b>
lea 0x1(%rsi),%rax
cmp %r14,%rsi
je 12a1 <func0+0xa2>
mov %rax,%rsi
mov (%r12,%rsi,4),%edx
test %edx,%edx
jg 126d <func0+0x6e>
jmp 128b <func0+0x8c>
mov 0x8(%rsp),%rdi
shl $0x3,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
js 12e9 <func0+0xea>
mov %ebx,%ebx
mov $0x0,%eax
mov $0x0,%ecx
jmp 12d0 <func0+0xd1>
lea 0x1(%rax),%rdx
cmp %rax,%rbx
je 12ee <func0+0xef>
mov %rdx,%rax
mov 0x0(%rbp,%rax,4),%edx
test %edx,%edx
jle 12c4 <func0+0xc5>
movslq %ecx,%rsi
lea (%r12,%rsi,8),%rsi
mov %eax,(%rsi)
mov %edx,0x4(%rsi)
add $0x1,%ecx
jmp 12c4 <func0+0xc5>
mov $0x0,%ecx
movslq %ecx,%rsi
lea -0x10f(%rip),%rcx
mov $0x8,%edx
mov %r12,%rdi
callq 10b0 <qsort@plt>
movslq %r15d,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rbx
test %r15d,%r15d
jle 1335 <func0+0x136>
lea -0x1(%r15),%ecx
mov $0x0,%eax
mov (%r12,%rax,8),%edx
mov %edx,(%rbx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rcx
jne 1322 <func0+0x123>
mov (%rsp),%rax
mov %r15d,(%rax)
mov %rbp,%rdi
callq 10a0 <free@plt>
mov %r12,%rdi
callq 10a0 <free@plt>
mov %rbx,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
lea 0x1(%rbx),%eax
cltq
mov %rax,0x8(%rsp)
mov $0x4,%esi
mov %rax,%rdi
callq 10e0 <calloc@plt>
mov %rax,%rbp
mov $0x0,%esi
jmpq 1297 <func0+0x98>
mov $0x4,%esi
mov $0x1,%edi
callq 10e0 <calloc@plt>
mov %rax,%rbp
mov $0x8,%edi
callq 10f0 <malloc@plt>
mov %rax,%r12
mov $0x0,%ebx
jmpq 12b6 <func0+0xb7>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r15d, ecx
mov [rsp+48h+var_48], r8
test esi, esi
jle loc_1375
mov r14, rdi
mov r13, rdx
mov r12d, esi
mov esi, 0
mov ebx, 0
jmp short loc_125E
loc_1235:
mov rax, [r14+rsi*8]
lea edx, [rdx-1]
lea rcx, [rax+rdx*4+4]
loc_1241:
mov edx, [rax]
cmp ebx, edx
cmovl ebx, edx
add rax, 4
cmp rax, rcx
jnz short loc_1241
loc_1251:
add rsi, 1
cmp rsi, r12
jz loc_1351
loc_125E:
mov edx, [r13+rsi*4+0]
test edx, edx
jg short loc_1235
jmp short loc_1251
loc_1269:
mov rax, [r14+rsi*8]
lea edx, [rdx-1]
lea rcx, [rax+rdx*4+4]
loc_1275:
movsxd rdx, dword ptr [rax]
add dword ptr [rbp+rdx*4+0], 1
add rax, 4
cmp rcx, rax
jnz short loc_1275
loc_1286:
add rsi, 1
cmp rsi, r12
jz short loc_129A
loc_128F:
mov edx, [r13+rsi*4+0]
test edx, edx
jg short loc_1269
jmp short loc_1286
loc_129A:
mov rdi, [rsp+48h+var_40]
shl rdi, 3
call _malloc
mov r12, rax
test ebx, ebx
js short loc_12E0
loc_12AF:
lea edi, [rbx+1]
mov eax, 0
mov ecx, 0
jmp short loc_12C7
loc_12BE:
add rax, 1
cmp rax, rdi
jz short loc_12E5
loc_12C7:
mov edx, [rbp+rax*4+0]
test edx, edx
jle short loc_12BE
movsxd rsi, ecx
lea rsi, [r12+rsi*8]
mov [rsi], eax
mov [rsi+4], edx
add ecx, 1
jmp short loc_12BE
loc_12E0:
mov ecx, 0
loc_12E5:
movsxd rsi, ecx
lea rcx, compare
mov edx, 8
mov rdi, r12
call _qsort
movsxd rdi, r15d
shl rdi, 2
call _malloc
mov rbx, rax
test r15d, r15d
jle short loc_1328
mov ecx, r15d
mov eax, 0
loc_1318:
mov edx, [r12+rax*8]
mov [rbx+rax*4], edx
add rax, 1
cmp rax, rcx
jnz short loc_1318
loc_1328:
mov rax, [rsp+48h+var_48]
mov [rax], r15d
mov rdi, rbp
call _free
mov rdi, r12
call _free
mov rax, rbx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1351:
lea eax, [rbx+1]
cdqe
mov [rsp+48h+var_40], rax
mov esi, 4
mov rdi, rax
call _calloc
mov rbp, rax
mov esi, 0
jmp loc_128F
loc_1375:
mov esi, 4
mov edi, 1
call _calloc
mov rbp, rax
mov edi, 8
call _malloc
mov r12, rax
mov ebx, 0
jmp loc_12AF | long long func0(long long a1, int a2, long long a3, int a4, int *a5)
{
long long v7; // r12
long long v8; // rsi
int v9; // ebx
int *v10; // rax
long long v11; // rcx
int v12; // edx
int *v13; // rax
long long v14; // rcx
long long i; // rsi
int v16; // edx
long long v17; // r12
long long v18; // rax
int v19; // ecx
int v20; // edx
_DWORD *v21; // rsi
long long v22; // rbx
long long v23; // rax
long long v25; // rbp
if ( a2 <= 0 )
{
v25 = calloc(1LL, 4LL);
v17 = malloc(8LL);
v9 = 0;
}
else
{
v7 = (unsigned int)a2;
v8 = 0LL;
v9 = 0;
do
{
v12 = *(_DWORD *)(a3 + 4 * v8);
if ( v12 > 0 )
{
v10 = *(int **)(a1 + 8 * v8);
v11 = (long long)&v10[v12 - 1 + 1];
do
{
if ( v9 < *v10 )
v9 = *v10;
++v10;
}
while ( v10 != (int *)v11 );
}
++v8;
}
while ( v8 != v7 );
v25 = calloc(v9 + 1, 4LL);
for ( i = 0LL; i != v7; ++i )
{
v16 = *(_DWORD *)(a3 + 4 * i);
if ( v16 > 0 )
{
v13 = *(int **)(a1 + 8 * i);
v14 = (long long)&v13[v16 - 1 + 1];
do
++*(_DWORD *)(v25 + 4LL * *v13++);
while ( (int *)v14 != v13 );
}
}
v17 = malloc(8LL * (v9 + 1));
if ( v9 < 0 )
{
v19 = 0;
goto LABEL_21;
}
}
v18 = 0LL;
v19 = 0;
do
{
v20 = *(_DWORD *)(v25 + 4 * v18);
if ( v20 > 0 )
{
v21 = (_DWORD *)(v17 + 8LL * v19);
*v21 = v18;
v21[1] = v20;
++v19;
}
++v18;
}
while ( v18 != v9 + 1 );
LABEL_21:
qsort(v17, v19, 8LL, compare);
v22 = malloc(4LL * a4);
if ( a4 > 0 )
{
v23 = 0LL;
do
{
*(_DWORD *)(v22 + 4 * v23) = *(_DWORD *)(v17 + 8 * v23);
++v23;
}
while ( v23 != a4 );
}
*a5 = a4;
free(v25);
free(v17);
return v22;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R15D,ECX
MOV qword ptr [RSP],R8
TEST ESI,ESI
JLE 0x00101375
MOV R14,RDI
MOV R13,RDX
MOV R12D,ESI
MOV ESI,0x0
MOV EBX,0x0
JMP 0x0010125e
LAB_00101235:
MOV RAX,qword ptr [R14 + RSI*0x8]
LEA EDX,[RDX + -0x1]
LEA RCX,[RAX + RDX*0x4 + 0x4]
LAB_00101241:
MOV EDX,dword ptr [RAX]
CMP EBX,EDX
CMOVL EBX,EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101241
LAB_00101251:
ADD RSI,0x1
CMP RSI,R12
JZ 0x00101351
LAB_0010125e:
MOV EDX,dword ptr [R13 + RSI*0x4]
TEST EDX,EDX
JG 0x00101235
JMP 0x00101251
LAB_00101269:
MOV RAX,qword ptr [R14 + RSI*0x8]
LEA EDX,[RDX + -0x1]
LEA RCX,[RAX + RDX*0x4 + 0x4]
LAB_00101275:
MOVSXD RDX,dword ptr [RAX]
ADD dword ptr [RBP + RDX*0x4],0x1
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101275
LAB_00101286:
ADD RSI,0x1
CMP RSI,R12
JZ 0x0010129a
LAB_0010128f:
MOV EDX,dword ptr [R13 + RSI*0x4]
TEST EDX,EDX
JG 0x00101269
JMP 0x00101286
LAB_0010129a:
MOV RDI,qword ptr [RSP + 0x8]
SHL RDI,0x3
CALL 0x001010f0
MOV R12,RAX
TEST EBX,EBX
JS 0x001012e0
LAB_001012af:
LEA EDI,[RBX + 0x1]
MOV EAX,0x0
MOV ECX,0x0
JMP 0x001012c7
LAB_001012be:
ADD RAX,0x1
CMP RAX,RDI
JZ 0x001012e5
LAB_001012c7:
MOV EDX,dword ptr [RBP + RAX*0x4]
TEST EDX,EDX
JLE 0x001012be
MOVSXD RSI,ECX
LEA RSI,[R12 + RSI*0x8]
MOV dword ptr [RSI],EAX
MOV dword ptr [RSI + 0x4],EDX
ADD ECX,0x1
JMP 0x001012be
LAB_001012e0:
MOV ECX,0x0
LAB_001012e5:
MOVSXD RSI,ECX
LEA RCX,[0x1011e9]
MOV EDX,0x8
MOV RDI,R12
CALL 0x001010b0
MOVSXD RDI,R15D
SHL RDI,0x2
CALL 0x001010f0
MOV RBX,RAX
TEST R15D,R15D
JLE 0x00101328
MOV ECX,R15D
MOV EAX,0x0
LAB_00101318:
MOV EDX,dword ptr [R12 + RAX*0x8]
MOV dword ptr [RBX + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101318
LAB_00101328:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX],R15D
MOV RDI,RBP
CALL 0x001010a0
MOV RDI,R12
CALL 0x001010a0
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101351:
LEA EAX,[RBX + 0x1]
CDQE
MOV qword ptr [RSP + 0x8],RAX
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010e0
MOV RBP,RAX
MOV ESI,0x0
JMP 0x0010128f
LAB_00101375:
MOV ESI,0x4
MOV EDI,0x1
CALL 0x001010e0
MOV RBP,RAX
MOV EDI,0x8
CALL 0x001010f0
MOV R12,RAX
MOV EBX,0x0
JMP 0x001012af | void * func0(long param_1,uint param_2,long param_3,uint param_4,uint *param_5)
{
int4 *puVar1;
int *piVar2;
int *piVar3;
int iVar4;
int *piVar5;
void *__base;
void *pvVar6;
void *__ptr;
int iVar7;
int iVar8;
ulong uVar9;
if ((int)param_2 < 1) {
__ptr = calloc(1,4);
__base = malloc(8);
iVar8 = 0;
}
else {
uVar9 = 0;
iVar8 = 0;
do {
iVar7 = *(int *)(param_3 + uVar9 * 4);
if (0 < iVar7) {
piVar5 = *(int **)(param_1 + uVar9 * 8);
piVar2 = piVar5 + (ulong)(iVar7 - 1) + 1;
do {
if (iVar8 < *piVar5) {
iVar8 = *piVar5;
}
piVar5 = piVar5 + 1;
} while (piVar5 != piVar2);
}
uVar9 = uVar9 + 1;
} while (uVar9 != param_2);
__ptr = calloc((long)(iVar8 + 1),4);
uVar9 = 0;
do {
iVar7 = *(int *)(param_3 + uVar9 * 4);
if (0 < iVar7) {
piVar5 = *(int **)(param_1 + uVar9 * 8);
piVar2 = piVar5 + (ulong)(iVar7 - 1) + 1;
do {
piVar3 = (int *)((long)__ptr + (long)*piVar5 * 4);
*piVar3 = *piVar3 + 1;
piVar5 = piVar5 + 1;
} while (piVar2 != piVar5);
}
uVar9 = uVar9 + 1;
} while (uVar9 != param_2);
__base = malloc((long)(iVar8 + 1) << 3);
if (iVar8 < 0) {
iVar7 = 0;
goto LAB_001012e5;
}
}
uVar9 = 0;
iVar7 = 0;
do {
iVar4 = *(int *)((long)__ptr + uVar9 * 4);
if (0 < iVar4) {
puVar1 = (int4 *)((long)__base + (long)iVar7 * 8);
*puVar1 = (int)uVar9;
puVar1[1] = iVar4;
iVar7 = iVar7 + 1;
}
uVar9 = uVar9 + 1;
} while (uVar9 != iVar8 + 1);
LAB_001012e5:
qsort(__base,(long)iVar7,8,compare);
pvVar6 = malloc((long)(int)param_4 << 2);
if (0 < (int)param_4) {
uVar9 = 0;
do {
*(int4 *)((long)pvVar6 + uVar9 * 4) = *(int4 *)((long)__base + uVar9 * 8);
uVar9 = uVar9 + 1;
} while (uVar9 != param_4);
}
*param_5 = param_4;
free(__ptr);
free(__base);
return pvVar6;
} |
4,018 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int key;
int count;
} Element;
int compare(const void* a, const void* b) {
Element* ea = (Element*)a;
Element* eb = (Element*)b;
if (eb->count != ea->count)
return eb->count - ea->count;
return ea->key - eb->key;
}
| int* func0(int** nums, int numsSize, int* numsColSizes, int k, int* returnSize) {
// Find the maximum possible key to size the frequency array
int max_key = 0;
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
if(nums[i][j] > max_key)
max_key = nums[i][j];
}
}
// Frequency array
int* freq = (int*)calloc(max_key + 1, sizeof(int));
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
freq[nums[i][j]] += 1;
}
}
// Collect elements with their counts
Element* elements = (Element*)malloc((max_key + 1) * sizeof(Element));
int count = 0;
for(int i = 0; i <= max_key; i++) {
if(freq[i] > 0) {
elements[count].key = i;
elements[count].count = freq[i];
count++;
}
}
// Sort the elements
qsort(elements, count, sizeof(Element), compare);
// Prepare the result
int* result = (int*)malloc(k * sizeof(int));
for(int i = 0; i < k; i++) {
result[i] = elements[i].key;
}
*returnSize = k;
free(freq);
free(elements);
return result;
}
| int main() {
// First test case
int row0[] = {1, 2, 6};
int row1[] = {1, 3, 4, 5, 7, 8};
int row2[] = {1, 3, 5, 6, 8, 9};
int row3[] = {2, 5, 7, 11};
int row4[] = {1, 4, 7, 8, 12};
int* nums1[] = {row0, row1, row2, row3, row4};
int numsColSizes1[] = {3, 6, 6, 4, 5};
int returnSize1;
int* res1 = func0(nums1, 5, numsColSizes1, 3, &returnSize1);
int expected1[] = {1, 5, 7};
for(int i = 0; i < 3; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Second test case
int returnSize2;
int* res2 = func0(nums1, 5, numsColSizes1, 1, &returnSize2);
int expected2[] = {1};
for(int i = 0; i < 1; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Third test case
int returnSize3;
int* res3 = func0(nums1, 5, numsColSizes1, 5, &returnSize3);
int expected3[] = {1, 5, 7, 8, 2};
for(int i = 0; i < 5; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %ecx,%ebp
push %rbx
sub $0x18,%rsp
mov %r8,(%rsp)
test %esi,%esi
jle 163d <func0+0x18d>
mov %rdi,%r13
mov %rdx,%r14
lea -0x1(%rsi),%r15d
xor %edi,%edi
xor %ebx,%ebx
xchg %ax,%ax
mov (%r14,%rdi,4),%eax
test %eax,%eax
jle 1515 <func0+0x65>
mov 0x0(%r13,%rdi,8),%rdx
lea -0x1(%rax),%ecx
lea 0x4(%rdx),%rax
lea (%rax,%rcx,4),%rsi
jmp 1504 <func0+0x54>
nopw 0x0(%rax,%rax,1)
add $0x4,%rax
movslq (%rdx),%rcx
mov %rax,%rdx
cmp %ecx,%ebx
cmovl %rcx,%rbx
cmp %rax,%rsi
jne 1500 <func0+0x50>
lea 0x1(%rdi),%rax
cmp %r15,%rdi
je 1528 <func0+0x78>
mov %rax,%rdi
jmp 14e0 <func0+0x30>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rbx),%edi
mov $0x4,%esi
movslq %edi,%rdi
mov %rdi,0x8(%rsp)
callq 10e0 <calloc@plt>
mov 0x8(%rsp),%rdi
xor %esi,%esi
mov %rax,%r12
nopw 0x0(%rax,%rax,1)
mov (%r14,%rsi,4),%eax
test %eax,%eax
jle 1584 <func0+0xd4>
mov 0x0(%r13,%rsi,8),%rcx
lea -0x1(%rax),%edx
lea 0x4(%rcx),%rax
lea (%rax,%rdx,4),%rdx
jmp 1574 <func0+0xc4>
nopw 0x0(%rax,%rax,1)
add $0x4,%rax
movslq (%rcx),%rcx
addl $0x1,(%r12,%rcx,4)
mov %rax,%rcx
cmp %rax,%rdx
jne 1570 <func0+0xc0>
lea 0x1(%rsi),%rax
cmp %r15,%rsi
je 1598 <func0+0xe8>
mov %rax,%rsi
jmp 1550 <func0+0xa0>
nopw 0x0(%rax,%rax,1)
shl $0x3,%rdi
callq 10f0 <malloc@plt>
xor %ecx,%ecx
xor %esi,%esi
mov %rax,%r13
xor %eax,%eax
jmp 15b3 <func0+0x103>
nopl 0x0(%rax)
mov %rdx,%rax
mov (%r12,%rax,4),%edx
test %edx,%edx
jle 15cb <func0+0x11b>
lea 0x0(%r13,%rsi,8),%rsi
add $0x1,%ecx
mov %eax,(%rsi)
mov %edx,0x4(%rsi)
movslq %ecx,%rsi
lea 0x1(%rax),%rdx
cmp %rax,%rbx
jne 15b0 <func0+0x100>
mov $0x8,%edx
lea -0x150(%rip),%rcx
mov %r13,%rdi
callq 10b0 <qsort@plt>
movslq %ebp,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
xor %edx,%edx
mov %rax,%r14
lea -0x1(%rbp),%eax
test %ebp,%ebp
jle 1615 <func0+0x165>
mov 0x0(%r13,%rdx,8),%ecx
mov %ecx,(%r14,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rax,%rcx
jne 1600 <func0+0x150>
mov (%rsp),%rax
mov %r12,%rdi
mov %ebp,(%rax)
callq 10a0 <free@plt>
mov %r13,%rdi
callq 10a0 <free@plt>
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%edi
mov $0x4,%esi
xor %ebx,%ebx
callq 10e0 <calloc@plt>
mov $0x8,%edi
mov %rax,%r12
jmpq 159c <func0+0xec>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov ebp, ecx
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], r8
test esi, esi
jle loc_1622
movsxd r15, esi
mov r13, rdi
mov r14, rdx
xor esi, esi
xor ebx, ebx
nop dword ptr [rax]
loc_14E0:
mov eax, [r14+rsi*4]
test eax, eax
jle short loc_1515
mov rdx, [r13+rsi*8+0]
lea ecx, [rax-1]
lea rax, [rdx+4]
lea rcx, [rax+rcx*4]
jmp short loc_1504
loc_1500:
add rax, 4
loc_1504:
movsxd rdx, dword ptr [rdx]
cmp ebx, edx
cmovl rbx, rdx
mov rdx, rax
cmp rcx, rax
jnz short loc_1500
loc_1515:
add rsi, 1
cmp rsi, r15
jnz short loc_14E0
lea edi, [rbx+1]
mov esi, 4
movsxd rdi, edi
mov [rsp+48h+var_40], rdi
call _calloc
mov rdi, [rsp+48h+var_40]
xor esi, esi
mov r12, rax
nop dword ptr [rax]
loc_1540:
mov eax, [r14+rsi*4]
test eax, eax
jle short loc_1574
mov rdx, [r13+rsi*8+0]
lea ecx, [rax-1]
lea rax, [rdx+4]
lea rcx, [rax+rcx*4]
jmp short loc_1564
loc_1560:
add rax, 4
loc_1564:
movsxd rdx, dword ptr [rdx]
add dword ptr [r12+rdx*4], 1
mov rdx, rax
cmp rcx, rax
jnz short loc_1560
loc_1574:
add rsi, 1
cmp rsi, r15
jnz short loc_1540
shl rdi, 3
loc_1581:
call _malloc
xor ecx, ecx
mov r13, rax
xor eax, eax
jmp short loc_1593
loc_1590:
mov rax, rdx
loc_1593:
mov edx, [r12+rax*4]
test edx, edx
jle short loc_15AB
movsxd rsi, ecx
add ecx, 1
lea rsi, [r13+rsi*8+0]
mov [rsi], eax
mov [rsi+4], edx
loc_15AB:
lea rdx, [rax+1]
cmp rbx, rax
jnz short loc_1590
movsxd rsi, ecx
mov edx, 8
mov rdi, r13
movsxd rbx, ebp
lea rcx, compare
call _qsort
lea rdi, ds:0[rbx*4]
call _malloc
xor edx, edx
mov r14, rax
test ebp, ebp
jle short loc_15FA
nop dword ptr [rax+00h]
loc_15E8:
mov ecx, [r13+rdx*8+0]
mov [r14+rdx*4], ecx
add rdx, 1
cmp rbx, rdx
jnz short loc_15E8
loc_15FA:
mov rax, [rsp+48h+var_48]
mov rdi, r12
mov [rax], ebp
call _free
mov rdi, r13
call _free
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1622:
mov edi, 1
mov esi, 4
xor ebx, ebx
call _calloc
mov edi, 8
mov r12, rax
jmp loc_1581 | long long func0(long long a1, int a2, long long a3, int a4, int *a5)
{
long long v6; // r15
long long v8; // rsi
long long v9; // rbx
int v10; // eax
int *v11; // rdx
long long v12; // rcx
int *v13; // rax
long long v14; // rcx
long long v15; // rdx
long long v16; // rsi
int *v17; // rdx
long long v18; // r12
int v19; // eax
long long v20; // rcx
int *v21; // rax
long long v22; // rcx
long long v23; // rdi
long long v24; // rax
int v25; // ecx
long long v26; // r13
long long i; // rax
int v28; // edx
long long v29; // rsi
_DWORD *v30; // rsi
long long v31; // rsi
long long v32; // rdx
long long v33; // rax
long long v34; // rdx
long long v35; // r14
long long v36; // rdx
if ( a2 <= 0 )
{
v16 = 4LL;
v9 = 0LL;
v23 = 8LL;
v18 = calloc(1LL, 4LL);
}
else
{
v6 = a2;
v8 = 0LL;
v9 = 0LL;
do
{
v10 = *(_DWORD *)(a3 + 4 * v8);
if ( v10 > 0 )
{
v11 = *(int **)(a1 + 8 * v8);
v12 = (unsigned int)(v10 - 1);
v13 = v11 + 1;
v14 = (long long)&v11[v12 + 1];
while ( 1 )
{
v15 = *v11;
if ( (int)v9 < (int)v15 )
v9 = v15;
v11 = v13;
if ( (int *)v14 == v13 )
break;
++v13;
}
}
++v8;
}
while ( v8 != v6 );
v16 = 0LL;
v18 = calloc((int)v9 + 1, 4LL);
do
{
v19 = *(_DWORD *)(a3 + 4 * v16);
if ( v19 > 0 )
{
v17 = *(int **)(a1 + 8 * v16);
v20 = (unsigned int)(v19 - 1);
v21 = v17 + 1;
v22 = (long long)&v17[v20 + 1];
while ( 1 )
{
++*(_DWORD *)(v18 + 4LL * *v17);
v17 = v21;
if ( (int *)v22 == v21 )
break;
++v21;
}
}
++v16;
}
while ( v16 != v6 );
v23 = 8LL * ((int)v9 + 1);
}
v24 = malloc(v23, v16, v17);
v25 = 0;
v26 = v24;
for ( i = 0LL; ; ++i )
{
v28 = *(_DWORD *)(v18 + 4 * i);
if ( v28 > 0 )
{
v29 = v25++;
v30 = (_DWORD *)(v26 + 8 * v29);
*v30 = i;
v30[1] = v28;
}
if ( v9 == i )
break;
}
v31 = v25;
qsort(v26, v25, 8LL, compare);
v33 = malloc(4LL * a4, v31, v32);
v34 = 0LL;
v35 = v33;
if ( a4 > 0 )
{
do
{
*(_DWORD *)(v33 + 4 * v34) = *(_DWORD *)(v26 + 8 * v34);
++v34;
}
while ( a4 != v34 );
}
*a5 = a4;
free(v18, v31, v34);
free(v26, v31, v36);
return v35;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ECX
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],R8
TEST ESI,ESI
JLE 0x00101622
MOVSXD R15,ESI
MOV R13,RDI
MOV R14,RDX
XOR ESI,ESI
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_001014e0:
MOV EAX,dword ptr [R14 + RSI*0x4]
TEST EAX,EAX
JLE 0x00101515
MOV RDX,qword ptr [R13 + RSI*0x8]
LEA ECX,[RAX + -0x1]
LEA RAX,[RDX + 0x4]
LEA RCX,[RAX + RCX*0x4]
JMP 0x00101504
LAB_00101500:
ADD RAX,0x4
LAB_00101504:
MOVSXD RDX,dword ptr [RDX]
CMP EBX,EDX
CMOVL RBX,RDX
MOV RDX,RAX
CMP RCX,RAX
JNZ 0x00101500
LAB_00101515:
ADD RSI,0x1
CMP RSI,R15
JNZ 0x001014e0
LEA EDI,[RBX + 0x1]
MOV ESI,0x4
MOVSXD RDI,EDI
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001010e0
MOV RDI,qword ptr [RSP + 0x8]
XOR ESI,ESI
MOV R12,RAX
NOP dword ptr [RAX]
LAB_00101540:
MOV EAX,dword ptr [R14 + RSI*0x4]
TEST EAX,EAX
JLE 0x00101574
MOV RDX,qword ptr [R13 + RSI*0x8]
LEA ECX,[RAX + -0x1]
LEA RAX,[RDX + 0x4]
LEA RCX,[RAX + RCX*0x4]
JMP 0x00101564
LAB_00101560:
ADD RAX,0x4
LAB_00101564:
MOVSXD RDX,dword ptr [RDX]
ADD dword ptr [R12 + RDX*0x4],0x1
MOV RDX,RAX
CMP RCX,RAX
JNZ 0x00101560
LAB_00101574:
ADD RSI,0x1
CMP RSI,R15
JNZ 0x00101540
SHL RDI,0x3
LAB_00101581:
CALL 0x001010f0
XOR ECX,ECX
MOV R13,RAX
XOR EAX,EAX
JMP 0x00101593
LAB_00101590:
MOV RAX,RDX
LAB_00101593:
MOV EDX,dword ptr [R12 + RAX*0x4]
TEST EDX,EDX
JLE 0x001015ab
MOVSXD RSI,ECX
ADD ECX,0x1
LEA RSI,[R13 + RSI*0x8]
MOV dword ptr [RSI],EAX
MOV dword ptr [RSI + 0x4],EDX
LAB_001015ab:
LEA RDX,[RAX + 0x1]
CMP RBX,RAX
JNZ 0x00101590
MOVSXD RSI,ECX
MOV EDX,0x8
MOV RDI,R13
MOVSXD RBX,EBP
LEA RCX,[0x101490]
CALL 0x001010b0
LEA RDI,[RBX*0x4]
CALL 0x001010f0
XOR EDX,EDX
MOV R14,RAX
TEST EBP,EBP
JLE 0x001015fa
NOP dword ptr [RAX]
LAB_001015e8:
MOV ECX,dword ptr [R13 + RDX*0x8]
MOV dword ptr [R14 + RDX*0x4],ECX
ADD RDX,0x1
CMP RBX,RDX
JNZ 0x001015e8
LAB_001015fa:
MOV RAX,qword ptr [RSP]
MOV RDI,R12
MOV dword ptr [RAX],EBP
CALL 0x001010a0
MOV RDI,R13
CALL 0x001010a0
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101622:
MOV EDI,0x1
MOV ESI,0x4
XOR EBX,EBX
CALL 0x001010e0
MOV EDI,0x8
MOV R12,RAX
JMP 0x00101581 | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
int *piVar1;
int4 *puVar2;
int iVar3;
int *piVar4;
void *__ptr;
int *piVar5;
void *__base;
void *pvVar6;
int iVar7;
int *piVar8;
long lVar9;
long lVar10;
long lVar11;
size_t sVar12;
bool bVar13;
if (param_2 < 1) {
lVar9 = 0;
__ptr = calloc(1,4);
sVar12 = 8;
}
else {
lVar10 = 0;
lVar9 = 0;
do {
iVar7 = *(int *)(param_3 + lVar10 * 4);
if (0 < iVar7) {
piVar8 = *(int **)(param_1 + lVar10 * 8);
piVar1 = piVar8 + 1;
piVar4 = piVar1;
while( true ) {
piVar5 = piVar4;
if ((int)lVar9 < *piVar8) {
lVar9 = (long)*piVar8;
}
if (piVar1 + (iVar7 - 1) == piVar5) break;
piVar4 = piVar5 + 1;
piVar8 = piVar5;
}
}
lVar10 = lVar10 + 1;
} while (lVar10 != param_2);
sVar12 = (size_t)((int)lVar9 + 1);
__ptr = calloc(sVar12,4);
lVar10 = 0;
do {
iVar7 = *(int *)(param_3 + lVar10 * 4);
if (0 < iVar7) {
piVar8 = *(int **)(param_1 + lVar10 * 8);
piVar1 = piVar8 + 1;
piVar4 = piVar1;
while (piVar5 = piVar4, piVar8 = (int *)((long)__ptr + (long)*piVar8 * 4),
*piVar8 = *piVar8 + 1, piVar1 + (iVar7 - 1) != piVar5) {
piVar8 = piVar5;
piVar4 = piVar5 + 1;
}
}
lVar10 = lVar10 + 1;
} while (lVar10 != param_2);
sVar12 = sVar12 << 3;
}
__base = malloc(sVar12);
iVar7 = 0;
lVar10 = 0;
do {
iVar3 = *(int *)((long)__ptr + lVar10 * 4);
if (0 < iVar3) {
lVar11 = (long)iVar7;
iVar7 = iVar7 + 1;
puVar2 = (int4 *)((long)__base + lVar11 * 8);
*puVar2 = (int)lVar10;
puVar2[1] = iVar3;
}
bVar13 = lVar9 != lVar10;
lVar10 = lVar10 + 1;
} while (bVar13);
qsort(__base,(long)iVar7,8,compare);
pvVar6 = malloc((long)param_4 * 4);
lVar9 = 0;
if (0 < param_4) {
do {
*(int4 *)((long)pvVar6 + lVar9 * 4) = *(int4 *)((long)__base + lVar9 * 8);
lVar9 = lVar9 + 1;
} while (param_4 != lVar9);
}
*param_5 = param_4;
free(__ptr);
free(__base);
return pvVar6;
} |
4,019 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int key;
int count;
} Element;
int compare(const void* a, const void* b) {
Element* ea = (Element*)a;
Element* eb = (Element*)b;
if (eb->count != ea->count)
return eb->count - ea->count;
return ea->key - eb->key;
}
| int* func0(int** nums, int numsSize, int* numsColSizes, int k, int* returnSize) {
// Find the maximum possible key to size the frequency array
int max_key = 0;
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
if(nums[i][j] > max_key)
max_key = nums[i][j];
}
}
// Frequency array
int* freq = (int*)calloc(max_key + 1, sizeof(int));
for(int i = 0; i < numsSize; i++) {
for(int j = 0; j < numsColSizes[i]; j++) {
freq[nums[i][j]] += 1;
}
}
// Collect elements with their counts
Element* elements = (Element*)malloc((max_key + 1) * sizeof(Element));
int count = 0;
for(int i = 0; i <= max_key; i++) {
if(freq[i] > 0) {
elements[count].key = i;
elements[count].count = freq[i];
count++;
}
}
// Sort the elements
qsort(elements, count, sizeof(Element), compare);
// Prepare the result
int* result = (int*)malloc(k * sizeof(int));
for(int i = 0; i < k; i++) {
result[i] = elements[i].key;
}
*returnSize = k;
free(freq);
free(elements);
return result;
}
| int main() {
// First test case
int row0[] = {1, 2, 6};
int row1[] = {1, 3, 4, 5, 7, 8};
int row2[] = {1, 3, 5, 6, 8, 9};
int row3[] = {2, 5, 7, 11};
int row4[] = {1, 4, 7, 8, 12};
int* nums1[] = {row0, row1, row2, row3, row4};
int numsColSizes1[] = {3, 6, 6, 4, 5};
int returnSize1;
int* res1 = func0(nums1, 5, numsColSizes1, 3, &returnSize1);
int expected1[] = {1, 5, 7};
for(int i = 0; i < 3; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Second test case
int returnSize2;
int* res2 = func0(nums1, 5, numsColSizes1, 1, &returnSize2);
int expected2[] = {1};
for(int i = 0; i < 1; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Third test case
int returnSize3;
int* res3 = func0(nums1, 5, numsColSizes1, 5, &returnSize3);
int expected3[] = {1, 5, 7, 8, 2};
for(int i = 0; i < 5; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %r8,%rbp
push %rbx
mov %ecx,%ebx
sub $0x18,%rsp
test %esi,%esi
jle 1726 <func0+0x2b6>
lea -0x1(%rsi),%r8d
mov %rdi,%r14
mov %rdx,%r15
xor %esi,%esi
xor %r12d,%r12d
xchg %ax,%ax
mov (%r15,%rsi,4),%ecx
test %ecx,%ecx
jle 1581 <func0+0x111>
lea -0x1(%rcx),%eax
mov (%r14,%rsi,8),%rdi
cmp $0x2,%eax
jbe 171f <func0+0x2af>
mov %ecx,%edx
movd %r12d,%xmm3
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
nopl (%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 14d8 <func0+0x68>
movdqa %xmm2,%xmm0
mov %ecx,%eax
psrldq $0x8,%xmm0
and $0xfffffffc,%eax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%r12d
test $0x3,%cl
je 1581 <func0+0x111>
movslq %eax,%rdx
lea 0x0(,%rdx,4),%r9
mov (%rdi,%rdx,4),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
lea 0x1(%rax),%edx
cmp %edx,%ecx
jle 1581 <func0+0x111>
mov 0x4(%rdi,%r9,1),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
add $0x2,%eax
cmp %eax,%ecx
jle 1581 <func0+0x111>
mov 0x8(%rdi,%r9,1),%eax
cmp %eax,%r12d
cmovl %eax,%r12d
lea 0x1(%rsi),%rax
cmp %r8,%rsi
je 1598 <func0+0x128>
mov %rax,%rsi
jmpq 14a0 <func0+0x30>
nopw 0x0(%rax,%rax,1)
lea 0x1(%r12),%edi
mov $0x4,%esi
mov %r8,0x8(%rsp)
movslq %edi,%rdi
mov %rdi,(%rsp)
callq 10e0 <calloc@plt>
mov (%rsp),%rdi
mov 0x8(%rsp),%r8
xor %esi,%esi
mov %rax,%r13
nopl 0x0(%rax)
mov (%r15,%rsi,4),%eax
test %eax,%eax
jle 15fd <func0+0x18d>
mov (%r14,%rsi,8),%rcx
lea -0x1(%rax),%edx
lea 0x4(%rcx),%rax
lea (%rax,%rdx,4),%rdx
jmp 15ec <func0+0x17c>
nopl 0x0(%rax)
add $0x4,%rax
movslq (%rcx),%rcx
addl $0x1,0x0(%r13,%rcx,4)
mov %rax,%rcx
cmp %rdx,%rax
jne 15e8 <func0+0x178>
lea 0x1(%rsi),%rax
cmp %r8,%rsi
je 1610 <func0+0x1a0>
mov %rax,%rsi
jmp 15c8 <func0+0x158>
nopl 0x0(%rax,%rax,1)
shl $0x3,%rdi
callq 10f0 <malloc@plt>
movslq %r12d,%r12
xor %ecx,%ecx
xor %esi,%esi
mov %rax,%r14
xor %eax,%eax
jmp 1633 <func0+0x1c3>
nopw 0x0(%rax,%rax,1)
mov %rdx,%rax
mov 0x0(%r13,%rax,4),%edx
test %edx,%edx
jle 164b <func0+0x1db>
lea (%r14,%rsi,8),%rsi
add $0x1,%ecx
mov %eax,(%rsi)
mov %edx,0x4(%rsi)
movslq %ecx,%rsi
lea 0x1(%rax),%rdx
cmp %rax,%r12
jne 1630 <func0+0x1c0>
lea -0x20b(%rip),%rcx
mov $0x8,%edx
mov %r14,%rdi
callq 10b0 <qsort@plt>
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 16fa <func0+0x28a>
lea -0x1(%rbx),%eax
cmp $0x3,%eax
jbe 1745 <func0+0x2d5>
mov %eax,%ecx
xor %edx,%edx
shr $0x2,%ecx
shl $0x4,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%r14,%rdx,2),%xmm0
movdqu 0x10(%r14,%rdx,2),%xmm4
shufps $0x88,%xmm4,%xmm0
movups %xmm0,(%r12,%rdx,1)
add $0x10,%rdx
cmp %rcx,%rdx
jne 1698 <func0+0x228>
and $0xfffffffc,%eax
movslq %eax,%rdx
mov (%r14,%rdx,8),%ecx
mov %ecx,(%r12,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%ebx
jle 16fa <func0+0x28a>
movslq %edx,%rdx
mov (%r14,%rdx,8),%ecx
mov %ecx,(%r12,%rdx,4)
lea 0x2(%rax),%edx
cmp %edx,%ebx
jle 16fa <func0+0x28a>
movslq %edx,%rdx
add $0x3,%eax
mov (%r14,%rdx,8),%ecx
mov %ecx,(%r12,%rdx,4)
cmp %eax,%ebx
jle 16fa <func0+0x28a>
cltq
mov (%r14,%rax,8),%edx
mov %edx,(%r12,%rax,4)
mov %ebx,0x0(%rbp)
mov %r13,%rdi
callq 10a0 <free@plt>
mov %r14,%rdi
callq 10a0 <free@plt>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %eax,%eax
jmpq 1546 <func0+0xd6>
mov $0x1,%edi
mov $0x4,%esi
xor %r12d,%r12d
callq 10e0 <calloc@plt>
mov $0x8,%edi
mov %rax,%r13
jmpq 1614 <func0+0x1a4>
xor %eax,%eax
jmpq 16ba <func0+0x24a>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, r8
push rbp
mov ebp, ecx
push rbx
sub rsp, 18h
test esi, esi
jle loc_16FA
mov r14, rdi
mov r15, rdx
movsxd r8, esi
xor ecx, ecx
xor ebx, ebx
nop dword ptr [rax+00h]
loc_1470:
mov esi, [r15+rcx*4]
test esi, esi
jle loc_154B
lea eax, [rsi-1]
mov rdi, [r14+rcx*8]
cmp eax, 2
jbe loc_16F3
mov edx, esi
movd xmm3, ebx
mov rax, rdi
shr edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00h]
loc_14A8:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rdx, rax
jnz short loc_14A8
movdqa xmm1, xmm2
psrldq xmm1, 8
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd ebx, xmm1
test sil, 3
jz short loc_154B
mov eax, esi
and eax, 0FFFFFFFCh
loc_1516:
movsxd rdx, eax
lea r9, ds:0[rdx*4]
mov edx, [rdi+rdx*4]
cmp ebx, edx
cmovl ebx, edx
lea edx, [rax+1]
cmp esi, edx
jle short loc_154B
mov edx, [rdi+r9+4]
cmp ebx, edx
cmovl ebx, edx
add eax, 2
cmp esi, eax
jle short loc_154B
mov eax, [rdi+r9+8]
cmp ebx, eax
cmovl ebx, eax
loc_154B:
lea rax, [rcx+1]
cmp r8, rax
jz short loc_1560
mov rcx, rax
jmp loc_1470
loc_1560:
lea r8d, [rbx+1]
mov esi, 4; size
mov [rsp+48h+var_40], rcx
movsxd r8, r8d
mov rdi, r8; nmemb
mov [rsp+48h+var_48], r8
call _calloc
mov r8, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_40]
xor edi, edi
mov r13, rax
nop dword ptr [rax+rax+00h]
loc_1590:
movsxd rdx, dword ptr [r15+rdi*4]
test edx, edx
jle short loc_15B2
mov rax, [r14+rdi*8]
lea rsi, [rax+rdx*4]
loc_15A0:
movsxd rdx, dword ptr [rax]
add rax, 4
add dword ptr [r13+rdx*4+0], 1
cmp rsi, rax
jnz short loc_15A0
loc_15B2:
lea rax, [rdi+1]
cmp rcx, rdi
jz short loc_15C0
mov rdi, rax
jmp short loc_1590
loc_15C0:
lea rdi, ds:0[r8*8]; size
call _malloc
mov r14, rax
test ebx, ebx
js loc_1720
loc_15D8:
movsxd rbx, ebx
xor eax, eax
xor ecx, ecx
jmp short loc_15EB
loc_15E8:
mov rax, rdx
loc_15EB:
mov edx, [r13+rax*4+0]
test edx, edx
jle short loc_160C
movd xmm0, eax
movd xmm5, edx
movsxd rsi, ecx
add ecx, 1
punpckldq xmm0, xmm5
movq qword ptr [r14+rsi*8], xmm0
loc_160C:
lea rdx, [rax+1]
cmp rbx, rax
jnz short loc_15E8
movsxd rsi, ecx; nmemb
loc_1618:
lea rcx, compare; compar
mov edx, 8; size
mov rdi, r14; base
call _qsort
movsxd rdi, ebp
shl rdi, 2; size
call _malloc
mov rbx, rax
test ebp, ebp
jle loc_16CD
lea edx, [rbp-1]
cmp edx, 3
jbe loc_1727
mov ecx, edx
xor eax, eax
shr ecx, 2
shl rcx, 4
nop word ptr [rax+rax+00h]
loc_1660:
movdqu xmm0, xmmword ptr [r14+rax*2]
movdqu xmm4, xmmword ptr [r14+rax*2+10h]
shufps xmm0, xmm4, 88h
movups xmmword ptr [rbx+rax], xmm0
add rax, 10h
cmp rcx, rax
jnz short loc_1660
mov eax, edx
and eax, 0FFFFFFFCh
loc_1683:
movsxd rdx, eax
mov edi, [r14+rdx*8]
lea rsi, ds:0[rdx*8]
lea rcx, ds:0[rdx*4]
mov [rbx+rdx*4], edi
lea edx, [rax+1]
cmp edx, ebp
jge short loc_16CD
mov edx, [r14+rsi+8]
mov [rbx+rcx+4], edx
lea edx, [rax+2]
cmp ebp, edx
jle short loc_16CD
mov edx, [r14+rsi+10h]
add eax, 3
mov [rbx+rcx+8], edx
cmp ebp, eax
jle short loc_16CD
mov eax, [r14+rsi+18h]
mov [rbx+rcx+0Ch], eax
loc_16CD:
mov [r12], ebp
mov rdi, r13; ptr
call _free
mov rdi, r14; ptr
call _free
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16F3:
xor eax, eax
jmp loc_1516
loc_16FA:
mov esi, 4; size
mov edi, 1; nmemb
xor ebx, ebx
call _calloc
mov edi, 8; size
mov r13, rax
call _malloc
mov r14, rax
jmp loc_15D8
loc_1720:
xor esi, esi
jmp loc_1618
loc_1727:
xor eax, eax
jmp loc_1683 | char * func0(long long a1, int a2, long long a3, int a4, int *a5)
{
long long v9; // r8
long long v10; // rcx
signed int v11; // ebx
int v12; // esi
long long v13; // rdi
const __m128i *v14; // rax
__m128i v15; // xmm2
__m128i v16; // xmm0
__m128i v17; // xmm1
__m128i v18; // xmm1
__m128i v19; // xmm0
__m128i v20; // xmm0
__m128i v21; // xmm2
__m128i v22; // xmm1
int v23; // eax
long long v24; // r9
long long v25; // rdi
_DWORD *v26; // r13
long long v27; // rdx
int *v28; // rax
int *v29; // rsi
long long v30; // rdx
_QWORD *v31; // r14
long long v32; // rax
int v33; // ecx
signed int v34; // edx
long long v35; // rsi
size_t v36; // rsi
char *v37; // rbx
unsigned int v38; // edx
long long v39; // rax
signed int v40; // eax
long long v41; // rsi
long long v42; // rcx
long long v44; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
v11 = 0;
v26 = calloc(1uLL, 4uLL);
v31 = malloc(8uLL);
goto LABEL_26;
}
v9 = a2;
v10 = 0LL;
v11 = 0;
while ( 1 )
{
v12 = *(_DWORD *)(a3 + 4 * v10);
if ( v12 <= 0 )
goto LABEL_17;
v13 = *(_QWORD *)(a1 + 8 * v10);
if ( (unsigned int)(v12 - 1) <= 2 )
{
v23 = 0;
}
else
{
v14 = *(const __m128i **)(a1 + 8 * v10);
v15 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v11), 0);
do
{
v16 = _mm_loadu_si128(v14++);
v17 = _mm_cmpgt_epi32(v16, v15);
v15 = _mm_or_si128(_mm_andnot_si128(v17, v15), _mm_and_si128(v16, v17));
}
while ( (const __m128i *)(v13 + 16LL * ((unsigned int)v12 >> 2)) != v14 );
v18 = _mm_srli_si128(v15, 8);
v19 = _mm_cmpgt_epi32(v18, v15);
v20 = _mm_or_si128(_mm_andnot_si128(v19, v15), _mm_and_si128(v18, v19));
v21 = _mm_srli_si128(v20, 4);
v22 = _mm_cmpgt_epi32(v21, v20);
v11 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v22, v20), _mm_and_si128(v21, v22)));
if ( (v12 & 3) == 0 )
goto LABEL_17;
v23 = v12 & 0x7FFFFFFC;
}
v24 = 4LL * v23;
if ( v11 < *(_DWORD *)(v13 + v24) )
v11 = *(_DWORD *)(v13 + 4LL * v23);
if ( v12 > v23 + 1 )
{
if ( v11 < *(_DWORD *)(v13 + v24 + 4) )
v11 = *(_DWORD *)(v13 + v24 + 4);
if ( v12 > v23 + 2 && v11 < *(_DWORD *)(v13 + v24 + 8) )
v11 = *(_DWORD *)(v13 + v24 + 8);
}
LABEL_17:
if ( v9 == v10 + 1 )
break;
++v10;
}
v44 = v10;
v25 = 0LL;
v26 = calloc(v11 + 1, 4uLL);
while ( 1 )
{
v27 = *(int *)(a3 + 4 * v25);
if ( (int)v27 > 0 )
{
v28 = *(int **)(a1 + 8 * v25);
v29 = &v28[v27];
do
{
v30 = *v28++;
++v26[v30];
}
while ( v29 != v28 );
}
if ( v44 == v25 )
break;
++v25;
}
v31 = malloc(8LL * (v11 + 1));
if ( v11 < 0 )
{
v36 = 0LL;
}
else
{
LABEL_26:
v32 = 0LL;
v33 = 0;
while ( 1 )
{
v34 = v26[v32];
if ( v34 > 0 )
{
v35 = v33++;
v31[v35] = _mm_unpacklo_epi32(_mm_cvtsi32_si128(v32), _mm_cvtsi32_si128(v34)).m128i_u64[0];
}
if ( v11 == v32 )
break;
++v32;
}
v36 = v33;
}
qsort(v31, v36, 8uLL, compare);
v37 = (char *)malloc(4LL * a4);
if ( a4 > 0 )
{
v38 = a4 - 1;
if ( (unsigned int)(a4 - 1) <= 3 )
{
v40 = 0;
}
else
{
v39 = 0LL;
do
{
*(__m128 *)&v37[v39 * 4] = _mm_shuffle_ps(
(__m128)_mm_loadu_si128((const __m128i *)&v31[v39]),
(__m128)_mm_loadu_si128((const __m128i *)&v31[v39 + 2]),
136);
v39 += 4LL;
}
while ( 4LL * (v38 >> 2) != v39 );
v40 = v38 & 0xFFFFFFFC;
}
v41 = v40;
v42 = 4LL * v40;
*(_DWORD *)&v37[v42] = v31[v41];
if ( v40 + 1 < a4 )
{
*(_DWORD *)&v37[v42 + 4] = v31[v41 + 1];
if ( a4 > v40 + 2 )
{
*(_DWORD *)&v37[v42 + 8] = v31[v41 + 2];
if ( a4 > v40 + 3 )
*(_DWORD *)&v37[v42 + 12] = v31[v41 + 3];
}
}
}
*a5 = a4;
free(v26);
free(v31);
return v37;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,R8
PUSH RBP
MOV EBP,ECX
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x001016fa
MOV R14,RDI
MOV R15,RDX
MOVSXD R8,ESI
XOR ECX,ECX
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_00101470:
MOV ESI,dword ptr [R15 + RCX*0x4]
TEST ESI,ESI
JLE 0x0010154b
LEA EAX,[RSI + -0x1]
MOV RDI,qword ptr [R14 + RCX*0x8]
CMP EAX,0x2
JBE 0x001016f3
MOV EDX,ESI
MOVD XMM3,EBX
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_001014a8:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RDX,RAX
JNZ 0x001014a8
MOVDQA XMM1,XMM2
PSRLDQ XMM1,0x8
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EBX,XMM1
TEST SIL,0x3
JZ 0x0010154b
MOV EAX,ESI
AND EAX,0xfffffffc
LAB_00101516:
MOVSXD RDX,EAX
LEA R9,[RDX*0x4]
MOV EDX,dword ptr [RDI + RDX*0x4]
CMP EBX,EDX
CMOVL EBX,EDX
LEA EDX,[RAX + 0x1]
CMP ESI,EDX
JLE 0x0010154b
MOV EDX,dword ptr [RDI + R9*0x1 + 0x4]
CMP EBX,EDX
CMOVL EBX,EDX
ADD EAX,0x2
CMP ESI,EAX
JLE 0x0010154b
MOV EAX,dword ptr [RDI + R9*0x1 + 0x8]
CMP EBX,EAX
CMOVL EBX,EAX
LAB_0010154b:
LEA RAX,[RCX + 0x1]
CMP R8,RAX
JZ 0x00101560
MOV RCX,RAX
JMP 0x00101470
LAB_00101560:
LEA R8D,[RBX + 0x1]
MOV ESI,0x4
MOV qword ptr [RSP + 0x8],RCX
MOVSXD R8,R8D
MOV RDI,R8
MOV qword ptr [RSP],R8
CALL 0x001010e0
MOV R8,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
XOR EDI,EDI
MOV R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101590:
MOVSXD RDX,dword ptr [R15 + RDI*0x4]
TEST EDX,EDX
JLE 0x001015b2
MOV RAX,qword ptr [R14 + RDI*0x8]
LEA RSI,[RAX + RDX*0x4]
LAB_001015a0:
MOVSXD RDX,dword ptr [RAX]
ADD RAX,0x4
ADD dword ptr [R13 + RDX*0x4],0x1
CMP RSI,RAX
JNZ 0x001015a0
LAB_001015b2:
LEA RAX,[RDI + 0x1]
CMP RCX,RDI
JZ 0x001015c0
MOV RDI,RAX
JMP 0x00101590
LAB_001015c0:
LEA RDI,[R8*0x8]
CALL 0x001010f0
MOV R14,RAX
TEST EBX,EBX
JS 0x00101720
LAB_001015d8:
MOVSXD RBX,EBX
XOR EAX,EAX
XOR ECX,ECX
JMP 0x001015eb
LAB_001015e8:
MOV RAX,RDX
LAB_001015eb:
MOV EDX,dword ptr [R13 + RAX*0x4]
TEST EDX,EDX
JLE 0x0010160c
MOVD XMM0,EAX
MOVD XMM5,EDX
MOVSXD RSI,ECX
ADD ECX,0x1
PUNPCKLDQ XMM0,XMM5
MOVQ qword ptr [R14 + RSI*0x8],XMM0
LAB_0010160c:
LEA RDX,[RAX + 0x1]
CMP RBX,RAX
JNZ 0x001015e8
MOVSXD RSI,ECX
LAB_00101618:
LEA RCX,[0x101420]
MOV EDX,0x8
MOV RDI,R14
CALL 0x001010b0
MOVSXD RDI,EBP
SHL RDI,0x2
CALL 0x001010f0
MOV RBX,RAX
TEST EBP,EBP
JLE 0x001016cd
LEA EDX,[RBP + -0x1]
CMP EDX,0x3
JBE 0x00101727
MOV ECX,EDX
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101660:
MOVDQU XMM0,xmmword ptr [R14 + RAX*0x2]
MOVDQU XMM4,xmmword ptr [R14 + RAX*0x2 + 0x10]
SHUFPS XMM0,XMM4,0x88
MOVUPS xmmword ptr [RBX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RCX,RAX
JNZ 0x00101660
MOV EAX,EDX
AND EAX,0xfffffffc
LAB_00101683:
MOVSXD RDX,EAX
MOV EDI,dword ptr [R14 + RDX*0x8]
LEA RSI,[RDX*0x8]
LEA RCX,[RDX*0x4]
MOV dword ptr [RBX + RDX*0x4],EDI
LEA EDX,[RAX + 0x1]
CMP EDX,EBP
JGE 0x001016cd
MOV EDX,dword ptr [R14 + RSI*0x1 + 0x8]
MOV dword ptr [RBX + RCX*0x1 + 0x4],EDX
LEA EDX,[RAX + 0x2]
CMP EBP,EDX
JLE 0x001016cd
MOV EDX,dword ptr [R14 + RSI*0x1 + 0x10]
ADD EAX,0x3
MOV dword ptr [RBX + RCX*0x1 + 0x8],EDX
CMP EBP,EAX
JLE 0x001016cd
MOV EAX,dword ptr [R14 + RSI*0x1 + 0x18]
MOV dword ptr [RBX + RCX*0x1 + 0xc],EAX
LAB_001016cd:
MOV dword ptr [R12],EBP
MOV RDI,R13
CALL 0x001010a0
MOV RDI,R14
CALL 0x001010a0
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016f3:
XOR EAX,EAX
JMP 0x00101516
LAB_001016fa:
MOV ESI,0x4
MOV EDI,0x1
XOR EBX,EBX
CALL 0x001010e0
MOV EDI,0x8
MOV R13,RAX
CALL 0x001010f0
MOV R14,RAX
JMP 0x001015d8
LAB_00101720:
XOR ESI,ESI
JMP 0x00101618
LAB_00101727:
XOR EAX,EAX
JMP 0x00101683 | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
int *piVar1;
int4 *puVar2;
int4 *puVar3;
int *piVar4;
uint uVar5;
int iVar6;
uint *puVar7;
uint uVar8;
uint *puVar9;
uint *puVar10;
uint *puVar11;
int4 uVar12;
int4 uVar13;
int4 uVar14;
uint uVar15;
uint *puVar16;
void *__ptr;
int *piVar17;
void *__base;
void *pvVar18;
long lVar19;
int iVar20;
long lVar21;
uint uVar22;
long lVar23;
size_t __nmemb;
bool bVar24;
uint uVar25;
uint uVar26;
uint uVar27;
uint uVar28;
uint uVar29;
uint uVar30;
if (param_2 < 1) {
uVar22 = 0;
__ptr = calloc(1,4);
__base = malloc(8);
}
else {
uVar22 = 0;
lVar19 = 0;
do {
lVar23 = lVar19;
uVar5 = *(uint *)(param_3 + lVar23 * 4);
if (0 < (int)uVar5) {
puVar7 = *(uint **)(param_1 + lVar23 * 8);
if (uVar5 - 1 < 3) {
uVar15 = 0;
}
else {
puVar16 = puVar7;
uVar15 = uVar22;
uVar26 = uVar22;
uVar30 = uVar22;
do {
uVar8 = *puVar16;
puVar9 = puVar16 + 1;
puVar10 = puVar16 + 2;
puVar11 = puVar16 + 3;
puVar16 = puVar16 + 4;
uVar25 = -(uint)((int)uVar22 < (int)uVar8);
uVar27 = -(uint)((int)uVar15 < (int)*puVar9);
uVar28 = -(uint)((int)uVar26 < (int)*puVar10);
uVar29 = -(uint)((int)uVar30 < (int)*puVar11);
uVar22 = ~uVar25 & uVar22 | uVar8 & uVar25;
uVar15 = ~uVar27 & uVar15 | *puVar9 & uVar27;
uVar26 = ~uVar28 & uVar26 | *puVar10 & uVar28;
uVar30 = ~uVar29 & uVar30 | *puVar11 & uVar29;
} while (puVar7 + (ulong)(uVar5 >> 2) * 4 != puVar16);
uVar22 = ~-(uint)((int)uVar22 < (int)uVar26) & uVar22 |
uVar26 & -(uint)((int)uVar22 < (int)uVar26);
uVar15 = ~-(uint)((int)uVar15 < (int)uVar30) & uVar15 |
uVar30 & -(uint)((int)uVar15 < (int)uVar30);
uVar26 = -(uint)((int)uVar22 < (int)uVar15);
uVar22 = ~uVar26 & uVar22 | uVar15 & uVar26;
if ((uVar5 & 3) == 0) goto LAB_0010154b;
uVar15 = uVar5 & 0xfffffffc;
}
if ((int)uVar22 < (int)puVar7[(int)uVar15]) {
uVar22 = puVar7[(int)uVar15];
}
if ((int)(uVar15 + 1) < (int)uVar5) {
if ((int)uVar22 < (int)puVar7[(long)(int)uVar15 + 1]) {
uVar22 = puVar7[(long)(int)uVar15 + 1];
}
if (((int)(uVar15 + 2) < (int)uVar5) && ((int)uVar22 < (int)puVar7[(long)(int)uVar15 + 2])
) {
uVar22 = puVar7[(long)(int)uVar15 + 2];
}
}
}
LAB_0010154b:
lVar19 = lVar23 + 1;
} while ((long)param_2 != lVar23 + 1);
__ptr = calloc((long)(int)(uVar22 + 1),4);
lVar19 = 0;
do {
iVar20 = *(int *)(param_3 + lVar19 * 4);
if (0 < iVar20) {
piVar17 = *(int **)(param_1 + lVar19 * 8);
piVar1 = piVar17 + iVar20;
do {
iVar20 = *piVar17;
piVar17 = piVar17 + 1;
piVar4 = (int *)((long)__ptr + (long)iVar20 * 4);
*piVar4 = *piVar4 + 1;
} while (piVar1 != piVar17);
}
bVar24 = lVar23 != lVar19;
lVar19 = lVar19 + 1;
} while (bVar24);
__base = malloc((long)(int)(uVar22 + 1) * 8);
if ((int)uVar22 < 0) {
__nmemb = 0;
goto LAB_00101618;
}
}
iVar20 = 0;
lVar19 = 0;
do {
iVar6 = *(int *)((long)__ptr + lVar19 * 4);
if (0 < iVar6) {
lVar23 = (long)iVar20;
iVar20 = iVar20 + 1;
*(ulong *)((long)__base + lVar23 * 8) = CONCAT44(iVar6,(int)lVar19);
}
bVar24 = (int)uVar22 != lVar19;
lVar19 = lVar19 + 1;
} while (bVar24);
__nmemb = (size_t)iVar20;
LAB_00101618:
qsort(__base,__nmemb,8,compare);
pvVar18 = malloc((long)param_4 << 2);
if (0 < param_4) {
uVar22 = param_4 - 1;
if (uVar22 < 4) {
uVar22 = 0;
}
else {
lVar19 = 0;
do {
puVar2 = (int4 *)((long)__base + lVar19 * 2);
uVar12 = puVar2[2];
puVar3 = (int4 *)((long)__base + lVar19 * 2 + 0x10);
uVar13 = *puVar3;
uVar14 = puVar3[2];
puVar3 = (int4 *)((long)pvVar18 + lVar19);
*puVar3 = *puVar2;
puVar3[1] = uVar12;
puVar3[2] = uVar13;
puVar3[3] = uVar14;
lVar19 = lVar19 + 0x10;
} while ((ulong)(uVar22 >> 2) << 4 != lVar19);
uVar22 = uVar22 & 0xfffffffc;
}
lVar21 = (long)(int)uVar22;
lVar19 = lVar21 * 8;
lVar23 = lVar21 * 4;
*(int4 *)((long)pvVar18 + lVar21 * 4) = *(int4 *)((long)__base + lVar21 * 8);
if ((((int)(uVar22 + 1) < param_4) &&
(*(int4 *)((long)pvVar18 + lVar23 + 4) = *(int4 *)((long)__base + lVar19 + 8),
(int)(uVar22 + 2) < param_4)) &&
(*(int4 *)((long)pvVar18 + lVar23 + 8) = *(int4 *)((long)__base + lVar19 + 0x10),
(int)(uVar22 + 3) < param_4)) {
*(int4 *)((long)pvVar18 + lVar23 + 0xc) = *(int4 *)((long)__base + lVar19 + 0x18);
}
}
*param_5 = param_4;
free(__ptr);
free(__base);
return pvVar18;
} |
4,020 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (int i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) {
maxPrime = n;
}
return maxPrime;
}
| int main() {
assert(func0(15) == 5);
assert(func0(6) == 3);
assert(func0(2) == 2);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0xffffffff,-0x8(%rbp)
jmp 11ab <func0+0x22>
movl $0x2,-0x8(%rbp)
sarl -0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11a1 <func0+0x18>
movl $0x3,-0x4(%rbp)
jmp 11df <func0+0x56>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
je 11be <func0+0x35>
addl $0x2,-0x4(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd %xmm1,-0x20(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
callq 1090 <sqrt@plt>
comisd -0x20(%rbp),%xmm0
jae 11ce <func0+0x45>
cmpl $0x2,-0x14(%rbp)
jle 1206 <func0+0x7d>
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_8], 0FFFFFFFFh
jmp short loc_11AB
loc_11A1:
mov [rbp+var_8], 2
sar [rbp+var_14], 1
loc_11AB:
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jz short loc_11A1
mov [rbp+var_4], 3
jmp short loc_11DF
loc_11BE:
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
loc_11CE:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jz short loc_11BE
add [rbp+var_4], 2
loc_11DF:
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_4]
movsd [rbp+var_20], xmm1
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movq rax, xmm2
movq xmm0, rax; x
call _sqrt
movq rax, xmm0
movq xmm3, rax
comisd xmm3, [rbp+var_20]
jnb short loc_11CE
cmp [rbp+var_14], 2
jle short loc_1222
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
loc_1222:
mov eax, [rbp+var_8]
leave
retn | long long func0(int a1)
{
unsigned int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = -1;
while ( (a1 & 1) == 0 )
{
v3 = 2;
a1 >>= 1;
}
for ( i = 3; sqrt((double)a1) >= (double)i; i += 2 )
{
while ( !(a1 % i) )
{
v3 = i;
a1 /= i;
}
}
if ( a1 > 2 )
return (unsigned int)a1;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0xffffffff
JMP 0x001011ab
LAB_001011a1:
MOV dword ptr [RBP + -0x8],0x2
SAR dword ptr [RBP + -0x14],0x1
LAB_001011ab:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011a1
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001011df
LAB_001011be:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
LAB_001011ce:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x001011be
ADD dword ptr [RBP + -0x4],0x2
LAB_001011df:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x4]
MOVSD qword ptr [RBP + -0x20],XMM1
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVQ RAX,XMM2
MOVQ XMM0,RAX
CALL 0x00101090
MOVQ RAX,XMM0
MOVQ XMM3,RAX
COMISD XMM3,qword ptr [RBP + -0x20]
JNC 0x001011ce
CMP dword ptr [RBP + -0x14],0x2
JLE 0x00101222
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
LAB_00101222:
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET | uint func0(uint param_1)
{
double dVar1;
int4 local_1c;
int4 local_10;
int4 local_c;
local_10 = 0xffffffff;
for (local_1c = param_1; (local_1c & 1) == 0; local_1c = (int)local_1c >> 1) {
local_10 = 2;
}
local_c = 3;
while( true ) {
dVar1 = sqrt((double)(int)local_1c);
if (dVar1 < (double)(int)local_c) break;
for (; (int)local_1c % (int)local_c == 0; local_1c = (int)local_1c / (int)local_c) {
local_10 = local_c;
}
local_c = local_c + 2;
}
if (2 < (int)local_1c) {
local_10 = local_1c;
}
return local_10;
} |
4,021 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (int i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) {
maxPrime = n;
}
return maxPrime;
}
| int main() {
assert(func0(15) == 5);
assert(func0(6) == 3);
assert(func0(2) == 2);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %edi,%ebx
test $0x1,%dil
jne 11b1 <func0+0x28>
sar %ebx
test $0x1,%bl
je 119d <func0+0x14>
mov $0x2,%r12d
mov $0x3,%ebp
jmp 11cd <func0+0x44>
mov $0xffffffff,%r12d
jmp 11aa <func0+0x21>
mov %ebx,%eax
cltd
idiv %ebp
mov %eax,%ebx
cltd
idiv %ebp
test %edx,%edx
je 11b9 <func0+0x30>
mov %ebp,%r12d
add $0x2,%ebp
pxor %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
movsd %xmm2,(%rsp)
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
movsd %xmm1,0x8(%rsp)
pxor %xmm3,%xmm3
ucomisd %xmm0,%xmm3
ja 1212 <func0+0x89>
movsd 0x8(%rsp),%xmm4
comisd (%rsp),%xmm4
jb 1219 <func0+0x90>
mov %ebx,%eax
cltd
idiv %ebp
test %edx,%edx
je 11b9 <func0+0x30>
jmp 11ca <func0+0x41>
callq 1090 <sqrt@plt>
jmp 11fa <func0+0x71>
cmp $0x3,%ebx
cmovge %ebx,%r12d
mov %r12d,%eax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov ebx, edi
test dil, 1
jnz short loc_11B1
loc_119D:
sar ebx, 1
test bl, 1
jz short loc_119D
mov r12d, 2
loc_11AA:
mov ebp, 3
jmp short loc_11CD
loc_11B1:
mov r12d, 0FFFFFFFFh
jmp short loc_11AA
loc_11B9:
mov eax, ebx
cdq
idiv ebp
mov ebx, eax
cdq
idiv ebp
test edx, edx
jz short loc_11B9
mov r12d, ebp
loc_11CA:
add ebp, 2
loc_11CD:
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
movsd [rsp+28h+var_20], xmm1
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pxor xmm2, xmm2
ucomisd xmm2, xmm0
ja short loc_1204
sqrtsd xmm0, xmm0
loc_11F1:
comisd xmm0, [rsp+28h+var_20]
jb short loc_120B
mov eax, ebx
cdq
idiv ebp
test edx, edx
jz short loc_11B9
jmp short loc_11CA
loc_1204:
call _sqrt
jmp short loc_11F1
loc_120B:
cmp ebx, 3
cmovge r12d, ebx
mov eax, r12d
add rsp, 10h
pop rbx
pop rbp
pop r12
retn | long long func0(int a1)
{
int v1; // ebx
unsigned int v2; // r12d
int i; // ebp
double v4; // xmm0_8
double v5; // xmm0_8
v1 = a1;
if ( (a1 & 1) != 0 )
{
v2 = -1;
}
else
{
do
v1 >>= 1;
while ( (v1 & 1) == 0 );
v2 = 2;
}
for ( i = 3; ; i += 2 )
{
v4 = (double)v1;
v5 = (double)v1 < 0.0 ? sqrt(v4) : sqrt(v4);
if ( v5 < (double)i )
break;
if ( !(v1 % i) )
{
do
v1 /= i;
while ( !(v1 % i) );
v2 = i;
}
}
if ( v1 >= 3 )
return (unsigned int)v1;
return v2;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV EBX,EDI
TEST DIL,0x1
JNZ 0x001011b1
LAB_0010119d:
SAR EBX,0x1
TEST BL,0x1
JZ 0x0010119d
MOV R12D,0x2
LAB_001011aa:
MOV EBP,0x3
JMP 0x001011cd
LAB_001011b1:
MOV R12D,0xffffffff
JMP 0x001011aa
LAB_001011b9:
MOV EAX,EBX
CDQ
IDIV EBP
MOV EBX,EAX
CDQ
IDIV EBP
TEST EDX,EDX
JZ 0x001011b9
MOV R12D,EBP
LAB_001011ca:
ADD EBP,0x2
LAB_001011cd:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
MOVSD qword ptr [RSP + 0x8],XMM1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
PXOR XMM2,XMM2
UCOMISD XMM2,XMM0
JA 0x00101204
SQRTSD XMM0,XMM0
LAB_001011f1:
COMISD XMM0,qword ptr [RSP + 0x8]
JC 0x0010120b
MOV EAX,EBX
CDQ
IDIV EBP
TEST EDX,EDX
JZ 0x001011b9
JMP 0x001011ca
LAB_00101204:
CALL 0x00101090
JMP 0x001011f1
LAB_0010120b:
CMP EBX,0x3
CMOVGE R12D,EBX
MOV EAX,R12D
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET | uint func0(uint param_1)
{
long lVar1;
int iVar2;
uint uVar3;
uint uVar4;
double dVar5;
if ((param_1 & 1) == 0) {
do {
param_1 = (int)param_1 >> 1;
} while ((param_1 & 1) == 0);
uVar4 = 2;
}
else {
uVar4 = 0xffffffff;
}
uVar3 = 3;
while( true ) {
dVar5 = (double)(int)param_1;
if (dVar5 < 0.0) {
dVar5 = sqrt(dVar5);
}
else {
dVar5 = SQRT(dVar5);
}
if (dVar5 < (double)(int)uVar3) break;
iVar2 = (int)param_1 % (int)uVar3;
while (iVar2 == 0) {
lVar1 = (long)(int)param_1;
param_1 = (uint)(lVar1 / (long)(int)uVar3);
uVar4 = uVar3;
iVar2 = (int)((long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 |
lVar1 / (long)(int)uVar3 & 0xffffffffU) % (long)(int)uVar3);
}
uVar3 = uVar3 + 2;
}
if (2 < (int)param_1) {
uVar4 = param_1;
}
return uVar4;
} |
4,022 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (int i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) {
maxPrime = n;
}
return maxPrime;
}
| int main() {
assert(func0(15) == 5);
assert(func0(6) == 3);
assert(func0(2) == 2);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbx
sub $0x28,%rsp
test $0x1,%dil
jne 12e2 <func0+0xa2>
nopl (%rax)
sar %edi
test $0x1,%dil
je 1258 <func0+0x18>
mov $0x2,%r12d
pxor %xmm1,%xmm1
mov $0x3,%ebx
pxor %xmm4,%xmm4
cvtsi2sd %edi,%xmm1
nopw 0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm4
pxor %xmm2,%xmm2
movapd %xmm1,%xmm3
cvtsi2sd %ebx,%xmm2
sqrtsd %xmm3,%xmm3
ja 12ed <func0+0xad>
comisd %xmm2,%xmm3
jb 12d0 <func0+0x90>
mov %edi,%eax
cltd
idiv %ebx
test %edx,%edx
jne 12c1 <func0+0x81>
nopl (%rax)
mov %edi,%eax
cltd
idiv %ebx
cltd
mov %eax,%edi
idiv %ebx
test %edx,%edx
je 12a8 <func0+0x68>
pxor %xmm1,%xmm1
mov %ebx,%r12d
cvtsi2sd %edi,%xmm1
add $0x2,%ebx
jmp 1280 <func0+0x40>
nopw %cs:0x0(%rax,%rax,1)
cmp $0x3,%edi
cmovge %edi,%r12d
add $0x28,%rsp
pop %rbx
mov %r12d,%eax
pop %r12
retq
mov $0xffffffff,%r12d
jmpq 1266 <func0+0x26>
movapd %xmm1,%xmm0
mov %edi,0x1c(%rsp)
movsd %xmm3,0x10(%rsp)
movsd %xmm2,0x8(%rsp)
movsd %xmm1,(%rsp)
callq 1090 <sqrt@plt>
mov 0x1c(%rsp),%edi
movsd 0x10(%rsp),%xmm3
pxor %xmm4,%xmm4
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm1
jmpq 1296 <func0+0x56>
nopl 0x0(%rax)
| func0:
endbr64
push r12
push rbx
sub rsp, 28h
test dil, 1
jnz loc_12E2
nop dword ptr [rax]
loc_1258:
sar edi, 1
test dil, 1
jz short loc_1258
mov r12d, 2
loc_1266:
pxor xmm1, xmm1
mov ebx, 3
pxor xmm3, xmm3
cvtsi2sd xmm1, edi
nop word ptr [rax+rax+00000000h]
loc_1280:
ucomisd xmm3, xmm1
pxor xmm2, xmm2
cvtsi2sd xmm2, ebx
ja short loc_12ED
movapd xmm0, xmm1
sqrtsd xmm0, xmm0
loc_1296:
comisd xmm0, xmm2
jb short loc_12D0
mov eax, edi
cdq
idiv ebx
test edx, edx
jnz short loc_12C1
nop dword ptr [rax]
loc_12A8:
mov eax, edi
cdq
idiv ebx
cdq
mov edi, eax
idiv ebx
test edx, edx
jz short loc_12A8
pxor xmm1, xmm1
mov r12d, ebx
cvtsi2sd xmm1, edi
loc_12C1:
add ebx, 2
jmp short loc_1280
loc_12D0:
cmp edi, 3
cmovge r12d, edi
add rsp, 28h
pop rbx
mov eax, r12d
pop r12
retn
loc_12E2:
mov r12d, 0FFFFFFFFh
jmp loc_1266
loc_12ED:
movapd xmm0, xmm1
mov [rsp+38h+var_1C], edi
movsd [rsp+38h+var_28], xmm2
movsd [rsp+38h+var_30], xmm1
call _sqrt
mov edi, [rsp+38h+var_1C]
movsd xmm2, [rsp+38h+var_28]
pxor xmm3, xmm3
movsd xmm1, [rsp+38h+var_30]
jmp loc_1296 | long long func0(int a1)
{
unsigned int v1; // r12d
int v2; // ebx
double v3; // xmm1_8
double v4; // xmm2_8
double v5; // xmm0_8
int v6; // edx
if ( (a1 & 1) != 0 )
{
v1 = -1;
}
else
{
do
a1 >>= 1;
while ( (a1 & 1) == 0 );
v1 = 2;
}
v2 = 3;
v3 = (double)a1;
while ( 1 )
{
v4 = (double)v2;
if ( v3 < 0.0 )
{
v5 = sqrt(v3);
v4 = (double)v2;
}
else
{
v5 = sqrt(v3);
}
if ( v5 < v4 )
break;
if ( !(a1 % v2) )
{
do
{
v6 = (a1 / v2) >> 31;
a1 /= v2;
}
while ( !(unsigned int)(__SPAIR64__(v6, a1) % v2) );
v1 = v2;
v3 = (double)a1;
}
v2 += 2;
}
if ( a1 >= 3 )
return (unsigned int)a1;
return v1;
} | func0:
ENDBR64
PUSH R12
PUSH RBX
SUB RSP,0x28
TEST DIL,0x1
JNZ 0x001012e2
NOP dword ptr [RAX]
LAB_00101258:
SAR EDI,0x1
TEST DIL,0x1
JZ 0x00101258
MOV R12D,0x2
LAB_00101266:
PXOR XMM1,XMM1
MOV EBX,0x3
PXOR XMM3,XMM3
CVTSI2SD XMM1,EDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101280:
UCOMISD XMM3,XMM1
PXOR XMM2,XMM2
CVTSI2SD XMM2,EBX
JA 0x001012ed
MOVAPD XMM0,XMM1
SQRTSD XMM0,XMM0
LAB_00101296:
COMISD XMM0,XMM2
JC 0x001012d0
MOV EAX,EDI
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x001012c1
NOP dword ptr [RAX]
LAB_001012a8:
MOV EAX,EDI
CDQ
IDIV EBX
CDQ
MOV EDI,EAX
IDIV EBX
TEST EDX,EDX
JZ 0x001012a8
PXOR XMM1,XMM1
MOV R12D,EBX
CVTSI2SD XMM1,EDI
LAB_001012c1:
ADD EBX,0x2
JMP 0x00101280
LAB_001012d0:
CMP EDI,0x3
CMOVGE R12D,EDI
ADD RSP,0x28
POP RBX
MOV EAX,R12D
POP R12
RET
LAB_001012e2:
MOV R12D,0xffffffff
JMP 0x00101266
LAB_001012ed:
MOVAPD XMM0,XMM1
MOV dword ptr [RSP + 0x1c],EDI
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
CALL 0x00101090
MOV EDI,dword ptr [RSP + 0x1c]
MOVSD XMM2,qword ptr [RSP + 0x10]
PXOR XMM3,XMM3
MOVSD XMM1,qword ptr [RSP + 0x8]
JMP 0x00101296 | ulong func0(ulong param_1)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
double dVar4;
double __x;
if ((param_1 & 1) == 0) {
do {
uVar2 = (int)param_1 >> 1;
param_1 = (ulong)uVar2;
} while ((uVar2 & 1) == 0);
uVar3 = 2;
}
else {
uVar3 = 0xffffffff;
}
uVar2 = 3;
__x = (double)(int)param_1;
while( true ) {
if (__x < 0.0) {
dVar4 = sqrt(__x);
param_1 = param_1 & 0xffffffff;
}
else {
dVar4 = SQRT(__x);
}
if (dVar4 < (double)(int)uVar2) break;
if ((int)((long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 | param_1 & 0xffffffff) %
(long)(int)uVar2) == 0) {
do {
uVar1 = (long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 | param_1 & 0xffffffff) /
(long)(int)uVar2;
param_1 = uVar1 & 0xffffffff;
} while ((int)((long)((ulong)(uint)((int)uVar1 >> 0x1f) << 0x20 | uVar1 & 0xffffffff) %
(long)(int)uVar2) == 0);
uVar3 = (ulong)uVar2;
__x = (double)(int)uVar1;
}
uVar2 = uVar2 + 2;
}
if (2 < (int)param_1) {
uVar3 = param_1 & 0xffffffff;
}
return uVar3;
} |
4,023 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (int i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) {
maxPrime = n;
}
return maxPrime;
}
| int main() {
assert(func0(15) == 5);
assert(func0(6) == 3);
assert(func0(2) == 2);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbx
sub $0x28,%rsp
test $0x1,%dil
jne 12e2 <func0+0xa2>
nopl (%rax)
sar %edi
test $0x1,%dil
je 1258 <func0+0x18>
mov $0x2,%r12d
pxor %xmm1,%xmm1
mov $0x3,%ebx
pxor %xmm4,%xmm4
cvtsi2sd %edi,%xmm1
nopw 0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm4
pxor %xmm2,%xmm2
movapd %xmm1,%xmm3
cvtsi2sd %ebx,%xmm2
sqrtsd %xmm3,%xmm3
ja 12ed <func0+0xad>
comisd %xmm2,%xmm3
jb 12d0 <func0+0x90>
mov %edi,%eax
cltd
idiv %ebx
test %edx,%edx
jne 12c1 <func0+0x81>
nopl (%rax)
mov %edi,%eax
cltd
idiv %ebx
cltd
mov %eax,%edi
idiv %ebx
test %edx,%edx
je 12a8 <func0+0x68>
pxor %xmm1,%xmm1
mov %ebx,%r12d
cvtsi2sd %edi,%xmm1
add $0x2,%ebx
jmp 1280 <func0+0x40>
nopw %cs:0x0(%rax,%rax,1)
cmp $0x3,%edi
cmovge %edi,%r12d
add $0x28,%rsp
pop %rbx
mov %r12d,%eax
pop %r12
retq
mov $0xffffffff,%r12d
jmpq 1266 <func0+0x26>
movapd %xmm1,%xmm0
mov %edi,0x1c(%rsp)
movsd %xmm3,0x10(%rsp)
movsd %xmm2,0x8(%rsp)
movsd %xmm1,(%rsp)
callq 1090 <sqrt@plt>
mov 0x1c(%rsp),%edi
movsd 0x10(%rsp),%xmm3
pxor %xmm4,%xmm4
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm1
jmpq 1296 <func0+0x56>
nopl 0x0(%rax)
| func0:
endbr64
push rbp
push rbx
sub rsp, 28h
test dil, 1
jnz short loc_12C7
loc_1250:
sar edi, 1
test dil, 1
jz short loc_1250
mov ebp, 2
loc_125D:
pxor xmm1, xmm1
mov ebx, 3
pxor xmm3, xmm3
cvtsi2sd xmm1, edi
xchg ax, ax
loc_1270:
ucomisd xmm3, xmm1
pxor xmm2, xmm2
cvtsi2sd xmm2, ebx
ja short loc_12CE
movapd xmm0, xmm1
sqrtsd xmm0, xmm0
loc_1286:
comisd xmm0, xmm2
jb short loc_12B8
mov eax, edi
cdq
idiv ebx
test edx, edx
jnz short loc_12B0
nop dword ptr [rax]
loc_1298:
mov eax, edi
cdq
idiv ebx
cdq
mov edi, eax
idiv ebx
test edx, edx
jz short loc_1298
pxor xmm1, xmm1
mov ebp, ebx
cvtsi2sd xmm1, edi
loc_12B0:
add ebx, 2
jmp short loc_1270
loc_12B8:
cmp edi, 2
cmovle edi, ebp
add rsp, 28h
pop rbx
pop rbp
mov eax, edi
retn
loc_12C7:
mov ebp, 0FFFFFFFFh
jmp short loc_125D
loc_12CE:
movapd xmm0, xmm1; x
mov [rsp+38h+var_1C], edi
movsd [rsp+38h+var_28], xmm2
movsd [rsp+38h+var_30], xmm1
call _sqrt
mov edi, [rsp+38h+var_1C]
movsd xmm2, [rsp+38h+var_28]
pxor xmm3, xmm3
movsd xmm1, [rsp+38h+var_30]
jmp short loc_1286 | long long func0(int a1)
{
unsigned int v1; // ebp
int v2; // ebx
double v3; // xmm1_8
double v4; // xmm2_8
double v5; // xmm0_8
int v6; // edx
if ( (a1 & 1) != 0 )
{
v1 = -1;
}
else
{
do
a1 >>= 1;
while ( (a1 & 1) == 0 );
v1 = 2;
}
v2 = 3;
v3 = (double)a1;
while ( 1 )
{
v4 = (double)v2;
if ( v3 < 0.0 )
{
v5 = sqrt(v3);
v4 = (double)v2;
}
else
{
v5 = sqrt(v3);
}
if ( v5 < v4 )
break;
if ( !(a1 % v2) )
{
do
{
v6 = (a1 / v2) >> 31;
a1 /= v2;
}
while ( !(unsigned int)(__SPAIR64__(v6, a1) % v2) );
v1 = v2;
v3 = (double)a1;
}
v2 += 2;
}
if ( a1 <= 2 )
return v1;
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x28
TEST DIL,0x1
JNZ 0x001012c7
LAB_00101250:
SAR EDI,0x1
TEST DIL,0x1
JZ 0x00101250
MOV EBP,0x2
LAB_0010125d:
PXOR XMM1,XMM1
MOV EBX,0x3
PXOR XMM3,XMM3
CVTSI2SD XMM1,EDI
NOP
LAB_00101270:
UCOMISD XMM3,XMM1
PXOR XMM2,XMM2
CVTSI2SD XMM2,EBX
JA 0x001012ce
MOVAPD XMM0,XMM1
SQRTSD XMM0,XMM0
LAB_00101286:
COMISD XMM0,XMM2
JC 0x001012b8
MOV EAX,EDI
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x001012b0
NOP dword ptr [RAX]
LAB_00101298:
MOV EAX,EDI
CDQ
IDIV EBX
CDQ
MOV EDI,EAX
IDIV EBX
TEST EDX,EDX
JZ 0x00101298
PXOR XMM1,XMM1
MOV EBP,EBX
CVTSI2SD XMM1,EDI
LAB_001012b0:
ADD EBX,0x2
JMP 0x00101270
LAB_001012b8:
CMP EDI,0x2
CMOVLE EDI,EBP
ADD RSP,0x28
POP RBX
POP RBP
MOV EAX,EDI
RET
LAB_001012c7:
MOV EBP,0xffffffff
JMP 0x0010125d
LAB_001012ce:
MOVAPD XMM0,XMM1
MOV dword ptr [RSP + 0x1c],EDI
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
CALL 0x00101090
MOV EDI,dword ptr [RSP + 0x1c]
MOVSD XMM2,qword ptr [RSP + 0x10]
PXOR XMM3,XMM3
MOVSD XMM1,qword ptr [RSP + 0x8]
JMP 0x00101286 | ulong func0(ulong param_1)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
double dVar4;
double __x;
if ((param_1 & 1) == 0) {
do {
uVar2 = (int)param_1 >> 1;
param_1 = (ulong)uVar2;
} while ((uVar2 & 1) == 0);
uVar1 = 2;
}
else {
uVar1 = 0xffffffff;
}
uVar2 = 3;
__x = (double)(int)param_1;
while( true ) {
if (__x < 0.0) {
dVar4 = sqrt(__x);
param_1 = param_1 & 0xffffffff;
}
else {
dVar4 = SQRT(__x);
}
if (dVar4 < (double)(int)uVar2) break;
if ((int)((long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 | param_1 & 0xffffffff) %
(long)(int)uVar2) == 0) {
do {
uVar3 = (long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 | param_1 & 0xffffffff) /
(long)(int)uVar2;
param_1 = uVar3 & 0xffffffff;
} while ((int)((long)((ulong)(uint)((int)uVar3 >> 0x1f) << 0x20 | uVar3 & 0xffffffff) %
(long)(int)uVar2) == 0);
uVar1 = (ulong)uVar2;
__x = (double)(int)uVar3;
}
uVar2 = uVar2 + 2;
}
uVar3 = param_1 & 0xffffffff;
if ((int)param_1 < 3) {
uVar3 = uVar1;
}
return uVar3;
} |
4,024 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int B_Number = 0;
int cnt = 0;
while (N != 0) {
int rem = N % 2;
int c = 1;
for (int i = 0; i < cnt; i++) {
c *= 10;
}
B_Number += rem * c;
N /= 2;
cnt++;
}
return B_Number;
}
| int main() {
assert(func0(10) == 1010);
assert(func0(1) == 1);
assert(func0(20) == 10100);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11bd <func0+0x74>
mov -0x24(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
mov %eax,-0x4(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 1198 <func0+0x4f>
mov -0xc(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 1185 <func0+0x3c>
mov -0x4(%rbp),%eax
imul -0xc(%rbp),%eax
add %eax,-0x14(%rbp)
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x24(%rbp)
addl $0x1,-0x10(%rbp)
cmpl $0x0,-0x24(%rbp)
jne 1164 <func0+0x1b>
mov -0x14(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_11C1
loc_1164:
mov edx, [rbp+var_24]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov [rbp+var_4], edx
mov [rbp+var_C], 1
mov [rbp+var_8], 0
jmp short loc_119C
loc_1189:
mov edx, [rbp+var_C]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov [rbp+var_C], eax
add [rbp+var_8], 1
loc_119C:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_10]
jl short loc_1189
mov eax, [rbp+var_4]
imul eax, [rbp+var_C]
add [rbp+var_14], eax
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_24], eax
add [rbp+var_10], 1
loc_11C1:
cmp [rbp+var_24], 0
jnz short loc_1164
mov eax, [rbp+var_14]
pop rbp
retn | long long func0(int a1)
{
unsigned int v3; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int v5; // [rsp+18h] [rbp-Ch]
int i; // [rsp+1Ch] [rbp-8h]
v3 = 0;
v4 = 0;
while ( a1 )
{
v5 = 1;
for ( i = 0; i < v4; ++i )
v5 *= 10;
v3 += v5 * (a1 % 2);
a1 /= 2;
++v4;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011c1
LAB_00101164:
MOV EDX,dword ptr [RBP + -0x24]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010119c
LAB_00101189:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_0010119c:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x00101189
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0xc]
ADD dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
ADD dword ptr [RBP + -0x10],0x1
LAB_001011c1:
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00101164
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET | int func0(int param_1)
{
int4 local_2c;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
local_1c = 0;
local_18 = 0;
for (local_2c = param_1; local_2c != 0; local_2c = local_2c / 2) {
local_14 = 1;
for (local_10 = 0; local_10 < local_18; local_10 = local_10 + 1) {
local_14 = local_14 * 10;
}
local_1c = local_1c + (local_2c % 2) * local_14;
local_18 = local_18 + 1;
}
return local_1c;
} |
4,025 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int B_Number = 0;
int cnt = 0;
while (N != 0) {
int rem = N % 2;
int c = 1;
for (int i = 0; i < cnt; i++) {
c *= 10;
}
B_Number += rem * c;
N /= 2;
cnt++;
}
return B_Number;
}
| int main() {
assert(func0(10) == 1010);
assert(func0(1) == 1);
assert(func0(20) == 10100);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%r8d
mov %edi,%r9d
test %edi,%edi
je 11ca <func0+0x81>
mov %edi,%edx
shr $0x1f,%edx
lea (%rdi,%rdx,1),%eax
and $0x1,%eax
sub %edx,%eax
mov %eax,%edi
mov $0x0,%esi
mov $0x0,%r9d
mov $0x1,%eax
mov $0x1,%r10d
jmp 1184 <func0+0x3b>
mov %r10d,%eax
mov %r11d,%esi
imul %edi,%eax
add %eax,%r9d
mov %r8d,%edi
shr $0x1f,%edi
add %r8d,%edi
sar %edi
mov %edi,%r8d
lea 0x1(%rsi),%r11d
je 11ca <func0+0x81>
mov %edi,%edx
shr $0x1f,%edx
lea (%rdi,%rdx,1),%eax
and $0x1,%eax
sub %edx,%eax
mov %eax,%edi
test %r11d,%r11d
jle 117e <func0+0x35>
mov $0x0,%edx
mov %r10d,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
mov %edx,%ecx
add $0x1,%edx
cmp %ecx,%esi
jne 11ba <func0+0x71>
jmp 1181 <func0+0x38>
mov %r9d,%eax
retq
| func0:
endbr64
mov r8d, edi
mov r9d, edi
test edi, edi
jz short loc_11C4
mov edx, edi
shr edx, 1Fh
lea eax, [rdi+rdx]
and eax, 1
sub eax, edx
mov ecx, eax
mov edi, 0
mov r9d, 0
mov eax, 1
mov r10d, 1
jmp short loc_11AA
loc_117E:
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
mov ecx, eax
test r11d, r11d
jle short loc_11C8
mov edx, 0
mov eax, r10d
loc_1199:
lea eax, [rax+rax*4]
add eax, eax
mov esi, edx
add edx, 1
cmp edi, esi
jnz short loc_1199
loc_11A7:
mov edi, r11d
loc_11AA:
imul eax, ecx
add r9d, eax
mov eax, r8d
shr eax, 1Fh
add eax, r8d
sar eax, 1
mov r8d, eax
lea r11d, [rdi+1]
jnz short loc_117E
loc_11C4:
mov eax, r9d
retn
loc_11C8:
mov eax, r10d
jmp short loc_11A7 | long long func0(int a1)
{
int v1; // r8d
unsigned int v2; // r9d
int v3; // ecx
int v4; // edi
int v5; // eax
int v6; // edx
int v7; // esi
bool v8; // zf
int v9; // eax
v1 = a1;
v2 = a1;
if ( a1 )
{
v3 = a1 % 2;
v4 = 0;
v2 = 0;
v5 = 1;
while ( 1 )
{
v2 += v3 * v5;
v8 = v1 / 2 == 0;
v9 = v1 / 2;
v1 /= 2;
if ( v8 )
break;
v3 = v9 % 2;
if ( v4 + 1 <= 0 )
{
v5 = 1;
}
else
{
v6 = 0;
v5 = 1;
do
{
v5 *= 10;
v7 = v6++;
}
while ( v4 != v7 );
}
++v4;
}
}
return v2;
} | func0:
ENDBR64
MOV R8D,EDI
MOV R9D,EDI
TEST EDI,EDI
JZ 0x001011c4
MOV EDX,EDI
SHR EDX,0x1f
LEA EAX,[RDI + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
MOV ECX,EAX
MOV EDI,0x0
MOV R9D,0x0
MOV EAX,0x1
MOV R10D,0x1
JMP 0x001011aa
LAB_0010117e:
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
MOV ECX,EAX
TEST R11D,R11D
JLE 0x001011c8
MOV EDX,0x0
MOV EAX,R10D
LAB_00101199:
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
MOV ESI,EDX
ADD EDX,0x1
CMP EDI,ESI
JNZ 0x00101199
LAB_001011a7:
MOV EDI,R11D
LAB_001011aa:
IMUL EAX,ECX
ADD R9D,EAX
MOV EAX,R8D
SHR EAX,0x1f
ADD EAX,R8D
SAR EAX,0x1
MOV R8D,EAX
LEA R11D,[RDI + 0x1]
JNZ 0x0010117e
LAB_001011c4:
MOV EAX,R9D
RET
LAB_001011c8:
MOV EAX,R10D
JMP 0x001011a7 | uint func0(uint param_1)
{
int iVar1;
int iVar2;
uint uVar3;
int iVar4;
int iVar5;
ulong uVar6;
int iVar7;
bool bVar8;
uVar6 = (ulong)param_1;
if (param_1 != 0) {
iVar2 = (int)param_1 % 2;
param_1 = 0;
iVar7 = 1;
iVar1 = 0;
while( true ) {
iVar5 = iVar1;
param_1 = param_1 + iVar7 * iVar2;
iVar2 = (int)(uVar6 >> 0x1f) + (int)uVar6;
uVar3 = iVar2 >> 1;
uVar6 = (ulong)uVar3;
iVar1 = iVar5 + 1;
if (uVar3 == 0) break;
iVar2 = iVar2 >> 0x1f;
iVar2 = (uVar3 - iVar2 & 1) + iVar2;
iVar7 = 1;
if (0 < iVar1) {
iVar7 = 1;
iVar4 = 0;
do {
iVar7 = iVar7 * 10;
bVar8 = iVar5 != iVar4;
iVar4 = iVar4 + 1;
} while (bVar8);
}
}
}
return param_1;
} |
4,026 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int B_Number = 0;
int cnt = 0;
while (N != 0) {
int rem = N % 2;
int c = 1;
for (int i = 0; i < cnt; i++) {
c *= 10;
}
B_Number += rem * c;
N /= 2;
cnt++;
}
return B_Number;
}
| int main() {
assert(func0(10) == 1010);
assert(func0(1) == 1);
assert(func0(20) == 10100);
return 0;
}
| O2 | c | func0:
endbr64
xor %r10d,%r10d
test %edi,%edi
je 12f0 <func0+0x70>
mov %edi,%edx
xor %r9d,%r9d
xor %r10d,%r10d
shr $0x1f,%edx
lea (%rdi,%rdx,1),%eax
and $0x1,%eax
sub %edx,%eax
mov %eax,%r8d
mov $0x1,%eax
nopw %cs:0x0(%rax,%rax,1)
imul %r8d,%eax
mov %r9d,%esi
add $0x1,%r9d
add %eax,%r10d
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
mov %eax,%edi
sar %edi
je 12f0 <func0+0x70>
shr $0x1f,%eax
xor %edx,%edx
lea (%rdi,%rax,1),%r8d
and $0x1,%r8d
sub %eax,%r8d
mov $0x1,%eax
lea (%rax,%rax,4),%eax
mov %edx,%ecx
add $0x1,%edx
add %eax,%eax
cmp %ecx,%esi
jne 12e0 <func0+0x60>
jmp 12b0 <func0+0x30>
mov %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov r8d, edi
xor r10d, r10d
test edi, edi
jz short loc_1270
mov edx, edi
xor r9d, r9d
xor r10d, r10d
shr edx, 1Fh
lea eax, [rdi+rdx]
and eax, 1
sub eax, edx
mov edi, eax
mov eax, 1
nop dword ptr [rax+rax+00000000h]
loc_1220:
imul eax, edi
mov esi, r9d
add r9d, 1
add r10d, eax
mov eax, r8d
shr eax, 1Fh
add eax, r8d
mov r8d, eax
sar r8d, 1
jz short loc_1270
shr eax, 1Fh
xor edx, edx
lea edi, [r8+rax]
and edi, 1
sub edi, eax
mov eax, 1
nop dword ptr [rax+00000000h]
loc_1258:
lea eax, [rax+rax*4]
mov ecx, edx
add edx, 1
add eax, eax
cmp esi, ecx
jnz short loc_1258
jmp short loc_1220
loc_1270:
mov eax, r10d
retn | long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // r10d
int v3; // r9d
int v4; // edi
int v5; // eax
int v6; // esi
int v7; // eax
int v8; // edx
int v9; // ecx
v1 = a1;
v2 = 0;
if ( a1 )
{
v3 = 0;
v2 = 0;
v4 = a1 % 2;
v5 = 1;
while ( 1 )
{
v6 = v3++;
v2 += v4 * v5;
v7 = v1 + (v1 >> 31);
v1 = (int)v1 / 2;
if ( !v1 )
break;
v8 = 0;
v4 = (((_BYTE)v1 + (v7 < 0)) & 1) - ((unsigned int)v7 >> 31);
v5 = 1;
do
{
v9 = v8++;
v5 *= 10;
}
while ( v6 != v9 );
}
}
return v2;
} | func0:
ENDBR64
MOV R8D,EDI
XOR R10D,R10D
TEST EDI,EDI
JZ 0x00101270
MOV EDX,EDI
XOR R9D,R9D
XOR R10D,R10D
SHR EDX,0x1f
LEA EAX,[RDI + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
MOV EDI,EAX
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101220:
IMUL EAX,EDI
MOV ESI,R9D
ADD R9D,0x1
ADD R10D,EAX
MOV EAX,R8D
SHR EAX,0x1f
ADD EAX,R8D
MOV R8D,EAX
SAR R8D,0x1
JZ 0x00101270
SHR EAX,0x1f
XOR EDX,EDX
LEA EDI,[R8 + RAX*0x1]
AND EDI,0x1
SUB EDI,EAX
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101258:
LEA EAX,[RAX + RAX*0x4]
MOV ECX,EDX
ADD EDX,0x1
ADD EAX,EAX
CMP ESI,ECX
JNZ 0x00101258
JMP 0x00101220
LAB_00101270:
MOV EAX,R10D
RET | int func0(uint param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
uint uVar5;
ulong uVar6;
int iVar7;
int iVar8;
bool bVar9;
uVar6 = (ulong)param_1;
iVar8 = 0;
if (param_1 != 0) {
iVar8 = 0;
iVar2 = (int)param_1 % 2;
iVar3 = 1;
iVar1 = 0;
while( true ) {
iVar7 = iVar1;
iVar8 = iVar8 + iVar3 * iVar2;
iVar2 = (int)(uVar6 >> 0x1f) + (int)uVar6;
uVar5 = iVar2 >> 1;
uVar6 = (ulong)uVar5;
if (uVar5 == 0) break;
iVar2 = iVar2 >> 0x1f;
iVar2 = (uVar5 - iVar2 & 1) + iVar2;
iVar3 = 1;
iVar4 = 0;
do {
iVar3 = iVar3 * 10;
bVar9 = iVar7 != iVar4;
iVar4 = iVar4 + 1;
iVar1 = iVar7 + 1;
} while (bVar9);
}
}
return iVar8;
} |
4,027 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int B_Number = 0;
int cnt = 0;
while (N != 0) {
int rem = N % 2;
int c = 1;
for (int i = 0; i < cnt; i++) {
c *= 10;
}
B_Number += rem * c;
N /= 2;
cnt++;
}
return B_Number;
}
| int main() {
assert(func0(10) == 1010);
assert(func0(1) == 1);
assert(func0(20) == 10100);
return 0;
}
| O3 | c | func0:
endbr64
xor %r8d,%r8d
test %edi,%edi
je 12d0 <func0+0x70>
mov %edi,%eax
mov $0x1,%ecx
shr $0x1f,%eax
lea (%rdi,%rax,1),%r8d
mov %eax,%esi
and $0x1,%r8d
add %edi,%esi
sub %eax,%r8d
sar %esi
je 12d0 <func0+0x70>
nopl 0x0(%rax,%rax,1)
mov %esi,%edx
shr $0x1f,%edx
lea (%rsi,%rdx,1),%eax
and $0x1,%eax
sub %edx,%eax
xor %edx,%edx
mov %eax,%edi
mov $0x1,%eax
nopw %cs:0x0(%rax,%rax,1)
lea (%rax,%rax,4),%eax
add $0x1,%edx
add %eax,%eax
cmp %ecx,%edx
jne 12b0 <func0+0x50>
imul %edi,%eax
add $0x1,%ecx
add %eax,%r8d
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
sar %esi
jne 1290 <func0+0x30>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov r8d, edi
test edi, edi
jz short loc_12C6
mov edx, edi
xor esi, esi
xor r9d, r9d
shr edx, 1Fh
lea eax, [rdi+rdx]
and eax, 1
sub eax, edx
nop dword ptr [rax]
loc_1280:
add r9d, eax
mov eax, r8d
lea r10d, [rsi+1]
shr eax, 1Fh
add eax, r8d
mov r8d, eax
sar r8d, 1
jz short loc_12C9
shr eax, 1Fh
xor edx, edx
lea edi, [r8+rax]
and edi, 1
sub edi, eax
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_12B0:
lea eax, [rax+rax*4]
mov ecx, edx
add edx, 1
add eax, eax
cmp esi, ecx
jnz short loc_12B0
imul eax, edi
mov esi, r10d
jmp short loc_1280
loc_12C6:
xor r9d, r9d
loc_12C9:
mov eax, r9d
retn | long long func0(int a1)
{
unsigned int v1; // r8d
int v2; // esi
unsigned int v3; // r9d
int v4; // eax
int v5; // eax
int v6; // edx
int v7; // edi
int v8; // eax
int v9; // ecx
v1 = a1;
if ( a1 )
{
v2 = 0;
v3 = 0;
v4 = a1 % 2;
while ( 1 )
{
v3 += v4;
v5 = v1 + (v1 >> 31);
v1 = (int)v1 / 2;
if ( !v1 )
break;
v6 = 0;
v7 = (((_BYTE)v1 + (v5 < 0)) & 1) - ((unsigned int)v5 >> 31);
v8 = 1;
do
{
v9 = v6++;
v8 *= 10;
}
while ( v2 != v9 );
v4 = v7 * v8;
++v2;
}
}
else
{
return 0;
}
return v3;
} | func0:
ENDBR64
MOV R8D,EDI
TEST EDI,EDI
JZ 0x001012c6
MOV EDX,EDI
XOR ESI,ESI
XOR R9D,R9D
SHR EDX,0x1f
LEA EAX,[RDI + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
NOP dword ptr [RAX]
LAB_00101280:
ADD R9D,EAX
MOV EAX,R8D
LEA R10D,[RSI + 0x1]
SHR EAX,0x1f
ADD EAX,R8D
MOV R8D,EAX
SAR R8D,0x1
JZ 0x001012c9
SHR EAX,0x1f
XOR EDX,EDX
LEA EDI,[R8 + RAX*0x1]
AND EDI,0x1
SUB EDI,EAX
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_001012b0:
LEA EAX,[RAX + RAX*0x4]
MOV ECX,EDX
ADD EDX,0x1
ADD EAX,EAX
CMP ESI,ECX
JNZ 0x001012b0
IMUL EAX,EDI
MOV ESI,R10D
JMP 0x00101280
LAB_001012c6:
XOR R9D,R9D
LAB_001012c9:
MOV EAX,R9D
RET | int func0(uint param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
uint uVar5;
ulong uVar6;
int iVar7;
bool bVar8;
uVar6 = (ulong)param_1;
if (param_1 == 0) {
iVar7 = 0;
}
else {
iVar7 = 0;
iVar1 = (int)param_1 % 2;
iVar4 = 0;
while( true ) {
iVar7 = iVar7 + iVar1;
iVar2 = (int)(uVar6 >> 0x1f) + (int)uVar6;
uVar5 = iVar2 >> 1;
uVar6 = (ulong)uVar5;
if (uVar5 == 0) break;
iVar2 = iVar2 >> 0x1f;
iVar1 = 1;
iVar3 = 0;
do {
iVar1 = iVar1 * 10;
bVar8 = iVar4 != iVar3;
iVar3 = iVar3 + 1;
} while (bVar8);
iVar1 = iVar1 * ((uVar5 - iVar2 & 1) + iVar2);
iVar4 = iVar4 + 1;
}
}
return iVar7;
} |
4,028 | func0 | #include <assert.h>
| int func0(int ar[], int N) {
int l = 0;
int r = N - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (ar[mid] != mid + 1 && ar[mid - 1] == mid) {
return mid + 1;
} else if (ar[mid] != mid + 1) {
r = mid - 1;
} else {
l = mid + 1;
}
}
return -1;
}
| int main() {
int ar1[] = {1, 2, 3, 5};
assert(func0(ar1, 4) == 4);
int ar2[] = {1, 3, 4, 5};
assert(func0(ar2, 4) == 2);
int ar3[] = {1, 2, 3, 5, 6, 7};
assert(func0(ar3, 6) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 1218 <func0+0xaf>
mov -0xc(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%edx
add $0x1,%edx
cmp %edx,%eax
je 11e4 <func0+0x7b>
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jne 11e4 <func0+0x7b>
mov -0x4(%rbp),%eax
add $0x1,%eax
jmp 1229 <func0+0xc0>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%edx
add $0x1,%edx
cmp %edx,%eax
je 120f <func0+0xa6>
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 1218 <func0+0xaf>
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jle 118d <func0+0x24>
mov $0xffffffff,%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 eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp loc_1218
loc_118D:
mov edx, [rbp+var_C]
mov eax, [rbp+var_8]
add eax, edx
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
jz short loc_11E4
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jnz short loc_11E4
mov eax, [rbp+var_4]
add eax, 1
jmp short loc_1229
loc_11E4:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
jz short loc_120F
mov eax, [rbp+var_4]
sub eax, 1
mov [rbp+var_8], eax
jmp short loc_1218
loc_120F:
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_C], eax
loc_1218:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jle loc_118D
mov eax, 0FFFFFFFFh
loc_1229:
pop rbp
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int v5; // [rsp+18h] [rbp-4h]
v3 = 0;
v4 = a2 - 1;
while ( v3 <= v4 )
{
v5 = (v3 + v4) / 2;
if ( *(_DWORD *)(4LL * v5 + a1) != v5 + 1 && v5 == *(_DWORD *)(4LL * v5 - 4 + a1) )
return (unsigned int)(v5 + 1);
if ( *(_DWORD *)(4LL * v5 + a1) == v5 + 1 )
v3 = v5 + 1;
else
v4 = v5 - 1;
}
return 0xFFFFFFFFLL;
} | 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 EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101218
LAB_0010118d:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
JZ 0x001011e4
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JNZ 0x001011e4
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
JMP 0x00101229
LAB_001011e4:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
JZ 0x0010120f
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101218
LAB_0010120f:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_00101218:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JLE 0x0010118d
MOV EAX,0xffffffff
LAB_00101229:
POP RBP
RET | int func0(long param_1,int param_2)
{
int iVar1;
int local_14;
int local_10;
local_14 = 0;
local_10 = param_2 + -1;
while( true ) {
if (local_10 < local_14) {
return -1;
}
iVar1 = (local_10 + local_14) / 2;
if ((*(int *)(param_1 + (long)iVar1 * 4) != iVar1 + 1) &&
(iVar1 == *(int *)(param_1 + (long)iVar1 * 4 + -4))) break;
if (*(int *)(param_1 + (long)iVar1 * 4) == iVar1 + 1) {
local_14 = iVar1 + 1;
}
else {
local_10 = iVar1 + -1;
}
}
return iVar1 + 1;
} |
4,029 | func0 | #include <assert.h>
| int func0(int ar[], int N) {
int l = 0;
int r = N - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (ar[mid] != mid + 1 && ar[mid - 1] == mid) {
return mid + 1;
} else if (ar[mid] != mid + 1) {
r = mid - 1;
} else {
l = mid + 1;
}
}
return -1;
}
| int main() {
int ar1[] = {1, 2, 3, 5};
assert(func0(ar1, 4) == 4);
int ar2[] = {1, 3, 4, 5};
assert(func0(ar2, 4) == 2);
int ar3[] = {1, 2, 3, 5, 6, 7};
assert(func0(ar3, 6) == 4);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
mov $0x0,%ecx
jmp 1179 <func0+0x10>
mov %eax,%ecx
cmp %ecx,%esi
jl 11ac <func0+0x43>
lea (%rsi,%rcx,1),%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
mov %eax,%r8d
movslq %eax,%rdx
lea 0x0(,%rdx,4),%r9
add $0x1,%eax
cmp %eax,(%rdi,%rdx,4)
je 1177 <func0+0xe>
cmp %r8d,-0x4(%rdi,%r9,1)
je 11b1 <func0+0x48>
lea -0x1(%r8),%esi
jmp 1179 <func0+0x10>
mov $0xffffffff,%eax
retq
| func0:
endbr64
sub esi, 1
mov ecx, 0
jmp short loc_117A
loc_1177:
mov ecx, r8d
loc_117A:
cmp esi, ecx
jl short loc_11AB
lea edx, [rsi+rcx]
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
movsxd rdx, eax
lea r9, ds:0[rdx*4]
lea r8d, [rax+1]
cmp [rdi+rdx*4], r8d
jz short loc_1177
cmp [rdi+r9-4], eax
jz short loc_11B1
lea esi, [rax-1]
jmp short loc_117A
loc_11AB:
mov r8d, 0FFFFFFFFh
loc_11B1:
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
int v2; // esi
int v3; // ecx
int v4; // eax
unsigned int v5; // r8d
v2 = a2 - 1;
v3 = 0;
while ( v2 >= v3 )
{
v4 = (v2 + v3) / 2;
v5 = v4 + 1;
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 + 1 )
{
v3 = v4 + 1;
}
else
{
if ( *(_DWORD *)(a1 + 4LL * v4 - 4) == v4 )
return v5;
v2 = v4 - 1;
}
}
return (unsigned int)-1;
} | func0:
ENDBR64
SUB ESI,0x1
MOV ECX,0x0
JMP 0x0010117a
LAB_00101177:
MOV ECX,R8D
LAB_0010117a:
CMP ESI,ECX
JL 0x001011ab
LEA EDX,[RSI + RCX*0x1]
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOVSXD RDX,EAX
LEA R9,[RDX*0x4]
LEA R8D,[RAX + 0x1]
CMP dword ptr [RDI + RDX*0x4],R8D
JZ 0x00101177
CMP dword ptr [RDI + R9*0x1 + -0x4],EAX
JZ 0x001011b1
LEA ESI,[RAX + -0x1]
JMP 0x0010117a
LAB_001011ab:
MOV R8D,0xffffffff
LAB_001011b1:
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
param_2 = param_2 + -1;
iVar1 = 0;
while( true ) {
do {
iVar3 = iVar1;
if (param_2 < iVar3) {
return -1;
}
iVar2 = (param_2 + iVar3) / 2;
iVar1 = iVar2 + 1;
} while (*(int *)(param_1 + (long)iVar2 * 4) == iVar1);
if (*(int *)(param_1 + -4 + (long)iVar2 * 4) == iVar2) break;
param_2 = iVar2 + -1;
iVar1 = iVar3;
}
return iVar1;
} |
4,030 | func0 | #include <assert.h>
| int func0(int ar[], int N) {
int l = 0;
int r = N - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (ar[mid] != mid + 1 && ar[mid - 1] == mid) {
return mid + 1;
} else if (ar[mid] != mid + 1) {
r = mid - 1;
} else {
l = mid + 1;
}
}
return -1;
}
| int main() {
int ar1[] = {1, 2, 3, 5};
assert(func0(ar1, 4) == 4);
int ar2[] = {1, 3, 4, 5};
assert(func0(ar2, 4) == 2);
int ar3[] = {1, 2, 3, 5, 6, 7};
assert(func0(ar3, 6) == 4);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
xor %ecx,%ecx
nopl 0x0(%rax)
cmp %ecx,%esi
jl 1318 <func0+0x48>
lea (%rsi,%rcx,1),%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
movslq %eax,%rdx
lea 0x1(%rax),%r8d
lea 0x0(,%rdx,4),%r9
cmp %r8d,(%rdi,%rdx,4)
je 1328 <func0+0x58>
cmp %eax,-0x4(%rdi,%r9,1)
je 131e <func0+0x4e>
lea -0x1(%rax),%esi
cmp %ecx,%esi
jge 12e4 <func0+0x14>
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %r8d,%ecx
jmp 12e0 <func0+0x10>
nopl (%rax)
| func0:
endbr64
sub esi, 1
xor ecx, ecx
nop dword ptr [rax+00000000h]
loc_12B0:
cmp esi, ecx
jl short loc_12E8
loc_12B4:
lea edx, [rsi+rcx]
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
movsxd rdx, eax
lea r8d, [rax+1]
lea r9, ds:0[rdx*4]
cmp [rdi+rdx*4], r8d
jz short loc_12F8
cmp [rdi+r9-4], eax
jz short loc_12EE
lea esi, [rax-1]
cmp esi, ecx
jge short loc_12B4
nop dword ptr [rax+rax+00h]
loc_12E8:
mov r8d, 0FFFFFFFFh
loc_12EE:
mov eax, r8d
retn
loc_12F8:
mov ecx, r8d
jmp short loc_12B0 | long long func0(long long a1, int a2)
{
int v2; // esi
int i; // ecx
int v4; // eax
unsigned int v5; // r8d
v2 = a2 - 1;
for ( i = 0; v2 >= i; i = v4 + 1 )
{
while ( 1 )
{
v4 = (v2 + i) / 2;
v5 = v4 + 1;
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 + 1 )
break;
if ( *(_DWORD *)(a1 + 4LL * v4 - 4) == v4 )
return v5;
v2 = v4 - 1;
if ( v4 - 1 < i )
return (unsigned int)-1;
}
}
return (unsigned int)-1;
} | func0:
ENDBR64
SUB ESI,0x1
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_001012b0:
CMP ESI,ECX
JL 0x001012e8
LAB_001012b4:
LEA EDX,[RSI + RCX*0x1]
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOVSXD RDX,EAX
LEA R8D,[RAX + 0x1]
LEA R9,[RDX*0x4]
CMP dword ptr [RDI + RDX*0x4],R8D
JZ 0x001012f8
CMP dword ptr [RDI + R9*0x1 + -0x4],EAX
JZ 0x001012ee
LEA ESI,[RAX + -0x1]
CMP ESI,ECX
JGE 0x001012b4
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e8:
MOV R8D,0xffffffff
LAB_001012ee:
MOV EAX,R8D
RET
LAB_001012f8:
MOV ECX,R8D
JMP 0x001012b0 | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
param_2 = param_2 + -1;
iVar1 = 0;
do {
iVar3 = iVar1;
if (param_2 < iVar3) {
return -1;
}
while( true ) {
iVar2 = (param_2 + iVar3) / 2;
iVar1 = iVar2 + 1;
if (*(int *)(param_1 + (long)iVar2 * 4) == iVar1) break;
if (*(int *)(param_1 + -4 + (long)iVar2 * 4) == iVar2) {
return iVar1;
}
param_2 = iVar2 + -1;
if (param_2 < iVar3) {
return -1;
}
}
} while( true );
} |
4,031 | func0 | #include <assert.h>
| int func0(int ar[], int N) {
int l = 0;
int r = N - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (ar[mid] != mid + 1 && ar[mid - 1] == mid) {
return mid + 1;
} else if (ar[mid] != mid + 1) {
r = mid - 1;
} else {
l = mid + 1;
}
}
return -1;
}
| int main() {
int ar1[] = {1, 2, 3, 5};
assert(func0(ar1, 4) == 4);
int ar2[] = {1, 3, 4, 5};
assert(func0(ar2, 4) == 2);
int ar3[] = {1, 2, 3, 5, 6, 7};
assert(func0(ar3, 6) == 4);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1,%esi
xor %ecx,%ecx
nopl 0x0(%rax)
cmp %ecx,%esi
jl 12e8 <func0+0x48>
lea (%rsi,%rcx,1),%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
movslq %eax,%rdx
lea 0x1(%rax),%r8d
lea 0x0(,%rdx,4),%r9
cmp %r8d,(%rdi,%rdx,4)
je 12f8 <func0+0x58>
cmp %eax,-0x4(%rdi,%r9,1)
je 12ee <func0+0x4e>
lea -0x1(%rax),%esi
cmp %ecx,%esi
jge 12b4 <func0+0x14>
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %r8d,%ecx
jmp 12b0 <func0+0x10>
nopl (%rax)
| func0:
endbr64
sub esi, 1
xor ecx, ecx
nop dword ptr [rax+00000000h]
loc_12B0:
cmp esi, ecx
jl short loc_12E8
loc_12B4:
lea edx, [rsi+rcx]
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
movsxd rdx, eax
lea r8d, [rax+1]
lea r9, ds:0[rdx*4]
cmp [rdi+rdx*4], r8d
jz short loc_12F8
cmp [rdi+r9-4], eax
jz short loc_12EE
lea esi, [rax-1]
cmp esi, ecx
jge short loc_12B4
nop dword ptr [rax+rax+00h]
loc_12E8:
mov r8d, 0FFFFFFFFh
loc_12EE:
mov eax, r8d
retn
loc_12F8:
mov ecx, r8d
jmp short loc_12B0 | long long func0(long long a1, int a2)
{
int v2; // esi
int i; // ecx
int v4; // eax
unsigned int v5; // r8d
v2 = a2 - 1;
for ( i = 0; v2 >= i; i = v4 + 1 )
{
while ( 1 )
{
v4 = (v2 + i) / 2;
v5 = v4 + 1;
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 + 1 )
break;
if ( *(_DWORD *)(a1 + 4LL * v4 - 4) == v4 )
return v5;
v2 = v4 - 1;
if ( v4 - 1 < i )
return (unsigned int)-1;
}
}
return (unsigned int)-1;
} | func0:
ENDBR64
SUB ESI,0x1
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_001012b0:
CMP ESI,ECX
JL 0x001012e8
LAB_001012b4:
LEA EDX,[RSI + RCX*0x1]
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOVSXD RDX,EAX
LEA R8D,[RAX + 0x1]
LEA R9,[RDX*0x4]
CMP dword ptr [RDI + RDX*0x4],R8D
JZ 0x001012f8
CMP dword ptr [RDI + R9*0x1 + -0x4],EAX
JZ 0x001012ee
LEA ESI,[RAX + -0x1]
CMP ESI,ECX
JGE 0x001012b4
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e8:
MOV R8D,0xffffffff
LAB_001012ee:
MOV EAX,R8D
RET
LAB_001012f8:
MOV ECX,R8D
JMP 0x001012b0 | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
param_2 = param_2 + -1;
iVar1 = 0;
do {
iVar3 = iVar1;
if (param_2 < iVar3) {
return -1;
}
while( true ) {
iVar2 = (param_2 + iVar3) / 2;
iVar1 = iVar2 + 1;
if (*(int *)(param_1 + (long)iVar2 * 4) == iVar1) break;
if (*(int *)(param_1 + -4 + (long)iVar2 * 4) == iVar2) {
return iVar1;
}
param_2 = iVar2 + -1;
if (param_2 < iVar3) {
return -1;
}
}
} while( true );
} |
4,032 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (n + 1);
}
| int main() {
assert(func0(4) == 20);
assert(func0(5) == 30);
assert(func0(6) == 42);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add $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, 1
imul eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
return (param_1 + 1) * param_1;
} |
4,033 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (n + 1);
}
| int main() {
assert(func0(4) == 20);
assert(func0(5) == 30);
assert(func0(6) == 42);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %edi,%eax
retq
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1));
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 + 1) * param_1;
} |
4,034 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (n + 1);
}
| int main() {
assert(func0(4) == 20);
assert(func0(5) == 30);
assert(func0(6) == 42);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1));
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 + 1) * param_1;
} |
4,035 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (n + 1);
}
| int main() {
assert(func0(4) == 20);
assert(func0(5) == 30);
assert(func0(6) == 42);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1));
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 + 1) * param_1;
} |
4,036 | func0 |
#include <assert.h>
| int func0(int p, int q, int N) {
int res;
while (N > 0) {
N--;
p *= 10;
res = p / q;
p = p % q;
}
return res;
}
| int main() {
assert(func0(1, 2, 1) == 5);
assert(func0(3, 5, 1) == 6);
assert(func0(5, 6, 5) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
jmp 1183 <func0+0x3a>
subl $0x1,-0x1c(%rbp)
mov -0x14(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x14(%rbp)
cmpl $0x0,-0x1c(%rbp)
jg 115c <func0+0x13>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
jmp short loc_1183
loc_115C:
sub [rbp+var_1C], 1
mov edx, [rbp+var_14]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_14], edx
loc_1183:
cmp [rbp+var_1C], 0
jg short loc_115C
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
int v6; // [rsp+8h] [rbp-14h]
unsigned int v7; // [rsp+18h] [rbp-4h]
while ( a3 > 0 )
{
--a3;
v6 = 10 * a1;
v7 = v6 / a2;
a1 = v6 % a2;
}
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
JMP 0x00101183
LAB_0010115c:
SUB dword ptr [RBP + -0x1c],0x1
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EDX
LAB_00101183:
CMP dword ptr [RBP + -0x1c],0x0
JG 0x0010115c
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2,int param_3)
{
int4 local_24;
int4 local_1c;
int4 local_c;
local_1c = param_1;
for (local_24 = param_3; 0 < local_24; local_24 = local_24 + -1) {
local_c = (local_1c * 10) / param_2;
local_1c = (local_1c * 10) % param_2;
}
return local_c;
} |
4,037 | func0 |
#include <assert.h>
| int func0(int p, int q, int N) {
int res;
while (N > 0) {
N--;
p *= 10;
res = p / q;
p = p % q;
}
return res;
}
| int main() {
assert(func0(1, 2, 1) == 5);
assert(func0(3, 5, 1) == 6);
assert(func0(5, 6, 5) == 3);
return 0;
}
| O1 | c | func0:
endbr64
mov %edx,%r8d
test %edx,%edx
jle 116c <func0+0x23>
lea (%rdi,%rdi,4),%ecx
add %ecx,%ecx
mov %ecx,%eax
cltd
idiv %esi
mov %edx,%edi
sub $0x1,%r8d
jne 1154 <func0+0xb>
mov %ecx,%eax
cltd
idiv %esi
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov r8d, edx
test edx, edx
jle short loc_116C
loc_1154:
lea ecx, [rdi+rdi*4]
add ecx, ecx
mov eax, ecx
cdq
idiv esi
mov edi, edx
sub r8d, 1
jnz short loc_1154
mov eax, ecx
cdq
idiv esi
retn
loc_116C:
mov eax, 0
retn | long long func0(int a1, int a2, int a3)
{
int v3; // r8d
int v4; // ecx
v3 = a3;
if ( a3 <= 0 )
return 0LL;
do
{
v4 = 10 * a1;
a1 = 10 * a1 % a2;
--v3;
}
while ( v3 );
return (unsigned int)(v4 / a2);
} | func0:
ENDBR64
MOV R8D,EDX
TEST EDX,EDX
JLE 0x0010116c
LAB_00101154:
LEA ECX,[RDI + RDI*0x4]
ADD ECX,ECX
MOV EAX,ECX
CDQ
IDIV ESI
MOV EDI,EDX
SUB R8D,0x1
JNZ 0x00101154
MOV EAX,ECX
CDQ
IDIV ESI
RET
LAB_0010116c:
MOV EAX,0x0
RET | int1 [16] func0(int param_1,int param_2,ulong param_3)
{
int1 auVar1 [16];
int iVar2;
uint uVar3;
ulong uVar4;
int1 auVar5 [16];
uVar4 = param_3 & 0xffffffff;
if (0 < (int)param_3) {
do {
iVar2 = param_1 * 10;
param_1 = iVar2 % param_2;
uVar3 = (int)uVar4 - 1;
uVar4 = (ulong)uVar3;
} while (uVar3 != 0);
auVar5._0_8_ = (long)iVar2 / (long)param_2 & 0xffffffff;
auVar5._8_8_ = (long)iVar2 % (long)param_2 & 0xffffffff;
return auVar5;
}
auVar1._8_8_ = 0;
auVar1._0_8_ = param_3;
return auVar1 << 0x40;
} |
4,038 | func0 |
#include <assert.h>
| int func0(int p, int q, int N) {
int res;
while (N > 0) {
N--;
p *= 10;
res = p / q;
p = p % q;
}
return res;
}
| int main() {
assert(func0(1, 2, 1) == 5);
assert(func0(3, 5, 1) == 6);
assert(func0(5, 6, 5) == 3);
return 0;
}
| O2 | c | func0:
endbr64
mov %edx,%ecx
test %edx,%edx
jle 1160 <func0+0x20>
nopw 0x0(%rax,%rax,1)
lea (%rdi,%rdi,4),%eax
add %eax,%eax
cltd
idiv %esi
mov %edx,%edi
sub $0x1,%ecx
jne 1150 <func0+0x10>
retq
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov ecx, edx
test edx, edx
jle short loc_1160
nop word ptr [rax+rax+00h]
loc_1150:
lea eax, [rdi+rdi*4]
add eax, eax
cdq
idiv esi
mov edi, edx
sub ecx, 1
jnz short loc_1150
retn
loc_1160:
xor eax, eax
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
v3 = a3;
if ( a3 <= 0 )
return 0LL;
do
{
result = (unsigned int)(10 * a1 / a2);
a1 = 10 * a1 % a2;
--v3;
}
while ( v3 );
return result;
} | func0:
ENDBR64
MOV ECX,EDX
TEST EDX,EDX
JLE 0x00101160
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EAX,[RDI + RDI*0x4]
ADD EAX,EAX
CDQ
IDIV ESI
MOV EDI,EDX
SUB ECX,0x1
JNZ 0x00101150
RET
LAB_00101160:
XOR EAX,EAX
RET | ulong func0(int param_1,int param_2,int param_3)
{
int iVar1;
if (param_3 < 1) {
return 0;
}
do {
iVar1 = param_1 * 10;
param_1 = iVar1 % param_2;
param_3 = param_3 + -1;
} while (param_3 != 0);
return (long)iVar1 / (long)param_2 & 0xffffffff;
} |
4,039 | func0 |
#include <assert.h>
| int func0(int p, int q, int N) {
int res;
while (N > 0) {
N--;
p *= 10;
res = p / q;
p = p % q;
}
return res;
}
| int main() {
assert(func0(1, 2, 1) == 5);
assert(func0(3, 5, 1) == 6);
assert(func0(5, 6, 5) == 3);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%ecx
test %edx,%edx
jle 1160 <func0+0x20>
nopw 0x0(%rax,%rax,1)
lea (%rdi,%rdi,4),%eax
add %eax,%eax
cltd
idiv %esi
mov %edx,%edi
sub $0x1,%ecx
jne 1150 <func0+0x10>
retq
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov ecx, edx
test edx, edx
jle short loc_1160
nop word ptr [rax+rax+00h]
loc_1150:
lea eax, [rdi+rdi*4]
add eax, eax
cdq
idiv esi
mov edi, edx
sub ecx, 1
jnz short loc_1150
retn
loc_1160:
xor eax, eax
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
v3 = a3;
if ( a3 <= 0 )
return 0LL;
do
{
result = (unsigned int)(10 * a1 / a2);
a1 = 10 * a1 % a2;
--v3;
}
while ( v3 );
return result;
} | func0:
ENDBR64
MOV ECX,EDX
TEST EDX,EDX
JLE 0x00101160
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EAX,[RDI + RDI*0x4]
ADD EAX,EAX
CDQ
IDIV ESI
MOV EDI,EDX
SUB ECX,0x1
JNZ 0x00101150
RET
LAB_00101160:
XOR EAX,EAX
RET | ulong func0(int param_1,int param_2,int param_3)
{
int iVar1;
if (param_3 < 1) {
return 0;
}
do {
iVar1 = param_1 * 10;
param_1 = iVar1 % param_2;
param_3 = param_3 + -1;
} while (param_3 != 0);
return (long)iVar1 / (long)param_2 & 0xffffffff;
} |
4,040 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int i;
char* s;
} value;
} Mixed;
int compare_ints(const void* a, const void* b) {
int int_a = ((Mixed*)a)->value.i;
int int_b = ((Mixed*)b)->value.i;
return (int_a > int_b) - (int_a < int_b);
}
int compare_strings(const void* a, const void* b) {
char* str_a = ((Mixed*)a)->value.s;
char* str_b = ((Mixed*)b)->value.s;
return strcmp(str_a, str_b);
}
| Mixed* func0(Mixed* mixed_list, size_t size, size_t* sorted_size) {
size_t int_count = 0, str_count = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) int_count++;
else str_count++;
}
Mixed* int_part = malloc(int_count * sizeof(Mixed));
Mixed* str_part = malloc(str_count * sizeof(Mixed));
size_t int_idx = 0, str_idx = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) {
int_part[int_idx++] = mixed_list[i];
} else {
str_part[str_idx++] = mixed_list[i];
}
}
qsort(int_part, int_count, sizeof(Mixed), compare_ints);
qsort(str_part, str_count, sizeof(Mixed), compare_strings);
Mixed* sorted = malloc(size * sizeof(Mixed));
for(size_t i = 0; i < int_count; i++) {
sorted[i] = int_part[i];
}
for(size_t i = 0; i < str_count; i++) {
sorted[int_count + i] = str_part[i];
}
free(int_part);
free(str_part);
*sorted_size = size;
return sorted;
}
| int main() {
Mixed input[] = {
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "red"},
{INT_TYPE, .value.i = 12},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "blue"},
{INT_TYPE, .value.i = 10},
{STRING_TYPE, .value.s = "white"},
{STRING_TYPE, .value.s = "green"},
{INT_TYPE, .value.i = 1}
};
size_t size = sizeof(input) / sizeof(input[0]);
Mixed* sorted = func0(input, size, &size);
Mixed expected[] = {
{INT_TYPE, .value.i = 1},
{INT_TYPE, .value.i = 10},
{INT_TYPE, .value.i = 12},
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "blue"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "red"},
{STRING_TYPE, .value.s = "white"}
};
size_t expected_size = sizeof(expected) / sizeof(expected[0]);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted[i].type == expected[i].type);
if(sorted[i].type == INT_TYPE) {
assert(sorted[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted[i].value.s, expected[i].value.s) == 0);
}
}
// Repeat the assertions
Mixed* sorted2 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted2[i].type == expected[i].type);
if(sorted2[i].type == INT_TYPE) {
assert(sorted2[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted2[i].value.s, expected[i].value.s) == 0);
}
}
Mixed* sorted3 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted3[i].type == expected[i].type);
if(sorted3[i].type == INT_TYPE) {
assert(sorted3[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted3[i].value.s, expected[i].value.s) == 0);
}
}
free(sorted);
free(sorted2);
free(sorted3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %rdx,-0x78(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
jmp 12c7 <func0+0x5b>
mov -0x48(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 12bd <func0+0x51>
addq $0x1,-0x58(%rbp)
jmp 12c2 <func0+0x56>
addq $0x1,-0x50(%rbp)
addq $0x1,-0x48(%rbp)
mov -0x48(%rbp),%rax
cmp -0x70(%rbp),%rax
jb 129e <func0+0x32>
mov -0x58(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x18(%rbp)
mov -0x50(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x10(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
movq $0x0,-0x30(%rbp)
jmpq 13ad <func0+0x141>
mov -0x30(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 136c <func0+0x100>
mov -0x30(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x68(%rbp),%rax
lea (%rdx,%rax,1),%rsi
mov -0x40(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x40(%rbp)
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov (%rsi),%rax
mov 0x8(%rsi),%rdx
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
jmp 13a8 <func0+0x13c>
mov -0x30(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x68(%rbp),%rax
lea (%rdx,%rax,1),%rsi
mov -0x38(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x38(%rbp)
shl $0x4,%rax
mov %rax,%rdx
mov -0x10(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov (%rsi),%rax
mov 0x8(%rsi),%rdx
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
addq $0x1,-0x30(%rbp)
mov -0x30(%rbp),%rax
cmp -0x70(%rbp),%rax
jb 1316 <func0+0xaa>
mov -0x58(%rbp),%rsi
mov -0x18(%rbp),%rax
lea -0x1e1(%rip),%rcx
mov $0x10,%edx
mov %rax,%rdi
callq 10b0 <qsort@plt>
mov -0x50(%rbp),%rsi
mov -0x10(%rbp),%rax
lea -0x1bb(%rip),%rcx
mov $0x10,%edx
mov %rax,%rdi
callq 10b0 <qsort@plt>
mov -0x70(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
movq $0x0,-0x28(%rbp)
jmp 1448 <func0+0x1dc>
mov -0x28(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x8(%rbp),%rdx
add %rdx,%rcx
mov 0x8(%rax),%rdx
mov (%rax),%rax
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
addq $0x1,-0x28(%rbp)
mov -0x28(%rbp),%rax
cmp -0x58(%rbp),%rax
jb 1411 <func0+0x1a5>
movq $0x0,-0x20(%rbp)
jmp 149a <func0+0x22e>
mov -0x20(%rbp),%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov -0x58(%rbp),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x8(%rbp),%rdx
add %rdx,%rcx
mov 0x8(%rax),%rdx
mov (%rax),%rax
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
addq $0x1,-0x20(%rbp)
mov -0x20(%rbp),%rax
cmp -0x50(%rbp),%rax
jb 145c <func0+0x1f0>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x78(%rbp),%rax
mov -0x70(%rbp),%rdx
mov %rdx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov [rbp+nmemb], 0
mov [rbp+var_50], 0
mov [rbp+var_48], 0
jmp short loc_12C7
loc_129E:
mov rax, [rbp+var_48]
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_68]
add rax, rdx
mov eax, [rax]
test eax, eax
jnz short loc_12BD
add [rbp+nmemb], 1
jmp short loc_12C2
loc_12BD:
add [rbp+var_50], 1
loc_12C2:
add [rbp+var_48], 1
loc_12C7:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_70]
jb short loc_129E
mov rax, [rbp+nmemb]
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+base], rax
mov rax, [rbp+var_50]
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov [rbp+var_30], 0
jmp loc_13AD
loc_1316:
mov rax, [rbp+var_30]
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_68]
add rax, rdx
mov eax, [rax]
test eax, eax
jnz short loc_136C
mov rax, [rbp+var_30]
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_68]
lea rsi, [rdx+rax]
mov rax, [rbp+var_40]
lea rdx, [rax+1]
mov [rbp+var_40], rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+base]
lea rcx, [rdx+rax]
mov rax, [rsi]
mov rdx, [rsi+8]
mov [rcx], rax
mov [rcx+8], rdx
jmp short loc_13A8
loc_136C:
mov rax, [rbp+var_30]
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_68]
lea rsi, [rdx+rax]
mov rax, [rbp+var_38]
lea rdx, [rax+1]
mov [rbp+var_38], rdx
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
lea rcx, [rdx+rax]
mov rax, [rsi]
mov rdx, [rsi+8]
mov [rcx], rax
mov [rcx+8], rdx
loc_13A8:
add [rbp+var_30], 1
loc_13AD:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_70]
jb loc_1316
mov rsi, [rbp+nmemb]; nmemb
mov rax, [rbp+base]
lea rdx, compare_ints
mov rcx, rdx; compar
mov edx, 10h; size
mov rdi, rax; base
call _qsort
mov rsi, [rbp+var_50]; nmemb
mov rax, [rbp+ptr]
lea rdx, compare_strings
mov rcx, rdx; compar
mov edx, 10h; size
mov rdi, rax; base
call _qsort
mov rax, [rbp+var_70]
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_28], 0
jmp short loc_144E
loc_1417:
mov rax, [rbp+var_28]
shl rax, 4
mov rdx, rax
mov rax, [rbp+base]
add rax, rdx
mov rdx, [rbp+var_28]
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_8]
add rcx, rdx
mov rdx, [rax+8]
mov rax, [rax]
mov [rcx], rax
mov [rcx+8], rdx
add [rbp+var_28], 1
loc_144E:
mov rax, [rbp+var_28]
cmp rax, [rbp+nmemb]
jb short loc_1417
mov [rbp+var_20], 0
jmp short loc_14A0
loc_1462:
mov rax, [rbp+var_20]
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
add rax, rdx
mov rcx, [rbp+nmemb]
mov rdx, [rbp+var_20]
add rdx, rcx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_8]
add rcx, rdx
mov rdx, [rax+8]
mov rax, [rax]
mov [rcx], rax
mov [rcx+8], rdx
add [rbp+var_20], 1
loc_14A0:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_50]
jb short loc_1462
mov rax, [rbp+base]
mov rdi, rax; ptr
call _free
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_78]
mov rdx, [rbp+var_70]
mov [rax], rdx
mov rax, [rbp+var_8]
leave
retn | char * func0(long long a1, unsigned long long a2, unsigned long long *a3)
{
long long v3; // rsi
long long v4; // rax
char *v5; // rcx
long long v6; // rdx
long long v7; // rax
char *v8; // rax
char *v9; // rcx
long long v10; // rdx
char *v11; // rax
char *v12; // rcx
long long v13; // rdx
size_t nmemb; // [rsp+28h] [rbp-58h]
size_t v18; // [rsp+30h] [rbp-50h]
unsigned long long i; // [rsp+38h] [rbp-48h]
long long v20; // [rsp+40h] [rbp-40h]
long long v21; // [rsp+48h] [rbp-38h]
unsigned long long j; // [rsp+50h] [rbp-30h]
size_t k; // [rsp+58h] [rbp-28h]
size_t m; // [rsp+60h] [rbp-20h]
char *base; // [rsp+68h] [rbp-18h]
char *ptr; // [rsp+70h] [rbp-10h]
char *v27; // [rsp+78h] [rbp-8h]
nmemb = 0LL;
v18 = 0LL;
for ( i = 0LL; i < a2; ++i )
{
if ( *(_DWORD *)(16 * i + a1) )
++v18;
else
++nmemb;
}
base = (char *)malloc(16 * nmemb);
ptr = (char *)malloc(16 * v18);
v20 = 0LL;
v21 = 0LL;
for ( j = 0LL; j < a2; ++j )
{
v3 = 16 * j + a1;
if ( *(_DWORD *)v3 )
{
v7 = v21++;
v5 = &ptr[16 * v7];
}
else
{
v4 = v20++;
v5 = &base[16 * v4];
}
v6 = *(_QWORD *)(v3 + 8);
*(_QWORD *)v5 = *(_QWORD *)v3;
*((_QWORD *)v5 + 1) = v6;
}
qsort(base, nmemb, 0x10uLL, compare_ints);
qsort(ptr, v18, 0x10uLL, compare_strings);
v27 = (char *)malloc(16 * a2);
for ( k = 0LL; k < nmemb; ++k )
{
v8 = &base[16 * k];
v9 = &v27[16 * k];
v10 = *((_QWORD *)v8 + 1);
*(_QWORD *)v9 = *(_QWORD *)v8;
*((_QWORD *)v9 + 1) = v10;
}
for ( m = 0LL; m < v18; ++m )
{
v11 = &ptr[16 * m];
v12 = &v27[16 * nmemb + 16 * m];
v13 = *((_QWORD *)v11 + 1);
*(_QWORD *)v12 = *(_QWORD *)v11;
*((_QWORD *)v12 + 1) = v13;
}
free(base);
free(ptr);
*a3 = a2;
return v27;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
JMP 0x001012c7
LAB_0010129e:
MOV RAX,qword ptr [RBP + -0x48]
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x001012bd
ADD qword ptr [RBP + -0x58],0x1
JMP 0x001012c2
LAB_001012bd:
ADD qword ptr [RBP + -0x50],0x1
LAB_001012c2:
ADD qword ptr [RBP + -0x48],0x1
LAB_001012c7:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x70]
JC 0x0010129e
MOV RAX,qword ptr [RBP + -0x58]
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x50]
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV qword ptr [RBP + -0x30],0x0
JMP 0x001013ad
LAB_00101316:
MOV RAX,qword ptr [RBP + -0x30]
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x0010136c
MOV RAX,qword ptr [RBP + -0x30]
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x68]
LEA RSI,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x40]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x40],RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
JMP 0x001013a8
LAB_0010136c:
MOV RAX,qword ptr [RBP + -0x30]
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x68]
LEA RSI,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x38],RDX
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
LAB_001013a8:
ADD qword ptr [RBP + -0x30],0x1
LAB_001013ad:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x70]
JC 0x00101316
MOV RSI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011e9]
MOV RCX,RDX
MOV EDX,0x10
MOV RDI,RAX
CALL 0x001010b0
MOV RSI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[0x10122b]
MOV RCX,RDX
MOV EDX,0x10
MOV RDI,RAX
CALL 0x001010b0
MOV RAX,qword ptr [RBP + -0x70]
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x28],0x0
JMP 0x0010144e
LAB_00101417:
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x8]
ADD RCX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
ADD qword ptr [RBP + -0x28],0x1
LAB_0010144e:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x58]
JC 0x00101417
MOV qword ptr [RBP + -0x20],0x0
JMP 0x001014a0
LAB_00101462:
MOV RAX,qword ptr [RBP + -0x20]
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x8]
ADD RCX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
ADD qword ptr [RBP + -0x20],0x1
LAB_001014a0:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x50]
JC 0x00101462
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,ulong param_2,ulong *param_3)
{
int8 uVar1;
void *__base;
void *__base_00;
void *pvVar2;
int8 *puVar3;
int8 *puVar4;
size_t local_60;
size_t local_58;
ulong local_50;
long local_48;
long local_40;
ulong local_38;
ulong local_30;
ulong local_28;
local_60 = 0;
local_58 = 0;
for (local_50 = 0; local_50 < param_2; local_50 = local_50 + 1) {
if (*(int *)(param_1 + local_50 * 0x10) == 0) {
local_60 = local_60 + 1;
}
else {
local_58 = local_58 + 1;
}
}
__base = malloc(local_60 << 4);
__base_00 = malloc(local_58 << 4);
local_48 = 0;
local_40 = 0;
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
if (*(int *)(param_1 + local_38 * 0x10) == 0) {
puVar3 = (int8 *)(local_38 * 0x10 + param_1);
puVar4 = (int8 *)(local_48 * 0x10 + (long)__base);
uVar1 = puVar3[1];
*puVar4 = *puVar3;
puVar4[1] = uVar1;
local_48 = local_48 + 1;
}
else {
puVar3 = (int8 *)(local_38 * 0x10 + param_1);
puVar4 = (int8 *)(local_40 * 0x10 + (long)__base_00);
uVar1 = puVar3[1];
*puVar4 = *puVar3;
puVar4[1] = uVar1;
local_40 = local_40 + 1;
}
}
qsort(__base,local_60,0x10,compare_ints);
qsort(__base_00,local_58,0x10,compare_strings);
pvVar2 = malloc(param_2 << 4);
for (local_30 = 0; local_30 < local_60; local_30 = local_30 + 1) {
puVar3 = (int8 *)((long)__base + local_30 * 0x10);
puVar4 = (int8 *)(local_30 * 0x10 + (long)pvVar2);
uVar1 = puVar3[1];
*puVar4 = *puVar3;
puVar4[1] = uVar1;
}
for (local_28 = 0; local_28 < local_58; local_28 = local_28 + 1) {
puVar3 = (int8 *)((long)__base_00 + local_28 * 0x10);
puVar4 = (int8 *)((local_28 + local_60) * 0x10 + (long)pvVar2);
uVar1 = puVar3[1];
*puVar4 = *puVar3;
puVar4[1] = uVar1;
}
free(__base);
free(__base_00);
*param_3 = param_2;
return pvVar2;
} |
4,041 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int i;
char* s;
} value;
} Mixed;
int compare_ints(const void* a, const void* b) {
int int_a = ((Mixed*)a)->value.i;
int int_b = ((Mixed*)b)->value.i;
return (int_a > int_b) - (int_a < int_b);
}
int compare_strings(const void* a, const void* b) {
char* str_a = ((Mixed*)a)->value.s;
char* str_b = ((Mixed*)b)->value.s;
return strcmp(str_a, str_b);
}
| Mixed* func0(Mixed* mixed_list, size_t size, size_t* sorted_size) {
size_t int_count = 0, str_count = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) int_count++;
else str_count++;
}
Mixed* int_part = malloc(int_count * sizeof(Mixed));
Mixed* str_part = malloc(str_count * sizeof(Mixed));
size_t int_idx = 0, str_idx = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) {
int_part[int_idx++] = mixed_list[i];
} else {
str_part[str_idx++] = mixed_list[i];
}
}
qsort(int_part, int_count, sizeof(Mixed), compare_ints);
qsort(str_part, str_count, sizeof(Mixed), compare_strings);
Mixed* sorted = malloc(size * sizeof(Mixed));
for(size_t i = 0; i < int_count; i++) {
sorted[i] = int_part[i];
}
for(size_t i = 0; i < str_count; i++) {
sorted[int_count + i] = str_part[i];
}
free(int_part);
free(str_part);
*sorted_size = size;
return sorted;
}
| int main() {
Mixed input[] = {
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "red"},
{INT_TYPE, .value.i = 12},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "blue"},
{INT_TYPE, .value.i = 10},
{STRING_TYPE, .value.s = "white"},
{STRING_TYPE, .value.s = "green"},
{INT_TYPE, .value.i = 1}
};
size_t size = sizeof(input) / sizeof(input[0]);
Mixed* sorted = func0(input, size, &size);
Mixed expected[] = {
{INT_TYPE, .value.i = 1},
{INT_TYPE, .value.i = 10},
{INT_TYPE, .value.i = 12},
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "blue"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "red"},
{STRING_TYPE, .value.s = "white"}
};
size_t expected_size = sizeof(expected) / sizeof(expected[0]);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted[i].type == expected[i].type);
if(sorted[i].type == INT_TYPE) {
assert(sorted[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted[i].value.s, expected[i].value.s) == 0);
}
}
// Repeat the assertions
Mixed* sorted2 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted2[i].type == expected[i].type);
if(sorted2[i].type == INT_TYPE) {
assert(sorted2[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted2[i].value.s, expected[i].value.s) == 0);
}
}
Mixed* sorted3 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted3[i].type == expected[i].type);
if(sorted3[i].type == INT_TYPE) {
assert(sorted3[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted3[i].value.s, expected[i].value.s) == 0);
}
}
free(sorted);
free(sorted2);
free(sorted3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,(%rsp)
mov %rdx,0x8(%rsp)
test %rsi,%rsi
je 1399 <func0+0x17b>
mov %rsi,%rax
mov %rdi,%rbx
shl $0x4,%rax
mov %rax,%r13
add %rdi,%r13
mov $0x0,%r12d
mov $0x0,%ebp
jmp 1270 <func0+0x52>
add $0x1,%r12
add $0x10,%rdi
cmp %r13,%rdi
je 136c <func0+0x14e>
cmpl $0x0,(%rdi)
jne 125f <func0+0x41>
add $0x1,%rbp
jmp 1263 <func0+0x45>
mov %rdx,%rcx
shl $0x4,%rcx
movdqu (%rbx),%xmm3
movups %xmm3,(%r14,%rcx,1)
lea 0x1(%rdx),%rdx
add $0x10,%rbx
cmp %r13,%rbx
je 12b3 <func0+0x95>
cmpl $0x0,(%rbx)
jne 127b <func0+0x5d>
mov %rax,%rcx
shl $0x4,%rcx
movdqu (%rbx),%xmm2
movups %xmm2,(%r15,%rcx,1)
lea 0x1(%rax),%rax
jmp 128f <func0+0x71>
lea -0xd1(%rip),%rcx
mov $0x10,%edx
mov %rbp,%rsi
mov %r15,%rdi
callq 10b0 <qsort@plt>
lea -0xcd(%rip),%rcx
mov $0x10,%edx
mov %r12,%rsi
mov %r14,%rdi
callq 10b0 <qsort@plt>
mov (%rsp),%rdi
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rbx
test %rbp,%rbp
je 1315 <func0+0xf7>
mov %rbp,%rdx
shl $0x4,%rdx
mov $0x0,%eax
movdqu (%r15,%rax,1),%xmm0
movups %xmm0,(%rbx,%rax,1)
add $0x10,%rax
cmp %rdx,%rax
jne 1302 <func0+0xe4>
test %r12,%r12
je 133e <func0+0x120>
shl $0x4,%r12
shl $0x4,%rbp
add %rbx,%rbp
mov $0x0,%eax
movdqu (%r14,%rax,1),%xmm1
movups %xmm1,0x0(%rbp,%rax,1)
add $0x10,%rax
cmp %r12,%rax
jne 132a <func0+0x10c>
mov %r15,%rdi
callq 10a0 <free@plt>
mov %r14,%rdi
callq 10a0 <free@plt>
mov 0x8(%rsp),%rax
mov (%rsp),%rsi
mov %rsi,(%rax)
mov %rbx,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rbp,%rdi
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r15
mov %r12,%rdi
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r14
mov $0x0,%edx
mov $0x0,%eax
jmpq 1298 <func0+0x7a>
mov $0x0,%edi
callq 10f0 <malloc@plt>
mov %rax,%r15
mov $0x0,%edi
callq 10f0 <malloc@plt>
mov %rax,%r14
lea -0x1d1(%rip),%rcx
mov $0x10,%edx
mov $0x0,%esi
mov %r15,%rdi
callq 10b0 <qsort@plt>
lea -0x1cf(%rip),%rcx
mov $0x10,%edx
mov $0x0,%esi
mov %r14,%rdi
callq 10b0 <qsort@plt>
mov (%rsp),%rbp
mov %rbp,%rdi
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rbx
mov %rbp,%r12
jmpq 1315 <func0+0xf7>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rsi
mov [rsp+48h+var_40], rdx
test rsi, rsi
jz loc_1397
mov rax, rsi
mov rbx, rdi
shl rax, 4
mov r13, rax
add r13, rdi
mov r12d, 0
mov ebp, 0
jmp short loc_126E
loc_125D:
add r12, 1
loc_1261:
add rdi, 10h
cmp rdi, r13
jz loc_136A
loc_126E:
cmp dword ptr [rdi], 0
jnz short loc_125D
add rbp, 1
jmp short loc_1261
loc_1279:
mov rcx, rdx
shl rcx, 4
movdqu xmm3, xmmword ptr [rbx]
movups xmmword ptr [r14+rcx], xmm3
lea rdx, [rdx+1]
loc_128D:
add rbx, 10h
cmp rbx, r13
jz short loc_12B1
loc_1296:
cmp dword ptr [rbx], 0
jnz short loc_1279
mov rcx, rax
shl rcx, 4
movdqu xmm2, xmmword ptr [rbx]
movups xmmword ptr [r15+rcx], xmm2
lea rax, [rax+1]
jmp short loc_128D
loc_12B1:
lea rcx, compare_ints
mov edx, 10h
mov rsi, rbp
mov rdi, r15
call _qsort
lea rcx, compare_strings
mov edx, 10h
mov rsi, r12
mov rdi, r14
call _qsort
mov rdi, [rsp+48h+var_48]
shl rdi, 4
call _malloc
mov rbx, rax
test rbp, rbp
jz short loc_1313
mov rdx, rbp
shl rdx, 4
mov eax, 0
loc_1300:
movdqu xmm0, xmmword ptr [r15+rax]
movups xmmword ptr [rbx+rax], xmm0
add rax, 10h
cmp rax, rdx
jnz short loc_1300
loc_1313:
test r12, r12
jz short loc_133C
shl r12, 4
shl rbp, 4
add rbp, rbx
mov eax, 0
loc_1328:
movdqu xmm1, xmmword ptr [r14+rax]
movups xmmword ptr [rbp+rax+0], xmm1
add rax, 10h
cmp rax, r12
jnz short loc_1328
loc_133C:
mov rdi, r15
call _free
mov rdi, r14
call _free
mov rax, [rsp+48h+var_40]
mov rsi, [rsp+48h+var_48]
mov [rax], rsi
mov rax, rbx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_136A:
mov rdi, rbp
shl rdi, 4
call _malloc
mov r15, rax
mov rdi, r12
shl rdi, 4
call _malloc
mov r14, rax
mov edx, 0
mov eax, 0
jmp loc_1296
loc_1397:
mov edi, 0
call _malloc
mov r15, rax
mov edi, 0
call _malloc
mov r14, rax
lea rcx, compare_ints
mov edx, 10h
mov esi, 0
mov rdi, r15
call _qsort
lea rcx, compare_strings
mov edx, 10h
mov esi, 0
mov rdi, r14
call _qsort
mov rbp, [rsp+48h+var_48]
mov rdi, rbp
shl rdi, 4
call _malloc
mov rbx, rax
mov r12, rbp
jmp loc_1313 | long long func0(const __m128i *a1, long long a2, _QWORD *a3)
{
const __m128i *v3; // rbx
const __m128i *v4; // r13
long long v5; // r12
long long v6; // rbp
long long v7; // rdx
long long v8; // rax
long long v9; // rbx
long long v10; // rax
long long v11; // r12
long long v12; // rbp
long long v13; // rax
long long v15; // r15
long long v16; // r14
if ( a2 )
{
v3 = a1;
v4 = &a1[a2];
v5 = 0LL;
v6 = 0LL;
do
{
if ( a1->m128i_i32[0] )
++v5;
else
++v6;
++a1;
}
while ( a1 != v4 );
v15 = malloc(16 * v6);
v16 = malloc(16 * v5);
v7 = 0LL;
v8 = 0LL;
do
{
if ( v3->m128i_i32[0] )
*(__m128i *)(v16 + 16 * v7++) = _mm_loadu_si128(v3);
else
*(__m128i *)(v15 + 16 * v8++) = _mm_loadu_si128(v3);
++v3;
}
while ( v3 != v4 );
qsort(v15, v6, 16LL, compare_ints);
qsort(v16, v5, 16LL, compare_strings);
v9 = malloc(16 * a2);
if ( v6 )
{
v10 = 0LL;
do
{
*(__m128i *)(v9 + v10) = _mm_loadu_si128((const __m128i *)(v15 + v10));
v10 += 16LL;
}
while ( v10 != 16 * v6 );
}
}
else
{
v15 = malloc(0LL);
v16 = malloc(0LL);
qsort(v15, 0LL, 16LL, compare_ints);
qsort(v16, 0LL, 16LL, compare_strings);
v6 = 0LL;
v9 = malloc(0LL);
v5 = 0LL;
}
if ( v5 )
{
v11 = 16 * v5;
v12 = v9 + 16 * v6;
v13 = 0LL;
do
{
*(__m128i *)(v12 + v13) = _mm_loadu_si128((const __m128i *)(v16 + v13));
v13 += 16LL;
}
while ( v13 != v11 );
}
free(v15);
free(v16);
*a3 = a2;
return v9;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RSI
MOV qword ptr [RSP + 0x8],RDX
TEST RSI,RSI
JZ 0x00101397
MOV RAX,RSI
MOV RBX,RDI
SHL RAX,0x4
MOV R13,RAX
ADD R13,RDI
MOV R12D,0x0
MOV EBP,0x0
JMP 0x0010126e
LAB_0010125d:
ADD R12,0x1
LAB_00101261:
ADD RDI,0x10
CMP RDI,R13
JZ 0x0010136a
LAB_0010126e:
CMP dword ptr [RDI],0x0
JNZ 0x0010125d
ADD RBP,0x1
JMP 0x00101261
LAB_00101279:
MOV RCX,RDX
SHL RCX,0x4
MOVDQU XMM3,xmmword ptr [RBX]
MOVUPS xmmword ptr [R14 + RCX*0x1],XMM3
LEA RDX,[RDX + 0x1]
LAB_0010128d:
ADD RBX,0x10
CMP RBX,R13
JZ 0x001012b1
LAB_00101296:
CMP dword ptr [RBX],0x0
JNZ 0x00101279
MOV RCX,RAX
SHL RCX,0x4
MOVDQU XMM2,xmmword ptr [RBX]
MOVUPS xmmword ptr [R15 + RCX*0x1],XMM2
LEA RAX,[RAX + 0x1]
JMP 0x0010128d
LAB_001012b1:
LEA RCX,[0x1011e9]
MOV EDX,0x10
MOV RSI,RBP
MOV RDI,R15
CALL 0x001010b0
LEA RCX,[0x101202]
MOV EDX,0x10
MOV RSI,R12
MOV RDI,R14
CALL 0x001010b0
MOV RDI,qword ptr [RSP]
SHL RDI,0x4
CALL 0x001010f0
MOV RBX,RAX
TEST RBP,RBP
JZ 0x00101313
MOV RDX,RBP
SHL RDX,0x4
MOV EAX,0x0
LAB_00101300:
MOVDQU XMM0,xmmword ptr [R15 + RAX*0x1]
MOVUPS xmmword ptr [RBX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101300
LAB_00101313:
TEST R12,R12
JZ 0x0010133c
SHL R12,0x4
SHL RBP,0x4
ADD RBP,RBX
MOV EAX,0x0
LAB_00101328:
MOVDQU XMM1,xmmword ptr [R14 + RAX*0x1]
MOVUPS xmmword ptr [RBP + RAX*0x1],XMM1
ADD RAX,0x10
CMP RAX,R12
JNZ 0x00101328
LAB_0010133c:
MOV RDI,R15
CALL 0x001010a0
MOV RDI,R14
CALL 0x001010a0
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP]
MOV qword ptr [RAX],RSI
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010136a:
MOV RDI,RBP
SHL RDI,0x4
CALL 0x001010f0
MOV R15,RAX
MOV RDI,R12
SHL RDI,0x4
CALL 0x001010f0
MOV R14,RAX
MOV EDX,0x0
MOV EAX,0x0
JMP 0x00101296
LAB_00101397:
MOV EDI,0x0
CALL 0x001010f0
MOV R15,RAX
MOV EDI,0x0
CALL 0x001010f0
MOV R14,RAX
LEA RCX,[0x1011e9]
MOV EDX,0x10
MOV ESI,0x0
MOV RDI,R15
CALL 0x001010b0
LEA RCX,[0x101202]
MOV EDX,0x10
MOV ESI,0x0
MOV RDI,R14
CALL 0x001010b0
MOV RBP,qword ptr [RSP]
MOV RDI,RBP
SHL RDI,0x4
CALL 0x001010f0
MOV RBX,RAX
MOV R12,RBP
JMP 0x00101313 | void * func0(int *param_1,long param_2,long *param_3)
{
int8 *puVar1;
int8 uVar2;
void *pvVar3;
void *__base;
void *__base_00;
long lVar4;
long lVar5;
size_t __nmemb;
int *piVar6;
size_t __nmemb_00;
int *piVar7;
if (param_2 == 0) {
__base = malloc(0);
__base_00 = malloc(0);
qsort(__base,0,0x10,compare_ints);
qsort(__base_00,0,0x10,compare_strings);
pvVar3 = malloc(0);
__nmemb = 0;
__nmemb_00 = 0;
}
else {
piVar7 = param_1 + param_2 * 4;
__nmemb_00 = 0;
__nmemb = 0;
piVar6 = param_1;
do {
if (*piVar6 == 0) {
__nmemb = __nmemb + 1;
}
else {
__nmemb_00 = __nmemb_00 + 1;
}
piVar6 = piVar6 + 4;
} while (piVar6 != piVar7);
__base = malloc(__nmemb << 4);
__base_00 = malloc(__nmemb_00 << 4);
lVar5 = 0;
lVar4 = 0;
do {
if (*param_1 == 0) {
uVar2 = *(int8 *)(param_1 + 2);
puVar1 = (int8 *)((long)__base + lVar4 * 0x10);
*puVar1 = *(int8 *)param_1;
puVar1[1] = uVar2;
lVar4 = lVar4 + 1;
}
else {
uVar2 = *(int8 *)(param_1 + 2);
puVar1 = (int8 *)((long)__base_00 + lVar5 * 0x10);
*puVar1 = *(int8 *)param_1;
puVar1[1] = uVar2;
lVar5 = lVar5 + 1;
}
param_1 = param_1 + 4;
} while (param_1 != piVar7);
qsort(__base,__nmemb,0x10,compare_ints);
qsort(__base_00,__nmemb_00,0x10,compare_strings);
pvVar3 = malloc(param_2 << 4);
if (__nmemb != 0) {
lVar5 = 0;
do {
uVar2 = ((int8 *)((long)__base + lVar5))[1];
*(int8 *)((long)pvVar3 + lVar5) = *(int8 *)((long)__base + lVar5);
((int8 *)((long)pvVar3 + lVar5))[1] = uVar2;
lVar5 = lVar5 + 0x10;
} while (lVar5 != __nmemb << 4);
}
}
if (__nmemb_00 != 0) {
lVar5 = 0;
do {
uVar2 = ((int8 *)((long)__base_00 + lVar5))[1];
puVar1 = (int8 *)((long)pvVar3 + lVar5 + __nmemb * 0x10);
*puVar1 = *(int8 *)((long)__base_00 + lVar5);
puVar1[1] = uVar2;
lVar5 = lVar5 + 0x10;
} while (lVar5 != __nmemb_00 * 0x10);
}
free(__base);
free(__base_00);
*param_3 = param_2;
return pvVar3;
} |
4,042 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int i;
char* s;
} value;
} Mixed;
int compare_ints(const void* a, const void* b) {
int int_a = ((Mixed*)a)->value.i;
int int_b = ((Mixed*)b)->value.i;
return (int_a > int_b) - (int_a < int_b);
}
int compare_strings(const void* a, const void* b) {
char* str_a = ((Mixed*)a)->value.s;
char* str_b = ((Mixed*)b)->value.s;
return strcmp(str_a, str_b);
}
| Mixed* func0(Mixed* mixed_list, size_t size, size_t* sorted_size) {
size_t int_count = 0, str_count = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) int_count++;
else str_count++;
}
Mixed* int_part = malloc(int_count * sizeof(Mixed));
Mixed* str_part = malloc(str_count * sizeof(Mixed));
size_t int_idx = 0, str_idx = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) {
int_part[int_idx++] = mixed_list[i];
} else {
str_part[str_idx++] = mixed_list[i];
}
}
qsort(int_part, int_count, sizeof(Mixed), compare_ints);
qsort(str_part, str_count, sizeof(Mixed), compare_strings);
Mixed* sorted = malloc(size * sizeof(Mixed));
for(size_t i = 0; i < int_count; i++) {
sorted[i] = int_part[i];
}
for(size_t i = 0; i < str_count; i++) {
sorted[int_count + i] = str_part[i];
}
free(int_part);
free(str_part);
*sorted_size = size;
return sorted;
}
| int main() {
Mixed input[] = {
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "red"},
{INT_TYPE, .value.i = 12},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "blue"},
{INT_TYPE, .value.i = 10},
{STRING_TYPE, .value.s = "white"},
{STRING_TYPE, .value.s = "green"},
{INT_TYPE, .value.i = 1}
};
size_t size = sizeof(input) / sizeof(input[0]);
Mixed* sorted = func0(input, size, &size);
Mixed expected[] = {
{INT_TYPE, .value.i = 1},
{INT_TYPE, .value.i = 10},
{INT_TYPE, .value.i = 12},
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "blue"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "red"},
{STRING_TYPE, .value.s = "white"}
};
size_t expected_size = sizeof(expected) / sizeof(expected[0]);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted[i].type == expected[i].type);
if(sorted[i].type == INT_TYPE) {
assert(sorted[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted[i].value.s, expected[i].value.s) == 0);
}
}
// Repeat the assertions
Mixed* sorted2 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted2[i].type == expected[i].type);
if(sorted2[i].type == INT_TYPE) {
assert(sorted2[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted2[i].value.s, expected[i].value.s) == 0);
}
}
Mixed* sorted3 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted3[i].type == expected[i].type);
if(sorted3[i].type == INT_TYPE) {
assert(sorted3[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted3[i].value.s, expected[i].value.s) == 0);
}
}
free(sorted);
free(sorted2);
free(sorted3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
mov %rdx,(%rsp)
test %rsi,%rsi
je 1860 <func0+0x190>
shl $0x4,%rsi
mov %rdi,%rbx
mov %rdi,%rax
xor %r14d,%r14d
add %rdi,%rsi
xor %r13d,%r13d
jmp 171d <func0+0x4d>
nopw 0x0(%rax,%rax,1)
add $0x10,%rax
add $0x1,%r13
cmp %rsi,%rax
je 1730 <func0+0x60>
mov (%rax),%edi
test %edi,%edi
je 1710 <func0+0x40>
add $0x10,%rax
add $0x1,%r14
cmp %rsi,%rax
jne 171d <func0+0x4d>
mov %r13,%rdi
mov %rsi,0x8(%rsp)
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %r14,%rdi
shl $0x4,%rdi
mov %rax,%r12
callq 10f0 <malloc@plt>
mov 0x8(%rsp),%rsi
xor %edx,%edx
mov %rax,%r15
xor %eax,%eax
jmp 177d <func0+0xad>
xchg %ax,%ax
movdqu (%rbx),%xmm2
mov %rax,%rcx
add $0x10,%rbx
add $0x1,%rax
shl $0x4,%rcx
movups %xmm2,(%r12,%rcx,1)
cmp %rsi,%rbx
je 17a0 <func0+0xd0>
mov (%rbx),%ecx
test %ecx,%ecx
je 1760 <func0+0x90>
movdqu (%rbx),%xmm3
mov %rdx,%rcx
add $0x10,%rbx
add $0x1,%rdx
shl $0x4,%rcx
movups %xmm3,(%r15,%rcx,1)
cmp %rsi,%rbx
jne 177d <func0+0xad>
lea -0x117(%rip),%rcx
mov $0x10,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 10b0 <qsort@plt>
mov $0x10,%edx
mov %r14,%rsi
mov %r15,%rdi
lea -0x119(%rip),%rcx
callq 10b0 <qsort@plt>
mov %rbp,%rdi
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rbx
test %r13,%r13
je 1803 <func0+0x133>
mov %r13,%rax
xor %edx,%edx
shl $0x4,%rax
nopl 0x0(%rax,%rax,1)
movdqu (%r12,%rdx,1),%xmm0
movups %xmm0,(%rbx,%rdx,1)
add $0x10,%rdx
cmp %rdx,%rax
jne 17f0 <func0+0x120>
test %r14,%r14
je 182d <func0+0x15d>
shl $0x4,%r13
shl $0x4,%r14
xor %edx,%edx
add %rbx,%r13
nopl (%rax)
movdqu (%r15,%rdx,1),%xmm1
movups %xmm1,0x0(%r13,%rdx,1)
add $0x10,%rdx
cmp %r14,%rdx
jne 1818 <func0+0x148>
mov %r12,%rdi
callq 10a0 <free@plt>
mov %r15,%rdi
callq 10a0 <free@plt>
mov (%rsp),%rax
mov %rbp,(%rax)
add $0x18,%rsp
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
xor %edi,%edi
callq 10f0 <malloc@plt>
xor %edi,%edi
mov %rax,%r12
callq 10f0 <malloc@plt>
mov $0x10,%edx
xor %esi,%esi
mov %r12,%rdi
mov %rax,%r15
lea -0x1f5(%rip),%rcx
callq 10b0 <qsort@plt>
mov $0x10,%edx
xor %esi,%esi
mov %r15,%rdi
lea -0x1eb(%rip),%rcx
callq 10b0 <qsort@plt>
xor %edi,%edi
callq 10f0 <malloc@plt>
mov %rax,%rbx
jmp 182d <func0+0x15d>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rsi
mov [rsp+48h+var_40], rdx
test rsi, rsi
jz loc_1860
mov rax, rsi
mov rbx, rdi
xor r15d, r15d
xor r12d, r12d
shl rax, 4
mov rbp, rax
mov rax, rdi
add rbp, rdi
jmp short loc_173D
loc_1730:
add rax, 10h
add r12, 1
cmp rbp, rax
jz short loc_1750
loc_173D:
mov esi, [rax]
test esi, esi
jz short loc_1730
add rax, 10h
add r15, 1
cmp rbp, rax
jnz short loc_173D
loc_1750:
mov rdi, r12
shl rdi, 4
call _malloc
mov rdi, r15
shl rdi, 4
mov r13, rax
call _malloc
xor edx, edx
mov r14, rax
xor eax, eax
jmp short loc_1796
loc_1778:
movdqu xmm0, xmmword ptr [rbx]
mov rcx, rax
add rbx, 10h
add rax, 1
shl rcx, 4
movups xmmword ptr [r13+rcx+0], xmm0
cmp rbp, rbx
jz short loc_17B9
loc_1796:
mov ecx, [rbx]
test ecx, ecx
jz short loc_1778
movdqu xmm1, xmmword ptr [rbx]
mov rcx, rdx
add rbx, 10h
add rdx, 1
shl rcx, 4
movups xmmword ptr [r14+rcx], xmm1
cmp rbp, rbx
jnz short loc_1796
loc_17B9:
lea rcx, compare_ints
mov edx, 10h
mov rsi, r12
mov rdi, r13
call _qsort
mov edx, 10h
mov rsi, r15
mov rdi, r14
lea rcx, compare_strings
call _qsort
mov rdi, [rsp+48h+var_48]
shl rdi, 4
call _malloc
mov rbx, rax
test r12, r12
jz short loc_180E
mov rdx, r12
mov rsi, r13
mov rdi, rax
shl rdx, 4
call _memcpy
loc_180E:
test r15, r15
jz short loc_182A
shl r12, 4
mov rdx, r15
mov rsi, r14
lea rdi, [rbx+r12]
shl rdx, 4
call _memcpy
loc_182A:
mov rdi, r13
call _free
mov rdi, r14
call _free
mov rax, [rsp+48h+var_40]
mov rsi, [rsp+48h+var_48]
mov [rax], rsi
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1860:
xor edi, edi
call _malloc
xor edi, edi
mov r13, rax
call _malloc
mov edx, 10h
xor esi, esi
mov rdi, r13
mov r14, rax
lea rcx, compare_ints
call _qsort
mov edx, 10h
xor esi, esi
mov rdi, r14
lea rcx, compare_strings
call _qsort
xor edi, edi
call _malloc
mov rbx, rax
jmp loc_182A | long long func0(const __m128i *a1, long long a2, _QWORD *a3)
{
const __m128i *v3; // rbx
long long v4; // r15
long long v5; // r12
const __m128i *v6; // rax
const __m128i *v7; // rbp
long long v8; // r13
long long v9; // rax
long long v10; // rdx
long long v11; // r14
long long v12; // rax
__m128i v13; // xmm0
long long v14; // rcx
__m128i v15; // xmm1
long long v16; // rcx
long long v17; // rax
long long v18; // rbx
if ( a2 )
{
v3 = a1;
v4 = 0LL;
v5 = 0LL;
v6 = a1;
v7 = &a1[a2];
do
{
while ( !v6->m128i_i32[0] )
{
++v6;
++v5;
if ( v7 == v6 )
goto LABEL_6;
}
++v6;
++v4;
}
while ( v7 != v6 );
LABEL_6:
v8 = malloc(16 * v5);
v9 = malloc(16 * v4);
v10 = 0LL;
v11 = v9;
v12 = 0LL;
do
{
while ( !v3->m128i_i32[0] )
{
v13 = _mm_loadu_si128(v3);
v14 = v12;
++v3;
++v12;
*(__m128i *)(v8 + 16 * v14) = v13;
if ( v7 == v3 )
goto LABEL_10;
}
v15 = _mm_loadu_si128(v3);
v16 = v10;
++v3;
++v10;
*(__m128i *)(v11 + 16 * v16) = v15;
}
while ( v7 != v3 );
LABEL_10:
qsort(v8, v5, 16LL, compare_ints);
qsort(v11, v4, 16LL, compare_strings);
v17 = malloc(16 * a2);
v18 = v17;
if ( v5 )
memcpy(v17, v8, 16 * v5);
if ( v4 )
memcpy(v18 + 16 * v5, v11, 16 * v4);
}
else
{
v8 = malloc(0LL);
v11 = malloc(0LL);
qsort(v8, 0LL, 16LL, compare_ints);
qsort(v11, 0LL, 16LL, compare_strings);
v18 = malloc(0LL);
}
free(v8);
free(v11);
*a3 = a2;
return v18;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RSI
MOV qword ptr [RSP + 0x8],RDX
TEST RSI,RSI
JZ 0x00101860
MOV RAX,RSI
MOV RBX,RDI
XOR R15D,R15D
XOR R12D,R12D
SHL RAX,0x4
MOV RBP,RAX
MOV RAX,RDI
ADD RBP,RDI
JMP 0x0010173d
LAB_00101730:
ADD RAX,0x10
ADD R12,0x1
CMP RBP,RAX
JZ 0x00101750
LAB_0010173d:
MOV ESI,dword ptr [RAX]
TEST ESI,ESI
JZ 0x00101730
ADD RAX,0x10
ADD R15,0x1
CMP RBP,RAX
JNZ 0x0010173d
LAB_00101750:
MOV RDI,R12
SHL RDI,0x4
CALL 0x00101110
MOV RDI,R15
SHL RDI,0x4
MOV R13,RAX
CALL 0x00101110
XOR EDX,EDX
MOV R14,RAX
XOR EAX,EAX
JMP 0x00101796
LAB_00101778:
MOVDQU XMM0,xmmword ptr [RBX]
MOV RCX,RAX
ADD RBX,0x10
ADD RAX,0x1
SHL RCX,0x4
MOVUPS xmmword ptr [R13 + RCX*0x1],XMM0
CMP RBP,RBX
JZ 0x001017b9
LAB_00101796:
MOV ECX,dword ptr [RBX]
TEST ECX,ECX
JZ 0x00101778
MOVDQU XMM1,xmmword ptr [RBX]
MOV RCX,RDX
ADD RBX,0x10
ADD RDX,0x1
SHL RCX,0x4
MOVUPS xmmword ptr [R14 + RCX*0x1],XMM1
CMP RBP,RBX
JNZ 0x00101796
LAB_001017b9:
LEA RCX,[0x1016b0]
MOV EDX,0x10
MOV RSI,R12
MOV RDI,R13
CALL 0x001010c0
MOV EDX,0x10
MOV RSI,R15
MOV RDI,R14
LEA RCX,[0x1016d0]
CALL 0x001010c0
MOV RDI,qword ptr [RSP]
SHL RDI,0x4
CALL 0x00101110
MOV RBX,RAX
TEST R12,R12
JZ 0x0010180e
MOV RDX,R12
MOV RSI,R13
MOV RDI,RAX
SHL RDX,0x4
CALL 0x00101100
LAB_0010180e:
TEST R15,R15
JZ 0x0010182a
SHL R12,0x4
MOV RDX,R15
MOV RSI,R14
LEA RDI,[RBX + R12*0x1]
SHL RDX,0x4
CALL 0x00101100
LAB_0010182a:
MOV RDI,R13
CALL 0x001010b0
MOV RDI,R14
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP]
MOV qword ptr [RAX],RSI
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101860:
XOR EDI,EDI
CALL 0x00101110
XOR EDI,EDI
MOV R13,RAX
CALL 0x00101110
MOV EDX,0x10
XOR ESI,ESI
MOV RDI,R13
MOV R14,RAX
LEA RCX,[0x1016b0]
CALL 0x001010c0
MOV EDX,0x10
XOR ESI,ESI
MOV RDI,R14
LEA RCX,[0x1016d0]
CALL 0x001010c0
XOR EDI,EDI
CALL 0x00101110
MOV RBX,RAX
JMP 0x0010182a | void * func0(int *param_1,long param_2,long *param_3)
{
int8 *puVar1;
int8 uVar2;
int8 uVar3;
int *piVar4;
void *__base;
void *__base_00;
long lVar5;
void *__dest;
long lVar6;
int *piVar7;
size_t __nmemb;
size_t __nmemb_00;
if (param_2 == 0) {
__base = malloc(0);
__base_00 = malloc(0);
qsort(__base,0,0x10,compare_ints);
qsort(__base_00,0,0x10,compare_strings);
__dest = malloc(0);
}
else {
__nmemb_00 = 0;
__nmemb = 0;
piVar7 = param_1 + param_2 * 4;
piVar4 = param_1;
do {
while (*piVar4 != 0) {
piVar4 = piVar4 + 4;
__nmemb_00 = __nmemb_00 + 1;
if (piVar7 == piVar4) goto LAB_00101750;
}
piVar4 = piVar4 + 4;
__nmemb = __nmemb + 1;
} while (piVar7 != piVar4);
LAB_00101750:
__base = malloc(__nmemb << 4);
__base_00 = malloc(__nmemb_00 << 4);
lVar5 = 0;
lVar6 = 0;
do {
while (*param_1 != 0) {
uVar2 = *(int8 *)param_1;
uVar3 = *(int8 *)(param_1 + 2);
param_1 = param_1 + 4;
puVar1 = (int8 *)((long)__base_00 + lVar6 * 0x10);
*puVar1 = uVar2;
puVar1[1] = uVar3;
lVar6 = lVar6 + 1;
if (piVar7 == param_1) goto LAB_001017b9;
}
uVar2 = *(int8 *)param_1;
uVar3 = *(int8 *)(param_1 + 2);
param_1 = param_1 + 4;
puVar1 = (int8 *)((long)__base + lVar5 * 0x10);
*puVar1 = uVar2;
puVar1[1] = uVar3;
lVar5 = lVar5 + 1;
} while (piVar7 != param_1);
LAB_001017b9:
qsort(__base,__nmemb,0x10,compare_ints);
qsort(__base_00,__nmemb_00,0x10,compare_strings);
__dest = malloc(param_2 << 4);
if (__nmemb != 0) {
memcpy(__dest,__base,__nmemb << 4);
}
if (__nmemb_00 != 0) {
memcpy((void *)((long)__dest + __nmemb * 0x10),__base_00,__nmemb_00 << 4);
}
}
free(__base);
free(__base_00);
*param_3 = param_2;
return __dest;
} |
4,043 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int i;
char* s;
} value;
} Mixed;
int compare_ints(const void* a, const void* b) {
int int_a = ((Mixed*)a)->value.i;
int int_b = ((Mixed*)b)->value.i;
return (int_a > int_b) - (int_a < int_b);
}
int compare_strings(const void* a, const void* b) {
char* str_a = ((Mixed*)a)->value.s;
char* str_b = ((Mixed*)b)->value.s;
return strcmp(str_a, str_b);
}
| Mixed* func0(Mixed* mixed_list, size_t size, size_t* sorted_size) {
size_t int_count = 0, str_count = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) int_count++;
else str_count++;
}
Mixed* int_part = malloc(int_count * sizeof(Mixed));
Mixed* str_part = malloc(str_count * sizeof(Mixed));
size_t int_idx = 0, str_idx = 0;
for(size_t i = 0; i < size; i++) {
if(mixed_list[i].type == INT_TYPE) {
int_part[int_idx++] = mixed_list[i];
} else {
str_part[str_idx++] = mixed_list[i];
}
}
qsort(int_part, int_count, sizeof(Mixed), compare_ints);
qsort(str_part, str_count, sizeof(Mixed), compare_strings);
Mixed* sorted = malloc(size * sizeof(Mixed));
for(size_t i = 0; i < int_count; i++) {
sorted[i] = int_part[i];
}
for(size_t i = 0; i < str_count; i++) {
sorted[int_count + i] = str_part[i];
}
free(int_part);
free(str_part);
*sorted_size = size;
return sorted;
}
| int main() {
Mixed input[] = {
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "red"},
{INT_TYPE, .value.i = 12},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "blue"},
{INT_TYPE, .value.i = 10},
{STRING_TYPE, .value.s = "white"},
{STRING_TYPE, .value.s = "green"},
{INT_TYPE, .value.i = 1}
};
size_t size = sizeof(input) / sizeof(input[0]);
Mixed* sorted = func0(input, size, &size);
Mixed expected[] = {
{INT_TYPE, .value.i = 1},
{INT_TYPE, .value.i = 10},
{INT_TYPE, .value.i = 12},
{INT_TYPE, .value.i = 19},
{STRING_TYPE, .value.s = "blue"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "green"},
{STRING_TYPE, .value.s = "red"},
{STRING_TYPE, .value.s = "white"}
};
size_t expected_size = sizeof(expected) / sizeof(expected[0]);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted[i].type == expected[i].type);
if(sorted[i].type == INT_TYPE) {
assert(sorted[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted[i].value.s, expected[i].value.s) == 0);
}
}
// Repeat the assertions
Mixed* sorted2 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted2[i].type == expected[i].type);
if(sorted2[i].type == INT_TYPE) {
assert(sorted2[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted2[i].value.s, expected[i].value.s) == 0);
}
}
Mixed* sorted3 = func0(input, size, &size);
assert(size == expected_size);
for(size_t i = 0; i < size; i++) {
assert(sorted3[i].type == expected[i].type);
if(sorted3[i].type == INT_TYPE) {
assert(sorted3[i].value.i == expected[i].value.i);
} else {
assert(strcmp(sorted3[i].value.s, expected[i].value.s) == 0);
}
}
free(sorted);
free(sorted2);
free(sorted3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
mov %rdx,0x8(%rsp)
test %rsi,%rsi
je 1cf0 <func0+0x290>
lea -0x1(%rsi),%rcx
mov %rdi,%rbx
cmp $0x3,%rcx
jbe 1d3f <func0+0x2df>
mov %rcx,%rdx
pxor %xmm2,%xmm2
pxor %xmm1,%xmm1
mov %rdi,%rax
shr %rdx
movdqa 0x783(%rip),%xmm6
movdqa 0x78b(%rip),%xmm5
movdqa %xmm2,%xmm3
shl $0x5,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm0
movdqu 0x10(%rax),%xmm7
movdqa %xmm6,%xmm4
add $0x20,%rax
shufps $0x0,%xmm7,%xmm0
pcmpeqd %xmm1,%xmm0
pand %xmm0,%xmm4
pandn %xmm5,%xmm0
por %xmm4,%xmm0
movdqa %xmm0,%xmm4
punpckhdq %xmm1,%xmm0
punpckldq %xmm1,%xmm4
paddq %xmm0,%xmm2
paddq %xmm4,%xmm3
cmp %rdx,%rax
jne 1ac0 <func0+0x60>
movq %xmm3,%r13
movq %xmm2,%rdx
psrldq $0x8,%xmm3
psrldq $0x8,%xmm2
movq %xmm2,%rax
movq %xmm3,%r14
add %rdx,%r13
add %rax,%r14
mov %rcx,%rax
and $0xfffffffffffffffe,%rax
mov %rax,%rdx
shl $0x4,%rdx
mov (%rbx,%rdx,1),%r10d
test %r10d,%r10d
je 1cb0 <func0+0x250>
add $0x1,%r13
lea 0x1(%rax),%rdx
cmp %rbp,%rdx
jae 1b99 <func0+0x139>
shl $0x4,%rdx
mov (%rbx,%rdx,1),%r9d
test %r9d,%r9d
jne 1cc0 <func0+0x260>
add $0x1,%r14
lea 0x2(%rax),%rdx
cmp %rbp,%rdx
jae 1b99 <func0+0x139>
shl $0x4,%rdx
mov (%rbx,%rdx,1),%r8d
test %r8d,%r8d
jne 1cd0 <func0+0x270>
add $0x1,%r14
add $0x3,%rax
cmp %rax,%rbp
jbe 1b99 <func0+0x139>
shl $0x4,%rax
mov (%rbx,%rax,1),%edi
test %edi,%edi
je 1ce0 <func0+0x280>
add $0x1,%r13
mov %r14,%rdi
shl $0x4,%rdi
callq 1110 <malloc@plt>
mov %r13,%rdi
shl $0x4,%rdi
mov %rax,%r12
callq 1110 <malloc@plt>
mov %rbp,%rcx
mov %rbx,%rdi
xor %edx,%edx
shl $0x4,%rcx
mov %rax,%r15
xor %eax,%eax
add %rbx,%rcx
jmp 1bed <func0+0x18d>
nopw 0x0(%rax,%rax,1)
movdqu (%rdi),%xmm5
mov %rax,%rsi
add $0x10,%rdi
add $0x1,%rax
shl $0x4,%rsi
movups %xmm5,(%r12,%rsi,1)
cmp %rcx,%rdi
je 1c10 <func0+0x1b0>
mov (%rdi),%esi
test %esi,%esi
je 1bd0 <func0+0x170>
movdqu (%rdi),%xmm6
mov %rdx,%rsi
add $0x10,%rdi
add $0x1,%rdx
shl $0x4,%rsi
movups %xmm6,(%r15,%rsi,1)
cmp %rcx,%rdi
jne 1bed <func0+0x18d>
lea -0x1f7(%rip),%rcx
mov $0x10,%edx
mov %r14,%rsi
mov %r12,%rdi
callq 10c0 <qsort@plt>
mov $0x10,%edx
mov %r13,%rsi
mov %r15,%rdi
lea -0x1f9(%rip),%rcx
callq 10c0 <qsort@plt>
mov %rbp,%rdi
shl $0x4,%rdi
callq 1110 <malloc@plt>
mov %rax,%rbx
test %r14,%r14
je 1c64 <func0+0x204>
mov %r14,%rdx
mov %r12,%rsi
mov %rax,%rdi
shl $0x4,%rdx
callq 1100 <memcpy@plt>
test %r13,%r13
je 1c83 <func0+0x223>
mov %r14,%rax
mov %r13,%rdx
mov %r15,%rsi
shl $0x4,%rax
shl $0x4,%rdx
lea (%rbx,%rax,1),%rdi
callq 1100 <memcpy@plt>
mov %r12,%rdi
callq 10b0 <free@plt>
mov %r15,%rdi
callq 10b0 <free@plt>
mov 0x8(%rsp),%rax
mov %rbp,(%rax)
add $0x18,%rsp
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
add $0x1,%r14
jmpq 1b41 <func0+0xe1>
nopl 0x0(%rax)
add $0x1,%r13
jmpq 1b5f <func0+0xff>
nopl 0x0(%rax)
add $0x1,%r13
jmpq 1b7d <func0+0x11d>
nopl 0x0(%rax)
add $0x1,%r14
jmpq 1b99 <func0+0x139>
nopl 0x0(%rax)
xor %edi,%edi
callq 1110 <malloc@plt>
xor %edi,%edi
mov %rax,%r12
callq 1110 <malloc@plt>
mov $0x10,%edx
xor %esi,%esi
mov %r12,%rdi
mov %rax,%r15
lea -0x2f5(%rip),%rcx
callq 10c0 <qsort@plt>
mov $0x10,%edx
xor %esi,%esi
mov %r15,%rdi
lea -0x2eb(%rip),%rcx
callq 10c0 <qsort@plt>
xor %edi,%edi
callq 1110 <malloc@plt>
mov %rax,%rbx
jmpq 1c83 <func0+0x223>
xor %eax,%eax
xor %r13d,%r13d
xor %r14d,%r14d
jmpq 1b29 <func0+0xc9>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 18h
mov [rsp+48h+var_40], rdx
test rsi, rsi
jz loc_1BE0
lea rdx, [rsi-1]
mov r15, rdi
cmp rdx, 9
jbe loc_1C2F
mov rcx, rdx
pxor xmm4, xmm4
pxor xmm5, xmm5
mov rax, rdi
shr rcx, 1
movdqa xmm7, cs:xmmword_2210
movdqa xmm6, cs:xmmword_2220
movdqa xmm3, xmm4
shl rcx, 5
add rcx, rdi
loc_1890:
movdqu xmm1, xmmword ptr [rax+10h]
movdqu xmm0, xmmword ptr [rax]
movdqa xmm2, xmm5
movdqa xmm8, xmm7
add rax, 20h ; ' '
shufps xmm0, xmm1, 0
pcmpeqd xmm0, xmm5
pcmpgtd xmm2, xmm0
movdqa xmm1, xmm0
punpckldq xmm1, xmm2
punpckhdq xmm0, xmm2
movdqa xmm2, xmm7
pand xmm8, xmm1
pand xmm2, xmm0
pandn xmm1, xmm6
pandn xmm0, xmm6
por xmm1, xmm8
por xmm0, xmm2
paddq xmm3, xmm1
paddq xmm4, xmm0
cmp rax, rcx
jnz short loc_1890
paddq xmm3, xmm4
mov rax, rdx
movhlps xmm5, xmm3
movq rbp, xmm3
and rax, 0FFFFFFFFFFFFFFFEh
movq r14, xmm5
loc_1901:
mov rdx, rax
shl rdx, 4
mov r8d, [r15+rdx]
test r8d, r8d
jz loc_1B40
add rbp, 1
loc_1919:
lea rcx, [rax+1]
cmp rcx, rbx
jnb loc_1A28
mov edi, [r15+rdx+10h]
test edi, edi
jnz loc_1B50
add r14, 1
loc_1937:
lea rcx, [rax+2]
cmp rcx, rbx
jnb loc_1A28
mov esi, [r15+rdx+20h]
test esi, esi
jnz loc_1B60
add r14, 1
loc_1955:
lea rcx, [rax+3]
cmp rcx, rbx
jnb loc_1A28
mov ecx, [r15+rdx+30h]
test ecx, ecx
jnz loc_1B70
add r14, 1
loc_1973:
lea rcx, [rax+4]
cmp rcx, rbx
jnb loc_1A28
mov r13d, [r15+rdx+40h]
test r13d, r13d
jnz loc_1B80
add r14, 1
loc_1992:
lea rcx, [rax+5]
cmp rcx, rbx
jnb loc_1A28
mov r12d, [r15+rdx+50h]
test r12d, r12d
jnz loc_1B90
add r14, 1
loc_19B1:
lea rcx, [rax+6]
cmp rcx, rbx
jnb short loc_1A28
mov r11d, [r15+rdx+60h]
test r11d, r11d
jnz loc_1BA0
add r14, 1
loc_19CC:
lea rcx, [rax+7]
cmp rcx, rbx
jnb short loc_1A28
mov r10d, [r15+rdx+70h]
test r10d, r10d
jz loc_1BB0
add rbp, 1
loc_19E7:
lea rcx, [rax+8]
cmp rcx, rbx
jnb short loc_1A28
mov r9d, [r15+rdx+80h]
test r9d, r9d
jnz loc_1BC0
add r14, 1
loc_1A05:
add rax, 9
cmp rax, rbx
jnb short loc_1A28
mov r8d, [r15+rdx+90h]
test r8d, r8d
jz loc_1BD0
add rbp, 1
nop dword ptr [rax+rax+00h]
loc_1A28:
mov rdi, r14
shl rdi, 4; size
call _malloc
mov rdi, rbp
shl rdi, 4; size
mov r13, rax
call _malloc
mov rsi, rbx
xor ecx, ecx
xor edx, edx
shl rsi, 4
mov r12, rax
mov rax, r15
add rsi, r15
jmp short loc_1A7E
loc_1A60:
movdqu xmm4, xmmword ptr [rax]
mov rdi, rdx
add rax, 10h
add rdx, 1
shl rdi, 4
movups xmmword ptr [r13+rdi+0], xmm4
cmp rsi, rax
jz short loc_1AA1
loc_1A7E:
mov edi, [rax]
test edi, edi
jz short loc_1A60
movdqu xmm3, xmmword ptr [rax]
mov rdi, rcx
add rax, 10h
add rcx, 1
shl rdi, 4
movups xmmword ptr [r12+rdi], xmm3
cmp rsi, rax
jnz short loc_1A7E
loc_1AA1:
lea rcx, compare_ints; compar
mov edx, 10h; size
mov rsi, r14; nmemb
mov rdi, r13; base
call _qsort
mov edx, 10h; size
mov rsi, rbp; nmemb
mov rdi, r12; base
lea rcx, compare_strings; compar
call _qsort
mov rdi, rbx
shl rdi, 4; size
call _malloc
mov r15, rax
test r14, r14
jz short loc_1AF5
mov rdx, r14
mov rsi, r13; src
mov rdi, rax; dest
shl rdx, 4; n
call _memcpy
loc_1AF5:
test rbp, rbp
jz short loc_1B13
mov rdi, r14
mov rdx, rbp
mov rsi, r12; src
shl rdi, 4
shl rdx, 4; n
add rdi, r15; dest
call _memcpy
loc_1B13:
mov rdi, r13; ptr
call _free
mov rdi, r12; ptr
call _free
mov rax, [rsp+48h+var_40]
mov [rax], rbx
add rsp, 18h
mov rax, r15
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1B40:
add r14, 1
jmp loc_1919
loc_1B50:
add rbp, 1
jmp loc_1937
loc_1B60:
add rbp, 1
jmp loc_1955
loc_1B70:
add rbp, 1
jmp loc_1973
loc_1B80:
add rbp, 1
jmp loc_1992
loc_1B90:
add rbp, 1
jmp loc_19B1
loc_1BA0:
add rbp, 1
jmp loc_19CC
loc_1BB0:
add r14, 1
jmp loc_19E7
loc_1BC0:
add rbp, 1
jmp loc_1A05
loc_1BD0:
add r14, 1
jmp loc_1A28
loc_1BE0:
xor edi, edi; size
call _malloc
xor edi, edi; size
mov r13, rax
call _malloc
mov edx, 10h; size
xor esi, esi; nmemb
mov rdi, r13; base
mov r12, rax
lea rcx, compare_ints; compar
call _qsort
mov edx, 10h; size
xor esi, esi; nmemb
mov rdi, r12; base
lea rcx, compare_strings; compar
call _qsort
xor edi, edi; size
call _malloc
mov r15, rax
jmp loc_1B13
loc_1C2F:
xor eax, eax
xor ebp, ebp
xor r14d, r14d
jmp loc_1901 | char * func0(const __m128i *a1, unsigned long long a2, unsigned long long *a3)
{
unsigned long long v4; // rdx
__m128i v5; // xmm4
const __m128i *v6; // rax
__m128i si128; // xmm7
__m128i v8; // xmm6
__m128i v9; // xmm3
__m128 v10; // xmm1
__m128 v11; // xmm0
__m128i v12; // xmm0
__m128i v13; // xmm2
__m128i v14; // xmm1
__m128i v15; // xmm0
__m128 v16; // xmm3
size_t v17; // rbp
unsigned long long v18; // rax
size_t v19; // r14
long long v20; // rdx
__m128i *v21; // r13
__m128i *v22; // rax
long long v23; // rcx
long long v24; // rdx
__m128i *v25; // r12
const __m128i *v26; // rax
const __m128i *v27; // rsi
__m128i v28; // xmm4
long long v29; // rdi
__m128i v30; // xmm3
long long v31; // rdi
char *v32; // rax
char *v33; // r15
if ( a2 )
{
v4 = a2 - 1;
if ( a2 - 1 <= 9 )
{
v18 = 0LL;
v17 = 0LL;
v19 = 0LL;
}
else
{
v5 = 0LL;
v6 = a1;
si128 = _mm_load_si128((const __m128i *)&xmmword_2210);
v8 = _mm_load_si128((const __m128i *)&xmmword_2220);
v9 = 0LL;
do
{
v10 = (__m128)_mm_loadu_si128(v6 + 1);
v11 = (__m128)_mm_loadu_si128(v6);
v6 += 2;
v12 = _mm_cmpeq_epi32((__m128i)_mm_shuffle_ps(v11, v10, 0), (__m128i)0LL);
v13 = _mm_cmpgt_epi32((__m128i)0LL, v12);
v14 = _mm_unpacklo_epi32(v12, v13);
v15 = _mm_unpackhi_epi32(v12, v13);
v9 = _mm_add_epi64(v9, _mm_or_si128(_mm_andnot_si128(v14, v8), _mm_and_si128(si128, v14)));
v5 = _mm_add_epi64(v5, _mm_or_si128(_mm_andnot_si128(v15, v8), _mm_and_si128(si128, v15)));
}
while ( v6 != &a1[2 * (v4 >> 1)] );
v16 = (__m128)_mm_add_epi64(v9, v5);
v17 = v16.m128_u64[0];
v18 = v4 & 0xFFFFFFFFFFFFFFFELL;
v19 = _mm_movehl_ps((__m128)0LL, v16).m128_u64[0];
}
v20 = v18;
if ( a1[v18].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 1 < a2 )
{
if ( a1[v20 + 1].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 2 < a2 )
{
if ( a1[v20 + 2].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 3 < a2 )
{
if ( a1[v20 + 3].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 4 < a2 )
{
if ( a1[v20 + 4].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 5 < a2 )
{
if ( a1[v20 + 5].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 6 < a2 )
{
if ( a1[v20 + 6].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 7 < a2 )
{
if ( a1[v20 + 7].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 8 < a2 )
{
if ( a1[v20 + 8].m128i_i32[0] )
++v17;
else
++v19;
if ( v18 + 9 < a2 )
{
if ( a1[v20 + 9].m128i_i32[0] )
++v17;
else
++v19;
}
}
}
}
}
}
}
}
}
v21 = (__m128i *)malloc(16 * v19);
v22 = (__m128i *)malloc(16 * v17);
v23 = 0LL;
v24 = 0LL;
v25 = v22;
v26 = a1;
v27 = &a1[a2];
do
{
while ( !v26->m128i_i32[0] )
{
v28 = _mm_loadu_si128(v26);
v29 = v24;
++v26;
++v24;
v21[v29] = v28;
if ( v27 == v26 )
goto LABEL_39;
}
v30 = _mm_loadu_si128(v26);
v31 = v23;
++v26;
++v23;
v25[v31] = v30;
}
while ( v27 != v26 );
LABEL_39:
qsort(v21, v19, 0x10uLL, compare_ints);
qsort(v25, v17, 0x10uLL, compare_strings);
v32 = (char *)malloc(16 * a2);
v33 = v32;
if ( v19 )
memcpy(v32, v21, 16 * v19);
if ( v17 )
memcpy(&v33[16 * v19], v25, 16 * v17);
}
else
{
v21 = (__m128i *)malloc(0LL);
v25 = (__m128i *)malloc(0LL);
qsort(v21, 0LL, 0x10uLL, compare_ints);
qsort(v25, 0LL, 0x10uLL, compare_strings);
v33 = (char *)malloc(0LL);
}
free(v21);
free(v25);
*a3 = a2;
return v33;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDX
TEST RSI,RSI
JZ 0x00101be0
LEA RDX,[RSI + -0x1]
MOV R15,RDI
CMP RDX,0x9
JBE 0x00101c2f
MOV RCX,RDX
PXOR XMM4,XMM4
PXOR XMM5,XMM5
MOV RAX,RDI
SHR RCX,0x1
MOVDQA XMM7,xmmword ptr [0x00102210]
MOVDQA XMM6,xmmword ptr [0x00102220]
MOVDQA XMM3,XMM4
SHL RCX,0x5
ADD RCX,RDI
LAB_00101890:
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM2,XMM5
MOVDQA XMM8,XMM7
ADD RAX,0x20
SHUFPS XMM0,XMM1,0x0
PCMPEQD XMM0,XMM5
PCMPGTD XMM2,XMM0
MOVDQA XMM1,XMM0
PUNPCKLDQ XMM1,XMM2
PUNPCKHDQ XMM0,XMM2
MOVDQA XMM2,XMM7
PAND XMM8,XMM1
PAND XMM2,XMM0
PANDN XMM1,XMM6
PANDN XMM0,XMM6
POR XMM1,XMM8
POR XMM0,XMM2
PADDQ XMM3,XMM1
PADDQ XMM4,XMM0
CMP RAX,RCX
JNZ 0x00101890
PADDQ XMM3,XMM4
MOV RAX,RDX
MOVHLPS XMM5,XMM3
MOVQ RBP,XMM3
AND RAX,-0x2
MOVQ R14,XMM5
LAB_00101901:
MOV RDX,RAX
SHL RDX,0x4
MOV R8D,dword ptr [R15 + RDX*0x1]
TEST R8D,R8D
JZ 0x00101b40
ADD RBP,0x1
LAB_00101919:
LEA RCX,[RAX + 0x1]
CMP RCX,RBX
JNC 0x00101a28
MOV EDI,dword ptr [R15 + RDX*0x1 + 0x10]
TEST EDI,EDI
JNZ 0x00101b50
ADD R14,0x1
LAB_00101937:
LEA RCX,[RAX + 0x2]
CMP RCX,RBX
JNC 0x00101a28
MOV ESI,dword ptr [R15 + RDX*0x1 + 0x20]
TEST ESI,ESI
JNZ 0x00101b60
ADD R14,0x1
LAB_00101955:
LEA RCX,[RAX + 0x3]
CMP RCX,RBX
JNC 0x00101a28
MOV ECX,dword ptr [R15 + RDX*0x1 + 0x30]
TEST ECX,ECX
JNZ 0x00101b70
ADD R14,0x1
LAB_00101973:
LEA RCX,[RAX + 0x4]
CMP RCX,RBX
JNC 0x00101a28
MOV R13D,dword ptr [R15 + RDX*0x1 + 0x40]
TEST R13D,R13D
JNZ 0x00101b80
ADD R14,0x1
LAB_00101992:
LEA RCX,[RAX + 0x5]
CMP RCX,RBX
JNC 0x00101a28
MOV R12D,dword ptr [R15 + RDX*0x1 + 0x50]
TEST R12D,R12D
JNZ 0x00101b90
ADD R14,0x1
LAB_001019b1:
LEA RCX,[RAX + 0x6]
CMP RCX,RBX
JNC 0x00101a28
MOV R11D,dword ptr [R15 + RDX*0x1 + 0x60]
TEST R11D,R11D
JNZ 0x00101ba0
ADD R14,0x1
LAB_001019cc:
LEA RCX,[RAX + 0x7]
CMP RCX,RBX
JNC 0x00101a28
MOV R10D,dword ptr [R15 + RDX*0x1 + 0x70]
TEST R10D,R10D
JZ 0x00101bb0
ADD RBP,0x1
LAB_001019e7:
LEA RCX,[RAX + 0x8]
CMP RCX,RBX
JNC 0x00101a28
MOV R9D,dword ptr [R15 + RDX*0x1 + 0x80]
TEST R9D,R9D
JNZ 0x00101bc0
ADD R14,0x1
LAB_00101a05:
ADD RAX,0x9
CMP RAX,RBX
JNC 0x00101a28
MOV R8D,dword ptr [R15 + RDX*0x1 + 0x90]
TEST R8D,R8D
JZ 0x00101bd0
ADD RBP,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101a28:
MOV RDI,R14
SHL RDI,0x4
CALL 0x00101110
MOV RDI,RBP
SHL RDI,0x4
MOV R13,RAX
CALL 0x00101110
MOV RSI,RBX
XOR ECX,ECX
XOR EDX,EDX
SHL RSI,0x4
MOV R12,RAX
MOV RAX,R15
ADD RSI,R15
JMP 0x00101a7e
LAB_00101a60:
MOVDQU XMM4,xmmword ptr [RAX]
MOV RDI,RDX
ADD RAX,0x10
ADD RDX,0x1
SHL RDI,0x4
MOVUPS xmmword ptr [R13 + RDI*0x1],XMM4
CMP RSI,RAX
JZ 0x00101aa1
LAB_00101a7e:
MOV EDI,dword ptr [RAX]
TEST EDI,EDI
JZ 0x00101a60
MOVDQU XMM3,xmmword ptr [RAX]
MOV RDI,RCX
ADD RAX,0x10
ADD RCX,0x1
SHL RDI,0x4
MOVUPS xmmword ptr [R12 + RDI*0x1],XMM3
CMP RSI,RAX
JNZ 0x00101a7e
LAB_00101aa1:
LEA RCX,[0x1017f0]
MOV EDX,0x10
MOV RSI,R14
MOV RDI,R13
CALL 0x001010c0
MOV EDX,0x10
MOV RSI,RBP
MOV RDI,R12
LEA RCX,[0x101810]
CALL 0x001010c0
MOV RDI,RBX
SHL RDI,0x4
CALL 0x00101110
MOV R15,RAX
TEST R14,R14
JZ 0x00101af5
MOV RDX,R14
MOV RSI,R13
MOV RDI,RAX
SHL RDX,0x4
CALL 0x00101100
LAB_00101af5:
TEST RBP,RBP
JZ 0x00101b13
MOV RDI,R14
MOV RDX,RBP
MOV RSI,R12
SHL RDI,0x4
SHL RDX,0x4
ADD RDI,R15
CALL 0x00101100
LAB_00101b13:
MOV RDI,R13
CALL 0x001010b0
MOV RDI,R12
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RBX
ADD RSP,0x18
MOV RAX,R15
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101b40:
ADD R14,0x1
JMP 0x00101919
LAB_00101b50:
ADD RBP,0x1
JMP 0x00101937
LAB_00101b60:
ADD RBP,0x1
JMP 0x00101955
LAB_00101b70:
ADD RBP,0x1
JMP 0x00101973
LAB_00101b80:
ADD RBP,0x1
JMP 0x00101992
LAB_00101b90:
ADD RBP,0x1
JMP 0x001019b1
LAB_00101ba0:
ADD RBP,0x1
JMP 0x001019cc
LAB_00101bb0:
ADD R14,0x1
JMP 0x001019e7
LAB_00101bc0:
ADD RBP,0x1
JMP 0x00101a05
LAB_00101bd0:
ADD R14,0x1
JMP 0x00101a28
LAB_00101be0:
XOR EDI,EDI
CALL 0x00101110
XOR EDI,EDI
MOV R13,RAX
CALL 0x00101110
MOV EDX,0x10
XOR ESI,ESI
MOV RDI,R13
MOV R12,RAX
LEA RCX,[0x1017f0]
CALL 0x001010c0
MOV EDX,0x10
XOR ESI,ESI
MOV RDI,R12
LEA RCX,[0x101810]
CALL 0x001010c0
XOR EDI,EDI
CALL 0x00101110
MOV R15,RAX
JMP 0x00101b13
LAB_00101c2f:
XOR EAX,EAX
XOR EBP,EBP
XOR R14D,R14D
JMP 0x00101901 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(int *param_1,ulong param_2,ulong *param_3)
{
int *piVar1;
int8 *puVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
int8 uVar7;
int8 uVar8;
int *piVar9;
ulong uVar10;
void *__base;
void *__base_00;
void *__dest;
int iVar11;
int iVar13;
int auVar12 [16];
int auVar14 [16];
int auVar15 [16];
long lVar16;
size_t __nmemb;
long lVar17;
size_t __nmemb_00;
long lVar18;
long lVar19;
if (param_2 == 0) {
__base = malloc(0);
__base_00 = malloc(0);
qsort(__base,0,0x10,compare_ints);
qsort(__base_00,0,0x10,compare_strings);
__dest = malloc(0);
}
else {
uVar10 = param_2 - 1;
if (uVar10 < 10) {
uVar10 = 0;
__nmemb = 0;
__nmemb_00 = 0;
}
else {
lVar18 = 0;
lVar19 = 0;
lVar16 = 0;
lVar17 = 0;
piVar9 = param_1;
do {
piVar1 = piVar9 + 4;
iVar13 = *piVar9;
piVar9 = piVar9 + 8;
uVar3 = (uint)(iVar13 == 0);
iVar11 = -uVar3;
uVar4 = (uint)(iVar13 == 0);
iVar13 = -uVar4;
auVar14._4_4_ = iVar13;
auVar14._0_4_ = iVar11;
uVar5 = (uint)(*piVar1 == 0);
uVar6 = (uint)(*piVar1 == 0);
auVar14._8_4_ = iVar13;
auVar14._12_4_ = -(uint)(uVar4 != 0);
auVar15._8_8_ = auVar14._8_8_;
auVar15._4_4_ = -(uint)(uVar3 != 0);
auVar15._0_4_ = iVar11;
auVar12._4_4_ = -(uint)(uVar5 != 0);
auVar12._0_4_ = -uVar5;
auVar12._8_4_ = -uVar6;
auVar12._12_4_ = -(uint)(uVar6 != 0);
auVar15 = ~auVar15 & _DAT_00102220 | _DAT_00102210 & auVar15;
auVar12 = ~auVar12 & _DAT_00102220 | _DAT_00102210 & auVar12;
lVar16 = lVar16 + auVar15._0_8_;
lVar17 = lVar17 + auVar15._8_8_;
lVar18 = lVar18 + auVar12._0_8_;
lVar19 = lVar19 + auVar12._8_8_;
} while (piVar9 != param_1 + (uVar10 >> 1) * 8);
__nmemb = lVar16 + lVar18;
__nmemb_00 = lVar17 + lVar19;
uVar10 = uVar10 & 0xfffffffffffffffe;
}
if (param_1[uVar10 * 4] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 1 < param_2) {
if (param_1[uVar10 * 4 + 4] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 2 < param_2) {
if (param_1[uVar10 * 4 + 8] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 3 < param_2) {
if (param_1[uVar10 * 4 + 0xc] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 4 < param_2) {
if (param_1[uVar10 * 4 + 0x10] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 5 < param_2) {
if (param_1[uVar10 * 4 + 0x14] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 6 < param_2) {
if (param_1[uVar10 * 4 + 0x18] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 7 < param_2) {
if (param_1[uVar10 * 4 + 0x1c] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 8 < param_2) {
if (param_1[uVar10 * 4 + 0x20] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
if (uVar10 + 9 < param_2) {
if (param_1[uVar10 * 4 + 0x24] == 0) {
__nmemb_00 = __nmemb_00 + 1;
}
else {
__nmemb = __nmemb + 1;
}
}
}
}
}
}
}
}
}
}
__base = malloc(__nmemb_00 << 4);
__base_00 = malloc(__nmemb << 4);
piVar9 = param_1 + param_2 * 4;
lVar16 = 0;
lVar17 = 0;
do {
while (*param_1 != 0) {
uVar7 = *(int8 *)param_1;
uVar8 = *(int8 *)(param_1 + 2);
param_1 = param_1 + 4;
puVar2 = (int8 *)((long)__base_00 + lVar16 * 0x10);
*puVar2 = uVar7;
puVar2[1] = uVar8;
lVar16 = lVar16 + 1;
if (piVar9 == param_1) goto LAB_00101aa1;
}
uVar7 = *(int8 *)param_1;
uVar8 = *(int8 *)(param_1 + 2);
param_1 = param_1 + 4;
puVar2 = (int8 *)((long)__base + lVar17 * 0x10);
*puVar2 = uVar7;
puVar2[1] = uVar8;
lVar17 = lVar17 + 1;
} while (piVar9 != param_1);
LAB_00101aa1:
qsort(__base,__nmemb_00,0x10,compare_ints);
qsort(__base_00,__nmemb,0x10,compare_strings);
__dest = malloc(param_2 << 4);
if (__nmemb_00 != 0) {
memcpy(__dest,__base,__nmemb_00 << 4);
}
if (__nmemb != 0) {
memcpy((void *)(__nmemb_00 * 0x10 + (long)__dest),__base_00,__nmemb << 4);
}
}
free(__base);
free(__base_00);
*param_3 = param_2;
return __dest;
} |
4,044 | func0 |
#include <assert.h>
| double func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
if (first_even != -1 && first_odd != -1) {
return (double) first_even / first_odd;
}
return -1;
}
| int main() {
int list1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 4);
int list2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 2);
int list3[] = {1, 5, 7, 9, 10};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0xffffffff,-0x10(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11c7 <func0+0x5e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
jmp 11d3 <func0+0x6a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118f <func0+0x26>
movl $0x0,-0x4(%rbp)
jmp 1218 <func0+0xaf>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
je 1214 <func0+0xab>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
jmp 1220 <func0+0xb7>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11dc <func0+0x73>
cmpl $0xffffffff,-0x10(%rbp)
je 123c <func0+0xd3>
cmpl $0xffffffff,-0xc(%rbp)
je 123c <func0+0xd3>
cvtsi2sdl -0x10(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd %xmm1,%xmm0
jmp 1244 <func0+0xdb>
movsd 0xe54(%rip),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0FFFFFFFFh
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0
jmp short loc_11CB
loc_118F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11C7
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
jmp short loc_11D3
loc_11C7:
add [rbp+var_8], 1
loc_11CB:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_118F
loc_11D3:
mov [rbp+var_4], 0
jmp short loc_1218
loc_11DC:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jz short loc_1214
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
jmp short loc_1220
loc_1214:
add [rbp+var_4], 1
loc_1218:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11DC
loc_1220:
cmp [rbp+var_10], 0FFFFFFFFh
jz short loc_1244
cmp [rbp+var_C], 0FFFFFFFFh
jz short loc_1244
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_10]
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_C]
divsd xmm0, xmm1
jmp short loc_124C
loc_1244:
movsd xmm0, cs:qword_2078
loc_124C:
pop rbp
retn | double func0(long long a1, int a2)
{
int v3; // [rsp+Ch] [rbp-10h]
int v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = -1;
v4 = -1;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
{
v3 = *(_DWORD *)(4LL * i + a1);
break;
}
}
for ( j = 0; j < a2; ++j )
{
if ( (*(_DWORD *)(4LL * j + a1) & 1) != 0 )
{
v4 = *(_DWORD *)(4LL * j + a1);
break;
}
}
if ( v3 == -1 || v4 == -1 )
return -1.0;
else
return (double)v3 / (double)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0xffffffff
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011cb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011c7
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001011d3
LAB_001011c7:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011cb:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118f
LAB_001011d3:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101218
LAB_001011dc:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JZ 0x00101214
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
JMP 0x00101220
LAB_00101214:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101218:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011dc
LAB_00101220:
CMP dword ptr [RBP + -0x10],-0x1
JZ 0x00101244
CMP dword ptr [RBP + -0xc],-0x1
JZ 0x00101244
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x10]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0xc]
DIVSD XMM0,XMM1
JMP 0x0010124c
LAB_00101244:
MOVSD XMM0,qword ptr [0x00102078]
LAB_0010124c:
POP RBP
RET | double func0(long param_1,int param_2)
{
double dVar1;
int local_18;
int local_14;
int local_10;
int local_c;
local_18 = -1;
local_14 = -1;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1) == 0) {
local_18 = *(int *)(param_1 + (long)local_10 * 4);
break;
}
}
local_c = 0;
do {
if (param_2 <= local_c) {
LAB_00101220:
dVar1 = DAT_00102078;
if ((local_18 != -1) && (local_14 != -1)) {
dVar1 = (double)local_18 / (double)local_14;
}
return dVar1;
}
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) != 0) {
local_14 = *(int *)(param_1 + (long)local_c * 4);
goto LAB_00101220;
}
local_c = local_c + 1;
} while( true );
} |
4,045 | func0 |
#include <assert.h>
| double func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
if (first_even != -1 && first_odd != -1) {
return (double) first_even / first_odd;
}
return -1;
}
| int main() {
int list1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 4);
int list2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 2);
int list3[] = {1, 5, 7, 9, 10};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 10);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c9 <func0+0x60>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov (%rdi),%edx
test $0x1,%dl
je 1191 <func0+0x28>
add $0x4,%rdi
cmp %rsi,%rdi
jne 117c <func0+0x13>
mov $0xffffffff,%edx
mov (%rax),%ecx
test $0x1,%cl
jne 11aa <func0+0x41>
add $0x4,%rax
cmp %rsi,%rax
jne 1191 <func0+0x28>
movsd 0xeef(%rip),%xmm0
retq
cmp $0xffffffff,%edx
je 11d2 <func0+0x69>
cmp $0xffffffff,%ecx
je 11d2 <func0+0x69>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd %xmm1,%xmm0
retq
movsd 0xec7(%rip),%xmm0
retq
movsd 0xebe(%rip),%xmm0
retq
| func0:
endbr64
test esi, esi
jle short loc_11C9
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
loc_117C:
mov edx, [rdi]
test dl, 1
jz short loc_1191
add rdi, 4
cmp rdi, rsi
jnz short loc_117C
mov edx, 0FFFFFFFFh
loc_1191:
mov ecx, [rax]
test cl, 1
jnz short loc_11AA
add rax, 4
cmp rax, rsi
jnz short loc_1191
movsd xmm0, cs:qword_2078
retn
loc_11AA:
cmp edx, 0FFFFFFFFh
jz short loc_11D2
cmp ecx, 0FFFFFFFFh
jz short loc_11D2
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
pxor xmm1, xmm1
cvtsi2sd xmm1, ecx
divsd xmm0, xmm1
retn
loc_11C9:
movsd xmm0, cs:qword_2078
retn
loc_11D2:
movsd xmm0, cs:qword_2078
retn | double func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rsi
int v4; // edx
int v5; // ecx
if ( a2 <= 0 )
return -1.0;
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
do
{
v4 = *a1;
if ( (*a1 & 1) == 0 )
goto LABEL_6;
++a1;
}
while ( a1 != (int *)v3 );
v4 = -1;
LABEL_6:
while ( 1 )
{
v5 = *v2;
if ( (*v2 & 1) != 0 )
break;
if ( ++v2 == (int *)v3 )
return -1.0;
}
if ( v4 == -1 || v5 == -1 )
return -1.0;
else
return (double)v4 / (double)v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c9
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
LAB_0010117c:
MOV EDX,dword ptr [RDI]
TEST DL,0x1
JZ 0x00101191
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x0010117c
MOV EDX,0xffffffff
LAB_00101191:
MOV ECX,dword ptr [RAX]
TEST CL,0x1
JNZ 0x001011aa
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101191
MOVSD XMM0,qword ptr [0x00102078]
RET
LAB_001011aa:
CMP EDX,-0x1
JZ 0x001011d2
CMP ECX,-0x1
JZ 0x001011d2
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,ECX
DIVSD XMM0,XMM1
RET
LAB_001011c9:
MOVSD XMM0,qword ptr [0x00102078]
RET
LAB_001011d2:
MOVSD XMM0,qword ptr [0x00102078]
RET | double func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
if (param_2 < 1) {
return DAT_00102078;
}
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar4 = param_1;
do {
uVar3 = *puVar4;
if ((uVar3 & 1) == 0) goto LAB_00101191;
puVar4 = puVar4 + 1;
} while (puVar4 != puVar1);
uVar3 = 0xffffffff;
LAB_00101191:
while (uVar2 = *param_1, (uVar2 & 1) == 0) {
param_1 = param_1 + 1;
if (param_1 == puVar1) {
return DAT_00102078;
}
}
if ((uVar3 != 0xffffffff) && (uVar2 != 0xffffffff)) {
return (double)(int)uVar3 / (double)(int)uVar2;
}
return DAT_00102078;
} |
4,046 | func0 |
#include <assert.h>
| double func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
if (first_even != -1 && first_odd != -1) {
return (double) first_even / first_odd;
}
return -1;
}
| int main() {
int list1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 4);
int list2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 2);
int list3[] = {1, 5, 7, 9, 10};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 10);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1370 <func0+0x60>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
mov %rdi,%rax
jmp 1331 <func0+0x21>
nopl (%rax)
add $0x4,%rax
cmp %rcx,%rax
je 1380 <func0+0x70>
mov (%rax),%edx
test $0x1,%dl
jne 1328 <func0+0x18>
jmp 1349 <func0+0x39>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rcx,%rdi
je 1370 <func0+0x60>
mov (%rdi),%eax
test $0x1,%al
je 1340 <func0+0x30>
cmp $0xffffffff,%edx
je 1370 <func0+0x60>
cmp $0xffffffff,%eax
je 1370 <func0+0x60>
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %edx,%xmm0
cvtsi2sd %eax,%xmm1
divsd %xmm1,%xmm0
retq
xchg %ax,%ax
movsd 0xd20(%rip),%xmm0
retq
nopl 0x0(%rax)
mov $0xffffffff,%edx
jmp 1349 <func0+0x39>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1370
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
mov rax, rdi
jmp short loc_1331
loc_1328:
add rax, 4
cmp rax, rcx
jz short loc_1380
loc_1331:
mov edx, [rax]
test dl, 1
jnz short loc_1328
jmp short loc_1349
loc_1340:
add rdi, 4
cmp rdi, rcx
jz short loc_1370
loc_1349:
mov eax, [rdi]
test al, 1
jz short loc_1340
cmp edx, 0FFFFFFFFh
jz short loc_1370
cmp eax, 0FFFFFFFFh
jz short loc_1370
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, edx
cvtsi2sd xmm1, eax
divsd xmm0, xmm1
retn
loc_1370:
movsd xmm0, cs:qword_2078
retn
loc_1380:
mov edx, 0FFFFFFFFh
jmp short loc_1349 | double func0(int *a1, int a2)
{
long long v2; // rcx
int *v3; // rax
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return -1.0;
v2 = (long long)&a1[a2 - 1 + 1];
v3 = a1;
while ( 1 )
{
v4 = *v3;
if ( (*v3 & 1) == 0 )
break;
if ( ++v3 == (int *)v2 )
{
v4 = -1;
break;
}
}
while ( 1 )
{
v5 = *a1;
if ( (*a1 & 1) != 0 )
break;
if ( ++a1 == (int *)v2 )
return -1.0;
}
if ( v4 == -1 || v5 == -1 )
return -1.0;
else
return (double)v4 / (double)v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101370
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV RAX,RDI
JMP 0x00101331
LAB_00101328:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101380
LAB_00101331:
MOV EDX,dword ptr [RAX]
TEST DL,0x1
JNZ 0x00101328
JMP 0x00101349
LAB_00101340:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x00101370
LAB_00101349:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 0x00101340
CMP EDX,-0x1
JZ 0x00101370
CMP EAX,-0x1
JZ 0x00101370
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDX
CVTSI2SD XMM1,EAX
DIVSD XMM0,XMM1
RET
LAB_00101370:
MOVSD XMM0,qword ptr [0x00102078]
RET
LAB_00101380:
MOV EDX,0xffffffff
JMP 0x00101349 | double func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint uVar4;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar3 = param_1;
do {
uVar4 = *puVar3;
if ((uVar4 & 1) == 0) goto LAB_00101349;
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
uVar4 = 0xffffffff;
LAB_00101349:
do {
uVar2 = *param_1;
if ((uVar2 & 1) != 0) {
if (uVar4 == 0xffffffff) {
return DAT_00102078;
}
if (uVar2 == 0xffffffff) {
return DAT_00102078;
}
return (double)(int)uVar4 / (double)(int)uVar2;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return DAT_00102078;
} |
4,047 | func0 |
#include <assert.h>
| double func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
first_odd = list1[i];
break;
}
}
if (first_even != -1 && first_odd != -1) {
return (double) first_even / first_odd;
}
return -1;
}
| int main() {
int list1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 4);
int list2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 2);
int list3[] = {1, 5, 7, 9, 10};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 10);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1320 <func0+0x60>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
mov %rdi,%rax
jmp 12e1 <func0+0x21>
nopl (%rax)
add $0x4,%rax
cmp %rcx,%rax
je 1330 <func0+0x70>
mov (%rax),%edx
test $0x1,%dl
jne 12d8 <func0+0x18>
jmp 12f9 <func0+0x39>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rcx,%rdi
je 1320 <func0+0x60>
mov (%rdi),%eax
test $0x1,%al
je 12f0 <func0+0x30>
cmp $0xffffffff,%edx
je 1320 <func0+0x60>
cmp $0xffffffff,%eax
je 1320 <func0+0x60>
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %edx,%xmm0
cvtsi2sd %eax,%xmm1
divsd %xmm1,%xmm0
retq
xchg %ax,%ax
movsd 0xd70(%rip),%xmm0
retq
nopl 0x0(%rax)
mov $0xffffffff,%edx
jmp 12f9 <func0+0x39>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1320
movsxd rsi, esi
mov rax, rdi
lea rcx, [rdi+rsi*4]
jmp short loc_12E1
loc_12D8:
add rax, 4
cmp rcx, rax
jz short loc_1330
loc_12E1:
mov edx, [rax]
test dl, 1
jnz short loc_12D8
mov esi, 1
jmp short loc_12F9
loc_12F0:
add rdi, 4
cmp rcx, rdi
jz short loc_1320
loc_12F9:
mov eax, [rdi]
test al, 1
jz short loc_12F0
cmp eax, 0FFFFFFFFh
jz short loc_1320
test sil, sil
jz short loc_1320
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, edx
cvtsi2sd xmm1, eax
divsd xmm0, xmm1
retn
loc_1320:
movsd xmm0, cs:qword_2078
retn
loc_1330:
xor esi, esi
mov edx, 0FFFFFFFFh
jmp short loc_12F9 | double func0(int *a1, int a2)
{
int *v2; // rax
int *v3; // rcx
int v4; // edx
char v5; // si
int v6; // eax
if ( a2 <= 0 )
return -1.0;
v2 = a1;
v3 = &a1[a2];
do
{
v4 = *v2;
if ( (*v2 & 1) == 0 )
{
v5 = 1;
goto LABEL_7;
}
++v2;
}
while ( v3 != v2 );
v5 = 0;
v4 = -1;
LABEL_7:
while ( 1 )
{
v6 = *a1;
if ( (*a1 & 1) != 0 )
break;
if ( v3 == ++a1 )
return -1.0;
}
if ( v6 == -1 || !v5 )
return -1.0;
else
return (double)v4 / (double)v6;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101320
MOVSXD RSI,ESI
MOV RAX,RDI
LEA RCX,[RDI + RSI*0x4]
JMP 0x001012e1
LAB_001012d8:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x00101330
LAB_001012e1:
MOV EDX,dword ptr [RAX]
TEST DL,0x1
JNZ 0x001012d8
MOV ESI,0x1
JMP 0x001012f9
LAB_001012f0:
ADD RDI,0x4
CMP RCX,RDI
JZ 0x00101320
LAB_001012f9:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 0x001012f0
CMP EAX,-0x1
JZ 0x00101320
TEST SIL,SIL
JZ 0x00101320
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDX
CVTSI2SD XMM1,EAX
DIVSD XMM0,XMM1
RET
LAB_00101320:
MOVSD XMM0,qword ptr [0x00102078]
RET
LAB_00101330:
XOR ESI,ESI
MOV EDX,0xffffffff
JMP 0x001012f9 | double func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
uint *puVar4;
uint uVar5;
if (0 < param_2) {
puVar1 = param_1 + param_2;
puVar4 = param_1;
do {
uVar5 = *puVar4;
if ((uVar5 & 1) == 0) {
bVar3 = true;
goto LAB_001012f9;
}
puVar4 = puVar4 + 1;
} while (puVar1 != puVar4);
bVar3 = false;
uVar5 = 0xffffffff;
LAB_001012f9:
do {
uVar2 = *param_1;
if ((uVar2 & 1) != 0) {
if (uVar2 == 0xffffffff) {
return DAT_00102078;
}
if (!bVar3) {
return DAT_00102078;
}
return (double)(int)uVar5 / (double)(int)uVar2;
}
param_1 = param_1 + 1;
} while (puVar1 != param_1);
}
return DAT_00102078;
} |
4,048 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int freq;
char ch;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
int compare(HeapNode a, HeapNode b) {
// Higher frequency has higher priority.
// If frequency equal, smaller char (lexicographically) has higher priority.
if(a.freq != b.freq)
return a.freq - b.freq; // positive if a.freq > b.freq.
else
return (b.ch - a.ch); // if a.ch < b.ch then priority: a
}
void heapify_down(HeapNode heap[], int n, int idx) {
int largest = idx;
int left = 2*idx + 1;
int right = 2*idx + 2;
if(left < n && (compare(heap[left], heap[largest]) > 0))
largest = left;
if(right < n && (compare(heap[right], heap[largest]) > 0))
largest = right;
if(largest != idx) {
swap(&heap[idx], &heap[largest]);
heapify_down(heap, n, largest);
}
}
void heapify_up(HeapNode heap[], int idx) {
while(idx > 0) {
int parent = (idx - 1)/2;
if(compare(heap[idx], heap[parent]) > 0) {
swap(&heap[idx], &heap[parent]);
idx = parent;
} else {
break;
}
}
}
void heap_push(HeapNode heap[], int *n, HeapNode node) {
heap[*n] = node;
(*n)++;
heapify_up(heap, (*n)-1);
}
HeapNode heap_pop(HeapNode heap[], int *n) {
HeapNode top = heap[0];
heap[0] = heap[(*n)-1];
(*n)--;
heapify_down(heap, *n, 0);
return top;
}
| char* func0(const char *S) {
int len = strlen(S);
if(len == 0) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
int freq[256] = {0};
for(int i = 0; i < len; i++) {
freq[(unsigned char)S[i]]++;
}
// Build heap array. Maximum unique characters are 256.
HeapNode heap[256];
int heapSize = 0;
for (int i = 0; i < 256; i++) {
if(freq[i] > 0) {
HeapNode node;
node.freq = freq[i];
node.ch = (char)i;
heap[heapSize++] = node;
}
}
// Build the heap using heapify_down from bottom-up.
for (int i = (heapSize/2) - 1; i >= 0; i--) {
heapify_down(heap, heapSize, i);
}
// Check feasibility: if the largest frequency is more than (len+1)/2,
// then it is not possible to rearrange, return empty string.
if(heapSize > 0 && heap[0].freq * 2 > len + 1) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
// Allocate result string
char *result = malloc(len + 1);
int pos = 0;
// Process heap: while there are at least two elements.
while(heapSize >= 2) {
HeapNode first = heap_pop(heap, &heapSize);
HeapNode second = heap_pop(heap, &heapSize);
result[pos++] = first.ch;
result[pos++] = second.ch;
first.freq--;
second.freq--;
if(first.freq > 0) {
heap_push(heap, &heapSize, first);
}
if(second.freq > 0) {
heap_push(heap, &heapSize, second);
}
}
if(heapSize > 0) {
HeapNode last = heap_pop(heap, &heapSize);
result[pos++] = last.ch;
}
result[pos] = '\0';
return result;
}
| int main() {
char *res1 = func0("aab");
// The expected output is "aba"
assert(strcmp(res1, "aba") == 0);
free(res1);
char *res2 = func0("aabb");
// The expected output is "abab"
assert(strcmp(res2, "abab") == 0);
free(res2);
char *res3 = func0("abccdd");
// The expected output is "cdabcd"
assert(strcmp(res3, "cdabcd") == 0);
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xc60,%rsp
mov %rdi,-0xc58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0xc58(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0xc3c(%rbp)
cmpl $0x0,-0xc3c(%rbp)
jne 1553 <func0+0x74>
mov $0x1,%edi
callq 10f0 <malloc@plt>
mov %rax,-0xc28(%rbp)
cmpq $0x0,-0xc28(%rbp)
je 1547 <func0+0x68>
mov -0xc28(%rbp),%rax
movb $0x0,(%rax)
mov -0xc28(%rbp),%rax
jmpq 186f <func0+0x390>
lea -0xc10(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0xc4c(%rbp)
jmp 15ac <func0+0xcd>
mov -0xc4c(%rbp),%eax
movslq %eax,%rdx
mov -0xc58(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
movslq %eax,%rdx
mov -0xc10(%rbp,%rdx,4),%edx
add $0x1,%edx
cltq
mov %edx,-0xc10(%rbp,%rax,4)
addl $0x1,-0xc4c(%rbp)
mov -0xc4c(%rbp),%eax
cmp -0xc3c(%rbp),%eax
jl 1576 <func0+0x97>
movl $0x0,-0xc50(%rbp)
movl $0x0,-0xc48(%rbp)
jmp 162b <func0+0x14c>
mov -0xc48(%rbp),%eax
cltq
mov -0xc10(%rbp,%rax,4),%eax
test %eax,%eax
jle 1624 <func0+0x145>
mov -0xc48(%rbp),%eax
cltq
mov -0xc10(%rbp,%rax,4),%eax
mov %eax,-0xc18(%rbp)
mov -0xc48(%rbp),%eax
mov %al,-0xc14(%rbp)
mov -0xc50(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc50(%rbp)
cltq
mov -0xc18(%rbp),%rdx
mov %rdx,-0x810(%rbp,%rax,8)
addl $0x1,-0xc48(%rbp)
cmpl $0xff,-0xc48(%rbp)
jle 15d0 <func0+0xf1>
mov -0xc50(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
sub $0x1,%eax
mov %eax,-0xc44(%rbp)
jmp 1675 <func0+0x196>
mov -0xc50(%rbp),%ecx
mov -0xc44(%rbp),%edx
lea -0x810(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 125a <heapify_down>
subl $0x1,-0xc44(%rbp)
cmpl $0x0,-0xc44(%rbp)
jns 1651 <func0+0x172>
mov -0xc50(%rbp),%eax
test %eax,%eax
jle 16cf <func0+0x1f0>
mov -0x810(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0xc3c(%rbp),%eax
add $0x1,%eax
cmp %eax,%edx
jle 16cf <func0+0x1f0>
mov $0x1,%edi
callq 10f0 <malloc@plt>
mov %rax,-0xc38(%rbp)
cmpq $0x0,-0xc38(%rbp)
je 16c3 <func0+0x1e4>
mov -0xc38(%rbp),%rax
movb $0x0,(%rax)
mov -0xc38(%rbp),%rax
jmpq 186f <func0+0x390>
mov -0xc3c(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0xc30(%rbp)
movl $0x0,-0xc40(%rbp)
jmpq 17f4 <func0+0x315>
lea -0xc50(%rbp),%rdx
lea -0x810(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1471 <heap_pop>
mov %rax,-0xc20(%rbp)
lea -0xc50(%rbp),%rdx
lea -0x810(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1471 <heap_pop>
mov %rax,-0xc18(%rbp)
mov -0xc40(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc40(%rbp)
movslq %eax,%rdx
mov -0xc30(%rbp),%rax
add %rax,%rdx
movzbl -0xc1c(%rbp),%eax
mov %al,(%rdx)
mov -0xc40(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc40(%rbp)
movslq %eax,%rdx
mov -0xc30(%rbp),%rax
add %rax,%rdx
movzbl -0xc14(%rbp),%eax
mov %al,(%rdx)
mov -0xc20(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc20(%rbp)
mov -0xc18(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc18(%rbp)
mov -0xc20(%rbp),%eax
test %eax,%eax
jle 17ca <func0+0x2eb>
mov -0xc20(%rbp),%rdx
lea -0xc50(%rbp),%rcx
lea -0x810(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1412 <heap_push>
mov -0xc18(%rbp),%eax
test %eax,%eax
jle 17f4 <func0+0x315>
mov -0xc18(%rbp),%rdx
lea -0xc50(%rbp),%rcx
lea -0x810(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1412 <heap_push>
mov -0xc50(%rbp),%eax
cmp $0x1,%eax
jg 16f8 <func0+0x219>
mov -0xc50(%rbp),%eax
test %eax,%eax
jle 1852 <func0+0x373>
lea -0xc50(%rbp),%rdx
lea -0x810(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1471 <heap_pop>
mov %rax,-0xc18(%rbp)
mov -0xc40(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc40(%rbp)
movslq %eax,%rdx
mov -0xc30(%rbp),%rax
add %rax,%rdx
movzbl -0xc14(%rbp),%eax
mov %al,(%rdx)
mov -0xc40(%rbp),%eax
movslq %eax,%rdx
mov -0xc30(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0xc30(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1883 <func0+0x3a4>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0C60h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C3C], eax
cmp [rbp+var_C3C], 0
jnz short loc_1561
mov edi, 1; size
call _malloc
mov [rbp+var_C28], rax
cmp [rbp+var_C28], 0
jz short loc_1555
mov rax, [rbp+var_C28]
mov byte ptr [rax], 0
loc_1555:
mov rax, [rbp+var_C28]
jmp loc_187D
loc_1561:
lea rdx, [rbp+var_C10]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_C4C], 0
jmp short loc_15BA
loc_1584:
mov eax, [rbp+var_C4C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
movsxd rdx, eax
mov edx, [rbp+rdx*4+var_C10]
add edx, 1
cdqe
mov [rbp+rax*4+var_C10], edx
add [rbp+var_C4C], 1
loc_15BA:
mov eax, [rbp+var_C4C]
cmp eax, [rbp+var_C3C]
jl short loc_1584
mov [rbp+var_C50], 0
mov [rbp+var_C48], 0
jmp short loc_1639
loc_15DE:
mov eax, [rbp+var_C48]
cdqe
mov eax, [rbp+rax*4+var_C10]
test eax, eax
jle short loc_1632
mov eax, [rbp+var_C48]
cdqe
mov eax, [rbp+rax*4+var_C10]
mov dword ptr [rbp+var_C18], eax
mov eax, [rbp+var_C48]
mov byte ptr [rbp+var_C18+4], al
mov eax, [rbp+var_C50]
lea edx, [rax+1]
mov [rbp+var_C50], edx
cdqe
mov rdx, [rbp+var_C18]
mov [rbp+rax*8+var_810], rdx
loc_1632:
add [rbp+var_C48], 1
loc_1639:
cmp [rbp+var_C48], 0FFh
jle short loc_15DE
mov eax, [rbp+var_C50]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
sub eax, 1
mov [rbp+var_C44], eax
jmp short loc_1683
loc_165F:
mov ecx, [rbp+var_C50]
mov edx, [rbp+var_C44]
lea rax, [rbp+var_810]
mov esi, ecx
mov rdi, rax
call heapify_down
sub [rbp+var_C44], 1
loc_1683:
cmp [rbp+var_C44], 0
jns short loc_165F
mov eax, [rbp+var_C50]
test eax, eax
jle short loc_16DD
mov eax, dword ptr [rbp+var_810]
lea edx, [rax+rax]
mov eax, [rbp+var_C3C]
add eax, 1
cmp edx, eax
jle short loc_16DD
mov edi, 1; size
call _malloc
mov [rbp+var_C38], rax
cmp [rbp+var_C38], 0
jz short loc_16D1
mov rax, [rbp+var_C38]
mov byte ptr [rax], 0
loc_16D1:
mov rax, [rbp+var_C38]
jmp loc_187D
loc_16DD:
mov eax, [rbp+var_C3C]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+var_C30], rax
mov [rbp+var_C40], 0
jmp loc_1802
loc_1706:
lea rdx, [rbp+var_C50]
lea rax, [rbp+var_810]
mov rsi, rdx
mov rdi, rax
call heap_pop
mov [rbp+var_C20], rax
lea rdx, [rbp+var_C50]
lea rax, [rbp+var_810]
mov rsi, rdx
mov rdi, rax
call heap_pop
mov [rbp+var_C18], rax
mov eax, [rbp+var_C40]
lea edx, [rax+1]
mov [rbp+var_C40], edx
movsxd rdx, eax
mov rax, [rbp+var_C30]
add rdx, rax
movzx eax, byte ptr [rbp+var_C20+4]
mov [rdx], al
mov eax, [rbp+var_C40]
lea edx, [rax+1]
mov [rbp+var_C40], edx
movsxd rdx, eax
mov rax, [rbp+var_C30]
add rdx, rax
movzx eax, byte ptr [rbp+var_C18+4]
mov [rdx], al
mov eax, dword ptr [rbp+var_C20]
sub eax, 1
mov dword ptr [rbp+var_C20], eax
mov eax, dword ptr [rbp+var_C18]
sub eax, 1
mov dword ptr [rbp+var_C18], eax
mov eax, dword ptr [rbp+var_C20]
test eax, eax
jle short loc_17D8
mov rdx, [rbp+var_C20]
lea rcx, [rbp+var_C50]
lea rax, [rbp+var_810]
mov rsi, rcx
mov rdi, rax
call heap_push
loc_17D8:
mov eax, dword ptr [rbp+var_C18]
test eax, eax
jle short loc_1802
mov rdx, [rbp+var_C18]
lea rcx, [rbp+var_C50]
lea rax, [rbp+var_810]
mov rsi, rcx
mov rdi, rax
call heap_push
loc_1802:
mov eax, [rbp+var_C50]
cmp eax, 1
jg loc_1706
mov eax, [rbp+var_C50]
test eax, eax
jle short loc_1860
lea rdx, [rbp+var_C50]
lea rax, [rbp+var_810]
mov rsi, rdx
mov rdi, rax
call heap_pop
mov [rbp+var_C18], rax
mov eax, [rbp+var_C40]
lea edx, [rax+1]
mov [rbp+var_C40], edx
movsxd rdx, eax
mov rax, [rbp+var_C30]
add rdx, rax
movzx eax, byte ptr [rbp+var_C18+4]
mov [rdx], al
loc_1860:
mov eax, [rbp+var_C40]
movsxd rdx, eax
mov rax, [rbp+var_C30]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_C30]
loc_187D:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1891
call ___stack_chk_fail
locret_1891:
leave
retn | _BYTE * func0(const char *a1)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // [rsp+10h] [rbp-C50h] BYREF
int i; // [rsp+14h] [rbp-C4Ch]
int j; // [rsp+18h] [rbp-C48h]
int k; // [rsp+1Ch] [rbp-C44h]
int v10; // [rsp+20h] [rbp-C40h]
int v11; // [rsp+24h] [rbp-C3Ch]
_BYTE *v12; // [rsp+28h] [rbp-C38h]
_BYTE *v13; // [rsp+30h] [rbp-C30h]
_BYTE *v14; // [rsp+38h] [rbp-C28h]
long long v15; // [rsp+40h] [rbp-C20h]
long long v16; // [rsp+48h] [rbp-C18h]
_DWORD v17[256]; // [rsp+50h] [rbp-C10h] BYREF
_QWORD v18[258]; // [rsp+450h] [rbp-810h] BYREF
v18[257] = __readfsqword(0x28u);
v11 = strlen(a1);
if ( v11 )
{
memset(v17, 0, sizeof(v17));
for ( i = 0; i < v11; ++i )
++v17[(unsigned __int8)a1[i]];
v6 = 0;
for ( j = 0; j <= 255; ++j )
{
if ( (int)v17[j] > 0 )
{
LODWORD(v16) = v17[j];
BYTE4(v16) = j;
v2 = v6++;
v18[v2] = v16;
}
}
for ( k = v6 / 2 - 1; k >= 0; --k )
heapify_down(v18, (unsigned int)v6, (unsigned int)k);
if ( v6 <= 0 || 2 * LODWORD(v18[0]) <= v11 + 1 )
{
v13 = malloc(v11 + 1);
v10 = 0;
while ( v6 > 1 )
{
v15 = heap_pop(v18, &v6);
v16 = heap_pop(v18, &v6);
v3 = v10++;
v13[v3] = BYTE4(v15);
v4 = v10++;
v13[v4] = BYTE4(v16);
LODWORD(v15) = v15 - 1;
LODWORD(v16) = v16 - 1;
if ( (int)v15 > 0 )
heap_push(v18, &v6, v15);
if ( (int)v16 > 0 )
heap_push(v18, &v6, v16);
}
if ( v6 > 0 )
{
v16 = heap_pop(v18, &v6);
v5 = v10++;
v13[v5] = BYTE4(v16);
}
v13[v10] = 0;
return v13;
}
else
{
v12 = malloc(1uLL);
if ( v12 )
*v12 = 0;
return v12;
}
}
else
{
v14 = malloc(1uLL);
if ( v14 )
*v14 = 0;
return v14;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc60
MOV qword ptr [RBP + -0xc58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xc58]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0xc3c],EAX
CMP dword ptr [RBP + -0xc3c],0x0
JNZ 0x00101561
MOV EDI,0x1
CALL 0x001010f0
MOV qword ptr [RBP + -0xc28],RAX
CMP qword ptr [RBP + -0xc28],0x0
JZ 0x00101555
MOV RAX,qword ptr [RBP + -0xc28]
MOV byte ptr [RAX],0x0
LAB_00101555:
MOV RAX,qword ptr [RBP + -0xc28]
JMP 0x0010187d
LAB_00101561:
LEA RDX,[RBP + -0xc10]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0xc4c],0x0
JMP 0x001015ba
LAB_00101584:
MOV EAX,dword ptr [RBP + -0xc4c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xc58]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
MOVSXD RDX,EAX
MOV EDX,dword ptr [RBP + RDX*0x4 + -0xc10]
ADD EDX,0x1
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0xc10],EDX
ADD dword ptr [RBP + -0xc4c],0x1
LAB_001015ba:
MOV EAX,dword ptr [RBP + -0xc4c]
CMP EAX,dword ptr [RBP + -0xc3c]
JL 0x00101584
MOV dword ptr [RBP + -0xc50],0x0
MOV dword ptr [RBP + -0xc48],0x0
JMP 0x00101639
LAB_001015de:
MOV EAX,dword ptr [RBP + -0xc48]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xc10]
TEST EAX,EAX
JLE 0x00101632
MOV EAX,dword ptr [RBP + -0xc48]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xc10]
MOV dword ptr [RBP + -0xc18],EAX
MOV EAX,dword ptr [RBP + -0xc48]
MOV byte ptr [RBP + -0xc14],AL
MOV EAX,dword ptr [RBP + -0xc50]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc50],EDX
CDQE
MOV RDX,qword ptr [RBP + -0xc18]
MOV qword ptr [RBP + RAX*0x8 + -0x810],RDX
LAB_00101632:
ADD dword ptr [RBP + -0xc48],0x1
LAB_00101639:
CMP dword ptr [RBP + -0xc48],0xff
JLE 0x001015de
MOV EAX,dword ptr [RBP + -0xc50]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
SUB EAX,0x1
MOV dword ptr [RBP + -0xc44],EAX
JMP 0x00101683
LAB_0010165f:
MOV ECX,dword ptr [RBP + -0xc50]
MOV EDX,dword ptr [RBP + -0xc44]
LEA RAX,[RBP + -0x810]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101256
SUB dword ptr [RBP + -0xc44],0x1
LAB_00101683:
CMP dword ptr [RBP + -0xc44],0x0
JNS 0x0010165f
MOV EAX,dword ptr [RBP + -0xc50]
TEST EAX,EAX
JLE 0x001016dd
MOV EAX,dword ptr [RBP + -0x810]
LEA EDX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc3c]
ADD EAX,0x1
CMP EDX,EAX
JLE 0x001016dd
MOV EDI,0x1
CALL 0x001010f0
MOV qword ptr [RBP + -0xc38],RAX
CMP qword ptr [RBP + -0xc38],0x0
JZ 0x001016d1
MOV RAX,qword ptr [RBP + -0xc38]
MOV byte ptr [RAX],0x0
LAB_001016d1:
MOV RAX,qword ptr [RBP + -0xc38]
JMP 0x0010187d
LAB_001016dd:
MOV EAX,dword ptr [RBP + -0xc3c]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0xc30],RAX
MOV dword ptr [RBP + -0xc40],0x0
JMP 0x00101802
LAB_00101706:
LEA RDX,[RBP + -0xc50]
LEA RAX,[RBP + -0x810]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010147f
MOV qword ptr [RBP + -0xc20],RAX
LEA RDX,[RBP + -0xc50]
LEA RAX,[RBP + -0x810]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010147f
MOV qword ptr [RBP + -0xc18],RAX
MOV EAX,dword ptr [RBP + -0xc40]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc40],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xc30]
ADD RDX,RAX
MOVZX EAX,byte ptr [RBP + -0xc1c]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0xc40]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc40],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xc30]
ADD RDX,RAX
MOVZX EAX,byte ptr [RBP + -0xc14]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0xc20]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc20],EAX
MOV EAX,dword ptr [RBP + -0xc18]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc18],EAX
MOV EAX,dword ptr [RBP + -0xc20]
TEST EAX,EAX
JLE 0x001017d8
MOV RDX,qword ptr [RBP + -0xc20]
LEA RCX,[RBP + -0xc50]
LEA RAX,[RBP + -0x810]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101420
LAB_001017d8:
MOV EAX,dword ptr [RBP + -0xc18]
TEST EAX,EAX
JLE 0x00101802
MOV RDX,qword ptr [RBP + -0xc18]
LEA RCX,[RBP + -0xc50]
LEA RAX,[RBP + -0x810]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101420
LAB_00101802:
MOV EAX,dword ptr [RBP + -0xc50]
CMP EAX,0x1
JG 0x00101706
MOV EAX,dword ptr [RBP + -0xc50]
TEST EAX,EAX
JLE 0x00101860
LEA RDX,[RBP + -0xc50]
LEA RAX,[RBP + -0x810]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010147f
MOV qword ptr [RBP + -0xc18],RAX
MOV EAX,dword ptr [RBP + -0xc40]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc40],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xc30]
ADD RDX,RAX
MOVZX EAX,byte ptr [RBP + -0xc14]
MOV byte ptr [RDX],AL
LAB_00101860:
MOV EAX,dword ptr [RBP + -0xc40]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xc30]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0xc30]
LAB_0010187d:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101891
CALL 0x001010c0
LAB_00101891:
LEAVE
RET | int * func0(char *param_1)
{
int iVar1;
size_t sVar2;
int *puVar3;
int8 uVar4;
long lVar5;
int *piVar6;
long in_FS_OFFSET;
byte bVar7;
int local_c58;
int local_c54;
int local_c50;
int local_c4c;
int local_c48;
int local_c44;
int *local_c40;
int *local_c38;
int *local_c30;
int8 local_c28;
int8 local_c20;
int local_c18 [256];
int local_818 [514];
long local_10;
bVar7 = 0;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
local_c44 = (int)sVar2;
if (local_c44 == 0) {
puVar3 = (int *)malloc(1);
local_c30 = puVar3;
if (puVar3 != (int *)0x0) {
*puVar3 = 0;
}
}
else {
piVar6 = local_c18;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
piVar6[0] = 0;
piVar6[1] = 0;
piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
}
for (local_c54 = 0; local_c54 < local_c44; local_c54 = local_c54 + 1) {
local_c18[(int)(uint)(byte)param_1[local_c54]] =
local_c18[(int)(uint)(byte)param_1[local_c54]] + 1;
}
local_c58 = 0;
for (local_c50 = 0; local_c50 < 0x100; local_c50 = local_c50 + 1) {
if (0 < local_c18[local_c50]) {
local_c20._0_5_ = CONCAT14((char)local_c50,local_c18[local_c50]);
*(int8 *)(local_818 + (long)local_c58 * 2) = local_c20;
local_c58 = local_c58 + 1;
}
}
local_c4c = local_c58 / 2;
while (local_c4c = local_c4c + -1, -1 < local_c4c) {
heapify_down(local_818,local_c58,local_c4c);
}
if ((local_c58 < 1) || (local_818[0] * 2 <= local_c44 + 1)) {
local_c38 = (int *)malloc((long)(local_c44 + 1));
local_c48 = 0;
while (1 < local_c58) {
local_c28 = heap_pop(local_818,&local_c58);
uVar4 = heap_pop(local_818,&local_c58);
iVar1 = local_c48 + 1;
local_c38[local_c48] = local_c28._4_1_;
local_c48 = local_c48 + 2;
local_c20._4_1_ = (int)((ulong)uVar4 >> 0x20);
local_c38[iVar1] = local_c20._4_1_;
iVar1 = (int)local_c28 + -1;
local_c28 = CONCAT44(local_c28._4_4_,iVar1);
local_c20._0_4_ = (int)uVar4;
local_c20 = CONCAT44((int)((ulong)uVar4 >> 0x20),(int)local_c20 + -1);
if (0 < iVar1) {
heap_push(local_818,&local_c58,local_c28);
}
if (0 < (int)local_c20) {
heap_push(local_818,&local_c58,local_c20);
}
}
if (0 < local_c58) {
uVar4 = heap_pop(local_818,&local_c58);
local_c20._4_1_ = (int)((ulong)uVar4 >> 0x20);
local_c38[local_c48] = local_c20._4_1_;
local_c48 = local_c48 + 1;
local_c20 = uVar4;
}
local_c38[local_c48] = 0;
puVar3 = local_c38;
}
else {
puVar3 = (int *)malloc(1);
local_c40 = puVar3;
if (puVar3 != (int *)0x0) {
*puVar3 = 0;
}
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,049 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int freq;
char ch;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
int compare(HeapNode a, HeapNode b) {
// Higher frequency has higher priority.
// If frequency equal, smaller char (lexicographically) has higher priority.
if(a.freq != b.freq)
return a.freq - b.freq; // positive if a.freq > b.freq.
else
return (b.ch - a.ch); // if a.ch < b.ch then priority: a
}
void heapify_down(HeapNode heap[], int n, int idx) {
int largest = idx;
int left = 2*idx + 1;
int right = 2*idx + 2;
if(left < n && (compare(heap[left], heap[largest]) > 0))
largest = left;
if(right < n && (compare(heap[right], heap[largest]) > 0))
largest = right;
if(largest != idx) {
swap(&heap[idx], &heap[largest]);
heapify_down(heap, n, largest);
}
}
void heapify_up(HeapNode heap[], int idx) {
while(idx > 0) {
int parent = (idx - 1)/2;
if(compare(heap[idx], heap[parent]) > 0) {
swap(&heap[idx], &heap[parent]);
idx = parent;
} else {
break;
}
}
}
void heap_push(HeapNode heap[], int *n, HeapNode node) {
heap[*n] = node;
(*n)++;
heapify_up(heap, (*n)-1);
}
HeapNode heap_pop(HeapNode heap[], int *n) {
HeapNode top = heap[0];
heap[0] = heap[(*n)-1];
(*n)--;
heapify_down(heap, *n, 0);
return top;
}
| char* func0(const char *S) {
int len = strlen(S);
if(len == 0) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
int freq[256] = {0};
for(int i = 0; i < len; i++) {
freq[(unsigned char)S[i]]++;
}
// Build heap array. Maximum unique characters are 256.
HeapNode heap[256];
int heapSize = 0;
for (int i = 0; i < 256; i++) {
if(freq[i] > 0) {
HeapNode node;
node.freq = freq[i];
node.ch = (char)i;
heap[heapSize++] = node;
}
}
// Build the heap using heapify_down from bottom-up.
for (int i = (heapSize/2) - 1; i >= 0; i--) {
heapify_down(heap, heapSize, i);
}
// Check feasibility: if the largest frequency is more than (len+1)/2,
// then it is not possible to rearrange, return empty string.
if(heapSize > 0 && heap[0].freq * 2 > len + 1) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
// Allocate result string
char *result = malloc(len + 1);
int pos = 0;
// Process heap: while there are at least two elements.
while(heapSize >= 2) {
HeapNode first = heap_pop(heap, &heapSize);
HeapNode second = heap_pop(heap, &heapSize);
result[pos++] = first.ch;
result[pos++] = second.ch;
first.freq--;
second.freq--;
if(first.freq > 0) {
heap_push(heap, &heapSize, first);
}
if(second.freq > 0) {
heap_push(heap, &heapSize, second);
}
}
if(heapSize > 0) {
HeapNode last = heap_pop(heap, &heapSize);
result[pos++] = last.ch;
}
result[pos] = '\0';
return result;
}
| int main() {
char *res1 = func0("aab");
// The expected output is "aba"
assert(strcmp(res1, "aba") == 0);
free(res1);
char *res2 = func0("aabb");
// The expected output is "abab"
assert(strcmp(res2, "abab") == 0);
free(res2);
char *res3 = func0("abccdd");
// The expected output is "cdabcd"
assert(strcmp(res3, "cdabcd") == 0);
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xc38,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0xc28(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
cmp $0x1,%ecx
je 140e <func0+0x98>
lea -0x1(%rcx),%rbx
lea 0x20(%rsp),%rdi
mov $0x80,%ecx
mov $0x0,%eax
rep stos %rax,%es:(%rdi)
test %ebx,%ebx
jle 13e8 <func0+0x72>
mov %rdx,%rax
lea -0x1(%rbx),%ecx
lea 0x1(%rdx,%rcx,1),%rcx
movzbl (%rax),%edx
addl $0x1,0x20(%rsp,%rdx,4)
add $0x1,%rax
cmp %rcx,%rax
jne 13d7 <func0+0x61>
movl $0x0,0x1c(%rsp)
mov $0x0,%eax
mov $0x0,%esi
mov $0x0,%ecx
lea 0x420(%rsp),%r8
mov $0x1,%edi
jmp 1438 <func0+0xc2>
mov $0x1,%edi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 15b1 <func0+0x23b>
movb $0x0,(%rax)
jmpq 15b1 <func0+0x23b>
add $0x1,%rax
cmp $0x100,%rax
je 1453 <func0+0xdd>
mov 0x20(%rsp,%rax,4),%edx
test %edx,%edx
jle 142c <func0+0xb6>
movslq %ecx,%rsi
lea (%r8,%rsi,8),%rsi
mov %edx,(%rsi)
mov %al,0x4(%rsi)
lea 0x1(%rcx),%ecx
mov %edi,%esi
jmp 142c <func0+0xb6>
test %sil,%sil
je 148a <func0+0x114>
mov %ecx,0x1c(%rsp)
mov %ecx,%eax
shr $0x1f,%eax
add %eax,%ecx
sar %ecx
sub $0x1,%ecx
mov %ecx,%ebp
js 148a <func0+0x114>
lea 0x420(%rsp),%r12
mov %ebp,%edx
mov 0x1c(%rsp),%esi
mov %r12,%rdi
callq 11e2 <heapify_down>
sub $0x1,%ebp
cmp $0xffffffff,%ebp
jne 1474 <func0+0xfe>
cmpl $0x0,0x1c(%rsp)
jle 14a1 <func0+0x12b>
mov 0x420(%rsp),%eax
add %eax,%eax
lea 0x1(%rbx),%edx
cmp %edx,%eax
jg 14ce <func0+0x158>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
mov 0x1c(%rsp),%eax
cmp $0x1,%eax
jle 159b <func0+0x225>
mov $0x2,%r12d
movabs $0xffffffff00000000,%r15
jmp 1519 <func0+0x1a3>
mov $0x1,%edi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 15b1 <func0+0x23b>
movb $0x0,(%rax)
jmpq 15b1 <func0+0x23b>
mov %edx,%edx
and %r15,%rbp
or %rbp,%rdx
lea 0x1c(%rsp),%rsi
lea 0x420(%rsp),%rdi
callq 1317 <heap_push>
jmp 1576 <func0+0x200>
mov 0x1c(%rsp),%eax
add $0x2,%r12
cmp $0x1,%eax
jle 15a3 <func0+0x22d>
lea 0x1c(%rsp),%r13
lea 0x420(%rsp),%rbx
mov %r13,%rsi
mov %rbx,%rdi
callq 1331 <heap_pop>
mov %rax,%rbp
mov %r13,%rsi
mov %rbx,%rdi
callq 1331 <heap_pop>
mov %rax,%rbx
mov %rbp,%rax
shl $0x18,%rax
sar $0x38,%rax
mov %al,-0x2(%r14,%r12,1)
mov %r12d,0xc(%rsp)
mov %rbx,%rax
shl $0x18,%rax
sar $0x38,%rax
mov %al,-0x1(%r14,%r12,1)
lea -0x1(%rbp),%edx
lea -0x1(%rbx),%r13d
test %edx,%edx
jg 14ec <func0+0x176>
test %r13d,%r13d
jle 1508 <func0+0x192>
mov %r13d,%edx
and %r15,%rbx
or %rbx,%rdx
lea 0x1c(%rsp),%rsi
lea 0x420(%rsp),%rdi
callq 1317 <heap_push>
jmpq 1508 <func0+0x192>
movl $0x0,0xc(%rsp)
test %eax,%eax
jg 15d9 <func0+0x263>
movslq 0xc(%rsp),%rax
movb $0x0,(%r14,%rax,1)
mov 0xc28(%rsp),%rax
xor %fs:0x28,%rax
jne 1607 <func0+0x291>
mov %r14,%rax
add $0xc38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
lea 0x1c(%rsp),%rsi
lea 0x420(%rsp),%rdi
callq 1331 <heap_pop>
mov 0xc(%rsp),%ebx
movslq %ebx,%rdx
shl $0x18,%rax
sar $0x38,%rax
mov %al,(%r14,%rdx,1)
lea 0x1(%rbx),%eax
mov %eax,0xc(%rsp)
jmp 15a7 <func0+0x231>
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C28h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+0C58h+var_40], rax
xor eax, eax
call _strlen
test eax, eax
jz short loc_143D
mov rbx, rax
lea rdi, [rsp+0C58h+var_C48]
mov ecx, 80h
mov eax, 0
rep stosq
jle short loc_141F
mov rax, rbp
lea edx, [rbx-1]
lea rcx, [rbp+rdx+1]
loc_140E:
movzx edx, byte ptr [rax]
add [rsp+rdx*4+0C58h+var_C48], 1
add rax, 1
cmp rax, rcx
jnz short loc_140E
loc_141F:
mov [rsp+0C58h+var_C4C], 0
mov eax, 0
mov esi, 0
mov ecx, 0
mov edi, 1
jmp short loc_147D
loc_143D:
mov edi, 1
call _malloc
mov r14, rax
test rax, rax
jz loc_15EB
mov byte ptr [rax], 0
jmp loc_15EB
loc_145B:
movsxd rsi, ecx
mov [rsp+rsi*8+0C58h+var_848], edx
mov [rsp+rsi*8+0C58h+var_844], al
lea ecx, [rcx+1]
mov esi, edi
loc_1471:
add rax, 1
cmp rax, 100h
jz short loc_1487
loc_147D:
mov edx, [rsp+rax*4+0C58h+var_C48]
test edx, edx
jg short loc_145B
jmp short loc_1471
loc_1487:
test sil, sil
jz loc_163A
mov [rsp+0C58h+var_C4C], ecx
mov r12d, ecx
mov ebp, ecx
shr ebp, 1Fh
add ebp, ecx
sar ebp, 1
sub ebp, 1
js short loc_14C2
lea r13, [rsp+0C58h+var_848]
loc_14AD:
mov edx, ebp
mov esi, r12d
mov rdi, r13
call heapify_down
sub ebp, 1
cmp ebp, 0FFFFFFFFh
jnz short loc_14AD
loc_14C2:
test r12d, r12d
jle short loc_14D7
mov eax, [rsp+0C58h+var_848]
add eax, eax
lea edx, [rbx+1]
cmp eax, edx
jg short loc_14FA
loc_14D7:
lea edi, [rbx+1]
movsxd rdi, edi
call _malloc
mov r14, rax
mov eax, [rsp+0C58h+var_C4C]
cmp eax, 1
jle loc_15D9
mov r12d, 2
jmp short loc_154F
loc_14FA:
mov edi, 1
call _malloc
mov r14, rax
test rax, rax
jz loc_15EB
mov byte ptr [rax], 0
jmp loc_15EB
loc_1518:
mov eax, eax
mov rdx, 0FFFFFFFF00000000h
and rdx, rbp
or rdx, rax
lea rsi, [rsp+0C58h+var_C4C]
lea rdi, [rsp+0C58h+var_848]
call heap_push
jmp short loc_15AA
loc_153E:
mov eax, [rsp+0C58h+var_C4C]
add r12, 2
cmp eax, 1
jle loc_15DF
loc_154F:
lea r13, [rsp+0C58h+var_C4C]
lea rbx, [rsp+0C58h+var_848]
mov rsi, r13
mov rdi, rbx
call heap_pop
mov rbp, rax
mov rsi, r13
mov rdi, rbx
call heap_pop
mov rbx, rax
mov rax, rbp
shl rax, 18h
sar rax, 38h
mov [r14+r12-2], al
mov r15d, r12d
mov rax, rbx
shl rax, 18h
sar rax, 38h
mov [r14+r12-1], al
lea eax, [rbp-1]
lea r13d, [rbx-1]
test eax, eax
jg loc_1518
loc_15AA:
test r13d, r13d
jle short loc_153E
mov r13d, r13d
mov rdx, 0FFFFFFFF00000000h
and rdx, rbx
or rdx, r13
lea rsi, [rsp+0C58h+var_C4C]
lea rdi, [rsp+0C58h+var_848]
call heap_push
jmp loc_153E
loc_15D9:
mov r15d, 0
loc_15DF:
test eax, eax
jg short loc_1613
loc_15E3:
movsxd r15, r15d
mov byte ptr [r14+r15], 0
loc_15EB:
mov rax, [rsp+0C58h+var_40]
sub rax, fs:28h
jnz short loc_1644
mov rax, r14
add rsp, 0C28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1613:
lea rsi, [rsp+0C58h+var_C4C]
lea rdi, [rsp+0C58h+var_848]
call heap_pop
movsxd rdx, r15d
shl rax, 18h
sar rax, 38h
mov [r14+rdx], al
lea r15d, [r15+1]
jmp short loc_15E3
loc_163A:
mov r12d, [rsp+0C58h+var_C4C]
jmp loc_14C2
loc_1644:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
int v1; // eax
int v2; // ebx
unsigned __int8 *v3; // rax
long long v4; // rax
char v5; // si
int v6; // ecx
_BYTE *v7; // rax
long long v8; // r14
int v9; // edx
int v10; // r12d
int v11; // ebp
int v12; // eax
long long v13; // r12
_BYTE *v14; // rax
long long v15; // rbp
long long v16; // rbx
int v17; // r15d
int v18; // r13d
int v20; // [rsp+Ch] [rbp-C4Ch] BYREF
_DWORD v21[256]; // [rsp+10h] [rbp-C48h] BYREF
_DWORD v22[514]; // [rsp+410h] [rbp-848h] BYREF
unsigned long long v23; // [rsp+C18h] [rbp-40h]
v23 = __readfsqword(0x28u);
v1 = strlen();
if ( v1 )
{
v2 = v1;
memset(v21, 0, sizeof(v21));
if ( v1 > 0 )
{
v3 = a1;
do
++v21[*v3++];
while ( v3 != &a1[v2 - 1 + 1] );
}
v20 = 0;
v4 = 0LL;
v5 = 0;
v6 = 0;
do
{
v9 = v21[v4];
if ( v9 > 0 )
{
v22[2 * v6] = v9;
LOBYTE(v22[2 * v6++ + 1]) = v4;
v5 = 1;
}
++v4;
}
while ( v4 != 256 );
if ( v5 )
{
v20 = v6;
v10 = v6;
v11 = v6 / 2 - 1;
if ( v11 >= 0 )
{
do
heapify_down(v22, (unsigned int)v10, (unsigned int)v11--);
while ( v11 != -1 );
}
}
else
{
v10 = v20;
}
if ( v10 > 0 && 2 * v22[0] > v2 + 1 )
{
v14 = (_BYTE *)malloc(1LL);
v8 = (long long)v14;
if ( v14 )
*v14 = 0;
}
else
{
v8 = malloc(v2 + 1);
v12 = v20;
if ( v20 <= 1 )
{
v17 = 0;
}
else
{
v13 = 2LL;
do
{
v15 = heap_pop(v22, &v20);
v16 = heap_pop(v22, &v20);
*(_BYTE *)(v8 + v13 - 2) = (unsigned long long)(v15 << 24) >> 56;
v17 = v13;
*(_BYTE *)(v8 + v13 - 1) = (unsigned long long)(v16 << 24) >> 56;
v18 = v16 - 1;
if ( (int)v15 - 1 > 0 )
heap_push(v22, &v20, (unsigned int)(v15 - 1) | v15 & 0xFFFFFFFF00000000LL);
if ( v18 > 0 )
heap_push(v22, &v20, (unsigned int)v18 | v16 & 0xFFFFFFFF00000000LL);
v12 = v20;
v13 += 2LL;
}
while ( v20 > 1 );
}
if ( v12 > 0 )
*(_BYTE *)(v8 + v17++) = (unsigned long long)(heap_pop(v22, &v20) << 24) >> 56;
*(_BYTE *)(v8 + v17) = 0;
}
}
else
{
v7 = (_BYTE *)malloc(1LL);
v8 = (long long)v7;
if ( v7 )
*v7 = 0;
}
return v8;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc28
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc18],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x0010143d
MOV RBX,RAX
LEA RDI,[RSP + 0x10]
MOV ECX,0x80
MOV EAX,0x0
STOSQ.REP RDI
JLE 0x0010141f
MOV RAX,RBP
LEA EDX,[RBX + -0x1]
LEA RCX,[RBP + RDX*0x1 + 0x1]
LAB_0010140e:
MOVZX EDX,byte ptr [RAX]
ADD dword ptr [RSP + RDX*0x4 + 0x10],0x1
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x0010140e
LAB_0010141f:
MOV dword ptr [RSP + 0xc],0x0
MOV EAX,0x0
MOV ESI,0x0
MOV ECX,0x0
MOV EDI,0x1
JMP 0x0010147d
LAB_0010143d:
MOV EDI,0x1
CALL 0x001010f0
MOV R14,RAX
TEST RAX,RAX
JZ 0x001015eb
MOV byte ptr [RAX],0x0
JMP 0x001015eb
LAB_0010145b:
MOVSXD RSI,ECX
MOV dword ptr [RSP + RSI*0x8 + 0x410],EDX
MOV byte ptr [RSP + RSI*0x8 + 0x414],AL
LEA ECX,[RCX + 0x1]
MOV ESI,EDI
LAB_00101471:
ADD RAX,0x1
CMP RAX,0x100
JZ 0x00101487
LAB_0010147d:
MOV EDX,dword ptr [RSP + RAX*0x4 + 0x10]
TEST EDX,EDX
JG 0x0010145b
JMP 0x00101471
LAB_00101487:
TEST SIL,SIL
JZ 0x0010163a
MOV dword ptr [RSP + 0xc],ECX
MOV R12D,ECX
MOV EBP,ECX
SHR EBP,0x1f
ADD EBP,ECX
SAR EBP,0x1
SUB EBP,0x1
JS 0x001014c2
LEA R13,[RSP + 0x410]
LAB_001014ad:
MOV EDX,EBP
MOV ESI,R12D
MOV RDI,R13
CALL 0x00101221
SUB EBP,0x1
CMP EBP,-0x1
JNZ 0x001014ad
LAB_001014c2:
TEST R12D,R12D
JLE 0x001014d7
MOV EAX,dword ptr [RSP + 0x410]
ADD EAX,EAX
LEA EDX,[RBX + 0x1]
CMP EAX,EDX
JG 0x001014fa
LAB_001014d7:
LEA EDI,[RBX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010f0
MOV R14,RAX
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,0x1
JLE 0x001015d9
MOV R12D,0x2
JMP 0x0010154f
LAB_001014fa:
MOV EDI,0x1
CALL 0x001010f0
MOV R14,RAX
TEST RAX,RAX
JZ 0x001015eb
MOV byte ptr [RAX],0x0
JMP 0x001015eb
LAB_00101518:
MOV EAX,EAX
MOV RDX,-0x100000000
AND RDX,RBP
OR RDX,RAX
LEA RSI,[RSP + 0xc]
LEA RDI,[RSP + 0x410]
CALL 0x0010135c
JMP 0x001015aa
LAB_0010153e:
MOV EAX,dword ptr [RSP + 0xc]
ADD R12,0x2
CMP EAX,0x1
JLE 0x001015df
LAB_0010154f:
LEA R13,[RSP + 0xc]
LEA RBX,[RSP + 0x410]
MOV RSI,R13
MOV RDI,RBX
CALL 0x00101376
MOV RBP,RAX
MOV RSI,R13
MOV RDI,RBX
CALL 0x00101376
MOV RBX,RAX
MOV RAX,RBP
SHL RAX,0x18
SAR RAX,0x38
MOV byte ptr [R14 + R12*0x1 + -0x2],AL
MOV R15D,R12D
MOV RAX,RBX
SHL RAX,0x18
SAR RAX,0x38
MOV byte ptr [R14 + R12*0x1 + -0x1],AL
LEA EAX,[RBP + -0x1]
LEA R13D,[RBX + -0x1]
TEST EAX,EAX
JG 0x00101518
LAB_001015aa:
TEST R13D,R13D
JLE 0x0010153e
MOV R13D,R13D
MOV RDX,-0x100000000
AND RDX,RBX
OR RDX,R13
LEA RSI,[RSP + 0xc]
LEA RDI,[RSP + 0x410]
CALL 0x0010135c
JMP 0x0010153e
LAB_001015d9:
MOV R15D,0x0
LAB_001015df:
TEST EAX,EAX
JG 0x00101613
LAB_001015e3:
MOVSXD R15,R15D
MOV byte ptr [R14 + R15*0x1],0x0
LAB_001015eb:
MOV RAX,qword ptr [RSP + 0xc18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101644
MOV RAX,R14
ADD RSP,0xc28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101613:
LEA RSI,[RSP + 0xc]
LEA RDI,[RSP + 0x410]
CALL 0x00101376
MOVSXD RDX,R15D
SHL RAX,0x18
SAR RAX,0x38
MOV byte ptr [R14 + RDX*0x1],AL
LEA R15D,[R15 + 0x1]
JMP 0x001015e3
LAB_0010163a:
MOV R12D,dword ptr [RSP + 0xc]
JMP 0x001014c2
LAB_00101644:
CALL 0x001010c0 | int1 * func0(byte *param_1)
{
byte *pbVar1;
bool bVar2;
uint uVar3;
int1 extraout_var;
size_t sVar4;
int1 *puVar5;
ulong uVar6;
ulong uVar7;
int iVar8;
long lVar9;
int iVar10;
int *piVar11;
int iVar12;
uint uVar13;
int iVar14;
long in_FS_OFFSET;
byte bVar15;
int local_c4c;
int local_c48 [256];
int local_848;
int1 auStack_844 [2052];
long local_40;
bVar15 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar4 = strlen((char *)param_1);
iVar14 = (int)sVar4;
if (iVar14 == 0) {
puVar5 = (int1 *)malloc(1);
if (puVar5 != (int1 *)0x0) {
*puVar5 = 0;
}
}
else {
piVar11 = local_c48;
for (lVar9 = 0x80; lVar9 != 0; lVar9 = lVar9 + -1) {
piVar11[0] = 0;
piVar11[1] = 0;
piVar11 = piVar11 + ((ulong)bVar15 * -2 + 1) * 2;
}
if (0 < iVar14) {
pbVar1 = param_1 + (ulong)(iVar14 - 1) + 1;
do {
local_c48[*param_1] = local_c48[*param_1] + 1;
param_1 = param_1 + 1;
} while (param_1 != pbVar1);
}
local_c4c = 0;
lVar9 = 0;
bVar2 = false;
iVar8 = 0;
do {
if (0 < local_c48[lVar9]) {
*(int *)(auStack_844 + (long)iVar8 * 8 + -4) = local_c48[lVar9];
auStack_844[(long)iVar8 * 8] = (char)lVar9;
iVar8 = iVar8 + 1;
bVar2 = true;
}
lVar9 = lVar9 + 1;
} while (lVar9 != 0x100);
iVar12 = local_c4c;
if ((bVar2) && (iVar10 = iVar8 / 2 + -1, iVar12 = iVar8, local_c4c = iVar8, -1 < iVar10)) {
do {
heapify_down(&local_848,iVar8,iVar10);
iVar10 = iVar10 + -1;
} while (iVar10 != -1);
}
if ((iVar12 < 1) || (local_848 * 2 <= iVar14 + 1)) {
puVar5 = (int1 *)malloc((long)(iVar14 + 1));
if (local_c4c < 2) {
iVar14 = 0;
}
else {
lVar9 = 2;
do {
uVar6 = heap_pop(&local_848,&local_c4c);
uVar7 = heap_pop(&local_848,&local_c4c);
puVar5[lVar9 + -2] = (char)(uVar6 >> 0x20);
iVar14 = (int)lVar9;
puVar5[lVar9 + -1] = (char)(uVar7 >> 0x20);
uVar3 = (int)uVar6 - 1;
uVar13 = (int)uVar7 - 1;
if (0 < (int)uVar3) {
heap_push(&local_848,&local_c4c,uVar6 & 0xffffffff00000000 | (ulong)uVar3);
}
if (0 < (int)uVar13) {
heap_push(&local_848,&local_c4c,uVar7 & 0xffffffff00000000 | (ulong)uVar13);
}
lVar9 = lVar9 + 2;
} while (1 < local_c4c);
}
if (0 < local_c4c) {
heap_pop(&local_848,&local_c4c);
puVar5[iVar14] = extraout_var;
iVar14 = iVar14 + 1;
}
puVar5[iVar14] = 0;
}
else {
puVar5 = (int1 *)malloc(1);
if (puVar5 != (int1 *)0x0) {
*puVar5 = 0;
}
}
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar5;
} |
4,050 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int freq;
char ch;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
int compare(HeapNode a, HeapNode b) {
// Higher frequency has higher priority.
// If frequency equal, smaller char (lexicographically) has higher priority.
if(a.freq != b.freq)
return a.freq - b.freq; // positive if a.freq > b.freq.
else
return (b.ch - a.ch); // if a.ch < b.ch then priority: a
}
void heapify_down(HeapNode heap[], int n, int idx) {
int largest = idx;
int left = 2*idx + 1;
int right = 2*idx + 2;
if(left < n && (compare(heap[left], heap[largest]) > 0))
largest = left;
if(right < n && (compare(heap[right], heap[largest]) > 0))
largest = right;
if(largest != idx) {
swap(&heap[idx], &heap[largest]);
heapify_down(heap, n, largest);
}
}
void heapify_up(HeapNode heap[], int idx) {
while(idx > 0) {
int parent = (idx - 1)/2;
if(compare(heap[idx], heap[parent]) > 0) {
swap(&heap[idx], &heap[parent]);
idx = parent;
} else {
break;
}
}
}
void heap_push(HeapNode heap[], int *n, HeapNode node) {
heap[*n] = node;
(*n)++;
heapify_up(heap, (*n)-1);
}
HeapNode heap_pop(HeapNode heap[], int *n) {
HeapNode top = heap[0];
heap[0] = heap[(*n)-1];
(*n)--;
heapify_down(heap, *n, 0);
return top;
}
| char* func0(const char *S) {
int len = strlen(S);
if(len == 0) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
int freq[256] = {0};
for(int i = 0; i < len; i++) {
freq[(unsigned char)S[i]]++;
}
// Build heap array. Maximum unique characters are 256.
HeapNode heap[256];
int heapSize = 0;
for (int i = 0; i < 256; i++) {
if(freq[i] > 0) {
HeapNode node;
node.freq = freq[i];
node.ch = (char)i;
heap[heapSize++] = node;
}
}
// Build the heap using heapify_down from bottom-up.
for (int i = (heapSize/2) - 1; i >= 0; i--) {
heapify_down(heap, heapSize, i);
}
// Check feasibility: if the largest frequency is more than (len+1)/2,
// then it is not possible to rearrange, return empty string.
if(heapSize > 0 && heap[0].freq * 2 > len + 1) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
// Allocate result string
char *result = malloc(len + 1);
int pos = 0;
// Process heap: while there are at least two elements.
while(heapSize >= 2) {
HeapNode first = heap_pop(heap, &heapSize);
HeapNode second = heap_pop(heap, &heapSize);
result[pos++] = first.ch;
result[pos++] = second.ch;
first.freq--;
second.freq--;
if(first.freq > 0) {
heap_push(heap, &heapSize, first);
}
if(second.freq > 0) {
heap_push(heap, &heapSize, second);
}
}
if(heapSize > 0) {
HeapNode last = heap_pop(heap, &heapSize);
result[pos++] = last.ch;
}
result[pos] = '\0';
return result;
}
| int main() {
char *res1 = func0("aab");
// The expected output is "aba"
assert(strcmp(res1, "aba") == 0);
free(res1);
char *res2 = func0("aabb");
// The expected output is "abab"
assert(strcmp(res2, "abab") == 0);
free(res2);
char *res3 = func0("abccdd");
// The expected output is "cdabcd"
assert(strcmp(res3, "cdabcd") == 0);
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0xc38,%rsp
mov %fs:0x28,%rax
mov %rax,0xc28(%rsp)
xor %eax,%eax
callq 10a0 <strlen@plt>
test %eax,%eax
je 16ea <func0+0x21a>
lea 0x20(%rsp),%r8
mov %rax,%rbx
mov $0x80,%ecx
mov $0x0,%eax
mov %r8,%rdi
rep stos %rax,%es:(%rdi)
jle 1734 <func0+0x264>
lea -0x1(%rbx),%eax
mov %rbp,%rdi
lea 0x1(%rbp,%rax,1),%rdx
nopl 0x0(%rax)
movzbl (%rdi),%eax
add $0x1,%rdi
addl $0x1,0x20(%rsp,%rax,4)
cmp %rdx,%rdi
jne 1538 <func0+0x68>
mov 0x20(%rsp),%edx
movl $0x0,0x1c(%rsp)
xor %eax,%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x420(%rsp),%rdi
jmp 156c <func0+0x9c>
nopl (%rax)
mov (%r8,%rax,4),%edx
test %edx,%edx
jle 1584 <func0+0xb4>
movslq %esi,%rcx
add $0x1,%esi
lea (%rdi,%rcx,8),%rcx
mov %edx,(%rcx)
mov %al,0x4(%rcx)
mov $0x1,%ecx
add $0x1,%rax
cmp $0x100,%rax
jne 1568 <func0+0x98>
test %cl,%cl
je 1701 <func0+0x231>
mov %esi,%eax
mov %esi,0x1c(%rsp)
sar %eax
lea -0x1(%rax),%ebp
je 15c3 <func0+0xf3>
lea 0x420(%rsp),%rdi
nopl (%rax)
mov %ebp,%edx
sub $0x1,%ebp
callq 1320 <heapify_down>
mov 0x1c(%rsp),%esi
cmp $0xffffffff,%ebp
jne 15b0 <func0+0xe0>
add $0x1,%ebx
test %esi,%esi
jle 15db <func0+0x10b>
mov 0x420(%rsp),%eax
add %eax,%eax
cmp %ebx,%eax
jg 16ea <func0+0x21a>
movslq %ebx,%rdi
callq 10d0 <malloc@plt>
mov 0x1c(%rsp),%esi
mov %rax,%r12
cmp $0x1,%esi
jle 173b <func0+0x26b>
mov $0x2,%r15d
lea 0x420(%rsp),%rdi
lea 0x1c(%rsp),%rbp
nopw %cs:0x0(%rax,%rax,1)
mov %rbp,%rsi
callq 1490 <heap_pop>
mov %rbp,%rsi
mov %rax,%rcx
mov %rax,%rbx
shl $0x18,%rcx
sub $0x1,%ebx
sar $0x38,%rcx
mov %rcx,%r13
callq 1490 <heap_pop>
mov %r13b,-0x2(%r12,%r15,1)
mov %rax,%rdx
mov %r15d,0x4(%rsp)
lea -0x1(%rax),%r14d
shl $0x18,%rdx
sar $0x38,%rdx
mov %dl,-0x1(%r12,%r15,1)
test %ebx,%ebx
jle 167e <func0+0x1ae>
movslq 0x1c(%rsp),%rax
mov %rdx,0x8(%rsp)
mov %rax,%rsi
lea (%rdi,%rax,8),%rax
mov %ebx,(%rax)
mov %r13b,0x4(%rax)
lea 0x1(%rsi),%eax
mov %eax,0x1c(%rsp)
callq 1400 <heapify_up>
mov 0x8(%rsp),%rdx
mov 0x1c(%rsp),%esi
test %r14d,%r14d
jle 16a4 <func0+0x1d4>
movslq %esi,%rax
lea (%rdi,%rax,8),%rax
mov %r14d,(%rax)
mov %dl,0x4(%rax)
lea 0x1(%rsi),%eax
mov %eax,0x1c(%rsp)
callq 1400 <heapify_up>
mov 0x1c(%rsp),%esi
add $0x2,%r15
cmp $0x1,%esi
jg 1610 <func0+0x140>
movslq 0x4(%rsp),%rax
lea (%r12,%rax,1),%rbx
cmp $0x1,%esi
je 1709 <func0+0x239>
movb $0x0,(%rbx)
mov 0xc28(%rsp),%rax
xor %fs:0x28,%rax
jne 174b <func0+0x27b>
add $0xc38,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%edi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 16c2 <func0+0x1f2>
movb $0x0,(%rax)
jmp 16c2 <func0+0x1f2>
add $0x1,%ebx
jmpq 15db <func0+0x10b>
lea 0x1c(%rsp),%rsi
lea 0x420(%rsp),%rdi
callq 1490 <heap_pop>
shl $0x18,%rax
sar $0x38,%rax
mov %al,(%rbx)
mov 0x4(%rsp),%eax
add $0x1,%eax
cltq
lea (%r12,%rax,1),%rbx
jmp 16bf <func0+0x1ef>
xor %edx,%edx
jmpq 154d <func0+0x7d>
movl $0x0,0x4(%rsp)
mov %rax,%rbx
jmpq 16ba <func0+0x1ea>
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 0C28h
mov rax, fs:28h
mov [rsp+0C58h+var_40], rax
xor eax, eax
call _strlen
test eax, eax
jz loc_1703
lea rsi, [rsp+0C58h+var_C48]
mov rbx, rax
mov ecx, 80h
mov eax, 0
mov rdi, rsi
rep stosq
jle loc_175E
lea eax, [rbx-1]
mov rdi, rbp
lea rdx, [rbp+rax+1]
nop dword ptr [rax+00000000h]
loc_1528:
movzx eax, byte ptr [rdi]
add rdi, 1
add [rsp+rax*4+0C58h+var_C48], 1
cmp rdx, rdi
jnz short loc_1528
mov edx, [rsp+0C58h+var_C48]
loc_153D:
xor eax, eax
xor r14d, r14d
jmp short loc_154B
loc_1548:
mov edx, [rsi+rax*4]
loc_154B:
test edx, edx
jle short loc_1564
movsxd rcx, r14d
add r14d, 1
mov dword ptr [rsp+rcx*8+0C58h+var_848], edx
mov byte ptr [rsp+rcx*8+0C58h+var_848+4], al
loc_1564:
add rax, 1
cmp rax, 100h
jnz short loc_1548
mov eax, r14d
lea r15, [rsp+0C58h+var_848]
sar eax, 1
lea ebp, [rax-1]
jz short loc_159A
nop word ptr [rax+rax+00h]
loc_1588:
mov edx, ebp
mov esi, r14d
mov rdi, r15
call heapify_down
sub ebp, 1
jnb short loc_1588
loc_159A:
lea eax, [rbx+1]
test r14d, r14d
jz loc_1765
mov ebx, dword ptr [rsp+0C58h+var_848]
lea edx, [rbx+rbx]
cmp edx, eax
jg loc_1703
movsxd rdi, eax
call _malloc
mov [rsp+0C58h+var_C50], rax
cmp r14d, 1
jz loc_171C
mov r13d, 2
lea r15, [rsp+0C58h+var_848]
jmp short loc_15E7
loc_15E0:
mov ebx, dword ptr [rsp+0C58h+var_848]
loc_15E7:
movsxd rdx, r14d
lea r12d, [r14-1]
mov rdi, r15
sub r14d, 2
mov rdx, [rsp+rdx*8+0C58h+var_850]
movzx ecx, byte ptr [rsp+0C58h+var_848+4]
mov esi, r12d
sub ebx, 1
mov [rsp+0C58h+var_848], rdx
xor edx, edx
mov byte ptr [rsp+0C58h+var_C54], cl
call heapify_down
movsxd rdx, r12d
movzx eax, byte ptr [rsp+0C58h+var_848+4]
mov esi, r14d
mov rdx, [rsp+rdx*8+0C58h+var_850]
mov ebp, dword ptr [rsp+0C58h+var_848]
mov [rsp+0C58h+var_C55], al
mov [rsp+0C58h+var_848], rdx
xor edx, edx
sub ebp, 1
call heapify_down
mov rdi, [rsp+0C58h+var_C50]
movzx ecx, byte ptr [rsp+0C58h+var_C54]
mov [rsp+0C58h+var_C54], r13d
movzx eax, [rsp+0C58h+var_C55]
mov [rdi+r13-2], cl
mov [rdi+r13-1], al
test ebx, ebx
jle short loc_168D
movsxd rdx, r14d
mov esi, r14d
mov rdi, r15
mov r14d, r12d
lea rdx, [r15+rdx*8]
mov [rdx], ebx
mov [rdx+4], cl
call heapify_up
loc_168D:
test ebp, ebp
jle short loc_16B4
movzx eax, [rsp+0C58h+var_C55]
movsxd rdx, r14d
mov esi, r14d
lea ebx, [r14+1]
lea rdx, [r15+rdx*8]
mov rdi, r15
mov r14d, ebx
mov [rdx], ebp
mov [rdx+4], al
call heapify_up
loc_16B4:
add r13, 2
cmp r14d, 1
jg loc_15E0
movsxd rbx, [rsp+0C58h+var_C54]
add rbx, [rsp+0C58h+var_C50]
cmp r14d, 1
jz short loc_1731
loc_16D2:
mov byte ptr [rbx], 0
loc_16D5:
mov rax, [rsp+0C58h+var_40]
sub rax, fs:28h
jnz loc_177A
mov rax, [rsp+0C58h+var_C50]
add rsp, 0C28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1703:
mov edi, 1
call _malloc
mov [rsp+0C58h+var_C50], rax
test rax, rax
jz short loc_16D5
mov byte ptr [rax], 0
jmp short loc_16D5
loc_171C:
mov [rsp+0C58h+var_C54], 0
mov rbx, [rsp+0C58h+var_C50]
lea r15, [rsp+0C58h+var_848]
loc_1731:
xor edx, edx
xor esi, esi
mov rdi, r15
movzx ebp, byte ptr [rsp+0C58h+var_848+4]
call heapify_down
mov eax, [rsp+0C58h+var_C54]
mov [rbx], bpl
mov rbx, [rsp+0C58h+var_C50]
add eax, 1
cdqe
add rbx, rax
jmp loc_16D2
loc_175E:
xor edx, edx
jmp loc_153D
loc_1765:
movsxd rdi, eax
call _malloc
mov [rsp+0C58h+var_C50], rax
mov rbx, rax
jmp loc_16D2
loc_177A:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
int v1; // eax
int v2; // ebx
long long v3; // rdx
long long v4; // rax
int v5; // edx
long long v6; // rax
int v7; // r14d
long long v8; // rcx
unsigned int v9; // ebp
int v11; // eax
int v12; // ebx
long long v13; // r13
long long v14; // rdx
unsigned int v15; // r12d
char v16; // cl
int v17; // ebx
int v18; // ebp
int v19; // ebp
char v20; // cl
long long v21; // rdx
long long v22; // rsi
_QWORD *v23; // rdx
long long v24; // rsi
_QWORD *v25; // rdx
_BYTE *v26; // rbx
_BYTE *v28; // rax
char v29; // bp
char v30; // [rsp+3h] [rbp-C55h]
char v31; // [rsp+4h] [rbp-C54h]
int v32; // [rsp+4h] [rbp-C54h]
long long v33; // [rsp+8h] [rbp-C50h]
_QWORD v34[128]; // [rsp+10h] [rbp-C48h] BYREF
_QWORD v35[265]; // [rsp+410h] [rbp-848h] BYREF
v35[257] = __readfsqword(0x28u);
v1 = strlen();
if ( v1 )
{
v2 = v1;
memset(v34, 0, sizeof(v34));
if ( v1 <= 0 )
{
v5 = 0;
}
else
{
v3 = (long long)&a1[v1 - 1 + 1];
do
{
v4 = *a1++;
++*((_DWORD *)v34 + v4);
}
while ( (unsigned __int8 *)v3 != a1 );
v5 = v34[0];
}
v6 = 0LL;
v7 = 0;
while ( 1 )
{
if ( v5 > 0 )
{
v8 = v7++;
LODWORD(v35[v8]) = v5;
BYTE4(v35[v8]) = v6;
}
if ( ++v6 == 256 )
break;
v5 = *((_DWORD *)v34 + v6);
}
v9 = (v7 >> 1) - 1;
if ( v7 >> 1 )
{
do
heapify_down(v35, (unsigned int)v7, v9);
while ( v9-- != 0 );
}
v11 = v2 + 1;
if ( !v7 )
{
v33 = malloc(v11);
v26 = (_BYTE *)v33;
goto LABEL_24;
}
v12 = v35[0];
if ( 2 * LODWORD(v35[0]) <= v11 )
{
v33 = malloc(v11);
if ( v7 == 1 )
{
v32 = 0;
v26 = (_BYTE *)v33;
}
else
{
v13 = 2LL;
while ( 1 )
{
v14 = v7;
v15 = v7 - 1;
v7 -= 2;
v16 = BYTE4(v35[0]);
v17 = v12 - 1;
v35[0] = v34[v14 + 127];
v31 = v16;
heapify_down(v35, v15, 0LL);
v18 = v35[0];
v30 = BYTE4(v35[0]);
v35[0] = v34[(int)v15 + 127];
v19 = v18 - 1;
heapify_down(v35, (unsigned int)v7, 0LL);
v20 = v31;
v32 = v13;
*(_BYTE *)(v33 + v13 - 2) = v20;
*(_BYTE *)(v33 + v13 - 1) = v30;
if ( v17 > 0 )
{
v21 = v7;
v22 = (unsigned int)v7;
v7 = v15;
v23 = &v35[v21];
*(_DWORD *)v23 = v17;
*((_BYTE *)v23 + 4) = v20;
heapify_up(v35, v22);
}
if ( v19 > 0 )
{
v24 = (unsigned int)v7;
v25 = &v35[v7++];
*(_DWORD *)v25 = v19;
*((_BYTE *)v25 + 4) = v30;
heapify_up(v35, v24);
}
v13 += 2LL;
if ( v7 <= 1 )
break;
v12 = v35[0];
}
v26 = (_BYTE *)(v33 + v32);
if ( v7 != 1 )
goto LABEL_24;
}
v29 = BYTE4(v35[0]);
heapify_down(v35, 0LL, 0LL);
*v26 = v29;
v26 = (_BYTE *)(v32 + 1 + v33);
LABEL_24:
*v26 = 0;
return v33;
}
}
v28 = (_BYTE *)malloc(1LL);
v33 = (long long)v28;
if ( v28 )
*v28 = 0;
return v33;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0xc28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc18],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101703
LEA RSI,[RSP + 0x10]
MOV RBX,RAX
MOV ECX,0x80
MOV EAX,0x0
MOV RDI,RSI
STOSQ.REP RDI
JLE 0x0010175e
LEA EAX,[RBX + -0x1]
MOV RDI,RBP
LEA RDX,[RBP + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00101528:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
ADD dword ptr [RSP + RAX*0x4 + 0x10],0x1
CMP RDX,RDI
JNZ 0x00101528
MOV EDX,dword ptr [RSP + 0x10]
LAB_0010153d:
XOR EAX,EAX
XOR R14D,R14D
JMP 0x0010154b
LAB_00101548:
MOV EDX,dword ptr [RSI + RAX*0x4]
LAB_0010154b:
TEST EDX,EDX
JLE 0x00101564
MOVSXD RCX,R14D
ADD R14D,0x1
MOV dword ptr [RSP + RCX*0x8 + 0x410],EDX
MOV byte ptr [RSP + RCX*0x8 + 0x414],AL
LAB_00101564:
ADD RAX,0x1
CMP RAX,0x100
JNZ 0x00101548
MOV EAX,R14D
LEA R15,[RSP + 0x410]
SAR EAX,0x1
LEA EBP,[RAX + -0x1]
JZ 0x0010159a
NOP word ptr [RAX + RAX*0x1]
LAB_00101588:
MOV EDX,EBP
MOV ESI,R14D
MOV RDI,R15
CALL 0x00101330
SUB EBP,0x1
JNC 0x00101588
LAB_0010159a:
LEA EAX,[RBX + 0x1]
TEST R14D,R14D
JZ 0x00101765
MOV EBX,dword ptr [RSP + 0x410]
LEA EDX,[RBX + RBX*0x1]
CMP EDX,EAX
JG 0x00101703
MOVSXD RDI,EAX
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
CMP R14D,0x1
JZ 0x0010171c
MOV R13D,0x2
LEA R15,[RSP + 0x410]
JMP 0x001015e7
LAB_001015e0:
MOV EBX,dword ptr [RSP + 0x410]
LAB_001015e7:
MOVSXD RDX,R14D
LEA R12D,[R14 + -0x1]
MOV RDI,R15
SUB R14D,0x2
MOV RDX,qword ptr [RSP + RDX*0x8 + 0x408]
MOVZX ECX,byte ptr [RSP + 0x414]
MOV ESI,R12D
SUB EBX,0x1
MOV qword ptr [RSP + 0x410],RDX
XOR EDX,EDX
MOV byte ptr [RSP + 0x4],CL
CALL 0x00101330
MOVSXD RDX,R12D
MOVZX EAX,byte ptr [RSP + 0x414]
MOV ESI,R14D
MOV RDX,qword ptr [RSP + RDX*0x8 + 0x408]
MOV EBP,dword ptr [RSP + 0x410]
MOV byte ptr [RSP + 0x3],AL
MOV qword ptr [RSP + 0x410],RDX
XOR EDX,EDX
SUB EBP,0x1
CALL 0x00101330
MOV RDI,qword ptr [RSP + 0x8]
MOVZX ECX,byte ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x4],R13D
MOVZX EAX,byte ptr [RSP + 0x3]
MOV byte ptr [RDI + R13*0x1 + -0x2],CL
MOV byte ptr [RDI + R13*0x1 + -0x1],AL
TEST EBX,EBX
JLE 0x0010168d
MOVSXD RDX,R14D
MOV ESI,R14D
MOV RDI,R15
MOV R14D,R12D
LEA RDX,[R15 + RDX*0x8]
MOV dword ptr [RDX],EBX
MOV byte ptr [RDX + 0x4],CL
CALL 0x001013f0
LAB_0010168d:
TEST EBP,EBP
JLE 0x001016b4
MOVZX EAX,byte ptr [RSP + 0x3]
MOVSXD RDX,R14D
MOV ESI,R14D
LEA EBX,[R14 + 0x1]
LEA RDX,[R15 + RDX*0x8]
MOV RDI,R15
MOV R14D,EBX
MOV dword ptr [RDX],EBP
MOV byte ptr [RDX + 0x4],AL
CALL 0x001013f0
LAB_001016b4:
ADD R13,0x2
CMP R14D,0x1
JG 0x001015e0
MOVSXD RBX,dword ptr [RSP + 0x4]
ADD RBX,qword ptr [RSP + 0x8]
CMP R14D,0x1
JZ 0x00101731
LAB_001016d2:
MOV byte ptr [RBX],0x0
LAB_001016d5:
MOV RAX,qword ptr [RSP + 0xc18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010177a
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0xc28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101703:
MOV EDI,0x1
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x001016d5
MOV byte ptr [RAX],0x0
JMP 0x001016d5
LAB_0010171c:
MOV dword ptr [RSP + 0x4],0x0
MOV RBX,qword ptr [RSP + 0x8]
LEA R15,[RSP + 0x410]
LAB_00101731:
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,R15
MOVZX EBP,byte ptr [RSP + 0x414]
CALL 0x00101330
MOV EAX,dword ptr [RSP + 0x4]
MOV byte ptr [RBX],BPL
MOV RBX,qword ptr [RSP + 0x8]
ADD EAX,0x1
CDQE
ADD RBX,RAX
JMP 0x001016d2
LAB_0010175e:
XOR EDX,EDX
JMP 0x0010153d
LAB_00101765:
MOVSXD RDI,EAX
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOV RBX,RAX
JMP 0x001016d2
LAB_0010177a:
CALL 0x001010c0 | int1 * func0(byte *param_1)
{
byte *pbVar1;
int1 uVar2;
int1 uVar3;
int iVar4;
int iVar5;
size_t sVar6;
long lVar7;
long lVar8;
int1 *puVar9;
int iVar10;
int *piVar11;
int iVar12;
int iVar13;
long in_FS_OFFSET;
byte bVar14;
int local_c54;
int1 *local_c50;
int local_c48 [254];
int8 local_850;
int8 local_848;
long local_40;
bVar14 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar6 = strlen((char *)param_1);
iVar5 = (int)sVar6;
if (iVar5 == 0) {
LAB_00101703:
local_c50 = (int1 *)malloc(1);
if (local_c50 != (int1 *)0x0) {
*local_c50 = 0;
}
}
else {
piVar11 = local_c48;
for (lVar7 = 0x80; lVar7 != 0; lVar7 = lVar7 + -1) {
piVar11[0] = 0;
piVar11[1] = 0;
piVar11 = piVar11 + ((ulong)bVar14 * -2 + 1) * 2;
}
if (iVar5 < 1) {
local_c48[0] = 0;
}
else {
pbVar1 = param_1 + (ulong)(iVar5 - 1) + 1;
do {
bVar14 = *param_1;
param_1 = param_1 + 1;
local_c48[bVar14] = local_c48[bVar14] + 1;
} while (pbVar1 != param_1);
}
lVar7 = 0;
iVar12 = 0;
while( true ) {
if (0 < local_c48[0]) {
lVar8 = (long)iVar12;
iVar12 = iVar12 + 1;
*(int *)(&local_848 + lVar8) = local_c48[0];
*(char *)((long)&local_848 + lVar8 * 8 + 4) = (char)lVar7;
}
lVar7 = lVar7 + 1;
if (lVar7 == 0x100) break;
local_c48[0] = local_c48[lVar7];
}
iVar4 = iVar12 >> 1;
while (iVar4 != 0) {
iVar4 = iVar4 + -1;
heapify_down(&local_848,iVar12,iVar4);
}
iVar5 = iVar5 + 1;
if (iVar12 == 0) {
puVar9 = (int1 *)malloc((long)iVar5);
local_c50 = puVar9;
}
else {
iVar4 = (int)local_848;
if (iVar5 < (int)local_848 * 2) goto LAB_00101703;
local_c50 = (int1 *)malloc((long)iVar5);
if (iVar12 == 1) {
local_c54 = 0;
puVar9 = local_c50;
}
else {
lVar7 = 2;
while( true ) {
iVar5 = iVar12 + -1;
iVar13 = iVar12 + -2;
uVar2 = local_848._4_1_;
local_848 = (&local_850)[iVar12];
heapify_down(&local_848,iVar5,0);
uVar3 = local_848._4_1_;
iVar10 = (int)local_848 + -1;
local_848 = (&local_850)[iVar5];
heapify_down();
local_c54 = (int)lVar7;
local_c50[lVar7 + -2] = uVar2;
local_c50[lVar7 + -1] = uVar3;
if (0 < iVar4 + -1) {
*(int *)(&local_848 + iVar13) = iVar4 + -1;
*(int1 *)((long)&local_848 + (long)iVar13 * 8 + 4) = uVar2;
heapify_up(&local_848,iVar13);
iVar13 = iVar5;
}
iVar12 = iVar13;
if (0 < iVar10) {
iVar12 = iVar13 + 1;
*(int *)(&local_848 + iVar13) = iVar10;
*(int1 *)((long)&local_848 + (long)iVar13 * 8 + 4) = uVar3;
heapify_up(&local_848,iVar13);
}
lVar7 = lVar7 + 2;
if (iVar12 < 2) break;
iVar4 = (int)local_848;
}
puVar9 = local_c50 + local_c54;
if (iVar12 != 1) goto LAB_001016d2;
}
uVar2 = local_848._4_1_;
heapify_down(&local_848,0,0);
*puVar9 = uVar2;
puVar9 = local_c50 + (local_c54 + 1);
}
LAB_001016d2:
*puVar9 = 0;
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_c50;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,051 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int freq;
char ch;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
int compare(HeapNode a, HeapNode b) {
// Higher frequency has higher priority.
// If frequency equal, smaller char (lexicographically) has higher priority.
if(a.freq != b.freq)
return a.freq - b.freq; // positive if a.freq > b.freq.
else
return (b.ch - a.ch); // if a.ch < b.ch then priority: a
}
void heapify_down(HeapNode heap[], int n, int idx) {
int largest = idx;
int left = 2*idx + 1;
int right = 2*idx + 2;
if(left < n && (compare(heap[left], heap[largest]) > 0))
largest = left;
if(right < n && (compare(heap[right], heap[largest]) > 0))
largest = right;
if(largest != idx) {
swap(&heap[idx], &heap[largest]);
heapify_down(heap, n, largest);
}
}
void heapify_up(HeapNode heap[], int idx) {
while(idx > 0) {
int parent = (idx - 1)/2;
if(compare(heap[idx], heap[parent]) > 0) {
swap(&heap[idx], &heap[parent]);
idx = parent;
} else {
break;
}
}
}
void heap_push(HeapNode heap[], int *n, HeapNode node) {
heap[*n] = node;
(*n)++;
heapify_up(heap, (*n)-1);
}
HeapNode heap_pop(HeapNode heap[], int *n) {
HeapNode top = heap[0];
heap[0] = heap[(*n)-1];
(*n)--;
heapify_down(heap, *n, 0);
return top;
}
| char* func0(const char *S) {
int len = strlen(S);
if(len == 0) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
int freq[256] = {0};
for(int i = 0; i < len; i++) {
freq[(unsigned char)S[i]]++;
}
// Build heap array. Maximum unique characters are 256.
HeapNode heap[256];
int heapSize = 0;
for (int i = 0; i < 256; i++) {
if(freq[i] > 0) {
HeapNode node;
node.freq = freq[i];
node.ch = (char)i;
heap[heapSize++] = node;
}
}
// Build the heap using heapify_down from bottom-up.
for (int i = (heapSize/2) - 1; i >= 0; i--) {
heapify_down(heap, heapSize, i);
}
// Check feasibility: if the largest frequency is more than (len+1)/2,
// then it is not possible to rearrange, return empty string.
if(heapSize > 0 && heap[0].freq * 2 > len + 1) {
char *empty = malloc(1);
if(empty) empty[0] = '\0';
return empty;
}
// Allocate result string
char *result = malloc(len + 1);
int pos = 0;
// Process heap: while there are at least two elements.
while(heapSize >= 2) {
HeapNode first = heap_pop(heap, &heapSize);
HeapNode second = heap_pop(heap, &heapSize);
result[pos++] = first.ch;
result[pos++] = second.ch;
first.freq--;
second.freq--;
if(first.freq > 0) {
heap_push(heap, &heapSize, first);
}
if(second.freq > 0) {
heap_push(heap, &heapSize, second);
}
}
if(heapSize > 0) {
HeapNode last = heap_pop(heap, &heapSize);
result[pos++] = last.ch;
}
result[pos] = '\0';
return result;
}
| int main() {
char *res1 = func0("aab");
// The expected output is "aba"
assert(strcmp(res1, "aba") == 0);
free(res1);
char *res2 = func0("aabb");
// The expected output is "abab"
assert(strcmp(res2, "abab") == 0);
free(res2);
char *res3 = func0("abccdd");
// The expected output is "cdabcd"
assert(strcmp(res3, "cdabcd") == 0);
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0xc38,%rsp
mov %fs:0x28,%rax
mov %rax,0xc28(%rsp)
xor %eax,%eax
callq 10a0 <strlen@plt>
test %eax,%eax
je 1829 <func0+0x2f9>
lea 0x20(%rsp),%rsi
mov %rax,%rbp
mov $0x80,%ecx
mov $0x0,%eax
mov %rsi,%rdi
rep stos %rax,%es:(%rdi)
jle 15a1 <func0+0x71>
lea -0x1(%rbp),%eax
mov %rbx,%rdi
lea 0x1(%rbx,%rax,1),%rdx
nopl (%rax)
movzbl (%rdi),%eax
add $0x1,%rdi
addl $0x1,0x20(%rsp,%rax,4)
cmp %rdi,%rdx
jne 1590 <func0+0x60>
xor %eax,%eax
xor %ebx,%ebx
lea 0x420(%rsp),%rdi
nopl (%rax)
mov (%rsi,%rax,4),%edx
test %edx,%edx
jle 15c6 <func0+0x96>
movslq %ebx,%rcx
add $0x1,%ebx
lea (%rdi,%rcx,8),%rcx
mov %edx,(%rcx)
mov %al,0x4(%rcx)
add $0x1,%rax
cmp $0x100,%rax
jne 15b0 <func0+0x80>
mov %ebx,%eax
lea 0x420(%rsp),%rdi
sar %eax
lea -0x1(%rax),%r12d
je 15fc <func0+0xcc>
nopl 0x0(%rax)
mov %r12d,%edx
mov %ebx,%esi
sub $0x1,%r12d
callq 1320 <heapify_down>
cmp $0xffffffff,%r12d
jne 15e8 <func0+0xb8>
lea 0x1(%rbp),%eax
test %ebx,%ebx
je 189f <func0+0x36f>
mov 0x420(%rsp),%ebp
lea 0x0(%rbp,%rbp,1),%edx
cmp %eax,%edx
jg 1829 <func0+0x2f9>
movslq %eax,%rdi
callq 10d0 <malloc@plt>
mov %rax,0x10(%rsp)
cmp $0x1,%ebx
je 1849 <func0+0x319>
mov $0x2,%r15d
lea 0x420(%rsp),%rdi
jmp 165f <func0+0x12f>
mov %esi,%ebx
test %r12d,%r12d
jg 17a0 <func0+0x270>
cmp $0x1,%ebx
jle 1753 <func0+0x223>
mov 0x420(%rsp),%ebp
add $0x2,%r15
movzbl 0x424(%rsp),%r13d
movslq %ebx,%rax
xor %edx,%edx
mov 0x418(%rsp,%rax,8),%rax
mov %rax,0x420(%rsp)
lea -0x1(%rbx),%eax
mov %eax,%esi
mov %eax,0xc(%rsp)
callq 1320 <heapify_down>
xor %edx,%edx
mov 0x420(%rsp),%r12d
movzbl 0x424(%rsp),%r14d
movslq %esi,%rax
lea -0x2(%rbx),%esi
shl $0x3,%rax
sub $0x1,%r12d
mov %rax,0x18(%rsp)
mov 0x418(%rsp,%rax,1),%rax
mov %rax,0x420(%rsp)
callq 1320 <heapify_down>
mov 0x10(%rsp),%rax
lea -0x1(%rbp),%ecx
mov %r15d,%r8d
mov %r13b,-0x2(%rax,%r15,1)
mov %r14b,-0x1(%rax,%r15,1)
test %ecx,%ecx
jle 1640 <func0+0x110>
movslq %esi,%rax
lea (%rdi,%rax,8),%rax
mov %ecx,(%rax)
mov %r13b,0x4(%rax)
test %esi,%esi
je 1807 <func0+0x2d7>
movsbl %r13b,%ebp
jmp 1710 <func0+0x1e0>
xchg %ax,%ax
mov (%rdx),%rax
mov %rax,(%r10)
mov %ecx,(%rdx)
mov %r13b,0x4(%rdx)
test %esi,%esi
je 173d <func0+0x20d>
movslq %esi,%rax
mov %ecx,%r11d
lea -0x1(%rax),%esi
lea (%rdi,%rax,8),%r10
sar %esi
movslq %esi,%rdx
lea (%rdi,%rdx,8),%rdx
mov (%rdx),%r9d
movsbl 0x4(%rdx),%eax
sub %r9d,%r11d
sub %ebp,%eax
cmp %ecx,%r9d
cmovne %r11d,%eax
test %eax,%eax
jg 1700 <func0+0x1d0>
test %r12d,%r12d
jg 1810 <func0+0x2e0>
mov 0xc(%rsp),%ebx
cmp $0x1,%ebx
jg 1654 <func0+0x124>
movslq %r8d,%rbp
add 0x10(%rsp),%rbp
cmp $0x1,%ebx
je 1859 <func0+0x329>
movb $0x0,0x0(%rbp)
mov 0xc28(%rsp),%rax
xor %fs:0x28,%rax
jne 18b4 <func0+0x384>
mov 0x10(%rsp),%rax
add $0xc38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
movslq %esi,%rax
lea (%rdi,%rax,8),%rax
mov %r12d,(%rax)
mov %r14b,0x4(%rax)
test %esi,%esi
je 1888 <func0+0x358>
movsbl %r14b,%r9d
jmp 17d1 <func0+0x2a1>
nopl 0x0(%rax)
mov (%rdx),%rax
mov %rax,(%r10)
mov %r12d,(%rdx)
mov %r14b,0x4(%rdx)
test %esi,%esi
je 17fe <func0+0x2ce>
movslq %esi,%rax
mov %r12d,%r8d
lea -0x1(%rax),%esi
lea (%rdi,%rax,8),%r10
sar %esi
movslq %esi,%rdx
lea (%rdi,%rdx,8),%rdx
mov (%rdx),%ecx
movsbl 0x4(%rdx),%eax
sub %ecx,%r8d
sub %r9d,%eax
cmp %ecx,%r12d
cmovne %r8d,%eax
test %eax,%eax
jg 17c0 <func0+0x290>
mov 0xc(%rsp),%ebx
jmpq 1654 <func0+0x124>
test %r12d,%r12d
jle 1888 <func0+0x358>
nopl 0x0(%rax)
mov 0x18(%rsp),%rax
mov 0xc(%rsp),%esi
mov %ebx,0xc(%rsp)
add %rdi,%rax
mov %r12d,(%rax)
mov %r14b,0x4(%rax)
jmp 17b6 <func0+0x286>
mov $0x1,%edi
callq 10d0 <malloc@plt>
mov %rax,0x10(%rsp)
test %rax,%rax
je 1768 <func0+0x238>
movb $0x0,(%rax)
jmpq 1768 <func0+0x238>
mov 0x10(%rsp),%rbp
xor %r8d,%r8d
lea 0x420(%rsp),%rdi
xor %edx,%edx
xor %esi,%esi
mov %r8d,0xc(%rsp)
movzbl 0x424(%rsp),%ebx
callq 1320 <heapify_down>
mov 0xc(%rsp),%r8d
mov %bl,0x0(%rbp)
lea 0x1(%r8),%ebp
movslq %ebp,%rbp
add 0x10(%rsp),%rbp
jmpq 1764 <func0+0x234>
mov 0xc(%rsp),%ebx
movslq %r8d,%rbp
add 0x10(%rsp),%rbp
cmp $0x1,%ebx
jne 1764 <func0+0x234>
jmp 1859 <func0+0x329>
movslq %eax,%rdi
callq 10d0 <malloc@plt>
mov %rax,0x10(%rsp)
mov %rax,%rbp
jmpq 1764 <func0+0x234>
callq 10b0 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C38h
mov rax, fs:28h
mov [rsp+0C68h+var_40], rax
xor eax, eax
call _strlen
test eax, eax
jz loc_1798
lea rsi, [rsp+0C68h+var_C48]
mov r12, rax
mov ecx, 80h
mov eax, 0
mov rdi, rsi
rep stosq
jle short loc_15C1
lea eax, [r12-1]
mov rdi, rbx
lea rdx, [rbx+rax+1]
nop
loc_15B0:
movzx eax, byte ptr [rdi]
add rdi, 1
add [rsp+rax*4+0C68h+var_C48], 1
cmp rdi, rdx
jnz short loc_15B0
loc_15C1:
xor eax, eax
xor ebp, ebp
nop dword ptr [rax]
loc_15C8:
mov edx, [rsi+rax*4]
test edx, edx
jle short loc_15E3
movsxd rcx, ebp
add ebp, 1
mov dword ptr [rsp+rcx*8+0C68h+var_848], edx
mov byte ptr [rsp+rcx*8+0C68h+var_848+4], al
loc_15E3:
add rax, 1
cmp rax, 100h
jnz short loc_15C8
mov ebx, ebp
lea rdi, [rsp+0C68h+var_848]
shr ebx, 1Fh
add ebx, ebp
sar ebx, 1
sub ebx, 1
js short loc_1616
nop dword ptr [rax]
loc_1608:
mov edx, ebx
mov esi, ebp
call heapify_down
sub ebx, 1
jnb short loc_1608
loc_1616:
lea eax, [r12+1]
test ebp, ebp
jle loc_187F
mov r12d, dword ptr [rsp+0C68h+var_848]
lea edx, [r12+r12]
cmp edx, eax
jg loc_1798
movsxd rdi, eax; size
call _malloc
mov r10, rax
cmp ebp, 1
jz loc_1901
mov [rsp+0C68h+var_C50], rax
mov r8d, 2
lea rdi, [rsp+0C68h+var_848]
jmp short loc_167F
loc_1660:
test ecx, ecx
jg loc_17E0
add r8, 2
cmp ebx, 1
jle loc_184F
loc_1675:
mov r12d, dword ptr [rsp+0C68h+var_848]
mov ebp, ebx
loc_167F:
movsxd rax, ebp
lea ebx, [rbp-1]
xor edx, edx
mov [rsp+0C68h+var_C68], r8
mov rax, [rsp+rax*8+0C68h+var_850]
mov esi, ebx
mov [rsp+0C68h+var_C5C], ebx
sub r12d, 1
movzx r15d, byte ptr [rsp+0C68h+var_848+4]
mov [rsp+0C68h+var_848], rax
call heapify_down
movsxd r9, ebx
lea ebx, [rbp-2]
movzx r14d, byte ptr [rsp+0C68h+var_848+4]
mov rdx, [rsp+r9*8+0C68h+var_850]
movzx eax, r15b
mov r13d, dword ptr [rsp+0C68h+var_848]
mov esi, ebx
mov ecx, r14d
mov [rsp+0C68h+var_C58], r9
mov ah, cl
mov [rsp+0C68h+var_848], rdx
xor edx, edx
mov word ptr [rsp+0C68h+var_C60], ax
call heapify_down
mov r8, [rsp+0C68h+var_C68]
mov rsi, [rsp+0C68h+var_C50]
lea ecx, [r13-1]
movzx eax, word ptr [rsp+0C68h+var_C60]
mov r11d, r8d
mov [rsi+r8-2], ax
test r12d, r12d
jle loc_1660
movsxd rax, ebx
lea rax, [rdi+rax*8]
mov [rax], r12d
mov [rax+4], r15b
test ebx, ebx
jz loc_188F
mov [rsp+0C68h+var_C60], r8d
mov r9, [rsp+0C68h+var_C58]
movsx r13d, r15b
jmp short loc_1751
loc_1740:
mov rax, [rdx]
mov [r11], rax
mov [rdx], r12d
mov [rdx+4], r15b
test ebx, ebx
jz short loc_177E
loc_1751:
movsxd rax, ebx
mov r10d, r12d
lea ebx, [rax-1]
lea r11, [rdi+rax*8]
sar ebx, 1
movsxd rdx, ebx
lea rdx, [rdi+rdx*8]
mov esi, [rdx]
movsx eax, byte ptr [rdx+4]
sub r10d, esi
sub eax, r13d
cmp r12d, esi
cmovnz eax, r10d
test eax, eax
jg short loc_1740
loc_177E:
mov r11d, [rsp+0C68h+var_C60]
test ecx, ecx
jg loc_1868
mov ebx, [rsp+0C68h+var_C5C]
add r8, 2
jmp loc_1675
loc_1798:
mov edi, 1; size
call _malloc
mov r10, rax
test rax, rax
jz short loc_17AD
mov byte ptr [rax], 0
loc_17AD:
mov rax, [rsp+0C68h+var_40]
sub rax, fs:28h
jnz loc_1911
add rsp, 0C38h
mov rax, r10
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_17E0:
movsxd rax, ebx
lea rax, [rdi+rax*8]
mov [rax], ecx
mov [rax+4], r14b
test ebx, ebx
jz loc_18CE
loc_17F5:
movsx esi, r14b
jmp short loc_1811
loc_1800:
mov rax, [rdx]
mov [rbp+0], rax
mov [rdx], ecx
mov [rdx+4], r14b
test ebx, ebx
jz short loc_183E
loc_1811:
movsxd rax, ebx
mov r10d, ecx
lea ebx, [rax-1]
lea rbp, [rdi+rax*8]
sar ebx, 1
movsxd rdx, ebx
lea rdx, [rdi+rdx*8]
mov r9d, [rdx]
movsx eax, byte ptr [rdx+4]
sub r10d, r9d
sub eax, esi
cmp ecx, r9d
cmovnz eax, r10d
test eax, eax
jg short loc_1800
loc_183E:
mov ebx, [rsp+0C68h+var_C5C]
add r8, 2
cmp ebx, 1
jg loc_1675
loc_184F:
mov r10, [rsp+0C68h+var_C50]
movsxd rbp, r11d
add rbp, r10
loc_185A:
cmp ebx, 1
jz short loc_189C
loc_185F:
mov byte ptr [rbp+0], 0
jmp loc_17AD
loc_1868:
lea rax, [rdi+r9*8]
mov ebx, [rsp+0C68h+var_C5C]
mov [rsp+0C68h+var_C5C], ebp
mov [rax], ecx
mov [rax+4], r14b
jmp loc_17F5
loc_187F:
movsxd rdi, eax; size
call _malloc
mov rbp, rax
mov r10, rax
jmp short loc_185F
loc_188F:
test ecx, ecx
jg short loc_18E0
movsxd rbp, r8d
mov r10, rsi
add rbp, rsi
loc_189C:
xor edx, edx
xor esi, esi
mov [rsp+0C68h+var_C68], r10
movzx ebx, byte ptr [rsp+0C68h+var_848+4]
mov [rsp+0C68h+var_C60], r11d
call heapify_down
mov r11d, [rsp+0C68h+var_C60]
mov r10, [rsp+0C68h+var_C68]
mov [rbp+0], bl
lea ebp, [r11+1]
movsxd rbp, ebp
add rbp, r10
jmp short loc_185F
loc_18CE:
movsxd rbp, r8d
mov ebx, [rsp+0C68h+var_C5C]
mov r10, rsi
add rbp, rsi
jmp loc_185A
loc_18E0:
mov [rsp+0C68h+var_840], ecx
mov ebx, 1
mov [rsp+0C68h+var_83C], r14b
mov [rsp+0C68h+var_C5C], 2
jmp loc_17F5
loc_1901:
mov rbp, rax
xor r11d, r11d
lea rdi, [rsp+0C68h+var_848]
jmp short loc_189C
loc_1911:
call ___stack_chk_fail | _BYTE * func0(const char *a1)
{
int v1; // eax
int v2; // r12d
long long v3; // rdx
long long v4; // rax
long long v5; // rax
int v6; // ebp
int v7; // edx
long long v8; // rcx
int v9; // ebx
int v11; // eax
int v12; // r12d
_BYTE *v13; // rax
_BYTE *v14; // r10
long long v15; // r8
int v16; // r12d
char v17; // r15
int v18; // ebx
char v19; // r14
__int16 v20; // ax
int v21; // r13d
int v22; // ecx
int v23; // r11d
long long *v24; // rax
long long *v25; // r11
long long *v26; // rdx
int v27; // eax
_BYTE *v28; // rax
long long *v30; // rax
long long *v31; // rbp
long long *v32; // rdx
int v33; // eax
_BYTE *v34; // rbp
long long *v35; // rax
char v36; // bl
long long v37; // [rsp+0h] [rbp-C68h]
_BYTE *v38; // [rsp+0h] [rbp-C68h]
__int16 v39; // [rsp+8h] [rbp-C60h]
int v40; // [rsp+8h] [rbp-C60h]
int v41; // [rsp+Ch] [rbp-C5Ch]
long long v42; // [rsp+10h] [rbp-C58h]
_BYTE *v43; // [rsp+18h] [rbp-C50h]
_QWORD v44[128]; // [rsp+20h] [rbp-C48h] BYREF
long long v45; // [rsp+420h] [rbp-848h] BYREF
int v46; // [rsp+428h] [rbp-840h]
char v47; // [rsp+42Ch] [rbp-83Ch]
unsigned long long v48; // [rsp+C28h] [rbp-40h]
v48 = __readfsqword(0x28u);
v1 = strlen(a1);
if ( !v1 )
goto LABEL_27;
v2 = v1;
memset(v44, 0, sizeof(v44));
if ( v1 > 0 )
{
v3 = (long long)&a1[v1 - 1 + 1];
do
{
v4 = *(unsigned __int8 *)a1++;
++*((_DWORD *)v44 + v4);
}
while ( a1 != (const char *)v3 );
}
v5 = 0LL;
v6 = 0;
do
{
v7 = *((_DWORD *)v44 + v5);
if ( v7 > 0 )
{
v8 = v6++;
*((_DWORD *)&v45 + 2 * v8) = v7;
*((_BYTE *)&v45 + 8 * v8 + 4) = v5;
}
++v5;
}
while ( v5 != 256 );
v9 = v6 / 2 - 1;
if ( v9 >= 0 )
{
do
heapify_down(&v45, (unsigned int)v6, (unsigned int)v9);
while ( v9-- != 0 );
}
v11 = v2 + 1;
if ( v6 <= 0 )
{
v34 = malloc(v11);
v14 = v34;
goto LABEL_39;
}
v12 = v45;
if ( 2 * (int)v45 > v11 )
{
LABEL_27:
v28 = malloc(1uLL);
v14 = v28;
if ( v28 )
*v28 = 0;
return v14;
}
v13 = malloc(v11);
v14 = v13;
if ( v6 == 1 )
{
v34 = v13;
v23 = 0;
LABEL_44:
v38 = v14;
v36 = BYTE4(v45);
v40 = v23;
heapify_down(&v45, 0LL, 0LL);
v14 = v38;
*v34 = v36;
v34 = &v38[v40 + 1];
goto LABEL_39;
}
v43 = v13;
v15 = 2LL;
while ( 1 )
{
v37 = v15;
v41 = v6 - 1;
v16 = v12 - 1;
v17 = BYTE4(v45);
v45 = v44[v6 + 127];
heapify_down(&v45, (unsigned int)(v6 - 1), 0LL);
v18 = v6 - 2;
v19 = BYTE4(v45);
LOBYTE(v20) = v17;
v21 = v45;
v42 = v6 - 1;
HIBYTE(v20) = BYTE4(v45);
v45 = v44[v42 + 127];
v39 = v20;
heapify_down(&v45, (unsigned int)(v6 - 2), 0LL);
v22 = v21 - 1;
v23 = v37;
*(_WORD *)&v43[v37 - 2] = v39;
if ( v16 > 0 )
{
v24 = &v45 + v18;
*(_DWORD *)v24 = v16;
*((_BYTE *)v24 + 4) = v17;
if ( v6 == 2 )
{
if ( v22 <= 0 )
{
v14 = v43;
v34 = &v43[(int)v37];
goto LABEL_44;
}
v46 = v21 - 1;
v18 = 1;
v47 = v19;
v41 = 2;
}
else
{
do
{
v25 = &v45 + v18;
v18 = (v18 - 1) >> 1;
v26 = &v45 + v18;
v27 = *((char *)v26 + 4) - v17;
if ( v16 != *(_DWORD *)v26 )
v27 = v16 - *(_DWORD *)v26;
if ( v27 <= 0 )
break;
*v25 = *v26;
*(_DWORD *)v26 = v16;
*((_BYTE *)v26 + 4) = v17;
}
while ( v18 );
v23 = v37;
if ( v22 <= 0 )
{
v18 = v6 - 1;
v15 = v37 + 2;
goto LABEL_17;
}
v35 = &v45 + v42;
v18 = v6 - 1;
v41 = v6;
*(_DWORD *)v35 = v22;
*((_BYTE *)v35 + 4) = v19;
}
goto LABEL_33;
}
if ( v22 <= 0 )
{
v15 = v37 + 2;
if ( v18 <= 1 )
goto LABEL_37;
goto LABEL_17;
}
v30 = &v45 + v18;
*(_DWORD *)v30 = v22;
*((_BYTE *)v30 + 4) = v19;
if ( v6 == 2 )
break;
do
{
LABEL_33:
v31 = &v45 + v18;
v18 = (v18 - 1) >> 1;
v32 = &v45 + v18;
v33 = *((char *)v32 + 4) - v19;
if ( v22 != *(_DWORD *)v32 )
v33 = v22 - *(_DWORD *)v32;
if ( v33 <= 0 )
break;
*v31 = *v32;
*(_DWORD *)v32 = v22;
*((_BYTE *)v32 + 4) = v19;
}
while ( v18 );
v18 = v41;
v15 = v37 + 2;
if ( v41 <= 1 )
{
LABEL_37:
v14 = v43;
v34 = &v43[v23];
goto LABEL_38;
}
LABEL_17:
v12 = v45;
v6 = v18;
}
v18 = v6 - 1;
v14 = v43;
v34 = &v43[(int)v37];
LABEL_38:
if ( v18 == 1 )
goto LABEL_44;
LABEL_39:
*v34 = 0;
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc28],RAX
XOR EAX,EAX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101798
LEA RSI,[RSP + 0x20]
MOV R12,RAX
MOV ECX,0x80
MOV EAX,0x0
MOV RDI,RSI
STOSQ.REP RDI
JLE 0x001015c1
LEA EAX,[R12 + -0x1]
MOV RDI,RBX
LEA RDX,[RBX + RAX*0x1 + 0x1]
NOP
LAB_001015b0:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
ADD dword ptr [RSP + RAX*0x4 + 0x20],0x1
CMP RDI,RDX
JNZ 0x001015b0
LAB_001015c1:
XOR EAX,EAX
XOR EBP,EBP
NOP dword ptr [RAX]
LAB_001015c8:
MOV EDX,dword ptr [RSI + RAX*0x4]
TEST EDX,EDX
JLE 0x001015e3
MOVSXD RCX,EBP
ADD EBP,0x1
MOV dword ptr [RSP + RCX*0x8 + 0x420],EDX
MOV byte ptr [RSP + RCX*0x8 + 0x424],AL
LAB_001015e3:
ADD RAX,0x1
CMP RAX,0x100
JNZ 0x001015c8
MOV EBX,EBP
LEA RDI,[RSP + 0x420]
SHR EBX,0x1f
ADD EBX,EBP
SAR EBX,0x1
SUB EBX,0x1
JS 0x00101616
NOP dword ptr [RAX]
LAB_00101608:
MOV EDX,EBX
MOV ESI,EBP
CALL 0x00101330
SUB EBX,0x1
JNC 0x00101608
LAB_00101616:
LEA EAX,[R12 + 0x1]
TEST EBP,EBP
JLE 0x0010187f
MOV R12D,dword ptr [RSP + 0x420]
LEA EDX,[R12 + R12*0x1]
CMP EDX,EAX
JG 0x00101798
MOVSXD RDI,EAX
CALL 0x001010f0
MOV R10,RAX
CMP EBP,0x1
JZ 0x00101901
MOV qword ptr [RSP + 0x18],RAX
MOV R8D,0x2
LEA RDI,[RSP + 0x420]
JMP 0x0010167f
LAB_00101660:
TEST ECX,ECX
JG 0x001017e0
ADD R8,0x2
CMP EBX,0x1
JLE 0x0010184f
LAB_00101675:
MOV R12D,dword ptr [RSP + 0x420]
MOV EBP,EBX
LAB_0010167f:
MOVSXD RAX,EBP
LEA EBX,[RBP + -0x1]
XOR EDX,EDX
MOV qword ptr [RSP],R8
MOV RAX,qword ptr [RSP + RAX*0x8 + 0x418]
MOV ESI,EBX
MOV dword ptr [RSP + 0xc],EBX
SUB R12D,0x1
MOVZX R15D,byte ptr [RSP + 0x424]
MOV qword ptr [RSP + 0x420],RAX
CALL 0x00101330
MOVSXD R9,EBX
LEA EBX,[RBP + -0x2]
MOVZX R14D,byte ptr [RSP + 0x424]
MOV RDX,qword ptr [RSP + R9*0x8 + 0x418]
MOVZX EAX,R15B
MOV R13D,dword ptr [RSP + 0x420]
MOV ESI,EBX
MOV ECX,R14D
MOV qword ptr [RSP + 0x10],R9
MOV AH,CL
MOV qword ptr [RSP + 0x420],RDX
XOR EDX,EDX
MOV word ptr [RSP + 0x8],AX
CALL 0x00101330
MOV R8,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x18]
LEA ECX,[R13 + -0x1]
MOVZX EAX,word ptr [RSP + 0x8]
MOV R11D,R8D
MOV word ptr [RSI + R8*0x1 + -0x2],AX
TEST R12D,R12D
JLE 0x00101660
MOVSXD RAX,EBX
LEA RAX,[RDI + RAX*0x8]
MOV dword ptr [RAX],R12D
MOV byte ptr [RAX + 0x4],R15B
TEST EBX,EBX
JZ 0x0010188f
MOV dword ptr [RSP + 0x8],R8D
MOV R9,qword ptr [RSP + 0x10]
MOVSX R13D,R15B
JMP 0x00101751
LAB_00101740:
MOV RAX,qword ptr [RDX]
MOV qword ptr [R11],RAX
MOV dword ptr [RDX],R12D
MOV byte ptr [RDX + 0x4],R15B
TEST EBX,EBX
JZ 0x0010177e
LAB_00101751:
MOVSXD RAX,EBX
MOV R10D,R12D
LEA EBX,[RAX + -0x1]
LEA R11,[RDI + RAX*0x8]
SAR EBX,0x1
MOVSXD RDX,EBX
LEA RDX,[RDI + RDX*0x8]
MOV ESI,dword ptr [RDX]
MOVSX EAX,byte ptr [RDX + 0x4]
SUB R10D,ESI
SUB EAX,R13D
CMP R12D,ESI
CMOVNZ EAX,R10D
TEST EAX,EAX
JG 0x00101740
LAB_0010177e:
MOV R11D,dword ptr [RSP + 0x8]
TEST ECX,ECX
JG 0x00101868
MOV EBX,dword ptr [RSP + 0xc]
ADD R8,0x2
JMP 0x00101675
LAB_00101798:
MOV EDI,0x1
CALL 0x001010f0
MOV R10,RAX
TEST RAX,RAX
JZ 0x001017ad
MOV byte ptr [RAX],0x0
LAB_001017ad:
MOV RAX,qword ptr [RSP + 0xc28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101911
ADD RSP,0xc38
MOV RAX,R10
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001017e0:
MOVSXD RAX,EBX
LEA RAX,[RDI + RAX*0x8]
MOV dword ptr [RAX],ECX
MOV byte ptr [RAX + 0x4],R14B
TEST EBX,EBX
JZ 0x001018ce
LAB_001017f5:
MOVSX ESI,R14B
JMP 0x00101811
LAB_00101800:
MOV RAX,qword ptr [RDX]
MOV qword ptr [RBP],RAX
MOV dword ptr [RDX],ECX
MOV byte ptr [RDX + 0x4],R14B
TEST EBX,EBX
JZ 0x0010183e
LAB_00101811:
MOVSXD RAX,EBX
MOV R10D,ECX
LEA EBX,[RAX + -0x1]
LEA RBP,[RDI + RAX*0x8]
SAR EBX,0x1
MOVSXD RDX,EBX
LEA RDX,[RDI + RDX*0x8]
MOV R9D,dword ptr [RDX]
MOVSX EAX,byte ptr [RDX + 0x4]
SUB R10D,R9D
SUB EAX,ESI
CMP ECX,R9D
CMOVNZ EAX,R10D
TEST EAX,EAX
JG 0x00101800
LAB_0010183e:
MOV EBX,dword ptr [RSP + 0xc]
ADD R8,0x2
CMP EBX,0x1
JG 0x00101675
LAB_0010184f:
MOV R10,qword ptr [RSP + 0x18]
MOVSXD RBP,R11D
ADD RBP,R10
LAB_0010185a:
CMP EBX,0x1
JZ 0x0010189c
LAB_0010185f:
MOV byte ptr [RBP],0x0
JMP 0x001017ad
LAB_00101868:
LEA RAX,[RDI + R9*0x8]
MOV EBX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0xc],EBP
MOV dword ptr [RAX],ECX
MOV byte ptr [RAX + 0x4],R14B
JMP 0x001017f5
LAB_0010187f:
MOVSXD RDI,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV R10,RAX
JMP 0x0010185f
LAB_0010188f:
TEST ECX,ECX
JG 0x001018e0
MOVSXD RBP,R8D
MOV R10,RSI
ADD RBP,RSI
LAB_0010189c:
XOR EDX,EDX
XOR ESI,ESI
MOV qword ptr [RSP],R10
MOVZX EBX,byte ptr [RSP + 0x424]
MOV dword ptr [RSP + 0x8],R11D
CALL 0x00101330
MOV R11D,dword ptr [RSP + 0x8]
MOV R10,qword ptr [RSP]
MOV byte ptr [RBP],BL
LEA EBP,[R11 + 0x1]
MOVSXD RBP,EBP
ADD RBP,R10
JMP 0x0010185f
LAB_001018ce:
MOVSXD RBP,R8D
MOV EBX,dword ptr [RSP + 0xc]
MOV R10,RSI
ADD RBP,RSI
JMP 0x0010185a
LAB_001018e0:
MOV dword ptr [RSP + 0x428],ECX
MOV EBX,0x1
MOV byte ptr [RSP + 0x42c],R14B
MOV dword ptr [RSP + 0xc],0x2
JMP 0x001017f5
LAB_00101901:
MOV RBP,RAX
XOR R11D,R11D
LEA RDI,[RSP + 0x420]
JMP 0x0010189c
LAB_00101911:
CALL 0x001010c0 | int * func0(byte *param_1)
{
int iVar1;
byte *pbVar2;
char cVar3;
char cVar4;
int uVar5;
int2 uVar6;
int iVar7;
int iVar8;
size_t sVar9;
int *puVar10;
long lVar11;
long lVar12;
int iVar13;
int iVar14;
int *puVar15;
int *piVar16;
int8 *puVar17;
int iVar18;
long in_FS_OFFSET;
bool bVar19;
byte bVar20;
int local_c5c;
int local_c48 [254];
int8 local_850;
int8 local_848;
int local_840;
char local_83c;
long local_40;
bVar20 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar9 = strlen((char *)param_1);
iVar7 = (int)sVar9;
if (iVar7 == 0) {
LAB_00101798:
puVar10 = (int *)malloc(1);
if (puVar10 != (int *)0x0) {
*puVar10 = 0;
}
}
else {
piVar16 = local_c48;
for (lVar11 = 0x80; lVar11 != 0; lVar11 = lVar11 + -1) {
piVar16[0] = 0;
piVar16[1] = 0;
piVar16 = piVar16 + ((ulong)bVar20 * -2 + 1) * 2;
}
if (0 < iVar7) {
pbVar2 = param_1 + (ulong)(iVar7 - 1) + 1;
do {
bVar20 = *param_1;
param_1 = param_1 + 1;
local_c48[bVar20] = local_c48[bVar20] + 1;
} while (param_1 != pbVar2);
}
lVar11 = 0;
local_c5c = 0;
do {
iVar13 = local_c48[lVar11];
if (0 < iVar13) {
lVar12 = (long)local_c5c;
local_c5c = local_c5c + 1;
*(int *)(&local_848 + lVar12) = iVar13;
*(char *)((long)&local_848 + lVar12 * 8 + 4) = (char)lVar11;
}
lVar11 = lVar11 + 1;
} while (lVar11 != 0x100);
iVar13 = local_c5c / 2 + -1;
if (-1 < iVar13) {
do {
heapify_down();
bVar19 = iVar13 != 0;
iVar13 = iVar13 + -1;
} while (bVar19);
}
iVar7 = iVar7 + 1;
if (local_c5c < 1) {
puVar15 = (int *)malloc((long)iVar7);
puVar10 = puVar15;
}
else {
iVar13 = (int)local_848;
if (iVar7 < (int)local_848 * 2) goto LAB_00101798;
puVar10 = (int *)malloc((long)iVar7);
if (local_c5c == 1) {
iVar18 = 0;
puVar15 = puVar10;
}
else {
lVar11 = 2;
puVar17 = &local_848;
LAB_0010167f:
iVar7 = local_c5c + -1;
iVar13 = iVar13 + -1;
cVar3 = local_848._4_1_;
local_848 = (&local_850)[local_c5c];
heapify_down();
iVar14 = local_c5c + -2;
cVar4 = local_848._4_1_;
iVar1 = (int)local_848;
uVar6 = CONCAT11(local_848._4_1_,cVar3);
local_848 = (&local_850)[iVar7];
heapify_down();
iVar1 = iVar1 + -1;
iVar18 = (int)lVar11;
*(int2 *)(puVar10 + lVar11 + -2) = uVar6;
if (0 < iVar13) {
*(int *)(puVar17 + iVar14) = iVar13;
*(char *)((long)(puVar17 + iVar14) + 4) = cVar3;
if (iVar14 == 0) {
if (0 < iVar1) {
local_840 = iVar1;
iVar14 = 1;
local_83c = cVar4;
local_c5c = 2;
LAB_001017f5:
do {
lVar12 = (long)iVar14;
iVar14 = iVar14 + -1 >> 1;
piVar16 = (int *)(puVar17 + iVar14);
iVar7 = (int)*(char *)(piVar16 + 1) - (int)cVar4;
if (iVar1 != *piVar16) {
iVar7 = iVar1 - *piVar16;
}
if (iVar7 < 1) break;
puVar17[lVar12] = *(int8 *)piVar16;
*piVar16 = iVar1;
*(char *)(piVar16 + 1) = cVar4;
} while (iVar14 != 0);
goto joined_r0x0010166f;
}
puVar15 = puVar10 + iVar18;
goto LAB_0010189c;
}
do {
lVar12 = (long)iVar14;
iVar14 = iVar14 + -1 >> 1;
piVar16 = (int *)(puVar17 + iVar14);
iVar8 = (int)*(char *)(piVar16 + 1) - (int)cVar3;
if (iVar13 != *piVar16) {
iVar8 = iVar13 - *piVar16;
}
if (iVar8 < 1) break;
puVar17[lVar12] = *(int8 *)piVar16;
*piVar16 = iVar13;
*(char *)(piVar16 + 1) = cVar3;
} while (iVar14 != 0);
if (0 < iVar1) {
*(int *)(puVar17 + iVar7) = iVar1;
*(char *)((long)(puVar17 + iVar7) + 4) = cVar4;
iVar14 = iVar7;
goto LAB_001017f5;
}
LAB_00101675:
local_c5c = iVar7;
lVar11 = lVar11 + 2;
iVar13 = (int)local_848;
goto LAB_0010167f;
}
local_c5c = iVar14;
if (iVar1 < 1) {
joined_r0x0010166f:
iVar7 = local_c5c;
if (iVar7 < 2) goto LAB_0010185a;
goto LAB_00101675;
}
*(int *)(puVar17 + iVar14) = iVar1;
*(char *)((long)(puVar17 + iVar14) + 4) = cVar4;
local_c5c = iVar7;
if (iVar14 != 0) goto LAB_001017f5;
LAB_0010185a:
puVar15 = puVar10 + iVar18;
if (iVar7 != 1) goto LAB_0010185f;
}
LAB_0010189c:
uVar5 = local_848._4_1_;
heapify_down();
*puVar15 = uVar5;
puVar15 = puVar10 + (iVar18 + 1);
}
LAB_0010185f:
*puVar15 = 0;
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar10;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,052 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int num;
int count;
} freq_t;
int compare_freq(const void *a, const void *b) {
freq_t *fa = (freq_t *)a;
freq_t *fb = (freq_t *)b;
return fa->num - fb->num;
}
| freq_t* func0(int nums[][4], int num_lists, int list_size, int *unique_count) {
freq_t *freq = malloc(num_lists * list_size * sizeof(freq_t));
int total = 0;
for(int i = 0; i < num_lists; i++) {
for(int j = 0; j < list_size; j++) {
int found = 0;
for(int k = 0; k < total; k++) {
if(freq[k].num == nums[i][j]) {
freq[k].count++;
found = 1;
break;
}
}
if(!found) {
freq[total].num = nums[i][j];
freq[total].count = 1;
total++;
}
}
}
qsort(freq, total, sizeof(freq_t), compare_freq);
*unique_count = total;
return freq;
}
| int main() {
int unique_count1, unique_count2, unique_count3;
int test1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
freq_t *result1 = func0(test1, 3, 4, &unique_count1);
freq_t expected1[] = {{1,2}, {2,3}, {3,1}, {4,1}, {5,2}, {6,1}, {7,1}, {9,1}};
assert(unique_count1 == 8);
for(int i = 0; i < unique_count1; i++) {
assert(result1[i].num == expected1[i].num);
assert(result1[i].count == expected1[i].count);
}
free(result1);
int test2[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
freq_t *result2 = func0(test2, 3, 4, &unique_count2);
freq_t expected2[] = {{1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}, {11,1}, {12,1}};
assert(unique_count2 == 12);
for(int i = 0; i < unique_count2; i++) {
assert(result2[i].num == expected2[i].num);
assert(result2[i].count == expected2[i].count);
}
free(result2);
int test3[][4] = {{15,20,30,40}, {80,90,100,110}, {30,30,80,90}};
freq_t *result3 = func0(test3, 3, 4, &unique_count3);
freq_t expected3[] = {{15,1}, {20,1}, {30,3}, {40,1}, {80,2}, {90,2}, {100,1}, {110,1}};
assert(unique_count3 == 8);
for(int i = 0; i < unique_count3; i++) {
assert(result3[i].num == expected3[i].num);
assert(result3[i].count == expected3[i].count);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
imul -0x30(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 132f <func0+0x134>
movl $0x0,-0x14(%rbp)
jmpq 131f <func0+0x124>
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 12bc <func0+0xc1>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rcx
mov -0x28(%rbp),%rax
add %rax,%rcx
mov -0x14(%rbp),%eax
cltq
mov (%rcx,%rax,4),%eax
cmp %eax,%edx
jne 12b8 <func0+0xbd>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
add $0x1,%edx
mov %edx,0x4(%rax)
movl $0x1,-0x10(%rbp)
jmp 12c4 <func0+0xc9>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 125d <func0+0x62>
cmpl $0x0,-0x10(%rbp)
jne 131b <func0+0x120>
mov -0x18(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
cltq
mov (%rcx,%rax,4),%eax
mov %eax,(%rdx)
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movl $0x1,0x4(%rax)
addl $0x1,-0x1c(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 124d <func0+0x52>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1241 <func0+0x46>
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x8(%rbp),%rax
lea -0x183(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x38(%rbp),%rax
mov -0x1c(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov eax, [rbp+var_2C]
imul eax, [rbp+var_30]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+base], rax
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp loc_132F
loc_1241:
mov [rbp+var_14], 0
jmp loc_131F
loc_124D:
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_12BC
loc_125D:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
shl rax, 4
mov rcx, rax
mov rax, [rbp+var_28]
add rcx, rax
mov eax, [rbp+var_14]
cdqe
mov eax, [rcx+rax*4]
cmp edx, eax
jnz short loc_12B8
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax+4]
add edx, 1
mov [rax+4], edx
mov [rbp+var_10], 1
jmp short loc_12C4
loc_12B8:
add [rbp+var_C], 1
loc_12BC:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_125D
loc_12C4:
cmp [rbp+var_10], 0
jnz short loc_131B
mov eax, [rbp+var_18]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rdx, rax
mov eax, [rbp+var_14]
cdqe
mov eax, [rcx+rax*4]
mov [rdx], eax
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov dword ptr [rax+4], 1
add [rbp+var_1C], 1
loc_131B:
add [rbp+var_14], 1
loc_131F:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jl loc_124D
add [rbp+var_18], 1
loc_132F:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl loc_1241
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare_freq
mov rcx, rdx; compar
mov edx, 8; size
mov rdi, rax; base
call _qsort
mov rax, [rbp+var_38]
mov edx, [rbp+var_1C]
mov [rax], edx
mov rax, [rbp+base]
leave
retn | _DWORD * func0(long long a1, int a2, int a3, _DWORD *a4)
{
int v7; // [rsp+24h] [rbp-1Ch]
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+30h] [rbp-10h]
int k; // [rsp+34h] [rbp-Ch]
_DWORD *base; // [rsp+38h] [rbp-8h]
base = malloc(8LL * a3 * a2);
v7 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a3; ++j )
{
v10 = 0;
for ( k = 0; k < v7; ++k )
{
if ( base[2 * k] == *(_DWORD *)(a1 + 16LL * i + 4LL * j) )
{
++base[2 * k + 1];
v10 = 1;
break;
}
}
if ( !v10 )
{
base[2 * v7] = *(_DWORD *)(16LL * i + a1 + 4LL * j);
base[2 * v7++ + 1] = 1;
}
}
}
qsort(base, v7, 8uLL, compare_freq);
*a4 = v7;
return base;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RBP + -0x2c]
IMUL EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010132f
LAB_00101241:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010131f
LAB_0010124d:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012bc
LAB_0010125d:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x4
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RCX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV EAX,dword ptr [RCX + RAX*0x4]
CMP EDX,EAX
JNZ 0x001012b8
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
ADD EDX,0x1
MOV dword ptr [RAX + 0x4],EDX
MOV dword ptr [RBP + -0x10],0x1
JMP 0x001012c4
LAB_001012b8:
ADD dword ptr [RBP + -0xc],0x1
LAB_001012bc:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010125d
LAB_001012c4:
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0010131b
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],0x1
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010131b:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010131f:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x0010124d
ADD dword ptr [RBP + -0x18],0x1
LAB_0010132f:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101241
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3,int *param_4)
{
bool bVar1;
void *__base;
int local_24;
int local_20;
int local_1c;
int local_14;
__base = malloc((long)(param_2 * param_3) << 3);
local_24 = 0;
local_20 = 0;
do {
if (param_2 <= local_20) {
qsort(__base,(long)local_24,8,compare_freq);
*param_4 = local_24;
return __base;
}
for (local_1c = 0; local_1c < param_3; local_1c = local_1c + 1) {
bVar1 = false;
for (local_14 = 0; local_14 < local_24; local_14 = local_14 + 1) {
if (*(int *)((long)__base + (long)local_14 * 8) ==
*(int *)((long)local_20 * 0x10 + param_1 + (long)local_1c * 4)) {
*(int *)((long)__base + (long)local_14 * 8 + 4) =
*(int *)((long)__base + (long)local_14 * 8 + 4) + 1;
bVar1 = true;
break;
}
}
if (!bVar1) {
*(int4 *)((long)local_24 * 8 + (long)__base) =
*(int4 *)((long)local_20 * 0x10 + param_1 + (long)local_1c * 4);
*(int4 *)((long)__base + (long)local_24 * 8 + 4) = 1;
local_24 = local_24 + 1;
}
}
local_20 = local_20 + 1;
} while( true );
} |
4,053 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int num;
int count;
} freq_t;
int compare_freq(const void *a, const void *b) {
freq_t *fa = (freq_t *)a;
freq_t *fb = (freq_t *)b;
return fa->num - fb->num;
}
| freq_t* func0(int nums[][4], int num_lists, int list_size, int *unique_count) {
freq_t *freq = malloc(num_lists * list_size * sizeof(freq_t));
int total = 0;
for(int i = 0; i < num_lists; i++) {
for(int j = 0; j < list_size; j++) {
int found = 0;
for(int k = 0; k < total; k++) {
if(freq[k].num == nums[i][j]) {
freq[k].count++;
found = 1;
break;
}
}
if(!found) {
freq[total].num = nums[i][j];
freq[total].count = 1;
total++;
}
}
}
qsort(freq, total, sizeof(freq_t), compare_freq);
*unique_count = total;
return freq;
}
| int main() {
int unique_count1, unique_count2, unique_count3;
int test1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
freq_t *result1 = func0(test1, 3, 4, &unique_count1);
freq_t expected1[] = {{1,2}, {2,3}, {3,1}, {4,1}, {5,2}, {6,1}, {7,1}, {9,1}};
assert(unique_count1 == 8);
for(int i = 0; i < unique_count1; i++) {
assert(result1[i].num == expected1[i].num);
assert(result1[i].count == expected1[i].count);
}
free(result1);
int test2[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
freq_t *result2 = func0(test2, 3, 4, &unique_count2);
freq_t expected2[] = {{1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}, {11,1}, {12,1}};
assert(unique_count2 == 12);
for(int i = 0; i < unique_count2; i++) {
assert(result2[i].num == expected2[i].num);
assert(result2[i].count == expected2[i].count);
}
free(result2);
int test3[][4] = {{15,20,30,40}, {80,90,100,110}, {30,30,80,90}};
freq_t *result3 = func0(test3, 3, 4, &unique_count3);
freq_t expected3[] = {{15,1}, {20,1}, {30,3}, {40,1}, {80,2}, {90,2}, {100,1}, {110,1}};
assert(unique_count3 == 8);
for(int i = 0; i < unique_count3; i++) {
assert(result3[i].num == expected3[i].num);
assert(result3[i].count == expected3[i].count);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %esi,%ebx
mov %edx,%r12d
mov %rcx,%r13
mov %esi,%edi
imul %edx,%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle 127b <func0+0xa9>
mov %r14,%r10
lea -0x1(%rbx),%eax
shl $0x4,%rax
lea 0x10(%r14,%rax,1),%r11
mov $0x0,%ebx
lea 0x8(%rbp),%r9
jmp 126c <func0+0x9a>
addl $0x1,0x4(%rax)
jmp 1239 <func0+0x67>
movslq %ebx,%rax
lea 0x0(%rbp,%rax,8),%rax
mov (%r8,%rdi,4),%edx
mov %edx,(%rax)
movl $0x1,0x4(%rax)
add $0x1,%ebx
add $0x1,%rdi
cmp %edi,%r12d
jle 1263 <func0+0x91>
test %ebx,%ebx
jle 1221 <func0+0x4f>
mov (%r8,%rdi,4),%ecx
mov %rbp,%rax
lea -0x1(%rbx),%edx
lea (%r9,%rdx,8),%rsi
cmp %ecx,(%rax)
je 121b <func0+0x49>
add $0x8,%rax
cmp %rsi,%rax
jne 1254 <func0+0x82>
jmp 1221 <func0+0x4f>
add $0x10,%r10
cmp %r11,%r10
je 1280 <func0+0xae>
test %r12d,%r12d
jle 1263 <func0+0x91>
mov %r10,%r8
mov $0x0,%edi
jmp 1242 <func0+0x70>
mov $0x0,%ebx
movslq %ebx,%rsi
lea -0xc1(%rip),%rcx
mov $0x8,%edx
mov %rbp,%rdi
callq 10a0 <qsort@plt>
mov %ebx,0x0(%r13)
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov ebx, esi
mov r12d, edx
mov r13, rcx
mov edi, esi
imul edi, edx
movsxd rdi, edi
shl rdi, 3
call _malloc
mov rbp, rax
test ebx, ebx
jle short loc_127B
mov r10, r14
lea eax, [rbx-1]
shl rax, 4
lea r11, [r14+rax+10h]
mov ebx, 0
lea r9, [rbp+8]
jmp short loc_126C
loc_121B:
add dword ptr [rax+4], 1
jmp short loc_1239
loc_1221:
movsxd rax, ebx
lea rax, [rbp+rax*8+0]
mov edx, [r8+rdi*4]
mov [rax], edx
mov dword ptr [rax+4], 1
add ebx, 1
loc_1239:
add rdi, 1
cmp r12d, edi
jle short loc_1263
loc_1242:
test ebx, ebx
jle short loc_1221
mov ecx, [r8+rdi*4]
mov rax, rbp
lea edx, [rbx-1]
lea rsi, [r9+rdx*8]
loc_1254:
cmp [rax], ecx
jz short loc_121B
add rax, 8
cmp rax, rsi
jnz short loc_1254
jmp short loc_1221
loc_1263:
add r10, 10h
cmp r10, r11
jz short loc_1280
loc_126C:
test r12d, r12d
jle short loc_1263
mov r8, r10
mov edi, 0
jmp short loc_1242
loc_127B:
mov ebx, 0
loc_1280:
movsxd rsi, ebx
lea rcx, compare_freq
mov edx, 8
mov rdi, rbp
call _qsort
mov [r13+0], ebx
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, int a2, int a3, int *a4)
{
long long v6; // rbp
long long v7; // r8
long long v8; // r10
long long v9; // r11
int v10; // ebx
_DWORD *v11; // rax
long long v12; // rdi
_DWORD *v13; // rax
v6 = malloc(8LL * a3 * a2);
if ( a2 <= 0 )
{
v10 = 0;
}
else
{
v8 = a1;
v9 = a1 + 16LL * (unsigned int)(a2 - 1) + 16;
v10 = 0;
do
{
if ( a3 > 0 )
{
v7 = v8;
v12 = 0LL;
do
{
if ( v10 <= 0 )
{
LABEL_4:
v11 = (_DWORD *)(v6 + 8LL * v10);
*v11 = *(_DWORD *)(v8 + 4 * v12);
v11[1] = 1;
++v10;
}
else
{
v13 = (_DWORD *)v6;
while ( *v13 != *(_DWORD *)(v8 + 4 * v12) )
{
v13 += 2;
if ( v13 == (_DWORD *)(v6 + 8 + 8LL * (unsigned int)(v10 - 1)) )
goto LABEL_4;
}
++v13[1];
}
++v12;
}
while ( a3 > (int)v12 );
}
v8 += 16LL;
}
while ( v8 != v9 );
}
qsort(v6, v10, 8LL, compare_freq, v7);
*a4 = v10;
return v6;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV EBX,ESI
MOV R12D,EDX
MOV R13,RCX
MOV EDI,ESI
IMUL EDI,EDX
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x001010d0
MOV RBP,RAX
TEST EBX,EBX
JLE 0x0010127b
MOV R10,R14
LEA EAX,[RBX + -0x1]
SHL RAX,0x4
LEA R11,[R14 + RAX*0x1 + 0x10]
MOV EBX,0x0
LEA R9,[RBP + 0x8]
JMP 0x0010126c
LAB_0010121b:
ADD dword ptr [RAX + 0x4],0x1
JMP 0x00101239
LAB_00101221:
MOVSXD RAX,EBX
LEA RAX,[RBP + RAX*0x8]
MOV EDX,dword ptr [R8 + RDI*0x4]
MOV dword ptr [RAX],EDX
MOV dword ptr [RAX + 0x4],0x1
ADD EBX,0x1
LAB_00101239:
ADD RDI,0x1
CMP R12D,EDI
JLE 0x00101263
LAB_00101242:
TEST EBX,EBX
JLE 0x00101221
MOV ECX,dword ptr [R8 + RDI*0x4]
MOV RAX,RBP
LEA EDX,[RBX + -0x1]
LEA RSI,[R9 + RDX*0x8]
LAB_00101254:
CMP dword ptr [RAX],ECX
JZ 0x0010121b
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x00101254
JMP 0x00101221
LAB_00101263:
ADD R10,0x10
CMP R10,R11
JZ 0x00101280
LAB_0010126c:
TEST R12D,R12D
JLE 0x00101263
MOV R8,R10
MOV EDI,0x0
JMP 0x00101242
LAB_0010127b:
MOV EBX,0x0
LAB_00101280:
MOVSXD RSI,EBX
LEA RCX,[0x1011c9]
MOV EDX,0x8
MOV RDI,RBP
CALL 0x001010a0
MOV dword ptr [R13],EBX
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int * func0(long param_1,int param_2,int param_3,int *param_4)
{
long lVar1;
int *__base;
int *piVar2;
int iVar3;
long lVar4;
__base = (int *)malloc((long)(param_2 * param_3) << 3);
if (param_2 < 1) {
iVar3 = 0;
}
else {
lVar1 = param_1 + 0x10;
iVar3 = 0;
do {
if (0 < param_3) {
lVar4 = 0;
do {
if (0 < iVar3) {
piVar2 = __base;
do {
if (*piVar2 == *(int *)(param_1 + lVar4 * 4)) {
piVar2[1] = piVar2[1] + 1;
goto LAB_00101239;
}
piVar2 = piVar2 + 2;
} while (piVar2 != __base + (ulong)(iVar3 - 1) * 2 + 2);
}
__base[(long)iVar3 * 2] = *(int *)(param_1 + lVar4 * 4);
(__base + (long)iVar3 * 2)[1] = 1;
iVar3 = iVar3 + 1;
LAB_00101239:
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_3);
}
param_1 = param_1 + 0x10;
} while (param_1 != lVar1 + (ulong)(param_2 - 1) * 0x10);
}
qsort(__base,(long)iVar3,8,compare_freq);
*param_4 = iVar3;
return __base;
} |
4,054 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int num;
int count;
} freq_t;
int compare_freq(const void *a, const void *b) {
freq_t *fa = (freq_t *)a;
freq_t *fb = (freq_t *)b;
return fa->num - fb->num;
}
| freq_t* func0(int nums[][4], int num_lists, int list_size, int *unique_count) {
freq_t *freq = malloc(num_lists * list_size * sizeof(freq_t));
int total = 0;
for(int i = 0; i < num_lists; i++) {
for(int j = 0; j < list_size; j++) {
int found = 0;
for(int k = 0; k < total; k++) {
if(freq[k].num == nums[i][j]) {
freq[k].count++;
found = 1;
break;
}
}
if(!found) {
freq[total].num = nums[i][j];
freq[total].count = 1;
total++;
}
}
}
qsort(freq, total, sizeof(freq_t), compare_freq);
*unique_count = total;
return freq;
}
| int main() {
int unique_count1, unique_count2, unique_count3;
int test1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
freq_t *result1 = func0(test1, 3, 4, &unique_count1);
freq_t expected1[] = {{1,2}, {2,3}, {3,1}, {4,1}, {5,2}, {6,1}, {7,1}, {9,1}};
assert(unique_count1 == 8);
for(int i = 0; i < unique_count1; i++) {
assert(result1[i].num == expected1[i].num);
assert(result1[i].count == expected1[i].count);
}
free(result1);
int test2[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
freq_t *result2 = func0(test2, 3, 4, &unique_count2);
freq_t expected2[] = {{1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}, {11,1}, {12,1}};
assert(unique_count2 == 12);
for(int i = 0; i < unique_count2; i++) {
assert(result2[i].num == expected2[i].num);
assert(result2[i].count == expected2[i].count);
}
free(result2);
int test3[][4] = {{15,20,30,40}, {80,90,100,110}, {30,30,80,90}};
freq_t *result3 = func0(test3, 3, 4, &unique_count3);
freq_t expected3[] = {{15,1}, {20,1}, {30,3}, {40,1}, {80,2}, {90,2}, {100,1}, {110,1}};
assert(unique_count3 == 8);
for(int i = 0; i < unique_count3; i++) {
assert(result3[i].num == expected3[i].num);
assert(result3[i].count == expected3[i].count);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
mov %rdi,%r14
mov %esi,%edi
imul %edx,%edi
push %r13
mov %edx,%r13d
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
movslq %edi,%rdi
mov %esi,%ebx
shl $0x3,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 17e5 <func0+0xe5>
lea -0x1(%r13),%r9d
lea -0x1(%rbx),%eax
xor %ebx,%ebx
lea (%r9,%rax,4),%rax
lea 0x4(%r14,%r9,4),%rdi
not %r9
lea 0x14(%r14,%rax,4),%r10
shl $0x2,%r9
lea 0x8(%r12),%r8
nopw %cs:0x0(%rax,%rax,1)
test %r13d,%r13d
jle 179a <func0+0x9a>
lea (%r9,%rdi,1),%rsi
mov (%rsi),%edx
test %ebx,%ebx
je 17d0 <func0+0xd0>
lea -0x1(%rbx),%ecx
mov %r12,%rax
lea (%r8,%rcx,8),%rcx
jmp 1789 <func0+0x89>
nopl 0x0(%rax,%rax,1)
add $0x8,%rax
cmp %rax,%rcx
je 17d0 <func0+0xd0>
cmp %edx,(%rax)
jne 1780 <func0+0x80>
addl $0x1,0x4(%rax)
add $0x4,%rsi
cmp %rdi,%rsi
jne 1769 <func0+0x69>
add $0x10,%rdi
cmp %r10,%rdi
jne 1760 <func0+0x60>
movslq %ebx,%rsi
mov %r12,%rdi
lea -0xc0(%rip),%rcx
mov $0x8,%edx
callq 10a0 <qsort@plt>
mov %ebx,0x0(%rbp)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
movslq %ebx,%rax
add $0x1,%ebx
lea (%r12,%rax,8),%rax
mov %edx,(%rax)
movl $0x1,0x4(%rax)
jmp 1791 <func0+0x91>
xor %esi,%esi
xor %ebx,%ebx
jmp 17a6 <func0+0xa6>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov r14, rdi
mov edi, esi
imul edi, edx
push r13
mov r13d, edx
push r12
push rbp
mov rbp, rcx
push rbx
movsxd rdi, edi
mov ebx, esi
shl rdi, 3
call _malloc
mov r12, rax
test ebx, ebx
jle loc_17ED
lea edx, [r13-1]
lea ecx, [rbx-1]
xor ebx, ebx
mov r10, 0FFFFFFFFFFFFFFFCh
lea rax, ds:0[rdx*4]
lea rdx, [rdx+rcx*4]
lea rdi, [r14+rax+4]
lea r9, [r14+rdx*4+14h]
sub r10, rax
lea r8, [r12+8]
nop dword ptr [rax+00000000h]
loc_1768:
test r13d, r13d
jle short loc_17A2
lea rsi, [r10+rdi]
loc_1771:
mov edx, [rsi]
test ebx, ebx
jz short loc_17D8
lea ecx, [rbx-1]
mov rax, r12
lea rcx, [r8+rcx*8]
jmp short loc_1791
loc_1788:
add rax, 8
cmp rax, rcx
jz short loc_17D8
loc_1791:
cmp [rax], edx
jnz short loc_1788
add dword ptr [rax+4], 1
loc_1799:
add rsi, 4
cmp rsi, rdi
jnz short loc_1771
loc_17A2:
add rdi, 10h
cmp rdi, r9
jnz short loc_1768
movsxd rsi, ebx
loc_17AE:
mov rdi, r12
lea rcx, compare_freq
mov edx, 8
call _qsort
mov [rbp+0], ebx
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17D8:
movsxd rax, ebx
add ebx, 1
lea rax, [r12+rax*8]
mov [rax], edx
mov dword ptr [rax+4], 1
jmp short loc_1799
loc_17ED:
xor esi, esi
xor ebx, ebx
jmp short loc_17AE | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
long long v7; // r8
long long v8; // r12
long long v9; // rdx
int v10; // ebx
long long v11; // rdi
long long v12; // r9
long long v13; // r10
int *v14; // rsi
int v15; // edx
_DWORD *v16; // rax
long long v17; // rsi
long long v19; // rax
_DWORD *v20; // rax
v8 = malloc(8LL * a3 * a2);
if ( a2 <= 0 )
{
v17 = 0LL;
v10 = 0;
}
else
{
v9 = (unsigned int)(a3 - 1);
v10 = 0;
v11 = a1 + 4 * v9 + 4;
v12 = a1 + 4 * (v9 + 4LL * (unsigned int)(a2 - 1)) + 20;
v13 = -4 - 4 * v9;
v7 = v8 + 8;
do
{
if ( a3 > 0 )
{
v14 = (int *)(v13 + v11);
do
{
v15 = *v14;
if ( v10 )
{
v16 = (_DWORD *)v8;
while ( *v16 != v15 )
{
v16 += 2;
if ( v16 == (_DWORD *)(v7 + 8LL * (unsigned int)(v10 - 1)) )
goto LABEL_14;
}
++v16[1];
}
else
{
LABEL_14:
v19 = v10++;
v20 = (_DWORD *)(v8 + 8 * v19);
*v20 = v15;
v20[1] = 1;
}
++v14;
}
while ( v14 != (int *)v11 );
}
v11 += 16LL;
}
while ( v11 != v12 );
v17 = v10;
}
qsort(v8, v17, 8LL, compare_freq, v7);
*a4 = v10;
return v8;
} | func0:
ENDBR64
PUSH R14
MOV R14,RDI
MOV EDI,ESI
IMUL EDI,EDX
PUSH R13
MOV R13D,EDX
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOVSXD RDI,EDI
MOV EBX,ESI
SHL RDI,0x3
CALL 0x001010d0
MOV R12,RAX
TEST EBX,EBX
JLE 0x001017ed
LEA EDX,[R13 + -0x1]
LEA ECX,[RBX + -0x1]
XOR EBX,EBX
MOV R10,-0x4
LEA RAX,[RDX*0x4]
LEA RDX,[RDX + RCX*0x4]
LEA RDI,[R14 + RAX*0x1 + 0x4]
LEA R9,[R14 + RDX*0x4 + 0x14]
SUB R10,RAX
LEA R8,[R12 + 0x8]
NOP dword ptr [RAX]
LAB_00101768:
TEST R13D,R13D
JLE 0x001017a2
LEA RSI,[R10 + RDI*0x1]
LAB_00101771:
MOV EDX,dword ptr [RSI]
TEST EBX,EBX
JZ 0x001017d8
LEA ECX,[RBX + -0x1]
MOV RAX,R12
LEA RCX,[R8 + RCX*0x8]
JMP 0x00101791
LAB_00101788:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x001017d8
LAB_00101791:
CMP dword ptr [RAX],EDX
JNZ 0x00101788
ADD dword ptr [RAX + 0x4],0x1
LAB_00101799:
ADD RSI,0x4
CMP RSI,RDI
JNZ 0x00101771
LAB_001017a2:
ADD RDI,0x10
CMP RDI,R9
JNZ 0x00101768
MOVSXD RSI,EBX
LAB_001017ae:
MOV RDI,R12
LEA RCX,[0x1016f0]
MOV EDX,0x8
CALL 0x001010a0
MOV dword ptr [RBP],EBX
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017d8:
MOVSXD RAX,EBX
ADD EBX,0x1
LEA RAX,[R12 + RAX*0x8]
MOV dword ptr [RAX],EDX
MOV dword ptr [RAX + 0x4],0x1
JMP 0x00101799
LAB_001017ed:
XOR ESI,ESI
XOR EBX,EBX
JMP 0x001017ae | int * func0(long param_1,int param_2,int param_3,int *param_4)
{
int *__base;
int *piVar1;
long lVar2;
ulong uVar3;
int iVar4;
int *piVar5;
size_t __nmemb;
int *piVar6;
__base = (int *)malloc((long)(param_2 * param_3) << 3);
if (param_2 < 1) {
__nmemb = 0;
iVar4 = 0;
}
else {
uVar3 = (ulong)(param_3 - 1);
iVar4 = 0;
piVar6 = (int *)(param_1 + 4 + uVar3 * 4);
do {
if (0 < param_3) {
piVar5 = piVar6 + (-1 - uVar3);
do {
if (iVar4 != 0) {
piVar1 = __base;
do {
if (*piVar1 == *piVar5) {
piVar1[1] = piVar1[1] + 1;
goto LAB_00101799;
}
piVar1 = piVar1 + 2;
} while (piVar1 != __base + (ulong)(iVar4 - 1) * 2 + 2);
}
lVar2 = (long)iVar4;
iVar4 = iVar4 + 1;
__base[lVar2 * 2] = *piVar5;
(__base + lVar2 * 2)[1] = 1;
LAB_00101799:
piVar5 = piVar5 + 1;
} while (piVar5 != piVar6);
}
piVar6 = piVar6 + 4;
} while (piVar6 != (int *)(param_1 + 0x14 + (uVar3 + (ulong)(param_2 - 1) * 4) * 4));
__nmemb = (size_t)iVar4;
}
qsort(__base,__nmemb,8,compare_freq);
*param_4 = iVar4;
return __base;
} |
4,055 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int num;
int count;
} freq_t;
int compare_freq(const void *a, const void *b) {
freq_t *fa = (freq_t *)a;
freq_t *fb = (freq_t *)b;
return fa->num - fb->num;
}
| freq_t* func0(int nums[][4], int num_lists, int list_size, int *unique_count) {
freq_t *freq = malloc(num_lists * list_size * sizeof(freq_t));
int total = 0;
for(int i = 0; i < num_lists; i++) {
for(int j = 0; j < list_size; j++) {
int found = 0;
for(int k = 0; k < total; k++) {
if(freq[k].num == nums[i][j]) {
freq[k].count++;
found = 1;
break;
}
}
if(!found) {
freq[total].num = nums[i][j];
freq[total].count = 1;
total++;
}
}
}
qsort(freq, total, sizeof(freq_t), compare_freq);
*unique_count = total;
return freq;
}
| int main() {
int unique_count1, unique_count2, unique_count3;
int test1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
freq_t *result1 = func0(test1, 3, 4, &unique_count1);
freq_t expected1[] = {{1,2}, {2,3}, {3,1}, {4,1}, {5,2}, {6,1}, {7,1}, {9,1}};
assert(unique_count1 == 8);
for(int i = 0; i < unique_count1; i++) {
assert(result1[i].num == expected1[i].num);
assert(result1[i].count == expected1[i].count);
}
free(result1);
int test2[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
freq_t *result2 = func0(test2, 3, 4, &unique_count2);
freq_t expected2[] = {{1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}, {11,1}, {12,1}};
assert(unique_count2 == 12);
for(int i = 0; i < unique_count2; i++) {
assert(result2[i].num == expected2[i].num);
assert(result2[i].count == expected2[i].count);
}
free(result2);
int test3[][4] = {{15,20,30,40}, {80,90,100,110}, {30,30,80,90}};
freq_t *result3 = func0(test3, 3, 4, &unique_count3);
freq_t expected3[] = {{15,1}, {20,1}, {30,3}, {40,1}, {80,2}, {90,2}, {100,1}, {110,1}};
assert(unique_count3 == 8);
for(int i = 0; i < unique_count3; i++) {
assert(result3[i].num == expected3[i].num);
assert(result3[i].count == expected3[i].count);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
mov %rdi,%r14
mov %esi,%edi
imul %edx,%edi
push %r13
mov %edx,%r13d
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
movslq %edi,%rdi
mov %esi,%ebx
shl $0x3,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1985 <func0+0xe5>
lea -0x1(%r13),%r9d
lea -0x1(%rbx),%eax
xor %ebx,%ebx
lea (%r9,%rax,4),%rax
lea 0x4(%r14,%r9,4),%rdi
not %r9
lea 0x14(%r14,%rax,4),%r10
shl $0x2,%r9
lea 0x8(%r12),%r8
nopw %cs:0x0(%rax,%rax,1)
test %r13d,%r13d
jle 193a <func0+0x9a>
lea (%r9,%rdi,1),%rsi
mov (%rsi),%edx
test %ebx,%ebx
je 1970 <func0+0xd0>
lea -0x1(%rbx),%ecx
mov %r12,%rax
lea (%r8,%rcx,8),%rcx
jmp 1929 <func0+0x89>
nopl 0x0(%rax,%rax,1)
add $0x8,%rax
cmp %rcx,%rax
je 1970 <func0+0xd0>
cmp %edx,(%rax)
jne 1920 <func0+0x80>
addl $0x1,0x4(%rax)
add $0x4,%rsi
cmp %rdi,%rsi
jne 1909 <func0+0x69>
add $0x10,%rdi
cmp %r10,%rdi
jne 1900 <func0+0x60>
movslq %ebx,%rsi
mov %r12,%rdi
lea -0xc0(%rip),%rcx
mov $0x8,%edx
callq 10a0 <qsort@plt>
mov %ebx,0x0(%rbp)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
movslq %ebx,%rax
add $0x1,%ebx
lea (%r12,%rax,8),%rax
mov %edx,(%rax)
movl $0x1,0x4(%rax)
jmp 1931 <func0+0x91>
xor %esi,%esi
xor %ebx,%ebx
jmp 1946 <func0+0xa6>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov r14, rdi
push r13
mov r13d, edx
push r12
movsxd r12, esi
mov edi, r12d
push rbp
mov rbp, rcx
imul edi, edx
push rbx
movsxd rdi, edi
shl rdi, 3; size
call _malloc
mov rbx, rax
test r12d, r12d
jle loc_1762
movsxd rax, r13d
xor esi, esi; nmemb
lea r10, ds:0[rax*4]
lea rax, [rax+r12*4]
xor r12d, r12d
lea r8, [r10+r14]
lea r9, [r14+rax*4]
nop word ptr [rax+rax+00h]
loc_16B8:
test r13d, r13d
jle short loc_1720
loc_16BD:
mov rdi, r8
sub rdi, r10
loc_16C3:
mov edx, [rdi]
lea rcx, [rbx+rsi*8]
test r12d, r12d
jle short loc_1700
loc_16CE:
mov rax, rbx
jmp short loc_16E1
loc_16D8:
add rax, 8
cmp rax, rcx
jz short loc_1700
loc_16E1:
cmp [rax], edx
jnz short loc_16D8
add rdi, 4
add dword ptr [rax+4], 1
cmp rdi, r8
jz short loc_1720
mov edx, [rdi]
jmp short loc_16CE
loc_1700:
lea rax, [rbx+rsi*8]
add rdi, 4
add r12d, 1
mov [rax], edx
mov dword ptr [rax+4], 1
cmp rdi, r8
jz short loc_1750
movsxd rsi, r12d
jmp short loc_16C3
loc_1720:
add r8, 10h
cmp r8, r9
jnz short loc_16B8
loc_1729:
mov rdi, rbx; base
lea rcx, compare_freq; compar
mov edx, 8; size
call _qsort
mov [rbp+0], r12d
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1750:
lea r8, [rdi+10h]
movsxd rsi, r12d
cmp r8, r9
jnz loc_16BD
jmp short loc_1729
loc_1762:
xor esi, esi
xor r12d, r12d
jmp short loc_1729 | _DWORD * func0(long long a1, int a2, int a3, int *a4)
{
long long v5; // r12
_DWORD *v7; // rbx
size_t v8; // rsi
long long v9; // r10
long long v10; // rax
int v11; // r12d
int *v12; // r8
int *v13; // r9
int *v14; // rdi
int v15; // edx
_DWORD *v16; // rax
_DWORD *v17; // rax
v5 = a2;
v7 = malloc(8LL * a3 * a2);
if ( a2 <= 0 )
{
v8 = 0LL;
v11 = 0;
}
else
{
v8 = 0LL;
v9 = 4LL * a3;
v10 = a3 + 4 * v5;
v11 = 0;
v12 = (int *)(v9 + a1);
v13 = (int *)(a1 + 4 * v10);
while ( a3 <= 0 )
{
LABEL_13:
v12 += 4;
if ( v12 == v13 )
goto LABEL_14;
}
while ( 2 )
{
v14 = &v12[v9 / 0xFFFFFFFFFFFFFFFCLL];
while ( 1 )
{
v15 = *v14;
if ( v11 > 0 )
{
while ( 1 )
{
v16 = v7;
while ( *v16 != v15 )
{
v16 += 2;
if ( v16 == &v7[2 * v8] )
goto LABEL_11;
}
++v14;
++v16[1];
if ( v14 == v12 )
goto LABEL_13;
v15 = *v14;
}
}
LABEL_11:
v17 = &v7[2 * v8];
++v14;
++v11;
*v17 = v15;
v17[1] = 1;
if ( v14 == v12 )
break;
v8 = v11;
}
v12 = v14 + 4;
v8 = v11;
if ( v14 + 4 != v13 )
continue;
break;
}
}
LABEL_14:
qsort(v7, v8, 8uLL, compare_freq);
*a4 = v11;
return v7;
} | func0:
ENDBR64
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13D,EDX
PUSH R12
MOVSXD R12,ESI
MOV EDI,R12D
PUSH RBP
MOV RBP,RCX
IMUL EDI,EDX
PUSH RBX
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x001010d0
MOV RBX,RAX
TEST R12D,R12D
JLE 0x00101762
MOVSXD RAX,R13D
XOR ESI,ESI
LEA R10,[RAX*0x4]
LEA RAX,[RAX + R12*0x4]
XOR R12D,R12D
LEA R8,[R10 + R14*0x1]
LEA R9,[R14 + RAX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001016b8:
TEST R13D,R13D
JLE 0x00101720
LAB_001016bd:
MOV RDI,R8
SUB RDI,R10
LAB_001016c3:
MOV EDX,dword ptr [RDI]
LEA RCX,[RBX + RSI*0x8]
TEST R12D,R12D
JLE 0x00101700
LAB_001016ce:
MOV RAX,RBX
JMP 0x001016e1
LAB_001016d8:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x00101700
LAB_001016e1:
CMP dword ptr [RAX],EDX
JNZ 0x001016d8
ADD RDI,0x4
ADD dword ptr [RAX + 0x4],0x1
CMP RDI,R8
JZ 0x00101720
MOV EDX,dword ptr [RDI]
JMP 0x001016ce
LAB_00101700:
LEA RAX,[RBX + RSI*0x8]
ADD RDI,0x4
ADD R12D,0x1
MOV dword ptr [RAX],EDX
MOV dword ptr [RAX + 0x4],0x1
CMP RDI,R8
JZ 0x00101750
MOVSXD RSI,R12D
JMP 0x001016c3
LAB_00101720:
ADD R8,0x10
CMP R8,R9
JNZ 0x001016b8
LAB_00101729:
MOV RDI,RBX
LEA RCX,[0x101650]
MOV EDX,0x8
CALL 0x001010a0
MOV dword ptr [RBP],R12D
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101750:
LEA R8,[RDI + 0x10]
MOVSXD RSI,R12D
CMP R8,R9
JNZ 0x001016bd
JMP 0x00101729
LAB_00101762:
XOR ESI,ESI
XOR R12D,R12D
JMP 0x00101729 | int * func0(long param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
int *__base;
long lVar2;
int *piVar3;
int iVar4;
size_t __nmemb;
int *piVar5;
int *piVar6;
int iVar7;
__base = (int *)malloc((long)(param_2 * param_3) << 3);
if (param_2 < 1) {
__nmemb = 0;
iVar7 = 0;
}
else {
lVar2 = (long)param_3;
__nmemb = 0;
iVar7 = 0;
piVar6 = (int *)(lVar2 * 4 + param_1);
piVar1 = (int *)(param_1 + (lVar2 + (long)param_2 * 4) * 4);
do {
if (0 < param_3) {
do {
piVar5 = piVar6 + -lVar2;
while( true ) {
iVar4 = *piVar5;
piVar3 = __base;
if (0 < iVar7) {
do {
while (*piVar3 == iVar4) {
piVar5 = piVar5 + 1;
piVar3[1] = piVar3[1] + 1;
if (piVar5 == piVar6) goto LAB_00101720;
piVar3 = __base;
iVar4 = *piVar5;
}
piVar3 = piVar3 + 2;
} while (piVar3 != __base + __nmemb * 2);
}
iVar7 = iVar7 + 1;
__base[__nmemb * 2] = iVar4;
(__base + __nmemb * 2)[1] = 1;
if (piVar5 + 1 == piVar6) break;
__nmemb = (size_t)iVar7;
piVar5 = piVar5 + 1;
}
piVar6 = piVar5 + 5;
__nmemb = (size_t)iVar7;
} while (piVar6 != piVar1);
break;
}
LAB_00101720:
piVar6 = piVar6 + 4;
} while (piVar6 != piVar1);
}
qsort(__base,__nmemb,8,compare_freq);
*param_4 = iVar7;
return __base;
} |
4,056 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int *func0(int *nums, int length, int *output_length) {
int *even_nums = malloc(length * sizeof(int));
int count = 0;
for (int i = 0; i < length; i++) {
if (nums[i] % 2 == 0) {
even_nums[count++] = nums[i];
}
}
*output_length = count;
return even_nums;
}
| int main() {
int output_length;
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int expected1[] = {2, 4, 6, 8, 10};
int *result1 = func0(nums1, 10, &output_length);
assert(output_length == 5);
for (int i = 0; i < output_length; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int nums2[] = {10, 20, 45, 67, 84, 93};
int expected2[] = {10, 20, 84};
int *result2 = func0(nums2, 6, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int nums3[] = {5, 7, 9, 8, 6, 4, 3};
int expected3[] = {8, 6, 4};
int *result3 = func0(nums3, 7, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1259 <func0+0x90>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 1255 <func0+0x8c>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1205 <func0+0x3c>
mov -0x28(%rbp),%rax
mov -0x10(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_1259
loc_1205:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_1255
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1255:
add [rbp+var_C], 1
loc_1259:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_1205
mov rax, [rbp+var_28]
mov edx, [rbp+var_10]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v8; // [rsp+28h] [rbp-8h]
v8 = malloc(4LL * a2);
v6 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
{
v3 = v6++;
v8[v3] = *(_DWORD *)(4LL * i + a1);
}
}
*a3 = v6;
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101259
LAB_00101205:
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]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101255
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101255:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101259:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101205
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if ((*(uint *)(param_1 + (long)local_14 * 4) & 1) == 0) {
*(int4 *)((long)local_18 * 4 + (long)pvVar1) =
*(int4 *)((long)local_14 * 4 + param_1);
local_18 = local_18 + 1;
}
}
*param_3 = local_18;
return pvVar1;
} |
4,057 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int *func0(int *nums, int length, int *output_length) {
int *even_nums = malloc(length * sizeof(int));
int count = 0;
for (int i = 0; i < length; i++) {
if (nums[i] % 2 == 0) {
even_nums[count++] = nums[i];
}
}
*output_length = count;
return even_nums;
}
| int main() {
int output_length;
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int expected1[] = {2, 4, 6, 8, 10};
int *result1 = func0(nums1, 10, &output_length);
assert(output_length == 5);
for (int i = 0; i < output_length; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int nums2[] = {10, 20, 45, 67, 84, 93};
int expected2[] = {10, 20, 84};
int *result2 = func0(nums2, 6, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int nums3[] = {5, 7, 9, 8, 6, 4, 3};
int expected3[] = {8, 6, 4};
int *result3 = func0(nums3, 7, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1217 <func0+0x4e>
mov %r12,%rdx
lea -0x1(%rbp),%ecx
lea 0x4(%r12,%rcx,4),%rdi
mov $0x0,%esi
jmp 1204 <func0+0x3b>
add $0x4,%rdx
cmp %rdi,%rdx
je 121c <func0+0x53>
mov (%rdx),%ecx
test $0x1,%cl
jne 11fb <func0+0x32>
movslq %esi,%r8
mov %ecx,(%rax,%r8,4)
lea 0x1(%rsi),%esi
jmp 11fb <func0+0x32>
mov $0x0,%esi
mov %esi,(%rbx)
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov ebp, esi
mov rbx, rdx
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_1217
mov rdx, r12
lea ecx, [rbp-1]
lea rdi, [r12+rcx*4+4]
mov esi, 0
jmp short loc_1204
loc_11FB:
add rdx, 4
cmp rdx, rdi
jz short loc_121C
loc_1204:
mov ecx, [rdx]
test cl, 1
jnz short loc_11FB
movsxd r8, esi
mov [rax+r8*4], ecx
lea esi, [rsi+1]
jmp short loc_11FB
loc_1217:
mov esi, 0
loc_121C:
mov [rbx], esi
pop rbx
pop rbp
pop r12
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3)
{
long long result; // rax
_DWORD *v6; // rdx
int v7; // esi
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( (*v6 & 1) == 0 )
*(_DWORD *)(result + 4LL * v7++) = *v6;
++v6;
}
while ( v6 != &a1[a2 - 1 + 1] );
}
*a3 = v7;
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV EBP,ESI
MOV RBX,RDX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010d0
TEST EBP,EBP
JLE 0x00101217
MOV RDX,R12
LEA ECX,[RBP + -0x1]
LEA RDI,[R12 + RCX*0x4 + 0x4]
MOV ESI,0x0
JMP 0x00101204
LAB_001011fb:
ADD RDX,0x4
CMP RDX,RDI
JZ 0x0010121c
LAB_00101204:
MOV ECX,dword ptr [RDX]
TEST CL,0x1
JNZ 0x001011fb
MOVSXD R8,ESI
MOV dword ptr [RAX + R8*0x4],ECX
LEA ESI,[RSI + 0x1]
JMP 0x001011fb
LAB_00101217:
MOV ESI,0x0
LAB_0010121c:
MOV dword ptr [RBX],ESI
POP RBX
POP RBP
POP R12
RET | void func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
void *pvVar2;
int iVar3;
pvVar2 = malloc((long)param_2 << 2);
if (param_2 < 1) {
iVar3 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
if ((*param_1 & 1) == 0) {
*(uint *)((long)pvVar2 + (long)iVar3 * 4) = *param_1;
iVar3 = iVar3 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
*param_3 = iVar3;
return;
} |
4,058 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int *func0(int *nums, int length, int *output_length) {
int *even_nums = malloc(length * sizeof(int));
int count = 0;
for (int i = 0; i < length; i++) {
if (nums[i] % 2 == 0) {
even_nums[count++] = nums[i];
}
}
*output_length = count;
return even_nums;
}
| int main() {
int output_length;
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int expected1[] = {2, 4, 6, 8, 10};
int *result1 = func0(nums1, 10, &output_length);
assert(output_length == 5);
for (int i = 0; i < output_length; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int nums2[] = {10, 20, 45, 67, 84, 93};
int expected2[] = {10, 20, 84};
int *result2 = func0(nums2, 6, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int nums3[] = {5, 7, 9, 8, 6, 4, 3};
int expected3[] = {8, 6, 4};
int *result3 = func0(nums3, 7, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 14d8 <func0+0x58>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x4(%rbx,%rdx,4),%r8
xchg %ax,%ax
mov (%rdi),%ecx
test $0x1,%cl
jne 14c1 <func0+0x41>
movslq %esi,%r9
add $0x1,%esi
mov %ecx,(%rax,%r9,4)
add $0x4,%rdi
cmp %r8,%rdi
jne 14b0 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_14D8
lea edx, [rbp-1]
mov rcx, rbx
xor edi, edi
lea r8, [rbx+rdx*4+4]
xchg ax, ax
loc_14B0:
mov esi, [rcx]
test sil, 1
jnz short loc_14C2
movsxd r9, edi
add edi, 1
mov [rax+r9*4], esi
loc_14C2:
add rcx, 4
cmp rcx, r8
jnz short loc_14B0
pop rbx
pop rbp
mov [r12], edi
pop r12
retn
loc_14D8:
xor edi, edi
pop rbx
pop rbp
mov [r12], edi
pop r12
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3)
{
long long result; // rax
_DWORD *v6; // rcx
int v7; // edi
long long v8; // r9
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( (*v6 & 1) == 0 )
{
v8 = v7++;
*(_DWORD *)(result + 4 * v8) = *v6;
}
++v6;
}
while ( v6 != &a1[a2 - 1 + 1] );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
CALL 0x001010d0
TEST EBP,EBP
JLE 0x001014d8
LEA EDX,[RBP + -0x1]
MOV RCX,RBX
XOR EDI,EDI
LEA R8,[RBX + RDX*0x4 + 0x4]
NOP
LAB_001014b0:
MOV ESI,dword ptr [RCX]
TEST SIL,0x1
JNZ 0x001014c2
MOVSXD R9,EDI
ADD EDI,0x1
MOV dword ptr [RAX + R9*0x4],ESI
LAB_001014c2:
ADD RCX,0x4
CMP RCX,R8
JNZ 0x001014b0
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET
LAB_001014d8:
XOR EDI,EDI
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET | void func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 << 2);
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) == 0) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(uint *)((long)pvVar2 + lVar4 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_3 = iVar3;
return;
}
*param_3 = 0;
return;
} |
4,059 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int *func0(int *nums, int length, int *output_length) {
int *even_nums = malloc(length * sizeof(int));
int count = 0;
for (int i = 0; i < length; i++) {
if (nums[i] % 2 == 0) {
even_nums[count++] = nums[i];
}
}
*output_length = count;
return even_nums;
}
| int main() {
int output_length;
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int expected1[] = {2, 4, 6, 8, 10};
int *result1 = func0(nums1, 10, &output_length);
assert(output_length == 5);
for (int i = 0; i < output_length; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int nums2[] = {10, 20, 45, 67, 84, 93};
int expected2[] = {10, 20, 84};
int *result2 = func0(nums2, 6, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int nums3[] = {5, 7, 9, 8, 6, 4, 3};
int expected3[] = {8, 6, 4};
int *result3 = func0(nums3, 7, &output_length);
assert(output_length == 3);
for (int i = 0; i < output_length; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1498 <func0+0x58>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x4(%rbx,%rdx,4),%r8
xchg %ax,%ax
mov (%rdi),%ecx
test $0x1,%cl
jne 1481 <func0+0x41>
movslq %esi,%r9
add $0x1,%esi
mov %ecx,(%rax,%r9,4)
add $0x4,%rdi
cmp %r8,%rdi
jne 1470 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r13
movsxd r8, esi
mov r13, rdx
push r12
mov r12, r8
push rbp
lea rbp, ds:0[r8*4]
push rbx
mov rbx, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_1480
mov rcx, rbx
lea r8, [rbx+rbp]
xor edi, edi
nop dword ptr [rax+rax+00000000h]
loc_1450:
mov esi, [rcx]
test sil, 1
jnz short loc_1462
movsxd r9, edi
add edi, 1
mov [rax+r9*4], esi
loc_1462:
add rcx, 4
cmp rcx, r8
jnz short loc_1450
mov [r13+0], edi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1480:
xor edi, edi
mov [r13+0], edi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *result; // rax
_DWORD *v6; // rcx
int v7; // edi
long long v8; // r9
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( (*v6 & 1) == 0 )
{
v8 = v7++;
result[v8] = *v6;
}
++v6;
}
while ( v6 != &a1[a2] );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R13
MOVSXD R8,ESI
MOV R13,RDX
PUSH R12
MOV R12,R8
PUSH RBP
LEA RBP,[R8*0x4]
PUSH RBX
MOV RBX,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010d0
TEST R12D,R12D
JLE 0x00101480
MOV RCX,RBX
LEA R8,[RBX + RBP*0x1]
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101450:
MOV ESI,dword ptr [RCX]
TEST SIL,0x1
JNZ 0x00101462
MOVSXD R9,EDI
ADD EDI,0x1
MOV dword ptr [RAX + R9*0x4],ESI
LAB_00101462:
ADD RCX,0x4
CMP RCX,R8
JNZ 0x00101450
MOV dword ptr [R13],EDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101480:
XOR EDI,EDI
MOV dword ptr [R13],EDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 * 4);
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
if ((*param_1 & 1) == 0) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(uint *)((long)pvVar2 + lVar4 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_3 = iVar3;
return;
}
*param_3 = 0;
return;
} |
4,060 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
int count = 1;
for (int j = 0; j < n; j++) {
if (arr[j] == arr[i] && j != i) {
count++;
}
}
if (count > 1) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 2};
int arr4[] = {1, 1, 2, 3, 4, 5, 6, 3, 5};
assert(func0(arr1, 8) == 3);
assert(func0(arr2, 5) == 3);
assert(func0(arr3, 3) == 2);
assert(func0(arr4, 9) == 18);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1223 <func0+0x9a>
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f8 <func0+0x6f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11f4 <func0+0x6b>
mov -0x4(%rbp),%eax
cmp -0xc(%rbp),%eax
je 11f4 <func0+0x6b>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11b8 <func0+0x2f>
cmpl $0x1,-0x8(%rbp)
jle 121f <func0+0x96>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11a8 <func0+0x1f>
mov -0x10(%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_10], 0
mov [rbp+var_C], 0
jmp short loc_1223
loc_11A8:
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_11F8
loc_11B8:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11F4
mov eax, [rbp+var_4]
cmp eax, [rbp+var_C]
jz short loc_11F4
add [rbp+var_8], 1
loc_11F4:
add [rbp+var_4], 1
loc_11F8:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11B8
cmp [rbp+var_8], 1
jle short loc_121F
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_10], eax
loc_121F:
add [rbp+var_C], 1
loc_1223:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_11A8
mov eax, [rbp+var_10]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-10h]
int i; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = 1;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) == *(_DWORD *)(4LL * i + a1) && j != i )
++v5;
}
if ( v5 > 1 )
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 + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101223
LAB_001011a8:
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f8
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011f4
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0xc]
JZ 0x001011f4
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f4:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011f8:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011b8
CMP dword ptr [RBP + -0x8],0x1
JLE 0x0010121f
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]
ADD dword ptr [RBP + -0x10],EAX
LAB_0010121f:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101223:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a8
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(int *)(param_1 + (long)local_c * 4) == *(int *)(param_1 + (long)local_14 * 4)) &&
(local_c != local_14)) {
local_10 = local_10 + 1;
}
}
if (1 < local_10) {
local_18 = local_18 + *(int *)(param_1 + (long)local_14 * 4);
}
}
return local_18;
} |
4,061 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
int count = 1;
for (int j = 0; j < n; j++) {
if (arr[j] == arr[i] && j != i) {
count++;
}
}
if (count > 1) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 2};
int arr4[] = {1, 1, 2, 3, 4, 5, 6, 3, 5};
assert(func0(arr1, 8) == 3);
assert(func0(arr2, 5) == 3);
assert(func0(arr3, 3) == 2);
assert(func0(arr4, 9) == 18);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ec <func0+0x63>
lea -0x1(%rsi),%r8d
mov $0x0,%r9d
mov $0x0,%r10d
mov $0x0,%r11d
jmp 11de <func0+0x55>
lea 0x1(%rax),%rdx
cmp %r8,%rax
je 11c8 <func0+0x3f>
mov %rdx,%rax
cmp %esi,(%rdi,%rax,4)
jne 11a9 <func0+0x20>
cmp %r9d,%eax
setne %dl
cmp $0x1,%dl
sbb $0xffffffff,%ecx
jmp 11a9 <func0+0x20>
add %r10d,%esi
cmp $0x1,%ecx
cmovg %esi,%r10d
lea 0x1(%r9),%rax
cmp %r8,%r9
je 11f2 <func0+0x69>
mov %rax,%r9
mov (%rdi,%r9,4),%esi
mov %r11,%rax
mov $0x1,%ecx
jmp 11b5 <func0+0x2c>
mov $0x0,%r10d
mov %r10d,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11E3
mov r8d, esi
mov r9d, 0
mov r10d, 0
jmp short loc_11D3
loc_11A2:
add rax, 1
cmp rax, r8
jz short loc_11C0
loc_11AB:
cmp [rdi+rax*4], ecx
jnz short loc_11A2
cmp eax, r9d
setnz sil
cmp sil, 1
sbb edx, 0FFFFFFFFh
jmp short loc_11A2
loc_11C0:
add ecx, r10d
cmp edx, 1
cmovg r10d, ecx
add r9, 1
cmp r9, r8
jz short loc_11E9
loc_11D3:
mov ecx, [rdi+r9*4]
mov eax, 0
mov edx, 1
jmp short loc_11AB
loc_11E3:
mov r10d, 0
loc_11E9:
mov eax, r10d
retn | long long func0(long long a1, int a2)
{
long long v2; // r9
unsigned int v3; // r10d
long long v4; // rax
int v5; // edx
unsigned int v6; // ecx
int v7; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 0LL;
v3 = 0;
do
{
v7 = *(_DWORD *)(a1 + 4 * v2);
v4 = 0LL;
v5 = 1;
do
{
if ( *(_DWORD *)(a1 + 4 * v4) == v7 )
v5 -= ((_DWORD)v4 == (_DWORD)v2) - 1;
++v4;
}
while ( v4 != a2 );
v6 = v3 + v7;
if ( v5 > 1 )
v3 = v6;
++v2;
}
while ( v2 != a2 );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011e3
MOV R8D,ESI
MOV R9D,0x0
MOV R10D,0x0
JMP 0x001011d3
LAB_001011a2:
ADD RAX,0x1
CMP RAX,R8
JZ 0x001011c0
LAB_001011ab:
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x001011a2
CMP EAX,R9D
SETNZ SIL
CMP SIL,0x1
SBB EDX,-0x1
JMP 0x001011a2
LAB_001011c0:
ADD ECX,R10D
CMP EDX,0x1
CMOVG R10D,ECX
ADD R9,0x1
CMP R9,R8
JZ 0x001011e9
LAB_001011d3:
MOV ECX,dword ptr [RDI + R9*0x4]
MOV EAX,0x0
MOV EDX,0x1
JMP 0x001011ab
LAB_001011e3:
MOV R10D,0x0
LAB_001011e9:
MOV EAX,R10D
RET | int func0(long param_1,uint param_2)
{
int iVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
int iVar5;
if ((int)param_2 < 1) {
iVar5 = 0;
}
else {
uVar4 = 0;
iVar5 = 0;
do {
iVar1 = *(int *)(param_1 + uVar4 * 4);
uVar2 = 0;
iVar3 = 1;
do {
if (*(int *)(param_1 + uVar2 * 4) == iVar1) {
iVar3 = (iVar3 + 1) - (uint)((int)uVar2 == (int)uVar4);
}
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
if (1 < iVar3) {
iVar5 = iVar1 + iVar5;
}
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
return iVar5;
} |
4,062 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
int count = 1;
for (int j = 0; j < n; j++) {
if (arr[j] == arr[i] && j != i) {
count++;
}
}
if (count > 1) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 2};
int arr4[] = {1, 1, 2, 3, 4, 5, 6, 3, 5};
assert(func0(arr1, 8) == 3);
assert(func0(arr2, 5) == 3);
assert(func0(arr3, 3) == 2);
assert(func0(arr4, 9) == 18);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 139d <func0+0x5d>
lea -0x1(%rsi),%r8d
xor %r9d,%r9d
xor %r10d,%r10d
nopw 0x0(%rax,%rax,1)
mov (%rdi,%r9,4),%esi
xor %eax,%eax
mov $0x1,%ecx
jmp 136b <func0+0x2b>
nopl (%rax)
mov %rdx,%rax
cmp %esi,(%rdi,%rax,4)
jne 137c <func0+0x3c>
cmp %r9d,%eax
setne %dl
cmp $0x1,%dl
sbb $0xffffffff,%ecx
lea 0x1(%rax),%rdx
cmp %rax,%r8
jne 1368 <func0+0x28>
add %r10d,%esi
cmp $0x1,%ecx
lea 0x1(%r9),%rax
cmovne %esi,%r10d
cmp %r9,%r8
je 13a0 <func0+0x60>
mov %rax,%r9
jmp 1358 <func0+0x18>
xor %r10d,%r10d
mov %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_139B
movsxd r8, esi
xor r9d, r9d
xor r10d, r10d
nop dword ptr [rax+00000000h]
loc_1358:
mov ecx, [rdi+r9*4]
xor eax, eax
mov edx, 1
nop dword ptr [rax+rax+00h]
loc_1368:
cmp [rdi+rax*4], ecx
jnz short loc_137B
cmp eax, r9d
setnz sil
cmp sil, 1
sbb edx, 0FFFFFFFFh
loc_137B:
add rax, 1
cmp r8, rax
jnz short loc_1368
add ecx, r10d
cmp edx, 1
cmovnz r10d, ecx
add r9, 1
cmp r8, r9
jnz short loc_1358
mov eax, r10d
retn
loc_139B:
xor r10d, r10d
mov eax, r10d
retn | long long func0(long long a1, int a2)
{
long long v2; // r9
unsigned int v3; // r10d
int v4; // ecx
long long v5; // rax
int v6; // edx
unsigned int v7; // ecx
if ( a2 <= 0 )
return 0LL;
v2 = 0LL;
v3 = 0;
do
{
v4 = *(_DWORD *)(a1 + 4 * v2);
v5 = 0LL;
v6 = 1;
do
{
if ( *(_DWORD *)(a1 + 4 * v5) == v4 )
v6 -= ((_DWORD)v5 == (_DWORD)v2) - 1;
++v5;
}
while ( a2 != v5 );
v7 = v3 + v4;
if ( v6 != 1 )
v3 = v7;
++v2;
}
while ( a2 != v2 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010139b
MOVSXD R8,ESI
XOR R9D,R9D
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_00101358:
MOV ECX,dword ptr [RDI + R9*0x4]
XOR EAX,EAX
MOV EDX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101368:
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x0010137b
CMP EAX,R9D
SETNZ SIL
CMP SIL,0x1
SBB EDX,-0x1
LAB_0010137b:
ADD RAX,0x1
CMP R8,RAX
JNZ 0x00101368
ADD ECX,R10D
CMP EDX,0x1
CMOVNZ R10D,ECX
ADD R9,0x1
CMP R8,R9
JNZ 0x00101358
MOV EAX,R10D
RET
LAB_0010139b:
XOR R10D,R10D
MOV EAX,R10D
RET | int func0(long param_1,int param_2)
{
int iVar1;
long lVar2;
int iVar3;
long lVar4;
int iVar5;
if (0 < param_2) {
lVar4 = 0;
iVar5 = 0;
do {
iVar1 = *(int *)(param_1 + lVar4 * 4);
lVar2 = 0;
iVar3 = 1;
do {
if (*(int *)(param_1 + lVar2 * 4) == iVar1) {
iVar3 = (iVar3 + 1) - (uint)((int)lVar2 == (int)lVar4);
}
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
if (iVar3 != 1) {
iVar5 = iVar1 + iVar5;
}
lVar4 = lVar4 + 1;
} while (param_2 != lVar4);
return iVar5;
}
return 0;
} |
4,063 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
int count = 1;
for (int j = 0; j < n; j++) {
if (arr[j] == arr[i] && j != i) {
count++;
}
}
if (count > 1) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 2, 3, 1, 1};
int arr3[] = {1, 1, 2};
int arr4[] = {1, 1, 2, 3, 4, 5, 6, 3, 5};
assert(func0(arr1, 8) == 3);
assert(func0(arr2, 5) == 3);
assert(func0(arr3, 3) == 2);
assert(func0(arr4, 9) == 18);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 14ac <func0+0x19c>
mov %esi,%r8d
push %r14
xor %ecx,%ecx
mov %esi,%r10d
push %r13
shr $0x2,%r8d
mov (%rdi,%rcx,4),%r9d
and $0xfffffffc,%r10d
push %r12
shl $0x4,%r8
xor %r11d,%r11d
pxor %xmm6,%xmm6
push %rbp
lea -0x1(%rsi),%ebp
movdqa 0xd83(%rip),%xmm7
add %rdi,%r8
push %rbx
mov %rbp,%rbx
movd %ecx,%xmm4
cmp $0x3,%ebx
jbe 145f <func0+0x14f>
nopl 0x0(%rax)
movd %r9d,%xmm5
pshufd $0x0,%xmm4,%xmm4
pxor %xmm2,%xmm2
mov %rdi,%rax
movdqa 0xd3f(%rip),%xmm3
pshufd $0x0,%xmm5,%xmm5
nopw %cs:0x0(%rax,%rax,1)
movdqa %xmm3,%xmm1
movdqu (%rax),%xmm0
add $0x10,%rax
paddd %xmm7,%xmm3
pcmpeqd %xmm4,%xmm1
pcmpeqd %xmm5,%xmm0
pcmpeqd %xmm6,%xmm1
pand %xmm1,%xmm0
psubd %xmm0,%xmm2
cmp %rax,%r8
jne 1390 <func0+0x80>
movdqa %xmm2,%xmm0
mov %r10d,%edx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm2
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%eax
add $0x1,%eax
cmp %r10d,%esi
je 143a <func0+0x12a>
movslq %edx,%r14
mov %ecx,%r13d
lea 0x0(,%r14,4),%r12
cmp %r9d,(%rdi,%r14,4)
jne 13fa <func0+0xea>
cmp %ecx,%edx
jne 1470 <func0+0x160>
add $0x1,%edx
cmp %esi,%edx
jge 143a <func0+0x12a>
cmp %r9d,0x4(%rdi,%r12,1)
jne 140d <func0+0xfd>
cmp %edx,%r13d
jne 1480 <func0+0x170>
add $0x1,%edx
cmp %edx,%esi
jle 143a <func0+0x12a>
cmp %r9d,0x8(%rdi,%r12,1)
jne 1420 <func0+0x110>
cmp %edx,%r13d
jne 1490 <func0+0x180>
add $0x1,%edx
cmp %edx,%esi
jle 143a <func0+0x12a>
cmp %r9d,0xc(%rdi,%r12,1)
jne 143a <func0+0x12a>
cmp %edx,%r13d
setne %dl
cmp $0x1,%dl
sbb $0xffffffff,%eax
cmp $0x1,%eax
je 1442 <func0+0x132>
add %r9d,%r11d
lea 0x1(%rcx),%rax
cmp %rbp,%rcx
je 14a0 <func0+0x190>
mov %rax,%rcx
mov (%rdi,%rcx,4),%r9d
movd %ecx,%xmm4
cmp $0x3,%ebx
ja 1368 <func0+0x58>
xor %edx,%edx
mov $0x1,%eax
jmpq 13e2 <func0+0xd2>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
add $0x1,%eax
cmp %edx,%esi
jg 1401 <func0+0xf1>
jmp 143f <func0+0x12f>
nopl 0x0(%rax)
add $0x1,%edx
add $0x1,%eax
cmp %edx,%esi
jg 1414 <func0+0x104>
jmp 143f <func0+0x12f>
nopl 0x0(%rax)
add $0x1,%edx
add $0x1,%eax
cmp %esi,%edx
jl 1427 <func0+0x117>
jmp 143f <func0+0x12f>
nopl 0x0(%rax)
pop %rbx
mov %r11d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %r11d,%r11d
mov %r11d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle loc_145C
mov ecx, esi
push r14
movdqa xmm7, cs:xmmword_20B0
mov r9d, esi
shr ecx, 2
push r13
mov r8, rdi
xor r10d, r10d
push r12
shl rcx, 4
movsxd r12, esi
pxor xmm6, xmm6
push rbp
add rcx, rdi
lea ebp, [rsi-1]
push rbx
mov ebx, esi
xor esi, esi
and ebx, 0FFFFFFFCh
nop word ptr [rax+rax+00h]
loc_1348:
mov edx, [r8+rsi*4]
cmp ebp, 2
jbe loc_1450
movd xmm4, esi
movdqa xmm3, cs:xmmword_20A0
mov rax, r8
pxor xmm2, xmm2
pshufd xmm5, xmm4, 0
movd xmm4, edx
pshufd xmm4, xmm4, 0
nop word ptr [rax+rax+00000000h]
loc_1380:
movdqa xmm1, xmm3
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
paddd xmm3, xmm7
pcmpeqd xmm1, xmm5
pcmpeqd xmm0, xmm4
pcmpeqd xmm1, xmm6
pand xmm0, xmm1
psubd xmm2, xmm0
cmp rax, rcx
jnz short loc_1380
movdqa xmm0, xmm2
mov edi, ebx
psrldq xmm0, 8
paddd xmm2, xmm0
movdqa xmm0, xmm2
psrldq xmm0, 4
paddd xmm2, xmm0
movd eax, xmm2
add eax, 1
cmp r9d, ebx
jz short loc_142D
loc_13D1:
movsxd r11, edi
mov r14d, esi
lea r13, ds:0[r11*4]
cmp [r8+r11*4], edx
jnz short loc_13F2
cmp esi, edi
setnz r11b
cmp r11b, 1
sbb eax, 0FFFFFFFFh
loc_13F2:
lea r11d, [rdi+1]
cmp r9d, r11d
jle short loc_142D
cmp [r8+r13+4], edx
jnz short loc_1410
cmp r11d, r14d
setnz r11b
cmp r11b, 1
sbb eax, 0FFFFFFFFh
loc_1410:
add edi, 2
cmp edi, r9d
jge short loc_142D
cmp [r8+r13+8], edx
jnz short loc_142D
cmp edi, r14d
setnz dil
cmp dil, 1
sbb eax, 0FFFFFFFFh
loc_142D:
add edx, r10d
cmp eax, 1
cmovg r10d, edx
add rsi, 1
cmp rsi, r12
jnz loc_1348
pop rbx
mov eax, r10d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1450:
xor edi, edi
mov eax, 1
jmp loc_13D1
loc_145C:
xor eax, eax
retn | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm7
unsigned int v5; // r10d
long long v6; // r12
const __m128i *v7; // rcx
unsigned int v8; // ebp
long long v10; // rsi
unsigned int v11; // ebx
unsigned int v12; // edx
__m128i v13; // xmm3
const __m128i *v14; // rax
__m128i v15; // xmm2
__m128i v16; // xmm5
__m128i v17; // xmm4
__m128i v18; // xmm1
__m128i v19; // xmm0
signed int v20; // edi
__m128i v21; // xmm2
int v22; // eax
long long v23; // r13
int v24; // edi
unsigned int v25; // edx
if ( a2 > 0 )
{
si128 = _mm_load_si128((const __m128i *)&xmmword_20B0);
v5 = 0;
v6 = a2;
v7 = &a1[(unsigned int)a2 >> 2];
v8 = a2 - 1;
v10 = 0LL;
v11 = a2 & 0xFFFFFFFC;
while ( 1 )
{
v12 = a1->m128i_u32[v10];
if ( v8 <= 2 )
break;
v13 = _mm_load_si128((const __m128i *)&xmmword_20A0);
v14 = a1;
v15 = 0LL;
v16 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v10), 0);
v17 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v12), 0);
do
{
v18 = v13;
v19 = _mm_loadu_si128(v14++);
v13 = _mm_add_epi32(v13, si128);
v15 = _mm_sub_epi32(
v15,
_mm_and_si128(_mm_cmpeq_epi32(v19, v17), _mm_cmpeq_epi32(_mm_cmpeq_epi32(v18, v16), (__m128i)0LL)));
}
while ( v14 != v7 );
v20 = v11;
v21 = _mm_add_epi32(v15, _mm_srli_si128(v15, 8));
v22 = _mm_cvtsi128_si32(_mm_add_epi32(v21, _mm_srli_si128(v21, 4))) + 1;
if ( a2 != v11 )
goto LABEL_7;
LABEL_15:
v25 = v5 + v12;
if ( v22 > 1 )
v5 = v25;
if ( ++v10 == v6 )
return v5;
}
v20 = 0;
v22 = 1;
LABEL_7:
v23 = v20;
if ( a1->m128i_i32[v23] == v12 )
v22 -= ((_DWORD)v10 == v20) - 1;
if ( a2 > v20 + 1 )
{
if ( a1->m128i_i32[v23 + 1] == v12 )
v22 -= (v20 + 1 == (_DWORD)v10) - 1;
v24 = v20 + 2;
if ( v24 < a2 && a1->m128i_i32[v23 + 2] == v12 )
v22 -= (v24 == (_DWORD)v10) - 1;
}
goto LABEL_15;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010145c
MOV ECX,ESI
PUSH R14
MOVDQA XMM7,xmmword ptr [0x001020b0]
MOV R9D,ESI
SHR ECX,0x2
PUSH R13
MOV R8,RDI
XOR R10D,R10D
PUSH R12
SHL RCX,0x4
MOVSXD R12,ESI
PXOR XMM6,XMM6
PUSH RBP
ADD RCX,RDI
LEA EBP,[RSI + -0x1]
PUSH RBX
MOV EBX,ESI
XOR ESI,ESI
AND EBX,0xfffffffc
NOP word ptr [RAX + RAX*0x1]
LAB_00101348:
MOV EDX,dword ptr [R8 + RSI*0x4]
CMP EBP,0x2
JBE 0x00101450
MOVD XMM4,ESI
MOVDQA XMM3,xmmword ptr [0x001020a0]
MOV RAX,R8
PXOR XMM2,XMM2
PSHUFD XMM5,XMM4,0x0
MOVD XMM4,EDX
PSHUFD XMM4,XMM4,0x0
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101380:
MOVDQA XMM1,XMM3
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM3,XMM7
PCMPEQD XMM1,XMM5
PCMPEQD XMM0,XMM4
PCMPEQD XMM1,XMM6
PAND XMM0,XMM1
PSUBD XMM2,XMM0
CMP RAX,RCX
JNZ 0x00101380
MOVDQA XMM0,XMM2
MOV EDI,EBX
PSRLDQ XMM0,0x8
PADDD XMM2,XMM0
MOVDQA XMM0,XMM2
PSRLDQ XMM0,0x4
PADDD XMM2,XMM0
MOVD EAX,XMM2
ADD EAX,0x1
CMP R9D,EBX
JZ 0x0010142d
LAB_001013d1:
MOVSXD R11,EDI
MOV R14D,ESI
LEA R13,[R11*0x4]
CMP dword ptr [R8 + R11*0x4],EDX
JNZ 0x001013f2
CMP ESI,EDI
SETNZ R11B
CMP R11B,0x1
SBB EAX,-0x1
LAB_001013f2:
LEA R11D,[RDI + 0x1]
CMP R9D,R11D
JLE 0x0010142d
CMP dword ptr [R8 + R13*0x1 + 0x4],EDX
JNZ 0x00101410
CMP R11D,R14D
SETNZ R11B
CMP R11B,0x1
SBB EAX,-0x1
LAB_00101410:
ADD EDI,0x2
CMP EDI,R9D
JGE 0x0010142d
CMP dword ptr [R8 + R13*0x1 + 0x8],EDX
JNZ 0x0010142d
CMP EDI,R14D
SETNZ DIL
CMP DIL,0x1
SBB EAX,-0x1
LAB_0010142d:
ADD EDX,R10D
CMP EAX,0x1
CMOVG R10D,EDX
ADD RSI,0x1
CMP RSI,R12
JNZ 0x00101348
POP RBX
MOV EAX,R10D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101450:
XOR EDI,EDI
MOV EAX,0x1
JMP 0x001013d1
LAB_0010145c:
XOR EAX,EAX
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
long lVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
uint uVar15;
uint uVar16;
uint uVar17;
if ((int)param_2 < 1) {
return 0;
}
iVar10 = 0;
lVar8 = 0;
do {
iVar1 = param_1[lVar8];
uVar7 = (uint)lVar8;
if (param_2 - 1 < 3) {
uVar9 = 0;
iVar11 = 1;
LAB_001013d1:
if (param_1[(int)uVar9] == iVar1) {
iVar11 = (iVar11 + 1) - (uint)(uVar7 == uVar9);
}
if ((int)(uVar9 + 1) < (int)param_2) {
if (param_1[(long)(int)uVar9 + 1] == iVar1) {
iVar11 = (iVar11 + 1) - (uint)(uVar9 + 1 == uVar7);
}
if (((int)(uVar9 + 2) < (int)param_2) && (param_1[(long)(int)uVar9 + 2] == iVar1)) {
iVar11 = (iVar11 + 1) - (uint)(uVar9 + 2 == uVar7);
}
}
}
else {
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
piVar6 = param_1;
uVar9 = _DAT_001020a0;
uVar15 = _UNK_001020a4;
uVar16 = _UNK_001020a8;
uVar17 = _UNK_001020ac;
do {
iVar2 = *piVar6;
piVar3 = piVar6 + 1;
piVar4 = piVar6 + 2;
piVar5 = piVar6 + 3;
piVar6 = piVar6 + 4;
iVar11 = iVar11 + (uint)(iVar2 == iVar1 && uVar9 != uVar7);
iVar12 = iVar12 + (uint)(*piVar3 == iVar1 && uVar15 != uVar7);
iVar13 = iVar13 + (uint)(*piVar4 == iVar1 && uVar16 != uVar7);
iVar14 = iVar14 + (uint)(*piVar5 == iVar1 && uVar17 != uVar7);
uVar9 = uVar9 + _DAT_001020b0;
uVar15 = uVar15 + _UNK_001020b4;
uVar16 = uVar16 + _UNK_001020b8;
uVar17 = uVar17 + _UNK_001020bc;
} while (piVar6 != param_1 + (ulong)(param_2 >> 2) * 4);
iVar11 = iVar11 + iVar13 + iVar12 + iVar14 + 1;
uVar9 = param_2 & 0xfffffffc;
if (param_2 != (param_2 & 0xfffffffc)) goto LAB_001013d1;
}
if (1 < iVar11) {
iVar10 = iVar1 + iVar10;
}
lVar8 = lVar8 + 1;
if (lVar8 == (int)param_2) {
return iVar10;
}
} while( true );
} |
4,064 | func0 | #include <string.h>
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char *text) {
regex_t regex;
int regexInit;
int regexSearch;
char *patterns = "^[a-z]+_[a-z]+$";
regexInit = regcomp(®ex, patterns, REG_EXTENDED);
if (regexInit) {
fprintf(stderr, "Could not compile regex\n");
return ("Compilation error");
}
regexSearch = regexec(®ex, text, 0, NULL, 0);
if (!regexSearch) {
regfree(®ex);
return ("Found a match!");
} else if (regexSearch == REG_NOMATCH) {
regfree(®ex);
return ("Not matched!");
} else {
char errorMessage[100];
regerror(regexSearch, ®ex, errorMessage, sizeof(errorMessage));
fprintf(stderr, "Regex match failed: %s\n", errorMessage);
regfree(®ex);
return ("Error occurred");
}
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %rdi,-0xc8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xd93(%rip),%rax
mov %rax,-0xb8(%rbp)
mov -0xb8(%rbp),%rcx
lea -0xb0(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 1100 <regcomp@plt>
mov %eax,-0xc0(%rbp)
cmpl $0x0,-0xc0(%rbp)
je 12d5 <func0+0x8c>
mov 0x2d70(%rip),%rax
mov %rax,%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xd54(%rip),%rdi
callq 1150 <fwrite@plt>
lea 0xd61(%rip),%rax
jmpq 1395 <func0+0x14c>
mov -0xc8(%rbp),%rsi
lea -0xb0(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 1140 <regexec@plt>
mov %eax,-0xbc(%rbp)
cmpl $0x0,-0xbc(%rbp)
jne 1322 <func0+0xd9>
lea -0xb0(%rbp),%rax
mov %rax,%rdi
callq 10d0 <regfree@plt>
lea 0xd23(%rip),%rax
jmp 1395 <func0+0x14c>
cmpl $0x1,-0xbc(%rbp)
jne 1343 <func0+0xfa>
lea -0xb0(%rbp),%rax
mov %rax,%rdi
callq 10d0 <regfree@plt>
lea 0xd11(%rip),%rax
jmp 1395 <func0+0x14c>
lea -0x70(%rbp),%rdx
lea -0xb0(%rbp),%rsi
mov -0xbc(%rbp),%eax
mov $0x64,%ecx
mov %eax,%edi
callq 1130 <regerror@plt>
mov 0x2cb9(%rip),%rax
lea -0x70(%rbp),%rdx
lea 0xced(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1120 <fprintf@plt>
lea -0xb0(%rbp),%rax
mov %rax,%rdi
callq 10d0 <regfree@plt>
lea 0xce2(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 13a9 <func0+0x160>
callq 10e0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAZAZ; "^[a-z]+_[a-z]+$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov [rbp+var_C0], eax
cmp [rbp+var_C0], 0
jz short loc_12D8
mov rax, cs:__bss_start
mov rcx, rax; s
mov edx, 18h; n
mov esi, 1; size
lea rax, aCouldNotCompil; "Could not compile regex\n"
mov rdi, rax; ptr
call _fwrite
lea rax, aCompilationErr; "Compilation error"
jmp loc_139B
loc_12D8:
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+errcode], eax
cmp [rbp+errcode], 0
jnz short loc_1325
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
lea rax, s2; "Found a match!"
jmp short loc_139B
loc_1325:
cmp [rbp+errcode], 1
jnz short loc_1346
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
lea rax, aNotMatched; "Not matched!"
jmp short loc_139B
loc_1346:
lea rdx, [rbp+errbuf]; errbuf
lea rsi, [rbp+preg]; preg
mov eax, [rbp+errcode]
mov ecx, 64h ; 'd'; errbuf_size
mov edi, eax; errcode
call _regerror
mov rax, cs:__bss_start
lea rdx, [rbp+errbuf]
lea rcx, format; "Regex match failed: %s\n"
mov rsi, rcx; format
mov rdi, rax; stream
mov eax, 0
call _fprintf
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
lea rax, aErrorOccurred; "Error occurred"
loc_139B:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13AF
call ___stack_chk_fail
locret_13AF:
leave
retn | const char * func0(const char *a1)
{
int errcode; // [rsp+14h] [rbp-BCh]
regex_t preg; // [rsp+20h] [rbp-B0h] BYREF
char errbuf[104]; // [rsp+60h] [rbp-70h] BYREF
unsigned long long v5; // [rsp+C8h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( regcomp(&preg, "^[a-z]+_[a-z]+$", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return "Compilation error";
}
else
{
errcode = regexec(&preg, a1, 0LL, 0LL, 0);
if ( errcode )
{
if ( errcode == 1 )
{
regfree(&preg);
return "Not matched!";
}
else
{
regerror(errcode, &preg, errbuf, 0x64uLL);
fprintf(_bss_start, "Regex match failed: %s\n", errbuf);
regfree(&preg);
return "Error occurred";
}
}
else
{
regfree(&preg);
return "Found a match!";
}
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xc8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0xb8],RAX
MOV RCX,qword ptr [RBP + -0xb8]
LEA RAX,[RBP + -0xb0]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101100
MOV dword ptr [RBP + -0xc0],EAX
CMP dword ptr [RBP + -0xc0],0x0
JZ 0x001012d8
MOV RAX,qword ptr [0x00104020]
MOV RCX,RAX
MOV EDX,0x18
MOV ESI,0x1
LEA RAX,[0x102018]
MOV RDI,RAX
CALL 0x00101150
LEA RAX,[0x102031]
JMP 0x0010139b
LAB_001012d8:
MOV RSI,qword ptr [RBP + -0xc8]
LEA RAX,[RBP + -0xb0]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x00101140
MOV dword ptr [RBP + -0xbc],EAX
CMP dword ptr [RBP + -0xbc],0x0
JNZ 0x00101325
LEA RAX,[RBP + -0xb0]
MOV RDI,RAX
CALL 0x001010d0
LEA RAX,[0x102043]
JMP 0x0010139b
LAB_00101325:
CMP dword ptr [RBP + -0xbc],0x1
JNZ 0x00101346
LEA RAX,[RBP + -0xb0]
MOV RDI,RAX
CALL 0x001010d0
LEA RAX,[0x102052]
JMP 0x0010139b
LAB_00101346:
LEA RDX,[RBP + -0x70]
LEA RSI,[RBP + -0xb0]
MOV EAX,dword ptr [RBP + -0xbc]
MOV ECX,0x64
MOV EDI,EAX
CALL 0x00101130
MOV RAX,qword ptr [0x00104020]
LEA RDX,[RBP + -0x70]
LEA RCX,[0x10205f]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101120
LEA RAX,[RBP + -0xb0]
MOV RDI,RAX
CALL 0x001010d0
LEA RAX,[0x102077]
LAB_0010139b:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013af
CALL 0x001010e0
LAB_001013af:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_b8;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_b8,"^[a-z]+_[a-z]+$",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_b8,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
regfree(&local_b8);
pcVar2 = "Found a match!";
}
else if (iVar1 == 1) {
regfree(&local_b8);
pcVar2 = "Not matched!";
}
else {
regerror(iVar1,&local_b8,local_78,100);
fprintf(stderr,"Regex match failed: %s\n",local_78);
regfree(&local_b8);
pcVar2 = "Error occurred";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Compilation error";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
4,065 | func0 | #include <string.h>
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char *text) {
regex_t regex;
int regexInit;
int regexSearch;
char *patterns = "^[a-z]+_[a-z]+$";
regexInit = regcomp(®ex, patterns, REG_EXTENDED);
if (regexInit) {
fprintf(stderr, "Could not compile regex\n");
return ("Compilation error");
}
regexSearch = regexec(®ex, text, 0, NULL, 0);
if (!regexSearch) {
regfree(®ex);
return ("Found a match!");
} else if (regexSearch == REG_NOMATCH) {
regfree(®ex);
return ("Not matched!");
} else {
char errorMessage[100];
regerror(regexSearch, ®ex, errorMessage, sizeof(errorMessage));
fprintf(stderr, "Regex match failed: %s\n", errorMessage);
regfree(®ex);
return ("Error occurred");
}
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xde6(%rip),%rsi
callq 10f0 <regcomp@plt>
test %eax,%eax
jne 12fa <func0+0xd1>
mov %rsp,%rdi
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
callq 1110 <regexec@plt>
test %eax,%eax
je 1320 <func0+0xf7>
cmp $0x1,%eax
je 1331 <func0+0x108>
lea 0x40(%rsp),%rbp
mov %rsp,%rbx
mov $0x64,%ecx
mov %rbp,%rdx
mov %rbx,%rsi
mov %eax,%edi
callq 1100 <regerror@plt>
mov %rbp,%rcx
lea 0xdb2(%rip),%rdx
mov $0x1,%esi
mov 0x2d5c(%rip),%rdi
mov $0x0,%eax
callq 1130 <__fprintf_chk@plt>
mov %rbx,%rdi
callq 10c0 <regfree@plt>
lea 0xd55(%rip),%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1342 <func0+0x119>
add $0xb8,%rsp
pop %rbx
pop %rbp
retq
mov 0x2d1f(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xd3f(%rip),%rdi
callq 1120 <fwrite@plt>
lea 0xce6(%rip),%rax
jmp 12dd <func0+0xb4>
mov %rsp,%rdi
callq 10c0 <regfree@plt>
lea 0xce7(%rip),%rax
jmp 12dd <func0+0xb4>
mov %rsp,%rdi
callq 10c0 <regfree@plt>
lea 0xce5(%rip),%rax
jmp 12dd <func0+0xb4>
callq 10d0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 0B8h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aAZAZ; "^[a-z]+_[a-z]+$"
call _regcomp
test eax, eax
jnz loc_131A
mov rdi, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
call _regexec
test eax, eax
jz loc_1340
cmp eax, 1
jz loc_1351
lea rbp, [rsp+0C8h+var_88]
mov rbx, rsp
mov ecx, 64h ; 'd'
mov rdx, rbp
mov rsi, rbx
mov edi, eax
call _regerror
mov rcx, rbp
lea rdx, aRegexMatchFail; "Regex match failed: %s\n"
mov esi, 1
mov rdi, cs:stderr@GLIBC_2_2_5
mov eax, 0
call ___fprintf_chk
mov rdi, rbx
call _regfree
lea rax, aErrorOccurred; "Error occurred"
loc_12FD:
mov rdx, [rsp+0C8h+var_20]
sub rdx, fs:28h
jnz short loc_1362
add rsp, 0B8h
pop rbx
pop rbp
retn
loc_131A:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 18h
mov esi, 1
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
lea rax, aCompilationErr; "Compilation error"
jmp short loc_12FD
loc_1340:
mov rdi, rsp
call _regfree
lea rax, aFoundAMatch; "Found a match!"
jmp short loc_12FD
loc_1351:
mov rdi, rsp
call _regfree
lea rax, aNotMatched; "Not matched!"
jmp short loc_12FD
loc_1362:
call ___stack_chk_fail | const char * func0(long long a1)
{
unsigned int v1; // eax
_BYTE v3[64]; // [rsp+0h] [rbp-C8h] BYREF
char v4[104]; // [rsp+40h] [rbp-88h] BYREF
unsigned long long v5; // [rsp+A8h] [rbp-20h]
v5 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "^[a-z]+_[a-z]+$", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Compilation error";
}
else
{
v1 = regexec(v3, a1, 0LL, 0LL, 0LL);
if ( v1 )
{
if ( v1 == 1 )
{
regfree(v3);
return "Not matched!";
}
else
{
regerror(v1, v3, v4, 100LL);
__fprintf_chk(stderr, 1LL, "Regex match failed: %s\n", v4);
regfree(v3);
return "Error occurred";
}
}
else
{
regfree(v3);
return "Found a match!";
}
}
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102041]
CALL 0x00101100
TEST EAX,EAX
JNZ 0x0010131a
MOV RDI,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
CALL 0x00101130
TEST EAX,EAX
JZ 0x00101340
CMP EAX,0x1
JZ 0x00101351
LEA RBP,[RSP + 0x40]
MOV RBX,RSP
MOV ECX,0x64
MOV RDX,RBP
MOV RSI,RBX
MOV EDI,EAX
CALL 0x00101120
MOV RCX,RBP
LEA RDX,[0x10206a]
MOV ESI,0x1
MOV RDI,qword ptr [0x00104020]
MOV EAX,0x0
CALL 0x00101150
MOV RDI,RBX
CALL 0x001010d0
LEA RAX,[0x102032]
LAB_001012fd:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101362
ADD RSP,0xb8
POP RBX
POP RBP
RET
LAB_0010131a:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102051]
CALL 0x00101140
LEA RAX,[0x102004]
JMP 0x001012fd
LAB_00101340:
MOV RDI,RSP
CALL 0x001010d0
LEA RAX,[0x102016]
JMP 0x001012fd
LAB_00101351:
MOV RDI,RSP
CALL 0x001010d0
LEA RAX,[0x102025]
JMP 0x001012fd
LAB_00101362:
CALL 0x001010e0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,"^[a-z]+_[a-z]+$",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
regfree(&rStack_c8);
pcVar2 = "Found a match!";
}
else if (iVar1 == 1) {
regfree(&rStack_c8);
pcVar2 = "Not matched!";
}
else {
regerror(iVar1,&rStack_c8,local_88,100);
__fprintf_chk(stderr,1,"Regex match failed: %s\n",local_88);
regfree(&rStack_c8);
pcVar2 = "Error occurred";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Compilation error";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,066 | func0 | #include <string.h>
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char *text) {
regex_t regex;
int regexInit;
int regexSearch;
char *patterns = "^[a-z]+_[a-z]+$";
regexInit = regcomp(®ex, patterns, REG_EXTENDED);
if (regexInit) {
fprintf(stderr, "Could not compile regex\n");
return ("Compilation error");
}
regexSearch = regexec(®ex, text, 0, NULL, 0);
if (!regexSearch) {
regfree(®ex);
return ("Found a match!");
} else if (regexSearch == REG_NOMATCH) {
regfree(®ex);
return ("Not matched!");
} else {
char errorMessage[100];
regerror(regexSearch, ®ex, errorMessage, sizeof(errorMessage));
fprintf(stderr, "Regex match failed: %s\n", errorMessage);
regfree(®ex);
return ("Error occurred");
}
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xcdc(%rip),%rsi
push %rbp
sub $0xb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10f0 <regcomp@plt>
test %eax,%eax
jne 1420 <func0+0xd0>
mov %rbp,%rdi
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r12,%rsi
callq 1110 <regexec@plt>
mov %eax,%edi
test %eax,%eax
je 1468 <func0+0x118>
cmp $0x1,%eax
je 1450 <func0+0x100>
lea 0x40(%rsp),%r12
mov $0x64,%ecx
mov %rbp,%rsi
mov %r12,%rdx
callq 1100 <regerror@plt>
mov %r12,%rcx
mov $0x1,%esi
xor %eax,%eax
mov 0x2c42(%rip),%rdi
lea 0xc85(%rip),%rdx
callq 1130 <__fprintf_chk@plt>
mov %rbp,%rdi
callq 10c0 <regfree@plt>
lea 0xc39(%rip),%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1479 <func0+0x129>
add $0xb8,%rsp
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov 0x2bf9(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xc19(%rip),%rdi
callq 1120 <fwrite@plt>
lea 0xbc0(%rip),%rax
jmp 13f9 <func0+0xa9>
nopw %cs:0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 10c0 <regfree@plt>
lea 0xbc6(%rip),%rax
jmp 13f9 <func0+0xa9>
nopl 0x0(%rax)
mov %rbp,%rdi
callq 10c0 <regfree@plt>
lea 0xb9f(%rip),%rax
jmp 13f9 <func0+0xa9>
callq 10d0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r12
mov edx, 1
mov r12, rdi
lea rsi, aAZAZ; "^[a-z]+_[a-z]+$"
push rbp
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+var_sA8], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
test eax, eax
jnz loc_1420
mov rdi, rbp
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rsi, r12
call _regexec
mov edi, eax
test eax, eax
jz loc_1468
cmp eax, 1
jz loc_1450
lea r12, [rsp+var_s40]
mov ecx, 64h ; 'd'
mov rsi, rbp
mov rdx, r12
call _regerror
mov rcx, r12
mov esi, 1
xor eax, eax
mov rdi, cs:stderr@GLIBC_2_2_5
lea rdx, aRegexMatchFail; "Regex match failed: %s\n"
call ___fprintf_chk
mov rdi, rbp
call _regfree
lea rax, aErrorOccurred; "Error occurred"
loc_13F9:
mov rdx, [rsp+var_sA8]
sub rdx, fs:28h
jnz short loc_1479
add rsp, 0B8h
pop rbp
pop r12
retn
loc_1420:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 18h
mov esi, 1
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
lea rax, aCompilationErr; "Compilation error"
jmp short loc_13F9
loc_1450:
mov rdi, rbp
call _regfree
lea rax, aNotMatched; "Not matched!"
jmp short loc_13F9
loc_1468:
mov rdi, rbp
call _regfree
lea rax, aFoundAMatch; "Found a match!"
jmp short loc_13F9
loc_1479:
call ___stack_chk_fail | const char * func0(long long a1)
{
unsigned int v1; // eax
_BYTE _0[64]; // [rsp+0h] [rbp+0h] BYREF
char vars40[104]; // [rsp+40h] [rbp+40h] BYREF
unsigned long long varsA8; // [rsp+A8h] [rbp+A8h]
varsA8 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(_0, "^[a-z]+_[a-z]+$", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Compilation error";
}
else
{
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
if ( v1 )
{
if ( v1 == 1 )
{
regfree(_0);
return "Not matched!";
}
else
{
regerror(v1, _0, vars40, 100LL);
__fprintf_chk(stderr, 1LL, "Regex match failed: %s\n", vars40);
regfree(_0);
return "Error occurred";
}
}
else
{
regfree(_0);
return "Found a match!";
}
}
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x102041]
PUSH RBP
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x00101100
TEST EAX,EAX
JNZ 0x00101420
MOV RDI,RBP
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R12
CALL 0x00101130
MOV EDI,EAX
TEST EAX,EAX
JZ 0x00101468
CMP EAX,0x1
JZ 0x00101450
LEA R12,[RSP + 0x40]
MOV ECX,0x64
MOV RSI,RBP
MOV RDX,R12
CALL 0x00101120
MOV RCX,R12
MOV ESI,0x1
XOR EAX,EAX
MOV RDI,qword ptr [0x00104020]
LEA RDX,[0x10206a]
CALL 0x00101150
MOV RDI,RBP
CALL 0x001010d0
LEA RAX,[0x102032]
LAB_001013f9:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101479
ADD RSP,0xb8
POP RBP
POP R12
RET
LAB_00101420:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102051]
CALL 0x00101140
LEA RAX,[0x102004]
JMP 0x001013f9
LAB_00101450:
MOV RDI,RBP
CALL 0x001010d0
LEA RAX,[0x102025]
JMP 0x001013f9
LAB_00101468:
MOV RDI,RBP
CALL 0x001010d0
LEA RAX,[0x102016]
JMP 0x001013f9
LAB_00101479:
CALL 0x001010e0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,"^[a-z]+_[a-z]+$",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
regfree(&rStack_c8);
pcVar2 = "Found a match!";
}
else if (iVar1 == 1) {
regfree(&rStack_c8);
pcVar2 = "Not matched!";
}
else {
regerror(iVar1,&rStack_c8,local_88,100);
__fprintf_chk(stderr,1,"Regex match failed: %s\n",local_88);
regfree(&rStack_c8);
pcVar2 = "Error occurred";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Compilation error";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,067 | func0 | #include <string.h>
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char *text) {
regex_t regex;
int regexInit;
int regexSearch;
char *patterns = "^[a-z]+_[a-z]+$";
regexInit = regcomp(®ex, patterns, REG_EXTENDED);
if (regexInit) {
fprintf(stderr, "Could not compile regex\n");
return ("Compilation error");
}
regexSearch = regexec(®ex, text, 0, NULL, 0);
if (!regexSearch) {
regfree(®ex);
return ("Found a match!");
} else if (regexSearch == REG_NOMATCH) {
regfree(®ex);
return ("Not matched!");
} else {
char errorMessage[100];
regerror(regexSearch, ®ex, errorMessage, sizeof(errorMessage));
fprintf(stderr, "Regex match failed: %s\n", errorMessage);
regfree(®ex);
return ("Error occurred");
}
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xcdc(%rip),%rsi
push %rbp
sub $0xb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10f0 <regcomp@plt>
test %eax,%eax
jne 1420 <func0+0xd0>
mov %rbp,%rdi
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r12,%rsi
callq 1110 <regexec@plt>
mov %eax,%edi
test %eax,%eax
je 1468 <func0+0x118>
cmp $0x1,%eax
je 1450 <func0+0x100>
lea 0x40(%rsp),%r12
mov $0x64,%ecx
mov %rbp,%rsi
mov %r12,%rdx
callq 1100 <regerror@plt>
mov %r12,%rcx
mov $0x1,%esi
xor %eax,%eax
mov 0x2c42(%rip),%rdi
lea 0xc85(%rip),%rdx
callq 1130 <__fprintf_chk@plt>
mov %rbp,%rdi
callq 10c0 <regfree@plt>
lea 0xc39(%rip),%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1479 <func0+0x129>
add $0xb8,%rsp
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov 0x2bf9(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xc19(%rip),%rdi
callq 1120 <fwrite@plt>
lea 0xbc0(%rip),%rax
jmp 13f9 <func0+0xa9>
nopw %cs:0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 10c0 <regfree@plt>
lea 0xbc6(%rip),%rax
jmp 13f9 <func0+0xa9>
nopl 0x0(%rax)
mov %rbp,%rdi
callq 10c0 <regfree@plt>
lea 0xb9f(%rip),%rax
jmp 13f9 <func0+0xa9>
callq 10d0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push rbp
mov edx, 1; cflags
mov rbp, rdi
lea rsi, pattern; "^[a-z]+_[a-z]+$"
push rbx
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
mov rbx, rsp
mov rdi, rbx; preg
call _regcomp
test eax, eax
jnz loc_1418
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbp; string
mov rdi, rbx; preg
call _regexec
test eax, eax
jz loc_1458
cmp eax, 1
jz loc_1440
lea rbp, [rsp+0C8h+errbuf]
mov ecx, 64h ; 'd'; errbuf_size
mov rsi, rbx; preg
mov edi, eax; errcode
mov rdx, rbp; errbuf
call _regerror
mov rcx, rbp
mov esi, 2
xor eax, eax
mov rdi, cs:__bss_start
lea rdx, aRegexMatchFail; "Regex match failed: %s\n"
call ___fprintf_chk
mov rdi, rbx; preg
call _regfree
lea rax, aErrorOccurred; "Error occurred"
loc_13F8:
mov rdx, [rsp+0C8h+var_20]
sub rdx, fs:28h
jnz short loc_1469
add rsp, 0B8h
pop rbx
pop rbp
retn
loc_1418:
mov rcx, cs:__bss_start; s
mov edx, 18h; n
mov esi, 1; size
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
lea rax, aCompilationErr; "Compilation error"
jmp short loc_13F8
loc_1440:
mov rdi, rbx; preg
call _regfree
lea rax, aNotMatched; "Not matched!"
jmp short loc_13F8
loc_1458:
mov rdi, rbx; preg
call _regfree
lea rax, s2; "Found a match!"
jmp short loc_13F8
loc_1469:
call ___stack_chk_fail | const char * func0(char *string)
{
int v1; // eax
regex_t v3; // [rsp+0h] [rbp-C8h] BYREF
char errbuf[104]; // [rsp+40h] [rbp-88h] BYREF
unsigned long long v5; // [rsp+A8h] [rbp-20h]
v5 = __readfsqword(0x28u);
if ( regcomp(&v3, "^[a-z]+_[a-z]+$", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return "Compilation error";
}
else
{
v1 = regexec(&v3, string, 0LL, 0LL, 0);
if ( v1 )
{
if ( v1 == 1 )
{
regfree(&v3);
return "Not matched!";
}
else
{
regerror(v1, &v3, errbuf, 0x64uLL);
__fprintf_chk(_bss_start, 2LL, "Regex match failed: %s\n", errbuf);
regfree(&v3);
return "Error occurred";
}
}
else
{
regfree(&v3);
return "Found a match!";
}
}
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
MOV RBP,RDI
LEA RSI,[0x102041]
PUSH RBX
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV RBX,RSP
MOV RDI,RBX
CALL 0x00101100
TEST EAX,EAX
JNZ 0x00101418
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBP
MOV RDI,RBX
CALL 0x00101130
TEST EAX,EAX
JZ 0x00101458
CMP EAX,0x1
JZ 0x00101440
LEA RBP,[RSP + 0x40]
MOV ECX,0x64
MOV RSI,RBX
MOV EDI,EAX
MOV RDX,RBP
CALL 0x00101120
MOV RCX,RBP
MOV ESI,0x2
XOR EAX,EAX
MOV RDI,qword ptr [0x00104020]
LEA RDX,[0x10206a]
CALL 0x00101150
MOV RDI,RBX
CALL 0x001010d0
LEA RAX,[0x102032]
LAB_001013f8:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101469
ADD RSP,0xb8
POP RBX
POP RBP
RET
LAB_00101418:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102051]
CALL 0x00101140
LEA RAX,[0x102004]
JMP 0x001013f8
LAB_00101440:
MOV RDI,RBX
CALL 0x001010d0
LEA RAX,[0x102025]
JMP 0x001013f8
LAB_00101458:
MOV RDI,RBX
CALL 0x001010d0
LEA RAX,[0x102016]
JMP 0x001013f8
LAB_00101469:
CALL 0x001010e0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,"^[a-z]+_[a-z]+$",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
regfree(&rStack_c8);
pcVar2 = "Found a match!";
}
else if (iVar1 == 1) {
regfree(&rStack_c8);
pcVar2 = "Not matched!";
}
else {
regerror(iVar1,&rStack_c8,local_88,100);
__fprintf_chk(stderr,2,"Regex match failed: %s\n",local_88);
regfree(&rStack_c8);
pcVar2 = "Error occurred";
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
pcVar2 = "Compilation error";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,068 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "^[[:alnum:]_]+";
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return "Regex compilation error";
}
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0(" python"), "Not matched!") == 0);
assert(strcmp(func0("python"), "Found a match!") == 0);
assert(strcmp(func0(" lang"), "Not matched!") == 0);
assert(strcmp(func0("foo"), "Found a match!") == 0);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdd9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10f0 <regcomp@plt>
test %eax,%eax
je 1258 <func0+0x4f>
lea 0xdc1(%rip),%rax
jmp 129d <func0+0x94>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 1110 <regexec@plt>
mov %eax,-0x5c(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 10c0 <regfree@plt>
cmpl $0x0,-0x5c(%rbp)
jne 1296 <func0+0x8d>
lea 0xd9b(%rip),%rax
jmp 129d <func0+0x94>
lea 0xda1(%rip),%rax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 12b1 <func0+0xa8>
callq 10d0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAlnum; "^[[:alnum:]_]+"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
test eax, eax
jz short loc_1258
lea rax, aRegexCompilati; "Regex compilation error"
jmp short loc_129D
loc_1258:
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_5C], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_5C], 0
jnz short loc_1296
lea rax, aFoundAMatch; "Found a match!"
jmp short loc_129D
loc_1296:
lea rax, s2; "Not matched!"
loc_129D:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12B1
call ___stack_chk_fail
locret_12B1:
leave
retn | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "^[[:alnum:]_]+", 1) )
return "Regex compilation error";
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
if ( v2 )
return "Not matched!";
else
return "Found a match!";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101258
LEA RAX,[0x102017]
JMP 0x0010129d
LAB_00101258:
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x00101110
MOV dword ptr [RBP + -0x5c],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001010c0
CMP dword ptr [RBP + -0x5c],0x0
JNZ 0x00101296
LEA RAX,[0x10202f]
JMP 0x0010129d
LAB_00101296:
LEA RAX,[0x10203e]
LAB_0010129d:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012b1
CALL 0x001010d0
LAB_001012b1:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"^[[:alnum:]_]+",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (iVar1 == 0) {
pcVar2 = "Found a match!";
}
else {
pcVar2 = "Not matched!";
}
}
else {
pcVar2 = "Regex compilation error";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
4,069 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "^[[:alnum:]_]+";
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return "Regex compilation error";
}
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0(" python"), "Not matched!") == 0);
assert(strcmp(func0("python"), "Found a match!") == 0);
assert(strcmp(func0(" lang"), "Not matched!") == 0);
assert(strcmp(func0("foo"), "Found a match!") == 0);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe23(%rip),%rsi
callq 10e0 <regcomp@plt>
mov %eax,%edx
lea 0xde1(%rip),%rax
test %edx,%edx
je 123e <func0+0x55>
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 127c <func0+0x93>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
mov %rsp,%rbp
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10f0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 10b0 <regfree@plt>
test %ebx,%ebx
lea 0xdad(%rip),%rax
lea 0xdb5(%rip),%rdx
cmovne %rdx,%rax
jmp 1227 <func0+0x3e>
callq 10c0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aAlnum; "^[[:alnum:]_]+"
call _regcomp
mov edx, eax
lea rax, aRegexCompilati; "Regex compilation error"
test edx, edx
jz short loc_125E
loc_1247:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_129C
add rsp, 58h
pop rbx
pop rbp
retn
loc_125E:
mov rbp, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
test ebx, ebx
lea rax, aFoundAMatch; "Found a match!"
lea rdx, aNotMatched; "Not matched!"
cmovnz rax, rdx
jmp short loc_1247
loc_129C:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "^[[:alnum:]_]+", 1LL);
result = "Regex compilation error";
if ( !v1 )
{
v3 = regexec(v4, a1, 0LL, 0LL, 0LL);
regfree(v4);
result = "Found a match!";
if ( v3 )
return "Not matched!";
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102038]
CALL 0x001010f0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x0010125e
LAB_00101247:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010129c
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_0010125e:
MOV RBP,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
MOV EBX,EAX
MOV RDI,RBP
CALL 0x001010c0
TEST EBX,EBX
LEA RAX,[0x10201c]
LEA RDX,[0x10202b]
CMOVNZ RAX,RDX
JMP 0x00101247
LAB_0010129c:
CALL 0x001010d0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^[[:alnum:]_]+",1);
pcVar2 = "Regex compilation error";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!";
if (iVar1 != 0) {
pcVar2 = "Not matched!";
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
4,070 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "^[[:alnum:]_]+";
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return "Regex compilation error";
}
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0(" python"), "Not matched!") == 0);
assert(strcmp(func0("python"), "Found a match!") == 0);
assert(strcmp(func0(" lang"), "Not matched!") == 0);
assert(strcmp(func0("foo"), "Found a match!") == 0);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xcf6(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10e0 <regcomp@plt>
mov %eax,%r8d
lea 0xc95(%rip),%rax
test %r8d,%r8d
jne 13a1 <func0+0x71>
xor %edx,%edx
xor %ecx,%ecx
mov %rbp,%rsi
mov %r12,%rdi
callq 10f0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 10b0 <regfree@plt>
test %ebp,%ebp
lea 0xc86(%rip),%rax
lea 0xc8e(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13b9 <func0+0x89>
add $0x58,%rsp
pop %rbp
pop %r12
retq
callq 10c0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r12
mov edx, 1
lea rsi, aAlnum; "^[[:alnum:]_]+"
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
mov r8d, eax
lea rax, aRegexCompilati; "Regex compilation error"
test r8d, r8d
jnz short loc_13A1
xor edx, edx
xor ecx, ecx
mov rsi, rbp
mov rdi, r12
call _regexec
mov rdi, r12
mov ebp, eax
call _regfree
test ebp, ebp
lea rax, aFoundAMatch; "Found a match!"
lea rdx, aNotMatched; "Not matched!"
cmovnz rax, rdx
loc_13A1:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_13B9
add rsp, 58h
pop rbp
pop r12
retn
loc_13B9:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // r8d
const char *result; // rax
int v3; // ebp
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "^[[:alnum:]_]+", 1LL);
result = "Regex compilation error";
if ( !v1 )
{
v3 = regexec(v4, a1, 0LL, 0LL);
regfree(v4);
result = "Found a match!";
if ( v3 )
return "Not matched!";
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102038]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010f0
MOV R8D,EAX
LEA RAX,[0x102004]
TEST R8D,R8D
JNZ 0x001013a1
XOR EDX,EDX
XOR ECX,ECX
MOV RSI,RBP
MOV RDI,R12
CALL 0x00101110
MOV RDI,R12
MOV EBP,EAX
CALL 0x001010c0
TEST EBP,EBP
LEA RAX,[0x10201c]
LEA RDX,[0x10202b]
CMOVNZ RAX,RDX
LAB_001013a1:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b9
ADD RSP,0x58
POP RBP
POP R12
RET
LAB_001013b9:
CALL 0x001010d0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^[[:alnum:]_]+",1);
pcVar2 = "Regex compilation error";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!";
if (iVar1 != 0) {
pcVar2 = "Not matched!";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,071 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "^[[:alnum:]_]+";
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return "Regex compilation error";
}
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0(" python"), "Not matched!") == 0);
assert(strcmp(func0("python"), "Found a match!") == 0);
assert(strcmp(func0(" lang"), "Not matched!") == 0);
assert(strcmp(func0("foo"), "Found a match!") == 0);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xcf6(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10e0 <regcomp@plt>
mov %eax,%r8d
lea 0xc95(%rip),%rax
test %r8d,%r8d
jne 13a1 <func0+0x71>
xor %edx,%edx
xor %ecx,%ecx
mov %rbp,%rsi
mov %r12,%rdi
callq 10f0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 10b0 <regfree@plt>
test %ebp,%ebp
lea 0xc86(%rip),%rax
lea 0xc8e(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13b9 <func0+0x89>
add $0x58,%rsp
pop %rbp
pop %r12
retq
callq 10c0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "^[[:alnum:]_]+"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
mov edx, eax
lea rax, aRegexCompilati; "Regex compilation error"
test edx, edx
jnz short loc_13A1
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
lea rax, s2; "Not matched!"
lea rdx, aFoundAMatch; "Found a match!"
cmovz rax, rdx
loc_13A1:
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_13B8
add rsp, 58h
pop rbx
pop rbp
retn
loc_13B8:
call ___stack_chk_fail | const char * func0(char *string)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
v1 = regcomp(&_0, "^[[:alnum:]_]+", 1);
result = "Regex compilation error";
if ( !v1 )
{
v3 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
result = "Not matched!";
if ( !v3 )
return "Found a match!";
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102038]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010f0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JNZ 0x001013a1
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
MOV RDI,RBP
MOV EBX,EAX
CALL 0x001010c0
TEST EBX,EBX
LEA RAX,[0x10202b]
LEA RDX,[0x10201c]
CMOVZ RAX,RDX
LAB_001013a1:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b8
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_001013b8:
CALL 0x001010d0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^[[:alnum:]_]+",1);
pcVar2 = "Regex compilation error";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Not matched!";
if (iVar1 == 0) {
pcVar2 = "Found a match!";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,072 | func0 |
#include <assert.h>
int find_gcd(int x, int y) {
while (y != 0) {
int temp = y;
y = x % y;
x = temp;
}
return x;
}
| int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int gcd = find_gcd(num1, num2);
for (int i = 2; i < size; i++) {
gcd = find_gcd(gcd, l[i]);
}
return gcd;
}
| int main() {
int arr1[] = {2, 4, 6, 8, 16};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 4, 6, 8};
assert(func0(arr1, 5) == 2);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov 0x4(%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1169 <find_gcd>
mov %eax,-0x10(%rbp)
movl $0x2,-0xc(%rbp)
jmp 1204 <func0+0x6a>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1169 <find_gcd>
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11db <func0+0x41>
mov -0x10(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_8], eax
mov rax, [rbp+var_18]
mov eax, [rax+4]
mov [rbp+var_4], eax
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
mov esi, edx
mov edi, eax
call find_gcd
mov [rbp+var_10], eax
mov [rbp+var_C], 2
jmp short loc_1204
loc_11DB:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
mov esi, edx
mov edi, eax
call find_gcd
mov [rbp+var_10], eax
add [rbp+var_C], 1
loc_1204:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11DB
mov eax, [rbp+var_10]
leave
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int gcd; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
gcd = find_gcd(*a1, a1[1]);
for ( i = 2; i < a2; ++i )
gcd = find_gcd(gcd, a1[i]);
return gcd;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
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 + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x2
JMP 0x00101204
LAB_001011db:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV dword ptr [RBP + -0x10],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_00101204:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011db
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | int4 func0(int4 *param_1,int param_2)
{
int4 local_18;
int local_14;
local_18 = find_gcd(*param_1,param_1[1]);
for (local_14 = 2; local_14 < param_2; local_14 = local_14 + 1) {
local_18 = find_gcd(local_18,param_1[local_14]);
}
return local_18;
} |
4,073 | func0 |
#include <assert.h>
int find_gcd(int x, int y) {
while (y != 0) {
int temp = y;
y = x % y;
x = temp;
}
return x;
}
| int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int gcd = find_gcd(num1, num2);
for (int i = 2; i < size; i++) {
gcd = find_gcd(gcd, l[i]);
}
return gcd;
}
| int main() {
int arr1[] = {2, 4, 6, 8, 16};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 4, 6, 8};
assert(func0(arr1, 5) == 2);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%eax
mov 0x4(%rdi),%r8d
test %r8d,%r8d
je 11b9 <func0+0x32>
mov %r8d,%ecx
cltd
idiv %r8d
mov %edx,%r8d
mov %ecx,%eax
test %edx,%edx
jne 1196 <func0+0xf>
cmp $0x2,%esi
jle 11de <func0+0x57>
lea 0x8(%rdi),%r8
lea -0x3(%rsi),%eax
lea 0xc(%rdi,%rax,4),%r9
jmp 11d5 <func0+0x4e>
mov %eax,%ecx
jmp 11a6 <func0+0x1f>
mov %esi,%edi
mov %ecx,%eax
cltd
idiv %esi
mov %edx,%esi
mov %edi,%ecx
test %edx,%edx
jne 11bd <func0+0x36>
add $0x4,%r8
cmp %r9,%r8
je 11de <func0+0x57>
mov (%r8),%esi
test %esi,%esi
jne 11bd <func0+0x36>
jmp 11cc <func0+0x45>
mov %ecx,%eax
retq
| func0:
endbr64
mov eax, [rdi]
mov r8d, [rdi+4]
test r8d, r8d
jz short loc_11D9
loc_1196:
mov ecx, r8d
cdq
idiv r8d
mov r8d, edx
mov eax, ecx
test edx, edx
jnz short loc_1196
loc_11A6:
cmp esi, 2
jle short loc_11D6
lea r8, [rdi+8]
lea eax, [rsi-3]
lea r9, [rdi+rax*4+0Ch]
loc_11B7:
mov esi, [r8]
test esi, esi
jz short loc_11CD
loc_11BE:
mov edi, esi
mov eax, ecx
cdq
idiv esi
mov esi, edx
mov ecx, edi
test edx, edx
jnz short loc_11BE
loc_11CD:
add r8, 4
cmp r8, r9
jnz short loc_11B7
loc_11D6:
mov eax, ecx
retn
loc_11D9:
mov ecx, eax
jmp short loc_11A6 | long long func0(int *a1, int a2)
{
int v2; // eax
int v3; // r8d
int v4; // ecx
int *v5; // r8
long long v6; // r9
int i; // esi
int v8; // edi
v2 = *a1;
v3 = a1[1];
if ( v3 )
{
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
}
else
{
v4 = *a1;
}
if ( a2 > 2 )
{
v5 = a1 + 2;
v6 = (long long)&a1[a2 - 3 + 3];
do
{
for ( i = *v5; i; v4 = v8 )
{
v8 = i;
i = v4 % i;
}
++v5;
}
while ( v5 != (int *)v6 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
MOV R8D,dword ptr [RDI + 0x4]
TEST R8D,R8D
JZ 0x001011d9
LAB_00101196:
MOV ECX,R8D
CDQ
IDIV R8D
MOV R8D,EDX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101196
LAB_001011a6:
CMP ESI,0x2
JLE 0x001011d6
LEA R8,[RDI + 0x8]
LEA EAX,[RSI + -0x3]
LEA R9,[RDI + RAX*0x4 + 0xc]
LAB_001011b7:
MOV ESI,dword ptr [R8]
TEST ESI,ESI
JZ 0x001011cd
LAB_001011be:
MOV EDI,ESI
MOV EAX,ECX
CDQ
IDIV ESI
MOV ESI,EDX
MOV ECX,EDI
TEST EDX,EDX
JNZ 0x001011be
LAB_001011cd:
ADD R8,0x4
CMP R8,R9
JNZ 0x001011b7
LAB_001011d6:
MOV EAX,ECX
RET
LAB_001011d9:
MOV ECX,EAX
JMP 0x001011a6 | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
iVar2 = *param_1;
iVar1 = param_1[1];
while (iVar1 != 0) {
iVar3 = iVar2 % iVar1;
iVar2 = iVar1;
iVar1 = iVar3;
}
if (2 < param_2) {
piVar4 = param_1 + 2;
do {
iVar1 = *piVar4;
while (iVar3 = iVar1, iVar3 != 0) {
iVar1 = iVar2 % iVar3;
iVar2 = iVar3;
}
piVar4 = piVar4 + 1;
} while (piVar4 != param_1 + (ulong)(param_2 - 3) + 3);
}
return iVar2;
} |
4,074 | func0 |
#include <assert.h>
int find_gcd(int x, int y) {
while (y != 0) {
int temp = y;
y = x % y;
x = temp;
}
return x;
}
| int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int gcd = find_gcd(num1, num2);
for (int i = 2; i < size; i++) {
gcd = find_gcd(gcd, l[i]);
}
return gcd;
}
| int main() {
int arr1[] = {2, 4, 6, 8, 16};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 4, 6, 8};
assert(func0(arr1, 5) == 2);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
mov 0x4(%rdi),%r8d
mov (%rdi),%eax
test %r8d,%r8d
jne 12eb <func0+0x1b>
jmp 133b <func0+0x6b>
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 12e8 <func0+0x18>
cmp $0x2,%esi
jle 1337 <func0+0x67>
lea -0x3(%rsi),%eax
lea 0x8(%rdi),%rcx
lea 0xc(%rdi,%rax,4),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rcx),%edx
test %edx,%edx
je 132e <func0+0x5e>
mov %r8d,%eax
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 1320 <func0+0x50>
add $0x4,%rcx
cmp %rsi,%rcx
jne 1310 <func0+0x40>
mov %r8d,%eax
retq
mov %eax,%r8d
jmp 12f6 <func0+0x26>
| func0:
endbr64
mov r8d, [rdi+4]
mov eax, [rdi]
test r8d, r8d
jnz short loc_12DB
jmp short loc_132B
loc_12D8:
mov r8d, edx
loc_12DB:
cdq
idiv r8d
mov eax, r8d
test edx, edx
jnz short loc_12D8
loc_12E6:
cmp esi, 2
jle short loc_1327
lea eax, [rsi-3]
lea rcx, [rdi+8]
lea rsi, [rdi+rax*4+0Ch]
nop word ptr [rax+rax+00000000h]
loc_1300:
mov edx, [rcx]
test edx, edx
jz short loc_131E
mov eax, r8d
nop dword ptr [rax+00000000h]
loc_1310:
mov r8d, edx
cdq
idiv r8d
mov eax, r8d
test edx, edx
jnz short loc_1310
loc_131E:
add rcx, 4
cmp rcx, rsi
jnz short loc_1300
loc_1327:
mov eax, r8d
retn
loc_132B:
mov r8d, eax
jmp short loc_12E6 | long long func0(int *a1, int a2)
{
int v2; // r8d
int v3; // eax
int v4; // edx
int *v5; // rcx
long long v6; // rsi
int v7; // edx
int v8; // eax
v2 = a1[1];
v3 = *a1;
if ( v2 )
{
while ( 1 )
{
v4 = v3 % v2;
v3 = v2;
if ( !v4 )
break;
v2 = v4;
}
}
else
{
v2 = *a1;
}
if ( a2 > 2 )
{
v5 = a1 + 2;
v6 = (long long)&a1[a2 - 3 + 3];
do
{
v7 = *v5;
if ( *v5 )
{
v8 = v2;
do
{
v2 = v7;
v7 = v8 % v7;
v8 = v2;
}
while ( v7 );
}
++v5;
}
while ( v5 != (int *)v6 );
}
return (unsigned int)v2;
} | func0:
ENDBR64
MOV R8D,dword ptr [RDI + 0x4]
MOV EAX,dword ptr [RDI]
TEST R8D,R8D
JNZ 0x001012db
JMP 0x0010132b
LAB_001012d8:
MOV R8D,EDX
LAB_001012db:
CDQ
IDIV R8D
MOV EAX,R8D
TEST EDX,EDX
JNZ 0x001012d8
LAB_001012e6:
CMP ESI,0x2
JLE 0x00101327
LEA EAX,[RSI + -0x3]
LEA RCX,[RDI + 0x8]
LEA RSI,[RDI + RAX*0x4 + 0xc]
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JZ 0x0010131e
MOV EAX,R8D
NOP dword ptr [RAX]
LAB_00101310:
MOV R8D,EDX
CDQ
IDIV R8D
MOV EAX,R8D
TEST EDX,EDX
JNZ 0x00101310
LAB_0010131e:
ADD RCX,0x4
CMP RCX,RSI
JNZ 0x00101300
LAB_00101327:
MOV EAX,R8D
RET
LAB_0010132b:
MOV R8D,EAX
JMP 0x001012e6 | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar2 = param_1[1];
iVar4 = *param_1;
while (iVar1 = iVar2, iVar1 != 0) {
iVar2 = iVar4 % iVar1;
iVar4 = iVar1;
}
if (2 < param_2) {
piVar3 = param_1 + 2;
do {
iVar2 = *piVar3;
while (iVar1 = iVar2, iVar1 != 0) {
iVar2 = iVar4 % iVar1;
iVar4 = iVar1;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 3) + 3);
}
return iVar4;
} |
4,075 | func0 |
#include <assert.h>
int find_gcd(int x, int y) {
while (y != 0) {
int temp = y;
y = x % y;
x = temp;
}
return x;
}
| int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int gcd = find_gcd(num1, num2);
for (int i = 2; i < size; i++) {
gcd = find_gcd(gcd, l[i]);
}
return gcd;
}
| int main() {
int arr1[] = {2, 4, 6, 8, 16};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 4, 6, 8};
assert(func0(arr1, 5) == 2);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
mov 0x4(%rdi),%r8d
mov (%rdi),%eax
test %r8d,%r8d
jne 12eb <func0+0x1b>
jmp 133b <func0+0x6b>
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 12e8 <func0+0x18>
cmp $0x2,%esi
jle 1337 <func0+0x67>
lea -0x3(%rsi),%eax
lea 0x8(%rdi),%rcx
lea 0xc(%rdi,%rax,4),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rcx),%edx
test %edx,%edx
je 132e <func0+0x5e>
mov %r8d,%eax
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 1320 <func0+0x50>
add $0x4,%rcx
cmp %rsi,%rcx
jne 1310 <func0+0x40>
mov %r8d,%eax
retq
mov %eax,%r8d
jmp 12f6 <func0+0x26>
| func0:
endbr64
mov ecx, [rdi+4]
mov eax, [rdi]
test ecx, ecx
jnz short loc_1332
jmp short loc_1377
loc_1330:
mov ecx, edx
loc_1332:
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1330
loc_133B:
cmp esi, 2
jle short loc_1374
lea eax, [rsi-3]
lea r8, [rdi+8]
lea rsi, [rdi+rax*4+0Ch]
nop dword ptr [rax+00h]
loc_1350:
mov edx, [r8]
test edx, edx
jz short loc_136B
mov eax, ecx
nop dword ptr [rax+00000000h]
loc_1360:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1360
loc_136B:
add r8, 4
cmp r8, rsi
jnz short loc_1350
loc_1374:
mov eax, ecx
retn
loc_1377:
mov ecx, eax
jmp short loc_133B | long long func0(int *a1, int a2)
{
int v2; // ecx
int v3; // eax
int v4; // edx
int *v5; // r8
long long v6; // rsi
int v7; // edx
int v8; // eax
v2 = a1[1];
v3 = *a1;
if ( v2 )
{
while ( 1 )
{
v4 = v3 % v2;
v3 = v2;
if ( !v4 )
break;
v2 = v4;
}
}
else
{
v2 = *a1;
}
if ( a2 > 2 )
{
v5 = a1 + 2;
v6 = (long long)&a1[a2 - 3 + 3];
do
{
v7 = *v5;
if ( *v5 )
{
v8 = v2;
do
{
v2 = v7;
v7 = v8 % v7;
v8 = v2;
}
while ( v7 );
}
++v5;
}
while ( v5 != (int *)v6 );
}
return (unsigned int)v2;
} | func0:
ENDBR64
MOV ECX,dword ptr [RDI + 0x4]
MOV EAX,dword ptr [RDI]
TEST ECX,ECX
JNZ 0x00101332
JMP 0x00101377
LAB_00101330:
MOV ECX,EDX
LAB_00101332:
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101330
LAB_0010133b:
CMP ESI,0x2
JLE 0x00101374
LEA EAX,[RSI + -0x3]
LEA R8,[RDI + 0x8]
LEA RSI,[RDI + RAX*0x4 + 0xc]
NOP dword ptr [RAX]
LAB_00101350:
MOV EDX,dword ptr [R8]
TEST EDX,EDX
JZ 0x0010136b
MOV EAX,ECX
NOP dword ptr [RAX]
LAB_00101360:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101360
LAB_0010136b:
ADD R8,0x4
CMP R8,RSI
JNZ 0x00101350
LAB_00101374:
MOV EAX,ECX
RET
LAB_00101377:
MOV ECX,EAX
JMP 0x0010133b | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
iVar2 = param_1[1];
iVar3 = *param_1;
while (iVar1 = iVar2, iVar1 != 0) {
iVar2 = iVar3 % iVar1;
iVar3 = iVar1;
}
if (2 < param_2) {
piVar4 = param_1 + 2;
do {
iVar2 = *piVar4;
while (iVar1 = iVar2, iVar1 != 0) {
iVar2 = iVar3 % iVar1;
iVar3 = iVar1;
}
piVar4 = piVar4 + 1;
} while (piVar4 != param_1 + (ulong)(param_2 - 3) + 3);
}
return iVar3;
} |
4,076 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int data[], int length) {
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (data[i] == data[j]) {
return false;
}
}
}
return true;
}
| int main() {
int data1[] = {1, 5, 7, 9};
int data2[] = {2, 4, 5, 5, 7, 9};
int data3[] = {1, 2, 3};
int length1 = sizeof(data1) / sizeof(data1[0]);
int length2 = sizeof(data2) / sizeof(data2[0]);
int length3 = sizeof(data3) / sizeof(data3[0]);
assert(func0(data1, length1) == true);
assert(func0(data2, length2) == false);
assert(func0(data3, length3) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d3 <func0+0x6a>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11c7 <func0+0x5e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11c3 <func0+0x5a>
mov $0x0,%eax
jmp 11e0 <func0+0x77>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118c <func0+0x23>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
jmp short loc_11D3
loc_1181:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11C7
loc_118C:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11C3
mov eax, 0
jmp short loc_11E0
loc_11C3:
add [rbp+var_4], 1
loc_11C7:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118C
add [rbp+var_8], 1
loc_11D3:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 1
loc_11E0:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
return 0LL;
}
}
return 1LL;
} | 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
JMP 0x001011d3
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011c7
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011c3
MOV EAX,0x0
JMP 0x001011e0
LAB_001011c3:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c7:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118c
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d3:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x1
LAB_001011e0:
POP RBP
RET | int8 func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
do {
local_c = local_10;
if (param_2 <= local_10) {
return 1;
}
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_1 + (long)local_c * 4)) {
return 0;
}
}
local_10 = local_10 + 1;
} while( true );
} |
4,077 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int data[], int length) {
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (data[i] == data[j]) {
return false;
}
}
}
return true;
}
| int main() {
int data1[] = {1, 5, 7, 9};
int data2[] = {2, 4, 5, 5, 7, 9};
int data3[] = {1, 2, 3};
int length1 = sizeof(data1) / sizeof(data1[0]);
int length2 = sizeof(data2) / sizeof(data2[0]);
int length3 = sizeof(data3) / sizeof(data3[0]);
assert(func0(data1, length1) == true);
assert(func0(data2, length2) == false);
assert(func0(data3, length3) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 119d <func0+0x34>
lea -0x1(%rsi),%r8d
add $0x1,%r8
mov $0x1,%ecx
cmp %r8,%rcx
je 11a3 <func0+0x3a>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
cmp (%rdi,%rax,4),%edx
je 11a9 <func0+0x40>
add $0x1,%rax
cmp %eax,%esi
jg 118a <func0+0x21>
add $0x1,%rcx
jmp 117e <func0+0x15>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1198
mov r8d, esi
mov ecx, 1
loc_1179:
cmp rcx, r8
jz short loc_119E
mov edx, [rdi+rcx*4-4]
mov rax, rcx
loc_1185:
cmp edx, [rdi+rax*4]
jz short loc_11A4
add rax, 1
cmp esi, eax
jg short loc_1185
add rcx, 1
jmp short loc_1179
loc_1198:
mov eax, 1
retn
loc_119E:
mov eax, 1
retn
loc_11A4:
mov eax, 0
retn | long long func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v2 = 1LL;
LABEL_3:
if ( v2 == a2 )
return 1LL;
v3 = v2;
while ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v3) )
{
if ( a2 <= (int)++v3 )
{
++v2;
goto LABEL_3;
}
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101198
MOV R8D,ESI
MOV ECX,0x1
LAB_00101179:
CMP RCX,R8
JZ 0x0010119e
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
LAB_00101185:
CMP EDX,dword ptr [RDI + RAX*0x4]
JZ 0x001011a4
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101185
ADD RCX,0x1
JMP 0x00101179
LAB_00101198:
MOV EAX,0x1
RET
LAB_0010119e:
MOV EAX,0x1
RET
LAB_001011a4:
MOV EAX,0x0
RET | int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if ((int)param_2 < 1) {
return 1;
}
uVar2 = 1;
do {
if (uVar2 == param_2) {
return 1;
}
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) == *(int *)(param_1 + uVar1 * 4)) {
return 0;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
uVar2 = uVar2 + 1;
} while( true );
} |
4,078 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int data[], int length) {
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (data[i] == data[j]) {
return false;
}
}
}
return true;
}
| int main() {
int data1[] = {1, 5, 7, 9};
int data2[] = {2, 4, 5, 5, 7, 9};
int data3[] = {1, 2, 3};
int length1 = sizeof(data1) / sizeof(data1[0]);
int length2 = sizeof(data2) / sizeof(data2[0]);
int length3 = sizeof(data3) / sizeof(data3[0]);
assert(func0(data1, length1) == true);
assert(func0(data2, length2) == false);
assert(func0(data3, length3) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 12f9 <func0+0x49>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %r8,%rcx
je 12f9 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 12e0 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 12f0 <func0+0x40>
cmp (%rdi,%rax,4),%edx
jne 12d8 <func0+0x28>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%rcx
cmp %r8,%rcx
jne 12ca <func0+0x1a>
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_12C9
movsxd r8, esi
mov ecx, 1
cmp rcx, r8
jz short loc_12C9
loc_12A5:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
jmp short loc_12B8
loc_12B0:
add rax, 1
cmp esi, eax
jle short loc_12C0
loc_12B8:
cmp edx, [rdi+rax*4]
jnz short loc_12B0
xor eax, eax
retn
loc_12C0:
add rcx, 1
cmp rcx, r8
jnz short loc_12A5
loc_12C9:
mov eax, 1
retn | long long func0(long long a1, int a2)
{
long long i; // rcx
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; i != a2; ++i )
{
v3 = i;
do
{
if ( *(_DWORD *)(a1 + 4 * i - 4) == *(_DWORD *)(a1 + 4 * v3) )
return 0LL;
++v3;
}
while ( a2 > (int)v3 );
}
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012c9
MOVSXD R8,ESI
MOV ECX,0x1
CMP RCX,R8
JZ 0x001012c9
LAB_001012a5:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
JMP 0x001012b8
LAB_001012b0:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x001012c0
LAB_001012b8:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x001012b0
XOR EAX,EAX
RET
LAB_001012c0:
ADD RCX,0x1
CMP RCX,R8
JNZ 0x001012a5
LAB_001012c9:
MOV EAX,0x1
RET | int8 func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
if (0 < param_2) {
lVar2 = 1;
if ((long)param_2 != 1) {
do {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + -4 + lVar2 * 4) == *(int *)(param_1 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while ((int)lVar1 < param_2);
lVar2 = lVar2 + 1;
} while (lVar2 != param_2);
}
}
return 1;
} |
4,079 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int data[], int length) {
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (data[i] == data[j]) {
return false;
}
}
}
return true;
}
| int main() {
int data1[] = {1, 5, 7, 9};
int data2[] = {2, 4, 5, 5, 7, 9};
int data3[] = {1, 2, 3};
int length1 = sizeof(data1) / sizeof(data1[0]);
int length2 = sizeof(data2) / sizeof(data2[0]);
int length3 = sizeof(data3) / sizeof(data3[0]);
assert(func0(data1, length1) == true);
assert(func0(data2, length2) == false);
assert(func0(data3, length3) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1309 <func0+0x49>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %r8,%rcx
je 1309 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 12f0 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 1300 <func0+0x40>
cmp (%rdi,%rax,4),%edx
jne 12e8 <func0+0x28>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%rcx
cmp %r8,%rcx
jne 12da <func0+0x1a>
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1179
mov r8d, esi
mov ecx, 1
cmp rcx, r8
jz short loc_1179
loc_1155:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
jmp short loc_1168
loc_1160:
add rax, 1
cmp esi, eax
jle short loc_1170
loc_1168:
cmp edx, [rdi+rax*4]
jnz short loc_1160
xor eax, eax
retn
loc_1170:
add rcx, 1
cmp rcx, r8
jnz short loc_1155
loc_1179:
mov eax, 1
retn | long long func0(long long a1, int a2)
{
long long i; // rcx
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; i != a2; ++i )
{
v3 = i;
do
{
if ( *(_DWORD *)(a1 + 4 * i - 4) == *(_DWORD *)(a1 + 4 * v3) )
return 0LL;
++v3;
}
while ( a2 > (int)v3 );
}
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101179
MOV R8D,ESI
MOV ECX,0x1
CMP RCX,R8
JZ 0x00101179
LAB_00101155:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
JMP 0x00101168
LAB_00101160:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101170
LAB_00101168:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101160
XOR EAX,EAX
RET
LAB_00101170:
ADD RCX,0x1
CMP RCX,R8
JNZ 0x00101155
LAB_00101179:
MOV EAX,0x1
RET | int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_2) {
uVar2 = 1;
if ((ulong)param_2 != 1) {
do {
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) == *(int *)(param_1 + uVar1 * 4)) {
return 0;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
}
return 1;
} |
4,080 | func0 |
#include <assert.h>
| int func0(int A, int B) {
int variable = 1;
if (A == B) {
return 1;
} else if ((B - A) >= 5) {
return 0;
} else {
for (int i = A + 1; i <= B; i++) {
variable = (variable * (i % 10)) % 10;
}
return variable % 10;
}
}
| int main() {
assert(func0(2, 4) == 2);
assert(func0(6, 8) == 6);
assert(func0(1, 2) == 2);
assert(func0(3, 7) == 0);
assert(func0(20, 23) == 6);
assert(func0(1021, 1024) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x1,-0x8(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jne 1170 <func0+0x27>
mov $0x1,%edx
jmpq 1226 <func0+0xdd>
mov -0x18(%rbp),%eax
sub -0x14(%rbp),%eax
cmp $0x4,%eax
jle 1185 <func0+0x3c>
mov $0x0,%edx
jmpq 1226 <func0+0xdd>
mov -0x14(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11f4 <func0+0xab>
mov -0x4(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
imul -0x8(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 1190 <func0+0x47>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
mov %edx,%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], 1
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jnz short loc_1170
mov edx, 1
jmp loc_1220
loc_1170:
mov eax, [rbp+var_18]
sub eax, [rbp+var_14]
cmp eax, 4
jle short loc_1185
mov edx, 0
jmp loc_1220
loc_1185:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11EE
loc_1190:
mov ecx, [rbp+var_4]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
imul edx, [rbp+var_8]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
sar eax, 2
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
mov [rbp+var_8], eax
mov ecx, [rbp+var_8]
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_8], edx
add [rbp+var_4], 1
loc_11EE:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_18]
jle short loc_1190
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
loc_1220:
mov eax, edx
pop rbp
retn | long long func0(int a1, int a2)
{
int v4; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v4 = 1;
if ( a1 == a2 )
{
return 1;
}
else if ( a2 - a1 <= 4 )
{
for ( i = a1 + 1; i <= a2; ++i )
v4 = v4 * (i % 10) % 10;
return (unsigned int)(v4 % 10);
}
else
{
return 0;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JNZ 0x00101170
MOV EDX,0x1
JMP 0x00101220
LAB_00101170:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,dword ptr [RBP + -0x14]
CMP EAX,0x4
JLE 0x00101185
MOV EDX,0x0
JMP 0x00101220
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011ee
LAB_00101190:
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
IMUL EDX,dword ptr [RBP + -0x8]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
SAR EAX,0x2
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
MOV dword ptr [RBP + -0x8],EAX
MOV ECX,dword ptr [RBP + -0x8]
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x8],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ee:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x00101190
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
LAB_00101220:
MOV EAX,EDX
POP RBP
RET | int func0(int param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
if (param_1 == param_2) {
local_10 = 1;
}
else if (param_2 - param_1 < 5) {
for (local_c = param_1 + 1; local_c <= param_2; local_c = local_c + 1) {
local_10 = ((local_c % 10) * local_10) % 10;
}
local_10 = local_10 % 10;
}
else {
local_10 = 0;
}
return local_10;
} |
4,081 | func0 |
#include <assert.h>
| int func0(int A, int B) {
int variable = 1;
if (A == B) {
return 1;
} else if ((B - A) >= 5) {
return 0;
} else {
for (int i = A + 1; i <= B; i++) {
variable = (variable * (i % 10)) % 10;
}
return variable % 10;
}
}
| int main() {
assert(func0(2, 4) == 2);
assert(func0(6, 8) == 6);
assert(func0(1, 2) == 2);
assert(func0(3, 7) == 0);
assert(func0(20, 23) == 6);
assert(func0(1021, 1024) == 4);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
cmp %esi,%edi
je 11dd <func0+0x94>
mov %esi,%edx
sub %edi,%edx
mov $0x0,%eax
cmp $0x4,%edx
jg 11dd <func0+0x94>
add $0x1,%edi
cmp %edi,%esi
jl 11de <func0+0x95>
add $0x1,%esi
mov $0x1,%edx
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
mov %edi,%ecx
sub %eax,%ecx
mov %ecx,%eax
imul %edx,%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%ecx
sar $0x1f,%ecx
sub %ecx,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
mov %eax,%edx
add $0x1,%edi
cmp %esi,%edi
jne 1177 <func0+0x2e>
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
retq
mov $0x1,%edx
jmp 11bf <func0+0x76>
| func0:
endbr64
mov eax, 1
cmp edi, esi
jz locret_11DB
mov edx, esi
sub edx, edi
mov eax, 0
cmp edx, 4
jg short locret_11DB
lea ecx, [rdi+1]
cmp esi, ecx
jl short loc_11DC
lea edi, [rsi+1]
mov edx, 1
loc_1177:
movsxd rax, ecx
imul rax, 66666667h
sar rax, 22h
mov esi, ecx
sar esi, 1Fh
sub eax, esi
lea esi, [rax+rax*4]
add esi, esi
mov eax, ecx
sub eax, esi
imul eax, edx
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
mov esi, eax
sar esi, 1Fh
sub edx, esi
lea esi, [rdx+rdx*4]
add esi, esi
sub eax, esi
mov edx, eax
add ecx, 1
cmp ecx, edi
jnz short loc_1177
loc_11BD:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
mov eax, edx
sub eax, ecx
locret_11DB:
retn
loc_11DC:
mov edx, 1
jmp short loc_11BD | long long func0(int a1, int a2)
{
long long result; // rax
int v3; // ecx
int v4; // edx
result = 1LL;
if ( a1 != a2 )
{
result = 0LL;
if ( a2 - a1 <= 4 )
{
v3 = a1 + 1;
if ( a2 < a1 + 1 )
{
v4 = 1;
}
else
{
v4 = 1;
do
{
v4 = v4 * (v3 % 10) % 10;
++v3;
}
while ( v3 != a2 + 1 );
}
return (unsigned int)(v4 % 10);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
CMP EDI,ESI
JZ 0x001011db
MOV EDX,ESI
SUB EDX,EDI
MOV EAX,0x0
CMP EDX,0x4
JG 0x001011db
LEA ECX,[RDI + 0x1]
CMP ESI,ECX
JL 0x001011dc
LEA EDI,[RSI + 0x1]
MOV EDX,0x1
LAB_00101177:
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ESI,ECX
SAR ESI,0x1f
SUB EAX,ESI
LEA ESI,[RAX + RAX*0x4]
ADD ESI,ESI
MOV EAX,ECX
SUB EAX,ESI
IMUL EAX,EDX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ESI,EAX
SAR ESI,0x1f
SUB EDX,ESI
LEA ESI,[RDX + RDX*0x4]
ADD ESI,ESI
SUB EAX,ESI
MOV EDX,EAX
ADD ECX,0x1
CMP ECX,EDI
JNZ 0x00101177
LAB_001011bd:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
MOV EAX,EDX
SUB EAX,ECX
LAB_001011db:
RET
LAB_001011dc:
MOV EDX,0x1
JMP 0x001011bd | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = 1;
if ((param_1 != param_2) && (iVar1 = 0, param_2 - param_1 < 5)) {
param_1 = param_1 + 1;
if (param_2 < param_1) {
iVar1 = 1;
}
else {
iVar1 = 1;
do {
iVar1 = ((param_1 % 10) * iVar1) % 10;
param_1 = param_1 + 1;
} while (param_1 != param_2 + 1);
}
iVar1 = iVar1 % 10;
}
return iVar1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.