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,282 | func0 |
#include <assert.h>
| int func0(int m, int n) {
if (n < m) {
int temp = m;
m = n;
n = temp;
}
return n * (n + 1) * (3 * m - n + 1) / 6;
}
| int main() {
assert(func0(4, 3) == 20);
assert(func0(1, 2) == 2);
assert(func0(2, 2) == 5);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jge 1150 <func0+0x10>
mov %edi,%edx
mov %esi,%edi
mov %edx,%eax
lea (%rdi,%rdi,2),%esi
lea 0x1(%rax),%edx
sub %eax,%esi
imul %edx,%eax
add $0x1,%esi
imul %eax,%esi
movslq %esi,%rax
sar $0x1f,%esi
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sub %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
cmp esi, edi
jge short loc_1150
mov edx, edi
mov edi, esi
mov eax, edx
loc_1150:
lea esi, [rdi+rdi*2]
lea edx, [rax+1]
sub esi, eax
imul eax, edx
add esi, 1
imul esi, eax
movsxd rax, esi
sar esi, 1Fh
imul rax, 2AAAAAABh
shr rax, 20h
sub eax, esi
retn | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // edx
v2 = a2;
if ( a2 < a1 )
{
v3 = a1;
a1 = a2;
v2 = v3;
}
return (unsigned int)((v2 + 1) * v2 * (3 * a1 - v2 + 1) / 6);
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JGE 0x00101150
MOV EDX,EDI
MOV EDI,ESI
MOV EAX,EDX
LAB_00101150:
LEA ESI,[RDI + RDI*0x2]
LEA EDX,[RAX + 0x1]
SUB ESI,EAX
IMUL EAX,EDX
ADD ESI,0x1
IMUL ESI,EAX
MOVSXD RAX,ESI
SAR ESI,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,ESI
RET | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_2;
if (param_2 < param_1) {
iVar1 = param_1;
param_1 = param_2;
}
return (((param_1 * 3 - iVar1) + 1) * iVar1 * (iVar1 + 1)) / 6;
} |
5,283 | func0 |
#include <assert.h>
| int func0(int m, int n) {
if (n < m) {
int temp = m;
m = n;
n = temp;
}
return n * (n + 1) * (3 * m - n + 1) / 6;
}
| int main() {
assert(func0(4, 3) == 20);
assert(func0(1, 2) == 2);
assert(func0(2, 2) == 5);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jge 1150 <func0+0x10>
mov %edi,%edx
mov %esi,%edi
mov %edx,%eax
lea (%rdi,%rdi,2),%esi
lea 0x1(%rax),%edx
sub %eax,%esi
imul %edx,%eax
add $0x1,%esi
imul %eax,%esi
movslq %esi,%rax
sar $0x1f,%esi
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sub %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cmp esi, edi
jl short loc_1150
mov edx, esi
mov esi, edi
mov eax, edx
loc_1150:
lea edi, [rsi+rsi*2]
lea edx, [rax+1]
sub edi, eax
imul eax, edx
add edi, 1
imul edi, eax
movsxd rax, edi
sar edi, 1Fh
imul rax, 2AAAAAABh
shr rax, 20h
sub eax, edi
retn | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // edx
v2 = a1;
if ( a2 >= a1 )
{
v3 = a2;
a2 = a1;
v2 = v3;
}
return (unsigned int)((v2 + 1) * v2 * (3 * a2 - v2 + 1) / 6);
} | func0:
ENDBR64
MOV EAX,EDI
CMP ESI,EDI
JL 0x00101150
MOV EDX,ESI
MOV ESI,EDI
MOV EAX,EDX
LAB_00101150:
LEA EDI,[RSI + RSI*0x2]
LEA EDX,[RAX + 0x1]
SUB EDI,EAX
IMUL EAX,EDX
ADD EDI,0x1
IMUL EDI,EAX
MOVSXD RAX,EDI
SAR EDI,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDI
RET | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_1;
if (param_1 <= param_2) {
iVar1 = param_2;
param_2 = param_1;
}
return (((param_2 * 3 - iVar1) + 1) * iVar1 * (iVar1 + 1)) / 6;
} |
5,284 | func0 |
#include <assert.h>
long bin_coff(int n, int r) {
long val = 1;
if (r > (n - r)) {
r = (n - r);
}
for (int i = 0; i < r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
| long func0(int M) {
int n = M / 2;
long a = bin_coff(2 * n, n);
long b = a / (n + 1);
return b;
}
| int main() {
assert(func0(4) == 2);
assert(func0(6) == 5);
assert(func0(8) == 14);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x28,%rsp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0x14(%rbp),%eax
mov %eax,%esi
mov %edx,%edi
callq 1149 <bin_coff>
mov %rax,-0x10(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
movslq %eax,%rcx
mov -0x10(%rbp),%rax
cqto
idiv %rcx
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 28h
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
lea edx, [rax+rax]
mov eax, [rbp+var_14]
mov esi, eax
mov edi, edx
call bin_coff
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
add eax, 1
movsxd rcx, eax
mov rax, [rbp+var_10]
cqo
idiv rcx
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
leave
retn | long long func0(int a1)
{
return bin_coff((unsigned int)(2 * (a1 / 2)), (unsigned int)(a1 / 2)) / (a1 / 2 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x28
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EAX
MOV EDI,EDX
CALL 0x00101149
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x10]
CQO
IDIV RCX
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | long func0(int param_1)
{
long lVar1;
param_1 = param_1 / 2;
lVar1 = bin_coff(param_1 * 2,param_1);
return lVar1 / (long)(param_1 + 1);
} |
5,285 | func0 |
#include <assert.h>
long bin_coff(int n, int r) {
long val = 1;
if (r > (n - r)) {
r = (n - r);
}
for (int i = 0; i < r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
| long func0(int M) {
int n = M / 2;
long a = bin_coff(2 * n, n);
long b = a / (n + 1);
return b;
}
| int main() {
assert(func0(4) == 2);
assert(func0(6) == 5);
assert(func0(8) == 14);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %edi,%eax
shr $0x1f,%eax
lea (%rax,%rdi,1),%edi
mov %edi,%ebx
sar %ebx
and $0xfffffffe,%edi
mov %ebx,%esi
callq 1149 <bin_coff>
add $0x1,%ebx
movslq %ebx,%rbx
cqto
idiv %rbx
pop %rbx
retq
| func0:
endbr64
push rbx
mov eax, edi
shr eax, 1Fh
lea edi, [rax+rdi]
mov ebx, edi
sar ebx, 1
and edi, 0FFFFFFFEh
mov esi, ebx
call bin_coff
add ebx, 1
movsxd rbx, ebx
cqo
idiv rbx
pop rbx
retn | long long func0(unsigned int a1)
{
return bin_coff(((a1 >> 31) + a1) & 0xFFFFFFFE, (unsigned int)((int)a1 / 2)) / ((int)a1 / 2 + 1);
} | func0:
ENDBR64
PUSH RBX
MOV EAX,EDI
SHR EAX,0x1f
LEA EDI,[RAX + RDI*0x1]
MOV EBX,EDI
SAR EBX,0x1
AND EDI,0xfffffffe
MOV ESI,EBX
CALL 0x00101149
ADD EBX,0x1
MOVSXD RBX,EBX
CQO
IDIV RBX
POP RBX
RET | long func0(int param_1)
{
long lVar1;
lVar1 = bin_coff(param_1 - (param_1 >> 0x1f) & 0xfffffffe,param_1 / 2);
return lVar1 / (long)(param_1 / 2 + 1);
} |
5,286 | func0 |
#include <assert.h>
long bin_coff(int n, int r) {
long val = 1;
if (r > (n - r)) {
r = (n - r);
}
for (int i = 0; i < r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
| long func0(int M) {
int n = M / 2;
long a = bin_coff(2 * n, n);
long b = a / (n + 1);
return b;
}
| int main() {
assert(func0(4) == 2);
assert(func0(6) == 5);
assert(func0(8) == 14);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
lea (%rax,%rdi,1),%esi
mov %esi,%r8d
and $0xfffffffe,%esi
sar %r8d
mov %esi,%eax
sub %r8d,%eax
cmp %r8d,%eax
cmovg %r8d,%eax
test %eax,%eax
jle 1208 <func0+0x68>
lea -0x1(%rax),%edi
movslq %esi,%rsi
mov $0x1,%ecx
mov $0x1,%eax
add $0x2,%rdi
add $0x1,%rsi
nopl (%rax)
mov %rsi,%rdx
sub %rcx,%rdx
imul %rdx,%rax
cqto
idiv %rcx
add $0x1,%rcx
cmp %rdi,%rcx
jne 11e0 <func0+0x40>
add $0x1,%r8d
cqto
movslq %r8d,%r8
idiv %r8
retq
nopl (%rax)
mov $0x1,%eax
add $0x1,%r8d
movslq %r8d,%r8
cqto
idiv %r8
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add eax, edi
mov edi, eax
and eax, 0FFFFFFFEh
sar edi, 1
mov edx, eax
sub eax, edi
cmp eax, edi
cmovg eax, edi
test eax, eax
jle short loc_1200
lea esi, [rdx+1]
lea r8d, [rax+1]
mov ecx, 1
mov eax, 1
movsxd rsi, esi
nop dword ptr [rax+rax+00h]
loc_11D8:
mov rdx, rsi
sub rdx, rcx
imul rax, rdx
cqo
idiv rcx
add rcx, 1
cmp rcx, r8
jnz short loc_11D8
add edi, 1
cqo
movsxd rdi, edi
idiv rdi
retn
loc_1200:
mov eax, 1
add edi, 1
movsxd rdi, edi
cqo
idiv rdi
retn | long long func0(unsigned int a1)
{
unsigned int v1; // eax
int v2; // edi
unsigned int v3; // edx
int v4; // eax
long long v5; // r8
long long v6; // rcx
long long v7; // rax
v1 = (a1 + (a1 >> 31)) & 0xFFFFFFFE;
v2 = (int)a1 / 2;
v3 = v1;
v4 = v1 - v2;
if ( v4 > v2 )
v4 = v2;
if ( v4 <= 0 )
return 1LL / (v2 + 1);
v5 = (unsigned int)(v4 + 1);
v6 = 1LL;
v7 = 1LL;
do
{
v7 = ((int)(v3 + 1) - v6) * v7 / v6;
++v6;
}
while ( v6 != v5 );
return v7 / (v2 + 1);
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
MOV EDI,EAX
AND EAX,0xfffffffe
SAR EDI,0x1
MOV EDX,EAX
SUB EAX,EDI
CMP EAX,EDI
CMOVG EAX,EDI
TEST EAX,EAX
JLE 0x00101200
LEA ESI,[RDX + 0x1]
LEA R8D,[RAX + 0x1]
MOV ECX,0x1
MOV EAX,0x1
MOVSXD RSI,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_001011d8:
MOV RDX,RSI
SUB RDX,RCX
IMUL RAX,RDX
CQO
IDIV RCX
ADD RCX,0x1
CMP RCX,R8
JNZ 0x001011d8
ADD EDI,0x1
CQO
MOVSXD RDI,EDI
IDIV RDI
RET
LAB_00101200:
MOV EAX,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
CQO
IDIV RDI
RET | long func0(int param_1)
{
int1 auVar1 [16];
uint uVar2;
int iVar3;
long lVar4;
ulong uVar5;
uVar2 = param_1 - (param_1 >> 0x1f) & 0xfffffffe;
param_1 = param_1 / 2;
iVar3 = uVar2 - param_1;
if (param_1 < iVar3) {
iVar3 = param_1;
}
if (0 < iVar3) {
uVar5 = 1;
lVar4 = 1;
do {
lVar4 = (long)(lVar4 * ((long)(int)(uVar2 + 1) - uVar5)) / (long)uVar5;
uVar5 = uVar5 + 1;
} while (uVar5 != iVar3 + 1);
return lVar4 / (long)(param_1 + 1);
}
auVar1._8_8_ = 0;
auVar1._0_8_ = SUB168(SEXT816(1),8);
return SUB168((auVar1 << 0x40 | ZEXT816(1)) / SEXT816((long)(param_1 + 1)),0);
} |
5,287 | func0 |
#include <assert.h>
long bin_coff(int n, int r) {
long val = 1;
if (r > (n - r)) {
r = (n - r);
}
for (int i = 0; i < r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
| long func0(int M) {
int n = M / 2;
long a = bin_coff(2 * n, n);
long b = a / (n + 1);
return b;
}
| int main() {
assert(func0(4) == 2);
assert(func0(6) == 5);
assert(func0(8) == 14);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
lea (%rax,%rdi,1),%esi
mov %esi,%r8d
and $0xfffffffe,%esi
sar %r8d
mov %esi,%eax
sub %r8d,%eax
cmp %r8d,%eax
cmovg %r8d,%eax
test %eax,%eax
jle 1208 <func0+0x68>
lea -0x1(%rax),%edi
movslq %esi,%rsi
mov $0x1,%ecx
mov $0x1,%eax
add $0x2,%rdi
add $0x1,%rsi
nopl (%rax)
mov %rsi,%rdx
sub %rcx,%rdx
imul %rdx,%rax
cqto
idiv %rcx
add $0x1,%rcx
cmp %rcx,%rdi
jne 11e0 <func0+0x40>
add $0x1,%r8d
cqto
movslq %r8d,%r8
idiv %r8
retq
nopl (%rax)
mov $0x1,%eax
add $0x1,%r8d
movslq %r8d,%r8
cqto
idiv %r8
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov esi, edi
shr esi, 1Fh
add esi, edi
sar esi, 1
cmp edi, 1
jle short loc_11E0
movsxd rdi, esi
mov ecx, 1
mov eax, 1
lea r8, [rdi+rdi+1]
nop dword ptr [rax+00h]
loc_11B8:
mov rdx, r8
sub rdx, rcx
imul rax, rdx
cqo
idiv rcx
mov rdx, rcx
add rcx, 1
cmp rdi, rdx
jnz short loc_11B8
lea ecx, [rsi+1]
cqo
movsxd rcx, ecx
idiv rcx
retn
loc_11E0:
mov eax, 1
lea ecx, [rsi+1]
movsxd rcx, ecx
cqo
idiv rcx
retn | long long func0(int a1)
{
int v1; // esi
long long v2; // rcx
long long v3; // rax
long long v4; // rdx
v1 = a1 / 2;
if ( a1 <= 1 )
return 1LL / (v1 + 1);
v2 = 1LL;
v3 = 1LL;
do
{
v3 = (2LL * v1 + 1 - v2) * v3 / v2;
v4 = v2++;
}
while ( v1 != v4 );
return v3 / (v1 + 1);
} | func0:
ENDBR64
MOV ESI,EDI
SHR ESI,0x1f
ADD ESI,EDI
SAR ESI,0x1
CMP EDI,0x1
JLE 0x001011e0
MOVSXD RDI,ESI
MOV ECX,0x1
MOV EAX,0x1
LEA R8,[RDI + RDI*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_001011b8:
MOV RDX,R8
SUB RDX,RCX
IMUL RAX,RDX
CQO
IDIV RCX
MOV RDX,RCX
ADD RCX,0x1
CMP RDI,RDX
JNZ 0x001011b8
LEA ECX,[RSI + 0x1]
CQO
MOVSXD RCX,ECX
IDIV RCX
RET
LAB_001011e0:
MOV EAX,0x1
LEA ECX,[RSI + 0x1]
MOVSXD RCX,ECX
CQO
IDIV RCX
RET | long func0(int param_1)
{
int auVar1 [16];
long lVar2;
long lVar3;
int iVar4;
bool bVar5;
iVar4 = param_1 / 2;
if (1 < param_1) {
lVar2 = 1;
lVar3 = 1;
do {
lVar2 = (lVar2 * (((long)iVar4 * 2 + 1) - lVar3)) / lVar3;
bVar5 = iVar4 != lVar3;
lVar3 = lVar3 + 1;
} while (bVar5);
return lVar2 / (long)(iVar4 + 1);
}
auVar1._8_8_ = 0;
auVar1._0_8_ = SUB168(SEXT816(1),8);
return SUB168((auVar1 << 0x40 | ZEXT816(1)) / SEXT816((long)(iVar4 + 1)),0);
} |
5,288 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* string) {
int has0 = 0;
int has1 = 0;
int hasOther = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == '0') {
has0 = 1;
} else if (string[i] == '1') {
has1 = 1;
} else {
hasOther = 1;
break;
}
}
if ((has0 || has1) && !hasOther) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0("01010101010"), "Yes") == 0);
assert(strcmp(func0("name0"), "No") == 0);
assert(strcmp(func0("101"), "Yes") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11ff <func0+0x76>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x30,%al
jne 11d5 <func0+0x4c>
movl $0x1,-0x20(%rbp)
jmp 11fb <func0+0x72>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x31,%al
jne 11f2 <func0+0x69>
movl $0x1,-0x1c(%rbp)
jmp 11fb <func0+0x72>
movl $0x1,-0x18(%rbp)
jmp 1216 <func0+0x8d>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
cmp %rax,%rbx
jb 11b8 <func0+0x2f>
cmpl $0x0,-0x20(%rbp)
jne 1222 <func0+0x99>
cmpl $0x0,-0x1c(%rbp)
je 1231 <func0+0xa8>
cmpl $0x0,-0x18(%rbp)
jne 1231 <func0+0xa8>
lea 0xdd9(%rip),%rax
jmp 1238 <func0+0xaf>
lea 0xdd4(%rip),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11FF
loc_11B8:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 30h ; '0'
jnz short loc_11D5
mov [rbp+var_20], 1
jmp short loc_11FB
loc_11D5:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 31h ; '1'
jnz short loc_11F2
mov [rbp+var_1C], 1
jmp short loc_11FB
loc_11F2:
mov [rbp+var_18], 1
jmp short loc_1216
loc_11FB:
add [rbp+var_14], 1
loc_11FF:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_11B8
loc_1216:
cmp [rbp+var_20], 0
jnz short loc_1222
cmp [rbp+var_1C], 0
jz short loc_1231
loc_1222:
cmp [rbp+var_18], 0
jnz short loc_1231
lea rax, s2; "Yes"
jmp short loc_1238
loc_1231:
lea rax, aNo; "No"
loc_1238:
mov rbx, [rbp+var_8]
leave
retn | const char * func0(const char *a1)
{
int v2; // [rsp+10h] [rbp-20h]
int v3; // [rsp+14h] [rbp-1Ch]
int v4; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
v3 = 0;
v4 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == 48 )
{
v2 = 1;
}
else
{
if ( a1[i] != 49 )
{
v4 = 1;
break;
}
v3 = 1;
}
}
if ( (v2 || v3) && !v4 )
return "Yes";
else
return "No";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011ff
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x30
JNZ 0x001011d5
MOV dword ptr [RBP + -0x20],0x1
JMP 0x001011fb
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x31
JNZ 0x001011f2
MOV dword ptr [RBP + -0x1c],0x1
JMP 0x001011fb
LAB_001011f2:
MOV dword ptr [RBP + -0x18],0x1
JMP 0x00101216
LAB_001011fb:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011ff:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
CMP RBX,RAX
JC 0x001011b8
LAB_00101216:
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x00101222
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x00101231
LAB_00101222:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00101231
LEA RAX,[0x102008]
JMP 0x00101238
LAB_00101231:
LEA RAX,[0x10200c]
LAB_00101238:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int * func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
size_t sVar4;
int *puVar5;
int local_1c;
bVar1 = false;
bVar2 = false;
bVar3 = false;
local_1c = 0;
do {
sVar4 = strlen(param_1);
if (sVar4 <= (ulong)(long)local_1c) {
LAB_00101216:
if (((!bVar1) && (!bVar2)) || (bVar3)) {
puVar5 = &DAT_0010200c;
}
else {
puVar5 = &DAT_00102008;
}
return puVar5;
}
if (param_1[local_1c] == '0') {
bVar1 = true;
}
else {
if (param_1[local_1c] != '1') {
bVar3 = true;
goto LAB_00101216;
}
bVar2 = true;
}
local_1c = local_1c + 1;
} while( true );
} |
5,289 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* string) {
int has0 = 0;
int has1 = 0;
int hasOther = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == '0') {
has0 = 1;
} else if (string[i] == '1') {
has1 = 1;
} else {
hasOther = 1;
break;
}
}
if ((has0 || has1) && !hasOther) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0("01010101010"), "Yes") == 0);
assert(strcmp(func0("name0"), "No") == 0);
assert(strcmp(func0("101"), "Yes") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rsi,%rdx
lea -0x1(%rsi,%rcx,1),%rcx
mov $0x0,%edi
mov $0x0,%r8d
mov $0x1,%esi
jmp 1182 <func0+0x39>
mov %esi,%r8d
add $0x1,%rdx
cmp %rcx,%rdx
je 1196 <func0+0x4d>
movzbl (%rdx),%eax
cmp $0x30,%al
je 117b <func0+0x32>
cmp $0x31,%al
jne 11ac <func0+0x63>
mov %esi,%edi
jmp 117e <func0+0x35>
or %edi,%r8d
lea 0xe64(%rip),%rax
lea 0xe61(%rip),%rdx
cmove %rdx,%rax
retq
lea 0xe55(%rip),%rax
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rax
mov rax, rbx
add rdi, rbx
mov esi, 0
mov r8d, 0
mov ecx, 1
jmp short loc_11B8
loc_11B1:
mov r8d, ecx
loc_11B4:
add rax, 1
loc_11B8:
cmp rax, rdi
jz short loc_11CE
movzx edx, byte ptr [rax]
cmp dl, 30h ; '0'
jz short loc_11B1
cmp dl, 31h ; '1'
jnz short loc_11E5
mov esi, ecx
jmp short loc_11B4
loc_11CE:
or r8d, esi
lea rax, unk_2004
lea rdx, unk_2008
cmovz rax, rdx
loc_11E3:
pop rbx
retn
loc_11E5:
lea rax, unk_2008
jmp short loc_11E3 | void * func0(_BYTE *a1)
{
long long v2; // rdi
_BYTE *v3; // rax
_BYTE *v4; // rdi
int v5; // esi
int v6; // r8d
void *result; // rax
v2 = strlen();
v3 = a1;
v4 = &a1[v2];
v5 = 0;
v6 = 0;
while ( v3 != v4 )
{
if ( *v3 == 48 )
{
v6 = 1;
}
else
{
if ( *v3 != 49 )
return &unk_2008;
v5 = 1;
}
++v3;
}
result = &unk_2004;
if ( !(v5 | v6) )
return &unk_2008;
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
MOV RDI,RAX
MOV RAX,RBX
ADD RDI,RBX
MOV ESI,0x0
MOV R8D,0x0
MOV ECX,0x1
JMP 0x001011b8
LAB_001011b1:
MOV R8D,ECX
LAB_001011b4:
ADD RAX,0x1
LAB_001011b8:
CMP RAX,RDI
JZ 0x001011ce
MOVZX EDX,byte ptr [RAX]
CMP DL,0x30
JZ 0x001011b1
CMP DL,0x31
JNZ 0x001011e5
MOV ESI,ECX
JMP 0x001011b4
LAB_001011ce:
OR R8D,ESI
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVZ RAX,RDX
LAB_001011e3:
POP RBX
RET
LAB_001011e5:
LEA RAX,[0x102008]
JMP 0x001011e3 | int * func0(char *param_1)
{
byte bVar1;
byte bVar2;
size_t sVar3;
int *puVar4;
char *pcVar5;
sVar3 = strlen(param_1);
pcVar5 = param_1 + sVar3;
bVar1 = 0;
bVar2 = 0;
do {
if (param_1 == pcVar5) {
puVar4 = &DAT_00102004;
if (!(bool)(bVar2 | bVar1)) {
puVar4 = &DAT_00102008;
}
return puVar4;
}
if (*param_1 == '0') {
bVar2 = 1;
}
else {
if (*param_1 != '1') {
return &DAT_00102008;
}
bVar1 = 1;
}
param_1 = param_1 + 1;
} while( true );
} |
5,290 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* string) {
int has0 = 0;
int has1 = 0;
int hasOther = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == '0') {
has0 = 1;
} else if (string[i] == '1') {
has1 = 1;
} else {
hasOther = 1;
break;
}
}
if ((has0 || has1) && !hasOther) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0("01010101010"), "Yes") == 0);
assert(strcmp(func0("name0"), "No") == 0);
assert(strcmp(func0("101"), "Yes") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
xor %esi,%esi
add %rbx,%rax
jmp 127e <func0+0x2e>
nopl 0x0(%rax)
cmp $0x31,%dl
jne 12b0 <func0+0x60>
mov $0x1,%ecx
add $0x1,%rdi
cmp %rdi,%rax
je 1298 <func0+0x48>
movzbl (%rdi),%edx
cmp $0x30,%dl
jne 1270 <func0+0x20>
mov $0x1,%esi
jmp 127a <func0+0x2a>
nopw 0x0(%rax,%rax,1)
or %ecx,%esi
lea 0xd63(%rip),%rax
lea 0xd5f(%rip),%rdx
pop %rbx
cmovne %rdx,%rax
retq
xchg %ax,%ax
lea 0xd4d(%rip),%rax
pop %rbx
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
xor esi, esi
add rax, rbx
jmp short loc_127E
loc_1270:
cmp dl, 31h ; '1'
jnz short loc_12B0
mov ecx, 1
loc_127A:
add rdi, 1
loc_127E:
cmp rax, rdi
jz short loc_1298
movzx edx, byte ptr [rdi]
cmp dl, 30h ; '0'
jnz short loc_1270
mov esi, 1
jmp short loc_127A
loc_1298:
or esi, ecx
lea rax, unk_2008
lea rdx, unk_2004
pop rbx
cmovnz rax, rdx
retn
loc_12B0:
lea rax, unk_2008
pop rbx
retn | void * func0(_BYTE *a1)
{
long long v1; // rax
int v2; // ecx
int v3; // esi
_BYTE *v4; // rax
void *result; // rax
v1 = strlen();
v2 = 0;
v3 = 0;
v4 = &a1[v1];
while ( v4 != a1 )
{
if ( *a1 == 48 )
{
v3 = 1;
}
else
{
if ( *a1 != 49 )
return &unk_2008;
v2 = 1;
}
++a1;
}
result = &unk_2008;
if ( v2 | v3 )
return &unk_2004;
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
MOV RDI,RBX
XOR ECX,ECX
XOR ESI,ESI
ADD RAX,RBX
JMP 0x0010127e
LAB_00101270:
CMP DL,0x31
JNZ 0x001012b0
MOV ECX,0x1
LAB_0010127a:
ADD RDI,0x1
LAB_0010127e:
CMP RAX,RDI
JZ 0x00101298
MOVZX EDX,byte ptr [RDI]
CMP DL,0x30
JNZ 0x00101270
MOV ESI,0x1
JMP 0x0010127a
LAB_00101298:
OR ESI,ECX
LEA RAX,[0x102008]
LEA RDX,[0x102004]
POP RBX
CMOVNZ RAX,RDX
RET
LAB_001012b0:
LEA RAX,[0x102008]
POP RBX
RET | int * func0(char *param_1)
{
bool bVar1;
bool bVar2;
size_t sVar3;
char *pcVar4;
int *puVar5;
sVar3 = strlen(param_1);
bVar2 = false;
bVar1 = false;
pcVar4 = param_1 + sVar3;
do {
if (pcVar4 == param_1) {
puVar5 = &DAT_00102008;
if (bVar1 || bVar2) {
puVar5 = &DAT_00102004;
}
return puVar5;
}
if (*param_1 == '0') {
bVar1 = true;
}
else {
if (*param_1 != '1') {
return &DAT_00102008;
}
bVar2 = true;
}
param_1 = param_1 + 1;
} while( true );
} |
5,291 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* string) {
int has0 = 0;
int has1 = 0;
int hasOther = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == '0') {
has0 = 1;
} else if (string[i] == '1') {
has1 = 1;
} else {
hasOther = 1;
break;
}
}
if ((has0 || has1) && !hasOther) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0("01010101010"), "Yes") == 0);
assert(strcmp(func0("name0"), "No") == 0);
assert(strcmp(func0("101"), "Yes") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
xor %esi,%esi
add %rbx,%rax
jmp 127e <func0+0x2e>
nopl 0x0(%rax)
cmp $0x31,%dl
jne 12b0 <func0+0x60>
mov $0x1,%ecx
add $0x1,%rdi
cmp %rdi,%rax
je 1298 <func0+0x48>
movzbl (%rdi),%edx
cmp $0x30,%dl
jne 1270 <func0+0x20>
mov $0x1,%esi
jmp 127a <func0+0x2a>
nopw 0x0(%rax,%rax,1)
or %ecx,%esi
lea 0xd63(%rip),%rax
lea 0xd5f(%rip),%rdx
pop %rbx
cmovne %rdx,%rax
retq
xchg %ax,%ax
lea 0xd4d(%rip),%rax
pop %rbx
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
xor esi, esi
add rax, rbx
jmp short loc_127E
loc_1270:
cmp dl, 31h ; '1'
jnz short loc_12B0
mov ecx, 1
loc_127A:
add rdi, 1
loc_127E:
cmp rdi, rax
jz short loc_1298
movzx edx, byte ptr [rdi]
cmp dl, 30h ; '0'
jnz short loc_1270
mov esi, 1
jmp short loc_127A
loc_1298:
or esi, ecx
lea rax, s2; "Yes"
lea rdx, aNo; "No"
pop rbx
cmovz rax, rdx
retn
loc_12B0:
lea rax, aNo; "No"
pop rbx
retn | const char * func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
int v3; // esi
const char *v4; // rax
const char *result; // rax
v1 = strlen(a1);
v2 = 0;
v3 = 0;
v4 = &a1[v1];
while ( a1 != v4 )
{
if ( *a1 == 48 )
{
v3 = 1;
}
else
{
if ( *a1 != 49 )
return "No";
v2 = 1;
}
++a1;
}
result = "Yes";
if ( !(v2 | v3) )
return "No";
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
MOV RDI,RBX
XOR ECX,ECX
XOR ESI,ESI
ADD RAX,RBX
JMP 0x0010127e
LAB_00101270:
CMP DL,0x31
JNZ 0x001012b0
MOV ECX,0x1
LAB_0010127a:
ADD RDI,0x1
LAB_0010127e:
CMP RDI,RAX
JZ 0x00101298
MOVZX EDX,byte ptr [RDI]
CMP DL,0x30
JNZ 0x00101270
MOV ESI,0x1
JMP 0x0010127a
LAB_00101298:
OR ESI,ECX
LEA RAX,[0x102004]
LEA RDX,[0x102008]
POP RBX
CMOVZ RAX,RDX
RET
LAB_001012b0:
LEA RAX,[0x102008]
POP RBX
RET | int * func0(char *param_1)
{
bool bVar1;
bool bVar2;
size_t sVar3;
char *pcVar4;
int *puVar5;
sVar3 = strlen(param_1);
bVar2 = false;
bVar1 = false;
pcVar4 = param_1 + sVar3;
do {
if (param_1 == pcVar4) {
puVar5 = &DAT_00102004;
if (!bVar1 && !bVar2) {
puVar5 = &DAT_00102008;
}
return puVar5;
}
if (*param_1 == '0') {
bVar1 = true;
}
else {
if (*param_1 != '1') {
return &DAT_00102008;
}
bVar2 = true;
}
param_1 = param_1 + 1;
} while( true );
} |
5,292 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* s) {
int maxOcc = 0;
int n = strlen(s);
int arr[26] = {0};
for (int i = 0; i < n; i++) {
arr[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (arr[i] > maxOcc) {
maxOcc = arr[i];
}
}
return n - maxOcc;
}
| int main() {
assert(func0("mnm") == 1);
assert(func0("abcda") == 3);
assert(func0("abcb") == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x80(%rbp)
mov -0x88(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x74(%rbp)
lea -0x70(%rbp),%rdx
mov $0x0,%eax
mov $0xd,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x7c(%rbp)
jmp 1211 <func0+0x88>
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
mov -0x88(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x61,%eax
movslq %eax,%rdx
mov -0x70(%rbp,%rdx,4),%edx
add $0x1,%edx
cltq
mov %edx,-0x70(%rbp,%rax,4)
addl $0x1,-0x7c(%rbp)
mov -0x7c(%rbp),%eax
cmp -0x74(%rbp),%eax
jl 11e4 <func0+0x5b>
movl $0x0,-0x78(%rbp)
jmp 1240 <func0+0xb7>
mov -0x78(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
cmp %eax,-0x80(%rbp)
jge 123c <func0+0xb3>
mov -0x78(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
mov %eax,-0x80(%rbp)
addl $0x1,-0x78(%rbp)
cmpl $0x19,-0x78(%rbp)
jle 1222 <func0+0x99>
mov -0x74(%rbp),%eax
sub -0x80(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1260 <func0+0xd7>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_80], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_74], eax
lea rdx, [rbp+var_70]
mov eax, 0
mov ecx, 0Dh
mov rdi, rdx
rep stosq
mov [rbp+var_7C], 0
jmp short loc_1211
loc_11E4:
mov eax, [rbp+var_7C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
sub eax, 61h ; 'a'
movsxd rdx, eax
mov edx, [rbp+rdx*4+var_70]
add edx, 1
cdqe
mov [rbp+rax*4+var_70], edx
add [rbp+var_7C], 1
loc_1211:
mov eax, [rbp+var_7C]
cmp eax, [rbp+var_74]
jl short loc_11E4
mov [rbp+var_78], 0
jmp short loc_1240
loc_1222:
mov eax, [rbp+var_78]
cdqe
mov eax, [rbp+rax*4+var_70]
cmp [rbp+var_80], eax
jge short loc_123C
mov eax, [rbp+var_78]
cdqe
mov eax, [rbp+rax*4+var_70]
mov [rbp+var_80], eax
loc_123C:
add [rbp+var_78], 1
loc_1240:
cmp [rbp+var_78], 19h
jle short loc_1222
mov eax, [rbp+var_74]
sub eax, [rbp+var_80]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1260
call ___stack_chk_fail
locret_1260:
leave
retn | long long func0(const char *a1)
{
int v1; // eax
int v3; // [rsp+10h] [rbp-80h]
int i; // [rsp+14h] [rbp-7Ch]
int j; // [rsp+18h] [rbp-78h]
int v6; // [rsp+1Ch] [rbp-74h]
_DWORD v7[26]; // [rsp+20h] [rbp-70h] BYREF
unsigned long long v8; // [rsp+88h] [rbp-8h]
v8 = __readfsqword(0x28u);
v3 = 0;
v6 = strlen(a1);
memset(v7, 0, sizeof(v7));
for ( i = 0; i < v6; ++i )
{
v1 = a1[i] - 97;
++v7[v1];
}
for ( j = 0; j <= 25; ++j )
{
if ( v3 < v7[j] )
v3 = v7[j];
}
return (unsigned int)(v6 - v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x80],0x0
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x74],EAX
LEA RDX,[RBP + -0x70]
MOV EAX,0x0
MOV ECX,0xd
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x7c],0x0
JMP 0x00101211
LAB_001011e4:
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
SUB EAX,0x61
MOVSXD RDX,EAX
MOV EDX,dword ptr [RBP + RDX*0x4 + -0x70]
ADD EDX,0x1
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x70],EDX
ADD dword ptr [RBP + -0x7c],0x1
LAB_00101211:
MOV EAX,dword ptr [RBP + -0x7c]
CMP EAX,dword ptr [RBP + -0x74]
JL 0x001011e4
MOV dword ptr [RBP + -0x78],0x0
JMP 0x00101240
LAB_00101222:
MOV EAX,dword ptr [RBP + -0x78]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
CMP dword ptr [RBP + -0x80],EAX
JGE 0x0010123c
MOV EAX,dword ptr [RBP + -0x78]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
MOV dword ptr [RBP + -0x80],EAX
LAB_0010123c:
ADD dword ptr [RBP + -0x78],0x1
LAB_00101240:
CMP dword ptr [RBP + -0x78],0x19
JLE 0x00101222
MOV EAX,dword ptr [RBP + -0x74]
SUB EAX,dword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101260
CALL 0x00101080
LAB_00101260:
LEAVE
RET | int func0(char *param_1)
{
size_t sVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
byte bVar4;
int local_88;
int local_84;
int local_80;
int local_78 [26];
long local_10;
bVar4 = 0;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = 0;
sVar1 = strlen(param_1);
piVar3 = local_78;
for (lVar2 = 0xd; lVar2 != 0; lVar2 = lVar2 + -1) {
piVar3[0] = 0;
piVar3[1] = 0;
piVar3 = piVar3 + ((ulong)bVar4 * -2 + 1) * 2;
}
for (local_84 = 0; local_84 < (int)sVar1; local_84 = local_84 + 1) {
local_78[param_1[local_84] + -0x61] = local_78[param_1[local_84] + -0x61] + 1;
}
for (local_80 = 0; local_80 < 0x1a; local_80 = local_80 + 1) {
if (local_88 < local_78[local_80]) {
local_88 = local_78[local_80];
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (int)sVar1 - local_88;
} |
5,293 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* s) {
int maxOcc = 0;
int n = strlen(s);
int arr[26] = {0};
for (int i = 0; i < n; i++) {
arr[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (arr[i] > maxOcc) {
maxOcc = arr[i];
}
}
return n - maxOcc;
}
| int main() {
assert(func0("mnm") == 1);
assert(func0("abcda") == 3);
assert(func0("abcb") == 2);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x78,%rsp
mov %rdi,%rsi
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r8
mov %rsp,%rdi
mov $0xd,%ecx
mov $0x0,%eax
rep stos %rax,%es:(%rdi)
test %r8d,%r8d
jle 11ca <func0+0x61>
mov %rsi,%rdx
lea -0x1(%r8),%eax
lea 0x1(%rsi,%rax,1),%rcx
movsbl (%rdx),%eax
sub $0x61,%eax
cltq
addl $0x1,(%rsp,%rax,4)
add $0x1,%rdx
cmp %rcx,%rdx
jne 11b5 <func0+0x4c>
mov %rsp,%rax
lea 0x68(%rsp),%rsi
mov $0x0,%edx
mov (%rax),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x4,%rax
cmp %rsi,%rax
jne 11d7 <func0+0x6e>
mov %r8d,%eax
sub %edx,%eax
mov 0x68(%rsp),%rdi
xor %fs:0x28,%rdi
jne 1201 <func0+0x98>
add $0x78,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 70h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
call _strlen
mov r8, rax
mov rdi, rsp
mov ecx, 0Dh
mov eax, 0
rep stosq
test r8d, r8d
jle short loc_11E3
mov rdx, rbx
lea eax, [r8-1]
lea rcx, [rbx+rax+1]
loc_11CE:
movsx eax, byte ptr [rdx]
sub eax, 61h ; 'a'
cdqe
add [rsp+rax*4+78h+var_78], 1
add rdx, 1
cmp rdx, rcx
jnz short loc_11CE
loc_11E3:
mov rax, rsp
lea rsi, [rsp+78h+var_10]
mov edx, 0
loc_11F0:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_11F0
mov eax, r8d
sub eax, edx
mov rdx, [rsp+78h+var_10]
sub rdx, fs:28h
jnz short loc_121B
add rsp, 70h
pop rbx
retn
loc_121B:
call ___stack_chk_fail | long long func0(char *a1)
{
int v1; // r8d
char *v2; // rdx
unsigned long long *v3; // rax
int v4; // edx
_DWORD v6[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-10h] BYREF
v7 = __readfsqword(0x28u);
v1 = strlen();
memset(v6, 0, sizeof(v6));
if ( v1 > 0 )
{
v2 = a1;
do
++v6[*v2++ - 97];
while ( v2 != &a1[v1 - 1 + 1] );
}
v3 = (unsigned long long *)v6;
v4 = 0;
do
{
if ( v4 < *(_DWORD *)v3 )
v4 = *(_DWORD *)v3;
v3 = (unsigned long long *)((char *)v3 + 4);
}
while ( v3 != &v7 );
return (unsigned int)(v1 - v4);
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x00101070
MOV R8,RAX
MOV RDI,RSP
MOV ECX,0xd
MOV EAX,0x0
STOSQ.REP RDI
TEST R8D,R8D
JLE 0x001011e3
MOV RDX,RBX
LEA EAX,[R8 + -0x1]
LEA RCX,[RBX + RAX*0x1 + 0x1]
LAB_001011ce:
MOVSX EAX,byte ptr [RDX]
SUB EAX,0x61
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
ADD RDX,0x1
CMP RDX,RCX
JNZ 0x001011ce
LAB_001011e3:
MOV RAX,RSP
LEA RSI,[RSP + 0x68]
MOV EDX,0x0
LAB_001011f0:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001011f0
MOV EAX,R8D
SUB EAX,EDX
MOV RDX,qword ptr [RSP + 0x68]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010121b
ADD RSP,0x70
POP RBX
RET
LAB_0010121b:
CALL 0x00101080 | int func0(char *param_1)
{
int *piVar1;
char *pcVar2;
size_t sVar3;
long *plVar4;
long lVar5;
int iVar6;
long *plVar7;
int iVar8;
long in_FS_OFFSET;
byte bVar9;
long local_78 [13];
long local_10;
bVar9 = 0;
plVar4 = local_78;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
plVar7 = local_78;
for (lVar5 = 0xd; lVar5 != 0; lVar5 = lVar5 + -1) {
*plVar7 = 0;
plVar7 = plVar7 + (ulong)bVar9 * -2 + 1;
}
iVar8 = (int)sVar3;
if (0 < iVar8) {
pcVar2 = param_1 + (ulong)(iVar8 - 1) + 1;
do {
piVar1 = (int *)((long)local_78 + (long)(*param_1 + -0x61) * 4);
*piVar1 = *piVar1 + 1;
param_1 = param_1 + 1;
} while (param_1 != pcVar2);
}
iVar6 = 0;
do {
if (iVar6 < (int)*plVar4) {
iVar6 = (int)*plVar4;
}
plVar4 = (long *)((long)plVar4 + 4);
} while (plVar4 != &local_10);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar8 - iVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,294 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* s) {
int maxOcc = 0;
int n = strlen(s);
int arr[26] = {0};
for (int i = 0; i < n; i++) {
arr[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (arr[i] > maxOcc) {
maxOcc = arr[i];
}
}
return n - maxOcc;
}
| int main() {
assert(func0("mnm") == 1);
assert(func0("abcda") == 3);
assert(func0("abcb") == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 1070 <strlen@plt>
mov %rsp,%rdi
mov $0xd,%ecx
mov %rax,%r8
xor %eax,%eax
rep stos %rax,%es:(%rdi)
test %r8d,%r8d
jle 12cb <func0+0x9b>
lea -0x1(%r8),%eax
mov %rbx,%rdi
lea 0x1(%rbx,%rax,1),%rdx
nopw 0x0(%rax,%rax,1)
movsbl (%rdi),%eax
add $0x1,%rdi
sub $0x61,%eax
cltq
addl $0x1,(%rsp,%rax,4)
cmp %rdx,%rdi
jne 1278 <func0+0x48>
mov (%rsp),%ecx
lea 0x4(%rsp),%rax
lea 0x68(%rsp),%rsi
xor %edx,%edx
jmp 12a6 <func0+0x76>
xchg %ax,%ax
mov (%rax),%ecx
add $0x4,%rax
cmp %ecx,%edx
cmovl %ecx,%edx
cmp %rax,%rsi
jne 12a0 <func0+0x70>
mov %r8d,%eax
sub %edx,%eax
mov 0x68(%rsp),%rbx
xor %fs:0x28,%rbx
jne 12cf <func0+0x9f>
add $0x70,%rsp
pop %rbx
retq
xor %ecx,%ecx
jmp 1290 <func0+0x60>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbx
mov rbx, rdi
sub rsp, 70h
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
call _strlen
mov rdi, rsp
mov ecx, 0Dh
mov r8, rax
xor eax, eax
rep stosq
test r8d, r8d
jle short loc_12CB
lea eax, [r8-1]
mov rdi, rbx
lea rdx, [rbx+rax+1]
nop word ptr [rax+rax+00h]
loc_1278:
movsx eax, byte ptr [rdi]
add rdi, 1
sub eax, 61h ; 'a'
cdqe
add [rsp+rax*4+78h+var_78], 1
cmp rdi, rdx
jnz short loc_1278
mov ecx, [rsp+78h+var_78]
loc_1290:
lea rax, [rsp+78h+var_74]
lea rsi, [rsp+78h+var_10]
xor edx, edx
jmp short loc_12A6
loc_12A0:
mov ecx, [rax]
add rax, 4
loc_12A6:
cmp edx, ecx
cmovl edx, ecx
cmp rsi, rax
jnz short loc_12A0
mov eax, r8d
sub eax, edx
mov rdx, [rsp+78h+var_10]
sub rdx, fs:28h
jnz short loc_12CF
add rsp, 70h
pop rbx
retn
loc_12CB:
xor ecx, ecx
jmp short loc_1290
loc_12CF:
call ___stack_chk_fail | long long func0(char *a1)
{
int v1; // r8d
long long v2; // rdx
int v3; // eax
int v4; // ecx
unsigned long long *v5; // rax
int v6; // edx
_DWORD v8[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v9; // [rsp+68h] [rbp-10h] BYREF
v9 = __readfsqword(0x28u);
v1 = strlen();
memset(v8, 0, sizeof(v8));
if ( v1 <= 0 )
{
v4 = 0;
}
else
{
v2 = (long long)&a1[v1 - 1 + 1];
do
{
v3 = *a1++;
++v8[v3 - 97];
}
while ( a1 != (char *)v2 );
v4 = v8[0];
}
v5 = (unsigned long long *)&v8[1];
v6 = 0;
while ( 1 )
{
if ( v6 < v4 )
v6 = v4;
if ( &v9 == v5 )
break;
v4 = *(_DWORD *)v5;
v5 = (unsigned long long *)((char *)v5 + 4);
}
return (unsigned int)(v1 - v6);
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x00101070
MOV RDI,RSP
MOV ECX,0xd
MOV R8,RAX
XOR EAX,EAX
STOSQ.REP RDI
TEST R8D,R8D
JLE 0x001012cb
LEA EAX,[R8 + -0x1]
MOV RDI,RBX
LEA RDX,[RBX + RAX*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_00101278:
MOVSX EAX,byte ptr [RDI]
ADD RDI,0x1
SUB EAX,0x61
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
CMP RDI,RDX
JNZ 0x00101278
MOV ECX,dword ptr [RSP]
LAB_00101290:
LEA RAX,[RSP + 0x4]
LEA RSI,[RSP + 0x68]
XOR EDX,EDX
JMP 0x001012a6
LAB_001012a0:
MOV ECX,dword ptr [RAX]
ADD RAX,0x4
LAB_001012a6:
CMP EDX,ECX
CMOVL EDX,ECX
CMP RSI,RAX
JNZ 0x001012a0
MOV EAX,R8D
SUB EAX,EDX
MOV RDX,qword ptr [RSP + 0x68]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012cf
ADD RSP,0x70
POP RBX
RET
LAB_001012cb:
XOR ECX,ECX
JMP 0x00101290
LAB_001012cf:
CALL 0x00101080 | int func0(char *param_1)
{
int *piVar1;
char *pcVar2;
char cVar3;
size_t sVar4;
long lVar5;
int iVar6;
long *plVar7;
int8 *puVar8;
int iVar9;
long in_FS_OFFSET;
byte bVar10;
int8 local_78;
long local_10;
bVar10 = 0;
plVar7 = &local_78;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar4 = strlen(param_1);
puVar8 = &local_78;
for (lVar5 = 0xd; lVar5 != 0; lVar5 = lVar5 + -1) {
*puVar8 = 0;
puVar8 = puVar8 + (ulong)bVar10 * -2 + 1;
}
iVar9 = (int)sVar4;
if (iVar9 < 1) {
local_78._0_4_ = 0;
}
else {
pcVar2 = param_1 + (ulong)(iVar9 - 1) + 1;
do {
cVar3 = *param_1;
param_1 = param_1 + 1;
piVar1 = (int *)((long)&local_78 + (long)(cVar3 + -0x61) * 4);
*piVar1 = *piVar1 + 1;
} while (param_1 != pcVar2);
}
iVar6 = 0;
while( true ) {
plVar7 = (long *)((long)plVar7 + 4);
if (iVar6 < (int)local_78) {
iVar6 = (int)local_78;
}
if (&local_10 == plVar7) break;
local_78._0_4_ = *(int *)plVar7;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar9 - iVar6;
} |
5,295 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char* s) {
int maxOcc = 0;
int n = strlen(s);
int arr[26] = {0};
for (int i = 0; i < n; i++) {
arr[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (arr[i] > maxOcc) {
maxOcc = arr[i];
}
}
return n - maxOcc;
}
| int main() {
assert(func0("mnm") == 1);
assert(func0("abcda") == 3);
assert(func0("abcb") == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 1070 <strlen@plt>
mov %rsp,%rdi
mov $0xd,%ecx
mov %rax,%rsi
xor %eax,%eax
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 1285 <func0+0x55>
lea -0x1(%rsi),%eax
mov %rbx,%rdi
lea 0x1(%rbx,%rax,1),%rdx
movsbl (%rdi),%eax
add $0x1,%rdi
sub $0x61,%eax
cltq
addl $0x1,(%rsp,%rax,4)
cmp %rdi,%rdx
jne 1270 <func0+0x40>
movdqa 0x10(%rsp),%xmm0
mov 0x64(%rsp),%edx
mov %esi,%ecx
cmp %edx,0x60(%rsp)
cmovge 0x60(%rsp),%edx
movdqa %xmm0,%xmm1
pcmpgtd 0x20(%rsp),%xmm1
pand %xmm1,%xmm0
movdqa %xmm0,%xmm2
movdqa %xmm1,%xmm0
pandn 0x20(%rsp),%xmm0
pxor %xmm1,%xmm1
por %xmm2,%xmm0
movdqa (%rsp),%xmm2
pcmpgtd %xmm1,%xmm2
pand (%rsp),%xmm2
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa 0x30(%rsp),%xmm1
movdqa %xmm1,%xmm2
pcmpgtd 0x40(%rsp),%xmm2
pand %xmm2,%xmm1
pandn 0x40(%rsp),%xmm2
por %xmm2,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd 0x50(%rsp),%xmm2
pand %xmm2,%xmm1
pandn 0x50(%rsp),%xmm2
por %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand %xmm2,%xmm0
pandn %xmm1,%xmm2
por %xmm2,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x8,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand %xmm2,%xmm1
pandn %xmm0,%xmm2
por %xmm2,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
cmp %eax,%edx
cmovge %edx,%eax
sub %eax,%ecx
mov 0x68(%rsp),%rbx
xor %fs:0x28,%rbx
mov %ecx,%eax
jne 1387 <func0+0x157>
add $0x70,%rsp
pop %rbx
retq
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
sub rsp, 70h
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
call _strlen
mov rdi, rsp
mov ecx, 0Dh
mov rsi, rax
xor eax, eax
rep stosq
test esi, esi
jle short loc_1285
lea eax, [rsi-1]
mov rdi, rbx
lea rdx, [rbx+rax+1]
loc_1270:
movsx eax, byte ptr [rdi]
add rdi, 1
sub eax, 61h ; 'a'
cdqe
add dword ptr [rsp+rax*4+78h+var_78], 1
cmp rdi, rdx
jnz short loc_1270
loc_1285:
movdqa xmm1, [rsp+78h+var_58]
pxor xmm3, xmm3
mov edx, [rsp+78h+var_18]
mov ecx, [rsp+78h+var_14]
movdqa xmm0, xmm1
pcmpgtd xmm0, [rsp+78h+var_48]
cmp edx, ecx
cmovl edx, ecx
pand xmm1, xmm0
pandn xmm0, [rsp+78h+var_48]
por xmm0, xmm1
movdqa xmm1, [rsp+78h+var_68]
movdqa xmm2, xmm1
pcmpgtd xmm2, [rsp+78h+var_78]
pand xmm1, xmm2
pandn xmm2, [rsp+78h+var_78]
por xmm2, xmm1
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, [rsp+78h+var_28]
por xmm1, xmm0
movdqa xmm0, xmm2
pcmpgtd xmm0, [rsp+78h+var_38]
pand xmm2, xmm0
pandn xmm0, [rsp+78h+var_38]
por xmm0, xmm2
movdqa xmm2, xmm0
pcmpgtd xmm2, xmm3
pand xmm0, xmm2
movdqa xmm2, xmm1
pcmpgtd xmm2, xmm0
pand xmm1, xmm2
pandn xmm2, xmm0
movdqa xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 8
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
cmp edx, eax
cmovl edx, eax
mov eax, esi
sub eax, edx
mov rdx, [rsp+78h+var_10]
sub rdx, fs:28h
jnz short loc_1383
add rsp, 70h
pop rbx
retn
loc_1383:
call ___stack_chk_fail | long long func0(const char *a1)
{
int v1; // esi
long long v2; // rdx
int v3; // eax
__m128i si128; // xmm1
int v5; // edx
__m128i v6; // xmm0
__m128i v7; // xmm0
__m128i v8; // xmm1
__m128i v9; // xmm2
__m128i v10; // xmm2
__m128i v11; // xmm1
__m128i v12; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm2
__m128i v15; // xmm1
__m128i v16; // xmm0
__m128i v17; // xmm0
__m128i v18; // xmm0
__m128i v19; // xmm2
__m128i v20; // xmm0
__m128i v21; // xmm2
__m128i v22; // xmm1
__m128i v23; // xmm1
__m128i v24; // xmm2
__m128i v25; // xmm0
int v26; // eax
_BYTE v28[104]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v29; // [rsp+68h] [rbp-10h]
v29 = __readfsqword(0x28u);
v1 = strlen(a1);
memset(v28, 0, sizeof(v28));
if ( v1 > 0 )
{
v2 = (long long)&a1[v1 - 1 + 1];
do
{
v3 = *a1++;
++*(_DWORD *)&v28[4 * v3 - 388];
}
while ( a1 != (const char *)v2 );
}
si128 = _mm_load_si128((const __m128i *)&v28[32]);
v5 = *(_DWORD *)&v28[96];
v6 = _mm_cmpgt_epi32(si128, *(__m128i *)&v28[48]);
if ( *(int *)&v28[96] < *(int *)&v28[100] )
v5 = *(_DWORD *)&v28[100];
v7 = _mm_or_si128(_mm_andnot_si128(v6, *(__m128i *)&v28[48]), _mm_and_si128(si128, v6));
v8 = _mm_load_si128((const __m128i *)&v28[16]);
v9 = _mm_cmpgt_epi32(v8, *(__m128i *)v28);
v10 = _mm_or_si128(_mm_andnot_si128(v9, *(__m128i *)v28), _mm_and_si128(v8, v9));
v11 = _mm_cmpgt_epi32(v7, v10);
v12 = _mm_and_si128(v7, v11);
v13 = _mm_andnot_si128(v11, v10);
v14 = _mm_load_si128((const __m128i *)&v28[80]);
v15 = _mm_or_si128(v13, v12);
v16 = _mm_cmpgt_epi32(v14, *(__m128i *)&v28[64]);
v17 = _mm_or_si128(_mm_andnot_si128(v16, *(__m128i *)&v28[64]), _mm_and_si128(v14, v16));
v18 = _mm_and_si128(v17, _mm_cmpgt_epi32(v17, (__m128i)0LL));
v19 = _mm_cmpgt_epi32(v15, v18);
v20 = _mm_or_si128(_mm_andnot_si128(v19, v18), _mm_and_si128(v15, v19));
v21 = _mm_srli_si128(v20, 8);
v22 = _mm_cmpgt_epi32(v21, v20);
v23 = _mm_or_si128(_mm_andnot_si128(v22, v20), _mm_and_si128(v21, v22));
v24 = _mm_srli_si128(v23, 4);
v25 = _mm_cmpgt_epi32(v24, v23);
v26 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v25, v23), _mm_and_si128(v24, v25)));
if ( v5 < v26 )
v5 = v26;
return (unsigned int)(v1 - v5);
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x00101070
MOV RDI,RSP
MOV ECX,0xd
MOV RSI,RAX
XOR EAX,EAX
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x00101285
LEA EAX,[RSI + -0x1]
MOV RDI,RBX
LEA RDX,[RBX + RAX*0x1 + 0x1]
LAB_00101270:
MOVSX EAX,byte ptr [RDI]
ADD RDI,0x1
SUB EAX,0x61
CDQE
ADD dword ptr [RSP + RAX*0x4],0x1
CMP RDI,RDX
JNZ 0x00101270
LAB_00101285:
MOVDQA XMM1,xmmword ptr [RSP + 0x20]
PXOR XMM3,XMM3
MOV EDX,dword ptr [RSP + 0x60]
MOV ECX,dword ptr [RSP + 0x64]
MOVDQA XMM0,XMM1
PCMPGTD XMM0,xmmword ptr [RSP + 0x30]
CMP EDX,ECX
CMOVL EDX,ECX
PAND XMM1,XMM0
PANDN XMM0,xmmword ptr [RSP + 0x30]
POR XMM0,XMM1
MOVDQA XMM1,xmmword ptr [RSP + 0x10]
MOVDQA XMM2,XMM1
PCMPGTD XMM2,xmmword ptr [RSP]
PAND XMM1,XMM2
PANDN XMM2,xmmword ptr [RSP]
POR XMM2,XMM1
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,xmmword ptr [RSP + 0x50]
POR XMM1,XMM0
MOVDQA XMM0,XMM2
PCMPGTD XMM0,xmmword ptr [RSP + 0x40]
PAND XMM2,XMM0
PANDN XMM0,xmmword ptr [RSP + 0x40]
POR XMM0,XMM2
MOVDQA XMM2,XMM0
PCMPGTD XMM2,XMM3
PAND XMM0,XMM2
MOVDQA XMM2,XMM1
PCMPGTD XMM2,XMM0
PAND XMM1,XMM2
PANDN XMM2,XMM0
MOVDQA XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x8
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
CMP EDX,EAX
CMOVL EDX,EAX
MOV EAX,ESI
SUB EAX,EDX
MOV RDX,qword ptr [RSP + 0x68]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101383
ADD RSP,0x70
POP RBX
RET
LAB_00101383:
CALL 0x00101080 | int func0(char *param_1)
{
char *pcVar1;
char cVar2;
int auVar3 [16];
int auVar4 [16];
size_t sVar5;
long lVar6;
int iVar7;
int *piVar8;
long in_FS_OFFSET;
byte bVar9;
uint uVar10;
int auVar12 [16];
int auVar13 [16];
uint uVar14;
int auVar15 [16];
int auVar16 [16];
int auVar17 [16];
int auVar18 [16];
int auVar19 [16];
int auVar20 [16];
int local_78 [4];
int local_68 [16];
int local_58 [16];
int local_48;
int iStack_44;
int iStack_40;
int iStack_3c;
int local_38;
int iStack_34;
int iStack_30;
int iStack_2c;
int local_28 [16];
uint local_18;
uint local_14;
long local_10;
uint uVar11;
bVar9 = 0;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar5 = strlen(param_1);
piVar8 = local_78;
for (lVar6 = 0xd; lVar6 != 0; lVar6 = lVar6 + -1) {
*(int8 *)piVar8 = 0;
piVar8 = (int *)((long)piVar8 + ((ulong)bVar9 * -2 + 1) * 8);
}
iVar7 = (int)sVar5;
if (0 < iVar7) {
pcVar1 = param_1 + (ulong)(iVar7 - 1) + 1;
do {
cVar2 = *param_1;
param_1 = param_1 + 1;
local_78[cVar2 + -0x61] = local_78[cVar2 + -0x61] + 1;
} while (param_1 != pcVar1);
}
auVar12._0_4_ = -(uint)(local_48 < local_58._0_4_);
auVar12._4_4_ = -(uint)(iStack_44 < local_58._4_4_);
auVar12._8_4_ = -(uint)(iStack_40 < local_58._8_4_);
auVar12._12_4_ = -(uint)(iStack_3c < local_58._12_4_);
if ((int)local_18 < (int)local_14) {
local_18 = local_14;
}
auVar3._4_4_ = iStack_44;
auVar3._0_4_ = local_48;
auVar3._8_4_ = iStack_40;
auVar3._12_4_ = iStack_3c;
auVar12 = ~auVar12 & auVar3 | local_58 & auVar12;
auVar17._0_4_ = -(uint)(local_78[0] < local_68._0_4_);
auVar17._4_4_ = -(uint)(local_78[1] < local_68._4_4_);
auVar17._8_4_ = -(uint)(local_78[2] < local_68._8_4_);
auVar17._12_4_ = -(uint)(local_78[3] < local_68._12_4_);
auVar18._4_4_ = local_78[1];
auVar18._0_4_ = local_78[0];
auVar18._8_4_ = local_78[2];
auVar18._12_4_ = local_78[3];
auVar18 = ~auVar17 & auVar18 | local_68 & auVar17;
auVar15._0_4_ = -(uint)(auVar18._0_4_ < auVar12._0_4_);
auVar15._4_4_ = -(uint)(auVar18._4_4_ < auVar12._4_4_);
auVar15._8_4_ = -(uint)(auVar18._8_4_ < auVar12._8_4_);
auVar15._12_4_ = -(uint)(auVar18._12_4_ < auVar12._12_4_);
auVar18 = ~auVar15 & auVar18 | auVar12 & auVar15;
auVar13._0_4_ = -(uint)(local_38 < local_28._0_4_);
auVar13._4_4_ = -(uint)(iStack_34 < local_28._4_4_);
auVar13._8_4_ = -(uint)(iStack_30 < local_28._8_4_);
auVar13._12_4_ = -(uint)(iStack_2c < local_28._12_4_);
auVar4._4_4_ = iStack_34;
auVar4._0_4_ = local_38;
auVar4._8_4_ = iStack_30;
auVar4._12_4_ = iStack_2c;
auVar12 = ~auVar13 & auVar4 | local_28 & auVar13;
auVar19._0_4_ = -(uint)(0 < auVar12._0_4_);
auVar19._4_4_ = -(uint)(0 < auVar12._4_4_);
auVar19._8_4_ = -(uint)(0 < auVar12._8_4_);
auVar19._12_4_ = -(uint)(0 < auVar12._12_4_);
auVar12 = auVar12 & auVar19;
auVar20._0_4_ = -(uint)(auVar12._0_4_ < auVar18._0_4_);
auVar20._4_4_ = -(uint)(auVar12._4_4_ < auVar18._4_4_);
auVar20._8_4_ = -(uint)(auVar12._8_4_ < auVar18._8_4_);
auVar20._12_4_ = -(uint)(auVar12._12_4_ < auVar18._12_4_);
auVar12 = ~auVar20 & auVar12 | auVar18 & auVar20;
auVar16._0_4_ = -(uint)(auVar12._0_4_ < auVar12._8_4_);
auVar16._4_4_ = -(uint)(auVar12._4_4_ < auVar12._12_4_);
auVar16._8_4_ = -(uint)(auVar12._8_4_ < 0);
auVar16._12_4_ = -(uint)(auVar12._12_4_ < 0);
auVar12 = ~auVar16 & auVar12 | auVar12 >> 0x40 & auVar16;
uVar11 = auVar12._4_4_;
uVar14 = auVar12._0_4_;
uVar10 = -(uint)((int)uVar14 < (int)uVar11);
uVar10 = ~uVar10 & uVar14 | uVar11 & uVar10;
if ((int)local_18 < (int)uVar10) {
local_18 = uVar10;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar7 - local_18;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,296 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count_map[256] = {0}; // Assuming the range of elements in array is 0-255
int i;
for (i = 0; i < n; i++) {
count_map[arr[i]]++;
}
for (i = 0; i < n; i++) {
if (count_map[arr[i]] == k) {
return arr[i];
}
}
return -1;
}
| int main() {
assert(func0((int[]){0,1,2,3,4,5},6,1) == 0);
assert(func0((int[]){1,2,1,3,4},5,2) == 1);
assert(func0((int[]){2,3,4,3,5,7,1,2,3,5},10,2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %esi,-0x42c(%rbp)
mov %edx,-0x430(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x414(%rbp)
jmp 11f6 <func0+0x8d>
mov -0x414(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
movslq %eax,%rdx
mov -0x410(%rbp,%rdx,4),%edx
add $0x1,%edx
cltq
mov %edx,-0x410(%rbp,%rax,4)
addl $0x1,-0x414(%rbp)
mov -0x414(%rbp),%eax
cmp -0x42c(%rbp),%eax
jl 11bd <func0+0x54>
movl $0x0,-0x414(%rbp)
jmp 1262 <func0+0xf9>
mov -0x414(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
cmp %eax,-0x430(%rbp)
jne 125b <func0+0xf2>
mov -0x414(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 1275 <func0+0x10c>
addl $0x1,-0x414(%rbp)
mov -0x414(%rbp),%eax
cmp -0x42c(%rbp),%eax
jl 1210 <func0+0xa7>
mov $0xffffffff,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1289 <func0+0x120>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+var_428], rdi
mov [rbp+var_42C], esi
mov [rbp+var_430], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_414], 0
jmp short loc_11F6
loc_11BD:
mov eax, [rbp+var_414]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_428]
add rax, rdx
mov eax, [rax]
movsxd rdx, eax
mov edx, [rbp+rdx*4+var_410]
add edx, 1
cdqe
mov [rbp+rax*4+var_410], edx
add [rbp+var_414], 1
loc_11F6:
mov eax, [rbp+var_414]
cmp eax, [rbp+var_42C]
jl short loc_11BD
mov [rbp+var_414], 0
jmp short loc_1262
loc_1210:
mov eax, [rbp+var_414]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_428]
add rax, rdx
mov eax, [rax]
cdqe
mov eax, [rbp+rax*4+var_410]
cmp [rbp+var_430], eax
jnz short loc_125B
mov eax, [rbp+var_414]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_428]
add rax, rdx
mov eax, [rax]
jmp short loc_1275
loc_125B:
add [rbp+var_414], 1
loc_1262:
mov eax, [rbp+var_414]
cmp eax, [rbp+var_42C]
jl short loc_1210
mov eax, 0FFFFFFFFh
loc_1275:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1289
call ___stack_chk_fail
locret_1289:
leave
retn | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+1Ch] [rbp-414h]
int j; // [rsp+1Ch] [rbp-414h]
_DWORD v6[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v7; // [rsp+428h] [rbp-8h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 0x400uLL);
for ( i = 0; i < a2; ++i )
++v6[*(int *)(4LL * i + a1)];
for ( j = 0; j < a2; ++j )
{
if ( a3 == v6[*(int *)(4LL * j + a1)] )
return *(unsigned int *)(4LL * j + a1);
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV dword ptr [RBP + -0x42c],ESI
MOV dword ptr [RBP + -0x430],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x414],0x0
JMP 0x001011f6
LAB_001011bd:
MOV EAX,dword ptr [RBP + -0x414]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOVSXD RDX,EAX
MOV EDX,dword ptr [RBP + RDX*0x4 + -0x410]
ADD EDX,0x1
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x410],EDX
ADD dword ptr [RBP + -0x414],0x1
LAB_001011f6:
MOV EAX,dword ptr [RBP + -0x414]
CMP EAX,dword ptr [RBP + -0x42c]
JL 0x001011bd
MOV dword ptr [RBP + -0x414],0x0
JMP 0x00101262
LAB_00101210:
MOV EAX,dword ptr [RBP + -0x414]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
CMP dword ptr [RBP + -0x430],EAX
JNZ 0x0010125b
MOV EAX,dword ptr [RBP + -0x414]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x00101275
LAB_0010125b:
ADD dword ptr [RBP + -0x414],0x1
LAB_00101262:
MOV EAX,dword ptr [RBP + -0x414]
CMP EAX,dword ptr [RBP + -0x42c]
JL 0x00101210
MOV EAX,0xffffffff
LAB_00101275:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101289
CALL 0x00101060
LAB_00101289:
LEAVE
RET | int4 func0(long param_1,int param_2,int param_3)
{
int iVar1;
int4 uVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int local_41c;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
piVar4[0] = 0;
piVar4[1] = 0;
piVar4 = piVar4 + 2;
}
for (local_41c = 0; local_41c < param_2; local_41c = local_41c + 1) {
iVar1 = *(int *)(param_1 + (long)local_41c * 4);
local_418[iVar1] = local_418[iVar1] + 1;
}
local_41c = 0;
do {
if (param_2 <= local_41c) {
uVar2 = 0xffffffff;
LAB_00101275:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
}
if (param_3 == local_418[*(int *)(param_1 + (long)local_41c * 4)]) {
uVar2 = *(int4 *)(param_1 + (long)local_41c * 4);
goto LAB_00101275;
}
local_41c = local_41c + 1;
} while( true );
} |
5,297 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count_map[256] = {0}; // Assuming the range of elements in array is 0-255
int i;
for (i = 0; i < n; i++) {
count_map[arr[i]]++;
}
for (i = 0; i < n; i++) {
if (count_map[arr[i]] == k) {
return arr[i];
}
}
return -1;
}
| int main() {
assert(func0((int[]){0,1,2,3,4,5},6,1) == 0);
assert(func0((int[]){1,2,1,3,4},5,2) == 1);
assert(func0((int[]){2,3,4,3,5,7,1,2,3,5},10,2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%r8
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 11ec <func0+0x83>
mov %r8,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%r8,%rcx,4),%r9
mov %r8,%rdi
movslq (%rdi),%rcx
addl $0x1,(%rsp,%rcx,4)
add $0x4,%rdi
cmp %r9,%rdi
jne 11a7 <func0+0x3e>
mov (%rax),%ecx
movslq %ecx,%rsi
cmp %edx,(%rsp,%rsi,4)
je 11cf <func0+0x66>
add $0x4,%rax
cmp %r9,%rax
jne 11b7 <func0+0x4e>
mov $0xffffffff,%ecx
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 11f3 <func0+0x8a>
mov %ecx,%eax
add $0x418,%rsp
retq
mov $0xffffffff,%ecx
jmp 11cf <func0+0x66>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
sub rsp, 418h
mov r8, rdi
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
test esi, esi
jle short loc_11EE
mov r9d, edx
mov rdx, r8
lea eax, [rsi-1]
lea rsi, [r8+rax*4+4]
mov rax, r8
loc_11AA:
movsxd rcx, dword ptr [rax]
add [rsp+rcx*4+418h+var_418], 1
add rax, 4
cmp rax, rsi
jnz short loc_11AA
loc_11BA:
mov eax, [rdx]
movsxd rcx, eax
cmp [rsp+rcx*4+418h+var_418], r9d
jz short loc_11D3
add rdx, 4
cmp rdx, rsi
jnz short loc_11BA
mov eax, 0FFFFFFFFh
loc_11D3:
mov rdx, [rsp+418h+var_10]
sub rdx, fs:28h
jnz short loc_11F5
add rsp, 418h
retn
loc_11EE:
mov eax, 0FFFFFFFFh
jmp short loc_11D3
loc_11F5:
call ___stack_chk_fail | long long func0(int *a1, int a2, int a3)
{
unsigned int *v4; // rdx
long long v5; // rsi
int *v6; // rax
long long result; // rax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v4 = (unsigned int *)a1;
v5 = (long long)&a1[a2 - 1 + 1];
v6 = a1;
do
++v8[*v6++];
while ( v6 != (int *)v5 );
while ( 1 )
{
result = *v4;
if ( v8[(int)result] == a3 )
break;
if ( ++v4 == (unsigned int *)v5 )
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x418
MOV R8,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x001011ee
MOV R9D,EDX
MOV RDX,R8
LEA EAX,[RSI + -0x1]
LEA RSI,[R8 + RAX*0x4 + 0x4]
MOV RAX,R8
LAB_001011aa:
MOVSXD RCX,dword ptr [RAX]
ADD dword ptr [RSP + RCX*0x4],0x1
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001011aa
LAB_001011ba:
MOV EAX,dword ptr [RDX]
MOVSXD RCX,EAX
CMP dword ptr [RSP + RCX*0x4],R9D
JZ 0x001011d3
ADD RDX,0x4
CMP RDX,RSI
JNZ 0x001011ba
MOV EAX,0xffffffff
LAB_001011d3:
MOV RDX,qword ptr [RSP + 0x408]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001011f5
ADD RSP,0x418
RET
LAB_001011ee:
MOV EAX,0xffffffff
JMP 0x001011d3
LAB_001011f5:
CALL 0x00101060 | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (int *)((long)piVar4 + 8);
}
if (param_2 < 1) {
iVar1 = -1;
}
else {
piVar4 = param_1 + (ulong)(param_2 - 1) + 1;
piVar2 = param_1;
do {
aiStack_418[*piVar2] = aiStack_418[*piVar2] + 1;
piVar2 = piVar2 + 1;
} while (piVar2 != piVar4);
do {
iVar1 = *param_1;
if (aiStack_418[iVar1] == param_3) goto LAB_001011d3;
param_1 = param_1 + 1;
} while (param_1 != piVar4);
iVar1 = -1;
}
LAB_001011d3:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
5,298 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count_map[256] = {0}; // Assuming the range of elements in array is 0-255
int i;
for (i = 0; i < n; i++) {
count_map[arr[i]]++;
}
for (i = 0; i < n; i++) {
if (count_map[arr[i]] == k) {
return arr[i];
}
}
return -1;
}
| int main() {
assert(func0((int[]){0,1,2,3,4,5},6,1) == 0);
assert(func0((int[]){1,2,1,3,4},5,2) == 1);
assert(func0((int[]){2,3,4,3,5,7,1,2,3,5},10,2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%r8
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 1370 <func0+0x90>
lea -0x1(%rsi),%eax
mov %r8,%rdi
lea 0x4(%r8,%rax,4),%rsi
mov %r8,%rax
xchg %ax,%ax
movslq (%rax),%rcx
add $0x4,%rax
addl $0x1,(%rsp,%rcx,4)
cmp %rsi,%rax
jne 1320 <func0+0x40>
movslq (%rdi),%rcx
mov %rcx,%rax
cmp %edx,(%rsp,%rcx,4)
je 1354 <func0+0x74>
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rsi,%rdi
je 1370 <func0+0x90>
movslq (%rdi),%rcx
mov %rcx,%rax
cmp %edx,(%rsp,%rcx,4)
jne 1340 <func0+0x60>
mov 0x408(%rsp),%rdx
xor %fs:0x28,%rdx
jne 1377 <func0+0x97>
add $0x418,%rsp
retq
mov $0xffffffff,%eax
jmp 1354 <func0+0x74>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
sub rsp, 418h
mov r8, rdi
mov ecx, 80h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
test esi, esi
jle short loc_1380
lea eax, [rsi-1]
mov r9d, edx
mov rdi, r8
lea rcx, [r8+rax*4+4]
mov rax, r8
nop dword ptr [rax+00000000h]
loc_1328:
movsxd rdx, dword ptr [rax]
add rax, 4
add [rsp+rdx*4+418h+var_418], 1
cmp rax, rcx
jnz short loc_1328
movsxd rdx, dword ptr [rdi]
mov rax, rdx
cmp [rsp+rdx*4+418h+var_418], r9d
jz short loc_135D
nop dword ptr [rax+00h]
loc_1348:
add rdi, 4
cmp rdi, rcx
jz short loc_1380
movsxd rdx, dword ptr [rdi]
mov rax, rdx
cmp [rsp+rdx*4+418h+var_418], r9d
jnz short loc_1348
loc_135D:
mov rdx, [rsp+418h+var_10]
sub rdx, fs:28h
jnz short loc_1387
add rsp, 418h
retn
loc_1380:
mov eax, 0FFFFFFFFh
jmp short loc_135D
loc_1387:
call ___stack_chk_fail | long long func0(int *a1, int a2, int a3)
{
long long v4; // rcx
int *v5; // rax
long long v6; // rdx
long long result; // rax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = a1;
do
{
v6 = *v5++;
++v8[v6];
}
while ( v5 != (int *)v4 );
result = *a1;
if ( v8[result] != a3 )
{
while ( ++a1 != (int *)v4 )
{
result = *a1;
if ( v8[result] == a3 )
return result;
}
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x418
MOV R8,RDI
MOV ECX,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x00101380
LEA EAX,[RSI + -0x1]
MOV R9D,EDX
MOV RDI,R8
LEA RCX,[R8 + RAX*0x4 + 0x4]
MOV RAX,R8
NOP dword ptr [RAX]
LAB_00101328:
MOVSXD RDX,dword ptr [RAX]
ADD RAX,0x4
ADD dword ptr [RSP + RDX*0x4],0x1
CMP RAX,RCX
JNZ 0x00101328
MOVSXD RDX,dword ptr [RDI]
MOV RAX,RDX
CMP dword ptr [RSP + RDX*0x4],R9D
JZ 0x0010135d
NOP dword ptr [RAX]
LAB_00101348:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x00101380
MOVSXD RDX,dword ptr [RDI]
MOV RAX,RDX
CMP dword ptr [RSP + RDX*0x4],R9D
JNZ 0x00101348
LAB_0010135d:
MOV RDX,qword ptr [RSP + 0x408]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101387
ADD RSP,0x418
RET
LAB_00101380:
MOV EAX,0xffffffff
JMP 0x0010135d
LAB_00101387:
CALL 0x00101060 | long func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (int *)((long)piVar4 + 8);
}
if (param_2 < 1) {
LAB_00101380:
lVar3 = 0xffffffff;
}
else {
piVar4 = param_1 + (ulong)(param_2 - 1) + 1;
piVar2 = param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
aiStack_418[iVar1] = aiStack_418[iVar1] + 1;
} while (piVar2 != piVar4);
lVar3 = (long)*param_1;
iVar1 = aiStack_418[lVar3];
while (iVar1 != param_3) {
param_1 = param_1 + 1;
if (param_1 == piVar4) goto LAB_00101380;
lVar3 = (long)*param_1;
iVar1 = aiStack_418[lVar3];
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar3;
} |
5,299 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count_map[256] = {0}; // Assuming the range of elements in array is 0-255
int i;
for (i = 0; i < n; i++) {
count_map[arr[i]]++;
}
for (i = 0; i < n; i++) {
if (count_map[arr[i]] == k) {
return arr[i];
}
}
return -1;
}
| int main() {
assert(func0((int[]){0,1,2,3,4,5},6,1) == 0);
assert(func0((int[]){1,2,1,3,4},5,2) == 1);
assert(func0((int[]){2,3,4,3,5,7,1,2,3,5},10,2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%r8
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 1340 <func0+0x90>
lea -0x1(%rsi),%eax
mov %r8,%rdi
lea 0x4(%r8,%rax,4),%rsi
mov %r8,%rax
xchg %ax,%ax
movslq (%rax),%rcx
add $0x4,%rax
addl $0x1,(%rsp,%rcx,4)
cmp %rsi,%rax
jne 12f0 <func0+0x40>
movslq (%rdi),%rcx
mov %rcx,%rax
cmp %edx,(%rsp,%rcx,4)
je 1324 <func0+0x74>
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rsi,%rdi
je 1340 <func0+0x90>
movslq (%rdi),%rcx
mov %rcx,%rax
cmp %edx,(%rsp,%rcx,4)
jne 1310 <func0+0x60>
mov 0x408(%rsp),%rdx
xor %fs:0x28,%rdx
jne 1347 <func0+0x97>
add $0x418,%rsp
retq
mov $0xffffffff,%eax
jmp 1324 <func0+0x74>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
sub rsp, 418h
mov r8, rdi
mov ecx, 80h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
test esi, esi
jle short loc_1340
movsxd rsi, esi
mov r9d, edx
mov rdi, r8
mov rax, r8
lea rcx, [r8+rsi*4]
loc_12F0:
movsxd rdx, dword ptr [rax]
add rax, 4
add [rsp+rdx*4+418h+var_418], 1
cmp rax, rcx
jnz short loc_12F0
movsxd rdx, dword ptr [rdi]
mov rax, rdx
cmp [rsp+rdx*4+418h+var_418], r9d
jz short loc_1325
nop dword ptr [rax+00h]
loc_1310:
add rdi, 4
cmp rdi, rcx
jz short loc_1340
movsxd rdx, dword ptr [rdi]
mov rax, rdx
cmp [rsp+rdx*4+418h+var_418], r9d
jnz short loc_1310
loc_1325:
mov rdx, [rsp+418h+var_10]
sub rdx, fs:28h
jnz short loc_1347
add rsp, 418h
retn
loc_1340:
mov eax, 0FFFFFFFFh
jmp short loc_1325
loc_1347:
call ___stack_chk_fail | long long func0(int *a1, int a2, int a3)
{
int *v4; // rax
int *v5; // rcx
long long v6; // rdx
long long result; // rax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v4 = a1;
v5 = &a1[a2];
do
{
v6 = *v4++;
++v8[v6];
}
while ( v4 != v5 );
result = *a1;
if ( v8[result] != a3 )
{
while ( ++a1 != v5 )
{
result = *a1;
if ( v8[result] == a3 )
return result;
}
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x418
MOV R8,RDI
MOV ECX,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x00101340
MOVSXD RSI,ESI
MOV R9D,EDX
MOV RDI,R8
MOV RAX,R8
LEA RCX,[R8 + RSI*0x4]
LAB_001012f0:
MOVSXD RDX,dword ptr [RAX]
ADD RAX,0x4
ADD dword ptr [RSP + RDX*0x4],0x1
CMP RAX,RCX
JNZ 0x001012f0
MOVSXD RDX,dword ptr [RDI]
MOV RAX,RDX
CMP dword ptr [RSP + RDX*0x4],R9D
JZ 0x00101325
NOP dword ptr [RAX]
LAB_00101310:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x00101340
MOVSXD RDX,dword ptr [RDI]
MOV RAX,RDX
CMP dword ptr [RSP + RDX*0x4],R9D
JNZ 0x00101310
LAB_00101325:
MOV RDX,qword ptr [RSP + 0x408]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101347
ADD RSP,0x418
RET
LAB_00101340:
MOV EAX,0xffffffff
JMP 0x00101325
LAB_00101347:
CALL 0x00101060 | long func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (int *)((long)piVar4 + 8);
}
if (param_2 < 1) {
LAB_00101340:
lVar3 = 0xffffffff;
}
else {
piVar4 = param_1 + param_2;
piVar2 = param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
aiStack_418[iVar1] = aiStack_418[iVar1] + 1;
} while (piVar2 != piVar4);
lVar3 = (long)*param_1;
iVar1 = aiStack_418[lVar3];
while (iVar1 != param_3) {
param_1 = param_1 + 1;
if (param_1 == piVar4) goto LAB_00101340;
lVar3 = (long)*param_1;
iVar1 = aiStack_418[lVar3];
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar3;
} |
5,300 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char* str) {
for (int i = 0; i < strlen(str); i++) {
for (int j = i + 1; j < strlen(str); j++) {
if (str[i] == str[j]) {
return false;
}
}
}
return true;
}
| int main() {
assert(func0("aba") == false);
assert(func0("abc") == true);
assert(func0("abab") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
jmp 11d8 <func0+0x6f>
mov -0x18(%rbp),%eax
add $0x1,%eax
mov %eax,-0x14(%rbp)
jmp 11bd <func0+0x54>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x14(%rbp),%eax
movslq %eax,%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 11b9 <func0+0x50>
mov $0x0,%eax
jmp 11f4 <func0+0x8b>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 118e <func0+0x25>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 1183 <func0+0x1a>
mov $0x1,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_18], 0
jmp short loc_11D8
loc_1183:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_11BD
loc_118E:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_14]
movsxd rcx, eax
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_11B9
mov eax, 0
jmp short loc_11F4
loc_11B9:
add [rbp+var_14], 1
loc_11BD:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_118E
add [rbp+var_18], 1
loc_11D8:
mov eax, [rbp+var_18]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_1183
mov eax, 1
loc_11F4:
mov rbx, [rbp+var_8]
leave
retn | long long func0(const char *a1)
{
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < strlen(a1); ++i )
{
for ( j = i + 1; j < strlen(a1); ++j )
{
if ( a1[i] == a1[j] )
return 0LL;
}
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001011d8
LAB_00101183:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001011bd
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001011b9
MOV EAX,0x0
JMP 0x001011f4
LAB_001011b9:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011bd:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x0010118e
ADD dword ptr [RBP + -0x18],0x1
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x00101183
MOV EAX,0x1
LAB_001011f4:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int8 func0(char *param_1)
{
size_t sVar1;
int local_20;
int local_1c;
local_20 = 0;
do {
sVar1 = strlen(param_1);
local_1c = local_20;
if (sVar1 <= (ulong)(long)local_20) {
return 1;
}
while( true ) {
local_1c = local_1c + 1;
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)local_1c) break;
if (param_1[local_20] == param_1[local_1c]) {
return 0;
}
}
local_20 = local_20 + 1;
} while( true );
} |
5,301 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char* str) {
for (int i = 0; i < strlen(str); i++) {
for (int j = i + 1; j < strlen(str); j++) {
if (str[i] == str[j]) {
return false;
}
}
}
return true;
}
| int main() {
assert(func0("aba") == false);
assert(func0("abc") == true);
assert(func0("abab") == false);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r9
mov $0x1,%edi
lea (%r8,%r9,1),%rsi
cmp %rcx,%rdi
je 1197 <func0+0x4e>
cmp %rdi,%r9
jbe 1191 <func0+0x48>
movzbl -0x1(%r8,%rdi,1),%edx
movslq %edi,%rax
add %r8,%rax
cmp (%rax),%dl
je 119d <func0+0x54>
add $0x1,%rax
cmp %rsi,%rax
jne 1184 <func0+0x3b>
add $0x1,%rdi
jmp 116e <func0+0x25>
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
lea r8, [rax+1]
mov edi, 1
lea rsi, [rbx+rax]
loc_1183:
cmp rdi, r8
jz short loc_11AB
cmp rax, rdi
jbe short loc_11A5
movzx ecx, byte ptr [rbx+rdi-1]
movsxd rdx, edi
add rdx, rbx
loc_1198:
cmp cl, [rdx]
jz short loc_11B2
add rdx, 1
cmp rdx, rsi
jnz short loc_1198
loc_11A5:
add rdi, 1
jmp short loc_1183
loc_11AB:
mov eax, 1
jmp short loc_11B7
loc_11B2:
mov eax, 0
loc_11B7:
pop rbx
retn | long long func0(long long a1)
{
unsigned long long v2; // rax
unsigned long long i; // rdi
_BYTE *v4; // rdx
v2 = strlen();
for ( i = 1LL; ; ++i )
{
if ( i == v2 + 1 )
return 1LL;
if ( v2 > i )
break;
LABEL_7:
;
}
v4 = (_BYTE *)(a1 + (int)i);
while ( *(_BYTE *)(a1 + i - 1) != *v4 )
{
if ( ++v4 == (_BYTE *)(a1 + v2) )
goto LABEL_7;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
LEA R8,[RAX + 0x1]
MOV EDI,0x1
LEA RSI,[RBX + RAX*0x1]
LAB_00101183:
CMP RDI,R8
JZ 0x001011ab
CMP RAX,RDI
JBE 0x001011a5
MOVZX ECX,byte ptr [RBX + RDI*0x1 + -0x1]
MOVSXD RDX,EDI
ADD RDX,RBX
LAB_00101198:
CMP CL,byte ptr [RDX]
JZ 0x001011b2
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x00101198
LAB_001011a5:
ADD RDI,0x1
JMP 0x00101183
LAB_001011ab:
MOV EAX,0x1
JMP 0x001011b7
LAB_001011b2:
MOV EAX,0x0
LAB_001011b7:
POP RBX
RET | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
sVar1 = strlen(param_1);
uVar3 = 1;
do {
if (uVar3 == sVar1 + 1) {
return 1;
}
if (uVar3 < sVar1) {
pcVar2 = param_1 + (int)uVar3;
do {
if (param_1[uVar3 - 1] == *pcVar2) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + sVar1);
}
uVar3 = uVar3 + 1;
} while( true );
} |
5,302 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char* str) {
for (int i = 0; i < strlen(str); i++) {
for (int j = i + 1; j < strlen(str); j++) {
if (str[i] == str[j]) {
return false;
}
}
}
return true;
}
| int main() {
assert(func0("aba") == false);
assert(func0("abc") == true);
assert(func0("abab") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov $0x1,%r8d
lea 0x1(%rax),%rdi
lea (%rbx,%rax,1),%rsi
cmp %rdi,%r8
je 1269 <func0+0x59>
cmp %r8,%rax
jbe 1260 <func0+0x50>
movslq %r8d,%rdx
movzbl -0x1(%rbx,%r8,1),%ecx
add %rbx,%rdx
jmp 1251 <func0+0x41>
nopl 0x0(%rax,%rax,1)
add $0x1,%rdx
cmp %rsi,%rdx
je 1260 <func0+0x50>
cmp (%rdx),%cl
jne 1248 <func0+0x38>
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
add $0x1,%r8
cmp %rdi,%r8
jne 1230 <func0+0x20>
mov $0x1,%eax
pop %rbx
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov r8d, 1
lea rdi, [rax+1]
lea rsi, [rbx+rax]
cmp r8, rdi
jz short loc_1269
loc_1230:
cmp rax, r8
jbe short loc_1260
movsxd rdx, r8d
movzx ecx, byte ptr [rbx+r8-1]
add rdx, rbx
jmp short loc_1251
loc_1248:
add rdx, 1
cmp rdx, rsi
jz short loc_1260
loc_1251:
cmp cl, [rdx]
jnz short loc_1248
xor eax, eax
pop rbx
retn
loc_1260:
add r8, 1
cmp r8, rdi
jnz short loc_1230
loc_1269:
mov eax, 1
pop rbx
retn | long long func0(long long a1)
{
unsigned long long v1; // rax
unsigned long long v2; // r8
_BYTE *v3; // rdx
v1 = strlen();
v2 = 1LL;
if ( !v1 )
return 1LL;
while ( v1 <= v2 )
{
LABEL_7:
if ( ++v2 == v1 + 1 )
return 1LL;
}
v3 = (_BYTE *)(a1 + (int)v2);
while ( *(_BYTE *)(a1 + v2 - 1) != *v3 )
{
if ( ++v3 == (_BYTE *)(a1 + v1) )
goto LABEL_7;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV R8D,0x1
LEA RDI,[RAX + 0x1]
LEA RSI,[RBX + RAX*0x1]
CMP R8,RDI
JZ 0x00101269
LAB_00101230:
CMP RAX,R8
JBE 0x00101260
MOVSXD RDX,R8D
MOVZX ECX,byte ptr [RBX + R8*0x1 + -0x1]
ADD RDX,RBX
JMP 0x00101251
LAB_00101248:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x00101260
LAB_00101251:
CMP CL,byte ptr [RDX]
JNZ 0x00101248
XOR EAX,EAX
POP RBX
RET
LAB_00101260:
ADD R8,0x1
CMP R8,RDI
JNZ 0x00101230
LAB_00101269:
MOV EAX,0x1
POP RBX
RET | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
sVar1 = strlen(param_1);
uVar3 = 1;
if (sVar1 + 1 != 1) {
do {
if (uVar3 < sVar1) {
pcVar2 = param_1 + (int)uVar3;
do {
if (param_1[uVar3 - 1] == *pcVar2) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + sVar1);
}
uVar3 = uVar3 + 1;
} while (uVar3 != sVar1 + 1);
}
return 1;
} |
5,303 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char* str) {
for (int i = 0; i < strlen(str); i++) {
for (int j = i + 1; j < strlen(str); j++) {
if (str[i] == str[j]) {
return false;
}
}
}
return true;
}
| int main() {
assert(func0("aba") == false);
assert(func0("abc") == true);
assert(func0("abab") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov $0x1,%r8d
lea 0x1(%rax),%rdi
lea (%rbx,%rax,1),%rsi
cmp %rdi,%r8
je 1269 <func0+0x59>
cmp %r8,%rax
jbe 1260 <func0+0x50>
movslq %r8d,%rdx
movzbl -0x1(%rbx,%r8,1),%ecx
add %rbx,%rdx
jmp 1251 <func0+0x41>
nopl 0x0(%rax,%rax,1)
add $0x1,%rdx
cmp %rsi,%rdx
je 1260 <func0+0x50>
cmp (%rdx),%cl
jne 1248 <func0+0x38>
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
add $0x1,%r8
cmp %rdi,%r8
jne 1230 <func0+0x20>
mov $0x1,%eax
pop %rbx
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov r8d, 1
lea rdi, [rax+1]
lea rsi, [rbx+rax]
cmp r8, rdi
jz short loc_1269
loc_1230:
cmp r8, rax
jnb short loc_1260
movsxd rdx, r8d
movzx ecx, byte ptr [rbx+r8-1]
add rdx, rbx
jmp short loc_1251
loc_1248:
add rdx, 1
cmp rdx, rsi
jz short loc_1260
loc_1251:
cmp cl, [rdx]
jnz short loc_1248
xor eax, eax
pop rbx
retn
loc_1260:
add r8, 1
cmp r8, rdi
jnz short loc_1230
loc_1269:
mov eax, 1
pop rbx
retn | long long func0(const char *a1)
{
size_t v1; // rax
unsigned long long v2; // r8
const char *v3; // rdx
v1 = strlen(a1);
v2 = 1LL;
if ( !v1 )
return 1LL;
while ( v2 >= v1 )
{
LABEL_7:
if ( ++v2 == v1 + 1 )
return 1LL;
}
v3 = &a1[(int)v2];
while ( a1[v2 - 1] != *v3 )
{
if ( ++v3 == &a1[v1] )
goto LABEL_7;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV R8D,0x1
LEA RDI,[RAX + 0x1]
LEA RSI,[RBX + RAX*0x1]
CMP R8,RDI
JZ 0x00101269
LAB_00101230:
CMP R8,RAX
JNC 0x00101260
MOVSXD RDX,R8D
MOVZX ECX,byte ptr [RBX + R8*0x1 + -0x1]
ADD RDX,RBX
JMP 0x00101251
LAB_00101248:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x00101260
LAB_00101251:
CMP CL,byte ptr [RDX]
JNZ 0x00101248
XOR EAX,EAX
POP RBX
RET
LAB_00101260:
ADD R8,0x1
CMP R8,RDI
JNZ 0x00101230
LAB_00101269:
MOV EAX,0x1
POP RBX
RET | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
sVar1 = strlen(param_1);
uVar3 = 1;
if (sVar1 + 1 != 1) {
do {
if (uVar3 < sVar1) {
pcVar2 = param_1 + (int)uVar3;
do {
if (param_1[uVar3 - 1] == *pcVar2) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + sVar1);
}
uVar3 = uVar3 + 1;
} while (uVar3 != sVar1 + 1);
}
return 1;
} |
5,304 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int* data;
int length;
} Row;
| Row* func0(Row list1[], int num_rows, int n) {
for(int i = 0; i < num_rows; i++) {
if(n < list1[i].length) {
for(int j = n; j < list1[i].length -1; j++) {
list1[i].data[j] = list1[i].data[j+1];
}
list1[i].length -=1;
}
}
return list1;
}
| int main() {
// Test case 1
{
int row0[] = {1, 2, 3};
int row1[] = {2, 4, 5};
int row2[] = {1, 1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 0);
int expected0[] = {2, 3};
int expected1[] = {4, 5};
int expected2[] = {1, 1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 2
{
int row0[] = {1, 2, 3};
int row1[] = {-2, 4, -5};
int row2[] = {1, -1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 2);
int expected0[] = {1, 2};
int expected1[] = {-2, 4};
int expected2[] = {1, -1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 3
{
int row0[] = {1, 3};
int row1[] = {5, 7};
int row2[] = {1, 3};
int row3[] = {13, 15, 17};
int row4[] = {5, 7};
int row5[] = {9, 11};
Row list1[6];
list1[0].data = row0;
list1[0].length = 2;
list1[1].data = row1;
list1[1].length = 2;
list1[2].data = row2;
list1[2].length = 2;
list1[3].data = row3;
list1[3].length = 3;
list1[4].data = row4;
list1[4].length = 2;
list1[5].data = row5;
list1[5].length = 2;
Row* result = func0(list1, 6, 0);
int expected0[] = {3};
int expected1[] = {7};
int expected2[] = {3};
int expected3[] = {15, 17};
int expected4[] = {7};
int expected5[] = {11};
Row expected[6];
expected[0].data = expected0;
expected[0].length = 1;
expected[1].data = expected1;
expected[1].length = 1;
expected[2].data = expected2;
expected[2].length = 1;
expected[3].data = expected3;
expected[3].length = 2;
expected[4].data = expected4;
expected[4].length = 1;
expected[5].data = expected5;
expected[5].length = 1;
for(int i = 0; i < 6; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1272 <func0+0xe9>
mov -0x8(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
cmp %eax,-0x20(%rbp)
jge 126e <func0+0xe5>
mov -0x20(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1221 <func0+0x98>
mov -0x8(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 11ce <func0+0x45>
mov -0x8(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
sub $0x1,%edx
mov %edx,0x8(%rax)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11a7 <func0+0x1e>
mov -0x18(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
jmp loc_1272
loc_11A7:
mov eax, [rbp+var_8]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax+8]
cmp [rbp+var_20], eax
jge loc_126E
mov eax, [rbp+var_20]
mov [rbp+var_4], eax
jmp short loc_1221
loc_11CE:
mov eax, [rbp+var_8]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
add rdx, 1
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4], 1
loc_1221:
mov eax, [rbp+var_8]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax+8]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_11CE
mov eax, [rbp+var_8]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax+8]
mov eax, [rbp+var_8]
cdqe
shl rax, 4
mov rcx, rax
mov rax, [rbp+var_18]
add rax, rcx
sub edx, 1
mov [rax+8], edx
loc_126E:
add [rbp+var_8], 1
loc_1272:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_11A7
mov rax, [rbp+var_18]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( a3 < *(_DWORD *)(16LL * i + a1 + 8) )
{
for ( j = a3; j < *(_DWORD *)(16LL * i + a1 + 8) - 1; ++j )
*(_DWORD *)(4LL * j + *(_QWORD *)(16LL * i + a1)) = *(_DWORD *)(4 * (j + 1LL) + *(_QWORD *)(16LL * i + a1));
--*(_DWORD *)(16LL * i + a1 + 8);
}
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101272
LAB_001011a7:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
CMP dword ptr [RBP + -0x20],EAX
JGE 0x0010126e
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101221
LAB_001011ce:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
ADD RDX,0x1
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101221:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011ce
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x8]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x4
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
SUB EDX,0x1
MOV dword ptr [RAX + 0x8],EDX
LAB_0010126e:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101272:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a7
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET | long func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
local_c = param_3;
if (param_3 < *(int *)(param_1 + (long)local_10 * 0x10 + 8)) {
for (; local_c < *(int *)(param_1 + (long)local_10 * 0x10 + 8) + -1; local_c = local_c + 1) {
*(int4 *)(*(long *)(param_1 + (long)local_10 * 0x10) + (long)local_c * 4) =
*(int4 *)(*(long *)(param_1 + (long)local_10 * 0x10) + ((long)local_c + 1) * 4);
}
*(int *)(param_1 + (long)local_10 * 0x10 + 8) =
*(int *)(param_1 + (long)local_10 * 0x10 + 8) + -1;
}
}
return param_1;
} |
5,305 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int* data;
int length;
} Row;
| Row* func0(Row list1[], int num_rows, int n) {
for(int i = 0; i < num_rows; i++) {
if(n < list1[i].length) {
for(int j = n; j < list1[i].length -1; j++) {
list1[i].data[j] = list1[i].data[j+1];
}
list1[i].length -=1;
}
}
return list1;
}
| int main() {
// Test case 1
{
int row0[] = {1, 2, 3};
int row1[] = {2, 4, 5};
int row2[] = {1, 1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 0);
int expected0[] = {2, 3};
int expected1[] = {4, 5};
int expected2[] = {1, 1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 2
{
int row0[] = {1, 2, 3};
int row1[] = {-2, 4, -5};
int row2[] = {1, -1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 2);
int expected0[] = {1, 2};
int expected1[] = {-2, 4};
int expected2[] = {1, -1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 3
{
int row0[] = {1, 3};
int row1[] = {5, 7};
int row2[] = {1, 3};
int row3[] = {13, 15, 17};
int row4[] = {5, 7};
int row5[] = {9, 11};
Row list1[6];
list1[0].data = row0;
list1[0].length = 2;
list1[1].data = row1;
list1[1].length = 2;
list1[2].data = row2;
list1[2].length = 2;
list1[3].data = row3;
list1[3].length = 3;
list1[4].data = row4;
list1[4].length = 2;
list1[5].data = row5;
list1[5].length = 2;
Row* result = func0(list1, 6, 0);
int expected0[] = {3};
int expected1[] = {7};
int expected2[] = {3};
int expected3[] = {15, 17};
int expected4[] = {7};
int expected5[] = {11};
Row expected[6];
expected[0].data = expected0;
expected[0].length = 1;
expected[1].data = expected1;
expected[1].length = 1;
expected[2].data = expected2;
expected[2].length = 1;
expected[3].data = expected3;
expected[3].length = 2;
expected[4].data = expected4;
expected[4].length = 1;
expected[5].data = expected5;
expected[5].length = 1;
for(int i = 0; i < 6; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11f6 <func0+0x6d>
push %rbx
lea 0x8(%rdi),%r9
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x18(%rdi,%rax,1),%r11
movslq %edx,%rax
lea 0x4(,%rax,4),%rbx
jmp 11bb <func0+0x32>
mov %eax,(%r8)
add $0x10,%r9
cmp %r11,%r9
je 11f1 <func0+0x68>
mov %r9,%r8
mov (%r9),%eax
cmp %edx,%eax
jle 11b2 <func0+0x29>
sub $0x1,%eax
cmp %eax,%edx
jge 11af <func0+0x26>
mov %rbx,%rcx
mov %edx,%esi
mov -0x8(%r8),%rax
mov (%rax,%rcx,1),%r10d
mov %r10d,-0x4(%rax,%rcx,1)
add $0x1,%esi
mov (%r8),%eax
sub $0x1,%eax
add $0x4,%rcx
cmp %esi,%eax
jg 11d1 <func0+0x48>
jmp 11af <func0+0x26>
mov %rdi,%rax
pop %rbx
retq
mov %rdi,%rax
retq
| func0:
endbr64
mov r11, rdi
test esi, esi
jle short loc_11FC
push rbx
mov r9d, edx
lea rdi, [rdi+8]
lea eax, [rsi-1]
shl rax, 4
lea r10, [r11+rax+18h]
movsxd rax, edx
lea rbx, ds:4[rax*4]
jmp short loc_11C0
loc_11B5:
mov [rsi], eax
loc_11B7:
add rdi, 10h
cmp rdi, r10
jz short loc_11F7
loc_11C0:
mov rsi, rdi
mov eax, [rdi]
cmp eax, r9d
jle short loc_11B7
sub eax, 1
cmp r9d, eax
jge short loc_11B5
mov rdx, rbx
mov ecx, r9d
loc_11D8:
mov rax, [rsi-8]
mov r8d, [rax+rdx]
mov [rax+rdx-4], r8d
add ecx, 1
mov eax, [rsi]
sub eax, 1
add rdx, 4
cmp eax, ecx
jg short loc_11D8
jmp short loc_11B5
loc_11F7:
mov rax, r11
pop rbx
retn
loc_11FC:
mov rax, rdi
retn | long long func0(long long a1, int a2, int a3)
{
int *v5; // rdi
long long v6; // rbx
int v7; // eax
long long v8; // rdx
int v9; // ecx
if ( a2 <= 0 )
return a1;
v5 = (int *)(a1 + 8);
v6 = 4LL * a3 + 4;
do
{
if ( *v5 > a3 )
{
v7 = *v5 - 1;
if ( a3 < v7 )
{
v8 = v6;
v9 = a3;
do
{
*(_DWORD *)(*((_QWORD *)v5 - 1) + v8 - 4) = *(_DWORD *)(*((_QWORD *)v5 - 1) + v8);
++v9;
v7 = *v5 - 1;
v8 += 4LL;
}
while ( v7 > v9 );
}
*v5 = v7;
}
v5 += 4;
}
while ( v5 != (int *)(a1 + 16LL * (unsigned int)(a2 - 1) + 24) );
return a1;
} | func0:
ENDBR64
MOV R11,RDI
TEST ESI,ESI
JLE 0x001011fc
PUSH RBX
MOV R9D,EDX
LEA RDI,[RDI + 0x8]
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA R10,[R11 + RAX*0x1 + 0x18]
MOVSXD RAX,EDX
LEA RBX,[0x4 + RAX*0x4]
JMP 0x001011c0
LAB_001011b5:
MOV dword ptr [RSI],EAX
LAB_001011b7:
ADD RDI,0x10
CMP RDI,R10
JZ 0x001011f7
LAB_001011c0:
MOV RSI,RDI
MOV EAX,dword ptr [RDI]
CMP EAX,R9D
JLE 0x001011b7
SUB EAX,0x1
CMP R9D,EAX
JGE 0x001011b5
MOV RDX,RBX
MOV ECX,R9D
LAB_001011d8:
MOV RAX,qword ptr [RSI + -0x8]
MOV R8D,dword ptr [RAX + RDX*0x1]
MOV dword ptr [RAX + RDX*0x1 + -0x4],R8D
ADD ECX,0x1
MOV EAX,dword ptr [RSI]
SUB EAX,0x1
ADD RDX,0x4
CMP EAX,ECX
JG 0x001011d8
JMP 0x001011b5
LAB_001011f7:
MOV RAX,R11
POP RBX
RET
LAB_001011fc:
MOV RAX,RDI
RET | long func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
int *piVar4;
if (param_2 < 1) {
return param_1;
}
piVar4 = (int *)(param_1 + 8);
do {
if (param_3 < *piVar4) {
iVar1 = *piVar4 + -1;
lVar3 = (long)param_3 * 4;
iVar2 = param_3;
if (param_3 < iVar1) {
do {
lVar3 = lVar3 + 4;
*(int4 *)(*(long *)(piVar4 + -2) + -4 + lVar3) =
*(int4 *)(*(long *)(piVar4 + -2) + lVar3);
iVar2 = iVar2 + 1;
iVar1 = *piVar4 + -1;
} while (iVar2 < iVar1);
}
*piVar4 = iVar1;
}
piVar4 = piVar4 + 4;
} while (piVar4 != (int *)(param_1 + 0x18 + (ulong)(param_2 - 1) * 0x10));
return param_1;
} |
5,306 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int* data;
int length;
} Row;
| Row* func0(Row list1[], int num_rows, int n) {
for(int i = 0; i < num_rows; i++) {
if(n < list1[i].length) {
for(int j = n; j < list1[i].length -1; j++) {
list1[i].data[j] = list1[i].data[j+1];
}
list1[i].length -=1;
}
}
return list1;
}
| int main() {
// Test case 1
{
int row0[] = {1, 2, 3};
int row1[] = {2, 4, 5};
int row2[] = {1, 1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 0);
int expected0[] = {2, 3};
int expected1[] = {4, 5};
int expected2[] = {1, 1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 2
{
int row0[] = {1, 2, 3};
int row1[] = {-2, 4, -5};
int row2[] = {1, -1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 2);
int expected0[] = {1, 2};
int expected1[] = {-2, 4};
int expected2[] = {1, -1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 3
{
int row0[] = {1, 3};
int row1[] = {5, 7};
int row2[] = {1, 3};
int row3[] = {13, 15, 17};
int row4[] = {5, 7};
int row5[] = {9, 11};
Row list1[6];
list1[0].data = row0;
list1[0].length = 2;
list1[1].data = row1;
list1[1].length = 2;
list1[2].data = row2;
list1[2].length = 2;
list1[3].data = row3;
list1[3].length = 3;
list1[4].data = row4;
list1[4].length = 2;
list1[5].data = row5;
list1[5].length = 2;
Row* result = func0(list1, 6, 0);
int expected0[] = {3};
int expected1[] = {7};
int expected2[] = {3};
int expected3[] = {15, 17};
int expected4[] = {7};
int expected5[] = {11};
Row expected[6];
expected[0].data = expected0;
expected[0].length = 1;
expected[1].data = expected1;
expected[1].length = 1;
expected[2].data = expected2;
expected[2].length = 1;
expected[3].data = expected3;
expected[3].length = 2;
expected[4].data = expected4;
expected[4].length = 1;
expected[5].data = expected5;
expected[5].length = 1;
for(int i = 0; i < 6; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
return 0;
}
| O2 | c | func0:
endbr64
mov %rdi,%r10
test %esi,%esi
jle 17d1 <func0+0x61>
lea -0x1(%rsi),%eax
lea 0x8(%rdi),%r8
shl $0x4,%rax
lea 0x18(%rdi,%rax,1),%r9
jmp 1799 <func0+0x29>
nopl (%rax)
add $0x10,%r8
cmp %r9,%r8
je 17d1 <func0+0x61>
mov (%r8),%eax
cmp %edx,%eax
jle 1790 <func0+0x20>
sub $0x1,%eax
cmp %eax,%edx
jge 17c5 <func0+0x55>
mov -0x8(%r8),%rsi
movslq %edx,%rcx
xchg %ax,%ax
mov 0x4(%rsi,%rcx,4),%eax
mov %eax,(%rsi,%rcx,4)
mov (%r8),%eax
add $0x1,%rcx
sub $0x1,%eax
cmp %ecx,%eax
jg 17b0 <func0+0x40>
mov %eax,(%r8)
add $0x10,%r8
cmp %r9,%r8
jne 1799 <func0+0x29>
mov %r10,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r9, rdi
test esi, esi
jle short loc_179F
lea eax, [rsi-1]
lea rdi, [rdi+8]
shl rax, 4
lea r8, [r9+rax+18h]
jmp short loc_1769
loc_1760:
add rdi, 10h
cmp rdi, r8
jz short loc_179F
loc_1769:
mov eax, [rdi]
cmp eax, edx
jle short loc_1760
sub eax, 1
cmp edx, eax
jge short loc_1794
mov rsi, [rdi-8]
movsxd rcx, edx
nop dword ptr [rax]
loc_1780:
mov eax, [rsi+rcx*4+4]
mov [rsi+rcx*4], eax
mov eax, [rdi]
add rcx, 1
sub eax, 1
cmp eax, ecx
jg short loc_1780
loc_1794:
mov [rdi], eax
add rdi, 10h
cmp rdi, r8
jnz short loc_1769
loc_179F:
mov rax, r9
retn | long long func0(long long a1, int a2, int a3)
{
int *v4; // rdi
long long v5; // r8
int v6; // eax
long long v7; // rsi
long long v8; // rcx
if ( a2 > 0 )
{
v4 = (int *)(a1 + 8);
v5 = a1 + 16LL * (unsigned int)(a2 - 1) + 24;
do
{
while ( *v4 <= a3 )
{
v4 += 4;
if ( v4 == (int *)v5 )
return a1;
}
v6 = *v4 - 1;
if ( a3 < v6 )
{
v7 = *((_QWORD *)v4 - 1);
v8 = a3;
do
{
*(_DWORD *)(v7 + 4 * v8) = *(_DWORD *)(v7 + 4 * v8 + 4);
++v8;
v6 = *v4 - 1;
}
while ( v6 > (int)v8 );
}
*v4 = v6;
v4 += 4;
}
while ( v4 != (int *)v5 );
}
return a1;
} | func0:
ENDBR64
MOV R9,RDI
TEST ESI,ESI
JLE 0x0010179f
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + 0x8]
SHL RAX,0x4
LEA R8,[R9 + RAX*0x1 + 0x18]
JMP 0x00101769
LAB_00101760:
ADD RDI,0x10
CMP RDI,R8
JZ 0x0010179f
LAB_00101769:
MOV EAX,dword ptr [RDI]
CMP EAX,EDX
JLE 0x00101760
SUB EAX,0x1
CMP EDX,EAX
JGE 0x00101794
MOV RSI,qword ptr [RDI + -0x8]
MOVSXD RCX,EDX
NOP dword ptr [RAX]
LAB_00101780:
MOV EAX,dword ptr [RSI + RCX*0x4 + 0x4]
MOV dword ptr [RSI + RCX*0x4],EAX
MOV EAX,dword ptr [RDI]
ADD RCX,0x1
SUB EAX,0x1
CMP EAX,ECX
JG 0x00101780
LAB_00101794:
MOV dword ptr [RDI],EAX
ADD RDI,0x10
CMP RDI,R8
JNZ 0x00101769
LAB_0010179f:
MOV RAX,R9
RET | long func0(long param_1,int param_2,int param_3)
{
int *piVar1;
long lVar2;
int iVar3;
long lVar4;
int *piVar5;
if (0 < param_2) {
piVar5 = (int *)(param_1 + 8);
piVar1 = (int *)(param_1 + 0x18 + (ulong)(param_2 - 1) * 0x10);
do {
while (param_3 < *piVar5) {
iVar3 = *piVar5 + -1;
if (param_3 < iVar3) {
lVar2 = *(long *)(piVar5 + -2);
lVar4 = (long)param_3;
do {
*(int4 *)(lVar2 + lVar4 * 4) = *(int4 *)(lVar2 + 4 + lVar4 * 4);
lVar4 = lVar4 + 1;
iVar3 = *piVar5 + -1;
} while ((int)lVar4 < iVar3);
}
*piVar5 = iVar3;
piVar5 = piVar5 + 4;
if (piVar5 == piVar1) {
return param_1;
}
}
piVar5 = piVar5 + 4;
} while (piVar5 != piVar1);
}
return param_1;
} |
5,307 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int* data;
int length;
} Row;
| Row* func0(Row list1[], int num_rows, int n) {
for(int i = 0; i < num_rows; i++) {
if(n < list1[i].length) {
for(int j = n; j < list1[i].length -1; j++) {
list1[i].data[j] = list1[i].data[j+1];
}
list1[i].length -=1;
}
}
return list1;
}
| int main() {
// Test case 1
{
int row0[] = {1, 2, 3};
int row1[] = {2, 4, 5};
int row2[] = {1, 1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 0);
int expected0[] = {2, 3};
int expected1[] = {4, 5};
int expected2[] = {1, 1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 2
{
int row0[] = {1, 2, 3};
int row1[] = {-2, 4, -5};
int row2[] = {1, -1, 1};
Row list1[3];
list1[0].data = row0;
list1[0].length = 3;
list1[1].data = row1;
list1[1].length = 3;
list1[2].data = row2;
list1[2].length = 3;
Row* result = func0(list1, 3, 2);
int expected0[] = {1, 2};
int expected1[] = {-2, 4};
int expected2[] = {1, -1};
Row expected[3];
expected[0].data = expected0;
expected[0].length = 2;
expected[1].data = expected1;
expected[1].length = 2;
expected[2].data = expected2;
expected[2].length = 2;
for(int i = 0; i < 3; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
// Test case 3
{
int row0[] = {1, 3};
int row1[] = {5, 7};
int row2[] = {1, 3};
int row3[] = {13, 15, 17};
int row4[] = {5, 7};
int row5[] = {9, 11};
Row list1[6];
list1[0].data = row0;
list1[0].length = 2;
list1[1].data = row1;
list1[1].length = 2;
list1[2].data = row2;
list1[2].length = 2;
list1[3].data = row3;
list1[3].length = 3;
list1[4].data = row4;
list1[4].length = 2;
list1[5].data = row5;
list1[5].length = 2;
Row* result = func0(list1, 6, 0);
int expected0[] = {3};
int expected1[] = {7};
int expected2[] = {3};
int expected3[] = {15, 17};
int expected4[] = {7};
int expected5[] = {11};
Row expected[6];
expected[0].data = expected0;
expected[0].length = 1;
expected[1].data = expected1;
expected[1].length = 1;
expected[2].data = expected2;
expected[2].length = 1;
expected[3].data = expected3;
expected[3].length = 2;
expected[4].data = expected4;
expected[4].length = 1;
expected[5].data = expected5;
expected[5].length = 1;
for(int i = 0; i < 6; i++) {
assert(result[i].length == expected[i].length);
assert(memcmp(result[i].data, expected[i].data, sizeof(int)*result[i].length) == 0);
}
}
return 0;
}
| O3 | c | func0:
endbr64
mov %rdi,%r10
test %esi,%esi
jle 1631 <func0+0x61>
lea -0x1(%rsi),%eax
lea 0x8(%rdi),%r8
shl $0x4,%rax
lea 0x18(%rdi,%rax,1),%r9
jmp 15f9 <func0+0x29>
nopl (%rax)
add $0x10,%r8
cmp %r8,%r9
je 1631 <func0+0x61>
mov (%r8),%eax
cmp %edx,%eax
jle 15f0 <func0+0x20>
sub $0x1,%eax
cmp %eax,%edx
jge 1625 <func0+0x55>
mov -0x8(%r8),%rsi
movslq %edx,%rcx
xchg %ax,%ax
mov 0x4(%rsi,%rcx,4),%eax
mov %eax,(%rsi,%rcx,4)
mov (%r8),%eax
add $0x1,%rcx
sub $0x1,%eax
cmp %ecx,%eax
jg 1610 <func0+0x40>
mov %eax,(%r8)
add $0x10,%r8
cmp %r8,%r9
jne 15f9 <func0+0x29>
mov %r10,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r9, rdi
test esi, esi
jle short loc_15D1
movsxd rsi, esi
shl rsi, 4
lea r8, [rsi+rdi]
jmp short loc_1599
loc_1590:
add rdi, 10h
cmp r8, rdi
jz short loc_15D1
loc_1599:
mov eax, [rdi+8]
cmp eax, edx
jle short loc_1590
sub eax, 1
cmp edx, eax
jge short loc_15C5
mov rsi, [rdi]
movsxd rcx, edx
nop dword ptr [rax]
loc_15B0:
mov eax, [rsi+rcx*4+4]
mov [rsi+rcx*4], eax
mov eax, [rdi+8]
add rcx, 1
sub eax, 1
cmp eax, ecx
jg short loc_15B0
loc_15C5:
mov [rdi+8], eax
add rdi, 10h
cmp r8, rdi
jnz short loc_1599
loc_15D1:
mov rax, r9
retn | long long * func0(long long *a1, int a2, int a3)
{
long long *v3; // r9
long long *v4; // r8
int v5; // eax
int v6; // eax
long long v7; // rsi
long long v8; // rcx
v3 = a1;
if ( a2 > 0 )
{
v4 = &a1[2 * a2];
do
{
while ( 1 )
{
v5 = *((_DWORD *)a1 + 2);
if ( v5 > a3 )
break;
a1 += 2;
if ( v4 == a1 )
return v3;
}
v6 = v5 - 1;
if ( a3 < v6 )
{
v7 = *a1;
v8 = a3;
do
{
*(_DWORD *)(v7 + 4 * v8) = *(_DWORD *)(v7 + 4 * v8 + 4);
++v8;
v6 = *((_DWORD *)a1 + 2) - 1;
}
while ( v6 > (int)v8 );
}
*((_DWORD *)a1 + 2) = v6;
a1 += 2;
}
while ( v4 != a1 );
}
return v3;
} | func0:
ENDBR64
MOV R9,RDI
TEST ESI,ESI
JLE 0x001015d1
MOVSXD RSI,ESI
SHL RSI,0x4
LEA R8,[RSI + RDI*0x1]
JMP 0x00101599
LAB_00101590:
ADD RDI,0x10
CMP R8,RDI
JZ 0x001015d1
LAB_00101599:
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JLE 0x00101590
SUB EAX,0x1
CMP EDX,EAX
JGE 0x001015c5
MOV RSI,qword ptr [RDI]
MOVSXD RCX,EDX
NOP dword ptr [RAX]
LAB_001015b0:
MOV EAX,dword ptr [RSI + RCX*0x4 + 0x4]
MOV dword ptr [RSI + RCX*0x4],EAX
MOV EAX,dword ptr [RDI + 0x8]
ADD RCX,0x1
SUB EAX,0x1
CMP EAX,ECX
JG 0x001015b0
LAB_001015c5:
MOV dword ptr [RDI + 0x8],EAX
ADD RDI,0x10
CMP R8,RDI
JNZ 0x00101599
LAB_001015d1:
MOV RAX,R9
RET | long * func0(long *param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
long lVar3;
long *plVar4;
if (0 < param_2) {
plVar4 = param_1;
do {
while (param_3 < *(int *)(plVar4 + 1)) {
iVar2 = *(int *)(plVar4 + 1) + -1;
if (param_3 < iVar2) {
lVar1 = *plVar4;
lVar3 = (long)param_3;
do {
*(int4 *)(lVar1 + lVar3 * 4) = *(int4 *)(lVar1 + 4 + lVar3 * 4);
lVar3 = lVar3 + 1;
iVar2 = *(int *)(plVar4 + 1) + -1;
} while ((int)lVar3 < iVar2);
}
*(int *)(plVar4 + 1) = iVar2;
plVar4 = plVar4 + 2;
if (param_1 + (long)param_2 * 2 == plVar4) {
return param_1;
}
}
plVar4 = plVar4 + 2;
} while (param_1 + (long)param_2 * 2 != plVar4);
}
return param_1;
} |
5,308 | func0 | #include <assert.h>
| int func0(int a, int n, int d) {
int tn = a + (n - 1) * d;
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 9);
assert(func0(2, 6, 4) == 22);
assert(func0(1, 4, 5) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x18(%rbp),%eax
sub $0x1,%eax
imul -0x1c(%rbp),%eax
mov %eax,%edx
mov -0x14(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_18]
sub eax, 1
imul eax, [rbp+var_1C]
mov edx, eax
mov eax, [rbp+var_14]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 * (a2 - 1) + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
IMUL EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2,int param_3)
{
return param_1 + (param_2 + -1) * param_3;
} |
5,309 | func0 | #include <assert.h>
| int func0(int a, int n, int d) {
int tn = a + (n - 1) * d;
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 9);
assert(func0(2, 6, 4) == 22);
assert(func0(1, 4, 5) == 16);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
imul %edx,%esi
lea (%rsi,%rdi,1),%eax
retq
| func0:
endbr64
sub esi, 1
imul esi, edx
lea eax, [rsi+rdi]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 * (a2 - 1) + a1);
} | func0:
ENDBR64
SUB ESI,0x1
IMUL ESI,EDX
LEA EAX,[RSI + RDI*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_2 + -1) * param_3 + param_1;
} |
5,310 | func0 | #include <assert.h>
| int func0(int a, int n, int d) {
int tn = a + (n - 1) * d;
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 9);
assert(func0(2, 6, 4) == 22);
assert(func0(1, 4, 5) == 16);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
imul %edx,%esi
lea (%rsi,%rdi,1),%eax
retq
xchg %ax,%ax
| func0:
endbr64
sub esi, 1
imul esi, edx
lea eax, [rsi+rdi]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 * (a2 - 1) + a1);
} | func0:
ENDBR64
SUB ESI,0x1
IMUL ESI,EDX
LEA EAX,[RSI + RDI*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_2 + -1) * param_3 + param_1;
} |
5,311 | func0 | #include <assert.h>
| int func0(int a, int n, int d) {
int tn = a + (n - 1) * d;
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 9);
assert(func0(2, 6, 4) == 22);
assert(func0(1, 4, 5) == 16);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1,%esi
imul %edx,%esi
lea (%rsi,%rdi,1),%eax
retq
xchg %ax,%ax
| func0:
endbr64
sub esi, 1
imul esi, edx
lea eax, [rsi+rdi]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 * (a2 - 1) + a1);
} | func0:
ENDBR64
SUB ESI,0x1
IMUL ESI,EDX
LEA EAX,[RSI + RDI*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_2 + -1) * param_3 + param_1;
} |
5,312 | func0 | #include <assert.h>
| int func0(int radius) {
int rectangles = 0;
int diameter = 2 * radius;
int diameterSquare = diameter * diameter;
for (int a = 1; a < 2 * radius; a++) {
for (int b = 1; b < 2 * radius; b++) {
int diagnalLengthSquare = (a * a + b * b);
if (diagnalLengthSquare <= diameterSquare) {
rectangles += 1;
}
}
}
return rectangles;
}
| int main() {
assert(func0(2) == 8);
assert(func0(1) == 1);
assert(func0(0) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x24(%rbp),%eax
add %eax,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
imul %eax,%eax
mov %eax,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
jmp 11af <func0+0x66>
movl $0x1,-0x10(%rbp)
jmp 11a1 <func0+0x58>
mov -0x14(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov -0x10(%rbp),%eax
imul %eax,%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jg 119d <func0+0x54>
addl $0x1,-0x18(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x24(%rbp),%eax
add %eax,%eax
cmp %eax,-0x10(%rbp)
jl 117e <func0+0x35>
addl $0x1,-0x14(%rbp)
mov -0x24(%rbp),%eax
add %eax,%eax
cmp %eax,-0x14(%rbp)
jl 1175 <func0+0x2c>
mov -0x18(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_18], 0
mov eax, [rbp+var_24]
add eax, eax
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
imul eax, eax
mov [rbp+var_8], eax
mov [rbp+var_14], 1
jmp short loc_11AF
loc_1175:
mov [rbp+var_10], 1
jmp short loc_11A1
loc_117E:
mov eax, [rbp+var_14]
imul eax, eax
mov edx, eax
mov eax, [rbp+var_10]
imul eax, eax
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jg short loc_119D
add [rbp+var_18], 1
loc_119D:
add [rbp+var_10], 1
loc_11A1:
mov eax, [rbp+var_24]
add eax, eax
cmp [rbp+var_10], eax
jl short loc_117E
add [rbp+var_14], 1
loc_11AF:
mov eax, [rbp+var_24]
add eax, eax
cmp [rbp+var_14], eax
jl short loc_1175
mov eax, [rbp+var_18]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-18h]
int i; // [rsp+10h] [rbp-14h]
int j; // [rsp+14h] [rbp-10h]
v2 = 0;
for ( i = 1; i < 2 * a1; ++i )
{
for ( j = 1; j < 2 * a1; ++j )
{
if ( i * i + j * j <= 2 * a1 * 2 * a1 )
++v2;
}
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x18],0x0
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EAX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001011af
LAB_00101175:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x001011a1
LAB_0010117e:
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
IMUL EAX,EAX
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JG 0x0010119d
ADD dword ptr [RBP + -0x18],0x1
LAB_0010119d:
ADD dword ptr [RBP + -0x10],0x1
LAB_001011a1:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EAX
CMP dword ptr [RBP + -0x10],EAX
JL 0x0010117e
ADD dword ptr [RBP + -0x14],0x1
LAB_001011af:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JL 0x00101175
MOV EAX,dword ptr [RBP + -0x18]
POP RBP
RET | int func0(int param_1)
{
int4 local_20;
int4 local_1c;
int4 local_18;
local_20 = 0;
for (local_1c = 1; local_1c < param_1 * 2; local_1c = local_1c + 1) {
for (local_18 = 1; local_18 < param_1 * 2; local_18 = local_18 + 1) {
if (local_18 * local_18 + local_1c * local_1c <= param_1 * 2 * param_1 * 2) {
local_20 = local_20 + 1;
}
}
}
return local_20;
} |
5,313 | func0 | #include <assert.h>
| int func0(int radius) {
int rectangles = 0;
int diameter = 2 * radius;
int diameterSquare = diameter * diameter;
for (int a = 1; a < 2 * radius; a++) {
for (int b = 1; b < 2 * radius; b++) {
int diagnalLengthSquare = (a * a + b * b);
if (diagnalLengthSquare <= diameterSquare) {
rectangles += 1;
}
}
}
return rectangles;
}
| int main() {
assert(func0(2) == 8);
assert(func0(1) == 1);
assert(func0(0) == 0);
return 0;
}
| O1 | c | func0:
endbr64
lea (%rdi,%rdi,1),%esi
mov %esi,%r8d
imul %esi,%r8d
mov $0x1,%r9d
mov $0x0,%ecx
cmp $0x1,%esi
jg 1173 <func0+0x2a>
mov %ecx,%eax
retq
add $0x1,%r9d
cmp %r9d,%esi
je 1167 <func0+0x1e>
mov %r9d,%edi
imul %r9d,%edi
mov $0x1,%eax
mov %eax,%edx
imul %eax,%edx
add %edi,%edx
cmp %edx,%r8d
setge %dl
movzbl %dl,%edx
add %edx,%ecx
add $0x1,%eax
cmp %eax,%esi
jne 117f <func0+0x36>
jmp 116a <func0+0x21>
| func0:
endbr64
lea esi, [rdi+rdi]
mov r8d, esi
imul r8d, esi
mov r9d, 1
mov ecx, 0
cmp esi, 1
jle short loc_1195
loc_1167:
mov edi, r9d
imul edi, r9d
mov eax, 1
loc_1173:
mov edx, eax
imul edx, eax
add edx, edi
cmp r8d, edx
setnl dl
movzx edx, dl
add ecx, edx
add eax, 1
cmp esi, eax
jnz short loc_1173
add r9d, 1
cmp esi, r9d
jnz short loc_1167
loc_1195:
mov eax, ecx
retn | long long func0(int a1)
{
int v1; // esi
int v2; // r9d
unsigned int v3; // ecx
int v4; // eax
v1 = 2 * a1;
v2 = 1;
v3 = 0;
if ( 2 * a1 > 1 )
{
do
{
v4 = 1;
do
{
v3 += v1 * v1 >= v2 * v2 + v4 * v4;
++v4;
}
while ( v1 != v4 );
++v2;
}
while ( v1 != v2 );
}
return v3;
} | func0:
ENDBR64
LEA ESI,[RDI + RDI*0x1]
MOV R8D,ESI
IMUL R8D,ESI
MOV R9D,0x1
MOV ECX,0x0
CMP ESI,0x1
JLE 0x00101195
LAB_00101167:
MOV EDI,R9D
IMUL EDI,R9D
MOV EAX,0x1
LAB_00101173:
MOV EDX,EAX
IMUL EDX,EAX
ADD EDX,EDI
CMP R8D,EDX
SETGE DL
MOVZX EDX,DL
ADD ECX,EDX
ADD EAX,0x1
CMP ESI,EAX
JNZ 0x00101173
ADD R9D,0x1
CMP ESI,R9D
JNZ 0x00101167
LAB_00101195:
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
param_1 = param_1 * 2;
iVar3 = 1;
iVar2 = 0;
if (1 < param_1) {
do {
iVar1 = 1;
do {
iVar2 = iVar2 + (uint)(iVar1 * iVar1 + iVar3 * iVar3 <= param_1 * param_1);
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
iVar3 = iVar3 + 1;
} while (param_1 != iVar3);
}
return iVar2;
} |
5,314 | func0 | #include <assert.h>
| int func0(int radius) {
int rectangles = 0;
int diameter = 2 * radius;
int diameterSquare = diameter * diameter;
for (int a = 1; a < 2 * radius; a++) {
for (int b = 1; b < 2 * radius; b++) {
int diagnalLengthSquare = (a * a + b * b);
if (diagnalLengthSquare <= diameterSquare) {
rectangles += 1;
}
}
}
return rectangles;
}
| int main() {
assert(func0(2) == 8);
assert(func0(1) == 1);
assert(func0(0) == 0);
return 0;
}
| O2 | c | func0:
endbr64
lea (%rdi,%rdi,1),%ecx
mov %ecx,%edi
imul %ecx,%edi
cmp $0x1,%ecx
jle 1196 <func0+0x56>
mov $0x1,%r9d
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
mov %r9d,%esi
mov $0x1,%eax
imul %r9d,%esi
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add %esi,%edx
cmp %edx,%edi
setge %dl
add $0x1,%eax
movzbl %dl,%edx
add %edx,%r8d
cmp %eax,%ecx
jne 1170 <func0+0x30>
add $0x1,%r9d
cmp %r9d,%ecx
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
lea ecx, [rdi+rdi]
mov r9d, 1
xor r8d, r8d
mov edi, ecx
imul edi, ecx
cmp ecx, 1
jle short loc_1242
nop word ptr [rax+rax+00h]
loc_1210:
mov esi, r9d
mov eax, 1
imul esi, r9d
nop dword ptr [rax+00h]
loc_1220:
mov edx, eax
imul edx, eax
add edx, esi
cmp edi, edx
setnl dl
add eax, 1
movzx edx, dl
add r8d, edx
cmp ecx, eax
jnz short loc_1220
add r9d, 1
cmp ecx, r9d
jnz short loc_1210
loc_1242:
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // ecx
int v2; // r9d
unsigned int v3; // r8d
int v4; // eax
bool v5; // dl
v1 = 2 * a1;
v2 = 1;
v3 = 0;
if ( 2 * a1 > 1 )
{
do
{
v4 = 1;
do
{
v5 = v1 * v1 >= v2 * v2 + v4 * v4;
++v4;
v3 += v5;
}
while ( v1 != v4 );
++v2;
}
while ( v1 != v2 );
}
return v3;
} | func0:
ENDBR64
LEA ECX,[RDI + RDI*0x1]
MOV R9D,0x1
XOR R8D,R8D
MOV EDI,ECX
IMUL EDI,ECX
CMP ECX,0x1
JLE 0x00101242
NOP word ptr [RAX + RAX*0x1]
LAB_00101210:
MOV ESI,R9D
MOV EAX,0x1
IMUL ESI,R9D
NOP dword ptr [RAX]
LAB_00101220:
MOV EDX,EAX
IMUL EDX,EAX
ADD EDX,ESI
CMP EDI,EDX
SETGE DL
ADD EAX,0x1
MOVZX EDX,DL
ADD R8D,EDX
CMP ECX,EAX
JNZ 0x00101220
ADD R9D,0x1
CMP ECX,R9D
JNZ 0x00101210
LAB_00101242:
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
param_1 = param_1 * 2;
iVar4 = 1;
iVar3 = 0;
if (1 < param_1) {
do {
iVar1 = 1;
do {
iVar2 = iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar3 = iVar3 + (uint)(iVar2 + iVar4 * iVar4 <= param_1 * param_1);
} while (param_1 != iVar1);
iVar4 = iVar4 + 1;
} while (param_1 != iVar4);
}
return iVar3;
} |
5,315 | func0 | #include <assert.h>
| int func0(int radius) {
int rectangles = 0;
int diameter = 2 * radius;
int diameterSquare = diameter * diameter;
for (int a = 1; a < 2 * radius; a++) {
for (int b = 1; b < 2 * radius; b++) {
int diagnalLengthSquare = (a * a + b * b);
if (diagnalLengthSquare <= diameterSquare) {
rectangles += 1;
}
}
}
return rectangles;
}
| int main() {
assert(func0(2) == 8);
assert(func0(1) == 1);
assert(func0(0) == 0);
return 0;
}
| O3 | c | func0:
endbr64
lea (%rdi,%rdi,1),%ecx
mov %ecx,%edi
imul %ecx,%edi
cmp $0x1,%ecx
jle 1286 <func0+0x146>
lea -0x2(%rcx),%eax
lea -0x1(%rcx),%r10d
cmp $0x2,%eax
jbe 128d <func0+0x14d>
movd %edi,%xmm6
mov %r10d,%esi
pxor %xmm2,%xmm2
xor %edx,%edx
movdqa 0xea6(%rip),%xmm5
pshufd $0x0,%xmm6,%xmm7
shr $0x2,%esi
movdqa 0xe85(%rip),%xmm8
movdqa 0xe9c(%rip),%xmm9
pcmpeqd %xmm6,%xmm6
nopl 0x0(%rax,%rax,1)
movdqa %xmm8,%xmm0
movdqa %xmm5,%xmm3
paddd %xmm9,%xmm8
mov $0x1,%eax
movdqa %xmm0,%xmm4
pmuludq %xmm0,%xmm4
psrlq $0x20,%xmm0
pmuludq %xmm0,%xmm0
pshufd $0x8,%xmm4,%xmm4
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
nopw 0x0(%rax,%rax,1)
movdqa %xmm3,%xmm1
add $0x1,%eax
paddd %xmm5,%xmm3
movdqa %xmm1,%xmm0
pmuludq %xmm1,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm1,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
paddd %xmm4,%xmm0
pcmpgtd %xmm7,%xmm0
pandn %xmm6,%xmm0
psubd %xmm0,%xmm2
cmp %eax,%ecx
jne 11d8 <func0+0x98>
add $0x1,%edx
cmp %esi,%edx
jne 11a0 <func0+0x60>
movdqa %xmm2,%xmm0
mov %r10d,%eax
psrldq $0x8,%xmm0
and $0xfffffffc,%eax
paddd %xmm0,%xmm2
lea 0x1(%rax),%r9d
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%r8d
cmp %eax,%r10d
je 1282 <func0+0x142>
nopl 0x0(%rax,%rax,1)
mov %r9d,%esi
mov $0x1,%eax
imul %r9d,%esi
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add %esi,%edx
cmp %edx,%edi
setge %dl
add $0x1,%eax
movzbl %dl,%edx
add %edx,%r8d
cmp %eax,%ecx
jne 1260 <func0+0x120>
add $0x1,%r9d
cmp %r9d,%ecx
jg 1250 <func0+0x110>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
mov $0x1,%r9d
xor %r8d,%r8d
jmp 1250 <func0+0x110>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea esi, [rdi+rdi]
mov r8d, esi
imul r8d, esi
cmp esi, 1
jle loc_127D
lea eax, [rsi-2]
lea r9d, [rsi-1]
cmp eax, 2
jbe loc_1282
movd xmm6, r8d
mov ecx, r9d
pxor xmm3, xmm3
xor edx, edx
movdqa xmm5, cs:xmmword_2010
pshufd xmm7, xmm6, 0
shr ecx, 2
movdqa xmm8, cs:xmmword_2020
movdqa xmm9, cs:xmmword_2030
movdqa xmm6, xmm3
nop dword ptr [rax+rax+00h]
loc_11A0:
movdqa xmm0, xmm8
movdqa xmm2, xmm5
paddd xmm8, xmm9
mov eax, 1
movdqa xmm4, xmm0
pmuludq xmm4, xmm0
psrlq xmm0, 20h ; ' '
pmuludq xmm0, xmm0
pshufd xmm4, xmm4, 8
pshufd xmm0, xmm0, 8
punpckldq xmm4, xmm0
nop word ptr [rax+rax+00h]
loc_11D8:
movdqa xmm1, xmm2
add eax, 1
paddd xmm2, xmm5
movdqa xmm0, xmm1
pmuludq xmm0, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm1, xmm1
pshufd xmm0, xmm0, 8
pshufd xmm1, xmm1, 8
punpckldq xmm0, xmm1
paddd xmm0, xmm4
pcmpgtd xmm0, xmm7
pcmpeqd xmm0, xmm6
psubd xmm3, xmm0
cmp esi, eax
jnz short loc_11D8
add edx, 1
cmp edx, ecx
jnz short loc_11A0
movdqa xmm0, xmm3
and r9d, 0FFFFFFFCh
psrldq xmm0, 8
add r9d, 1
paddd xmm0, xmm3
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd ecx, xmm0
nop dword ptr [rax+rax+00h]
loc_1248:
mov edi, r9d
mov eax, 1
imul edi, r9d
nop dword ptr [rax+00h]
loc_1258:
mov edx, eax
imul edx, eax
add edx, edi
cmp r8d, edx
setnl dl
add eax, 1
movzx edx, dl
add ecx, edx
cmp esi, eax
jnz short loc_1258
add r9d, 1
cmp esi, r9d
jg short loc_1248
mov eax, ecx
retn
loc_127D:
xor ecx, ecx
mov eax, ecx
retn
loc_1282:
mov r9d, 1
xor ecx, ecx
jmp short loc_1248 | long long func0(int a1)
{
int v1; // esi
signed int v2; // r8d
unsigned int v3; // r9d
__m128i v4; // xmm3
int v5; // edx
__m128i si128; // xmm5
__m128i v7; // xmm7
__m128i v8; // xmm8
__m128i v9; // xmm9
__m128i v10; // xmm0
__m128i v11; // xmm2
int v12; // eax
__m128i v13; // xmm4
__m128i v14; // xmm0
__m128i v15; // xmm4
__m128i v16; // xmm1
__m128i v17; // xmm0
__m128i v18; // xmm1
signed int v19; // r9d
__m128i v20; // xmm0
unsigned int v21; // ecx
int v22; // eax
bool v23; // dl
v1 = 2 * a1;
v2 = v1 * v1;
if ( 2 * a1 <= 1 )
return 0LL;
v3 = v1 - 1;
if ( (unsigned int)(v1 - 2) <= 2 )
{
v19 = 1;
v21 = 0;
}
else
{
v4 = 0LL;
v5 = 0;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v7 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v2), 0);
v8 = _mm_load_si128((const __m128i *)&xmmword_2020);
v9 = _mm_load_si128((const __m128i *)&xmmword_2030);
do
{
v10 = v8;
v11 = si128;
v8 = _mm_add_epi32(v8, v9);
v12 = 1;
v13 = _mm_mul_epu32(v10, v10);
v14 = _mm_srli_epi64(v10, 0x20u);
v15 = _mm_unpacklo_epi32(_mm_shuffle_epi32(v13, 8), _mm_shuffle_epi32(_mm_mul_epu32(v14, v14), 8));
do
{
v16 = v11;
++v12;
v11 = _mm_add_epi32(v11, si128);
v17 = _mm_mul_epu32(v16, v16);
v18 = _mm_srli_epi64(v16, 0x20u);
v4 = _mm_sub_epi32(
v4,
_mm_cmpeq_epi32(
_mm_cmpgt_epi32(
_mm_add_epi32(
_mm_unpacklo_epi32(_mm_shuffle_epi32(v17, 8), _mm_shuffle_epi32(_mm_mul_epu32(v18, v18), 8)),
v15),
v7),
(__m128i)0LL));
}
while ( v1 != v12 );
++v5;
}
while ( v5 != v3 >> 2 );
v19 = (v3 & 0xFFFFFFFC) + 1;
v20 = _mm_add_epi32(_mm_srli_si128(v4, 8), v4);
v21 = _mm_cvtsi128_si32(_mm_add_epi32(v20, _mm_srli_si128(v20, 4)));
}
do
{
v22 = 1;
do
{
v23 = v2 >= v19 * v19 + v22 * v22;
++v22;
v21 += v23;
}
while ( v1 != v22 );
++v19;
}
while ( v1 > v19 );
return v21;
} | func0:
ENDBR64
LEA ESI,[RDI + RDI*0x1]
MOV R8D,ESI
IMUL R8D,ESI
CMP ESI,0x1
JLE 0x0010127d
LEA EAX,[RSI + -0x2]
LEA R9D,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101282
MOVD XMM6,R8D
MOV ECX,R9D
PXOR XMM3,XMM3
XOR EDX,EDX
MOVDQA XMM5,xmmword ptr [0x00102010]
PSHUFD XMM7,XMM6,0x0
SHR ECX,0x2
MOVDQA XMM8,xmmword ptr [0x00102020]
MOVDQA XMM9,xmmword ptr [0x00102030]
MOVDQA XMM6,XMM3
NOP dword ptr [RAX + RAX*0x1]
LAB_001011a0:
MOVDQA XMM0,XMM8
MOVDQA XMM2,XMM5
PADDD XMM8,XMM9
MOV EAX,0x1
MOVDQA XMM4,XMM0
PMULUDQ XMM4,XMM0
PSRLQ XMM0,0x20
PMULUDQ XMM0,XMM0
PSHUFD XMM4,XMM4,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM4,XMM0
NOP word ptr [RAX + RAX*0x1]
LAB_001011d8:
MOVDQA XMM1,XMM2
ADD EAX,0x1
PADDD XMM2,XMM5
MOVDQA XMM0,XMM1
PMULUDQ XMM0,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM1,XMM1
PSHUFD XMM0,XMM0,0x8
PSHUFD XMM1,XMM1,0x8
PUNPCKLDQ XMM0,XMM1
PADDD XMM0,XMM4
PCMPGTD XMM0,XMM7
PCMPEQD XMM0,XMM6
PSUBD XMM3,XMM0
CMP ESI,EAX
JNZ 0x001011d8
ADD EDX,0x1
CMP EDX,ECX
JNZ 0x001011a0
MOVDQA XMM0,XMM3
AND R9D,0xfffffffc
PSRLDQ XMM0,0x8
ADD R9D,0x1
PADDD XMM0,XMM3
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD ECX,XMM0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101248:
MOV EDI,R9D
MOV EAX,0x1
IMUL EDI,R9D
NOP dword ptr [RAX]
LAB_00101258:
MOV EDX,EAX
IMUL EDX,EAX
ADD EDX,EDI
CMP R8D,EDX
SETGE DL
ADD EAX,0x1
MOVZX EDX,DL
ADD ECX,EDX
CMP ESI,EAX
JNZ 0x00101258
ADD R9D,0x1
CMP ESI,R9D
JG 0x00101248
MOV EAX,ECX
RET
LAB_0010127d:
XOR ECX,ECX
MOV EAX,ECX
RET
LAB_00101282:
MOV R9D,0x1
XOR ECX,ECX
JMP 0x00101248 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1)
{
int iVar1;
uint uVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
int auVar7 [16];
int auVar8 [16];
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int auVar15 [16];
int auVar16 [16];
int iVar6;
int iVar9;
int iVar14;
int iVar17;
param_1 = param_1 * 2;
iVar3 = param_1 * param_1;
if (1 < param_1) {
if (param_1 - 2U < 3) {
iVar1 = 1;
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
uVar2 = 0;
auVar15 = _DAT_00102020;
do {
iVar14 = auVar15._0_4_;
auVar16._0_4_ = iVar14 + _DAT_00102030;
iVar17 = auVar15._4_4_;
auVar16._4_4_ = iVar17 + _UNK_00102034;
auVar16._8_4_ = auVar15._8_4_ + _UNK_00102038;
auVar16._12_4_ = auVar15._12_4_ + _UNK_0010203c;
iVar1 = 1;
uVar4 = auVar15._8_8_ >> 0x20;
auVar7 = _DAT_00102010;
do {
iVar1 = iVar1 + 1;
iVar6 = auVar7._0_4_;
auVar8._0_4_ = iVar6 + SUB164(_DAT_00102010,0);
iVar9 = auVar7._4_4_;
auVar8._4_4_ = iVar9 + SUB164(_DAT_00102010,4);
auVar8._8_4_ = auVar7._8_4_ + SUB164(_DAT_00102010,8);
auVar8._12_4_ = auVar7._12_4_ + SUB164(_DAT_00102010,0xc);
uVar5 = auVar7._8_8_ >> 0x20;
iVar10 = iVar10 + (uint)(iVar6 * iVar6 + iVar14 * iVar14 <= iVar3);
iVar11 = iVar11 + (uint)(iVar9 * iVar9 + iVar17 * iVar17 <= iVar3);
iVar12 = iVar12 + (uint)((int)((auVar7._8_8_ & 0xffffffff) * (ulong)auVar7._8_4_) +
(int)((auVar15._8_8_ & 0xffffffff) * (ulong)auVar15._8_4_) <=
iVar3);
iVar13 = iVar13 + (uint)((int)(uVar5 * uVar5) + (int)(uVar4 * uVar4) <= iVar3);
auVar7 = auVar8;
} while (param_1 != iVar1);
uVar2 = uVar2 + 1;
auVar15 = auVar16;
} while (uVar2 != param_1 - 1U >> 2);
iVar1 = (param_1 - 1U & 0xfffffffc) + 1;
iVar10 = iVar12 + iVar10 + iVar13 + iVar11;
}
do {
iVar11 = 1;
do {
iVar12 = iVar11 * iVar11;
iVar11 = iVar11 + 1;
iVar10 = iVar10 + (uint)(iVar12 + iVar1 * iVar1 <= iVar3);
} while (param_1 != iVar11);
iVar1 = iVar1 + 1;
} while (iVar1 < param_1);
return iVar10;
}
return 0;
} |
5,316 | func0 | #include <assert.h>
| int func0(int a, int b) {
int c = 180 - (a + b);
return c;
}
| int main() {
assert(func0(47, 89) == 44);
assert(func0(45, 95) == 40);
assert(func0(50, 40) == 90);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
mov $0xb4,%edx
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add edx, eax
mov eax, 0B4h
sub eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(180 - (a2 + a1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EDX,EAX
MOV EAX,0xb4
SUB EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2)
{
return 0xb4 - (param_1 + param_2);
} |
5,317 | func0 | #include <assert.h>
| int func0(int a, int b) {
int c = 180 - (a + b);
return c;
}
| int main() {
assert(func0(47, 89) == 44);
assert(func0(45, 95) == 40);
assert(func0(50, 40) == 90);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
mov $0xb4,%eax
sub %edi,%eax
retq
| func0:
endbr64
add edi, esi
mov eax, 0B4h
sub eax, edi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(180 - (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
MOV EAX,0xb4
SUB EAX,EDI
RET | int func0(int param_1,int param_2)
{
return 0xb4 - (param_1 + param_2);
} |
5,318 | func0 | #include <assert.h>
| int func0(int a, int b) {
int c = 180 - (a + b);
return c;
}
| int main() {
assert(func0(47, 89) == 44);
assert(func0(45, 95) == 40);
assert(func0(50, 40) == 90);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
mov $0xb4,%eax
sub %edi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
add edi, esi
mov eax, 0B4h
sub eax, edi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(180 - (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
MOV EAX,0xb4
SUB EAX,EDI
RET | int func0(int param_1,int param_2)
{
return 0xb4 - (param_1 + param_2);
} |
5,319 | func0 | #include <assert.h>
| int func0(int a, int b) {
int c = 180 - (a + b);
return c;
}
| int main() {
assert(func0(47, 89) == 44);
assert(func0(45, 95) == 40);
assert(func0(50, 40) == 90);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
mov $0xb4,%eax
sub %edi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
add edi, esi
mov eax, 0B4h
sub eax, edi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(180 - (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
MOV EAX,0xb4
SUB EAX,EDI
RET | int func0(int param_1,int param_2)
{
return 0xb4 - (param_1 + param_2);
} |
5,320 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][2], int n) {
int res = test_list[0][0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (test_list[i][j] > res) {
res = test_list[i][j];
}
}
}
return res;
}
| int main() {
int list1[5][2] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}, {8, 7}};
int list2[5][2] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}, {9, 8}};
int list3[5][2] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}, {10, 9}};
assert(func0(list1, 5) == 10);
assert(func0(list2, 5) == 11);
assert(func0(list3, 5) == 12);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e1 <func0+0x78>
movl $0x0,-0x4(%rbp)
jmp 11d7 <func0+0x6e>
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),%eax
cmp %eax,-0xc(%rbp)
jge 11d3 <func0+0x6a>
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),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jle 1193 <func0+0x2a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118a <func0+0x21>
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 eax, [rax]
mov [rbp+var_C], eax
mov [rbp+var_8], 0
jmp short loc_11E1
loc_118A:
mov [rbp+var_4], 0
jmp short loc_11D7
loc_1193:
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 eax, [rdx+rax*4]
cmp [rbp+var_C], eax
jge short loc_11D3
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 eax, [rdx+rax*4]
mov [rbp+var_C], eax
loc_11D3:
add [rbp+var_4], 1
loc_11D7:
cmp [rbp+var_4], 1
jle short loc_1193
add [rbp+var_8], 1
loc_11E1:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_118A
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = *a1;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j <= 1; ++j )
{
if ( (int)v3 < (int)a1[2 * i + j] )
v3 = a1[2 * i + j];
}
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011e1
LAB_0010118a:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d7
LAB_00101193:
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 EAX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RBP + -0xc],EAX
JGE 0x001011d3
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 EAX,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011d3:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d7:
CMP dword ptr [RBP + -0x4],0x1
JLE 0x00101193
ADD dword ptr [RBP + -0x8],0x1
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118a
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int *param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = *param_1;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
for (local_c = 0; local_c < 2; local_c = local_c + 1) {
if (local_14 < param_1[(long)local_10 * 2 + (long)local_c]) {
local_14 = param_1[(long)local_10 * 2 + (long)local_c];
}
}
}
return local_14;
} |
5,321 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][2], int n) {
int res = test_list[0][0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (test_list[i][j] > res) {
res = test_list[i][j];
}
}
}
return res;
}
| int main() {
int list1[5][2] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}, {8, 7}};
int list2[5][2] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}, {9, 8}};
int list3[5][2] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}, {10, 9}};
assert(func0(list1, 5) == 10);
assert(func0(list2, 5) == 11);
assert(func0(list3, 5) == 12);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%ecx
test %esi,%esi
jle 1195 <func0+0x2c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x8(%rdi,%rdx,8),%rsi
mov (%rax),%edx
cmp %edx,0x4(%rax)
cmovge 0x4(%rax),%edx
cmp %edx,%ecx
cmovl %edx,%ecx
add $0x8,%rax
cmp %rsi,%rax
jne 117e <func0+0x15>
mov %ecx,%eax
retq
| func0:
endbr64
mov ecx, [rdi]
test esi, esi
jle short loc_1196
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*8+8]
loc_117E:
mov eax, [rdx+4]
mov esi, [rdx]
cmp eax, esi
cmovl eax, esi
cmp ecx, eax
cmovl ecx, eax
add rdx, 8
cmp rdx, rdi
jnz short loc_117E
loc_1196:
mov eax, ecx
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // ecx
int *v3; // rdx
long long v4; // rdi
int v5; // eax
v2 = *a1;
if ( a2 > 0 )
{
v3 = (int *)a1;
v4 = (long long)&a1[2 * (a2 - 1) + 2];
do
{
v5 = v3[1];
if ( v5 < *v3 )
v5 = *v3;
if ( (int)v2 < v5 )
v2 = v5;
v3 += 2;
}
while ( v3 != (int *)v4 );
}
return v2;
} | func0:
ENDBR64
MOV ECX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x00101196
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x8 + 0x8]
LAB_0010117e:
MOV EAX,dword ptr [RDX + 0x4]
MOV ESI,dword ptr [RDX]
CMP EAX,ESI
CMOVL EAX,ESI
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x8
CMP RDX,RDI
JNZ 0x0010117e
LAB_00101196:
MOV EAX,ECX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
iVar3 = *param_1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
iVar2 = param_1[1];
if (param_1[1] < *param_1) {
iVar2 = *param_1;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
}
return iVar3;
} |
5,322 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][2], int n) {
int res = test_list[0][0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (test_list[i][j] > res) {
res = test_list[i][j];
}
}
}
return res;
}
| int main() {
int list1[5][2] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}, {8, 7}};
int list2[5][2] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}, {9, 8}};
int list3[5][2] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}, {10, 9}};
assert(func0(list1, 5) == 10);
assert(func0(list2, 5) == 11);
assert(func0(list3, 5) == 12);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%eax
test %esi,%esi
jle 13e6 <func0+0x36>
lea -0x1(%rsi),%ecx
lea 0x4(%rdi),%rdx
lea 0xc(%rdi,%rcx,8),%rsi
mov %eax,%ecx
jmp 13d3 <func0+0x23>
nopw 0x0(%rax,%rax,1)
mov -0x4(%rdx),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
cmp %eax,(%rdx)
cmovge (%rdx),%eax
add $0x8,%rdx
cmp %rsi,%rdx
jne 13d0 <func0+0x20>
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, [rdi]
test esi, esi
jle short locret_1368
lea ecx, [rsi-1]
lea rdx, [rdi+4]
lea rsi, [rdi+rcx*8+0Ch]
mov ecx, eax
jmp short loc_1353
loc_1350:
mov ecx, [rdx-4]
loc_1353:
cmp eax, ecx
cmovl eax, ecx
mov ecx, [rdx]
cmp eax, ecx
cmovl eax, ecx
add rdx, 8
cmp rdx, rsi
jnz short loc_1350
locret_1368:
retn | long long func0(int *a1, int a2)
{
long long result; // rax
_DWORD *v3; // rdx
long long v4; // rsi
int i; // ecx
result = (unsigned int)*a1;
if ( a2 > 0 )
{
v3 = a1 + 1;
v4 = (long long)&a1[2 * (a2 - 1) + 3];
for ( i = *a1; ; i = *(v3 - 1) )
{
if ( (int)result < i )
result = (unsigned int)i;
if ( (int)result < *v3 )
result = (unsigned int)*v3;
v3 += 2;
if ( v3 == (_DWORD *)v4 )
break;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x00101368
LEA ECX,[RSI + -0x1]
LEA RDX,[RDI + 0x4]
LEA RSI,[RDI + RCX*0x8 + 0xc]
MOV ECX,EAX
JMP 0x00101353
LAB_00101350:
MOV ECX,dword ptr [RDX + -0x4]
LAB_00101353:
CMP EAX,ECX
CMOVL EAX,ECX
MOV ECX,dword ptr [RDX]
CMP EAX,ECX
CMOVL EAX,ECX
ADD RDX,0x8
CMP RDX,RSI
JNZ 0x00101350
LAB_00101368:
RET | void func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
iVar1 = *param_1;
if (0 < param_2) {
piVar3 = param_1 + 1;
iVar2 = iVar1;
while( true ) {
if (iVar1 < iVar2) {
iVar1 = iVar2;
}
if (iVar1 < *piVar3) {
iVar1 = *piVar3;
}
if (piVar3 + 2 == param_1 + (ulong)(param_2 - 1) * 2 + 3) break;
iVar2 = piVar3[1];
piVar3 = piVar3 + 2;
}
}
return;
} |
5,323 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][2], int n) {
int res = test_list[0][0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (test_list[i][j] > res) {
res = test_list[i][j];
}
}
}
return res;
}
| int main() {
int list1[5][2] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}, {8, 7}};
int list2[5][2] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}, {9, 8}};
int list3[5][2] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}, {10, 9}};
assert(func0(list1, 5) == 10);
assert(func0(list2, 5) == 11);
assert(func0(list3, 5) == 12);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%eax
test %esi,%esi
jle 125c <func0+0x11c>
lea -0x1(%rsi),%edx
cmp $0x2,%edx
jbe 125e <func0+0x11e>
mov %esi,%edx
movd %eax,%xmm6
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm6,%xmm3
shl $0x5,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
movdqu 0x10(%rax),%xmm4
add $0x20,%rax
movdqa %xmm2,%xmm0
shufps $0xdd,%xmm4,%xmm2
shufps $0x88,%xmm4,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
movdqa %xmm1,%xmm3
por %xmm0,%xmm3
cmp %rdx,%rax
jne 1178 <func0+0x38>
movdqa %xmm3,%xmm0
mov %esi,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 125d <func0+0x11d>
movslq %edx,%rcx
lea (%rdi,%rcx,8),%r8
mov 0x4(%r8),%ecx
cmp %ecx,(%r8)
cmovge (%r8),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 125c <func0+0x11c>
movslq %ecx,%rcx
lea (%rdi,%rcx,8),%r8
mov 0x4(%r8),%ecx
cmp %ecx,(%r8)
cmovge (%r8),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x2,%edx
cmp %edx,%esi
jle 125c <func0+0x11c>
movslq %edx,%rdx
lea (%rdi,%rdx,8),%rcx
mov (%rcx),%edx
cmp %edx,0x4(%rcx)
cmovge 0x4(%rcx),%edx
cmp %edx,%eax
cmovl %edx,%eax
retq
retq
xor %edx,%edx
jmp 120b <func0+0xcb>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, [rdi]
mov ecx, esi
test esi, esi
jle locret_1262
lea edx, [rsi-1]
cmp edx, 2
jbe loc_1264
mov edx, esi
movd xmm6, eax
mov rax, rdi
shr edx, 2
pshufd xmm3, xmm6, 0
shl rdx, 5
add rdx, rdi
nop dword ptr [rax+00h]
loc_1178:
movdqu xmm1, xmmword ptr [rax]
movdqu xmm4, xmmword ptr [rax+10h]
add rax, 20h ; ' '
movdqa xmm2, xmm1
shufps xmm1, xmm4, 0DDh
shufps xmm2, xmm4, 88h
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm3
pand xmm0, xmm1
pandn xmm1, xmm3
movdqa xmm3, xmm1
por xmm3, xmm0
cmp rdx, rax
jnz short loc_1178
movdqa xmm1, xmm3
mov esi, ecx
psrldq xmm1, 8
and esi, 0FFFFFFFCh
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm3
pand xmm1, xmm0
pandn xmm0, xmm3
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
test cl, 3
jz short locret_1263
loc_120A:
movsxd r8, esi
shl r8, 3
lea r9, [rdi+r8]
mov edx, [r9]
mov r9d, [r9+4]
cmp edx, r9d
cmovl edx, r9d
cmp eax, edx
cmovl eax, edx
lea edx, [rsi+1]
cmp ecx, edx
jle short locret_1262
lea r9, [rdi+r8+8]
mov edx, [r9]
mov r9d, [r9+4]
cmp edx, r9d
cmovl edx, r9d
cmp eax, edx
cmovl eax, edx
add esi, 2
cmp ecx, esi
jle short locret_1262
lea rcx, [rdi+r8+10h]
mov edx, [rcx+4]
mov ecx, [rcx]
cmp edx, ecx
cmovl edx, ecx
cmp eax, edx
cmovl eax, edx
locret_1262:
retn
locret_1263:
retn
loc_1264:
xor esi, esi
jmp short loc_120A | long long func0(const __m128i *a1, int a2)
{
long long result; // rax
__m128i v4; // xmm6
const __m128i *v5; // rax
__m128i v6; // xmm3
__m128 v7; // xmm1
__m128 v8; // xmm4
__m128 v9; // xmm2
__m128i v10; // xmm1
__m128i v11; // xmm2
__m128i v12; // xmm0
__m128i v13; // xmm0
__m128i v14; // xmm1
__m128i v15; // xmm1
signed int v16; // esi
__m128i v17; // xmm0
__m128i v18; // xmm0
__m128i v19; // xmm2
__m128i v20; // xmm1
long long v21; // r8
int v22; // edx
int v23; // edx
int v24; // edx
result = a1->m128i_u32[0];
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v16 = 0;
}
else
{
v4 = _mm_cvtsi32_si128(result);
v5 = a1;
v6 = _mm_shuffle_epi32(v4, 0);
do
{
v7 = (__m128)_mm_loadu_si128(v5);
v8 = (__m128)_mm_loadu_si128(v5 + 1);
v5 += 2;
v9 = v7;
v10 = (__m128i)_mm_shuffle_ps(v7, v8, 221);
v11 = (__m128i)_mm_shuffle_ps(v9, v8, 136);
v12 = _mm_cmpgt_epi32(v11, v10);
v13 = _mm_or_si128(_mm_andnot_si128(v12, v10), _mm_and_si128(v11, v12));
v14 = _mm_cmpgt_epi32(v13, v6);
v6 = _mm_or_si128(_mm_andnot_si128(v14, v6), _mm_and_si128(v13, v14));
}
while ( &a1[2 * ((unsigned int)a2 >> 2)] != v5 );
v15 = _mm_srli_si128(v6, 8);
v16 = a2 & 0xFFFFFFFC;
v17 = _mm_cmpgt_epi32(v15, v6);
v18 = _mm_or_si128(_mm_andnot_si128(v17, v6), _mm_and_si128(v15, v17));
v19 = _mm_srli_si128(v18, 4);
v20 = _mm_cmpgt_epi32(v19, v18);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v20, v18), _mm_and_si128(v19, v20)));
if ( (a2 & 3) == 0 )
return result;
}
v21 = 2LL * v16;
v22 = a1->m128i_i32[v21];
if ( v22 < a1->m128i_i32[v21 + 1] )
v22 = a1->m128i_i32[v21 + 1];
if ( (int)result < v22 )
result = (unsigned int)v22;
if ( a2 > v16 + 1 )
{
v23 = a1->m128i_i32[v21 + 2];
if ( v23 < a1->m128i_i32[v21 + 3] )
v23 = a1->m128i_i32[v21 + 3];
if ( (int)result < v23 )
result = (unsigned int)v23;
if ( a2 > v16 + 2 )
{
v24 = a1[1].m128i_i32[v21 + 1];
if ( v24 < a1[1].m128i_i32[v21] )
v24 = a1[1].m128i_i32[v21];
if ( (int)result < v24 )
return (unsigned int)v24;
}
}
}
return result;
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101262
LEA EDX,[RSI + -0x1]
CMP EDX,0x2
JBE 0x00101264
MOV EDX,ESI
MOVD XMM6,EAX
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM3,XMM6,0x0
SHL RDX,0x5
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM4,xmmword ptr [RAX + 0x10]
ADD RAX,0x20
MOVDQA XMM2,XMM1
SHUFPS XMM1,XMM4,0xdd
SHUFPS XMM2,XMM4,0x88
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM3
PAND XMM0,XMM1
PANDN XMM1,XMM3
MOVDQA XMM3,XMM1
POR XMM3,XMM0
CMP RDX,RAX
JNZ 0x00101178
MOVDQA XMM1,XMM3
MOV ESI,ECX
PSRLDQ XMM1,0x8
AND ESI,0xfffffffc
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM3
PAND XMM1,XMM0
PANDN XMM0,XMM3
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
TEST CL,0x3
JZ 0x00101263
LAB_0010120a:
MOVSXD R8,ESI
SHL R8,0x3
LEA R9,[RDI + R8*0x1]
MOV EDX,dword ptr [R9]
MOV R9D,dword ptr [R9 + 0x4]
CMP EDX,R9D
CMOVL EDX,R9D
CMP EAX,EDX
CMOVL EAX,EDX
LEA EDX,[RSI + 0x1]
CMP ECX,EDX
JLE 0x00101262
LEA R9,[RDI + R8*0x1 + 0x8]
MOV EDX,dword ptr [R9]
MOV R9D,dword ptr [R9 + 0x4]
CMP EDX,R9D
CMOVL EDX,R9D
CMP EAX,EDX
CMOVL EAX,EDX
ADD ESI,0x2
CMP ECX,ESI
JLE 0x00101262
LEA RCX,[RDI + R8*0x1 + 0x10]
MOV EDX,dword ptr [RCX + 0x4]
MOV ECX,dword ptr [RCX]
CMP EDX,ECX
CMOVL EDX,ECX
CMP EAX,EDX
CMOVL EAX,EDX
LAB_00101262:
RET
LAB_00101263:
RET
LAB_00101264:
XOR ESI,ESI
JMP 0x0010120a | uint func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint uVar8;
uint *puVar9;
uint uVar10;
uint uVar11;
long lVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uVar8 = *param_1;
if (0 < (int)param_2) {
if (param_2 - 1 < 3) {
uVar11 = 0;
}
else {
puVar9 = param_1;
uVar10 = uVar8;
uVar17 = uVar8;
uVar21 = uVar8;
do {
uVar11 = *puVar9;
puVar2 = puVar9 + 1;
puVar3 = puVar9 + 2;
puVar4 = puVar9 + 3;
puVar1 = puVar9 + 4;
puVar5 = puVar9 + 5;
puVar6 = puVar9 + 6;
puVar7 = puVar9 + 7;
puVar9 = puVar9 + 8;
uVar13 = -(uint)((int)*puVar2 < (int)uVar11);
uVar14 = -(uint)((int)*puVar4 < (int)*puVar3);
uVar15 = -(uint)((int)*puVar5 < (int)*puVar1);
uVar16 = -(uint)((int)*puVar7 < (int)*puVar6);
uVar11 = ~uVar13 & *puVar2 | uVar11 & uVar13;
uVar13 = ~uVar14 & *puVar4 | *puVar3 & uVar14;
uVar14 = ~uVar15 & *puVar5 | *puVar1 & uVar15;
uVar15 = ~uVar16 & *puVar7 | *puVar6 & uVar16;
uVar16 = -(uint)((int)uVar8 < (int)uVar11);
uVar18 = -(uint)((int)uVar10 < (int)uVar13);
uVar19 = -(uint)((int)uVar17 < (int)uVar14);
uVar20 = -(uint)((int)uVar21 < (int)uVar15);
uVar8 = ~uVar16 & uVar8 | uVar11 & uVar16;
uVar10 = ~uVar18 & uVar10 | uVar13 & uVar18;
uVar17 = ~uVar19 & uVar17 | uVar14 & uVar19;
uVar21 = ~uVar20 & uVar21 | uVar15 & uVar20;
} while (param_1 + (ulong)(param_2 >> 2) * 8 != puVar9);
uVar11 = param_2 & 0xfffffffc;
uVar8 = ~-(uint)((int)uVar8 < (int)uVar17) & uVar8 |
uVar17 & -(uint)((int)uVar8 < (int)uVar17);
uVar10 = ~-(uint)((int)uVar10 < (int)uVar21) & uVar10 |
uVar21 & -(uint)((int)uVar10 < (int)uVar21);
uVar17 = -(uint)((int)uVar8 < (int)uVar10);
uVar8 = ~uVar17 & uVar8 | uVar10 & uVar17;
if ((param_2 & 3) == 0) {
return uVar8;
}
}
lVar12 = (long)(int)uVar11;
uVar10 = param_1[lVar12 * 2];
uVar17 = (param_1 + lVar12 * 2)[1];
if ((int)uVar10 < (int)uVar17) {
uVar10 = uVar17;
}
if ((int)uVar8 < (int)uVar10) {
uVar8 = uVar10;
}
if ((int)(uVar11 + 1) < (int)param_2) {
uVar10 = param_1[lVar12 * 2 + 2];
uVar17 = (param_1 + lVar12 * 2 + 2)[1];
if ((int)uVar10 < (int)uVar17) {
uVar10 = uVar17;
}
if ((int)uVar8 < (int)uVar10) {
uVar8 = uVar10;
}
if ((int)(uVar11 + 2) < (int)param_2) {
uVar11 = (param_1 + lVar12 * 2 + 4)[1];
uVar10 = param_1[lVar12 * 2 + 4];
if ((int)uVar11 < (int)uVar10) {
uVar11 = uVar10;
}
if ((int)uVar8 < (int)uVar11) {
uVar8 = uVar11;
}
}
}
}
return uVar8;
} |
5,324 | func0 |
#include <assert.h>
#include <stdlib.h>
| int *func0(int *nums1, int *nums2, int size) {
int *result = malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
result[i] = nums1[i] % nums2[i];
}
return result;
}
| int main() {
int nums1_1[] = {4, 5, 6};
int nums2_1[] = {1, 2, 3};
int *result1 = func0(nums1_1, nums2_1, 3);
assert(result1[0] == 0 && result1[1] == 1 && result1[2] == 0);
free(result1);
int nums1_2[] = {3, 2};
int nums2_2[] = {1, 4};
int *result2 = func0(nums1_2, nums2_2, 2);
assert(result2[0] == 0 && result2[1] == 2);
free(result2);
int nums1_3[] = {90, 120};
int nums2_3[] = {50, 70};
int *result3 = func0(nums1_3, nums2_3, 2);
assert(result3[0] == 40 && result3[1] == 50);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 122b <func0+0x82>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%esi
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rdx,%rcx
cltd
idiv %esi
mov %edx,%eax
mov %eax,(%rcx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11de <func0+0x35>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_122D
loc_11DE:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_20]
add rdx, rcx
mov edi, [rdx]
mov ecx, [rbp+var_C]
movsxd rcx, ecx
lea rsi, ds:0[rcx*4]
mov rcx, [rbp+var_8]
add rcx, rsi
cdq
idiv edi
mov esi, edx
mov eax, esi
mov [rcx], eax
add [rbp+var_C], 1
loc_122D:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
jl short loc_11DE
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, long long a2, int a3)
{
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v6; // [rsp+28h] [rbp-8h]
v6 = malloc(4LL * a3);
for ( i = 0; i < a3; ++i )
v6[i] = *(_DWORD *)(4LL * i + a1) % *(_DWORD *)(4LL * i + a2);
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010122d
LAB_001011de:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV EDI,dword ptr [RDX]
MOV ECX,dword ptr [RBP + -0xc]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x4]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,RSI
CDQ
IDIV EDI
MOV ESI,EDX
MOV EAX,ESI
MOV dword ptr [RCX],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010122d:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011de
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_3 << 2);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
*(int *)((long)pvVar1 + (long)local_14 * 4) =
*(int *)(param_1 + (long)local_14 * 4) % *(int *)(param_2 + (long)local_14 * 4);
}
return pvVar1;
} |
5,325 | func0 |
#include <assert.h>
#include <stdlib.h>
| int *func0(int *nums1, int *nums2, int size) {
int *result = malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
result[i] = nums1[i] % nums2[i];
}
return result;
}
| int main() {
int nums1_1[] = {4, 5, 6};
int nums2_1[] = {1, 2, 3};
int *result1 = func0(nums1_1, nums2_1, 3);
assert(result1[0] == 0 && result1[1] == 1 && result1[2] == 0);
free(result1);
int nums1_2[] = {3, 2};
int nums2_2[] = {1, 4};
int *result2 = func0(nums1_2, nums2_2, 2);
assert(result2[0] == 0 && result2[1] == 2);
free(result2);
int nums1_3[] = {90, 120};
int nums2_3[] = {50, 70};
int *result3 = func0(nums1_3, nums2_3, 2);
assert(result3[0] == 40 && result3[1] == 50);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%rbx
mov %edx,%r12d
movslq %edx,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rsi
test %r12d,%r12d
jle 11ef <func0+0x46>
lea -0x1(%r12),%edi
mov $0x0,%ecx
mov 0x0(%rbp,%rcx,4),%eax
cltd
idivl (%rbx,%rcx,4)
mov %edx,(%rsi,%rcx,4)
mov %rcx,%rax
add $0x1,%rcx
cmp %rdi,%rax
jne 11d8 <func0+0x2f>
mov %rsi,%rax
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov rbx, rsi
mov r12d, edx
movsxd rdi, edx
shl rdi, 2
call _malloc
mov rdi, rax
test r12d, r12d
jle short loc_11EA
mov esi, r12d
mov ecx, 0
loc_11D6:
mov eax, [rbp+rcx*4+0]
cdq
idiv dword ptr [rbx+rcx*4]
mov [rdi+rcx*4], edx
add rcx, 1
cmp rcx, rsi
jnz short loc_11D6
loc_11EA:
mov rax, rdi
pop rbx
pop rbp
pop r12
retn | long long func0(long long a1, long long a2, int a3)
{
long long v5; // rdi
long long v6; // rcx
v5 = malloc(4LL * a3);
if ( a3 > 0 )
{
v6 = 0LL;
do
{
*(_DWORD *)(v5 + 4 * v6) = *(_DWORD *)(a1 + 4 * v6) % *(_DWORD *)(a2 + 4 * v6);
++v6;
}
while ( v6 != a3 );
}
return v5;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV RBX,RSI
MOV R12D,EDX
MOVSXD RDI,EDX
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST R12D,R12D
JLE 0x001011ea
MOV ESI,R12D
MOV ECX,0x0
LAB_001011d6:
MOV EAX,dword ptr [RBP + RCX*0x4]
CDQ
IDIV dword ptr [RBX + RCX*0x4]
MOV dword ptr [RDI + RCX*0x4],EDX
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001011d6
LAB_001011ea:
MOV RAX,RDI
POP RBX
POP RBP
POP R12
RET | void * func0(long param_1,long param_2,uint param_3)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)(int)param_3 << 2);
if (0 < (int)param_3) {
uVar2 = 0;
do {
*(int *)((long)pvVar1 + uVar2 * 4) =
*(int *)(param_1 + uVar2 * 4) % *(int *)(param_2 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_3);
}
return pvVar1;
} |
5,326 | func0 |
#include <assert.h>
#include <stdlib.h>
| int *func0(int *nums1, int *nums2, int size) {
int *result = malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
result[i] = nums1[i] % nums2[i];
}
return result;
}
| int main() {
int nums1_1[] = {4, 5, 6};
int nums2_1[] = {1, 2, 3};
int *result1 = func0(nums1_1, nums2_1, 3);
assert(result1[0] == 0 && result1[1] == 1 && result1[2] == 0);
free(result1);
int nums1_2[] = {3, 2};
int nums2_2[] = {1, 4};
int *result2 = func0(nums1_2, nums2_2, 2);
assert(result2[0] == 0 && result2[1] == 2);
free(result2);
int nums1_3[] = {90, 120};
int nums2_3[] = {50, 70};
int *result3 = func0(nums1_3, nums2_3, 2);
assert(result3[0] == 40 && result3[1] == 50);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %edx,%rdi
push %rbx
mov %rdi,%r12
shl $0x2,%rdi
mov %rsi,%rbx
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 1388 <func0+0x48>
lea -0x1(%r12),%esi
xor %ecx,%ecx
nopl 0x0(%rax)
mov 0x0(%rbp,%rcx,4),%eax
cltd
idivl (%rbx,%rcx,4)
mov %rcx,%rax
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %rsi,%rax
jne 1370 <func0+0x30>
pop %rbx
mov %r8,%rax
pop %rbp
pop %r12
retq
| func0:
endbr64
push r13
push r12
movsxd r12, edx
push rbp
mov rbp, rdi
lea rdi, ds:0[r12*4]
push rbx
mov rbx, rsi
sub rsp, 8
call _malloc
mov r8, rax
test r12d, r12d
jle short loc_1385
xor ecx, ecx
xchg ax, ax
loc_1370:
mov eax, [rbp+rcx*4+0]
cdq
idiv dword ptr [rbx+rcx*4]
mov [r8+rcx*4], edx
add rcx, 1
cmp r12, rcx
jnz short loc_1370
loc_1385:
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r12
long long v4; // r8
long long i; // rcx
v3 = a3;
v4 = malloc(4LL * a3);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
*(_DWORD *)(v4 + 4 * i) = *(_DWORD *)(a1 + 4 * i) % *(_DWORD *)(a2 + 4 * i);
}
return v4;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
MOV RBP,RDI
LEA RDI,[R12*0x4]
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R12D,R12D
JLE 0x00101385
XOR ECX,ECX
NOP
LAB_00101370:
MOV EAX,dword ptr [RBP + RCX*0x4]
CDQ
IDIV dword ptr [RBX + RCX*0x4]
MOV dword ptr [R8 + RCX*0x4],EDX
ADD RCX,0x1
CMP R12,RCX
JNZ 0x00101370
LAB_00101385:
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
long lVar2;
pvVar1 = malloc((long)param_3 * 4);
if (0 < param_3) {
lVar2 = 0;
do {
*(int *)((long)pvVar1 + lVar2 * 4) =
*(int *)(param_1 + lVar2 * 4) % *(int *)(param_2 + lVar2 * 4);
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return pvVar1;
} |
5,327 | func0 |
#include <assert.h>
#include <stdlib.h>
| int *func0(int *nums1, int *nums2, int size) {
int *result = malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
result[i] = nums1[i] % nums2[i];
}
return result;
}
| int main() {
int nums1_1[] = {4, 5, 6};
int nums2_1[] = {1, 2, 3};
int *result1 = func0(nums1_1, nums2_1, 3);
assert(result1[0] == 0 && result1[1] == 1 && result1[2] == 0);
free(result1);
int nums1_2[] = {3, 2};
int nums2_2[] = {1, 4};
int *result2 = func0(nums1_2, nums2_2, 2);
assert(result2[0] == 0 && result2[1] == 2);
free(result2);
int nums1_3[] = {90, 120};
int nums2_3[] = {50, 70};
int *result3 = func0(nums1_3, nums2_3, 2);
assert(result3[0] == 40 && result3[1] == 50);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %edx,%rdi
push %rbx
mov %rdi,%r12
shl $0x2,%rdi
mov %rsi,%rbx
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 1388 <func0+0x48>
lea -0x1(%r12),%esi
xor %ecx,%ecx
nopl 0x0(%rax)
mov 0x0(%rbp,%rcx,4),%eax
cltd
idivl (%rbx,%rcx,4)
mov %rcx,%rax
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %rax,%rsi
jne 1370 <func0+0x30>
pop %rbx
mov %r8,%rax
pop %rbp
pop %r12
retq
| func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
movsxd rbp, edx
push rbx
mov r13, rbp
shl rbp, 2
mov rbx, rsi
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov rsi, rax
test r13d, r13d
jle short loc_1374
xor ecx, ecx
loc_1360:
mov eax, [r12+rcx]
cdq
idiv dword ptr [rbx+rcx]
mov [rsi+rcx], edx
add rcx, 4
cmp rbp, rcx
jnz short loc_1360
loc_1374:
add rsp, 8
mov rax, rsi
pop rbx
pop rbp
pop r12
pop r13
retn | char * func0(long long a1, long long a2, int a3)
{
size_t v4; // rbp
char *v6; // rsi
long long v7; // rcx
v4 = 4LL * a3;
v6 = (char *)malloc(v4);
if ( a3 > 0 )
{
v7 = 0LL;
do
{
*(_DWORD *)&v6[v7] = *(_DWORD *)(a1 + v7) % *(_DWORD *)(a2 + v7);
v7 += 4LL;
}
while ( v4 != v7 );
}
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
MOV R13,RBP
SHL RBP,0x2
MOV RBX,RSI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
MOV RSI,RAX
TEST R13D,R13D
JLE 0x00101374
XOR ECX,ECX
LAB_00101360:
MOV EAX,dword ptr [R12 + RCX*0x1]
CDQ
IDIV dword ptr [RBX + RCX*0x1]
MOV dword ptr [RSI + RCX*0x1],EDX
ADD RCX,0x4
CMP RBP,RCX
JNZ 0x00101360
LAB_00101374:
ADD RSP,0x8
MOV RAX,RSI
POP RBX
POP RBP
POP R12
POP R13
RET | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
size_t sVar2;
pvVar1 = malloc((long)param_3 * 4);
if (0 < param_3) {
sVar2 = 0;
do {
*(int *)((long)pvVar1 + sVar2) = *(int *)(param_1 + sVar2) % *(int *)(param_2 + sVar2);
sVar2 = sVar2 + 4;
} while ((long)param_3 * 4 != sVar2);
}
return pvVar1;
} |
5,328 | func0 | #include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (2*b*b == 9*a*c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(1, 3, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
lea (%rax,%rax,1),%ecx
mov -0x4(%rbp),%eax
imul -0xc(%rbp),%eax
mov %eax,%edx
mov %edx,%eax
shl $0x3,%eax
add %edx,%eax
cmp %eax,%ecx
jne 11a0 <func0+0x37>
lea 0xe6a(%rip),%rax
jmp 11a7 <func0+0x3e>
lea 0xe65(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov eax, [rbp+var_8]
imul eax, eax
lea ecx, [rax+rax]
mov eax, [rbp+var_4]
imul eax, [rbp+var_C]
mov edx, eax
mov eax, edx
shl eax, 3
add eax, edx
cmp ecx, eax
jnz short loc_11A0
lea rax, s2; "Yes"
jmp short loc_11A7
loc_11A0:
lea rax, aNo; "No"
loc_11A7:
pop rbp
retn | const char * func0(int a1, int a2, int a3)
{
if ( 2 * a2 * a2 == 9 * a3 * a1 )
return "Yes";
else
return "No";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
LEA ECX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0xc]
MOV EDX,EAX
MOV EAX,EDX
SHL EAX,0x3
ADD EAX,EDX
CMP ECX,EAX
JNZ 0x001011a0
LEA RAX,[0x102008]
JMP 0x001011a7
LAB_001011a0:
LEA RAX,[0x10200c]
LAB_001011a7:
POP RBP
RET | int * func0(int param_1,int param_2,int param_3)
{
int *puVar1;
if (param_2 * param_2 * 2 == param_1 * param_3 * 9) {
puVar1 = &DAT_00102008;
}
else {
puVar1 = &DAT_0010200c;
}
return puVar1;
} |
5,329 | func0 | #include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (2*b*b == 9*a*c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(1, 3, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
return 0;
}
| O1 | c | func0:
endbr64
imul %esi,%esi
add %esi,%esi
imul %edi,%edx
lea (%rdx,%rdx,8),%eax
cmp %eax,%esi
lea 0xec3(%rip),%rax
lea 0xec0(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
imul esi, esi
add esi, esi
imul edi, edx
lea eax, [rdi+rdi*8]
cmp esi, eax
lea rax, unk_2004
lea rdx, unk_2008
cmovnz rax, rdx
retn | void * func0(int a1, int a2, int a3)
{
void *result; // rax
result = &unk_2004;
if ( 2 * a2 * a2 != 9 * a3 * a1 )
return &unk_2008;
return result;
} | func0:
ENDBR64
IMUL ESI,ESI
ADD ESI,ESI
IMUL EDI,EDX
LEA EAX,[RDI + RDI*0x8]
CMP ESI,EAX
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVNZ RAX,RDX
RET | int * func0(int param_1,int param_2,int param_3)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_2 * param_2 * 2 != param_1 * param_3 * 9) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
5,330 | func0 | #include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (2*b*b == 9*a*c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(1, 3, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
return 0;
}
| O2 | c | func0:
endbr64
imul %edi,%edx
imul %esi,%esi
lea (%rdx,%rdx,8),%eax
lea 0xeb4(%rip),%rdx
add %esi,%esi
cmp %eax,%esi
lea 0xea5(%rip),%rax
cmovne %rdx,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
imul edi, edx
lea rdx, unk_2008
imul esi, esi
lea eax, [rdi+rdi*8]
add esi, esi
cmp esi, eax
lea rax, unk_2004
cmovnz rax, rdx
retn | void * func0(int a1, int a2, int a3)
{
void *result; // rax
result = &unk_2004;
if ( 2 * a2 * a2 != 9 * a3 * a1 )
return &unk_2008;
return result;
} | func0:
ENDBR64
IMUL EDI,EDX
LEA RDX,[0x102008]
IMUL ESI,ESI
LEA EAX,[RDI + RDI*0x8]
ADD ESI,ESI
CMP ESI,EAX
LEA RAX,[0x102004]
CMOVNZ RAX,RDX
RET | int * func0(int param_1,int param_2,int param_3)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_2 * param_2 * 2 != param_1 * param_3 * 9) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
5,331 | func0 | #include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (2*b*b == 9*a*c) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(strcmp(func0(1, 3, 2), "Yes") == 0);
assert(strcmp(func0(1, 2, 3), "No") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
return 0;
}
| O3 | c | func0:
endbr64
imul %edi,%edx
imul %esi,%esi
lea (%rdx,%rdx,8),%eax
lea 0xeb4(%rip),%rdx
add %esi,%esi
cmp %eax,%esi
lea 0xea5(%rip),%rax
cmovne %rdx,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
imul edi, edx
lea rdx, unk_2004
imul esi, esi
lea eax, [rdi+rdi*8]
add esi, esi
cmp esi, eax
lea rax, unk_2008
cmovz rax, rdx
retn | void * func0(int a1, int a2, int a3)
{
void *result; // rax
result = &unk_2008;
if ( 2 * a2 * a2 == 9 * a3 * a1 )
return &unk_2004;
return result;
} | func0:
ENDBR64
IMUL EDI,EDX
LEA RDX,[0x102004]
IMUL ESI,ESI
LEA EAX,[RDI + RDI*0x8]
ADD ESI,ESI
CMP ESI,EAX
LEA RAX,[0x102008]
CMOVZ RAX,RDX
RET | int * func0(int param_1,int param_2,int param_3)
{
int *puVar1;
puVar1 = &DAT_00102008;
if (param_2 * param_2 * 2 == param_1 * param_3 * 9) {
puVar1 = &DAT_00102004;
}
return puVar1;
} |
5,332 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int result = pow(2, n) - 1;
return result * result - 2;
}
| int main() {
assert(func0(2) == 7);
assert(func0(4) == 223);
assert(func0(5) == 959);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
mov 0xef4(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xee6(%rip),%xmm1
subsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
sub $0x2,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_14]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
movsd xmm0, cs:qword_2068
movq xmm1, rax
subsd xmm1, xmm0
cvttsd2si eax, xmm1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
imul eax, eax
sub eax, 2
leave
retn | long long func0(int a1)
{
double v1; // rax
v1 = pow(2.0, (double)a1);
return (unsigned int)((int)(v1 - 1.0) * (int)(v1 - 1.0) - 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [0x00102060]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVQ RAX,XMM0
MOVSD XMM0,qword ptr [0x00102068]
MOVQ XMM1,RAX
SUBSD XMM1,XMM0
CVTTSD2SI EAX,XMM1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
SUB EAX,0x2
LEAVE
RET | int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102060,(double)param_1);
return (int)(dVar1 - DAT_00102068) * (int)(dVar1 - DAT_00102068) + -2;
} |
5,333 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int result = pow(2, n) - 1;
return result * result - 2;
}
| int main() {
assert(func0(2) == 7);
assert(func0(4) == 223);
assert(func0(5) == 959);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xef7(%rip),%xmm0
callq 1060 <pow@plt>
subsd 0xef2(%rip),%xmm0
cvttsd2si %xmm0,%eax
imul %eax,%eax
sub $0x2,%eax
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movsd xmm0, cs:qword_2058
call _pow
subsd xmm0, cs:qword_2060
cvttsd2si eax, xmm0
imul eax, eax
sub eax, 2
add rsp, 8
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(2.0, (double)a1);
return (unsigned int)((int)(v1 - 1.0) * (int)(v1 - 1.0) - 2);
} | func0:
ENDBR64
SUB RSP,0x8
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x00102058]
CALL 0x00101060
SUBSD XMM0,qword ptr [0x00102060]
CVTTSD2SI EAX,XMM0
IMUL EAX,EAX
SUB EAX,0x2
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102058,(double)param_1);
return (int)(dVar1 - _DAT_00102060) * (int)(dVar1 - _DAT_00102060) + -2;
} |
5,334 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int result = pow(2, n) - 1;
return result * result - 2;
}
| int main() {
assert(func0(2) == 7);
assert(func0(4) == 223);
assert(func0(5) == 959);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm1,%xmm1
sub $0x8,%rsp
movsd 0xe94(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1050 <pow@plt>
subsd 0xe8b(%rip),%xmm0
add $0x8,%rsp
cvttsd2si %xmm0,%eax
imul %eax,%eax
sub $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:qword_2058
cvtsi2sd xmm1, edi
call _pow
subsd xmm0, cs:qword_2060
add rsp, 8
cvttsd2si eax, xmm0
imul eax, eax
sub eax, 2
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(2.0, (double)a1);
return (unsigned int)((int)(v1 - 1.0) * (int)(v1 - 1.0) - 2);
} | func0:
ENDBR64
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102058]
CVTSI2SD XMM1,EDI
CALL 0x00101060
SUBSD XMM0,qword ptr [0x00102060]
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
IMUL EAX,EAX
SUB EAX,0x2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102058,(double)param_1);
return (int)(dVar1 - _DAT_00102060) * (int)(dVar1 - _DAT_00102060) + -2;
} |
5,335 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int result = pow(2, n) - 1;
return result * result - 2;
}
| int main() {
assert(func0(2) == 7);
assert(func0(4) == 223);
assert(func0(5) == 959);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm1,%xmm1
sub $0x8,%rsp
movsd 0xe94(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1050 <pow@plt>
subsd 0xe8b(%rip),%xmm0
add $0x8,%rsp
cvttsd2si %xmm0,%eax
imul %eax,%eax
sub $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:x; x
cvtsi2sd xmm1, edi; y
call _pow
subsd xmm0, cs:qword_2010
add rsp, 8
cvttsd2si eax, xmm0
imul eax, eax
sub eax, 2
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(2.0, (double)a1);
return (unsigned int)((int)(v1 - 1.0) * (int)(v1 - 1.0) - 2);
} | func0:
ENDBR64
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102008]
CVTSI2SD XMM1,EDI
CALL 0x00101050
SUBSD XMM0,qword ptr [0x00102010]
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
IMUL EAX,EAX
SUB EAX,0x2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102008,(double)param_1);
return (int)(dVar1 - _DAT_00102010) * (int)(dVar1 - _DAT_00102010) + -2;
} |
5,336 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char* list1[], int size, char* result[]) {
int k = 0;
for (int i = 0; i < size; i++) {
if (strcmp(list1[i], "") != 0) { // Checking if the string is not empty
result[k++] = list1[i];
}
}
return k;
}
| int main() {
// Test data
char* list1[] = {"", "", "", "Red", "Green", "12", "Blue", "", ""};
char* expected1[] = {"Red", "Green", "12", "Blue"};
char* result1[4];
char* list2[] = {"", "", "", "", "", "Green", "12", "Blue", "", ""};
char* expected2[] = {"Green", "12", "Blue"};
char* result2[3];
char* list3[] = {"", "", "", "Python", "", "", "programming", "language", "", "", "", "", ""};
char* expected3[] = {"Python", "programming", "language"};
char* result3[3];
// Test case1
int resSize1 = func0(list1, 9, result1);
assert(resSize1 == 4);
for (int i = 0; i < resSize1; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
}
// Test case2
int resSize2 = func0(list2, 10, result2);
assert(resSize2 == 3);
for (int i = 0; i < resSize2; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
}
// Test case3
int resSize3 = func0(list3, 13, result3);
assert(resSize3 == 3);
for (int i = 0; i < resSize3; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1206 <func0+0x7d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
movzbl (%rax),%eax
movzbl %al,%eax
test %eax,%eax
je 1202 <func0+0x79>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ac <func0+0x23>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1206
loc_11AC:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
movzx eax, byte ptr [rax]
movzx eax, al
test eax, eax
jz short loc_1202
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
loc_1202:
add [rbp+var_4], 1
loc_1206:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11AC
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2, long long a3)
{
int v3; // eax
unsigned int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( **(_BYTE **)(8LL * i + a1) )
{
v3 = v5++;
*(_QWORD *)(a3 + 8LL * v3) = *(_QWORD *)(8LL * i + a1);
}
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101206
LAB_001011ac:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
TEST EAX,EAX
JZ 0x00101202
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
LAB_00101202:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101206:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ac
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2,long param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (**(char **)(param_1 + (long)local_c * 8) != '\0') {
*(int8 *)((long)local_10 * 8 + param_3) = *(int8 *)((long)local_c * 8 + param_1);
local_10 = local_10 + 1;
}
}
return local_10;
} |
5,337 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char* list1[], int size, char* result[]) {
int k = 0;
for (int i = 0; i < size; i++) {
if (strcmp(list1[i], "") != 0) { // Checking if the string is not empty
result[k++] = list1[i];
}
}
return k;
}
| int main() {
// Test data
char* list1[] = {"", "", "", "Red", "Green", "12", "Blue", "", ""};
char* expected1[] = {"Red", "Green", "12", "Blue"};
char* result1[4];
char* list2[] = {"", "", "", "", "", "Green", "12", "Blue", "", ""};
char* expected2[] = {"Green", "12", "Blue"};
char* result2[3];
char* list3[] = {"", "", "", "Python", "", "", "programming", "language", "", "", "", "", ""};
char* expected3[] = {"Python", "programming", "language"};
char* result3[3];
// Test case1
int resSize1 = func0(list1, 9, result1);
assert(resSize1 == 4);
for (int i = 0; i < resSize1; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
}
// Test case2
int resSize2 = func0(list2, 10, result2);
assert(resSize2 == 3);
for (int i = 0; i < resSize2; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
}
// Test case3
int resSize3 = func0(list3, 13, result3);
assert(resSize3 == 3);
for (int i = 0; i < resSize3; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
}
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c0 <func0+0x37>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x8(%rdi,%rcx,8),%rdi
mov $0x0,%esi
jmp 11ac <func0+0x23>
add $0x8,%rax
cmp %rdi,%rax
je 11c5 <func0+0x3c>
mov (%rax),%rcx
cmpb $0x0,(%rcx)
je 11a3 <func0+0x1a>
movslq %esi,%r8
mov %rcx,(%rdx,%r8,8)
lea 0x1(%rsi),%esi
jmp 11a3 <func0+0x1a>
mov $0x0,%esi
mov %esi,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11C0
mov rax, rdi
lea ecx, [rsi-1]
lea rdi, [rdi+rcx*8+8]
mov esi, 0
jmp short loc_11AC
loc_11A3:
add rax, 8
cmp rax, rdi
jz short loc_11C5
loc_11AC:
mov rcx, [rax]
cmp byte ptr [rcx], 0
jz short loc_11A3
movsxd r8, esi
mov [rdx+r8*8], rcx
lea esi, [rsi+1]
jmp short loc_11A3
loc_11C0:
mov esi, 0
loc_11C5:
mov eax, esi
retn | long long func0(_QWORD *a1, int a2, long long a3)
{
_QWORD *v3; // rax
long long v4; // rdi
unsigned int v5; // esi
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
v5 = 0;
do
{
if ( *(_BYTE *)*v3 )
*(_QWORD *)(a3 + 8LL * (int)v5++) = *v3;
++v3;
}
while ( v3 != (_QWORD *)v4 );
}
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c0
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RDI,[RDI + RCX*0x8 + 0x8]
MOV ESI,0x0
JMP 0x001011ac
LAB_001011a3:
ADD RAX,0x8
CMP RAX,RDI
JZ 0x001011c5
LAB_001011ac:
MOV RCX,qword ptr [RAX]
CMP byte ptr [RCX],0x0
JZ 0x001011a3
MOVSXD R8,ESI
MOV qword ptr [RDX + R8*0x8],RCX
LEA ESI,[RSI + 0x1]
JMP 0x001011a3
LAB_001011c0:
MOV ESI,0x0
LAB_001011c5:
MOV EAX,ESI
RET | int func0(int8 *param_1,int param_2,long param_3)
{
int8 *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (*(char *)*param_1 != '\0') {
*(char **)(param_3 + (long)iVar2 * 8) = (char *)*param_1;
iVar2 = iVar2 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar2;
} |
5,338 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char* list1[], int size, char* result[]) {
int k = 0;
for (int i = 0; i < size; i++) {
if (strcmp(list1[i], "") != 0) { // Checking if the string is not empty
result[k++] = list1[i];
}
}
return k;
}
| int main() {
// Test data
char* list1[] = {"", "", "", "Red", "Green", "12", "Blue", "", ""};
char* expected1[] = {"Red", "Green", "12", "Blue"};
char* result1[4];
char* list2[] = {"", "", "", "", "", "Green", "12", "Blue", "", ""};
char* expected2[] = {"Green", "12", "Blue"};
char* result2[3];
char* list3[] = {"", "", "", "Python", "", "", "programming", "language", "", "", "", "", ""};
char* expected3[] = {"Python", "programming", "language"};
char* result3[3];
// Test case1
int resSize1 = func0(list1, 9, result1);
assert(resSize1 == 4);
for (int i = 0; i < resSize1; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
}
// Test case2
int resSize2 = func0(list2, 10, result2);
assert(resSize2 == 3);
for (int i = 0; i < resSize2; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
}
// Test case3
int resSize3 = func0(list3, 13, result3);
assert(resSize3 == 3);
for (int i = 0; i < resSize3; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
}
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 15c0 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rdi),%rax
cmpb $0x0,(%rax)
je 15ab <func0+0x2b>
movslq %r8d,%rsi
add $0x1,%r8d
mov %rax,(%rdx,%rsi,8)
add $0x8,%rdi
cmp %rcx,%rdi
jne 1598 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1550
lea eax, [rsi-1]
xor r8d, r8d
lea rcx, [rdi+rax*8+8]
nop dword ptr [rax+rax+00h]
loc_1528:
mov rax, [rdi]
cmp byte ptr [rax], 0
jz short loc_153B
movsxd rsi, r8d
add r8d, 1
mov [rdx+rsi*8], rax
loc_153B:
add rdi, 8
cmp rdi, rcx
jnz short loc_1528
mov eax, r8d
retn
loc_1550:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_QWORD *a1, int a2, long long a3)
{
unsigned int v3; // r8d
long long v4; // rcx
long long v5; // rsi
if ( a2 <= 0 )
return 0LL;
v3 = 0;
v4 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
do
{
if ( *(_BYTE *)*a1 )
{
v5 = (int)v3++;
*(_QWORD *)(a3 + 8 * v5) = *a1;
}
++a1;
}
while ( a1 != (_QWORD *)v4 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101550
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RCX,[RDI + RAX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101528:
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX],0x0
JZ 0x0010153b
MOVSXD RSI,R8D
ADD R8D,0x1
MOV qword ptr [RDX + RSI*0x8],RAX
LAB_0010153b:
ADD RDI,0x8
CMP RDI,RCX
JNZ 0x00101528
MOV EAX,R8D
RET
LAB_00101550:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int8 *param_1,int param_2,long param_3)
{
int8 *puVar1;
long lVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*(char *)*param_1 != '\0') {
lVar2 = (long)iVar3;
iVar3 = iVar3 + 1;
*(char **)(param_3 + lVar2 * 8) = (char *)*param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return iVar3;
}
return 0;
} |
5,339 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char* list1[], int size, char* result[]) {
int k = 0;
for (int i = 0; i < size; i++) {
if (strcmp(list1[i], "") != 0) { // Checking if the string is not empty
result[k++] = list1[i];
}
}
return k;
}
| int main() {
// Test data
char* list1[] = {"", "", "", "Red", "Green", "12", "Blue", "", ""};
char* expected1[] = {"Red", "Green", "12", "Blue"};
char* result1[4];
char* list2[] = {"", "", "", "", "", "Green", "12", "Blue", "", ""};
char* expected2[] = {"Green", "12", "Blue"};
char* result2[3];
char* list3[] = {"", "", "", "Python", "", "", "programming", "language", "", "", "", "", ""};
char* expected3[] = {"Python", "programming", "language"};
char* result3[3];
// Test case1
int resSize1 = func0(list1, 9, result1);
assert(resSize1 == 4);
for (int i = 0; i < resSize1; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
}
// Test case2
int resSize2 = func0(list2, 10, result2);
assert(resSize2 == 3);
for (int i = 0; i < resSize2; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
}
// Test case3
int resSize3 = func0(list3, 13, result3);
assert(resSize3 == 3);
for (int i = 0; i < resSize3; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
}
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 17e0 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rdi),%rax
cmpb $0x0,(%rax)
je 17cb <func0+0x2b>
movslq %r8d,%rsi
add $0x1,%r8d
mov %rax,(%rdx,%rsi,8)
add $0x8,%rdi
cmp %rdi,%rcx
jne 17b8 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1180
movsxd rsi, esi
xor ecx, ecx
lea rsi, [rdi+rsi*8]
nop dword ptr [rax+00000000h]
loc_1158:
mov rax, [rdi]
cmp byte ptr [rax], 0
jz short loc_116A
movsxd r8, ecx
add ecx, 1
mov [rdx+r8*8], rax
loc_116A:
add rdi, 8
cmp rdi, rsi
jnz short loc_1158
mov eax, ecx
retn
loc_1180:
xor ecx, ecx
mov eax, ecx
retn | long long func0(_QWORD *a1, int a2, long long a3)
{
unsigned int v3; // ecx
_QWORD *v4; // rsi
long long v5; // r8
if ( a2 <= 0 )
return 0LL;
v3 = 0;
v4 = &a1[a2];
do
{
if ( *(_BYTE *)*a1 )
{
v5 = (int)v3++;
*(_QWORD *)(a3 + 8 * v5) = *a1;
}
++a1;
}
while ( a1 != v4 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
MOVSXD RSI,ESI
XOR ECX,ECX
LEA RSI,[RDI + RSI*0x8]
NOP dword ptr [RAX]
LAB_00101158:
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX],0x0
JZ 0x0010116a
MOVSXD R8,ECX
ADD ECX,0x1
MOV qword ptr [RDX + R8*0x8],RAX
LAB_0010116a:
ADD RDI,0x8
CMP RDI,RSI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101180:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int8 *param_1,int param_2,long param_3)
{
int8 *puVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
puVar1 = param_1 + param_2;
do {
if (*(char *)*param_1 != '\0') {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
*(char **)(param_3 + lVar3 * 8) = (char *)*param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return iVar2;
}
return 0;
} |
5,340 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int max_val = 0;
int result = nums[0];
for (int i = 0; i < size; i++) {
int occu = 0;
for (int j = 0; j < size; j++) {
if (nums[j] == nums[i]) {
occu++;
}
}
if (occu > max_val) {
max_val = occu;
result = nums[i];
}
}
return result;
}
| int main() {
int arr1[] = {1,2,3,1,2,3,12,4,2};
int arr2[] = {1,2,6,7,0,1,0,1,0};
int arr3[] = {1,2,3,1,2,4,1};
assert(func0(arr1, 9) == 2);
assert(func0(arr2, 9) == 1);
assert(func0(arr3, 7) == 1);
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),%eax
mov %eax,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 120c <func0+0xa3>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d9 <func0+0x70>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11d5 <func0+0x6c>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11a1 <func0+0x38>
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1208 <func0+0x9f>
mov -0x8(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1191 <func0+0x28>
mov -0x10(%rbp),%eax
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 eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_C], 0
jmp short loc_120C
loc_1191:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11D9
loc_11A1:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11D5
add [rbp+var_8], 1
loc_11D5:
add [rbp+var_4], 1
loc_11D9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_11A1
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jle short loc_1208
mov eax, [rbp+var_8]
mov [rbp+var_14], eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
loc_1208:
add [rbp+var_C], 1
loc_120C:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl loc_1191
mov eax, [rbp+var_10]
pop rbp
retn | long long func0(unsigned int *a1, int a2)
{
int v3; // [rsp+18h] [rbp-14h]
unsigned int v4; // [rsp+1Ch] [rbp-10h]
int i; // [rsp+20h] [rbp-Ch]
int v6; // [rsp+24h] [rbp-8h]
int j; // [rsp+28h] [rbp-4h]
v3 = 0;
v4 = *a1;
for ( i = 0; i < a2; ++i )
{
v6 = 0;
for ( j = 0; j < a2; ++j )
{
if ( a1[j] == a1[i] )
++v6;
}
if ( v6 > v3 )
{
v3 = v6;
v4 = a1[i];
}
}
return v4;
} | 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 EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010120c
LAB_00101191:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d9
LAB_001011a1:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011d5
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011a1
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101208
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
LAB_00101208:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010120c:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101191
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET | int4 func0(int4 *param_1,int param_2)
{
int local_1c;
int4 local_18;
int local_14;
int local_10;
int local_c;
local_1c = 0;
local_18 = *param_1;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (param_1[local_c] == param_1[local_14]) {
local_10 = local_10 + 1;
}
}
if (local_1c < local_10) {
local_1c = local_10;
local_18 = param_1[local_14];
}
}
return local_18;
} |
5,341 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int max_val = 0;
int result = nums[0];
for (int i = 0; i < size; i++) {
int occu = 0;
for (int j = 0; j < size; j++) {
if (nums[j] == nums[i]) {
occu++;
}
}
if (occu > max_val) {
max_val = occu;
result = nums[i];
}
}
return result;
}
| int main() {
int arr1[] = {1,2,3,1,2,3,12,4,2};
int arr2[] = {1,2,6,7,0,1,0,1,0};
int arr3[] = {1,2,3,1,2,4,1};
assert(func0(arr1, 9) == 2);
assert(func0(arr2, 9) == 1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%r11d
test %esi,%esi
jle 11ba <func0+0x51>
mov %rdi,%r10
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r8
mov $0x0,%r9d
jmp 1190 <func0+0x27>
add $0x4,%rdi
cmp %r8,%rdi
je 11ba <func0+0x51>
mov (%rdi),%esi
mov %r10,%rax
mov $0x0,%edx
cmp %esi,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %r8,%rax
jne 119a <func0+0x31>
cmp %r9d,%edx
jle 1187 <func0+0x1e>
mov %esi,%r11d
mov %edx,%r9d
jmp 1187 <func0+0x1e>
mov %r11d,%eax
retq
| func0:
endbr64
mov r11d, [rdi]
test esi, esi
jle short loc_11BB
lea eax, [rsi-1]
lea r8, [rdi+rax*4+4]
mov r9, rdi
mov r10d, 0
jmp short loc_1190
loc_1187:
add r9, 4
cmp r9, r8
jz short loc_11BB
loc_1190:
mov esi, [r9]
mov rax, rdi
mov edx, 0
loc_119B:
cmp [rax], esi
setz cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, r8
jnz short loc_119B
cmp edx, r10d
jle short loc_1187
mov r11d, esi
mov r10d, edx
jmp short loc_1187
loc_11BB:
mov eax, r11d
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r11d
long long v3; // r8
unsigned int *v4; // r9
int v5; // r10d
unsigned int *v6; // rax
int v7; // edx
v2 = *a1;
if ( a2 > 0 )
{
v3 = (long long)&a1[a2 - 1 + 1];
v4 = a1;
v5 = 0;
do
{
v6 = a1;
v7 = 0;
do
v7 += *v6++ == *v4;
while ( v6 != (unsigned int *)v3 );
if ( v7 > v5 )
{
v2 = *v4;
v5 = v7;
}
++v4;
}
while ( v4 != (unsigned int *)v3 );
}
return v2;
} | func0:
ENDBR64
MOV R11D,dword ptr [RDI]
TEST ESI,ESI
JLE 0x001011bb
LEA EAX,[RSI + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV R9,RDI
MOV R10D,0x0
JMP 0x00101190
LAB_00101187:
ADD R9,0x4
CMP R9,R8
JZ 0x001011bb
LAB_00101190:
MOV ESI,dword ptr [R9]
MOV RAX,RDI
MOV EDX,0x0
LAB_0010119b:
CMP dword ptr [RAX],ESI
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x0010119b
CMP EDX,R10D
JLE 0x00101187
MOV R11D,ESI
MOV R10D,EDX
JMP 0x00101187
LAB_001011bb:
MOV EAX,R11D
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int iVar4;
int iVar5;
iVar5 = *param_1;
if (0 < param_2) {
iVar4 = 0;
piVar3 = param_1;
do {
iVar2 = 0;
piVar1 = param_1;
do {
iVar2 = iVar2 + (uint)(*piVar1 == *piVar3);
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(param_2 - 1) + 1);
if (iVar4 < iVar2) {
iVar5 = *piVar3;
iVar4 = iVar2;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 1) + 1);
}
return iVar5;
} |
5,342 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int max_val = 0;
int result = nums[0];
for (int i = 0; i < size; i++) {
int occu = 0;
for (int j = 0; j < size; j++) {
if (nums[j] == nums[i]) {
occu++;
}
}
if (occu > max_val) {
max_val = occu;
result = nums[i];
}
}
return result;
}
| int main() {
int arr1[] = {1,2,3,1,2,3,12,4,2};
int arr2[] = {1,2,6,7,0,1,0,1,0};
int arr3[] = {1,2,3,1,2,4,1};
assert(func0(arr1, 9) == 2);
assert(func0(arr2, 9) == 1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov (%rdi),%r11d
test %esi,%esi
jle 1346 <func0+0x66>
lea 0x4(%rdi),%r9
lea -0x1(%rsi),%eax
mov %r11d,%r12d
mov %r11d,%esi
lea (%r9,%rax,4),%rdi
mov %r9,%r8
xor %r10d,%r10d
nopl 0x0(%rax)
mov %r9,%rax
mov %r11d,%ecx
xor %edx,%edx
jmp 131e <func0+0x3e>
nopw 0x0(%rax,%rax,1)
mov (%rax),%ecx
add $0x4,%rax
cmp %ecx,%esi
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
cmp %rdi,%rax
jne 1318 <func0+0x38>
cmp %r10d,%edx
jle 1338 <func0+0x58>
mov %esi,%r12d
mov %edx,%r10d
cmp %rdi,%r8
je 1349 <func0+0x69>
mov (%r8),%esi
add $0x4,%r8
jmp 1308 <func0+0x28>
mov %r11d,%r12d
mov %r12d,%eax
pop %r12
retq
| func0:
endbr64
push r12
mov r11d, [rdi]
test esi, esi
jle short loc_1346
lea r9, [rdi+4]
lea eax, [rsi-1]
mov r12d, r11d
mov esi, r11d
lea rdi, [r9+rax*4]
mov r8, r9
xor r10d, r10d
nop dword ptr [rax+00h]
loc_1308:
mov rax, r9
mov ecx, r11d
xor edx, edx
jmp short loc_131E
loc_1318:
mov ecx, [rax]
add rax, 4
loc_131E:
cmp esi, ecx
setz cl
movzx ecx, cl
add edx, ecx
cmp rax, rdi
jnz short loc_1318
cmp edx, r10d
jle short loc_1338
mov r12d, esi
mov r10d, edx
loc_1338:
cmp r8, rdi
jz short loc_1349
mov esi, [r8]
add r8, 4
jmp short loc_1308
loc_1346:
mov r12d, r11d
loc_1349:
mov eax, r12d
pop r12
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r11d
unsigned int *v3; // r9
long long v4; // rax
unsigned int v5; // r12d
unsigned int v6; // esi
long long v7; // rdi
unsigned int *v8; // r8
int v9; // r10d
unsigned int *v10; // rax
unsigned int v11; // ecx
int v12; // edx
v2 = *a1;
if ( a2 <= 0 )
{
return *a1;
}
else
{
v3 = a1 + 1;
v4 = (unsigned int)(a2 - 1);
v5 = *a1;
v6 = *a1;
v7 = (long long)&a1[v4 + 1];
v8 = v3;
v9 = 0;
while ( 1 )
{
v10 = v3;
v11 = v2;
v12 = 0;
while ( 1 )
{
v12 += v6 == v11;
if ( v10 == (unsigned int *)v7 )
break;
v11 = *v10++;
}
if ( v12 > v9 )
{
v5 = v6;
v9 = v12;
}
if ( v8 == (unsigned int *)v7 )
break;
v6 = *v8++;
}
}
return v5;
} | func0:
ENDBR64
PUSH R12
MOV R11D,dword ptr [RDI]
TEST ESI,ESI
JLE 0x00101346
LEA R9,[RDI + 0x4]
LEA EAX,[RSI + -0x1]
MOV R12D,R11D
MOV ESI,R11D
LEA RDI,[R9 + RAX*0x4]
MOV R8,R9
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_00101308:
MOV RAX,R9
MOV ECX,R11D
XOR EDX,EDX
JMP 0x0010131e
LAB_00101318:
MOV ECX,dword ptr [RAX]
ADD RAX,0x4
LAB_0010131e:
CMP ESI,ECX
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
CMP RAX,RDI
JNZ 0x00101318
CMP EDX,R10D
JLE 0x00101338
MOV R12D,ESI
MOV R10D,EDX
LAB_00101338:
CMP R8,RDI
JZ 0x00101349
MOV ESI,dword ptr [R8]
ADD R8,0x4
JMP 0x00101308
LAB_00101346:
MOV R12D,R11D
LAB_00101349:
MOV EAX,R12D
POP R12
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int *piVar6;
int iVar7;
int iVar8;
iVar1 = *param_1;
iVar8 = iVar1;
if (0 < param_2) {
param_1 = param_1 + 1;
iVar7 = 0;
piVar6 = param_1;
iVar5 = iVar1;
while( true ) {
iVar4 = 0;
iVar3 = iVar1;
for (piVar2 = param_1; iVar4 = iVar4 + (uint)(iVar5 == iVar3),
piVar2 != param_1 + (param_2 - 1); piVar2 = piVar2 + 1) {
iVar3 = *piVar2;
}
if (iVar7 < iVar4) {
iVar8 = iVar5;
iVar7 = iVar4;
}
if (piVar6 == param_1 + (param_2 - 1)) break;
iVar5 = *piVar6;
piVar6 = piVar6 + 1;
}
}
return iVar8;
} |
5,343 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int max_val = 0;
int result = nums[0];
for (int i = 0; i < size; i++) {
int occu = 0;
for (int j = 0; j < size; j++) {
if (nums[j] == nums[i]) {
occu++;
}
}
if (occu > max_val) {
max_val = occu;
result = nums[i];
}
}
return result;
}
| int main() {
int arr1[] = {1,2,3,1,2,3,12,4,2};
int arr2[] = {1,2,6,7,0,1,0,1,0};
int arr3[] = {1,2,3,1,2,4,1};
assert(func0(arr1, 9) == 2);
assert(func0(arr2, 9) == 1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
mov (%rdi),%r13d
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 13a6 <func0+0x106>
mov %esi,%edx
lea -0x1(%rsi),%eax
mov %esi,%r11d
mov %rdi,%r9
shr $0x2,%edx
mov %rax,%rbp
lea 0x4(%rdi,%rax,4),%r12
and $0xfffffffc,%r11d
shl $0x4,%rdx
xor %ebx,%ebx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
mov (%r9),%ecx
cmp $0x3,%ebp
jbe 13b8 <func0+0x118>
movd %ecx,%xmm3
mov %rdi,%rax
pxor %xmm1,%xmm1
pshufd $0x0,%xmm3,%xmm2
nopl 0x0(%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
pcmpeqd %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rax,%rdx
jne 1300 <func0+0x60>
movdqa %xmm1,%xmm0
mov %r11d,%r8d
psrldq $0x8,%xmm0
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
cmp %esi,%r11d
je 1390 <func0+0xf0>
movslq %r8d,%r14
cmp %ecx,(%rdi,%r14,4)
lea 0x0(,%r14,4),%r10
sete %r14b
movzbl %r14b,%r14d
add %r14d,%eax
lea 0x1(%r8),%r14d
cmp %esi,%r14d
jge 1390 <func0+0xf0>
cmp 0x4(%rdi,%r10,1),%ecx
jne 1368 <func0+0xc8>
add $0x1,%eax
lea 0x2(%r8),%r14d
cmp %esi,%r14d
jge 1390 <func0+0xf0>
cmp 0x8(%rdi,%r10,1),%ecx
jne 137b <func0+0xdb>
add $0x1,%eax
add $0x3,%r8d
cmp %r8d,%esi
jle 1390 <func0+0xf0>
cmp 0xc(%rdi,%r10,1),%ecx
jne 1390 <func0+0xf0>
add $0x1,%eax
xchg %ax,%ax
cmp %eax,%ebx
jge 1399 <func0+0xf9>
mov %ecx,%r13d
mov %eax,%ebx
add $0x4,%r9
cmp %r12,%r9
jne 12e0 <func0+0x40>
pop %rbx
mov %r13d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
xor %eax,%eax
jmpq 133b <func0+0x9b>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
mov r13d, [rdi]
push r12
push rbp
push rbx
test esi, esi
jle loc_138A
mov edx, esi
movsxd rax, esi
mov r11d, esi
mov r8, rdi
shr edx, 2
mov r9d, esi
lea r12, [rdi+rax*4]
and r11d, 0FFFFFFFCh
shl rdx, 4
lea ebp, [rsi-1]
xor ebx, ebx
add rdx, rdi
nop dword ptr [rax+00h]
loc_12E0:
mov esi, [rdi]
cmp ebp, 2
jbe loc_13A0
movd xmm3, esi
mov rax, r8
pxor xmm1, xmm1
pshufd xmm2, xmm3, 0
nop dword ptr [rax+rax+00h]
loc_1300:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rdx, rax
jnz short loc_1300
movdqa xmm0, xmm1
mov ecx, r11d
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
cmp r9d, r11d
jz short loc_1374
loc_133B:
movsxd r10, ecx
lea r14, ds:0[r10*4]
cmp [r8+r10*4], esi
jnz short loc_134F
add eax, 1
loc_134F:
lea r10d, [rcx+1]
cmp r9d, r10d
jle short loc_1374
cmp esi, [r8+r14+4]
jnz short loc_1362
add eax, 1
loc_1362:
add ecx, 2
cmp ecx, r9d
jge short loc_1374
cmp esi, [r8+r14+8]
jnz short loc_1374
add eax, 1
loc_1374:
cmp ebx, eax
jge short loc_137D
mov r13d, esi
mov ebx, eax
loc_137D:
add rdi, 4
cmp r12, rdi
jnz loc_12E0
loc_138A:
pop rbx
mov eax, r13d
pop rbp
pop r12
pop r13
pop r14
retn
loc_13A0:
xor ecx, ecx
xor eax, eax
jmp short loc_133B | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r13d
const __m128i *v3; // r8
unsigned int *v5; // r12
unsigned int v6; // r11d
unsigned int v7; // ebp
int v8; // ebx
const __m128i *v9; // rdx
unsigned int v10; // esi
const __m128i *v11; // rax
__m128i v12; // xmm1
__m128i v13; // xmm2
__m128i v14; // xmm0
signed int v15; // ecx
__m128i v16; // xmm1
int v17; // eax
long long v18; // r14
v2 = *a1;
if ( a2 > 0 )
{
v3 = (const __m128i *)a1;
v5 = &a1[a2];
v6 = a2 & 0xFFFFFFFC;
v7 = a2 - 1;
v8 = 0;
v9 = (const __m128i *)&a1[4 * ((unsigned int)a2 >> 2)];
while ( 1 )
{
v10 = *a1;
if ( v7 <= 2 )
break;
v11 = v3;
v12 = 0LL;
v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v10), 0);
do
{
v14 = _mm_loadu_si128(v11++);
v12 = _mm_sub_epi32(v12, _mm_cmpeq_epi32(v14, v13));
}
while ( v9 != v11 );
v15 = v6;
v16 = _mm_add_epi32(v12, _mm_srli_si128(v12, 8));
v17 = _mm_cvtsi128_si32(_mm_add_epi32(v16, _mm_srli_si128(v16, 4)));
if ( a2 != v6 )
goto LABEL_7;
LABEL_15:
if ( v8 < v17 )
{
v2 = *a1;
v8 = v17;
}
if ( v5 == ++a1 )
return v2;
}
v15 = 0;
v17 = 0;
LABEL_7:
v18 = v15;
if ( v3->m128i_i32[v18] == v10 )
++v17;
if ( a2 > v15 + 1 )
{
if ( v10 == v3->m128i_i32[v18 + 1] )
++v17;
if ( v15 + 2 < a2 && v10 == v3->m128i_i32[v18 + 2] )
++v17;
}
goto LABEL_15;
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13D,dword ptr [RDI]
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x0010138a
MOV EDX,ESI
MOVSXD RAX,ESI
MOV R11D,ESI
MOV R8,RDI
SHR EDX,0x2
MOV R9D,ESI
LEA R12,[RDI + RAX*0x4]
AND R11D,0xfffffffc
SHL RDX,0x4
LEA EBP,[RSI + -0x1]
XOR EBX,EBX
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_001012e0:
MOV ESI,dword ptr [RDI]
CMP EBP,0x2
JBE 0x001013a0
MOVD XMM3,ESI
MOV RAX,R8
PXOR XMM1,XMM1
PSHUFD XMM2,XMM3,0x0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101300:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RDX,RAX
JNZ 0x00101300
MOVDQA XMM0,XMM1
MOV ECX,R11D
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
CMP R9D,R11D
JZ 0x00101374
LAB_0010133b:
MOVSXD R10,ECX
LEA R14,[R10*0x4]
CMP dword ptr [R8 + R10*0x4],ESI
JNZ 0x0010134f
ADD EAX,0x1
LAB_0010134f:
LEA R10D,[RCX + 0x1]
CMP R9D,R10D
JLE 0x00101374
CMP ESI,dword ptr [R8 + R14*0x1 + 0x4]
JNZ 0x00101362
ADD EAX,0x1
LAB_00101362:
ADD ECX,0x2
CMP ECX,R9D
JGE 0x00101374
CMP ESI,dword ptr [R8 + R14*0x1 + 0x8]
JNZ 0x00101374
ADD EAX,0x1
LAB_00101374:
CMP EBX,EAX
JGE 0x0010137d
MOV R13D,ESI
MOV EBX,EAX
LAB_0010137d:
ADD RDI,0x4
CMP R12,RDI
JNZ 0x001012e0
LAB_0010138a:
POP RBX
MOV EAX,R13D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013a0:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x0010133b | int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int iVar8;
int *piVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
iVar10 = *param_1;
if (0 < (int)param_2) {
iVar8 = 0;
piVar9 = param_1;
do {
iVar1 = *piVar9;
if (param_2 - 1 < 3) {
uVar7 = 0;
iVar11 = 0;
LAB_0010133b:
if (param_1[(int)uVar7] == iVar1) {
iVar11 = iVar11 + 1;
}
if ((int)(uVar7 + 1) < (int)param_2) {
if (iVar1 == param_1[(long)(int)uVar7 + 1]) {
iVar11 = iVar11 + 1;
}
if (((int)(uVar7 + 2) < (int)param_2) && (iVar1 == param_1[(long)(int)uVar7 + 2])) {
iVar11 = iVar11 + 1;
}
}
}
else {
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
piVar6 = param_1;
do {
iVar2 = *piVar6;
piVar3 = piVar6 + 1;
piVar4 = piVar6 + 2;
piVar5 = piVar6 + 3;
piVar6 = piVar6 + 4;
iVar11 = iVar11 + (uint)(iVar2 == iVar1);
iVar12 = iVar12 + (uint)(*piVar3 == iVar1);
iVar13 = iVar13 + (uint)(*piVar4 == iVar1);
iVar14 = iVar14 + (uint)(*piVar5 == iVar1);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != piVar6);
iVar11 = iVar11 + iVar13 + iVar12 + iVar14;
uVar7 = param_2 & 0xfffffffc;
if (param_2 != (param_2 & 0xfffffffc)) goto LAB_0010133b;
}
if (iVar8 < iVar11) {
iVar10 = iVar1;
iVar8 = iVar11;
}
piVar9 = piVar9 + 1;
} while (param_1 + (int)param_2 != piVar9);
}
return iVar10;
} |
5,344 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int test_list[][3], int size, int K, int result[][3]) {
for(int i = 0; i < size; i++) {
for(int j = 0; j < 3; j++) {
result[i][j] = test_list[i][j] + K;
}
}
}
| int main() {
int test_list1[3][3] = {{1, 3, 4}, {2, 4, 6}, {3, 8, 1}};
int result1[3][3];
func0(test_list1, 3, 4, result1);
int expected1[3][3] = {{5, 7, 8}, {6, 8, 10}, {7, 12, 5}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
int test_list2[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int result2[3][3];
func0(test_list2, 3, 8, result2);
int expected2[3][3] = {{9, 10, 11}, {12, 13, 14}, {15, 16, 17}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
int test_list3[3][3] = {{11, 12, 13}, {14, 15, 16}, {17, 18, 19}};
int result3[3][3];
func0(test_list3, 3, 9, result3);
int expected3[3][3] = {{20, 21, 22}, {23, 24, 25}, {26, 27, 28}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result3[i][j] == expected3[i][j]);
}
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11ee <func0+0x85>
movl $0x0,-0x4(%rbp)
jmp 11e4 <func0+0x7b>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
cltq
mov (%rdx,%rax,4),%ecx
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
add %eax,%ecx
mov -0x4(%rbp),%eax
cltq
mov %ecx,(%rdx,%rax,4)
addl $0x1,-0x4(%rbp)
cmpl $0x2,-0x4(%rbp)
jle 1191 <func0+0x28>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_8], 0
jmp short loc_11EE
loc_1188:
mov [rbp+var_4], 0
jmp short loc_11E4
loc_1191:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
cdqe
mov ecx, [rdx+rax*4]
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_20]
add ecx, eax
mov eax, [rbp+var_4]
cdqe
mov [rdx+rax*4], ecx
add [rbp+var_4], 1
loc_11E4:
cmp [rbp+var_4], 2
jle short loc_1191
add [rbp+var_8], 1
loc_11EE:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
nop
nop
pop rbp
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
for ( j = 0; j <= 2; ++j )
*(_DWORD *)(a4 + 12LL * (int)i + 4LL * j) = a3 + *(_DWORD *)(a1 + 12LL * (int)i + 4LL * j);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011ee
LAB_00101188:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e4
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
ADD ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
MOV dword ptr [RDX + RAX*0x4],ECX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011e4:
CMP dword ptr [RBP + -0x4],0x2
JLE 0x00101191
ADD dword ptr [RBP + -0x8],0x1
LAB_001011ee:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
for (local_c = 0; local_c < 3; local_c = local_c + 1) {
*(int *)((long)local_10 * 0xc + param_4 + (long)local_c * 4) =
*(int *)((long)local_10 * 0xc + param_1 + (long)local_c * 4) + param_3;
}
}
return;
} |
5,345 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int test_list[][3], int size, int K, int result[][3]) {
for(int i = 0; i < size; i++) {
for(int j = 0; j < 3; j++) {
result[i][j] = test_list[i][j] + K;
}
}
}
| int main() {
int test_list1[3][3] = {{1, 3, 4}, {2, 4, 6}, {3, 8, 1}};
int result1[3][3];
func0(test_list1, 3, 4, result1);
int expected1[3][3] = {{5, 7, 8}, {6, 8, 10}, {7, 12, 5}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
int test_list2[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int result2[3][3];
func0(test_list2, 3, 8, result2);
int expected2[3][3] = {{9, 10, 11}, {12, 13, 14}, {15, 16, 17}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
int test_list3[3][3] = {{11, 12, 13}, {14, 15, 16}, {17, 18, 19}};
int result3[3][3];
func0(test_list3, 3, 9, result3);
int expected3[3][3] = {{20, 21, 22}, {23, 24, 25}, {26, 27, 28}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result3[i][j] == expected3[i][j]);
}
}
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a3 <func0+0x3a>
mov %rdi,%rax
lea -0x1(%rsi),%esi
lea (%rsi,%rsi,2),%rsi
lea 0xc(%rdi,%rsi,4),%rdi
mov %edx,%esi
add (%rax),%esi
mov %esi,(%rcx)
mov %edx,%esi
add 0x4(%rax),%esi
mov %esi,0x4(%rcx)
mov %edx,%esi
add 0x8(%rax),%esi
mov %esi,0x8(%rcx)
add $0xc,%rax
add $0xc,%rcx
cmp %rdi,%rax
jne 1180 <func0+0x17>
retq
| func0:
endbr64
test esi, esi
jle short locret_11A3
mov rax, rdi
lea esi, [rsi-1]
lea rsi, [rsi+rsi*2]
lea rdi, [rdi+rsi*4+0Ch]
loc_1180:
mov esi, edx
add esi, [rax]
mov [rcx], esi
mov esi, edx
add esi, [rax+4]
mov [rcx+4], esi
mov esi, edx
add esi, [rax+8]
mov [rcx+8], esi
add rax, 0Ch
add rcx, 0Ch
cmp rax, rdi
jnz short loc_1180
locret_11A3:
retn | void func0(_DWORD *a1, int a2, int a3, _DWORD *a4)
{
_DWORD *v4; // rax
long long v5; // rdi
if ( a2 > 0 )
{
v4 = a1;
v5 = (long long)&a1[3 * (a2 - 1) + 3];
do
{
*a4 = *v4 + a3;
a4[1] = v4[1] + a3;
a4[2] = v4[2] + a3;
v4 += 3;
a4 += 3;
}
while ( v4 != (_DWORD *)v5 );
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a3
MOV RAX,RDI
LEA ESI,[RSI + -0x1]
LEA RSI,[RSI + RSI*0x2]
LEA RDI,[RDI + RSI*0x4 + 0xc]
LAB_00101180:
MOV ESI,EDX
ADD ESI,dword ptr [RAX]
MOV dword ptr [RCX],ESI
MOV ESI,EDX
ADD ESI,dword ptr [RAX + 0x4]
MOV dword ptr [RCX + 0x4],ESI
MOV ESI,EDX
ADD ESI,dword ptr [RAX + 0x8]
MOV dword ptr [RCX + 0x8],ESI
ADD RAX,0xc
ADD RCX,0xc
CMP RAX,RDI
JNZ 0x00101180
LAB_001011a3:
RET | void func0(int *param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 3 + 3;
do {
*param_4 = param_3 + *param_1;
param_4[1] = param_3 + param_1[1];
param_4[2] = param_3 + param_1[2];
param_1 = param_1 + 3;
param_4 = param_4 + 3;
} while (param_1 != piVar1);
}
return;
} |
5,346 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int test_list[][3], int size, int K, int result[][3]) {
for(int i = 0; i < size; i++) {
for(int j = 0; j < 3; j++) {
result[i][j] = test_list[i][j] + K;
}
}
}
| int main() {
int test_list1[3][3] = {{1, 3, 4}, {2, 4, 6}, {3, 8, 1}};
int result1[3][3];
func0(test_list1, 3, 4, result1);
int expected1[3][3] = {{5, 7, 8}, {6, 8, 10}, {7, 12, 5}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
int test_list2[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int result2[3][3];
func0(test_list2, 3, 8, result2);
int expected2[3][3] = {{9, 10, 11}, {12, 13, 14}, {15, 16, 17}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
int test_list3[3][3] = {{11, 12, 13}, {14, 15, 16}, {17, 18, 19}};
int result3[3][3];
func0(test_list3, 3, 9, result3);
int expected3[3][3] = {{20, 21, 22}, {23, 24, 25}, {26, 27, 28}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result3[i][j] == expected3[i][j]);
}
}
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 15bc <func0+0x3c>
lea -0x1(%rsi),%eax
lea (%rax,%rax,2),%rax
lea 0xc(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov (%rdi),%eax
add $0xc,%rdi
add $0xc,%rcx
add %edx,%eax
mov %eax,-0xc(%rcx)
mov -0x8(%rdi),%eax
add %edx,%eax
mov %eax,-0x8(%rcx)
mov -0x4(%rdi),%eax
add %edx,%eax
mov %eax,-0x4(%rcx)
cmp %rsi,%rdi
jne 1598 <func0+0x18>
retq
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short locret_152C
lea eax, [rsi-1]
lea rax, [rax+rax*2]
lea rsi, [rdi+rax*4+0Ch]
nop dword ptr [rax+00h]
loc_1508:
mov eax, [rdi]
add rdi, 0Ch
add rcx, 0Ch
add eax, edx
mov [rcx-0Ch], eax
mov eax, [rdi-8]
add eax, edx
mov [rcx-8], eax
mov eax, [rdi-4]
add eax, edx
mov [rcx-4], eax
cmp rdi, rsi
jnz short loc_1508
locret_152C:
retn | long long func0(int *a1, int a2, int a3, long long a4)
{
long long v4; // rsi
int v5; // eax
long long result; // rax
if ( a2 > 0 )
{
v4 = (long long)&a1[3 * (a2 - 1) + 3];
do
{
v5 = *a1;
a1 += 3;
a4 += 12LL;
*(_DWORD *)(a4 - 12) = a3 + v5;
*(_DWORD *)(a4 - 8) = a3 + *(a1 - 2);
result = (unsigned int)(a3 + *(a1 - 1));
*(_DWORD *)(a4 - 4) = result;
}
while ( a1 != (int *)v4 );
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010152c
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x2]
LEA RSI,[RDI + RAX*0x4 + 0xc]
NOP dword ptr [RAX]
LAB_00101508:
MOV EAX,dword ptr [RDI]
ADD RDI,0xc
ADD RCX,0xc
ADD EAX,EDX
MOV dword ptr [RCX + -0xc],EAX
MOV EAX,dword ptr [RDI + -0x8]
ADD EAX,EDX
MOV dword ptr [RCX + -0x8],EAX
MOV EAX,dword ptr [RDI + -0x4]
ADD EAX,EDX
MOV dword ptr [RCX + -0x4],EAX
CMP RDI,RSI
JNZ 0x00101508
LAB_0010152c:
RET | void func0(int *param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_2) {
piVar1 = param_1;
do {
piVar2 = piVar1 + 3;
*param_4 = *piVar1 + param_3;
param_4[1] = piVar1[1] + param_3;
param_4[2] = piVar1[2] + param_3;
param_4 = param_4 + 3;
piVar1 = piVar2;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) * 3 + 3);
}
return;
} |
5,347 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int test_list[][3], int size, int K, int result[][3]) {
for(int i = 0; i < size; i++) {
for(int j = 0; j < 3; j++) {
result[i][j] = test_list[i][j] + K;
}
}
}
| int main() {
int test_list1[3][3] = {{1, 3, 4}, {2, 4, 6}, {3, 8, 1}};
int result1[3][3];
func0(test_list1, 3, 4, result1);
int expected1[3][3] = {{5, 7, 8}, {6, 8, 10}, {7, 12, 5}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
int test_list2[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int result2[3][3];
func0(test_list2, 3, 8, result2);
int expected2[3][3] = {{9, 10, 11}, {12, 13, 14}, {15, 16, 17}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
int test_list3[3][3] = {{11, 12, 13}, {14, 15, 16}, {17, 18, 19}};
int result3[3][3];
func0(test_list3, 3, 9, result3);
int expected3[3][3] = {{20, 21, 22}, {23, 24, 25}, {26, 27, 28}};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
assert(result3[i][j] == expected3[i][j]);
}
}
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 160c <func0+0x15c>
lea 0x2f(%rdi),%rax
lea -0x1(%rsi),%r8d
sub %rcx,%rax
cmp $0x5e,%rax
jbe 15d8 <func0+0x128>
cmp $0x2,%r8d
jbe 15d8 <func0+0x128>
mov %esi,%r9d
movd %edx,%xmm4
mov %rdi,%rax
mov %rcx,%r8
shr $0x2,%r9d
pshufd $0x0,%xmm4,%xmm3
lea (%r9,%r9,2),%r9
shl $0x4,%r9
add %rdi,%r9
nopl 0x0(%rax)
movdqu 0x10(%rax),%xmm1
movdqu (%rax),%xmm2
add $0x30,%rax
add $0x30,%r8
movdqu -0x10(%rax),%xmm0
paddd %xmm3,%xmm1
paddd %xmm3,%xmm2
paddd %xmm3,%xmm0
movups %xmm2,-0x30(%r8)
movups %xmm1,-0x20(%r8)
movups %xmm0,-0x10(%r8)
cmp %r9,%rax
jne 1500 <func0+0x50>
mov %esi,%r9d
and $0xfffffffc,%r9d
test $0x3,%sil
je 160c <func0+0x15c>
mov %r9d,%eax
lea (%rax,%rax,2),%rax
shl $0x2,%rax
lea (%rdi,%rax,1),%r10
lea (%rcx,%rax,1),%r8
mov (%r10),%r11d
add %edx,%r11d
mov %r11d,(%r8)
mov 0x4(%r10),%r11d
add %edx,%r11d
mov %r11d,0x4(%r8)
mov 0x8(%r10),%r11d
add %edx,%r11d
mov %r11d,0x8(%r8)
lea 0x1(%r9),%r8d
cmp %r8d,%esi
jle 160c <func0+0x15c>
lea 0xc(%rax),%r8
add $0x2,%r9d
lea (%rdi,%r8,1),%r10
add %rcx,%r8
mov (%r10),%r11d
add %edx,%r11d
mov %r11d,(%r8)
mov 0x4(%r10),%r11d
add %edx,%r11d
mov %r11d,0x4(%r8)
mov 0x8(%r10),%r11d
add %edx,%r11d
mov %r11d,0x8(%r8)
cmp %r9d,%esi
jle 160c <func0+0x15c>
add $0x18,%rax
add %rax,%rdi
add %rax,%rcx
mov (%rdi),%eax
add %edx,%eax
mov %eax,(%rcx)
mov 0x4(%rdi),%eax
add %edx,%eax
mov %eax,0x4(%rcx)
add 0x8(%rdi),%edx
mov %edx,0x8(%rcx)
retq
lea (%r8,%r8,2),%rsi
mov %rdi,%rax
lea 0xc(%rdi,%rsi,4),%rdi
nopl 0x0(%rax)
mov (%rax),%esi
add $0xc,%rax
add $0xc,%rcx
add %edx,%esi
mov %esi,-0xc(%rcx)
mov -0x8(%rax),%esi
add %edx,%esi
mov %esi,-0x8(%rcx)
mov -0x4(%rax),%esi
add %edx,%esi
mov %esi,-0x4(%rcx)
cmp %rdi,%rax
jne 15e8 <func0+0x138>
retq
nopl (%rax)
| func0:
endbr64
movsxd r8, esi
mov rax, rdi
mov esi, edx
mov rdx, rcx
test r8d, r8d
jle short locret_1194
cmp r8d, 1
jz short loc_1167
lea rcx, [rdi+2Fh]
sub rcx, rdx
cmp rcx, 5Eh ; '^'
ja short loc_1198
loc_1167:
lea rcx, [r8+r8*2]
lea rdi, [rax+rcx*4]
nop
loc_1170:
mov ecx, [rax]
add rax, 0Ch
add rdx, 0Ch
add ecx, esi
mov [rdx-0Ch], ecx
mov ecx, [rax-8]
add ecx, esi
mov [rdx-8], ecx
mov ecx, [rax-4]
add ecx, esi
mov [rdx-4], ecx
cmp rax, rdi
jnz short loc_1170
locret_1194:
retn
loc_1198:
lea ecx, [r8-1]
mov r9d, r8d
cmp ecx, 2
jbe loc_129A
shr r9d, 2
movd xmm5, esi
mov rcx, rdi
mov rdi, rdx
lea r9, [r9+r9*2]
pshufd xmm3, xmm5, 0
shl r9, 4
add r9, rax
nop word ptr [rax+rax+00000000h]
loc_11D0:
movdqu xmm1, xmmword ptr [rcx+10h]
movdqu xmm2, xmmword ptr [rcx]
add rcx, 30h ; '0'
add rdi, 30h ; '0'
movdqu xmm0, xmmword ptr [rcx-10h]
paddd xmm1, xmm3
paddd xmm2, xmm3
paddd xmm0, xmm3
movups xmmword ptr [rdi-30h], xmm2
movups xmmword ptr [rdi-20h], xmm1
movups xmmword ptr [rdi-10h], xmm0
cmp rcx, r9
jnz short loc_11D0
mov ecx, r8d
and ecx, 0FFFFFFFCh
mov edi, ecx
cmp r8d, ecx
jz short locret_1194
sub r8d, ecx
mov r9d, r8d
cmp r8d, 1
jz short loc_1274
loc_121C:
lea rdi, [rdi+rdi*2]
movd xmm4, esi
shl rdi, 2
pshufd xmm0, xmm4, 0E0h
lea r8, [rax+rdi]
add rdi, rdx
movq xmm1, qword ptr [r8+8]
movq xmm3, qword ptr [r8]
movdqa xmm2, xmm1
movq xmm1, qword ptr [r8+10h]
paddd xmm2, xmm0
paddd xmm1, xmm0
paddd xmm0, xmm3
movq qword ptr [rdi+8], xmm2
movq qword ptr [rdi], xmm0
movq qword ptr [rdi+10h], xmm1
test r9b, 1
jz locret_1194
and r9d, 0FFFFFFFEh
add ecx, r9d
loc_1274:
movsxd rcx, ecx
lea rcx, [rcx+rcx*2]
shl rcx, 2
add rax, rcx
add rdx, rcx
mov ecx, [rax]
add ecx, esi
mov [rdx], ecx
mov ecx, [rax+4]
add ecx, esi
mov [rdx+4], ecx
add esi, [rax+8]
mov [rdx+8], esi
retn
loc_129A:
xor edi, edi
xor ecx, ecx
jmp loc_121C | const __m128i * func0(const __m128i *a1, int a2, unsigned int a3, long long a4)
{
long long v4; // r8
const __m128i *result; // rax
long long v7; // rdx
__int32 *v8; // rdi
__int32 v9; // ecx
int v10; // r9d
const __m128i *v11; // rcx
long long v12; // rdi
__m128i v13; // xmm3
__m128i v14; // xmm1
__m128i v15; // xmm2
__m128i v16; // xmm0
int v17; // ecx
long long v18; // rdi
long long v19; // rdi
__m128i v20; // xmm0
__int32 *v21; // r8
_QWORD *v22; // rdi
unsigned long long v23; // xmm2_8
unsigned long long v24; // xmm1_8
long long v25; // rcx
_DWORD *v26; // rdx
v4 = a2;
result = a1;
v7 = a4;
if ( (int)v4 > 0 )
{
if ( (_DWORD)v4 == 1 || (unsigned long long)&a1[2].m128i_u64[1] - a4 + 7 <= 0x5E )
{
v8 = &a1->m128i_i32[3 * v4];
do
{
v9 = result->m128i_i32[0];
result = (const __m128i *)((char *)result + 12);
v7 += 12LL;
*(_DWORD *)(v7 - 12) = a3 + v9;
*(_DWORD *)(v7 - 8) = a3 + result[-1].m128i_i32[2];
*(_DWORD *)(v7 - 4) = a3 + result[-1].m128i_i32[3];
}
while ( result != (const __m128i *)v8 );
return result;
}
v10 = v4;
if ( (unsigned int)(v4 - 1) <= 2 )
{
v18 = 0LL;
v17 = 0;
LABEL_12:
v19 = 3 * v18;
v20 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a3), 224);
v21 = &result->m128i_i32[v19];
v22 = (_QWORD *)(v7 + v19 * 4);
v23 = _mm_add_epi32(_mm_loadl_epi64((const __m128i *)(v21 + 2)), v20).m128i_u64[0];
v24 = _mm_add_epi32(_mm_loadl_epi64((const __m128i *)v21 + 1), v20).m128i_u64[0];
v20.m128i_i64[0] = _mm_add_epi32(v20, _mm_loadl_epi64((const __m128i *)v21)).m128i_u64[0];
v22[1] = v23;
*v22 = v20.m128i_i64[0];
v22[2] = v24;
if ( (v10 & 1) == 0 )
return result;
v17 += v10 & 0xFFFFFFFE;
LABEL_14:
v25 = 12LL * v17;
result = (const __m128i *)((char *)result + v25);
v26 = (_DWORD *)(v25 + v7);
*v26 = a3 + result->m128i_i32[0];
v26[1] = a3 + result->m128i_i32[1];
v26[2] = result->m128i_i32[2] + a3;
return result;
}
v11 = a1;
v12 = v7;
v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a3), 0);
do
{
v14 = _mm_loadu_si128(v11 + 1);
v15 = _mm_loadu_si128(v11);
v11 += 3;
v12 += 48LL;
v16 = _mm_add_epi32(_mm_loadu_si128(v11 - 1), v13);
*(__m128i *)(v12 - 48) = _mm_add_epi32(v15, v13);
*(__m128i *)(v12 - 32) = _mm_add_epi32(v14, v13);
*(__m128i *)(v12 - 16) = v16;
}
while ( v11 != &result[3 * ((unsigned int)v4 >> 2)] );
v17 = v4 & 0x7FFFFFFC;
v18 = (unsigned int)v4 & 0xFFFFFFFC;
if ( (_DWORD)v4 != (v4 & 0xFFFFFFFC) )
{
v10 = v4 - v17;
if ( (_DWORD)v4 - v17 == 1 )
goto LABEL_14;
goto LABEL_12;
}
}
return result;
} | func0:
ENDBR64
MOVSXD R8,ESI
MOV RAX,RDI
MOV ESI,EDX
MOV RDX,RCX
TEST R8D,R8D
JLE 0x00101194
CMP R8D,0x1
JZ 0x00101167
LEA RCX,[RDI + 0x2f]
SUB RCX,RDX
CMP RCX,0x5e
JA 0x00101198
LAB_00101167:
LEA RCX,[R8 + R8*0x2]
LEA RDI,[RAX + RCX*0x4]
NOP
LAB_00101170:
MOV ECX,dword ptr [RAX]
ADD RAX,0xc
ADD RDX,0xc
ADD ECX,ESI
MOV dword ptr [RDX + -0xc],ECX
MOV ECX,dword ptr [RAX + -0x8]
ADD ECX,ESI
MOV dword ptr [RDX + -0x8],ECX
MOV ECX,dword ptr [RAX + -0x4]
ADD ECX,ESI
MOV dword ptr [RDX + -0x4],ECX
CMP RAX,RDI
JNZ 0x00101170
LAB_00101194:
RET
LAB_00101198:
LEA ECX,[R8 + -0x1]
MOV R9D,R8D
CMP ECX,0x2
JBE 0x0010129a
SHR R9D,0x2
MOVD XMM5,ESI
MOV RCX,RDI
MOV RDI,RDX
LEA R9,[R9 + R9*0x2]
PSHUFD XMM3,XMM5,0x0
SHL R9,0x4
ADD R9,RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001011d0:
MOVDQU XMM1,xmmword ptr [RCX + 0x10]
MOVDQU XMM2,xmmword ptr [RCX]
ADD RCX,0x30
ADD RDI,0x30
MOVDQU XMM0,xmmword ptr [RCX + -0x10]
PADDD XMM1,XMM3
PADDD XMM2,XMM3
PADDD XMM0,XMM3
MOVUPS xmmword ptr [RDI + -0x30],XMM2
MOVUPS xmmword ptr [RDI + -0x20],XMM1
MOVUPS xmmword ptr [RDI + -0x10],XMM0
CMP RCX,R9
JNZ 0x001011d0
MOV ECX,R8D
AND ECX,0xfffffffc
MOV EDI,ECX
CMP R8D,ECX
JZ 0x00101194
SUB R8D,ECX
MOV R9D,R8D
CMP R8D,0x1
JZ 0x00101274
LAB_0010121c:
LEA RDI,[RDI + RDI*0x2]
MOVD XMM4,ESI
SHL RDI,0x2
PSHUFD XMM0,XMM4,0xe0
LEA R8,[RAX + RDI*0x1]
ADD RDI,RDX
MOVQ XMM1,qword ptr [R8 + 0x8]
MOVQ XMM3,qword ptr [R8]
MOVDQA XMM2,XMM1
MOVQ XMM1,qword ptr [R8 + 0x10]
PADDD XMM2,XMM0
PADDD XMM1,XMM0
PADDD XMM0,XMM3
MOVQ qword ptr [RDI + 0x8],XMM2
MOVQ qword ptr [RDI],XMM0
MOVQ qword ptr [RDI + 0x10],XMM1
TEST R9B,0x1
JZ 0x00101194
AND R9D,0xfffffffe
ADD ECX,R9D
LAB_00101274:
MOVSXD RCX,ECX
LEA RCX,[RCX + RCX*0x2]
SHL RCX,0x2
ADD RAX,RCX
ADD RDX,RCX
MOV ECX,dword ptr [RAX]
ADD ECX,ESI
MOV dword ptr [RDX],ECX
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
ADD ESI,dword ptr [RAX + 0x8]
MOV dword ptr [RDX + 0x8],ESI
RET
LAB_0010129a:
XOR EDI,EDI
XOR ECX,ECX
JMP 0x0010121c | void func0(int *param_1,uint param_2,int param_3,int *param_4)
{
int8 uVar1;
int8 uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int *piVar14;
uint uVar15;
int *piVar16;
int *piVar17;
ulong uVar18;
if (0 < (int)param_2) {
if ((param_2 == 1) || ((ulong)((long)param_1 + (0x2f - (long)param_4)) < 0x5f)) {
piVar14 = param_1;
do {
piVar17 = piVar14 + 3;
*param_4 = *piVar14 + param_3;
param_4[1] = piVar14[1] + param_3;
param_4[2] = piVar14[2] + param_3;
piVar14 = piVar17;
param_4 = param_4 + 3;
} while (piVar17 != param_1 + (long)(int)param_2 * 3);
return;
}
if (param_2 - 1 < 3) {
uVar18 = 0;
uVar15 = 0;
}
else {
piVar14 = param_1;
piVar17 = param_4;
do {
iVar3 = piVar14[4];
iVar4 = piVar14[5];
iVar5 = piVar14[6];
iVar6 = piVar14[7];
iVar7 = piVar14[1];
iVar8 = piVar14[2];
iVar9 = piVar14[3];
piVar16 = piVar14 + 0xc;
iVar10 = piVar14[8];
iVar11 = piVar14[9];
iVar12 = piVar14[10];
iVar13 = piVar14[0xb];
*piVar17 = *piVar14 + param_3;
piVar17[1] = iVar7 + param_3;
piVar17[2] = iVar8 + param_3;
piVar17[3] = iVar9 + param_3;
piVar17[4] = iVar3 + param_3;
piVar17[5] = iVar4 + param_3;
piVar17[6] = iVar5 + param_3;
piVar17[7] = iVar6 + param_3;
piVar17[8] = iVar10 + param_3;
piVar17[9] = iVar11 + param_3;
piVar17[10] = iVar12 + param_3;
piVar17[0xb] = iVar13 + param_3;
piVar14 = piVar16;
piVar17 = piVar17 + 0xc;
} while (piVar16 != param_1 + (ulong)(param_2 >> 2) * 0xc);
uVar15 = param_2 & 0xfffffffc;
uVar18 = (ulong)uVar15;
if (param_2 == uVar15) {
return;
}
param_2 = param_2 - uVar15;
if (param_2 == 1) goto LAB_00101274;
}
piVar14 = param_1 + uVar18 * 3;
piVar17 = param_4 + uVar18 * 3;
uVar1 = *(int8 *)piVar14;
uVar2 = *(int8 *)(piVar14 + 4);
*(ulong *)(piVar17 + 2) =
CONCAT44((int)((ulong)*(int8 *)(piVar14 + 2) >> 0x20) + param_3,
(int)*(int8 *)(piVar14 + 2) + param_3);
*(ulong *)piVar17 = CONCAT44(param_3 + (int)((ulong)uVar1 >> 0x20),param_3 + (int)uVar1);
*(ulong *)(piVar17 + 4) = CONCAT44((int)((ulong)uVar2 >> 0x20) + param_3,(int)uVar2 + param_3);
if ((param_2 & 1) != 0) {
uVar15 = uVar15 + (param_2 & 0xfffffffe);
LAB_00101274:
param_1 = param_1 + (long)(int)uVar15 * 3;
param_4 = param_4 + (long)(int)uVar15 * 3;
*param_4 = *param_1 + param_3;
param_4[1] = param_1[1] + param_3;
param_4[2] = param_3 + param_1[2];
return;
}
}
return;
} |
5,348 | func0 |
#include <assert.h>
#include <string.h>
char make_flip(char ch) {
return (ch == '0') ? '1' : '0';
}
int get_flip_with_starting_character(const char *str, char expected) {
int flip_count = 0;
int length = strlen(str);
for (int i = 0; i < length; i++) {
if (str[i] != expected) {
flip_count++;
}
expected = make_flip(expected);
}
return flip_count;
}
| int func0(const char *str) {
return (get_flip_with_starting_character(str, '0') < get_flip_with_starting_character(str, '1'))
? get_flip_with_starting_character(str, '0')
: get_flip_with_starting_character(str, '1');
}
| int main() {
assert(func0("0001010111") == 2);
assert(func0("001") == 1);
assert(func0("010111011") == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov $0x30,%esi
mov %rax,%rdi
callq 118a <get_flip_with_starting_character>
mov %eax,%ebx
mov -0x18(%rbp),%rax
mov $0x31,%esi
mov %rax,%rdi
callq 118a <get_flip_with_starting_character>
cmp %eax,%ebx
jge 1242 <func0+0x4c>
mov -0x18(%rbp),%rax
mov $0x30,%esi
mov %rax,%rdi
callq 118a <get_flip_with_starting_character>
jmp 1253 <func0+0x5d>
mov -0x18(%rbp),%rax
mov $0x31,%esi
mov %rax,%rdi
callq 118a <get_flip_with_starting_character>
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_18], rdi
mov rax, [rbp+var_18]
mov esi, 30h ; '0'
mov rdi, rax
call get_flip_with_starting_character
mov ebx, eax
mov rax, [rbp+var_18]
mov esi, 31h ; '1'
mov rdi, rax
call get_flip_with_starting_character
cmp ebx, eax
jge short loc_1242
mov rax, [rbp+var_18]
mov esi, 30h ; '0'
mov rdi, rax
call get_flip_with_starting_character
jmp short loc_1253
loc_1242:
mov rax, [rbp+var_18]
mov esi, 31h ; '1'
mov rdi, rax
call get_flip_with_starting_character
loc_1253:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
int flip_with_starting_character; // ebx
flip_with_starting_character = get_flip_with_starting_character(a1, 48LL);
if ( flip_with_starting_character >= (int)get_flip_with_starting_character(a1, 49LL) )
return get_flip_with_starting_character(a1, 49LL);
else
return get_flip_with_starting_character(a1, 48LL);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x30
MOV RDI,RAX
CALL 0x0010118a
MOV EBX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x31
MOV RDI,RAX
CALL 0x0010118a
CMP EBX,EAX
JGE 0x00101242
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x30
MOV RDI,RAX
CALL 0x0010118a
JMP 0x00101253
LAB_00101242:
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,0x31
MOV RDI,RAX
CALL 0x0010118a
LAB_00101253:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void func0(int8 param_1)
{
int iVar1;
int iVar2;
iVar1 = get_flip_with_starting_character(param_1,0x30);
iVar2 = get_flip_with_starting_character(param_1,0x31);
if (iVar1 < iVar2) {
get_flip_with_starting_character(param_1,0x30);
}
else {
get_flip_with_starting_character(param_1,0x31);
}
return;
} |
5,349 | func0 |
#include <assert.h>
#include <string.h>
char make_flip(char ch) {
return (ch == '0') ? '1' : '0';
}
int get_flip_with_starting_character(const char *str, char expected) {
int flip_count = 0;
int length = strlen(str);
for (int i = 0; i < length; i++) {
if (str[i] != expected) {
flip_count++;
}
expected = make_flip(expected);
}
return flip_count;
}
| int func0(const char *str) {
return (get_flip_with_starting_character(str, '0') < get_flip_with_starting_character(str, '1'))
? get_flip_with_starting_character(str, '0')
: get_flip_with_starting_character(str, '1');
}
| int main() {
assert(func0("0001010111") == 2);
assert(func0("001") == 1);
assert(func0("010111011") == 2);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov $0x30,%esi
callq 1158 <get_flip_with_starting_character>
mov %eax,%ebx
mov $0x31,%esi
mov %rbp,%rdi
callq 1158 <get_flip_with_starting_character>
cmp %eax,%ebx
cmovle %ebx,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov esi, 30h ; '0'
call get_flip_with_starting_character
mov ebx, eax
mov esi, 31h ; '1'
mov rdi, rbp
call get_flip_with_starting_character
cmp ebx, eax
cmovle eax, ebx
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1)
{
int flip_with_starting_character; // ebx
long long result; // rax
flip_with_starting_character = get_flip_with_starting_character(a1, 48LL);
result = get_flip_with_starting_character(a1, 49LL);
if ( flip_with_starting_character <= (int)result )
return (unsigned int)flip_with_starting_character;
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV ESI,0x30
CALL 0x00101178
MOV EBX,EAX
MOV ESI,0x31
MOV RDI,RBP
CALL 0x00101178
CMP EBX,EAX
CMOVLE EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(int8 param_1)
{
int iVar1;
int iVar2;
iVar1 = get_flip_with_starting_character(param_1,0x30);
iVar2 = get_flip_with_starting_character(param_1,0x31);
if (iVar1 <= iVar2) {
iVar2 = iVar1;
}
return iVar2;
} |
5,350 | func0 |
#include <assert.h>
#include <string.h>
char make_flip(char ch) {
return (ch == '0') ? '1' : '0';
}
int get_flip_with_starting_character(const char *str, char expected) {
int flip_count = 0;
int length = strlen(str);
for (int i = 0; i < length; i++) {
if (str[i] != expected) {
flip_count++;
}
expected = make_flip(expected);
}
return flip_count;
}
| int func0(const char *str) {
return (get_flip_with_starting_character(str, '0') < get_flip_with_starting_character(str, '1'))
? get_flip_with_starting_character(str, '0')
: get_flip_with_starting_character(str, '1');
}
| int main() {
assert(func0("0001010111") == 2);
assert(func0("001") == 1);
assert(func0("010111011") == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov $0x30,%esi
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1220 <get_flip_with_starting_character>
mov %rbp,%rdi
mov $0x31,%esi
mov %eax,%ebx
callq 1220 <get_flip_with_starting_character>
cmp %eax,%ebx
cmovle %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_1308
sub eax, 1
mov rdi, rbx
xor ecx, ecx
mov edx, 30h ; '0'
lea rsi, [rbx+rax+1]
mov r9d, 61h ; 'a'
mov rax, rbx
nop dword ptr [rax+00h]
loc_12B0:
xor r8d, r8d
mov ebx, r9d
cmp [rax], dl
setnz r8b
sub ebx, edx
add rax, 1
add ecx, r8d
mov edx, ebx
cmp rax, rsi
jnz short loc_12B0
xor eax, eax
mov edx, 31h ; '1'
mov r9d, 61h ; 'a'
nop dword ptr [rax+00000000h]
loc_12E0:
xor r8d, r8d
mov ebx, r9d
cmp [rdi], dl
setnz r8b
sub ebx, edx
add rdi, 1
add eax, r8d
mov edx, ebx
cmp rdi, rsi
jnz short loc_12E0
cmp eax, ecx
pop rbx
cmovg eax, ecx
retn
loc_1308:
xor eax, eax
pop rbx
retn | long long func0(_BYTE *a1)
{
int v1; // eax
int v2; // ecx
int v3; // edx
long long v4; // rsi
_BYTE *v5; // rax
int v6; // r8d
long long result; // rax
int v8; // edx
BOOL v9; // r8d
v1 = strlen();
if ( v1 <= 0 )
return 0LL;
v2 = 0;
v3 = 48;
v4 = (long long)&a1[v1 - 1 + 1];
v5 = a1;
do
{
v6 = *v5++ != (unsigned __int8)v3;
v2 += v6;
v3 = 97 - v3;
}
while ( v5 != (_BYTE *)v4 );
LODWORD(result) = 0;
v8 = 49;
do
{
v9 = *a1++ != (unsigned __int8)v8;
result = (unsigned int)(v9 + result);
v8 = 97 - v8;
}
while ( a1 != (_BYTE *)v4 );
if ( (int)result > v2 )
return (unsigned int)v2;
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101308
SUB EAX,0x1
MOV RDI,RBX
XOR ECX,ECX
MOV EDX,0x30
LEA RSI,[RBX + RAX*0x1 + 0x1]
MOV R9D,0x61
MOV RAX,RBX
NOP dword ptr [RAX]
LAB_001012b0:
XOR R8D,R8D
MOV EBX,R9D
CMP byte ptr [RAX],DL
SETNZ R8B
SUB EBX,EDX
ADD RAX,0x1
ADD ECX,R8D
MOV EDX,EBX
CMP RAX,RSI
JNZ 0x001012b0
XOR EAX,EAX
MOV EDX,0x31
MOV R9D,0x61
NOP dword ptr [RAX]
LAB_001012e0:
XOR R8D,R8D
MOV EBX,R9D
CMP byte ptr [RDI],DL
SETNZ R8B
SUB EBX,EDX
ADD RDI,0x1
ADD EAX,R8D
MOV EDX,EBX
CMP RDI,RSI
JNZ 0x001012e0
CMP EAX,ECX
POP RBX
CMOVG EAX,ECX
RET
LAB_00101308:
XOR EAX,EAX
POP RBX
RET | int func0(char *param_1)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
int iVar5;
char cVar6;
bool bVar7;
sVar3 = strlen(param_1);
if (0 < (int)sVar3) {
iVar5 = 0;
cVar6 = '0';
pcVar1 = param_1 + (ulong)((int)sVar3 - 1) + 1;
pcVar4 = param_1;
do {
bVar7 = *pcVar4 != cVar6;
cVar6 = 'a' - cVar6;
pcVar4 = pcVar4 + 1;
iVar5 = iVar5 + (uint)bVar7;
} while (pcVar4 != pcVar1);
iVar2 = 0;
cVar6 = '1';
do {
bVar7 = *param_1 != cVar6;
cVar6 = 'a' - cVar6;
param_1 = param_1 + 1;
iVar2 = iVar2 + (uint)bVar7;
} while (param_1 != pcVar1);
if (iVar5 < iVar2) {
iVar2 = iVar5;
}
return iVar2;
}
return 0;
} |
5,351 | func0 |
#include <assert.h>
#include <string.h>
char make_flip(char ch) {
return (ch == '0') ? '1' : '0';
}
int get_flip_with_starting_character(const char *str, char expected) {
int flip_count = 0;
int length = strlen(str);
for (int i = 0; i < length; i++) {
if (str[i] != expected) {
flip_count++;
}
expected = make_flip(expected);
}
return flip_count;
}
| int func0(const char *str) {
return (get_flip_with_starting_character(str, '0') < get_flip_with_starting_character(str, '1'))
? get_flip_with_starting_character(str, '0')
: get_flip_with_starting_character(str, '1');
}
| int main() {
assert(func0("0001010111") == 2);
assert(func0("001") == 1);
assert(func0("010111011") == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %eax,%eax
jle 1308 <func0+0x88>
sub $0x1,%eax
mov %rbx,%rdi
mov %rbx,%rdx
xor %ecx,%ecx
lea 0x1(%rbx,%rax,1),%rsi
mov $0x61,%r9d
mov $0x30,%eax
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r9d,%ebx
cmp (%rdx),%al
setne %r8b
sub %eax,%ebx
add $0x1,%rdx
add %r8d,%ecx
mov %ebx,%eax
cmp %rsi,%rdx
jne 12b0 <func0+0x30>
xor %eax,%eax
mov $0x31,%edx
mov $0x61,%r9d
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r9d,%ebx
cmp (%rdi),%dl
setne %r8b
sub %edx,%ebx
add $0x1,%rdi
add %r8d,%eax
mov %ebx,%edx
cmp %rsi,%rdi
jne 12e0 <func0+0x60>
cmp %ecx,%eax
pop %rbx
cmovg %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_1308
sub eax, 1
mov rdi, rbx
xor ecx, ecx
mov edx, 30h ; '0'
lea rsi, [rbx+rax+1]
mov r9d, 61h ; 'a'
mov rax, rbx
nop dword ptr [rax+00h]
loc_12B0:
xor r8d, r8d
mov ebx, r9d
cmp dl, [rax]
setnz r8b
sub ebx, edx
add rax, 1
add ecx, r8d
mov edx, ebx
cmp rax, rsi
jnz short loc_12B0
xor eax, eax
mov edx, 31h ; '1'
mov r9d, 61h ; 'a'
nop dword ptr [rax+00000000h]
loc_12E0:
xor r8d, r8d
mov ebx, r9d
cmp dl, [rdi]
setnz r8b
sub ebx, edx
add rdi, 1
add eax, r8d
mov edx, ebx
cmp rdi, rsi
jnz short loc_12E0
cmp eax, ecx
pop rbx
cmovg eax, ecx
retn
loc_1308:
xor eax, eax
pop rbx
retn | long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
int v3; // edx
long long v4; // rsi
const char *v5; // rax
int v6; // r8d
long long result; // rax
int v8; // edx
_BOOL4 v9; // r8d
v1 = strlen(a1);
if ( v1 <= 0 )
return 0LL;
v2 = 0;
v3 = 48;
v4 = (long long)&a1[v1 - 1 + 1];
v5 = a1;
do
{
v6 = (_BYTE)v3 != *v5++;
v2 += v6;
v3 = 97 - v3;
}
while ( v5 != (const char *)v4 );
LODWORD(result) = 0;
v8 = 49;
do
{
v9 = (_BYTE)v8 != *a1++;
result = (unsigned int)(v9 + result);
v8 = 97 - v8;
}
while ( a1 != (const char *)v4 );
if ( (int)result > v2 )
return (unsigned int)v2;
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101308
SUB EAX,0x1
MOV RDI,RBX
XOR ECX,ECX
MOV EDX,0x30
LEA RSI,[RBX + RAX*0x1 + 0x1]
MOV R9D,0x61
MOV RAX,RBX
NOP dword ptr [RAX]
LAB_001012b0:
XOR R8D,R8D
MOV EBX,R9D
CMP DL,byte ptr [RAX]
SETNZ R8B
SUB EBX,EDX
ADD RAX,0x1
ADD ECX,R8D
MOV EDX,EBX
CMP RAX,RSI
JNZ 0x001012b0
XOR EAX,EAX
MOV EDX,0x31
MOV R9D,0x61
NOP dword ptr [RAX]
LAB_001012e0:
XOR R8D,R8D
MOV EBX,R9D
CMP DL,byte ptr [RDI]
SETNZ R8B
SUB EBX,EDX
ADD RDI,0x1
ADD EAX,R8D
MOV EDX,EBX
CMP RDI,RSI
JNZ 0x001012e0
CMP EAX,ECX
POP RBX
CMOVG EAX,ECX
RET
LAB_00101308:
XOR EAX,EAX
POP RBX
RET | int func0(char *param_1)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
int iVar5;
char cVar6;
bool bVar7;
sVar3 = strlen(param_1);
if (0 < (int)sVar3) {
iVar5 = 0;
cVar6 = '0';
pcVar1 = param_1 + (ulong)((int)sVar3 - 1) + 1;
pcVar4 = param_1;
do {
bVar7 = cVar6 != *pcVar4;
cVar6 = 'a' - cVar6;
pcVar4 = pcVar4 + 1;
iVar5 = iVar5 + (uint)bVar7;
} while (pcVar4 != pcVar1);
iVar2 = 0;
cVar6 = '1';
do {
bVar7 = cVar6 != *param_1;
cVar6 = 'a' - cVar6;
param_1 = param_1 + 1;
iVar2 = iVar2 + (uint)bVar7;
} while (param_1 != pcVar1);
if (iVar5 < iVar2) {
iVar2 = iVar5;
}
return iVar2;
}
return 0;
} |
5,352 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n != 0) {
n /= 10;
count += 1;
}
return count;
}
| int main() {
assert(func0(12345) == 5);
assert(func0(11223305) == 8);
assert(func0(4123459) == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
jmp 117f <func0+0x36>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x14(%rbp)
addl $0x1,-0x4(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 115d <func0+0x14>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_117F
loc_115D:
mov eax, [rbp+var_14]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_14], eax
add [rbp+var_4], 1
loc_117F:
cmp [rbp+var_14], 0
jnz short loc_115D
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
unsigned int v3; // [rsp+10h] [rbp-4h]
v3 = 0;
while ( a1 )
{
a1 /= 10;
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010117f
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117f:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010115d
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
int4 local_1c;
int4 local_c;
local_c = 0;
for (local_1c = param_1; local_1c != 0; local_1c = local_1c / 10) {
local_c = local_c + 1;
}
return local_c;
} |
5,353 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n != 0) {
n /= 10;
count += 1;
}
return count;
}
| int main() {
assert(func0(12345) == 5);
assert(func0(11223305) == 8);
assert(func0(4123459) == 7);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
je 1175 <func0+0x2c>
mov $0x0,%edx
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sar $0x1f,%edi
sub %edi,%eax
mov %eax,%edi
add $0x1,%edx
test %eax,%eax
jne 1156 <func0+0xd>
mov %edx,%eax
retq
mov %edi,%edx
jmp 1172 <func0+0x29>
| func0:
endbr64
test edi, edi
jz short loc_1175
mov edx, 0
loc_1156:
movsxd rax, edi
imul rax, 66666667h
sar rax, 22h
sar edi, 1Fh
sub eax, edi
mov edi, eax
add edx, 1
test eax, eax
jnz short loc_1156
loc_1172:
mov eax, edx
retn
loc_1175:
mov edx, edi
jmp short loc_1172 | long long func0(int a1)
{
unsigned int v1; // edx
if ( a1 )
{
v1 = 0;
do
{
a1 /= 10;
++v1;
}
while ( a1 );
}
else
{
return 0;
}
return v1;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101175
MOV EDX,0x0
LAB_00101156:
MOVSXD RAX,EDI
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
SAR EDI,0x1f
SUB EAX,EDI
MOV EDI,EAX
ADD EDX,0x1
TEST EAX,EAX
JNZ 0x00101156
LAB_00101172:
MOV EAX,EDX
RET
LAB_00101175:
MOV EDX,EDI
JMP 0x00101172 | int func0(int param_1)
{
int iVar1;
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = 0;
do {
param_1 = param_1 / 10;
iVar1 = iVar1 + 1;
} while (param_1 != 0);
}
return iVar1;
} |
5,354 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n != 0) {
n /= 10;
count += 1;
}
return count;
}
| int main() {
assert(func0(12345) == 5);
assert(func0(11223305) == 8);
assert(func0(4123459) == 7);
return 0;
}
| O2 | c | func0:
endbr64
xor %r8d,%r8d
test %edi,%edi
je 116b <func0+0x2b>
nopl 0x0(%rax,%rax,1)
movslq %edi,%rax
sar $0x1f,%edi
add $0x1,%r8d
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sub %edi,%eax
mov %eax,%edi
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
| func0:
endbr64
xor r8d, r8d
test edi, edi
jz short loc_116D
nop dword ptr [rax+rax+00h]
loc_1150:
movsxd rax, edi
mov edx, edi
add r8d, 1
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
mov edi, eax
jnz short loc_1150
loc_116D:
mov eax, r8d
retn | long long func0(int a1)
{
unsigned int i; // r8d
for ( i = 0; a1; a1 /= 10 )
++i;
return i;
} | func0:
ENDBR64
XOR R8D,R8D
TEST EDI,EDI
JZ 0x0010116d
NOP dword ptr [RAX + RAX*0x1]
LAB_00101150:
MOVSXD RAX,EDI
MOV EDX,EDI
ADD R8D,0x1
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
MOV EDI,EAX
JNZ 0x00101150
LAB_0010116d:
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
iVar1 = 0;
if (param_1 != 0) {
do {
iVar1 = iVar1 + 1;
param_1 = param_1 / 10;
} while (param_1 != 0);
}
return iVar1;
} |
5,355 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
while (n != 0) {
n /= 10;
count += 1;
}
return count;
}
| int main() {
assert(func0(12345) == 5);
assert(func0(11223305) == 8);
assert(func0(4123459) == 7);
return 0;
}
| O3 | c | func0:
endbr64
xor %r8d,%r8d
test %edi,%edi
je 116b <func0+0x2b>
nopl 0x0(%rax,%rax,1)
movslq %edi,%rax
sar $0x1f,%edi
add $0x1,%r8d
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sub %edi,%eax
mov %eax,%edi
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
| func0:
endbr64
xor ecx, ecx
test edi, edi
jz short loc_116C
nop word ptr [rax+rax+00h]
loc_1150:
movsxd rax, edi
mov edx, edi
add ecx, 1
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
mov edi, eax
jnz short loc_1150
loc_116C:
mov eax, ecx
retn | long long func0(int a1)
{
unsigned int i; // ecx
for ( i = 0; a1; a1 /= 10 )
++i;
return i;
} | func0:
ENDBR64
XOR ECX,ECX
TEST EDI,EDI
JZ 0x0010116c
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
MOVSXD RAX,EDI
MOV EDX,EDI
ADD ECX,0x1
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
MOV EDI,EAX
JNZ 0x00101150
LAB_0010116c:
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
iVar1 = 0;
if (param_1 != 0) {
do {
iVar1 = iVar1 + 1;
param_1 = param_1 / 10;
} while (param_1 != 0);
}
return iVar1;
} |
5,356 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int list_nums[], size_t list_length) {
int max_product = list_nums[0] * list_nums[1];
for (size_t i = 1; i < list_length - 1; i++) {
int product = list_nums[i] * list_nums[i + 1];
if (product > max_product) {
max_product = product;
}
}
return max_product;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {1, 2, 3, 4, 5};
int list3[] = {2, 3};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 30);
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 20);
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
add $0x4,%rax
mov (%rax),%eax
imul %edx,%eax
mov %eax,-0x10(%rbp)
movq $0x1,-0x8(%rbp)
jmp 11e0 <func0+0x77>
mov -0x8(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
imul %edx,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x10(%rbp),%eax
jle 11db <func0+0x72>
mov -0xc(%rbp),%eax
mov %eax,-0x10(%rbp)
addq $0x1,-0x8(%rbp)
mov -0x20(%rbp),%rax
sub $0x1,%rax
cmp %rax,-0x8(%rbp)
jb 1199 <func0+0x30>
mov -0x10(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_18]
mov edx, [rax]
mov rax, [rbp+var_18]
add rax, 4
mov eax, [rax]
imul eax, edx
mov [rbp+var_10], eax
mov [rbp+var_8], 1
jmp short loc_11E0
loc_1199:
mov rax, [rbp+var_8]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_8]
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
imul eax, edx
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jle short loc_11DB
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
loc_11DB:
add [rbp+var_8], 1
loc_11E0:
mov rax, [rbp+var_20]
sub rax, 1
cmp [rbp+var_8], rax
jb short loc_1199
mov eax, [rbp+var_10]
pop rbp
retn | long long func0(_DWORD *a1, long long a2)
{
int v3; // [rsp+10h] [rbp-10h]
unsigned long long i; // [rsp+18h] [rbp-8h]
v3 = *a1 * a1[1];
for ( i = 1LL; i < a2 - 1; ++i )
{
if ( a1[i] * a1[i + 1] > v3 )
v3 = a1[i] * a1[i + 1];
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x10],EAX
MOV qword ptr [RBP + -0x8],0x1
JMP 0x001011e0
LAB_00101199:
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JLE 0x001011db
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
LAB_001011db:
ADD qword ptr [RBP + -0x8],0x1
LAB_001011e0:
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,0x1
CMP qword ptr [RBP + -0x8],RAX
JC 0x00101199
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET | int func0(int *param_1,long param_2)
{
int local_18;
ulong local_10;
local_18 = param_1[1] * *param_1;
for (local_10 = 1; local_10 < param_2 - 1U; local_10 = local_10 + 1) {
if (local_18 < param_1[local_10 + 1] * param_1[local_10]) {
local_18 = param_1[local_10 + 1] * param_1[local_10];
}
}
return local_18;
} |
5,357 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int list_nums[], size_t list_length) {
int max_product = list_nums[0] * list_nums[1];
for (size_t i = 1; i < list_length - 1; i++) {
int product = list_nums[i] * list_nums[i + 1];
if (product > max_product) {
max_product = product;
}
}
return max_product;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {1, 2, 3, 4, 5};
int list3[] = {2, 3};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 30);
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 20);
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 6);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
lea -0x1(%rsi),%rdx
cmp $0x1,%rdx
jbe 119a <func0+0x31>
lea 0x4(%rdi),%rdx
lea -0x4(%rdi,%rsi,4),%rsi
mov (%rdx),%ecx
imul 0x4(%rdx),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x4,%rdx
cmp %rsi,%rdx
jne 1186 <func0+0x1d>
retq
| func0:
endbr64
mov eax, [rdi]
imul eax, [rdi+4]
lea rdx, [rsi-1]
cmp rdx, 1
jbe short locret_119A
lea rdx, [rdi+4]
lea rsi, [rdi+rsi*4-4]
loc_1186:
mov ecx, [rdx]
imul ecx, [rdx+4]
cmp eax, ecx
cmovl eax, ecx
add rdx, 4
cmp rdx, rsi
jnz short loc_1186
locret_119A:
retn | long long func0(_DWORD *a1, long long a2)
{
long long result; // rax
_DWORD *v3; // rdx
long long v4; // rsi
int v5; // ecx
result = (unsigned int)(a1[1] * *a1);
if ( (unsigned long long)(a2 - 1) > 1 )
{
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 1];
do
{
v5 = v3[1] * *v3;
if ( (int)result < v5 )
result = (unsigned int)v5;
++v3;
}
while ( v3 != (_DWORD *)v4 );
}
return result;
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
LEA RDX,[RSI + -0x1]
CMP RDX,0x1
JBE 0x0010119a
LEA RDX,[RDI + 0x4]
LEA RSI,[RDI + RSI*0x4 + -0x4]
LAB_00101186:
MOV ECX,dword ptr [RDX]
IMUL ECX,dword ptr [RDX + 0x4]
CMP EAX,ECX
CMOVL EAX,ECX
ADD RDX,0x4
CMP RDX,RSI
JNZ 0x00101186
LAB_0010119a:
RET | void func0(int *param_1,long param_2)
{
int iVar1;
int *piVar2;
iVar1 = *param_1 * param_1[1];
if (1 < param_2 - 1U) {
piVar2 = param_1 + 1;
do {
if (iVar1 < *piVar2 * piVar2[1]) {
iVar1 = *piVar2 * piVar2[1];
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + param_2 + -1);
}
return;
} |
5,358 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int list_nums[], size_t list_length) {
int max_product = list_nums[0] * list_nums[1];
for (size_t i = 1; i < list_length - 1; i++) {
int product = list_nums[i] * list_nums[i + 1];
if (product > max_product) {
max_product = product;
}
}
return max_product;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {1, 2, 3, 4, 5};
int list3[] = {2, 3};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 30);
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 20);
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 6);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rsi),%rdx
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cmp $0x1,%rdx
jbe 1178 <func0+0x38>
mov 0x4(%rdi),%r8d
lea 0x8(%rdi),%rcx
lea (%rdi,%rsi,4),%rsi
mov %r8d,%edx
mov (%rcx),%r8d
imul %r8d,%edx
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rcx
cmp %rcx,%rsi
jne 1160 <func0+0x20>
retq
nopl 0x0(%rax)
| func0:
endbr64
mov ecx, [rdi+4]
mov r8d, [rdi]
lea rax, [rsi-1]
imul r8d, ecx
cmp rax, 1
jbe short loc_12C7
lea rdx, [rdi+8]
lea rsi, [rdi+rsi*4]
loc_12B0:
mov eax, ecx
mov ecx, [rdx]
imul eax, ecx
cmp r8d, eax
cmovl r8d, eax
add rdx, 4
cmp rsi, rdx
jnz short loc_12B0
loc_12C7:
mov eax, r8d
retn | long long func0(_DWORD *a1, long long a2)
{
int v2; // ecx
int v3; // r8d
int *v4; // rdx
int *v5; // rsi
int v6; // eax
int v7; // eax
v2 = a1[1];
v3 = v2 * *a1;
if ( (unsigned long long)(a2 - 1) > 1 )
{
v4 = a1 + 2;
v5 = &a1[a2];
do
{
v6 = v2;
v2 = *v4;
v7 = *v4 * v6;
if ( v3 < v7 )
v3 = v7;
++v4;
}
while ( v5 != v4 );
}
return (unsigned int)v3;
} | func0:
ENDBR64
MOV ECX,dword ptr [RDI + 0x4]
MOV R8D,dword ptr [RDI]
LEA RAX,[RSI + -0x1]
IMUL R8D,ECX
CMP RAX,0x1
JBE 0x001012c7
LEA RDX,[RDI + 0x8]
LEA RSI,[RDI + RSI*0x4]
LAB_001012b0:
MOV EAX,ECX
MOV ECX,dword ptr [RDX]
IMUL EAX,ECX
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDX,0x4
CMP RSI,RDX
JNZ 0x001012b0
LAB_001012c7:
MOV EAX,R8D
RET | int func0(int *param_1,long param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar4 = *param_1 * param_1[1];
if (1 < param_2 - 1U) {
piVar3 = param_1 + 2;
iVar2 = param_1[1];
do {
iVar1 = *piVar3;
iVar2 = iVar2 * iVar1;
if (iVar4 < iVar2) {
iVar4 = iVar2;
}
piVar3 = piVar3 + 1;
iVar2 = iVar1;
} while (param_1 + param_2 != piVar3);
}
return iVar4;
} |
5,359 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int list_nums[], size_t list_length) {
int max_product = list_nums[0] * list_nums[1];
for (size_t i = 1; i < list_length - 1; i++) {
int product = list_nums[i] * list_nums[i + 1];
if (product > max_product) {
max_product = product;
}
}
return max_product;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {1, 2, 3, 4, 5};
int list3[] = {2, 3};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 30);
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 20);
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 6);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%r8
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cmp $0x1,%r8
jbe 1262 <func0+0x122>
lea -0x2(%rsi),%rcx
sub $0x3,%rsi
cmp $0x2,%rsi
jbe 1269 <func0+0x129>
mov %rcx,%rdx
movd %eax,%xmm5
mov %rdi,%rax
shr $0x2,%rdx
pshufd $0x0,%xmm5,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax)
movdqu 0x4(%rax),%xmm1
movdqu 0x8(%rax),%xmm3
add $0x10,%rax
movdqu -0xc(%rax),%xmm0
movdqu -0x8(%rax),%xmm4
psrlq $0x20,%xmm1
psrlq $0x20,%xmm3
pmuludq %xmm4,%xmm0
pmuludq %xmm3,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 1188 <func0+0x48>
movdqa %xmm2,%xmm1
mov %rcx,%rsi
psrldq $0x8,%xmm1
and $0xfffffffffffffffc,%rsi
movdqa %xmm1,%xmm0
lea 0x1(%rsi),%rdx
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
cmp %rcx,%rsi
je 1268 <func0+0x128>
mov 0x4(%rdi,%rdx,4),%ecx
mov (%rdi,%rdx,4),%esi
imul %ecx,%esi
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rdx),%rsi
cmp %r8,%rsi
jae 1262 <func0+0x122>
lea 0x2(%rdx),%r9
mov (%rdi,%r9,4),%esi
imul %esi,%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
cmp %r9,%r8
jbe 1262 <func0+0x122>
imul 0xc(%rdi,%rdx,4),%esi
cmp %esi,%eax
cmovl %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
mov $0x1,%edx
jmp 122b <func0+0xeb>
| func0:
endbr64
lea r8, [rsi-1]
mov eax, [rdi]
imul eax, [rdi+4]
cmp r8, 1
jbe locret_126A
lea rdx, [rsi-2]
sub rsi, 3
cmp rsi, 2
jbe loc_126B
mov rcx, rdx
movd xmm5, eax
mov rax, rdi
shr rcx, 2
pshufd xmm3, xmm5, 0
shl rcx, 4
add rcx, rdi
nop dword ptr [rax+00h]
loc_1188:
movdqu xmm1, xmmword ptr [rax+4]
movdqu xmm2, xmmword ptr [rax+8]
add rax, 10h
movdqu xmm0, xmmword ptr [rax-0Ch]
movdqu xmm4, xmmword ptr [rax-8]
psrlq xmm1, 20h ; ' '
psrlq xmm2, 20h ; ' '
pmuludq xmm0, xmm4
pmuludq xmm1, xmm2
pshufd xmm0, xmm0, 8
pshufd xmm1, xmm1, 8
punpckldq xmm0, xmm1
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm3
pand xmm0, xmm1
pandn xmm1, xmm3
movdqa xmm3, xmm1
por xmm3, xmm0
cmp rax, rcx
jnz short loc_1188
movdqa xmm1, xmm3
psrldq xmm1, 8
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm3
pand xmm1, xmm0
pandn xmm0, xmm3
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd eax, xmm1
test dl, 3
jz short locret_126A
and rdx, 0FFFFFFFFFFFFFFFCh
add rdx, 1
loc_1228:
lea r9, ds:0[rdx*4]
mov esi, [rdi+rdx*4]
mov ecx, [rdi+r9+4]
imul esi, ecx
cmp eax, esi
cmovl eax, esi
lea rsi, [rdx+1]
cmp rsi, r8
jnb short locret_126A
mov esi, [rdi+r9+8]
imul ecx, esi
cmp eax, ecx
cmovl eax, ecx
add rdx, 2
cmp rdx, r8
jnb short locret_126A
imul esi, [rdi+r9+0Ch]
cmp eax, esi
cmovl eax, esi
locret_126A:
retn
loc_126B:
mov edx, 1
jmp short loc_1228 | long long func0(_DWORD *a1, long long a2)
{
unsigned long long v2; // r8
long long result; // rax
unsigned long long v4; // rdx
__m128i v5; // xmm5
_DWORD *v6; // rax
__m128i v7; // xmm3
__m128i v8; // xmm1
__m128i v9; // xmm2
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm1
__m128i v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm2
__m128i v16; // xmm1
unsigned long long v17; // rdx
long long v18; // r9
int v19; // ecx
int v20; // esi
int v21; // esi
int v22; // ecx
int v23; // esi
v2 = a2 - 1;
result = (unsigned int)(a1[1] * *a1);
if ( (unsigned long long)(a2 - 1) > 1 )
{
v4 = a2 - 2;
if ( (unsigned long long)(a2 - 3) <= 2 )
{
v17 = 1LL;
}
else
{
v5 = _mm_cvtsi32_si128(result);
v6 = a1;
v7 = _mm_shuffle_epi32(v5, 0);
do
{
v8 = _mm_loadu_si128((const __m128i *)(v6 + 1));
v9 = _mm_loadu_si128((const __m128i *)(v6 + 2));
v6 += 4;
v10 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(
_mm_mul_epu32(_mm_loadu_si128((const __m128i *)(v6 - 3)), _mm_loadu_si128((const __m128i *)(v6 - 2))),
8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v8, 0x20u), _mm_srli_epi64(v9, 0x20u)), 8));
v11 = _mm_cmpgt_epi32(v10, v7);
v7 = _mm_or_si128(_mm_andnot_si128(v11, v7), _mm_and_si128(v10, v11));
}
while ( v6 != &a1[4 * (v4 >> 2)] );
v12 = _mm_srli_si128(v7, 8);
v13 = _mm_cmpgt_epi32(v12, v7);
v14 = _mm_or_si128(_mm_andnot_si128(v13, v7), _mm_and_si128(v12, v13));
v15 = _mm_srli_si128(v14, 4);
v16 = _mm_cmpgt_epi32(v15, v14);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v16, v14), _mm_and_si128(v15, v16)));
if ( (v4 & 3) == 0 )
return result;
v17 = (v4 & 0xFFFFFFFFFFFFFFFCLL) + 1;
}
v18 = v17;
v19 = a1[v17 + 1];
v20 = v19 * a1[v17];
if ( (int)result < v20 )
result = (unsigned int)v20;
if ( v17 + 1 < v2 )
{
v21 = a1[v18 + 2];
v22 = v21 * v19;
if ( (int)result < v22 )
result = (unsigned int)v22;
if ( v17 + 2 < v2 )
{
v23 = a1[v18 + 3] * v21;
if ( (int)result < v23 )
return (unsigned int)v23;
}
}
}
return result;
} | func0:
ENDBR64
LEA R8,[RSI + -0x1]
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
CMP R8,0x1
JBE 0x0010126a
LEA RDX,[RSI + -0x2]
SUB RSI,0x3
CMP RSI,0x2
JBE 0x0010126b
MOV RCX,RDX
MOVD XMM5,EAX
MOV RAX,RDI
SHR RCX,0x2
PSHUFD XMM3,XMM5,0x0
SHL RCX,0x4
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101188:
MOVDQU XMM1,xmmword ptr [RAX + 0x4]
MOVDQU XMM2,xmmword ptr [RAX + 0x8]
ADD RAX,0x10
MOVDQU XMM0,xmmword ptr [RAX + -0xc]
MOVDQU XMM4,xmmword ptr [RAX + -0x8]
PSRLQ XMM1,0x20
PSRLQ XMM2,0x20
PMULUDQ XMM0,XMM4
PMULUDQ XMM1,XMM2
PSHUFD XMM0,XMM0,0x8
PSHUFD XMM1,XMM1,0x8
PUNPCKLDQ XMM0,XMM1
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM3
PAND XMM0,XMM1
PANDN XMM1,XMM3
MOVDQA XMM3,XMM1
POR XMM3,XMM0
CMP RAX,RCX
JNZ 0x00101188
MOVDQA XMM1,XMM3
PSRLDQ XMM1,0x8
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM3
PAND XMM1,XMM0
PANDN XMM0,XMM3
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EAX,XMM1
TEST DL,0x3
JZ 0x0010126a
AND RDX,-0x4
ADD RDX,0x1
LAB_00101228:
LEA R9,[RDX*0x4]
MOV ESI,dword ptr [RDI + RDX*0x4]
MOV ECX,dword ptr [RDI + R9*0x1 + 0x4]
IMUL ESI,ECX
CMP EAX,ESI
CMOVL EAX,ESI
LEA RSI,[RDX + 0x1]
CMP RSI,R8
JNC 0x0010126a
MOV ESI,dword ptr [RDI + R9*0x1 + 0x8]
IMUL ECX,ESI
CMP EAX,ECX
CMOVL EAX,ECX
ADD RDX,0x2
CMP RDX,R8
JNC 0x0010126a
IMUL ESI,dword ptr [RDI + R9*0x1 + 0xc]
CMP EAX,ESI
CMOVL EAX,ESI
LAB_0010126a:
RET
LAB_0010126b:
MOV EDX,0x1
JMP 0x00101228 | uint func0(int *param_1,long param_2)
{
ulong uVar1;
ulong uVar2;
uint uVar3;
int *piVar4;
int *piVar5;
long lVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uVar1 = param_2 - 1;
uVar3 = *param_1 * param_1[1];
if (1 < uVar1) {
uVar2 = param_2 - 2;
if (param_2 - 3U < 3) {
lVar6 = 1;
}
else {
piVar4 = param_1;
uVar7 = uVar3;
uVar12 = uVar3;
uVar17 = uVar3;
do {
piVar5 = piVar4 + 4;
uVar8 = (uint)((*(ulong *)(piVar4 + 1) & 0xffffffff) * (ulong)(uint)piVar4[2]);
uVar9 = (uint)((*(ulong *)(piVar4 + 3) & 0xffffffff) * (ulong)(uint)piVar4[4]);
uVar10 = (uint)((*(ulong *)(piVar4 + 1) >> 0x20) * (*(ulong *)(piVar4 + 2) >> 0x20));
uVar14 = (uint)((*(ulong *)(piVar4 + 3) >> 0x20) * (*(ulong *)(piVar4 + 4) >> 0x20));
uVar11 = -(uint)((int)uVar3 < (int)uVar8);
uVar13 = -(uint)((int)uVar7 < (int)uVar10);
uVar15 = -(uint)((int)uVar12 < (int)uVar9);
uVar16 = -(uint)((int)uVar17 < (int)uVar14);
uVar3 = ~uVar11 & uVar3 | uVar8 & uVar11;
uVar7 = ~uVar13 & uVar7 | uVar10 & uVar13;
uVar12 = ~uVar15 & uVar12 | uVar9 & uVar15;
uVar17 = ~uVar16 & uVar17 | uVar14 & uVar16;
piVar4 = piVar5;
} while (piVar5 != param_1 + (uVar2 & 0xfffffffffffffffc));
uVar3 = ~-(uint)((int)uVar3 < (int)uVar12) & uVar3 |
uVar12 & -(uint)((int)uVar3 < (int)uVar12);
uVar7 = ~-(uint)((int)uVar7 < (int)uVar17) & uVar7 |
uVar17 & -(uint)((int)uVar7 < (int)uVar17);
uVar12 = -(uint)((int)uVar3 < (int)uVar7);
uVar3 = ~uVar12 & uVar3 | uVar7 & uVar12;
if ((uVar2 & 3) == 0) {
return uVar3;
}
lVar6 = (uVar2 & 0xfffffffffffffffc) + 1;
}
uVar7 = param_1[lVar6] * param_1[lVar6 + 1];
if ((int)uVar3 < (int)uVar7) {
uVar3 = uVar7;
}
if (lVar6 + 1U < uVar1) {
uVar7 = param_1[lVar6 + 1] * param_1[lVar6 + 2];
if ((int)uVar3 < (int)uVar7) {
uVar3 = uVar7;
}
if ((lVar6 + 2U < uVar1) &&
(uVar7 = param_1[lVar6 + 2] * param_1[lVar6 + 3], (int)uVar3 < (int)uVar7)) {
uVar3 = uVar7;
}
}
}
return uVar3;
} |
5,360 | func0 |
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
} Node;
Node* newNode(int data) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
int get_height(Node* root) {
if (root == NULL) {
return 0;
}
int leftHeight = get_height(root->left);
int rightHeight = get_height(root->right);
return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}
| bool func0(Node* root) {
if (root == NULL) {
return true;
}
int lh = get_height(root->left);
int rh = get_height(root->right);
if (abs(lh - rh) <= 1 && func0(root->left) && func0(root->right)) {
return true;
}
return false;
}
| int main() {
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->left->left->left = newNode(8);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->left->right = newNode(5);
root1->right->left = newNode(6);
root1->left->left->left = newNode(7);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(7);
assert(func0(root) == false);
assert(func0(root1) == true);
assert(func0(root2) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 121e <func0+0x1e>
mov $0x1,%eax
jmp 128e <func0+0x8e>
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov %rax,%rdi
callq 11ad <get_height>
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov 0x10(%rax),%rax
mov %rax,%rdi
callq 11ad <get_height>
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
sub -0x4(%rbp),%eax
cmp $0xffffffff,%eax
jl 1289 <func0+0x89>
mov -0x8(%rbp),%eax
sub -0x4(%rbp),%eax
cmp $0x1,%eax
jg 1289 <func0+0x89>
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov %rax,%rdi
callq 1200 <func0>
test %al,%al
je 1289 <func0+0x89>
mov -0x18(%rbp),%rax
mov 0x10(%rax),%rax
mov %rax,%rdi
callq 1200 <func0>
test %al,%al
je 1289 <func0+0x89>
mov $0x1,%eax
jmp 128e <func0+0x8e>
mov $0x0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
cmp [rbp+var_18], 0
jnz short loc_121F
mov eax, 1
jmp short locret_128F
loc_121F:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdi, rax
call get_height
mov [rbp+var_8], eax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rdi, rax
call get_height
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
sub eax, [rbp+var_4]
cmp eax, 0FFFFFFFFh
jl short loc_128A
mov eax, [rbp+var_8]
sub eax, [rbp+var_4]
cmp eax, 1
jg short loc_128A
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdi, rax
call func0
test al, al
jz short loc_128A
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rdi, rax
call func0
test al, al
jz short loc_128A
mov eax, 1
jmp short locret_128F
loc_128A:
mov eax, 0
locret_128F:
leave
retn | _BOOL8 func0(long long a1)
{
int height; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
if ( !a1 )
return 1LL;
height = get_height(*(_QWORD *)(a1 + 8));
v3 = get_height(*(_QWORD *)(a1 + 16));
return height - v3 >= -1
&& height - v3 <= 1
&& (unsigned __int8)func0(*(_QWORD *)(a1 + 8))
&& (unsigned __int8)func0(*(_QWORD *)(a1 + 16));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0010121f
MOV EAX,0x1
JMP 0x0010128f
LAB_0010121f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,RAX
CALL 0x001011ad
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,RAX
CALL 0x001011ad
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0x4]
CMP EAX,-0x1
JL 0x0010128a
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0x4]
CMP EAX,0x1
JG 0x0010128a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,RAX
CALL 0x00101201
TEST AL,AL
JZ 0x0010128a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,RAX
CALL 0x00101201
TEST AL,AL
JZ 0x0010128a
MOV EAX,0x1
JMP 0x0010128f
LAB_0010128a:
MOV EAX,0x0
LAB_0010128f:
LEAVE
RET | int8 func0(long param_1)
{
char cVar1;
int iVar2;
int iVar3;
int8 uVar4;
if (param_1 == 0) {
uVar4 = 1;
}
else {
iVar2 = get_height(*(int8 *)(param_1 + 8));
iVar3 = get_height(*(int8 *)(param_1 + 0x10));
if ((((-2 < iVar2 - iVar3) && (iVar2 - iVar3 < 2)) &&
(cVar1 = func0(*(int8 *)(param_1 + 8)), cVar1 != '\0')) &&
(cVar1 = func0(*(int8 *)(param_1 + 0x10)), cVar1 != '\0')) {
return 1;
}
uVar4 = 0;
}
return uVar4;
} |
5,361 | func0 |
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
} Node;
Node* newNode(int data) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
int get_height(Node* root) {
if (root == NULL) {
return 0;
}
int leftHeight = get_height(root->left);
int rightHeight = get_height(root->right);
return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}
| bool func0(Node* root) {
if (root == NULL) {
return true;
}
int lh = get_height(root->left);
int rh = get_height(root->right);
if (abs(lh - rh) <= 1 && func0(root->left) && func0(root->right)) {
return true;
}
return false;
}
| int main() {
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->left->left->left = newNode(8);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->left->right = newNode(5);
root1->right->left = newNode(6);
root1->left->left->left = newNode(7);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(7);
assert(func0(root) == false);
assert(func0(root1) == true);
assert(func0(root2) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %rdi,%rdi
je 1222 <func0+0x59>
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov 0x8(%rdi),%r12
mov %r12,%rdi
callq 118e <get_height>
mov %eax,%ebx
mov 0x10(%rbp),%rbp
mov %rbp,%rdi
callq 118e <get_height>
sub %eax,%ebx
add $0x1,%ebx
mov $0x0,%eax
cmp $0x2,%ebx
jbe 120c <func0+0x43>
pop %rbx
pop %rbp
pop %r12
retq
mov %r12,%rdi
callq 11c9 <func0>
test %al,%al
je 1207 <func0+0x3e>
mov %rbp,%rdi
callq 11c9 <func0>
jmp 1207 <func0+0x3e>
retq
| func0:
endbr64
mov eax, 1
test rdi, rdi
jz short locret_1222
push r12
push rbp
push rbx
mov rbp, rdi
mov r12, [rdi+8]
mov rdi, r12
call get_height
mov ebx, eax
mov rbp, [rbp+10h]
mov rdi, rbp
call get_height
sub ebx, eax
add ebx, 1
mov eax, 0
cmp ebx, 2
jbe short loc_120C
loc_1207:
pop rbx
pop rbp
pop r12
retn
loc_120C:
mov rdi, r12
call func0
test al, al
jz short loc_1207
mov rdi, rbp
call func0
jmp short loc_1207
locret_1222:
retn | long long func0(long long a1)
{
long long result; // rax
long long v2; // r12
int height; // ebx
long long v4; // rbp
unsigned int v5; // ebx
result = 1LL;
if ( a1 )
{
v2 = *(_QWORD *)(a1 + 8);
height = get_height(v2);
v4 = *(_QWORD *)(a1 + 16);
v5 = height - get_height(v4) + 1;
result = 0LL;
if ( v5 <= 2 )
{
result = func0(v2);
if ( (_BYTE)result )
return func0(v4);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST RDI,RDI
JZ 0x00101222
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RDI,R12
CALL 0x0010118e
MOV EBX,EAX
MOV RBP,qword ptr [RBP + 0x10]
MOV RDI,RBP
CALL 0x0010118e
SUB EBX,EAX
ADD EBX,0x1
MOV EAX,0x0
CMP EBX,0x2
JBE 0x0010120c
LAB_00101207:
POP RBX
POP RBP
POP R12
RET
LAB_0010120c:
MOV RDI,R12
CALL 0x001011c9
TEST AL,AL
JZ 0x00101207
MOV RDI,RBP
CALL 0x001011c9
JMP 0x00101207
LAB_00101222:
RET | int8 func0(long param_1)
{
int8 uVar1;
int8 uVar2;
int iVar3;
int iVar4;
int8 uVar5;
if (param_1 != 0) {
uVar1 = *(int8 *)(param_1 + 8);
iVar3 = get_height(uVar1);
uVar2 = *(int8 *)(param_1 + 0x10);
iVar4 = get_height(uVar2);
uVar5 = 0;
if ((iVar3 - iVar4) + 1U < 3) {
uVar5 = func0(uVar1);
if ((char)uVar5 != '\0') {
uVar5 = func0(uVar2);
}
}
return uVar5;
}
return 1;
} |
5,362 | func0 |
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
} Node;
Node* newNode(int data) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
int get_height(Node* root) {
if (root == NULL) {
return 0;
}
int leftHeight = get_height(root->left);
int rightHeight = get_height(root->right);
return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}
| bool func0(Node* root) {
if (root == NULL) {
return true;
}
int lh = get_height(root->left);
int rh = get_height(root->right);
if (abs(lh - rh) <= 1 && func0(root->left) && func0(root->right)) {
return true;
}
return false;
}
| int main() {
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->left->left->left = newNode(8);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->left->right = newNode(5);
root1->right->left = newNode(6);
root1->left->left->left = newNode(7);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(7);
assert(func0(root) == false);
assert(func0(root1) == true);
assert(func0(root2) == false);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
test %rbx,%rbx
je 1540 <func0+0x70>
mov 0x8(%rbx),%r12
test %r12,%r12
je 1518 <func0+0x48>
mov %r12,%rdi
callq 14a0 <get_height.part.0>
mov 0x10(%rbx),%rbx
mov %eax,%ebp
test %rbx,%rbx
je 1506 <func0+0x36>
mov %rbx,%rdi
callq 14a0 <get_height.part.0>
sub %eax,%ebp
add $0x1,%ebp
cmp $0x2,%ebp
jbe 1528 <func0+0x58>
pop %rbx
xor %eax,%eax
pop %rbp
pop %r12
retq
nopl (%rax)
mov 0x10(%rbx),%rbx
test %rbx,%rbx
je 1540 <func0+0x70>
xor %ebp,%ebp
jmp 14fc <func0+0x2c>
nopl (%rax)
mov %r12,%rdi
callq 14d0 <func0>
test %al,%al
jne 14db <func0+0xb>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
loc_1A48:
test rbx, rbx
jz loc_1C98
mov r8, [rbx+8]
test r8, r8
jz loc_1C60
mov r9, [r8+8]
xor esi, esi
test r9, r9
jz short loc_1AD7
mov rsi, [r9+8]
xor ecx, ecx
test rsi, rsi
jz short loc_1A9C
mov rdi, [rsi+8]
test rdi, rdi
jz short loc_1A84
call get_height_part_0
mov ecx, eax
loc_1A84:
mov rdi, [rsi+10h]
xor eax, eax
test rdi, rdi
jz short loc_1A94
call get_height_part_0
loc_1A94:
cmp eax, ecx
cmovl eax, ecx
lea ecx, [rax+1]
loc_1A9C:
mov r9, [r9+10h]
xor esi, esi
test r9, r9
jz short loc_1ACF
mov rdi, [r9+8]
test rdi, rdi
jz short loc_1AB7
call get_height_part_0
mov esi, eax
loc_1AB7:
mov rdi, [r9+10h]
xor eax, eax
test rdi, rdi
jz short loc_1AC7
call get_height_part_0
loc_1AC7:
cmp eax, esi
cmovge esi, eax
add esi, 1
loc_1ACF:
cmp esi, ecx
cmovl esi, ecx
add esi, 1
loc_1AD7:
mov r10, [r8+10h]
xor ecx, ecx
test r10, r10
jz short loc_1B54
mov r11, [r10+8]
xor r9d, r9d
test r11, r11
jz short loc_1B17
mov rdi, [r11+8]
test rdi, rdi
jz short loc_1AFE
call get_height_part_0
mov ecx, eax
loc_1AFE:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1B0E
call get_height_part_0
loc_1B0E:
cmp eax, ecx
cmovl eax, ecx
lea r9d, [rax+1]
loc_1B17:
mov r10, [r10+10h]
xor ecx, ecx
test r10, r10
jz short loc_1B4A
mov rdi, [r10+8]
test rdi, rdi
jz short loc_1B32
call get_height_part_0
mov ecx, eax
loc_1B32:
mov rdi, [r10+10h]
xor eax, eax
test rdi, rdi
jz short loc_1B42
call get_height_part_0
loc_1B42:
cmp eax, ecx
cmovge ecx, eax
add ecx, 1
loc_1B4A:
cmp ecx, r9d
cmovl ecx, r9d
add ecx, 1
loc_1B54:
cmp ecx, esi
mov rbx, [rbx+10h]
cmovl ecx, esi
add ecx, 1
test rbx, rbx
jz loc_1C53
mov r10, [rbx+8]
xor esi, esi
test r10, r10
jz short loc_1BC3
loc_1B74:
mov r11, [r10+8]
xor r9d, r9d
test r11, r11
jz short loc_1BA9
mov rdi, [r11+8]
test rdi, rdi
jz short loc_1B90
call get_height_part_0
mov esi, eax
loc_1B90:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1BA0
call get_height_part_0
loc_1BA0:
cmp eax, esi
cmovl eax, esi
lea r9d, [rax+1]
loc_1BA9:
mov rdi, [r10+10h]
xor eax, eax
test rdi, rdi
jz short loc_1BB9
call get_height_part_0
loc_1BB9:
cmp eax, r9d
cmovl eax, r9d
lea esi, [rax+1]
loc_1BC3:
mov r10, [rbx+10h]
xor eax, eax
test r10, r10
jz short loc_1C49
mov r11, [r10+8]
xor r9d, r9d
test r11, r11
jz short loc_1C06
mov rdi, [r11+8]
test rdi, rdi
jz short loc_1BEB
call get_height_part_0
mov r9d, eax
loc_1BEB:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1BFB
call get_height_part_0
loc_1BFB:
cmp eax, r9d
cmovl eax, r9d
lea r9d, [rax+1]
loc_1C06:
mov r11, [r10+10h]
xor eax, eax
test r11, r11
jz short loc_1C3F
mov rdi, [r11+8]
xor r10d, r10d
test rdi, rdi
jz short loc_1C25
call get_height_part_0
mov r10d, eax
loc_1C25:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1C35
call get_height_part_0
loc_1C35:
cmp eax, r10d
cmovl eax, r10d
add eax, 1
loc_1C3F:
cmp eax, r9d
cmovl eax, r9d
add eax, 1
loc_1C49:
cmp eax, esi
cmovl eax, esi
add eax, 1
sub ecx, eax
loc_1C53:
add ecx, 1
cmp ecx, 2
jbe short loc_1C80
xor eax, eax
pop rbx
retn
loc_1C60:
mov rbx, [rbx+10h]
test rbx, rbx
jz short loc_1C98
mov r10, [rbx+8]
xor ecx, ecx
xor esi, esi
test r10, r10
jnz loc_1B74
jmp loc_1BC3
loc_1C80:
mov rdi, r8
call func0
test al, al
jnz loc_1A48
pop rbx
retn
loc_1C98:
mov eax, 1
pop rbx
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v4; // r8
long long v5; // r9
long long v6; // rsi
long long v7; // rsi
long long v8; // rcx
long long v9; // rdi
long long v10; // rdi
int v11; // eax
long long v12; // r9
long long v13; // rsi
long long v14; // rdi
long long v15; // rdi
int v16; // eax
long long v17; // r10
long long v18; // rcx
long long v19; // r11
int v20; // r9d
long long v21; // rdi
long long v22; // rdi
int v23; // eax
long long v24; // r10
long long v25; // rdi
long long v26; // rdi
int v27; // eax
long long v28; // rcx
long long v29; // r10
long long height_part_0; // rsi
long long v31; // r11
int v32; // r9d
long long v33; // rdi
long long v34; // rdi
int v35; // eax
long long v36; // rdi
int v37; // eax
long long v38; // r10
int v39; // eax
long long v40; // r11
int v41; // r9d
long long v42; // rdi
long long v43; // rdi
int v44; // eax
long long v45; // r11
int v46; // eax
long long v47; // rdi
int v48; // r10d
long long v49; // rdi
int v50; // eax
long long result; // rax
while ( a1 )
{
v4 = *(_QWORD *)(a1 + 8);
if ( !v4 )
{
a1 = *(_QWORD *)(a1 + 16);
if ( !a1 )
return 1LL;
v29 = *(_QWORD *)(a1 + 8);
v28 = 0LL;
height_part_0 = 0LL;
if ( v29 )
{
LABEL_47:
v31 = *(_QWORD *)(v29 + 8);
v32 = 0;
if ( v31 )
{
v33 = *(_QWORD *)(v31 + 8);
if ( v33 )
height_part_0 = (unsigned int)get_height_part_0(v33, 0LL, a3, v28);
v34 = *(_QWORD *)(v31 + 16);
v35 = 0;
if ( v34 )
v35 = get_height_part_0(v34, height_part_0, a3, v28);
if ( v35 < (int)height_part_0 )
v35 = height_part_0;
v32 = v35 + 1;
}
v36 = *(_QWORD *)(v29 + 16);
v37 = 0;
if ( v36 )
v37 = get_height_part_0(v36, height_part_0, a3, v28);
if ( v37 < v32 )
v37 = v32;
height_part_0 = (unsigned int)(v37 + 1);
}
LABEL_60:
v38 = *(_QWORD *)(a1 + 16);
v39 = 0;
if ( v38 )
{
v40 = *(_QWORD *)(v38 + 8);
v41 = 0;
if ( v40 )
{
v42 = *(_QWORD *)(v40 + 8);
if ( v42 )
v41 = get_height_part_0(v42, height_part_0, a3, v28);
v43 = *(_QWORD *)(v40 + 16);
v44 = 0;
if ( v43 )
v44 = get_height_part_0(v43, height_part_0, a3, v28);
if ( v44 < v41 )
v44 = v41;
v41 = v44 + 1;
}
v45 = *(_QWORD *)(v38 + 16);
v46 = 0;
if ( v45 )
{
v47 = *(_QWORD *)(v45 + 8);
v48 = 0;
if ( v47 )
v48 = get_height_part_0(v47, height_part_0, a3, v28);
v49 = *(_QWORD *)(v45 + 16);
v50 = 0;
if ( v49 )
v50 = get_height_part_0(v49, height_part_0, a3, v28);
if ( v50 < v48 )
v50 = v48;
v46 = v50 + 1;
}
if ( v46 < v41 )
v46 = v41;
v39 = v46 + 1;
}
if ( v39 < (int)height_part_0 )
v39 = height_part_0;
LODWORD(v28) = v28 - (v39 + 1);
goto LABEL_83;
}
v5 = *(_QWORD *)(v4 + 8);
v6 = 0LL;
if ( v5 )
{
v7 = *(_QWORD *)(v5 + 8);
v8 = 0LL;
if ( v7 )
{
v9 = *(_QWORD *)(v7 + 8);
if ( v9 )
v8 = (unsigned int)get_height_part_0(v9, v7, a3, 0LL);
v10 = *(_QWORD *)(v7 + 16);
v11 = 0;
if ( v10 )
v11 = get_height_part_0(v10, v7, a3, v8);
if ( v11 < (int)v8 )
v11 = v8;
v8 = (unsigned int)(v11 + 1);
}
v12 = *(_QWORD *)(v5 + 16);
v13 = 0LL;
if ( v12 )
{
v14 = *(_QWORD *)(v12 + 8);
if ( v14 )
v13 = (unsigned int)get_height_part_0(v14, 0LL, a3, v8);
v15 = *(_QWORD *)(v12 + 16);
v16 = 0;
if ( v15 )
v16 = get_height_part_0(v15, v13, a3, v8);
if ( v16 >= (int)v13 )
LODWORD(v13) = v16;
LODWORD(v13) = v13 + 1;
}
if ( (int)v13 < (int)v8 )
LODWORD(v13) = v8;
v6 = (unsigned int)(v13 + 1);
}
v17 = *(_QWORD *)(v4 + 16);
v18 = 0LL;
if ( v17 )
{
v19 = *(_QWORD *)(v17 + 8);
v20 = 0;
if ( v19 )
{
v21 = *(_QWORD *)(v19 + 8);
if ( v21 )
v18 = (unsigned int)get_height_part_0(v21, v6, a3, 0LL);
v22 = *(_QWORD *)(v19 + 16);
v23 = 0;
if ( v22 )
v23 = get_height_part_0(v22, v6, a3, v18);
if ( v23 < (int)v18 )
v23 = v18;
v20 = v23 + 1;
}
v24 = *(_QWORD *)(v17 + 16);
v18 = 0LL;
if ( v24 )
{
v25 = *(_QWORD *)(v24 + 8);
if ( v25 )
v18 = (unsigned int)get_height_part_0(v25, v6, a3, 0LL);
v26 = *(_QWORD *)(v24 + 16);
v27 = 0;
if ( v26 )
v27 = get_height_part_0(v26, v6, a3, v18);
if ( v27 >= (int)v18 )
LODWORD(v18) = v27;
LODWORD(v18) = v18 + 1;
}
if ( (int)v18 < v20 )
LODWORD(v18) = v20;
LODWORD(v18) = v18 + 1;
}
a1 = *(_QWORD *)(a1 + 16);
if ( (int)v18 < (int)v6 )
LODWORD(v18) = v6;
v28 = (unsigned int)(v18 + 1);
if ( a1 )
{
v29 = *(_QWORD *)(a1 + 8);
height_part_0 = 0LL;
if ( v29 )
goto LABEL_47;
goto LABEL_60;
}
LABEL_83:
if ( (unsigned int)(v28 + 1) > 2 )
return 0LL;
result = func0(v4);
if ( !(_BYTE)result )
return result;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
LAB_00101a48:
TEST RBX,RBX
JZ 0x00101c98
MOV R8,qword ptr [RBX + 0x8]
TEST R8,R8
JZ 0x00101c60
MOV R9,qword ptr [R8 + 0x8]
XOR ESI,ESI
TEST R9,R9
JZ 0x00101ad7
MOV RSI,qword ptr [R9 + 0x8]
XOR ECX,ECX
TEST RSI,RSI
JZ 0x00101a9c
MOV RDI,qword ptr [RSI + 0x8]
TEST RDI,RDI
JZ 0x00101a84
CALL 0x001013e0
MOV ECX,EAX
LAB_00101a84:
MOV RDI,qword ptr [RSI + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101a94
CALL 0x001013e0
LAB_00101a94:
CMP EAX,ECX
CMOVL EAX,ECX
LEA ECX,[RAX + 0x1]
LAB_00101a9c:
MOV R9,qword ptr [R9 + 0x10]
XOR ESI,ESI
TEST R9,R9
JZ 0x00101acf
MOV RDI,qword ptr [R9 + 0x8]
TEST RDI,RDI
JZ 0x00101ab7
CALL 0x001013e0
MOV ESI,EAX
LAB_00101ab7:
MOV RDI,qword ptr [R9 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101ac7
CALL 0x001013e0
LAB_00101ac7:
CMP EAX,ESI
CMOVGE ESI,EAX
ADD ESI,0x1
LAB_00101acf:
CMP ESI,ECX
CMOVL ESI,ECX
ADD ESI,0x1
LAB_00101ad7:
MOV R10,qword ptr [R8 + 0x10]
XOR ECX,ECX
TEST R10,R10
JZ 0x00101b54
MOV R11,qword ptr [R10 + 0x8]
XOR R9D,R9D
TEST R11,R11
JZ 0x00101b17
MOV RDI,qword ptr [R11 + 0x8]
TEST RDI,RDI
JZ 0x00101afe
CALL 0x001013e0
MOV ECX,EAX
LAB_00101afe:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101b0e
CALL 0x001013e0
LAB_00101b0e:
CMP EAX,ECX
CMOVL EAX,ECX
LEA R9D,[RAX + 0x1]
LAB_00101b17:
MOV R10,qword ptr [R10 + 0x10]
XOR ECX,ECX
TEST R10,R10
JZ 0x00101b4a
MOV RDI,qword ptr [R10 + 0x8]
TEST RDI,RDI
JZ 0x00101b32
CALL 0x001013e0
MOV ECX,EAX
LAB_00101b32:
MOV RDI,qword ptr [R10 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101b42
CALL 0x001013e0
LAB_00101b42:
CMP EAX,ECX
CMOVGE ECX,EAX
ADD ECX,0x1
LAB_00101b4a:
CMP ECX,R9D
CMOVL ECX,R9D
ADD ECX,0x1
LAB_00101b54:
CMP ECX,ESI
MOV RBX,qword ptr [RBX + 0x10]
CMOVL ECX,ESI
ADD ECX,0x1
TEST RBX,RBX
JZ 0x00101c53
MOV R10,qword ptr [RBX + 0x8]
XOR ESI,ESI
TEST R10,R10
JZ 0x00101bc3
LAB_00101b74:
MOV R11,qword ptr [R10 + 0x8]
XOR R9D,R9D
TEST R11,R11
JZ 0x00101ba9
MOV RDI,qword ptr [R11 + 0x8]
TEST RDI,RDI
JZ 0x00101b90
CALL 0x001013e0
MOV ESI,EAX
LAB_00101b90:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101ba0
CALL 0x001013e0
LAB_00101ba0:
CMP EAX,ESI
CMOVL EAX,ESI
LEA R9D,[RAX + 0x1]
LAB_00101ba9:
MOV RDI,qword ptr [R10 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101bb9
CALL 0x001013e0
LAB_00101bb9:
CMP EAX,R9D
CMOVL EAX,R9D
LEA ESI,[RAX + 0x1]
LAB_00101bc3:
MOV R10,qword ptr [RBX + 0x10]
XOR EAX,EAX
TEST R10,R10
JZ 0x00101c49
MOV R11,qword ptr [R10 + 0x8]
XOR R9D,R9D
TEST R11,R11
JZ 0x00101c06
MOV RDI,qword ptr [R11 + 0x8]
TEST RDI,RDI
JZ 0x00101beb
CALL 0x001013e0
MOV R9D,EAX
LAB_00101beb:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101bfb
CALL 0x001013e0
LAB_00101bfb:
CMP EAX,R9D
CMOVL EAX,R9D
LEA R9D,[RAX + 0x1]
LAB_00101c06:
MOV R11,qword ptr [R10 + 0x10]
XOR EAX,EAX
TEST R11,R11
JZ 0x00101c3f
MOV RDI,qword ptr [R11 + 0x8]
XOR R10D,R10D
TEST RDI,RDI
JZ 0x00101c25
CALL 0x001013e0
MOV R10D,EAX
LAB_00101c25:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101c35
CALL 0x001013e0
LAB_00101c35:
CMP EAX,R10D
CMOVL EAX,R10D
ADD EAX,0x1
LAB_00101c3f:
CMP EAX,R9D
CMOVL EAX,R9D
ADD EAX,0x1
LAB_00101c49:
CMP EAX,ESI
CMOVL EAX,ESI
ADD EAX,0x1
SUB ECX,EAX
LAB_00101c53:
ADD ECX,0x1
CMP ECX,0x2
JBE 0x00101c80
XOR EAX,EAX
POP RBX
RET
LAB_00101c60:
MOV RBX,qword ptr [RBX + 0x10]
TEST RBX,RBX
JZ 0x00101c98
MOV R10,qword ptr [RBX + 0x8]
XOR ECX,ECX
XOR ESI,ESI
TEST R10,R10
JNZ 0x00101b74
JMP 0x00101bc3
LAB_00101c80:
MOV RDI,R8
CALL 0x00101a40
TEST AL,AL
JNZ 0x00101a48
POP RBX
RET
LAB_00101c98:
MOV EAX,0x1
POP RBX
RET | int8 func0(long param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int8 uVar6;
long lVar7;
long lVar8;
long lVar9;
do {
if (param_1 == 0) {
return 1;
}
lVar8 = *(long *)(param_1 + 8);
if (lVar8 == 0) {
param_1 = *(long *)(param_1 + 0x10);
if (param_1 == 0) {
return 1;
}
lVar9 = *(long *)(param_1 + 8);
iVar2 = 0;
joined_r0x00101c74:
iVar1 = 0;
if (lVar9 != 0) {
iVar1 = 0;
lVar7 = *(long *)(lVar9 + 8);
iVar3 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar1 = get_height_part_0();
}
iVar3 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar3 = get_height_part_0();
}
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
iVar3 = iVar3 + 1;
}
iVar1 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar1 = get_height_part_0();
}
if (iVar1 < iVar3) {
iVar1 = iVar3;
}
iVar1 = iVar1 + 1;
}
lVar9 = *(long *)(param_1 + 0x10);
iVar3 = 0;
if (lVar9 != 0) {
lVar7 = *(long *)(lVar9 + 8);
iVar4 = 0;
iVar3 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar4 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar4 = get_height_part_0();
}
if (iVar4 < iVar3) {
iVar4 = iVar3;
}
iVar4 = iVar4 + 1;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
if (lVar9 != 0) {
iVar5 = 0;
if (*(long *)(lVar9 + 8) != 0) {
iVar5 = get_height_part_0();
}
iVar3 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar3 = get_height_part_0();
}
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
iVar3 = iVar3 + 1;
}
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
iVar3 = iVar3 + 1;
}
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
iVar2 = iVar2 - (iVar3 + 1);
}
else {
lVar9 = *(long *)(lVar8 + 8);
iVar1 = 0;
if (lVar9 != 0) {
lVar7 = *(long *)(lVar9 + 8);
iVar2 = 0;
iVar1 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar1 = get_height_part_0();
}
iVar2 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar2 = get_height_part_0();
}
if (iVar2 < iVar1) {
iVar2 = iVar1;
}
iVar2 = iVar2 + 1;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
iVar1 = 0;
if (lVar9 != 0) {
if (*(long *)(lVar9 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar1 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar1 = get_height_part_0();
}
if (iVar3 <= iVar1) {
iVar3 = iVar1;
}
iVar1 = iVar3 + 1;
}
if (iVar1 < iVar2) {
iVar1 = iVar2;
}
iVar1 = iVar1 + 1;
}
lVar9 = *(long *)(lVar8 + 0x10);
iVar3 = 0;
iVar2 = 0;
if (lVar9 != 0) {
lVar7 = *(long *)(lVar9 + 8);
iVar4 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar4 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar4 = get_height_part_0();
}
if (iVar4 < iVar3) {
iVar4 = iVar3;
}
iVar4 = iVar4 + 1;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
iVar2 = 0;
if (lVar9 != 0) {
if (*(long *)(lVar9 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar2 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar2 = get_height_part_0();
}
if (iVar3 <= iVar2) {
iVar3 = iVar2;
}
iVar2 = iVar3 + 1;
}
if (iVar2 < iVar4) {
iVar2 = iVar4;
}
iVar2 = iVar2 + 1;
}
param_1 = *(long *)(param_1 + 0x10);
if (iVar2 < iVar1) {
iVar2 = iVar1;
}
iVar2 = iVar2 + 1;
if (param_1 != 0) {
lVar9 = *(long *)(param_1 + 8);
goto joined_r0x00101c74;
}
}
if (2 < iVar2 + 1U) {
return 0;
}
uVar6 = func0(lVar8);
if ((char)uVar6 == '\0') {
return uVar6;
}
} while( true );
} |
5,363 | func0 |
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
} Node;
Node* newNode(int data) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
int get_height(Node* root) {
if (root == NULL) {
return 0;
}
int leftHeight = get_height(root->left);
int rightHeight = get_height(root->right);
return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}
| bool func0(Node* root) {
if (root == NULL) {
return true;
}
int lh = get_height(root->left);
int rh = get_height(root->right);
if (abs(lh - rh) <= 1 && func0(root->left) && func0(root->right)) {
return true;
}
return false;
}
| int main() {
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->left->left->left = newNode(8);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->left->right = newNode(5);
root1->right->left = newNode(6);
root1->left->left->left = newNode(7);
Node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
root2->left->left = newNode(4);
root2->left->right = newNode(5);
root2->left->left->left = newNode(7);
assert(func0(root) == false);
assert(func0(root1) == true);
assert(func0(root2) == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
test %rbx,%rbx
je 22b0 <func0+0x980>
mov 0x8(%rbx),%r8
mov 0x10(%rbx),%rbx
test %r8,%r8
je 2288 <func0+0x958>
mov 0x8(%r8),%rsi
xor %ecx,%ecx
test %rsi,%rsi
je 1b84 <func0+0x254>
mov 0x8(%rsi),%r10
test %r10,%r10
je 1a6f <func0+0x13f>
mov 0x8(%r10),%r9
test %r9,%r9
je 19ea <func0+0xba>
mov 0x8(%r9),%r11
test %r11,%r11
je 19af <func0+0x7f>
mov 0x8(%r11),%rdi
xor %edx,%edx
test %rdi,%rdi
je 1997 <func0+0x67>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 19a7 <func0+0x77>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovge %eax,%edx
lea 0x1(%rdx),%ecx
mov 0x10(%r9),%r9
xor %edx,%edx
test %r9,%r9
je 19e2 <func0+0xb2>
mov 0x8(%r9),%rdi
test %rdi,%rdi
je 19ca <func0+0x9a>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r9),%rdi
xor %eax,%eax
test %rdi,%rdi
je 19da <func0+0xaa>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
cmp %ecx,%edx
cmovl %ecx,%edx
lea 0x1(%rdx),%ecx
mov 0x10(%r10),%r9
xor %edx,%edx
test %r9,%r9
je 1a67 <func0+0x137>
mov 0x8(%r9),%r10
test %r10,%r10
je 1a26 <func0+0xf6>
mov 0x8(%r10),%rdi
test %rdi,%rdi
je 1a0e <func0+0xde>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r10),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1a1e <func0+0xee>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
mov 0x10(%r9),%r10
xor %eax,%eax
test %r10,%r10
je 1a5f <func0+0x12f>
mov 0x8(%r10),%rdi
xor %r9d,%r9d
test %rdi,%rdi
je 1a45 <func0+0x115>
callq 1410 <get_height.part.0>
mov %eax,%r9d
mov 0x10(%r10),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1a55 <func0+0x125>
callq 1410 <get_height.part.0>
cmp %r9d,%eax
cmovl %r9d,%eax
add $0x1,%eax
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
cmp %ecx,%edx
cmovl %ecx,%edx
lea 0x1(%rdx),%ecx
mov 0x10(%rsi),%r9
xor %edx,%edx
test %r9,%r9
je 1b7c <func0+0x24c>
mov 0x8(%r9),%rsi
test %rsi,%rsi
je 1af5 <func0+0x1c5>
mov 0x8(%rsi),%r10
test %r10,%r10
je 1ab8 <func0+0x188>
mov 0x8(%r10),%rdi
test %rdi,%rdi
je 1aa0 <func0+0x170>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r10),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1ab0 <func0+0x180>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
mov 0x10(%rsi),%r10
xor %eax,%eax
test %r10,%r10
je 1aed <func0+0x1bd>
mov 0x8(%r10),%rdi
xor %esi,%esi
test %rdi,%rdi
je 1ad5 <func0+0x1a5>
callq 1410 <get_height.part.0>
mov %eax,%esi
mov 0x10(%r10),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1ae5 <func0+0x1b5>
callq 1410 <get_height.part.0>
cmp %esi,%eax
cmovl %esi,%eax
add $0x1,%eax
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
mov 0x10(%r9),%r9
xor %eax,%eax
test %r9,%r9
je 1b74 <func0+0x244>
mov 0x8(%r9),%r10
xor %esi,%esi
test %r10,%r10
je 1b33 <func0+0x203>
mov 0x8(%r10),%rdi
test %rdi,%rdi
je 1b1b <func0+0x1eb>
callq 1410 <get_height.part.0>
mov %eax,%esi
mov 0x10(%r10),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1b2b <func0+0x1fb>
callq 1410 <get_height.part.0>
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rax),%esi
mov 0x10(%r9),%r10
xor %eax,%eax
test %r10,%r10
je 1b6c <func0+0x23c>
mov 0x8(%r10),%rdi
xor %r9d,%r9d
test %rdi,%rdi
je 1b52 <func0+0x222>
callq 1410 <get_height.part.0>
mov %eax,%r9d
mov 0x10(%r10),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1b62 <func0+0x232>
callq 1410 <get_height.part.0>
cmp %r9d,%eax
cmovl %r9d,%eax
add $0x1,%eax
cmp %esi,%eax
cmovl %esi,%eax
add $0x1,%eax
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
cmp %ecx,%edx
cmovl %ecx,%edx
lea 0x1(%rdx),%ecx
mov 0x10(%r8),%r9
xor %edx,%edx
test %r9,%r9
je 1dbc <func0+0x48c>
mov 0x8(%r9),%r10
xor %esi,%esi
test %r10,%r10
je 1c9c <func0+0x36c>
mov 0x8(%r10),%r11
test %r11,%r11
je 1c17 <func0+0x2e7>
mov 0x8(%r11),%rbp
test %rbp,%rbp
je 1bdc <func0+0x2ac>
mov 0x8(%rbp),%rdi
test %rdi,%rdi
je 1bc4 <func0+0x294>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1bd4 <func0+0x2a4>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovge %eax,%edx
lea 0x1(%rdx),%esi
mov 0x10(%r11),%r11
xor %edx,%edx
test %r11,%r11
je 1c0f <func0+0x2df>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1bf7 <func0+0x2c7>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1c07 <func0+0x2d7>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
cmp %esi,%edx
cmovl %esi,%edx
lea 0x1(%rdx),%esi
mov 0x10(%r10),%r10
xor %edx,%edx
test %r10,%r10
je 1c94 <func0+0x364>
mov 0x8(%r10),%r11
test %r11,%r11
je 1c53 <func0+0x323>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1c3b <func0+0x30b>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1c4b <func0+0x31b>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1c8c <func0+0x35c>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1c72 <func0+0x342>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1c82 <func0+0x352>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
cmp %esi,%edx
cmovl %esi,%edx
lea 0x1(%rdx),%esi
mov 0x10(%r9),%r9
xor %edx,%edx
test %r9,%r9
je 1db4 <func0+0x484>
mov 0x8(%r9),%r10
test %r10,%r10
je 1d26 <func0+0x3f6>
mov 0x8(%r10),%r11
test %r11,%r11
je 1ce5 <func0+0x3b5>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1ccd <func0+0x39d>
callq 1410 <get_height.part.0>
mov %eax,%edx
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1cdd <func0+0x3ad>
callq 1410 <get_height.part.0>
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1d1e <func0+0x3ee>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1d04 <func0+0x3d4>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1d14 <func0+0x3e4>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
mov 0x10(%r9),%r10
xor %eax,%eax
test %r10,%r10
je 1dac <func0+0x47c>
mov 0x8(%r10),%r11
xor %r9d,%r9d
test %r11,%r11
je 1d69 <func0+0x439>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1d4e <func0+0x41e>
callq 1410 <get_height.part.0>
mov %eax,%r9d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1d5e <func0+0x42e>
callq 1410 <get_height.part.0>
cmp %r9d,%eax
cmovl %r9d,%eax
lea 0x1(%rax),%r9d
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1da2 <func0+0x472>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1d88 <func0+0x458>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1d98 <func0+0x468>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %r9d,%eax
cmovl %r9d,%eax
add $0x1,%eax
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rax),%edx
cmp %esi,%edx
cmovl %esi,%edx
add $0x1,%edx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x1,%edx
test %rbx,%rbx
je 2271 <func0+0x941>
mov 0x8(%rbx),%rsi
xor %ecx,%ecx
test %rsi,%rsi
je 2014 <func0+0x6e4>
mov 0x8(%rsi),%r9
test %r9,%r9
je 1ef2 <func0+0x5c2>
mov 0x8(%r9),%r10
test %r10,%r10
je 1e64 <func0+0x534>
mov 0x8(%r10),%r11
test %r11,%r11
je 1e23 <func0+0x4f3>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1e0b <func0+0x4db>
callq 1410 <get_height.part.0>
mov %eax,%ecx
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1e1b <func0+0x4eb>
callq 1410 <get_height.part.0>
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rax),%ecx
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1e5c <func0+0x52c>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1e42 <func0+0x512>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1e52 <func0+0x522>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rax),%ecx
mov 0x10(%r9),%r10
xor %eax,%eax
test %r10,%r10
je 1eea <func0+0x5ba>
mov 0x8(%r10),%r11
xor %r9d,%r9d
test %r11,%r11
je 1ea7 <func0+0x577>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1e8c <func0+0x55c>
callq 1410 <get_height.part.0>
mov %eax,%r9d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1e9c <func0+0x56c>
callq 1410 <get_height.part.0>
cmp %r9d,%eax
cmovl %r9d,%eax
lea 0x1(%rax),%r9d
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1ee0 <func0+0x5b0>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1ec6 <func0+0x596>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1ed6 <func0+0x5a6>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %r9d,%eax
cmovl %r9d,%eax
add $0x1,%eax
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rax),%ecx
mov 0x10(%rsi),%r9
xor %eax,%eax
test %r9,%r9
je 200c <func0+0x6dc>
mov 0x8(%r9),%r10
xor %esi,%esi
test %r10,%r10
je 1f7e <func0+0x64e>
mov 0x8(%r10),%r11
test %r11,%r11
je 1f3d <func0+0x60d>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1f25 <func0+0x5f5>
callq 1410 <get_height.part.0>
mov %eax,%esi
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1f35 <func0+0x605>
callq 1410 <get_height.part.0>
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rax),%esi
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1f76 <func0+0x646>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1f5c <func0+0x62c>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1f6c <func0+0x63c>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rax),%esi
mov 0x10(%r9),%r10
xor %eax,%eax
test %r10,%r10
je 2004 <func0+0x6d4>
mov 0x8(%r10),%r11
xor %r9d,%r9d
test %r11,%r11
je 1fc1 <func0+0x691>
mov 0x8(%r11),%rdi
test %rdi,%rdi
je 1fa6 <func0+0x676>
callq 1410 <get_height.part.0>
mov %eax,%r9d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1fb6 <func0+0x686>
callq 1410 <get_height.part.0>
cmp %r9d,%eax
cmovl %r9d,%eax
lea 0x1(%rax),%r9d
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 1ffa <func0+0x6ca>
mov 0x8(%r11),%rdi
xor %r10d,%r10d
test %rdi,%rdi
je 1fe0 <func0+0x6b0>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%r11),%rdi
xor %eax,%eax
test %rdi,%rdi
je 1ff0 <func0+0x6c0>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %r9d,%eax
cmovl %r9d,%eax
add $0x1,%eax
cmp %esi,%eax
cmovl %esi,%eax
add $0x1,%eax
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rax),%ecx
mov 0x10(%rbx),%r9
xor %eax,%eax
test %r9,%r9
je 2267 <func0+0x937>
mov 0x8(%r9),%r10
xor %esi,%esi
test %r10,%r10
je 213b <func0+0x80b>
mov 0x8(%r10),%r11
test %r11,%r11
je 20ad <func0+0x77d>
mov 0x8(%r11),%rbp
test %rbp,%rbp
je 206c <func0+0x73c>
mov 0x8(%rbp),%rdi
test %rdi,%rdi
je 2054 <func0+0x724>
callq 1410 <get_height.part.0>
mov %eax,%esi
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 2064 <func0+0x734>
callq 1410 <get_height.part.0>
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rax),%esi
mov 0x10(%r11),%rbp
xor %eax,%eax
test %rbp,%rbp
je 20a5 <func0+0x775>
mov 0x8(%rbp),%rdi
xor %r11d,%r11d
test %rdi,%rdi
je 208b <func0+0x75b>
callq 1410 <get_height.part.0>
mov %eax,%r11d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 209b <func0+0x76b>
callq 1410 <get_height.part.0>
cmp %r11d,%eax
cmovl %r11d,%eax
add $0x1,%eax
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rax),%esi
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 2133 <func0+0x803>
mov 0x8(%r11),%rbp
xor %r10d,%r10d
test %rbp,%rbp
je 20f0 <func0+0x7c0>
mov 0x8(%rbp),%rdi
test %rdi,%rdi
je 20d5 <func0+0x7a5>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 20e5 <func0+0x7b5>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
lea 0x1(%rax),%r10d
mov 0x10(%r11),%rbp
xor %eax,%eax
test %rbp,%rbp
je 2129 <func0+0x7f9>
mov 0x8(%rbp),%rdi
xor %r11d,%r11d
test %rdi,%rdi
je 210f <func0+0x7df>
callq 1410 <get_height.part.0>
mov %eax,%r11d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 211f <func0+0x7ef>
callq 1410 <get_height.part.0>
cmp %r11d,%eax
cmovl %r11d,%eax
add $0x1,%eax
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %esi,%eax
cmovl %esi,%eax
lea 0x1(%rax),%esi
mov 0x10(%r9),%r10
xor %eax,%eax
test %r10,%r10
je 225f <func0+0x92f>
mov 0x8(%r10),%r11
xor %r9d,%r9d
test %r11,%r11
je 21cf <func0+0x89f>
mov 0x8(%r11),%rbp
test %rbp,%rbp
je 218b <func0+0x85b>
mov 0x8(%rbp),%rdi
test %rdi,%rdi
je 2170 <func0+0x840>
callq 1410 <get_height.part.0>
mov %eax,%r9d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 2180 <func0+0x850>
callq 1410 <get_height.part.0>
cmp %r9d,%eax
cmovl %r9d,%eax
lea 0x1(%rax),%r9d
mov 0x10(%r11),%rbp
xor %eax,%eax
test %rbp,%rbp
je 21c4 <func0+0x894>
mov 0x8(%rbp),%rdi
xor %r11d,%r11d
test %rdi,%rdi
je 21aa <func0+0x87a>
callq 1410 <get_height.part.0>
mov %eax,%r11d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 21ba <func0+0x88a>
callq 1410 <get_height.part.0>
cmp %r11d,%eax
cmovl %r11d,%eax
add $0x1,%eax
cmp %r9d,%eax
cmovl %r9d,%eax
lea 0x1(%rax),%r9d
mov 0x10(%r10),%r11
xor %eax,%eax
test %r11,%r11
je 2255 <func0+0x925>
mov 0x8(%r11),%rbp
xor %r10d,%r10d
test %rbp,%rbp
je 2212 <func0+0x8e2>
mov 0x8(%rbp),%rdi
test %rdi,%rdi
je 21f7 <func0+0x8c7>
callq 1410 <get_height.part.0>
mov %eax,%r10d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 2207 <func0+0x8d7>
callq 1410 <get_height.part.0>
cmp %r10d,%eax
cmovl %r10d,%eax
lea 0x1(%rax),%r10d
mov 0x10(%r11),%rbp
xor %eax,%eax
test %rbp,%rbp
je 224b <func0+0x91b>
mov 0x8(%rbp),%rdi
xor %r11d,%r11d
test %rdi,%rdi
je 2231 <func0+0x901>
callq 1410 <get_height.part.0>
mov %eax,%r11d
mov 0x10(%rbp),%rdi
xor %eax,%eax
test %rdi,%rdi
je 2241 <func0+0x911>
callq 1410 <get_height.part.0>
cmp %r11d,%eax
cmovl %r11d,%eax
add $0x1,%eax
cmp %r10d,%eax
cmovl %r10d,%eax
add $0x1,%eax
cmp %r9d,%eax
cmovl %r9d,%eax
add $0x1,%eax
cmp %esi,%eax
cmovl %esi,%eax
add $0x1,%eax
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%eax
sub %eax,%edx
add $0x1,%edx
cmp $0x2,%edx
jbe 2293 <func0+0x963>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
test %rbx,%rbx
jne 1dcd <func0+0x49d>
mov %r8,%rdi
callq 1930 <func0>
test %al,%al
jne 193d <func0+0xd>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
loc_19F8:
test rbx, rbx
jz loc_1C48
mov r8, [rbx+8]
test r8, r8
jz loc_1C10
mov r9, [r8+8]
xor esi, esi
test r9, r9
jz short loc_1A87
mov rsi, [r9+8]
xor ecx, ecx
test rsi, rsi
jz short loc_1A4C
mov rdi, [rsi+8]
test rdi, rdi
jz short loc_1A34
call get_height_part_0
mov ecx, eax
loc_1A34:
mov rdi, [rsi+10h]
xor eax, eax
test rdi, rdi
jz short loc_1A44
call get_height_part_0
loc_1A44:
cmp eax, ecx
cmovl eax, ecx
lea ecx, [rax+1]
loc_1A4C:
mov r9, [r9+10h]
xor esi, esi
test r9, r9
jz short loc_1A7F
mov rdi, [r9+8]
test rdi, rdi
jz short loc_1A67
call get_height_part_0
mov esi, eax
loc_1A67:
mov rdi, [r9+10h]
xor eax, eax
test rdi, rdi
jz short loc_1A77
call get_height_part_0
loc_1A77:
cmp eax, esi
cmovge esi, eax
add esi, 1
loc_1A7F:
cmp esi, ecx
cmovl esi, ecx
add esi, 1
loc_1A87:
mov r9, [r8+10h]
xor ecx, ecx
test r9, r9
jz short loc_1ADB
mov r10, [r9+8]
test r10, r10
jz short loc_1AC3
mov rdi, [r10+8]
test rdi, rdi
jz short loc_1AAB
call get_height_part_0
mov ecx, eax
loc_1AAB:
mov rdi, [r10+10h]
xor eax, eax
test rdi, rdi
jz short loc_1ABB
call get_height_part_0
loc_1ABB:
cmp eax, ecx
cmovl eax, ecx
lea ecx, [rax+1]
loc_1AC3:
mov rdi, [r9+10h]
xor eax, eax
test rdi, rdi
jz short loc_1AD3
call get_height_part_0
loc_1AD3:
cmp eax, ecx
cmovge ecx, eax
add ecx, 1
loc_1ADB:
cmp ecx, esi
mov rbx, [rbx+10h]
cmovl ecx, esi
add ecx, 1
test rbx, rbx
jz loc_1BFD
mov r10, [rbx+8]
xor esi, esi
test r10, r10
jz short loc_1B6D
loc_1AFB:
mov r11, [r10+8]
xor r9d, r9d
test r11, r11
jz short loc_1B30
mov rdi, [r11+8]
test rdi, rdi
jz short loc_1B17
call get_height_part_0
mov esi, eax
loc_1B17:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1B27
call get_height_part_0
loc_1B27:
cmp eax, esi
cmovl eax, esi
lea r9d, [rax+1]
loc_1B30:
mov r10, [r10+10h]
xor esi, esi
test r10, r10
jz short loc_1B63
mov rdi, [r10+8]
test rdi, rdi
jz short loc_1B4B
call get_height_part_0
mov esi, eax
loc_1B4B:
mov rdi, [r10+10h]
xor eax, eax
test rdi, rdi
jz short loc_1B5B
call get_height_part_0
loc_1B5B:
cmp eax, esi
cmovge esi, eax
add esi, 1
loc_1B63:
cmp esi, r9d
cmovl esi, r9d
add esi, 1
loc_1B6D:
mov r10, [rbx+10h]
xor eax, eax
test r10, r10
jz short loc_1BF3
mov r11, [r10+8]
xor r9d, r9d
test r11, r11
jz short loc_1BB0
mov rdi, [r11+8]
test rdi, rdi
jz short loc_1B95
call get_height_part_0
mov r9d, eax
loc_1B95:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1BA5
call get_height_part_0
loc_1BA5:
cmp eax, r9d
cmovl eax, r9d
lea r9d, [rax+1]
loc_1BB0:
mov r11, [r10+10h]
xor eax, eax
test r11, r11
jz short loc_1BE9
mov rdi, [r11+8]
xor r10d, r10d
test rdi, rdi
jz short loc_1BCF
call get_height_part_0
mov r10d, eax
loc_1BCF:
mov rdi, [r11+10h]
xor eax, eax
test rdi, rdi
jz short loc_1BDF
call get_height_part_0
loc_1BDF:
cmp eax, r10d
cmovl eax, r10d
add eax, 1
loc_1BE9:
cmp eax, r9d
cmovl eax, r9d
add eax, 1
loc_1BF3:
cmp eax, esi
cmovl eax, esi
add eax, 1
sub ecx, eax
loc_1BFD:
add ecx, 1
cmp ecx, 2
jbe short loc_1C30
xor eax, eax
pop rbx
retn
loc_1C10:
mov rbx, [rbx+10h]
test rbx, rbx
jz short loc_1C48
mov r10, [rbx+8]
xor ecx, ecx
xor esi, esi
test r10, r10
jnz loc_1AFB
jmp loc_1B6D
loc_1C30:
mov rdi, r8
call func0
test al, al
jnz loc_19F8
pop rbx
retn
loc_1C48:
mov eax, 1
pop rbx
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v4; // r8
long long v5; // r9
long long v6; // rsi
long long v7; // rsi
long long v8; // rcx
long long v9; // rdi
long long v10; // rdi
int v11; // eax
long long v12; // r9
long long v13; // rsi
long long v14; // rdi
long long v15; // rdi
int v16; // eax
long long v17; // r9
long long v18; // rcx
long long v19; // r10
long long v20; // rdi
long long v21; // rdi
int v22; // eax
long long v23; // rdi
int v24; // eax
long long v25; // rcx
long long v26; // r10
long long height_part_0; // rsi
long long v28; // r11
int v29; // r9d
long long v30; // rdi
long long v31; // rdi
int v32; // eax
long long v33; // r10
long long v34; // rsi
long long v35; // rdi
long long v36; // rdi
int v37; // eax
long long v38; // r10
int v39; // eax
long long v40; // r11
int v41; // r9d
long long v42; // rdi
long long v43; // rdi
int v44; // eax
long long v45; // r11
int v46; // eax
long long v47; // rdi
int v48; // r10d
long long v49; // rdi
int v50; // eax
long long result; // rax
while ( a1 )
{
v4 = *(_QWORD *)(a1 + 8);
if ( !v4 )
{
a1 = *(_QWORD *)(a1 + 16);
if ( !a1 )
return 1LL;
v26 = *(_QWORD *)(a1 + 8);
v25 = 0LL;
height_part_0 = 0LL;
if ( v26 )
{
LABEL_41:
v28 = *(_QWORD *)(v26 + 8);
v29 = 0;
if ( v28 )
{
v30 = *(_QWORD *)(v28 + 8);
if ( v30 )
height_part_0 = (unsigned int)get_height_part_0(v30, 0LL, a3, v25);
v31 = *(_QWORD *)(v28 + 16);
v32 = 0;
if ( v31 )
v32 = get_height_part_0(v31, height_part_0, a3, v25);
if ( v32 < (int)height_part_0 )
v32 = height_part_0;
v29 = v32 + 1;
}
v33 = *(_QWORD *)(v26 + 16);
v34 = 0LL;
if ( v33 )
{
v35 = *(_QWORD *)(v33 + 8);
if ( v35 )
v34 = (unsigned int)get_height_part_0(v35, 0LL, a3, v25);
v36 = *(_QWORD *)(v33 + 16);
v37 = 0;
if ( v36 )
v37 = get_height_part_0(v36, v34, a3, v25);
if ( v37 >= (int)v34 )
LODWORD(v34) = v37;
LODWORD(v34) = v34 + 1;
}
if ( (int)v34 < v29 )
LODWORD(v34) = v29;
height_part_0 = (unsigned int)(v34 + 1);
}
LABEL_60:
v38 = *(_QWORD *)(a1 + 16);
v39 = 0;
if ( v38 )
{
v40 = *(_QWORD *)(v38 + 8);
v41 = 0;
if ( v40 )
{
v42 = *(_QWORD *)(v40 + 8);
if ( v42 )
v41 = get_height_part_0(v42, height_part_0, a3, v25);
v43 = *(_QWORD *)(v40 + 16);
v44 = 0;
if ( v43 )
v44 = get_height_part_0(v43, height_part_0, a3, v25);
if ( v44 < v41 )
v44 = v41;
v41 = v44 + 1;
}
v45 = *(_QWORD *)(v38 + 16);
v46 = 0;
if ( v45 )
{
v47 = *(_QWORD *)(v45 + 8);
v48 = 0;
if ( v47 )
v48 = get_height_part_0(v47, height_part_0, a3, v25);
v49 = *(_QWORD *)(v45 + 16);
v50 = 0;
if ( v49 )
v50 = get_height_part_0(v49, height_part_0, a3, v25);
if ( v50 < v48 )
v50 = v48;
v46 = v50 + 1;
}
if ( v46 < v41 )
v46 = v41;
v39 = v46 + 1;
}
if ( v39 < (int)height_part_0 )
v39 = height_part_0;
LODWORD(v25) = v25 - (v39 + 1);
goto LABEL_83;
}
v5 = *(_QWORD *)(v4 + 8);
v6 = 0LL;
if ( v5 )
{
v7 = *(_QWORD *)(v5 + 8);
v8 = 0LL;
if ( v7 )
{
v9 = *(_QWORD *)(v7 + 8);
if ( v9 )
v8 = (unsigned int)get_height_part_0(v9, v7, a3, 0LL);
v10 = *(_QWORD *)(v7 + 16);
v11 = 0;
if ( v10 )
v11 = get_height_part_0(v10, v7, a3, v8);
if ( v11 < (int)v8 )
v11 = v8;
v8 = (unsigned int)(v11 + 1);
}
v12 = *(_QWORD *)(v5 + 16);
v13 = 0LL;
if ( v12 )
{
v14 = *(_QWORD *)(v12 + 8);
if ( v14 )
v13 = (unsigned int)get_height_part_0(v14, 0LL, a3, v8);
v15 = *(_QWORD *)(v12 + 16);
v16 = 0;
if ( v15 )
v16 = get_height_part_0(v15, v13, a3, v8);
if ( v16 >= (int)v13 )
LODWORD(v13) = v16;
LODWORD(v13) = v13 + 1;
}
if ( (int)v13 < (int)v8 )
LODWORD(v13) = v8;
v6 = (unsigned int)(v13 + 1);
}
v17 = *(_QWORD *)(v4 + 16);
v18 = 0LL;
if ( v17 )
{
v19 = *(_QWORD *)(v17 + 8);
if ( v19 )
{
v20 = *(_QWORD *)(v19 + 8);
if ( v20 )
v18 = (unsigned int)get_height_part_0(v20, v6, a3, 0LL);
v21 = *(_QWORD *)(v19 + 16);
v22 = 0;
if ( v21 )
v22 = get_height_part_0(v21, v6, a3, v18);
if ( v22 < (int)v18 )
v22 = v18;
v18 = (unsigned int)(v22 + 1);
}
v23 = *(_QWORD *)(v17 + 16);
v24 = 0;
if ( v23 )
v24 = get_height_part_0(v23, v6, a3, v18);
if ( v24 >= (int)v18 )
LODWORD(v18) = v24;
LODWORD(v18) = v18 + 1;
}
a1 = *(_QWORD *)(a1 + 16);
if ( (int)v18 < (int)v6 )
LODWORD(v18) = v6;
v25 = (unsigned int)(v18 + 1);
if ( a1 )
{
v26 = *(_QWORD *)(a1 + 8);
height_part_0 = 0LL;
if ( v26 )
goto LABEL_41;
goto LABEL_60;
}
LABEL_83:
if ( (unsigned int)(v25 + 1) > 2 )
return 0LL;
result = func0(v4);
if ( !(_BYTE)result )
return result;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
LAB_001019f8:
TEST RBX,RBX
JZ 0x00101c48
MOV R8,qword ptr [RBX + 0x8]
TEST R8,R8
JZ 0x00101c10
MOV R9,qword ptr [R8 + 0x8]
XOR ESI,ESI
TEST R9,R9
JZ 0x00101a87
MOV RSI,qword ptr [R9 + 0x8]
XOR ECX,ECX
TEST RSI,RSI
JZ 0x00101a4c
MOV RDI,qword ptr [RSI + 0x8]
TEST RDI,RDI
JZ 0x00101a34
CALL 0x001013a0
MOV ECX,EAX
LAB_00101a34:
MOV RDI,qword ptr [RSI + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101a44
CALL 0x001013a0
LAB_00101a44:
CMP EAX,ECX
CMOVL EAX,ECX
LEA ECX,[RAX + 0x1]
LAB_00101a4c:
MOV R9,qword ptr [R9 + 0x10]
XOR ESI,ESI
TEST R9,R9
JZ 0x00101a7f
MOV RDI,qword ptr [R9 + 0x8]
TEST RDI,RDI
JZ 0x00101a67
CALL 0x001013a0
MOV ESI,EAX
LAB_00101a67:
MOV RDI,qword ptr [R9 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101a77
CALL 0x001013a0
LAB_00101a77:
CMP EAX,ESI
CMOVGE ESI,EAX
ADD ESI,0x1
LAB_00101a7f:
CMP ESI,ECX
CMOVL ESI,ECX
ADD ESI,0x1
LAB_00101a87:
MOV R9,qword ptr [R8 + 0x10]
XOR ECX,ECX
TEST R9,R9
JZ 0x00101adb
MOV R10,qword ptr [R9 + 0x8]
TEST R10,R10
JZ 0x00101ac3
MOV RDI,qword ptr [R10 + 0x8]
TEST RDI,RDI
JZ 0x00101aab
CALL 0x001013a0
MOV ECX,EAX
LAB_00101aab:
MOV RDI,qword ptr [R10 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101abb
CALL 0x001013a0
LAB_00101abb:
CMP EAX,ECX
CMOVL EAX,ECX
LEA ECX,[RAX + 0x1]
LAB_00101ac3:
MOV RDI,qword ptr [R9 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101ad3
CALL 0x001013a0
LAB_00101ad3:
CMP EAX,ECX
CMOVGE ECX,EAX
ADD ECX,0x1
LAB_00101adb:
CMP ECX,ESI
MOV RBX,qword ptr [RBX + 0x10]
CMOVL ECX,ESI
ADD ECX,0x1
TEST RBX,RBX
JZ 0x00101bfd
MOV R10,qword ptr [RBX + 0x8]
XOR ESI,ESI
TEST R10,R10
JZ 0x00101b6d
LAB_00101afb:
MOV R11,qword ptr [R10 + 0x8]
XOR R9D,R9D
TEST R11,R11
JZ 0x00101b30
MOV RDI,qword ptr [R11 + 0x8]
TEST RDI,RDI
JZ 0x00101b17
CALL 0x001013a0
MOV ESI,EAX
LAB_00101b17:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101b27
CALL 0x001013a0
LAB_00101b27:
CMP EAX,ESI
CMOVL EAX,ESI
LEA R9D,[RAX + 0x1]
LAB_00101b30:
MOV R10,qword ptr [R10 + 0x10]
XOR ESI,ESI
TEST R10,R10
JZ 0x00101b63
MOV RDI,qword ptr [R10 + 0x8]
TEST RDI,RDI
JZ 0x00101b4b
CALL 0x001013a0
MOV ESI,EAX
LAB_00101b4b:
MOV RDI,qword ptr [R10 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101b5b
CALL 0x001013a0
LAB_00101b5b:
CMP EAX,ESI
CMOVGE ESI,EAX
ADD ESI,0x1
LAB_00101b63:
CMP ESI,R9D
CMOVL ESI,R9D
ADD ESI,0x1
LAB_00101b6d:
MOV R10,qword ptr [RBX + 0x10]
XOR EAX,EAX
TEST R10,R10
JZ 0x00101bf3
MOV R11,qword ptr [R10 + 0x8]
XOR R9D,R9D
TEST R11,R11
JZ 0x00101bb0
MOV RDI,qword ptr [R11 + 0x8]
TEST RDI,RDI
JZ 0x00101b95
CALL 0x001013a0
MOV R9D,EAX
LAB_00101b95:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101ba5
CALL 0x001013a0
LAB_00101ba5:
CMP EAX,R9D
CMOVL EAX,R9D
LEA R9D,[RAX + 0x1]
LAB_00101bb0:
MOV R11,qword ptr [R10 + 0x10]
XOR EAX,EAX
TEST R11,R11
JZ 0x00101be9
MOV RDI,qword ptr [R11 + 0x8]
XOR R10D,R10D
TEST RDI,RDI
JZ 0x00101bcf
CALL 0x001013a0
MOV R10D,EAX
LAB_00101bcf:
MOV RDI,qword ptr [R11 + 0x10]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101bdf
CALL 0x001013a0
LAB_00101bdf:
CMP EAX,R10D
CMOVL EAX,R10D
ADD EAX,0x1
LAB_00101be9:
CMP EAX,R9D
CMOVL EAX,R9D
ADD EAX,0x1
LAB_00101bf3:
CMP EAX,ESI
CMOVL EAX,ESI
ADD EAX,0x1
SUB ECX,EAX
LAB_00101bfd:
ADD ECX,0x1
CMP ECX,0x2
JBE 0x00101c30
XOR EAX,EAX
POP RBX
RET
LAB_00101c10:
MOV RBX,qword ptr [RBX + 0x10]
TEST RBX,RBX
JZ 0x00101c48
MOV R10,qword ptr [RBX + 0x8]
XOR ECX,ECX
XOR ESI,ESI
TEST R10,R10
JNZ 0x00101afb
JMP 0x00101b6d
LAB_00101c30:
MOV RDI,R8
CALL 0x001019f0
TEST AL,AL
JNZ 0x001019f8
POP RBX
RET
LAB_00101c48:
MOV EAX,0x1
POP RBX
RET | int8 func0(long param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int8 uVar6;
long lVar7;
long lVar8;
long lVar9;
do {
if (param_1 == 0) {
return 1;
}
lVar8 = *(long *)(param_1 + 8);
if (lVar8 == 0) {
param_1 = *(long *)(param_1 + 0x10);
if (param_1 == 0) {
return 1;
}
lVar9 = *(long *)(param_1 + 8);
iVar2 = 0;
joined_r0x00101c24:
iVar1 = 0;
if (lVar9 != 0) {
iVar1 = 0;
lVar7 = *(long *)(lVar9 + 8);
iVar3 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar1 = get_height_part_0();
}
iVar3 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar3 = get_height_part_0();
}
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
iVar3 = iVar3 + 1;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar4 = 0;
iVar1 = 0;
if (lVar9 != 0) {
if (*(long *)(lVar9 + 8) != 0) {
iVar4 = get_height_part_0();
}
iVar1 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar1 = get_height_part_0();
}
if (iVar4 <= iVar1) {
iVar4 = iVar1;
}
iVar1 = iVar4 + 1;
}
if (iVar1 < iVar3) {
iVar1 = iVar3;
}
iVar1 = iVar1 + 1;
}
lVar9 = *(long *)(param_1 + 0x10);
iVar3 = 0;
if (lVar9 != 0) {
lVar7 = *(long *)(lVar9 + 8);
iVar4 = 0;
iVar3 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar4 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar4 = get_height_part_0();
}
if (iVar4 < iVar3) {
iVar4 = iVar3;
}
iVar4 = iVar4 + 1;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
if (lVar9 != 0) {
iVar5 = 0;
if (*(long *)(lVar9 + 8) != 0) {
iVar5 = get_height_part_0();
}
iVar3 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar3 = get_height_part_0();
}
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
iVar3 = iVar3 + 1;
}
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
iVar3 = iVar3 + 1;
}
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
iVar2 = iVar2 - (iVar3 + 1);
}
else {
lVar9 = *(long *)(lVar8 + 8);
iVar1 = 0;
if (lVar9 != 0) {
lVar7 = *(long *)(lVar9 + 8);
iVar2 = 0;
iVar1 = 0;
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar1 = get_height_part_0();
}
iVar2 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar2 = get_height_part_0();
}
if (iVar2 < iVar1) {
iVar2 = iVar1;
}
iVar2 = iVar2 + 1;
}
lVar9 = *(long *)(lVar9 + 0x10);
iVar3 = 0;
iVar1 = 0;
if (lVar9 != 0) {
if (*(long *)(lVar9 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar1 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar1 = get_height_part_0();
}
if (iVar3 <= iVar1) {
iVar3 = iVar1;
}
iVar1 = iVar3 + 1;
}
if (iVar1 < iVar2) {
iVar1 = iVar2;
}
iVar1 = iVar1 + 1;
}
lVar9 = *(long *)(lVar8 + 0x10);
iVar3 = 0;
iVar2 = 0;
if (lVar9 != 0) {
lVar7 = *(long *)(lVar9 + 8);
if (lVar7 != 0) {
if (*(long *)(lVar7 + 8) != 0) {
iVar3 = get_height_part_0();
}
iVar2 = 0;
if (*(long *)(lVar7 + 0x10) != 0) {
iVar2 = get_height_part_0();
}
if (iVar2 < iVar3) {
iVar2 = iVar3;
}
iVar3 = iVar2 + 1;
}
iVar2 = 0;
if (*(long *)(lVar9 + 0x10) != 0) {
iVar2 = get_height_part_0();
}
if (iVar3 <= iVar2) {
iVar3 = iVar2;
}
iVar2 = iVar3 + 1;
}
param_1 = *(long *)(param_1 + 0x10);
if (iVar2 < iVar1) {
iVar2 = iVar1;
}
iVar2 = iVar2 + 1;
if (param_1 != 0) {
lVar9 = *(long *)(param_1 + 8);
goto joined_r0x00101c24;
}
}
if (2 < iVar2 + 1U) {
return 0;
}
uVar6 = func0(lVar8);
if ((char)uVar6 == '\0') {
return uVar6;
}
} while( true );
} |
5,364 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int a;
int b;
} repeat_tuples_result;
| repeat_tuples_result* func0(repeat_tuples_result test_tup, int N) {
repeat_tuples_result* res = malloc(N * sizeof(repeat_tuples_result));
for(int i = 0; i < N; i++) {
res[i] = test_tup;
}
return res;
}
| int main() {
// First test
repeat_tuples_result t1 = {1, 3};
int N1 = 4;
repeat_tuples_result* res1 = func0(t1, N1);
repeat_tuples_result expected1[4] = { {1,3}, {1,3}, {1,3}, {1,3} };
for(int i = 0; i < N1; i++) {
assert(res1[i].a == expected1[i].a && res1[i].b == expected1[i].b);
}
free(res1);
// Second test
repeat_tuples_result t2 = {1, 2};
int N2 = 3;
repeat_tuples_result* res2 = func0(t2, N2);
repeat_tuples_result expected2[3] = { {1,2}, {1,2}, {1,2} };
for(int i = 0; i < N2; i++) {
assert(res2[i].a == expected2[i].a && res2[i].b == expected2[i].b);
}
free(res2);
// Third test
repeat_tuples_result t3 = {3, 4};
int N3 = 5;
repeat_tuples_result* res3 = func0(t3, N3);
repeat_tuples_result expected3[5] = { {3,4}, {3,4}, {3,4}, {3,4}, {3,4} };
for(int i = 0; i < N3; i++) {
assert(res3[i].a == expected3[i].a && res3[i].b == expected3[i].b);
}
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11f9 <func0+0x50>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x18(%rbp),%rax
mov %rax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11da <func0+0x31>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_11F9
loc_11DA:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rdx, rax
mov rax, [rbp+var_18]
mov [rdx], rax
add [rbp+var_C], 1
loc_11F9:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11DA
mov rax, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_QWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = a1;
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 EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011f9
LAB_001011da:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RDX],RAX
ADD dword ptr [RBP + -0xc],0x1
LAB_001011f9:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011da
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int8 param_1,int param_2)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_2 << 3);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
*(int8 *)((long)local_14 * 8 + (long)pvVar1) = param_1;
}
return pvVar1;
} |
5,365 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int a;
int b;
} repeat_tuples_result;
| repeat_tuples_result* func0(repeat_tuples_result test_tup, int N) {
repeat_tuples_result* res = malloc(N * sizeof(repeat_tuples_result));
for(int i = 0; i < N; i++) {
res[i] = test_tup;
}
return res;
}
| int main() {
// First test
repeat_tuples_result t1 = {1, 3};
int N1 = 4;
repeat_tuples_result* res1 = func0(t1, N1);
repeat_tuples_result expected1[4] = { {1,3}, {1,3}, {1,3}, {1,3} };
for(int i = 0; i < N1; i++) {
assert(res1[i].a == expected1[i].a && res1[i].b == expected1[i].b);
}
free(res1);
// Second test
repeat_tuples_result t2 = {1, 2};
int N2 = 3;
repeat_tuples_result* res2 = func0(t2, N2);
repeat_tuples_result expected2[3] = { {1,2}, {1,2}, {1,2} };
for(int i = 0; i < N2; i++) {
assert(res2[i].a == expected2[i].a && res2[i].b == expected2[i].b);
}
free(res2);
// Third test
repeat_tuples_result t3 = {3, 4};
int N3 = 5;
repeat_tuples_result* res3 = func0(t3, N3);
repeat_tuples_result expected3[5] = { {3,4}, {3,4}, {3,4}, {3,4}, {3,4} };
for(int i = 0; i < N3; i++) {
assert(res3[i].a == expected3[i].a && res3[i].b == expected3[i].b);
}
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 11df <func0+0x36>
mov %rax,%rdx
lea -0x1(%rbp),%ecx
lea 0x8(%rax,%rcx,8),%rcx
mov %rbx,(%rdx)
add $0x8,%rdx
cmp %rcx,%rdx
jne 11d3 <func0+0x2a>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
movsxd rdi, esi
shl rdi, 3
call _malloc
test ebp, ebp
jle short loc_11DD
mov rdx, rax
mov ebp, ebp
lea rcx, [rax+rbp*8]
loc_11D1:
mov [rdx], rbx
add rdx, 8
cmp rdx, rcx
jnz short loc_11D1
loc_11DD:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
long long result; // rax
_QWORD *v3; // rdx
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v3 = (_QWORD *)result;
do
*v3++ = a1;
while ( v3 != (_QWORD *)(result + 8LL * (unsigned int)a2) );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001011dd
MOV RDX,RAX
MOV EBP,EBP
LEA RCX,[RAX + RBP*0x8]
LAB_001011d1:
MOV qword ptr [RDX],RBX
ADD RDX,0x8
CMP RDX,RCX
JNZ 0x001011d1
LAB_001011dd:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(int8 param_1,uint param_2)
{
int8 *puVar1;
int8 *puVar2;
puVar2 = (int8 *)malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
puVar1 = puVar2 + param_2;
do {
*puVar2 = param_1;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar1);
}
return;
} |
5,366 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int a;
int b;
} repeat_tuples_result;
| repeat_tuples_result* func0(repeat_tuples_result test_tup, int N) {
repeat_tuples_result* res = malloc(N * sizeof(repeat_tuples_result));
for(int i = 0; i < N; i++) {
res[i] = test_tup;
}
return res;
}
| int main() {
// First test
repeat_tuples_result t1 = {1, 3};
int N1 = 4;
repeat_tuples_result* res1 = func0(t1, N1);
repeat_tuples_result expected1[4] = { {1,3}, {1,3}, {1,3}, {1,3} };
for(int i = 0; i < N1; i++) {
assert(res1[i].a == expected1[i].a && res1[i].b == expected1[i].b);
}
free(res1);
// Second test
repeat_tuples_result t2 = {1, 2};
int N2 = 3;
repeat_tuples_result* res2 = func0(t2, N2);
repeat_tuples_result expected2[3] = { {1,2}, {1,2}, {1,2} };
for(int i = 0; i < N2; i++) {
assert(res2[i].a == expected2[i].a && res2[i].b == expected2[i].b);
}
free(res2);
// Third test
repeat_tuples_result t3 = {3, 4};
int N3 = 5;
repeat_tuples_result* res3 = func0(t3, N3);
repeat_tuples_result expected3[5] = { {3,4}, {3,4}, {3,4}, {3,4}, {3,4} };
for(int i = 0; i < N3; i++) {
assert(res3[i].a == expected3[i].a && res3[i].b == expected3[i].b);
}
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 13dc <func0+0x3c>
lea -0x1(%rbp),%ecx
mov %rax,%rdx
lea 0x8(%rax,%rcx,8),%rcx
nopl 0x0(%rax,%rax,1)
mov %rbx,(%rdx)
add $0x8,%rdx
cmp %rcx,%rdx
jne 13d0 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 3
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_13AC
mov ebp, ebp
mov rdx, rax
lea rcx, [rax+rbp*8]
nop dword ptr [rax+00000000h]
loc_13A0:
mov [rdx], rbx
add rdx, 8
cmp rdx, rcx
jnz short loc_13A0
loc_13AC:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
long long result; // rax
_QWORD *v3; // rdx
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v3 = (_QWORD *)result;
do
*v3++ = a1;
while ( v3 != (_QWORD *)(result + 8LL * (unsigned int)a2) );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x3
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001013ac
MOV EBP,EBP
MOV RDX,RAX
LEA RCX,[RAX + RBP*0x8]
NOP dword ptr [RAX]
LAB_001013a0:
MOV qword ptr [RDX],RBX
ADD RDX,0x8
CMP RDX,RCX
JNZ 0x001013a0
LAB_001013ac:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(int8 param_1,uint param_2)
{
int8 *puVar1;
int8 *puVar2;
puVar2 = (int8 *)malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
puVar1 = puVar2 + param_2;
do {
*puVar2 = param_1;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar1);
}
return;
} |
5,367 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int a;
int b;
} repeat_tuples_result;
| repeat_tuples_result* func0(repeat_tuples_result test_tup, int N) {
repeat_tuples_result* res = malloc(N * sizeof(repeat_tuples_result));
for(int i = 0; i < N; i++) {
res[i] = test_tup;
}
return res;
}
| int main() {
// First test
repeat_tuples_result t1 = {1, 3};
int N1 = 4;
repeat_tuples_result* res1 = func0(t1, N1);
repeat_tuples_result expected1[4] = { {1,3}, {1,3}, {1,3}, {1,3} };
for(int i = 0; i < N1; i++) {
assert(res1[i].a == expected1[i].a && res1[i].b == expected1[i].b);
}
free(res1);
// Second test
repeat_tuples_result t2 = {1, 2};
int N2 = 3;
repeat_tuples_result* res2 = func0(t2, N2);
repeat_tuples_result expected2[3] = { {1,2}, {1,2}, {1,2} };
for(int i = 0; i < N2; i++) {
assert(res2[i].a == expected2[i].a && res2[i].b == expected2[i].b);
}
free(res2);
// Third test
repeat_tuples_result t3 = {3, 4};
int N3 = 5;
repeat_tuples_result* res3 = func0(t3, N3);
repeat_tuples_result expected3[5] = { {3,4}, {3,4}, {3,4}, {3,4}, {3,4} };
for(int i = 0; i < N3; i++) {
assert(res3[i].a == expected3[i].a && res3[i].b == expected3[i].b);
}
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 13fc <func0+0x3c>
lea -0x1(%rbp),%ecx
mov %rax,%rdx
lea 0x8(%rax,%rcx,8),%rcx
nopl 0x0(%rax,%rax,1)
mov %rbx,(%rdx)
add $0x8,%rdx
cmp %rcx,%rdx
jne 13f0 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
push rbp
movsxd rbp, esi
push rbx
mov r12, rbp
shl rbp, 3
mov rbx, rdi
mov rdi, rbp; size
call _malloc
test r12d, r12d
jle short loc_11B0
lea rcx, [rbp+rax+0]
and ebp, 8
mov rdx, rax
jz short loc_11A0
lea rdx, [rax+8]
mov [rax], rbx
cmp rdx, rcx
jz short loc_11B0
nop dword ptr [rax+rax+00h]
loc_11A0:
mov [rdx], rbx
add rdx, 10h
mov [rdx-8], rbx
cmp rdx, rcx
jnz short loc_11A0
loc_11B0:
pop rbx
pop rbp
pop r12
retn | _QWORD * func0(long long a1, int a2)
{
size_t v2; // rbp
_QWORD *result; // rax
_QWORD *v4; // rcx
_QWORD *v5; // rdx
v2 = 8LL * a2;
result = malloc(v2);
if ( a2 > 0 )
{
v4 = &result[v2 / 8];
v5 = result;
if ( (v2 & 8) == 0 || (v5 = result + 1, *result = a1, result + 1 != v4) )
{
do
{
*v5 = a1;
v5 += 2;
*(v5 - 1) = a1;
}
while ( v5 != v4 );
}
}
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV R12,RBP
SHL RBP,0x3
MOV RBX,RDI
MOV RDI,RBP
CALL 0x00101050
TEST R12D,R12D
JLE 0x001011b0
LEA RCX,[RBP + RAX*0x1]
AND EBP,0x8
MOV RDX,RAX
JZ 0x001011a0
LEA RDX,[RAX + 0x8]
MOV qword ptr [RAX],RBX
CMP RDX,RCX
JZ 0x001011b0
NOP dword ptr [RAX + RAX*0x1]
LAB_001011a0:
MOV qword ptr [RDX],RBX
ADD RDX,0x10
MOV qword ptr [RDX + -0x8],RBX
CMP RDX,RCX
JNZ 0x001011a0
LAB_001011b0:
POP RBX
POP RBP
POP R12
RET | void func0(int8 param_1,int param_2)
{
int8 *puVar1;
int8 *puVar2;
int8 *puVar3;
size_t __size;
__size = (long)param_2 * 8;
puVar1 = (int8 *)malloc(__size);
if (0 < param_2) {
puVar2 = puVar1;
if ((__size & 8) != 0) {
puVar2 = puVar1 + 1;
*puVar1 = param_1;
if (puVar2 == puVar1 + param_2) {
return;
}
}
do {
*puVar2 = param_1;
puVar3 = puVar2 + 2;
puVar2[1] = param_1;
puVar2 = puVar3;
} while (puVar3 != puVar1 + param_2);
}
return;
} |
5,368 | func0 |
#include <assert.h>
| int func0(int l, int w, int h) {
int LSA = 2 * h * (l + w);
return LSA;
}
| int main() {
assert(func0(8, 5, 6) == 156);
assert(func0(7, 9, 10) == 320);
assert(func0(10, 20, 30) == 1800);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
imul -0x1c(%rbp),%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add eax, edx
imul eax, [rbp+var_1C]
add eax, eax
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(2 * a3 * (a1 + a2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
IMUL EAX,dword ptr [RBP + -0x1c]
ADD EAX,EAX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_2 + param_1) * param_3 * 2;
} |
5,369 | func0 |
#include <assert.h>
| int func0(int l, int w, int h) {
int LSA = 2 * h * (l + w);
return LSA;
}
| int main() {
assert(func0(8, 5, 6) == 156);
assert(func0(7, 9, 10) == 320);
assert(func0(10, 20, 30) == 1800);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
imul %edx,%edi
lea (%rdi,%rdi,1),%eax
retq
| func0:
endbr64
add edi, esi
imul edi, edx
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(2 * a3 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
IMUL EDI,EDX
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_1 + param_2) * param_3 * 2;
} |
5,370 | func0 |
#include <assert.h>
| int func0(int l, int w, int h) {
int LSA = 2 * h * (l + w);
return LSA;
}
| int main() {
assert(func0(8, 5, 6) == 156);
assert(func0(7, 9, 10) == 320);
assert(func0(10, 20, 30) == 1800);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
imul %edx,%edi
lea (%rdi,%rdi,1),%eax
retq
nopl (%rax)
| func0:
endbr64
add edi, esi
imul edi, edx
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(2 * a3 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
IMUL EDI,EDX
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_1 + param_2) * param_3 * 2;
} |
5,371 | func0 |
#include <assert.h>
| int func0(int l, int w, int h) {
int LSA = 2 * h * (l + w);
return LSA;
}
| int main() {
assert(func0(8, 5, 6) == 156);
assert(func0(7, 9, 10) == 320);
assert(func0(10, 20, 30) == 1800);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
imul %edx,%edi
lea (%rdi,%rdi,1),%eax
retq
nopl (%rax)
| func0:
endbr64
add edi, esi
imul edi, edx
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(2 * a3 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
IMUL EDI,EDX
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return (param_1 + param_2) * param_3 * 2;
} |
5,372 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *item;
char *price;
} Tuple;
int compare_tuples(const void *a, const void *b) {
const Tuple *tuple_a = (const Tuple *)a;
const Tuple *tuple_b = (const Tuple *)b;
float price_a = atof(tuple_a->price);
float price_b = atof(tuple_b->price);
return (price_b > price_a) - (price_b < price_a);
}
| Tuple* func0(Tuple arr[], int len) {
qsort(arr, len, sizeof(Tuple), compare_tuples);
return arr;
}
| int main() {
Tuple arr1[3] = {{"item1", "12.20"}, {"item2", "15.10"}, {"item3", "24.5"}};
Tuple arr2[3] = {{"item1", "15"}, {"item2", "10"}, {"item3", "20"}};
Tuple arr3[3] = {{"item1", "5"}, {"item2", "10"}, {"item3", "14"}};
Tuple *sorted_arr1 = func0(arr1, 3);
assert(strcmp(sorted_arr1[0].item, "item3") == 0 && strcmp(sorted_arr1[1].item, "item2") == 0 && strcmp(sorted_arr1[2].item, "item1") == 0);
Tuple *sorted_arr2 = func0(arr2, 3);
assert(strcmp(sorted_arr2[0].item, "item3") == 0 && strcmp(sorted_arr2[1].item, "item1") == 0 && strcmp(sorted_arr2[2].item, "item2") == 0);
Tuple *sorted_arr3 = func0(arr3, 3);
assert(strcmp(sorted_arr3[0].item, "item3") == 0 && strcmp(sorted_arr3[1].item, "item2") == 0 && strcmp(sorted_arr3[2].item, "item1") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rsi
mov -0x8(%rbp),%rax
lea -0x9e(%rip),%rcx
mov $0x10,%edx
mov %rax,%rdi
callq 1090 <qsort@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+base], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare_tuples
mov rcx, rdx; compar
mov edx, 10h; size
mov rdi, rax; base
call _qsort
mov rax, [rbp+base]
leave
retn | void * func0(void *a1, int a2)
{
qsort(a1, a2, 0x10uLL, compare_tuples);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x10
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x10,compare_tuples);
return param_1;
} |
5,373 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *item;
char *price;
} Tuple;
int compare_tuples(const void *a, const void *b) {
const Tuple *tuple_a = (const Tuple *)a;
const Tuple *tuple_b = (const Tuple *)b;
float price_a = atof(tuple_a->price);
float price_b = atof(tuple_b->price);
return (price_b > price_a) - (price_b < price_a);
}
| Tuple* func0(Tuple arr[], int len) {
qsort(arr, len, sizeof(Tuple), compare_tuples);
return arr;
}
| int main() {
Tuple arr1[3] = {{"item1", "12.20"}, {"item2", "15.10"}, {"item3", "24.5"}};
Tuple arr2[3] = {{"item1", "15"}, {"item2", "10"}, {"item3", "20"}};
Tuple arr3[3] = {{"item1", "5"}, {"item2", "10"}, {"item3", "14"}};
Tuple *sorted_arr1 = func0(arr1, 3);
assert(strcmp(sorted_arr1[0].item, "item3") == 0 && strcmp(sorted_arr1[1].item, "item2") == 0 && strcmp(sorted_arr1[2].item, "item1") == 0);
Tuple *sorted_arr2 = func0(arr2, 3);
assert(strcmp(sorted_arr2[0].item, "item3") == 0 && strcmp(sorted_arr2[1].item, "item1") == 0 && strcmp(sorted_arr2[2].item, "item2") == 0);
Tuple *sorted_arr3 = func0(arr3, 3);
assert(strcmp(sorted_arr3[0].item, "item3") == 0 && strcmp(sorted_arr3[1].item, "item2") == 0 && strcmp(sorted_arr3[2].item, "item1") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
movslq %esi,%rsi
lea -0x6c(%rip),%rcx
mov $0x10,%edx
callq 1080 <qsort@plt>
mov %rbx,%rax
pop %rbx
retq
| func0:
endbr64
push rbx
mov rbx, rdi
movsxd rsi, esi
lea rcx, compare_tuples
mov edx, 10h
call _qsort
mov rax, rbx
pop rbx
retn | long long func0(long long a1, int a2)
{
qsort(a1, a2, 16LL, compare_tuples);
return a1;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOVSXD RSI,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x10
CALL 0x00101090
MOV RAX,RBX
POP RBX
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x10,compare_tuples);
return param_1;
} |
5,374 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *item;
char *price;
} Tuple;
int compare_tuples(const void *a, const void *b) {
const Tuple *tuple_a = (const Tuple *)a;
const Tuple *tuple_b = (const Tuple *)b;
float price_a = atof(tuple_a->price);
float price_b = atof(tuple_b->price);
return (price_b > price_a) - (price_b < price_a);
}
| Tuple* func0(Tuple arr[], int len) {
qsort(arr, len, sizeof(Tuple), compare_tuples);
return arr;
}
| int main() {
Tuple arr1[3] = {{"item1", "12.20"}, {"item2", "15.10"}, {"item3", "24.5"}};
Tuple arr2[3] = {{"item1", "15"}, {"item2", "10"}, {"item3", "20"}};
Tuple arr3[3] = {{"item1", "5"}, {"item2", "10"}, {"item3", "14"}};
Tuple *sorted_arr1 = func0(arr1, 3);
assert(strcmp(sorted_arr1[0].item, "item3") == 0 && strcmp(sorted_arr1[1].item, "item2") == 0 && strcmp(sorted_arr1[2].item, "item1") == 0);
Tuple *sorted_arr2 = func0(arr2, 3);
assert(strcmp(sorted_arr2[0].item, "item3") == 0 && strcmp(sorted_arr2[1].item, "item1") == 0 && strcmp(sorted_arr2[2].item, "item2") == 0);
Tuple *sorted_arr3 = func0(arr3, 3);
assert(strcmp(sorted_arr3[0].item, "item3") == 0 && strcmp(sorted_arr3[1].item, "item2") == 0 && strcmp(sorted_arr3[2].item, "item1") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %rdi,%r12
mov $0x10,%edx
lea -0x78(%rip),%rcx
callq 1080 <qsort@plt>
mov %r12,%rax
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
movsxd rsi, esi
mov r12, rdi
mov edx, 10h
lea rcx, compare_tuples
call _qsort
mov rax, r12
pop r12
retn | long long func0(long long a1, int a2)
{
qsort(a1, a2, 16LL, compare_tuples);
return a1;
} | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV R12,RDI
MOV EDX,0x10
LEA RCX,[0x101430]
CALL 0x00101090
MOV RAX,R12
POP R12
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x10,compare_tuples);
return param_1;
} |
5,375 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *item;
char *price;
} Tuple;
int compare_tuples(const void *a, const void *b) {
const Tuple *tuple_a = (const Tuple *)a;
const Tuple *tuple_b = (const Tuple *)b;
float price_a = atof(tuple_a->price);
float price_b = atof(tuple_b->price);
return (price_b > price_a) - (price_b < price_a);
}
| Tuple* func0(Tuple arr[], int len) {
qsort(arr, len, sizeof(Tuple), compare_tuples);
return arr;
}
| int main() {
Tuple arr1[3] = {{"item1", "12.20"}, {"item2", "15.10"}, {"item3", "24.5"}};
Tuple arr2[3] = {{"item1", "15"}, {"item2", "10"}, {"item3", "20"}};
Tuple arr3[3] = {{"item1", "5"}, {"item2", "10"}, {"item3", "14"}};
Tuple *sorted_arr1 = func0(arr1, 3);
assert(strcmp(sorted_arr1[0].item, "item3") == 0 && strcmp(sorted_arr1[1].item, "item2") == 0 && strcmp(sorted_arr1[2].item, "item1") == 0);
Tuple *sorted_arr2 = func0(arr2, 3);
assert(strcmp(sorted_arr2[0].item, "item3") == 0 && strcmp(sorted_arr2[1].item, "item1") == 0 && strcmp(sorted_arr2[2].item, "item2") == 0);
Tuple *sorted_arr3 = func0(arr3, 3);
assert(strcmp(sorted_arr3[0].item, "item3") == 0 && strcmp(sorted_arr3[1].item, "item2") == 0 && strcmp(sorted_arr3[2].item, "item1") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %rdi,%r12
mov $0x10,%edx
lea -0x78(%rip),%rcx
callq 1080 <qsort@plt>
mov %r12,%rax
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbx
movsxd rsi, esi; nmemb
mov rbx, rdi
lea rcx, compare_tuples; compar
mov edx, 10h; size
call _qsort
mov rax, rbx
pop rbx
retn | void * func0(void *a1, int a2)
{
qsort(a1, a2, 0x10uLL, compare_tuples);
return a1;
} | func0:
ENDBR64
PUSH RBX
MOVSXD RSI,ESI
MOV RBX,RDI
LEA RCX,[0x101470]
MOV EDX,0x10
CALL 0x00101090
MOV RAX,RBX
POP RBX
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x10,compare_tuples);
return param_1;
} |
5,376 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A[], int left_element, int right_element) {
if (left_element > right_element) {
return left_element;
}
int mid = left_element + (right_element - left_element) / 2;
if (A[mid] == mid) {
return func0(A, mid + 1, right_element);
} else {
return func0(A, left_element, mid - 1);
}
}
| int main() {
int test_array1[] = {0, 1, 2, 3, 4, 5, 6};
int test_array2[] = {0, 1, 2, 6, 9, 11, 15};
int test_array3[] = {1, 2, 3, 4, 6, 9, 11, 15};
assert(func0(test_array1, 0, 6) == 7);
assert(func0(test_array2, 0, 6) == 3);
assert(func0(test_array3, 0, 7) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 118c <func0+0x23>
mov -0x1c(%rbp),%eax
jmp 11f0 <func0+0x87>
mov -0x20(%rbp),%eax
sub -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jne 11d9 <func0+0x70>
mov -0x4(%rbp),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%edx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <func0>
jmp 11f0 <func0+0x87>
mov -0x4(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <func0>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jle short loc_118C
mov eax, [rbp+var_1C]
jmp short locret_11F0
loc_118C:
mov eax, [rbp+var_20]
sub eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jnz short loc_11D9
mov eax, [rbp+var_4]
lea ecx, [rax+1]
mov edx, [rbp+var_20]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
jmp short locret_11F0
loc_11D9:
mov eax, [rbp+var_4]
lea edx, [rax-1]
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
locret_11F0:
leave
retn | long long func0(long long a1, unsigned int a2, unsigned int a3)
{
unsigned int v4; // [rsp+1Ch] [rbp-4h]
if ( (int)a2 > (int)a3 )
return a2;
v4 = (int)(a3 - a2) / 2 + a2;
if ( v4 == *(_DWORD *)(4LL * (int)v4 + a1) )
return func0(a1, v4 + 1, a3);
else
return func0(a1, a2, v4 - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x0010118c
MOV EAX,dword ptr [RBP + -0x1c]
JMP 0x001011f0
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JNZ 0x001011d9
MOV EAX,dword ptr [RBP + -0x4]
LEA ECX,[RAX + 0x1]
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
JMP 0x001011f0
LAB_001011d9:
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + -0x1]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
LAB_001011f0:
LEAVE
RET | ulong func0(long param_1,uint param_2,int param_3)
{
int iVar1;
ulong uVar2;
if (param_3 < (int)param_2) {
uVar2 = (ulong)param_2;
}
else {
iVar1 = param_2 + (int)(param_3 - param_2) / 2;
if (iVar1 == *(int *)(param_1 + (long)iVar1 * 4)) {
uVar2 = func0(param_1,iVar1 + 1,param_3);
}
else {
uVar2 = func0(param_1,param_2,iVar1 + -1);
}
}
return uVar2;
} |
5,377 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A[], int left_element, int right_element) {
if (left_element > right_element) {
return left_element;
}
int mid = left_element + (right_element - left_element) / 2;
if (A[mid] == mid) {
return func0(A, mid + 1, right_element);
} else {
return func0(A, left_element, mid - 1);
}
}
| int main() {
int test_array1[] = {0, 1, 2, 3, 4, 5, 6};
int test_array2[] = {0, 1, 2, 6, 9, 11, 15};
int test_array3[] = {1, 2, 3, 4, 6, 9, 11, 15};
assert(func0(test_array1, 0, 6) == 7);
assert(func0(test_array2, 0, 6) == 3);
assert(func0(test_array3, 0, 7) == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %esi,%eax
cmp %edx,%esi
jg 11a5 <func0+0x3c>
sub $0x8,%rsp
mov %edx,%ecx
sub %esi,%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
add %esi,%eax
movslq %eax,%rcx
cmp %eax,(%rdi,%rcx,4)
je 119b <func0+0x32>
lea -0x1(%rax),%edx
callq 1169 <func0>
add $0x8,%rsp
retq
lea 0x1(%rax),%esi
callq 1169 <func0>
jmp 1196 <func0+0x2d>
retq
| func0:
endbr64
mov eax, esi
cmp esi, edx
jg short locret_11A5
sub rsp, 8
mov ecx, edx
sub ecx, esi
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
add eax, esi
movsxd rcx, eax
cmp [rdi+rcx*4], eax
jz short loc_119B
lea edx, [rax-1]
call func0
loc_1196:
add rsp, 8
retn
loc_119B:
lea esi, [rax+1]
call func0
jmp short loc_1196
locret_11A5:
retn | long long func0(long long a1, long long a2, int a3)
{
long long result; // rax
int v4; // eax
result = (unsigned int)a2;
if ( (int)a2 <= a3 )
{
v4 = a2 + (a3 - (int)a2) / 2;
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 )
return func0(a1, (unsigned int)(v4 + 1));
else
return func0(a1, a2);
}
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDX
JG 0x001011a5
SUB RSP,0x8
MOV ECX,EDX
SUB ECX,ESI
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
ADD EAX,ESI
MOVSXD RCX,EAX
CMP dword ptr [RDI + RCX*0x4],EAX
JZ 0x0010119b
LEA EDX,[RAX + -0x1]
CALL 0x00101169
LAB_00101196:
ADD RSP,0x8
RET
LAB_0010119b:
LEA ESI,[RAX + 0x1]
CALL 0x00101169
JMP 0x00101196
LAB_001011a5:
RET | ulong func0(long param_1,ulong param_2,int param_3)
{
int iVar1;
ulong uVar2;
iVar1 = (int)param_2;
if (iVar1 <= param_3) {
iVar1 = (param_3 - iVar1) / 2 + iVar1;
if (*(int *)(param_1 + (long)iVar1 * 4) == iVar1) {
uVar2 = func0(param_1,iVar1 + 1);
}
else {
uVar2 = func0(param_1,param_2,iVar1 + -1);
}
return uVar2;
}
return param_2 & 0xffffffff;
} |
5,378 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A[], int left_element, int right_element) {
if (left_element > right_element) {
return left_element;
}
int mid = left_element + (right_element - left_element) / 2;
if (A[mid] == mid) {
return func0(A, mid + 1, right_element);
} else {
return func0(A, left_element, mid - 1);
}
}
| int main() {
int test_array1[] = {0, 1, 2, 3, 4, 5, 6};
int test_array2[] = {0, 1, 2, 6, 9, 11, 15};
int test_array3[] = {1, 2, 3, 4, 6, 9, 11, 15};
assert(func0(test_array1, 0, 6) == 7);
assert(func0(test_array2, 0, 6) == 3);
assert(func0(test_array3, 0, 7) == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%eax
cmp %edx,%esi
jle 1347 <func0+0x17>
jmp 1360 <func0+0x30>
nopl 0x0(%rax)
lea -0x1(%rcx),%edx
cmp %edx,%eax
jg 135e <func0+0x2e>
mov %edx,%ecx
sub %eax,%ecx
sar %ecx
add %eax,%ecx
movslq %ecx,%rsi
cmp %ecx,(%rdi,%rsi,4)
jne 1340 <func0+0x10>
lea 0x1(%rcx),%eax
cmp %edx,%eax
jle 1347 <func0+0x17>
retq
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
cmp esi, edx
jle short loc_12F7
jmp short locret_1310
loc_12F0:
lea edx, [rcx-1]
cmp edx, eax
jl short locret_130E
loc_12F7:
mov ecx, edx
sub ecx, eax
sar ecx, 1
add ecx, eax
movsxd rsi, ecx
cmp [rdi+rsi*4], ecx
jnz short loc_12F0
lea eax, [rcx+1]
cmp edx, eax
jge short loc_12F7
locret_130E:
retn
locret_1310:
retn | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
int v4; // ecx
result = (unsigned int)a2;
if ( a2 <= a3 )
{
do
{
while ( 1 )
{
v4 = result + ((a3 - (int)result) >> 1);
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 )
break;
a3 = v4 - 1;
if ( v4 - 1 < (int)result )
return result;
}
result = (unsigned int)(v4 + 1);
}
while ( a3 >= (int)result );
}
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDX
JLE 0x001012f7
JMP 0x00101310
LAB_001012f0:
LEA EDX,[RCX + -0x1]
CMP EDX,EAX
JL 0x0010130e
LAB_001012f7:
MOV ECX,EDX
SUB ECX,EAX
SAR ECX,0x1
ADD ECX,EAX
MOVSXD RSI,ECX
CMP dword ptr [RDI + RSI*0x4],ECX
JNZ 0x001012f0
LEA EAX,[RCX + 0x1]
CMP EDX,EAX
JGE 0x001012f7
LAB_0010130e:
RET
LAB_00101310:
RET | void func0(long param_1,int param_2,int param_3)
{
int iVar1;
if (param_3 < param_2) {
return;
}
do {
while (iVar1 = (param_3 - param_2 >> 1) + param_2, *(int *)(param_1 + (long)iVar1 * 4) == iVar1)
{
param_2 = iVar1 + 1;
if (param_3 < param_2) {
return;
}
}
param_3 = iVar1 + -1;
} while (param_2 <= param_3);
return;
} |
5,379 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A[], int left_element, int right_element) {
if (left_element > right_element) {
return left_element;
}
int mid = left_element + (right_element - left_element) / 2;
if (A[mid] == mid) {
return func0(A, mid + 1, right_element);
} else {
return func0(A, left_element, mid - 1);
}
}
| int main() {
int test_array1[] = {0, 1, 2, 3, 4, 5, 6};
int test_array2[] = {0, 1, 2, 6, 9, 11, 15};
int test_array3[] = {1, 2, 3, 4, 6, 9, 11, 15};
assert(func0(test_array1, 0, 6) == 7);
assert(func0(test_array2, 0, 6) == 3);
assert(func0(test_array3, 0, 7) == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%eax
cmp %edx,%esi
jg 1337 <func0+0x27>
nopw 0x0(%rax,%rax,1)
mov %edx,%ecx
sub %eax,%ecx
sar %ecx
add %eax,%ecx
movslq %ecx,%rsi
cmp %ecx,(%rdi,%rsi,4)
je 1340 <func0+0x30>
lea -0x1(%rcx),%edx
cmp %eax,%edx
jge 1320 <func0+0x10>
retq
nopl 0x0(%rax,%rax,1)
lea 0x1(%rcx),%eax
cmp %edx,%eax
jle 1320 <func0+0x10>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
cmp esi, edx
jg short locret_1337
nop word ptr [rax+rax+00h]
loc_1320:
mov ecx, edx
sub ecx, eax
sar ecx, 1
add ecx, eax
movsxd rsi, ecx
cmp [rdi+rsi*4], ecx
jz short loc_1340
lea edx, [rcx-1]
cmp edx, eax
jge short loc_1320
locret_1337:
retn
loc_1340:
lea eax, [rcx+1]
cmp eax, edx
jle short loc_1320
retn | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
int v4; // ecx
result = (unsigned int)a2;
if ( a2 <= a3 )
{
do
{
while ( 1 )
{
v4 = result + ((a3 - (int)result) >> 1);
if ( *(_DWORD *)(a1 + 4LL * v4) == v4 )
break;
a3 = v4 - 1;
if ( v4 - 1 < (int)result )
return result;
}
result = (unsigned int)(v4 + 1);
}
while ( (int)result <= a3 );
}
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDX
JG 0x00101337
NOP word ptr [RAX + RAX*0x1]
LAB_00101320:
MOV ECX,EDX
SUB ECX,EAX
SAR ECX,0x1
ADD ECX,EAX
MOVSXD RSI,ECX
CMP dword ptr [RDI + RSI*0x4],ECX
JZ 0x00101340
LEA EDX,[RCX + -0x1]
CMP EDX,EAX
JGE 0x00101320
LAB_00101337:
RET
LAB_00101340:
LEA EAX,[RCX + 0x1]
CMP EAX,EDX
JLE 0x00101320
RET | void func0(long param_1,int param_2,int param_3)
{
int iVar1;
if (param_2 <= param_3) {
do {
while (iVar1 = (param_3 - param_2 >> 1) + param_2,
*(int *)(param_1 + (long)iVar1 * 4) == iVar1) {
param_2 = iVar1 + 1;
if (param_3 < param_2) {
return;
}
}
param_3 = iVar1 + -1;
} while (param_2 <= param_3);
}
return;
} |
5,380 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to maintain the min heap property
void min_heapify(int* heap, int size, int i) {
int smallest = i;
int left = 2*i +1;
int right = 2*i +2;
if(left < size && heap[left] < heap[smallest])
smallest = left;
if(right < size && heap[right] < heap[smallest])
smallest = right;
if(smallest != i){
int temp = heap[i];
heap[i] = heap[smallest];
heap[smallest] = temp;
min_heapify(heap, size, smallest);
}
}
| int* func0(int* nums, int size) {
// Copy nums to heap array
int* heap = malloc(size * sizeof(int));
for(int i=0; i<size; i++)
heap[i] = nums[i];
// Heapify
for(int i=(size/2)-1; i>=0; i--)
min_heapify(heap, size, i);
// Extract elements
int* sorted = malloc(size * sizeof(int));
int heap_size = size;
for(int i=0; i<size; i++) {
sorted[i] = heap[0];
heap[0] = heap[heap_size-1];
heap_size--;
min_heapify(heap, heap_size, 0);
}
free(heap);
return sorted;
}
| int main() {
// Test Case 1
int test1[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int expected1[] = {1, 2, 3, 4, 7, 8, 9, 9, 10, 14, 18};
int size1 = sizeof(test1)/sizeof(test1[0]);
int* result1 = func0(test1, size1);
for(int i=0; i<size1; i++)
assert(result1[i] == expected1[i]);
free(result1);
// Test Case 2
int test2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int expected2[] = {14, 22, 25, 25, 35, 58, 65, 75, 85};
int size2 = sizeof(test2)/sizeof(test2[0]);
int* result2 = func0(test2, size2);
for(int i=0; i<size2; i++)
assert(result2[i] == expected2[i]);
free(result2);
// Test Case 3
int test3[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 0};
int expected3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int size3 = sizeof(test3)/sizeof(test3[0]);
int* result3 = func0(test3, size3);
for(int i=0; i<size3; i++)
assert(result3[i] == expected3[i]);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1337 <func0+0x62>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x10(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1306 <func0+0x31>
mov -0x2c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
sub $0x1,%eax
mov %eax,-0x1c(%rbp)
jmp 136b <func0+0x96>
mov -0x1c(%rbp),%edx
mov -0x2c(%rbp),%ecx
mov -0x10(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 11a9 <min_heapify>
subl $0x1,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jns 1353 <func0+0x7e>
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x2c(%rbp),%eax
mov %eax,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 13eb <func0+0x116>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%rax
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%rax
mov %edx,(%rax)
subl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%ecx
mov -0x10(%rbp),%rax
mov $0x0,%edx
mov %ecx,%esi
mov %rax,%rdi
callq 11a9 <min_heapify>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1395 <func0+0xc0>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_20], 0
jmp short loc_1337
loc_1306:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_20], 1
loc_1337:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jl short loc_1306
mov eax, [rbp+var_2C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
sub eax, 1
mov [rbp+var_1C], eax
jmp short loc_136B
loc_1353:
mov edx, [rbp+var_1C]
mov ecx, [rbp+var_2C]
mov rax, [rbp+ptr]
mov esi, ecx
mov rdi, rax
call min_heapify
sub [rbp+var_1C], 1
loc_136B:
cmp [rbp+var_1C], 0
jns short loc_1353
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov eax, [rbp+var_2C]
mov [rbp+var_18], eax
mov [rbp+var_14], 0
jmp short loc_13EB
loc_1395:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov rax, [rbp+ptr]
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_18]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+ptr]
mov [rax], edx
sub [rbp+var_18], 1
mov ecx, [rbp+var_18]
mov rax, [rbp+ptr]
mov edx, 0
mov esi, ecx
mov rdi, rax
call min_heapify
add [rbp+var_14], 1
loc_13EB:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_1395
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, signed int a2)
{
int i; // [rsp+10h] [rbp-20h]
int j; // [rsp+14h] [rbp-1Ch]
unsigned int v5; // [rsp+18h] [rbp-18h]
int k; // [rsp+1Ch] [rbp-14h]
_DWORD *ptr; // [rsp+20h] [rbp-10h]
_DWORD *v8; // [rsp+28h] [rbp-8h]
ptr = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
ptr[i] = *(_DWORD *)(4LL * i + a1);
for ( j = a2 / 2 - 1; j >= 0; --j )
min_heapify(ptr, (unsigned int)a2, (unsigned int)j);
v8 = malloc(4LL * a2);
v5 = a2;
for ( k = 0; k < a2; ++k )
{
v8[k] = *ptr;
*ptr = ptr[--v5];
min_heapify(ptr, v5, 0LL);
}
free(ptr);
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101337
LAB_00101306:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x20],0x1
LAB_00101337:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101306
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
SUB EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0010136b
LAB_00101353:
MOV EDX,dword ptr [RBP + -0x1c]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x001011a9
SUB dword ptr [RBP + -0x1c],0x1
LAB_0010136b:
CMP dword ptr [RBP + -0x1c],0x0
JNS 0x00101353
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x18],EAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013eb
LAB_00101395:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
SUB dword ptr [RBP + -0x18],0x1
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,0x0
MOV ESI,ECX
MOV RDI,RAX
CALL 0x001011a9
ADD dword ptr [RBP + -0x14],0x1
LAB_001013eb:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101395
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
int4 *__ptr;
void *pvVar1;
int local_28;
int local_24;
int local_20;
int local_1c;
__ptr = (int4 *)malloc((long)param_2 << 2);
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
__ptr[local_28] = *(int4 *)(param_1 + (long)local_28 * 4);
}
local_24 = param_2 / 2;
while (local_24 = local_24 + -1, -1 < local_24) {
min_heapify(__ptr,param_2,local_24);
}
pvVar1 = malloc((long)param_2 << 2);
local_20 = param_2;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
*(int4 *)((long)local_1c * 4 + (long)pvVar1) = *__ptr;
*__ptr = __ptr[(long)local_20 + -1];
local_20 = local_20 + -1;
min_heapify(__ptr,local_20,0);
}
free(__ptr);
return pvVar1;
} |
5,381 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to maintain the min heap property
void min_heapify(int* heap, int size, int i) {
int smallest = i;
int left = 2*i +1;
int right = 2*i +2;
if(left < size && heap[left] < heap[smallest])
smallest = left;
if(right < size && heap[right] < heap[smallest])
smallest = right;
if(smallest != i){
int temp = heap[i];
heap[i] = heap[smallest];
heap[smallest] = temp;
min_heapify(heap, size, smallest);
}
}
| int* func0(int* nums, int size) {
// Copy nums to heap array
int* heap = malloc(size * sizeof(int));
for(int i=0; i<size; i++)
heap[i] = nums[i];
// Heapify
for(int i=(size/2)-1; i>=0; i--)
min_heapify(heap, size, i);
// Extract elements
int* sorted = malloc(size * sizeof(int));
int heap_size = size;
for(int i=0; i<size; i++) {
sorted[i] = heap[0];
heap[0] = heap[heap_size-1];
heap_size--;
min_heapify(heap, heap_size, 0);
}
free(heap);
return sorted;
}
| int main() {
// Test Case 1
int test1[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int expected1[] = {1, 2, 3, 4, 7, 8, 9, 9, 10, 14, 18};
int size1 = sizeof(test1)/sizeof(test1[0]);
int* result1 = func0(test1, size1);
for(int i=0; i<size1; i++)
assert(result1[i] == expected1[i]);
free(result1);
// Test Case 2
int test2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int expected2[] = {14, 22, 25, 25, 35, 58, 65, 75, 85};
int size2 = sizeof(test2)/sizeof(test2[0]);
int* result2 = func0(test2, size2);
for(int i=0; i<size2; i++)
assert(result2[i] == expected2[i]);
free(result2);
// Test Case 3
int test3[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 0};
int expected3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int size3 = sizeof(test3)/sizeof(test3[0]);
int* result3 = func0(test3, size3);
for(int i=0; i<size3; i++)
assert(result3[i] == expected3[i]);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%r12d
movslq %esi,%r13
shl $0x2,%r13
mov %r13,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbx
test %r12d,%r12d
jle 12f7 <func0+0xd2>
lea -0x1(%r12),%ecx
mov $0x0,%eax
mov 0x0(%rbp,%rax,4),%edx
mov %edx,(%rbx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 125c <func0+0x37>
mov %r12d,%ebp
shr $0x1f,%ebp
add %r12d,%ebp
sar %ebp
sub $0x1,%ebp
js 12ea <func0+0xc5>
mov %ebp,%edx
mov %r12d,%esi
mov %rbx,%rdi
callq 11a9 <min_heapify>
sub $0x1,%ebp
jns 127f <func0+0x5a>
mov %r13,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %r12d,%r12d
jle 12d6 <func0+0xb1>
lea -0x1(%r12),%ebp
movslq %ebp,%rbp
mov $0x0,%r13d
mov (%rbx),%eax
mov %eax,(%r14,%r13,4)
mov (%rbx,%rbp,4),%eax
mov %eax,(%rbx)
mov $0x0,%edx
mov %ebp,%esi
mov %rbx,%rdi
callq 11a9 <min_heapify>
add $0x1,%r13
sub $0x1,%rbp
cmp %r13d,%r12d
jg 12af <func0+0x8a>
mov %rbx,%rdi
callq 1080 <free@plt>
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov %r13,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
jmp 12a1 <func0+0x7c>
mov %r13,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
jmp 12d6 <func0+0xb1>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov r12d, esi
movsxd r13, esi
shl r13, 2
mov rdi, r13
call _malloc
mov rbx, rax
test r12d, r12d
jle loc_12F2
mov ecx, r12d
mov eax, 0
loc_125A:
mov edx, [rbp+rax*4+0]
mov [rbx+rax*4], edx
add rax, 1
cmp rax, rcx
jnz short loc_125A
mov ebp, r12d
shr ebp, 1Fh
add ebp, r12d
sar ebp, 1
sub ebp, 1
js short loc_12E5
loc_127A:
mov edx, ebp
mov esi, r12d
mov rdi, rbx
call min_heapify
sub ebp, 1
jns short loc_127A
mov rdi, r13
call _malloc
mov r14, rax
test r12d, r12d
jle short loc_12D1
loc_129C:
lea ebp, [r12-1]
movsxd rbp, ebp
mov r13d, 0
loc_12AA:
mov eax, [rbx]
mov [r14+r13*4], eax
mov eax, [rbx+rbp*4]
mov [rbx], eax
mov edx, 0
mov esi, ebp
mov rdi, rbx
call min_heapify
add r13, 1
sub rbp, 1
cmp r12d, r13d
jg short loc_12AA
loc_12D1:
mov rdi, rbx
call _free
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12E5:
mov rdi, r13
call _malloc
mov r14, rax
jmp short loc_129C
loc_12F2:
mov rdi, r13
call _malloc
mov r14, rax
jmp short loc_12D1 | long long func0(long long a1, int a2)
{
_DWORD *v2; // rbx
long long v3; // rcx
long long i; // rax
int j; // ebp
long long v6; // rcx
long long v7; // r14
long long v8; // rbp
long long v9; // r13
v2 = (_DWORD *)malloc(4LL * a2);
if ( a2 <= 0 )
{
v7 = malloc(4LL * a2);
}
else
{
v3 = (unsigned int)a2;
for ( i = 0LL; i != a2; ++i )
v2[i] = *(_DWORD *)(a1 + 4 * i);
for ( j = a2 / 2 - 1; j >= 0; --j )
min_heapify(v2, (unsigned int)a2, (unsigned int)j, v3);
v7 = malloc(4LL * a2);
v8 = a2 - 1;
v9 = 0LL;
do
{
*(_DWORD *)(v7 + 4 * v9) = *v2;
*v2 = v2[v8];
min_heapify(v2, (unsigned int)v8, 0LL, v6);
++v9;
--v8;
}
while ( a2 > (int)v9 );
}
free(v2);
return v7;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV R12D,ESI
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010b0
MOV RBX,RAX
TEST R12D,R12D
JLE 0x001012f2
MOV ECX,R12D
MOV EAX,0x0
LAB_0010125a:
MOV EDX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [RBX + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x0010125a
MOV EBP,R12D
SHR EBP,0x1f
ADD EBP,R12D
SAR EBP,0x1
SUB EBP,0x1
JS 0x001012e5
LAB_0010127a:
MOV EDX,EBP
MOV ESI,R12D
MOV RDI,RBX
CALL 0x001011a9
SUB EBP,0x1
JNS 0x0010127a
MOV RDI,R13
CALL 0x001010b0
MOV R14,RAX
TEST R12D,R12D
JLE 0x001012d1
LAB_0010129c:
LEA EBP,[R12 + -0x1]
MOVSXD RBP,EBP
MOV R13D,0x0
LAB_001012aa:
MOV EAX,dword ptr [RBX]
MOV dword ptr [R14 + R13*0x4],EAX
MOV EAX,dword ptr [RBX + RBP*0x4]
MOV dword ptr [RBX],EAX
MOV EDX,0x0
MOV ESI,EBP
MOV RDI,RBX
CALL 0x001011a9
ADD R13,0x1
SUB RBP,0x1
CMP R12D,R13D
JG 0x001012aa
LAB_001012d1:
MOV RDI,RBX
CALL 0x00101080
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012e5:
MOV RDI,R13
CALL 0x001010b0
MOV R14,RAX
JMP 0x0010129c
LAB_001012f2:
MOV RDI,R13
CALL 0x001010b0
MOV R14,RAX
JMP 0x001012d1 | void * func0(long param_1,uint param_2)
{
int4 *__ptr;
ulong uVar1;
void *pvVar2;
int iVar3;
size_t __size;
long lVar4;
__size = (long)(int)param_2 << 2;
__ptr = (int4 *)malloc(__size);
if ((int)param_2 < 1) {
pvVar2 = malloc(__size);
}
else {
uVar1 = 0;
do {
__ptr[uVar1] = *(int4 *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
iVar3 = (int)param_2 / 2 + -1;
if (iVar3 < 0) {
pvVar2 = malloc(__size);
}
else {
do {
min_heapify(__ptr,param_2,iVar3);
iVar3 = iVar3 + -1;
} while (-1 < iVar3);
pvVar2 = malloc(__size);
if ((int)param_2 < 1) goto LAB_001012d1;
}
uVar1 = (ulong)(int)(param_2 - 1);
lVar4 = 0;
do {
*(int4 *)((long)pvVar2 + lVar4 * 4) = *__ptr;
*__ptr = __ptr[uVar1];
min_heapify(__ptr,uVar1 & 0xffffffff,0);
lVar4 = lVar4 + 1;
uVar1 = uVar1 - 1;
} while ((int)lVar4 < (int)param_2);
}
LAB_001012d1:
free(__ptr);
return pvVar2;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.