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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
2,682 | func0 |
#include <cmath>
#include <cassert>
| int func0(int n) {
if (n == 0) {
return 1;
}
if ((n & (n + 1)) == 0) {
return n;
}
int pos = int(log2((~n) & -(~n)) + 1);
// int pos = get_Pos_Of_Right_most_Set_Bit(~n);
return ((1 << (pos - 1)) | n);
}
| int main() {
assert(func0(21) == 23);
assert(func0(11) == 15);
assert(func0(15) == 15);
return 0;
}
| O2 | cpp | func0(int) [clone .part.0]:
lea 0x1(%rdi),%edx
push %r12
mov %edi,%r12d
test %edx,%edi
je 1248 <_Z5func0i.part.0+0x38>
mov %edi,%eax
pxor %xmm0,%xmm0
not %eax
and %edx,%eax
cvtsi2sd %eax,%xmm0
callq 1060 <log2@plt>
addsd 0xe51(%rip),%xmm0
mov $0x1,%eax
cvttsd2si %xmm0,%ecx
sub $0x1,%ecx... | _Z5func0i:
endbr64
push rbx
mov ebx, 1
test edi, edi
jz short loc_1177
lea eax, [rdi+1]
mov ebx, edi
test edi, eax
jnz short loc_1180
loc_1177:
mov eax, ebx
pop rbx
retn
loc_1180:
mov edx, edi
pxor xmm0, xmm0
not edx
and eax, edx
cvtsi2sd xmm0, eax; x
call _log2
a... | long long func0(unsigned int a1)
{
unsigned int v1; // ebx
v1 = 1;
if ( a1 && (v1 = a1, ((a1 + 1) & a1) != 0) )
return (1 << ((int)(log2((double)(int)(~a1 & (a1 + 1))) + 1.0) - 1)) | a1;
else
return v1;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,0x1
TEST EDI,EDI
JZ 0x00101177
LEA EAX,[RDI + 0x1]
MOV EBX,EDI
TEST EDI,EAX
JNZ 0x00101180
LAB_00101177:
MOV EAX,EBX
POP RBX
RET
LAB_00101180:
MOV EDX,EDI
PXOR XMM0,XMM0
NOT EDX
AND EAX,EDX
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
MOV EAX,0x1
CVTTSD2SI ECX,XMM0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
uint func0(int param_1)
{
uint uVar1;
double dVar2;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = param_1, (param_1 & param_1 + 1U) != 0)) {
dVar2 = log2((double)(int)(param_1 + 1U & ~param_1));
return... |
2,683 | func0 |
#include <cmath>
#include <cassert>
| int func0(int n) {
if (n == 0) {
return 1;
}
if ((n & (n + 1)) == 0) {
return n;
}
int pos = int(log2((~n) & -(~n)) + 1);
// int pos = get_Pos_Of_Right_most_Set_Bit(~n);
return ((1 << (pos - 1)) | n);
}
| int main() {
assert(func0(21) == 23);
assert(func0(11) == 15);
assert(func0(15) == 15);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r12
mov $0x1,%r12d
test %edi,%edi
je 117a <_Z5func0i+0x1a>
lea 0x1(%rdi),%edx
mov %edi,%r12d
test %edx,%edi
jne 1180 <_Z5func0i+0x20>
mov %r12d,%eax
pop %r12
retq
mov %edi,%eax
pxor %xmm0,%xmm0
not %eax
and %edx,%eax
cvtsi2sd %eax,%xmm0
callq 1050 <log2@... | _Z5func0i:
endbr64
push rbx
mov ebx, 1
test edi, edi
jz short loc_1177
lea eax, [rdi+1]
mov ebx, edi
test edi, eax
jnz short loc_1180
loc_1177:
mov eax, ebx
pop rbx
retn
loc_1180:
mov edx, edi
pxor xmm0, xmm0
not edx
and eax, edx
cvtsi2sd xmm0, eax; x
call _log2
a... | long long func0(unsigned int a1)
{
unsigned int v1; // ebx
v1 = 1;
if ( a1 && (v1 = a1, ((a1 + 1) & a1) != 0) )
return (1 << ((int)(log2((double)(int)(~a1 & (a1 + 1))) + 1.0) - 1)) | a1;
else
return v1;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,0x1
TEST EDI,EDI
JZ 0x00101177
LEA EAX,[RDI + 0x1]
MOV EBX,EDI
TEST EDI,EAX
JNZ 0x00101180
LAB_00101177:
MOV EAX,EBX
POP RBX
RET
LAB_00101180:
MOV EDX,EDI
PXOR XMM0,XMM0
NOT EDX
AND EAX,EDX
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
MOV EAX,0x1
CVTTSD2SI ECX,XMM0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
uint func0(int param_1)
{
uint uVar1;
double dVar2;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = param_1, (param_1 & param_1 + 1U) != 0)) {
dVar2 = log2((double)(int)(param_1 + 1U & ~param_1));
return... |
2,684 | func0 |
#include <cassert>
| int func0(int num1, int num2, int num3) {
int lnum;
if (num1 >= num2 && num1 >= num3) {
lnum = num1;
} else if (num2 >= num1 && num2 >= num3) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jl 1172 <_Z5func0iii+0x29>
mov -0x14(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1172 <_Z5func0iii+0x29>
mov -0x14(%rbp),%eax
mov ... | _Z5func0iii:
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_14]
cmp eax, [rbp+var_18]
jl short loc_1172
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jl short loc_1172
mov eax, [rbp+var_14]
mov [rbp+var... | long long func0(signed int a1, signed int a2, signed int a3)
{
if ( a1 < a2 || a1 < a3 )
{
if ( a2 < a1 || a2 < a3 )
return (unsigned int)a3;
else
return (unsigned int)a2;
}
else
{
return (unsigned int)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 + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x00101172
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101172
MOV EAX,dword ptr [RBP + -0x14]
... | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
int local_c;
if ((((param_1 < param_2) || (local_c = param_1, param_1 < param_3)) &&
(local_c = param_3, param_1 <= param_2)) && (param_3 <= param_2)) {
local_c = param_2;
}
return local_c;
} |
2,685 | func0 |
#include <cassert>
| int func0(int num1, int num2, int num3) {
int lnum;
if (num1 >= num2 && num1 >= num3) {
lnum = num1;
} else if (num2 >= num1 && num2 >= num3) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
mov %edi,%eax
cmp %edx,%esi
mov %edx,%ecx
cmovge %esi,%ecx
cmp %ecx,%edi
jge 1146 <_Z5func0iii+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
| _Z5func0iii:
endbr64
mov eax, edi
cmp esi, edx
mov ecx, edx
cmovge ecx, esi
cmp edi, ecx
jge short locret_1146
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, esi
cmovl eax, edx
locret_1146:
retn | long long func0(int a1, int a2, int a3)
{
long long result; // rax
int v4; // ecx
bool v5; // cc
result = (unsigned int)a1;
v4 = a3;
if ( a2 >= a3 )
v4 = a2;
if ( a1 < v4 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a2;
if ( v5 )
... | func0:
ENDBR64
MOV EAX,EDI
CMP ESI,EDX
MOV ECX,EDX
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x00101146
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,ESI
CMOVL EAX,EDX
LAB_00101146:
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
iVar2 = param_3;
if (param_3 <= param_2) {
iVar2 = param_2;
}
if (param_1 < iVar2) {
if (param_1 < param_3) {
param_1 = param_3;
}
bVar1 = param_2 < param_1;
param_1 = param_2;
... |
2,686 | func0 |
#include <cassert>
| int func0(int num1, int num2, int num3) {
int lnum;
if (num1 >= num2 && num1 >= num3) {
lnum = num1;
} else if (num2 >= num1 && num2 >= num3) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovge %esi,%ecx
cmp %ecx,%edi
jge 115d <_Z5func0iii+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
xchg %ax,%ax
| _Z5func0iii:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovge ecx, esi
cmp edi, ecx
jge short locret_115D
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, esi
cmovl eax, edx
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 >= a3 )
v3 = a2;
if ( a1 < v3 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a2;
if ( v5 )
... | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x0010115d
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,ESI
CMOVL EAX,EDX
LAB_0010115d:
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
iVar2 = param_3;
if (param_3 <= param_2) {
iVar2 = param_2;
}
if (param_1 < iVar2) {
if (param_1 < param_3) {
param_1 = param_3;
}
bVar1 = param_2 < param_1;
param_1 = param_2;
... |
2,687 | func0 |
#include <cassert>
| int func0(int num1, int num2, int num3) {
int lnum;
if (num1 >= num2 && num1 >= num3) {
lnum = num1;
} else if (num2 >= num1 && num2 >= num3) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovge %esi,%ecx
cmp %ecx,%edi
jge 115d <_Z5func0iii+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
xchg %ax,%ax
| _Z5func0iii:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovge ecx, esi
cmp edi, ecx
jge short locret_115D
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, esi
cmovl eax, edx
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 >= a3 )
v3 = a2;
if ( a1 < v3 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a2;
if ( v5 )
... | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x0010115d
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,ESI
CMOVL EAX,EDX
LAB_0010115d:
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
iVar2 = param_3;
if (param_3 <= param_2) {
iVar2 = param_2;
}
if (param_1 < iVar2) {
if (param_1 < param_3) {
param_1 = param_3;
}
bVar1 = param_2 < param_1;
param_1 = param_2;
... |
2,688 | func0 | #include <iostream>
#include <vector>
#include <cassert>
#include <string>
| int func0(const std::vector<int>& list) {
std::string s;
for (int i : list) {
s += std::to_string(i);
}
return std::stoi(s);
}
| int main() {
assert(func0({1,2,3}) == 123);
assert(func0({4,5,6}) == 456);
assert(func0({7,8,9}) == 789);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 23c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev@p... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_60]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string... | long long func0(long long a1)
{
unsigned int v1; // ebx
int v3; // [rsp+14h] [rbp-7Ch]
long long v4; // [rsp+18h] [rbp-78h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-70h] BYREF
_BYTE v6[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v7[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+78h] [rbp-18h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00101270
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
... | /* func0(std::vector<int, std::allocator<int> > const&) */
int4 func0(vector *param_1)
{
bool bVar1;
int4 uVar2;
long in_FS_OFFSET;
int8 local_80;
int8 local_78;
vector<int,std::allocator<int>> *local_70;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFS... |
2,689 | func0 | #include <iostream>
#include <vector>
#include <cassert>
#include <string>
| int func0(const std::vector<int>& list) {
std::string s;
for (int i : list) {
s += std::to_string(i);
}
return std::stoi(s);
}
| int main() {
assert(func0({1,2,3}) == 123);
assert(func0({4,5,6}) == 456);
assert(func0({7,8,9}) == 789);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
mov (%rdi),%rbx
mov 0x8(%rdi),%rb... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 130h
mov rax, fs:28h
mov [rsp+158h+var_30], rax
xor eax, eax
lea rax, [rsp+158h+var_138]
mov [rsp+158h+var_148], rax
mov [rsp+158h+var_140], 0
mov byte ptr [rsp+158h+var_138], 0
mov ... | long long func0(unsigned int **a1)
{
unsigned int *v1; // r13
unsigned int *v2; // r14
void *v3; // rbx
int *v4; // rbp
int v5; // r12d
long long v6; // rax
unsigned int v7; // ebx
unsigned int v9; // ebx
char *v10; // r12
int v11; // ebp
char v12; // bp
unsigned int v13; // eax
unsigned int ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x130
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x0
MOV byte ptr [RSP + 0x20],0x0
MOV R13,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
CMP R14... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
int iVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
int8 uVar7;
uint uVar8;
ulong uVar9;
uint uVar10;
char cVar11;
uint uVar12;
char *pcVar13;
uint *puVar14;
long in_FS_OFFSE... |
2,690 | func0 | #include <iostream>
#include <vector>
#include <cassert>
#include <string>
| int func0(const std::vector<int>& list) {
std::string s;
for (int i : list) {
s += std::to_string(i);
}
return std::stoi(s);
}
| int main() {
assert(func0({1,2,3}) == 123);
assert(func0({4,5,6}) == 456);
assert(func0({7,8,9}) == 789);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r15
movb $0x0,0x20(%rsp)
mov %r15,0x10(%rs... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148], 0
mov [rsp+188h+var_170], rax
mov... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rbx
unsigned int *v2; // rax
unsigned int v3; // r15d
unsigned int v4; // ecx
unsigned int v5; // r13d
unsigned int v6; // r12d
int v7; // esi
unsigned int v8; // r14d
__int8 *v9; // r15
unsigned int v10; // eax
unsigned int v11; // esi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
char cVar7;
uint uVar8;
uint *puVar9;
int iVar... |
2,691 | func0 | #include <iostream>
#include <vector>
#include <cassert>
#include <string>
| int func0(const std::vector<int>& list) {
std::string s;
for (int i : list) {
s += std::to_string(i);
}
return std::stoi(s);
}
| int main() {
assert(func0({1,2,3}) == 123);
assert(func0({4,5,6}) == 456);
assert(func0({7,8,9}) == 789);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
movb $0x0,0x30(%rsp)
mov %rax,0x8(%rsp... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148], 0
mov [rsp+188h+var_170], rax
mov... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rbx
unsigned int *v2; // rax
unsigned int v3; // r15d
unsigned int v4; // ecx
unsigned int v5; // r14d
unsigned int v6; // r12d
int v7; // esi
unsigned int v8; // r13d
__int8 *v9; // r15
unsigned int v10; // eax
unsigned int v11; // esi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
char cVar7;
uint uVar8;
uint *puVar9;
int iVar... |
2,692 | func0 |
#include <iostream>
#include <string>
#include <sstream>
#include <unordered_map>
#include <cassert>
| std::string func0(const std::string& input) {
std::istringstream iss(input);
std::unordered_map<std::string, bool> words;
std::string result, word;
while (iss >> word) {
if (words.find(word) == words.end()) {
words[word] = true;
result += word + " ";
}
... | int main() {
assert(func0("Python Exercises Practice Solution Exercises") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Python") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Practice") == "Python Exercises Practice... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x238,%rsp
mov %rdi,-0x238(%rbp)
mov %rsi,-0x240(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x240(%rbp),%rcx
lea -0x1a0(%rbp),... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 238h
mov [rbp+var_238], rdi
mov [rbp+var_240], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rcx, [rbp+var_240]
lea rax, [rbp+var_1A0]
mov edx, 8
mov... | long long func0(long long a1, long long a2)
{
_QWORD *v2; // rax
long long v4; // [rsp+10h] [rbp-230h] BYREF
long long v5; // [rsp+18h] [rbp-228h] BYREF
_BYTE v6[64]; // [rsp+20h] [rbp-220h] BYREF
_BYTE v7[32]; // [rsp+60h] [rbp-1E0h] BYREF
_BYTE v8[32]; // [rsp+80h] [rbp-1C0h] BYREF
_BYTE v9[392]; // [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x238
MOV qword ptr [RBP + -0x238],RDI
MOV qword ptr [RBP + -0x240],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RCX,qword ptr [RBP + -0x240]
LEA RAX,[RBP + -0x1a0]
MOV EDX,0x8
MOV RSI,RCX
MOV RDI,RAX
LAB_0010270f:
CALL 0x00102590
L... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
char cVar2;
int *puVar3;
istream *piVar4;
string *in_RSI;
long in_FS_OFFSET;
int8 local_238;
int8 local_230;
unordered_map<std::string,bool,std::hash<std::string>,std::equal_to<std::string>,std::allocator<std::pair<std::st... |
2,693 | func0 |
#include <iostream>
#include <string>
#include <sstream>
#include <unordered_map>
#include <cassert>
| std::string func0(const std::string& input) {
std::istringstream iss(input);
std::unordered_map<std::string, bool> words;
std::string result, word;
while (iss >> word) {
if (words.find(word) == words.end()) {
words[word] = true;
result += word + " ";
}
... | int main() {
assert(func0("Python Exercises Practice Solution Exercises") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Python") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Practice") == "Python Exercises Practice... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x218,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x208(%rsp)
xor %eax,%eax
lea 0x80(%rsp),%r14
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 218h
mov r13, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+248h+var_40], rax
xor eax, eax
lea rbp, [rsp+248h+var_1C8]
lea rdi, [rsp+248h+v... | long long func0(long long a1, long long *a2)
{
long long v2; // rax
long long v3; // rsi
long long **v4; // rbx
unsigned long long v5; // rax
_QWORD *v6; // rax
_QWORD *v7; // rax
unsigned long long v8; // rbx
void *v9; // rbp
size_t v10; // rbp
void *v11; // r12
long long v12; // rax
long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x218
MOV R13,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x208],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x80]
LEA RDI,[RSP + 0xf8]
CALL 0x00102260
LEA RAX,[0x105b28]
MOV qword ptr [RSP + 0xf8],RAX
MOV qword ptr [RSP + 0x1d0],0x0
M... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char *pcVar1;
int8 *puVar2;
int *puVar3;
size_t sVar4;
int iVar5;
int8 uVar6;
ulong uVar7;
long *plVar8;
istream *piVar9;
int *puVar10;
int8 uVar11;
int8 *in_RSI;
long in_FS_OFFSET;
int8 *local_248;
ulong local_240;
int8... |
2,694 | func0 |
#include <iostream>
#include <string>
#include <sstream>
#include <unordered_map>
#include <cassert>
| std::string func0(const std::string& input) {
std::istringstream iss(input);
std::unordered_map<std::string, bool> words;
std::string result, word;
while (iss >> word) {
if (words.find(word) == words.end()) {
words[word] = true;
result += word + " ";
}
... | int main() {
assert(func0("Python Exercises Practice Solution Exercises") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Python") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Practice") == "Python Exercises Practice... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x248,%rsp
mov %rdi,(%rsp)
lea 0xb0(%rsp),%r12
mov %fs:0x28,%rax
mov %rax,0x238(%rsp)
xor %eax,%eax
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 248h
mov [rsp+278h+var_270], rdi
lea rbp, [rsp+278h+var_1C8]
mov rax, fs:28h
mov [rsp+278h+var_40], rax
xor eax, eax
lea r... | long long func0(long long a1, long long a2)
{
long long *v2; // rbx
_BYTE *v3; // r12
_QWORD *v4; // rax
_QWORD *v5; // rax
long long **v6; // r13
size_t v7; // r14
void *v8; // r12
size_t v9; // r13
_QWORD *v10; // rdi
unsigned long long v11; // rax
_QWORD *v12; // rax
long long v13; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x248
MOV qword ptr [RSP + 0x8],RDI
LEA RBP,[RSP + 0xb0]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x238],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x128]
MOV RDI,RAX
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001022a0
LEA RAX,[0x105b10]
XO... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 *__n;
int *puVar1;
size_t sVar2;
int iVar3;
istream *piVar4;
int *puVar5;
ulong uVar6;
long *plVar7;
int8 **__dest;
string *psVar8;
int uVar9;
int8 uVar10;
int extraout_DL;
int uVar11;
int8 *in_RSI;
char *pcVar12;
... |
2,695 | func0 |
#include <iostream>
#include <string>
#include <sstream>
#include <unordered_map>
#include <cassert>
| std::string func0(const std::string& input) {
std::istringstream iss(input);
std::unordered_map<std::string, bool> words;
std::string result, word;
while (iss >> word) {
if (words.find(word) == words.end()) {
words[word] = true;
result += word + " ";
}
... | int main() {
assert(func0("Python Exercises Practice Solution Exercises") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Python") == "Python Exercises Practice Solution");
assert(func0("Python Exercises Practice Solution Practice") == "Python Exercises Practice... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x288,%rsp
mov %rdi,0x28(%rsp)
lea 0xf0(%rsp),%rbp
mov %fs:0x28,%rax
mov %rax,0x278(%rsp)
xor %eax,%eax
l... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 258h
mov [rsp+288h+var_280], rdi
lea r14, [rsp+288h+var_1C8]
mov rax, fs:28h
mov [rsp+288h+var_40], rax
xor eax, eax
lea r... | long long func0(long long a1, long long a2)
{
int **v2; // r14
char *v3; // rbx
_BYTE *v4; // rbp
_QWORD *v5; // rax
void **p_s1; // rbx
_QWORD *v7; // rax
void *v8; // rbp
size_t v9; // r12
void *v10; // r13
size_t v11; // r12
void *v12; // r15
_QWORD *v13; // rdi
unsigned long long v14; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x258
MOV qword ptr [RSP + 0x8],RDI
LEA R14,[RSP + 0xc0]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x248],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x138]
MOV RDI,RAX
MOV qword ptr [RSP + 0x18],RAX
CALL 0x001022a0
LEA RAX,[0x105b10]
XO... | /* WARNING: Removing unreachable block (ram,0x00102dc0) */
/* WARNING: Removing unreachable block (ram,0x00102dfc) */
/* WARNING: Removing unreachable block (ram,0x00102eb2) */
/* WARNING: Removing unreachable block (ram,0x00102e80) */
/* WARNING: Removing unreachable block (ram,0x00102e8b) */
/* WARNING: Removing unre... |
2,696 | func0 |
#include <cassert>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums < n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O0 | cpp | func0(int, int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 117f <_Z5func0iiii... | _Z5func0iiii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11... | long long func0(int a1, int a2, int a3, int a4)
{
unsigned int v5; // [rsp+1Ch] [rbp-4h]
v5 = a1 + a2;
if ( a1 + a2 < a3 || (int)v5 >= a4 )
return v5;
else
return 20LL;
} | 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 dword ptr [RBP + -0x20],ECX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr ... | /* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
iVar1 = param_2 + param_1;
if ((param_3 <= iVar1) && (iVar1 < param_4)) {
iVar1 = 0x14;
}
return iVar1;
} |
2,697 | func0 |
#include <cassert>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums < n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O1 | cpp | func0(int, int, int, int):
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 113e <_Z5func0iiii+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovl %edx,%eax
retq
| _Z5func0iiii:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_113E
cmp eax, ecx
mov edx, 14h
cmovl eax, edx
locret_113E:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result < a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x0010113e
CMP EAX,ECX
MOV EDX,0x14
CMOVL EAX,EDX
LAB_0010113e:
RET | /* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
iVar1 = param_1 + param_2;
if ((param_3 <= iVar1) && (iVar1 < param_4)) {
iVar1 = 0x14;
}
return iVar1;
} |
2,698 | func0 |
#include <cassert>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums < n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O2 | cpp | func0(int, int, int, int):
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 1155 <_Z5func0iiii+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovl %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iiii:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_1155
cmp eax, ecx
mov edx, 14h
cmovl eax, edx
locret_1155:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result < a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x00101155
CMP EAX,ECX
MOV EDX,0x14
CMOVL EAX,EDX
LAB_00101155:
RET | /* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
iVar1 = param_1 + param_2;
if ((param_3 <= iVar1) && (iVar1 < param_4)) {
iVar1 = 0x14;
}
return iVar1;
} |
2,699 | func0 |
#include <cassert>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums < n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O3 | cpp | func0(int, int, int, int):
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 1155 <_Z5func0iiii+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovl %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iiii:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_1155
cmp eax, ecx
mov edx, 14h
cmovl eax, edx
locret_1155:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result < a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x00101155
CMP EAX,ECX
MOV EDX,0x14
CMOVL EAX,EDX
LAB_00101155:
RET | /* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
iVar1 = param_1 + param_2;
if ((param_3 <= iVar1) && (iVar1 < param_4)) {
iVar1 = 0x14;
}
return iVar1;
} |
2,700 | func0 |
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex pattern("[\\W_]+");
return std::regex_replace(text1, pattern, "");
}
| int main() {
assert(func0("**//Google Android// - 12. ") == "GoogleAndroid12");
assert(func0("****//Google Flutter//*** - 36. ") == "GoogleFlutter36");
assert(func0("**//Google Firebase// - 478. ") == "GoogleFirebase478");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aW; "[\\W_]+"
mov ... | long long func0(long long a1, long long a2)
{
_BYTE v3[40]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-18h]
v4 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v3, "[\\W_]+", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_traits... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b63:
CALL 0x00106150
MOV RAX,qword ptr ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 in_RSI;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"[\\W_]+",0x10);
/* try { // try from 00104b84 to 00104b88 has its CatchH... |
2,701 | func0 |
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex pattern("[\\W_]+");
return std::regex_replace(text1, pattern, "");
}
| int main() {
assert(func0("**//Google Android// - 12. ") == "GoogleAndroid12");
assert(func0("****//Google Flutter//*** - 36. ") == "GoogleFlutter36");
assert(func0("**//Google Firebase// - 478. ") == "GoogleFirebase478");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%r13
mov %r13,%rdi
callq 46f0 <_ZNS... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_50]
lea rdi, [rbp+var_48]; this
call __Z... | long long func0(long long a1, long long *a2)
{
long long v4; // rsi
_DWORD *v5; // rdi
volatile signed __int32 *v6; // rcx
long long v7; // rdx
signed __int32 v8; // eax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
long long v12; // [rsp+10h] [rbp-40h]
long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x50]
LEA RDI,[RBP + -0x48]
CALL 0x00104710
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV ECX,0x10
LEA RDX,[0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int8 local_48;
_Sp_counted_base<(_Lock_policy)2> *local_40;
long... |
2,702 | func0 |
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex pattern("[\\W_]+");
return std::regex_replace(text1, pattern, "");
}
| int main() {
assert(func0("**//Google Android// - 12. ") == "GoogleAndroid12");
assert(func0("****//Google Flutter//*** - 36. ") == "GoogleFlutter36");
assert(func0("**//Google Firebase// - 478. ") == "GoogleFirebase478");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_50]
push r12
lea r12, [rbp+var_48]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_28], rax... | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
long long v4; // rdi
long long v5; // rdx
volatile signed __int32 *v6; // rcx
signed __int32 v7; // eax
long long v9; // rax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
__int128 v12; // [rsp+10... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x50]
PUSH R12
LEA R12,[RBP + -0x48]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001036f0
LEA RDX,[0x1196c5]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::... |
2,703 | func0 |
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex pattern("[\\W_]+");
return std::regex_replace(text1, pattern, "");
}
| int main() {
assert(func0("**//Google Android// - 12. ") == "GoogleAndroid12");
assert(func0("****//Google Flutter//*** - 36. ") == "GoogleFlutter36");
assert(func0("**//Google Firebase// - 478. ") == "GoogleFirebase478");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
lea r14, [rbp+var_E0]
push r13
push r12
mov r12, rsi
push rbx
mov rbx, rdi
sub rsp, 108h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v3; // rax
long long v4; // r13
char *v5; // r15
char *v6; // r12
char v7; // al
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
unsigned long long v12; // rsi
long long v13; // rdi
volatile signed __int32 *v14; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R14,[RBP + -0xe0]
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x108
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x130],R14
MOV RDI,RAX
MOV qword ptr [RBP + -0x128],RAX
CALL 0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
string sVar2;
string *psVar3;
long lVar4;
int8 uVar5;
bool bVar6;
char cVar7;
int iVar8;
int8 *puVar9;
string *psVar10;
long lVar11;
long *plVar12;
ulong uVar13;
ulong uVar14;
lon... |
2,704 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O0 | cpp | func0(int, int, int):
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 %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
cmpl $0xb4,-0x4(%rbp)
jne 11ba <_Z5func0iii+0x31>
mov ... | _Z5func0iii:
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 edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
cmp [rbp+var_4], 0B4h
jnz short loc_117A
mov ... | _BOOL8 func0(int a1, int a2, int a3)
{
return a2 + a1 + a3 == 180;
} | 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 EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0xb4
JNZ 0... | /* func0(int, int, int) */
bool func0(int param_1,int param_2,int param_3)
{
return param_3 + param_1 + param_2 == 0xb4;
} |
2,705 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
| _Z5func0iii:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | /* func0(int, int, int) */
bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
2,706 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0iii:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | /* func0(int, int, int) */
bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
2,707 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0iii:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | /* func0(int, int, int) */
bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
2,708 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
#include <algorithm>
| std::string func0(std::string str1) {
str1.erase(std::remove(str1.begin(), str1.end(), ' '), str1.end());
return str1;
}
| int main() {
assert(func0("a b c") == "abc");
assert(func0("1 2 3") == "123");
assert(func0(" b c") == "bc");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 2230 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_50]
mov rdi, rax
call __ZNSt7__cxx1112basic_stri... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
char v5; // [rsp+17h] [rbp-39h] BYREF
long long v6; // [rsp+18h] [rbp-38h] BYREF
long long v7; // [rsp+20h] [rbp-30h] BYREF
long long v8; // [rsp+28h] [rbp-28h] BYREF
_QWORD v9[3]; // [rsp+30h] [rbp-20h] BYREF
v9[1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x001021d0
MOV qword ptr [RBP + -0x30],RAX
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP... | /* func0(std::string) */
string * func0(string *param_1,string *param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int4 extraout_var;
long in_FS_OFFSET;
char local_41;
int8 local_40;
int8 local_38;
__normal_iterator local_30 [2];
__normal_iterator<char_const*,std::string> local_28 [8];
l... |
2,709 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
#include <algorithm>
| std::string func0(std::string str1) {
str1.erase(std::remove(str1.begin(), str1.end(), ' '), str1.end());
return str1;
}
| int main() {
assert(func0("a b c") == "abc");
assert(func0("1 2 3") == "123");
assert(func0(" b c") == "bc");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rdi
mov %rdi,%r12
add 0x8(%rsi),%r12
movb $0x20,0x7(%... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov rdi, [rsi]
mov r12, rdi
add r12, [rsi+8]
mov [rsp+28h+var_21], 20h ; ' '
lea... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long v4; // rdi
long long v5; // r12
_BYTE *v6; // rax
_BYTE *v7; // rsi
_QWORD *v8; // rcx
char *v9; // rax
unsigned int v11; // edx
unsigned long long v12; // rdi
char *v13; // rcx
char *v14; // r9
unsigned int v15; // edx
unsigned int v16; // edx
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV RDI,qword ptr [RSI]
MOV R12,RDI
ADD R12,qword ptr [RSI + 0x8]
MOV byte ptr [RSP + 0x7],0x20
LEA RDX,[RSP + 0x7]
MOV RSI,R12
CALL 0x001016fc
MOV RCX,qword ptr [RBX]
MOV... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
long *plVar1;
__normal_iterator _Var2;
int4 extraout_var;
uint uVar3;
uint uVar4;
ulong uVar5;
long lVar6;
long in_FS_OFFSET;
int local_21;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
lVar6 = *param_2 + param... |
2,710 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
#include <algorithm>
| std::string func0(std::string str1) {
str1.erase(std::remove(str1.begin(), str1.end(), ' '), str1.end());
return str1;
}
| int main() {
assert(func0("a b c") == "abc");
assert(func0("1 2 3") == "123");
assert(func0(" b c") == "bc");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov (%rsi),%rdi
mov 0x8(%rsi),%rsi
mov %rsi,%rax
lea (%rdi,%rsi,1),%rdx
sar $0x2,%rax
test %rax,%rax
jle 1690 <_Z5func0NSt7__cxx1... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
mov rdi, [rsi]
mov rsi, [rsi+8]
mov rax, rsi
lea rdx, [rdi+rsi]
sar rax, 2
test rax, rax
jle loc_166B
lea rcx, [rdi+rax*4]
mov rax, rdi
jmp ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_BYTE *v4; // rdi
long long v5; // rsi
_BYTE *v6; // rdx
_BYTE *v7; // rax
_BYTE *v8; // rcx
_QWORD *v9; // rcx
char *v10; // rax
long long v11; // rsi
_QWORD *result; // rax
long long v13; // rcx
unsigned int v14; // edx
unsigned long long v15; // rdi
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOV RDI,qword ptr [RSI]
MOV RSI,qword ptr [RSI + 0x8]
MOV RAX,RSI
LEA RDX,[RDI + RSI*0x1]
SAR RAX,0x2
TEST RAX,RAX
JLE 0x0010166b
LEA RCX,[RDI + RAX*0x4]
MOV RAX,RDI
JMP 0x001014a3
LAB_00101478:
CMP byte ptr [RAX + 0x1],0x20
JZ 0x00101550
CMP byte ptr... | /* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2)
{
long *plVar1;
char *pcVar2;
char *pcVar3;
char *pcVar4;
uint uVar5;
char *pcVar6;
ulong uVar7;
long lVar8;
uint uVar9;
ulong uVar10;
pcVar3 = (char *)*param_2;
uVar10 = param_2[1];
pcVar2 = pcVar3 + uVar10;
pcVar4 = pc... |
2,711 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
#include <algorithm>
| std::string func0(std::string str1) {
str1.erase(std::remove(str1.begin(), str1.end(), ' '), str1.end());
return str1;
}
| int main() {
assert(func0("a b c") == "abc");
assert(func0("1 2 3") == "123");
assert(func0(" b c") == "bc");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov (%rsi),%rdi
mov 0x8(%rsi),%rsi
mov %rsi,%rax
lea (%rdi,%rsi,1),%rdx
sar $0x2,%rax
test %rax,%rax
jle 1690 <_Z5func0NSt7__cxx1... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
mov rdi, [rsi]
mov rsi, [rsi+8]
mov rax, rsi
lea rdx, [rdi+rsi]
sar rax, 2
test rax, rax
jle loc_166B
lea rcx, [rdi+rax*4]
mov rax, rdi
jmp ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_BYTE *v4; // rdi
long long v5; // rsi
_BYTE *v6; // rdx
_BYTE *v7; // rax
_BYTE *v8; // rcx
_QWORD *v9; // rcx
char *v10; // rax
long long v11; // rsi
_QWORD *result; // rax
long long v13; // rcx
unsigned int v14; // edx
unsigned long long v15; // rdi
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOV RDI,qword ptr [RSI]
MOV RSI,qword ptr [RSI + 0x8]
MOV RAX,RSI
LEA RDX,[RDI + RSI*0x1]
SAR RAX,0x2
TEST RAX,RAX
JLE 0x0010166b
LEA RCX,[RDI + RAX*0x4]
MOV RAX,RDI
JMP 0x001014a3
LAB_00101478:
CMP byte ptr [RAX + 0x1],0x20
JZ 0x00101550
CMP byte ptr... | /* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2)
{
long *plVar1;
char *pcVar2;
char *pcVar3;
char *pcVar4;
uint uVar5;
char *pcVar6;
ulong uVar7;
long lVar8;
uint uVar9;
ulong uVar10;
pcVar3 = (char *)*param_2;
uVar10 = param_2[1];
pcVar2 = pcVar3 + uVar10;
pcVar4 = pc... |
2,712 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<std::string, int>>& dictionary, size_t key) {
return dictionary[key].first;
}
| int main() {
assert(func0({{"physics", 80}, {"math", 90}, {"chemistry", 86}}, 0) == "physics");
assert(func0({{"python", 10}, {"java", 20}, {"C++", 30}}, 2) == "C++");
assert(func0({{"program", 15}, {"computer", 45}}, 1) == "computer");
}
| O0 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> > > const&, unsigned long):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EEm:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdx, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, rdx
mov rdi, rax
call _Z... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
v3 = std::vector<std::pair<std::string,int>>::operator[](a2, a3);
std::string::basic_string(a1, v3);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00103310
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL ... | /* func0(std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > >
const&, unsigned long) */
vector * func0(vector *param_1,ulong param_2)
{
string *psVar1;
ulong in_RDX;
psVar1 = (string *)
std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::strin... |
2,713 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<std::string, int>>& dictionary, size_t key) {
return dictionary[key].first;
}
| int main() {
assert(func0({{"physics", 80}, {"math", 90}, {"chemistry", 86}}, 0) == "physics");
assert(func0({{"python", 10}, {"java", 20}, {"C++", 30}}, 2) == "C++");
assert(func0({{"program", 15}, {"computer", 45}}, 1) == "computer");
}
| O1 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> > > const&, unsigned long):
endbr64
push %rbx
mov %rdi,%rbx
lea (%rdx,%rdx,4),%rdx
mov... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EEm:
endbr64
push rbx
mov rbx, rdi
lea rdx, [rdx+rdx*4]
mov rax, [rsi]
lea rax, [rax+rdx*8]
lea rdx, [rdi+10h]
mov [rdi], rdx
mov rsi, [rax]
mov rdx, rsi
add rdx, [rax+8]
call _ZNSt7__cxx111... | _QWORD * func0(_QWORD *a1, _QWORD *a2, long long a3)
{
_QWORD *v3; // rax
v3 = (_QWORD *)(*a2 + 40 * a3);
*a1 = a1 + 2;
std::string::_M_construct<char *>(a1, *v3, v3[1] + *v3);
return a1;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
LEA RDX,[RDX + RDX*0x4]
MOV RAX,qword ptr [RSI]
LEA RAX,[RAX + RDX*0x8]
LEA RDX,[RDI + 0x10]
MOV qword ptr [RDI],RDX
MOV RSI,qword ptr [RAX]
MOV RDX,RSI
ADD RDX,qword ptr [RAX + 0x8]
CALL 0x00101a22
MOV RAX,RBX
POP RBX
RET | /* func0(std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > >
const&, unsigned long) */
vector * func0(vector *param_1,ulong param_2)
{
int8 *puVar1;
char *pcVar2;
long in_RDX;
puVar1 = (int8 *)(*(long *)param_2 + in_RDX * 0x28);
*(vector **)param_1 = param_1 + 0x10;... |
2,714 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<std::string, int>>& dictionary, size_t key) {
return dictionary[key].first;
}
| int main() {
assert(func0({{"physics", 80}, {"math", 90}, {"chemistry", 86}}, 0) == "physics");
assert(func0({{"python", 10}, {"java", 20}, {"C++", 30}}, 2) == "C++");
assert(func0({{"program", 15}, {"computer", 45}}, 1) == "computer");
}
| O2 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> > > const&, unsigned long):
endbr64
push %r12
mov (%rsi),%rax
lea (%rdx,%rdx,4),%rdx
m... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EEm:
endbr64
push r12
lea rdx, [rdx+rdx*4]
push rbp
push rbx
mov rbx, rdi
add rdi, 10h
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov rax, [rsi]
mov [rbx], rdi
le... | long long * func0(long long *a1, long long *a2, long long a3)
{
void *v4; // rdi
long long v5; // rax
long long v6; // rax
size_t v7; // rbp
_BYTE *v8; // r12
long long v10; // rax
_QWORD v11[5]; // [rsp+0h] [rbp-28h] BYREF
v4 = a1 + 2;
v11[1] = __readfsqword(0x28u);
v5 = *a2;
*a1 = (long long)v4... | func0:
ENDBR64
PUSH R12
LEA RDX,[RDX + RDX*0x4]
PUSH RBP
PUSH RBX
MOV RBX,RDI
ADD RDI,0x10
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RBX],RDI
LEA RAX,[RAX + RDX*0x8]
MOV RBP,qword ptr [RAX + 0x8]
MOV R12,qword ptr [RAX]
MOV qword ptr [RSP],... | /* func0(std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > >
const&, unsigned long) */
vector * func0(vector *param_1,ulong param_2)
{
int8 *puVar1;
long lVar2;
ulong __n;
vector *__src;
long in_RDX;
vector *__dest;
long in_FS_OFFSET;
ulong local_28;
long local... |
2,715 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<std::string, int>>& dictionary, size_t key) {
return dictionary[key].first;
}
| int main() {
assert(func0({{"physics", 80}, {"math", 90}, {"chemistry", 86}}, 0) == "physics");
assert(func0({{"python", 10}, {"java", 20}, {"C++", 30}}, 2) == "C++");
assert(func0({{"program", 15}, {"computer", 45}}, 1) == "computer");
}
| O3 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> > > const&, unsigned long):
endbr64
push %r13
lea (%rdx,%rdx,4),%rdx
push %r12
mov %... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EEm:
endbr64
push r12
lea rdx, [rdx+rdx*4]
push rbp
push rbx
mov rbx, rdi
add rdi, 10h
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov rax, [rsi]
mov [rbx], rdi
le... | long long * func0(long long *a1, long long *a2, long long a3)
{
void *v4; // rdi
long long v5; // rax
long long v6; // rax
size_t v7; // rbp
_BYTE *v8; // r12
long long v10; // rax
_QWORD v11[5]; // [rsp+0h] [rbp-28h] BYREF
v4 = a1 + 2;
v11[1] = __readfsqword(0x28u);
v5 = *a2;
*a1 = (long long)v4... | func0:
ENDBR64
PUSH R12
LEA RDX,[RDX + RDX*0x4]
PUSH RBP
PUSH RBX
MOV RBX,RDI
ADD RDI,0x10
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RBX],RDI
LEA RAX,[RAX + RDX*0x8]
MOV RBP,qword ptr [RAX + 0x8]
MOV R12,qword ptr [RAX]
MOV qword ptr [RSP],... | /* func0(std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > >
const&, unsigned long) */
vector * func0(vector *param_1,ulong param_2)
{
int8 *puVar1;
long lVar2;
ulong __n;
vector *__src;
long in_RDX;
vector *__dest;
long in_FS_OFFSET;
ulong local_28;
long local... |
2,716 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| bool func0(const std::vector<int>& nums) {
std::vector<int> sorted_nums = nums;
std::sort(sorted_nums.begin(), sorted_nums.end());
if (sorted_nums == nums) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({1,2,3,4}) == true);
assert(func0({4,3,2,1}) == false);
assert(func0({0,1,4,9}) == true);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 171a <_ZNSt6vectorIiSaIi... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+var_38]
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2ERKS1_; std::vector<... | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
_BYTE v4[24]; // [rsp+10h] [rbp-30h] BYREF
unsigned long long v5; // [rsp+28h] [rbp-18h]
v5 = __readfsqword(0x28u);
std::vector<int>::vector(v4, a1);
v1 = std::vector<int>::end(v4);
v2 = std::vector<int>::begin(v4);
std::sort<... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0x38]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101297:
CALL 0x001016b0
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001018be
... | /* func0(std::vector<int, std::allocator<int> > const&) */
bool func0(vector *param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
long in_FS_OFFSET;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::all... |
2,717 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| bool func0(const std::vector<int>& nums) {
std::vector<int> sorted_nums = nums;
std::sort(sorted_nums.begin(), sorted_nums.end());
if (sorted_nums == nums) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({1,2,3,4}) == true);
assert(func0({4,3,2,1}) == false);
assert(func0({0,1,4,9}) == true);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov 0x8(%rdi),%rdi
sub (%rbx),%rdi
mov %rdi,%rax
sar $0x2,%rax
je 1359 <_Z5func0RKSt6vectorIiSaIiEE+0xb0>
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 135... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r14, [rdi+8]
sub r14, [rdi]
jz loc_1316
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, r14
jb short loc_1311
mov rdi, r14; unsigned __int64
call __Znwm... | long long func0(long long a1)
{
unsigned int v1; // ebx
unsigned long long v2; // r14
int *v3; // r13
_DWORD *v4; // rsi
long long v5; // r12
int *v6; // r15
unsigned long long v7; // rax
int *v8; // rbx
int *v9; // rsi
int *v10; // rax
int v11; // edx
int v12; // ecx
size_t n; // [rsp+8h] [r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R14,qword ptr [RDI + 0x8]
SUB R14,qword ptr [RDI]
JZ 0x00101316
MOV RAX,0x7ffffffffffffffc
CMP RAX,R14
JC 0x00101311
MOV RDI,R14
CALL 0x00101130
MOV R13,RAX
LAB_001012a5:
MOV RSI,qword ptr [RBP]
MOV R12,qword ptr [RBP + 0x... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7)
{
int iVar1;
int4 *__src;
long lVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int4 *__dest;
_Iter_less_... |
2,718 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| bool func0(const std::vector<int>& nums) {
std::vector<int> sorted_nums = nums;
std::sort(sorted_nums.begin(), sorted_nums.end());
if (sorted_nums == nums) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({1,2,3,4}) == true);
assert(func0({4,3,2,1}) == false);
assert(func0({0,1,4,9}) == true);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%rax
mov (%rdi),%r14
mov %rax,%rbp
sub %r14,%rbp
mov %rbp,%rdx
sar $0x2,%rdx
je 1630 <_Z5func0RKSt6vectorIiSaIiEE+0x... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, [rdi+8]
mov rsi, [rdi]
mov rbp, rax
sub rbp, rsi
jz loc_18F0
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb loc_1957
mov r14, rdi
mov rdi, rbp; uns... | long long func0(long long a1)
{
_DWORD *v1; // rbx
size_t v2; // r12
long long v3; // r14
long long v4; // r15
_DWORD *v5; // rax
_DWORD *v6; // rsi
unsigned long long v7; // rbp
_DWORD *v8; // rax
_DWORD *v9; // r8
unsigned long long v10; // rdx
long long v11; // rdx
int *v12; // r13
int v13... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
MOV RBP,RAX
SUB RBP,RSI
JZ 0x001018f0
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x00101957
MOV R14,RDI
MOV RDI,RBP
CALL 0x00101130
MOV RSI,qword ptr [R14]
MOV RBX,RAX
MOV RAX,qword ptr... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7)
{
int iVar1;
int *piVar2;
int *piVar3;
_Iter_less_iter _Var4;
int7 in_register_00000009;
_Iter_less_iter extraout_EDX;
int iVar5;
... |
2,719 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| bool func0(const std::vector<int>& nums) {
std::vector<int> sorted_nums = nums;
std::sort(sorted_nums.begin(), sorted_nums.end());
if (sorted_nums == nums) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({1,2,3,4}) == true);
assert(func0({4,3,2,1}) == false);
assert(func0({0,1,4,9}) == true);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rdi),%rax
mov (%rdi),%r13
mov %rax,%r12
sub %r13,%r12
mov %r12,%rdx
sar $0x2,%rdx
je 16f0 <_Z5func0RKSt6vectorIiSaIiEE+0... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov ebx, 1
sub rsp, 18h
mov r12, [rdi+8]
sub r12, [rdi]
jz loc_184C
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, r12
jb loc_193C
mov rbx, rdi
mov rdi, r12; unsigned __int64
call ... | long long func0(_QWORD *a1, _DWORD *a2)
{
char *v2; // r15
signed long long v3; // rbx
unsigned long long v4; // r12
char *v5; // rax
bool v6; // zf
char *v7; // rbp
char *v8; // r13
unsigned long long v9; // rdx
char *v10; // rax
char *v11; // r14
int v12; // ecx
char *v13; // rsi
int v14; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,0x1
SUB RSP,0x18
MOV R12,qword ptr [RDI + 0x8]
SUB R12,qword ptr [RDI]
JZ 0x0010184c
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x0010193c
MOV RBX,RDI
MOV RDI,R12
CALL 0x00101130
MOV RSI,qword ptr [RBX]
MOV RBX,qword ptr [RBX + 0x8]
MOV R15,RAX... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7)
{
long lVar1;
int *piVar2;
int iVar3;
int *piVar4;
_Iter_less_iter _Var5;
int7 in_register_00000009;
int iVar6;
size_t sVar7;
s... |
2,720 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i*i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1165 <_Z5func0i+0x1c>
mov $0x2,%eax
jmp 1192 <_Z5func0i+0x49>
movl $0x3,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jl 118f <_Z5func0i+0x46... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jnz short loc_1165
mov eax, 2
jmp short loc_1192
loc_1165:
mov [rbp+var_4], 3
jmp short loc_1184
loc_116E:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( (a1 & 1) == 0 )
return 2LL;
for ( i = 3; a1 >= i * i; i += 2 )
{
if ( !(a1 % i) )
return (unsigned int)i;
}
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101165
MOV EAX,0x2
JMP 0x00101192
LAB_00101165:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00101184
LAB_0010116e:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TES... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int local_c;
if ((param_1 & 1U) == 0) {
iVar1 = 2;
}
else {
for (local_c = 3;
(iVar1 = param_1, local_c * local_c <= param_1 && (iVar1 = local_c, param_1 % local_c != 0))
; local_c = local_c + 2) {
}
}
return iVar1;
} |
2,721 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i*i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x2,%ecx
test $0x1,%dil
je 1197 <_Z5func0i+0x4e>
cmp $0x8,%edi
jle 119a <_Z5func0i+0x51>
movslq %edi,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,2),%eax
cmp %eax,%edi
je 119e <_Z5func0i+0x55>
mov... | _Z5func0i:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1197
cmp edi, 8
jle short loc_119A
movsxd rax, edi
imul rax, 55555556h
shr rax, 20h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea eax, [rax+rax*2]
cmp edi, eax
jz short loc_119E
mov ecx, 3
loc_117E:
add ecx,... | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 <= 8 )
{
return (unsigned int)a1;
}
else if ( a1 == 3 * (a1 / 3) )
{
return 3;
}
else
{
v1 = 3;
while ( 1 )
{
v1 += 2;
if ( (int)(v1 * v1) > a1... | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101197
CMP EDI,0x8
JLE 0x0010119a
MOVSXD RAX,EDI
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EAX,[RAX + RAX*0x2]
CMP EDI,EAX
JZ 0x0010119e
MOV ECX,0x3
LAB_0010117e:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x00101195
MOV EAX,EDI... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
iVar1 = 2;
if (((param_1 & 1U) != 0) && (iVar1 = param_1, 8 < param_1)) {
if (param_1 == (param_1 / 3) * 3) {
iVar1 = 3;
}
else {
iVar1 = 3;
do {
iVar1 = iVar1 + 2;
if (param_1 < iVar1 * iVar1) {
retu... |
2,722 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i*i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O2 | cpp | func0(int) [clone .part.0]:
mov %edi,%r8d
cmp $0x8,%edi
jle 11ff <_Z5func0i.part.0+0x3f>
imul $0xaaaaaaab,%edi,%eax
add $0x2aaaaaaa,%eax
cmp $0x55555554,%eax
jbe 120f <_Z5func0i.part.0+0x4f>
mov $0x3,%ecx
jmp 11f2 <_Z5func0i.part.0+0x32>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
test ... | _Z5func0i:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1187
cmp edi, 8
jle short loc_1185
imul eax, edi, 0AAAAAAABh
mov ecx, 3
add eax, 2AAAAAAAh
cmp eax, 55555554h
ja short loc_1179
jmp short loc_1187
loc_1170:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short ... | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 > 8 )
{
v1 = 3;
if ( (unsigned int)(-1431655765 * a1 + 715827882) <= 0x55555554 )
return v1;
while ( 1 )
{
v1 += 2;
if ( a1 < (int)(v1 * v1) )
break;
... | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101187
CMP EDI,0x8
JLE 0x00101185
IMUL EAX,EDI,-0x55555555
MOV ECX,0x3
ADD EAX,0x2aaaaaaa
CMP EAX,0x55555554
JA 0x00101179
JMP 0x00101187
LAB_00101170:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101187
LAB_00101179:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EDI,EAX
JGE 0x... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
iVar1 = 2;
if ((((param_1 & 1U) != 0) && (iVar1 = param_1, 8 < param_1)) &&
(iVar1 = 3, 0x55555554 < param_1 * -0x55555555 + 0x2aaaaaaaU)) {
do {
iVar1 = iVar1 + 2;
if (param_1 < iVar1 * iVar1) {
return param_1;
}
} w... |
2,723 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i*i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov $0x2,%r8d
test $0x1,%dil
je 118c <_Z5func0i+0x4c>
cmp $0x8,%edi
jle 1189 <_Z5func0i+0x49>
imul $0xaaaaaaab,%edi,%eax
mov $0x3,%r8d
add $0x2aaaaaaa,%eax
cmp $0x55555554,%eax
ja 117a <_Z5func0i+0x3a>
jmp 118c <_Z5func0i+0x4c>
mov %edi,%eax
cltd
idiv %r8d
test ... | _Z5func0i:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1187
cmp edi, 8
jle short loc_1185
imul eax, edi, 0AAAAAAABh
mov ecx, 3
add eax, 2AAAAAAAh
cmp eax, 55555554h
ja short loc_1179
jmp short loc_1187
loc_1170:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short ... | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 > 8 )
{
v1 = 3;
if ( (unsigned int)(-1431655765 * a1 + 715827882) <= 0x55555554 )
return v1;
while ( 1 )
{
v1 += 2;
if ( a1 < (int)(v1 * v1) )
break;
... | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101187
CMP EDI,0x8
JLE 0x00101185
IMUL EAX,EDI,-0x55555555
MOV ECX,0x3
ADD EAX,0x2aaaaaaa
CMP EAX,0x55555554
JA 0x00101179
JMP 0x00101187
LAB_00101170:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101187
LAB_00101179:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EDI,EAX
JGE 0x... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
iVar1 = 2;
if ((((param_1 & 1U) != 0) && (iVar1 = param_1, 8 < param_1)) &&
(iVar1 = 3, 0x55555554 < param_1 * -0x55555555 + 0x2aaaaaaaU)) {
do {
iVar1 = iVar1 + 2;
if (param_1 < iVar1 * iVar1) {
return param_1;
}
} w... |
2,724 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for(size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] * nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({4, 10, 18}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({3, 8}));
assert(func0({90, 120}, {50, 70}) == std::vector<int>({4500, 8400}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp)... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std:... | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
unsigned long long v4; // rax
int v7; // [rsp+2Ch] [rbp-24h] BYREF
unsigned long long i; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = 0L... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c04
MOV qword ptr [RBP + -0x20],0x0
JM... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
int local_2c;
ulong local_28;
long local_20;
... |
2,725 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for(size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] * nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({4, 10, 18}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({3, 8}));
assert(func0({90, 120}, {50, 70}) == std::vector<int>({4500, 8400}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [r... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
int v7; // eax
int *v8; // rsi
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101314
... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28... |
2,726 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for(size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] * nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({4, 10, 18}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({3, 8}));
assert(func0({90, 120}, {50, 70}) == std::vector<int>({4500, 8400}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
c... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
int *v6; // rcx
int *v7; // rsi
long long v8; // rbx
int v9; // eax
int v11; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+4h] [rbp-30h]
v12 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QWO... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017a0
MOV R12,R... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_F... |
2,727 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for(size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] * nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({4, 10, 18}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({3, 8}));
assert(func0({90, 120}, {50, 70}) == std::vector<int>({4500, 8400}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rd... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
c... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
int *v6; // rcx
int *v7; // rsi
long long v8; // rbx
int v9; // eax
int v11; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+4h] [rbp-30h]
v12 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QWO... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017a0
MOV R12,R... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_F... |
2,728 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jl 11e0 <_Z5func0i+0x57>
movl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jl 11da <_Z5func0i+0x51>
mov -0x8(%rb... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
jmp short loc_1195
loc_115D:
mov [rbp+var_4], 1
jmp short loc_1186
loc_1166:
mov eax, [rbp+var_8]
imul eax, eax
mov edx, eax
mov eax, [rbp+var_4]
imul eax, eax
add eax, edx
cmp [rbp+var... | long long func0(int a1)
{
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
for ( i = 1; a1 >= i * i; ++i )
{
for ( j = 1; a1 >= j * j; ++j )
{
if ( a1 == i * i + j * j )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101195
LAB_0010115d:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101186
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
ADD EAX,EDX
CMP dword ptr [RBP +... | /* func0(int) */
int8 func0(int param_1)
{
int local_10;
int local_c;
local_10 = 1;
do {
if (param_1 < local_10 * local_10) {
return 0;
}
for (local_c = 1; local_c * local_c <= param_1; local_c = local_c + 1) {
if (param_1 == local_c * local_c + local_10 * local_10) {
return... |
2,729 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11d1 <_Z5func0i+0x48>
mov $0x1,%esi
mov $0x1,%ecx
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 11d7 <_Z5func0i+0x4e>
mov $0x1,%edx
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%eax
jg 11bf <_Z5func0i+0x36>
add %ecx,%eax
cmp %edi,%eax
jne ... | _Z5func0i:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_117F
loc_115B:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_1197
mov edx, 1
loc_1167:
add edx, 1
mov eax, edx
imul eax, edx
cmp eax, edi
jg short loc_1185
add eax, ecx
cmp eax, edi
jnz shor... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
... | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x0010117f
LAB_0010115b:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x00101197
MOV EDX,0x1
LAB_00101167:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JG 0x00101185
ADD EAX,ECX
CMP EAX,EDI
JNZ 0x00101167
MOV EAX,0x1
RET
LAB_0010117f:
MOV EAX,0x0
RET
LAB_00101185:
ADD E... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (param_1 < 1) {
return 0;
}
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
... |
2,730 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 134e <_Z5func0i+0x3e>
mov $0x1,%esi
mov $0x1,%ecx
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 1358 <_Z5func0i+0x48>
mov $0x1,%edx
jmp 1336 <_Z5func0i+0x26>
add %ecx,%eax
cmp %edi,%eax
je 1358 <_Z5func0i+0x48>
add $0x1,%edx
mov %edx,%eax
imul %e... | _Z5func0i:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_122E
loc_1202:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_1238
mov edx, 1
jmp short loc_1216
loc_1210:
add eax, ecx
cmp eax, edi
jz short loc_1238
loc_1216:
add edx, 1
mov eax, edx
imul eax, ... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
... | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x0010122e
LAB_00101202:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x00101238
MOV EDX,0x1
JMP 0x00101216
LAB_00101210:
ADD EAX,ECX
CMP EAX,EDI
JZ 0x00101238
LAB_00101216:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JLE 0x00101210
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (0 < param_1) {
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
... |
2,731 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 134e <_Z5func0i+0x3e>
mov $0x1,%esi
mov $0x1,%ecx
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 1358 <_Z5func0i+0x48>
mov $0x1,%edx
jmp 1336 <_Z5func0i+0x26>
add %ecx,%eax
cmp %edi,%eax
je 1358 <_Z5func0i+0x48>
add $0x1,%edx
mov %edx,%eax
imul %e... | _Z5func0i:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_12DE
loc_12B2:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_12E8
mov edx, 1
jmp short loc_12C6
loc_12C0:
add eax, ecx
cmp eax, edi
jz short loc_12E8
loc_12C6:
add edx, 1
mov eax, edx
imul eax, ... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
... | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x001012de
LAB_001012b2:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x001012e8
MOV EDX,0x1
JMP 0x001012c6
LAB_001012c0:
ADD EAX,ECX
CMP EAX,EDI
JZ 0x001012e8
LAB_001012c6:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JLE 0x001012c0
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (0 < param_1) {
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
... |
2,732 | func0 |
#include <iostream>
#include <cassert>
| int func0(std::string str, char x) {
int count = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == x) {
count++;
}
}
int n = 10;
int repetitions = n / len;
count *= repetitions;
int l = n % len;
for (int i = 0; i < l;... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,%eax
mov %al,-0x2c(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 22c0 <_ZNKSt7__cxx1112basic_stringI... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov eax, esi
mov [rbp+var_2C], al
mov [rbp+var_1C], 0
mov rax, [rbp+var_28]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6leng... | long long func0(long long a1, char a2)
{
int v3; // [rsp+14h] [rbp-1Ch]
unsigned int v4; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v7; // [rsp+20h] [rbp-10h]
v3 = 0;
v7 = std::string::length(a1);
for ( i = 0; i < v7; ++i )
{
if ( a2 == *(_BYTE *)std::... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x2c],AL
MOV dword ptr [RBP + -0x1c],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101210
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001013a7
LAB_0010137d:
MOV EAX,dwor... | /* func0(std::string, char) */
int func0(ulong param_1,char param_2)
{
int iVar1;
char *pcVar2;
int4 local_24;
int4 local_20;
int4 local_1c;
local_24 = 0;
iVar1 = std::string::length();
for (local_20 = 0; local_20 < iVar1; local_20 = local_20 + 1) {
pcVar2 = (char *)std::string::operator[](para... |
2,733 | func0 |
#include <iostream>
#include <cassert>
| int func0(std::string str, char x) {
int count = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == x) {
count++;
}
}
int n = 10;
int repetitions = n / len;
count *= repetitions;
int l = n % len;
for (int i = 0; i < l;... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char):
endbr64
mov 0x8(%rdi),%rdx
mov %edx,%r9d
test %edx,%edx
jle 128c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc+0x63>
mov (%rdi),%rax
lea -0x1(%rdx),%edx
lea 0x1(%rax,%rdx,1),%r8
mov $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
endbr64
mov r8, rdi
mov rdx, [rdi+8]
mov r9d, edx
test edx, edx
jle short loc_1273
mov rax, [rdi]
lea edx, [rdx-1]
lea rdi, [rax+rdx+1]
mov ecx, 0
loc_122B:
cmp [rax], sil
setz dl
movzx edx, dl
add ecx, edx
ad... | long long func0(_QWORD *a1, unsigned __int8 a2)
{
long long v3; // rdx
_BYTE *v4; // rax
long long v5; // rdi
int v6; // ecx
long long result; // rax
_BYTE *v8; // rcx
v3 = a1[1];
if ( (int)v3 <= 0 )
{
v6 = 0;
}
else
{
v4 = (_BYTE *)*a1;
v5 = *a1 + (unsigned int)(v3 - 1) + 1LL;
... | func0:
ENDBR64
MOV R8,RDI
MOV RDX,qword ptr [RDI + 0x8]
MOV R9D,EDX
TEST EDX,EDX
JLE 0x00101273
MOV RAX,qword ptr [RDI]
LEA EDX,[RDX + -0x1]
LEA RDI,[RAX + RDX*0x1 + 0x1]
MOV ECX,0x0
LAB_0010122b:
CMP byte ptr [RAX],SIL
SETZ DL
MOVZX EDX,DL
ADD ECX,EDX
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x0010122b
LAB_0010123f:
MOV EAX,0xa
MO... | /* func0(std::string, char) */
int func0(int8 *param_1,char param_2)
{
char *pcVar1;
int iVar2;
char *pcVar3;
int iVar4;
iVar4 = (int)param_1[1];
if (iVar4 < 1) {
iVar2 = 0;
}
else {
pcVar1 = (char *)*param_1;
pcVar3 = pcVar1 + (ulong)(iVar4 - 1) + 1;
iVar2 = 0;
do {
iVar2... |
2,734 | func0 |
#include <iostream>
#include <cassert>
| int func0(std::string str, char x) {
int count = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == x) {
count++;
}
}
int n = 10;
int repetitions = n / len;
count *= repetitions;
int l = n % len;
for (int i = 0; i < l;... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char):
endbr64
mov 0x8(%rdi),%r10
mov $0xa,%eax
cltd
idiv %r10d
mov %r10d,%r11d
test %r10d,%r10d
jle 1470 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc+0x90>
mov (%rdi),%r9
sub $0x1,%r10d
xor ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
endbr64
mov r9, rdi
mov eax, 0Ah
xor edx, edx
mov edi, esi
mov rcx, [r9+8]
idiv ecx
mov r10d, ecx
test ecx, ecx
jle short loc_13C0
mov rsi, [r9]
lea r8d, [rcx-1]
xor ecx, ecx
lea rdx, [rsi+1]
add r8, rdx... | long long func0(long long a1, unsigned __int8 a2)
{
long long v4; // rcx
int v5; // eax
int v6; // r10d
_BYTE *v7; // rsi
long long v8; // r8
int v9; // ecx
long long v10; // rdx
long long v11; // r8
unsigned int v12; // esi
_BYTE *v13; // rcx
int v14; // eax
v4 = *(_QWORD *)(a1 + 8);
v5 = 1... | func0:
ENDBR64
MOV R9,RDI
MOV EAX,0xa
XOR EDX,EDX
MOV EDI,ESI
MOV RCX,qword ptr [R9 + 0x8]
IDIV ECX
MOV R10D,ECX
TEST ECX,ECX
JLE 0x001013c0
MOV RSI,qword ptr [R9]
LEA R8D,[RCX + -0x1]
XOR ECX,ECX
LEA RDX,[RSI + 0x1]
ADD R8,RDX
JMP 0x00101374
LAB_00101370:
ADD RDX,0x1
LAB_00101374:
CMP DIL,byte ptr [RSI]
SETZ SIL
MOVZX... | /* func0(std::string, char) */
int func0(int8 *param_1,char param_2)
{
char cVar1;
int iVar2;
int iVar3;
char *pcVar4;
char *pcVar5;
char *pcVar6;
char *pcVar7;
iVar2 = (int)param_1[1];
if (iVar2 < 1) {
iVar3 = 0;
}
else {
iVar3 = 0;
pcVar4 = (char *)*param_1 + 1;
pcVar6 = pcV... |
2,735 | func0 |
#include <iostream>
#include <cassert>
| int func0(std::string str, char x) {
int count = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == x) {
count++;
}
}
int n = 10;
int repetitions = n / len;
count *= repetitions;
int l = n % len;
for (int i = 0; i < l;... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char):
endbr64
mov 0x8(%rdi),%r9
mov $0xa,%eax
cltd
idiv %r9d
mov %r9d,%r11d
test %r9d,%r9d
jle 1760 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc+0x380>
lea -0x1(%r9),%ecx
mov (%rdi),%rdx
cmp ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
endbr64
push rbp
mov eax, 0Ah
xor edx, edx
push rbx
mov r9, [rdi+8]
idiv r9d
mov r8d, r9d
test r9d, r9d
jle loc_1700
lea edx, [r9-1]
mov r10, [rdi]
cmp edx, 0Eh
jbe loc_1707
movd xmm4, esi
mov ecx, r9d
... | long long func0(const __m128i **a1, unsigned __int8 a2)
{
const __m128i *v2; // r9
const __m128i *v3; // r10
__m128i v4; // xmm4
__m128i v5; // xmm1
const __m128i *v6; // rdx
__m128i v7; // xmm4
__m128i v8; // xmm4
__m128i v9; // xmm0
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2... | func0:
ENDBR64
PUSH RBP
MOV EAX,0xa
XOR EDX,EDX
PUSH RBX
MOV R9,qword ptr [RDI + 0x8]
IDIV R9D
MOV R8D,R9D
TEST R9D,R9D
JLE 0x00101700
LEA EDX,[R9 + -0x1]
MOV R10,qword ptr [RDI]
CMP EDX,0xe
JBE 0x00101707
MOVD XMM4,ESI
MOV ECX,R9D
PXOR XMM1,XMM1
MOV RDX,R10
PUNPCKLBW XMM4,XMM4
SHR ECX,0x4
PXOR XMM6,XMM6
PXOR XMM5,XMM5... | /* func0(std::string, char) */
int func0(long *param_1,char param_2)
{
ulong uVar1;
char *pcVar2;
int8 *puVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
... |
2,736 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n) {
std::vector<bool> prime(n + 1, true);
int p = 2;
while (p * p <= n) {
if (prime[p]) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %edi,-0x74(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1700 <_ZNSaIbEC1Ev>
movb $0x1,-0x61(%rbp)
mov -0x74(%rbp),%eax
add $0x1,%eax
movslq %eax,%rsi
lea ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_74], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov [rbp+var_58], rax
nop
nop
mov [rbp+var_69], 1
mov eax, [rbp+var_74]
add eax, 1
movsxd rsi, eax
lea rcx,... | long long func0(int a1)
{
long long v1; // rdx
long long v2; // rdx
long long v3; // rdx
unsigned int v4; // ebx
char v6; // [rsp+17h] [rbp-69h] BYREF
int i; // [rsp+18h] [rbp-68h]
int j; // [rsp+1Ch] [rbp-64h]
unsigned int v9; // [rsp+20h] [rbp-60h]
int k; // [rsp+24h] [rbp-5Ch]
long long *v11; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV dword ptr [RBP + -0x74],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x58],RAX
NOP
NOP
MOV byte ptr [RBP + -0x69],0x1
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOVSXD RSI,EAX
LEA RC... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
bool bVar2;
long in_FS_OFFSET;
int auVar3 [16];
bool local_71;
int local_70;
int local_6c;
int local_68;
int local_64;
int *local_60;
int local_58 [16];
vector<bool,std::allocator<bool>> local_48 [40];
long local_20;
local_20 = *(long... |
2,737 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n) {
std::vector<bool> prime(n + 1, true);
int p = 2;
while (p * p <= n) {
if (prime[p]) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r12
push %rbp
push %rbx
lea 0x1(%rdi),%eax
cltq
mov $0x0,%ebx
mov $0x0,%r12d
test %rax,%rax
je 1241 <_Z5func0i+0x98>
mov %edi,%ebp
add $0x3f,%rax
shr $0x6,%rax
lea 0x0(,%rax,8),%r12
mov %r12,%rdi
callq 10b0 <_Znwm@plt>
mov %rax,%rbx
mov %r12,%rdx
mov ... | _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebp, edi
lea eax, [rdi+1]
cdqe
mov r12d, 0
mov ebx, 0
test rax, rax
jnz short loc_11FC
loc_11CE:
cmp ebp, 1
jg loc_12FA
mov ebp, 0
loc_11DC:
test rbx, rbx
jz short loc_11EF
mov rsi, r12
... | long long func0(int a1)
{
char *v2; // r12
char *v3; // rbx
unsigned int v4; // ebp
unsigned long long v6; // r13
int v7; // r10d
long long v8; // rdi
int v9; // r8d
char *v10; // rsi
long long v11; // rcx
int i; // esi
long long v13; // rdx
char *v14; // rdx
signed long long v15; // rax
ch... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDI
LEA EAX,[RDI + 0x1]
CDQE
MOV R12D,0x0
MOV EBX,0x0
TEST RAX,RAX
JNZ 0x001011fc
LAB_001011ce:
CMP EBP,0x1
JG 0x001012fa
MOV EBP,0x0
LAB_001011dc:
TEST RBX,RBX
JZ 0x001011ef
MOV RSI,R12
SUB RSI,RBX
MOV RDI,RBX
CALL 0x001010b0
LAB_001011ef:
MOV EAX,... | /* func0(int) */
int func0(int param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
byte bVar4;
ulong *puVar5;
ulong uVar6;
void *__s;
int iVar7;
long lVar8;
int iVar9;
void *pvVar10;
pvVar10 = (void *)0x0;
__s = (void *)0x0;
if ((long)(param_1 + 1) == 0) {
LAB_001011ce:
if (param_1 < 2)... |
2,738 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n) {
std::vector<bool> prime(n + 1, true);
int p = 2;
while (p * p <= n) {
if (prime[p]) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
return 0;
}
| O2 | cpp | func0(int):
endbr64
lea 0x1(%rdi),%eax
push %r13
cltq
push %r12
xor %r12d,%r12d
push %rbx
test %rax,%rax
jne 1270 <_Z5func0i+0x20>
mov %r12d,%eax
pop %rbx
pop %r12
pop %r13
retq
add $0x3f,%rax
mov %edi,%ebx
shr $0x6,%rax
lea 0x0(,%rax,8),%r13
mov %r13,%rdi
callq 10b0 <_Znwm@... | _Z5func0i:
endbr64
push r13
lea eax, [rdi+1]
xor r13d, r13d
push r12
cdqe
push rbp
push rbx
sub rsp, 8
test rax, rax
jnz short loc_1280
add rsp, 8
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1280:
add rax, 3Fh ; '?'
mov ebp, edi
mov r12d, 4
s... | long long func0(int a1)
{
unsigned int v1; // r13d
int v4; // r12d
unsigned long long v5; // rbx
void *v6; // rax
_QWORD *v7; // rax
long long v8; // r8
_QWORD *v9; // r9
int v10; // edi
int i; // edx
long long v12; // rcx
_QWORD *v13; // rsi
signed long long v14; // rax
char v15; // cl
lon... | func0:
ENDBR64
PUSH R13
LEA EAX,[RDI + 0x1]
XOR R13D,R13D
PUSH R12
CDQE
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST RAX,RAX
JNZ 0x00101280
ADD RSP,0x8
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101280:
ADD RAX,0x3f
MOV EBP,EDI
MOV R12D,0x4
SHR RAX,0x6
LEA RBX,[RAX*0x8]
MOV RDI,RBX
CALL 0x001010a0
MOV RDX,RBX
MOV ESI... | /* func0(int) */
int func0(int param_1)
{
ulong __n;
void *pvVar1;
long lVar2;
long lVar3;
byte bVar4;
ulong *puVar5;
int iVar6;
long lVar7;
int iVar8;
iVar6 = 0;
if ((long)(param_1 + 1) == 0) {
return 0;
}
iVar8 = 4;
__n = ((long)(param_1 + 1) + 0x3fU >> 6) * 8;
pvVar1 = operator... |
2,739 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n) {
std::vector<bool> prime(n + 1, true);
int p = 2;
while (p * p <= n) {
if (prime[p]) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
return 0;
}
| O3 | cpp | func0(int):
endbr64
lea 0x1(%rdi),%eax
push %r13
cltq
push %r12
xor %r12d,%r12d
push %rbx
test %rax,%rax
jne 1270 <_Z5func0i+0x20>
mov %r12d,%eax
pop %rbx
pop %r12
pop %r13
retq
add $0x3f,%rax
mov %edi,%ebx
shr $0x6,%rax
lea 0x0(,%rax,8),%r13
mov %r13,%rdi
callq 10b0 <_Znwm@... | _Z5func0i:
endbr64
lea eax, [rdi+1]
push r12
xor r12d, r12d
cdqe
push rbp
push rbx
test rax, rax
jnz short loc_1270
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1270:
add rax, 3Fh ; '?'
mov ebp, edi
shr rax, 6
lea rbx, ds:0[rax*8]
mov rdi, rbx; unsigned __in... | long long func0(int a1)
{
unsigned int v1; // r12d
unsigned long long v4; // rbx
void *v5; // rax
_QWORD *v6; // rax
int v7; // r11d
long long v8; // rdi
_QWORD *v9; // r8
int v10; // edx
int i; // eax
long long v12; // rsi
_QWORD *v13; // rsi
signed long long v14; // rcx
long long v15; // ra... | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PUSH R12
XOR R12D,R12D
CDQE
PUSH RBP
PUSH RBX
TEST RAX,RAX
JNZ 0x00101270
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101270:
ADD RAX,0x3f
MOV EBP,EDI
SHR RAX,0x6
LEA RBX,[RAX*0x8]
MOV RDI,RBX
CALL 0x001010a0
MOV RDX,RBX
MOV ESI,0xffffffff
MOV RDI,RAX
CALL 0x00101080
MOV R11D,0x4
M... | /* func0(int) */
int func0(int param_1)
{
ulong *puVar1;
ulong __n;
int iVar2;
void *pvVar3;
byte bVar4;
long lVar5;
long lVar6;
int iVar7;
long lVar8;
int iVar9;
iVar2 = 0;
if ((long)(param_1 + 1) == 0) {
return 0;
}
__n = ((long)(param_1 + 1) + 0x3fU >> 6) * 8;
pvVar3 = operator... |
2,740 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| string func0(const vector<int>& test_tup) {
unordered_map<int, int> counts;
vector<int> order;
for(auto ele : test_tup){
if(counts.find(ele) == counts.end()){
order.push_back(ele);
}
counts[ele]++;
}
string s = "{";
for(int i =0;i < order.size(); ++i... | int main(){
assert(func0(vector<int>{4, 5, 4, 5, 6, 6, 5, 5, 4}) == "{4: 3, 5: 4, 6: 2}");
assert(func0(vector<int>{7, 8, 8, 9, 4, 7, 6, 5, 4}) == "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}");
assert(func0(vector<int>{1, 4, 3, 1, 4, 5, 2, 6, 2, 7}) == "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}");
}
| O0 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x138,%rsp
mov %rdi,-0x138(%rbp)
mov %rsi,-0x140(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0xe0(%rbp),%rax
mov %rax,%rdi
callq 3140 <_ZNSt13unordered_mapI... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 148h
mov [rbp+var_148], rdi
mov [rbp+var_150], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_E0]
mov rdi, rax
call _ZNSt13unordered_mapIiiSt4hashIiESt8equal_toIiESa... | long long func0[abi:cxx11](long long a1, long long a2)
{
_DWORD *v2; // rax
long long v3; // rax
int *v4; // rax
int *v5; // rax
unsigned long long v6; // rbx
int v8; // [rsp+18h] [rbp-138h] BYREF
int i; // [rsp+1Ch] [rbp-134h]
long long v10; // [rsp+20h] [rbp-130h] BYREF
long long v11; // [rsp+28h] ... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x148
MOV qword ptr [RBP + -0x148],RDI
MOV qword ptr [RBP + -0x150],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xe0]
MOV RDI,RAX
CALL 0x001032d8
LEA RAX,[RBP + -0x100]
MOV RDI,RAX
CALL 0x00103360
MOV RAX,qwo... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
char cVar1;
bool bVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
int local_140;
int local_13c;
int8 local_138;
int8 local_1... |
2,741 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| string func0(const vector<int>& test_tup) {
unordered_map<int, int> counts;
vector<int> order;
for(auto ele : test_tup){
if(counts.find(ele) == counts.end()){
order.push_back(ele);
}
counts[ele]++;
}
string s = "{";
for(int i =0;i < order.size(); ++i... | int main(){
assert(func0(vector<int>{4, 5, 4, 5, 6, 6, 5, 5, 4}) == "{4: 3, 5: 4, 6: 2}");
assert(func0(vector<int>{7, 8, 8, 9, 4, 7, 6, 5, 4}) == "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}");
assert(func0(vector<int>{1, 4, 3, 1, 4, 5, 2, 6, 2, 7}) == "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}");
}
| O1 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x100,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0xf8(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%rax
mov %rax,0x30(%rsp)
movq $0x1,0x38(%rsp)
movq $0x0,0x40(%rsp... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 128h
mov r14, rdi
mov rax, fs:28h
mov [rsp+158h+var_40], rax
xor eax, eax
lea rax, [rsp+158h+var_D8]
mov [rsp+158h+var_108], rax
mov [rsp+158h+var_100], 1
mov ... | long long func0[abi:cxx11](long long a1, int **a2)
{
int *v3; // rbx
int *v4; // r12
_QWORD *v5; // rax
_DWORD *v6; // rax
int v7; // r13d
long long *v8; // rax
char *v9; // rsi
unsigned long long v10; // r15
int v11; // eax
unsigned int v12; // r13d
unsigned int v13; // r12d
unsigned int v14; ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],0x1
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
ulong *puVar1;
int8 *puVar2;
int *piVar3;
uint *puVar4;
long *plVar5;
long *plVar6;
int8 uVar7;
uint uVar8;
long *plVar9;
uint uVar10;
long lVar11;
ulong uVar12;
ulong *puVar13;... |
2,742 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| string func0(const vector<int>& test_tup) {
unordered_map<int, int> counts;
vector<int> order;
for(auto ele : test_tup){
if(counts.find(ele) == counts.end()){
order.push_back(ele);
}
counts[ele]++;
}
string s = "{";
for(int i =0;i < order.size(); ++i... | int main(){
assert(func0(vector<int>{4, 5, 4, 5, 6, 6, 5, 5, 4}) == "{4: 3, 5: 4, 6: 2}");
assert(func0(vector<int>{7, 8, 8, 9, 4, 7, 6, 5, 4}) == "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}");
assert(func0(vector<int>{1, 4, 3, 1, 4, 5, 2, 6, 2, 7}) == "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}");
}
| O2 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
mov %rsi,%rax
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x118,%rsp
mov 0x8(%rax),%rbp
mov %fs:0x28,%rbx
mov %rbx,0x108(%rsp)
xor %ebx,%ebx
mov (%rax),%rbx
lea 0x70(%rsp),%... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 218h
mov rbp, [rsi]
mov r12, [rsi+8]
mov rax, fs:28h
mov [rsp+248h+var_40], rax
xor eax, eax
lea rax, [rsp+248h+var_1A8]
movaps [r... | long long func0[abi:cxx11](long long a1, int **a2)
{
int *v3; // rbp
int *v4; // r12
int v5; // ecx
long long *i; // rax
_DWORD *v7; // rax
long long **v8; // r10
long long *v9; // rax
int v10; // esi
long long v11; // rsi
_BYTE *v12; // rax
_BYTE *v13; // rdi
unsigned int *v14; // r12
int v1... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x218
MOV RBP,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x208],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xa0]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV qword ptr [... | /* WARNING: Type propagation algorithm not settling */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
int *piVar1;
long *plVar2;
long *plVar3;
int8 *puVar4;
... |
2,743 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| string func0(const vector<int>& test_tup) {
unordered_map<int, int> counts;
vector<int> order;
for(auto ele : test_tup){
if(counts.find(ele) == counts.end()){
order.push_back(ele);
}
counts[ele]++;
}
string s = "{";
for(int i =0;i < order.size(); ++i... | int main(){
assert(func0(vector<int>{4, 5, 4, 5, 6, 6, 5, 5, 4}) == "{4: 3, 5: 4, 6: 2}");
assert(func0(vector<int>{7, 8, 8, 9, 4, 7, 6, 5, 4}) == "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}");
assert(func0(vector<int>{1, 4, 3, 1, 4, 5, 2, 6, 2, 7}) == "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}");
}
| O3 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x118,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
lea 0x70(%rsp)... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 218h
mov rbp, [rsi]
mov r12, [rsi+8]
mov rax, fs:28h
mov [rsp+248h+var_40], rax
xor eax, eax
lea rax, [rsp+248h+var_1A8]
movaps [r... | long long func0[abi:cxx11](long long a1, int **a2)
{
int *v3; // rbp
int *v4; // r12
int v5; // ecx
_DWORD *v6; // rax
_DWORD *v7; // rax
long long **v8; // r10
long long *v9; // rax
int v10; // esi
long long v11; // rsi
_BYTE *v12; // rax
_BYTE *v13; // rdi
unsigned int *v14; // r12
int v15;... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x218
MOV RBP,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x208],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xa0]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV qword ptr [... | /* WARNING: Type propagation algorithm not settling */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
uint uVar1;
long ******pppppplVar2;
int *piVar3;
long *... |
2,744 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int a, int b) {
int low = std::min(a, b);
int high = std::max(a, b);
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
lea -0x18(%rbp),%rdx
lea -0x14(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1307 <_ZSt3minIiERKT_S2_S2_>
mov (%rax),%eax
mov %eax,-0x8(%rbp)
lea -0x18(%rbp),%rdx
lea -0x14(%rb... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
lea rdx, [rbp+var_18]
lea rax, [rbp+var_14]
mov rsi, rdx
mov rdi, rax
call _ZSt3minIiERKT_S2_S2_; std::min<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_8], eax
lea ... | long long func0(int a1, int a2)
{
int v3; // [rsp+8h] [rbp-18h] BYREF
_DWORD v4[3]; // [rsp+Ch] [rbp-14h] BYREF
int v5; // [rsp+18h] [rbp-8h]
unsigned int v6; // [rsp+1Ch] [rbp-4h]
v4[0] = a1;
v3 = a2;
v5 = *(_DWORD *)std::min<int>(v4, &v3);
v6 = *(_DWORD *)std::max<int>(v4, &v3);
if ( !v5 )
ret... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x14]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010127c
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x14]
MOV RSI,RDX
MOV RDI,RAX
... | /* func0(int, int) */
ulong func0(int param_1,int param_2)
{
int *piVar1;
uint *puVar2;
ulong uVar3;
int local_20;
int local_1c [3];
int local_10;
uint local_c;
local_20 = param_2;
local_1c[0] = param_1;
piVar1 = std::min<int>(local_1c,&local_20);
local_10 = *piVar1;
puVar2 = (uint *)std::m... |
2,745 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int a, int b) {
int low = std::min(a, b);
int high = std::max(a, b);
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovle %edi,%ecx
mov %esi,%eax
cmovge %edi,%eax
test %ecx,%ecx
je 11ba <_Z5func0ii+0x31>
cmp $0x1,%ecx
je 11b7 <_Z5func0ii+0x2e>
sub $0x8,%rsp
cltd
idiv %ecx
mov %edx,%esi
mov %ecx,%edi
callq 1189 <_Z5func0ii>
add $0x8,%rsp
retq
m... | _Z5func0ii:
endbr64
cmp edi, esi
mov ecx, esi
cmovle ecx, edi
mov eax, esi
cmovge eax, edi
test ecx, ecx
jz short locret_117A
cmp ecx, 1
jz short loc_1177
sub rsp, 8
cdq
idiv ecx
mov esi, edx; int
mov edi, ecx; int
call _Z5func0ii; func0(int,int)
add rsp, 8
retn
loc_... | long long func0(int a1, int a2)
{
int v2; // ecx
long long result; // rax
v2 = a2;
if ( a1 <= a2 )
v2 = a1;
result = (unsigned int)a2;
if ( a1 >= a2 )
result = (unsigned int)a1;
if ( v2 )
{
if ( v2 == 1 )
return 1LL;
else
return func0(v2, (int)result % v2);
}
return res... | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVLE ECX,EDI
MOV EAX,ESI
CMOVGE EAX,EDI
TEST ECX,ECX
JZ 0x0010117a
CMP ECX,0x1
JZ 0x00101177
SUB RSP,0x8
CDQ
IDIV ECX
MOV ESI,EDX
MOV EDI,ECX
CALL 0x00101149
ADD RSP,0x8
RET
LAB_00101177:
MOV EAX,ECX
RET
LAB_0010117a:
RET | /* func0(int, int) */
ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
iVar2 = param_2;
if (param_1 <= param_2) {
iVar2 = param_1;
}
uVar1 = (ulong)(uint)param_2;
if (param_2 <= param_1) {
uVar1 = (ulong)(uint)param_1;
}
if (iVar2 != 0) {
if (iVar2 != 1) {
uVar1 = ... |
2,746 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int a, int b) {
int low = std::min(a, b);
int high = std::max(a, b);
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
mov %esi,%r8d
cmp %edi,%r8d
jge 1294 <_Z5func0ii+0x14>
mov %r8d,%eax
mov %edi,%r8d
mov %eax,%edi
test %edi,%edi
je 12af <_Z5func0ii+0x2f>
cmp $0x1,%edi
je 12b8 <_Z5func0ii+0x38>
mov %r8d,%eax
cltd
idiv %edi
mov %edx,%r8d
cmp %edi,%r8d
jl 128c <_Z5fu... | _Z5func0ii:
endbr64
loc_1204:
mov edx, edi
cmp edi, esi
jg short loc_120F
cmovl edx, esi
mov esi, edi
loc_120F:
test esi, esi
jz short loc_1245
cmp esi, 1
jz short loc_1240
mov eax, edx
cdq
idiv esi
cmp edx, esi
jl short loc_1268
mov eax, edx
cmovl eax, esi
loc_... | long long func0(int a1, int a2)
{
unsigned int v2; // edx
signed int v3; // eax
int v4; // eax
while ( 1 )
{
v2 = a1;
if ( a1 <= a2 )
{
if ( a1 < a2 )
v2 = a2;
a2 = a1;
}
if ( !a2 )
break;
if ( a2 == 1 )
return 1;
v2 = (int)v2 % a2;
if ( (int)v... | func0:
ENDBR64
LAB_00101204:
MOV EDX,EDI
CMP EDI,ESI
JG 0x0010120f
CMOVL EDX,ESI
MOV ESI,EDI
LAB_0010120f:
TEST ESI,ESI
JZ 0x00101245
CMP ESI,0x1
JZ 0x00101240
MOV EAX,EDX
CDQ
IDIV ESI
CMP EDX,ESI
JL 0x00101268
MOV EAX,EDX
CMOVL EAX,ESI
LAB_00101226:
CDQ
IDIV ESI
CMP EDX,ESI
JL 0x00101250
MOV EAX,EDX
CMOVL EAX,ESI
LAB_... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
do {
iVar1 = param_1;
iVar3 = param_2;
if ((param_1 <= param_2) && (iVar3 = param_1, param_1 < param_2)) {
iVar1 = param_2;
}
if (iVar3 == 0) {
return iVar1;
}
if... |
2,747 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int a, int b) {
int low = std::min(a, b);
int high = std::max(a, b);
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
mov %esi,%r8d
cmp %edi,%r8d
jge 1294 <_Z5func0ii+0x14>
mov %r8d,%eax
mov %edi,%r8d
mov %eax,%edi
test %edi,%edi
je 12af <_Z5func0ii+0x2f>
cmp $0x1,%edi
je 12b8 <_Z5func0ii+0x38>
mov %r8d,%eax
cltd
idiv %edi
mov %edx,%r8d
cmp %edi,%r8d
jl 128c <_Z5fu... | _Z5func0ii:
endbr64
loc_1204:
mov edx, edi
cmp edi, esi
jg short loc_120F
cmovl edx, esi
mov esi, edi
loc_120F:
test esi, esi
jz short loc_1245
cmp esi, 1
jz short loc_1240
mov eax, edx
cdq
idiv esi
cmp edx, esi
jl short loc_1268
mov eax, edx
cmovl eax, esi
loc_... | long long func0(int a1, int a2)
{
unsigned int v2; // edx
signed int v3; // eax
int v4; // eax
while ( 1 )
{
v2 = a1;
if ( a1 <= a2 )
{
if ( a1 < a2 )
v2 = a2;
a2 = a1;
}
if ( !a2 )
break;
if ( a2 == 1 )
return 1;
v2 = (int)v2 % a2;
if ( (int)v... | func0:
ENDBR64
LAB_00101204:
MOV EDX,EDI
CMP EDI,ESI
JG 0x0010120f
CMOVL EDX,ESI
MOV ESI,EDI
LAB_0010120f:
TEST ESI,ESI
JZ 0x00101245
CMP ESI,0x1
JZ 0x00101240
MOV EAX,EDX
CDQ
IDIV ESI
CMP EDX,ESI
JL 0x00101268
MOV EAX,EDX
CMOVL EAX,ESI
LAB_00101226:
CDQ
IDIV ESI
CMP EDX,ESI
JL 0x00101250
MOV EAX,EDX
CMOVL EAX,ESI
LAB_... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
do {
iVar1 = param_1;
iVar3 = param_2;
if ((param_1 <= param_2) && (iVar3 = param_1, param_1 < param_2)) {
iVar1 = param_2;
}
if (iVar3 == 0) {
return iVar1;
}
if... |
2,748 | func0 |
#include <complex>
#include <assert.h>
// Function to calculate the length of a complex number
| double func0(double a, double b) {
std::complex<double> cn(a, b);
double length = std::abs(cn);
return length;
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(func0(9, 10) == 13.45362404707371);
assert(func0(7, 9) == 11.40175425099138);
return 0;
}
| O0 | cpp | func0(double, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
movsd %xmm0,-0x38(%rbp)
movsd %xmm1,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movsd -0x40(%rbp),%xmm0
mov -0x38(%rbp),%rdx
lea -0x20(%rbp),%rax
movapd %xmm0,%xmm1
movq %rdx,%xmm0
mov %rax,%rdi
call... | _Z5func0dd:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
movsd [rbp+var_38], xmm0
movsd [rbp+var_40], xmm1
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsd xmm0, [rbp+var_40]
mov rdx, [rbp+var_38]
lea rax, [rbp+var_20]
movapd xmm1, xmm0
movq xmm0, rdx
mov rdi, rax
call ... | unsigned long long func0(double a1, double a2)
{
_BYTE v3[24]; // [rsp+20h] [rbp-20h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-8h]
v4 = __readfsqword(0x28u);
std::complex<double>::complex(v3, a1, a2);
std::abs<double>(v3);
return v4 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOVSD qword ptr [RBP + -0x38],XMM0
MOVSD qword ptr [RBP + -0x40],XMM1
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSD XMM0,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
LEA RAX,[RBP + -0x20]
MOVAPD XMM1,XMM0
MOVQ XMM0,RDX
MOV RDI,RA... | /* func0(double, double) */
double func0(double param_1,double param_2)
{
long in_FS_OFFSET;
double dVar1;
complex<double> local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
std::complex<double>::complex(local_28,param_1,param_2);
dVar1 = std::abs<double>((complex *)local_28);
... |
2,749 | func0 |
#include <complex>
#include <assert.h>
// Function to calculate the length of a complex number
| double func0(double a, double b) {
std::complex<double> cn(a, b);
double length = std::abs(cn);
return length;
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(func0(9, 10) == 13.45362404707371);
assert(func0(7, 9) == 11.40175425099138);
return 0;
}
| O1 | cpp | func0(double, double):
endbr64
sub $0x8,%rsp
callq 1070 <cabs@plt>
add $0x8,%rsp
retq
| _Z5func0dd:
endbr64
sub rsp, 8
call _cabs
add rsp, 8
retn | long long func0(double a1, double a2)
{
return cabs(a1, a2);
} | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101070
ADD RSP,0x8
RET | /* func0(double, double) */
void func0(double param_1,double param_2)
{
cabs(param_1);
return;
} |
2,750 | func0 |
#include <complex>
#include <assert.h>
// Function to calculate the length of a complex number
| double func0(double a, double b) {
std::complex<double> cn(a, b);
double length = std::abs(cn);
return length;
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(func0(9, 10) == 13.45362404707371);
assert(func0(7, 9) == 11.40175425099138);
return 0;
}
| O2 | cpp | func0(double, double):
endbr64
jmpq 1050 <cabs@plt>
nopl 0x0(%rax)
| _Z5func0dd:
endbr64
jmp _cabs | long long func0(double a1, double a2)
{
return cabs(a1, a2);
} | func0:
ENDBR64
JMP 0x00101050 | /* func0(double, double) */
void func0(double param_1,double param_2)
{
cabs(param_1);
return;
} |
2,751 | func0 |
#include <complex>
#include <assert.h>
// Function to calculate the length of a complex number
| double func0(double a, double b) {
std::complex<double> cn(a, b);
double length = std::abs(cn);
return length;
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(func0(9, 10) == 13.45362404707371);
assert(func0(7, 9) == 11.40175425099138);
return 0;
}
| O3 | cpp | func0(double, double):
endbr64
jmpq 1050 <cabs@plt>
nopl 0x0(%rax)
| _Z5func0dd:
endbr64
jmp _cabs | long long func0(double a1, double a2)
{
return cabs(a1, a2);
} | func0:
ENDBR64
JMP 0x00101050 | /* func0(double, double) */
void func0(double param_1,double param_2)
{
cabs(param_1);
return;
} |
2,752 | func0 |
#include <iostream>
#include <vector>
#include <climits>
#include <assert.h>
| int func0(const std::vector<int>& arr, int n) {
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
std::vector<int> jumps(n, INT_MAX);
jumps[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
... | int main() {
assert(func0({1, 3, 6, 1, 0, 9}, 6) == 3);
assert(func0({1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}, 11) == 3);
assert(func0({1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, 11) == 10);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
cmpl $0x0,-0x4c(%rbp)
je 12a9 <_Z5func0RKSt6vectorIiSaIiEEi+0x40>
mov -0x48... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
cmp [rbp+var_5C], 0
jz short loc_1289
mov rax, [rbp+var_58]
mov esi, 0
mov rdi, rax
call... | long long func0(long long a1, int a2)
{
unsigned int v3; // ebx
_DWORD *v4; // rax
long long v6; // rax
int v7; // ebx
char v9; // [rsp+1Bh] [rbp-45h] BYREF
int v10; // [rsp+1Ch] [rbp-44h] BYREF
int i; // [rsp+20h] [rbp-40h]
int j; // [rsp+24h] [rbp-3Ch]
char *v13; // [rsp+28h] [rbp-38h]
_BYTE v14[... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x00101289
MOV RAX,qword ptr [RBP + -0x58]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101852
MOV EAX,... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int4 func0(vector *param_1,int param_2)
{
int iVar1;
bool bVar2;
int *piVar3;
int4 *puVar4;
int4 uVar5;
long in_FS_OFFSET;
allocator local_4d;
int local_4c;
int local_48;
int local_44;
allocator *local_40;
vector<int,std::allocato... |
2,753 | func0 |
#include <iostream>
#include <vector>
#include <climits>
#include <assert.h>
| int func0(const std::vector<int>& arr, int n) {
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
std::vector<int> jumps(n, INT_MAX);
jumps[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
... | int main() {
assert(func0({1, 3, 6, 1, 0, 9}, 6) == 3);
assert(func0({1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}, 11) == 3);
assert(func0({1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, 11) == 10);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
je 1355 <_Z5func0RKSt6vectorIiSaIiEEi+0x10c>
mov %rdi,%rbx
mov %esi,%r12d
mov (%rdi),%rax
cmpl $0x0,(%rax)
... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
test esi, esi
jz loc_132B
mov rbx, rdi
mov r12d, esi
mov rax, [rdi]
cmp dword ptr [rax], 0
jz loc_1332
movsxd rbp, esi
mov rax, ... | long long func0(_QWORD *a1, int a2)
{
unsigned long long v2; // rbp
int *v3; // rax
int *v4; // r8
int *v5; // rdx
int *v6; // r9
long long i; // rcx
long long v8; // rax
int v9; // edx
int *v10; // rax
unsigned int v11; // ebx
int v13; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v14; // [rs... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JZ 0x0010132b
MOV RBX,RDI
MOV R12D,ESI
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX],0x0
JZ 0x00101332
MOVSXD RBP,ESI
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x0010128c
SHL RBP,0x2
MOV RDI,RBP
CA... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int4 func0(vector *param_1,int param_2)
{
int4 *puVar1;
int4 *puVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
int4 uVar6;
ulong uVar7;
int *piVar8;
long in_FS_OFFSET;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSE... |
2,754 | func0 |
#include <iostream>
#include <vector>
#include <climits>
#include <assert.h>
| int func0(const std::vector<int>& arr, int n) {
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
std::vector<int> jumps(n, INT_MAX);
jumps[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
... | int main() {
assert(func0({1, 3, 6, 1, 0, 9}, 6) == 3);
assert(func0({1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}, 11) == 3);
assert(func0({1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, 11) == 10);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int) [clone .part.0]:
movabs $0x1fffffffffffffff,%rax
push %r12
push %rbp
push %rbx
movslq %esi,%rbx
cmp %rax,%rbx
ja 15cb <_Z5func0RKSt6vectorIiSaIiEEi.part.0+0xcb>
mov %rbx,%rbp
shl $0x2,%rbx
mov %rdi,%r12
mov %rbx,%rdi
callq 1120 <_Znwm@p... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r12
push rbp
push rbx
test esi, esi
jz loc_1510
mov rax, [rdi]
mov r12, rdi
mov eax, [rax]
test eax, eax
jz loc_1510
movsxd rbp, esi
mov ebx, esi
mov rax, rbp
shr rax, 3Dh
jnz loc_151C
shl rbp, 2
mov rdi, rbp; unsig... | long long func0(_DWORD **a1, int a2)
{
unsigned long long v2; // rbp
_DWORD *v3; // rax
_DWORD *v4; // r8
_DWORD *v5; // rdx
_DWORD *v6; // rdi
long long v7; // rdx
long long v8; // rax
int v9; // ecx
unsigned int v10; // ebx
int v12; // eax
if ( !a2 || !**a1 )
return 0x7FFFFFFFLL;
if ( (u... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JZ 0x00101510
MOV RAX,qword ptr [RDI]
MOV R12,RDI
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x00101510
MOVSXD RBP,ESI
MOV EBX,ESI
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x0010151c
SHL RBP,0x2
MOV RDI,RBP
CALL 0x001010e0
MOV R8,RAX
LEA RDX,[RAX + RBP*0x1]
TEST BPL,0x4
JZ 0x0010... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
void * func0(vector *param_1,int param_2)
{
uint uVar1;
long lVar2;
void *pvVar3;
int iVar4;
int4 *puVar5;
int4 *puVar6;
int4 *puVar7;
ulong uVar8;
void *extraout_RAX;
ulong uVar9;
ulong uVar10;
ulong uVar11;
char *pcVar12;
... |
2,755 | func0 |
#include <iostream>
#include <vector>
#include <climits>
#include <assert.h>
| int func0(const std::vector<int>& arr, int n) {
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
std::vector<int> jumps(n, INT_MAX);
jumps[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
... | int main() {
assert(func0({1, 3, 6, 1, 0, 9}, 6) == 3);
assert(func0({1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}, 11) == 3);
assert(func0({1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, 11) == 10);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int) [clone .part.0]:
movabs $0x1fffffffffffffff,%rax
push %r13
push %r12
movslq %esi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
cmp %rax,%r12
ja 1603 <_Z5func0RKSt6vectorIiSaIiEEi.part.0+0x143>
lea 0x0(,%r12,4),%rbx
mov %rdi,%rbp
mov %r12,%r13... | _Z5func0RKSt6vectorIiSaIiEEi_part_0:
push r12
push rbp
movsxd rbp, esi
mov rax, rbp
push rbx
shr rax, 3Dh
jnz loc_1561
mov rbx, rbp
shl rbp, 2
mov r12, rdi
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
lea r8, [rax+rbp]
lea rax,... | long long func0(long long *a1, int a2)
{
unsigned long long v3; // rbp
__m128i *v5; // rax
__m128i *v6; // rdi
char *v7; // r8
unsigned long long v8; // rdx
__m128i si128; // xmm0
long long v10; // rcx
__m128i *v11; // rsi
long long v12; // rsi
long long v13; // rdx
long long v14; // rax
__int3... | func0:
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
MOV RAX,RBP
PUSH RBX
SHR RAX,0x3d
JNZ 0x00101561
MOV RBX,RBP
SHL RBP,0x2
MOV R12,RDI
MOV RDI,RBP
CALL 0x001010e0
MOV RDI,RAX
LEA R8,[RAX + RBP*0x1]
LEA RAX,[RBP + -0x4]
MOV RDX,RAX
SHR RDX,0x2
ADD RDX,0x1
CMP RAX,0x8
MOV RAX,RDI
JBE 0x001014c0
MOV RCX,RDX
MOVDQA XMM0,xmmword ptr ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) [clone .part.0] */
ulong func0(vector *param_1,int param_2)
{
uint uVar1;
int iVar2;
long lVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int8 *puVar7;
int8 *puVa... |
2,756 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> result;
for (size_t i = 0; i < nums.size() - 1; ++i) {
result.push_back(nums[i] * nums[i + 1]);
}
return result;
}
| int main() {
assert(func0({1, 1, 3, 4, 4, 5, 6, 7}) == std::vector<int>({1, 3, 12, 16, 20, 30, 42}));
assert(func0({4, 5, 8, 9, 6, 10}) == std::vector<int>({20, 40, 72, 54, 60}));
assert(func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>({2, 6, 12, 20, 30, 42, 56, 72, 90}));
return 0;
... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1a78 <_ZNSt6vectorIiSaIiEEC1Ev>
movq $0... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mo... | long long func0(long long a1, long long a2)
{
int v2; // ebx
long long v3; // rax
int v5; // [rsp+1Ch] [rbp-24h] BYREF
unsigned long long i; // [rsp+20h] [rbp-20h]
unsigned long long v7; // [rsp+28h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = 0LL; ; ++i )
{
v3 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101afc
MOV qword ptr [RBP + -0x20],0x0
JMP 0x001012ef
LAB_001012a3:
MOV R... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int *piVar2;
long lVar3;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
int local_2c;
ulong local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,st... |
2,757 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> result;
for (size_t i = 0; i < nums.size() - 1; ++i) {
result.push_back(nums[i] * nums[i + 1]);
}
return result;
}
| int main() {
assert(func0({1, 1, 3, 4, 4, 5, 6, 7}) == std::vector<int>({1, 3, 12, 16, 20, 30, 42}));
assert(func0({4, 5, 8, 9, 6, 10}) == std::vector<int>({20, 40, 72, 54, 60}));
assert(func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>({2, 6, 12, 20, 30, 42, 56, 72, 90}));
return 0;
... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
mov 0x8(%rsi),%rax
sub %rd... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
mov rax, [rsi+8]
sub ... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v2; // rdx
unsigned long long v4; // rbp
long long v5; // rcx
int v6; // eax
int *v7; // rsi
int v9; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v10; // [rsp+8h] [rbp-30h]
v10 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001013... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int *piVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) ... |
2,758 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> result;
for (size_t i = 0; i < nums.size() - 1; ++i) {
result.push_back(nums[i] * nums[i + 1]);
}
return result;
}
| int main() {
assert(func0({1, 1, 3, 4, 4, 5, 6, 7}) == std::vector<int>({1, 3, 12, 16, 20, 30, 42}));
assert(func0({4, 5, 8, 9, 6, 10}) == std::vector<int>({20, 40, 72, 54, 60}));
assert(func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>({2, 6, 12, 20, 30, 42, 56, 72, 90}));
return 0;
... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
mov 0x8(%rsi),%rax
sub %rd... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov rax, [rsi+8]
mov qword ptr [rdi+10h], 0
sub rax,... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
long long v4; // rax
int *v6; // rdi
int *v7; // rsi
unsigned long long v8; // rbx
long long v9; // rcx
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001016f8
MOV R1... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
long *in_RSI;
int *piVar4;
int *piVar5;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [... |
2,759 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> result;
for (size_t i = 0; i < nums.size() - 1; ++i) {
result.push_back(nums[i] * nums[i + 1]);
}
return result;
}
| int main() {
assert(func0({1, 1, 3, 4, 4, 5, 6, 7}) == std::vector<int>({1, 3, 12, 16, 20, 30, 42}));
assert(func0({4, 5, 8, 9, 6, 10}) == std::vector<int>({20, 40, 72, 54, 60}));
assert(func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>({2, 6, 12, 20, 30, 42, 56, 72, 90}));
return 0;
... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
mov 0x8(%rsi),%rax
sub %rdx,... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov rax, [rsi+8]
mov qword ptr [rdi+10h], 0
sub rax,... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
long long v4; // rax
int *v6; // rdi
int *v7; // rsi
unsigned long long v8; // rbx
long long v9; // rcx
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001016f8
MOV R1... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
long *in_RSI;
int *piVar4;
int *piVar5;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [... |
2,760 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| map<int, vector<int>> func0(const vector<pair<int, int>>& test_list) {
// Sort the list based on the second element of each pair
vector<pair<int, int>> sorted_list = test_list;
sort(sorted_list.begin(), sorted_list.end(), [](const pair<int, int>& a, const pair<int, int>& b) -> bool {
return a.se... | int main() {
// First test case
vector<pair<int, int>> test1 = { {6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7} };
map<int, vector<int>> expected1 = { {5, {6, 2}}, {7, {2, 8, 3}}, {8, {9}} };
assert(func0(test1) == expected1);
// Second test case
vector<pair<int, int>> test2 = { {7, 6}, ... | O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)::{lambda(std::pair<int, int> const&, std::pair<int, int> const&)#1}::operator()(std::pair<int, int> const&, std::pair<int, int> const&) const:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov %rdx,-0x... | _ZZ5func0RKSt6vectorISt4pairIiiESaIS1_EEENKUlRKS1_S7_E_clES7_S7_:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov edx, [rax+4]
mov rax, [rbp+var_18]
mov eax, [rax+4]
cmp edx, eax
setl al
pop rbp
retn | bool func0(std::vector<std::pair<int,int>> const&)::{lambda(std::pair<int,int> const&,std::pair<int,int> const&)#1}::operator()(
long long a1,
long long a2,
long long a3)
{
return *(_DWORD *)(a2 + 4) < *(_DWORD *)(a3 + 4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0x70]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_001013a1:
CALL 0x001036ae
LEA RAX,[RBP + -0x... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1)
{
char cVar1;
bool bVar2;
__normal_iterator _Var3;
__normal_iterator _Var4;
long lVar5;
vector<int,std::allocator<int>> *this;
_lambda_std__pair<int,int>_const__std__pair<int,int>_... |
2,761 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| map<int, vector<int>> func0(const vector<pair<int, int>>& test_list) {
// Sort the list based on the second element of each pair
vector<pair<int, int>> sorted_list = test_list;
sort(sorted_list.begin(), sorted_list.end(), [](const pair<int, int>& a, const pair<int, int>& b) -> bool {
return a.se... | int main() {
// First test case
vector<pair<int, int>> test1 = { {6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7} };
map<int, vector<int>> expected1 = { {5, {6, 2}}, {7, {2, 8, 3}}, {8, {9}} };
assert(func0(test1) == expected1);
// Second test case
vector<pair<int, int>> test2 = { {7, 6}, ... | O1 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<int, int>*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > >, __gnu_cxx::__ops::_Val_comp_iter<func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)::{lambda(std::pair<int, int> const&, st... | _ZSt25__unguarded_linear_insertIN9__gnu_cxx17__normal_iteratorIPSt4pairIiiESt6vectorIS3_SaIS3_EEEENS0_5__ops14_Val_comp_iterIZ5func0RKS7_EUlRKS3_SE_E_EEEvT_T0_:
mov esi, [rdi]
mov ecx, [rdi+4]
lea rax, [rdi-8]
cmp ecx, [rdi-4]
jge short loc_136E
loc_1357:
mov rdi, rax
mov edx, [rax]
mov ... | int * std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<int,int> *,std::vector<std::pair<int,int>>>,__gnu_cxx::__ops::_Val_comp_iter<func0(std::vector<std::pair<int,int>> const&)::{lambda(std::pair<int,int> const&,std::pair<int,int> const&)#1}>>(
int *a1)
{
int v1; // esi
int v2; // ecx
... | __unguarded_linear_insert<__normal_iterator<std::pair<int,int>*,std::vector<std::pair<int,int>,std::allocator<std::pair<int,int>>>>,__ops::_Val_comp_iter<func0(std::vector<std::pair<int,int>,std::allocator<std::pair<int,int>>>const&)::{lambda(std::pair<int,int>const&,std::pair<int,int>const&)#1}>>:
MOV ESI,dword ptr [R... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__unguarded_linear_insert<__normal_iterator<std::pair<int, int>*,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > >,
__ops::_Val_comp_iter<func0(std::vector<std::pair<int, int>, std::allocator<std::pa... |
2,762 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| map<int, vector<int>> func0(const vector<pair<int, int>>& test_list) {
// Sort the list based on the second element of each pair
vector<pair<int, int>> sorted_list = test_list;
sort(sorted_list.begin(), sorted_list.end(), [](const pair<int, int>& a, const pair<int, int>& b) -> bool {
return a.se... | int main() {
// First test case
vector<pair<int, int>> test1 = { {6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7} };
map<int, vector<int>> expected1 = { {5, {6, 2}}, {7, {2, 8, 3}}, {8, {9}} };
assert(func0(test1) == expected1);
// Second test case
vector<pair<int, int>> test2 = { {7, 6}, ... | O2 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<int, int>*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > >, long, std::pair<int, int>, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)::{lambda(std::pair<int,... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt4pairIiiESt6vectorIS3_SaIS3_EEEElS3_NS0_5__ops15_Iter_comp_iterIZ5func0RKS7_EUlRKS3_SE_E_EEEvT_T0_SI_T1_T2__isra_0:
lea rax, [rdx-1]
push r13
movq xmm1, rcx
push r12
mov r12, rdx
pshufd xmm3, xmm1, 0E5h
movd r8d, xmm3
push rbp
and r12d, 1... | unsigned int * std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<int,int> *,std::vector<std::pair<int,int>>>,long,std::pair<int,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::pair<int,int>> const&)::{lambda(std::pair<int,int> const&,std::pair<int,int> const&)#1}>>(
long long a1,
l... | func0:
MOV RDI,qword ptr [R12 + 0x10]
CALL 0x001022f0
LEA RDI,[RSP + 0x20]
CALL 0x001026d0
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012ac
MOV RDI,RBX
LAB_001012a7:
CALL 0x00101270
LAB_001012ac:
CALL 0x00101220 | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,long param_11)
{
long unaff_R12;
long in_FS_OFF... |
2,763 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| map<int, vector<int>> func0(const vector<pair<int, int>>& test_list) {
// Sort the list based on the second element of each pair
vector<pair<int, int>> sorted_list = test_list;
sort(sorted_list.begin(), sorted_list.end(), [](const pair<int, int>& a, const pair<int, int>& b) -> bool {
return a.se... | int main() {
// First test case
vector<pair<int, int>> test1 = { {6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7} };
map<int, vector<int>> expected1 = { {5, {6, 2}}, {7, {2, 8, 3}}, {8, {9}} };
assert(func0(test1) == expected1);
// Second test case
vector<pair<int, int>> test2 = { {7, 6}, ... | O3 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<int, int>*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > >, long, std::pair<int, int>, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)::{lambda(std::pair<int,... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt4pairIiiESt6vectorIS3_SaIS3_EEEElS3_NS0_5__ops15_Iter_comp_iterIZ5func0RKS7_EUlRKS3_SE_E_EEEvT_T0_SI_T1_T2__isra_0:
lea rax, [rdx-1]
push r13
movq xmm1, rcx
push r12
mov r12, rdx
pshufd xmm3, xmm1, 0E5h
movd r8d, xmm3
push rbp
and r12d, 1... | unsigned int * std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<int,int> *,std::vector<std::pair<int,int>>>,long,std::pair<int,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::pair<int,int>> const&)::{lambda(std::pair<int,int> const&,std::pair<int,int> const&)#1}>>(
long long a1,
l... | func0:
MOV RDI,qword ptr [R13 + 0x10]
CALL 0x00102210
LEA RDI,[RSP + 0x20]
CALL 0x00102a80
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012ab
MOV RDI,RBX
LAB_001012a6:
CALL 0x00101270
LAB_001012ab:
CALL 0x00101220 | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,long param_11)
{
long unaff_R13;
long in_FS_OFF... |
2,764 | func0 |
#include <assert.h>
| int func0(int N) {
if (N < 10) {
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
return 0;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x9,-0x14(%rbp)
jg 11a8 <_Z5func0i+0x5f>
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 11a3 <_Z5func0i+0x5a>
mov -0x8(%rbp),%eax
imul -0x4(%rbp),%eax
movslq %eax,%rdx
imul $0... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 9
jg short loc_11A8
mov [rbp+var_8], 1
mov [rbp+var_4], 1
jmp short loc_119B
loc_116A:
mov eax, [rbp+var_8]
imul eax, [rbp+var_4]
movsxd rdx, eax
imul rdx, 51EB851Fh
shr rdx, 20h
sar edx, ... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
if ( a1 > 9 )
return 0LL;
v2 = 1;
for ( i = 1; i <= a1; ++i )
v2 = (int)(i * v2) % 100;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x9
JG 0x001011a8
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010119b
LAB_0010116a:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x51eb851f
SHR RDX,0x20
... | /* func0(int) */
int func0(int param_1)
{
int4 local_10;
int4 local_c;
if (param_1 < 10) {
local_10 = 1;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = (local_10 * local_c) % 100;
}
}
else {
local_10 = 0;
}
return local_10;
} |
2,765 | func0 |
#include <assert.h>
| int func0(int N) {
if (N < 10) {
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
return 0;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x0,%eax
cmp $0x9,%edi
jle 1158 <_Z5func0i+0xf>
retq
test %edi,%edi
jle 1191 <_Z5func0i+0x48>
add $0x1,%edi
mov $0x1,%edx
mov $0x1,%eax
imul %edx,%eax
mov %eax,%ecx
cltq
imul $0x51eb851f,%rax,%rax
sar $0x25,%rax
mov %ecx,%esi
sar $0x1f,%esi
sub %esi,%ea... | _Z5func0i:
endbr64
mov eax, 0
cmp edi, 9
jle short loc_1158
retn
loc_1158:
test edi, edi
jle short loc_1191
add edi, 1
mov edx, 1
mov eax, 1
loc_1169:
imul eax, edx
mov ecx, eax
cdqe
imul rax, 51EB851Fh
sar rax, 25h
mov esi, ecx
sar esi, 1Fh
sub eax, esi
imul ... | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 <= 0 )
{
return 1LL;
}
else
{
v2 = a1 + 1;
v3 = 1;
LODWORD(result) = 1;
do
{
result = (unsigned int)(v3 * (int)result % 10... | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0x9
JLE 0x00101158
RET
LAB_00101158:
TEST EDI,EDI
JLE 0x00101191
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x1
LAB_00101169:
IMUL EAX,EDX
MOV ECX,EAX
CDQE
IMUL RAX,RAX,0x51eb851f
SAR RAX,0x25
MOV ESI,ECX
SAR ESI,0x1f
SUB EAX,ESI
IMUL ESI,EAX,0x64
MOV EAX,ECX
SUB EAX,ESI
ADD EDX,0x1
CMP EDX,EDI
... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (9 < param_1) {
return 0;
}
if (0 < param_1) {
iVar2 = 1;
iVar1 = 1;
do {
iVar1 = (iVar1 * iVar2) % 100;
iVar2 = iVar2 + 1;
} while (iVar2 != param_1 + 1);
return iVar1;
}
return 1;
} |
2,766 | func0 |
#include <assert.h>
| int func0(int N) {
if (N < 10) {
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
return 0;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O2 | cpp | func0(int):
endbr64
xor %eax,%eax
cmp $0x9,%edi
jle 11c0 <_Z5func0i+0x10>
retq
nopl 0x0(%rax)
test %edi,%edi
jle 1200 <_Z5func0i+0x50>
add $0x1,%edi
mov $0x1,%eax
mov $0x1,%edx
nopl 0x0(%rax)
imul %edx,%eax
add $0x1,%edx
mov %eax,%ecx
cltq
imul $0x51eb851f,%rax,%rax
mov %ecx,%esi... | _Z5func0i:
endbr64
xor eax, eax
cmp edi, 9
jle short loc_11C0
retn
loc_11C0:
test edi, edi
jle short loc_1200
add edi, 1
mov edx, 1
mov eax, 1
nop dword ptr [rax+00000000h]
loc_11D8:
imul eax, edx
add edx, 1
mov ecx, eax
cdqe
imul rax, 51EB851Fh
mov esi, ecx
sar ... | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
int v4; // eax
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 <= 0 )
{
return 1LL;
}
else
{
v2 = a1 + 1;
v3 = 1;
LODWORD(result) = 1;
do
{
v4 = v3 * result;
++... | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x9
JLE 0x001011c0
RET
LAB_001011c0:
TEST EDI,EDI
JLE 0x00101200
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001011d8:
IMUL EAX,EDX
ADD EDX,0x1
MOV ECX,EAX
CDQE
IMUL RAX,RAX,0x51eb851f
MOV ESI,ECX
SAR ESI,0x1f
SAR RAX,0x25
SUB EAX,ESI
IMUL ESI,EAX,0x64
MOV EAX,ECX
SUB ... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (9 < param_1) {
return 0;
}
if (0 < param_1) {
iVar2 = 1;
iVar1 = 1;
do {
iVar1 = iVar1 * iVar2;
iVar2 = iVar2 + 1;
iVar1 = iVar1 % 100;
} while (param_1 + 1 != iVar2);
return iVar1;
}
return ... |
2,767 | func0 |
#include <assert.h>
| int func0(int N) {
if (N < 10) {
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
return 0;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O3 | cpp | func0(int):
endbr64
xor %eax,%eax
cmp $0x9,%edi
jle 1150 <_Z5func0i+0x10>
retq
nopl 0x0(%rax)
test %edi,%edi
jle 1190 <_Z5func0i+0x50>
cmp $0x1,%edi
je 1190 <_Z5func0i+0x50>
cmp $0x2,%edi
je 11a6 <_Z5func0i+0x66>
cmp $0x3,%edi
je 11ac <_Z5func0i+0x6c>
cmp $0x4,%edi
je 1196 <_... | _Z5func0i:
endbr64
xor eax, eax
cmp edi, 9
jle short loc_1150
retn
loc_1150:
test edi, edi
jle short loc_1188
cmp edi, 1
jz short loc_1188
cmp edi, 2
jz short loc_1194
cmp edi, 3
jz short loc_119A
cmp edi, 4
jz short loc_118E
cmp edi, 6
jle short loc_11A0
c... | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 < 2 )
{
return 1LL;
}
else
{
switch ( a1 )
{
case 2:
return 2LL;
case 3:
return 6LL;
case 4:
return 24LL;
default:
... | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x9
JLE 0x00101150
RET
LAB_00101150:
TEST EDI,EDI
JLE 0x00101188
CMP EDI,0x1
JZ 0x00101188
CMP EDI,0x2
JZ 0x00101194
CMP EDI,0x3
JZ 0x0010119a
CMP EDI,0x4
JZ 0x0010118e
CMP EDI,0x6
JLE 0x001011a0
CMP EDI,0x7
JZ 0x001011a6
CMP EDI,0x9
MOV EDX,0x14
MOV EAX,0x50
CMOVNZ EAX,EDX
RET
LAB_00... | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
if (9 < param_1) {
return 0;
}
if ((param_1 < 1) || (param_1 == 1)) {
return 1;
}
if (param_1 == 2) {
return 2;
}
if (param_1 != 3) {
if (param_1 == 4) {
return 0x18;
}
if (6 < param_1) {
if (param_1 != 7) {
... |
2,768 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex multiple_spaces(" +");
return std::regex_replace(text1, multiple_spaces, " ");
}
| int main() {
assert(func0("Google Assistant") == "Google Assistant");
assert(func0("Quad Core") == "Quad Core");
assert(func0("ChromeCast Built-in") == "ChromeCast Built-in");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, asc_34051; " +"
mov... | long long func0(long long a1, long long a2)
{
_BYTE v3[40]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-18h]
v4 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v3, " +", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_traits<char... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b63:
CALL 0x00106152
MOV RAX,qword ptr ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 in_RSI;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48," +",0x10);
/* try { // try from 00104b84 to 00104b88 has its CatchHandle... |
2,769 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex multiple_spaces(" +");
return std::regex_replace(text1, multiple_spaces, " ");
}
| int main() {
assert(func0("Google Assistant") == "Google Assistant");
assert(func0("Quad Core") == "Quad Core");
assert(func0("ChromeCast Built-in") == "ChromeCast Built-in");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZNS... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_50]
lea rdi, [rbp+var_48]; this
call __Z... | long long func0(long long a1, long long *a2)
{
long long v4; // rsi
_DWORD *v5; // rdi
volatile signed __int32 *v6; // rcx
long long v7; // rdx
signed __int32 v8; // eax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
long long v12; // [rsp+10h] [rbp-40h]
long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x50]
LEA RDI,[RBP + -0x48]
CALL 0x00104710
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV ECX,0x10
LEA RDX,[0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int8 local_48;
_Sp_counted_base<(_Lock_policy)2> *local_40;
long... |
2,770 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex multiple_spaces(" +");
return std::regex_replace(text1, multiple_spaces, " ");
}
| int main() {
assert(func0("Google Assistant") == "Google Assistant");
assert(func0("Quad Core") == "Quad Core");
assert(func0("ChromeCast Built-in") == "ChromeCast Built-in");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_50]
push r12
lea r12, [rbp+var_48]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_28], rax... | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
long long v4; // rdi
long long v5; // rdx
volatile signed __int32 *v6; // rcx
signed __int32 v7; // eax
long long v9; // rax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
__int128 v12; // [rsp+10... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x50]
PUSH R12
LEA R12,[RBP + -0x48]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001046f0
LEA RDX,[0x11a67d]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::... |
2,771 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text1) {
std::regex multiple_spaces(" +");
return std::regex_replace(text1, multiple_spaces, " ");
}
| int main() {
assert(func0("Google Assistant") == "Google Assistant");
assert(func0("Quad Core") == "Quad Core");
assert(func0("ChromeCast Built-in") == "ChromeCast Built-in");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
lea r15, [rbp+var_E0]
push r13
push r12
mov r12, rsi
push rbx
mov rbx, rdi
sub rsp, 108h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v3; // rax
long long v4; // r13
char *v5; // r15
char *v6; // r12
char v7; // al
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
unsigned long long v12; // rsi
long long v13; // rdi
volatile signed __int32 *v14; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R15,[RBP + -0xe0]
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x108
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x128],R15
MOV RDI,RAX
MOV qword ptr [RBP + -0x130],RAX
CALL 0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
string sVar2;
string *psVar3;
long lVar4;
int8 uVar5;
bool bVar6;
char cVar7;
int iVar8;
int8 *puVar9;
string *psVar10;
long lVar11;
long *plVar12;
ulong uVar13;
ulong uVar14;
lon... |
2,772 | func0 |
#include <cassert>
#include <map>
#include <vector>
#include <set>
#include <string>
| std::vector<int> func0(const std::map<std::string, std::vector<int>>& test_dict) {
std::set<int> unique_set;
for (const auto& pair : test_dict) {
for (int ele : pair.second) {
unique_set.insert(ele);
}
}
return std::vector<int>(unique_set.begin(), unique_set.end());
}... | int main() {
std::map<std::string, std::vector<int>> dict1 = {
{"msm", {5, 6, 7, 8}},
{"is", {10, 11, 7, 5}},
{"best", {6, 12, 10, 8}},
{"for", {1, 2, 5}}
};
std::vector<int> expected1 = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(func0(dict1) == expected1);
... | O0 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEESt4lessIS5_ESaISt4pairIKS5_S8_EEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+1Ch] [rbp-94h] BYREF
long long v6; // [rsp+20h] [rbp-90h] BYREF
long long v7; // [rsp+28h] [rbp-88h] BYREF
long long v8; // [rsp+30h] [rbp-80h] BYREF
_QWORD v9[2]; // [rsp+38h] [rbp-78h] BYREF
long l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00103e98
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qwor... | /* func0(std::map<std::string, std::vector<int, std::allocator<int> >, std::less<std::string >,
std::allocator<std::pair<std::string const, std::vector<int, std::allocator<int> > > > > const&)
*/
map * func0(map *param_1)
{
bool bVar1;
char cVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
map<std::strin... |
2,773 | func0 |
#include <cassert>
#include <map>
#include <vector>
#include <set>
#include <string>
| std::vector<int> func0(const std::map<std::string, std::vector<int>>& test_dict) {
std::set<int> unique_set;
for (const auto& pair : test_dict) {
for (int ele : pair.second) {
unique_set.insert(ele);
}
}
return std::vector<int>(unique_set.begin(), unique_set.end());
}... | int main() {
std::map<std::string, std::vector<int>> dict1 = {
{"msm", {5, 6, 7, 8}},
{"is", {10, 11, 7, 5}},
{"best", {6, 12, 10, 8}},
{"for", {1, 2, 5}}
};
std::vector<int> expected1 = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(func0(dict1) == expected1);
... | O1 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEESt4lessIS5_ESaISt4pairIKS5_S8_EEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov r15, rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov [rsp+88h+v... | _QWORD * func0(_QWORD *a1, long long a2)
{
long long v3; // r13
int *v4; // rbx
int *i; // rbp
int *v6; // rbx
int *v7; // rdi
unsigned long long v8; // rbp
unsigned long long v9; // r12
_DWORD *v10; // rax
_DWORD *v11; // rbp
int v13; // [rsp+Ch] [rbp-7Ch] BYREF
_BYTE v14[8]; // [rsp+10h] [rbp-78... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV qword ... | /* func0(std::map<std::string, std::vector<int, std::allocator<int> >, std::less<std::string >,
std::allocator<std::pair<std::string const, std::vector<int, std::allocator<int> > > > > const&)
*/
map * func0(map *param_1)
{
int *piVar1;
_Rb_tree_node_base *p_Var2;
int4 *puVar3;
int8 uVar4;
_Rb_tree_n... |
2,774 | func0 |
#include <cassert>
#include <map>
#include <vector>
#include <set>
#include <string>
| std::vector<int> func0(const std::map<std::string, std::vector<int>>& test_dict) {
std::set<int> unique_set;
for (const auto& pair : test_dict) {
for (int ele : pair.second) {
unique_set.insert(ele);
}
}
return std::vector<int>(unique_set.begin(), unique_set.end());
}... | int main() {
std::map<std::string, std::vector<int>> dict1 = {
{"msm", {5, 6, 7, 8}},
{"is", {10, 11, 7, 5}},
{"best", {6, 12, 10, 8}},
{"for", {1, 2, 5}}
};
std::vector<int> expected1 = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(func0(dict1) == expected1);
... | O2 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEESt4lessIS5_ESaISt4pairIKS5_S8_EEE:
endbr64
push r15
add rsi, 8
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_80], rdi
lea r14, [rsp+98h+var_70]
mov rax, fs:28h
mov ... | _QWORD * func0(_QWORD *a1, long long a2)
{
long long v2; // rsi
long long v3; // rax
int *v4; // r15
int *v5; // r12
int *v6; // rbx
int v7; // ebp
int v8; // edx
int *v9; // rax
bool v10; // r13
long long v11; // rax
int *v12; // rbx
int *v13; // rdi
long long v14; // r12
unsigned long long... | func0:
ENDBR64
PUSH R15
ADD RSI,0x8
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x18],RDI
LEA R14,[RSP + 0x28]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x10]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ... | /* func0(std::map<std::string, std::vector<int, std::allocator<int> >, std::less<std::string >,
std::allocator<std::pair<std::string const, std::vector<int, std::allocator<int> > > > > const&)
*/
map * func0(map *param_1)
{
int iVar1;
int *piVar2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;... |
2,775 | func0 |
#include <cassert>
#include <map>
#include <vector>
#include <set>
#include <string>
| std::vector<int> func0(const std::map<std::string, std::vector<int>>& test_dict) {
std::set<int> unique_set;
for (const auto& pair : test_dict) {
for (int ele : pair.second) {
unique_set.insert(ele);
}
}
return std::vector<int>(unique_set.begin(), unique_set.end());
}... | int main() {
std::map<std::string, std::vector<int>> dict1 = {
{"msm", {5, 6, 7, 8}},
{"is", {10, 11, 7, 5}},
{"best", {6, 12, 10, 8}},
{"for", {1, 2, 5}}
};
std::vector<int> expected1 = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(func0(dict1) == expected1);
... | O3 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEESt4lessIS5_ESaISt4pairIKS5_S8_EEE:
endbr64
push r15
add rsi, 8
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_80], rdi
lea r14, [rsp+98h+var_70]
mov rax, fs:28h
mov ... | _QWORD * func0(_QWORD *a1, long long a2)
{
long long v2; // rsi
long long v3; // rax
int *v4; // r15
int *v5; // r12
int *v6; // rbx
int v7; // ebp
int v8; // edx
int *v9; // rax
bool v10; // r13
long long v11; // rax
int *v12; // rbx
int *v13; // rdi
long long v14; // r12
unsigned long long... | func0:
ENDBR64
PUSH R15
ADD RSI,0x8
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x18],RDI
LEA R14,[RSP + 0x28]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x10]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ... | /* func0(std::map<std::string, std::vector<int, std::allocator<int> >, std::less<std::string >,
std::allocator<std::pair<std::string const, std::vector<int, std::allocator<int> > > > > const&)
*/
map * func0(map *param_1)
{
int iVar1;
int *piVar2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;... |
2,776 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| bool func0(const std::tuple<int, int, int>& test_tup1, const std::tuple<int, int, int>& test_tup2) {
return std::get<0>(test_tup1) < std::get<0>(test_tup2) &&
std::get<1>(test_tup1) < std::get<1>(test_tup2) &&
std::get<2>(test_tup1) < std::get<2>(test_tup2);
}
| int main() {
assert(func0(std::make_tuple(10, 4, 5), std::make_tuple(13, 5, 18)) == true);
assert(func0(std::make_tuple(1, 2, 3), std::make_tuple(2, 1, 4)) == false);
assert(func0(std::make_tuple(4, 5, 6), std::make_tuple(5, 6, 7)) == true);
return 0;
}
| O0 | cpp | func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 14ce <_ZSt3getILm0EJiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
m... | _Z5func0RKSt5tupleIJiiiEES2_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_18]
mov rdi, rax
call _ZSt3getILm0EJiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<0ul,int,int,int>(std::tuple<int,int,i... | _BOOL8 func0(long long a1, long long a2)
{
int v2; // ebx
int v3; // ebx
int v4; // ebx
_BOOL8 result; // rax
v2 = *(_DWORD *)std::get<0ul,int,int,int>(a1);
result = 0;
if ( v2 < *(_DWORD *)std::get<0ul,int,int,int>(a2) )
{
v3 = *(_DWORD *)std::get<1ul,int,int,int>(a1);
if ( v3 < *(_DWORD *)st... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001013fc
MOV EBX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001013fc
MOV EAX,dword ptr [RAX]
CMP EBX,EAX
JGE 0x001011e5
MOV... | /* func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&) */
int8 func0(tuple *param_1,tuple *param_2)
{
int iVar1;
type *ptVar2;
type *ptVar3;
type *ptVar4;
ptVar2 = std::get<0ul,int,int,int>(param_1);
iVar1 = *(int *)ptVar2;
ptVar2 = std::get<0ul,int,int,int>(param_2);
if (iVar... |
2,777 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| bool func0(const std::tuple<int, int, int>& test_tup1, const std::tuple<int, int, int>& test_tup2) {
return std::get<0>(test_tup1) < std::get<0>(test_tup2) &&
std::get<1>(test_tup1) < std::get<1>(test_tup2) &&
std::get<2>(test_tup1) < std::get<2>(test_tup2);
}
| int main() {
assert(func0(std::make_tuple(10, 4, 5), std::make_tuple(13, 5, 18)) == true);
assert(func0(std::make_tuple(1, 2, 3), std::make_tuple(2, 1, 4)) == false);
assert(func0(std::make_tuple(4, 5, 6), std::make_tuple(5, 6, 7)) == true);
return 0;
}
| O1 | cpp | func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&):
endbr64
mov $0x0,%eax
mov 0x8(%rsi),%edx
cmp %edx,0x8(%rdi)
jge 11c9 <_Z5func0RKSt5tupleIJiiiEES2_+0x20>
mov 0x4(%rsi),%ecx
cmp %ecx,0x4(%rdi)
jge 11c9 <_Z5func0RKSt5tupleIJiiiEES2_+0x20>
mov (%rsi),%eax
cmp %eax,(%rdi... | _Z5func0RKSt5tupleIJiiiEES2_:
endbr64
mov eax, 0
mov edx, [rsi+8]
cmp [rdi+8], edx
jge short locret_1189
mov ecx, [rsi+4]
cmp [rdi+4], ecx
jge short locret_1189
mov eax, [rsi]
cmp [rdi], eax
setl al
locret_1189:
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
bool result; // al
result = 0;
if ( a1[2] < a2[2] && a1[1] < a2[1] )
return *a1 < *a2;
return result;
} | func0:
ENDBR64
MOV EAX,0x0
MOV EDX,dword ptr [RSI + 0x8]
CMP dword ptr [RDI + 0x8],EDX
JGE 0x00101189
MOV ECX,dword ptr [RSI + 0x4]
CMP dword ptr [RDI + 0x4],ECX
JGE 0x00101189
MOV EAX,dword ptr [RSI]
CMP dword ptr [RDI],EAX
SETL AL
LAB_00101189:
RET | /* func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&) */
int4 func0(tuple *param_1,tuple *param_2)
{
int4 uVar1;
uVar1 = 0;
if ((*(int *)(param_1 + 8) < *(int *)(param_2 + 8)) &&
(*(int *)(param_1 + 4) < *(int *)(param_2 + 4))) {
uVar1 = CONCAT31((int3)((uint)*(int *)param_2 >... |
2,778 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| bool func0(const std::tuple<int, int, int>& test_tup1, const std::tuple<int, int, int>& test_tup2) {
return std::get<0>(test_tup1) < std::get<0>(test_tup2) &&
std::get<1>(test_tup1) < std::get<1>(test_tup2) &&
std::get<2>(test_tup1) < std::get<2>(test_tup2);
}
| int main() {
assert(func0(std::make_tuple(10, 4, 5), std::make_tuple(13, 5, 18)) == true);
assert(func0(std::make_tuple(1, 2, 3), std::make_tuple(2, 1, 4)) == false);
assert(func0(std::make_tuple(4, 5, 6), std::make_tuple(5, 6, 7)) == true);
return 0;
}
| O2 | cpp | func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&):
endbr64
mov 0x8(%rsi),%edx
xor %eax,%eax
cmp %edx,0x8(%rdi)
jge 11dd <_Z5func0RKSt5tupleIJiiiEES2_+0x1d>
mov 0x4(%rsi),%ecx
cmp %ecx,0x4(%rdi)
jge 11dd <_Z5func0RKSt5tupleIJiiiEES2_+0x1d>
mov (%rsi),%eax
cmp %eax,(%rdi... | _Z5func0RKSt5tupleIJiiiEES2_:
endbr64
mov edx, [rsi+8]
xor eax, eax
cmp [rdi+8], edx
jge short locret_115D
mov ecx, [rsi+4]
cmp [rdi+4], ecx
jge short locret_115D
mov eax, [rsi]
cmp [rdi], eax
setl al
locret_115D:
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
bool result; // al
result = 0;
if ( a1[2] < a2[2] && a1[1] < a2[1] )
return *a1 < *a2;
return result;
} | func0:
ENDBR64
MOV EDX,dword ptr [RSI + 0x8]
XOR EAX,EAX
CMP dword ptr [RDI + 0x8],EDX
JGE 0x0010115d
MOV ECX,dword ptr [RSI + 0x4]
CMP dword ptr [RDI + 0x4],ECX
JGE 0x0010115d
MOV EAX,dword ptr [RSI]
CMP dword ptr [RDI],EAX
SETL AL
LAB_0010115d:
RET | /* func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&) */
int4 func0(tuple *param_1,tuple *param_2)
{
int4 uVar1;
uVar1 = 0;
if ((*(int *)(param_1 + 8) < *(int *)(param_2 + 8)) &&
(*(int *)(param_1 + 4) < *(int *)(param_2 + 4))) {
uVar1 = CONCAT31((int3)((uint)*(int *)param_2 >... |
2,779 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| bool func0(const std::tuple<int, int, int>& test_tup1, const std::tuple<int, int, int>& test_tup2) {
return std::get<0>(test_tup1) < std::get<0>(test_tup2) &&
std::get<1>(test_tup1) < std::get<1>(test_tup2) &&
std::get<2>(test_tup1) < std::get<2>(test_tup2);
}
| int main() {
assert(func0(std::make_tuple(10, 4, 5), std::make_tuple(13, 5, 18)) == true);
assert(func0(std::make_tuple(1, 2, 3), std::make_tuple(2, 1, 4)) == false);
assert(func0(std::make_tuple(4, 5, 6), std::make_tuple(5, 6, 7)) == true);
return 0;
}
| O3 | cpp | func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&):
endbr64
mov 0x8(%rsi),%edx
xor %eax,%eax
cmp %edx,0x8(%rdi)
jge 11dd <_Z5func0RKSt5tupleIJiiiEES2_+0x1d>
mov 0x4(%rsi),%ecx
cmp %ecx,0x4(%rdi)
jge 11dd <_Z5func0RKSt5tupleIJiiiEES2_+0x1d>
mov (%rsi),%eax
cmp %eax,(%rdi... | _Z5func0RKSt5tupleIJiiiEES2_:
endbr64
mov edx, [rsi+8]
xor eax, eax
cmp [rdi+8], edx
jge short locret_115D
mov ecx, [rsi+4]
cmp [rdi+4], ecx
jge short locret_115D
mov eax, [rsi]
cmp [rdi], eax
setl al
locret_115D:
retn | bool func0(_DWORD *a1, _DWORD *a2)
{
bool result; // al
result = 0;
if ( a1[2] < a2[2] && a1[1] < a2[1] )
return *a1 < *a2;
return result;
} | func0:
ENDBR64
MOV EDX,dword ptr [RSI + 0x8]
XOR EAX,EAX
CMP dword ptr [RDI + 0x8],EDX
JGE 0x0010115d
MOV ECX,dword ptr [RSI + 0x4]
CMP dword ptr [RDI + 0x4],ECX
JGE 0x0010115d
MOV EAX,dword ptr [RSI]
CMP dword ptr [RDI],EAX
SETL AL
LAB_0010115d:
RET | /* func0(std::tuple<int, int, int> const&, std::tuple<int, int, int> const&) */
int4 func0(tuple *param_1,tuple *param_2)
{
int4 uVar1;
uVar1 = 0;
if ((*(int *)(param_1 + 8) < *(int *)(param_2 + 8)) &&
(*(int *)(param_1 + 4) < *(int *)(param_2 + 4))) {
uVar1 = CONCAT31((int3)((uint)*(int *)param_2 >... |
2,780 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& list1, const std::vector<std::vector<std::string>>& list2) {
std::vector<std::vector<std::string>> result;
for (size_t i = 0; i < list1.size(); ++i) {
std::vector<std::string> combined = list1[i];
combin... | int main() {
assert(func0({{"1", "3"}, {"5", "7"}, {"9", "11"}}, {{"2", "4"}, {"6", "8"}, {"10", "12", "14"}}) == std::vector<std::vector<std::string>>({{"1", "3", "2", "4"}, {"5", "7", "6", "8"}, {"9", "11", "10", "12", "14"}}));
assert(func0({{"1", "2"}, {"3", "4"}, {"5", "6"}}, {{"7", "8"}, {"9", "10"}, {"... | O0 | cpp | func0(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0RKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EESB_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov ... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v5; // r12
long long v6; // rax
long long v7; // rbx
unsigned long long v8; // rax
long long v11; // [rsp+28h] [rbp-48h] BYREF
long long v12; // [rsp+30h] [rbp-40h] BYREF
unsigned long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00103fda
MOV qword ptr [RBP + -0x3... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&,
std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&... |
2,781 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& list1, const std::vector<std::vector<std::string>>& list2) {
std::vector<std::vector<std::string>> result;
for (size_t i = 0; i < list1.size(); ++i) {
std::vector<std::string> combined = list1[i];
combin... | int main() {
assert(func0({{"1", "3"}, {"5", "7"}, {"9", "11"}}, {{"2", "4"}, {"6", "8"}, {"10", "12", "14"}}) == std::vector<std::vector<std::string>>({{"1", "3", "2", "4"}, {"5", "7", "6", "8"}, {"9", "11", "10", "12", "14"}}));
assert(func0({{"1", "2"}, {"3", "4"}, {"5", "6"}}, {{"7", "8"}, {"9", "10"}, {"... | O1 | cpp | func0(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0RKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EESB_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r13, rdi
mov [rsp+78h+var_60], rdx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov qword... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v3; // rbx
unsigned long long i; // r12
struct _Unwind_Exception *v5; // rbx
char *v6; // rdx
void **v7; // rbp
_QWORD *v8; // rbx
void **v9; // rax
unsigned long long v10; // r14
long long v11; // rdx
long long v12; // r14
void **v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R13,RDI
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
CMP qword ptr [... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&,
std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&... |
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.