index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
5,482 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
median = b;
} else {
median = c;
}
}
return median;
}
| int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1150 <func0+0x10>
cmp %edx,%edi
jge 1160 <func0+0x20>
retq
cmp %edx,%edi
jg 114e <func0+0xe>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
nopl 0x0(%rax)
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1158
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_1158:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101158
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_00101158:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <= param_3) {
param_1 = param_2;
}
return param_1;
} |
5,483 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
median = b;
} else {
median = c;
}
}
return median;
}
| int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1150 <func0+0x10>
cmp %edx,%edi
jge 1160 <func0+0x20>
retq
cmp %edx,%edi
jg 114e <func0+0xe>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
nopl 0x0(%rax)
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1158
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_1158:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101158
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_00101158:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <= param_3) {
param_1 = param_2;
}
return param_1;
} |
5,484 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 1201 <func0+0x98>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 11f7 <func0+0x8e>
negl -0x4(%rbp)
jmp 11f7 <func0+0x8e>
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
add %edx,-0xc(%rbp)
mov -0x4(%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,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jg 11ac <func0+0x43>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_1201
loc_1188:
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_4], eax
cmp [rbp+var_4], 0
jns short loc_11F7
neg [rbp+var_4]
jmp short loc_11F7
loc_11AC:
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
add [rbp+var_C], edx
mov eax, [rbp+var_4]
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_4], eax
loc_11F7:
cmp [rbp+var_4], 0
jg short loc_11AC
add [rbp+var_8], 1
loc_1201:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_1188
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int v5; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = *(_DWORD *)(4LL * i + a1);
if ( v5 < 0 )
v5 = -v5;
while ( v5 > 0 )
{
v3 += v5 % 10;
v5 /= 10;
}
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101201
LAB_00101188:
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 + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x0
JNS 0x001011f7
NEG dword ptr [RBP + -0x4]
JMP 0x001011f7
LAB_001011ac:
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
ADD dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [RBP + -0x4]
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 + -0x4],EAX
LAB_001011f7:
CMP dword ptr [RBP + -0x4],0x0
JG 0x001011ac
ADD dword ptr [RBP + -0x8],0x1
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
local_c = *(int *)(param_1 + (long)local_10 * 4);
if (local_c < 0) {
local_c = -local_c;
}
for (; 0 < local_c; local_c = local_c / 10) {
local_14 = local_14 + local_c % 10;
}
}
return local_14;
} |
5,485 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ca <func0+0x61>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%esi
jmp 118c <func0+0x23>
add $0x4,%r8
cmp %rdi,%r8
je 11cf <func0+0x66>
mov (%r8),%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
sub %eax,%edx
test %edx,%edx
jle 1183 <func0+0x1a>
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
mov %edx,%r9d
sub %ecx,%r9d
add %r9d,%esi
mov %edx,%ecx
mov %eax,%edx
cmp $0x9,%ecx
jg 119c <func0+0x33>
jmp 1183 <func0+0x1a>
mov $0x0,%esi
mov %esi,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11C4
mov r8, rdi
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
mov esi, 0
loc_1181:
mov eax, [r8]
mov edx, eax
neg edx
cmovs edx, eax
test edx, edx
jle short loc_11B8
loc_118F:
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 edi, edx
sub edi, ecx
add esi, edi
mov ecx, edx
mov edx, eax
cmp ecx, 9
jg short loc_118F
loc_11B8:
add r8, 4
cmp r8, r9
jnz short loc_1181
loc_11C1:
mov eax, esi
retn
loc_11C4:
mov esi, 0
jmp short loc_11C1 | long long func0(int *a1, int a2)
{
int *v2; // r8
long long v3; // r9
unsigned int v4; // esi
int v5; // edx
int v6; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
v5 = -*v2;
if ( *v2 > 0 )
v5 = *v2;
if ( v5 > 0 )
{
do
{
v4 += v5 % 10;
v6 = v5;
v5 /= 10;
}
while ( v6 > 9 );
}
++v2;
}
while ( v2 != (int *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c4
MOV R8,RDI
LEA EAX,[RSI + -0x1]
LEA R9,[RDI + RAX*0x4 + 0x4]
MOV ESI,0x0
LAB_00101181:
MOV EAX,dword ptr [R8]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EDX,EDX
JLE 0x001011b8
LAB_0010118f:
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 EDI,EDX
SUB EDI,ECX
ADD ESI,EDI
MOV ECX,EDX
MOV EDX,EAX
CMP ECX,0x9
JG 0x0010118f
LAB_001011b8:
ADD R8,0x4
CMP R8,R9
JNZ 0x00101181
LAB_001011c1:
MOV EAX,ESI
RET
LAB_001011c4:
MOV ESI,0x0
JMP 0x001011c1 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
iVar5 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar5 = 0;
do {
iVar2 = *param_1;
iVar4 = -iVar2;
if (0 < iVar2) {
iVar4 = iVar2;
}
if (0 < iVar4) {
do {
iVar5 = iVar5 + iVar4 % 10;
bVar3 = 9 < iVar4;
iVar4 = iVar4 / 10;
} while (bVar3);
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar5;
} |
5,486 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13ef <func0+0x5f>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r9
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
mov %eax,%ecx
sar $0x1f,%ecx
mov %ecx,%edx
xor %eax,%edx
sub %ecx,%edx
test %eax,%eax
je 13e2 <func0+0x52>
nopl 0x0(%rax)
mov %edx,%eax
imul %rsi,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%edx
add %edx,%r8d
mov %eax,%edx
test %eax,%eax
jne 13c8 <func0+0x38>
add $0x4,%rdi
cmp %r9,%rdi
jne 13b0 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12F7
lea eax, [rsi-1]
xor r8d, r8d
mov esi, 0CCCCCCCDh
lea r9, [rdi+rax*4+4]
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov eax, [rdi]
mov edx, eax
neg edx
cmovs edx, eax
test eax, eax
jz short loc_12EA
nop dword ptr [rax]
loc_12D0:
mov eax, edx
imul rax, rsi
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
add r8d, edx
mov edx, eax
test eax, eax
jnz short loc_12D0
loc_12EA:
add rdi, 4
cmp rdi, r9
jnz short loc_12C0
mov eax, r8d
retn
loc_12F7:
xor r8d, r8d
mov eax, r8d
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r8d
long long v3; // r9
unsigned int v4; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[a2 - 1 + 1];
do
{
v4 = -*a1;
if ( (int)*a1 > 0 )
v4 = *a1;
if ( *a1 )
{
do
{
v2 += v4 % 0xA;
v4 /= 0xAu;
}
while ( v4 );
}
++a1;
}
while ( a1 != (unsigned int *)v3 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012f7
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
MOV ESI,0xcccccccd
LEA R9,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EAX,dword ptr [RDI]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EAX,EAX
JZ 0x001012ea
NOP dword ptr [RAX]
LAB_001012d0:
MOV EAX,EDX
IMUL RAX,RSI
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
ADD R8D,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x001012d0
LAB_001012ea:
ADD RDI,0x4
CMP RDI,R9
JNZ 0x001012c0
MOV EAX,R8D
RET
LAB_001012f7:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
int iVar4;
if (0 < param_2) {
iVar4 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
uVar3 = *param_1;
uVar2 = -uVar3;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
while (uVar3 != 0) {
iVar4 = iVar4 + uVar2 % 10;
uVar3 = uVar2 / 10;
uVar2 = uVar3;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return iVar4;
}
return 0;
} |
5,487 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 139f <func0+0x5f>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r9
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
mov %eax,%ecx
sar $0x1f,%ecx
mov %ecx,%edx
xor %eax,%edx
sub %ecx,%edx
test %eax,%eax
je 1392 <func0+0x52>
nopl 0x0(%rax)
mov %edx,%eax
imul %rsi,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%edx
add %edx,%r8d
mov %eax,%edx
test %eax,%eax
jne 1378 <func0+0x38>
add $0x4,%rdi
cmp %rdi,%r9
jne 1360 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1395
movsxd rsi, esi
mov r8d, 0CCCCCCCDh
lea r9, [rdi+rsi*4]
xor esi, esi
nop word ptr [rax+rax+00000000h]
loc_1360:
mov eax, [rdi]
mov edx, eax
neg edx
cmovs edx, eax
test eax, eax
jz short loc_1389
nop dword ptr [rax]
loc_1370:
mov eax, edx
imul rax, r8
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
add esi, edx
mov edx, eax
test eax, eax
jnz short loc_1370
loc_1389:
add rdi, 4
cmp r9, rdi
jnz short loc_1360
mov eax, esi
retn
loc_1395:
xor esi, esi
mov eax, esi
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // r9
unsigned int v3; // esi
unsigned int v4; // edx
if ( a2 <= 0 )
return 0LL;
v2 = &a1[a2];
v3 = 0;
do
{
v4 = -*a1;
if ( (int)*a1 > 0 )
v4 = *a1;
if ( *a1 )
{
do
{
v3 += v4 % 0xA;
v4 /= 0xAu;
}
while ( v4 );
}
++a1;
}
while ( v2 != a1 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101395
MOVSXD RSI,ESI
MOV R8D,0xcccccccd
LEA R9,[RDI + RSI*0x4]
XOR ESI,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101360:
MOV EAX,dword ptr [RDI]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EAX,EAX
JZ 0x00101389
NOP dword ptr [RAX]
LAB_00101370:
MOV EAX,EDX
IMUL RAX,R8
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
ADD ESI,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x00101370
LAB_00101389:
ADD RDI,0x4
CMP R9,RDI
JNZ 0x00101360
MOV EAX,ESI
RET
LAB_00101395:
XOR ESI,ESI
MOV EAX,ESI
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
int iVar4;
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar4 = 0;
do {
uVar3 = *param_1;
uVar2 = -uVar3;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
while (uVar3 != 0) {
iVar4 = iVar4 + uVar2 % 10;
uVar3 = uVar2 / 10;
uVar2 = uVar3;
}
param_1 = param_1 + 1;
} while (puVar1 != param_1);
return iVar4;
}
return 0;
} |
5,488 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int test_tup3[4] = {11, 5, 7, 10};
int test_tup4[4] = {6, 3, 4, 4};
int expected2[4] = {13, 6, 3, 14};
func0(test_tup3, test_tup4, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected2[i]);
}
int test_tup5[4] = {12, 6, 8, 11};
int test_tup6[4] = {7, 4, 5, 6};
int expected3[4] = {11, 2, 13, 13};
func0(test_tup5, test_tup6, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x28(%rbp),%rax
add %rsi,%rax
xor %ecx,%edx
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1189 <func0+0x20>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11D1
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rsi
xor edx, ecx
mov [rax], edx
add [rbp+var_4], 1
loc_11D1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_1189
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
*(_DWORD *)(4LL * (int)i + a3) = *(_DWORD *)(4LL * (int)i + a1) ^ *(_DWORD *)(4LL * (int)i + a2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RSI
XOR EDX,ECX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101189
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(uint *)(param_3 + (long)local_c * 4) =
*(uint *)(param_2 + (long)local_c * 4) ^ *(uint *)(param_1 + (long)local_c * 4);
}
return;
} |
5,489 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int test_tup3[4] = {11, 5, 7, 10};
int test_tup4[4] = {6, 3, 4, 4};
int expected2[4] = {13, 6, 3, 14};
func0(test_tup3, test_tup4, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected2[i]);
}
int test_tup5[4] = {12, 6, 8, 11};
int test_tup6[4] = {7, 4, 5, 6};
int expected3[4] = {11, 2, 13, 13};
func0(test_tup5, test_tup6, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 118f <func0+0x26>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov (%rdi,%rax,4),%ecx
xor (%rsi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 117a <func0+0x11>
retq
| func0:
endbr64
test ecx, ecx
jle short locret_118D
mov ecx, ecx
mov eax, 0
loc_1178:
mov r8d, [rdi+rax*4]
xor r8d, [rsi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rax, rcx
jnz short loc_1178
locret_118D:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a2 + 4 * i) ^ *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x0010118d
MOV ECX,ECX
MOV EAX,0x0
LAB_00101178:
MOV R8D,dword ptr [RDI + RAX*0x4]
XOR R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101178
LAB_0010118d:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(uint *)(param_3 + uVar1 * 4) =
*(uint *)(param_1 + uVar1 * 4) ^ *(uint *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;
} |
5,490 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int test_tup3[4] = {11, 5, 7, 10};
int test_tup4[4] = {6, 3, 4, 4};
int expected2[4] = {13, 6, 3, 14};
func0(test_tup3, test_tup4, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected2[i]);
}
int test_tup5[4] = {12, 6, 8, 11};
int test_tup6[4] = {7, 4, 5, 6};
int expected3[4] = {11, 2, 13, 13};
func0(test_tup5, test_tup6, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1165 <func0+0x25>
lea -0x1(%rcx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rdi,%rax,4),%ecx
xor (%rsi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 1150 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test ecx, ecx
jle short locret_1425
movsxd rcx, ecx
xor eax, eax
nop dword ptr [rax]
loc_1410:
mov r8d, [rdi+rax*4]
xor r8d, [rsi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rcx, rax
jnz short loc_1410
locret_1425:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a2 + 4 * i) ^ *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101425
MOVSXD RCX,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101410:
MOV R8D,dword ptr [RDI + RAX*0x4]
XOR R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101410
LAB_00101425:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(uint *)(param_3 + lVar1 * 4) =
*(uint *)(param_1 + lVar1 * 4) ^ *(uint *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
5,491 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int test_tup3[4] = {11, 5, 7, 10};
int test_tup4[4] = {6, 3, 4, 4};
int expected2[4] = {13, 6, 3, 14};
func0(test_tup3, test_tup4, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected2[i]);
}
int test_tup5[4] = {12, 6, 8, 11};
int test_tup6[4] = {7, 4, 5, 6};
int expected3[4] = {11, 2, 13, 13};
func0(test_tup5, test_tup6, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 120d <func0+0xcd>
lea 0xf(%rdi),%r8
lea -0x1(%rcx),%eax
sub %rdx,%r8
cmp $0x1e,%r8
seta %r9b
cmp $0x2,%eax
seta %r8b
test %r8b,%r9b
je 11f0 <func0+0xb0>
lea 0xf(%rsi),%r8
sub %rdx,%r8
cmp $0x1e,%r8
jbe 11f0 <func0+0xb0>
mov %ecx,%r8d
xor %eax,%eax
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
pxor %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 1190 <func0+0x50>
mov %ecx,%eax
and $0xfffffffc,%eax
test $0x3,%cl
je 120d <func0+0xcd>
mov %eax,%r8d
mov (%rdi,%r8,4),%r9d
xor (%rsi,%r8,4),%r9d
mov %r9d,(%rdx,%r8,4)
lea 0x1(%rax),%r8d
cmp %r8d,%ecx
jle 120d <func0+0xcd>
movslq %r8d,%r8
add $0x2,%eax
mov (%rdi,%r8,4),%r9d
xor (%rsi,%r8,4),%r9d
mov %r9d,(%rdx,%r8,4)
cmp %eax,%ecx
jle 120d <func0+0xcd>
cltq
mov (%rdi,%rax,4),%ecx
xor (%rsi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
retq
mov %eax,%r8d
xor %eax,%eax
nopl (%rax)
mov (%rdi,%rax,4),%ecx
xor (%rsi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 11f8 <func0+0xb8>
retq
xchg %ax,%ax
| func0:
endbr64
movsxd rax, ecx
mov r8, rsi
mov rsi, rdx
test eax, eax
jle locret_122B
cmp eax, 1
jz loc_1208
lea rcx, [rdi+4]
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea rcx, [r8+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea edx, [rax-1]
mov r9d, eax
cmp edx, 2
jbe loc_122C
mov ecx, eax
xor edx, edx
shr ecx, 2
shl rcx, 4
nop dword ptr [rax]
loc_11A0:
movdqu xmm0, xmmword ptr [rdi+rdx]
movdqu xmm2, xmmword ptr [r8+rdx]
pxor xmm0, xmm2
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
cmp rcx, rdx
jnz short loc_11A0
mov edx, eax
and edx, 0FFFFFFFCh
mov ecx, edx
cmp eax, edx
jz short locret_122B
sub eax, edx
mov r9d, eax
cmp eax, 1
jz short loc_11F4
loc_11D1:
mov eax, ecx
movq xmm0, qword ptr [rdi+rax*4]
movq xmm1, qword ptr [r8+rax*4]
pxor xmm0, xmm1
movq qword ptr [rsi+rax*4], xmm0
test r9b, 1
jz short locret_122B
and r9d, 0FFFFFFFEh
add edx, r9d
loc_11F4:
movsxd rax, edx
mov edx, [rdi+rax*4]
xor edx, [r8+rax*4]
mov [rsi+rax*4], edx
retn
loc_1208:
lea rcx, ds:0[rax*4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1218:
mov edx, [rdi+rax]
xor edx, [r8+rax]
mov [rsi+rax], edx
add rax, 4
cmp rax, rcx
jnz short loc_1218
locret_122B:
retn
loc_122C:
xor ecx, ecx
xor edx, edx
jmp short loc_11D1 | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
int v7; // r9d
long long v8; // rdx
int v9; // edx
unsigned int v10; // ecx
long long v11; // rcx
result = a4;
if ( a4 > 0 )
{
if ( a4 == 1 || (unsigned long long)(a3 - (a1 + 4)) <= 8 || (unsigned long long)(a3 - (a2 + 4)) <= 8 )
{
v11 = 4LL * a4;
result = 0LL;
do
{
*(_DWORD *)(a3 + result) = *(_DWORD *)(a2 + result) ^ *(_DWORD *)(a1 + result);
result += 4LL;
}
while ( result != v11 );
}
else
{
v7 = a4;
if ( (unsigned int)(a4 - 1) <= 2 )
{
v10 = 0;
v9 = 0;
}
else
{
v8 = 0LL;
do
{
*(__m128i *)(a3 + v8) = _mm_xor_si128(
_mm_loadu_si128((const __m128i *)(a1 + v8)),
_mm_loadu_si128((const __m128i *)(a2 + v8)));
v8 += 16LL;
}
while ( 16LL * ((unsigned int)a4 >> 2) != v8 );
v9 = a4 & 0x7FFFFFFC;
v10 = a4 & 0xFFFFFFFC;
if ( (_DWORD)result == (result & 0xFFFFFFFC) )
return result;
v7 = result - v9;
if ( (_DWORD)result - v9 == 1 )
{
LABEL_12:
result = v9;
*(_DWORD *)(a3 + 4LL * v9) = *(_DWORD *)(a2 + 4LL * v9) ^ *(_DWORD *)(a1 + 4LL * v9);
return result;
}
}
result = v10;
*(_QWORD *)(a3 + 4LL * v10) = _mm_xor_si128(
_mm_loadl_epi64((const __m128i *)(a1 + 4LL * v10)),
_mm_loadl_epi64((const __m128i *)(a2 + 4LL * v10))).m128i_u64[0];
if ( (v7 & 1) != 0 )
{
v9 += v7 & 0xFFFFFFFE;
goto LABEL_12;
}
}
}
return result;
} | func0:
ENDBR64
MOVSXD RAX,ECX
MOV R8,RSI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x0010122b
CMP EAX,0x1
JZ 0x00101208
LEA RCX,[RDI + 0x4]
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA RCX,[R8 + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP EDX,0x2
JBE 0x0010122c
MOV ECX,EAX
XOR EDX,EDX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_001011a0:
MOVDQU XMM0,xmmword ptr [RDI + RDX*0x1]
MOVDQU XMM2,xmmword ptr [R8 + RDX*0x1]
PXOR XMM0,XMM2
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
CMP RCX,RDX
JNZ 0x001011a0
MOV EDX,EAX
AND EDX,0xfffffffc
MOV ECX,EDX
CMP EAX,EDX
JZ 0x0010122b
SUB EAX,EDX
MOV R9D,EAX
CMP EAX,0x1
JZ 0x001011f4
LAB_001011d1:
MOV EAX,ECX
MOVQ XMM0,qword ptr [RDI + RAX*0x4]
MOVQ XMM1,qword ptr [R8 + RAX*0x4]
PXOR XMM0,XMM1
MOVQ qword ptr [RSI + RAX*0x4],XMM0
TEST R9B,0x1
JZ 0x0010122b
AND R9D,0xfffffffe
ADD EDX,R9D
LAB_001011f4:
MOVSXD RAX,EDX
MOV EDX,dword ptr [RDI + RAX*0x4]
XOR EDX,dword ptr [R8 + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
RET
LAB_00101208:
LEA RCX,[RAX*0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101218:
MOV EDX,dword ptr [RDI + RAX*0x1]
XOR EDX,dword ptr [R8 + RAX*0x1]
MOV dword ptr [RSI + RAX*0x1],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101218
LAB_0010122b:
RET
LAB_0010122c:
XOR ECX,ECX
XOR EDX,EDX
JMP 0x001011d1 | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
ulong uVar2;
uint uVar3;
long lVar4;
if (0 < (int)param_4) {
if (((param_4 == 1) || ((ulong)(param_3 - (param_1 + 4)) < 9)) ||
((ulong)(param_3 - (param_2 + 4)) < 9)) {
lVar4 = 0;
do {
*(uint *)(param_3 + lVar4) = *(uint *)(param_1 + lVar4) ^ *(uint *)(param_2 + lVar4);
lVar4 = lVar4 + 4;
} while (lVar4 != (long)(int)param_4 * 4);
return;
}
if (param_4 - 1 < 3) {
uVar3 = 0;
}
else {
lVar4 = 0;
do {
uVar2 = ((ulong *)(param_1 + lVar4))[1];
uVar1 = ((ulong *)(param_2 + lVar4))[1];
*(ulong *)(param_3 + lVar4) = *(ulong *)(param_1 + lVar4) ^ *(ulong *)(param_2 + lVar4);
((ulong *)(param_3 + lVar4))[1] = uVar2 ^ uVar1;
lVar4 = lVar4 + 0x10;
} while ((ulong)(param_4 >> 2) << 4 != lVar4);
uVar3 = param_4 & 0xfffffffc;
if (param_4 == uVar3) {
return;
}
param_4 = param_4 - uVar3;
if (param_4 == 1) goto LAB_001011f4;
}
uVar2 = (ulong)uVar3;
*(ulong *)(param_3 + uVar2 * 4) =
*(ulong *)(param_1 + uVar2 * 4) ^ *(ulong *)(param_2 + uVar2 * 4);
if ((param_4 & 1) != 0) {
uVar3 = uVar3 + (param_4 & 0xfffffffe);
LAB_001011f4:
lVar4 = (long)(int)uVar3;
*(uint *)(param_3 + lVar4 * 4) =
*(uint *)(param_1 + lVar4 * 4) ^ *(uint *)(param_2 + lVar4 * 4);
return;
}
}
return;
} |
5,492 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of pairs
qsort(test_list, n, sizeof(test_list[0]), cmp);
// Count unique pairs
if(n == 0) return 0;
int res = 1;
for(int i = 1; i < n; i++) {
if(test_list[i][0] != test_list[i-1][0] || test_list[i][1] != test_list[i-1][1]) {
res++;
}
}
return res;
}
| int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 129a <func0+0xb5>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
cmp %eax,%edx
jle 1296 <func0+0xb1>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov 0x4(%rax),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,0x4(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1204 <func0+0x1f>
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x12e(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
cmpl $0x0,-0x1c(%rbp)
jne 12d4 <func0+0xef>
mov $0x0,%eax
jmpq 1359 <func0+0x174>
movl $0x1,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 134e <func0+0x169>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 1346 <func0+0x161>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
cmp %eax,%edx
je 134a <func0+0x165>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 12e4 <func0+0xff>
mov -0xc(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
jmp loc_1298
loc_1202:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax+4]
cmp edx, eax
jle short loc_1294
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+base]
add rdx, rcx
mov eax, [rax+4]
mov [rdx], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx+4], eax
loc_1294:
add [rbp+var_10], 1
loc_1298:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jl loc_1202
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, cmp
mov rcx, rdx; compar
mov edx, 8; size
mov rdi, rax; base
call _qsort
cmp [rbp+var_1C], 0
jnz short loc_12D5
mov eax, 0
jmp locret_135A
loc_12D5:
mov [rbp+var_C], 1
mov [rbp+var_8], 1
jmp short loc_134F
loc_12E5:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
shl rax, 3
lea rcx, [rax-8]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_1347
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax+4]
mov eax, [rbp+var_8]
cdqe
shl rax, 3
lea rcx, [rax-8]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax+4]
cmp edx, eax
jz short loc_134B
loc_1347:
add [rbp+var_C], 1
loc_134B:
add [rbp+var_8], 1
loc_134F:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_12E5
mov eax, [rbp+var_C]
locret_135A:
leave
retn | long long func0(_DWORD *a1, int a2)
{
int i; // [rsp+10h] [rbp-10h]
unsigned int v4; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( a1[2 * i] > a1[2 * i + 1] )
{
v6 = a1[2 * i];
a1[2 * i] = a1[2 * i + 1];
a1[2 * i + 1] = v6;
}
}
qsort(a1, a2, 8uLL, cmp);
if ( !a2 )
return 0LL;
v4 = 1;
for ( j = 1; j < a2; ++j )
{
if ( a1[2 * j] != a1[2 * j - 2] || a1[2 * j + 1] != a1[2 * j - 1] )
++v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101298
LAB_00101202:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
JLE 0x00101294
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
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]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX + 0x4],EAX
LAB_00101294:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101298:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101202
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
CALL 0x00101070
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001012d5
MOV EAX,0x0
JMP 0x0010135a
LAB_001012d5:
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010134f
LAB_001012e5:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x3
LEA RCX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101347
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x3
LEA RCX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
JZ 0x0010134b
LAB_00101347:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010134b:
ADD dword ptr [RBP + -0x8],0x1
LAB_0010134f:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001012e5
MOV EAX,dword ptr [RBP + -0xc]
LAB_0010135a:
LEAVE
RET | int func0(void *param_1,int param_2)
{
int4 uVar1;
int local_18;
int local_14;
int local_10;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
if (*(int *)((long)param_1 + (long)local_18 * 8 + 4) <
*(int *)((long)param_1 + (long)local_18 * 8)) {
uVar1 = *(int4 *)((long)param_1 + (long)local_18 * 8);
*(int4 *)((long)param_1 + (long)local_18 * 8) =
*(int4 *)((long)param_1 + (long)local_18 * 8 + 4);
*(int4 *)((long)param_1 + (long)local_18 * 8 + 4) = uVar1;
}
}
qsort(param_1,(long)param_2,8,cmp);
if (param_2 == 0) {
local_14 = 0;
}
else {
local_14 = 1;
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(int *)((long)param_1 + (long)local_10 * 8) !=
*(int *)((long)param_1 + (long)local_10 * 8 + -8)) ||
(*(int *)((long)param_1 + (long)local_10 * 8 + 4) !=
*(int *)((long)param_1 + (long)local_10 * 8 + -4))) {
local_14 = local_14 + 1;
}
}
}
return local_14;
} |
5,493 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of pairs
qsort(test_list, n, sizeof(test_list[0]), cmp);
// Count unique pairs
if(n == 0) return 0;
int res = 1;
for(int i = 1; i < n; i++) {
if(test_list[i][0] != test_list[i-1][0] || test_list[i][1] != test_list[i-1][1]) {
res++;
}
}
return res;
}
| int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
test %esi,%esi
jle 11d8 <func0+0x39>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x8(%rdi,%rdx,8),%rsi
jmp 11c8 <func0+0x29>
add $0x8,%rax
cmp %rsi,%rax
je 121a <func0+0x7b>
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 11bf <func0+0x20>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
jmp 11bf <func0+0x20>
movslq %esi,%rsi
lea -0x59(%rip),%rcx
mov $0x8,%edx
callq 1070 <qsort@plt>
test %ebx,%ebx
setne %dl
movzbl %dl,%edx
mov %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
add $0x1,%edx
add $0x8,%rax
cmp %rcx,%rax
je 11f4 <func0+0x55>
mov (%rax),%edi
cmp %edi,0x8(%rax)
jne 11fd <func0+0x5e>
mov 0x4(%rax),%ebx
cmp %ebx,0xc(%rax)
jne 11fd <func0+0x5e>
jmp 1200 <func0+0x61>
movslq %ebx,%rsi
lea -0x9b(%rip),%rcx
mov $0x8,%edx
mov %rbp,%rdi
callq 1070 <qsort@plt>
cmp $0x1,%ebx
jle 1248 <func0+0xa9>
mov %rbp,%rax
lea -0x2(%rbx),%edx
lea 0x8(%rbp,%rdx,8),%rcx
mov $0x1,%edx
jmp 1209 <func0+0x6a>
mov $0x1,%edx
jmp 11f4 <func0+0x55>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
test esi, esi
jle short loc_11D8
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*8+8]
jmp short loc_11C8
loc_11BF:
add rax, 8
cmp rax, rsi
jz short loc_121A
loc_11C8:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_11BF
mov [rax], ecx
mov [rax+4], edx
jmp short loc_11BF
loc_11D8:
movsxd rsi, esi
lea rcx, cmp
mov edx, 8
call _qsort
test ebx, ebx
setnz dl
movzx edx, dl
loc_11F4:
mov eax, edx
add rsp, 8
pop rbx
pop rbp
retn
loc_11FD:
add edx, 1
loc_1200:
add rax, 8
cmp rax, rcx
jz short loc_11F4
loc_1209:
mov edi, [rax]
cmp [rax+8], edi
jnz short loc_11FD
mov ebx, [rax+4]
cmp [rax+0Ch], ebx
jnz short loc_11FD
jmp short loc_1200
loc_121A:
movsxd rsi, ebx
lea rcx, cmp
mov edx, 8
mov rdi, rbp
call _qsort
cmp ebx, 1
jle short loc_1248
mov rax, rbp
lea edx, [rbx-2]
lea rcx, [rbp+rdx*8+8]
mov edx, 1
jmp short loc_1209
loc_1248:
mov edx, 1
jmp short loc_11F4 | long long func0(int *a1, int a2)
{
int *v3; // rax
long long v4; // rsi
int v5; // edx
int v6; // ecx
unsigned int v7; // edx
int *v9; // rax
if ( a2 <= 0 )
{
qsort(a1, a2, 8LL, cmp);
return a2 != 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[2 * (a2 - 1) + 2];
do
{
v5 = *v3;
v6 = v3[1];
if ( *v3 > v6 )
{
*v3 = v6;
v3[1] = v5;
}
v3 += 2;
}
while ( v3 != (int *)v4 );
qsort(a1, a2, 8LL, cmp);
if ( a2 <= 1 )
{
return 1;
}
else
{
v9 = a1;
v7 = 1;
do
{
if ( v9[2] != *v9 || v9[3] != v9[1] )
++v7;
v9 += 2;
}
while ( v9 != &a1[2 * (a2 - 2) + 2] );
}
}
return v7;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
TEST ESI,ESI
JLE 0x001011d8
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x8 + 0x8]
JMP 0x001011c8
LAB_001011bf:
ADD RAX,0x8
CMP RAX,RSI
JZ 0x0010121a
LAB_001011c8:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x001011bf
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
JMP 0x001011bf
LAB_001011d8:
MOVSXD RSI,ESI
LEA RCX,[0x101189]
MOV EDX,0x8
CALL 0x00101070
TEST EBX,EBX
SETNZ DL
MOVZX EDX,DL
LAB_001011f4:
MOV EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011fd:
ADD EDX,0x1
LAB_00101200:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x001011f4
LAB_00101209:
MOV EDI,dword ptr [RAX]
CMP dword ptr [RAX + 0x8],EDI
JNZ 0x001011fd
MOV EBX,dword ptr [RAX + 0x4]
CMP dword ptr [RAX + 0xc],EBX
JNZ 0x001011fd
JMP 0x00101200
LAB_0010121a:
MOVSXD RSI,EBX
LEA RCX,[0x101189]
MOV EDX,0x8
MOV RDI,RBP
CALL 0x00101070
CMP EBX,0x1
JLE 0x00101248
MOV RAX,RBP
LEA EDX,[RBX + -0x2]
LEA RCX,[RBP + RDX*0x8 + 0x8]
MOV EDX,0x1
JMP 0x00101209
LAB_00101248:
MOV EDX,0x1
JMP 0x001011f4 | uint func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
uint uVar3;
if (param_2 < 1) {
qsort(param_1,(long)param_2,8,cmp);
uVar3 = (uint)(param_2 != 0);
}
else {
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 2;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) * 2 + 2);
qsort(param_1,(long)param_2,8,cmp);
if (param_2 < 2) {
uVar3 = 1;
}
else {
piVar2 = param_1 + (ulong)(param_2 - 2) * 2 + 2;
uVar3 = 1;
do {
if ((param_1[2] != *param_1) || (param_1[3] != param_1[1])) {
uVar3 = uVar3 + 1;
}
param_1 = param_1 + 2;
} while (param_1 != piVar2);
}
}
return uVar3;
} |
5,494 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of pairs
qsort(test_list, n, sizeof(test_list[0]), cmp);
// Count unique pairs
if(n == 0) return 0;
int res = 1;
for(int i = 1; i < n; i++) {
if(test_list[i][0] != test_list[i-1][0] || test_list[i][1] != test_list[i-1][1]) {
res++;
}
}
return res;
}
| int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%r8
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %r8,%rbx
test %r8d,%r8d
jle 13d8 <func0+0xa8>
lea -0x1(%r8),%edx
lea 0x8(%rdi),%r12
mov %rdi,%rax
lea (%r12,%rdx,8),%rsi
nopl 0x0(%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 136e <func0+0x3e>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x8,%rax
cmp %rsi,%rax
jne 1360 <func0+0x30>
lea -0x6e(%rip),%rcx
mov $0x8,%edx
mov %r8,%rsi
mov %rbp,%rdi
callq 1070 <qsort@plt>
cmp $0x1,%ebx
je 13f8 <func0+0xc8>
lea -0x2(%rbx),%eax
mov %rbp,%rdi
lea (%r12,%rax,8),%rdx
mov $0x1,%eax
jmp 13b4 <func0+0x84>
nopl 0x0(%rax)
add $0x8,%rdi
add $0x1,%eax
cmp %rdx,%rdi
je 13cc <func0+0x9c>
mov (%rdi),%ebx
cmp %ebx,0x8(%rdi)
jne 13a8 <func0+0x78>
mov 0x4(%rdi),%esi
cmp %esi,0xc(%rdi)
jne 13a8 <func0+0x78>
add $0x8,%rdi
cmp %rdx,%rdi
jne 13b4 <func0+0x84>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
lea -0xcf(%rip),%rcx
mov $0x8,%edx
mov %r8,%rsi
callq 1070 <qsort@plt>
xor %eax,%eax
test %ebx,%ebx
pop %rbx
setne %al
pop %rbp
pop %r12
retq
mov $0x1,%eax
jmp 13cc <func0+0x9c>
| func0:
endbr64
movsxd r8, esi
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, r8
test r8d, r8d
jle loc_13D8
lea edx, [r8-1]
lea r12, [rdi+8]
mov rax, rdi
lea rsi, [r12+rdx*8]
nop dword ptr [rax+00000000h]
loc_1360:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_136E
mov [rax], ecx
mov [rax+4], edx
loc_136E:
add rax, 8
cmp rax, rsi
jnz short loc_1360
lea rcx, cmp
mov edx, 8
mov rsi, r8
mov rdi, rbp
call _qsort
cmp ebx, 1
jz short loc_13FD
lea edx, [rbx-2]
mov rax, rbp
mov r8d, 1
lea rdx, [r12+rdx*8]
jmp short loc_13B5
loc_13A8:
add rax, 8
add r8d, 1
cmp rax, rdx
jz short loc_13CD
loc_13B5:
mov edi, [rax]
cmp [rax+8], edi
jnz short loc_13A8
mov ebx, [rax+4]
cmp [rax+0Ch], ebx
jnz short loc_13A8
add rax, 8
cmp rax, rdx
jnz short loc_13B5
loc_13CD:
pop rbx
mov eax, r8d
pop rbp
pop r12
retn
loc_13D8:
mov rsi, r8
lea rcx, cmp
mov edx, 8
call _qsort
xor r8d, r8d
test ebx, ebx
pop rbx
setnz r8b
pop rbp
pop r12
mov eax, r8d
retn
loc_13FD:
mov r8d, 1
jmp short loc_13CD | long long func0(int *a1, int a2)
{
int *v2; // rax
int v3; // edx
int v4; // ecx
int *v5; // rax
unsigned int v6; // r8d
long long v7; // rdx
if ( a2 <= 0 )
{
qsort(a1, a2, 8LL, cmp);
return a2 != 0;
}
else
{
v2 = a1;
do
{
v3 = *v2;
v4 = v2[1];
if ( *v2 > v4 )
{
*v2 = v4;
v2[1] = v3;
}
v2 += 2;
}
while ( v2 != &a1[2 * (a2 - 1) + 2] );
qsort(a1, a2, 8LL, cmp);
if ( a2 == 1 )
{
return 1;
}
else
{
v5 = a1;
v6 = 1;
v7 = (long long)&a1[2 * (a2 - 2) + 2];
do
{
while ( v5[2] != *v5 || v5[3] != v5[1] )
{
v5 += 2;
++v6;
if ( v5 == (int *)v7 )
return v6;
}
v5 += 2;
}
while ( v5 != (int *)v7 );
}
return v6;
}
} | func0:
ENDBR64
MOVSXD R8,ESI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R8
TEST R8D,R8D
JLE 0x001013d8
LEA EDX,[R8 + -0x1]
LEA R12,[RDI + 0x8]
MOV RAX,RDI
LEA RSI,[R12 + RDX*0x8]
NOP dword ptr [RAX]
LAB_00101360:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x0010136e
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
LAB_0010136e:
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x00101360
LEA RCX,[0x101310]
MOV EDX,0x8
MOV RSI,R8
MOV RDI,RBP
CALL 0x00101070
CMP EBX,0x1
JZ 0x001013fd
LEA EDX,[RBX + -0x2]
MOV RAX,RBP
MOV R8D,0x1
LEA RDX,[R12 + RDX*0x8]
JMP 0x001013b5
LAB_001013a8:
ADD RAX,0x8
ADD R8D,0x1
CMP RAX,RDX
JZ 0x001013cd
LAB_001013b5:
MOV EDI,dword ptr [RAX]
CMP dword ptr [RAX + 0x8],EDI
JNZ 0x001013a8
MOV EBX,dword ptr [RAX + 0x4]
CMP dword ptr [RAX + 0xc],EBX
JNZ 0x001013a8
ADD RAX,0x8
CMP RAX,RDX
JNZ 0x001013b5
LAB_001013cd:
POP RBX
MOV EAX,R8D
POP RBP
POP R12
RET
LAB_001013d8:
MOV RSI,R8
LEA RCX,[0x101310]
MOV EDX,0x8
CALL 0x00101070
XOR R8D,R8D
TEST EBX,EBX
POP RBX
SETNZ R8B
POP RBP
POP R12
MOV EAX,R8D
RET
LAB_001013fd:
MOV R8D,0x1
JMP 0x001013cd | uint func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
uint uVar3;
if (param_2 < 1) {
qsort(param_1,(long)param_2,8,cmp);
return (uint)(param_2 != 0);
}
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 2;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) * 2 + 2);
qsort(param_1,(long)param_2,8,cmp);
if (param_2 == 1) {
uVar3 = 1;
}
else {
uVar3 = 1;
piVar2 = param_1 + (ulong)(param_2 - 2) * 2 + 2;
do {
while ((param_1[2] == *param_1 && (param_1[3] == param_1[1]))) {
param_1 = param_1 + 2;
if (param_1 == piVar2) {
return uVar3;
}
}
param_1 = param_1 + 2;
uVar3 = uVar3 + 1;
} while (param_1 != piVar2);
}
return uVar3;
} |
5,495 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of pairs
qsort(test_list, n, sizeof(test_list[0]), cmp);
// Count unique pairs
if(n == 0) return 0;
int res = 1;
for(int i = 1; i < n; i++) {
if(test_list[i][0] != test_list[i-1][0] || test_list[i][1] != test_list[i-1][1]) {
res++;
}
}
return res;
}
| int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
movslq %esi,%r8
mov %rdi,%rbp
push %rbx
mov %r8,%rbx
sub $0x8,%rsp
test %r8d,%r8d
jle 13a8 <func0+0xd8>
lea -0x1(%r8),%edx
mov %rdi,%rax
lea 0x8(%rdi,%rdx,8),%rsi
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 130e <func0+0x3e>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x8,%rax
cmp %rsi,%rax
jne 1300 <func0+0x30>
lea -0x6e(%rip),%rcx
mov $0x8,%edx
mov %r8,%rsi
mov %rbp,%rdi
callq 1070 <qsort@plt>
cmp $0x1,%ebx
je 13ea <func0+0x11a>
cmp $0x3,%ebx
jle 13f2 <func0+0x122>
lea -0x4(%rbx),%ecx
mov 0x0(%rbp),%esi
lea 0x4(%rbp),%rdx
mov $0x1,%r8d
and $0xfffffffe,%ecx
mov $0x1,%eax
add $0x3,%ecx
mov 0x4(%rdx),%edi
cmp %edi,%esi
je 13d0 <func0+0x100>
add $0x1,%r8d
mov 0xc(%rdx),%esi
cmp %esi,%edi
je 13e0 <func0+0x110>
add $0x1,%r8d
add $0x2,%eax
add $0x10,%rdx
cmp %ecx,%eax
jne 135b <func0+0x8b>
cltq
jmp 138c <func0+0xbc>
add $0x1,%r8d
add $0x1,%rax
cmp %eax,%ebx
jle 13c5 <func0+0xf5>
mov -0x8(%rbp,%rax,8),%edi
cmp %edi,0x0(%rbp,%rax,8)
jne 1380 <func0+0xb0>
mov -0x4(%rbp,%rax,8),%esi
cmp %esi,0x4(%rbp,%rax,8)
jne 1380 <func0+0xb0>
jmp 1384 <func0+0xb4>
nopw 0x0(%rax,%rax,1)
mov %r8,%rsi
lea -0x102(%rip),%rcx
mov $0x8,%edx
callq 1070 <qsort@plt>
xor %r8d,%r8d
test %ebx,%ebx
setne %r8b
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
mov (%rdx),%esi
cmp %esi,0x8(%rdx)
jne 1362 <func0+0x92>
jmp 1366 <func0+0x96>
nopl 0x0(%rax)
mov 0x8(%rdx),%edi
cmp %edi,0x10(%rdx)
jne 136d <func0+0x9d>
jmp 1371 <func0+0xa1>
mov $0x1,%r8d
jmp 13c5 <func0+0xf5>
mov $0x1,%r8d
mov $0x1,%eax
jmpq 137c <func0+0xac>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
sub rsp, 8
test edi, edi
jle loc_13E0
mov rax, rbx
lea rsi, [rbx+rdi*8]
nop word ptr [rax+rax+00h]
loc_12F8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_1316
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_1316:
add rax, 8
cmp rax, rsi
jnz short loc_12F8
mov rsi, rdi; nmemb
lea rcx, cmp; compar
mov edx, 8; size
mov rdi, rbx; base
call _qsort
cmp ebp, 1
jz loc_1407
cmp ebp, 3
jle short loc_139C
lea eax, [rbp-4]
mov edi, [rbx]
lea rcx, [rbx+4]
mov edx, 1
and eax, 0FFFFFFFEh
mov esi, 1
add eax, 3
jmp short loc_1379
loc_1360:
add edx, 1
loc_1363:
mov edi, [rcx+0Ch]
cmp r8d, edi
jz short loc_1390
loc_136B:
add edx, 1
loc_136E:
add esi, 2
add rcx, 10h
cmp esi, eax
jz short loc_13A6
loc_1379:
mov r8d, [rcx+4]
cmp r8d, edi
jnz short loc_1360
mov edi, [rcx]
cmp [rcx+8], edi
jnz short loc_1360
jmp short loc_1363
loc_1390:
mov r9d, [rcx+8]
cmp [rcx+10h], r9d
jnz short loc_136B
jmp short loc_136E
loc_139C:
mov edx, 1
mov eax, 1
loc_13A6:
cdqe
jmp short loc_13BB
loc_13B0:
add rax, 1
add edx, 1
cmp ebp, eax
jle short loc_13D6
loc_13BB:
mov edi, [rbx+rax*8-8]
cmp [rbx+rax*8], edi
jnz short loc_13B0
mov esi, [rbx+rax*8-4]
cmp [rbx+rax*8+4], esi
jnz short loc_13B0
add rax, 1
cmp ebp, eax
jg short loc_13BB
loc_13D6:
add rsp, 8
mov eax, edx
pop rbx
pop rbp
retn
loc_13E0:
mov edx, 8; size
mov rsi, rdi; nmemb
lea rcx, cmp; compar
mov rdi, rbx; base
call _qsort
xor edx, edx
test ebp, ebp
setnz dl
add rsp, 8
mov eax, edx
pop rbx
pop rbp
retn
loc_1407:
mov edx, 1
jmp short loc_13D6 | long long func0(__m128i *base, int a2)
{
size_t v3; // rdi
__m128i *v5; // rax
__m128i *v6; // rsi
__m128i v7; // xmm0
__int32 v8; // edi
__int32 *v9; // rcx
unsigned int v10; // edx
int v11; // esi
long long v12; // rax
__int32 v13; // r8d
v3 = a2;
if ( a2 <= 0 )
{
qsort(base, a2, 8uLL, cmp);
return a2 != 0;
}
else
{
v5 = base;
v6 = (__m128i *)((char *)base + 8 * a2);
do
{
v7 = _mm_loadl_epi64(v5);
if ( _mm_cvtsi128_si32(v7) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v7, 229)) )
v5->m128i_i64[0] = _mm_shuffle_epi32(v7, 225).m128i_u64[0];
v5 = (__m128i *)((char *)v5 + 8);
}
while ( v5 != v6 );
qsort(base, v3, 8uLL, cmp);
if ( a2 == 1 )
{
return 1;
}
else
{
if ( a2 <= 3 )
{
v10 = 1;
LODWORD(v12) = 1;
}
else
{
v8 = base->m128i_i32[0];
v9 = &base->m128i_i32[1];
v10 = 1;
v11 = 1;
LODWORD(v12) = ((a2 - 4) & 0xFFFFFFFE) + 3;
do
{
v13 = v9[1];
if ( v13 != v8 || v9[2] != *v9 )
++v10;
v8 = v9[3];
if ( v13 != v8 || v9[4] != v9[2] )
++v10;
v11 += 2;
v9 += 4;
}
while ( v11 != (_DWORD)v12 );
}
v12 = (int)v12;
do
{
while ( base->m128i_i32[2 * v12] != base->m128i_i32[2 * v12 - 2]
|| base->m128i_i32[2 * v12 + 1] != base->m128i_i32[2 * v12 - 1] )
{
++v12;
++v10;
if ( a2 <= (int)v12 )
return v10;
}
++v12;
}
while ( a2 > (int)v12 );
}
return v10;
}
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SUB RSP,0x8
TEST EDI,EDI
JLE 0x001013e0
MOV RAX,RBX
LEA RSI,[RBX + RDI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001012f8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x00101316
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_00101316:
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x001012f8
MOV RSI,RDI
LEA RCX,[0x1012b0]
MOV EDX,0x8
MOV RDI,RBX
CALL 0x00101070
CMP EBP,0x1
JZ 0x00101407
CMP EBP,0x3
JLE 0x0010139c
LEA EAX,[RBP + -0x4]
MOV EDI,dword ptr [RBX]
LEA RCX,[RBX + 0x4]
MOV EDX,0x1
AND EAX,0xfffffffe
MOV ESI,0x1
ADD EAX,0x3
JMP 0x00101379
LAB_00101360:
ADD EDX,0x1
LAB_00101363:
MOV EDI,dword ptr [RCX + 0xc]
CMP R8D,EDI
JZ 0x00101390
LAB_0010136b:
ADD EDX,0x1
LAB_0010136e:
ADD ESI,0x2
ADD RCX,0x10
CMP ESI,EAX
JZ 0x001013a6
LAB_00101379:
MOV R8D,dword ptr [RCX + 0x4]
CMP R8D,EDI
JNZ 0x00101360
MOV EDI,dword ptr [RCX]
CMP dword ptr [RCX + 0x8],EDI
JNZ 0x00101360
JMP 0x00101363
LAB_00101390:
MOV R9D,dword ptr [RCX + 0x8]
CMP dword ptr [RCX + 0x10],R9D
JNZ 0x0010136b
JMP 0x0010136e
LAB_0010139c:
MOV EDX,0x1
MOV EAX,0x1
LAB_001013a6:
CDQE
JMP 0x001013bb
LAB_001013b0:
ADD RAX,0x1
ADD EDX,0x1
CMP EBP,EAX
JLE 0x001013d6
LAB_001013bb:
MOV EDI,dword ptr [RBX + RAX*0x8 + -0x8]
CMP dword ptr [RBX + RAX*0x8],EDI
JNZ 0x001013b0
MOV ESI,dword ptr [RBX + RAX*0x8 + -0x4]
CMP dword ptr [RBX + RAX*0x8 + 0x4],ESI
JNZ 0x001013b0
ADD RAX,0x1
CMP EBP,EAX
JG 0x001013bb
LAB_001013d6:
ADD RSP,0x8
MOV EAX,EDX
POP RBX
POP RBP
RET
LAB_001013e0:
MOV EDX,0x8
MOV RSI,RDI
LEA RCX,[0x1012b0]
MOV RDI,RBX
CALL 0x00101070
XOR EDX,EDX
TEST EBP,EBP
SETNZ DL
ADD RSP,0x8
MOV EAX,EDX
POP RBX
POP RBP
RET
LAB_00101407:
MOV EDX,0x1
JMP 0x001013d6 | uint func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
long lVar3;
uint uVar4;
int iVar5;
size_t __nmemb;
int iVar6;
__nmemb = (size_t)param_2;
if (param_2 < 1) {
qsort(param_1,__nmemb,8,cmp);
return (uint)(param_2 != 0);
}
piVar2 = param_1;
do {
iVar1 = (int)*(int8 *)piVar2;
iVar6 = (int)((ulong)*(int8 *)piVar2 >> 0x20);
if (iVar6 < iVar1) {
*(ulong *)piVar2 = CONCAT44(iVar1,iVar6);
}
piVar2 = piVar2 + 2;
} while (piVar2 != param_1 + __nmemb * 2);
qsort(param_1,__nmemb,8,cmp);
if (param_2 == 1) {
uVar4 = 1;
}
else {
if (param_2 < 4) {
uVar4 = 1;
iVar1 = 1;
}
else {
iVar6 = *param_1;
piVar2 = param_1 + 1;
uVar4 = 1;
iVar5 = 1;
iVar1 = (param_2 - 4U & 0xfffffffe) + 3;
do {
if ((piVar2[1] != iVar6) || (piVar2[2] != *piVar2)) {
uVar4 = uVar4 + 1;
}
iVar6 = piVar2[3];
if ((piVar2[1] != iVar6) || (piVar2[4] != piVar2[2])) {
uVar4 = uVar4 + 1;
}
iVar5 = iVar5 + 2;
piVar2 = piVar2 + 4;
} while (iVar5 != iVar1);
}
lVar3 = (long)iVar1;
do {
while ((param_1[lVar3 * 2] != param_1[lVar3 * 2 + -2] ||
(param_1[lVar3 * 2 + 1] != param_1[lVar3 * 2 + -1]))) {
lVar3 = lVar3 + 1;
uVar4 = uVar4 + 1;
if (param_2 <= (int)lVar3) {
return uVar4;
}
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < param_2);
}
return uVar4;
} |
5,496 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected[i][j]);
int test_tup1_2[][2] = {{2, 4}, {5, 6}, {3, 10}, {2, 11}};
int test_tup2_2[][2] = {{7, 8}, {4, 10}, {2, 2}, {8, 4}};
int expected_2[][2] = {{9, 12}, {9, 16}, {5, 12}, {10, 15}};
func0(test_tup1_2, test_tup2_2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_2[i][j]);
int test_tup1_3[][2] = {{3, 5}, {6, 7}, {4, 11}, {3, 12}};
int test_tup2_3[][2] = {{8, 9}, {5, 11}, {3, 3}, {9, 5}};
int expected_3[][2] = {{11, 14}, {11, 18}, {7, 14}, {12, 17}};
func0(test_tup1_3, test_tup2_3, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_3[i][j]);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x8e>
movl $0x0,-0x4(%rbp)
jmp 11ed <func0+0x84>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rsi
mov -0x28(%rbp),%rdx
add %rsi,%rdx
add %eax,%ecx
mov -0x4(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
addl $0x1,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jle 1192 <func0+0x29>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1189 <func0+0x20>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_8], 0
jmp short loc_11F7
loc_1189:
mov [rbp+var_4], 0
jmp short loc_11ED
loc_1192:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_20]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov eax, [rdx+rax*4]
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rsi, ds:0[rdx*8]
mov rdx, [rbp+var_28]
add rdx, rsi
add ecx, eax
mov eax, [rbp+var_4]
cdqe
mov [rdx+rax*4], ecx
add [rbp+var_4], 1
loc_11ED:
cmp [rbp+var_4], 1
jle short loc_1192
add [rbp+var_8], 1
loc_11F7:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_2C]
jl short loc_1189
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+24h] [rbp-8h]
int j; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
for ( j = 0; j <= 1; ++j )
*(_DWORD *)(8LL * (int)i + a3 + 4LL * j) = *(_DWORD *)(a2 + 8LL * (int)i + 4LL * j)
+ *(_DWORD *)(a1 + 8LL * (int)i + 4LL * j);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f7
LAB_00101189:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ed
LAB_00101192:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RSI,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RSI
ADD ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ed:
CMP dword ptr [RBP + -0x4],0x1
JLE 0x00101192
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101189
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
for (local_c = 0; local_c < 2; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_10 * 8 + (long)local_c * 4) =
*(int *)((long)local_10 * 8 + param_1 + (long)local_c * 4) +
*(int *)((long)local_10 * 8 + param_2 + (long)local_c * 4);
}
}
return;
} |
5,497 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected[i][j]);
int test_tup1_2[][2] = {{2, 4}, {5, 6}, {3, 10}, {2, 11}};
int test_tup2_2[][2] = {{7, 8}, {4, 10}, {2, 2}, {8, 4}};
int expected_2[][2] = {{9, 12}, {9, 16}, {5, 12}, {10, 15}};
func0(test_tup1_2, test_tup2_2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_2[i][j]);
int test_tup1_3[][2] = {{3, 5}, {6, 7}, {4, 11}, {3, 12}};
int test_tup2_3[][2] = {{8, 9}, {5, 11}, {3, 3}, {9, 5}};
int expected_3[][2] = {{11, 14}, {11, 18}, {7, 14}, {12, 17}};
func0(test_tup1_3, test_tup2_3, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_3[i][j]);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 119b <func0+0x32>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov (%rsi,%rax,8),%ecx
add (%rdi,%rax,8),%ecx
mov %ecx,(%rdx,%rax,8)
mov 0x4(%rsi,%rax,8),%ecx
add 0x4(%rdi,%rax,8),%ecx
mov %ecx,0x4(%rdx,%rax,8)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 117a <func0+0x11>
retq
| func0:
endbr64
test ecx, ecx
jle short locret_1197
mov r8d, ecx
mov eax, 0
loc_1179:
mov ecx, [rsi+rax*8]
add ecx, [rdi+rax*8]
mov [rdx+rax*8], ecx
mov ecx, [rsi+rax*8+4]
add ecx, [rdi+rax*8+4]
mov [rdx+rax*8+4], ecx
add rax, 1
cmp rax, r8
jnz short loc_1179
locret_1197:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
*(_DWORD *)(a3 + 8 * i) = *(_DWORD *)(a1 + 8 * i) + *(_DWORD *)(a2 + 8 * i);
*(_DWORD *)(a3 + 8 * i + 4) = *(_DWORD *)(a1 + 8 * i + 4) + *(_DWORD *)(a2 + 8 * i + 4);
}
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101197
MOV R8D,ECX
MOV EAX,0x0
LAB_00101179:
MOV ECX,dword ptr [RSI + RAX*0x8]
ADD ECX,dword ptr [RDI + RAX*0x8]
MOV dword ptr [RDX + RAX*0x8],ECX
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
ADD ECX,dword ptr [RDI + RAX*0x8 + 0x4]
MOV dword ptr [RDX + RAX*0x8 + 0x4],ECX
ADD RAX,0x1
CMP RAX,R8
JNZ 0x00101179
LAB_00101197:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 8) = *(int *)(param_2 + uVar1 * 8) + *(int *)(param_1 + uVar1 * 8);
*(int *)(param_3 + 4 + uVar1 * 8) =
*(int *)(param_2 + 4 + uVar1 * 8) + *(int *)(param_1 + 4 + uVar1 * 8);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;
} |
5,498 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected[i][j]);
int test_tup1_2[][2] = {{2, 4}, {5, 6}, {3, 10}, {2, 11}};
int test_tup2_2[][2] = {{7, 8}, {4, 10}, {2, 2}, {8, 4}};
int expected_2[][2] = {{9, 12}, {9, 16}, {5, 12}, {10, 15}};
func0(test_tup1_2, test_tup2_2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_2[i][j]);
int test_tup1_3[][2] = {{3, 5}, {6, 7}, {4, 11}, {3, 12}};
int test_tup2_3[][2] = {{8, 9}, {5, 11}, {3, 3}, {9, 5}};
int expected_3[][2] = {{11, 14}, {11, 18}, {7, 14}, {12, 17}};
func0(test_tup1_3, test_tup2_3, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_3[i][j]);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1591 <func0+0x31>
lea -0x1(%rcx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rsi,%rax,8),%ecx
add (%rdi,%rax,8),%ecx
mov %ecx,(%rdx,%rax,8)
mov 0x4(%rsi,%rax,8),%ecx
add 0x4(%rdi,%rax,8),%ecx
mov %ecx,0x4(%rdx,%rax,8)
mov %rax,%rcx
add $0x1,%rax
cmp %rcx,%r8
jne 1570 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
test ecx, ecx
jle short locret_157E
movsxd r8, ecx
xor eax, eax
nop dword ptr [rax]
loc_1560:
mov ecx, [rsi+rax*8]
add ecx, [rdi+rax*8]
mov [rdx+rax*8], ecx
mov ecx, [rsi+rax*8+4]
add ecx, [rdi+rax*8+4]
mov [rdx+rax*8+4], ecx
add rax, 1
cmp r8, rax
jnz short loc_1560
locret_157E:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
*(_DWORD *)(a3 + 8 * i) = *(_DWORD *)(a1 + 8 * i) + *(_DWORD *)(a2 + 8 * i);
*(_DWORD *)(a3 + 8 * i + 4) = *(_DWORD *)(a1 + 8 * i + 4) + *(_DWORD *)(a2 + 8 * i + 4);
}
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x0010157e
MOVSXD R8,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101560:
MOV ECX,dword ptr [RSI + RAX*0x8]
ADD ECX,dword ptr [RDI + RAX*0x8]
MOV dword ptr [RDX + RAX*0x8],ECX
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
ADD ECX,dword ptr [RDI + RAX*0x8 + 0x4]
MOV dword ptr [RDX + RAX*0x8 + 0x4],ECX
ADD RAX,0x1
CMP R8,RAX
JNZ 0x00101560
LAB_0010157e:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 8) = *(int *)(param_2 + lVar1 * 8) + *(int *)(param_1 + lVar1 * 8);
*(int *)(param_3 + 4 + lVar1 * 8) =
*(int *)(param_2 + 4 + lVar1 * 8) + *(int *)(param_1 + 4 + lVar1 * 8);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
5,499 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected[i][j]);
int test_tup1_2[][2] = {{2, 4}, {5, 6}, {3, 10}, {2, 11}};
int test_tup2_2[][2] = {{7, 8}, {4, 10}, {2, 2}, {8, 4}};
int expected_2[][2] = {{9, 12}, {9, 16}, {5, 12}, {10, 15}};
func0(test_tup1_2, test_tup2_2, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_2[i][j]);
int test_tup1_3[][2] = {{3, 5}, {6, 7}, {4, 11}, {3, 12}};
int test_tup2_3[][2] = {{8, 9}, {5, 11}, {3, 3}, {9, 5}};
int expected_3[][2] = {{11, 14}, {11, 18}, {7, 14}, {12, 17}};
func0(test_tup1_3, test_tup2_3, res, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < 2; j++)
assert(res[i][j] == expected_3[i][j]);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1521 <func0+0xb1>
lea 0xf(%rsi),%rax
sub %rdx,%rax
cmp $0x1e,%rax
seta %r8b
cmp $0x1,%ecx
setne %al
test %al,%r8b
je 14f5 <func0+0x85>
lea 0xf(%rdi),%rax
sub %rdx,%rax
cmp $0x1e,%rax
jbe 14f5 <func0+0x85>
mov %ecx,%eax
xor %r8d,%r8d
shr %eax
shl $0x4,%rax
xchg %ax,%ax
movdqu (%rdi,%r8,1),%xmm0
movdqu (%rsi,%r8,1),%xmm1
paddd %xmm1,%xmm0
movups %xmm0,(%rdx,%r8,1)
add $0x10,%r8
cmp %rax,%r8
jne 14b0 <func0+0x40>
mov %ecx,%eax
and $0xfffffffe,%eax
and $0x1,%ecx
je 1521 <func0+0xb1>
shl $0x3,%rax
add %rax,%rdi
add %rax,%rsi
add %rdx,%rax
mov (%rsi),%edx
add (%rdi),%edx
mov %edx,(%rax)
mov 0x4(%rsi),%edx
add 0x4(%rdi),%edx
mov %edx,0x4(%rax)
retq
lea -0x1(%rcx),%r8d
xor %ecx,%ecx
nopl 0x0(%rax,%rax,1)
mov (%rsi,%rcx,8),%eax
add (%rdi,%rcx,8),%eax
mov %eax,(%rdx,%rcx,8)
mov 0x4(%rsi,%rcx,8),%eax
add 0x4(%rdi,%rcx,8),%eax
mov %eax,0x4(%rdx,%rcx,8)
mov %rcx,%rax
add $0x1,%rcx
cmp %rax,%r8
jne 1500 <func0+0x90>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
test ecx, ecx
jle locret_11EC
lea rax, [rdi+0Fh]
sub rax, rdx
cmp rax, 1Eh
jbe short loc_11B9
lea rax, [rsi+0Fh]
sub rax, rdx
cmp rax, 1Eh
jbe short loc_11B9
cmp ecx, 1
jz loc_11EE
mov r8d, ecx
xor eax, eax
shr r8d, 1
shl r8, 4
nop dword ptr [rax+rax+00h]
loc_1180:
movdqu xmm0, xmmword ptr [rdi+rax]
movdqu xmm2, xmmword ptr [rsi+rax]
paddd xmm0, xmm2
movups xmmword ptr [rdx+rax], xmm0
add rax, 10h
cmp rax, r8
jnz short loc_1180
mov eax, ecx
and eax, 0FFFFFFFEh
and ecx, 1
jz short locret_11ED
loc_11A5:
movq xmm0, qword ptr [rdi+rax*8]
movq xmm1, qword ptr [rsi+rax*8]
paddd xmm0, xmm1
movq qword ptr [rdx+rax*8], xmm0
retn
loc_11B9:
movsxd rcx, ecx
xor eax, eax
shl rcx, 3
nop word ptr [rax+rax+00h]
loc_11C8:
mov r8d, [rsi+rax]
add r8d, [rdi+rax]
mov [rdx+rax], r8d
mov r8d, [rsi+rax+4]
add r8d, [rdi+rax+4]
mov [rdx+rax+4], r8d
add rax, 8
cmp rax, rcx
jnz short loc_11C8
locret_11EC:
retn
locret_11ED:
retn
loc_11EE:
xor eax, eax
jmp short loc_11A5 | void func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rcx
if ( a4 > 0 )
{
if ( (unsigned long long)(a1 + 15 - a3) <= 0x1E || (unsigned long long)(a2 + 15 - a3) <= 0x1E )
{
v6 = 0LL;
v7 = 8LL * a4;
do
{
*(_DWORD *)(a3 + v6) = *(_DWORD *)(a1 + v6) + *(_DWORD *)(a2 + v6);
*(_DWORD *)(a3 + v6 + 4) = *(_DWORD *)(a1 + v6 + 4) + *(_DWORD *)(a2 + v6 + 4);
v6 += 8LL;
}
while ( v6 != v7 );
}
else
{
if ( a4 == 1 )
{
v5 = 0LL;
LABEL_8:
*(_QWORD *)(a3 + 8 * v5) = _mm_add_epi32(
_mm_loadl_epi64((const __m128i *)(a1 + 8 * v5)),
_mm_loadl_epi64((const __m128i *)(a2 + 8 * v5))).m128i_u64[0];
return;
}
v4 = 0LL;
do
{
*(__m128i *)(a3 + v4) = _mm_add_epi32(
_mm_loadu_si128((const __m128i *)(a1 + v4)),
_mm_loadu_si128((const __m128i *)(a2 + v4)));
v4 += 16LL;
}
while ( v4 != 16LL * ((unsigned int)a4 >> 1) );
v5 = a4 & 0xFFFFFFFE;
if ( (a4 & 1) != 0 )
goto LABEL_8;
}
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x001011ec
LEA RAX,[RDI + 0xf]
SUB RAX,RDX
CMP RAX,0x1e
JBE 0x001011b9
LEA RAX,[RSI + 0xf]
SUB RAX,RDX
CMP RAX,0x1e
JBE 0x001011b9
CMP ECX,0x1
JZ 0x001011ee
MOV R8D,ECX
XOR EAX,EAX
SHR R8D,0x1
SHL R8,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RDI + RAX*0x1]
MOVDQU XMM2,xmmword ptr [RSI + RAX*0x1]
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RDX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,R8
JNZ 0x00101180
MOV EAX,ECX
AND EAX,0xfffffffe
AND ECX,0x1
JZ 0x001011ed
LAB_001011a5:
MOVQ XMM0,qword ptr [RDI + RAX*0x8]
MOVQ XMM1,qword ptr [RSI + RAX*0x8]
PADDD XMM0,XMM1
MOVQ qword ptr [RDX + RAX*0x8],XMM0
RET
LAB_001011b9:
MOVSXD RCX,ECX
XOR EAX,EAX
SHL RCX,0x3
NOP word ptr [RAX + RAX*0x1]
LAB_001011c8:
MOV R8D,dword ptr [RSI + RAX*0x1]
ADD R8D,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RDX + RAX*0x1],R8D
MOV R8D,dword ptr [RSI + RAX*0x1 + 0x4]
ADD R8D,dword ptr [RDI + RAX*0x1 + 0x4]
MOV dword ptr [RDX + RAX*0x1 + 0x4],R8D
ADD RAX,0x8
CMP RAX,RCX
JNZ 0x001011c8
LAB_001011ec:
RET
LAB_001011ed:
RET
LAB_001011ee:
XOR EAX,EAX
JMP 0x001011a5 | void func0(long param_1,long param_2,long param_3,uint param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
long lVar12;
ulong uVar13;
if (0 < (int)param_4) {
if ((0x1e < (ulong)((param_1 + 0xf) - param_3)) && (0x1e < (ulong)((param_2 + 0xf) - param_3)))
{
if (param_4 == 1) {
uVar13 = 0;
}
else {
lVar12 = 0;
do {
piVar1 = (int *)(param_1 + lVar12);
iVar6 = piVar1[1];
iVar7 = piVar1[2];
iVar8 = piVar1[3];
piVar2 = (int *)(param_2 + lVar12);
iVar9 = piVar2[1];
iVar10 = piVar2[2];
iVar11 = piVar2[3];
piVar3 = (int *)(param_3 + lVar12);
*piVar3 = *piVar1 + *piVar2;
piVar3[1] = iVar6 + iVar9;
piVar3[2] = iVar7 + iVar10;
piVar3[3] = iVar8 + iVar11;
lVar12 = lVar12 + 0x10;
} while (lVar12 != (ulong)(param_4 >> 1) << 4);
uVar13 = (ulong)(param_4 & 0xfffffffe);
if ((param_4 & 1) == 0) {
return;
}
}
uVar4 = *(int8 *)(param_1 + uVar13 * 8);
uVar5 = *(int8 *)(param_2 + uVar13 * 8);
*(ulong *)(param_3 + uVar13 * 8) =
CONCAT44((int)((ulong)uVar4 >> 0x20) + (int)((ulong)uVar5 >> 0x20),
(int)uVar4 + (int)uVar5);
return;
}
lVar12 = 0;
do {
*(int *)(param_3 + lVar12) = *(int *)(param_2 + lVar12) + *(int *)(param_1 + lVar12);
*(int *)(param_3 + 4 + lVar12) =
*(int *)(param_2 + 4 + lVar12) + *(int *)(param_1 + 4 + lVar12);
lVar12 = lVar12 + 8;
} while (lVar12 != (long)(int)param_4 * 8);
}
return;
} |
5,500 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %edx,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x48(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 120d <func0+0xa4>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f6 <func0+0x8d>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1237 <func0+0xce>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 1268 <func0+0xff>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x48(%rbp),%eax
jle 1253 <func0+0xea>
mov -0x20(%rbp),%rax
movl $0x1,(%rax)
movl $0x1,-0x30(%rbp)
jmp 12d2 <func0+0x169>
mov -0x30(%rbp),%eax
cmp %eax,-0x48(%rbp)
cmovle -0x48(%rbp),%eax
mov %eax,-0x34(%rbp)
jmp 12c8 <func0+0x15f>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x34(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %ecx,%eax
cltd
idivl -0x4c(%rbp)
mov %edx,%ecx
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
subl $0x1,-0x34(%rbp)
cmpl $0x0,-0x34(%rbp)
jg 1292 <func0+0x129>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 1283 <func0+0x11a>
mov -0x20(%rbp),%rax
mov -0x48(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 12fe <func0+0x195>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_3C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_38]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11DB:
cmp rsp, rdx
jz short loc_11F2
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11DB
loc_11F2:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_121C
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_121C:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_24], 0
jmp short loc_124D
loc_1238:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 0
add [rbp+var_24], 1
loc_124D:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_38]
jle short loc_1238
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov [rbp+var_20], 1
jmp short loc_12B8
loc_1268:
mov edx, [rbp+var_38]
mov eax, [rbp+var_20]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_1C], eax
jmp short loc_12AE
loc_1278:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, ecx
cdq
idiv [rbp+var_3C]
mov ecx, edx
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
sub [rbp+var_1C], 1
loc_12AE:
cmp [rbp+var_1C], 0
jg short loc_1278
add [rbp+var_20], 1
loc_12B8:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_34]
jle short loc_1268
mov rax, [rbp+var_10]
mov edx, [rbp+var_38]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12E4
call ___stack_chk_fail
locret_12E4:
leave
retn | long long func0(int a1, int a2, int a3)
{
unsigned long long v3; // rax
void *v4; // rsp
int v5; // eax
_BYTE v7[4]; // [rsp+8h] [rbp-40h] BYREF
int v8; // [rsp+Ch] [rbp-3Ch]
int v9; // [rsp+10h] [rbp-38h]
int v10; // [rsp+14h] [rbp-34h]
int i; // [rsp+24h] [rbp-24h]
int j; // [rsp+28h] [rbp-20h]
int k; // [rsp+2Ch] [rbp-1Ch]
long long v14; // [rsp+30h] [rbp-18h]
_DWORD *v15; // [rsp+38h] [rbp-10h]
unsigned long long v16; // [rsp+40h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v16 = __readfsqword(0x28u);
v14 = a2 + 1 - 1LL;
v3 = 16 * ((4LL * (a2 + 1) + 15) / 0x10uLL);
while ( v7 != &v7[-(v3 & 0xFFFFFFFFFFFFF000LL)] )
;
v4 = alloca(v3 & 0xFFF);
if ( (v3 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v3 & 0xFFF) - 8] = *(_QWORD *)&v7[(v3 & 0xFFF) - 8];
v15 = v7;
for ( i = 0; i <= v9; ++i )
v15[i] = 0;
*v15 = 1;
for ( j = 1; j <= v10; ++j )
{
v5 = j;
if ( v9 <= j )
v5 = v9;
for ( k = v5; k > 0; --k )
v15[k] = (v15[k] + v15[k - 1]) % v8;
}
return (unsigned int)v15[v9];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV dword ptr [RBP + -0x3c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011db:
CMP RSP,RDX
JZ 0x001011f2
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011db
LAB_001011f2:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010121c
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010121c:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010124d
LAB_00101238:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x0
ADD dword ptr [RBP + -0x24],0x1
LAB_0010124d:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x38]
JLE 0x00101238
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV dword ptr [RBP + -0x20],0x1
JMP 0x001012b8
LAB_00101268:
MOV EDX,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x20]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001012ae
LAB_00101278:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,ECX
CDQ
IDIV dword ptr [RBP + -0x3c]
MOV ECX,EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
SUB dword ptr [RBP + -0x1c],0x1
LAB_001012ae:
CMP dword ptr [RBP + -0x1c],0x0
JG 0x00101278
ADD dword ptr [RBP + -0x20],0x1
LAB_001012b8:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101268
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012e4
CALL 0x00101060
LAB_001012e4:
LEAVE
RET | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
int local_40;
int local_3c;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_40 = param_2;
local_44 = param_3;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_2 + 1) + -1;
uVar2 = (((long)(param_2 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_2c = 0; local_2c <= local_40; local_2c = local_2c + 1) {
*(int4 *)(puVar3 + (long)local_2c * 4 + lVar1) = 0;
}
*(int4 *)(puVar3 + lVar1) = 1;
for (local_28 = 1; local_28 <= local_3c; local_28 = local_28 + 1) {
local_24 = local_28;
if (local_40 <= local_28) {
local_24 = local_40;
}
for (; 0 < local_24; local_24 = local_24 + -1) {
*(int *)(puVar3 + (long)local_24 * 4 + lVar1) =
(*(int *)(puVar3 + (long)(local_24 + -1) * 4 + lVar1) +
*(int *)(puVar3 + (long)local_24 * 4 + lVar1)) % local_44;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar3 + (long)local_40 * 4 + lVar1);
}
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,501 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edx,%r8d
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11c4 <func0+0x5b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ad <func0+0x44>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11da <func0+0x71>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r12
mov %r12,%rcx
shr $0x2,%rcx
and $0xfffffffffffffffc,%r12
mov %r12,%r11
test %esi,%esi
js 120a <func0+0xa1>
mov %r12,%rax
mov %esi,%edx
lea 0x4(%r12,%rdx,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 11fb <func0+0x92>
movl $0x1,0x0(,%rcx,4)
test %edi,%edi
jle 126d <func0+0x104>
lea 0x1(%rdi),%r10d
mov $0x1,%r9d
lea -0x4(%r11),%rbx
jmp 1232 <func0+0xc9>
add $0x1,%r9d
cmp %r10d,%r9d
je 126d <func0+0x104>
cmp %r9d,%esi
mov %r9d,%eax
cmovle %esi,%eax
test %eax,%eax
jle 1229 <func0+0xc0>
movslq %eax,%rdi
shl $0x2,%rdi
lea (%r11,%rdi,1),%rcx
add %rbx,%rdi
lea -0x1(%rax),%eax
shl $0x2,%rax
sub %rax,%rdi
mov -0x4(%rcx),%eax
add (%rcx),%eax
cltd
idiv %r8d
mov %edx,(%rcx)
sub $0x4,%rcx
cmp %rdi,%rcx
jne 1257 <func0+0xee>
jmp 1229 <func0+0xc0>
movslq %esi,%rsi
mov (%r12,%rsi,4),%eax
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
jne 128c <func0+0x123>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov r10d, edi
mov r9d, esi
mov esi, edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea eax, [r9+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11AE:
cmp rsp, rdx
jz short loc_11C5
sub rsp, 1000h
or [rsp+1020h+var_28], 0
jmp short loc_11AE
loc_11C5:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11DB
or [rsp+rax+20h+var_28], 0
loc_11DB:
lea r11, [rsp+20h+var_1D]
mov rcx, r11
shr rcx, 2
and r11, 0FFFFFFFFFFFFFFFCh
test r9d, r9d
js short loc_120A
mov rax, r11
lea edx, [r9+1]
lea rdx, [r11+rdx*4]
loc_11FB:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_11FB
loc_120A:
mov ds:dword_0[rcx*4], 1
test r10d, r10d
jle short loc_126A
add r10d, 1
mov r8d, 1
lea rbx, [r11-4]
loc_1228:
cmp r9d, r8d
mov eax, r8d
cmovle eax, r9d
test eax, eax
jle short loc_1261
movsxd rdi, eax
shl rdi, 2
lea rcx, [r11+rdi]
add rdi, rbx
lea eax, [rax-1]
shl rax, 2
sub rdi, rax
loc_124E:
mov eax, [rcx-4]
add eax, [rcx]
cdq
idiv esi
mov [rcx], edx
sub rcx, 4
cmp rcx, rdi
jnz short loc_124E
loc_1261:
add r8d, 1
cmp r8d, r10d
jnz short loc_1228
loc_126A:
movsxd r9, r9d
mov eax, [r11+r9*4]
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jnz short loc_1286
mov rbx, [rbp+var_8]
leave
retn
loc_1286:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
signed long long v3; // rax
void *v4; // rsp
_DWORD *v5; // rax
int v6; // r10d
int v7; // r8d
int v8; // eax
long long v9; // rdi
int *v10; // rcx
int *v11; // rdi
_DWORD v14[2]; // [rsp+8h] [rbp-20h] BYREF
unsigned long long v15; // [rsp+10h] [rbp-18h]
v15 = __readfsqword(0x28u);
while ( v14 != (_DWORD *)((char *)v14 - ((4LL * (a2 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v3 = (4 * ((_WORD)a2 + 1) + 15) & 0xFF0;
v4 = alloca(v3);
if ( ((4 * ((_WORD)a2 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v14[-2] + v3) = *(_QWORD *)((char *)&v14[-2] + v3);
if ( a2 >= 0 )
{
v5 = v14;
do
*v5++ = 0;
while ( v5 != &v14[a2 + 1] );
}
v14[0] = 1;
if ( a1 > 0 )
{
v6 = a1 + 1;
v7 = 1;
do
{
v8 = v7;
if ( a2 <= v7 )
v8 = a2;
if ( v8 > 0 )
{
v9 = v8;
v10 = &v14[v9];
v11 = &v14[v9 - 1 - (unsigned int)(v8 - 1)];
do
{
*v10 = (*v10 + *(v10 - 1)) % a3;
--v10;
}
while ( v10 != v11 );
}
++v7;
}
while ( v7 != v6 );
}
return (unsigned int)v14[a2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV R10D,EDI
MOV R9D,ESI
MOV ESI,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA EAX,[R9 + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ae:
CMP RSP,RDX
JZ 0x001011c5
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ae
LAB_001011c5:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011db
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011db:
LEA R11,[RSP + 0x3]
MOV RCX,R11
SHR RCX,0x2
AND R11,-0x4
TEST R9D,R9D
JS 0x0010120a
MOV RAX,R11
LEA EDX,[R9 + 0x1]
LEA RDX,[R11 + RDX*0x4]
LAB_001011fb:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011fb
LAB_0010120a:
MOV dword ptr [RCX*0x4],0x1
TEST R10D,R10D
JLE 0x0010126a
ADD R10D,0x1
MOV R8D,0x1
LEA RBX,[R11 + -0x4]
LAB_00101228:
CMP R9D,R8D
MOV EAX,R8D
CMOVLE EAX,R9D
TEST EAX,EAX
JLE 0x00101261
MOVSXD RDI,EAX
SHL RDI,0x2
LEA RCX,[R11 + RDI*0x1]
ADD RDI,RBX
LEA EAX,[RAX + -0x1]
SHL RAX,0x2
SUB RDI,RAX
LAB_0010124e:
MOV EAX,dword ptr [RCX + -0x4]
ADD EAX,dword ptr [RCX]
CDQ
IDIV ESI
MOV dword ptr [RCX],EDX
SUB RCX,0x4
CMP RCX,RDI
JNZ 0x0010124e
LAB_00101261:
ADD R8D,0x1
CMP R8D,R10D
JNZ 0x00101228
LAB_0010126a:
MOVSXD R9,R9D
MOV EAX,dword ptr [R11 + R9*0x4]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101286
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
LAB_00101286:
CALL 0x00101060 | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
int4 *puVar4;
int *piVar5;
int1 *puVar6;
int iVar7;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_2 + 1) * 4 + 0xf;
for (puVar6 = auStack_28; puVar6 != auStack_28 + -(uVar3 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
puVar4 = (int4 *)(puVar6 + lVar1);
if (uVar3 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (-1 < param_2) {
do {
*puVar4 = 0;
puVar4 = puVar4 + 1;
} while (puVar4 != (int4 *)(puVar6 + (ulong)(param_2 + 1) * 4 + lVar1));
}
*(int4 *)(puVar6 + lVar1) = 1;
if (0 < param_1) {
iVar7 = 1;
do {
iVar2 = iVar7;
if (param_2 <= iVar7) {
iVar2 = param_2;
}
if (0 < iVar2) {
piVar5 = (int *)(puVar6 + (long)iVar2 * 4 + lVar1);
do {
*piVar5 = (piVar5[-1] + *piVar5) % param_3;
piVar5 = piVar5 + -1;
} while (piVar5 != (int *)(puVar6 + (ulong)(iVar2 - 1) * -4 + (long)iVar2 * 4 + lVar1 + -4))
;
}
iVar7 = iVar7 + 1;
} while (iVar7 != param_1 + 1);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar6 + (long)param_2 * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar1 + -8) = main;
__stack_chk_fail();
} |
5,502 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %edx,%r8d
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 151e <func0+0x5e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1509 <func0+0x49>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 15ea <func0+0x12a>
lea 0x3(%rsp),%r11
movslq %esi,%r12
mov %r11,%rcx
and $0xfffffffffffffffc,%r11
shr $0x2,%rcx
test %esi,%esi
js 1567 <func0+0xa7>
movslq %esi,%r12
mov %r11,%rax
lea 0x4(%r11,%r12,4),%rdx
nopw 0x0(%rax,%rax,1)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1558 <func0+0x98>
movl $0x1,0x0(,%rcx,4)
test %edi,%edi
jle 15ce <func0+0x10e>
lea 0x1(%rdi),%r10d
mov $0x1,%r9d
lea -0x4(%r11),%rbx
nopl 0x0(%rax)
cmp %r9d,%esi
mov %r9d,%eax
cmovle %esi,%eax
test %eax,%eax
jle 15c5 <func0+0x105>
movslq %eax,%rdi
sub $0x1,%eax
shl $0x2,%rdi
shl $0x2,%rax
lea (%r11,%rdi,1),%rcx
add %rbx,%rdi
sub %rax,%rdi
nopl (%rax)
mov -0x4(%rcx),%eax
add (%rcx),%eax
sub $0x4,%rcx
cltd
idiv %r8d
mov %edx,0x4(%rcx)
cmp %rdi,%rcx
jne 15b0 <func0+0xf0>
add $0x1,%r9d
cmp %r10d,%r9d
jne 1588 <func0+0xc8>
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r11,%r12,4),%eax
jne 15f5 <func0+0x135>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1530 <func0+0x70>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15d, edi
push r14
push r13
push r12
mov r12d, esi
push rbx
mov ebx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rsi+1]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12B6
loc_12A1:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_12A1
loc_12B6:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_137E
loc_12C8:
lea r9, [rsp+1040h+var_103D]
movsxd r13, r12d
mov r14, r9
and r9, 0FFFFFFFFFFFFFFFCh
shr r14, 2
test r12d, r12d
js short loc_12F5
mov rdi, r9
lea rdx, ds:4[r13*4]
xor esi, esi
call _memset
mov r9, rax
loc_12F5:
mov ds:dword_0[r14*4], 1
test r15d, r15d
jle short loc_135C
lea r8d, [r15+1]
mov edi, 1
lea r10, [r9-4]
nop dword ptr [rax+rax+00h]
loc_1318:
cmp r12d, edi
mov eax, edi
cmovle eax, r12d
test eax, eax
jle short loc_1354
movsxd rsi, eax
sub eax, 1
shl rsi, 2
shl rax, 2
lea rcx, [r9+rsi]
add rsi, r10
sub rsi, rax
nop dword ptr [rax]
loc_1340:
mov eax, [rcx-4]
add eax, [rcx]
sub rcx, 4
cdq
idiv ebx
mov [rcx+4], edx
cmp rcx, rsi
jnz short loc_1340
loc_1354:
add edi, 1
cmp edi, r8d
jnz short loc_1318
loc_135C:
mov eax, [r9+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1389
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_137E:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_12C8
loc_1389:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
long long v6; // rdx
_DWORD *v7; // rcx
__int16 v8; // dx
signed long long v9; // rdx
void *v10; // rsp
_DWORD *v11; // r9
int v12; // edi
int v13; // eax
long long v14; // rsi
_DWORD *v15; // rcx
long long v16; // rsi
int v17; // eax
_DWORD v20[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v21[8]; // [rsp+1008h] [rbp-40h] BYREF
v21[1] = __readfsqword(0x28u);
v6 = 4LL * (a2 + 1) + 15;
v7 = (_DWORD *)((char *)v21 - (v6 & 0xFFFFFFFFFFFFF000LL));
v8 = v6 & 0xFFF0;
if ( v21 != (_QWORD *)v7 )
{
while ( v20 != v7 )
;
}
v9 = v8 & 0xFFF;
v10 = alloca(v9);
if ( v9 )
*(_QWORD *)((char *)&v20[-2] + v9) = *(_QWORD *)((char *)&v20[-2] + v9);
v11 = v20;
if ( a2 >= 0 )
v11 = (_DWORD *)memset(v20, 0LL, 4LL * a2 + 4);
v20[0] = 1;
if ( a1 > 0 )
{
v12 = 1;
do
{
v13 = v12;
if ( a2 <= v12 )
v13 = a2;
if ( v13 > 0 )
{
v14 = v13;
v15 = &v11[v14];
v16 = (long long)&v11[v14 - 1 - (unsigned int)(v13 - 1)];
do
{
v17 = *v15 + *(v15 - 1);
--v15;
v15[1] = v17 % a3;
}
while ( v15 != (_DWORD *)v16 );
}
++v12;
}
while ( v12 != a1 + 1 );
}
return (unsigned int)v11[a2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15D,EDI
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RSI + 0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012b6
LAB_001012a1:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012a1
LAB_001012b6:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010137e
LAB_001012c8:
LEA R9,[RSP + 0x3]
MOVSXD R13,R12D
MOV R14,R9
AND R9,-0x4
SHR R14,0x2
TEST R12D,R12D
JS 0x001012f5
MOV RDI,R9
LEA RDX,[0x4 + R13*0x4]
XOR ESI,ESI
CALL 0x00101090
MOV R9,RAX
LAB_001012f5:
MOV dword ptr [R14*0x4],0x1
TEST R15D,R15D
JLE 0x0010135c
LEA R8D,[R15 + 0x1]
MOV EDI,0x1
LEA R10,[R9 + -0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101318:
CMP R12D,EDI
MOV EAX,EDI
CMOVLE EAX,R12D
TEST EAX,EAX
JLE 0x00101354
MOVSXD RSI,EAX
SUB EAX,0x1
SHL RSI,0x2
SHL RAX,0x2
LEA RCX,[R9 + RSI*0x1]
ADD RSI,R10
SUB RSI,RAX
NOP dword ptr [RAX]
LAB_00101340:
MOV EAX,dword ptr [RCX + -0x4]
ADD EAX,dword ptr [RCX]
SUB RCX,0x4
CDQ
IDIV EBX
MOV dword ptr [RCX + 0x4],EDX
CMP RCX,RSI
JNZ 0x00101340
LAB_00101354:
ADD EDI,0x1
CMP EDI,R8D
JNZ 0x00101318
LAB_0010135c:
MOV EAX,dword ptr [R9 + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101389
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010137e:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012c8
LAB_00101389:
CALL 0x00101070 | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
int1 *puVar3;
int *piVar4;
int *piVar5;
ulong uVar6;
int1 *puVar7;
int iVar9;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int1 *puVar8;
puVar7 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(param_2 + 1) * 4 + 0xf;
puVar8 = auStack_48;
puVar3 = auStack_48;
while (puVar8 != auStack_48 + -(uVar6 & 0xfffffffffffff000)) {
puVar7 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar8 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar1 = -uVar6;
puVar3 = puVar7 + lVar1;
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < param_2) {
*(int8 *)(puVar7 + lVar1 + -8) = 0x1012f2;
puVar3 = (int1 *)memset(puVar7 + lVar1,0,(long)param_2 * 4 + 4);
}
*(int4 *)(puVar7 + lVar1) = 1;
if (0 < param_1) {
iVar9 = 1;
do {
iVar2 = iVar9;
if (param_2 <= iVar9) {
iVar2 = param_2;
}
if (0 < iVar2) {
piVar4 = (int *)(puVar3 + (long)iVar2 * 4);
do {
piVar5 = piVar4 + -1;
*piVar4 = (piVar4[-1] + *piVar4) % param_3;
piVar4 = piVar5;
} while (piVar5 != (int *)(puVar3 + (ulong)(iVar2 - 1) * -4 + (long)iVar2 * 4 + -4));
}
iVar9 = iVar9 + 1;
} while (iVar9 != param_1 + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x10138e;
__stack_chk_fail();
}
return *(int4 *)(puVar3 + (long)param_2 * 4);
} |
5,503 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %edi,%r15d
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbx
mov %edx,%ebx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rdi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 1909 <func0+0x69>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 18f4 <func0+0x54>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 19e1 <func0+0x141>
lea 0x3(%rsp),%r10
movslq %r12d,%r13
mov %r10,%r14
and $0xfffffffffffffffc,%r10
shr $0x2,%r14
test %r12d,%r12d
js 1948 <func0+0xa8>
mov %r10,%rdi
lea 0x4(,%r13,4),%rdx
xor %esi,%esi
callq 1090 <memset@plt>
mov %rax,%r10
movl $0x1,0x0(,%r14,4)
test %r15d,%r15d
jle 19bf <func0+0x11f>
lea 0x1(%r15),%r9d
mov $0x1,%r8d
lea -0x4(%r10),%r11
nopw 0x0(%rax,%rax,1)
cmp %r8d,%r12d
mov %r8d,%eax
cmovle %r12d,%eax
test %eax,%eax
jle 19b6 <func0+0x116>
movslq %eax,%rdi
sub $0x1,%eax
shl $0x2,%rdi
shl $0x2,%rax
lea (%r10,%rdi,1),%rcx
add %r11,%rdi
mov (%rcx),%esi
sub %rax,%rdi
nopl 0x0(%rax,%rax,1)
mov %esi,%eax
mov -0x4(%rcx),%esi
sub $0x4,%rcx
add %esi,%eax
cltd
idiv %ebx
mov %edx,0x4(%rcx)
cmp %rdi,%rcx
jne 19a0 <func0+0x100>
add $0x1,%r8d
cmp %r9d,%r8d
jne 1970 <func0+0xd0>
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r10,%r13,4),%eax
jne 19ec <func0+0x14c>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 191b <func0+0x7b>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15d, edi
push r14
push r13
push r12
mov r12d, esi
push rbx
mov ebx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rsi+1]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12B6
loc_12A1:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_12A1
loc_12B6:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1381
loc_12C8:
lea r10, [rsp+1040h+var_103D]
movsxd r13, r12d
mov r14, r10
and r10, 0FFFFFFFFFFFFFFFCh
shr r14, 2
test r12d, r12d
js short loc_12F5
mov rdi, r10; s
lea rdx, ds:4[r13*4]; n
xor esi, esi; c
call _memset
mov r10, rax
loc_12F5:
mov ds:dword_0[r14*4], 1
test r15d, r15d
jle short loc_135F
lea r9d, [r15+1]
mov r8d, 1
lea r11, [r10-4]
nop dword ptr [rax+00h]
loc_1318:
cmp r12d, r8d
mov eax, r8d
cmovle eax, r12d
test eax, eax
jle short loc_1356
movsxd rdi, eax
sub eax, 1
shl rdi, 2
shl rax, 2
lea rcx, [r10+rdi]
add rdi, r11
mov esi, [rcx]
sub rdi, rax
loc_1340:
mov eax, esi
mov esi, [rcx-4]
sub rcx, 4
add eax, esi
cdq
idiv ebx
mov [rcx+4], edx
cmp rcx, rdi
jnz short loc_1340
loc_1356:
add r8d, 1
cmp r8d, r9d
jnz short loc_1318
loc_135F:
mov eax, [r10+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_138C
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1381:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_12C8
loc_138C:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
long long v5; // rdx
_DWORD *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
_DWORD *v10; // r10
int v11; // r9d
int v12; // r8d
int v13; // eax
long long v14; // rdi
_DWORD *v15; // rcx
int v16; // esi
long long v17; // rdi
int v18; // eax
_DWORD v21[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v22[8]; // [rsp+1008h] [rbp-40h] BYREF
v22[1] = __readfsqword(0x28u);
v5 = 4LL * (a2 + 1) + 15;
v6 = (_DWORD *)((char *)v22 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( v22 != (_QWORD *)v6 )
{
while ( v21 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v21[-2] + v8) = *(_QWORD *)((char *)&v21[-2] + v8);
v10 = v21;
if ( a2 >= 0 )
v10 = memset(v21, 0, 4LL * a2 + 4);
v21[0] = 1;
if ( a1 > 0 )
{
v11 = a1 + 1;
v12 = 1;
do
{
v13 = v12;
if ( a2 <= v12 )
v13 = a2;
if ( v13 > 0 )
{
v14 = v13;
v15 = &v10[v14];
v16 = v10[v14];
v17 = (long long)&v10[v14 - 1 - (unsigned int)(v13 - 1)];
do
{
v18 = v16;
v16 = *--v15;
v15[1] = (v16 + v18) % a3;
}
while ( v15 != (_DWORD *)v17 );
}
++v12;
}
while ( v12 != v11 );
}
return (unsigned int)v10[a2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15D,EDI
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RSI + 0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012b6
LAB_001012a1:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012a1
LAB_001012b6:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101381
LAB_001012c8:
LEA R10,[RSP + 0x3]
MOVSXD R13,R12D
MOV R14,R10
AND R10,-0x4
SHR R14,0x2
TEST R12D,R12D
JS 0x001012f5
MOV RDI,R10
LEA RDX,[0x4 + R13*0x4]
XOR ESI,ESI
CALL 0x00101090
MOV R10,RAX
LAB_001012f5:
MOV dword ptr [R14*0x4],0x1
TEST R15D,R15D
JLE 0x0010135f
LEA R9D,[R15 + 0x1]
MOV R8D,0x1
LEA R11,[R10 + -0x4]
NOP dword ptr [RAX]
LAB_00101318:
CMP R12D,R8D
MOV EAX,R8D
CMOVLE EAX,R12D
TEST EAX,EAX
JLE 0x00101356
MOVSXD RDI,EAX
SUB EAX,0x1
SHL RDI,0x2
SHL RAX,0x2
LEA RCX,[R10 + RDI*0x1]
ADD RDI,R11
MOV ESI,dword ptr [RCX]
SUB RDI,RAX
LAB_00101340:
MOV EAX,ESI
MOV ESI,dword ptr [RCX + -0x4]
SUB RCX,0x4
ADD EAX,ESI
CDQ
IDIV EBX
MOV dword ptr [RCX + 0x4],EDX
CMP RCX,RDI
JNZ 0x00101340
LAB_00101356:
ADD R8D,0x1
CMP R8D,R9D
JNZ 0x00101318
LAB_0010135f:
MOV EAX,dword ptr [R10 + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010138c
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101381:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012c8
LAB_0010138c:
CALL 0x00101070 | int4 func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long lVar2;
int iVar3;
int *puVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *puVar8;
int iVar10;
int iVar11;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int *puVar9;
puVar8 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar7 = (long)(param_2 + 1) * 4 + 0xf;
puVar9 = auStack_48;
puVar4 = auStack_48;
while (puVar9 != auStack_48 + -(uVar7 & 0xfffffffffffff000)) {
puVar8 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar9 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar2 = -uVar7;
puVar4 = puVar8 + lVar2;
if (uVar7 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (-1 < param_2) {
*(int8 *)(puVar8 + lVar2 + -8) = 0x1012f2;
puVar4 = (int *)memset(puVar8 + lVar2,0,(long)param_2 * 4 + 4);
}
*(int4 *)(puVar8 + lVar2) = 1;
if (0 < param_1) {
iVar11 = 1;
do {
iVar3 = iVar11;
if (param_2 <= iVar11) {
iVar3 = param_2;
}
if (0 < iVar3) {
piVar5 = (int *)(puVar4 + (long)iVar3 * 4);
iVar10 = *(int *)(puVar4 + (long)iVar3 * 4);
do {
piVar1 = piVar5 + -1;
piVar6 = piVar5 + -1;
*piVar5 = (iVar10 + *piVar1) % param_3;
piVar5 = piVar6;
iVar10 = *piVar1;
} while (piVar6 != (int *)(puVar4 + (ulong)(iVar3 - 1) * -4 + (long)iVar3 * 4 + -4));
}
iVar11 = iVar11 + 1;
} while (iVar11 != param_1 + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + lVar2 + -8) = 0x101391;
__stack_chk_fail();
}
return *(int4 *)(puVar4 + (long)param_2 * 4);
} |
5,504 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
return false;
}
result = regexec(®ex, str, 0, NULL, 0);
match = (result == 0);
regfree(®ex);
return match;
}
| int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
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 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
cmpq $0x0,-0x68(%rbp)
jne 1201 <func0+0x38>
mov $0x0,%eax
jmp 1266 <func0+0x9d>
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
mov %eax,-0x5c(%rbp)
cmpl $0x0,-0x5c(%rbp)
je 1229 <func0+0x60>
mov $0x0,%eax
jmp 1266 <func0+0x9d>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x5c(%rbp)
cmpl $0x0,-0x5c(%rbp)
sete %al
mov %al,-0x5d(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1090 <regfree@plt>
movzbl -0x5d(%rbp),%eax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 127a <func0+0xb1>
callq 10a0 <__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, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
mov [rbp+pattern], rax
cmp [rbp+string], 0
jnz short loc_1201
mov eax, 0
jmp short loc_1266
loc_1201:
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_5C], eax
cmp [rbp+var_5C], 0
jz short loc_1229
mov eax, 0
jmp short loc_1266
loc_1229:
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
cmp [rbp+var_5C], 0
setz al
mov [rbp+var_5D], al
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
movzx eax, [rbp+var_5D]
loc_1266:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_127A
call ___stack_chk_fail
locret_127A:
leave
retn | _BOOL8 func0(const char *a1)
{
bool v2; // [rsp+13h] [rbp-5Dh]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( !a1 )
return 0LL;
if ( regcomp(
&preg,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)",
1) )
{
return 0LL;
}
v2 = regexec(&preg, a1, 0LL, 0LL, 0) == 0;
regfree(&preg);
return v2;
} | 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
CMP qword ptr [RBP + -0x68],0x0
JNZ 0x00101201
MOV EAX,0x0
JMP 0x00101266
LAB_00101201:
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x00101229
MOV EAX,0x0
JMP 0x00101266
LAB_00101229:
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
SETZ AL
MOV byte ptr [RBP + -0x5d],AL
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101090
MOVZX EAX,byte ptr [RBP + -0x5d]
LAB_00101266:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010127a
CALL 0x001010a0
LAB_0010127a:
LEAVE
RET | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == (char *)0x0) {
bVar2 = false;
}
else {
iVar1 = regcomp(&local_58,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)"
,1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
bVar2 = iVar1 == 0;
regfree(&local_58);
}
else {
bVar2 = false;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return bVar2;
} |
5,505 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
return false;
}
result = regexec(®ex, str, 0, NULL, 0);
match = (result == 0);
regfree(®ex);
return match;
}
| int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov $0x0,%ebp
test %rdi,%rdi
je 120a <func0+0x41>
mov %rdi,%rbx
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe07(%rip),%rsi
callq 10c0 <regcomp@plt>
test %eax,%eax
je 1225 <func0+0x5c>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 1253 <func0+0x8a>
mov %ebp,%eax
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
mov %rsp,%r12
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %r12,%rdi
callq 10d0 <regexec@plt>
test %eax,%eax
sete %bpl
mov %r12,%rdi
callq 1090 <regfree@plt>
jmp 120a <func0+0x41>
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov ebp, 0
test rdi, rdi
jz short loc_120A
mov rbx, rdi
mov rdi, rsp
mov edx, 1
lea rsi, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
call _regcomp
test eax, eax
jz short loc_1225
loc_120A:
mov rax, [rsp+68h+var_20]
sub rax, fs:28h
jnz short loc_1253
mov eax, ebp
add rsp, 50h
pop rbx
pop rbp
pop r12
retn
loc_1225:
mov r12, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, r12
call _regexec
test eax, eax
setz bpl
mov rdi, r12
call _regfree
jmp short loc_120A
loc_1253:
call ___stack_chk_fail | long long func0(long long a1)
{
unsigned int v1; // ebp
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
v1 = 0;
if ( a1
&& !(unsigned int)regcomp(
v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)",
1LL) )
{
LOBYTE(v1) = (unsigned int)regexec(v3, a1, 0LL, 0LL, 0LL) == 0;
regfree(v3);
}
return v1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV EBP,0x0
TEST RDI,RDI
JZ 0x0010120a
MOV RBX,RDI
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102008]
CALL 0x001010c0
TEST EAX,EAX
JZ 0x00101225
LAB_0010120a:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101253
MOV EAX,EBP
ADD RSP,0x50
POP RBX
POP RBP
POP R12
RET
LAB_00101225:
MOV R12,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,R12
CALL 0x001010d0
TEST EAX,EAX
SETZ BPL
MOV RDI,R12
CALL 0x00101090
JMP 0x0010120a
LAB_00101253:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
if (param_1 != (char *)0x0) {
iVar1 = regcomp(&rStack_68,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)"
,1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
bVar2 = iVar1 == 0;
regfree(&rStack_68);
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,506 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
return false;
}
result = regexec(®ex, str, 0, NULL, 0);
match = (result == 0);
regfree(®ex);
return match;
}
| int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O2 | c | func0:
endbr64
test %rdi,%rdi
je 1300 <func0+0x10>
jmpq 1270 <func0.part.0>
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
push r13
mov edx, 1
lea rsi, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
xor r13d, r13d
push r12
push rbp
mov rbp, rdi
sub rsp, 50h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test eax, eax
jnz short loc_12CA
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rdi, r12
mov rsi, rbp
call _regexec
mov rdi, r12
test eax, eax
setz r13b
call _regfree
loc_12CA:
mov rax, [rsp+68h+var_20]
sub rax, fs:28h
jnz short loc_12E7
add rsp, 50h
mov eax, r13d
pop rbp
pop r12
pop r13
retn
loc_12E7:
call ___stack_chk_fail | long long func0_part_0(long long a1)
{
unsigned int v1; // r13d
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v1 = 0;
v3[9] = __readfsqword(0x28u);
if ( !(unsigned int)regcomp(
v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)",
1LL) )
{
LOBYTE(v1) = (unsigned int)regexec(v3, a1, 0LL, 0LL, 0LL) == 0;
regfree(v3);
}
return v1;
} | func0.part.0:
PUSH R13
MOV EDX,0x1
LEA RSI,[0x102008]
XOR R13D,R13D
PUSH R12
PUSH RBP
MOV RBP,RDI
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x001012ca
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RDI,R12
MOV RSI,RBP
CALL 0x001010d0
MOV RDI,R12
TEST EAX,EAX
SETZ R13B
CALL 0x00101090
LAB_001012ca:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012e7
ADD RSP,0x50
MOV EAX,R13D
POP RBP
POP R12
POP R13
RET
LAB_001012e7:
CALL 0x001010a0 | bool func0_part_0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
bVar2 = false;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)"
,1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
bVar2 = iVar1 == 0;
regfree(&rStack_68);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,507 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
return false;
}
result = regexec(®ex, str, 0, NULL, 0);
match = (result == 0);
regfree(®ex);
return match;
}
| int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
xor %r12d,%r12d
push %rbp
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
test %rdi,%rdi
je 1333 <func0+0x43>
mov %rsp,%r13
mov %rdi,%rbp
mov $0x1,%edx
lea 0xce1(%rip),%rsi
mov %r13,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
je 1350 <func0+0x60>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 1372 <func0+0x82>
add $0x50,%rsp
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r13,%rdi
mov %rbp,%rsi
callq 10d0 <regexec@plt>
mov %r13,%rdi
test %eax,%eax
sete %r12b
callq 1090 <regfree@plt>
jmp 1333 <func0+0x43>
callq 10a0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
test rdi, rdi
jz short loc_12AD
mov rbp, rsp
mov rbx, rdi
mov edx, 1; cflags
lea rsi, pattern; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
mov rdi, rbp; preg
call _regcomp
test eax, eax
jz short loc_12D0
loc_12AD:
xor ebx, ebx
loc_12AF:
mov rax, [rsp+68h+var_20]
sub rax, fs:28h
jnz short loc_12F1
add rsp, 58h
mov eax, ebx
pop rbx
pop rbp
retn
loc_12D0:
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
test eax, eax
setz bl
call _regfree
jmp short loc_12AF
loc_12F1:
call ___stack_chk_fail | long long func0(char *string)
{
unsigned int v1; // ebx
regex_t v3; // [rsp+0h] [rbp-68h] BYREF
unsigned long long v4; // [rsp+48h] [rbp-20h]
v4 = __readfsqword(0x28u);
if ( string
&& (v1 = (unsigned int)string,
!regcomp(
&v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)",
1)) )
{
LOBYTE(v1) = regexec(&v3, string, 0LL, 0LL, 0) == 0;
regfree(&v3);
}
else
{
return 0;
}
return v1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001012ad
MOV RBP,RSP
MOV RBX,RDI
MOV EDX,0x1
LEA RSI,[0x102008]
MOV RDI,RBP
CALL 0x001010c0
TEST EAX,EAX
JZ 0x001012d0
LAB_001012ad:
XOR EBX,EBX
LAB_001012af:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012f1
ADD RSP,0x58
MOV EAX,EBX
POP RBX
POP RBP
RET
LAB_001012d0:
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
TEST EAX,EAX
SETZ BL
CALL 0x00101090
JMP 0x001012af
LAB_001012f1:
CALL 0x001010a0 | ulong func0(char *param_1)
{
int iVar1;
ulong uVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != (char *)0x0) {
iVar1 = regcomp(&rStack_68,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)"
,1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
uVar2 = CONCAT71((int7)((ulong)param_1 >> 8),iVar1 == 0);
regfree(&rStack_68);
goto LAB_001012af;
}
}
uVar2 = 0;
LAB_001012af:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,508 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jg 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jg short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 > (int)a2 )
return a2;
else
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JG 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,509 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,510 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,511 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,512 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,%eax
mov %al,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a3 <func0+0x3a>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x1c(%rbp)
jne 119f <func0+0x36>
mov $0x1,%eax
jmp 11ae <func0+0x45>
addl $0x1,-0x4(%rbp)
cmpl $0x9,-0x4(%rbp)
jle 1183 <func0+0x1a>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov eax, esi
mov [rbp+var_1C], al
mov [rbp+var_4], 0
jmp short loc_11A3
loc_1183:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_1C], al
jnz short loc_119F
mov eax, 1
jmp short loc_11AE
loc_119F:
add [rbp+var_4], 1
loc_11A3:
cmp [rbp+var_4], 9
jle short loc_1183
mov eax, 0
loc_11AE:
pop rbp
retn | long long func0(long long a1, char a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i <= 9; ++i )
{
if ( a2 == *(_BYTE *)(i + a1) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x1c],AL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a3
LAB_00101183:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x1c],AL
JNZ 0x0010119f
MOV EAX,0x1
JMP 0x001011ae
LAB_0010119f:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a3:
CMP dword ptr [RBP + -0x4],0x9
JLE 0x00101183
MOV EAX,0x0
LAB_001011ae:
POP RBP
RET | int8 func0(long param_1,char param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (9 < local_c) {
return 0;
}
if (param_2 == *(char *)(param_1 + local_c)) break;
local_c = local_c + 1;
}
return 1;
} |
5,513 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
add $0xa,%rdi
cmp %sil,(%rax)
je 1188 <func0+0x1f>
add $0x1,%rax
cmp %rdi,%rax
jne 1174 <func0+0xb>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
mov rax, rdi
add rdi, 0Ah
loc_1174:
cmp [rax], sil
jz short loc_1188
add rax, 1
cmp rax, rdi
jnz short loc_1174
mov eax, 0
retn
loc_1188:
mov eax, 1
retn | long long func0(_BYTE *a1, char a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rdi
v2 = a1;
v3 = a1 + 10;
while ( *v2 != a2 )
{
if ( ++v2 == v3 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,RDI
ADD RDI,0xa
LAB_00101174:
CMP byte ptr [RAX],SIL
JZ 0x00101188
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x00101174
MOV EAX,0x0
RET
LAB_00101188:
MOV EAX,0x1
RET | int8 func0(char *param_1,char param_2)
{
char *pcVar1;
pcVar1 = param_1 + 10;
do {
if (*param_1 == param_2) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
return 0;
} |
5,514 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O2 | c | func0:
endbr64
lea 0xa(%rdi),%rax
nopl 0x0(%rax,%rax,1)
cmp %sil,(%rdi)
je 1298 <func0+0x28>
add $0x1,%rdi
cmp %rax,%rdi
jne 1280 <func0+0x10>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
lea rax, [rdi+0Ah]
nop dword ptr [rax+rax+00000000h]
loc_1280:
cmp [rdi], sil
jz short loc_1298
add rdi, 1
cmp rdi, rax
jnz short loc_1280
xor eax, eax
retn
loc_1298:
mov eax, 1
retn | long long func0(_BYTE *a1, char a2)
{
_BYTE *v2; // rax
v2 = a1 + 10;
while ( *a1 != a2 )
{
if ( ++a1 == v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
LEA RAX,[RDI + 0xa]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101280:
CMP byte ptr [RDI],SIL
JZ 0x00101298
ADD RDI,0x1
CMP RDI,RAX
JNZ 0x00101280
XOR EAX,EAX
RET
LAB_00101298:
MOV EAX,0x1
RET | int8 func0(char *param_1,char param_2)
{
char *pcVar1;
pcVar1 = param_1 + 10;
do {
if (*param_1 == param_2) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
return 0;
} |
5,515 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O3 | c | func0:
endbr64
cmp (%rdi),%sil
je 1378 <func0+0x48>
cmp 0x1(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x2(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x3(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x4(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x5(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x6(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x7(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x8(%rdi),%sil
je 1378 <func0+0x48>
cmp %sil,0x9(%rdi)
sete %al
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp sil, [rdi]
jz short loc_1188
cmp sil, [rdi+1]
jz short loc_1188
cmp sil, [rdi+2]
jz short loc_1188
cmp sil, [rdi+3]
jz short loc_1188
cmp sil, [rdi+4]
jz short loc_1188
cmp sil, [rdi+5]
jz short loc_1188
cmp sil, [rdi+6]
jz short loc_1188
cmp sil, [rdi+7]
jz short loc_1188
cmp sil, [rdi+8]
jz short loc_1188
cmp [rdi+9], sil
setz al
retn
loc_1188:
mov eax, 1
retn | bool func0(_BYTE *a1, unsigned __int8 a2)
{
return a2 == *a1
|| a2 == a1[1]
|| a2 == a1[2]
|| a2 == a1[3]
|| a2 == a1[4]
|| a2 == a1[5]
|| a2 == a1[6]
|| a2 == a1[7]
|| a2 == a1[8]
|| a1[9] == a2;
} | func0:
ENDBR64
CMP SIL,byte ptr [RDI]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x1]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x2]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x3]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x4]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x5]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x6]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x7]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x8]
JZ 0x00101188
CMP byte ptr [RDI + 0x9],SIL
SETZ AL
RET
LAB_00101188:
MOV EAX,0x1
RET | bool func0(char *param_1,char param_2)
{
if ((((((param_2 != *param_1) && (param_2 != param_1[1])) && (param_2 != param_1[2])) &&
((param_2 != param_1[3] && (param_2 != param_1[4])))) &&
((param_2 != param_1[5] && ((param_2 != param_1[6] && (param_2 != param_1[7])))))) &&
(param_2 != param_1[8])) {
return param_1[9] == param_2;
}
return true;
} |
5,516 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
shr %eax
xor -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x2,%eax
xor %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x4,%eax
xor %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x8,%eax
xor %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x10,%eax
xor %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11b6 <func0+0x4d>
lea 0xe54(%rip),%rax
jmp 11bd <func0+0x54>
lea 0xe56(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
shr eax, 1
xor eax, [rbp+var_14]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 2
xor [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 4
xor [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 8
xor [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 10h
xor [rbp+var_4], eax
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jz short loc_11B6
lea rax, aOddParity; "Odd Parity"
jmp short loc_11BD
loc_11B6:
lea rax, s2; "Even Parity"
loc_11BD:
pop rbp
retn | const char * func0(unsigned int a1)
{
unsigned int v2; // [rsp+10h] [rbp-4h]
unsigned int v3; // [rsp+10h] [rbp-4h]
v2 = ((a1 ^ (a1 >> 1)) >> 2) ^ a1 ^ (a1 >> 1);
v3 = (((v2 >> 4) ^ v2) >> 8) ^ (v2 >> 4) ^ v2;
if ( ((BYTE2(v3) ^ (unsigned __int8)v3) & 1) != 0 )
return "Odd Parity";
else
return "Even Parity";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
SHR EAX,0x1
XOR EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x2
XOR dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x4
XOR dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x8
XOR dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x10
XOR dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011b6
LEA RAX,[0x102008]
JMP 0x001011bd
LAB_001011b6:
LEA RAX,[0x102013]
LAB_001011bd:
POP RBP
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 ^ param_1 >> 2;
param_1 = param_1 ^ param_1 >> 4;
param_1 = param_1 ^ param_1 >> 8;
if (((param_1 ^ param_1 >> 0x10) & 1) == 0) {
pcVar1 = "Even Parity";
}
else {
pcVar1 = "Odd Parity";
}
return pcVar1;
} |
5,517 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
shr %eax
xor %eax,%edi
mov %edi,%eax
shr $0x2,%eax
xor %edi,%eax
mov %eax,%edi
shr $0x4,%edi
xor %edi,%eax
mov %eax,%edi
shr $0x8,%edi
xor %eax,%edi
mov %edi,%eax
shr $0x10,%eax
xor %eax,%edi
test $0x1,%dil
lea 0xeaa(%rip),%rax
lea 0xeaf(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
mov edx, edi
shr edx, 1
xor edx, edi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
test al, 1
lea rax, aEvenParity; "Even Parity"
lea rdx, aOddParity; "Odd Parity"
cmovnz rax, rdx
retn | const char * func0(unsigned int a1)
{
const char *result; // rax
result = "Even Parity";
if ( (((unsigned __int8)((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8)) >> 16) ^ (unsigned __int8)(a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((unsigned __int16)(a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8))) & 1) != 0 )
return "Odd Parity";
return result;
} | func0:
ENDBR64
MOV EDX,EDI
SHR EDX,0x1
XOR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
TEST AL,0x1
LEA RAX,[0x10200f]
LEA RDX,[0x102004]
CMOVNZ RAX,RDX
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 >> 2 ^ param_1;
param_1 = param_1 >> 4 ^ param_1;
param_1 = param_1 >> 8 ^ param_1;
pcVar1 = "Even Parity";
if (((param_1 ^ param_1 >> 0x10) & 1) != 0) {
pcVar1 = "Odd Parity";
}
return pcVar1;
} |
5,518 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
lea 0xec3(%rip),%rdx
shr %eax
xor %eax,%edi
mov %edi,%eax
shr $0x2,%eax
xor %edi,%eax
mov %eax,%edi
shr $0x4,%edi
xor %edi,%eax
mov %eax,%edi
shr $0x8,%edi
xor %eax,%edi
mov %edi,%eax
shr $0x10,%eax
xor %eax,%edi
lea 0xe90(%rip),%rax
and $0x1,%edi
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
mov edx, edi
shr edx, 1
xor edx, edi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
lea rdx, aOddParity; "Odd Parity"
test al, 1
lea rax, aEvenParity; "Even Parity"
cmovnz rax, rdx
retn | const char * func0(unsigned int a1)
{
const char *result; // rax
result = "Even Parity";
if ( (((unsigned __int8)((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8)) >> 16) ^ (unsigned __int8)(a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((unsigned __int16)(a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8))) & 1) != 0 )
return "Odd Parity";
return result;
} | func0:
ENDBR64
MOV EDX,EDI
SHR EDX,0x1
XOR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
LEA RDX,[0x102004]
TEST AL,0x1
LEA RAX,[0x10200f]
CMOVNZ RAX,RDX
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 >> 2 ^ param_1;
param_1 = param_1 >> 4 ^ param_1;
param_1 = param_1 >> 8 ^ param_1;
pcVar1 = "Even Parity";
if (((param_1 ^ param_1 >> 0x10) & 1) != 0) {
pcVar1 = "Odd Parity";
}
return pcVar1;
} |
5,519 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
lea 0xec3(%rip),%rdx
shr %eax
xor %eax,%edi
mov %edi,%eax
shr $0x2,%eax
xor %edi,%eax
mov %eax,%edi
shr $0x4,%edi
xor %edi,%eax
mov %eax,%edi
shr $0x8,%edi
xor %eax,%edi
mov %edi,%eax
shr $0x10,%eax
xor %eax,%edi
lea 0xe90(%rip),%rax
and $0x1,%edi
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
mov edx, edi
shr edx, 1
xor edx, edi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
lea rdx, aEvenParity; "Even Parity"
test al, 1
lea rax, aOddParity; "Odd Parity"
cmovz rax, rdx
retn | const char * func0(unsigned int a1)
{
const char *result; // rax
result = "Odd Parity";
if ( (((unsigned __int8)((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8)) >> 16) ^ (unsigned __int8)(a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((unsigned __int16)(a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8))) & 1) == 0 )
return "Even Parity";
return result;
} | func0:
ENDBR64
MOV EDX,EDI
SHR EDX,0x1
XOR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
LEA RDX,[0x10200f]
TEST AL,0x1
LEA RAX,[0x102004]
CMOVZ RAX,RDX
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 >> 2 ^ param_1;
param_1 = param_1 >> 4 ^ param_1;
param_1 = param_1 >> 8 ^ param_1;
pcVar1 = "Odd Parity";
if (((param_1 ^ param_1 >> 0x10) & 1) == 0) {
pcVar1 = "Even Parity";
}
return pcVar1;
} |
5,520 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
char y = z[1]; // Assume the smallest bigger element is the next one in the beginning
// Find minimum element in z that is greater than z[0]
for (size_t j = 1; j < z_len; ++j) {
if (z[j] > z[0] && z[j] < y) {
y = z[j];
}
}
// Remove the chosen element y from z
for (size_t j = 0; j < z_len; ++j) {
if (z[j] == y) {
for (size_t k = j; k < z_len - 1; ++k) {
z[k] = z[k + 1];
}
z[z_len-1] = '\0';
break;
}
}
// Sort rest of z
qsort(z, strlen(z), sizeof(char), (int(*)(const void *, const void *))strcmp);
// Replace contents from index i in nums with [y] + sorted z
nums[i] = y;
strcpy(nums + i + 1, z);
// Convert back to integer and return
return atoi(nums);
}
}
return 0; // Using 0 to signify false.
}
| int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %edi,-0x54(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x54(%rbp),%edx
lea -0x1e(%rbp),%rax
lea 0xdb3(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1130 <sprintf@plt>
lea -0x1e(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %rax,-0x30(%rbp)
mov -0x30(%rbp),%rax
sub $0x2,%eax
mov %eax,-0x4c(%rbp)
jmpq 13ff <func0+0x1d6>
mov -0x4c(%rbp),%eax
cltq
movzbl -0x1e(%rbp,%rax,1),%edx
mov -0x4c(%rbp),%eax
add $0x1,%eax
cltq
movzbl -0x1e(%rbp,%rax,1),%eax
cmp %al,%dl
jge 13fb <func0+0x1d2>
mov -0x4c(%rbp),%eax
cltq
lea -0x1e(%rbp),%rdx
add %rax,%rdx
lea -0x13(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10c0 <strcpy@plt>
lea -0x13(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %rax,-0x28(%rbp)
movzbl -0x12(%rbp),%eax
mov %al,-0x4d(%rbp)
movq $0x1,-0x48(%rbp)
jmp 131b <func0+0xf2>
lea -0x13(%rbp),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
movzbl -0x13(%rbp),%eax
cmp %al,%dl
jle 1316 <func0+0xed>
lea -0x13(%rbp),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x4d(%rbp)
jle 1316 <func0+0xed>
lea -0x13(%rbp),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x4d(%rbp)
addq $0x1,-0x48(%rbp)
mov -0x48(%rbp),%rax
cmp -0x28(%rbp),%rax
jb 12dc <func0+0xb3>
movq $0x0,-0x40(%rbp)
jmp 138d <func0+0x164>
lea -0x13(%rbp),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x4d(%rbp)
jne 1388 <func0+0x15f>
mov -0x40(%rbp),%rax
mov %rax,-0x38(%rbp)
jmp 136b <func0+0x142>
mov -0x38(%rbp),%rax
add $0x1,%rax
movzbl -0x13(%rbp,%rax,1),%eax
lea -0x13(%rbp),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
mov %al,(%rdx)
addq $0x1,-0x38(%rbp)
mov -0x28(%rbp),%rax
sub $0x1,%rax
cmp %rax,-0x38(%rbp)
jb 134c <func0+0x123>
mov -0x28(%rbp),%rax
sub $0x1,%rax
movb $0x0,-0x13(%rbp,%rax,1)
jmp 1397 <func0+0x16e>
addq $0x1,-0x40(%rbp)
mov -0x40(%rbp),%rax
cmp -0x28(%rbp),%rax
jb 132f <func0+0x106>
lea -0x13(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %rax,%rsi
lea -0x13(%rbp),%rax
mov 0x2c2f(%rip),%rdx
mov %rdx,%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 10e0 <qsort@plt>
mov -0x4c(%rbp),%eax
cltq
movzbl -0x4d(%rbp),%edx
mov %dl,-0x1e(%rbp,%rax,1)
mov -0x4c(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
lea -0x1e(%rbp),%rax
add %rax,%rdx
lea -0x13(%rbp),%rax
mov %rax,%rsi
mov %rdx,%rdi
callq 10c0 <strcpy@plt>
lea -0x1e(%rbp),%rax
mov %rax,%rdi
callq 1120 <atoi@plt>
jmp 140e <func0+0x1e5>
subl $0x1,-0x4c(%rbp)
cmpl $0x0,-0x4c(%rbp)
jns 1281 <func0+0x58>
mov $0x0,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1422 <func0+0x1f9>
callq 1100 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_54], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edx, [rbp+var_54]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
sub eax, 2
mov [rbp+var_4C], eax
jmp loc_1402
loc_1284:
mov eax, [rbp+var_4C]
cdqe
movzx edx, [rbp+rax+s]
mov eax, [rbp+var_4C]
add eax, 1
cdqe
movzx eax, [rbp+rax+s]
cmp dl, al
jge loc_13FE
mov eax, [rbp+var_4C]
cdqe
lea rdx, [rbp+s]
add rdx, rax
lea rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
lea rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov [rbp+var_28], rax
movzx eax, [rbp+var_12]
mov [rbp+var_4D], al
mov [rbp+var_48], 1
jmp short loc_131E
loc_12DF:
lea rdx, [rbp+dest]
mov rax, [rbp+var_48]
add rax, rdx
movzx edx, byte ptr [rax]
movzx eax, [rbp+dest]
cmp dl, al
jle short loc_1319
lea rdx, [rbp+dest]
mov rax, [rbp+var_48]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_4D], al
jle short loc_1319
lea rdx, [rbp+dest]
mov rax, [rbp+var_48]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_4D], al
loc_1319:
add [rbp+var_48], 1
loc_131E:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_28]
jb short loc_12DF
mov [rbp+var_40], 0
jmp short loc_1390
loc_1332:
lea rdx, [rbp+dest]
mov rax, [rbp+var_40]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_4D], al
jnz short loc_138B
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
jmp short loc_136E
loc_134F:
mov rax, [rbp+var_38]
add rax, 1
movzx eax, [rbp+rax+dest]
lea rcx, [rbp+dest]
mov rdx, [rbp+var_38]
add rdx, rcx
mov [rdx], al
add [rbp+var_38], 1
loc_136E:
mov rax, [rbp+var_28]
sub rax, 1
cmp [rbp+var_38], rax
jb short loc_134F
mov rax, [rbp+var_28]
sub rax, 1
mov [rbp+rax+dest], 0
jmp short loc_139A
loc_138B:
add [rbp+var_40], 1
loc_1390:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_28]
jb short loc_1332
loc_139A:
lea rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rsi, rax; nmemb
lea rax, [rbp+dest]
mov rdx, cs:compar
mov rcx, rdx; compar
mov edx, 1; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_4C]
cdqe
movzx edx, [rbp+var_4D]
mov [rbp+rax+s], dl
mov eax, [rbp+var_4C]
cdqe
lea rdx, [rax+1]
lea rax, [rbp+s]
add rdx, rax
lea rax, [rbp+dest]
mov rsi, rax; src
mov rdi, rdx; dest
call _strcpy
lea rax, [rbp+s]
mov rdi, rax; nptr
call _atoi
jmp short loc_1411
loc_13FE:
sub [rbp+var_4C], 1
loc_1402:
cmp [rbp+var_4C], 0
jns loc_1284
mov eax, 0
loc_1411:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1425
call ___stack_chk_fail
locret_1425:
leave
retn | int func0(int a1)
{
size_t v1; // rax
char v3; // [rsp+13h] [rbp-4Dh]
int i; // [rsp+14h] [rbp-4Ch]
unsigned long long j; // [rsp+18h] [rbp-48h]
size_t k; // [rsp+20h] [rbp-40h]
unsigned long long m; // [rsp+28h] [rbp-38h]
size_t v8; // [rsp+38h] [rbp-28h]
char s[11]; // [rsp+42h] [rbp-1Eh] BYREF
char dest[11]; // [rsp+4Dh] [rbp-13h] BYREF
unsigned long long v11; // [rsp+58h] [rbp-8h]
v11 = __readfsqword(0x28u);
sprintf(s, "%d", a1);
for ( i = strlen(s) - 2; ; --i )
{
if ( i < 0 )
return 0;
if ( s[i] < s[i + 1] )
break;
}
strcpy(dest, &s[i]);
v8 = strlen(dest);
v3 = dest[1];
for ( j = 1LL; j < v8; ++j )
{
if ( dest[j] > dest[0] && v3 > dest[j] )
v3 = dest[j];
}
for ( k = 0LL; k < v8; ++k )
{
if ( v3 == dest[k] )
{
for ( m = k; m < v8 - 1; ++m )
dest[m] = dest[m + 1];
dest[v8 - 1] = 0;
break;
}
}
v1 = strlen(dest);
qsort(dest, v1, 1uLL, (__compar_fn_t)&strcmp);
s[i] = v3;
strcpy(&s[i + 1], dest);
return atoi(s);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x54],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDX,dword ptr [RBP + -0x54]
LEA RAX,[RBP + -0x1e]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101130
LEA RAX,[RBP + -0x1e]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
SUB EAX,0x2
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00101402
LAB_00101284:
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
MOVZX EDX,byte ptr [RBP + RAX*0x1 + -0x1e]
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x1
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x1e]
CMP DL,AL
JGE 0x001013fe
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
LEA RDX,[RBP + -0x1e]
ADD RDX,RAX
LEA RAX,[RBP + -0x13]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010c0
LEA RAX,[RBP + -0x13]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x28],RAX
MOVZX EAX,byte ptr [RBP + -0x12]
MOV byte ptr [RBP + -0x4d],AL
MOV qword ptr [RBP + -0x48],0x1
JMP 0x0010131e
LAB_001012df:
LEA RDX,[RBP + -0x13]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOVZX EAX,byte ptr [RBP + -0x13]
CMP DL,AL
JLE 0x00101319
LEA RDX,[RBP + -0x13]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x4d],AL
JLE 0x00101319
LEA RDX,[RBP + -0x13]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x4d],AL
LAB_00101319:
ADD qword ptr [RBP + -0x48],0x1
LAB_0010131e:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001012df
MOV qword ptr [RBP + -0x40],0x0
JMP 0x00101390
LAB_00101332:
LEA RDX,[RBP + -0x13]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x4d],AL
JNZ 0x0010138b
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0010136e
LAB_0010134f:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x13]
LEA RCX,[RBP + -0x13]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV byte ptr [RDX],AL
ADD qword ptr [RBP + -0x38],0x1
LAB_0010136e:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
CMP qword ptr [RBP + -0x38],RAX
JC 0x0010134f
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
MOV byte ptr [RBP + RAX*0x1 + -0x13],0x0
JMP 0x0010139a
LAB_0010138b:
ADD qword ptr [RBP + -0x40],0x1
LAB_00101390:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00101332
LAB_0010139a:
LEA RAX,[RBP + -0x13]
MOV RDI,RAX
CALL 0x001010f0
MOV RSI,RAX
LEA RAX,[RBP + -0x13]
MOV RDX,qword ptr [0x00103fe0]
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001010e0
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
MOVZX EDX,byte ptr [RBP + -0x4d]
MOV byte ptr [RBP + RAX*0x1 + -0x1e],DL
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
LEA RDX,[RAX + 0x1]
LEA RAX,[RBP + -0x1e]
ADD RDX,RAX
LEA RAX,[RBP + -0x13]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001010c0
LEA RAX,[RBP + -0x1e]
MOV RDI,RAX
CALL 0x00101120
JMP 0x00101411
LAB_001013fe:
SUB dword ptr [RBP + -0x4c],0x1
LAB_00101402:
CMP dword ptr [RBP + -0x4c],0x0
JNS 0x00101284
MOV EAX,0x0
LAB_00101411:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101425
CALL 0x00101100
LAB_00101425:
LEAVE
RET | int func0(uint param_1)
{
int iVar1;
size_t sVar2;
long in_FS_OFFSET;
char local_55;
int local_54;
ulong local_50;
ulong local_48;
ulong local_40;
char local_26 [10];
char acStack_1c [12];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(local_26,"%d",(ulong)param_1);
sVar2 = strlen(local_26);
local_54 = (int)sVar2 + -2;
LAB_00101402:
if (local_54 < 0) {
iVar1 = 0;
LAB_00101411:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1;
}
if (local_26[local_54 + 1] <= local_26[local_54]) {
local_54 = local_54 + -1;
goto LAB_00101402;
}
strcpy(acStack_1c + 1,local_26 + local_54);
sVar2 = strlen(acStack_1c + 1);
local_55 = acStack_1c[2];
for (local_50 = 1; local_50 < sVar2; local_50 = local_50 + 1) {
if ((acStack_1c[1] < acStack_1c[local_50 + 1]) && (acStack_1c[local_50 + 1] < local_55)) {
local_55 = acStack_1c[local_50 + 1];
}
}
local_48 = 0;
while( true ) {
if (sVar2 <= local_48) goto LAB_0010139a;
if (local_55 == acStack_1c[local_48 + 1]) break;
local_48 = local_48 + 1;
}
for (local_40 = local_48; local_40 < sVar2 - 1; local_40 = local_40 + 1) {
acStack_1c[local_40 + 1] = acStack_1c[local_40 + 2];
}
acStack_1c[sVar2] = '\0';
LAB_0010139a:
sVar2 = strlen(acStack_1c + 1);
qsort(acStack_1c + 1,sVar2,1,(__compar_fn_t)PTR_strcmp_00103fe0);
local_26[local_54] = local_55;
strcpy(local_26 + (long)local_54 + 1,acStack_1c + 1);
iVar1 = atoi(local_26);
goto LAB_00101411;
} |
5,521 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
char y = z[1]; // Assume the smallest bigger element is the next one in the beginning
// Find minimum element in z that is greater than z[0]
for (size_t j = 1; j < z_len; ++j) {
if (z[j] > z[0] && z[j] < y) {
y = z[j];
}
}
// Remove the chosen element y from z
for (size_t j = 0; j < z_len; ++j) {
if (z[j] == y) {
for (size_t k = j; k < z_len - 1; ++k) {
z[k] = z[k + 1];
}
z[z_len-1] = '\0';
break;
}
}
// Sort rest of z
qsort(z, strlen(z), sizeof(char), (int(*)(const void *, const void *))strcmp);
// Replace contents from index i in nums with [y] + sorted z
nums[i] = y;
strcpy(nums + i + 1, z);
// Convert back to integer and return
return atoi(nums);
}
}
return 0; // Using 0 to signify false.
}
| int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %edi,%r8d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbx
lea 0xdae(%rip),%rcx
mov $0xb,%edx
mov $0x1,%esi
mov %rbx,%rdi
callq 1130 <__sprintf_chk@plt>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
mov %ecx,%edx
sub $0x2,%ecx
js 13e3 <func0+0x1ba>
movslq %ecx,%rcx
mov %rcx,%rax
lea 0x2(%rsp),%rsi
sub $0x1,%edx
movslq %edx,%rdx
sub %rcx,%rdx
add %rsi,%rdx
mov %eax,%ebx
movzbl (%rdx,%rax,1),%edi
cmp %dil,(%rsi,%rax,1)
jl 12c0 <func0+0x97>
sub $0x1,%rax
test %eax,%eax
jns 12a2 <func0+0x79>
mov $0x0,%eax
jmpq 13c8 <func0+0x19f>
movslq %eax,%r12
lea 0x2(%rsp,%r12,1),%rsi
lea 0xd(%rsp),%rbp
mov $0xb,%edx
mov %rbp,%rdi
callq 1120 <__strcpy_chk@plt>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbp,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
movzbl 0xe(%rsp),%ebp
cmp $0x1,%rcx
jbe 1327 <func0+0xfe>
movzbl 0xd(%rsp),%edi
lea 0xe(%rsp),%rax
lea 0xd(%rsp,%rcx,1),%rsi
jmp 1317 <func0+0xee>
add $0x1,%rax
cmp %rsi,%rax
je 132c <func0+0x103>
movzbl (%rax),%edx
cmp %dil,%dl
jle 130e <func0+0xe5>
cmp %dl,%bpl
cmovg %edx,%ebp
jmp 130e <func0+0xe5>
test %rcx,%rcx
je 136e <func0+0x145>
mov $0x0,%eax
lea 0xd(%rsp),%rdx
cmp %bpl,(%rax,%rdx,1)
je 1347 <func0+0x11e>
add $0x1,%rax
cmp %rax,%rcx
ja 1336 <func0+0x10d>
jmp 136e <func0+0x145>
lea -0x1(%rcx),%rsi
cmp %rax,%rsi
jbe 1369 <func0+0x140>
lea 0xd(%rsp,%rax,1),%rax
lea 0xc(%rsp,%rcx,1),%rcx
movzbl 0x1(%rax),%edx
mov %dl,(%rax)
add $0x1,%rax
cmp %rcx,%rax
jne 135a <func0+0x131>
movb $0x0,0xd(%rsp,%rsi,1)
lea 0xd(%rsp),%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r13,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rsi
mov 0x2c4e(%rip),%rcx
mov $0x1,%edx
mov %r13,%rdi
callq 10e0 <qsort@plt>
movslq %ebx,%rbx
mov %bpl,0x2(%rsp,%rbx,1)
lea 0x3(%rsp,%r12,1),%rdi
mov %r13,%rsi
callq 10c0 <strcpy@plt>
mov $0xa,%edx
mov $0x0,%esi
lea 0x2(%rsp),%rdi
callq 1110 <strtol@plt>
mov 0x18(%rsp),%rbx
xor %fs:0x28,%rbx
jne 13ea <func0+0x1c1>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%eax
jmp 13c8 <func0+0x19f>
callq 10f0 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r8d, edi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea rbx, [rsp+48h+var_46]
lea rcx, unk_2004
mov edx, 0Bh
mov esi, 1
mov rdi, rbx
call ___sprintf_chk
mov rdi, rbx
call _strlen
mov edx, eax
sub eax, 2
js loc_13D3
movsxd rcx, eax
mov rax, rcx
mov rsi, rbx
sub edx, 1
movsxd rdx, edx
sub rdx, rcx
add rdx, rbx
loc_12B0:
mov ebp, eax
movzx edi, byte ptr [rdx+rax]
cmp [rsi+rax], dil
jl short loc_12CE
sub rax, 1
test eax, eax
jns short loc_12B0
mov eax, 0
jmp loc_13B8
loc_12CE:
movsxd r12, eax
lea rsi, [rsp+r12+48h+var_46]
lea rbx, [rsp+48h+var_3B]
mov edx, 0Bh
mov rdi, rbx
call ___strcpy_chk
mov rdi, rbx
call _strlen
movzx ebx, [rsp+48h+var_3A]
cmp rax, 1
jbe short loc_133E
movzx r8d, [rsp+48h+var_3B]
lea rdx, [rsp+48h+var_3A]
lea rdi, [rsp+rax+48h+var_3B]
loc_130B:
movzx ecx, byte ptr [rdx]
cmp bl, cl
mov esi, ecx
cmovle esi, ebx
cmp cl, r8b
cmovg ebx, esi
add rdx, 1
cmp rdx, rdi
jnz short loc_130B
loc_1324:
mov edx, 0
lea rcx, [rsp+48h+var_3B]
loc_132E:
cmp [rdx+rcx], bl
jz short loc_1345
add rdx, 1
cmp rax, rdx
ja short loc_132E
jmp short loc_136C
loc_133E:
test rax, rax
jz short loc_136C
jmp short loc_1324
loc_1345:
lea rsi, [rax-1]
cmp rsi, rdx
jbe short loc_1367
lea rdx, [rsp+rdx+48h+var_3B]
lea rcx, [rsp+rax+48h+var_3C]
loc_1358:
movzx eax, byte ptr [rdx+1]
mov [rdx], al
add rdx, 1
cmp rdx, rcx
jnz short loc_1358
loc_1367:
mov [rsp+rsi+48h+var_3B], 0
loc_136C:
lea r13, [rsp+48h+var_3B]
mov rdi, r13
call _strlen
mov rsi, rax
mov rcx, cs:strcmp_ptr
mov edx, 1
mov rdi, r13
call _qsort
movsxd rbp, ebp
mov [rsp+rbp+48h+var_46], bl
lea rdi, [rsp+r12+48h+var_45]
mov rsi, r13
call _strcpy
mov edx, 0Ah
mov esi, 0
lea rdi, [rsp+48h+var_46]
call _strtol
loc_13B8:
mov rdx, [rsp+48h+var_30]
sub rdx, fs:28h
jnz short loc_13DA
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13D3:
mov eax, 0
jmp short loc_13B8
loc_13DA:
call ___stack_chk_fail | long long func0(unsigned int a1)
{
int v1; // edx
long long v2; // rax
_BYTE *v3; // rdx
int v4; // ebp
long long v6; // r12
unsigned long long v7; // rax
int v8; // ebx
char *v9; // rdx
int v10; // esi
unsigned long long v11; // rdx
char *v12; // rdx
long long v13; // rax
_BYTE v14[11]; // [rsp+2h] [rbp-46h] BYREF
char v15; // [rsp+Dh] [rbp-3Bh] BYREF
unsigned __int8 v16; // [rsp+Eh] [rbp-3Ah] BYREF
unsigned long long v17; // [rsp+18h] [rbp-30h]
v17 = __readfsqword(0x28u);
__sprintf_chk(v14, 1LL, 11LL, &unk_2004, a1);
v1 = strlen(v14);
LODWORD(v2) = v1 - 2;
if ( v1 - 2 >= 0 )
{
v2 = (int)v2;
v3 = &v14[v1 - 1 - (long long)(int)v2];
while ( 1 )
{
v4 = v2;
if ( v14[v2] < v3[v2] )
break;
if ( (int)--v2 < 0 )
return 0LL;
}
v6 = (int)v2;
__strcpy_chk(&v15, &v14[(int)v2], 11LL);
v7 = strlen(&v15);
v8 = v16;
if ( v7 <= 1 )
{
if ( !v7 )
{
LABEL_23:
v13 = strlen(&v15);
qsort(&v15, v13, 1LL, &strcmp);
v14[v4] = v8;
strcpy(&v14[v6 + 1], &v15);
return strtol(v14, 0LL, 10LL);
}
}
else
{
v9 = (char *)&v16;
do
{
v10 = (unsigned __int8)*v9;
if ( (char)v8 <= *v9 )
v10 = v8;
if ( *v9 > v15 )
v8 = v10;
++v9;
}
while ( v9 != &v15 + v7 );
}
v11 = 0LL;
while ( *(&v15 + v11) != (_BYTE)v8 )
{
if ( v7 <= ++v11 )
goto LABEL_23;
}
if ( v7 - 1 > v11 )
{
v12 = &v15 + v11;
do
{
*v12 = v12[1];
++v12;
}
while ( v12 != &v14[v7 + 10] );
}
*(&v15 + v7 - 1) = 0;
goto LABEL_23;
}
return 0LL;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x2]
LEA RCX,[0x102004]
MOV EDX,0xb
MOV ESI,0x1
MOV RDI,RBX
CALL 0x00101150
MOV RDI,RBX
CALL 0x00101100
MOV EDX,EAX
SUB EAX,0x2
JS 0x001013d3
MOVSXD RCX,EAX
MOV RAX,RCX
MOV RSI,RBX
SUB EDX,0x1
MOVSXD RDX,EDX
SUB RDX,RCX
ADD RDX,RBX
LAB_001012b0:
MOV EBP,EAX
MOVZX EDI,byte ptr [RDX + RAX*0x1]
CMP byte ptr [RSI + RAX*0x1],DIL
JL 0x001012ce
SUB RAX,0x1
TEST EAX,EAX
JNS 0x001012b0
MOV EAX,0x0
JMP 0x001013b8
LAB_001012ce:
MOVSXD R12,EAX
LEA RSI,[RSP + R12*0x1 + 0x2]
LEA RBX,[RSP + 0xd]
MOV EDX,0xb
MOV RDI,RBX
CALL 0x00101140
MOV RDI,RBX
CALL 0x00101100
MOVZX EBX,byte ptr [RSP + 0xe]
CMP RAX,0x1
JBE 0x0010133e
MOVZX R8D,byte ptr [RSP + 0xd]
LEA RDX,[RSP + 0xe]
LEA RDI,[RSP + RAX*0x1 + 0xd]
LAB_0010130b:
MOVZX ECX,byte ptr [RDX]
CMP BL,CL
MOV ESI,ECX
CMOVLE ESI,EBX
CMP CL,R8B
CMOVG EBX,ESI
ADD RDX,0x1
CMP RDX,RDI
JNZ 0x0010130b
LAB_00101324:
MOV EDX,0x0
LEA RCX,[RSP + 0xd]
LAB_0010132e:
CMP byte ptr [RDX + RCX*0x1],BL
JZ 0x00101345
ADD RDX,0x1
CMP RAX,RDX
JA 0x0010132e
JMP 0x0010136c
LAB_0010133e:
TEST RAX,RAX
JZ 0x0010136c
JMP 0x00101324
LAB_00101345:
LEA RSI,[RAX + -0x1]
CMP RSI,RDX
JBE 0x00101367
LEA RDX,[RSP + RDX*0x1 + 0xd]
LEA RCX,[RSP + RAX*0x1 + 0xc]
LAB_00101358:
MOVZX EAX,byte ptr [RDX + 0x1]
MOV byte ptr [RDX],AL
ADD RDX,0x1
CMP RDX,RCX
JNZ 0x00101358
LAB_00101367:
MOV byte ptr [RSP + RSI*0x1 + 0xd],0x0
LAB_0010136c:
LEA R13,[RSP + 0xd]
MOV RDI,R13
CALL 0x00101100
MOV RSI,RAX
MOV RCX,qword ptr [0x00103fe0]
MOV EDX,0x1
MOV RDI,R13
CALL 0x001010f0
MOVSXD RBP,EBP
MOV byte ptr [RSP + RBP*0x1 + 0x2],BL
LEA RDI,[RSP + R12*0x1 + 0x3]
MOV RSI,R13
CALL 0x001010d0
MOV EDX,0xa
MOV ESI,0x0
LEA RDI,[RSP + 0x2]
CALL 0x00101130
LAB_001013b8:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013da
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013d3:
MOV EAX,0x0
JMP 0x001013b8
LAB_001013da:
CALL 0x00101110 | long func0(int4 param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
long lVar4;
char *pcVar5;
ulong uVar6;
char cVar7;
char cVar8;
long in_FS_OFFSET;
char local_46 [10];
char acStack_3c [12];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_46,1,0xb,&DAT_00102004,param_1);
sVar2 = strlen(local_46);
iVar1 = (int)sVar2 + -2;
if (-1 < iVar1) {
lVar3 = (long)iVar1;
lVar4 = ((int)sVar2 + -1) - lVar3;
while (iVar1 = (int)lVar3, local_46[lVar3 + lVar4] <= local_46[lVar3]) {
lVar3 = lVar3 + -1;
if ((int)lVar3 < 0) goto code_r0x001012c4;
}
__strcpy_chk(acStack_3c + 1,local_46 + iVar1,0xb);
sVar2 = strlen(acStack_3c + 1);
if (sVar2 < 2) {
cVar7 = acStack_3c[2];
if (sVar2 != 0) goto LAB_00101324;
goto LAB_0010136c;
}
pcVar5 = acStack_3c + 2;
do {
cVar7 = *pcVar5;
cVar8 = cVar7;
if (acStack_3c[2] <= cVar7) {
cVar8 = acStack_3c[2];
}
if (acStack_3c[1] < cVar7) {
acStack_3c[2] = cVar8;
}
pcVar5 = pcVar5 + 1;
cVar7 = acStack_3c[2];
} while (pcVar5 != acStack_3c + sVar2 + 1);
LAB_00101324:
uVar6 = 0;
while (acStack_3c[uVar6 + 1] != cVar7) {
uVar6 = uVar6 + 1;
if (sVar2 <= uVar6) goto LAB_0010136c;
}
if (uVar6 < sVar2 - 1) {
pcVar5 = acStack_3c + uVar6 + 1;
do {
*pcVar5 = pcVar5[1];
pcVar5 = pcVar5 + 1;
} while (pcVar5 != acStack_3c + sVar2);
}
acStack_3c[sVar2] = '\0';
LAB_0010136c:
pcVar5 = acStack_3c + 1;
sVar2 = strlen(pcVar5);
qsort(pcVar5,sVar2,1,(__compar_fn_t)PTR_strcmp_00103fe0);
local_46[iVar1] = cVar7;
strcpy(local_46 + (long)iVar1 + 1,pcVar5);
lVar3 = strtol(local_46,(char **)0x0,10);
goto LAB_001013b8;
}
lVar3 = 0;
LAB_001013b8:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar3;
code_r0x001012c4:
lVar3 = 0;
goto LAB_001013b8;
} |
5,522 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
char y = z[1]; // Assume the smallest bigger element is the next one in the beginning
// Find minimum element in z that is greater than z[0]
for (size_t j = 1; j < z_len; ++j) {
if (z[j] > z[0] && z[j] < y) {
y = z[j];
}
}
// Remove the chosen element y from z
for (size_t j = 0; j < z_len; ++j) {
if (z[j] == y) {
for (size_t k = j; k < z_len - 1; ++k) {
z[k] = z[k + 1];
}
z[z_len-1] = '\0';
break;
}
}
// Sort rest of z
qsort(z, strlen(z), sizeof(char), (int(*)(const void *, const void *))strcmp);
// Replace contents from index i in nums with [y] + sorted z
nums[i] = y;
strcpy(nums + i + 1, z);
// Convert back to integer and return
return atoi(nums);
}
}
return 0; // Using 0 to signify false.
}
| int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %edi,%r8d
mov $0xb,%edx
mov $0x1,%esi
push %r12
lea 0xce8(%rip),%rcx
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbp
mov %rbp,%rdi
callq 1150 <__sprintf_chk@plt>
mov %rbp,%rdi
callq 1100 <strlen@plt>
mov %eax,%edx
sub $0x2,%eax
js 1470 <func0+0x170>
sub $0x1,%edx
cltq
movslq %edx,%rdx
sub %rax,%rdx
add %rbp,%rdx
jmp 1374 <func0+0x74>
nopw 0x0(%rax,%rax,1)
sub $0x1,%rax
test %eax,%eax
js 1470 <func0+0x170>
movzbl (%rdx,%rax,1),%edi
movslq %eax,%rbx
cmp %dil,0x0(%rbp,%rax,1)
jge 1368 <func0+0x68>
lea 0xd(%rsp),%r13
lea 0x0(%rbp,%rbx,1),%rsi
mov $0xb,%edx
mov %r13,%rdi
callq 1140 <__stpcpy_chk@plt>
movzbl 0xe(%rsp),%r12d
sub %r13,%rax
mov %rax,%r8
cmp $0x1,%rax
jbe 148d <func0+0x18d>
movzbl 0xd(%rsp),%ecx
lea 0xf(%rsp),%rdx
lea 0x0(%r13,%rax,1),%rax
mov %r12d,%esi
jmp 13cf <func0+0xcf>
nopl 0x0(%rax,%rax,1)
movzbl (%rdx),%esi
add $0x1,%rdx
cmp %sil,%cl
jge 13db <func0+0xdb>
cmp %sil,%r12b
cmovg %esi,%r12d
cmp %rax,%rdx
jne 13c8 <func0+0xc8>
xor %edx,%edx
jmp 13f7 <func0+0xf7>
nopl 0x0(%rax)
add $0x1,%rdx
cmp %rdx,%r8
jbe 1430 <func0+0x130>
movzbl 0x0(%r13,%rdx,1),%ecx
cmp %cl,%r12b
jne 13e8 <func0+0xe8>
lea -0x1(%r8),%rdi
lea 0x0(%r13,%rdx,1),%rcx
lea 0xc(%rsp,%r8,1),%rsi
cmp %rdx,%rdi
jbe 1420 <func0+0x120>
movzbl 0x1(%rcx),%eax
add $0x1,%rcx
mov %al,-0x1(%rcx)
cmp %rcx,%rsi
jne 1410 <func0+0x110>
movb $0x0,0xd(%rsp,%rdi,1)
mov %r13,%rdi
callq 1100 <strlen@plt>
mov %rax,%r8
mov 0x2ba9(%rip),%rcx
mov %r8,%rsi
mov $0x1,%edx
mov %r13,%rdi
callq 10f0 <qsort@plt>
lea 0x1(%rbp,%rbx,1),%rdi
mov %r13,%rsi
mov %r12b,0x2(%rsp,%rbx,1)
callq 10d0 <strcpy@plt>
mov $0xa,%edx
xor %esi,%esi
mov %rbp,%rdi
callq 1130 <strtol@plt>
jmp 1472 <func0+0x172>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
mov 0x18(%rsp),%rbx
xor %fs:0x28,%rbx
jne 149c <func0+0x19c>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
test %rax,%rax
je 1430 <func0+0x130>
movzbl 0xd(%rsp),%ecx
jmpq 13e0 <func0+0xe0>
callq 1110 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov r8d, edi
mov edx, 0Bh
mov esi, 1
push r13
lea rcx, unk_2004
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea rbp, [rsp+48h+var_46]
mov rdi, rbp
call ___sprintf_chk
mov rdi, rbp
call _strlen
mov edx, eax
sub eax, 2
js loc_1480
sub edx, 1
cdqe
movsxd rdx, edx
sub rdx, rax
add rdx, rbp
jmp short loc_1394
loc_1388:
sub rax, 1
test eax, eax
js loc_1480
loc_1394:
movzx esi, byte ptr [rdx+rax]
movsxd r12, eax
cmp [rbp+rax+0], sil
jge short loc_1388
lea r13, [rsp+48h+var_3B]
lea rsi, [rbp+r12+0]
mov edx, 0Bh
mov rdi, r13
call ___stpcpy_chk
movzx ebx, [rsp+48h+var_3A]
sub rax, r13
mov rsi, rax
cmp rax, 1
jbe loc_149F
movzx r8d, [rsp+48h+var_3B]
lea rcx, [rsp+48h+var_39]
lea rdi, [r13+rax+0]
mov edx, ebx
jmp short loc_13EF
loc_13E8:
movzx edx, byte ptr [rcx]
add rcx, 1
loc_13EF:
cmp bl, dl
mov eax, edx
cmovle eax, ebx
cmp r8b, dl
cmovl ebx, eax
cmp rdi, rcx
jnz short loc_13E8
loc_1401:
xor edi, edi
jmp short loc_1417
loc_1408:
add rdi, 1
cmp rsi, rdi
jbe short loc_1449
movzx r8d, byte ptr [r13+rdi+0]
loc_1417:
cmp bl, r8b
jnz short loc_1408
lea r14, [rsi-1]
cmp r14, rdi
jbe short loc_1438
mov rdx, r14
lea rsi, [r13+rdi+1]
sub rdx, rdi
add rdi, r13
call _memmove
loc_1438:
mov rdi, r13
mov [rsp+r14+48h+var_3B], 0
call _strlen
mov rsi, rax
loc_1449:
mov rcx, cs:strcmp_ptr
mov edx, 1
mov rdi, r13
call _qsort
lea rdi, [rbp+r12+1]
mov rsi, r13
mov [rsp+r12+48h+var_46], bl
call _strcpy
mov edx, 0Ah
xor esi, esi
mov rdi, rbp
call _strtol
jmp short loc_1482
loc_1480:
xor eax, eax
loc_1482:
mov rdx, [rsp+48h+var_30]
sub rdx, fs:28h
jnz short loc_14AF
add rsp, 20h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_149F:
test rax, rax
jz short loc_1449
movzx r8d, [rsp+48h+var_3B]
jmp loc_1401
loc_14AF:
call ___stack_chk_fail | long long func0(unsigned int a1)
{
int v1; // edx
long long v2; // rax
_BYTE *v3; // rdx
long long v4; // r12
long long v5; // rax
int v6; // ebx
unsigned long long v7; // rax
unsigned long long v8; // rsi
char v9; // r8
char *v10; // rcx
char *v11; // rdi
int i; // edx
int v13; // eax
unsigned long long v14; // rdi
unsigned long long v15; // r14
_BYTE v17[11]; // [rsp+2h] [rbp-46h] BYREF
char v18; // [rsp+Dh] [rbp-3Bh] BYREF
unsigned __int8 v19; // [rsp+Eh] [rbp-3Ah]
char v20; // [rsp+Fh] [rbp-39h] BYREF
unsigned long long v21; // [rsp+18h] [rbp-30h]
v21 = __readfsqword(0x28u);
__sprintf_chk(v17, 1LL, 11LL, &unk_2004, a1);
v1 = strlen(v17);
LODWORD(v2) = v1 - 2;
if ( v1 - 2 >= 0 )
{
v2 = (int)v2;
v3 = &v17[v1 - 1 - (long long)(int)v2];
while ( 1 )
{
v4 = (int)v2;
if ( v17[v2] < v3[v2] )
break;
if ( (int)--v2 < 0 )
return 0LL;
}
v5 = __stpcpy_chk(&v18, &v17[(int)v2], 11LL);
v6 = v19;
v7 = v5 - (_QWORD)&v18;
v8 = v7;
if ( v7 <= 1 )
{
if ( !v7 )
{
LABEL_20:
qsort(&v18, v8, 1LL, &strcmp);
v17[v4] = v6;
strcpy(&v17[v4 + 1], &v18);
return strtol(v17, 0LL, 10LL);
}
v9 = v18;
}
else
{
v9 = v18;
v10 = &v20;
v11 = &v18 + v7;
for ( i = v19; ; i = (unsigned __int8)*v10++ )
{
v13 = i;
if ( (char)v6 <= (char)i )
v13 = v6;
if ( v18 < (char)i )
v6 = v13;
if ( v11 == v10 )
break;
}
}
v14 = 0LL;
while ( (_BYTE)v6 != v9 )
{
if ( v8 <= ++v14 )
goto LABEL_20;
v9 = *(&v18 + v14);
}
v15 = v8 - 1;
if ( v8 - 1 > v14 )
memmove(&v18 + v14, &v18 + v14 + 1, v15 - v14);
*(&v18 + v15) = 0;
v8 = strlen(&v18);
goto LABEL_20;
}
return 0LL;
} | func0:
ENDBR64
PUSH R14
MOV R8D,EDI
MOV EDX,0xb
MOV ESI,0x1
PUSH R13
LEA RCX,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x2]
MOV RDI,RBP
CALL 0x00101170
MOV RDI,RBP
CALL 0x00101110
MOV EDX,EAX
SUB EAX,0x2
JS 0x00101480
SUB EDX,0x1
CDQE
MOVSXD RDX,EDX
SUB RDX,RAX
ADD RDX,RBP
JMP 0x00101394
LAB_00101388:
SUB RAX,0x1
TEST EAX,EAX
JS 0x00101480
LAB_00101394:
MOVZX ESI,byte ptr [RDX + RAX*0x1]
MOVSXD R12,EAX
CMP byte ptr [RBP + RAX*0x1],SIL
JGE 0x00101388
LEA R13,[RSP + 0xd]
LEA RSI,[RBP + R12*0x1]
MOV EDX,0xb
MOV RDI,R13
CALL 0x00101150
MOVZX EBX,byte ptr [RSP + 0xe]
SUB RAX,R13
MOV RSI,RAX
CMP RAX,0x1
JBE 0x0010149f
MOVZX R8D,byte ptr [RSP + 0xd]
LEA RCX,[RSP + 0xf]
LEA RDI,[R13 + RAX*0x1]
MOV EDX,EBX
JMP 0x001013ef
LAB_001013e8:
MOVZX EDX,byte ptr [RCX]
ADD RCX,0x1
LAB_001013ef:
CMP BL,DL
MOV EAX,EDX
CMOVLE EAX,EBX
CMP R8B,DL
CMOVL EBX,EAX
CMP RDI,RCX
JNZ 0x001013e8
LAB_00101401:
XOR EDI,EDI
JMP 0x00101417
LAB_00101408:
ADD RDI,0x1
CMP RSI,RDI
JBE 0x00101449
MOVZX R8D,byte ptr [R13 + RDI*0x1]
LAB_00101417:
CMP BL,R8B
JNZ 0x00101408
LEA R14,[RSI + -0x1]
CMP R14,RDI
JBE 0x00101438
MOV RDX,R14
LEA RSI,[R13 + RDI*0x1 + 0x1]
SUB RDX,RDI
ADD RDI,R13
CALL 0x00101160
LAB_00101438:
MOV RDI,R13
MOV byte ptr [RSP + R14*0x1 + 0xd],0x0
CALL 0x00101110
MOV RSI,RAX
LAB_00101449:
MOV RCX,qword ptr [0x00103fe0]
MOV EDX,0x1
MOV RDI,R13
CALL 0x00101100
LEA RDI,[RBP + R12*0x1 + 0x1]
MOV RSI,R13
MOV byte ptr [RSP + R12*0x1 + 0x2],BL
CALL 0x001010e0
MOV EDX,0xa
XOR ESI,ESI
MOV RDI,RBP
CALL 0x00101140
JMP 0x00101482
LAB_00101480:
XOR EAX,EAX
LAB_00101482:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001014af
ADD RSP,0x20
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010149f:
TEST RAX,RAX
JZ 0x00101449
MOVZX R8D,byte ptr [RSP + 0xd]
JMP 0x00101401
LAB_001014af:
CALL 0x00101120 | long func0(int4 param_1)
{
char *__s;
char cVar1;
int iVar2;
size_t sVar3;
long lVar4;
char *pcVar5;
char cVar6;
long lVar7;
ulong uVar8;
long lVar9;
long in_FS_OFFSET;
char local_46 [10];
char acStack_3c [12];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_46,1,0xb,&DAT_00102004,param_1);
sVar3 = strlen(local_46);
iVar2 = (int)sVar3 + -2;
if (iVar2 < 0) {
LAB_00101480:
lVar4 = 0;
LAB_00101482:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar4;
}
lVar4 = (long)iVar2;
lVar7 = ((int)sVar3 + -1) - lVar4;
while (lVar9 = (long)(int)lVar4, local_46[lVar4 + lVar7] <= local_46[lVar4]) {
lVar4 = lVar4 + -1;
if ((int)lVar4 < 0) goto LAB_00101480;
}
__s = acStack_3c + 1;
lVar4 = __stpcpy_chk(__s,local_46 + lVar9,0xb);
sVar3 = lVar4 - (long)__s;
if (sVar3 < 2) {
if (sVar3 != 0) goto LAB_00101401;
goto LAB_00101449;
}
pcVar5 = acStack_3c + 3;
cVar6 = acStack_3c[2];
while( true ) {
cVar1 = cVar6;
if (acStack_3c[2] <= cVar6) {
cVar1 = acStack_3c[2];
}
if (acStack_3c[1] < cVar6) {
acStack_3c[2] = cVar1;
}
if (__s + sVar3 == pcVar5) break;
cVar6 = *pcVar5;
pcVar5 = pcVar5 + 1;
}
LAB_00101401:
uVar8 = 0;
while (acStack_3c[2] != acStack_3c[1]) {
uVar8 = uVar8 + 1;
if (sVar3 <= uVar8) goto LAB_00101449;
acStack_3c[1] = __s[uVar8];
}
if (uVar8 < sVar3 - 1) {
memmove(__s + uVar8,acStack_3c + uVar8 + 2,(sVar3 - 1) - uVar8);
}
acStack_3c[sVar3] = '\0';
sVar3 = strlen(__s);
LAB_00101449:
qsort(__s,sVar3,1,(__compar_fn_t)PTR_strcmp_00103fe0);
local_46[lVar9] = acStack_3c[2];
strcpy(local_46 + lVar9 + 1,__s);
lVar4 = strtol(local_46,(char **)0x0,10);
goto LAB_00101482;
} |
5,523 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
char y = z[1]; // Assume the smallest bigger element is the next one in the beginning
// Find minimum element in z that is greater than z[0]
for (size_t j = 1; j < z_len; ++j) {
if (z[j] > z[0] && z[j] < y) {
y = z[j];
}
}
// Remove the chosen element y from z
for (size_t j = 0; j < z_len; ++j) {
if (z[j] == y) {
for (size_t k = j; k < z_len - 1; ++k) {
z[k] = z[k + 1];
}
z[z_len-1] = '\0';
break;
}
}
// Sort rest of z
qsort(z, strlen(z), sizeof(char), (int(*)(const void *, const void *))strcmp);
// Replace contents from index i in nums with [y] + sorted z
nums[i] = y;
strcpy(nums + i + 1, z);
// Convert back to integer and return
return atoi(nums);
}
}
return 0; // Using 0 to signify false.
}
| int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r14
mov %edi,%r8d
mov $0xb,%edx
mov $0x1,%esi
push %r13
lea 0xcc8(%rip),%rcx
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbp
mov %rbp,%rdi
callq 1170 <__sprintf_chk@plt>
mov %rbp,%rdi
callq 1110 <strlen@plt>
mov %eax,%ebx
sub $0x2,%ebx
js 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%edx
cmp %dl,0x3(%rsp,%rbx,1)
jg 1470 <func0+0x150>
lea -0x3(%rax),%ebx
cmp $0x2,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%ecx
cmp %cl,%dl
jg 1470 <func0+0x150>
lea -0x4(%rax),%ebx
cmp $0x3,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%edx
cmp %dl,%cl
jg 1470 <func0+0x150>
lea -0x5(%rax),%ebx
cmp $0x4,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%ecx
cmp %cl,%dl
jg 1470 <func0+0x150>
lea -0x6(%rax),%ebx
cmp $0x5,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%edx
cmp %dl,%cl
jg 1470 <func0+0x150>
lea -0x7(%rax),%ebx
cmp $0x6,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%ecx
cmp %cl,%dl
jg 1470 <func0+0x150>
lea -0x8(%rax),%ebx
cmp $0x7,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%edx
cmp %dl,%cl
jg 1470 <func0+0x150>
lea -0x9(%rax),%ebx
cmp $0x8,%eax
je 1460 <func0+0x140>
movslq %ebx,%rbx
movzbl 0x2(%rsp,%rbx,1),%ecx
cmp %cl,%dl
jg 1470 <func0+0x150>
cmp $0xa,%eax
mov $0x0,%eax
jne 143e <func0+0x11e>
cmp %cl,0x2(%rsp)
jl 1464 <func0+0x144>
mov 0x18(%rsp),%rdi
xor %fs:0x28,%rdi
jne 1734 <func0+0x414>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %eax,%eax
jmp 143e <func0+0x11e>
xor %ebx,%ebx
nopw %cs:0x0(%rax,%rax,1)
lea 0xd(%rsp),%r13
lea 0x0(%rbp,%rbx,1),%rsi
mov $0xb,%edx
mov %r13,%rdi
callq 1150 <__stpcpy_chk@plt>
movzbl 0xe(%rsp),%edx
sub %r13,%rax
mov %rax,%rsi
cmp $0x1,%rax
jbe 167c <func0+0x35c>
movzbl 0xd(%rsp),%eax
cmp $0x2,%rsi
je 16e2 <func0+0x3c2>
movzbl 0xf(%rsp),%ecx
mov %edx,%r12d
cmp %cl,%al
jl 1630 <func0+0x310>
cmp $0x3,%rsi
je 1550 <func0+0x230>
movzbl 0x10(%rsp),%ecx
cmp %cl,%al
jl 1640 <func0+0x320>
cmp $0x4,%rsi
je 1550 <func0+0x230>
movzbl 0x11(%rsp),%ecx
cmp %cl,%al
jl 1650 <func0+0x330>
cmp $0x5,%rsi
je 1550 <func0+0x230>
movzbl 0x12(%rsp),%ecx
cmp %cl,%al
jl 1660 <func0+0x340>
cmp $0x6,%rsi
je 1550 <func0+0x230>
movzbl 0x13(%rsp),%ecx
cmp %cl,%al
jl 1670 <func0+0x350>
cmp $0x7,%rsi
je 1550 <func0+0x230>
movzbl 0x14(%rsp),%ecx
cmp %cl,%al
jge 1521 <func0+0x201>
cmp %cl,%r12b
cmovg %ecx,%r12d
cmp $0x8,%rsi
je 1550 <func0+0x230>
movzbl 0x15(%rsp),%ecx
cmp %cl,%al
jge 1537 <func0+0x217>
cmp %cl,%r12b
cmovg %ecx,%r12d
cmp $0xa,%rsi
jne 1550 <func0+0x230>
movzbl 0x16(%rsp),%ecx
cmp %cl,%al
jge 1550 <func0+0x230>
cmp %cl,%r12b
cmovg %ecx,%r12d
nopl (%rax)
cmp 0xd(%rsp),%r12b
je 16ea <func0+0x3ca>
cmp %r12b,%dl
je 16f2 <func0+0x3d2>
cmp $0x2,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0xf(%rsp)
je 16f9 <func0+0x3d9>
cmp $0x3,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0x10(%rsp)
je 1700 <func0+0x3e0>
cmp $0x4,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0x11(%rsp)
je 1707 <func0+0x3e7>
cmp $0x5,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0x12(%rsp)
je 170e <func0+0x3ee>
cmp $0x6,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0x13(%rsp)
je 1715 <func0+0x3f5>
cmp $0x7,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0x14(%rsp)
je 169c <func0+0x37c>
cmp $0x8,%rsi
je 15f4 <func0+0x2d4>
cmp %r12b,0x15(%rsp)
je 171c <func0+0x3fc>
cmp $0xa,%rsi
jne 1723 <func0+0x403>
cmp %r12b,0x16(%rsp)
je 16da <func0+0x3ba>
mov 0x29e5(%rip),%rcx
mov $0x1,%edx
mov %r13,%rdi
callq 1100 <qsort@plt>
lea 0x1(%rbp,%rbx,1),%rdi
mov %r13,%rsi
mov %r12b,0x2(%rsp,%rbx,1)
callq 10e0 <strcpy@plt>
mov $0xa,%edx
xor %esi,%esi
mov %rbp,%rdi
callq 1140 <strtol@plt>
jmpq 143e <func0+0x11e>
xchg %ax,%ax
cmp %cl,%dl
cmovle %edx,%ecx
mov %ecx,%r12d
jmpq 14bb <func0+0x19b>
nopl (%rax)
cmp %cl,%r12b
cmovg %ecx,%r12d
jmpq 14d2 <func0+0x1b2>
nopl 0x0(%rax)
cmp %cl,%r12b
cmovg %ecx,%r12d
jmpq 14e5 <func0+0x1c5>
nopl 0x0(%rax)
cmp %cl,%r12b
cmovg %ecx,%r12d
jmpq 14f8 <func0+0x1d8>
nopl 0x0(%rax)
cmp %cl,%r12b
cmovg %ecx,%r12d
jmpq 150b <func0+0x1eb>
mov %edx,%r12d
test %rax,%rax
je 15f4 <func0+0x2d4>
cmp 0xd(%rsp),%dl
je 172d <func0+0x40d>
mov $0x1,%esi
jmpq 15f4 <func0+0x2d4>
mov $0x7,%edi
nopl 0x0(%rax)
lea -0x1(%rsi),%r14
cmp %rdi,%r14
jbe 16c4 <func0+0x3a4>
mov %r14,%rdx
lea 0x1(%r13,%rdi,1),%rsi
sub %rdi,%rdx
add %r13,%rdi
callq 1160 <memmove@plt>
mov %r13,%rdi
movb $0x0,0xd(%rsp,%r14,1)
callq 1110 <strlen@plt>
mov %rax,%rsi
jmpq 15f4 <func0+0x2d4>
mov $0x9,%r14d
jmp 16c4 <func0+0x3a4>
mov %edx,%r12d
jmpq 1550 <func0+0x230>
lea -0x1(%rsi),%r14
xor %edi,%edi
jmp 16b1 <func0+0x391>
mov $0x1,%edi
jmp 16a8 <func0+0x388>
mov $0x2,%edi
jmp 16a8 <func0+0x388>
mov $0x3,%edi
jmp 16a8 <func0+0x388>
mov $0x4,%edi
jmp 16a8 <func0+0x388>
mov $0x5,%edi
jmp 16a8 <func0+0x388>
mov $0x6,%edi
jmp 16a8 <func0+0x388>
mov $0x8,%edi
jmp 16a8 <func0+0x388>
mov $0x9,%esi
jmpq 15f4 <func0+0x2d4>
xor %edi,%edi
jmpq 16a8 <func0+0x388>
callq 1120 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r14
mov r8d, edi
mov edx, 0Bh
mov esi, 2
push r13
lea rcx, unk_2004
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea rbp, [rsp+48h+s]
mov rdi, rbp
call ___sprintf_chk
mov rdi, rbp; s
call _strlen
mov edx, eax
sub edx, 2
js loc_1468
movsxd rbx, edx
mov edx, edx
movzx ecx, [rsp+rbx+48h+s]
cmp [rsp+rdx+48h+var_45], cl
jg loc_1470
lea ebx, [rax-3]
cmp eax, 2
jz loc_1468
movsxd rbx, ebx
movzx edx, [rsp+rbx+48h+s]
cmp cl, dl
jg loc_1470
lea ebx, [rax-4]
cmp eax, 3
jz loc_1468
movsxd rbx, ebx
movzx ecx, [rsp+rbx+48h+s]
cmp dl, cl
jg loc_1470
lea ebx, [rax-5]
cmp eax, 4
jz loc_1468
movsxd rbx, ebx
movzx edx, [rsp+rbx+48h+s]
cmp cl, dl
jg loc_1470
lea ebx, [rax-6]
cmp eax, 5
jz loc_1468
movsxd rbx, ebx
movzx ecx, [rsp+rbx+48h+s]
cmp dl, cl
jg loc_1470
lea ebx, [rax-7]
cmp eax, 6
jz short loc_1468
movsxd rbx, ebx
movzx edx, [rsp+rbx+48h+s]
cmp cl, dl
jg short loc_1470
lea ebx, [rax-8]
cmp eax, 7
jz short loc_1468
movsxd rbx, ebx
movzx ecx, [rsp+rbx+48h+s]
cmp dl, cl
jg short loc_1470
lea ebx, [rax-9]
cmp eax, 8
jz short loc_1468
movsxd rbx, ebx
movzx edx, [rsp+rbx+48h+s]
cmp cl, dl
jg short loc_1470
cmp eax, 0Ah
mov eax, 0
jnz short loc_1444
cmp [rsp+48h+s], dl
jl short loc_146C
loc_1444:
mov rdx, [rsp+48h+var_30]
sub rdx, fs:28h
jnz loc_17AB
add rsp, 20h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1468:
xor eax, eax
jmp short loc_1444
loc_146C:
xor ebx, ebx
xchg ax, ax
loc_1470:
lea r14, [rsp+48h+base]
lea rsi, [rbp+rbx+0]
mov edx, 0Bh
mov rdi, r14
call ___stpcpy_chk
movzx edx, [rsp+48h+var_3A]
sub rax, r14
mov rsi, rax; nmemb
cmp rax, 1
jbe loc_1710
movzx eax, [rsp+48h+base]
cmp rsi, 2
jz loc_1703
movzx ecx, [rsp+48h+var_39]
cmp cl, al
jg loc_1650
cmp rsi, 3
jz loc_1703
movzx edi, [rsp+48h+var_38]
mov r13d, edx
cmp al, dil
jl loc_16C0
cmp rsi, 4
jz loc_178A
loc_14DD:
movzx ecx, [rsp+48h+var_37]
cmp cl, al
jg loc_16F0
cmp rsi, 5
jz loc_1742
loc_14F4:
movzx ecx, [rsp+48h+var_36]
cmp cl, al
jle short loc_1504
cmp r13b, cl
cmovg r13d, ecx
loc_1504:
cmp rsi, 6
jz loc_16D8
movzx ecx, [rsp+48h+var_35]
cmp cl, al
jle short loc_151E
cmp r13b, cl
cmovg r13d, ecx
loc_151E:
cmp rsi, 7
jz loc_16D8
movzx ecx, [rsp+48h+var_34]
cmp al, cl
jge short loc_1538
cmp r13b, cl
cmovg r13d, ecx
loc_1538:
cmp rsi, 8
jz loc_16D8
movzx ecx, [rsp+48h+var_33]
cmp al, cl
jge short loc_1552
cmp r13b, cl
cmovg r13d, ecx
loc_1552:
cmp rsi, 0Ah
jnz loc_16D8
movzx ecx, [rsp+48h+var_32]
cmp cl, al
jle loc_16D8
cmp r13b, cl
cmovg r13d, ecx
cmp al, r13b
jz loc_16E1
loc_1579:
cmp dl, r13b
jz loc_1680
loc_1582:
cmp [rsp+48h+var_39], r13b
jz loc_172E
cmp rsi, 3
jz short loc_1604
cmp [rsp+48h+var_38], r13b
jz loc_1738
cmp rsi, 4
jz short loc_1604
cmp [rsp+48h+var_37], r13b
jz loc_1758
cmp rsi, 5
jz short loc_1604
cmp [rsp+48h+var_36], r13b
jz loc_1762
cmp rsi, 6
jz short loc_1604
cmp [rsp+48h+var_35], r13b
jz loc_176C
cmp rsi, 7
jz short loc_1604
cmp [rsp+48h+var_34], r13b
jz loc_1776
cmp rsi, 8
jz short loc_1604
cmp [rsp+48h+var_33], r13b
jz loc_1780
cmp rsi, 0Ah
jnz short loc_1604
cmp r13b, [rsp+48h+var_32]
jz loc_17A0
loc_1604:
mov rcx, cs:compar; compar
mov rdi, r14; base
mov edx, 1; size
call _qsort
mov [rsp+rbx+48h+s], r13b
mov edx, 0Bh
mov rsi, r14
add rbx, 1
sub rdx, rbx
lea rdi, [rbp+rbx+0]
call ___strcpy_chk
mov edx, 0Ah; base
xor esi, esi; endptr
mov rdi, rbp; nptr
call _strtol
jmp loc_1444
loc_1650:
cmp dl, cl
mov r13d, ecx
cmovle r13d, edx
cmp rsi, 3
jz short loc_16D8
movzx edi, [rsp+48h+var_38]
cmp dil, al
jg short loc_16C0
cmp rsi, 4
jnz loc_14DD
cmp r13b, al
jz short loc_16E1
cmp dl, cl
jg loc_1582
loc_1680:
mov edi, 1
loc_1685:
lea r12, [rsi-1]
cmp rdi, r12
jnb short loc_16A1
loc_168E:
mov rdx, r12
lea rsi, [r14+rdi+1]; src
sub rdx, rdi; n
add rdi, r14; dest
call _memmove
loc_16A1:
mov rdi, r14; s
mov [rsp+r12+48h+base], 0
call _strlen
mov rsi, rax
jmp loc_1604
loc_16C0:
cmp r13b, dil
cmovg r13d, edi
cmp rsi, 4
ja loc_14DD
nop dword ptr [rax+00000000h]
loc_16D8:
cmp r13b, al
jnz loc_1579
loc_16E1:
lea r12, [rsi-1]
xor edi, edi
jmp short loc_168E
loc_16F0:
cmp r13b, cl
cmovg r13d, ecx
cmp rsi, 5
jnz loc_14F4
jmp short loc_16D8
loc_1703:
mov r13d, edx
cmp dl, al
jnz loc_1680
jmp short loc_16E1
loc_1710:
mov r13d, edx
test rax, rax
jz loc_1604
cmp dl, [rsp+48h+base]
jnz loc_1604
xor r12d, r12d
jmp loc_16A1
loc_172E:
mov edi, 2
jmp loc_1685
loc_1738:
mov edi, 3
jmp loc_1685
loc_1742:
cmp r13b, al
jz short loc_16E1
cmp r13b, dl
jnz loc_1582
jmp loc_1680
loc_1758:
mov edi, 4
jmp loc_1685
loc_1762:
mov edi, 5
jmp loc_1685
loc_176C:
mov edi, 6
jmp loc_1685
loc_1776:
mov edi, 7
jmp loc_1685
loc_1780:
mov edi, 8
jmp loc_1685
loc_178A:
cmp dl, al
jnz loc_1680
jmp loc_16E1
loc_17A0:
mov r12d, 9
jmp loc_16A1
loc_17AB:
call ___stack_chk_fail | long long func0(unsigned int a1)
{
int v1; // eax
int v2; // edx
long long v3; // rbx
char v4; // cl
char v5; // dl
char v6; // cl
char v7; // dl
char v8; // cl
char v9; // dl
char v10; // cl
char v11; // dl
bool v12; // zf
long long result; // rax
unsigned long long v14; // rax
size_t v15; // rsi
char v16; // di
char v17; // r13
unsigned long long v18; // rdi
long long v19; // r12
char s[11]; // [rsp+2h] [rbp-46h] BYREF
char base; // [rsp+Dh] [rbp-3Bh] BYREF
char v22; // [rsp+Eh] [rbp-3Ah]
char v23; // [rsp+Fh] [rbp-39h]
char v24; // [rsp+10h] [rbp-38h]
char v25; // [rsp+11h] [rbp-37h]
char v26; // [rsp+12h] [rbp-36h]
char v27; // [rsp+13h] [rbp-35h]
char v28; // [rsp+14h] [rbp-34h]
char v29; // [rsp+15h] [rbp-33h]
char v30; // [rsp+16h] [rbp-32h]
unsigned long long v31; // [rsp+18h] [rbp-30h]
v31 = __readfsqword(0x28u);
__sprintf_chk(s, 2LL, 11LL, &unk_2004, a1);
v1 = strlen(s);
v2 = v1 - 2;
if ( v1 - 2 < 0 )
return 0LL;
v3 = v2;
v4 = s[v2];
if ( s[v2 + 1] > v4 )
goto LABEL_22;
LODWORD(v3) = v1 - 3;
if ( v1 == 2 )
return 0LL;
v3 = (int)v3;
v5 = s[(int)v3];
if ( v4 > v5 )
goto LABEL_22;
LODWORD(v3) = v1 - 4;
if ( v1 == 3 )
return 0LL;
v3 = (int)v3;
v6 = s[(int)v3];
if ( v5 > v6 )
goto LABEL_22;
LODWORD(v3) = v1 - 5;
if ( v1 == 4 )
return 0LL;
v3 = (int)v3;
v7 = s[(int)v3];
if ( v6 > v7 )
goto LABEL_22;
LODWORD(v3) = v1 - 6;
if ( v1 == 5 )
return 0LL;
v3 = (int)v3;
v8 = s[(int)v3];
if ( v7 > v8 )
goto LABEL_22;
LODWORD(v3) = v1 - 7;
if ( v1 == 6 )
return 0LL;
v3 = (int)v3;
v9 = s[(int)v3];
if ( v8 > v9 )
goto LABEL_22;
LODWORD(v3) = v1 - 8;
if ( v1 == 7 )
return 0LL;
v3 = (int)v3;
v10 = s[(int)v3];
if ( v9 > v10 )
goto LABEL_22;
LODWORD(v3) = v1 - 9;
if ( v1 == 8 )
return 0LL;
v3 = (int)v3;
v11 = s[(int)v3];
if ( v10 > v11 )
{
LABEL_22:
v14 = __stpcpy_chk(&base, &s[v3], 11LL) - (_QWORD)&base;
v15 = v14;
if ( v14 <= 1 )
{
v17 = v22;
if ( !v14 || v22 != base )
goto LABEL_66;
v19 = 0LL;
goto LABEL_77;
}
if ( v14 != 2 )
{
if ( v23 > base )
{
v17 = v23;
if ( v22 <= v23 )
v17 = v22;
if ( v14 == 3 )
goto LABEL_81;
v16 = v24;
if ( v24 <= base )
{
if ( v14 == 4 )
{
if ( v17 == base )
goto LABEL_82;
if ( v22 <= v23 )
goto LABEL_74;
goto LABEL_51;
}
LABEL_28:
if ( v25 > base )
{
if ( v17 > v25 )
v17 = v25;
if ( v14 == 5 )
goto LABEL_81;
goto LABEL_30;
}
if ( v14 != 5 )
{
LABEL_30:
if ( v26 > base && v17 > v26 )
v17 = v26;
if ( v14 != 6 )
{
if ( v27 > base && v17 > v27 )
v17 = v27;
if ( v14 != 7 )
{
if ( base < v28 && v17 > v28 )
v17 = v28;
if ( v14 != 8 )
{
if ( base < v29 && v17 > v29 )
v17 = v29;
if ( v14 == 10 && v30 > base )
{
if ( v17 > v30 )
v17 = v30;
if ( base != v17 )
{
LABEL_50:
if ( v22 != v17 )
goto LABEL_51;
LABEL_74:
v18 = 1LL;
goto LABEL_75;
}
LABEL_82:
v19 = v14 - 1;
v18 = 0LL;
goto LABEL_76;
}
}
}
}
LABEL_81:
if ( v17 != base )
goto LABEL_50;
goto LABEL_82;
}
if ( v17 == base )
goto LABEL_82;
if ( v17 == v22 )
goto LABEL_74;
LABEL_51:
if ( v23 == v17 )
{
v18 = 2LL;
goto LABEL_75;
}
if ( v14 != 3 )
{
if ( v24 == v17 )
{
v18 = 3LL;
goto LABEL_75;
}
if ( v14 != 4 )
{
if ( v25 == v17 )
{
v18 = 4LL;
goto LABEL_75;
}
if ( v14 != 5 )
{
if ( v26 == v17 )
{
v18 = 5LL;
goto LABEL_75;
}
if ( v14 != 6 )
{
if ( v27 == v17 )
{
v18 = 6LL;
goto LABEL_75;
}
if ( v14 != 7 )
{
if ( v28 == v17 )
{
v18 = 7LL;
goto LABEL_75;
}
if ( v14 != 8 )
{
if ( v29 != v17 )
{
if ( v14 != 10 || v17 != v30 )
goto LABEL_66;
v19 = 9LL;
goto LABEL_77;
}
v18 = 8LL;
LABEL_75:
v19 = v14 - 1;
if ( v18 >= v14 - 1 )
{
LABEL_77:
*(&base + v19) = 0;
v15 = strlen(&base);
goto LABEL_66;
}
LABEL_76:
memmove(&base + v18, &base + v18 + 1, v19 - v18);
goto LABEL_77;
}
}
}
}
}
}
LABEL_66:
qsort(&base, v15, 1uLL, (__compar_fn_t)&strcmp);
s[v3] = v17;
__strcpy_chk(&s[v3 + 1], &base, 11 - (v3 + 1));
return strtol(s, 0LL, 10);
}
LABEL_78:
if ( v17 > v16 )
v17 = v16;
if ( v14 <= 4 )
goto LABEL_81;
goto LABEL_28;
}
if ( v14 != 3 )
{
v16 = v24;
v17 = v22;
if ( base >= v24 )
{
if ( v14 == 4 )
{
if ( v22 != base )
goto LABEL_74;
goto LABEL_82;
}
goto LABEL_28;
}
goto LABEL_78;
}
}
v17 = v22;
if ( v22 != base )
goto LABEL_74;
goto LABEL_82;
}
v12 = v1 == 10;
result = 0LL;
if ( v12 && s[0] < v11 )
{
v3 = 0LL;
goto LABEL_22;
}
return result;
} | func0:
ENDBR64
PUSH R14
MOV R8D,EDI
MOV EDX,0xb
MOV ESI,0x2
PUSH R13
LEA RCX,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x2]
MOV RDI,RBP
CALL 0x00101170
MOV RDI,RBP
CALL 0x00101100
MOV EDX,EAX
SUB EDX,0x2
JS 0x00101468
MOVSXD RBX,EDX
MOV EDX,EDX
MOVZX ECX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP byte ptr [RSP + RDX*0x1 + 0x3],CL
JG 0x00101470
LEA EBX,[RAX + -0x3]
CMP EAX,0x2
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX EDX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP CL,DL
JG 0x00101470
LEA EBX,[RAX + -0x4]
CMP EAX,0x3
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX ECX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP DL,CL
JG 0x00101470
LEA EBX,[RAX + -0x5]
CMP EAX,0x4
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX EDX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP CL,DL
JG 0x00101470
LEA EBX,[RAX + -0x6]
CMP EAX,0x5
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX ECX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP DL,CL
JG 0x00101470
LEA EBX,[RAX + -0x7]
CMP EAX,0x6
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX EDX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP CL,DL
JG 0x00101470
LEA EBX,[RAX + -0x8]
CMP EAX,0x7
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX ECX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP DL,CL
JG 0x00101470
LEA EBX,[RAX + -0x9]
CMP EAX,0x8
JZ 0x00101468
MOVSXD RBX,EBX
MOVZX EDX,byte ptr [RSP + RBX*0x1 + 0x2]
CMP CL,DL
JG 0x00101470
CMP EAX,0xa
MOV EAX,0x0
JNZ 0x00101444
CMP byte ptr [RSP + 0x2],DL
JL 0x0010146c
LAB_00101444:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001017ab
ADD RSP,0x20
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101468:
XOR EAX,EAX
JMP 0x00101444
LAB_0010146c:
XOR EBX,EBX
NOP
LAB_00101470:
LEA R14,[RSP + 0xd]
LEA RSI,[RBP + RBX*0x1]
MOV EDX,0xb
MOV RDI,R14
CALL 0x00101140
MOVZX EDX,byte ptr [RSP + 0xe]
SUB RAX,R14
MOV RSI,RAX
CMP RAX,0x1
JBE 0x00101710
MOVZX EAX,byte ptr [RSP + 0xd]
CMP RSI,0x2
JZ 0x00101703
MOVZX ECX,byte ptr [RSP + 0xf]
CMP CL,AL
JG 0x00101650
CMP RSI,0x3
JZ 0x00101703
MOVZX EDI,byte ptr [RSP + 0x10]
MOV R13D,EDX
CMP AL,DIL
JL 0x001016c0
CMP RSI,0x4
JZ 0x0010178a
LAB_001014dd:
MOVZX ECX,byte ptr [RSP + 0x11]
CMP CL,AL
JG 0x001016f0
CMP RSI,0x5
JZ 0x00101742
LAB_001014f4:
MOVZX ECX,byte ptr [RSP + 0x12]
CMP CL,AL
JLE 0x00101504
CMP R13B,CL
CMOVG R13D,ECX
LAB_00101504:
CMP RSI,0x6
JZ 0x001016d8
MOVZX ECX,byte ptr [RSP + 0x13]
CMP CL,AL
JLE 0x0010151e
CMP R13B,CL
CMOVG R13D,ECX
LAB_0010151e:
CMP RSI,0x7
JZ 0x001016d8
MOVZX ECX,byte ptr [RSP + 0x14]
CMP AL,CL
JGE 0x00101538
CMP R13B,CL
CMOVG R13D,ECX
LAB_00101538:
CMP RSI,0x8
JZ 0x001016d8
MOVZX ECX,byte ptr [RSP + 0x15]
CMP AL,CL
JGE 0x00101552
CMP R13B,CL
CMOVG R13D,ECX
LAB_00101552:
CMP RSI,0xa
JNZ 0x001016d8
MOVZX ECX,byte ptr [RSP + 0x16]
CMP CL,AL
JLE 0x001016d8
CMP R13B,CL
CMOVG R13D,ECX
CMP AL,R13B
JZ 0x001016e1
LAB_00101579:
CMP DL,R13B
JZ 0x00101680
LAB_00101582:
CMP byte ptr [RSP + 0xf],R13B
JZ 0x0010172e
CMP RSI,0x3
JZ 0x00101604
CMP byte ptr [RSP + 0x10],R13B
JZ 0x00101738
CMP RSI,0x4
JZ 0x00101604
CMP byte ptr [RSP + 0x11],R13B
JZ 0x00101758
CMP RSI,0x5
JZ 0x00101604
CMP byte ptr [RSP + 0x12],R13B
JZ 0x00101762
CMP RSI,0x6
JZ 0x00101604
CMP byte ptr [RSP + 0x13],R13B
JZ 0x0010176c
CMP RSI,0x7
JZ 0x00101604
CMP byte ptr [RSP + 0x14],R13B
JZ 0x00101776
CMP RSI,0x8
JZ 0x00101604
CMP byte ptr [RSP + 0x15],R13B
JZ 0x00101780
CMP RSI,0xa
JNZ 0x00101604
CMP R13B,byte ptr [RSP + 0x16]
JZ 0x001017a0
LAB_00101604:
MOV RCX,qword ptr [0x00103fe0]
MOV RDI,R14
MOV EDX,0x1
CALL 0x001010f0
MOV byte ptr [RSP + RBX*0x1 + 0x2],R13B
MOV EDX,0xb
MOV RSI,R14
ADD RBX,0x1
SUB RDX,RBX
LEA RDI,[RBP + RBX*0x1]
CALL 0x00101150
MOV EDX,0xa
XOR ESI,ESI
MOV RDI,RBP
CALL 0x00101130
JMP 0x00101444
LAB_00101650:
CMP DL,CL
MOV R13D,ECX
CMOVLE R13D,EDX
CMP RSI,0x3
JZ 0x001016d8
MOVZX EDI,byte ptr [RSP + 0x10]
CMP DIL,AL
JG 0x001016c0
CMP RSI,0x4
JNZ 0x001014dd
CMP R13B,AL
JZ 0x001016e1
CMP DL,CL
JG 0x00101582
LAB_00101680:
MOV EDI,0x1
LAB_00101685:
LEA R12,[RSI + -0x1]
CMP RDI,R12
JNC 0x001016a1
LAB_0010168e:
MOV RDX,R12
LEA RSI,[R14 + RDI*0x1 + 0x1]
SUB RDX,RDI
ADD RDI,R14
CALL 0x00101160
LAB_001016a1:
MOV RDI,R14
MOV byte ptr [RSP + R12*0x1 + 0xd],0x0
CALL 0x00101100
MOV RSI,RAX
JMP 0x00101604
LAB_001016c0:
CMP R13B,DIL
CMOVG R13D,EDI
CMP RSI,0x4
JA 0x001014dd
NOP dword ptr [RAX]
LAB_001016d8:
CMP R13B,AL
JNZ 0x00101579
LAB_001016e1:
LEA R12,[RSI + -0x1]
XOR EDI,EDI
JMP 0x0010168e
LAB_001016f0:
CMP R13B,CL
CMOVG R13D,ECX
CMP RSI,0x5
JNZ 0x001014f4
JMP 0x001016d8
LAB_00101703:
MOV R13D,EDX
CMP DL,AL
JNZ 0x00101680
JMP 0x001016e1
LAB_00101710:
MOV R13D,EDX
TEST RAX,RAX
JZ 0x00101604
CMP DL,byte ptr [RSP + 0xd]
JNZ 0x00101604
XOR R12D,R12D
JMP 0x001016a1
LAB_0010172e:
MOV EDI,0x2
JMP 0x00101685
LAB_00101738:
MOV EDI,0x3
JMP 0x00101685
LAB_00101742:
CMP R13B,AL
JZ 0x001016e1
CMP R13B,DL
JNZ 0x00101582
JMP 0x00101680
LAB_00101758:
MOV EDI,0x4
JMP 0x00101685
LAB_00101762:
MOV EDI,0x5
JMP 0x00101685
LAB_0010176c:
MOV EDI,0x6
JMP 0x00101685
LAB_00101776:
MOV EDI,0x7
JMP 0x00101685
LAB_00101780:
MOV EDI,0x8
JMP 0x00101685
LAB_0010178a:
CMP DL,AL
JNZ 0x00101680
JMP 0x001016e1
LAB_001017a0:
MOV R12D,0x9
JMP 0x001016a1
LAB_001017ab:
CALL 0x00101110 | long func0(int4 param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
size_t sVar4;
long lVar5;
ulong __nmemb;
uint uVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
char cVar10;
long in_FS_OFFSET;
char local_46 [11];
char local_3b [5];
char local_36;
char local_35;
char local_34;
char local_33;
char local_32;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_46,2,0xb,&DAT_00102004,param_1);
sVar4 = strlen(local_46);
iVar3 = (int)sVar4;
uVar6 = iVar3 - 2;
if ((int)uVar6 < 0) {
LAB_00101468:
lVar5 = 0;
goto LAB_00101444;
}
lVar7 = (long)(int)uVar6;
pcVar1 = local_46 + lVar7;
if (local_46[(ulong)uVar6 + 1] <= *pcVar1) {
if (iVar3 == 2) goto LAB_00101468;
lVar7 = (long)(iVar3 + -3);
pcVar2 = local_46 + lVar7;
if (*pcVar1 <= *pcVar2) {
if (iVar3 == 3) goto LAB_00101468;
lVar7 = (long)(iVar3 + -4);
pcVar1 = local_46 + lVar7;
if (*pcVar2 <= *pcVar1) {
if (iVar3 == 4) goto LAB_00101468;
lVar7 = (long)(iVar3 + -5);
pcVar2 = local_46 + lVar7;
if (*pcVar1 <= *pcVar2) {
if (iVar3 == 5) goto LAB_00101468;
lVar7 = (long)(iVar3 + -6);
pcVar1 = local_46 + lVar7;
if (*pcVar2 <= *pcVar1) {
if (iVar3 == 6) goto LAB_00101468;
lVar7 = (long)(iVar3 + -7);
pcVar2 = local_46 + lVar7;
if (*pcVar1 <= *pcVar2) {
if (iVar3 == 7) goto LAB_00101468;
lVar7 = (long)(iVar3 + -8);
pcVar1 = local_46 + lVar7;
if (*pcVar2 <= *pcVar1) {
if (iVar3 == 8) goto LAB_00101468;
lVar7 = (long)(iVar3 + -9);
if (*pcVar1 <= local_46[lVar7]) {
lVar5 = 0;
if ((iVar3 != 10) || (local_46[lVar7] <= local_46[0])) goto LAB_00101444;
lVar7 = 0;
}
}
}
}
}
}
}
}
lVar5 = __stpcpy_chk(local_3b,local_46 + lVar7,0xb);
__nmemb = lVar5 - (long)local_3b;
if (__nmemb < 2) {
if ((__nmemb == 0) || (local_3b[1] != local_3b[0])) goto LAB_00101604;
uVar9 = 0;
LAB_001016a1:
local_3b[uVar9] = '\0';
__nmemb = strlen(local_3b);
}
else {
cVar10 = local_3b[1];
if (__nmemb == 2) {
LAB_00101703:
if (local_3b[1] != local_3b[0]) {
LAB_00101680:
uVar8 = 1;
goto LAB_00101685;
}
LAB_001016e1:
uVar8 = 0;
LAB_0010168e:
uVar9 = __nmemb - 1;
memmove(local_3b + uVar8,local_3b + uVar8 + 1,uVar9 - uVar8);
local_3b[1] = cVar10;
goto LAB_001016a1;
}
if (local_3b[0] < local_3b[2]) {
cVar10 = local_3b[2];
if (local_3b[1] <= local_3b[2]) {
cVar10 = local_3b[1];
}
if (__nmemb == 3) goto joined_r0x001016db;
if (local_3b[0] < local_3b[3]) goto LAB_001016c0;
if (__nmemb != 4) goto LAB_001014dd;
if (cVar10 == local_3b[0]) goto LAB_001016e1;
if (local_3b[1] <= local_3b[2]) goto LAB_00101680;
}
else {
if (__nmemb == 3) goto LAB_00101703;
if (local_3b[0] < local_3b[3]) {
LAB_001016c0:
if (local_3b[3] < cVar10) {
cVar10 = local_3b[3];
}
if (__nmemb < 5) goto joined_r0x001016db;
}
else if (__nmemb == 4) {
if (local_3b[1] == local_3b[0]) goto LAB_001016e1;
goto LAB_00101680;
}
LAB_001014dd:
if ((local_3b[0] < local_3b[4]) && (local_3b[4] < cVar10)) {
cVar10 = local_3b[4];
}
if (__nmemb != 5) {
if ((local_3b[0] < local_36) && (local_36 < cVar10)) {
cVar10 = local_36;
}
if (__nmemb != 6) {
if ((local_3b[0] < local_35) && (local_35 < cVar10)) {
cVar10 = local_35;
}
if (__nmemb != 7) {
if ((local_3b[0] < local_34) && (local_34 < cVar10)) {
cVar10 = local_34;
}
if (__nmemb != 8) {
if ((local_3b[0] < local_33) && (local_33 < cVar10)) {
cVar10 = local_33;
}
if (((__nmemb == 10) && (local_3b[0] < local_32)) && (local_32 < cVar10)) {
cVar10 = local_32;
}
}
}
}
}
joined_r0x001016db:
if (cVar10 == local_3b[0]) goto LAB_001016e1;
if (cVar10 == local_3b[1]) goto LAB_00101680;
}
if (local_3b[2] == cVar10) {
uVar8 = 2;
LAB_00101685:
uVar9 = __nmemb - 1;
local_3b[1] = cVar10;
if (uVar9 <= uVar8) goto LAB_001016a1;
goto LAB_0010168e;
}
local_3b[1] = cVar10;
if (__nmemb != 3) {
if (local_3b[3] == cVar10) {
uVar8 = 3;
goto LAB_00101685;
}
if (__nmemb != 4) {
if (local_3b[4] == cVar10) {
uVar8 = 4;
goto LAB_00101685;
}
if (__nmemb != 5) {
if (local_36 == cVar10) {
uVar8 = 5;
goto LAB_00101685;
}
if (__nmemb != 6) {
if (local_35 == cVar10) {
uVar8 = 6;
goto LAB_00101685;
}
if (__nmemb != 7) {
if (local_34 == cVar10) {
uVar8 = 7;
goto LAB_00101685;
}
if (__nmemb != 8) {
if (local_33 == cVar10) {
uVar8 = 8;
goto LAB_00101685;
}
if ((__nmemb == 10) && (cVar10 == local_32)) {
uVar9 = 9;
goto LAB_001016a1;
}
}
}
}
}
}
}
}
LAB_00101604:
qsort(local_3b,__nmemb,1,(__compar_fn_t)PTR_strcmp_00103fe0);
local_46[lVar7] = local_3b[1];
__strcpy_chk(local_46 + lVar7 + 1,local_3b,0xb - (lVar7 + 1));
lVar5 = strtol(local_46,(char **)0x0,10);
LAB_00101444:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return lVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,524 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
int l = 2*i + 1;
int r = 2*i + 2;
if (l < n && heap[l].sum < heap[smallest].sum)
smallest = l;
if (r < n && heap[r].sum < heap[smallest].sum)
smallest = r;
if (smallest != i) {
swap(&heap[i], &heap[smallest]);
heapify(heap, n, smallest);
}
}
void heapPush(HeapNode heap[], int *size, HeapNode node) {
int i = *size;
heap[i] = node;
(*size)++;
while (i != 0 && heap[(i-1)/2].sum > heap[i].sum) {
swap(&heap[(i-1)/2], &heap[i]);
i = (i-1)/2;
}
}
HeapNode heapPop(HeapNode heap[], int *size) {
if (*size <= 0) {
HeapNode invalid = {-1, -1, -1};
return invalid;
}
if (*size == 1) {
(*size)--;
return heap[0];
}
HeapNode root = heap[0];
heap[0] = heap[*size - 1];
(*size)--;
heapify(heap, *size, 0);
return root;
}
| int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int *)malloc(sizeof(int) * 2);
}
if (nums1Size == 0 || nums2Size == 0 || k == 0) {
*returnSize = 0;
free(heap);
return result;
}
heapPush(heap, &heapSize, (HeapNode){nums1[0] + nums2[0], 0, 0});
int count = 0;
while (heapSize > 0 && count < k) {
HeapNode node = heapPop(heap, &heapSize);
result[count][0] = nums1[node.index1];
result[count][1] = nums2[node.index2];
count++;
if (node.index2 + 1 < nums2Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1] + nums2[node.index2 + 1], node.index1, node.index2 + 1});
}
if (node.index2 == 0 && node.index1 + 1 < nums1Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1 + 1] + nums2[0], node.index1 + 1, 0});
}
}
*returnSize = count;
free(heap);
return result;
}
| int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &returnSize);
assert(returnSize == 1 && result[0][0] == 1 && result[0][1] == 2);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 7, &returnSize);
assert(returnSize == 7 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %rdx,-0x78(%rbp)
mov %ecx,-0x70(%rbp)
mov %r8d,-0x7c(%rbp)
mov %r9,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x6c(%rbp),%eax
imul -0x70(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x50(%rbp)
movl $0x0,-0x5c(%rbp)
mov -0x7c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x48(%rbp)
movl $0x0,-0x58(%rbp)
jmp 15f2 <func0+0xa6>
mov -0x58(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 15cc <func0+0x80>
cmpl $0x0,-0x6c(%rbp)
je 160c <func0+0xc0>
cmpl $0x0,-0x70(%rbp)
je 160c <func0+0xc0>
cmpl $0x0,-0x7c(%rbp)
jne 162e <func0+0xe2>
mov -0x88(%rbp),%rax
movl $0x0,(%rax)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x48(%rbp),%rax
jmpq 17fe <func0+0x2b2>
mov -0x68(%rbp),%rax
mov (%rax),%edx
mov -0x78(%rbp),%rax
mov (%rax),%eax
add %edx,%eax
mov %eax,-0x3c(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
mov -0x3c(%rbp),%rax
mov -0x34(%rbp),%ecx
mov %rcx,%rdx
lea -0x5c(%rbp),%rsi
mov -0x50(%rbp),%rdi
mov %rdx,%rcx
mov %rax,%rdx
callq 1329 <heapPush>
movl $0x0,-0x54(%rbp)
jmpq 17cf <func0+0x283>
lea -0x5c(%rbp),%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1455 <heapPop>
mov %rax,-0x30(%rbp)
mov -0x28(%rbp),%eax
and $0x0,%eax
or %edx,%eax
mov %eax,-0x28(%rbp)
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rax,%rdx
mov -0x54(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov (%rdx),%edx
mov %edx,(%rax)
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov -0x54(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
add $0x4,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x54(%rbp)
mov -0x28(%rbp),%eax
add $0x1,%eax
cmp %eax,-0x70(%rbp)
jle 176b <func0+0x21f>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x28(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x78(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %edx,%eax
mov %eax,-0x24(%rbp)
mov -0x2c(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x28(%rbp),%eax
add $0x1,%eax
mov %eax,-0x1c(%rbp)
mov -0x24(%rbp),%rax
mov -0x1c(%rbp),%ecx
mov %rcx,%rdx
lea -0x5c(%rbp),%rsi
mov -0x50(%rbp),%rdi
mov %rdx,%rcx
mov %rax,%rdx
callq 1329 <heapPush>
mov -0x28(%rbp),%eax
test %eax,%eax
jne 17cf <func0+0x283>
mov -0x2c(%rbp),%eax
add $0x1,%eax
cmp %eax,-0x6c(%rbp)
jle 17cf <func0+0x283>
mov -0x2c(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x78(%rbp),%rax
mov (%rax),%eax
add %edx,%eax
mov %eax,-0x24(%rbp)
mov -0x2c(%rbp),%eax
add $0x1,%eax
mov %eax,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x24(%rbp),%rax
mov -0x1c(%rbp),%ecx
mov %rcx,%rdx
lea -0x5c(%rbp),%rsi
mov -0x50(%rbp),%rdi
mov %rdx,%rcx
mov %rax,%rdx
callq 1329 <heapPush>
mov -0x5c(%rbp),%eax
test %eax,%eax
jle 17e2 <func0+0x296>
mov -0x54(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 1676 <func0+0x12a>
mov -0x88(%rbp),%rax
mov -0x54(%rbp),%edx
mov %edx,(%rax)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x48(%rbp),%rax
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
je 1812 <func0+0x2c6>
callq 1090 <__stack_chk_fail@plt>
add $0x88,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_68], rdi
mov [rbp+var_6C], esi
mov [rbp+var_78], rdx
mov [rbp+var_70], ecx
mov [rbp+var_7C], r8d
mov [rbp+var_88], r9
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_6C]
imul eax, [rbp+var_70]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_5C], 0
mov eax, [rbp+var_7C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_48], rax
mov [rbp+var_58], 0
jmp short loc_15F2
loc_15CC:
mov eax, [rbp+var_58]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
lea rbx, [rdx+rax]
mov edi, 8; size
call _malloc
mov [rbx], rax
add [rbp+var_58], 1
loc_15F2:
mov eax, [rbp+var_58]
cmp eax, [rbp+var_7C]
jl short loc_15CC
cmp [rbp+var_6C], 0
jz short loc_160C
cmp [rbp+var_70], 0
jz short loc_160C
cmp [rbp+var_7C], 0
jnz short loc_162E
loc_160C:
mov rax, [rbp+var_88]
mov dword ptr [rax], 0
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_48]
jmp loc_17FE
loc_162E:
mov rax, [rbp+var_68]
mov edx, [rax]
mov rax, [rbp+var_78]
mov eax, [rax]
add eax, edx
mov dword ptr [rbp+var_3C], eax
mov dword ptr [rbp+var_3C+4], 0
mov [rbp+var_34], 0
mov rax, [rbp+var_3C]
mov ecx, [rbp+var_34]
mov rdx, rcx
lea rsi, [rbp+var_5C]
mov rdi, [rbp+ptr]
mov rcx, rdx
mov rdx, rax
call heapPush
mov [rbp+var_54], 0
jmp loc_17CF
loc_1676:
lea rdx, [rbp+var_5C]
mov rax, [rbp+ptr]
mov rsi, rdx
mov rdi, rax
call heapPop
mov [rbp+var_30], rax
mov eax, [rbp+var_28]
and eax, 0
or eax, edx
mov [rbp+var_28], eax
mov eax, dword ptr [rbp+var_30+4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_68]
add rdx, rax
mov eax, [rbp+var_54]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rcx
mov rax, [rax]
mov edx, [rdx]
mov [rax], edx
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rdx
mov edx, [rbp+var_54]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_48]
add rdx, rcx
mov rdx, [rdx]
add rdx, 4
mov eax, [rax]
mov [rdx], eax
add [rbp+var_54], 1
mov eax, [rbp+var_28]
add eax, 1
cmp [rbp+var_70], eax
jle short loc_176B
mov eax, dword ptr [rbp+var_30+4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_68]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_28]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_78]
add rax, rcx
mov eax, [rax]
add eax, edx
mov dword ptr [rbp+var_24], eax
mov eax, dword ptr [rbp+var_30+4]
mov dword ptr [rbp+var_24+4], eax
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_1C], eax
mov rax, [rbp+var_24]
mov ecx, [rbp+var_1C]
mov rdx, rcx
lea rsi, [rbp+var_5C]
mov rdi, [rbp+ptr]
mov rcx, rdx
mov rdx, rax
call heapPush
loc_176B:
mov eax, [rbp+var_28]
test eax, eax
jnz short loc_17CF
mov eax, dword ptr [rbp+var_30+4]
add eax, 1
cmp [rbp+var_6C], eax
jle short loc_17CF
mov eax, dword ptr [rbp+var_30+4]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_68]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_78]
mov eax, [rax]
add eax, edx
mov dword ptr [rbp+var_24], eax
mov eax, dword ptr [rbp+var_30+4]
add eax, 1
mov dword ptr [rbp+var_24+4], eax
mov [rbp+var_1C], 0
mov rax, [rbp+var_24]
mov ecx, [rbp+var_1C]
mov rdx, rcx
lea rsi, [rbp+var_5C]
mov rdi, [rbp+ptr]
mov rcx, rdx
mov rdx, rax
call heapPush
loc_17CF:
mov eax, [rbp+var_5C]
test eax, eax
jle short loc_17E2
mov eax, [rbp+var_54]
cmp eax, [rbp+var_7C]
jl loc_1676
loc_17E2:
mov rax, [rbp+var_88]
mov edx, [rbp+var_54]
mov [rax], edx
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_48]
loc_17FE:
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1812
call ___stack_chk_fail
loc_1812:
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(_DWORD *a1, int a2, _DWORD *a3, int a4, int a5, _DWORD *a6)
{
int v7; // edx
int v12; // [rsp+34h] [rbp-5Ch] BYREF
int i; // [rsp+38h] [rbp-58h]
int v14; // [rsp+3Ch] [rbp-54h]
void *ptr; // [rsp+40h] [rbp-50h]
_QWORD *v16; // [rsp+48h] [rbp-48h]
long long v17; // [rsp+54h] [rbp-3Ch]
int v18; // [rsp+5Ch] [rbp-34h]
long long v19; // [rsp+60h] [rbp-30h]
int v20; // [rsp+68h] [rbp-28h]
long long v21; // [rsp+6Ch] [rbp-24h]
int v22; // [rsp+74h] [rbp-1Ch]
unsigned long long v23; // [rsp+78h] [rbp-18h]
v23 = __readfsqword(0x28u);
ptr = malloc(12LL * a4 * a2);
v12 = 0;
v16 = malloc(8LL * a5);
for ( i = 0; i < a5; ++i )
v16[i] = malloc(8uLL);
if ( a2 && a4 && a5 )
{
v17 = (unsigned int)(*a1 + *a3);
v18 = 0;
heapPush(ptr, &v12, v17, 0LL);
v14 = 0;
while ( v12 > 0 && v14 < a5 )
{
v19 = heapPop(ptr, &v12);
v20 = v7;
*(_DWORD *)v16[v14] = a1[SHIDWORD(v19)];
*(_DWORD *)(v16[v14++] + 4LL) = a3[v20];
if ( a4 > v20 + 1 )
{
LODWORD(v21) = a1[SHIDWORD(v19)] + a3[v20 + 1];
HIDWORD(v21) = HIDWORD(v19);
v22 = v20 + 1;
heapPush(ptr, &v12, v21, (unsigned int)(v20 + 1));
}
if ( !v20 && a2 > HIDWORD(v19) + 1 )
{
LODWORD(v21) = a1[SHIDWORD(v19) + 1] + *a3;
HIDWORD(v21) = HIDWORD(v19) + 1;
v22 = 0;
heapPush(ptr, &v12, v21, 0LL);
}
}
*a6 = v14;
free(ptr);
return v16;
}
else
{
*a6 = 0;
free(ptr);
return v16;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x68],RDI
MOV dword ptr [RBP + -0x6c],ESI
MOV qword ptr [RBP + -0x78],RDX
MOV dword ptr [RBP + -0x70],ECX
MOV dword ptr [RBP + -0x7c],R8D
MOV qword ptr [RBP + -0x88],R9
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x6c]
IMUL EAX,dword ptr [RBP + -0x70]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x5c],0x0
MOV EAX,dword ptr [RBP + -0x7c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x48],RAX
MOV dword ptr [RBP + -0x58],0x0
JMP 0x001015f2
LAB_001015cc:
MOV EAX,dword ptr [RBP + -0x58]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
LEA RBX,[RDX + RAX*0x1]
MOV EDI,0x8
CALL 0x001010b0
MOV qword ptr [RBX],RAX
ADD dword ptr [RBP + -0x58],0x1
LAB_001015f2:
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,dword ptr [RBP + -0x7c]
JL 0x001015cc
CMP dword ptr [RBP + -0x6c],0x0
JZ 0x0010160c
CMP dword ptr [RBP + -0x70],0x0
JZ 0x0010160c
CMP dword ptr [RBP + -0x7c],0x0
JNZ 0x0010162e
LAB_0010160c:
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x48]
JMP 0x001017fe
LAB_0010162e:
MOV RAX,qword ptr [RBP + -0x68]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x78]
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
MOV dword ptr [RBP + -0x3c],EAX
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x3c]
MOV ECX,dword ptr [RBP + -0x34]
MOV RDX,RCX
LEA RSI,[RBP + -0x5c]
MOV RDI,qword ptr [RBP + -0x50]
MOV RCX,RDX
MOV RDX,RAX
CALL 0x00101329
MOV dword ptr [RBP + -0x54],0x0
JMP 0x001017cf
LAB_00101676:
LEA RDX,[RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101455
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x0
OR EAX,EDX
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x68]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x54]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RDX]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x54]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
ADD RDX,0x4
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x54],0x1
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
CMP dword ptr [RBP + -0x70],EAX
JLE 0x0010176b
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x28]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x24]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,RCX
LEA RSI,[RBP + -0x5c]
MOV RDI,qword ptr [RBP + -0x50]
MOV RCX,RDX
MOV RDX,RAX
CALL 0x00101329
LAB_0010176b:
MOV EAX,dword ptr [RBP + -0x28]
TEST EAX,EAX
JNZ 0x001017cf
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
CMP dword ptr [RBP + -0x6c],EAX
JLE 0x001017cf
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x78]
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x1c],0x0
MOV RAX,qword ptr [RBP + -0x24]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,RCX
LEA RSI,[RBP + -0x5c]
MOV RDI,qword ptr [RBP + -0x50]
MOV RCX,RDX
MOV RDX,RAX
CALL 0x00101329
LAB_001017cf:
MOV EAX,dword ptr [RBP + -0x5c]
TEST EAX,EAX
JLE 0x001017e2
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x7c]
JL 0x00101676
LAB_001017e2:
MOV RAX,qword ptr [RBP + -0x88]
MOV EDX,dword ptr [RBP + -0x54]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x48]
LAB_001017fe:
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101812
CALL 0x00101090
LAB_00101812:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int *param_1,int param_2,int *param_3,int param_4,int param_5,int *param_6)
{
long lVar1;
void *pvVar2;
long lVar3;
void *pvVar4;
int extraout_var;
int extraout_EDX;
long in_FS_OFFSET;
int local_64;
int local_60;
int local_5c;
void *local_58;
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = malloc((long)(param_2 * param_4) * 0xc);
local_64 = 0;
pvVar2 = malloc((long)param_5 << 3);
for (local_60 = 0; local_60 < param_5; local_60 = local_60 + 1) {
lVar3 = (long)local_60;
pvVar4 = malloc(8);
*(void **)(lVar3 * 8 + (long)pvVar2) = pvVar4;
}
if (((param_2 == 0) || (param_4 == 0)) || (param_5 == 0)) {
*param_6 = 0;
free(local_58);
}
else {
heapPush(local_58,&local_64,*param_3 + *param_1,0);
local_5c = 0;
while ((0 < local_64 && (local_5c < param_5))) {
heapPop(local_58,&local_64);
**(int **)((long)pvVar2 + (long)local_5c * 8) = param_1[extraout_var];
*(int *)(*(long *)((long)pvVar2 + (long)local_5c * 8) + 4) = param_3[extraout_EDX];
local_5c = local_5c + 1;
if (extraout_EDX + 1 < param_4) {
heapPush(local_58,&local_64,
CONCAT44(extraout_var,param_3[(long)extraout_EDX + 1] + param_1[extraout_var]),
extraout_EDX + 1);
}
if ((extraout_EDX == 0) && (extraout_var + 1 < param_2)) {
heapPush(local_58,&local_64,
CONCAT44(extraout_var + 1,*param_3 + param_1[(long)extraout_var + 1]),0);
}
}
*param_6 = local_5c;
free(local_58);
}
if (lVar1 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pvVar2;
} |
5,525 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
int l = 2*i + 1;
int r = 2*i + 2;
if (l < n && heap[l].sum < heap[smallest].sum)
smallest = l;
if (r < n && heap[r].sum < heap[smallest].sum)
smallest = r;
if (smallest != i) {
swap(&heap[i], &heap[smallest]);
heapify(heap, n, smallest);
}
}
void heapPush(HeapNode heap[], int *size, HeapNode node) {
int i = *size;
heap[i] = node;
(*size)++;
while (i != 0 && heap[(i-1)/2].sum > heap[i].sum) {
swap(&heap[(i-1)/2], &heap[i]);
i = (i-1)/2;
}
}
HeapNode heapPop(HeapNode heap[], int *size) {
if (*size <= 0) {
HeapNode invalid = {-1, -1, -1};
return invalid;
}
if (*size == 1) {
(*size)--;
return heap[0];
}
HeapNode root = heap[0];
heap[0] = heap[*size - 1];
(*size)--;
heapify(heap, *size, 0);
return root;
}
| int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int *)malloc(sizeof(int) * 2);
}
if (nums1Size == 0 || nums2Size == 0 || k == 0) {
*returnSize = 0;
free(heap);
return result;
}
heapPush(heap, &heapSize, (HeapNode){nums1[0] + nums2[0], 0, 0});
int count = 0;
while (heapSize > 0 && count < k) {
HeapNode node = heapPop(heap, &heapSize);
result[count][0] = nums1[node.index1];
result[count][1] = nums2[node.index2];
count++;
if (node.index2 + 1 < nums2Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1] + nums2[node.index2 + 1], node.index1, node.index2 + 1});
}
if (node.index2 == 0 && node.index1 + 1 < nums1Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1 + 1] + nums2[0], node.index1 + 1, 0});
}
}
*returnSize = count;
free(heap);
return result;
}
| int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &returnSize);
assert(returnSize == 1 && result[0][0] == 1 && result[0][1] == 2);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 7, &returnSize);
assert(returnSize == 7 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,0x10(%rsp)
mov %esi,0x24(%rsp)
mov %rdx,%r15
mov %ecx,0x18(%rsp)
mov %r8d,%ebx
mov %r8d,0x1c(%rsp)
mov %r9,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov %esi,%eax
imul %ecx,%eax
cltq
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rsp)
movl $0x0,0x30(%rsp)
movslq %ebx,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %ebx,%ebx
jle 15a9 <func0+0x239>
mov %ebx,%eax
mov %r14,%rbx
lea -0x1(%rax),%eax
lea 0x8(%r14,%rax,8),%rbp
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
add $0x8,%rbx
cmp %rbp,%rbx
jne 13f3 <func0+0x83>
cmpl $0x0,0x24(%rsp)
je 146d <func0+0xfd>
cmpl $0x0,0x18(%rsp)
je 146d <func0+0xfd>
mov (%r15),%eax
mov 0x10(%rsp),%rsi
add (%rsi),%eax
mov %eax,0x34(%rsp)
movl $0x0,0x38(%rsp)
movl $0x0,0x3c(%rsp)
lea 0x30(%rsp),%rsi
mov 0x34(%rsp),%rdx
mov $0x0,%ecx
mov (%rsp),%rdi
callq 1270 <heapPush>
cmpl $0x0,0x30(%rsp)
jle 159f <func0+0x22f>
mov $0x1,%r12d
lea 0x30(%rsp),%rax
mov %rax,0x8(%rsp)
jmpq 14ed <func0+0x17d>
mov 0x28(%rsp),%rax
movl $0x0,(%rax)
mov (%rsp),%rdi
callq 1080 <free@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 161b <func0+0x2ab>
mov %r14,%rax
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov (%rdx),%eax
add 0x4(%r15,%rsi,1),%eax
mov %eax,0x4c(%rsp)
mov %ebx,0x50(%rsp)
mov %ecx,0x54(%rsp)
mov %ecx,%ecx
mov 0x4c(%rsp),%rdx
mov 0x8(%rsp),%rsi
mov (%rsp),%rdi
callq 1270 <heapPush>
jmp 1550 <func0+0x1e0>
cmpl $0x0,0x30(%rsp)
setg %dl
cmp %r12d,0x1c(%rsp)
setg %al
add $0x1,%r12
test %al,%dl
je 1602 <func0+0x292>
mov 0x8(%rsp),%rsi
mov (%rsp),%rdi
callq 12d6 <heapPop>
mov %rax,%rbx
mov %rdx,%rbp
mov %rax,0x40(%rsp)
mov %edx,0x48(%rsp)
shr $0x20,%rbx
movslq %ebx,%r13
shl $0x2,%r13
mov 0x10(%rsp),%rax
lea (%rax,%r13,1),%rdx
mov -0x8(%r14,%r12,8),%rax
mov (%rdx),%ecx
mov %ecx,(%rax)
movslq %ebp,%rax
lea 0x0(,%rax,4),%rsi
mov -0x8(%r14,%r12,8),%rcx
mov (%r15,%rax,4),%eax
mov %eax,0x4(%rcx)
mov %r12d,0x20(%rsp)
lea 0x1(%rbp),%ecx
cmp 0x18(%rsp),%ecx
jl 14a7 <func0+0x137>
test %ebp,%ebp
jne 14d1 <func0+0x161>
add $0x1,%ebx
cmp 0x24(%rsp),%ebx
jge 14d1 <func0+0x161>
mov (%r15),%eax
mov 0x10(%rsp),%rsi
add 0x4(%rsi,%r13,1),%eax
mov %eax,0x4c(%rsp)
mov %ebx,0x50(%rsp)
movl $0x0,0x54(%rsp)
mov 0x4c(%rsp),%rdx
mov $0x0,%ecx
mov 0x8(%rsp),%rsi
mov (%rsp),%rdi
callq 1270 <heapPush>
jmpq 14d1 <func0+0x161>
movl $0x0,0x20(%rsp)
jmp 1602 <func0+0x292>
cmpl $0x0,0x18(%rsp)
sete %dl
cmpl $0x0,0x1c(%rsp)
sete %al
or %al,%dl
jne 146d <func0+0xfd>
cmpl $0x0,0x24(%rsp)
je 146d <func0+0xfd>
mov 0x10(%rsp),%rax
mov (%rax),%eax
add (%r15),%eax
mov %eax,0x34(%rsp)
movl $0x0,0x38(%rsp)
lea 0x30(%rsp),%rsi
mov 0x34(%rsp),%rdx
mov $0x0,%ecx
mov (%rsp),%rdi
callq 1270 <heapPush>
movl $0x0,0x20(%rsp)
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%esi
mov %esi,(%rax)
mov (%rsp),%rdi
callq 1080 <free@plt>
jmpq 1481 <func0+0x111>
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_90], rdi
mov [rsp+98h+var_74], esi
mov r14, rdx
mov [rsp+98h+var_88], ecx
mov ebx, r8d
mov [rsp+98h+var_84], r8d
mov [rsp+98h+var_70], r9
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov eax, esi
imul eax, ecx
cdqe
lea rdi, [rax+rax*2]
shl rdi, 2
call _malloc
mov r15, rax
mov [rsp+98h+var_68], 0
movsxd rdi, ebx
shl rdi, 3
call _malloc
mov r13, rax
test ebx, ebx
jle loc_15A2
mov eax, ebx
mov rbx, r13
mov eax, eax
lea rbp, [r13+rax*8+0]
loc_13F1:
mov edi, 8
call _malloc
mov [rbx], rax
add rbx, 8
cmp rbx, rbp
jnz short loc_13F1
cmp [rsp+98h+var_74], 0
jz short loc_1465
cmp [rsp+98h+var_88], 0
jz short loc_1465
mov eax, [r14]
mov rsi, [rsp+98h+var_90]
add eax, [rsi]
mov dword ptr [rsp+98h+var_64], eax
mov dword ptr [rsp+98h+var_64+4], 0
mov [rsp+98h+var_5C], 0
lea rsi, [rsp+98h+var_68]
mov rdx, [rsp+98h+var_64]
mov ecx, 0
mov rdi, r15
call heapPush
cmp [rsp+98h+var_68], 0
jle loc_1598
mov ebp, 1
lea rax, [rsp+98h+var_68]
mov [rsp+98h+var_98], rax
jmp short loc_14E0
loc_1465:
mov rax, [rsp+98h+var_70]
mov dword ptr [rax], 0
mov rdi, r15
call _free
loc_1478:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz loc_1612
mov rax, r13
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_149E:
add esi, [r14+rdi+4]
mov dword ptr [rsp+98h+var_4C], esi
mov dword ptr [rsp+98h+var_4C+4], r12d
mov [rsp+98h+var_44], ecx
mov ecx, ecx
mov rdx, [rsp+98h+var_4C]
mov rsi, [rsp+98h+var_98]
mov rdi, r15
call heapPush
jmp short loc_1544
loc_14C5:
cmp [rsp+98h+var_68], 0
setnle dl
cmp [rsp+98h+var_84], ebp
setnle al
add rbp, 1
test dl, al
jz loc_15FA
loc_14E0:
mov rsi, [rsp+98h+var_98]
mov rdi, r15
call heapPop
mov rbx, rdx
mov rcx, rax
shr rcx, 20h
mov r12, rcx
mov [rsp+98h+var_58], rax
mov [rsp+98h+var_50], edx
movsxd rdx, ecx
lea rax, ds:0[rdx*4]
mov [rsp+98h+var_80], rax
mov rax, [r13+rbp*8-8]
mov rsi, [rsp+98h+var_90]
mov esi, [rsi+rdx*4]
mov [rax], esi
movsxd rdx, ebx
lea rdi, ds:0[rdx*4]
mov edx, [r14+rdx*4]
mov [rax+4], edx
mov [rsp+98h+var_78], ebp
lea ecx, [rbx+1]
cmp ecx, [rsp+98h+var_88]
jl loc_149E
loc_1544:
test ebx, ebx
jnz loc_14C5
add r12d, 1
cmp r12d, [rsp+98h+var_74]
jge loc_14C5
mov eax, [r14]
mov rsi, [rsp+98h+var_90]
mov rcx, [rsp+98h+var_80]
add eax, [rsi+rcx+4]
mov dword ptr [rsp+98h+var_4C], eax
mov dword ptr [rsp+98h+var_4C+4], r12d
mov [rsp+98h+var_44], 0
mov rdx, [rsp+98h+var_4C]
mov ecx, 0
mov rsi, [rsp+98h+var_98]
mov rdi, r15
call heapPush
jmp loc_14C5
loc_1598:
mov [rsp+98h+var_78], 0
jmp short loc_15FA
loc_15A2:
cmp [rsp+98h+var_88], 0
setz al
cmp [rsp+98h+var_84], 0
setz dl
or al, dl
jnz loc_1465
cmp [rsp+98h+var_74], 0
jz loc_1465
mov rax, [rsp+98h+var_90]
mov eax, [rax]
add eax, [r14]
mov dword ptr [rsp+98h+var_64], eax
mov dword ptr [rsp+98h+var_64+4], 0
lea rsi, [rsp+98h+var_68]
mov rdx, [rsp+98h+var_64]
mov ecx, 0
mov rdi, r15
call heapPush
mov [rsp+98h+var_78], 0
loc_15FA:
mov rax, [rsp+98h+var_70]
mov esi, [rsp+98h+var_78]
mov [rax], esi
mov rdi, r15
call _free
jmp loc_1478
loc_1612:
call ___stack_chk_fail | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4, int a5, _DWORD *a6)
{
long long v8; // r15
long long v9; // r13
unsigned int v10; // eax
_QWORD *v11; // rbx
_QWORD *v12; // rbp
long long v13; // rbp
unsigned long long i; // rax
int v15; // edx
bool v17; // al
int v18; // ebx
unsigned long long v19; // r12
long long v20; // rdx
_DWORD *v21; // rax
int v22; // esi
long long v23; // rdi
int v24; // r12d
long long v28; // [rsp+18h] [rbp-80h]
int v29; // [rsp+20h] [rbp-78h]
int v32; // [rsp+30h] [rbp-68h] BYREF
long long v33; // [rsp+34h] [rbp-64h]
int v34; // [rsp+3Ch] [rbp-5Ch]
unsigned long long v35; // [rsp+40h] [rbp-58h]
int v36; // [rsp+48h] [rbp-50h]
long long v37; // [rsp+4Ch] [rbp-4Ch]
int v38; // [rsp+54h] [rbp-44h]
unsigned long long v39; // [rsp+58h] [rbp-40h]
v39 = __readfsqword(0x28u);
v8 = malloc(12LL * a4 * a2);
v32 = 0;
v9 = malloc(8LL * a5);
if ( a5 <= 0 )
{
if ( a5 != 0 && a4 != 0 && a2 )
{
v33 = (unsigned int)(*a3 + *a1);
heapPush(v8, &v32, v33, 0LL);
v29 = 0;
LABEL_21:
*a6 = v29;
free(v8);
return v9;
}
}
else
{
v10 = a5;
v11 = (_QWORD *)v9;
v12 = (_QWORD *)(v9 + 8LL * v10);
do
*v11++ = malloc(8LL);
while ( v11 != v12 );
if ( a2 && a4 )
{
v33 = (unsigned int)(*a1 + *a3);
v34 = 0;
heapPush(v8, &v32, v33, 0LL);
if ( v32 <= 0 )
{
v29 = 0;
}
else
{
v13 = 1LL;
for ( i = heapPop(v8, &v32); ; i = heapPop(v8, &v32) )
{
v18 = v15;
v19 = HIDWORD(i);
v35 = i;
v36 = v15;
v20 = SHIDWORD(i);
v28 = SHIDWORD(i);
v21 = *(_DWORD **)(v9 + 8 * v13 - 8);
v22 = a1[v20];
*v21 = v22;
v23 = v18;
v21[1] = a3[v23];
v29 = v13;
if ( v18 + 1 < a4 )
{
LODWORD(v37) = a3[v23 + 1] + v22;
HIDWORD(v37) = v19;
v38 = v18 + 1;
heapPush(v8, &v32, v37, (unsigned int)(v18 + 1));
}
if ( !v18 )
{
v24 = v19 + 1;
if ( v24 < a2 )
{
LODWORD(v37) = a1[v28 + 1] + *a3;
HIDWORD(v37) = v24;
v38 = 0;
heapPush(v8, &v32, v37, 0LL);
}
}
v17 = a5 > (int)v13++;
if ( !v17 || v32 <= 0 )
break;
}
}
goto LABEL_21;
}
}
*a6 = 0;
free(v8);
return v9;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x8],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV R14,RDX
MOV dword ptr [RSP + 0x10],ECX
MOV EBX,R8D
MOV dword ptr [RSP + 0x14],R8D
MOV qword ptr [RSP + 0x28],R9
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV EAX,ESI
IMUL EAX,ECX
CDQE
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010b0
MOV R15,RAX
MOV dword ptr [RSP + 0x30],0x0
MOVSXD RDI,EBX
SHL RDI,0x3
CALL 0x001010b0
MOV R13,RAX
TEST EBX,EBX
JLE 0x001015a2
MOV EAX,EBX
MOV RBX,R13
MOV EAX,EAX
LEA RBP,[R13 + RAX*0x8]
LAB_001013f1:
MOV EDI,0x8
CALL 0x001010b0
MOV qword ptr [RBX],RAX
ADD RBX,0x8
CMP RBX,RBP
JNZ 0x001013f1
CMP dword ptr [RSP + 0x24],0x0
JZ 0x00101465
CMP dword ptr [RSP + 0x10],0x0
JZ 0x00101465
MOV EAX,dword ptr [R14]
MOV RSI,qword ptr [RSP + 0x8]
ADD EAX,dword ptr [RSI]
MOV dword ptr [RSP + 0x34],EAX
MOV dword ptr [RSP + 0x38],0x0
MOV dword ptr [RSP + 0x3c],0x0
LEA RSI,[RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x34]
MOV ECX,0x0
MOV RDI,R15
CALL 0x00101270
CMP dword ptr [RSP + 0x30],0x0
JLE 0x00101598
MOV EBP,0x1
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP],RAX
JMP 0x001014e0
LAB_00101465:
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX],0x0
MOV RDI,R15
CALL 0x00101080
LAB_00101478:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101612
MOV RAX,R13
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010149e:
ADD ESI,dword ptr [R14 + RDI*0x1 + 0x4]
MOV dword ptr [RSP + 0x4c],ESI
MOV dword ptr [RSP + 0x50],R12D
MOV dword ptr [RSP + 0x54],ECX
MOV ECX,ECX
MOV RDX,qword ptr [RSP + 0x4c]
MOV RSI,qword ptr [RSP]
MOV RDI,R15
CALL 0x00101270
JMP 0x00101544
LAB_001014c5:
CMP dword ptr [RSP + 0x30],0x0
SETG DL
CMP dword ptr [RSP + 0x14],EBP
SETG AL
ADD RBP,0x1
TEST DL,AL
JZ 0x001015fa
LAB_001014e0:
MOV RSI,qword ptr [RSP]
MOV RDI,R15
CALL 0x001012d6
MOV RBX,RDX
MOV RCX,RAX
SHR RCX,0x20
MOV R12,RCX
MOV qword ptr [RSP + 0x40],RAX
MOV dword ptr [RSP + 0x48],EDX
MOVSXD RDX,ECX
LEA RAX,[RDX*0x4]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [R13 + RBP*0x8 + -0x8]
MOV RSI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSI + RDX*0x4]
MOV dword ptr [RAX],ESI
MOVSXD RDX,EBX
LEA RDI,[RDX*0x4]
MOV EDX,dword ptr [R14 + RDX*0x4]
MOV dword ptr [RAX + 0x4],EDX
MOV dword ptr [RSP + 0x20],EBP
LEA ECX,[RBX + 0x1]
CMP ECX,dword ptr [RSP + 0x10]
JL 0x0010149e
LAB_00101544:
TEST EBX,EBX
JNZ 0x001014c5
ADD R12D,0x1
CMP R12D,dword ptr [RSP + 0x24]
JGE 0x001014c5
MOV EAX,dword ptr [R14]
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
ADD EAX,dword ptr [RSI + RCX*0x1 + 0x4]
MOV dword ptr [RSP + 0x4c],EAX
MOV dword ptr [RSP + 0x50],R12D
MOV dword ptr [RSP + 0x54],0x0
MOV RDX,qword ptr [RSP + 0x4c]
MOV ECX,0x0
MOV RSI,qword ptr [RSP]
MOV RDI,R15
CALL 0x00101270
JMP 0x001014c5
LAB_00101598:
MOV dword ptr [RSP + 0x20],0x0
JMP 0x001015fa
LAB_001015a2:
CMP dword ptr [RSP + 0x10],0x0
SETZ AL
CMP dword ptr [RSP + 0x14],0x0
SETZ DL
OR AL,DL
JNZ 0x00101465
CMP dword ptr [RSP + 0x24],0x0
JZ 0x00101465
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX]
ADD EAX,dword ptr [R14]
MOV dword ptr [RSP + 0x34],EAX
MOV dword ptr [RSP + 0x38],0x0
LEA RSI,[RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x34]
MOV ECX,0x0
MOV RDI,R15
CALL 0x00101270
MOV dword ptr [RSP + 0x20],0x0
LAB_001015fa:
MOV RAX,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x20]
MOV dword ptr [RAX],ESI
MOV RDI,R15
CALL 0x00101080
JMP 0x00101478
LAB_00101612:
CALL 0x00101090 | int8 * func0(int *param_1,int param_2,int *param_3,int param_4,uint param_5,int *param_6)
{
int *piVar1;
void *__ptr;
int8 *puVar2;
void *pvVar3;
int iVar4;
int iVar5;
int iVar6;
int8 *puVar7;
long lVar8;
int iVar9;
long in_FS_OFFSET;
int1 auVar10 [12];
int local_78;
int local_68;
int local_64;
int4 uStack_60;
int4 local_5c;
int1 local_58 [12];
int local_4c;
int iStack_48;
int local_44;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = malloc((long)(param_2 * param_4) * 0xc);
local_68 = 0;
puVar2 = (int8 *)malloc((long)(int)param_5 << 3);
if ((int)param_5 < 1) {
if ((param_4 == 0 || param_5 == 0) || (param_2 == 0)) goto LAB_00101465;
local_64 = *param_1 + *param_3;
uStack_60 = 0;
heapPush(__ptr,&local_68,local_64,0);
local_78 = 0;
}
else {
puVar7 = puVar2;
do {
pvVar3 = malloc(8);
*puVar7 = pvVar3;
puVar7 = puVar7 + 1;
} while (puVar7 != puVar2 + param_5);
if ((param_2 == 0) || (param_4 == 0)) {
LAB_00101465:
*param_6 = 0;
free(__ptr);
goto LAB_00101478;
}
local_64 = *param_3 + *param_1;
uStack_60 = 0;
local_5c = 0;
heapPush(__ptr,&local_68,local_64,0);
if (local_68 < 1) {
local_78 = 0;
}
else {
lVar8 = 1;
do {
auVar10 = heapPop(__ptr,&local_68);
iVar6 = auVar10._8_4_;
iVar4 = auVar10._4_4_;
piVar1 = (int *)puVar2[lVar8 + -1];
iVar9 = param_1[iVar4];
*piVar1 = iVar9;
piVar1[1] = param_3[iVar6];
local_78 = (int)lVar8;
iVar5 = iVar6 + 1;
local_58 = auVar10;
if (iVar5 < param_4) {
local_4c = iVar9 + param_3[(long)iVar6 + 1];
iStack_48 = iVar4;
local_44 = iVar5;
heapPush(__ptr,&local_68,CONCAT44(iVar4,local_4c),iVar5);
}
if ((iVar6 == 0) && (iVar9 = iVar4 + 1, iVar9 < param_2)) {
local_4c = *param_3 + param_1[(long)iVar4 + 1];
local_44 = 0;
iStack_48 = iVar9;
heapPush(__ptr,&local_68,CONCAT44(iVar9,local_4c),0);
}
lVar8 = lVar8 + 1;
} while (0 < local_68 && local_78 < (int)param_5);
}
}
*param_6 = local_78;
free(__ptr);
LAB_00101478:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,526 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
int l = 2*i + 1;
int r = 2*i + 2;
if (l < n && heap[l].sum < heap[smallest].sum)
smallest = l;
if (r < n && heap[r].sum < heap[smallest].sum)
smallest = r;
if (smallest != i) {
swap(&heap[i], &heap[smallest]);
heapify(heap, n, smallest);
}
}
void heapPush(HeapNode heap[], int *size, HeapNode node) {
int i = *size;
heap[i] = node;
(*size)++;
while (i != 0 && heap[(i-1)/2].sum > heap[i].sum) {
swap(&heap[(i-1)/2], &heap[i]);
i = (i-1)/2;
}
}
HeapNode heapPop(HeapNode heap[], int *size) {
if (*size <= 0) {
HeapNode invalid = {-1, -1, -1};
return invalid;
}
if (*size == 1) {
(*size)--;
return heap[0];
}
HeapNode root = heap[0];
heap[0] = heap[*size - 1];
(*size)--;
heapify(heap, *size, 0);
return root;
}
| int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int *)malloc(sizeof(int) * 2);
}
if (nums1Size == 0 || nums2Size == 0 || k == 0) {
*returnSize = 0;
free(heap);
return result;
}
heapPush(heap, &heapSize, (HeapNode){nums1[0] + nums2[0], 0, 0});
int count = 0;
while (heapSize > 0 && count < k) {
HeapNode node = heapPop(heap, &heapSize);
result[count][0] = nums1[node.index1];
result[count][1] = nums2[node.index2];
count++;
if (node.index2 + 1 < nums2Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1] + nums2[node.index2 + 1], node.index1, node.index2 + 1});
}
if (node.index2 == 0 && node.index1 + 1 < nums1Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1 + 1] + nums2[0], node.index1 + 1, 0});
}
}
*returnSize = count;
free(heap);
return result;
}
| int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &returnSize);
assert(returnSize == 1 && result[0][0] == 1 && result[0][1] == 2);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 7, &returnSize);
assert(returnSize == 7 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov %ecx,%r15d
push %r14
mov %rdx,%r14
push %r13
mov %esi,%r13d
push %r12
push %rbp
push %rbx
mov %r8d,%ebx
sub $0x58,%rsp
mov %rdi,0x10(%rsp)
mov %esi,0xc(%rsp)
mov %ecx,0x4(%rsp)
mov %r9,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %esi,%eax
imul %ecx,%eax
cltq
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movslq %ebx,%rdi
movl $0x0,0x20(%rsp)
shl $0x3,%rdi
mov %rax,%rbp
callq 10b0 <malloc@plt>
test %r15d,%r15d
sete %r15b
test %ebx,%ebx
mov %rax,%r12
sete %al
or %eax,%r15d
test %r13d,%r13d
sete %al
or %eax,%r15d
mov %r15b,0x8(%rsp)
test %ebx,%ebx
jle 17f0 <func0+0x250>
lea -0x1(%rbx),%eax
mov %r12,%r15
lea 0x8(%r12,%rax,8),%r13
xchg %ax,%ax
mov $0x8,%edi
add $0x8,%r15
callq 10b0 <malloc@plt>
mov %rax,-0x8(%r15)
cmp %r13,%r15
jne 1640 <func0+0xa0>
cmpb $0x0,0x8(%rsp)
je 16a0 <func0+0x100>
mov 0x18(%rsp),%rax
mov %rbp,%rdi
movl $0x0,(%rax)
callq 1080 <free@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 182d <func0+0x28d>
add $0x58,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov 0x10(%rsp),%r11
mov (%r14),%eax
lea 0x20(%rsp),%r13
mov %rbp,%rdi
movq $0x0,0x28(%rsp)
mov 0x2c(%rsp),%ecx
mov %r13,%rsi
add (%r11),%eax
mov %eax,0x24(%rsp)
mov 0x24(%rsp),%rdx
callq 1480 <heapPush>
mov 0x20(%rsp),%edx
test %edx,%edx
jle 1832 <func0+0x292>
mov %ebx,0x8(%rsp)
mov $0x1,%r15d
mov %r11,%rbx
jmp 1721 <func0+0x181>
nopl 0x0(%rax)
test %r11d,%r11d
jne 1704 <func0+0x164>
add $0x1,%r10d
cmp 0xc(%rsp),%r10d
jl 17a0 <func0+0x200>
mov 0x20(%rsp),%eax
test %eax,%eax
setg %dl
cmp %r15d,0x8(%rsp)
setg %al
add $0x1,%r15
test %al,%dl
je 17d0 <func0+0x230>
mov %r13,%rsi
mov %r15d,%ebp
callq 14f0 <heapPop>
mov -0x8(%r12,%r15,8),%rcx
mov %rax,%r10
mov %rax,0x30(%rsp)
mov %rdx,%r11
shr $0x20,%r10
mov %edx,0x38(%rsp)
movslq %r11d,%r9
movslq %r10d,%rax
shl $0x2,%rax
lea (%rbx,%rax,1),%rdx
mov (%rdx),%esi
mov %esi,(%rcx)
lea 0x0(,%r9,4),%rsi
mov (%r14,%r9,4),%r9d
mov %r9d,0x4(%rcx)
lea 0x1(%r11),%ecx
cmp 0x4(%rsp),%ecx
jge 16f0 <func0+0x150>
mov (%rdx),%edx
add 0x4(%r14,%rsi,1),%edx
mov %r10d,0x40(%rsp)
mov %r13,%rsi
mov %edx,0x3c(%rsp)
mov 0x3c(%rsp),%rdx
mov %rax,0x10(%rsp)
mov %ecx,0x44(%rsp)
callq 1480 <heapPush>
mov 0x10(%rsp),%rax
jmpq 16f0 <func0+0x150>
mov (%r14),%edx
add 0x4(%rbx,%rax,1),%edx
mov %r10d,0x40(%rsp)
xor %ecx,%ecx
mov %edx,0x3c(%rsp)
mov 0x3c(%rsp),%rdx
mov %r13,%rsi
movl $0x0,0x44(%rsp)
callq 1480 <heapPush>
jmpq 1704 <func0+0x164>
nopl 0x0(%rax)
mov %ebp,%r9d
mov %rdi,%rbp
mov 0x18(%rsp),%rax
mov %rbp,%rdi
mov %r9d,(%rax)
callq 1080 <free@plt>
jmpq 1671 <func0+0xd1>
nopl 0x0(%rax,%rax,1)
cmpb $0x0,0x8(%rsp)
jne 165e <func0+0xbe>
mov 0x10(%rsp),%rax
lea 0x20(%rsp),%rsi
mov %rbp,%rdi
movq $0x0,0x28(%rsp)
mov 0x2c(%rsp),%ecx
mov (%rax),%eax
add (%r14),%eax
mov %eax,0x24(%rsp)
mov 0x24(%rsp),%rdx
callq 1480 <heapPush>
xor %r9d,%r9d
jmp 17d6 <func0+0x236>
callq 1090 <__stack_chk_fail@plt>
xor %r9d,%r9d
jmp 17d6 <func0+0x236>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov r15d, ecx
push r14
mov r14, rdx
push r13
mov r13d, esi
push r12
push rbp
push rbx
mov ebx, r8d
sub rsp, 58h
mov [rsp+88h+var_78], rdi
mov [rsp+88h+var_7C], esi
mov [rsp+88h+var_84], ecx
mov [rsp+88h+var_70], r9
mov rax, fs:28h
mov [rsp+88h+var_40], rax
mov eax, esi
imul eax, ecx
cdqe
lea rdi, [rax+rax*2]
shl rdi, 2
call _malloc
movsxd rdi, ebx
mov [rsp+88h+var_68], 0
shl rdi, 3
mov rbp, rax
call _malloc
test r15d, r15d
setz r15b
test ebx, ebx
mov r12, rax
setz al
or r15d, eax
test r13d, r13d
setz al
or r15d, eax
mov byte ptr [rsp+88h+var_80], r15b
test ebx, ebx
jle loc_17F0
mov eax, ebx
mov r15, r12
lea r13, [r12+rax*8]
nop word ptr [rax+rax+00h]
loc_1630:
mov edi, 8
add r15, 8
call _malloc
mov [r15-8], rax
cmp r13, r15
jnz short loc_1630
cmp byte ptr [rsp+88h+var_80], 0
jz short loc_1690
loc_164E:
mov rax, [rsp+88h+var_70]
mov rdi, rbp
mov dword ptr [rax], 0
call _free
loc_1661:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz loc_182D
add rsp, 58h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1690:
mov r11, [rsp+88h+var_78]
mov eax, [r14]
lea r13, [rsp+88h+var_68]
mov rdi, rbp
mov [rsp+88h+var_64+4], 0
mov ecx, [rsp+88h+var_5C]
mov rsi, r13
add eax, [r11]
mov dword ptr [rsp+88h+var_64], eax
mov rdx, [rsp+88h+var_64]
call heapPush
mov edx, [rsp+88h+var_68]
test edx, edx
jle loc_1832
mov [rsp+88h+var_80], ebx
mov r15d, 1
mov rbx, r11
jmp short loc_1711
loc_16E0:
test r10d, r10d
jnz short loc_16F4
add r11d, 1
cmp r11d, [rsp+88h+var_7C]
jl loc_17A0
loc_16F4:
mov eax, [rsp+88h+var_68]
test eax, eax
setnle dl
cmp [rsp+88h+var_80], r15d
setnle al
add r15, 1
test dl, al
jz loc_17D0
loc_1711:
mov rsi, r13
mov ebp, r15d
call heapPop
mov rcx, [r12+r15*8-8]
mov rsi, rax
mov r10, rdx
mov [rsp+88h+var_50], edx
shr rsi, 20h
movsxd r8, r10d
mov [rsp+88h+var_58], rax
movsxd rdx, esi
mov r11, rsi
lea rsi, ds:0[r8*4]
mov r8d, [r14+r8*4]
lea rax, ds:0[rdx*4]
mov edx, [rbx+rdx*4]
mov [rcx+4], r8d
mov [rcx], edx
lea ecx, [r10+1]
cmp ecx, [rsp+88h+var_84]
jge loc_16E0
add edx, [r14+rsi+4]
mov dword ptr [rsp+88h+var_4C+4], r11d
mov rsi, r13
mov dword ptr [rsp+88h+var_4C], edx
mov rdx, [rsp+88h+var_4C]
mov [rsp+88h+var_78], rax
mov [rsp+88h+var_44], ecx
call heapPush
mov rax, [rsp+88h+var_78]
jmp loc_16E0
loc_17A0:
mov edx, [r14]
add edx, [rbx+rax+4]
mov dword ptr [rsp+88h+var_4C+4], r11d
xor ecx, ecx
mov dword ptr [rsp+88h+var_4C], edx
mov rdx, [rsp+88h+var_4C]
mov rsi, r13
mov [rsp+88h+var_44], 0
call heapPush
jmp loc_16F4
loc_17D0:
mov r8d, ebp
mov rbp, rdi
loc_17D6:
mov rax, [rsp+88h+var_70]
mov rdi, rbp
mov [rax], r8d
call _free
jmp loc_1661
loc_17F0:
cmp byte ptr [rsp+88h+var_80], 0
jnz loc_164E
mov rax, [rsp+88h+var_78]
lea rsi, [rsp+88h+var_68]
mov rdi, rbp
mov [rsp+88h+var_64+4], 0
mov ecx, [rsp+88h+var_5C]
mov eax, [rax]
add eax, [r14]
mov dword ptr [rsp+88h+var_64], eax
mov rdx, [rsp+88h+var_64]
call heapPush
xor r8d, r8d
jmp short loc_17D6
loc_182D:
call ___stack_chk_fail
loc_1832:
xor r8d, r8d
jmp short loc_17D6 | long long func0(_DWORD *a1, int a2, int *a3, int a4, int a5, _DWORD *a6)
{
long long v9; // rbp
long long v10; // r12
long long v11; // r15
int v13; // eax
long long v14; // rdi
long long v15; // r11
long long v16; // r15
long long v17; // rbx
signed int v18; // r11d
bool v19; // al
int v20; // ebp
unsigned long long v21; // rax
_DWORD *v22; // rcx
int v23; // edx
int v24; // r10d
unsigned long long v25; // r11
long long v26; // rsi
long long v27; // rax
int v28; // edx
long long v29; // rcx
unsigned int v30; // edx
int v31; // r8d
bool v33; // [rsp+8h] [rbp-80h]
int v34; // [rsp+8h] [rbp-80h]
long long v37; // [rsp+10h] [rbp-78h]
int v39; // [rsp+20h] [rbp-68h] BYREF
_BYTE v40[12]; // [rsp+24h] [rbp-64h]
unsigned long long v41; // [rsp+30h] [rbp-58h]
int v42; // [rsp+38h] [rbp-50h]
unsigned long long v43; // [rsp+3Ch] [rbp-4Ch]
int v44; // [rsp+44h] [rbp-44h]
unsigned long long v45; // [rsp+48h] [rbp-40h]
v45 = __readfsqword(0x28u);
v39 = 0;
v9 = malloc(12LL * a4 * a2);
v10 = malloc(8LL * a5);
v33 = a2 == 0 || a5 == 0 || a4 == 0;
if ( a5 > 0 )
{
v11 = v10;
do
{
v11 += 8LL;
*(_QWORD *)(v11 - 8) = malloc(8LL);
}
while ( v10 + 8LL * (unsigned int)a5 != v11 );
if ( v33 )
goto LABEL_5;
v13 = *a3;
v14 = v9;
*(_QWORD *)&v40[4] = 0LL;
*(_QWORD *)v40 = (unsigned int)(*a1 + v13);
heapPush(v9, &v39, *(_QWORD *)v40, 0LL);
if ( v39 <= 0 )
{
v31 = 0;
}
else
{
v34 = a5;
v16 = 1LL;
v17 = v15;
do
{
v20 = v16;
v21 = heapPop(v14, &v39);
v22 = *(_DWORD **)(v10 + 8 * v16 - 8);
v24 = v23;
v42 = v23;
v41 = v21;
v25 = HIDWORD(v21);
v26 = v23;
v27 = 4LL * SHIDWORD(v21);
v28 = *(_DWORD *)(v17 + v27);
v22[1] = a3[v26];
*v22 = v28;
v29 = (unsigned int)(v24 + 1);
if ( (int)v29 < a4 )
{
v30 = a3[v26 + 1] + v28;
v43 = __PAIR64__(v25, v30);
v37 = v27;
v44 = v24 + 1;
heapPush(v14, &v39, __PAIR64__(v25, v30), v29);
v27 = v37;
}
if ( !v24 )
{
v18 = v25 + 1;
if ( v18 < a2 )
{
v43 = __PAIR64__(v18, *(_DWORD *)(v17 + v27 + 4) + *a3);
v44 = 0;
heapPush(v14, &v39, v43, 0LL);
}
}
v19 = v34 > (int)v16++;
}
while ( v19 && v39 > 0 );
v31 = v20;
v9 = v14;
}
LABEL_16:
*a6 = v31;
free(v9);
return v10;
}
if ( !v33 )
{
*(_QWORD *)&v40[4] = 0LL;
*(_DWORD *)v40 = *a3 + *a1;
heapPush(v9, &v39, *(unsigned int *)v40, 0LL);
v31 = 0;
goto LABEL_16;
}
LABEL_5:
*a6 = 0;
free(v9);
return v10;
} | func0:
ENDBR64
PUSH R15
MOV R15D,ECX
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,R8D
SUB RSP,0x58
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0xc],ESI
MOV dword ptr [RSP + 0x4],ECX
MOV qword ptr [RSP + 0x18],R9
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
MOV EAX,ESI
IMUL EAX,ECX
CDQE
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010b0
MOVSXD RDI,EBX
MOV dword ptr [RSP + 0x20],0x0
SHL RDI,0x3
MOV RBP,RAX
CALL 0x001010b0
TEST R15D,R15D
SETZ R15B
TEST EBX,EBX
MOV R12,RAX
SETZ AL
OR R15D,EAX
TEST R13D,R13D
SETZ AL
OR R15D,EAX
MOV byte ptr [RSP + 0x8],R15B
TEST EBX,EBX
JLE 0x001017f0
MOV EAX,EBX
MOV R15,R12
LEA R13,[R12 + RAX*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101630:
MOV EDI,0x8
ADD R15,0x8
CALL 0x001010b0
MOV qword ptr [R15 + -0x8],RAX
CMP R13,R15
JNZ 0x00101630
CMP byte ptr [RSP + 0x8],0x0
JZ 0x00101690
LAB_0010164e:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,RBP
MOV dword ptr [RAX],0x0
CALL 0x00101080
LAB_00101661:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010182d
ADD RSP,0x58
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101690:
MOV R11,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [R14]
LEA R13,[RSP + 0x20]
MOV RDI,RBP
MOV qword ptr [RSP + 0x28],0x0
MOV ECX,dword ptr [RSP + 0x2c]
MOV RSI,R13
ADD EAX,dword ptr [R11]
MOV dword ptr [RSP + 0x24],EAX
MOV RDX,qword ptr [RSP + 0x24]
CALL 0x00101470
MOV EDX,dword ptr [RSP + 0x20]
TEST EDX,EDX
JLE 0x00101832
MOV dword ptr [RSP + 0x8],EBX
MOV R15D,0x1
MOV RBX,R11
JMP 0x00101711
LAB_001016e0:
TEST R10D,R10D
JNZ 0x001016f4
ADD R11D,0x1
CMP R11D,dword ptr [RSP + 0xc]
JL 0x001017a0
LAB_001016f4:
MOV EAX,dword ptr [RSP + 0x20]
TEST EAX,EAX
SETG DL
CMP dword ptr [RSP + 0x8],R15D
SETG AL
ADD R15,0x1
TEST DL,AL
JZ 0x001017d0
LAB_00101711:
MOV RSI,R13
MOV EBP,R15D
CALL 0x001014e0
MOV RCX,qword ptr [R12 + R15*0x8 + -0x8]
MOV RSI,RAX
MOV R10,RDX
MOV dword ptr [RSP + 0x38],EDX
SHR RSI,0x20
MOVSXD R8,R10D
MOV qword ptr [RSP + 0x30],RAX
MOVSXD RDX,ESI
MOV R11,RSI
LEA RSI,[R8*0x4]
MOV R8D,dword ptr [R14 + R8*0x4]
LEA RAX,[RDX*0x4]
MOV EDX,dword ptr [RBX + RDX*0x4]
MOV dword ptr [RCX + 0x4],R8D
MOV dword ptr [RCX],EDX
LEA ECX,[R10 + 0x1]
CMP ECX,dword ptr [RSP + 0x4]
JGE 0x001016e0
ADD EDX,dword ptr [R14 + RSI*0x1 + 0x4]
MOV dword ptr [RSP + 0x40],R11D
MOV RSI,R13
MOV dword ptr [RSP + 0x3c],EDX
MOV RDX,qword ptr [RSP + 0x3c]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x44],ECX
CALL 0x00101470
MOV RAX,qword ptr [RSP + 0x10]
JMP 0x001016e0
LAB_001017a0:
MOV EDX,dword ptr [R14]
ADD EDX,dword ptr [RBX + RAX*0x1 + 0x4]
MOV dword ptr [RSP + 0x40],R11D
XOR ECX,ECX
MOV dword ptr [RSP + 0x3c],EDX
MOV RDX,qword ptr [RSP + 0x3c]
MOV RSI,R13
MOV dword ptr [RSP + 0x44],0x0
CALL 0x00101470
JMP 0x001016f4
LAB_001017d0:
MOV R8D,EBP
MOV RBP,RDI
LAB_001017d6:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,RBP
MOV dword ptr [RAX],R8D
CALL 0x00101080
JMP 0x00101661
LAB_001017f0:
CMP byte ptr [RSP + 0x8],0x0
JNZ 0x0010164e
MOV RAX,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x20]
MOV RDI,RBP
MOV qword ptr [RSP + 0x28],0x0
MOV ECX,dword ptr [RSP + 0x2c]
MOV EAX,dword ptr [RAX]
ADD EAX,dword ptr [R14]
MOV dword ptr [RSP + 0x24],EAX
MOV RDX,qword ptr [RSP + 0x24]
CALL 0x00101470
XOR R8D,R8D
JMP 0x001017d6
LAB_0010182d:
CALL 0x00101090
LAB_00101832:
XOR R8D,R8D
JMP 0x001017d6 | int8 * func0(int *param_1,int param_2,int *param_3,int param_4,uint param_5,int *param_6)
{
int iVar1;
int *piVar2;
void *__ptr;
int8 *puVar3;
void *pvVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int8 *puVar9;
int8 *puVar10;
long lVar11;
long in_FS_OFFSET;
int1 auVar12 [12];
int local_68;
int local_64;
int4 uStack_60;
int4 uStack_5c;
int1 local_58 [12];
int local_4c;
int iStack_48;
int local_44;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = malloc((long)(param_2 * param_4) * 0xc);
local_68 = 0;
puVar3 = (int8 *)malloc((long)(int)param_5 << 3);
if ((int)param_5 < 1) {
if ((param_4 != 0 && param_5 != 0) && param_2 != 0) {
uStack_60 = 0;
uStack_5c = 0;
local_64 = *param_1 + *param_3;
heapPush(__ptr,&local_68,local_64,0);
iVar8 = 0;
goto LAB_001017d6;
}
}
else {
puVar9 = puVar3;
do {
puVar10 = puVar9 + 1;
pvVar4 = malloc(8);
*puVar9 = pvVar4;
puVar9 = puVar10;
} while (puVar3 + param_5 != puVar10);
if ((param_4 != 0 && param_5 != 0) && param_2 != 0) {
uStack_60 = 0;
uStack_5c = 0;
local_64 = *param_3 + *param_1;
pvVar4 = __ptr;
heapPush(__ptr,&local_68,local_64,0);
if (local_68 < 1) {
iVar8 = 0;
}
else {
lVar11 = 1;
__ptr = pvVar4;
do {
iVar8 = (int)lVar11;
auVar12 = heapPop();
iVar6 = auVar12._8_4_;
piVar2 = (int *)puVar3[lVar11 + -1];
iVar5 = auVar12._4_4_;
iVar1 = param_1[iVar5];
piVar2[1] = param_3[iVar6];
*piVar2 = iVar1;
iVar7 = iVar5;
local_58._8_4_ = iVar6;
if (iVar6 + 1 < param_4) {
local_4c = iVar1 + param_3[(long)iVar6 + 1];
iStack_48 = iVar5;
local_44 = iVar6 + 1;
local_58 = auVar12;
heapPush();
auVar12._8_4_ = iVar6;
auVar12._0_8_ = local_58._0_8_;
}
local_58._0_8_ = auVar12._0_8_;
if ((auVar12._8_4_ == 0) && (iVar7 + 1 < param_2)) {
local_4c = *param_3 + param_1[(long)iVar5 + 1];
local_44 = 0;
iStack_48 = iVar7 + 1;
heapPush();
}
lVar11 = lVar11 + 1;
} while (0 < local_68 && iVar8 < (int)param_5);
}
LAB_001017d6:
*param_6 = iVar8;
free(__ptr);
goto LAB_00101661;
}
}
*param_6 = 0;
free(__ptr);
LAB_00101661:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar3;
} |
5,527 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
int l = 2*i + 1;
int r = 2*i + 2;
if (l < n && heap[l].sum < heap[smallest].sum)
smallest = l;
if (r < n && heap[r].sum < heap[smallest].sum)
smallest = r;
if (smallest != i) {
swap(&heap[i], &heap[smallest]);
heapify(heap, n, smallest);
}
}
void heapPush(HeapNode heap[], int *size, HeapNode node) {
int i = *size;
heap[i] = node;
(*size)++;
while (i != 0 && heap[(i-1)/2].sum > heap[i].sum) {
swap(&heap[(i-1)/2], &heap[i]);
i = (i-1)/2;
}
}
HeapNode heapPop(HeapNode heap[], int *size) {
if (*size <= 0) {
HeapNode invalid = {-1, -1, -1};
return invalid;
}
if (*size == 1) {
(*size)--;
return heap[0];
}
HeapNode root = heap[0];
heap[0] = heap[*size - 1];
(*size)--;
heapify(heap, *size, 0);
return root;
}
| int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int *)malloc(sizeof(int) * 2);
}
if (nums1Size == 0 || nums2Size == 0 || k == 0) {
*returnSize = 0;
free(heap);
return result;
}
heapPush(heap, &heapSize, (HeapNode){nums1[0] + nums2[0], 0, 0});
int count = 0;
while (heapSize > 0 && count < k) {
HeapNode node = heapPop(heap, &heapSize);
result[count][0] = nums1[node.index1];
result[count][1] = nums2[node.index2];
count++;
if (node.index2 + 1 < nums2Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1] + nums2[node.index2 + 1], node.index1, node.index2 + 1});
}
if (node.index2 == 0 && node.index1 + 1 < nums1Size) {
heapPush(heap, &heapSize, (HeapNode){nums1[node.index1 + 1] + nums2[0], node.index1 + 1, 0});
}
}
*returnSize = count;
free(heap);
return result;
}
| int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &returnSize);
assert(returnSize == 1 && result[0][0] == 1 && result[0][1] == 2);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 7, &returnSize);
assert(returnSize == 7 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%eax
push %r15
mov %rdi,%r15
imul %ecx,%eax
push %r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
cltq
mov %r8d,%ebp
push %rbx
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
sub $0x38,%rsp
mov %esi,0x14(%rsp)
mov %ecx,0xc(%rsp)
mov %r9,0x28(%rsp)
callq 10b0 <malloc@plt>
movslq %ebp,%rdi
shl $0x3,%rdi
mov %rax,%r13
callq 10b0 <malloc@plt>
mov %rax,(%rsp)
test %ebp,%ebp
jle 160f <func0+0x7f>
mov %rax,%rbx
mov %rax,%r14
lea -0x1(%rbp),%eax
lea 0x8(%rbx,%rax,8),%rbx
nopl 0x0(%rax)
mov $0x8,%edi
add $0x8,%r14
callq 10b0 <malloc@plt>
mov %rax,-0x8(%r14)
cmp %r14,%rbx
jne 15f8 <func0+0x68>
mov 0xc(%rsp),%edx
test %edx,%edx
sete %dl
test %ebp,%ebp
sete %al
or %al,%dl
jne 1820 <func0+0x290>
mov 0x14(%rsp),%eax
test %eax,%eax
je 1820 <func0+0x290>
mov (%r12),%eax
add (%r15),%eax
mov %ebp,0x10(%rsp)
mov %r15,%r8
mov %eax,0x0(%r13)
xor %r14d,%r14d
mov $0x1,%ebx
movq $0x0,0x4(%r13)
jmp 1678 <func0+0xe8>
nopl (%rax)
mov %esi,%ebx
test %r15d,%r15d
jne 166c <func0+0xdc>
add $0x1,%ebp
cmp 0x14(%rsp),%ebp
jl 179e <func0+0x20e>
test %ebx,%ebx
je 1850 <func0+0x2c0>
add $0x1,%r14
mov %r14d,%eax
mov %r14d,%r11d
cmp %r14d,0x10(%rsp)
jle 1850 <func0+0x2c0>
mov 0x4(%r13),%ebp
mov 0x8(%r13),%r15d
xor %esi,%esi
cmp $0x1,%ebx
je 16d2 <func0+0x142>
movslq %ebx,%rdx
lea -0x1(%rbx),%esi
mov %r13,%rdi
mov %r8,0x20(%rsp)
lea (%rdx,%rdx,2),%rdx
mov %eax,0x18(%rsp)
lea 0x0(%r13,%rdx,4),%rdx
mov -0xc(%rdx),%rcx
mov %rcx,0x0(%r13)
mov -0x4(%rdx),%edx
mov %edx,0x8(%r13)
xor %edx,%edx
callq 13c0 <heapify>
mov 0x20(%rsp),%r8
mov 0x18(%rsp),%eax
movslq %ebp,%r10
mov (%rsp),%rdi
movslq %r15d,%r9
lea 0x1(%rax),%r11d
shl $0x2,%r10
lea 0x1(%r15),%eax
lea (%r8,%r10,1),%rdx
mov (%rdi,%r14,8),%rdi
mov (%rdx),%ecx
mov %ecx,(%rdi)
lea 0x0(,%r9,4),%rcx
mov (%r12,%r9,4),%r9d
mov %r9d,0x4(%rdi)
cmp 0xc(%rsp),%eax
jge 1658 <func0+0xc8>
mov (%rdx),%r9d
add 0x4(%r12,%rcx,1),%r9d
movslq %esi,%rcx
lea (%rcx,%rcx,2),%rdx
lea 0x0(%r13,%rdx,4),%rdx
mov %r9d,(%rdx)
mov %ebp,0x4(%rdx)
mov %eax,0x8(%rdx)
test %esi,%esi
je 1788 <func0+0x1f8>
mov %r8,0x18(%rsp)
jmp 1764 <func0+0x1d4>
nopw %cs:0x0(%rax,%rax,1)
mov (%rdx),%r8
mov 0x8(%rax),%ecx
mov (%rax),%r9
mov %r8,(%rax)
mov 0x8(%rdx),%r8d
mov %r8d,0x8(%rax)
mov %r9,(%rdx)
mov %ecx,0x8(%rdx)
test %esi,%esi
je 1783 <func0+0x1f3>
mov (%rax),%r9d
mov %rdi,%rcx
sub $0x1,%esi
lea (%rcx,%rcx,2),%rdx
sar %esi
lea 0x0(%r13,%rdx,4),%rdx
movslq %esi,%rdi
lea (%rdi,%rdi,2),%rax
lea 0x0(%r13,%rax,4),%rax
cmp %r9d,(%rax)
jg 1740 <func0+0x1b0>
mov 0x18(%rsp),%r8
test %r15d,%r15d
jne 1674 <func0+0xe4>
add $0x1,%ebp
cmp 0x14(%rsp),%ebp
jge 166c <func0+0xdc>
movslq %ebx,%rdx
mov (%r12),%esi
add 0x4(%r8,%r10,1),%esi
lea 0x1(%rbx),%edi
lea (%rdx,%rdx,2),%rax
lea 0x0(%r13,%rax,4),%rax
mov %esi,(%rax)
mov %ebp,0x4(%rax)
movl $0x0,0x8(%rax)
test %ebx,%ebx
jne 17f3 <func0+0x263>
jmp 1811 <func0+0x281>
nopl 0x0(%rax,%rax,1)
mov (%rdx),%r10
mov 0x8(%rax),%esi
mov (%rax),%r9
mov %r10,(%rax)
mov 0x8(%rdx),%r10d
mov %r10d,0x8(%rax)
mov %r9,(%rdx)
mov %esi,0x8(%rdx)
test %ebx,%ebx
je 1811 <func0+0x281>
mov (%rax),%esi
mov %rcx,%rdx
sub $0x1,%ebx
lea (%rdx,%rdx,2),%rdx
sar %ebx
lea 0x0(%r13,%rdx,4),%rdx
movslq %ebx,%rcx
lea (%rcx,%rcx,2),%rax
lea 0x0(%r13,%rax,4),%rax
cmp %esi,(%rax)
jg 17d0 <func0+0x240>
mov %edi,%ebx
jmpq 1674 <func0+0xe4>
nopl 0x0(%rax,%rax,1)
mov 0x28(%rsp),%rax
mov %r13,%rdi
movl $0x0,(%rax)
callq 1080 <free@plt>
mov (%rsp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
mov 0x28(%rsp),%rax
mov %r13,%rdi
mov %r11d,(%rax)
callq 1080 <free@plt>
jmp 1833 <func0+0x2a3>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, esi
push r15
imul eax, ecx
push r14
push r13
mov r13, rdx
push r12
mov r12d, ecx
push rbp
cdqe
push rbx
movsxd rbx, r8d
sub rsp, 38h
mov [rsp+68h+var_60], rdi
lea rdi, [rax+rax*2]
shl rdi, 2; size
mov [rsp+68h+var_64], esi
mov [rsp+68h+var_48], r9
call _malloc
mov [rsp+68h+var_68], ebx
shl rbx, 3
mov rdi, rbx; size
mov r14, rax
call _malloc
mov esi, [rsp+68h+var_68]
mov rbp, rax
add rbx, rax
mov r15, rax
test esi, esi
jle loc_1750
nop dword ptr [rax+rax+00h]
loc_15F8:
mov edi, 8; size
add r15, 8
call _malloc
mov [r15-8], rax
cmp r15, rbx
jnz short loc_15F8
mov ecx, [rsp+68h+var_64]
test ecx, ecx
jz loc_1778
test r12d, r12d
jz loc_1778
mov rdi, [rsp+68h+var_60]
mov r9d, [r13+0]
xor ecx, ecx
xor r15d, r15d
mov qword ptr [r14+4], 0
mov r8d, 1
mov r11d, 1
xor ebx, ebx
mov eax, [rdi]
mov [rsp+68h+var_3C], r9d
add eax, r9d
mov [r14], eax
mov rax, rdi
mov edi, r12d
mov r12d, ecx
mov rcx, rbp
mov rbp, r13
mov r13, r8
mov r8d, edi
nop word ptr [rax+rax+00h]
loc_1670:
movsxd rdx, r12d
movsxd r9, r15d
movd xmm0, dword ptr [rax+rdx*4]
movd xmm2, dword ptr [rbp+r9*4+0]
lea rsi, ds:0[rdx*4]
lea rdx, ds:0[r9*4]
mov r9, [rcx+r13*8-8]
movdqa xmm1, xmm0
punpckldq xmm1, xmm2
movq qword ptr [r9], xmm1
lea r9d, [r15+1]
cmp r9d, r8d
jl loc_17A0
loc_16B1:
test r15d, r15d
jnz short loc_16C7
mov edi, [rsp+68h+var_64]
add r12d, 1
cmp r12d, edi
jl loc_1830
loc_16C7:
test ebx, ebx
setnz dl
cmp [rsp+68h+var_68], r13d
jle loc_18C0
loc_16D6:
test dl, dl
jz loc_18C0
mov r12d, [r14+4]
mov r15d, [r14+8]
xor esi, esi
cmp ebx, 1
jz short loc_1739
movsxd rdx, ebx
mov rdi, r14
mov [rsp+68h+var_40], r8d
lea rdx, [rdx+rdx*2]
mov [rsp+68h+var_50], rax
lea rdx, [r14+rdx*4]
mov [rsp+68h+var_58], rcx
mov rsi, [rdx-0Ch]
mov [r14], rsi
mov edx, [rdx-4]
lea esi, [rbx-1]
mov dword ptr [rsp+68h+var_60], esi
mov [r14+8], edx
xor edx, edx
call heapify
mov r8d, [rsp+68h+var_40]
mov rax, [rsp+68h+var_50]
mov rcx, [rsp+68h+var_58]
mov esi, dword ptr [rsp+68h+var_60]
loc_1739:
mov r11d, ebx
add r13, 1
mov ebx, esi
jmp loc_1670
loc_1750:
mov edx, [rsp+68h+var_68]
test r12d, r12d
setz al
test edx, edx
setz dl
or al, dl
jnz short loc_1778
mov eax, [rsp+68h+var_64]
xor r8d, r8d
test eax, eax
jnz loc_18C6
nop dword ptr [rax+00000000h]
loc_1778:
mov rax, [rsp+68h+var_48]
mov rdi, r14; ptr
mov dword ptr [rax], 0
call _free
loc_178B:
add rsp, 38h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_17A0:
movd edi, xmm0
add edi, [rbp+rdx+4]
movsxd rdx, ebx
lea r10, [rdx+rdx*2]
lea r10, [r14+r10*4]
mov [r10], edi
mov [r10+4], r12d
mov [r10+8], r9d
test ebx, ebx
jz short loc_1820
mov [rsp+68h+var_60], rsi
mov [rsp+68h+var_58], rax
jmp short loc_17F1
loc_17D0:
mov rax, [rdx]
mov r10, [rsi]
mov edi, [rsi+8]
mov [rsi], rax
mov eax, [rdx+8]
mov [rsi+8], eax
mov [rdx], r10
mov [rdx+8], edi
test ebx, ebx
jz short loc_1816
mov edi, [rsi]
mov rdx, r9
loc_17F1:
sub ebx, 1
lea rdx, [rdx+rdx*2]
mov esi, ebx
lea rdx, [r14+rdx*4]
shr esi, 1Fh
add esi, ebx
mov ebx, esi
sar ebx, 1
movsxd r9, ebx
lea rsi, [r9+r9*2]
lea rsi, [r14+rsi*4]
cmp [rsi], edi
jg short loc_17D0
loc_1816:
mov rsi, [rsp+68h+var_60]
mov rax, [rsp+68h+var_58]
loc_1820:
mov ebx, r11d
jmp loc_16B1
loc_1830:
movsxd rdx, ebx
mov r9d, [rsp+68h+var_3C]
add r9d, [rax+rsi+4]
lea edi, [rbx+1]
lea rsi, [rdx+rdx*2]
lea rsi, [r14+rsi*4]
mov [rsi], r9d
mov [rsi+4], r12d
mov dword ptr [rsi+8], 0
test ebx, ebx
jnz short loc_1886
jmp short loc_18AC
loc_1860:
mov r12, [rdx]
mov r11, [rsi]
mov r9d, [rsi+8]
mov [rsi], r12
mov r12d, [rdx+8]
mov [rsi+8], r12d
mov [rdx], r11
mov [rdx+8], r9d
test ebx, ebx
jz short loc_18AC
mov r9d, [rsi]
mov rdx, r10
loc_1886:
sub ebx, 1
lea rdx, [rdx+rdx*2]
mov esi, ebx
lea rdx, [r14+rdx*4]
shr esi, 1Fh
add esi, ebx
mov ebx, esi
sar ebx, 1
movsxd r10, ebx
lea rsi, [r10+r10*2]
lea rsi, [r14+rsi*4]
cmp [rsi], r9d
jg short loc_1860
loc_18AC:
mov ebx, edi
mov edx, 1
cmp [rsp+68h+var_68], r13d
jg loc_16D6
nop dword ptr [rax]
loc_18C0:
mov r8, r13
mov rbp, rcx
loc_18C6:
mov rax, [rsp+68h+var_48]
mov rdi, r14; ptr
mov [rax], r8d
call _free
jmp loc_178B | char * func0(_DWORD *a1, int a2, _DWORD *a3, int a4, int a5, _DWORD *a6)
{
size_t v8; // rbx
_DWORD *v9; // r14
char *v10; // rbp
char *v11; // rbx
char *v12; // r15
int v13; // r9d
int v14; // r15d
int v15; // r11d
int v16; // ebx
_DWORD *v17; // rax
int v18; // edi
int v19; // r12d
char *v20; // rcx
_DWORD *v21; // rbp
long long v22; // r13
int v23; // r8d
__m128i v24; // xmm0
long long v25; // rsi
int v26; // r12d
bool v27; // dl
int v28; // esi
_DWORD *v29; // rdx
int v30; // r8d
int v32; // edi
long long v33; // rdx
int *v34; // r10
long long v35; // r10
int v36; // edi
_DWORD *v37; // rdx
int *v38; // rsi
long long v39; // rdx
int v40; // r9d
int v41; // edi
_DWORD *v42; // rsi
long long v43; // r11
int v44; // r9d
_DWORD *v45; // rdx
_DWORD *v46; // rsi
char *v49; // [rsp+10h] [rbp-58h]
_DWORD *v50; // [rsp+18h] [rbp-50h]
int v52; // [rsp+28h] [rbp-40h]
int v53; // [rsp+2Ch] [rbp-3Ch]
v8 = 8LL * a5;
v9 = malloc(12LL * a4 * a2);
v10 = (char *)malloc(v8);
v11 = &v10[v8];
v12 = v10;
if ( a5 <= 0 )
{
if ( a5 != 0 && a4 != 0 )
{
v30 = 0;
if ( a2 )
{
LABEL_32:
*a6 = v30;
free(v9);
return v10;
}
}
}
else
{
do
{
v12 += 8;
*((_QWORD *)v12 - 1) = malloc(8uLL);
}
while ( v12 != v11 );
if ( a2 && a4 )
{
v13 = *a3;
v14 = 0;
*(_QWORD *)(v9 + 1) = 0LL;
v15 = 1;
v16 = 0;
v53 = v13;
*v9 = v13 + *a1;
v17 = a1;
v18 = a4;
v19 = 0;
v20 = v10;
v21 = a3;
v22 = 1LL;
v23 = v18;
while ( 1 )
{
v24 = _mm_cvtsi32_si128(v17[v19]);
v25 = v19;
**(_QWORD **)&v20[8 * v22 - 8] = _mm_unpacklo_epi32(v24, _mm_cvtsi32_si128(v21[v14])).m128i_u64[0];
if ( v14 + 1 < v23 )
{
v32 = v21[v14 + 1] + _mm_cvtsi128_si32(v24);
v33 = v16;
v34 = &v9[3 * v16];
*v34 = v32;
v34[1] = v19;
v34[2] = v14 + 1;
if ( v16 )
{
while ( 1 )
{
v37 = &v9[3 * v33];
v16 = (v16 - 1) / 2;
v38 = &v9[3 * v16];
if ( *v38 <= v32 )
break;
v35 = *(_QWORD *)v38;
v36 = v38[2];
*(_QWORD *)v38 = *(_QWORD *)v37;
v38[2] = v37[2];
*(_QWORD *)v37 = v35;
v37[2] = v36;
if ( !v16 )
break;
v32 = *v38;
v33 = v16;
}
v25 = v19;
}
v16 = v15;
}
if ( v14 || (v26 = v19 + 1, v26 >= a2) )
{
v27 = v16 != 0;
if ( a5 <= (int)v22 )
goto LABEL_31;
}
else
{
v39 = v16;
v40 = v17[v25 + 1] + v53;
v41 = v16 + 1;
v42 = &v9[3 * v16];
*v42 = v40;
v42[1] = v26;
v42[2] = 0;
if ( v16 )
{
while ( 1 )
{
v45 = &v9[3 * v39];
v16 = (v16 - 1) / 2;
v46 = &v9[3 * v16];
if ( *v46 <= v40 )
break;
v43 = *(_QWORD *)v46;
v44 = v46[2];
*(_QWORD *)v46 = *(_QWORD *)v45;
v46[2] = v45[2];
*(_QWORD *)v45 = v43;
v45[2] = v44;
if ( !v16 )
break;
v40 = *v46;
v39 = v16;
}
}
v16 = v41;
v27 = 1;
if ( a5 <= (int)v22 )
{
LABEL_31:
v30 = v22;
v10 = v20;
goto LABEL_32;
}
}
if ( !v27 )
goto LABEL_31;
v19 = v9[1];
v14 = v9[2];
v28 = 0;
if ( v16 != 1 )
{
v52 = v23;
v50 = v17;
v29 = &v9[3 * v16];
v49 = v20;
*(_QWORD *)v9 = *(_QWORD *)(v29 - 3);
v9[2] = *(v29 - 1);
heapify(v9, (unsigned int)(v16 - 1), 0LL);
v23 = v52;
v17 = v50;
v20 = v49;
v28 = v16 - 1;
}
v15 = v16;
++v22;
v16 = v28;
}
}
}
*a6 = 0;
free(v9);
return v10;
} | func0:
ENDBR64
MOV EAX,ESI
PUSH R15
IMUL EAX,ECX
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12D,ECX
PUSH RBP
CDQE
PUSH RBX
MOVSXD RBX,R8D
SUB RSP,0x38
MOV qword ptr [RSP + 0x8],RDI
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
MOV dword ptr [RSP + 0x4],ESI
MOV qword ptr [RSP + 0x20],R9
CALL 0x001010b0
MOV dword ptr [RSP],EBX
SHL RBX,0x3
MOV RDI,RBX
MOV R14,RAX
CALL 0x001010b0
MOV ESI,dword ptr [RSP]
MOV RBP,RAX
ADD RBX,RAX
MOV R15,RAX
TEST ESI,ESI
JLE 0x00101750
NOP dword ptr [RAX + RAX*0x1]
LAB_001015f8:
MOV EDI,0x8
ADD R15,0x8
CALL 0x001010b0
MOV qword ptr [R15 + -0x8],RAX
CMP R15,RBX
JNZ 0x001015f8
MOV ECX,dword ptr [RSP + 0x4]
TEST ECX,ECX
JZ 0x00101778
TEST R12D,R12D
JZ 0x00101778
MOV RDI,qword ptr [RSP + 0x8]
MOV R9D,dword ptr [R13]
XOR ECX,ECX
XOR R15D,R15D
MOV qword ptr [R14 + 0x4],0x0
MOV R8D,0x1
MOV R11D,0x1
XOR EBX,EBX
MOV EAX,dword ptr [RDI]
MOV dword ptr [RSP + 0x2c],R9D
ADD EAX,R9D
MOV dword ptr [R14],EAX
MOV RAX,RDI
MOV EDI,R12D
MOV R12D,ECX
MOV RCX,RBP
MOV RBP,R13
MOV R13,R8
MOV R8D,EDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101670:
MOVSXD RDX,R12D
MOVSXD R9,R15D
MOVD XMM0,dword ptr [RAX + RDX*0x4]
MOVD XMM2,dword ptr [RBP + R9*0x4]
LEA RSI,[RDX*0x4]
LEA RDX,[R9*0x4]
MOV R9,qword ptr [RCX + R13*0x8 + -0x8]
MOVDQA XMM1,XMM0
PUNPCKLDQ XMM1,XMM2
MOVQ qword ptr [R9],XMM1
LEA R9D,[R15 + 0x1]
CMP R9D,R8D
JL 0x001017a0
LAB_001016b1:
TEST R15D,R15D
JNZ 0x001016c7
MOV EDI,dword ptr [RSP + 0x4]
ADD R12D,0x1
CMP R12D,EDI
JL 0x00101830
LAB_001016c7:
TEST EBX,EBX
SETNZ DL
CMP dword ptr [RSP],R13D
JLE 0x001018c0
LAB_001016d6:
TEST DL,DL
JZ 0x001018c0
MOV R12D,dword ptr [R14 + 0x4]
MOV R15D,dword ptr [R14 + 0x8]
XOR ESI,ESI
CMP EBX,0x1
JZ 0x00101739
MOVSXD RDX,EBX
MOV RDI,R14
MOV dword ptr [RSP + 0x28],R8D
LEA RDX,[RDX + RDX*0x2]
MOV qword ptr [RSP + 0x18],RAX
LEA RDX,[R14 + RDX*0x4]
MOV qword ptr [RSP + 0x10],RCX
MOV RSI,qword ptr [RDX + -0xc]
MOV qword ptr [R14],RSI
MOV EDX,dword ptr [RDX + -0x4]
LEA ESI,[RBX + -0x1]
MOV dword ptr [RSP + 0x8],ESI
MOV dword ptr [R14 + 0x8],EDX
XOR EDX,EDX
CALL 0x001013b0
MOV R8D,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x8]
LAB_00101739:
MOV R11D,EBX
ADD R13,0x1
MOV EBX,ESI
JMP 0x00101670
LAB_00101750:
MOV EDX,dword ptr [RSP]
TEST R12D,R12D
SETZ AL
TEST EDX,EDX
SETZ DL
OR AL,DL
JNZ 0x00101778
MOV EAX,dword ptr [RSP + 0x4]
XOR R8D,R8D
TEST EAX,EAX
JNZ 0x001018c6
NOP dword ptr [RAX]
LAB_00101778:
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,R14
MOV dword ptr [RAX],0x0
CALL 0x00101080
LAB_0010178b:
ADD RSP,0x38
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001017a0:
MOVD EDI,XMM0
ADD EDI,dword ptr [RBP + RDX*0x1 + 0x4]
MOVSXD RDX,EBX
LEA R10,[RDX + RDX*0x2]
LEA R10,[R14 + R10*0x4]
MOV dword ptr [R10],EDI
MOV dword ptr [R10 + 0x4],R12D
MOV dword ptr [R10 + 0x8],R9D
TEST EBX,EBX
JZ 0x00101820
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001017f1
LAB_001017d0:
MOV RAX,qword ptr [RDX]
MOV R10,qword ptr [RSI]
MOV EDI,dword ptr [RSI + 0x8]
MOV qword ptr [RSI],RAX
MOV EAX,dword ptr [RDX + 0x8]
MOV dword ptr [RSI + 0x8],EAX
MOV qword ptr [RDX],R10
MOV dword ptr [RDX + 0x8],EDI
TEST EBX,EBX
JZ 0x00101816
MOV EDI,dword ptr [RSI]
MOV RDX,R9
LAB_001017f1:
SUB EBX,0x1
LEA RDX,[RDX + RDX*0x2]
MOV ESI,EBX
LEA RDX,[R14 + RDX*0x4]
SHR ESI,0x1f
ADD ESI,EBX
MOV EBX,ESI
SAR EBX,0x1
MOVSXD R9,EBX
LEA RSI,[R9 + R9*0x2]
LEA RSI,[R14 + RSI*0x4]
CMP dword ptr [RSI],EDI
JG 0x001017d0
LAB_00101816:
MOV RSI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
LAB_00101820:
MOV EBX,R11D
JMP 0x001016b1
LAB_00101830:
MOVSXD RDX,EBX
MOV R9D,dword ptr [RSP + 0x2c]
ADD R9D,dword ptr [RAX + RSI*0x1 + 0x4]
LEA EDI,[RBX + 0x1]
LEA RSI,[RDX + RDX*0x2]
LEA RSI,[R14 + RSI*0x4]
MOV dword ptr [RSI],R9D
MOV dword ptr [RSI + 0x4],R12D
MOV dword ptr [RSI + 0x8],0x0
TEST EBX,EBX
JNZ 0x00101886
JMP 0x001018ac
LAB_00101860:
MOV R12,qword ptr [RDX]
MOV R11,qword ptr [RSI]
MOV R9D,dword ptr [RSI + 0x8]
MOV qword ptr [RSI],R12
MOV R12D,dword ptr [RDX + 0x8]
MOV dword ptr [RSI + 0x8],R12D
MOV qword ptr [RDX],R11
MOV dword ptr [RDX + 0x8],R9D
TEST EBX,EBX
JZ 0x001018ac
MOV R9D,dword ptr [RSI]
MOV RDX,R10
LAB_00101886:
SUB EBX,0x1
LEA RDX,[RDX + RDX*0x2]
MOV ESI,EBX
LEA RDX,[R14 + RDX*0x4]
SHR ESI,0x1f
ADD ESI,EBX
MOV EBX,ESI
SAR EBX,0x1
MOVSXD R10,EBX
LEA RSI,[R10 + R10*0x2]
LEA RSI,[R14 + RSI*0x4]
CMP dword ptr [RSI],R9D
JG 0x00101860
LAB_001018ac:
MOV EBX,EDI
MOV EDX,0x1
CMP dword ptr [RSP],R13D
JG 0x001016d6
NOP dword ptr [RAX]
LAB_001018c0:
MOV R8,R13
MOV RBP,RCX
LAB_001018c6:
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,R14
MOV dword ptr [RAX],R8D
CALL 0x00101080
JMP 0x0010178b | int8 *
func0(int *param_1,int param_2,int *param_3,int param_4,int param_5,int4 *param_6)
{
int *piVar1;
int *piVar2;
int iVar3;
int8 uVar4;
int *__ptr;
int8 *puVar5;
void *pvVar6;
int iVar7;
long lVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
long lVar13;
int iVar14;
int8 *puVar15;
int8 *puVar16;
bool bVar17;
__ptr = (int *)malloc((long)(param_2 * param_4) * 0xc);
puVar5 = (int8 *)malloc((long)param_5 * 8);
puVar15 = puVar5;
if (param_5 < 1) {
if ((param_4 != 0 && param_5 != 0) && (lVar13 = 0, param_2 != 0)) {
LAB_001018c6:
*param_6 = (int)lVar13;
free(__ptr);
return puVar5;
}
}
else {
do {
puVar16 = puVar15 + 1;
pvVar6 = malloc(8);
*puVar15 = pvVar6;
puVar15 = puVar16;
} while (puVar16 != puVar5 + param_5);
if ((param_2 != 0) && (param_4 != 0)) {
iVar3 = *param_3;
iVar7 = 0;
iVar14 = 0;
__ptr[1] = 0;
__ptr[2] = 0;
iVar12 = 1;
iVar11 = 0;
*__ptr = *param_1 + iVar3;
lVar13 = 1;
do {
iVar10 = param_1[iVar7];
*(ulong *)puVar5[lVar13 + -1] = CONCAT44(param_3[iVar14],iVar10);
iVar9 = iVar11;
if (iVar14 + 1 < param_4) {
iVar10 = iVar10 + param_3[(long)iVar14 + 1];
lVar8 = (long)iVar11;
piVar1 = __ptr + lVar8 * 3;
*piVar1 = iVar10;
piVar1[1] = iVar7;
piVar1[2] = iVar14 + 1;
iVar9 = iVar12;
if (iVar11 != 0) {
while( true ) {
piVar1 = __ptr + lVar8 * 3;
iVar11 = (iVar11 + -1) / 2;
lVar8 = (long)iVar11;
piVar2 = __ptr + lVar8 * 3;
if (*piVar2 <= iVar10) break;
uVar4 = *(int8 *)piVar2;
iVar12 = piVar2[2];
*(int8 *)piVar2 = *(int8 *)piVar1;
piVar2[2] = piVar1[2];
*(int8 *)piVar1 = uVar4;
piVar1[2] = iVar12;
if (iVar11 == 0) break;
iVar10 = *piVar2;
}
}
}
if ((iVar14 == 0) && (iVar7 + 1 < param_2)) {
lVar8 = (long)iVar9;
iVar11 = iVar3 + param_1[(long)iVar7 + 1];
iVar12 = iVar9 + 1;
piVar1 = __ptr + lVar8 * 3;
*piVar1 = iVar11;
piVar1[1] = iVar7 + 1;
piVar1[2] = 0;
if (iVar9 != 0) {
while( true ) {
piVar1 = __ptr + lVar8 * 3;
iVar9 = (iVar9 + -1) / 2;
lVar8 = (long)iVar9;
piVar2 = __ptr + lVar8 * 3;
if (*piVar2 <= iVar11) break;
uVar4 = *(int8 *)piVar2;
iVar11 = piVar2[2];
*(int8 *)piVar2 = *(int8 *)piVar1;
piVar2[2] = piVar1[2];
*(int8 *)piVar1 = uVar4;
piVar1[2] = iVar11;
if (iVar9 == 0) break;
iVar11 = *piVar2;
}
}
bVar17 = true;
}
else {
bVar17 = iVar9 != 0;
iVar12 = iVar9;
}
if ((param_5 <= (int)lVar13) || (!bVar17)) goto LAB_001018c6;
iVar7 = __ptr[1];
iVar14 = __ptr[2];
iVar11 = 0;
if (iVar12 != 1) {
*(int8 *)__ptr = *(int8 *)(__ptr + (long)iVar12 * 3 + -3);
iVar11 = iVar12 + -1;
__ptr[2] = __ptr[(long)iVar12 * 3 + -1];
heapify(__ptr,iVar11,0);
}
lVar13 = lVar13 + 1;
} while( true );
}
}
*param_6 = 0;
free(__ptr);
return puVar5;
} |
5,528 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov 0x4(%rax),%eax
imul %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0xc(%rbp)
sub %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 11ed <func0+0x84>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
imul %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0x4(%rbp)
sub %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0xc(%rbp),%eax
jge 11e9 <func0+0x80>
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119e <func0+0x35>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov edx, [rax]
mov rax, [rbp+var_18]
mov eax, [rax+4]
imul eax, edx
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_C], eax
mov [rbp+var_8], 1
jmp short loc_11E7
loc_119B:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax+4]
imul eax, edx
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_C]
jge short loc_11E3
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
loc_11E3:
add [rbp+var_8], 1
loc_11E7:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_119B
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // eax
int v3; // eax
int v5; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
v2 = *a1 * a1[1];
if ( v2 <= 0 )
v2 = -(*a1 * a1[1]);
v5 = v2;
for ( i = 1; i < a2; ++i )
{
v3 = a1[2 * i] * a1[2 * i + 1];
if ( v3 <= 0 )
v3 = -v3;
if ( v3 < v5 )
v5 = v3;
}
return (unsigned int)v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
IMUL EAX,EDX
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x1
JMP 0x001011e7
LAB_0010119b:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
IMUL EAX,EDX
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0xc]
JGE 0x001011e3
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011e3:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011e7:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119b
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int local_14;
int local_10;
local_14 = param_1[1] * *param_1;
if (local_14 < 1) {
local_14 = -local_14;
}
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = param_1[(long)local_10 * 2 + 1] * param_1[(long)local_10 * 2];
if (iVar1 < 1) {
iVar1 = -iVar1;
}
if (iVar1 < local_14) {
local_14 = iVar1;
}
}
return local_14;
} |
5,529 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp $0x1,%esi
jle 11a6 <func0+0x3d>
lea 0x8(%rdi),%rcx
lea -0x2(%rsi),%edx
lea 0x10(%rdi,%rdx,8),%rdi
mov (%rcx),%edx
imul 0x4(%rcx),%edx
mov %edx,%esi
sar $0x1f,%esi
xor %esi,%edx
sub %esi,%edx
cmp %edx,%eax
cmovg %edx,%eax
add $0x8,%rcx
cmp %rdi,%rcx
jne 1189 <func0+0x20>
retq
| func0:
endbr64
mov eax, [rdi]
imul eax, [rdi+4]
mov r8d, eax
neg r8d
cmovs r8d, eax
cmp esi, 1
jle short loc_11AB
lea rdx, [rdi+8]
lea eax, [rsi-2]
lea rsi, [rdi+rax*8+10h]
loc_118E:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp r8d, eax
cmovg r8d, eax
add rdx, 8
cmp rdx, rsi
jnz short loc_118E
loc_11AB:
mov eax, r8d
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
_DWORD *v3; // rdx
long long v4; // rsi
int v5; // eax
v2 = -(a1[1] * *a1);
if ( a1[1] * *a1 > 0 )
v2 = a1[1] * *a1;
if ( a2 > 1 )
{
v3 = a1 + 2;
v4 = (long long)&a1[2 * (a2 - 2) + 4];
do
{
v5 = v3[1] * *v3;
if ( v5 <= 0 )
v5 = -(v3[1] * *v3);
if ( v2 > v5 )
v2 = v5;
v3 += 2;
}
while ( v3 != (_DWORD *)v4 );
}
return (unsigned int)v2;
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
CMP ESI,0x1
JLE 0x001011ab
LEA RDX,[RDI + 0x8]
LEA EAX,[RSI + -0x2]
LEA RSI,[RDI + RAX*0x8 + 0x10]
LAB_0010118e:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP R8D,EAX
CMOVG R8D,EAX
ADD RDX,0x8
CMP RDX,RSI
JNZ 0x0010118e
LAB_001011ab:
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
iVar1 = *param_1 * param_1[1];
iVar3 = -iVar1;
if (0 < iVar1) {
iVar3 = iVar1;
}
if (1 < param_2) {
piVar2 = param_1 + 2;
do {
iVar1 = *piVar2 * piVar2[1];
if (iVar1 < 1) {
iVar1 = -iVar1;
}
if (iVar1 < iVar3) {
iVar3 = iVar1;
}
piVar2 = piVar2 + 2;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) * 2 + 4);
}
return iVar3;
} |
5,530 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp $0x1,%esi
jle 117d <func0+0x3d>
lea -0x2(%rsi),%edx
lea 0x8(%rdi),%rcx
lea 0x10(%rdi,%rdx,8),%rdi
mov (%rcx),%edx
imul 0x4(%rcx),%edx
mov %edx,%esi
sar $0x1f,%esi
xor %esi,%edx
sub %esi,%edx
cmp %edx,%eax
cmovg %edx,%eax
add $0x8,%rcx
cmp %rdi,%rcx
jne 1160 <func0+0x20>
retq
xchg %ax,%ax
| func0:
endbr64
mov eax, [rdi]
imul eax, [rdi+4]
mov r8d, eax
neg r8d
cmovs r8d, eax
cmp esi, 1
jle short loc_1325
lea eax, [rsi-2]
lea rdx, [rdi+8]
lea rsi, [rdi+rax*8+10h]
nop dword ptr [rax]
loc_1308:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp r8d, eax
cmovg r8d, eax
add rdx, 8
cmp rdx, rsi
jnz short loc_1308
loc_1325:
mov eax, r8d
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
_DWORD *v3; // rdx
long long v4; // rsi
int v5; // eax
v2 = -(a1[1] * *a1);
if ( a1[1] * *a1 > 0 )
v2 = a1[1] * *a1;
if ( a2 > 1 )
{
v3 = a1 + 2;
v4 = (long long)&a1[2 * (a2 - 2) + 4];
do
{
v5 = v3[1] * *v3;
if ( v5 <= 0 )
v5 = -(v3[1] * *v3);
if ( v2 > v5 )
v2 = v5;
v3 += 2;
}
while ( v3 != (_DWORD *)v4 );
}
return (unsigned int)v2;
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
CMP ESI,0x1
JLE 0x00101325
LEA EAX,[RSI + -0x2]
LEA RDX,[RDI + 0x8]
LEA RSI,[RDI + RAX*0x8 + 0x10]
NOP dword ptr [RAX]
LAB_00101308:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP R8D,EAX
CMOVG R8D,EAX
ADD RDX,0x8
CMP RDX,RSI
JNZ 0x00101308
LAB_00101325:
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
iVar1 = *param_1 * param_1[1];
iVar3 = -iVar1;
if (0 < iVar1) {
iVar3 = iVar1;
}
if (1 < param_2) {
piVar2 = param_1 + 2;
do {
iVar1 = *piVar2 * piVar2[1];
if (iVar1 < 1) {
iVar1 = -iVar1;
}
if (iVar1 < iVar3) {
iVar3 = iVar1;
}
piVar2 = piVar2 + 2;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) * 2 + 4);
}
return iVar3;
} |
5,531 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp $0x1,%esi
jle 12a1 <func0+0x161>
lea -0x2(%rsi),%edx
lea -0x1(%rsi),%r8d
cmp $0x2,%edx
jbe 12a9 <func0+0x169>
mov %r8d,%edx
movd %eax,%xmm6
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm6,%xmm3
shl $0x5,%rdx
add %rdi,%rdx
nopl 0x0(%rax)
movdqu 0x8(%rax),%xmm2
movdqu 0x18(%rax),%xmm4
add $0x20,%rax
movdqa %xmm2,%xmm1
shufps $0xdd,%xmm4,%xmm2
shufps $0x88,%xmm4,%xmm1
movdqa %xmm1,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm2,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrad $0x1f,%xmm1
pxor %xmm1,%xmm0
psubd %xmm1,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm3
pandn %xmm0,%xmm1
por %xmm1,%xmm3
cmp %rdx,%rax
jne 1188 <func0+0x48>
movdqa %xmm3,%xmm1
mov %r8d,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
movdqa %xmm1,%xmm0
lea 0x1(%rdx),%ecx
pcmpgtd %xmm3,%xmm0
pand %xmm0,%xmm3
pandn %xmm1,%xmm0
por %xmm0,%xmm3
movdqa %xmm3,%xmm1
psrldq $0x4,%xmm1
movdqa %xmm1,%xmm0
pcmpgtd %xmm3,%xmm0
pand %xmm0,%xmm3
pandn %xmm1,%xmm0
por %xmm0,%xmm3
movd %xmm3,%eax
cmp %edx,%r8d
je 12a8 <func0+0x168>
movslq %ecx,%r8
mov (%rdi,%r8,8),%edx
imul 0x4(%rdi,%r8,8),%edx
mov %edx,%r8d
sar $0x1f,%r8d
xor %r8d,%edx
sub %r8d,%edx
cmp %edx,%eax
cmovg %edx,%eax
lea 0x1(%rcx),%edx
cmp %edx,%esi
jle 12a1 <func0+0x161>
movslq %edx,%r8
mov (%rdi,%r8,8),%edx
imul 0x4(%rdi,%r8,8),%edx
mov %edx,%r8d
sar $0x1f,%r8d
xor %r8d,%edx
sub %r8d,%edx
cmp %edx,%eax
cmovg %edx,%eax
add $0x2,%ecx
cmp %ecx,%esi
jle 12a1 <func0+0x161>
movslq %ecx,%rcx
mov 0x4(%rdi,%rcx,8),%edx
imul (%rdi,%rcx,8),%edx
mov %edx,%ecx
sar $0x1f,%ecx
xor %ecx,%edx
sub %ecx,%edx
cmp %edx,%eax
cmovg %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
retq
mov $0x1,%ecx
jmp 123c <func0+0xfc>
| func0:
endbr64
mov rcx, rdi
mov edi, esi
mov edx, [rcx]
imul edx, [rcx+4]
mov eax, edx
neg eax
cmovs eax, edx
cmp esi, 1
jle locret_12A5
lea edx, [rdi-2]
lea esi, [rsi-1]
cmp edx, 2
jbe loc_12A6
mov edx, esi
movd xmm6, eax
mov rax, rcx
shr edx, 2
pshufd xmm3, xmm6, 0
shl rdx, 5
add rdx, rcx
nop word ptr [rax+rax+00000000h]
loc_1190:
movdqu xmm2, xmmword ptr [rax+8]
movdqu xmm4, xmmword ptr [rax+18h]
add rax, 20h ; ' '
movdqa xmm1, xmm2
shufps xmm2, xmm4, 0DDh
shufps xmm1, xmm4, 88h
movdqa xmm0, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm2
psrlq xmm2, 20h ; ' '
pmuludq xmm1, xmm2
pshufd xmm0, xmm0, 8
pshufd xmm1, xmm1, 8
punpckldq xmm0, xmm1
movdqa xmm1, xmm0
psrad xmm1, 1Fh
pxor xmm0, xmm1
psubd xmm0, xmm1
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm3
pand xmm3, xmm1
pandn xmm1, xmm0
por xmm3, xmm1
cmp rax, rdx
jnz short loc_1190
movdqa xmm1, xmm3
psrldq xmm1, 8
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm3
pand xmm3, xmm0
pandn xmm0, xmm1
por xmm0, xmm3
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movd eax, xmm1
test sil, 3
jz short locret_12A5
and esi, 0FFFFFFFCh
add esi, 1
loc_1242:
movsxd r8, esi
shl r8, 3
lea r9, [rcx+r8]
mov edx, [r9]
imul edx, [r9+4]
mov r9d, edx
neg r9d
cmovns edx, r9d
cmp eax, edx
cmovg eax, edx
lea edx, [rsi+1]
cmp edi, edx
jle short locret_12A5
lea r9, [rcx+r8+8]
mov edx, [r9]
imul edx, [r9+4]
mov r9d, edx
neg r9d
cmovns edx, r9d
cmp eax, edx
cmovg eax, edx
add esi, 2
cmp edi, esi
jle short locret_12A5
lea rcx, [rcx+r8+10h]
mov edx, [rcx+4]
imul edx, [rcx]
mov ecx, edx
neg ecx
cmovns edx, ecx
cmp eax, edx
cmovg eax, edx
locret_12A5:
retn
loc_12A6:
mov esi, 1
jmp short loc_1242 | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
unsigned int v5; // esi
__m128i v6; // xmm6
_DWORD *v7; // rax
__m128i v8; // xmm3
__m128 v9; // xmm2
__m128 v10; // xmm4
__m128 v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm1
__m128i v16; // xmm0
__m128i v17; // xmm1
__m128i v18; // xmm1
__m128i v19; // xmm0
__m128i v20; // xmm0
__m128i v21; // xmm2
__m128i v22; // xmm1
signed int v23; // esi
long long v24; // r8
int v25; // edx
int v26; // edx
int v27; // edx
result = (unsigned int)-(a1[1] * *a1);
if ( a1[1] * *a1 > 0 )
result = (unsigned int)(a1[1] * *a1);
if ( a2 > 1 )
{
v5 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v23 = 1;
}
else
{
v6 = _mm_cvtsi32_si128(result);
v7 = a1;
v8 = _mm_shuffle_epi32(v6, 0);
do
{
v9 = (__m128)_mm_loadu_si128((const __m128i *)(v7 + 2));
v10 = (__m128)_mm_loadu_si128((const __m128i *)(v7 + 6));
v7 += 8;
v11 = v9;
v12 = (__m128i)_mm_shuffle_ps(v9, v10, 221);
v13 = (__m128i)_mm_shuffle_ps(v11, v10, 136);
v14 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v13, v12), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v13, 0x20u), _mm_srli_epi64(v12, 0x20u)), 8));
v15 = _mm_srai_epi32(v14, 0x1Fu);
v16 = _mm_sub_epi32(_mm_xor_si128(v14, v15), v15);
v17 = _mm_cmpgt_epi32(v16, v8);
v8 = _mm_or_si128(_mm_and_si128(v8, v17), _mm_andnot_si128(v17, v16));
}
while ( v7 != &a1[8 * (v5 >> 2)] );
v18 = _mm_srli_si128(v8, 8);
v19 = _mm_cmpgt_epi32(v18, v8);
v20 = _mm_or_si128(_mm_andnot_si128(v19, v18), _mm_and_si128(v8, v19));
v21 = _mm_srli_si128(v20, 4);
v22 = _mm_cmpgt_epi32(v21, v20);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v22, v21), _mm_and_si128(v20, v22)));
if ( (v5 & 3) == 0 )
return result;
v23 = (v5 & 0xFFFFFFFC) + 1;
}
v24 = 2LL * v23;
v25 = a1[v24 + 1] * a1[v24];
if ( v25 <= 0 )
v25 = -(a1[2 * v23 + 1] * a1[2 * v23]);
if ( (int)result > v25 )
result = (unsigned int)v25;
if ( a2 > v23 + 1 )
{
v26 = a1[v24 + 3] * a1[v24 + 2];
if ( v26 <= 0 )
v26 = -(a1[v24 + 3] * a1[v24 + 2]);
if ( (int)result > v26 )
result = (unsigned int)v26;
if ( a2 > v23 + 2 )
{
v27 = a1[v24 + 4] * a1[v24 + 5];
if ( v27 <= 0 )
v27 = -v27;
if ( (int)result > v27 )
return (unsigned int)v27;
}
}
}
return result;
} | func0:
ENDBR64
MOV RCX,RDI
MOV EDI,ESI
MOV EDX,dword ptr [RCX]
IMUL EDX,dword ptr [RCX + 0x4]
MOV EAX,EDX
NEG EAX
CMOVS EAX,EDX
CMP ESI,0x1
JLE 0x001012a5
LEA EDX,[RDI + -0x2]
LEA ESI,[RSI + -0x1]
CMP EDX,0x2
JBE 0x001012a6
MOV EDX,ESI
MOVD XMM6,EAX
MOV RAX,RCX
SHR EDX,0x2
PSHUFD XMM3,XMM6,0x0
SHL RDX,0x5
ADD RDX,RCX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101190:
MOVDQU XMM2,xmmword ptr [RAX + 0x8]
MOVDQU XMM4,xmmword ptr [RAX + 0x18]
ADD RAX,0x20
MOVDQA XMM1,XMM2
SHUFPS XMM2,XMM4,0xdd
SHUFPS XMM1,XMM4,0x88
MOVDQA XMM0,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM2
PSRLQ XMM2,0x20
PMULUDQ XMM1,XMM2
PSHUFD XMM0,XMM0,0x8
PSHUFD XMM1,XMM1,0x8
PUNPCKLDQ XMM0,XMM1
MOVDQA XMM1,XMM0
PSRAD XMM1,0x1f
PXOR XMM0,XMM1
PSUBD XMM0,XMM1
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM3
PAND XMM3,XMM1
PANDN XMM1,XMM0
POR XMM3,XMM1
CMP RAX,RDX
JNZ 0x00101190
MOVDQA XMM1,XMM3
PSRLDQ XMM1,0x8
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM3
PAND XMM3,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM3
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVD EAX,XMM1
TEST SIL,0x3
JZ 0x001012a5
AND ESI,0xfffffffc
ADD ESI,0x1
LAB_00101242:
MOVSXD R8,ESI
SHL R8,0x3
LEA R9,[RCX + R8*0x1]
MOV EDX,dword ptr [R9]
IMUL EDX,dword ptr [R9 + 0x4]
MOV R9D,EDX
NEG R9D
CMOVNS EDX,R9D
CMP EAX,EDX
CMOVG EAX,EDX
LEA EDX,[RSI + 0x1]
CMP EDI,EDX
JLE 0x001012a5
LEA R9,[RCX + R8*0x1 + 0x8]
MOV EDX,dword ptr [R9]
IMUL EDX,dword ptr [R9 + 0x4]
MOV R9D,EDX
NEG R9D
CMOVNS EDX,R9D
CMP EAX,EDX
CMOVG EAX,EDX
ADD ESI,0x2
CMP EDI,ESI
JLE 0x001012a5
LEA RCX,[RCX + R8*0x1 + 0x10]
MOV EDX,dword ptr [RCX + 0x4]
IMUL EDX,dword ptr [RCX]
MOV ECX,EDX
NEG ECX
CMOVNS EDX,ECX
CMP EAX,EDX
CMOVG EAX,EDX
LAB_001012a5:
RET
LAB_001012a6:
MOV ESI,0x1
JMP 0x00101242 | uint func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint *puVar6;
int *piVar7;
int *piVar8;
uint uVar9;
int *piVar10;
uint uVar11;
int iVar12;
long lVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
int auVar17 [16];
uint uVar22;
uint uVar23;
int auVar24 [16];
uint uVar25;
uint uVar26;
uVar11 = *param_1 * param_1[1];
uVar9 = -uVar11;
if (0 < (int)uVar11) {
uVar9 = uVar11;
}
if (1 < param_2) {
uVar11 = param_2 - 1;
if (param_2 - 2U < 3) {
iVar12 = 1;
}
else {
piVar10 = param_1;
uVar25 = uVar9;
uVar16 = uVar9;
uVar26 = uVar9;
do {
piVar1 = piVar10 + 2;
piVar3 = piVar10 + 3;
piVar4 = piVar10 + 4;
piVar5 = piVar10 + 5;
piVar2 = piVar10 + 6;
puVar6 = (uint *)(piVar10 + 7);
piVar7 = piVar10 + 8;
piVar8 = piVar10 + 9;
piVar10 = piVar10 + 8;
auVar24._4_4_ = *piVar5;
auVar24._0_4_ = *piVar3;
auVar24._8_4_ = *puVar6;
auVar24._12_4_ = *piVar8;
auVar17._4_4_ = *piVar4;
auVar17._0_4_ = *piVar1;
auVar17._8_4_ = *piVar2;
auVar17._12_4_ = *piVar7;
uVar15 = *piVar1 * *piVar3;
uVar21 = *piVar4 * *piVar5;
uVar19 = (uint)((auVar17._8_8_ & 0xffffffff) * (ulong)*puVar6);
uVar23 = (uint)((auVar17._8_8_ >> 0x20) * (auVar24._8_8_ >> 0x20));
uVar14 = (int)uVar15 >> 0x1f;
uVar18 = (int)uVar21 >> 0x1f;
uVar20 = (int)uVar19 >> 0x1f;
uVar22 = (int)uVar23 >> 0x1f;
uVar14 = (uVar15 ^ uVar14) - uVar14;
uVar18 = (uVar21 ^ uVar18) - uVar18;
uVar20 = (uVar19 ^ uVar20) - uVar20;
uVar22 = (uVar23 ^ uVar22) - uVar22;
uVar15 = -(uint)((int)uVar9 < (int)uVar14);
uVar19 = -(uint)((int)uVar25 < (int)uVar18);
uVar21 = -(uint)((int)uVar16 < (int)uVar20);
uVar23 = -(uint)((int)uVar26 < (int)uVar22);
uVar9 = uVar9 & uVar15 | ~uVar15 & uVar14;
uVar25 = uVar25 & uVar19 | ~uVar19 & uVar18;
uVar16 = uVar16 & uVar21 | ~uVar21 & uVar20;
uVar26 = uVar26 & uVar23 | ~uVar23 & uVar22;
} while (piVar10 != param_1 + (ulong)(uVar11 >> 2) * 8);
uVar9 = ~-(uint)((int)uVar9 < (int)uVar16) & uVar16 |
uVar9 & -(uint)((int)uVar9 < (int)uVar16);
uVar25 = ~-(uint)((int)uVar25 < (int)uVar26) & uVar26 |
uVar25 & -(uint)((int)uVar25 < (int)uVar26);
uVar16 = -(uint)((int)uVar9 < (int)uVar25);
uVar9 = ~uVar16 & uVar25 | uVar9 & uVar16;
if ((uVar11 & 3) == 0) {
return uVar9;
}
iVar12 = (uVar11 & 0xfffffffc) + 1;
}
lVar13 = (long)iVar12;
uVar11 = param_1[lVar13 * 2] * (param_1 + lVar13 * 2)[1];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar11 < (int)uVar9) {
uVar9 = uVar11;
}
if (iVar12 + 1 < param_2) {
uVar11 = param_1[lVar13 * 2 + 2] * (param_1 + lVar13 * 2 + 2)[1];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar11 < (int)uVar9) {
uVar9 = uVar11;
}
if (iVar12 + 2 < param_2) {
uVar11 = (param_1 + lVar13 * 2 + 4)[1] * param_1[lVar13 * 2 + 4];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar11 < (int)uVar9) {
uVar9 = uVar11;
}
}
}
}
return uVar9;
} |
5,532 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}
| int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x7fffffff,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1200 <func0+0x77>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
lea -0x14(%rbp),%rdx
lea 0xe2b(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1090 <__isoc99_sscanf@plt>
test %eax,%eax
je 11fc <func0+0x73>
mov -0x14(%rbp),%eax
cmp %eax,-0x10(%rbp)
jle 11fc <func0+0x73>
mov -0x14(%rbp),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11bb <func0+0x32>
mov -0x10(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 121f <func0+0x96>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_10], 7FFFFFFFh
mov [rbp+var_C], 0
jmp short loc_1203
loc_11BB:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
lea rdx, [rbp+var_14]
lea rcx, unk_2004
mov rsi, rcx
mov rdi, rax
mov eax, 0
call ___isoc99_sscanf
test eax, eax
jz short loc_11FF
mov eax, [rbp+var_14]
cmp [rbp+var_10], eax
jle short loc_11FF
mov eax, [rbp+var_14]
mov [rbp+var_10], eax
loc_11FF:
add [rbp+var_C], 1
loc_1203:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl short loc_11BB
mov eax, [rbp+var_10]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1222
call ___stack_chk_fail
locret_1222:
leave
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h] BYREF
int v4; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
unsigned long long v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( (unsigned int)__isoc99_sscanf(*(_QWORD *)(8LL * i + a1), &unk_2004, &v3) && v4 > v3 )
v4 = v3;
}
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x10],0x7fffffff
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101203
LAB_001011bb:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
LEA RDX,[RBP + -0x14]
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101090
TEST EAX,EAX
JZ 0x001011ff
MOV EAX,dword ptr [RBP + -0x14]
CMP dword ptr [RBP + -0x10],EAX
JLE 0x001011ff
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x10],EAX
LAB_001011ff:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101203:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011bb
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101222
CALL 0x00101070
LAB_00101222:
LEAVE
RET | int func0(long param_1,int param_2)
{
int iVar1;
long in_FS_OFFSET;
int local_1c;
int local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = 0x7fffffff;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
iVar1 = __isoc99_sscanf(*(int8 *)(param_1 + (long)local_14 * 8),&DAT_00102004,&local_1c);
if ((iVar1 != 0) && (local_1c < local_18)) {
local_18 = local_1c;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_18;
} |
5,533 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}
| int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 11f1 <func0+0x68>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r13
mov $0x7fffffff,%ebp
lea 0x4(%rsp),%r12
jmp 11cb <func0+0x42>
add $0x8,%rbx
cmp %r13,%rbx
je 11f6 <func0+0x6d>
mov %r12,%rdx
lea 0xe2f(%rip),%rsi
mov (%rbx),%rdi
mov $0x0,%eax
callq 1090 <__isoc99_sscanf@plt>
test %eax,%eax
je 11c2 <func0+0x39>
mov 0x4(%rsp),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
jmp 11c2 <func0+0x39>
mov $0x7fffffff,%ebp
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1213 <func0+0x8a>
mov %ebp,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_11F1
mov rbx, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*8+8]
mov ebp, 7FFFFFFFh
lea r12, unk_2004
jmp short loc_11CD
loc_11C4:
add rbx, 8
cmp rbx, r13
jz short loc_11F6
loc_11CD:
lea rdx, [rsp+38h+var_34]
mov rsi, r12
mov rdi, [rbx]
mov eax, 0
call ___isoc99_sscanf
test eax, eax
jz short loc_11C4
mov eax, [rsp+38h+var_34]
cmp ebp, eax
cmovg ebp, eax
jmp short loc_11C4
loc_11F1:
mov ebp, 7FFFFFFFh
loc_11F6:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1213
mov eax, ebp
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1213:
call ___stack_chk_fail | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
int v3; // ebp
int v5; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = 0x7FFFFFFF;
do
{
if ( (unsigned int)__isoc99_sscanf(*v2, &unk_2004, &v5) && v3 > v5 )
v3 = v5;
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001011f1
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x8 + 0x8]
MOV EBP,0x7fffffff
LEA R12,[0x102004]
JMP 0x001011cd
LAB_001011c4:
ADD RBX,0x8
CMP RBX,R13
JZ 0x001011f6
LAB_001011cd:
LEA RDX,[RSP + 0x4]
MOV RSI,R12
MOV RDI,qword ptr [RBX]
MOV EAX,0x0
CALL 0x00101090
TEST EAX,EAX
JZ 0x001011c4
MOV EAX,dword ptr [RSP + 0x4]
CMP EBP,EAX
CMOVG EBP,EAX
JMP 0x001011c4
LAB_001011f1:
MOV EBP,0x7fffffff
LAB_001011f6:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101213
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101213:
CALL 0x00101070 | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
iVar3 = 0x7fffffff;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0x7fffffff;
do {
iVar2 = __isoc99_sscanf(*param_1,&DAT_00102004,&local_34);
if ((iVar2 != 0) && (local_34 < iVar3)) {
iVar3 = local_34;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar3;
} |
5,534 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}
| int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13b0 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov $0x7fffffff,%r12d
lea 0x8(%rdi,%rax,8),%r14
lea 0x4(%rsp),%r13
lea 0xca3(%rip),%rbp
nopl 0x0(%rax)
mov (%rbx),%rdi
xor %eax,%eax
mov %r13,%rdx
mov %rbp,%rsi
callq 1090 <__isoc99_sscanf@plt>
test %eax,%eax
je 1387 <func0+0x67>
mov 0x4(%rsp),%eax
cmp %eax,%r12d
cmovg %eax,%r12d
add $0x8,%rbx
cmp %r14,%rbx
jne 1368 <func0+0x48>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13b8 <func0+0x98>
add $0x10,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x7fffffff,%r12d
jmp 1390 <func0+0x70>
callq 1070 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_13B0
lea eax, [rsi-1]
mov rbx, rdi
mov r12d, 7FFFFFFFh
lea r14, [rdi+rax*8+8]
lea r13, [rsp+38h+var_34]
lea rbp, unk_2004
nop dword ptr [rax+00000000h]
loc_1368:
mov rdi, [rbx]
xor eax, eax
mov rdx, r13
mov rsi, rbp
call ___isoc99_sscanf
test eax, eax
jz short loc_1387
mov eax, [rsp+38h+var_34]
cmp r12d, eax
cmovg r12d, eax
loc_1387:
add rbx, 8
cmp rbx, r14
jnz short loc_1368
loc_1390:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_13B8
add rsp, 10h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_13B0:
mov r12d, 7FFFFFFFh
jmp short loc_1390
loc_13B8:
call ___stack_chk_fail | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
int v3; // r12d
int v5; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = 0x7FFFFFFF;
do
{
if ( (unsigned int)__isoc99_sscanf(*v2, &unk_2004, &v5) && v3 > v5 )
v3 = v5;
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001013b0
LEA EAX,[RSI + -0x1]
MOV RBX,RDI
MOV R12D,0x7fffffff
LEA R14,[RDI + RAX*0x8 + 0x8]
LEA R13,[RSP + 0x4]
LEA RBP,[0x102004]
NOP dword ptr [RAX]
LAB_00101368:
MOV RDI,qword ptr [RBX]
XOR EAX,EAX
MOV RDX,R13
MOV RSI,RBP
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101387
MOV EAX,dword ptr [RSP + 0x4]
CMP R12D,EAX
CMOVG R12D,EAX
LAB_00101387:
ADD RBX,0x8
CMP RBX,R14
JNZ 0x00101368
LAB_00101390:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013b8
ADD RSP,0x10
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013b0:
MOV R12D,0x7fffffff
JMP 0x00101390
LAB_001013b8:
CALL 0x00101070 | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
iVar3 = 0x7fffffff;
}
else {
iVar3 = 0x7fffffff;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
iVar2 = __isoc99_sscanf(*param_1,&DAT_00102004,&local_34);
if (iVar2 != 0) {
if (local_34 < iVar3) {
iVar3 = local_34;
}
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,535 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}
| int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13e0 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov $0x7fffffff,%r12d
lea 0x8(%rdi,%rax,8),%r14
lea 0x4(%rsp),%r13
lea 0xc73(%rip),%rbp
nopl 0x0(%rax)
mov (%rbx),%rdi
xor %eax,%eax
mov %r13,%rdx
mov %rbp,%rsi
callq 1090 <__isoc99_sscanf@plt>
test %eax,%eax
je 13b7 <func0+0x67>
mov 0x4(%rsp),%eax
cmp %eax,%r12d
cmovg %eax,%r12d
add $0x8,%rbx
cmp %r14,%rbx
jne 1398 <func0+0x48>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13e8 <func0+0x98>
add $0x10,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x7fffffff,%r12d
jmp 13c0 <func0+0x70>
callq 1070 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_1428
movsxd rsi, esi
mov rbx, rdi
lea r13, [rsp+38h+var_34]
mov ebp, 7FFFFFFFh
lea r14, [rdi+rsi*8]
lea r12, unk_2004
nop
loc_13E0:
mov rdi, [rbx]
xor eax, eax
mov rdx, r13
mov rsi, r12
call ___isoc99_sscanf
test eax, eax
jz short loc_13FD
mov eax, [rsp+38h+var_34]
cmp ebp, eax
cmovg ebp, eax
loc_13FD:
add rbx, 8
cmp rbx, r14
jnz short loc_13E0
loc_1406:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_142F
add rsp, 10h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1428:
mov ebp, 7FFFFFFFh
jmp short loc_1406
loc_142F:
call ___stack_chk_fail | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
int v3; // ebp
int v5; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = 0x7FFFFFFF;
do
{
if ( (unsigned int)__isoc99_sscanf(*v2, &unk_2004, &v5) && v3 > v5 )
v3 = v5;
++v2;
}
while ( v2 != &a1[a2] );
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101428
MOVSXD RSI,ESI
MOV RBX,RDI
LEA R13,[RSP + 0x4]
MOV EBP,0x7fffffff
LEA R14,[RDI + RSI*0x8]
LEA R12,[0x102004]
NOP
LAB_001013e0:
MOV RDI,qword ptr [RBX]
XOR EAX,EAX
MOV RDX,R13
MOV RSI,R12
CALL 0x00101090
TEST EAX,EAX
JZ 0x001013fd
MOV EAX,dword ptr [RSP + 0x4]
CMP EBP,EAX
CMOVG EBP,EAX
LAB_001013fd:
ADD RBX,0x8
CMP RBX,R14
JNZ 0x001013e0
LAB_00101406:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010142f
ADD RSP,0x10
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101428:
MOV EBP,0x7fffffff
JMP 0x00101406
LAB_0010142f:
CALL 0x00101070 | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
iVar3 = 0x7fffffff;
}
else {
iVar3 = 0x7fffffff;
puVar1 = param_1 + param_2;
do {
iVar2 = __isoc99_sscanf(*param_1,&DAT_00102004,&local_34);
if (iVar2 != 0) {
if (local_34 < iVar3) {
iVar3 = local_34;
}
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,536 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize = 0;
} else {
result[index++] = word[i];
}
}
}
result[index] = '\0';
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1260 <func0+0xb7>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5f,%al
jne 11f4 <func0+0x4b>
movl $0x1,-0x8(%rbp)
jmp 125c <func0+0xb3>
cmpl $0x0,-0x8(%rbp)
je 1236 <func0+0x8d>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 1080 <toupper@plt>
mov %eax,%ecx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
movl $0x0,-0x8(%rbp)
jmp 125c <func0+0xb3>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11d7 <func0+0x2e>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x20(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp loc_1260
loc_11D7:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 5Fh ; '_'
jnz short loc_11F4
mov [rbp+var_8], 1
jmp short loc_125C
loc_11F4:
cmp [rbp+var_8], 0
jz short loc_1236
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _toupper
mov ecx, eax
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov edx, ecx
mov [rax], dl
mov [rbp+var_8], 0
jmp short loc_125C
loc_1236:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
lea edx, [rax+1]
mov [rbp+var_C], edx
movsxd rdx, eax
mov rax, [rbp+var_20]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_125C:
add [rbp+var_4], 1
loc_1260:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11D7
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_20]
leave
retn | long long func0(long long a1, long long a2)
{
char v2; // cl
int v3; // eax
int v4; // eax
int v6; // [rsp+14h] [rbp-Ch]
int v7; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v6 = 0;
v7 = 1;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(_BYTE *)(i + a1) == 95 )
{
v7 = 1;
}
else if ( v7 )
{
v2 = toupper(*(char *)(i + a1));
v3 = v6++;
*(_BYTE *)(v3 + a2) = v2;
v7 = 0;
}
else
{
v4 = v6++;
*(_BYTE *)(a2 + v4) = *(_BYTE *)(i + a1);
}
}
*(_BYTE *)(v6 + a2) = 0;
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101260
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x5f
JNZ 0x001011f4
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010125c
LAB_001011f4:
CMP dword ptr [RBP + -0x8],0x0
JZ 0x00101236
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x00101080
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010125c
LAB_00101236:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0xc],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_0010125c:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101260:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011d7
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
LEAVE
RET | long func0(long param_1,long param_2)
{
bool bVar1;
int iVar2;
int4 local_14;
int4 local_c;
local_14 = 0;
bVar1 = true;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == '_') {
bVar1 = true;
}
else if (bVar1) {
iVar2 = toupper((int)*(char *)(param_1 + local_c));
*(char *)(param_2 + local_14) = (char)iVar2;
bVar1 = false;
local_14 = local_14 + 1;
}
else {
*(int *)(local_14 + param_2) = *(int *)(local_c + param_1);
local_14 = local_14 + 1;
}
}
*(int *)(param_2 + local_14) = 0;
return param_2;
} |
5,537 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize = 0;
} else {
result[index++] = word[i];
}
}
}
result[index] = '\0';
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rsi,%r13
movzbl (%rdi),%ebx
test %bl,%bl
je 120d <func0+0x84>
lea 0x1(%rdi),%rbp
mov $0x1,%eax
mov $0x0,%r12d
mov $0x1,%r14d
mov $0x0,%r15d
jmp 11e0 <func0+0x57>
movslq %r12d,%rdx
mov %bl,0x0(%r13,%rdx,1)
lea 0x1(%r12),%r12d
jmp 11d4 <func0+0x4b>
mov %r14d,%eax
add $0x1,%rbp
movzbl -0x1(%rbp),%ebx
test %bl,%bl
je 1213 <func0+0x8a>
cmp $0x5f,%bl
je 11d1 <func0+0x48>
test %eax,%eax
je 11c2 <func0+0x39>
callq 1070 <__ctype_toupper_loc@plt>
mov %rax,%rdx
movslq %r12d,%rax
movsbq %bl,%rbx
mov (%rdx),%rdx
mov (%rdx,%rbx,4),%edx
mov %dl,0x0(%r13,%rax,1)
lea 0x1(%r12),%r12d
mov %r15d,%eax
jmp 11d4 <func0+0x4b>
mov $0x0,%r12d
movslq %r12d,%r12
movb $0x0,0x0(%r13,%r12,1)
mov %r13,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_122D
lea rbp, [rdi+1]
mov eax, 1
mov r12d, 0
mov r14d, 1
mov r15d, 0
jmp short loc_1200
loc_11E2:
movsxd rdx, r12d
mov [r13+rdx+0], bl
lea r12d, [r12+1]
jmp short loc_11F4
loc_11F1:
mov eax, r14d
loc_11F4:
add rbp, 1
movzx ebx, byte ptr [rbp-1]
test bl, bl
jz short loc_1233
loc_1200:
cmp bl, 5Fh ; '_'
jz short loc_11F1
test eax, eax
jz short loc_11E2
call ___ctype_toupper_loc
mov rdx, rax
movsxd rax, r12d
movsx rbx, bl
mov rdx, [rdx]
mov edx, [rdx+rbx*4]
mov [r13+rax+0], dl
lea r12d, [r12+1]
mov eax, r15d
jmp short loc_11F4
loc_122D:
mov r12d, 0
loc_1233:
movsxd r12, r12d
mov byte ptr [r13+r12+0], 0
mov rax, r13
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char *a1, long long a2)
{
char v2; // bl
char *v3; // rbp
int v4; // eax
int v5; // r12d
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 1;
v5 = 0;
do
{
if ( v2 == 95 )
{
v4 = 1;
}
else if ( v4 )
{
*(_BYTE *)(a2 + v5++) = *(_DWORD *)(*(_QWORD *)__ctype_toupper_loc() + 4LL * v2);
v4 = 0;
}
else
{
*(_BYTE *)(a2 + v5++) = v2;
}
v2 = *v3++;
}
while ( v2 );
}
else
{
v5 = 0;
}
*(_BYTE *)(a2 + v5) = 0;
return a2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x0010122d
LEA RBP,[RDI + 0x1]
MOV EAX,0x1
MOV R12D,0x0
MOV R14D,0x1
MOV R15D,0x0
JMP 0x00101200
LAB_001011e2:
MOVSXD RDX,R12D
MOV byte ptr [R13 + RDX*0x1],BL
LEA R12D,[R12 + 0x1]
JMP 0x001011f4
LAB_001011f1:
MOV EAX,R14D
LAB_001011f4:
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP + -0x1]
TEST BL,BL
JZ 0x00101233
LAB_00101200:
CMP BL,0x5f
JZ 0x001011f1
TEST EAX,EAX
JZ 0x001011e2
CALL 0x00101080
MOV RDX,RAX
MOVSXD RAX,R12D
MOVSX RBX,BL
MOV RDX,qword ptr [RDX]
MOV EDX,dword ptr [RDX + RBX*0x4]
MOV byte ptr [R13 + RAX*0x1],DL
LEA R12D,[R12 + 0x1]
MOV EAX,R15D
JMP 0x001011f4
LAB_0010122d:
MOV R12D,0x0
LAB_00101233:
MOVSXD R12,R12D
MOV byte ptr [R13 + R12*0x1],0x0
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | long func0(char *param_1,long param_2)
{
bool bVar1;
__int32_t **pp_Var2;
char cVar3;
char *pcVar4;
int iVar5;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar5 = 0;
}
else {
bVar1 = true;
iVar5 = 0;
pcVar4 = param_1 + 1;
do {
if (cVar3 == '_') {
bVar1 = true;
}
else if (bVar1) {
pp_Var2 = __ctype_toupper_loc();
*(char *)(param_2 + iVar5) = (char)(*pp_Var2)[cVar3];
iVar5 = iVar5 + 1;
bVar1 = false;
}
else {
*(char *)(param_2 + iVar5) = cVar3;
iVar5 = iVar5 + 1;
}
cVar3 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar3 != '\0');
}
*(int1 *)(param_2 + iVar5) = 0;
return param_2;
} |
5,538 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize = 0;
} else {
result[index++] = word[i];
}
}
}
result[index] = '\0';
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
mov $0x1,%eax
xor %r15d,%r15d
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%r15d
movslq %r15d,%r13
lea (%r14,%r13,1),%rdx
test %eax,%eax
je 1358 <func0+0xa8>
mov %rdx,0x8(%rsp)
callq 1070 <__ctype_toupper_loc@plt>
mov 0x8(%rsp),%rdx
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,(%r12)
mov %rdx,%r12
xor %eax,%eax
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
test %bl,%bl
je 133d <func0+0x8d>
lea (%r14,%r13,1),%r12
cmp $0x5f,%bl
jne 12e8 <func0+0x38>
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
mov $0x1,%eax
test %bl,%bl
jne 1322 <func0+0x72>
movb $0x0,(%r12)
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %bl,(%r12)
mov %rdx,%r12
jmp 1315 <func0+0x65>
nopl 0x0(%rax)
mov %rsi,%r12
jmp 133d <func0+0x8d>
nopl (%rax)
| func0:
endbr64
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
mov edx, 1
xor r12d, r12d
jmp short loc_1305
loc_12D8:
movsxd rax, r12d
add r12d, 1
lea r13, [r14+rax]
test edx, edx
jz short loc_1338
call ___ctype_toupper_loc
xor edx, edx
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [r13+0], al
loc_12F8:
movsx rbx, byte ptr [rbp+0]
add rbp, 1
test bl, bl
jz short loc_131C
loc_1305:
cmp bl, 5Fh ; '_'
jnz short loc_12D8
movsx rbx, byte ptr [rbp+0]
add rbp, 1
mov edx, 1
test bl, bl
jnz short loc_1305
loc_131C:
movsxd r12, r12d
add r12, r14
loc_1322:
mov byte ptr [r12], 0
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1338:
mov [r13+0], bl
jmp short loc_12F8
loc_1340:
mov r12, rsi
jmp short loc_1322 | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // edx
int v5; // r12d
long long v6; // rax
_BYTE *v7; // r13
_QWORD *v8; // rax
_BYTE *v9; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 1;
v5 = 0;
do
{
while ( (_BYTE)v2 == 95 )
{
v2 = *v3++;
v4 = 1;
if ( !(_BYTE)v2 )
goto LABEL_8;
}
v6 = v5++;
v7 = &a2[v6];
if ( v4 )
{
v8 = (_QWORD *)__ctype_toupper_loc();
v4 = 0;
*v7 = *(_DWORD *)(*v8 + 4 * v2);
}
else
{
*v7 = v2;
}
v2 = *v3++;
}
while ( (_BYTE)v2 );
LABEL_8:
v9 = &a2[v5];
}
else
{
v9 = a2;
}
*v9 = 0;
return a2;
} | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
MOV EDX,0x1
XOR R12D,R12D
JMP 0x00101305
LAB_001012d8:
MOVSXD RAX,R12D
ADD R12D,0x1
LEA R13,[R14 + RAX*0x1]
TEST EDX,EDX
JZ 0x00101338
CALL 0x00101080
XOR EDX,EDX
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [R13],AL
LAB_001012f8:
MOVSX RBX,byte ptr [RBP]
ADD RBP,0x1
TEST BL,BL
JZ 0x0010131c
LAB_00101305:
CMP BL,0x5f
JNZ 0x001012d8
MOVSX RBX,byte ptr [RBP]
ADD RBP,0x1
MOV EDX,0x1
TEST BL,BL
JNZ 0x00101305
LAB_0010131c:
MOVSXD R12,R12D
ADD R12,R14
LAB_00101322:
MOV byte ptr [R12],0x0
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101338:
MOV byte ptr [R13],BL
JMP 0x001012f8
LAB_00101340:
MOV R12,RSI
JMP 0x00101322 | int1 * func0(char *param_1,int1 *param_2)
{
char cVar1;
bool bVar2;
long lVar3;
__int32_t **pp_Var4;
long lVar5;
int iVar6;
int1 *puVar7;
lVar5 = (long)*param_1;
puVar7 = param_2;
if (*param_1 != '\0') {
param_1 = param_1 + 1;
bVar2 = true;
iVar6 = 0;
do {
while ((char)lVar5 != '_') {
lVar3 = (long)iVar6;
iVar6 = iVar6 + 1;
if (bVar2) {
pp_Var4 = __ctype_toupper_loc();
bVar2 = false;
param_2[lVar3] = (char)(*pp_Var4)[lVar5];
}
else {
param_2[lVar3] = (char)lVar5;
}
cVar1 = *param_1;
lVar5 = (long)cVar1;
param_1 = param_1 + 1;
if (cVar1 == '\0') goto LAB_0010131c;
}
cVar1 = *param_1;
lVar5 = (long)cVar1;
param_1 = param_1 + 1;
bVar2 = true;
} while (cVar1 != '\0');
LAB_0010131c:
puVar7 = param_2 + iVar6;
}
*puVar7 = 0;
return param_2;
} |
5,539 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize = 0;
} else {
result[index++] = word[i];
}
}
}
result[index] = '\0';
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
mov $0x1,%eax
xor %r15d,%r15d
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%r15d
movslq %r15d,%r13
lea (%r14,%r13,1),%rdx
test %eax,%eax
je 1358 <func0+0xa8>
mov %rdx,0x8(%rsp)
callq 1070 <__ctype_toupper_loc@plt>
mov 0x8(%rsp),%rdx
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,(%r12)
mov %rdx,%r12
xor %eax,%eax
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
test %bl,%bl
je 133d <func0+0x8d>
lea (%r14,%r13,1),%r12
cmp $0x5f,%bl
jne 12e8 <func0+0x38>
movsbq 0x0(%rbp),%rbx
add $0x1,%rbp
mov $0x1,%eax
test %bl,%bl
jne 1322 <func0+0x72>
movb $0x0,(%r12)
add $0x18,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %bl,(%r12)
mov %rdx,%r12
jmp 1315 <func0+0x65>
nopl 0x0(%rax)
mov %rsi,%r12
jmp 133d <func0+0x8d>
nopl (%rax)
| func0:
endbr64
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
mov eax, 1
xor r12d, r12d
jmp short loc_130B
loc_12E0:
test eax, eax
jz short loc_12F0
call ___ctype_toupper_loc
mov rax, [rax]
movzx ebx, byte ptr [rax+rbx*4]
loc_12F0:
movsxd rax, r12d
add rbp, 1
add r12d, 1
mov [r13+rax+0], bl
movsx rbx, byte ptr [rbp-1]
xor eax, eax
test bl, bl
jz short loc_1322
loc_130B:
cmp bl, 5Fh ; '_'
jnz short loc_12E0
movsx rbx, byte ptr [rbp+0]
add rbp, 1
mov eax, 1
test bl, bl
jnz short loc_130B
loc_1322:
movsxd r12, r12d
add r12, r13
loc_1328:
mov byte ptr [r12], 0
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1340:
mov r12, rsi
jmp short loc_1328 | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // eax
int v5; // r12d
long long v6; // rax
_BYTE *v7; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 1;
v5 = 0;
do
{
while ( (_BYTE)v2 == 95 )
{
v2 = *v3++;
v4 = 1;
if ( !(_BYTE)v2 )
goto LABEL_8;
}
if ( v4 )
LOBYTE(v2) = (*__ctype_toupper_loc())[v2];
v6 = v5;
++v3;
++v5;
a2[v6] = v2;
v2 = *(v3 - 1);
v4 = 0;
}
while ( (_BYTE)v2 );
LABEL_8:
v7 = &a2[v5];
}
else
{
v7 = a2;
}
*v7 = 0;
return a2;
} | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
MOV EAX,0x1
XOR R12D,R12D
JMP 0x0010130b
LAB_001012e0:
TEST EAX,EAX
JZ 0x001012f0
CALL 0x00101080
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + RBX*0x4]
LAB_001012f0:
MOVSXD RAX,R12D
ADD RBP,0x1
ADD R12D,0x1
MOV byte ptr [R13 + RAX*0x1],BL
MOVSX RBX,byte ptr [RBP + -0x1]
XOR EAX,EAX
TEST BL,BL
JZ 0x00101322
LAB_0010130b:
CMP BL,0x5f
JNZ 0x001012e0
MOVSX RBX,byte ptr [RBP]
ADD RBP,0x1
MOV EAX,0x1
TEST BL,BL
JNZ 0x0010130b
LAB_00101322:
MOVSXD R12,R12D
ADD R12,R13
LAB_00101328:
MOV byte ptr [R12],0x0
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101340:
MOV R12,RSI
JMP 0x00101328 | int * func0(char *param_1,int *param_2)
{
char cVar1;
bool bVar2;
__int32_t **pp_Var3;
long lVar4;
ulong uVar5;
char *pcVar6;
int iVar7;
int *puVar8;
uVar5 = (ulong)*param_1;
puVar8 = param_2;
if (*param_1 != '\0') {
bVar2 = true;
iVar7 = 0;
pcVar6 = param_1 + 1;
do {
while ((char)uVar5 != '_') {
if (bVar2) {
pp_Var3 = __ctype_toupper_loc();
uVar5 = (ulong)*(byte *)(*pp_Var3 + uVar5);
}
lVar4 = (long)iVar7;
iVar7 = iVar7 + 1;
param_2[lVar4] = (char)uVar5;
cVar1 = *pcVar6;
uVar5 = (ulong)cVar1;
bVar2 = false;
pcVar6 = pcVar6 + 1;
if (cVar1 == '\0') goto LAB_00101322;
}
cVar1 = *pcVar6;
uVar5 = (ulong)cVar1;
bVar2 = true;
pcVar6 = pcVar6 + 1;
} while (cVar1 != '\0');
LAB_00101322:
puVar8 = param_2 + iVar7;
}
*puVar8 = 0;
return param_2;
} |
5,540 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[] = {10, 20};
assert(func0(l1, sizeL1, expectedL1, 1));
assert(func0(l2, sizeL2, expectedL2, 3));
assert(func0(l3, sizeL3, expectedL3, 2));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
je 1219 <func0+0x25>
mov $0x0,%eax
jmp 126a <func0+0x76>
movl $0x0,-0x4(%rbp)
jmp 125d <func0+0x69>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 1259 <func0+0x65>
mov $0x0,%eax
jmp 126a <func0+0x76>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1222 <func0+0x2e>
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_28], rdx
mov [rbp+var_20], ecx
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jz short loc_1219
mov eax, 0
jmp short loc_126A
loc_1219:
mov [rbp+var_4], 0
jmp short loc_125D
loc_1222:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1259
mov eax, 0
jmp short loc_126A
loc_1259:
add [rbp+var_4], 1
loc_125D:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1222
mov eax, 1
loc_126A:
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+24h] [rbp-4h]
if ( a2 != a4 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * i + a3) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JZ 0x00101219
MOV EAX,0x0
JMP 0x0010126a
LAB_00101219:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010125d
LAB_00101222:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101259
MOV EAX,0x0
JMP 0x0010126a
LAB_00101259:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010125d:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101222
MOV EAX,0x1
LAB_0010126a:
POP RBP
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int8 uVar1;
int local_c;
if (param_2 == param_4) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) != *(int *)(param_3 + (long)local_c * 4)) {
return 0;
}
}
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
5,541 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[] = {10, 20};
assert(func0(l1, sizeL1, expectedL1, 1));
assert(func0(l2, sizeL2, expectedL2, 3));
assert(func0(l3, sizeL3, expectedL3, 2));
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%esi
jne 11e2 <func0+0x40>
test %esi,%esi
jle 11d7 <func0+0x35>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 11c0 <func0+0x1e>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
jne 11dd <func0+0x3b>
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne 11bd <func0+0x1b>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov eax, 0
cmp esi, ecx
jnz short locret_11E2
test esi, esi
jle short loc_11D7
lea esi, [rsi-1]
mov eax, 0
jmp short loc_11C0
loc_11BD:
mov rax, rcx
loc_11C0:
mov ecx, [rdx+rax*4]
cmp [rdi+rax*4], ecx
jnz short loc_11DD
lea rcx, [rax+1]
cmp rax, rsi
jnz short loc_11BD
mov eax, 1
retn
loc_11D7:
mov eax, 1
retn
loc_11DD:
mov eax, 0
locret_11E2:
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rsi
long long i; // rax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (unsigned int)(a2 - 1);
for ( i = 0LL; *(_DWORD *)(a1 + 4 * i) == *(_DWORD *)(a3 + 4 * i); ++i )
{
if ( i == v5 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,ECX
JNZ 0x001011e2
TEST ESI,ESI
JLE 0x001011d7
LEA ESI,[RSI + -0x1]
MOV EAX,0x0
JMP 0x001011c0
LAB_001011bd:
MOV RAX,RCX
LAB_001011c0:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x001011dd
LEA RCX,[RAX + 0x1]
CMP RAX,RSI
JNZ 0x001011bd
MOV EAX,0x1
RET
LAB_001011d7:
MOV EAX,0x1
RET
LAB_001011dd:
MOV EAX,0x0
LAB_001011e2:
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
ulong uVar1;
bool bVar2;
if (param_2 == param_4) {
if (param_2 < 1) {
return 1;
}
uVar1 = 0;
while (*(int *)(param_1 + uVar1 * 4) == *(int *)(param_3 + uVar1 * 4)) {
bVar2 = uVar1 == param_2 - 1;
uVar1 = uVar1 + 1;
if (bVar2) {
return 1;
}
}
}
return 0;
} |
5,542 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[] = {10, 20};
assert(func0(l1, sizeL1, expectedL1, 1));
assert(func0(l2, sizeL2, expectedL2, 3));
assert(func0(l3, sizeL3, expectedL3, 2));
return 0;
}
| O2 | c | func0:
endbr64
cmp %ecx,%esi
jne 1340 <func0+0x10>
jmpq 12b0 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
xor eax, eax
cmp esi, ecx
jnz short locret_135B
test esi, esi
jle short loc_1360
movsxd rsi, esi
xor eax, eax
jmp short loc_1351
loc_1348:
add rax, 1
cmp rax, rsi
jz short loc_1360
loc_1351:
mov ecx, [rdx+rax*4]
cmp [rdi+rax*4], ecx
jz short loc_1348
xor eax, eax
locret_135B:
retn
loc_1360:
mov eax, 1
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v5) == *(_DWORD *)(a3 + 4 * v5) )
{
if ( ++v5 == a2 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP ESI,ECX
JNZ 0x0010135b
TEST ESI,ESI
JLE 0x00101360
MOVSXD RSI,ESI
XOR EAX,EAX
JMP 0x00101351
LAB_00101348:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101360
LAB_00101351:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x00101348
XOR EAX,EAX
LAB_0010135b:
RET
LAB_00101360:
MOV EAX,0x1
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
long lVar1;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) != *(int *)(param_3 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return 1;
} |
5,543 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[] = {10, 20};
assert(func0(l1, sizeL1, expectedL1, 1));
assert(func0(l2, sizeL2, expectedL2, 3));
assert(func0(l3, sizeL3, expectedL3, 2));
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
jne 137e <func0+0x2e>
test %esi,%esi
jle 1380 <func0+0x30>
sub $0x1,%esi
xor %eax,%eax
jmp 1374 <func0+0x24>
nopl (%rax)
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 1380 <func0+0x30>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
je 1368 <func0+0x18>
xor %eax,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
test esi, esi
jle short loc_12D0
movsxd rsi, esi
xor eax, eax
lea rcx, ds:0[rsi*4]
jmp short loc_12C1
loc_12B8:
add rax, 4
cmp rcx, rax
jz short loc_12D0
loc_12C1:
mov esi, [rdx+rax]
cmp [rdi+rax], esi
jz short loc_12B8
xor eax, eax
retn
loc_12D0:
mov eax, 1
retn | long long func0_part_0(long long a1, int a2, long long a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + v3) == *(_DWORD *)(a3 + v3) )
{
v3 += 4LL;
if ( 4LL * a2 == v3 )
return 1LL;
}
return 0LL;
} | func0.part.0:
TEST ESI,ESI
JLE 0x001012d0
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RSI*0x4]
JMP 0x001012c1
LAB_001012b8:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x001012d0
LAB_001012c1:
MOV ESI,dword ptr [RDX + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ESI
JZ 0x001012b8
XOR EAX,EAX
RET
LAB_001012d0:
MOV EAX,0x1
RET | int8 func0_part_0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1) != *(int *)(param_3 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_2 * 4 - lVar1 != 0);
}
return 1;
} |
5,544 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") == 0);
assert(strcmp(result[2], "Wyatt Knott") == 0);
assert(strcmp(result[3], "Beau Turnbull") == 0);
func0(data, 4, 2, result);
assert(strcmp(result[0], "99") == 0);
assert(strcmp(result[1], "96") == 0);
assert(strcmp(result[2], "94") == 0);
assert(strcmp(result[3], "98") == 0);
func0(data, 4, 1, result);
assert(strcmp(result[0], "98") == 0);
assert(strcmp(result[1], "97") == 0);
assert(strcmp(result[2], "91") == 0);
assert(strcmp(result[3], "94") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1238 <func0+0x8f>
mov -0x4(%rbp),%eax
cltq
imul $0x96,%rax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
add %rax,%rax
add %rax,%rcx
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
add %rax,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1080 <strcpy@plt>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11cc <func0+0x23>
mov -0x28(%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_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_4], 0
jmp short loc_1238
loc_11CC:
mov eax, [rbp+var_4]
cdqe
imul rdx, rax, 96h
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
add rax, rax
add rcx, rax
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
add rax, rax
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov rsi, rcx; src
mov rdi, rax; dest
call _strcpy
add [rbp+var_4], 1
loc_1238:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11CC
mov rax, [rbp+var_28]
leave
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
strcpy((char *)(50LL * i + a4), (const char *)(50LL * a3 + 150LL * i + a1));
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101238
LAB_001011cc:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
IMUL RDX,RAX,0x96
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
ADD RAX,RAX
ADD RCX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
ADD RAX,RAX
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101080
ADD dword ptr [RBP + -0x4],0x1
LAB_00101238:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011cc
MOV RAX,qword ptr [RBP + -0x28]
LEAVE
RET | long func0(long param_1,int param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
strcpy((char *)(param_4 + (long)local_c * 0x32),
(char *)((long)local_c * 0x96 + param_1 + (long)param_3 * 0x32));
}
return param_4;
} |
5,545 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") == 0);
assert(strcmp(result[2], "Wyatt Knott") == 0);
assert(strcmp(result[3], "Beau Turnbull") == 0);
func0(data, 4, 2, result);
assert(strcmp(result[0], "99") == 0);
assert(strcmp(result[1], "96") == 0);
assert(strcmp(result[2], "94") == 0);
assert(strcmp(result[3], "98") == 0);
func0(data, 4, 1, result);
assert(strcmp(result[0], "98") == 0);
assert(strcmp(result[1], "97") == 0);
assert(strcmp(result[2], "91") == 0);
assert(strcmp(result[3], "94") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rcx,%r13
test %esi,%esi
jle 11db <func0+0x52>
mov %rcx,%rbx
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
lea (%rax,%rax,4),%rax
lea (%rdi,%rax,2),%rbp
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x32(%rcx,%rax,2),%r12
mov %rbp,%rsi
mov %rbx,%rdi
callq 1070 <strcpy@plt>
add $0x32,%rbx
add $0x96,%rbp
cmp %r12,%rbx
jne 11c0 <func0+0x37>
mov %r13,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rcx
test esi, esi
jle short loc_11FB
mov rbx, rcx
movsxd rdx, edx
lea rax, [rdx+rdx*4]
lea rax, [rax+rax*4]
lea rbp, [rdi+rax*2]
lea eax, [rsi-1]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea r12, [rcx+rax*2+32h]
loc_11E0:
mov rsi, rbp
mov rdi, rbx
call _strcpy
add rbx, 32h ; '2'
add rbp, 96h
cmp rbx, r12
jnz short loc_11E0
loc_11FB:
mov rax, r13
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // rbp
long long v7; // r12
if ( a2 > 0 )
{
v5 = a4;
v6 = a1 + 50LL * a3;
v7 = a4 + 50LL * (unsigned int)(a2 - 1) + 50;
do
{
strcpy(v5, v6);
v5 += 50LL;
v6 += 150LL;
}
while ( v5 != v7 );
}
return a4;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RCX
TEST ESI,ESI
JLE 0x001011fb
MOV RBX,RCX
MOVSXD RDX,EDX
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RDI + RAX*0x2]
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA R12,[RCX + RAX*0x2 + 0x32]
LAB_001011e0:
MOV RSI,RBP
MOV RDI,RBX
CALL 0x00101080
ADD RBX,0x32
ADD RBP,0x96
CMP RBX,R12
JNZ 0x001011e0
LAB_001011fb:
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | char * func0(long param_1,int param_2,int param_3,char *param_4)
{
char *__dest;
char *__src;
if (0 < param_2) {
__src = (char *)(param_1 + (long)param_3 * 0x32);
__dest = param_4;
do {
strcpy(__dest,__src);
__dest = __dest + 0x32;
__src = __src + 0x96;
} while (__dest != param_4 + (ulong)(param_2 - 1) * 0x32 + 0x32);
}
return param_4;
} |
5,546 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") == 0);
assert(strcmp(result[2], "Wyatt Knott") == 0);
assert(strcmp(result[3], "Beau Turnbull") == 0);
func0(data, 4, 2, result);
assert(strcmp(result[0], "99") == 0);
assert(strcmp(result[1], "96") == 0);
assert(strcmp(result[2], "94") == 0);
assert(strcmp(result[3], "98") == 0);
func0(data, 4, 1, result);
assert(strcmp(result[0], "98") == 0);
assert(strcmp(result[1], "97") == 0);
assert(strcmp(result[2], "91") == 0);
assert(strcmp(result[3], "94") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rcx,%r12
push %rbp
push %rbx
test %esi,%esi
jle 161e <func0+0x4e>
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
lea (%rax,%rax,4),%rax
lea (%rdi,%rax,2),%rbx
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x32(%rcx,%rax,2),%rbp
xchg %ax,%ax
mov %rbx,%rsi
mov %rcx,%rdi
add $0x96,%rbx
callq 1080 <strcpy@plt>
mov %rax,%rcx
add $0x32,%rcx
cmp %rbp,%rcx
jne 1600 <func0+0x30>
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12, rcx
push rbp
push rbx
test esi, esi
jle short loc_151E
movsxd rdx, edx
lea rax, [rdx+rdx*4]
lea rax, [rax+rax*4]
lea rbx, [rdi+rax*2]
lea eax, [rsi-1]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea rbp, [rcx+rax*2+32h]
xchg ax, ax
loc_1500:
mov rsi, rbx
mov rdi, rcx
add rbx, 96h
call _strcpy
mov rcx, rax
add rcx, 32h ; '2'
cmp rcx, rbp
jnz short loc_1500
loc_151E:
mov rax, r12
pop rbx
pop rbp
pop r12
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long v4; // r12
long long v5; // rbx
long long v6; // rbp
long long v7; // rsi
v4 = a4;
if ( a2 > 0 )
{
v5 = a1 + 50LL * a3;
v6 = a4 + 50LL * (unsigned int)(a2 - 1) + 50;
do
{
v7 = v5;
v5 += 150LL;
a4 = strcpy(a4, v7) + 50;
}
while ( a4 != v6 );
}
return v4;
} | func0:
ENDBR64
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x0010151e
MOVSXD RDX,EDX
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBX,[RDI + RAX*0x2]
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RCX + RAX*0x2 + 0x32]
NOP
LAB_00101500:
MOV RSI,RBX
MOV RDI,RCX
ADD RBX,0x96
CALL 0x00101070
MOV RCX,RAX
ADD RCX,0x32
CMP RCX,RBP
JNZ 0x00101500
LAB_0010151e:
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET | char * func0(long param_1,int param_2,int param_3,char *param_4)
{
char *pcVar1;
char *__src;
if (0 < param_2) {
pcVar1 = param_4;
__src = (char *)(param_1 + (long)param_3 * 0x32);
do {
pcVar1 = strcpy(pcVar1,__src);
pcVar1 = pcVar1 + 0x32;
__src = __src + 0x96;
} while (pcVar1 != param_4 + (ulong)(param_2 - 1) * 0x32 + 0x32);
}
return param_4;
} |
5,547 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") == 0);
assert(strcmp(result[2], "Wyatt Knott") == 0);
assert(strcmp(result[3], "Beau Turnbull") == 0);
func0(data, 4, 2, result);
assert(strcmp(result[0], "99") == 0);
assert(strcmp(result[1], "96") == 0);
assert(strcmp(result[2], "94") == 0);
assert(strcmp(result[3], "98") == 0);
func0(data, 4, 1, result);
assert(strcmp(result[0], "98") == 0);
assert(strcmp(result[1], "97") == 0);
assert(strcmp(result[2], "91") == 0);
assert(strcmp(result[3], "94") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rcx,%r12
push %rbp
push %rbx
test %esi,%esi
jle 161e <func0+0x4e>
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
lea (%rax,%rax,4),%rax
lea (%rdi,%rax,2),%rbx
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x32(%rcx,%rax,2),%rbp
xchg %ax,%ax
mov %rbx,%rsi
mov %rcx,%rdi
add $0x96,%rbx
callq 1080 <strcpy@plt>
mov %rax,%rcx
add $0x32,%rcx
cmp %rbp,%rcx
jne 1600 <func0+0x30>
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12, rcx
push rbp
push rbx
test esi, esi
jle short loc_14FE
movsxd rdx, edx
movsxd rsi, esi
lea rax, [rdx+rdx*4]
lea rax, [rax+rax*4]
lea rbx, [rdi+rax*2]
lea rax, [rsi+rsi*4]
lea rax, [rax+rax*4]
lea rbp, [rcx+rax*2]
nop dword ptr [rax]
loc_14E0:
mov rsi, rbx; src
mov rdi, rcx; dest
add rbx, 96h
call _strcpy
mov rcx, rax
add rcx, 32h ; '2'
cmp rcx, rbp
jnz short loc_14E0
loc_14FE:
mov rax, r12
pop rbx
pop rbp
pop r12
retn | char * func0(long long a1, int a2, int a3, char *a4)
{
char *v4; // r12
const char *v5; // rbx
char *v6; // rbp
const char *v7; // rsi
v4 = a4;
if ( a2 > 0 )
{
v5 = (const char *)(a1 + 50LL * a3);
v6 = &a4[50 * a2];
do
{
v7 = v5;
v5 += 150;
a4 = strcpy(a4, v7) + 50;
}
while ( a4 != v6 );
}
return v4;
} | func0:
ENDBR64
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001014fe
MOVSXD RDX,EDX
MOVSXD RSI,ESI
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBX,[RDI + RAX*0x2]
LEA RAX,[RSI + RSI*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RCX + RAX*0x2]
NOP dword ptr [RAX]
LAB_001014e0:
MOV RSI,RBX
MOV RDI,RCX
ADD RBX,0x96
CALL 0x00101070
MOV RCX,RAX
ADD RCX,0x32
CMP RCX,RBP
JNZ 0x001014e0
LAB_001014fe:
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET | char * func0(long param_1,int param_2,int param_3,char *param_4)
{
char *pcVar1;
char *__src;
if (0 < param_2) {
pcVar1 = param_4;
__src = (char *)(param_1 + (long)param_3 * 0x32);
do {
pcVar1 = strcpy(pcVar1,__src);
pcVar1 = pcVar1 + 0x32;
__src = __src + 0x96;
} while (pcVar1 != param_4 + (long)param_2 * 0x32);
}
return param_4;
} |
5,548 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
assert(func0(list1_c, 3, list2_c, 3) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d8 <func0+0x6f>
movl $0x0,-0x4(%rbp)
jmp 11cc <func0+0x63>
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 -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11c8 <func0+0x5f>
mov $0x1,%eax
jmp 11e5 <func0+0x7c>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 1191 <func0+0x28>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
jmp short loc_11D8
loc_1188:
mov [rbp+var_4], 0
jmp short loc_11CC
loc_1191:
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_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11C8
mov eax, 1
jmp short loc_11E5
loc_11C8:
add [rbp+var_4], 1
loc_11CC:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl short loc_1191
add [rbp+var_8], 1
loc_11D8:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, 0
loc_11E5:
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a4; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a3) )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d8
LAB_00101188:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cc
LAB_00101191:
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 + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011c8
MOV EAX,0x1
JMP 0x001011e5
LAB_001011c8:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011cc:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101191
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,0x0
LAB_001011e5:
POP RBP
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int local_10;
int local_c;
local_10 = 0;
do {
if (param_2 <= local_10) {
return 0;
}
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_3 + (long)local_c * 4)) {
return 1;
}
}
local_10 = local_10 + 1;
} while( true );
} |
5,549 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
assert(func0(list1_c, 3, list2_c, 3) == 1);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ad <func0+0x44>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov %rdx,%rdi
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%rsi
test %ecx,%ecx
jle 119e <func0+0x35>
mov (%r8),%edx
mov %rdi,%rax
cmp (%rax),%edx
je 11b3 <func0+0x4a>
add $0x4,%rax
cmp %rsi,%rax
jne 1191 <func0+0x28>
add $0x4,%r8
cmp %r9,%r8
jne 1187 <func0+0x1e>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11AA
mov r8, rdi
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
lea eax, [rcx-1]
lea rdi, [rdx+rax*4+4]
loc_1184:
test ecx, ecx
jle short loc_119B
mov esi, [r8]
mov rax, rdx
loc_118E:
cmp esi, [rax]
jz short loc_11B0
add rax, 4
cmp rax, rdi
jnz short loc_118E
loc_119B:
add r8, 4
cmp r8, r9
jnz short loc_1184
mov eax, 0
retn
loc_11AA:
mov eax, 0
retn
loc_11B0:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v4; // r8
_DWORD *v5; // rax
if ( a2 <= 0 )
return 0LL;
v4 = a1;
while ( a4 <= 0 )
{
LABEL_7:
if ( ++v4 == &a1[a2 - 1 + 1] )
return 0LL;
}
v5 = a3;
while ( *v4 != *v5 )
{
if ( ++v5 == &a3[a4 - 1 + 1] )
goto LABEL_7;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011aa
MOV R8,RDI
LEA EAX,[RSI + -0x1]
LEA R9,[RDI + RAX*0x4 + 0x4]
LEA EAX,[RCX + -0x1]
LEA RDI,[RDX + RAX*0x4 + 0x4]
LAB_00101184:
TEST ECX,ECX
JLE 0x0010119b
MOV ESI,dword ptr [R8]
MOV RAX,RDX
LAB_0010118e:
CMP ESI,dword ptr [RAX]
JZ 0x001011b0
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x0010118e
LAB_0010119b:
ADD R8,0x4
CMP R8,R9
JNZ 0x00101184
MOV EAX,0x0
RET
LAB_001011aa:
MOV EAX,0x0
RET
LAB_001011b0:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (param_2 < 1) {
return 0;
}
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (0 < param_4) {
piVar2 = param_3;
do {
if (*param_1 == *piVar2) {
return 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_3 + (ulong)(param_4 - 1) + 1);
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 0;
} |
5,550 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
assert(func0(list1_c, 3, list2_c, 3) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1289 <func0+0x49>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r8
test %ecx,%ecx
jle 1280 <func0+0x40>
mov (%rdi),%esi
mov %rdx,%rax
jmp 1271 <func0+0x31>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %r8,%rax
je 1280 <func0+0x40>
cmp (%rax),%esi
jne 1268 <func0+0x28>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %r9,%rdi
jne 1258 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
test esi, esi
jle short loc_1339
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
lea eax, [rcx-1]
lea r8, [rdx+rax*4+4]
loc_1308:
test ecx, ecx
jle short loc_1330
mov esi, [rdi]
mov rax, rdx
jmp short loc_1321
loc_1318:
add rax, 4
cmp rax, r8
jz short loc_1330
loc_1321:
cmp esi, [rax]
jnz short loc_1318
mov eax, 1
retn
loc_1330:
add rdi, 4
cmp rdi, r9
jnz short loc_1308
loc_1339:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long v4; // r9
_DWORD *v5; // rax
if ( a2 <= 0 )
return 0LL;
v4 = (long long)&a1[a2 - 1 + 1];
while ( a4 <= 0 )
{
LABEL_8:
if ( ++a1 == (_DWORD *)v4 )
return 0LL;
}
v5 = a3;
while ( *a1 != *v5 )
{
if ( ++v5 == &a3[a4 - 1 + 1] )
goto LABEL_8;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101339
LEA EAX,[RSI + -0x1]
LEA R9,[RDI + RAX*0x4 + 0x4]
LEA EAX,[RCX + -0x1]
LEA R8,[RDX + RAX*0x4 + 0x4]
LAB_00101308:
TEST ECX,ECX
JLE 0x00101330
MOV ESI,dword ptr [RDI]
MOV RAX,RDX
JMP 0x00101321
LAB_00101318:
ADD RAX,0x4
CMP RAX,R8
JZ 0x00101330
LAB_00101321:
CMP ESI,dword ptr [RAX]
JNZ 0x00101318
MOV EAX,0x1
RET
LAB_00101330:
ADD RDI,0x4
CMP RDI,R9
JNZ 0x00101308
LAB_00101339:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (0 < param_4) {
piVar2 = param_3;
do {
if (*param_1 == *piVar2) {
return 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_3 + (ulong)(param_4 - 1) + 1);
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 0;
} |
5,551 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
assert(func0(list1_c, 3, list2_c, 3) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1239 <func0+0x49>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r8
test %ecx,%ecx
jle 1230 <func0+0x40>
mov (%rdi),%esi
mov %rdx,%rax
jmp 1221 <func0+0x31>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %r8,%rax
je 1230 <func0+0x40>
cmp (%rax),%esi
jne 1218 <func0+0x28>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %r9,%rdi
jne 1208 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
test esi, esi
jle short loc_1189
movsxd rsi, esi
movsxd rax, ecx
lea r8, [rdi+rsi*4]
lea rsi, [rdx+rax*4]
loc_1156:
test ecx, ecx
jle short loc_1190
loc_115A:
mov ecx, [rdi]
mov rax, rdx
jmp short loc_1171
loc_1168:
add rax, 4
cmp rax, rsi
jz short loc_1180
loc_1171:
cmp ecx, [rax]
jnz short loc_1168
mov eax, 1
retn
loc_1180:
add rdi, 4
cmp rdi, r8
jnz short loc_115A
loc_1189:
xor eax, eax
retn
loc_1190:
add rdi, 4
cmp rdi, r8
jnz short loc_1156
jmp short loc_1189 | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v4; // r8
_DWORD *v5; // rax
if ( a2 > 0 )
{
v4 = &a1[a2];
while ( a4 <= 0 )
{
if ( ++a1 == v4 )
return 0LL;
}
do
{
v5 = a3;
do
{
if ( *a1 == *v5 )
return 1LL;
++v5;
}
while ( v5 != &a3[a4] );
++a1;
}
while ( a1 != v4 );
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101189
MOVSXD RSI,ESI
MOVSXD RAX,ECX
LEA R8,[RDI + RSI*0x4]
LEA RSI,[RDX + RAX*0x4]
LAB_00101156:
TEST ECX,ECX
JLE 0x00101190
LAB_0010115a:
MOV ECX,dword ptr [RDI]
MOV RAX,RDX
JMP 0x00101171
LAB_00101168:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x00101180
LAB_00101171:
CMP ECX,dword ptr [RAX]
JNZ 0x00101168
MOV EAX,0x1
RET
LAB_00101180:
ADD RDI,0x4
CMP RDI,R8
JNZ 0x0010115a
LAB_00101189:
XOR EAX,EAX
RET
LAB_00101190:
ADD RDI,0x4
CMP RDI,R8
JNZ 0x00101156
JMP 0x00101189 | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (0 < param_4) {
do {
piVar2 = param_3;
do {
if (*param_1 == *piVar2) {
return 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_3 + param_4);
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 0;
} |
5,552 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
x = arr[i];
y = arr[j];
}
}
}
result[0] = x;
result[1] = y;
return result;
}
| int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
int arr3[] = {1,2,3};
func0(arr3, 3, result3);
assert(result3[0] == 2 && result3[1] == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
cmpl $0x1,-0x1c(%rbp)
jg 118c <func0+0x23>
mov $0x0,%eax
jmpq 1258 <func0+0xef>
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov 0x4(%rax),%eax
mov %eax,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1232 <func0+0xc9>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 1226 <func0+0xbd>
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
imul %eax,%edx
mov -0x10(%rbp),%eax
imul -0xc(%rbp),%eax
cmp %eax,%edx
jle 1222 <func0+0xb9>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11b6 <func0+0x4d>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ab <func0+0x42>
mov -0x28(%rbp),%rax
mov -0x10(%rbp),%edx
mov %edx,(%rax)
mov -0x28(%rbp),%rax
lea 0x4(%rax),%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
mov -0x28(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
cmp [rbp+var_1C], 1
jg short loc_118C
mov eax, 0
jmp loc_1258
loc_118C:
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_10], eax
mov rax, [rbp+var_18]
mov eax, [rax+4]
mov [rbp+var_C], eax
mov [rbp+var_8], 0
jmp loc_1232
loc_11AB:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_1226
loc_11B6:
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]
imul edx, eax
mov eax, [rbp+var_10]
imul eax, [rbp+var_C]
cmp edx, eax
jle short loc_1222
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
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_1222:
add [rbp+var_4], 1
loc_1226:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11B6
add [rbp+var_8], 1
loc_1232:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_11AB
mov rax, [rbp+var_28]
mov edx, [rbp+var_10]
mov [rax], edx
mov rax, [rbp+var_28]
lea rdx, [rax+4]
mov eax, [rbp+var_C]
mov [rdx], eax
mov rax, [rbp+var_28]
loc_1258:
pop rbp
retn | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v4; // [rsp+18h] [rbp-10h]
int v5; // [rsp+1Ch] [rbp-Ch]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
if ( a2 <= 1 )
return 0LL;
v4 = *a1;
v5 = a1[1];
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a1[j] * a1[i] > v5 * v4 )
{
v4 = a1[i];
v5 = a1[j];
}
}
}
*a3 = v4;
a3[1] = v5;
return a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
CMP dword ptr [RBP + -0x1c],0x1
JG 0x0010118c
MOV EAX,0x0
JMP 0x00101258
LAB_0010118c:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101232
LAB_001011ab:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101226
LAB_001011b6:
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]
IMUL EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RBP + -0xc]
CMP EDX,EAX
JLE 0x00101222
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
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_00101222:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101226:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011b6
ADD dword ptr [RBP + -0x8],0x1
LAB_00101232:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ab
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[RAX + 0x4]
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x28]
LAB_00101258:
POP RBP
RET | int * func0(int *param_1,int param_2,int *param_3)
{
int local_18;
int local_14;
int local_10;
int local_c;
if (param_2 < 2) {
param_3 = (int *)0x0;
}
else {
local_18 = *param_1;
local_14 = param_1[1];
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (local_18 * local_14 < param_1[local_10] * param_1[local_c]) {
local_18 = param_1[local_10];
local_14 = param_1[local_c];
}
}
}
*param_3 = local_18;
param_3[1] = local_14;
}
return param_3;
} |
5,553 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
x = arr[i];
y = arr[j];
}
}
}
result[0] = x;
result[1] = y;
return result;
}
| int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
int arr3[] = {1,2,3};
func0(arr3, 3, result3);
assert(result3[0] == 2 && result3[1] == 3);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11da <func0+0x71>
push %r12
push %rbp
push %rbx
mov %rdx,%r12
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
mov $0x0,%ebx
mov $0x1,%ebp
mov $0x1,%ecx
jmp 1195 <func0+0x2c>
mov %ebp,%ebx
mov %ecx,%ebp
movslq %ebx,%r10
mov (%rdi,%r10,4),%r10d
movslq %ecx,%r11
mov (%rdi,%r11,4),%edx
mov %r10d,%eax
imul %edx,%eax
mov %r8d,%r11d
imul %r9d,%r11d
cmp %r11d,%eax
cmovg %edx,%r9d
cmovg %r10d,%r8d
add $0x1,%ecx
cmp %ecx,%esi
jg 1195 <func0+0x2c>
lea 0x1(%rbp),%ecx
cmp %ecx,%esi
jg 1191 <func0+0x28>
mov %r8d,(%r12)
mov %r9d,0x4(%r12)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
mov $0x0,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_11DE
push r12
push rbp
push rbx
mov rax, rdi
mov ebx, esi
mov r12, rdx
mov esi, [rdi]
mov edi, [rdi+4]
mov edx, 0
mov ebp, 1
mov ecx, 1
jmp short loc_1198
loc_1194:
mov edx, ebp
mov ebp, ecx
loc_1198:
movsxd r8, edx
mov r8d, [rax+r8*4]
movsxd r9, ecx
mov r11d, [rax+r9*4]
mov r10d, r8d
imul r10d, r11d
mov r9d, esi
imul r9d, edi
cmp r10d, r9d
cmovg edi, r11d
cmovg esi, r8d
add ecx, 1
cmp ebx, ecx
jg short loc_1198
lea ecx, [rbp+1]
cmp ebx, ecx
jg short loc_1194
mov [r12], esi
mov [r12+4], edi
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_11DE:
mov eax, 0
retn | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v6; // esi
int v7; // edi
int v8; // edx
int v9; // ebp
int v10; // ecx
int v11; // r10d
int v12; // r9d
if ( a2 <= 1 )
return 0LL;
v6 = *a1;
v7 = a1[1];
v8 = 0;
v9 = 1;
v10 = 1;
while ( 1 )
{
do
{
v11 = a1[v10] * a1[v8];
v12 = v7 * v6;
if ( v11 > v7 * v6 )
v7 = a1[v10];
if ( v11 > v12 )
v6 = a1[v8];
++v10;
}
while ( a2 > v10 );
v10 = v9 + 1;
if ( a2 <= v9 + 1 )
break;
v8 = v9++;
}
*a3 = v6;
a3[1] = v7;
return a3;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011de
PUSH R12
PUSH RBP
PUSH RBX
MOV RAX,RDI
MOV EBX,ESI
MOV R12,RDX
MOV ESI,dword ptr [RDI]
MOV EDI,dword ptr [RDI + 0x4]
MOV EDX,0x0
MOV EBP,0x1
MOV ECX,0x1
JMP 0x00101198
LAB_00101194:
MOV EDX,EBP
MOV EBP,ECX
LAB_00101198:
MOVSXD R8,EDX
MOV R8D,dword ptr [RAX + R8*0x4]
MOVSXD R9,ECX
MOV R11D,dword ptr [RAX + R9*0x4]
MOV R10D,R8D
IMUL R10D,R11D
MOV R9D,ESI
IMUL R9D,EDI
CMP R10D,R9D
CMOVG EDI,R11D
CMOVG ESI,R8D
ADD ECX,0x1
CMP EBX,ECX
JG 0x00101198
LEA ECX,[RBP + 0x1]
CMP EBX,ECX
JG 0x00101194
MOV dword ptr [R12],ESI
MOV dword ptr [R12 + 0x4],EDI
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_001011de:
MOV EAX,0x0
RET | int * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (1 < param_2) {
iVar5 = *param_1;
iVar6 = param_1[1];
iVar2 = 1;
iVar1 = 1;
iVar3 = 0;
do {
iVar4 = iVar1;
if (iVar5 * iVar6 < param_1[iVar3] * param_1[iVar2]) {
iVar5 = param_1[iVar3];
iVar6 = param_1[iVar2];
}
iVar2 = iVar2 + 1;
iVar1 = iVar4;
} while ((iVar2 < param_2) || (iVar2 = iVar4 + 1, iVar1 = iVar2, iVar3 = iVar4, iVar2 < param_2)
);
*param_3 = iVar5;
param_3[1] = iVar6;
return param_3;
}
return (int *)0x0;
} |
5,554 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
x = arr[i];
y = arr[j];
}
}
}
result[0] = x;
result[1] = y;
return result;
}
| int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
int arr3[] = {1,2,3};
func0(arr3, 3, result3);
assert(result3[0] == 2 && result3[1] == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 143e <func0+0x6e>
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
push %rbp
mov $0x1,%ecx
push %rbx
mov %rdx,%rbp
mov $0x1,%ebx
mov %r8d,%edx
nopw 0x0(%rax,%rax,1)
movslq %ecx,%r10
mov (%rdi,%r10,4),%eax
mov %r9d,%r10d
imul %r8d,%r10d
mov %eax,%r11d
imul %edx,%r11d
cmp %r10d,%r11d
cmovg %eax,%r9d
cmovg %edx,%r8d
add $0x1,%ecx
cmp %ecx,%esi
jg 13f8 <func0+0x28>
lea 0x1(%rbx),%ecx
cmp %ecx,%esi
jle 1430 <func0+0x60>
mov (%rdi,%rbx,4),%edx
movslq %ecx,%rbx
jmp 13f8 <func0+0x28>
xchg %ax,%ax
mov %r8d,0x0(%rbp)
mov %rbp,%rax
mov %r9d,0x4(%rbp)
pop %rbx
pop %rbp
retq
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, 1
jle short loc_135D
push rbp
mov ecx, 1
mov rbp, rdx
mov edx, 1
push rbx
mov rbx, rdi
mov edi, [rdi]
mov r8d, [rbx+4]
mov r10d, edi
nop dword ptr [rax+00h]
loc_1318:
movsxd r9, ecx
mov r11d, r8d
mov r9d, [rbx+r9*4]
imul r11d, edi
mov eax, r9d
imul eax, r10d
cmp eax, r11d
cmovg r8d, r9d
cmovg edi, r10d
add ecx, 1
cmp esi, ecx
jg short loc_1318
lea ecx, [rdx+1]
cmp esi, ecx
jle short loc_1350
mov r10d, [rbx+rdx*4]
movsxd rdx, ecx
jmp short loc_1318
loc_1350:
mov [rbp+0], edi
mov rax, rbp
mov [rbp+4], r8d
pop rbx
pop rbp
retn
loc_135D:
xor eax, eax
retn | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v3; // ecx
long long v5; // rdx
int v7; // edi
int v8; // r8d
int v9; // r10d
int v10; // r11d
int v11; // eax
_DWORD *result; // rax
if ( a2 <= 1 )
return 0LL;
v3 = 1;
v5 = 1LL;
v7 = *a1;
v8 = a1[1];
v9 = v7;
while ( 1 )
{
do
{
v10 = v7 * v8;
v11 = v9 * a1[v3];
if ( v11 > v7 * v8 )
v8 = a1[v3];
if ( v11 > v10 )
v7 = v9;
++v3;
}
while ( a2 > v3 );
v3 = v5 + 1;
if ( a2 <= (int)v5 + 1 )
break;
v9 = a1[v5];
v5 = v3;
}
*a3 = v7;
result = a3;
a3[1] = v8;
return result;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010135d
PUSH RBP
MOV ECX,0x1
MOV RBP,RDX
MOV EDX,0x1
PUSH RBX
MOV RBX,RDI
MOV EDI,dword ptr [RDI]
MOV R8D,dword ptr [RBX + 0x4]
MOV R10D,EDI
NOP dword ptr [RAX]
LAB_00101318:
MOVSXD R9,ECX
MOV R11D,R8D
MOV R9D,dword ptr [RBX + R9*0x4]
IMUL R11D,EDI
MOV EAX,R9D
IMUL EAX,R10D
CMP EAX,R11D
CMOVG R8D,R9D
CMOVG EDI,R10D
ADD ECX,0x1
CMP ESI,ECX
JG 0x00101318
LEA ECX,[RDX + 0x1]
CMP ESI,ECX
JLE 0x00101350
MOV R10D,dword ptr [RBX + RDX*0x4]
MOVSXD RDX,ECX
JMP 0x00101318
LAB_00101350:
MOV dword ptr [RBP],EDI
MOV RAX,RBP
MOV dword ptr [RBP + 0x4],R8D
POP RBX
POP RBP
RET
LAB_0010135d:
XOR EAX,EAX
RET | int * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 < 2) {
return (int *)0x0;
}
iVar1 = 1;
lVar2 = 1;
iVar3 = *param_1;
iVar4 = param_1[1];
iVar5 = iVar3;
while( true ) {
do {
if (iVar4 * iVar3 < param_1[iVar1] * iVar5) {
iVar3 = iVar5;
iVar4 = param_1[iVar1];
}
iVar1 = iVar1 + 1;
} while (iVar1 < param_2);
iVar1 = (int)lVar2 + 1;
if (param_2 <= iVar1) break;
iVar5 = param_1[lVar2];
lVar2 = (long)iVar1;
}
*param_3 = iVar3;
param_3[1] = iVar4;
return param_3;
} |
5,555 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
x = arr[i];
y = arr[j];
}
}
}
result[0] = x;
result[1] = y;
return result;
}
| int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
int arr3[] = {1,2,3};
func0(arr3, 3, result3);
assert(result3[0] == 2 && result3[1] == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 140e <func0+0x6e>
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
push %rbp
mov $0x1,%ecx
push %rbx
mov %rdx,%rbp
mov $0x1,%ebx
mov %r8d,%edx
nopw 0x0(%rax,%rax,1)
movslq %ecx,%r10
mov (%rdi,%r10,4),%eax
mov %r9d,%r10d
imul %r8d,%r10d
mov %eax,%r11d
imul %edx,%r11d
cmp %r10d,%r11d
cmovg %eax,%r9d
cmovg %edx,%r8d
add $0x1,%ecx
cmp %ecx,%esi
jg 13c8 <func0+0x28>
lea 0x1(%rbx),%ecx
cmp %ecx,%esi
jle 1400 <func0+0x60>
mov (%rdi,%rbx,4),%edx
movslq %ecx,%rbx
jmp 13c8 <func0+0x28>
xchg %ax,%ax
mov %r8d,0x0(%rbp)
mov %rbp,%rax
mov %r9d,0x4(%rbp)
pop %rbx
pop %rbp
retq
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, 1
jle short loc_137D
push r12
mov r12d, esi
push rbp
mov rbp, rdx
mov edx, 1
push rbx
mov rbx, rdi
mov r8d, [rdi]
mov edi, [rdi+4]
nop dword ptr [rax+00000000h]
loc_1338:
mov r10d, [rbx+rdx*4-4]
mov rcx, rdx
loc_1340:
mov r9d, [rbx+rcx*4]
mov r11d, r8d
mov eax, r10d
imul r11d, edi
imul eax, r9d
cmp eax, r11d
cmovg edi, r9d
cmovg r8d, r10d
add rcx, 1
cmp esi, ecx
jg short loc_1340
add rdx, 1
cmp rdx, r12
jnz short loc_1338
mov [rbp+0], r8d
mov rax, rbp
mov [rbp+4], edi
pop rbx
pop rbp
pop r12
retn
loc_137D:
xor eax, eax
retn | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
long long v4; // rdx
int v6; // r8d
int v7; // edi
int v8; // r10d
long long v9; // rcx
int v10; // r9d
int v11; // r11d
_DWORD *result; // rax
if ( a2 <= 1 )
return 0LL;
v4 = 1LL;
v6 = *a1;
v7 = a1[1];
do
{
v8 = a1[v4 - 1];
v9 = v4;
do
{
v10 = a1[v9];
v11 = v7 * v6;
if ( v10 * v8 > v7 * v6 )
v7 = a1[v9];
if ( v10 * v8 > v11 )
v6 = a1[v4 - 1];
++v9;
}
while ( a2 > (int)v9 );
++v4;
}
while ( v4 != a2 );
*a3 = v6;
result = a3;
a3[1] = v7;
return result;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010137d
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDX
MOV EDX,0x1
PUSH RBX
MOV RBX,RDI
MOV R8D,dword ptr [RDI]
MOV EDI,dword ptr [RDI + 0x4]
NOP dword ptr [RAX]
LAB_00101338:
MOV R10D,dword ptr [RBX + RDX*0x4 + -0x4]
MOV RCX,RDX
LAB_00101340:
MOV R9D,dword ptr [RBX + RCX*0x4]
MOV R11D,R8D
MOV EAX,R10D
IMUL R11D,EDI
IMUL EAX,R9D
CMP EAX,R11D
CMOVG EDI,R9D
CMOVG R8D,R10D
ADD RCX,0x1
CMP ESI,ECX
JG 0x00101340
ADD RDX,0x1
CMP RDX,R12
JNZ 0x00101338
MOV dword ptr [RBP],R8D
MOV RAX,RBP
MOV dword ptr [RBP + 0x4],EDI
POP RBX
POP RBP
POP R12
RET
LAB_0010137d:
XOR EAX,EAX
RET | int * func0(int *param_1,uint param_2,int *param_3)
{
ulong uVar1;
ulong uVar2;
int iVar3;
int iVar4;
if ((int)param_2 < 2) {
return (int *)0x0;
}
uVar2 = 1;
iVar4 = *param_1;
iVar3 = param_1[1];
do {
uVar1 = uVar2;
do {
if (iVar4 * iVar3 < param_1[uVar2 - 1] * param_1[uVar1]) {
iVar4 = param_1[uVar2 - 1];
iVar3 = param_1[uVar1];
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
*param_3 = iVar4;
param_3[1] = iVar3;
return param_3;
} |
5,556 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x34(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1207 <func0+0x9e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f0 <func0+0x87>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1231 <func0+0xc8>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
movl $0x0,(%rax)
mov -0x20(%rbp),%rax
movl $0x1,0x4(%rax)
movl $0x2,-0x2c(%rbp)
jmpq 12ee <func0+0x185>
mov -0x2c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x2c(%rbp),%eax
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %eax,%ecx
mov -0x2c(%rbp),%eax
lea 0x3(%rax),%edx
test %eax,%eax
cmovs %edx,%eax
sar $0x2,%eax
mov %eax,%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %eax,%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,-0x2c(%rbp)
jle 12ea <func0+0x181>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov -0x2c(%rbp),%ecx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x34(%rbp),%eax
jle 1265 <func0+0xfc>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 131e <func0+0x1b5>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_24]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D5:
cmp rsp, rdx
jz short loc_11EC
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11D5
loc_11EC:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1216
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1216:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1
mov [rbp+var_1C], 2
jmp loc_12D3
loc_124A:
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_1C]
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
sar eax, 1Fh
sub edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add ecx, eax
mov eax, [rbp+var_1C]
lea edx, [rax+3]
test eax, eax
cmovs eax, edx
sar eax, 2
mov edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add ecx, eax
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp [rbp+var_1C], eax
jle short loc_12CF
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rbp+var_1C]
mov [rax+rdx*4], ecx
loc_12CF:
add [rbp+var_1C], 1
loc_12D3:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jle loc_124A
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1303
call ___stack_chk_fail
locret_1303:
leave
retn | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
_DWORD v4[3]; // [rsp+8h] [rbp-30h] BYREF
int v5; // [rsp+14h] [rbp-24h]
int i; // [rsp+1Ch] [rbp-1Ch]
long long v7; // [rsp+20h] [rbp-18h]
_DWORD *v8; // [rsp+28h] [rbp-10h]
unsigned long long v9; // [rsp+30h] [rbp-8h]
v5 = a1;
v9 = __readfsqword(0x28u);
v7 = a1 + 1 - 1LL;
v1 = 16 * ((4LL * (a1 + 1) + 15) / 0x10uLL);
while ( v4 != (_DWORD *)((char *)v4 - (v1 & 0xFFFFFFFFFFFFF000LL)) )
;
v2 = alloca(v1 & 0xFFF);
if ( (v1 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v4[-2] + (v1 & 0xFFF)) = *(_QWORD *)((char *)&v4[-2] + (v1 & 0xFFF));
v8 = v4;
v4[0] = 0;
v4[1] = 1;
for ( i = 2; i <= v5; ++i )
{
v8[i] = v8[i / 4] + v8[i / 3] + v8[i / 2];
if ( i > v8[i] )
v8[i] = i;
}
return (unsigned int)v8[v5];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d5:
CMP RSP,RDX
JZ 0x001011ec
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d5
LAB_001011ec:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101216
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101216:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1
MOV dword ptr [RBP + -0x1c],0x2
JMP 0x001012d3
LAB_0010124a:
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
SAR EAX,0x1f
SUB EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD ECX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x3]
TEST EAX,EAX
CMOVS EAX,EDX
SAR EAX,0x2
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP dword ptr [RBP + -0x1c],EAX
JLE 0x001012cf
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_001012cf:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012d3:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x0010124a
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101303
CALL 0x00101060
LAB_00101303:
LEAVE
RET | int4 func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_38 [12];
int local_2c;
int local_24;
long local_20;
int *local_18;
long local_10;
local_2c = param_1;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_1 + 1) + -1;
uVar3 = (((long)(param_1 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar4 = auStack_38; puVar4 != auStack_38 + -(uVar3 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
*(int4 *)(puVar4 + lVar1) = 0;
*(int4 *)(puVar4 + lVar1 + 4) = 1;
for (local_24 = 2; local_24 <= local_2c; local_24 = local_24 + 1) {
iVar2 = local_24;
if (local_24 < 0) {
iVar2 = local_24 + 3;
}
*(int *)(puVar4 + (long)local_24 * 4 + lVar1) =
*(int *)(puVar4 + (long)(local_24 / 2) * 4 + lVar1) +
*(int *)(puVar4 + (long)(local_24 / 3) * 4 + lVar1) +
*(int *)(puVar4 + (long)(iVar2 >> 2) * 4 + lVar1);
if (*(int *)(puVar4 + (long)local_24 * 4 + lVar1) < local_24) {
*(int *)(puVar4 + (long)local_24 * 4 + lVar1) = local_24;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar4 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar4 + (long)local_2c * 4 + lVar1);
} |
5,557 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 11be <func0+0x55>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a7 <func0+0x3e>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d4 <func0+0x6b>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r8
mov %r8,%rax
shr $0x2,%rax
and $0xfffffffffffffffc,%r8
mov %r8,%rcx
movl $0x0,0x0(,%rax,4)
movl $0x1,0x4(,%rax,4)
cmp $0x1,%edi
jle 1266 <func0+0xfd>
lea -0x2(%rdi),%esi
add $0x3,%rsi
mov $0x2,%eax
mov %eax,%r9d
shr $0x1f,%r9d
add %eax,%r9d
sar %r9d
movslq %r9d,%r9
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
mov %eax,%r10d
sar $0x1f,%r10d
sub %r10d,%edx
movslq %edx,%rdx
mov (%rcx,%rdx,4),%edx
add (%rcx,%r9,4),%edx
lea 0x3(%rax),%r9d
test %eax,%eax
cmovns %eax,%r9d
sar $0x2,%r9d
movslq %r9d,%r9
add (%rcx,%r9,4),%edx
cmp %eax,%edx
cmovl %eax,%edx
mov %edx,(%rcx,%rax,4)
add $0x1,%rax
cmp %rsi,%rax
jne 120e <func0+0xa5>
movslq %edi,%rdi
mov (%r8,%rdi,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 127e <func0+0x115>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r8d, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A7:
cmp rsp, rdx
jz short loc_11BE
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11A7
loc_11BE:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D4
or [rsp+rax+10h+var_18], 0
loc_11D4:
lea rcx, [rsp+10h+var_D]
mov rax, rcx
shr rax, 2
and rcx, 0FFFFFFFFFFFFFFFCh
mov ds:dword_0[rax*4], 0
mov dword ptr ds:byte_4[rax*4], 1
cmp r8d, 1
jle short loc_127F
mov dword ptr ds:byte_8[rax*4], 1
lea edi, [r8+1]
mov eax, 3
mov esi, 2
jmp short loc_121F
loc_121B:
add rax, 1
loc_121F:
mov [rcx+rax*4-4], esi
mov esi, eax
cmp rdi, rax
jz short loc_127F
mov r9d, eax
shr r9d, 1Fh
add r9d, eax
sar r9d, 1
movsxd r9, r9d
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
mov r10d, eax
sar r10d, 1Fh
sub edx, r10d
movsxd rdx, edx
mov edx, [rcx+rdx*4]
add edx, [rcx+r9*4]
mov r9d, edx
lea edx, [rax+3]
test eax, eax
cmovns edx, eax
sar edx, 2
movsxd rdx, edx
add r9d, [rcx+rdx*4]
mov [rcx+rax*4], r9d
cmp r9d, eax
jl short loc_121B
mov esi, r9d
jmp short loc_121B
loc_127F:
movsxd r8, r8d
mov eax, [rcx+r8*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1297
leave
retn
loc_1297:
call ___stack_chk_fail | long long func0(int a1)
{
signed long long v2; // rax
void *v3; // rsp
unsigned long long v4; // rax
long long v5; // rdi
long long v6; // rax
int v7; // esi
int v8; // r9d
_BYTE v11[3]; // [rsp+8h] [rbp-10h] BYREF
char v12; // [rsp+Bh] [rbp-Dh] BYREF
unsigned long long v13; // [rsp+10h] [rbp-8h]
v13 = __readfsqword(0x28u);
while ( v11 != &v11[-((4LL * (a1 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)] )
;
v2 = (4 * ((_WORD)a1 + 1) + 15) & 0xFF0;
v3 = alloca(v2);
if ( ((4 * ((_WORD)a1 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)&v11[v2 - 8] = *(_QWORD *)&v11[v2 - 8];
v4 = (unsigned long long)&v12 >> 2;
*(_DWORD *)(4 * v4) = 0;
*(_DWORD *)&byte_4[4 * v4] = 1;
if ( a1 > 1 )
{
LODWORD(v13) = 1;
v5 = (unsigned int)(a1 + 1);
v6 = 3LL;
v7 = 2;
while ( 1 )
{
*(_DWORD *)&v11[4 * v6 - 4] = v7;
v7 = v6;
if ( v5 == v6 )
break;
v8 = *(_DWORD *)&v11[4 * ((int)v6 / 4)] + *(_DWORD *)&v11[4 * ((int)v6 / 2)] + *(_DWORD *)&v11[4 * ((int)v6 / 3)];
*(_DWORD *)&v11[4 * v6] = v8;
if ( v8 >= (int)v6 )
v7 = v8;
++v6;
}
}
return *(unsigned int *)&v11[4 * a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a7:
CMP RSP,RDX
JZ 0x001011be
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011a7
LAB_001011be:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d4
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d4:
LEA RCX,[RSP + 0x3]
MOV RAX,RCX
SHR RAX,0x2
AND RCX,-0x4
MOV dword ptr [RAX*0x4],0x0
MOV dword ptr [0x4 + RAX*0x4],0x1
CMP R8D,0x1
JLE 0x0010127f
MOV dword ptr [0x8 + RAX*0x4],0x1
LEA EDI,[R8 + 0x1]
MOV EAX,0x3
MOV ESI,0x2
JMP 0x0010121f
LAB_0010121b:
ADD RAX,0x1
LAB_0010121f:
MOV dword ptr [RCX + RAX*0x4 + -0x4],ESI
MOV ESI,EAX
CMP RDI,RAX
JZ 0x0010127f
MOV R9D,EAX
SHR R9D,0x1f
ADD R9D,EAX
SAR R9D,0x1
MOVSXD R9,R9D
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
MOV R10D,EAX
SAR R10D,0x1f
SUB EDX,R10D
MOVSXD RDX,EDX
MOV EDX,dword ptr [RCX + RDX*0x4]
ADD EDX,dword ptr [RCX + R9*0x4]
MOV R9D,EDX
LEA EDX,[RAX + 0x3]
TEST EAX,EAX
CMOVNS EDX,EAX
SAR EDX,0x2
MOVSXD RDX,EDX
ADD R9D,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RCX + RAX*0x4],R9D
CMP R9D,EAX
JL 0x0010121b
MOV ESI,R9D
JMP 0x0010121b
LAB_0010127f:
MOVSXD R8,R8D
MOV EAX,dword ptr [RCX + R8*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101297
LEAVE
RET
LAB_00101297:
CALL 0x00101060 | int4 func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int1 *puVar6;
uint uVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_1 + 1) * 4 + 0xf;
for (puVar6 = auStack_18; puVar6 != auStack_18 + -(uVar3 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
if (uVar3 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar3 = (ulong)(puVar6 + lVar1 + 3) >> 2;
*(int4 *)(uVar3 * 4) = 0;
*(int4 *)(uVar3 * 4 + 4) = 1;
if (1 < param_1) {
*(int4 *)(uVar3 * 4 + 8) = 1;
uVar4 = 3;
uVar3 = 2;
while( true ) {
*(int *)(puVar6 + uVar4 * 4 + lVar1 + -4) = (int)uVar3;
iVar2 = (int)uVar4;
if (param_1 + 1 == uVar4) break;
iVar5 = iVar2 + 3;
if (-1 < iVar2) {
iVar5 = iVar2;
}
uVar7 = *(int *)(puVar6 + (long)(iVar2 / 3) * 4 + lVar1) +
*(int *)(puVar6 + (long)((int)(((uint)(uVar4 >> 0x1f) & 1) + iVar2) >> 1) * 4 + lVar1)
+ *(int *)(puVar6 + (long)(iVar5 >> 2) * 4 + lVar1);
*(uint *)(puVar6 + uVar4 * 4 + lVar1) = uVar7;
uVar3 = uVar4 & 0xffffffff;
if (iVar2 <= (int)uVar7) {
uVar3 = (ulong)uVar7;
}
uVar4 = uVar4 + 1;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar6 + (long)param_1 * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar1 + -8) = main;
__stack_chk_fail();
} |
5,558 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rcx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1268 <func0+0x58>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1253 <func0+0x43>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1318 <func0+0x108>
movabs $0x100000000,%rcx
lea 0x3(%rsp),%r8
mov %r8,%rax
and $0xfffffffffffffffc,%r8
shr $0x2,%rax
mov %rcx,0x0(,%rax,4)
cmp $0x1,%edi
jle 12fb <func0+0xeb>
lea -0x2(%rdi),%r9d
mov $0x2,%ecx
xor %edx,%edx
xor %esi,%esi
add $0x3,%r9
mov $0x1,%eax
mov $0xaaaaaaab,%r10d
jmp 12e2 <func0+0xd2>
mov %edx,%esi
mov %edx,%eax
sar $0x2,%edx
imul %r10,%rsi
sar %eax
movslq %edx,%rdx
cltq
mov (%r8,%rdx,4),%edx
mov (%r8,%rax,4),%eax
shr $0x21,%rsi
mov (%r8,%rsi,4),%esi
add %esi,%eax
add %edx,%eax
lea 0x1(%rcx),%edx
cmp %ecx,%eax
cmovl %ecx,%eax
mov %eax,(%r8,%rcx,4)
add $0x1,%rcx
cmp %rcx,%r9
jne 12c0 <func0+0xb0>
movslq %edi,%rdi
mov (%r8,%rdi,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 1323 <func0+0x113>
leaveq
retq
nopl 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 127a <func0+0x6a>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r9, edi
lea edi, [r9+1]
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_126A
loc_1255:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1255
loc_126A:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1318
loc_127C:
mov rdx, 100000000h
lea rcx, [rsp+1010h+var_100D]
mov rax, rcx
and rcx, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov qword ptr ds:dword_0[rax*4], rdx
cmp r9d, 1
jle short loc_12FF
mov edi, edi
mov edx, 3
mov dword ptr ds:byte_8[rax*4], 1
mov r8d, 0AAAAAAABh
mov eax, 2
jmp short loc_12F6
loc_12C8:
mov eax, edx
mov esi, edx
imul rax, r8
sar esi, 1
movsxd rsi, esi
shr rax, 21h
mov eax, [rcx+rax*4]
add eax, [rcx+rsi*4]
mov esi, edx
sar esi, 2
movsxd rsi, esi
add eax, [rcx+rsi*4]
cmp eax, edx
mov [rcx+rdx*4], eax
cmovl eax, edx
add rdx, 1
loc_12F6:
mov [rcx+rdx*4-4], eax
cmp rdx, rdi
jnz short loc_12C8
loc_12FF:
mov eax, [rcx+r9*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1323
leave
retn
loc_1318:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_127C
loc_1323:
call ___stack_chk_fail | long long func0(int a1)
{
long long v1; // r9
int v2; // edi
long long v3; // rdx
long long *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
long long v8; // rdx
int v9; // eax
long long v11; // [rsp+0h] [rbp-1018h]
long long v12; // [rsp+8h] [rbp-1010h] BYREF
int v13; // [rsp+10h] [rbp-1008h]
_QWORD v14[2]; // [rsp+1008h] [rbp-10h] BYREF
v1 = a1;
v2 = a1 + 1;
v14[1] = __readfsqword(0x28u);
v3 = 4LL * v2 + 15;
v4 = (_QWORD *)((char *)v14 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( v14 != v4 )
{
while ( &v12 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(long long *)((char *)&v11 + v6) = *(long long *)((char *)&v11 + v6);
v12 = 0x100000000LL;
if ( (int)v1 > 1 )
{
v8 = 3LL;
v13 = 1;
v9 = 2;
while ( 1 )
{
*((_DWORD *)&v12 + v8 - 1) = v9;
if ( v8 == v2 )
break;
v9 = *((_DWORD *)&v12 + ((int)v8 >> 2))
+ *((_DWORD *)&v12 + ((int)v8 >> 1))
+ *((_DWORD *)&v12 + (unsigned int)v8 / 3uLL);
*((_DWORD *)&v12 + v8) = v9;
if ( v9 < (int)v8 )
v9 = v8;
++v8;
}
}
return *((unsigned int *)&v12 + v1);
} | func0:
ENDBR64
PUSH RBP
MOVSXD R9,EDI
LEA EDI,[R9 + 0x1]
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010126a
LAB_00101255:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101255
LAB_0010126a:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101318
LAB_0010127c:
MOV RDX,0x100000000
LEA RCX,[RSP + 0x3]
MOV RAX,RCX
AND RCX,-0x4
SHR RAX,0x2
MOV qword ptr [RAX*0x4],RDX
CMP R9D,0x1
JLE 0x001012ff
MOV EDI,EDI
MOV EDX,0x3
MOV dword ptr [0x8 + RAX*0x4],0x1
MOV R8D,0xaaaaaaab
MOV EAX,0x2
JMP 0x001012f6
LAB_001012c8:
MOV EAX,EDX
MOV ESI,EDX
IMUL RAX,R8
SAR ESI,0x1
MOVSXD RSI,ESI
SHR RAX,0x21
MOV EAX,dword ptr [RCX + RAX*0x4]
ADD EAX,dword ptr [RCX + RSI*0x4]
MOV ESI,EDX
SAR ESI,0x2
MOVSXD RSI,ESI
ADD EAX,dword ptr [RCX + RSI*0x4]
CMP EAX,EDX
MOV dword ptr [RCX + RDX*0x4],EAX
CMOVL EAX,EDX
ADD RDX,0x1
LAB_001012f6:
MOV dword ptr [RCX + RDX*0x4 + -0x4],EAX
CMP RDX,RDI
JNZ 0x001012c8
LAB_001012ff:
MOV EAX,dword ptr [RCX + R9*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101323
LEAVE
RET
LAB_00101318:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010127c
LAB_00101323:
CALL 0x00101060 | int4 func0(int param_1)
{
long lVar1;
int1 *puVar2;
uint uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int1 *puVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)(param_1 + 1U) * 4 + 0xf;
puVar8 = auStack_18;
puVar2 = auStack_18;
while (puVar8 != auStack_18 + -(uVar4 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
*(int8 *)(((ulong)(puVar7 + lVar1 + 3) >> 2) * 4) = 0x100000000;
if (1 < param_1) {
*(int4 *)(((ulong)(puVar7 + lVar1 + 3) >> 2) * 4 + 8) = 1;
uVar4 = 2;
for (uVar6 = 3; *(int *)(puVar7 + uVar6 * 4 + lVar1 + -4) = (int)uVar4, uVar6 != param_1 + 1U;
uVar6 = uVar6 + 1) {
iVar5 = (int)uVar6;
uVar3 = *(int *)(puVar7 + ((uVar6 & 0xffffffff) / 3) * 4 + lVar1) +
*(int *)(puVar7 + (long)(iVar5 >> 1) * 4 + lVar1) +
*(int *)(puVar7 + (long)(iVar5 >> 2) * 4 + lVar1);
*(uint *)(puVar7 + uVar6 * 4 + lVar1) = uVar3;
uVar4 = (ulong)uVar3;
if ((int)uVar3 < iVar5) {
uVar4 = uVar6 & 0xffffffff;
}
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar1 + -8) = _fini;
__stack_chk_fail();
}
return *(int4 *)(puVar7 + (long)param_1 * 4 + lVar1);
} |
5,559 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rcx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1268 <func0+0x58>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1253 <func0+0x43>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1318 <func0+0x108>
movabs $0x100000000,%rcx
lea 0x3(%rsp),%r8
mov %r8,%rax
and $0xfffffffffffffffc,%r8
shr $0x2,%rax
mov %rcx,0x0(,%rax,4)
cmp $0x1,%edi
jle 12fb <func0+0xeb>
lea -0x2(%rdi),%r9d
mov $0x2,%ecx
xor %edx,%edx
xor %esi,%esi
add $0x3,%r9
mov $0x1,%eax
mov $0xaaaaaaab,%r10d
jmp 12e2 <func0+0xd2>
mov %edx,%esi
mov %edx,%eax
sar $0x2,%edx
imul %r10,%rsi
sar %eax
movslq %edx,%rdx
cltq
mov (%r8,%rdx,4),%edx
mov (%r8,%rax,4),%eax
shr $0x21,%rsi
mov (%r8,%rsi,4),%esi
add %esi,%eax
add %edx,%eax
lea 0x1(%rcx),%edx
cmp %ecx,%eax
cmovl %ecx,%eax
mov %eax,(%r8,%rcx,4)
add $0x1,%rcx
cmp %r9,%rcx
jne 12c0 <func0+0xb0>
movslq %edi,%rdi
mov (%r8,%rdi,4),%eax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
jne 1323 <func0+0x113>
leaveq
retq
nopl 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 127a <func0+0x6a>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r10, edi
lea r8d, [r10+1]
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, r8d
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_126A
loc_1255:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1255
loc_126A:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1320
loc_127C:
lea rdi, [rsp+1010h+var_100D]
mov rdx, cs:qword_2058
mov rax, rdi
and rdi, 0FFFFFFFFFFFFFFFCh
shr rax, 2
mov qword ptr ds:dword_0[rax*4], rdx
cmp r10d, 1
jle short loc_1308
mov r8d, r8d
mov edx, 2
xor r11d, r11d
xor esi, esi
mov ecx, 1
mov r9d, 0AAAAAAABh
jmp short loc_12EF
loc_12C0:
mov [rdi+rdx*4], edx
lea eax, [rdx+1]
add rdx, 1
cmp r8, rdx
jz short loc_1308
loc_12CF:
mov esi, eax
mov ecx, eax
sar eax, 2
imul rsi, r9
sar ecx, 1
cdqe
movsxd rcx, ecx
mov r11d, [rdi+rax*4]
mov ecx, [rdi+rcx*4]
shr rsi, 21h
mov esi, [rdi+rsi*4]
loc_12EF:
lea eax, [rcx+rsi]
add eax, r11d
cmp eax, edx
jl short loc_12C0
mov [rdi+rdx*4], eax
lea eax, [rdx+1]
add rdx, 1
cmp rdx, r8
jnz short loc_12CF
loc_1308:
mov eax, [rdi+r10*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_132B
leave
retn
loc_1320:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_127C
loc_132B:
call ___stack_chk_fail | long long func0(int a1)
{
int v1; // r8d
long long v2; // rdx
_QWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long v7; // rdx
int v8; // r11d
int v9; // esi
int v10; // ecx
int v11; // eax
int v12; // eax
_QWORD v15[511]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v16[2]; // [rsp+1008h] [rbp-10h] BYREF
v1 = a1 + 1;
v16[1] = __readfsqword(0x28u);
v2 = 4LL * (a1 + 1) + 15;
v3 = (_QWORD *)((char *)v16 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( v16 != v3 )
{
while ( v15 != v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(_QWORD *)((char *)&v15[-1] + v5) = *(_QWORD *)((char *)&v15[-1] + v5);
v15[0] = 0x100000000LL;
if ( a1 > 1 )
{
v7 = 2LL;
v8 = 0;
v9 = 0;
v10 = 1;
while ( 1 )
{
v12 = v8 + v10 + v9;
if ( v12 < (int)v7 )
{
*((_DWORD *)v15 + v7) = v7;
v11 = ++v7;
if ( v1 == v7 )
return *((unsigned int *)v15 + a1);
}
else
{
*((_DWORD *)v15 + v7) = v12;
v11 = ++v7;
if ( v7 == v1 )
return *((unsigned int *)v15 + a1);
}
v8 = *((_DWORD *)v15 + (v11 >> 2));
v10 = *((_DWORD *)v15 + (v11 >> 1));
v9 = *((_DWORD *)v15 + (unsigned int)v11 / 3uLL);
}
}
return *((unsigned int *)v15 + a1);
} | func0:
ENDBR64
PUSH RBP
MOVSXD R10,EDI
LEA R8D,[R10 + 0x1]
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,R8D
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010126a
LAB_00101255:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101255
LAB_0010126a:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101320
LAB_0010127c:
LEA RDI,[RSP + 0x3]
MOV RDX,qword ptr [0x00102058]
MOV RAX,RDI
AND RDI,-0x4
SHR RAX,0x2
MOV qword ptr [RAX*0x4],RDX
CMP R10D,0x1
JLE 0x00101308
MOV R8D,R8D
MOV EDX,0x2
XOR R11D,R11D
XOR ESI,ESI
MOV ECX,0x1
MOV R9D,0xaaaaaaab
JMP 0x001012ef
LAB_001012c0:
MOV dword ptr [RDI + RDX*0x4],EDX
LEA EAX,[RDX + 0x1]
ADD RDX,0x1
CMP R8,RDX
JZ 0x00101308
LAB_001012cf:
MOV ESI,EAX
MOV ECX,EAX
SAR EAX,0x2
IMUL RSI,R9
SAR ECX,0x1
CDQE
MOVSXD RCX,ECX
MOV R11D,dword ptr [RDI + RAX*0x4]
MOV ECX,dword ptr [RDI + RCX*0x4]
SHR RSI,0x21
MOV ESI,dword ptr [RDI + RSI*0x4]
LAB_001012ef:
LEA EAX,[RCX + RSI*0x1]
ADD EAX,R11D
CMP EAX,EDX
JL 0x001012c0
MOV dword ptr [RDI + RDX*0x4],EAX
LEA EAX,[RDX + 0x1]
ADD RDX,0x1
CMP RDX,R8
JNZ 0x001012cf
LAB_00101308:
MOV EAX,dword ptr [RDI + R10*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010132b
LEAVE
RET
LAB_00101320:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010127c
LAB_0010132b:
CALL 0x00101060 | int4 func0(int param_1)
{
long lVar1;
int *puVar2;
int iVar3;
uint uVar4;
int iVar5;
ulong uVar6;
long lVar7;
int *puVar8;
int iVar10;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar9;
puVar8 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(int)(param_1 + 1U) * 4 + 0xf;
puVar9 = auStack_18;
puVar2 = auStack_18;
while (puVar9 != auStack_18 + -(uVar6 & 0xfffffffffffff000)) {
puVar8 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar9 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar1 = -uVar6;
if (uVar6 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
*(int8 *)(puVar8 + lVar1) = DAT_00102058;
if (1 < param_1) {
lVar7 = 2;
iVar3 = 0;
iVar10 = 0;
iVar5 = 1;
while( true ) {
iVar3 = iVar5 + iVar10 + iVar3;
iVar5 = (int)lVar7;
if (iVar3 < iVar5) {
*(int *)(puVar8 + lVar7 * 4 + lVar1) = iVar5;
}
else {
*(int *)(puVar8 + lVar7 * 4 + lVar1) = iVar3;
}
if ((ulong)(param_1 + 1U) == lVar7 + 1U) break;
uVar4 = iVar5 + 1;
lVar7 = lVar7 + 1;
iVar3 = *(int *)(puVar8 + (long)((int)uVar4 >> 2) * 4 + lVar1);
iVar5 = *(int *)(puVar8 + (long)((int)uVar4 >> 1) * 4 + lVar1);
iVar10 = *(int *)(puVar8 + ((ulong)uVar4 / 3) * 4 + lVar1);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar8 + lVar1 + -8) = _fini;
__stack_chk_fail();
}
return *(int4 *)(puVar8 + (long)param_1 * 4 + lVar1);
} |
5,560 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t new_size = out[j].size + 1;
out[j].values = realloc(out[j].values, new_size);
out[j].values[new_size - 1] = Input[i][1];
out[j].size = new_size;
found = 1;
break;
}
}
if (!found) {
out[outCount].key = Input[i][0];
out[outCount].values = malloc(2);
out[outCount].values[0] = Input[i][0];
out[outCount].values[1] = Input[i][1];
out[outCount].size = 2;
outCount++;
}
}
*returnSize = outCount;
return out;
}
| int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size == 2);
free(result1[0].values);
free(result1[1].values);
free(result1);
char input2[][2] = { {'a', 'b'}, {'a', 'c'}, {'d', 'e'} };
int size2;
TupleGroup *result2 = func0(input2, 3, &size2);
assert(size2 == 2);
assert(memcmp(result2[0].values, "abc", 3) == 0 && result2[0].size == 3);
assert(memcmp(result2[1].values, "de", 2) == 0 && result2[1].size == 2);
free(result2[0].values);
free(result2[1].values);
free(result2);
char input3[][2] = { {'f', 'g'}, {'f', 'g'}, {'h', 'i'} };
int size3;
TupleGroup *result3 = func0(input3, 3, &size3);
assert(size3 == 2);
assert(memcmp(result3[0].values, "fgg", 3) == 0 && result3[0].size == 3);
assert(memcmp(result3[1].values, "hi", 2) == 0 && result3[1].size == 2);
free(result3[0].values);
free(result3[1].values);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov -0x40(%rbp),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x30(%rbp)
movl $0x0,-0x2c(%rbp)
jmpq 1485 <func0+0x29c>
movl $0x0,-0x28(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 1370 <func0+0x187>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x2c(%rbp),%eax
cltq
lea (%rax,%rax,1),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 136c <func0+0x183>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x10(%rax),%rax
add $0x1,%rax
mov %rax,-0x18(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rcx
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov -0x18(%rbp),%rax
mov %rax,%rsi
mov %rcx,%rdi
callq 10f0 <realloc@plt>
mov %rax,0x8(%rbx)
mov -0x2c(%rbp),%eax
cltq
lea (%rax,%rax,1),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rax
mov -0x18(%rbp),%rdx
sub $0x1,%rdx
add %rax,%rdx
movzbl 0x1(%rcx),%eax
mov %al,(%rdx)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x18(%rbp),%rax
mov %rax,0x10(%rdx)
movl $0x1,-0x28(%rbp)
jmp 137c <func0+0x193>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1245 <func0+0x5c>
cmpl $0x0,-0x28(%rbp)
jne 1481 <func0+0x298>
mov -0x2c(%rbp),%eax
cltq
lea (%rax,%rax,1),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov $0x2,%edi
callq 10e0 <malloc@plt>
mov %rax,0x8(%rbx)
mov -0x2c(%rbp),%eax
cltq
lea (%rax,%rax,1),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rax
movzbl (%rcx),%edx
mov %dl,(%rax)
mov -0x2c(%rbp),%eax
cltq
lea (%rax,%rax,1),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rax
lea 0x1(%rax),%rdx
movzbl 0x1(%rcx),%eax
mov %al,(%rdx)
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movq $0x2,0x10(%rax)
addl $0x1,-0x30(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cltq
cmp %rax,-0x40(%rbp)
ja 1232 <func0+0x49>
mov -0x48(%rbp),%rax
mov -0x30(%rbp),%edx
mov %edx,(%rax)
mov -0x20(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rdx, [rbp+var_40]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov [rbp+var_30], 0
mov [rbp+var_2C], 0
jmp loc_1485
loc_1232:
mov [rbp+var_28], 0
mov [rbp+var_24], 0
jmp loc_1370
loc_1245:
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_2C]
cdqe
lea rcx, [rax+rax]
mov rax, [rbp+var_38]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz loc_136C
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
mov rax, [rax+10h]
add rax, 1
mov [rbp+size], rax
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
mov rcx, [rax+8]
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
lea rbx, [rdx+rax]
mov rax, [rbp+size]
mov rsi, rax; size
mov rdi, rcx; ptr
call _realloc
mov [rbx+8], rax
mov eax, [rbp+var_2C]
cdqe
lea rdx, [rax+rax]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
mov rax, [rax+8]
mov rdx, [rbp+size]
sub rdx, 1
add rdx, rax
movzx eax, byte ptr [rcx+1]
mov [rdx], al
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rdx, rax
mov rax, [rbp+size]
mov [rdx+10h], rax
mov [rbp+var_28], 1
jmp short loc_137C
loc_136C:
add [rbp+var_24], 1
loc_1370:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_30]
jl loc_1245
loc_137C:
cmp [rbp+var_28], 0
jnz loc_1481
mov eax, [rbp+var_2C]
cdqe
lea rdx, [rax+rax]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
lea rbx, [rdx+rax]
mov edi, 2; size
call _malloc
mov [rbx+8], rax
mov eax, [rbp+var_2C]
cdqe
lea rdx, [rax+rax]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
mov rax, [rax+8]
movzx edx, byte ptr [rcx]
mov [rax], dl
mov eax, [rbp+var_2C]
cdqe
lea rdx, [rax+rax]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
mov rax, [rax+8]
lea rdx, [rax+1]
movzx eax, byte ptr [rcx+1]
mov [rdx], al
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_20]
add rax, rdx
mov qword ptr [rax+10h], 2
add [rbp+var_30], 1
loc_1481:
add [rbp+var_2C], 1
loc_1485:
mov eax, [rbp+var_2C]
cdqe
cmp rax, [rbp+var_40]
jb loc_1232
mov rax, [rbp+var_48]
mov edx, [rbp+var_30]
mov [rax], edx
mov rax, [rbp+var_20]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, unsigned long long a2, _DWORD *a3)
{
int v5; // [rsp+20h] [rbp-30h]
int i; // [rsp+24h] [rbp-2Ch]
int v7; // [rsp+28h] [rbp-28h]
int j; // [rsp+2Ch] [rbp-24h]
_QWORD *v9; // [rsp+30h] [rbp-20h]
long long size; // [rsp+38h] [rbp-18h]
v9 = malloc(24 * a2);
v5 = 0;
for ( i = 0; i < a2; ++i )
{
v7 = 0;
for ( j = 0; j < v5; ++j )
{
if ( LOBYTE(v9[3 * j]) == *(_BYTE *)(2LL * i + a1) )
{
size = v9[3 * j + 2] + 1LL;
v9[3 * j + 1] = realloc((void *)v9[3 * j + 1], size);
*(_BYTE *)(v9[3 * j + 1] + size - 1) = *(_BYTE *)(2LL * i + a1 + 1);
v9[3 * j + 2] = size;
v7 = 1;
break;
}
}
if ( !v7 )
{
LOBYTE(v9[3 * v5]) = *(_BYTE *)(2LL * i + a1);
v9[3 * v5 + 1] = malloc(2uLL);
*(_BYTE *)v9[3 * v5 + 1] = *(_BYTE *)(2LL * i + a1);
*(_BYTE *)(v9[3 * v5 + 1] + 1LL) = *(_BYTE *)(2LL * i + a1 + 1);
v9[3 * v5++ + 2] = 2LL;
}
}
*a3 = v5;
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101485
LAB_00101232:
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101370
LAB_00101245:
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x0010136c
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RCX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RAX
MOV RDI,RCX
CALL 0x001010f0
MOV qword ptr [RBX + 0x8],RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX + 0x1]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RDX + 0x10],RAX
MOV dword ptr [RBP + -0x28],0x1
JMP 0x0010137c
LAB_0010136c:
ADD dword ptr [RBP + -0x24],0x1
LAB_00101370:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101245
LAB_0010137c:
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x00101481
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV EDI,0x2
CALL 0x001010e0
MOV qword ptr [RBX + 0x8],RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EDX,byte ptr [RCX]
MOV byte ptr [RAX],DL
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x8]
LEA RDX,[RAX + 0x1]
MOVZX EAX,byte ptr [RCX + 0x1]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV qword ptr [RAX + 0x10],0x2
ADD dword ptr [RBP + -0x30],0x1
LAB_00101481:
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101485:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
CMP RAX,qword ptr [RBP + -0x40]
JC 0x00101232
MOV RAX,qword ptr [RBP + -0x48]
MOV EDX,dword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,ulong param_2,int *param_3)
{
long lVar1;
bool bVar2;
void *pvVar3;
size_t __size;
void *pvVar4;
int local_38;
int local_34;
int local_2c;
pvVar3 = malloc(param_2 * 0x18);
local_38 = 0;
local_34 = 0;
do {
if (param_2 <= (ulong)(long)local_34) {
*param_3 = local_38;
return pvVar3;
}
bVar2 = false;
for (local_2c = 0; local_2c < local_38; local_2c = local_2c + 1) {
if (*(char *)((long)pvVar3 + (long)local_2c * 0x18) == *(char *)(param_1 + (long)local_34 * 2)
) {
lVar1 = *(long *)((long)pvVar3 + (long)local_2c * 0x18 + 0x10);
__size = lVar1 + 1;
pvVar4 = realloc(*(void **)((long)pvVar3 + (long)local_2c * 0x18 + 8),__size);
*(void **)((long)pvVar3 + (long)local_2c * 0x18 + 8) = pvVar4;
*(int *)(lVar1 + *(long *)((long)pvVar3 + (long)local_2c * 0x18 + 8)) =
*(int *)((long)local_34 * 2 + param_1 + 1);
*(size_t *)((long)pvVar3 + (long)local_2c * 0x18 + 0x10) = __size;
bVar2 = true;
break;
}
}
if (!bVar2) {
*(int *)((long)local_38 * 0x18 + (long)pvVar3) =
*(int *)((long)local_34 * 2 + param_1);
pvVar4 = malloc(2);
*(void **)((long)pvVar3 + (long)local_38 * 0x18 + 8) = pvVar4;
**(int **)((long)pvVar3 + (long)local_38 * 0x18 + 8) =
*(int *)((long)local_34 * 2 + param_1);
*(int *)(*(long *)((long)pvVar3 + (long)local_38 * 0x18 + 8) + 1) =
*(int *)((long)local_34 * 2 + param_1 + 1);
*(int8 *)((long)pvVar3 + (long)local_38 * 0x18 + 0x10) = 2;
local_38 = local_38 + 1;
}
local_34 = local_34 + 1;
} while( true );
} |
5,561 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t new_size = out[j].size + 1;
out[j].values = realloc(out[j].values, new_size);
out[j].values[new_size - 1] = Input[i][1];
out[j].size = new_size;
found = 1;
break;
}
}
if (!found) {
out[outCount].key = Input[i][0];
out[outCount].values = malloc(2);
out[outCount].values[0] = Input[i][0];
out[outCount].values[1] = Input[i][1];
out[outCount].size = 2;
outCount++;
}
}
*returnSize = outCount;
return out;
}
| int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size == 2);
free(result1[0].values);
free(result1[1].values);
free(result1);
char input2[][2] = { {'a', 'b'}, {'a', 'c'}, {'d', 'e'} };
int size2;
TupleGroup *result2 = func0(input2, 3, &size2);
assert(size2 == 2);
assert(memcmp(result2[0].values, "abc", 3) == 0 && result2[0].size == 3);
assert(memcmp(result2[1].values, "de", 2) == 0 && result2[1].size == 2);
free(result2[0].values);
free(result2[1].values);
free(result2);
char input3[][2] = { {'f', 'g'}, {'f', 'g'}, {'h', 'i'} };
int size3;
TupleGroup *result3 = func0(input3, 3, &size3);
assert(size3 == 2);
assert(memcmp(result3[0].values, "fgg", 3) == 0 && result3[0].size == 3);
assert(memcmp(result3[1].values, "hi", 2) == 0 && result3[1].size == 2);
free(result3[0].values);
free(result3[1].values);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,%rbx
mov %rdx,0x18(%rsp)
lea (%rsi,%rsi,2),%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r13
test %rbx,%rbx
je 12e1 <func0+0xf8>
mov %r12,%rbp
lea (%r12,%rbx,2),%rax
mov %rax,0x8(%rsp)
mov $0x0,%r12d
lea 0x18(%r13),%rax
mov %rax,0x10(%rsp)
jmp 12a9 <func0+0xc0>
mov 0x10(%rax),%r15
lea 0x1(%r15),%r14
mov 0x8(%rax),%rdi
mov %r14,%rsi
callq 10f0 <realloc@plt>
mov %rax,0x8(%rbx)
mov (%rsp),%rsi
movzbl 0x1(%rsi),%edx
mov %dl,(%rax,%r15,1)
mov %r14,0x10(%rbx)
jmp 129e <func0+0xb5>
movslq %r12d,%rax
lea (%rax,%rax,2),%rax
lea 0x0(%r13,%rax,8),%rbx
movzbl 0x0(%rbp),%r14d
mov %r14b,(%rbx)
mov $0x2,%edi
callq 10e0 <malloc@plt>
mov %rax,0x8(%rbx)
mov %r14b,(%rax)
movzbl 0x1(%rbp),%edx
mov %dl,0x1(%rax)
movq $0x2,0x10(%rbx)
add $0x1,%r12d
add $0x2,%rbp
cmp 0x8(%rsp),%rbp
je 12e7 <func0+0xfe>
test %r12d,%r12d
jle 1266 <func0+0x7d>
mov %rbp,(%rsp)
movzbl 0x0(%rbp),%edx
mov %r13,%rax
lea -0x1(%r12),%ecx
lea (%rcx,%rcx,2),%rcx
mov 0x10(%rsp),%rsi
lea (%rsi,%rcx,8),%rcx
mov %rax,%rbx
cmp %dl,(%rax)
je 123c <func0+0x53>
add $0x18,%rax
cmp %rcx,%rax
jne 12cb <func0+0xe2>
jmp 1266 <func0+0x7d>
mov $0x0,%r12d
mov 0x18(%rsp),%rax
mov %r12d,(%rax)
mov %r13,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r12, rdi
mov rbx, rsi
mov [rsp+58h+var_40], rdx
lea rdi, [rsi+rsi*2]
shl rdi, 3
call _malloc
mov r13, rax
test rbx, rbx
jz loc_12E1
mov rbp, r12
lea rax, [r12+rbx*2]
mov [rsp+58h+var_50], rax
mov r12d, 0
lea rax, [r13+18h]
mov [rsp+58h+var_48], rax
jmp short loc_12A9
loc_123C:
mov r15, [rax+10h]
lea r14, [r15+1]
mov rdi, [rax+8]
mov rsi, r14
call _realloc
mov [rbx+8], rax
mov rsi, [rsp+58h+var_58]
movzx edx, byte ptr [rsi+1]
mov [rax+r15], dl
mov [rbx+10h], r14
jmp short loc_129E
loc_1266:
movsxd rax, r12d
lea rax, [rax+rax*2]
lea rbx, [r13+rax*8+0]
movzx r14d, byte ptr [rbp+0]
mov [rbx], r14b
mov edi, 2
call _malloc
mov [rbx+8], rax
mov [rax], r14b
movzx edx, byte ptr [rbp+1]
mov [rax+1], dl
mov qword ptr [rbx+10h], 2
add r12d, 1
loc_129E:
add rbp, 2
cmp rbp, [rsp+58h+var_50]
jz short loc_12E7
loc_12A9:
test r12d, r12d
jle short loc_1266
mov [rsp+58h+var_58], rbp
movzx edx, byte ptr [rbp+0]
mov rax, r13
lea ecx, [r12-1]
lea rcx, [rcx+rcx*2]
mov rsi, [rsp+58h+var_48]
lea rcx, [rsi+rcx*8]
loc_12CB:
mov rbx, rax
cmp [rax], dl
jz loc_123C
add rax, 18h
cmp rax, rcx
jnz short loc_12CB
jmp short loc_1266
loc_12E1:
mov r12d, 0
loc_12E7:
mov rax, [rsp+58h+var_40]
mov [rax], r12d
mov rax, r13
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char *a1, long long a2, int *a3)
{
long long v3; // r13
char *v4; // rbp
int v5; // r12d
long long v6; // r15
long long v7; // rax
long long v8; // rbx
char v9; // r14
_BYTE *v10; // rax
long long v11; // rax
long long v12; // rbx
v3 = malloc(24 * a2);
if ( a2 )
{
v4 = a1;
v5 = 0;
do
{
if ( v5 <= 0 )
{
LABEL_4:
v8 = v3 + 24LL * v5;
v9 = *v4;
*(_BYTE *)v8 = *v4;
v10 = (_BYTE *)malloc(2LL);
*(_QWORD *)(v8 + 8) = v10;
*v10 = v9;
v10[1] = v4[1];
*(_QWORD *)(v8 + 16) = 2LL;
++v5;
}
else
{
v11 = v3;
while ( 1 )
{
v12 = v11;
if ( *(_BYTE *)v11 == *v4 )
break;
v11 += 24LL;
if ( v11 == v3 + 24 + 24LL * (unsigned int)(v5 - 1) )
goto LABEL_4;
}
v6 = *(_QWORD *)(v11 + 16);
v7 = realloc(*(_QWORD *)(v11 + 8), v6 + 1);
*(_QWORD *)(v12 + 8) = v7;
*(_BYTE *)(v7 + v6) = v4[1];
*(_QWORD *)(v12 + 16) = v6 + 1;
}
v4 += 2;
}
while ( v4 != &a1[2 * a2] );
}
else
{
v5 = 0;
}
*a3 = v5;
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R12,RDI
MOV RBX,RSI
MOV qword ptr [RSP + 0x18],RDX
LEA RDI,[RSI + RSI*0x2]
SHL RDI,0x3
CALL 0x001010e0
MOV R13,RAX
TEST RBX,RBX
JZ 0x001012e1
MOV RBP,R12
LEA RAX,[R12 + RBX*0x2]
MOV qword ptr [RSP + 0x8],RAX
MOV R12D,0x0
LEA RAX,[R13 + 0x18]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001012a9
LAB_0010123c:
MOV R15,qword ptr [RAX + 0x10]
LEA R14,[R15 + 0x1]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,R14
CALL 0x001010f0
MOV qword ptr [RBX + 0x8],RAX
MOV RSI,qword ptr [RSP]
MOVZX EDX,byte ptr [RSI + 0x1]
MOV byte ptr [RAX + R15*0x1],DL
MOV qword ptr [RBX + 0x10],R14
JMP 0x0010129e
LAB_00101266:
MOVSXD RAX,R12D
LEA RAX,[RAX + RAX*0x2]
LEA RBX,[R13 + RAX*0x8]
MOVZX R14D,byte ptr [RBP]
MOV byte ptr [RBX],R14B
MOV EDI,0x2
CALL 0x001010e0
MOV qword ptr [RBX + 0x8],RAX
MOV byte ptr [RAX],R14B
MOVZX EDX,byte ptr [RBP + 0x1]
MOV byte ptr [RAX + 0x1],DL
MOV qword ptr [RBX + 0x10],0x2
ADD R12D,0x1
LAB_0010129e:
ADD RBP,0x2
CMP RBP,qword ptr [RSP + 0x8]
JZ 0x001012e7
LAB_001012a9:
TEST R12D,R12D
JLE 0x00101266
MOV qword ptr [RSP],RBP
MOVZX EDX,byte ptr [RBP]
MOV RAX,R13
LEA ECX,[R12 + -0x1]
LEA RCX,[RCX + RCX*0x2]
MOV RSI,qword ptr [RSP + 0x10]
LEA RCX,[RSI + RCX*0x8]
LAB_001012cb:
MOV RBX,RAX
CMP byte ptr [RAX],DL
JZ 0x0010123c
ADD RAX,0x18
CMP RAX,RCX
JNZ 0x001012cb
JMP 0x00101266
LAB_001012e1:
MOV R12D,0x0
LAB_001012e7:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R12D
MOV RAX,R13
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | char * func0(char *param_1,long param_2,int *param_3)
{
size_t __size;
char *pcVar1;
char cVar2;
long lVar3;
char *pcVar4;
void *pvVar5;
char *pcVar6;
char *pcVar7;
int iVar8;
pcVar4 = (char *)malloc(param_2 * 0x18);
if (param_2 == 0) {
iVar8 = 0;
}
else {
pcVar1 = param_1 + param_2 * 2;
iVar8 = 0;
do {
if (0 < iVar8) {
pcVar7 = pcVar4;
do {
if (*pcVar7 == *param_1) {
lVar3 = *(long *)(pcVar7 + 0x10);
__size = lVar3 + 1;
pvVar5 = realloc(*(void **)(pcVar7 + 8),__size);
*(void **)(pcVar7 + 8) = pvVar5;
*(char *)((long)pvVar5 + lVar3) = param_1[1];
*(size_t *)(pcVar7 + 0x10) = __size;
goto LAB_0010129e;
}
pcVar7 = pcVar7 + 0x18;
} while (pcVar7 != pcVar4 + (ulong)(iVar8 - 1) * 0x18 + 0x18);
}
pcVar7 = pcVar4 + (long)iVar8 * 0x18;
cVar2 = *param_1;
*pcVar7 = cVar2;
pcVar6 = (char *)malloc(2);
*(char **)(pcVar7 + 8) = pcVar6;
*pcVar6 = cVar2;
pcVar6[1] = param_1[1];
pcVar7[0x10] = '\x02';
pcVar7[0x11] = '\0';
pcVar7[0x12] = '\0';
pcVar7[0x13] = '\0';
pcVar7[0x14] = '\0';
pcVar7[0x15] = '\0';
pcVar7[0x16] = '\0';
pcVar7[0x17] = '\0';
iVar8 = iVar8 + 1;
LAB_0010129e:
param_1 = param_1 + 2;
} while (param_1 != pcVar1);
}
*param_3 = iVar8;
return pcVar4;
} |
5,562 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t new_size = out[j].size + 1;
out[j].values = realloc(out[j].values, new_size);
out[j].values[new_size - 1] = Input[i][1];
out[j].size = new_size;
found = 1;
break;
}
}
if (!found) {
out[outCount].key = Input[i][0];
out[outCount].values = malloc(2);
out[outCount].values[0] = Input[i][0];
out[outCount].values[1] = Input[i][1];
out[outCount].size = 2;
outCount++;
}
}
*returnSize = outCount;
return out;
}
| int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size == 2);
free(result1[0].values);
free(result1[1].values);
free(result1);
char input2[][2] = { {'a', 'b'}, {'a', 'c'}, {'d', 'e'} };
int size2;
TupleGroup *result2 = func0(input2, 3, &size2);
assert(size2 == 2);
assert(memcmp(result2[0].values, "abc", 3) == 0 && result2[0].size == 3);
assert(memcmp(result2[1].values, "de", 2) == 0 && result2[1].size == 2);
free(result2[0].values);
free(result2[1].values);
free(result2);
char input3[][2] = { {'f', 'g'}, {'f', 'g'}, {'h', 'i'} };
int size3;
TupleGroup *result3 = func0(input3, 3, &size3);
assert(size3 == 2);
assert(memcmp(result3[0].values, "fgg", 3) == 0 && result3[0].size == 3);
assert(memcmp(result3[1].values, "hi", 2) == 0 && result3[1].size == 2);
free(result3[0].values);
free(result3[1].values);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
lea (%rsi,%rsi,1),%r13
push %r12
lea 0x0(%r13,%rsi,1),%rdi
push %rbp
shl $0x3,%rdi
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %rdx,0x18(%rsp)
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rbx,%rbx
je 15a6 <func0+0x116>
lea (%r14,%r13,1),%rax
xor %r15d,%r15d
mov %rax,0x8(%rsp)
lea 0x18(%r12),%rax
mov %rax,0x10(%rsp)
nopl 0x0(%rax)
movzbl (%r14),%ebp
test %r15d,%r15d
je 1570 <func0+0xe0>
mov 0x10(%rsp),%rcx
lea -0x1(%r15),%eax
mov %r12,%rbx
lea (%rax,%rax,2),%rax
lea (%rcx,%rax,8),%rax
jmp 1519 <func0+0x89>
nopw 0x0(%rax,%rax,1)
add $0x18,%rbx
cmp %rax,%rbx
je 1570 <func0+0xe0>
cmp %bpl,(%rbx)
jne 1510 <func0+0x80>
mov 0x10(%rbx),%r13
mov 0x8(%rbx),%rdi
lea 0x1(%r13),%rbp
mov %rbp,%rsi
callq 10d0 <realloc@plt>
movzbl 0x1(%r14),%esi
mov %rax,0x8(%rbx)
mov %sil,(%rax,%r13,1)
mov %rbp,0x10(%rbx)
add $0x2,%r14
cmp 0x8(%rsp),%r14
jne 14e8 <func0+0x58>
mov 0x18(%rsp),%rax
mov %r15d,(%rax)
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
movslq %r15d,%rax
mov $0x2,%edi
add $0x1,%r15d
lea (%rax,%rax,2),%rax
lea (%r12,%rax,8),%rbx
mov %bpl,(%rbx)
callq 10c0 <malloc@plt>
movzbl 0x1(%r14),%esi
movq $0x2,0x10(%rbx)
mov %rax,0x8(%rbx)
mov %bpl,(%rax)
mov %sil,0x1(%rax)
jmp 1543 <func0+0xb3>
xor %r15d,%r15d
jmp 154e <func0+0xbe>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
lea r13, [rsi+rsi]
push r12
lea rdi, [r13+rsi+0]
push rbp
shl rdi, 3
push rbx
mov rbx, rsi
sub rsp, 28h
mov [rsp+58h+var_40], rdx
call _malloc
mov r12, rax
test rbx, rbx
jz loc_15A6
lea rax, [r14+r13]
xor r15d, r15d
mov [rsp+58h+var_50], rax
lea rax, [r12+18h]
mov [rsp+58h+var_48], rax
nop dword ptr [rax+00000000h]
loc_14E8:
movzx ebp, byte ptr [r14]
test r15d, r15d
jz short loc_1570
mov rcx, [rsp+58h+var_48]
lea eax, [r15-1]
mov rbx, r12
lea rax, [rax+rax*2]
lea rax, [rcx+rax*8]
jmp short loc_1519
loc_1510:
add rbx, 18h
cmp rax, rbx
jz short loc_1570
loc_1519:
cmp [rbx], bpl
jnz short loc_1510
mov r13, [rbx+10h]
mov rdi, [rbx+8]
lea rbp, [r13+1]
mov rsi, rbp
call _realloc
movzx esi, byte ptr [r14+1]
mov [rbx+8], rax
mov [rax+r13], sil
mov [rbx+10h], rbp
loc_1543:
add r14, 2
cmp r14, [rsp+58h+var_50]
jnz short loc_14E8
loc_154E:
mov rax, [rsp+58h+var_40]
mov [rax], r15d
add rsp, 28h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1570:
movsxd rax, r15d
mov edi, 2
add r15d, 1
lea rax, [rax+rax*2]
lea rbx, [r12+rax*8]
mov [rbx], bpl
call _malloc
movzx esi, byte ptr [r14+1]
mov qword ptr [rbx+10h], 2
mov [rbx+8], rax
mov [rax], bpl
mov [rax+1], sil
jmp short loc_1543
loc_15A6:
xor r15d, r15d
jmp short loc_154E | long long func0(char *a1, long long a2, _DWORD *a3)
{
char *v3; // r14
long long v4; // r12
int v5; // r15d
char v6; // bp
long long v7; // rbx
long long v8; // r13
long long v9; // rax
char v10; // si
long long v12; // rax
long long v13; // rbx
_BYTE *v14; // rax
char v15; // si
char *v16; // [rsp+8h] [rbp-50h]
v3 = a1;
v4 = malloc(24 * a2);
if ( a2 )
{
v5 = 0;
v16 = &a1[2 * a2];
do
{
v6 = *v3;
if ( v5 )
{
v7 = v4;
while ( *(_BYTE *)v7 != v6 )
{
v7 += 24LL;
if ( v4 + 24 + 24LL * (unsigned int)(v5 - 1) == v7 )
goto LABEL_10;
}
v8 = *(_QWORD *)(v7 + 16);
v9 = realloc(*(_QWORD *)(v7 + 8), v8 + 1);
v10 = v3[1];
*(_QWORD *)(v7 + 8) = v9;
*(_BYTE *)(v9 + v8) = v10;
*(_QWORD *)(v7 + 16) = v8 + 1;
}
else
{
LABEL_10:
v12 = v5++;
v13 = v4 + 24 * v12;
*(_BYTE *)v13 = v6;
v14 = (_BYTE *)malloc(2LL);
v15 = v3[1];
*(_QWORD *)(v13 + 16) = 2LL;
*(_QWORD *)(v13 + 8) = v14;
*v14 = v6;
v14[1] = v15;
}
v3 += 2;
}
while ( v3 != v16 );
}
else
{
v5 = 0;
}
*a3 = v5;
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
LEA R13,[RSI + RSI*0x1]
PUSH R12
LEA RDI,[R13 + RSI*0x1]
PUSH RBP
SHL RDI,0x3
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDX
CALL 0x001010c0
MOV R12,RAX
TEST RBX,RBX
JZ 0x001015a6
LEA RAX,[R14 + R13*0x1]
XOR R15D,R15D
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[R12 + 0x18]
MOV qword ptr [RSP + 0x10],RAX
NOP dword ptr [RAX]
LAB_001014e8:
MOVZX EBP,byte ptr [R14]
TEST R15D,R15D
JZ 0x00101570
MOV RCX,qword ptr [RSP + 0x10]
LEA EAX,[R15 + -0x1]
MOV RBX,R12
LEA RAX,[RAX + RAX*0x2]
LEA RAX,[RCX + RAX*0x8]
JMP 0x00101519
LAB_00101510:
ADD RBX,0x18
CMP RAX,RBX
JZ 0x00101570
LAB_00101519:
CMP byte ptr [RBX],BPL
JNZ 0x00101510
MOV R13,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX + 0x8]
LEA RBP,[R13 + 0x1]
MOV RSI,RBP
CALL 0x001010d0
MOVZX ESI,byte ptr [R14 + 0x1]
MOV qword ptr [RBX + 0x8],RAX
MOV byte ptr [RAX + R13*0x1],SIL
MOV qword ptr [RBX + 0x10],RBP
LAB_00101543:
ADD R14,0x2
CMP R14,qword ptr [RSP + 0x8]
JNZ 0x001014e8
LAB_0010154e:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R15D
ADD RSP,0x28
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101570:
MOVSXD RAX,R15D
MOV EDI,0x2
ADD R15D,0x1
LEA RAX,[RAX + RAX*0x2]
LEA RBX,[R12 + RAX*0x8]
MOV byte ptr [RBX],BPL
CALL 0x001010c0
MOVZX ESI,byte ptr [R14 + 0x1]
MOV qword ptr [RBX + 0x10],0x2
MOV qword ptr [RBX + 0x8],RAX
MOV byte ptr [RAX],BPL
MOV byte ptr [RAX + 0x1],SIL
JMP 0x00101543
LAB_001015a6:
XOR R15D,R15D
JMP 0x0010154e | char * func0(char *param_1,long param_2,int *param_3)
{
size_t __size;
char *pcVar1;
char cVar2;
char cVar3;
char *pcVar4;
void *pvVar5;
long lVar6;
char *pcVar7;
char *pcVar8;
int iVar9;
pcVar4 = (char *)malloc(param_2 * 0x18);
if (param_2 == 0) {
iVar9 = 0;
}
else {
pcVar1 = param_1 + param_2 * 2;
iVar9 = 0;
do {
cVar2 = *param_1;
if (iVar9 != 0) {
pcVar8 = pcVar4;
do {
if (*pcVar8 == cVar2) {
lVar6 = *(long *)(pcVar8 + 0x10);
__size = lVar6 + 1;
pvVar5 = realloc(*(void **)(pcVar8 + 8),__size);
cVar2 = param_1[1];
*(void **)(pcVar8 + 8) = pvVar5;
*(char *)((long)pvVar5 + lVar6) = cVar2;
*(size_t *)(pcVar8 + 0x10) = __size;
goto LAB_00101543;
}
pcVar8 = pcVar8 + 0x18;
} while (pcVar4 + (ulong)(iVar9 - 1) * 0x18 + 0x18 != pcVar8);
}
lVar6 = (long)iVar9;
iVar9 = iVar9 + 1;
pcVar8 = pcVar4 + lVar6 * 0x18;
*pcVar8 = cVar2;
pcVar7 = (char *)malloc(2);
cVar3 = param_1[1];
pcVar8[0x10] = '\x02';
pcVar8[0x11] = '\0';
pcVar8[0x12] = '\0';
pcVar8[0x13] = '\0';
pcVar8[0x14] = '\0';
pcVar8[0x15] = '\0';
pcVar8[0x16] = '\0';
pcVar8[0x17] = '\0';
*(char **)(pcVar8 + 8) = pcVar7;
*pcVar7 = cVar2;
pcVar7[1] = cVar3;
LAB_00101543:
param_1 = param_1 + 2;
} while (param_1 != pcVar1);
}
*param_3 = iVar9;
return pcVar4;
} |
5,563 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t new_size = out[j].size + 1;
out[j].values = realloc(out[j].values, new_size);
out[j].values[new_size - 1] = Input[i][1];
out[j].size = new_size;
found = 1;
break;
}
}
if (!found) {
out[outCount].key = Input[i][0];
out[outCount].values = malloc(2);
out[outCount].values[0] = Input[i][0];
out[outCount].values[1] = Input[i][1];
out[outCount].size = 2;
outCount++;
}
}
*returnSize = outCount;
return out;
}
| int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size == 2);
free(result1[0].values);
free(result1[1].values);
free(result1);
char input2[][2] = { {'a', 'b'}, {'a', 'c'}, {'d', 'e'} };
int size2;
TupleGroup *result2 = func0(input2, 3, &size2);
assert(size2 == 2);
assert(memcmp(result2[0].values, "abc", 3) == 0 && result2[0].size == 3);
assert(memcmp(result2[1].values, "de", 2) == 0 && result2[1].size == 2);
free(result2[0].values);
free(result2[1].values);
free(result2);
char input3[][2] = { {'f', 'g'}, {'f', 'g'}, {'h', 'i'} };
int size3;
TupleGroup *result3 = func0(input3, 3, &size3);
assert(size3 == 2);
assert(memcmp(result3[0].values, "fgg", 3) == 0 && result3[0].size == 3);
assert(memcmp(result3[1].values, "hi", 2) == 0 && result3[1].size == 2);
free(result3[0].values);
free(result3[1].values);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
lea (%rsi,%rsi,1),%r13
push %r12
lea 0x0(%r13,%rsi,1),%rdi
push %rbp
shl $0x3,%rdi
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %rdx,0x18(%rsp)
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rbx,%rbx
je 15a6 <func0+0x116>
lea (%r14,%r13,1),%rax
xor %r15d,%r15d
mov %rax,0x8(%rsp)
lea 0x18(%r12),%rax
mov %rax,0x10(%rsp)
nopl 0x0(%rax)
movzbl (%r14),%ebp
test %r15d,%r15d
je 1570 <func0+0xe0>
mov 0x10(%rsp),%rcx
lea -0x1(%r15),%eax
mov %r12,%rbx
lea (%rax,%rax,2),%rax
lea (%rcx,%rax,8),%rax
jmp 1519 <func0+0x89>
nopw 0x0(%rax,%rax,1)
add $0x18,%rbx
cmp %rax,%rbx
je 1570 <func0+0xe0>
cmp %bpl,(%rbx)
jne 1510 <func0+0x80>
mov 0x10(%rbx),%r13
mov 0x8(%rbx),%rdi
lea 0x1(%r13),%rbp
mov %rbp,%rsi
callq 10d0 <realloc@plt>
movzbl 0x1(%r14),%esi
mov %rax,0x8(%rbx)
mov %sil,(%rax,%r13,1)
mov %rbp,0x10(%rbx)
add $0x2,%r14
cmp %r14,0x8(%rsp)
jne 14e8 <func0+0x58>
mov 0x18(%rsp),%rax
mov %r15d,(%rax)
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
movslq %r15d,%rax
mov $0x2,%edi
add $0x1,%r15d
lea (%rax,%rax,2),%rax
lea (%r12,%rax,8),%rbx
mov %bpl,(%rbx)
callq 10c0 <malloc@plt>
movzbl 0x1(%r14),%esi
movq $0x2,0x10(%rbx)
mov %rax,0x8(%rbx)
mov %bpl,(%rax)
mov %sil,0x1(%rax)
jmp 1543 <func0+0xb3>
xor %r15d,%r15d
jmp 154e <func0+0xbe>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
lea rbp, [rsi+rsi]
push rbx
lea rdi, [rbp+rsi+0]
mov rbx, rsi
shl rdi, 3; size
sub rsp, 28h
mov [rsp+58h+var_40], rdx
call _malloc
mov r13, rax
test rbx, rbx
jz loc_15BF
lea rax, [r14+rbp]
xor r15d, r15d
mov [rsp+58h+var_58], rax
nop word ptr [rax+rax+00000000h]
loc_14E0:
movzx ebp, byte ptr [r14]
movsxd rcx, r15d
test r15d, r15d
jle short loc_1560
lea rax, [rcx+rcx*2]
lea r12, [r13+rax*8+0]
loc_14F5:
mov rbx, r13
jmp short loc_1509
loc_1500:
add rbx, 18h
cmp rbx, r12
jz short loc_1560
loc_1509:
cmp [rbx], bpl
jnz short loc_1500
mov r9, [rbx+10h]
mov rdi, [rbx+8]; ptr
mov [rsp+58h+var_48], rcx
add r14, 2
lea rbp, [r9+1]
mov [rsp+58h+var_50], r9
mov rsi, rbp; size
call _realloc
movzx esi, byte ptr [r14-1]
mov r9, [rsp+58h+var_50]
mov [rbx+8], rax
mov [rax+r9], sil
mov rax, [rsp+58h+var_58]
mov [rbx+10h], rbp
cmp r14, rax
jz short loc_15A5
movzx ebp, byte ptr [r14]
mov rcx, [rsp+58h+var_48]
jmp short loc_14F5
loc_1560:
lea rax, [rcx+rcx*2]
mov edi, 2; size
add r14, 2
add r15d, 1
lea rbx, [r13+rax*8+0]
mov [rbx], bpl
call _malloc
movzx edx, byte ptr [r14-1]
movzx ecx, bpl
mov qword ptr [rbx+10h], 2
mov [rbx+8], rax
mov ch, dl
mov [rax], cx
mov rax, [rsp+58h+var_58]
cmp r14, rax
jnz loc_14E0
loc_15A5:
mov rax, [rsp+58h+var_40]
mov [rax], r15d
add rsp, 28h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15BF:
xor r15d, r15d
jmp short loc_15A5 | char * func0(char *a1, long long a2, int *a3)
{
char *v3; // r14
char *v4; // r13
int v5; // r15d
char v6; // bp
long long v7; // rcx
char *v8; // rbx
size_t v9; // rbp
_BYTE *v10; // rax
char v11; // si
char *v12; // rbx
_WORD *v13; // rax
char v14; // dl
__int16 v15; // cx
char *v17; // [rsp+0h] [rbp-58h]
long long v18; // [rsp+8h] [rbp-50h]
long long v19; // [rsp+10h] [rbp-48h]
v3 = a1;
v4 = (char *)malloc(24 * a2);
if ( a2 )
{
v5 = 0;
v17 = &a1[2 * a2];
while ( 1 )
{
v6 = *v3;
v7 = v5;
if ( v5 > 0 )
break;
LABEL_9:
v3 += 2;
++v5;
v12 = &v4[24 * v7];
*v12 = v6;
v13 = malloc(2uLL);
v14 = *(v3 - 1);
LOBYTE(v15) = v6;
*((_QWORD *)v12 + 2) = 2LL;
*((_QWORD *)v12 + 1) = v13;
HIBYTE(v15) = v14;
*v13 = v15;
if ( v3 == v17 )
goto LABEL_10;
}
while ( 1 )
{
v8 = v4;
while ( *v8 != v6 )
{
v8 += 24;
if ( v8 == &v4[24 * v5] )
goto LABEL_9;
}
v19 = v7;
v3 += 2;
v9 = *((_QWORD *)v8 + 2) + 1LL;
v18 = *((_QWORD *)v8 + 2);
v10 = realloc(*((void **)v8 + 1), v9);
v11 = *(v3 - 1);
*((_QWORD *)v8 + 1) = v10;
v10[v18] = v11;
*((_QWORD *)v8 + 2) = v9;
if ( v3 == v17 )
break;
v6 = *v3;
v7 = v19;
}
}
else
{
v5 = 0;
}
LABEL_10:
*a3 = v5;
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
LEA RBP,[RSI + RSI*0x1]
PUSH RBX
LEA RDI,[RBP + RSI*0x1]
MOV RBX,RSI
SHL RDI,0x3
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDX
CALL 0x001010c0
MOV R13,RAX
TEST RBX,RBX
JZ 0x001015bf
LEA RAX,[R14 + RBP*0x1]
XOR R15D,R15D
MOV qword ptr [RSP],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001014e0:
MOVZX EBP,byte ptr [R14]
MOVSXD RCX,R15D
TEST R15D,R15D
JLE 0x00101560
LEA RAX,[RCX + RCX*0x2]
LEA R12,[R13 + RAX*0x8]
LAB_001014f5:
MOV RBX,R13
JMP 0x00101509
LAB_00101500:
ADD RBX,0x18
CMP RBX,R12
JZ 0x00101560
LAB_00101509:
CMP byte ptr [RBX],BPL
JNZ 0x00101500
MOV R9,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX + 0x8]
MOV qword ptr [RSP + 0x10],RCX
ADD R14,0x2
LEA RBP,[R9 + 0x1]
MOV qword ptr [RSP + 0x8],R9
MOV RSI,RBP
CALL 0x001010d0
MOVZX ESI,byte ptr [R14 + -0x1]
MOV R9,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x8],RAX
MOV byte ptr [RAX + R9*0x1],SIL
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBX + 0x10],RBP
CMP R14,RAX
JZ 0x001015a5
MOVZX EBP,byte ptr [R14]
MOV RCX,qword ptr [RSP + 0x10]
JMP 0x001014f5
LAB_00101560:
LEA RAX,[RCX + RCX*0x2]
MOV EDI,0x2
ADD R14,0x2
ADD R15D,0x1
LEA RBX,[R13 + RAX*0x8]
MOV byte ptr [RBX],BPL
CALL 0x001010c0
MOVZX EDX,byte ptr [R14 + -0x1]
MOVZX ECX,BPL
MOV qword ptr [RBX + 0x10],0x2
MOV qword ptr [RBX + 0x8],RAX
MOV CH,DL
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RSP]
CMP R14,RAX
JNZ 0x001014e0
LAB_001015a5:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],R15D
ADD RSP,0x28
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015bf:
XOR R15D,R15D
JMP 0x001015a5 | char * func0(char *param_1,long param_2,int *param_3)
{
size_t __size;
char cVar1;
long lVar2;
char *pcVar3;
void *pvVar4;
int2 *puVar5;
long lVar6;
char *pcVar7;
char cVar8;
char *pcVar9;
char *pcVar10;
int iVar11;
pcVar3 = (char *)malloc(param_2 * 0x18);
if (param_2 == 0) {
iVar11 = 0;
}
else {
iVar11 = 0;
pcVar10 = param_1;
do {
cVar8 = *pcVar10;
lVar6 = (long)iVar11;
if (0 < iVar11) {
pcVar7 = pcVar3;
do {
while (*pcVar7 == cVar8) {
lVar2 = *(long *)(pcVar7 + 0x10);
pcVar9 = pcVar10 + 2;
__size = lVar2 + 1;
pvVar4 = realloc(*(void **)(pcVar7 + 8),__size);
cVar8 = pcVar10[1];
*(void **)(pcVar7 + 8) = pvVar4;
*(char *)((long)pvVar4 + lVar2) = cVar8;
*(size_t *)(pcVar7 + 0x10) = __size;
if (pcVar9 == param_1 + param_2 * 2) goto LAB_001015a5;
pcVar7 = pcVar3;
pcVar10 = pcVar9;
cVar8 = *pcVar9;
}
pcVar7 = pcVar7 + 0x18;
} while (pcVar7 != pcVar3 + lVar6 * 0x18);
}
pcVar9 = pcVar10 + 2;
iVar11 = iVar11 + 1;
pcVar7 = pcVar3 + lVar6 * 0x18;
*pcVar7 = cVar8;
puVar5 = (int2 *)malloc(2);
cVar1 = pcVar10[1];
pcVar7[0x10] = '\x02';
pcVar7[0x11] = '\0';
pcVar7[0x12] = '\0';
pcVar7[0x13] = '\0';
pcVar7[0x14] = '\0';
pcVar7[0x15] = '\0';
pcVar7[0x16] = '\0';
pcVar7[0x17] = '\0';
*(int2 **)(pcVar7 + 8) = puVar5;
*puVar5 = CONCAT11(cVar1,cVar8);
pcVar10 = pcVar9;
} while (pcVar9 != param_1 + param_2 * 2);
}
LAB_001015a5:
*param_3 = iVar11;
return pcVar3;
} |
5,564 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return maxList;
}
| int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0(list3, 3)[3] == 1);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1205 <func0+0x7c>
movl $0x0,-0xc(%rbp)
jmp 11e2 <func0+0x59>
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 11de <func0+0x55>
mov -0xc(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x10(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov %rax,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
mov -0x10(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
test %eax,%eax
jne 11b9 <func0+0x30>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11b0 <func0+0x27>
mov -0x8(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp short loc_1205
loc_11B0:
mov [rbp+var_C], 0
jmp short loc_11E2
loc_11B9:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jle short loc_11DE
mov eax, [rbp+var_C]
mov [rbp+var_14], eax
mov eax, [rbp+var_10]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov [rbp+var_8], rax
loc_11DE:
add [rbp+var_C], 1
loc_11E2:
mov eax, [rbp+var_10]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
mov eax, [rdx+rax*4]
test eax, eax
jnz short loc_11B9
add [rbp+var_10], 1
loc_1205:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl short loc_11B0
mov rax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int j; // [rsp+20h] [rbp-Ch]
long long v6; // [rsp+24h] [rbp-8h]
v3 = 0;
v6 = a1;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; *(_DWORD *)(a1 + 16LL * i + 4LL * j); ++j )
{
if ( j > v3 )
{
v3 = j;
v6 = 16LL * i + a1;
}
}
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101205
LAB_001011b0:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011e2
LAB_001011b9:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x001011de
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV qword ptr [RBP + -0x8],RAX
LAB_001011de:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011e2:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
TEST EAX,EAX
JNZ 0x001011b9
ADD dword ptr [RBP + -0x10],0x1
LAB_00101205:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011b0
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET | long func0(long param_1,int param_2)
{
int4 local_1c;
int4 local_18;
int4 local_14;
int8 local_10;
local_1c = 0;
local_10 = param_1;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
local_14 = 0;
while (*(int *)((long)local_18 * 0x10 + param_1 + (long)local_14 * 4) != 0) {
if (local_1c < local_14) {
local_1c = local_14;
local_10 = param_1 + (long)local_18 * 0x10;
}
local_14 = local_14 + 1;
}
}
return local_10;
} |
5,565 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return maxList;
}
| int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0(list3, 3)[3] == 1);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11d8 <func0+0x4f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%r9
mov $0x0,%edx
jmp 11c5 <func0+0x3c>
add $0x1,%rax
cmpl $0x0,(%rcx,%rax,4)
je 11bc <func0+0x33>
cmp %eax,%edx
jge 11a7 <func0+0x1e>
mov %rsi,%rdi
mov %eax,%edx
jmp 11a7 <func0+0x1e>
add $0x10,%r8
cmp %r9,%r8
je 11d8 <func0+0x4f>
mov %r8,%rcx
mov $0x0,%eax
mov %r8,%rsi
cmpl $0x0,(%r8)
jne 11b1 <func0+0x28>
jmp 11bc <func0+0x33>
mov %rdi,%rax
retq
| func0:
endbr64
test esi, esi
jle short loc_11D5
mov r8, rdi
lea eax, [rsi-1]
shl rax, 4
lea rsi, [rdi+rax+10h]
mov ecx, 0
jmp short loc_11C5
loc_11A7:
add rax, 1
cmp dword ptr [rdx+rax*4], 0
jz short loc_11BC
loc_11B1:
cmp ecx, eax
jge short loc_11A7
mov rdi, rdx
mov ecx, eax
jmp short loc_11A7
loc_11BC:
add r8, 10h
cmp r8, rsi
jz short loc_11D5
loc_11C5:
mov rdx, r8
mov eax, 0
cmp dword ptr [r8], 0
jnz short loc_11B1
jmp short loc_11BC
loc_11D5:
mov rax, rdi
retn | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r8
long long v3; // rsi
int v4; // ecx
long long v5; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = (long long)&a1[4 * (a2 - 1) + 4];
v4 = 0;
do
{
v5 = 0LL;
if ( *v2 )
{
do
{
if ( v4 < (int)v5 )
{
a1 = v2;
v4 = v5;
}
++v5;
}
while ( v2[v5] );
}
v2 += 4;
}
while ( v2 != (_DWORD *)v3 );
}
return a1;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011d5
MOV R8,RDI
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA RSI,[RDI + RAX*0x1 + 0x10]
MOV ECX,0x0
JMP 0x001011c5
LAB_001011a7:
ADD RAX,0x1
CMP dword ptr [RDX + RAX*0x4],0x0
JZ 0x001011bc
LAB_001011b1:
CMP ECX,EAX
JGE 0x001011a7
MOV RDI,RDX
MOV ECX,EAX
JMP 0x001011a7
LAB_001011bc:
ADD R8,0x10
CMP R8,RSI
JZ 0x001011d5
LAB_001011c5:
MOV RDX,R8
MOV EAX,0x0
CMP dword ptr [R8],0x0
JNZ 0x001011b1
JMP 0x001011bc
LAB_001011d5:
MOV RAX,RDI
RET | int * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
int *piVar5;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
iVar4 = 0;
piVar5 = param_1;
do {
lVar3 = 0;
iVar2 = *piVar5;
while (iVar2 != 0) {
if (iVar4 < (int)lVar3) {
param_1 = piVar5;
iVar4 = (int)lVar3;
}
lVar3 = lVar3 + 1;
iVar2 = piVar5[lVar3];
}
piVar5 = piVar5 + 4;
} while (piVar5 != piVar1);
}
return param_1;
} |
5,566 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return maxList;
}
| int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0(list3, 3)[3] == 1);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1463 <func0+0x53>
lea -0x1(%rsi),%eax
mov %rdi,%r8
xor %edx,%edx
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%rcx
nopl 0x0(%rax)
mov (%rdi),%esi
xor %eax,%eax
test %esi,%esi
je 1456 <func0+0x46>
nopl 0x0(%rax,%rax,1)
cmp %eax,%edx
jge 1449 <func0+0x39>
mov %rdi,%r8
mov %eax,%edx
add $0x1,%rax
mov (%rdi,%rax,4),%r9d
test %r9d,%r9d
jne 1440 <func0+0x30>
add $0x10,%rdi
cmp %rcx,%rdi
jne 1430 <func0+0x20>
mov %r8,%rax
retq
mov %rdi,%r8
mov %r8,%rax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_137B
lea eax, [rsi-1]
mov r8, rdi
xor edx, edx
shl rax, 4
lea rcx, [rdi+rax+10h]
nop dword ptr [rax+00000000h]
loc_1350:
mov esi, [rdi]
xor eax, eax
test esi, esi
jz short loc_136E
loc_1358:
cmp edx, eax
jge short loc_1361
mov r8, rdi
mov edx, eax
loc_1361:
add rax, 1
mov r9d, [rdi+rax*4]
test r9d, r9d
jnz short loc_1358
loc_136E:
add rdi, 10h
cmp rdi, rcx
jnz short loc_1350
mov rax, r8
retn
loc_137B:
mov r8, rdi
mov rax, r8
retn | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r8
int v3; // edx
long long v4; // rcx
long long v5; // rax
if ( a2 <= 0 )
return a1;
v2 = a1;
v3 = 0;
v4 = (long long)&a1[4 * (a2 - 1) + 4];
do
{
v5 = 0LL;
if ( *a1 )
{
do
{
if ( v3 < (int)v5 )
{
v2 = a1;
v3 = v5;
}
++v5;
}
while ( a1[v5] );
}
a1 += 4;
}
while ( a1 != (_DWORD *)v4 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010137b
LEA EAX,[RSI + -0x1]
MOV R8,RDI
XOR EDX,EDX
SHL RAX,0x4
LEA RCX,[RDI + RAX*0x1 + 0x10]
NOP dword ptr [RAX]
LAB_00101350:
MOV ESI,dword ptr [RDI]
XOR EAX,EAX
TEST ESI,ESI
JZ 0x0010136e
LAB_00101358:
CMP EDX,EAX
JGE 0x00101361
MOV R8,RDI
MOV EDX,EAX
LAB_00101361:
ADD RAX,0x1
MOV R9D,dword ptr [RDI + RAX*0x4]
TEST R9D,R9D
JNZ 0x00101358
LAB_0010136e:
ADD RDI,0x10
CMP RDI,RCX
JNZ 0x00101350
MOV RAX,R8
RET
LAB_0010137b:
MOV R8,RDI
MOV RAX,R8
RET | int * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
int *piVar5;
if (param_2 < 1) {
return param_1;
}
iVar4 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
piVar5 = param_1;
do {
lVar3 = 0;
iVar2 = *param_1;
while (iVar2 != 0) {
if (iVar4 < (int)lVar3) {
piVar5 = param_1;
iVar4 = (int)lVar3;
}
lVar3 = lVar3 + 1;
iVar2 = param_1[lVar3];
}
param_1 = param_1 + 4;
} while (param_1 != piVar1);
return piVar5;
} |
5,567 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return maxList;
}
| int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0(list3, 3)[3] == 1);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
mov %rdi,%rax
test %esi,%esi
jle 15ee <func0+0xbe>
lea -0x1(%rsi),%edx
mov %rdi,%r8
shl $0x4,%rdx
lea 0x10(%rdi,%rdx,1),%rsi
xor %edx,%edx
mov (%rax),%ecx
test %ecx,%ecx
je 15a0 <func0+0x70>
mov 0x4(%rax),%r9d
test %r9d,%r9d
je 15a0 <func0+0x70>
test %edx,%edx
je 15b0 <func0+0x80>
mov 0x8(%rax),%ecx
test %ecx,%ecx
je 15a0 <func0+0x70>
cmp $0x1,%edx
je 15bf <func0+0x8f>
mov 0xc(%rax),%r10d
test %r10d,%r10d
je 15a0 <func0+0x70>
cmp $0x2,%edx
je 15e4 <func0+0xb4>
mov 0x10(%rax),%r9d
test %r9d,%r9d
je 15a0 <func0+0x70>
mov $0x4,%ecx
cmp %ecx,%edx
jge 1594 <func0+0x64>
mov %rax,%r8
mov %ecx,%edx
add $0x1,%rcx
mov (%rax,%rcx,4),%edi
test %edi,%edi
jne 158b <func0+0x5b>
add $0x10,%rax
cmp %rsi,%rax
jne 1550 <func0+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov 0x8(%rax),%edi
mov %rax,%r8
mov $0x1,%edx
test %edi,%edi
je 15a0 <func0+0x70>
mov 0xc(%rax),%r11d
mov %rax,%r8
mov $0x3,%edx
test %r11d,%r11d
jne 157d <func0+0x4d>
add $0x10,%rax
mov $0x2,%edx
cmp %rsi,%rax
jne 1550 <func0+0x20>
jmp 15a9 <func0+0x79>
mov %rax,%r8
mov $0x3,%edx
jmp 157d <func0+0x4d>
mov %rdi,%r8
mov %r8,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle loc_161C
movsxd rsi, esi
xor eax, eax
shl rsi, 4
lea rdx, [rdi+rsi]
mov rsi, rdi
nop dword ptr [rax+00h]
loc_1560:
mov ecx, [rdi]
test ecx, ecx
jz short loc_15B8
mov r8d, [rdi+4]
test r8d, r8d
jz short loc_15B8
test eax, eax
jle short loc_15C8
mov ecx, [rdi+8]
test ecx, ecx
jz short loc_15B8
cmp eax, 1
jz short loc_15CF
mov r10d, [rdi+0Ch]
test r10d, r10d
jz short loc_15B8
cmp eax, 2
jz loc_160F
loc_1591:
mov r9d, [rdi+10h]
test r9d, r9d
jz short loc_15B8
mov ecx, 4
loc_159F:
cmp eax, ecx
cmovl eax, ecx
cmovl rsi, rdi
add rcx, 1
mov r8d, [rdi+rcx*4]
test r8d, r8d
jnz short loc_159F
nop dword ptr [rax]
loc_15B8:
add rdi, 10h
cmp rdi, rdx
jnz short loc_1560
loc_15C1:
mov rax, rsi
retn
loc_15C8:
mov esi, [rdi+8]
test esi, esi
jz short loc_15F8
loc_15CF:
mov r11d, [rdi+0Ch]
mov rsi, rdi
mov eax, 3
test r11d, r11d
jnz short loc_1591
add rdi, 10h
mov eax, 2
cmp rdi, rdx
jnz loc_1560
jmp short loc_15C1
loc_15F8:
mov rsi, rdi
add rdi, 10h
mov eax, 1
cmp rdi, rdx
jnz loc_1560
jmp short loc_15C1
loc_160F:
mov rsi, rdi
mov eax, 3
jmp loc_1591
loc_161C:
mov rsi, rdi
mov rax, rsi
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // eax
_DWORD *v3; // rdx
_DWORD *v4; // rsi
long long v5; // rcx
if ( a2 > 0 )
{
v2 = 0;
v3 = &a1[4 * a2];
v4 = a1;
while ( 1 )
{
if ( !*a1 || !a1[1] )
goto LABEL_16;
if ( v2 <= 0 )
{
if ( a1[2] )
goto LABEL_19;
v4 = a1;
a1 += 4;
v2 = 1;
if ( a1 == v3 )
return v4;
}
else
{
if ( !a1[2] )
goto LABEL_16;
if ( v2 == 1 )
{
LABEL_19:
v4 = a1;
v2 = 3;
if ( a1[3] )
goto LABEL_11;
a1 += 4;
v2 = 2;
if ( a1 == v3 )
return v4;
}
else
{
if ( a1[3] )
{
if ( v2 == 2 )
{
v4 = a1;
v2 = 3;
}
LABEL_11:
if ( a1[4] )
{
v5 = 4LL;
do
{
if ( v2 < (int)v5 )
{
v2 = v5;
v4 = a1;
}
++v5;
}
while ( a1[v5] );
}
}
LABEL_16:
a1 += 4;
if ( a1 == v3 )
return v4;
}
}
}
}
return a1;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010161c
MOVSXD RSI,ESI
XOR EAX,EAX
SHL RSI,0x4
LEA RDX,[RDI + RSI*0x1]
MOV RSI,RDI
NOP dword ptr [RAX]
LAB_00101560:
MOV ECX,dword ptr [RDI]
TEST ECX,ECX
JZ 0x001015b8
MOV R8D,dword ptr [RDI + 0x4]
TEST R8D,R8D
JZ 0x001015b8
TEST EAX,EAX
JLE 0x001015c8
MOV ECX,dword ptr [RDI + 0x8]
TEST ECX,ECX
JZ 0x001015b8
CMP EAX,0x1
JZ 0x001015cf
MOV R10D,dword ptr [RDI + 0xc]
TEST R10D,R10D
JZ 0x001015b8
CMP EAX,0x2
JZ 0x0010160f
LAB_00101591:
MOV R9D,dword ptr [RDI + 0x10]
TEST R9D,R9D
JZ 0x001015b8
MOV ECX,0x4
LAB_0010159f:
CMP EAX,ECX
CMOVL EAX,ECX
CMOVL RSI,RDI
ADD RCX,0x1
MOV R8D,dword ptr [RDI + RCX*0x4]
TEST R8D,R8D
JNZ 0x0010159f
NOP dword ptr [RAX]
LAB_001015b8:
ADD RDI,0x10
CMP RDI,RDX
JNZ 0x00101560
LAB_001015c1:
MOV RAX,RSI
RET
LAB_001015c8:
MOV ESI,dword ptr [RDI + 0x8]
TEST ESI,ESI
JZ 0x001015f8
LAB_001015cf:
MOV R11D,dword ptr [RDI + 0xc]
MOV RSI,RDI
MOV EAX,0x3
TEST R11D,R11D
JNZ 0x00101591
ADD RDI,0x10
MOV EAX,0x2
CMP RDI,RDX
JNZ 0x00101560
JMP 0x001015c1
LAB_001015f8:
MOV RSI,RDI
ADD RDI,0x10
MOV EAX,0x1
CMP RDI,RDX
JNZ 0x00101560
JMP 0x001015c1
LAB_0010160f:
MOV RSI,RDI
MOV EAX,0x3
JMP 0x00101591
LAB_0010161c:
MOV RSI,RDI
MOV RAX,RSI
RET | int * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int *piVar4;
if (param_2 < 1) {
return param_1;
}
iVar2 = 0;
piVar1 = param_1 + (long)param_2 * 4;
piVar4 = param_1;
do {
if ((*piVar4 != 0) && (piVar4[1] != 0)) {
if (iVar2 < 1) {
if (piVar4[2] == 0) {
iVar2 = 1;
param_1 = piVar4;
}
else {
LAB_001015cf:
iVar2 = 3;
param_1 = piVar4;
if (piVar4[3] == 0) {
iVar2 = 2;
}
else {
LAB_00101591:
if (piVar4[4] != 0) {
lVar3 = 4;
do {
if (iVar2 < (int)lVar3) {
param_1 = piVar4;
iVar2 = (int)lVar3;
}
lVar3 = lVar3 + 1;
} while (piVar4[lVar3] != 0);
}
}
}
}
else if (piVar4[2] != 0) {
if (iVar2 == 1) goto LAB_001015cf;
if (piVar4[3] != 0) {
if (iVar2 == 2) {
iVar2 = 3;
param_1 = piVar4;
}
goto LAB_00101591;
}
}
}
piVar4 = piVar4 + 4;
if (piVar4 == piVar1) {
return param_1;
}
} while( true );
} |
5,568 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == 345);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == 513);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e7 <func0+0x5e>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd %xmm1,-0x28(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
movq %rax,%xmm0
callq 1070 <round@plt>
addsd -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov %eax,-0x4(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ac <func0+0x23>
mov -0x4(%rbp),%eax
imul -0x1c(%rbp),%eax
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_4], 0
mov [rbp+var_8], 0
jmp short loc_11EB
loc_11AC:
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_4]
movsd [rbp+var_28], xmm1
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
movq xmm0, rax; x
call _round
addsd xmm0, [rbp+var_28]
cvttsd2si eax, xmm0
mov [rbp+var_4], eax
add [rbp+var_8], 1
loc_11EB:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_11AC
mov eax, [rbp+var_4]
imul eax, [rbp+var_1C]
leave
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+28h] [rbp-8h]
int v4; // [rsp+2Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
v4 = (int)(round(*(double *)(8LL * i + a1)) + (double)v4);
return (unsigned int)(a2 * v4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011eb
LAB_001011ac:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x4]
MOVSD qword ptr [RBP + -0x28],XMM1
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOVQ XMM0,RAX
CALL 0x00101070
ADDSD XMM0,qword ptr [RBP + -0x28]
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_001011eb:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ac
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x1c]
LEAVE
RET | int func0(long param_1,int param_2)
{
double dVar1;
int4 local_10;
int4 local_c;
local_c = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
dVar1 = round(*(double *)(param_1 + (long)local_10 * 8));
local_c = (int)(dVar1 + (double)local_c);
}
return local_c * param_2;
} |
5,569 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == 345);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == 513);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %esi,%r13d
test %esi,%esi
jle 11e6 <func0+0x5d>
mov %rdi,%rbp
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r12
mov $0x0,%ebx
movsd 0x0(%rbp),%xmm0
callq 1070 <round@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%ebx
add $0x8,%rbp
cmp %r12,%rbp
jne 11ae <func0+0x25>
mov %r13d,%eax
imul %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%ebx
jmp 11d5 <func0+0x4c>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13d, esi
test esi, esi
jle short loc_11E5
mov rbx, rdi
lea eax, [rsi-1]
lea r12, [rdi+rax*8+8]
mov ebp, 0
loc_11AE:
movsd xmm0, qword ptr [rbx]
call _round
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebp
addsd xmm0, xmm1
cvttsd2si ebp, xmm0
add rbx, 8
cmp rbx, r12
jnz short loc_11AE
loc_11D4:
mov eax, r13d
imul eax, ebp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11E5:
mov ebp, 0
jmp short loc_11D4 | long long func0(double *a1, int a2)
{
double *v2; // rbx
int v3; // ebp
if ( a2 <= 0 )
{
v3 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 = (int)((double)v3 + round(*v2++));
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return (unsigned int)(v3 * a2);
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13D,ESI
TEST ESI,ESI
JLE 0x001011e5
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R12,[RDI + RAX*0x8 + 0x8]
MOV EBP,0x0
LAB_001011ae:
MOVSD XMM0,qword ptr [RBX]
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
ADDSD XMM0,XMM1
CVTTSD2SI EBP,XMM0
ADD RBX,0x8
CMP RBX,R12
JNZ 0x001011ae
LAB_001011d4:
MOV EAX,R13D
IMUL EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011e5:
MOV EBP,0x0
JMP 0x001011d4 | int func0(double *param_1,int param_2)
{
double *pdVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pdVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
dVar3 = round(*param_1);
iVar2 = (int)((double)iVar2 + dVar3);
param_1 = param_1 + 1;
} while (param_1 != pdVar1);
}
return param_2 * iVar2;
} |
5,570 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == 345);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == 513);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13b0 <func0+0x60>
push %r13
lea -0x1(%rsi),%eax
mov %esi,%r13d
push %r12
lea 0x8(%rdi,%rax,8),%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
nopw 0x0(%rax,%rax,1)
movsd 0x0(%rbp),%xmm0
add $0x8,%rbp
callq 1070 <round@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%ebx
cmp %rbp,%r12
jne 1378 <func0+0x28>
add $0x8,%rsp
mov %r13d,%eax
imul %ebx,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_13B0
push r13
lea eax, [rsi-1]
mov r13d, esi
push r12
lea r12, [rdi+rax*8+8]
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
sub rsp, 8
nop word ptr [rax+rax+00h]
loc_1378:
movsd xmm0, qword ptr [rbx]
add rbx, 8
call _round
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebp
addsd xmm0, xmm1
cvttsd2si ebp, xmm0
cmp r12, rbx
jnz short loc_1378
add rsp, 8
mov eax, r13d
pop rbx
imul eax, ebp
pop rbp
pop r12
pop r13
retn
loc_13B0:
xor eax, eax
retn | long long func0(double *a1, int a2)
{
int v2; // ebp
double *v3; // rbx
double v4; // xmm0_8
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = a1;
do
{
v4 = *v3++;
v2 = (int)((double)v2 + round(v4));
}
while ( &a1[(unsigned int)(a2 - 1) + 1] != v3 );
return (unsigned int)(v2 * a2);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b0
PUSH R13
LEA EAX,[RSI + -0x1]
MOV R13D,ESI
PUSH R12
LEA R12,[RDI + RAX*0x8 + 0x8]
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
NOP word ptr [RAX + RAX*0x1]
LAB_00101378:
MOVSD XMM0,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
ADDSD XMM0,XMM1
CVTTSD2SI EBP,XMM0
CMP R12,RBX
JNZ 0x00101378
ADD RSP,0x8
MOV EAX,R13D
POP RBX
IMUL EAX,EBP
POP RBP
POP R12
POP R13
RET
LAB_001013b0:
XOR EAX,EAX
RET | int func0(double *param_1,int param_2)
{
double *pdVar1;
int iVar2;
double dVar3;
if (0 < param_2) {
pdVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
dVar3 = *param_1;
param_1 = param_1 + 1;
dVar3 = round(dVar3);
iVar2 = (int)((double)iVar2 + dVar3);
} while (pdVar1 != param_1);
return param_2 * iVar2;
}
return 0;
} |
5,571 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == 345);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == 513);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1360 <func0+0x60>
push %r13
lea -0x1(%rsi),%eax
mov %esi,%r13d
push %r12
lea 0x8(%rdi,%rax,8),%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
nopw 0x0(%rax,%rax,1)
movsd 0x0(%rbp),%xmm0
add $0x8,%rbp
callq 1070 <round@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%ebx
cmp %rbp,%r12
jne 1328 <func0+0x28>
add $0x8,%rsp
mov %r13d,%eax
imul %ebx,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1360
push r13
movsxd rax, esi
mov r13d, esi
push r12
lea r12, [rdi+rax*8]
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
sub rsp, 8
nop dword ptr [rax+00000000h]
loc_1328:
movsd xmm0, qword ptr [rbx]; x
add rbx, 8
call _round
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebp
addsd xmm0, xmm1
cvttsd2si ebp, xmm0
cmp r12, rbx
jnz short loc_1328
add rsp, 8
mov eax, r13d
pop rbx
imul eax, ebp
pop rbp
pop r12
pop r13
retn
loc_1360:
xor eax, eax
retn | long long func0(double *a1, int a2)
{
int v2; // ebp
double *v3; // rbx
double v4; // xmm0_8
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = a1;
do
{
v4 = *v3++;
v2 = (int)((double)v2 + round(v4));
}
while ( &a1[a2] != v3 );
return (unsigned int)(v2 * a2);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101360
PUSH R13
MOVSXD RAX,ESI
MOV R13D,ESI
PUSH R12
LEA R12,[RDI + RAX*0x8]
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
NOP dword ptr [RAX]
LAB_00101328:
MOVSD XMM0,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
ADDSD XMM0,XMM1
CVTTSD2SI EBP,XMM0
CMP R12,RBX
JNZ 0x00101328
ADD RSP,0x8
MOV EAX,R13D
POP RBX
IMUL EAX,EBP
POP RBP
POP R12
POP R13
RET
LAB_00101360:
XOR EAX,EAX
RET | int func0(double *param_1,int param_2)
{
double *pdVar1;
int iVar2;
double dVar3;
if (0 < param_2) {
pdVar1 = param_1 + param_2;
iVar2 = 0;
do {
dVar3 = *param_1;
param_1 = param_1 + 1;
dVar3 = round(dVar3);
iVar2 = (int)((double)iVar2 + dVar3);
} while (pdVar1 != param_1);
return param_2 * iVar2;
}
return 0;
} |
5,572 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1178 <func0+0x2f>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
shl $0x3,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_1178
loc_1164:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
shl eax, 3
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1178:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jle short loc_1164
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += 8 * i * i * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101178
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
SHL EAX,0x3
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101178:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = local_10 + local_c * local_c * local_c * 8;
}
return local_10;
} |
5,573 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1173 <func0+0x2a>
add $0x1,%edi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
lea (%rcx,%rdx,8),%ecx
add $0x1,%eax
cmp %edi,%eax
jne 115e <func0+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1170 <func0+0x27>
| func0:
endbr64
test edi, edi
jle short loc_1173
add edi, 1
mov eax, 1
mov ecx, 0
loc_115E:
mov edx, eax
imul edx, eax
imul edx, eax
lea ecx, [rcx+rdx*8]
add eax, 1
cmp eax, edi
jnz short loc_115E
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short loc_1170 | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v3 += 8 * v2 * v2 * v2;
++v2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
ADD EDI,0x1
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115e:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
LEA ECX,[RCX + RDX*0x8]
ADD EAX,0x1
CMP EAX,EDI
JNZ 0x0010115e
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * 8;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
return iVar2;
} |
5,574 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
lea (%r8,%rdx,8),%r8d
cmp %edi,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
lea r8d, [r8+rdx*8]
cmp eax, edi
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // r8d
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += 8 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
LEA R8D,[R8 + RDX*0x8]
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar3 = iVar3 + iVar2 * 8;
} while (iVar1 != param_1 + 1);
return iVar3;
}
return 0;
} |
5,575 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
lea (%r8,%rdx,8),%r8d
cmp %eax,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
lea ecx, [rcx+rdx*8]
cmp eax, edi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ecx, ecx
mov eax, ecx
retn | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += 8 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
LEA ECX,[RCX + RDX*0x8]
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar2 = iVar2 + iVar3 * 8;
} while (iVar1 != param_1 + 1);
return iVar2;
}
return 0;
} |
5,576 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movb $0x0,0x2e6e(%rip)
movw $0x2d,-0xa(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1229 <func0+0x80>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rsi
lea 0x2e3e(%rip),%rdi
callq 10b0 <strcat@plt>
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x10(%rbp)
jge 1225 <func0+0x7c>
lea -0xa(%rbp),%rax
mov %rax,%rsi
lea 0x2e20(%rip),%rdi
callq 10b0 <strcat@plt>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11e1 <func0+0x38>
lea 0x2e08(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 124c <func0+0xa3>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov cs:res_1, 0
mov word ptr [rbp+src], 2Dh ; '-'
mov [rbp+var_10], 0
jmp short loc_122F
loc_11E1:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rsi, rax; src
lea rax, res_1
mov rdi, rax; dest
call _strcat
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_10], eax
jge short loc_122B
lea rax, [rbp+src]
mov rsi, rax; src
lea rax, res_1
mov rdi, rax; dest
call _strcat
loc_122B:
add [rbp+var_10], 1
loc_122F:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jl short loc_11E1
lea rax, res_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1252
call ___stack_chk_fail
locret_1252:
leave
retn | char * func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-10h]
char src[2]; // [rsp+16h] [rbp-Ah] BYREF
unsigned long long v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
res_1 = 0;
strcpy(src, "-");
for ( i = 0; i < a2; ++i )
{
strcat(&res_1, *(const char **)(8LL * i + a1));
if ( i < a2 - 1 )
strcat(&res_1, src);
}
return &res_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x0
MOV word ptr [RBP + -0xa],0x2d
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010122f
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x10],EAX
JGE 0x0010122b
LEA RAX,[RBP + -0xa]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010b0
LAB_0010122b:
ADD dword ptr [RBP + -0x10],0x1
LAB_0010122f:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011e1
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101252
CALL 0x00101080
LAB_00101252:
LEAVE
RET | int1 * func0(long param_1,int param_2)
{
long in_FS_OFFSET;
int local_18;
char local_12 [2];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_12[0] = '-';
local_12[1] = '\0';
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
strcat(res_1,*(char **)(param_1 + (long)local_18 * 8));
if (local_18 < param_2 + -1) {
strcat(res_1,local_12);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
5,577 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movb $0x0,0x2e92(%rip)
movw $0x2d,0x6(%rsp)
test %esi,%esi
jle 1207 <func0+0x7e>
mov %rdi,%r12
lea -0x1(%rsi),%r13d
mov $0x0,%ebx
lea -0x1(%rsi),%ebp
jmp 11ec <func0+0x63>
lea 0x6(%rsp),%rsi
mov $0x3e8,%edx
lea 0x2e65(%rip),%rdi
callq 1070 <__strcat_chk@plt>
lea 0x1(%rbx),%rax
cmp %r13,%rbx
je 1207 <func0+0x7e>
mov %rax,%rbx
mov (%r12,%rbx,8),%rsi
mov $0x3e8,%edx
lea 0x2e44(%rip),%rdi
callq 1070 <__strcat_chk@plt>
cmp %ebx,%ebp
jle 11e0 <func0+0x57>
jmp 11ca <func0+0x41>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1229 <func0+0xa0>
lea 0x2e22(%rip),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov cs:res_1, 0
mov [rsp+38h+var_32], 2Dh ; '-'
test esi, esi
jle short loc_1227
mov r13, rdi
mov ebp, esi
mov r14d, esi
mov ebx, 0
lea r12, res_1
jmp short loc_11FA
loc_11F1:
add rbx, 1
cmp rbx, r14
jz short loc_1227
loc_11FA:
mov rsi, [r13+rbx*8+0]
mov edx, 3E8h
mov rdi, r12
call ___strcat_chk
lea eax, [rbp-1]
cmp eax, ebx
jle short loc_11F1
lea rsi, [rsp+38h+var_32]
mov edx, 3E8h
mov rdi, r12
call ___strcat_chk
jmp short loc_11F1
loc_1227:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_124B
lea rax, res_1
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_124B:
call ___stack_chk_fail | char * func0(long long a1, int a2)
{
long long i; // rbx
__int16 v4; // [rsp+6h] [rbp-32h] BYREF
unsigned long long v5; // [rsp+8h] [rbp-30h]
v5 = __readfsqword(0x28u);
res_1 = 0;
v4 = 45;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
__strcat_chk(&res_1, *(_QWORD *)(a1 + 8 * i), 1000LL);
if ( a2 - 1 > (int)i )
__strcat_chk(&res_1, &v4, 1000LL);
}
}
return &res_1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x0
MOV word ptr [RSP + 0x6],0x2d
TEST ESI,ESI
JLE 0x00101227
MOV R13,RDI
MOV EBP,ESI
MOV R14D,ESI
MOV EBX,0x0
LEA R12,[0x104040]
JMP 0x001011fa
LAB_001011f1:
ADD RBX,0x1
CMP RBX,R14
JZ 0x00101227
LAB_001011fa:
MOV RSI,qword ptr [R13 + RBX*0x8]
MOV EDX,0x3e8
MOV RDI,R12
CALL 0x00101080
LEA EAX,[RBP + -0x1]
CMP EAX,EBX
JLE 0x001011f1
LEA RSI,[RSP + 0x6]
MOV EDX,0x3e8
MOV RDI,R12
CALL 0x00101080
JMP 0x001011f1
LAB_00101227:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010124b
LEA RAX,[0x104040]
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010124b:
CALL 0x00101090 | int1 * func0(long param_1,uint param_2)
{
ulong uVar1;
long in_FS_OFFSET;
int2 local_32;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_32 = 0x2d;
if (0 < (int)param_2) {
uVar1 = 0;
do {
__strcat_chk(res_1,*(int8 *)(param_1 + uVar1 * 8),1000);
if ((int)uVar1 < (int)(param_2 - 1)) {
__strcat_chk(res_1,&local_32,1000);
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return res_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,578 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0x2d,%eax
movb $0x0,0x2cd2(%rip)
mov %ax,0x16(%rsp)
lea 0x16(%rsp),%rax
mov %rax,0x8(%rsp)
test %esi,%esi
jle 141c <func0+0xdc>
lea -0x1(%rsi),%r14d
lea 0x2cb0(%rip),%rbp
mov %rdi,%rbx
xor %r15d,%r15d
mov %r14,%r12
mov %rbp,%r13
jmp 13a3 <func0+0x63>
xchg %ax,%ax
mov %rax,%r15
lea 0x2c96(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 13aa <func0+0x6a>
mov %eax,%edx
mov (%rbx,%r15,8),%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdi
sub %rbp,%rdi
add %r13,%rdi
callq 10b0 <__stpcpy_chk@plt>
mov %rax,%rdi
cmp %r15d,%r12d
jle 1413 <func0+0xd3>
lea 0x3027(%rip),%rcx
mov 0x8(%rsp),%rsi
mov $0x2,%edx
sub %rax,%rcx
callq 10a0 <__memcpy_chk@plt>
lea 0x1(%r15),%rax
cmp %r15,%r14
jne 13a0 <func0+0x60>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1442 <func0+0x102>
add $0x28,%rsp
lea 0x2c09(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov eax, 2Dh ; '-'
mov cs:res_1, 0
mov [rsp+48h+var_42], ax
test esi, esi
jle loc_1428
lea r12, res_1
mov r13, rdi
lea r14d, [rsi-1]
xor ebx, ebx
movsxd rbp, esi
lea r15, [r12+3E8h]
nop word ptr [rax+rax+00000000h]
loc_13C0:
mov rdi, r12
call _strlen
mov rsi, [r13+rbx*8+0]
mov edx, 3E8h
lea rdi, [r12+rax]
call ___stpcpy_chk
mov rdi, rax
cmp r14d, ebx
jle short loc_13F8
mov rcx, r15
lea rsi, [rsp+48h+var_42]
mov edx, 2
sub rcx, rax
call ___memcpy_chk
loc_13F8:
add rbx, 1
cmp rbx, rbp
jnz short loc_13C0
loc_1401:
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz short loc_1431
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1428:
lea r12, res_1
jmp short loc_1401
loc_1431:
call ___stack_chk_fail | char * func0(long long a1, int a2)
{
long long i; // rbx
long long v3; // rax
long long v4; // rax
__int16 v6; // [rsp+6h] [rbp-42h] BYREF
unsigned long long v7; // [rsp+8h] [rbp-40h]
v7 = __readfsqword(0x28u);
res_1[0] = 0;
v6 = 45;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v3 = strlen(res_1);
v4 = __stpcpy_chk(&res_1[v3], *(_QWORD *)(a1 + 8 * i), 1000LL);
if ( a2 - 1 > (int)i )
__memcpy_chk(v4, &v6, 2LL, &res_1[-v4 + 1000]);
}
}
return res_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV EAX,0x2d
MOV byte ptr [0x00104040],0x0
MOV word ptr [RSP + 0x6],AX
TEST ESI,ESI
JLE 0x00101428
LEA R12,[0x104040]
MOV R13,RDI
LEA R14D,[RSI + -0x1]
XOR EBX,EBX
MOVSXD RBP,ESI
LEA R15,[R12 + 0x3e8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013c0:
MOV RDI,R12
CALL 0x001010a0
MOV RSI,qword ptr [R13 + RBX*0x8]
MOV EDX,0x3e8
LEA RDI,[R12 + RAX*0x1]
CALL 0x001010f0
MOV RDI,RAX
CMP R14D,EBX
JLE 0x001013f8
MOV RCX,R15
LEA RSI,[RSP + 0x6]
MOV EDX,0x2
SUB RCX,RAX
CALL 0x001010e0
LAB_001013f8:
ADD RBX,0x1
CMP RBX,RBP
JNZ 0x001013c0
LAB_00101401:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101431
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101428:
LEA R12,[0x104040]
JMP 0x00101401
LAB_00101431:
CALL 0x001010b0 | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
int2 local_42;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_42 = 0x2d;
if (0 < param_2) {
lVar3 = 0;
do {
sVar1 = strlen(res_1);
lVar2 = __stpcpy_chk(res_1 + sVar1,*(int8 *)(param_1 + lVar3 * 8),1000);
if ((int)lVar3 < param_2 + -1) {
__memcpy_chk(lVar2,&local_42,2,(long)&_end - lVar2);
}
lVar3 = lVar3 + 1;
} while (lVar3 != param_2);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
5,579 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov $0x2d,%eax
movb $0x0,0x2c92(%rip)
mov %ax,0x6(%rsp)
test %esi,%esi
jle 147e <func0+0xfe>
lea -0x1(%rsi),%r12d
mov %rdi,%rbp
mov %esi,%ebx
test %r12d,%r12d
jle 14a8 <func0+0x128>
mov %rdi,%r14
xor %r15d,%r15d
lea 0x6(%rsp),%r13
nopl 0x0(%rax,%rax,1)
lea 0x2c59(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 13e7 <func0+0x67>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%esi
add %al,%sil
mov (%r14),%rsi
sbb $0x3,%rdi
add $0x1,%r15d
add $0x8,%r14
callq 10d0 <__stpcpy_chk@plt>
lea 0x2ff0(%rip),%rcx
mov $0x2,%edx
mov %r13,%rsi
mov %rax,%rdi
sub %rax,%rcx
callq 10c0 <__memcpy_chk@plt>
cmp %r12d,%r15d
jl 13e0 <func0+0x60>
cmp %r15d,%ebx
jle 147e <func0+0xfe>
movslq %r15d,%r15
lea 0x2be1(%rip),%rcx
mov 0x0(%rbp,%r15,8),%rsi
mov %rcx,%rdi
mov $0x3e8,%edx
add $0x1,%r15
callq 1090 <__strcat_chk@plt>
mov %rax,%rcx
cmp %r15d,%ebx
jg 1460 <func0+0xe0>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 14ad <func0+0x12d>
add $0x18,%rsp
lea 0x2ba7(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
xor %r15d,%r15d
jmp 1455 <func0+0xd5>
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov eax, 2Dh ; '-'
mov cs:res_1, 0
mov [rsp+58h+var_42], ax
test esi, esi
jle loc_14B0
lea r14d, [rsi-1]
mov r13, rdi
mov r12d, esi
xor r15d, r15d
lea rbx, res_1
test r14d, r14d
jg short loc_1448
loc_13F4:
movsxd rbp, r15d
nop word ptr [rax+rax+00000000h]
loc_1400:
mov rsi, [r13+rbp*8+0]
mov edx, 3E8h
mov rdi, rbx
add rbp, 1
call ___strcat_chk
cmp r12d, ebp
jg short loc_1400
loc_141B:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz loc_14BC
add rsp, 28h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1448:
lea rax, [rsp+58h+var_42]
mov rbp, rdi
mov [rsp+58h+var_50], rax
loc_1455:
mov rdi, rbx; s
add r15d, 1
add rbp, 8
call _strlen
mov rsi, [rbp-8]
mov edx, 3E8h
lea rdi, [rbx+rax]
call ___stpcpy_chk
mov rsi, [rsp+58h+var_50]
mov edx, 2
lea rcx, _end
mov rdi, rax
sub rcx, rax
call ___memcpy_chk
cmp r15d, r14d
jl short loc_1455
cmp r12d, r15d
jg loc_13F4
jmp loc_141B
loc_14B0:
lea rbx, res_1
jmp loc_141B
loc_14BC:
call ___stack_chk_fail | char * func0(long long a1, int a2)
{
int v3; // r15d
long long v4; // rbp
long long v5; // rsi
long long v7; // rbp
size_t v8; // rax
long long v9; // rax
__int16 v10; // [rsp+16h] [rbp-42h] BYREF
unsigned long long v11; // [rsp+18h] [rbp-40h]
v11 = __readfsqword(0x28u);
res_1[0] = 0;
v10 = 45;
if ( a2 > 0 )
{
v3 = 0;
if ( a2 - 1 <= 0 )
goto LABEL_3;
v7 = a1;
do
{
++v3;
v7 += 8LL;
v8 = strlen(res_1);
v9 = __stpcpy_chk(&res_1[v8], *(_QWORD *)(v7 - 8), 1000LL);
__memcpy_chk(v9, &v10, 2LL, (char *)&end - v9);
}
while ( v3 < a2 - 1 );
if ( a2 > v3 )
{
LABEL_3:
v4 = v3;
do
{
v5 = *(_QWORD *)(a1 + 8 * v4++);
__strcat_chk(res_1, v5, 1000LL);
}
while ( a2 > (int)v4 );
}
}
return res_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV EAX,0x2d
MOV byte ptr [0x00104040],0x0
MOV word ptr [RSP + 0x16],AX
TEST ESI,ESI
JLE 0x001014b0
LEA R14D,[RSI + -0x1]
MOV R13,RDI
MOV R12D,ESI
XOR R15D,R15D
LEA RBX,[0x104040]
TEST R14D,R14D
JG 0x00101448
LAB_001013f4:
MOVSXD RBP,R15D
NOP word ptr [RAX + RAX*0x1]
LAB_00101400:
MOV RSI,qword ptr [R13 + RBP*0x8]
MOV EDX,0x3e8
MOV RDI,RBX
ADD RBP,0x1
CALL 0x001010b0
CMP R12D,EBP
JG 0x00101400
LAB_0010141b:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014bc
ADD RSP,0x28
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101448:
LEA RAX,[RSP + 0x16]
MOV RBP,RDI
MOV qword ptr [RSP + 0x8],RAX
LAB_00101455:
MOV RDI,RBX
ADD R15D,0x1
ADD RBP,0x8
CALL 0x001010c0
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x3e8
LEA RDI,[RBX + RAX*0x1]
CALL 0x00101110
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,0x2
LEA RCX,[0x104428]
MOV RDI,RAX
SUB RCX,RAX
CALL 0x00101100
CMP R15D,R14D
JL 0x00101455
CMP R12D,R15D
JG 0x001013f4
JMP 0x0010141b
LAB_001014b0:
LEA RBX,[0x104040]
JMP 0x0010141b
LAB_001014bc:
CALL 0x001010d0 | int1 * func0(int8 *param_1,int param_2)
{
size_t sVar1;
long lVar2;
int8 *puVar3;
int iVar4;
long in_FS_OFFSET;
int2 local_42;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_42 = 0x2d;
if (0 < param_2) {
iVar4 = 0;
if (0 < param_2 + -1) {
puVar3 = param_1;
do {
iVar4 = iVar4 + 1;
sVar1 = strlen(res_1);
lVar2 = __stpcpy_chk(res_1 + sVar1,*puVar3,1000);
__memcpy_chk(lVar2,&local_42,2,(long)&_end - lVar2);
puVar3 = puVar3 + 1;
} while (iVar4 < param_2 + -1);
if (param_2 <= iVar4) goto LAB_0010141b;
}
lVar2 = (long)iVar4;
do {
puVar3 = param_1 + lVar2;
lVar2 = lVar2 + 1;
__strcat_chk(res_1,*puVar3,1000);
} while ((int)lVar2 < param_2);
}
LAB_0010141b:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return res_1;
} |
5,580 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11aa <func0+0x41>
mov -0xc(%rbp),%eax
imul %eax,%eax
imul -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd -0x8(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 118a <func0+0x21>
cvtsi2sdl -0x14(%rbp),%xmm1
movsd -0x8(%rbp),%xmm0
divsd %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd 0xeac(%rip),%xmm0
mulsd %xmm1,%xmm0
callq 1060 <round@plt>
movsd 0xe9b(%rip),%xmm1
divsd %xmm1,%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm0, xmm0
movsd [rbp+var_8], xmm0
mov [rbp+var_C], 1
jmp short loc_11AE
loc_118A:
mov eax, [rbp+var_C]
imul eax, eax
imul eax, [rbp+var_C]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, [rbp+var_8]
addsd xmm0, xmm1
movsd [rbp+var_8], xmm0
add [rbp+var_C], 1
loc_11AE:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jle short loc_118A
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movsd xmm0, [rbp+var_8]
movapd xmm1, xmm0
divsd xmm1, xmm2
movsd xmm0, cs:qword_2058
mulsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _round
movq rax, xmm0
movsd xmm0, cs:qword_2058
movq xmm1, rax
divsd xmm1, xmm0
movapd xmm0, xmm1
leave
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
double v1; // rax
__int128 v2; // xmm1
int i; // [rsp+14h] [rbp-Ch]
double v5; // [rsp+18h] [rbp-8h]
v5 = 0.0;
for ( i = 1; i <= a1; ++i )
v5 = (double)(i * i * i) + v5;
v1 = round(v5 / (double)a1 * 1000000.0);
v2 = *(unsigned long long *)&v1;
*(double *)&v2 = v1 / 1000000.0;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001011ae
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0xc]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [RBP + -0x8]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
ADD dword ptr [RBP + -0xc],0x1
LAB_001011ae:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x0010118a
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVAPD XMM1,XMM0
DIVSD XMM1,XMM2
MOVSD XMM0,qword ptr [0x00102058]
MULSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101060
MOVQ RAX,XMM0
MOVSD XMM0,qword ptr [0x00102058]
MOVQ XMM1,RAX
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
LEAVE
RET | double func0(int param_1)
{
double dVar1;
int4 local_14;
int8 local_10;
local_10 = 0.0;
for (local_14 = 1; local_14 <= param_1; local_14 = local_14 + 1) {
local_10 = (double)(local_14 * local_14 * local_14) + local_10;
}
dVar1 = round((local_10 / (double)param_1) * DAT_00102058);
return dVar1 / DAT_00102058;
} |
5,581 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
test %edi,%edi
jle 11c2 <func0+0x59>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
pxor %xmm0,%xmm0
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
pxor %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
addsd %xmm1,%xmm0
add $0x1,%eax
cmp %ecx,%eax
jne 1181 <func0+0x18>
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xec8(%rip),%xmm0
callq 1060 <round@plt>
divsd 0xebb(%rip),%xmm0
add $0x8,%rsp
retq
pxor %xmm0,%xmm0
jmp 119c <func0+0x33>
| func0:
endbr64
sub rsp, 8
test edi, edi
jle short loc_11C2
lea ecx, [rdi+1]
mov eax, 1
pxor xmm0, xmm0
loc_1181:
mov edx, eax
imul edx, eax
imul edx, eax
pxor xmm1, xmm1
cvtsi2sd xmm1, edx
addsd xmm0, xmm1
add eax, 1
cmp eax, ecx
jnz short loc_1181
loc_119C:
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2058
call _round
divsd xmm0, cs:qword_2058
add rsp, 8
retn
loc_11C2:
pxor xmm0, xmm0
jmp short loc_119C | double func0(int a1)
{
int v1; // eax
double v2; // xmm0_8
if ( a1 <= 0 )
{
v2 = 0.0;
}
else
{
v1 = 1;
v2 = 0.0;
do
{
v2 = v2 + (double)(v1 * v1 * v1);
++v1;
}
while ( v1 != a1 + 1 );
}
return round(v2 / (double)a1 * 1000000.0) / 1000000.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST EDI,EDI
JLE 0x001011c2
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
PXOR XMM0,XMM0
LAB_00101181:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDX
ADDSD XMM0,XMM1
ADD EAX,0x1
CMP EAX,ECX
JNZ 0x00101181
LAB_0010119c:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102058]
CALL 0x00101060
DIVSD XMM0,qword ptr [0x00102058]
ADD RSP,0x8
RET
LAB_001011c2:
PXOR XMM0,XMM0
JMP 0x0010119c | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
int iVar1;
double dVar2;
if (param_1 < 1) {
dVar2 = 0.0;
}
else {
iVar1 = 1;
dVar2 = 0.0;
do {
dVar2 = dVar2 + (double)(iVar1 * iVar1 * iVar1);
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
dVar2 = round((dVar2 / (double)param_1) * _DAT_00102058);
return dVar2 / _DAT_00102058;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.