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,982 | func0 |
#include <assert.h>
#include <cmath>
| double func0(double r, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return std::nan("1");
}
double sectorarea = (pi * std::pow(r, 2)) * (a / 360);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(std::isnan(func0(9, 360)));
return 0;
}
| O2 | cpp | func0(double, double):
endbr64
movsd 0xec4(%rip),%xmm2
comisd %xmm2,%xmm1
jb 1160 <_Z5func0dd+0x20>
movsd 0xeae(%rip),%xmm0
retq
nopl 0x0(%rax,%rax,1)
divsd %xmm2,%xmm1
mulsd %xmm0,%xmm0
mulsd 0xea8(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0dd:
endbr64
movsd xmm2, cs:qword_2010
comisd xmm1, xmm2
jb short loc_1160
movsd xmm0, cs:qword_2008
retn
loc_1160:
divsd xmm1, xmm2
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2018
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
if ( a2 < 360.0 )
return a1 * a1 * 3.142857142857143 * (a2 / 360.0);
else
return NAN;
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102010]
COMISD XMM1,XMM2
JC 0x00101160
MOVSD XMM0,qword ptr [0x00102008]
RET
LAB_00101160:
DIVSD XMM1,XMM2
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102018]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
if (DAT_00102010 <= param_2) {
return DAT_00102008;
}
return param_1 * param_1 * _DAT_00102018 * (param_2 / DAT_00102010);
} |
2,983 | func0 |
#include <assert.h>
#include <cmath>
| double func0(double r, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return std::nan("1");
}
double sectorarea = (pi * std::pow(r, 2)) * (a / 360);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(std::isnan(func0(9, 360)));
return 0;
}
| O3 | cpp | func0(double, double):
endbr64
movsd 0xec4(%rip),%xmm2
comisd %xmm2,%xmm1
jb 1160 <_Z5func0dd+0x20>
movsd 0xeae(%rip),%xmm0
retq
nopl 0x0(%rax,%rax,1)
divsd %xmm2,%xmm1
mulsd %xmm0,%xmm0
mulsd 0xea8(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0dd:
endbr64
movsd xmm2, cs:qword_2010
comisd xmm1, xmm2
jb short loc_1160
movsd xmm0, cs:qword_2008
retn
loc_1160:
divsd xmm1, xmm2
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2018
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
if ( a2 < 360.0 )
return a1 * a1 * 3.142857142857143 * (a2 / 360.0);
else
return NAN;
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102010]
COMISD XMM1,XMM2
JC 0x00101160
MOVSD XMM0,qword ptr [0x00102008]
RET
LAB_00101160:
DIVSD XMM1,XMM2
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102018]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
if (DAT_00102010 <= param_2) {
return DAT_00102008;
}
return param_1 * param_1 * _DAT_00102018 * (param_2 / DAT_00102010);
} |
2,984 | func0 | #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::string &X, const std::string &Y, const std::string &Z, int m, int n, int o) {
std::vector<std::vector<std::vector<int>>> L(m + 1, std::vector<std::vector<int>>(n + 1, std::vector<int>(o + 1)));
for (int i = 0; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
for (... | int main() {
assert(func0("AGGT12", "12TXAYB", "12XBA", 6, 7, 5) == 2);
assert(func0("Reels", "Reelsfor", "ReelsforReels", 5, 8, 13) == 5);
assert(func0("abcd1e2", "bc12ea", "bd1ea", 7, 6, 5) == 3);
std::cout << "All test cases passed." << std::endl;
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int, int, int):
endbr64
push %rbp
mov %rsp,%r... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_S6_iii:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 0D8h
mov [rbp+var_C8], rdi
mov [rbp+var_D0], rsi
mov [rbp+var_D8], rdx
mov [rbp+var_DC], ecx
mov [rbp+var_E0], r8d
mov [rbp+var_E4], r9d
... | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
long long v6; // rax
long long v7; // rax
char v8; // bl
char v9; // bl
long long v11; // rax
long long v12; // rax
int v13; // ebx
long long v14; // rax
long long v15; // rax
long long v16; // rax
long long v17; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RBP + -0xc8],RDI
MOV qword ptr [RBP + -0xd0],RSI
MOV qword ptr [RBP + -0xd8],RDX
MOV dword ptr [RBP + -0xdc],ECX
MOV dword ptr [RBP + -0xe0],R8D
MOV dword ptr [RBP + -0xe4],R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x... | /* func0(std::string const&, std::string const&, std::string const&, int, int, int) */
int4
func0(string *param_1,string *param_2,string *param_3,int param_4,int param_5,int param_6)
{
char cVar1;
int4 uVar2;
bool bVar3;
int iVar4;
char *pcVar5;
int *piVar6;
vector<std::vector<int,std::allocator<int>>,s... |
2,985 | func0 | #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::string &X, const std::string &Y, const std::string &Z, int m, int n, int o) {
std::vector<std::vector<std::vector<int>>> L(m + 1, std::vector<std::vector<int>>(n + 1, std::vector<int>(o + 1)));
for (int i = 0; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
for (... | int main() {
assert(func0("AGGT12", "12TXAYB", "12XBA", 6, 7, 5) == 2);
assert(func0("Reels", "Reelsfor", "ReelsforReels", 5, 8, 13) == 5);
assert(func0("abcd1e2", "bc12ea", "bd1ea", 7, 6, 5) == 3);
std::cout << "All test cases passed." << std::endl;
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int, int, int):
endbr64
push %r15
push %r14
pu... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_S6_iii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov [rsp+0E8h+var_C0], rdx
mov dword ptr [rsp+0E8h+var_E0], ecx
mov [rsp+0E8h+var_B4], r8d
mov [rsp+0E8h+var_B8], r9d
mov rax, fs... | long long func0(_QWORD *a1, _QWORD *a2, _QWORD *a3, int a4, int a5, int a6)
{
unsigned long long v6; // rbp
unsigned long long v9; // r14
_DWORD *v10; // rdx
_DWORD *v11; // rax
long long v12; // rax
char *v13; // r12
long long v14; // r13
unsigned long long v15; // rbp
char *i; // rbp
long long *v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RSP + 0x28],RDX
MOV dword ptr [RSP + 0x8],ECX
MOV dword ptr [RSP + 0x34],R8D
MOV dword ptr [RSP + 0x30],R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA EBP,[R9 + 0x1]
MOVSXD RBP,EBP
MOV RAX,RB... | /* func0(std::string const&, std::string const&, std::string const&, int, int, int) */
int4
func0(string *param_1,string *param_2,string *param_3,int param_4,int param_5,int param_6)
{
char cVar1;
int4 uVar2;
long lVar3;
void *pvVar4;
int8 *puVar5;
int4 *puVar6;
ulong uVar7;
vector *pvVar8;
int8 uVa... |
2,986 | func0 | #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::string &X, const std::string &Y, const std::string &Z, int m, int n, int o) {
std::vector<std::vector<std::vector<int>>> L(m + 1, std::vector<std::vector<int>>(n + 1, std::vector<int>(o + 1)));
for (int i = 0; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
for (... | int main() {
assert(func0("AGGT12", "12TXAYB", "12XBA", 6, 7, 5) == 2);
assert(func0("Reels", "Reelsfor", "ReelsforReels", 5, 8, 13) == 5);
assert(func0("abcd1e2", "bc12ea", "bd1ea", 7, 6, 5) == 3);
std::cout << "All test cases passed." << std::endl;
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int, int, int):
endbr64
push %r15
mov %r9d,%e... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_S6_iii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_B0], rdx
mov [rsp+0D8h+var_A4], ecx
mov [rsp+0D8h+var_98], r8d
mov [rsp+0D8h+var_94], r9d
mov rax, fs:28h
mov ... | long long func0(_QWORD *a1, _QWORD *a2, _QWORD *a3, int a4, int a5, int a6)
{
_DWORD *v8; // rax
void *v9; // r13
_DWORD *v10; // rdi
unsigned long long v11; // rbx
char *v12; // rbx
unsigned long long v13; // rbp
long long v14; // rbp
char *i; // r12
long long v16; // rsi
long long *v17; // r12
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x28],RDX
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x40],R8D
MOV dword ptr [RSP + 0x44],R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
MOV EAX,R9D
ADD EAX,0x1
CDQE
MOV qword ptr [RSP],RAX
SH... | /* func0(std::string const&, std::string const&, std::string const&, int, int, int) */
ulong func0(string *param_1,string *param_2,string *param_3,int param_4,int param_5,int param_6)
{
int4 *__s;
ulong uVar1;
ulong uVar2;
uint uVar3;
void *pvVar4;
long lVar5;
long lVar6;
int8 *puVar7;
ulong uVar8;
... |
2,987 | func0 | #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::string &X, const std::string &Y, const std::string &Z, int m, int n, int o) {
std::vector<std::vector<std::vector<int>>> L(m + 1, std::vector<std::vector<int>>(n + 1, std::vector<int>(o + 1)));
for (int i = 0; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
for (... | int main() {
assert(func0("AGGT12", "12TXAYB", "12XBA", 6, 7, 5) == 2);
assert(func0("Reels", "Reelsfor", "ReelsforReels", 5, 8, 13) == 5);
assert(func0("abcd1e2", "bc12ea", "bd1ea", 7, 6, 5) == 3);
std::cout << "All test cases passed." << std::endl;
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int, int, int):
endbr64
push %r15
mov %r9d,%e... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_S6_iii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_B0], rdx
mov dword ptr [rsp+0D8h+var_B8], ecx
mov [rsp+0D8h+var_80], r8d
mov [rsp+0D8h+var_7C], r9d
mov rax, fs... | long long func0(_QWORD *a1, _QWORD *a2, _QWORD *a3, int a4, int a5, int a6)
{
char *v8; // rax
char *v9; // r12
char *v10; // r13
char *v11; // r14
unsigned long long v12; // r12
void **v13; // rsi
void **v14; // rax
signed long long v15; // r14
void **v16; // rbx
char *v17; // rax
unsigned long ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x28],RDX
MOV dword ptr [RSP + 0x20],ECX
MOV dword ptr [RSP + 0x58],R8D
MOV dword ptr [RSP + 0x5c],R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
MOV EAX,R9D
ADD EAX,0x1
CDQE
MOV qword ptr [RSP + 0x10]... | /* func0(std::string const&, std::string const&, std::string const&, int, int, int) */
int4
func0(string *param_1,string *param_2,string *param_3,int param_4,int param_5,int param_6)
{
int4 *__s;
long *plVar1;
ulong uVar2;
vector *pvVar3;
char cVar4;
int iVar5;
int iVar6;
int4 uVar7;
long lVar8;
l... |
2,988 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &str1) {
std::regex pattern(R"((\w)([A-Z]))");
std::string replaced = std::regex_replace(str1, pattern, "$1 $2");
return replaced;
}
| int main() {
assert(func0("Python") == "Python");
assert(func0("PythonProgrammingExamples") == "Python Programming Examples");
assert(func0("GetReadyToBeCodingFreak") == "Get Ready To Be Coding Freak");
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, aWAZ; "(\\w)([A-Z])... | 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)([A-Z])", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_t... | 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,"(\\w)([A-Z])",0x10);
/* try { // try from 00104b84 to 00104b88 has its C... |
2,989 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &str1) {
std::regex pattern(R"((\w)([A-Z]))");
std::string replaced = std::regex_replace(str1, pattern, "$1 $2");
return replaced;
}
| int main() {
assert(func0("Python") == "Python");
assert(func0("PythonProgrammingExamples") == "Python Programming Examples");
assert(func0("GetReadyToBeCodingFreak") == "Get Ready To Be Coding Freak");
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,990 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &str1) {
std::regex pattern(R"((\w)([A-Z]))");
std::string replaced = std::regex_replace(str1, pattern, "$1 $2");
return replaced;
}
| int main() {
assert(func0("Python") == "Python");
assert(func0("PythonProgrammingExamples") == "Python Programming Examples");
assert(func0("GetReadyToBeCodingFreak") == "Get Ready To Be Coding Freak");
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,[0x11a676]
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,991 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &str1) {
std::regex pattern(R"((\w)([A-Z]))");
std::string replaced = std::regex_replace(str1, pattern, "$1 $2");
return replaced;
}
| int main() {
assert(func0("Python") == "Python");
assert(func0("PythonProgrammingExamples") == "Python Programming Examples");
assert(func0("GetReadyToBeCodingFreak") == "Get Ready To Be Coding Freak");
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
push r13
push r12
mov r12, rsi
push rbx
lea rbx, [rbp+var_E0]
sub rsp, 128h
mov [rbp+var_F8], rdi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea r... | long long * func0(long long a1, char **a2)
{
char *v2; // rbx
long long v3; // r13
char *v4; // r12
char v5; // al
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
unsigned long long v10; // rsi
long long v11; // rbx
volatile signed __int32 *v12; // rdx
signed __... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBX
LEA RBX,[RBP + -0xe0]
SUB RSP,0x128
MOV qword ptr [RBP + -0xf8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x138],RBX
MOV RDI,RAX
MOV qword ptr [RBP +... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *psVar1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
string sVar3;
int8 uVar4;
bool bVar5;
char cVar6;
int iVar7;
int8 *puVar8;
string *psVar9;
long lVar10;
ulong uVar11;
string *psVar12;
long *plVar13;
long lVar14;
... |
2,992 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<std::string> nums_str) {
std::vector<int> result;
for (auto& num : nums_str) {
result.push_back(std::stoi(num));
}
std::sort(result.begin(), result.end());
return result;
}
| int main() {
assert((func0({"4","12","45","7","0","100","200","-12","-500"}) == std::vector<int>{-500, -12, 0, 4, 7, 12, 45, 100, 200}));
assert((func0({"2","3","8","4","7","9","8","2","6","5","1","6","1","2","3","4","6","9","1","2"}) == std::vector<int>{1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9... | O0 | cpp | func0(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> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
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_48]
mov rdi, rax
call _ZNSt6ve... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+14h] [rbp-3Ch] BYREF
long long v6; // [rsp+18h] [rbp-38h] BYREF
_QWORD v7[2]; // [rsp+20h] [rbp-30h] BYREF
long long v8; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __r... | 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 + -0x48]
MOV RDI,RAX
CALL 0x00103098
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
MO... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
int8 uVar2;
int8 uVar3;
vector<std::string,std::allocator<std::string>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;... |
2,993 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<std::string> nums_str) {
std::vector<int> result;
for (auto& num : nums_str) {
result.push_back(std::stoi(num));
}
std::sort(result.begin(), result.end());
return result;
}
| int main() {
assert((func0({"4","12","45","7","0","100","200","-12","-500"}) == std::vector<int>{-500, -12, 0, 4, 7, 12, 45, 100, 200}));
assert((func0({"2","3","8","4","7","9","8","2","6","5","1","6","1","2","3","4","6","9","1","2"}) == std::vector<int>{1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9... | O1 | cpp | func0(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> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbx
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov... | char ** func0(char **a1, long long **a2)
{
long long *v3; // rbp
int *v4; // r12
char *v5; // rsi
long long v6; // r13
int v7; // r14d
long long v8; // rax
char *v9; // rbp
char *v10; // r13
int v11; // eax
unsigned long long v12; // rax
char *v13; // rdi
char *v14; // rsi
int v15; // ecx
ch... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [R... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<int,std::allocator<int>> *
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,int8 param_9)
{
int iVar1;
int iVar2;
long *plVar3;
int *piVar4;
long lVar5;
int *piVar6;
... |
2,994 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<std::string> nums_str) {
std::vector<int> result;
for (auto& num : nums_str) {
result.push_back(std::stoi(num));
}
std::sort(result.begin(), result.end());
return result;
}
| int main() {
assert((func0({"4","12","45","7","0","100","200","-12","-500"}) == std::vector<int>{-500, -12, 0, 4, 7, 12, 45, 100, 200}));
assert((func0({"2","3","8","4","7","9","8","2","6","5","1","6","1","2","3","4","6","9","1","2"}) == std::vector<int>{1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9... | O2 | cpp | func0(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> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov rax, [rsi+8]
... | char ** func0(char **a1, long long **a2)
{
long long *v2; // rbx
long long *v3; // rax
int *v4; // r12
long long v5; // r14
int v6; // r13d
long long v7; // rax
char *v8; // rsi
char *v9; // r13
char *v10; // r12
long long v11; // rdx
unsigned long long v12; // rax
char *v13; // rbx
int v14; /... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSP + 0x8]... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<int,std::allocator<int>> *
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,int8 param_9)
{
int iVar1;
long *plVar2;
int *piVar3;
int *piVar4;
int *piVar5;
long lVar6;
... |
2,995 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<std::string> nums_str) {
std::vector<int> result;
for (auto& num : nums_str) {
result.push_back(std::stoi(num));
}
std::sort(result.begin(), result.end());
return result;
}
| int main() {
assert((func0({"4","12","45","7","0","100","200","-12","-500"}) == std::vector<int>{-500, -12, 0, 4, 7, 12, 45, 100, 200}));
assert((func0({"2","3","8","4","7","9","8","2","6","5","1","6","1","2","3","4","6","9","1","2"}) == std::vector<int>{1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9... | O3 | cpp | func0(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> > > >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov rax, [rsi+8]
... | char ** func0(char **a1, long long **a2)
{
long long *v2; // rbx
long long *v3; // rax
int *v4; // r12
long long v5; // r14
int v6; // r13d
long long v7; // rax
char *v8; // rsi
char *v9; // r15
char *v10; // r12
char *v11; // rbx
unsigned long long v12; // rdx
char *v13; // r14
int v14; // r1... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSP + 0x8]... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<int,std::allocator<int>> *
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,int8 param_9)
{
int iVar1;
long *plVar2;
long lVar3;
int *piVar4;
int *piVar5;
int *piVar6;
... |
2,996 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_list, const std::vector<int>& test_tup) {
test_list.insert(test_list.end(), test_tup.begin(), test_tup.end());
return test_list;
}
| int main() {
assert((func0({5, 6, 7}, {9, 10}) == std::vector<int>{5, 6, 7, 9, 10}));
assert((func0({6, 7, 8}, {10, 11}) == std::vector<int>{6, 7, 8, 10, 11}));
assert((func0({7, 8, 9}, {11, 12}) == std::vector<int>{7, 8, 9, 11, 12}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x40,%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 -0x48(... | _Z5func0St6vectorIiSaIiEERKS1_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
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_48]
mov rdi, rax
call _ZNKSt6vectorIiSaI... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r12
long long v4; // rbx
long long v7; // [rsp+28h] [rbp-28h] BYREF
_QWORD v8[4]; // [rsp+30h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
v3 = std::vector<int>::end(a3);
v4 = std::vector<int>::begin(a3);
v7 = std::vector<i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
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 + -0x48]
MOV RDI,RAX
CALL 0x00101d22
MOV R12,RAX
MOV RAX,qword... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&) */
vector<int,std::allocator<int>> * func0(vector param_1,vector_conflict *param_2)
{
int8 uVar1;
int8 uVar2;
vector<int,std::allocator<int>> *in_RDX;
int4 in_register_0000003c;
long in_FS_OFFSET;
int8 local_30... |
2,997 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_list, const std::vector<int>& test_tup) {
test_list.insert(test_list.end(), test_tup.begin(), test_tup.end());
return test_list;
}
| int main() {
assert((func0({5, 6, 7}, {9, 10}) == std::vector<int>{5, 6, 7, 9, 10}));
assert((func0({6, 7, 8}, {10, 11}) == std::vector<int>{6, 7, 8, 10, 11}));
assert((func0({7, 8, 9}, {11, 12}) == std::vector<int>{7, 8, 9, 11, 12}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov 0x8(%rdx),%rcx
mov (%rdx),%rdx
mov 0x8(%rsi),%rsi
mov %rbx,%rdi
callq 18ae <_ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx1... | _Z5func0St6vectorIiSaIiEERKS1_:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
mov rcx, [rdx+8]
mov rsi, [rsi+8]
mov rdx, [rdx]
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(a2, a2[1], *a3, a3[1]);
*a1 = *a2;
a1[1] = a2[1];
a1[2] = a2[2];
a2[2] = 0LL;
a2[1] = 0LL;
*a2 = 0LL;
return a1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOV RCX,qword ptr [RDX + 0x8]
MOV RSI,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RDX]
MOV RDI,RBX
CALL 0x001018ca
MOV RAX,qword ptr [RBX]
MOV qword ptr [RBP],RAX
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RBP + 0x8],RAX
MOV RAX,qword ptr [RBX + 0x10]
... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&) */
int8 * func0(vector param_1,vector_conflict *param_2)
{
int8 *in_RDX;
int4 in_register_0000003c;
int8 *puVar1;
puVar1 = (int8 *)CONCAT44(in_register_0000003c,param_1);
std::vector<int,std::allocator<int>>::... |
2,998 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_list, const std::vector<int>& test_tup) {
test_list.insert(test_list.end(), test_tup.begin(), test_tup.end());
return test_list;
}
| int main() {
assert((func0({5, 6, 7}, {9, 10}) == std::vector<int>{5, 6, 7, 9, 10}));
assert((func0({6, 7, 8}, {10, 11}) == std::vector<int>{6, 7, 8, 10, 11}));
assert((func0({7, 8, 9}, {11, 12}) == std::vector<int>{7, 8, 9, 11, 12}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
mov %rbx,%rdi
sub $0x8,%rsp
mov 0x8(%rdx),%rcx
mov 0x8(%rsi),%rsi
mov (%rdx),%rdx
callq 18a0 <_ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx1... | _Z5func0St6vectorIiSaIiEERKS1_:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 18h
mov r14, [rdx+8]
mov rcx, [rdx]
mov r12, [rsi+8]
mov r13, [rsi]
mov r15, [rsi+10h]
cmp rcx, r14
jz short loc_1753
mov rax, r... | char ** func0(char **a1, char **a2, long long a3)
{
long long v5; // r14
_DWORD *v6; // rcx
char *v7; // r12
char *v8; // r13
char *v9; // r15
signed long long v10; // r14
char **result; // rax
signed long long v12; // r12
unsigned long long v13; // rsi
unsigned long long v14; // r15
unsigned long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x18
MOV R14,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RDX]
MOV R12,qword ptr [RSI + 0x8]
MOV R13,qword ptr [RSI]
MOV R15,qword ptr [RSI + 0x10]
CMP RCX,R14
JZ 0x00101753
MOV RAX,R15
SUB R14,RCX
SUB RAX,R12
CMP RAX,R14
J... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&) */
int8 * func0(int8 *param_1,int (*param_2) [16],int8 *param_3)
{
ulong uVar1;
int4 *__src;
ulong uVar2;
int4 *puVar3;
int4 *__dest;
int4 *__src_00;
int4 *puVar4;
ulong uVar5;
long lVar6;
int4 *local_4... |
2,999 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_list, const std::vector<int>& test_tup) {
test_list.insert(test_list.end(), test_tup.begin(), test_tup.end());
return test_list;
}
| int main() {
assert((func0({5, 6, 7}, {9, 10}) == std::vector<int>{5, 6, 7, 9, 10}));
assert((func0({6, 7, 8}, {10, 11}) == std::vector<int>{6, 7, 8, 10, 11}));
assert((func0({7, 8, 9}, {11, 12}) == std::vector<int>{7, 8, 9, 11, 12}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov 0x8(%rdx),%r14
mov (%rdx),%r9
mov 0x8(%rsi),%r15
mov (%rsi),%r13
mov 0x10(%... | _Z5func0St6vectorIiSaIiEERKS1_:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 18h
mov r12, [rdx+8]
mov r13, [rdx]
mov rbp, [rsi+8]
mov r14, [rsi+10h]
cmp r13, r12
jz short loc_174D
mov rax, r14
sub r12, r13... | char ** func0(char **a1, char **a2, long long a3)
{
long long v3; // r12
_DWORD *v4; // r13
char *v5; // rbp
char *v6; // r14
signed long long v7; // r12
char *v8; // r8
char **result; // rax
signed long long v10; // rbp
unsigned long long v11; // rcx
unsigned long long v12; // r14
unsigned long l... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x18
MOV R12,qword ptr [RDX + 0x8]
MOV R13,qword ptr [RDX]
MOV RBP,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI + 0x10]
CMP R13,R12
JZ 0x0010174d
MOV RAX,R14
SUB R12,R13
SUB RAX,RBP
CMP RAX,R12
JC 0x00101780
CMP R12,0x4... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > const&) */
int8 *
func0(int8 *param_1,int (*param_2) [16],int8 *param_3,int8 param_4,
int4 *param_5)
{
int4 *__src;
int4 *__src_00;
ulong uVar1;
ulong uVar2;
int4 *puVar3;
int4 *__dest;
int4 *__n;
ulong uVar4;... |
3,000 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& arr, int i) {
if (2 * i + 2 >= arr.size()) {
return true;
}
bool left_child = (arr[i] <= arr[2 * i + 1]) && func0(arr, 2 * i + 1);
bool right_child = (2 * i + 2 == arr.size()) || (arr[i] <= arr[2 * i + 2]
&& func0(ar... | int main() {
assert(func0({1, 2, 3, 4, 5, 6}, 0) == true);
assert(func0({2, 3, 4, 5, 10, 15}, 0) == true);
assert(func0({2, 10, 4, 5, 3, 15}, 0) == false);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
add $0x1,%eax
add %eax,%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 168c <_ZNKSt6vectorIiSa... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov eax, [rbp+var_2C]
add eax, 1
add eax, eax
movsxd rbx, eax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>... | _BOOL8 func0(long long a1, int a2)
{
int v3; // ebx
bool v4; // al
int v5; // ebx
bool v6; // al
bool v7; // [rsp+1Eh] [rbp-12h]
if ( 2 * (a2 + 1) >= (unsigned long long)std::vector<int>::size(a1) )
return 1LL;
v3 = *(_DWORD *)std::vector<int>::operator[](a1, a2);
v4 = v3 <= *(_DWORD *)std::vector... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
ADD EAX,EAX
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101708
CMP RBX,RAX
SETNC AL
TEST AL,AL
JZ 0x00101288
MOV EAX,0x1
JMP 0x001... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int8 func0(vector *param_1,int param_2)
{
int iVar1;
bool bVar2;
bool bVar3;
char cVar4;
ulong uVar5;
int *piVar6;
long lVar7;
int8 uVar8;
uVar5 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_1)... |
3,001 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& arr, int i) {
if (2 * i + 2 >= arr.size()) {
return true;
}
bool left_child = (arr[i] <= arr[2 * i + 1]) && func0(arr, 2 * i + 1);
bool right_child = (2 * i + 2 == arr.size()) || (arr[i] <= arr[2 * i + 2]
&& func0(ar... | int main() {
assert(func0({1, 2, 3, 4, 5, 6}, 0) == true);
assert(func0({2, 3, 4, 5, 10, 15}, 0) == true);
assert(func0({2, 10, 4, 5, 3, 15}, 0) == false);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
lea 0x2(%rsi,%rsi,1),%r12d
movslq %r12d,%r13
mov (%rdi),%rbp
mov 0x8(%rdi),%rdx
sub %rbp,%rdx
sar $0x2,%rdx
mov $0x1,%eax
cmp %rdx,%r13
jae ... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
lea r12d, [rsi+rsi+2]
movsxd r13, r12d
mov rbp, [rdi]
mov rdx, [rdi+8]
sub rdx, rbp
sar rdx, 2
mov eax, 1
cmp r13, rdx
jnb short loc_126A
mov rbx, rdi
movsxd ... | long long func0(long long *a1, int a2)
{
int v2; // r12d
long long v3; // rbp
long long result; // rax
int v5; // r15d
int v6; // r14d
unsigned int v7; // eax
v2 = 2 * a2 + 2;
v3 = *a1;
result = 1LL;
if ( v2 < (unsigned long long)((a1[1] - *a1) >> 2) )
{
v5 = *(_DWORD *)(v3 + 4LL * a2);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
LEA R12D,[RSI + RSI*0x1 + 0x2]
MOVSXD R13,R12D
MOV RBP,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
SUB RDX,RBP
SAR RDX,0x2
MOV EAX,0x1
CMP R13,RDX
JNC 0x0010126a
MOV RBX,RDI
MOVSXD RSI,ESI
MOV R15D,dword ptr [RBP + RSI*0x4]
LEA ESI,[R12 ... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
uint func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
uint uVar5;
uint uVar6;
iVar4 = param_2 * 2 + 2;
lVar3 = *(long *)param_1;
uVar5 = 1;
if ((ulong)(long)iVar4 < (ulong)(*(long *)(param_1 + 8) - ... |
3,002 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& arr, int i) {
if (2 * i + 2 >= arr.size()) {
return true;
}
bool left_child = (arr[i] <= arr[2 * i + 1]) && func0(arr, 2 * i + 1);
bool right_child = (2 * i + 2 == arr.size()) || (arr[i] <= arr[2 * i + 2]
&& func0(ar... | int main() {
assert(func0({1, 2, 3, 4, 5, 6}, 0) == true);
assert(func0({2, 3, 4, 5, 10, 15}, 0) == true);
assert(func0({2, 10, 4, 5, 3, 15}, 0) == false);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
mov $0x1,%eax
push %r14
push %r13
push %r12
lea 0x2(%rsi,%rsi,1),%r12d
push %rbp
movslq %r12d,%r13
push %rbx
sub $0x8,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rdx
sub %rbx,%rdx
sar $0x2,%rdx
cmp %rdx,%r13
jae ... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
mov eax, 1
push r14
push r13
push r12
lea r12d, [rsi+rsi+2]
push rbp
movsxd r13, r12d
push rbx
sub rsp, 8
mov rbp, [rdi]
mov rdx, [rdi+8]
sub rdx, rbp
sar rdx, 2
cmp r13, rdx
jnb short loc_13E8
movsxd rsi, esi
mov ... | long long func0(long long *a1, int a2)
{
long long result; // rax
int v3; // r12d
long long v4; // rbp
int v5; // r15d
int v6; // r14d
result = 1LL;
v3 = 2 * a2 + 2;
v4 = *a1;
if ( v3 < (unsigned long long)((a1[1] - *a1) >> 2) )
{
v5 = 0;
v6 = *(_DWORD *)(v4 + 4LL * a2);
if ( v6 > *(_D... | func0:
ENDBR64
PUSH R15
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
LEA R12D,[RSI + RSI*0x1 + 0x2]
PUSH RBP
MOVSXD R13,R12D
PUSH RBX
SUB RSP,0x8
MOV RBP,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
SUB RDX,RBP
SAR RDX,0x2
CMP R13,RDX
JNC 0x001013e8
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R15D,R15D
MOV R14D,dword ptr [RBP + RSI*0x4]... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
uint func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
uVar6 = 1;
iVar4 = param_2 * 2 + 2;
uVar7 = (ulong)iVar4;
lVar3 = *(long *)param_1;
if (uVar7 < (ulong)... |
3,003 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& arr, int i) {
if (2 * i + 2 >= arr.size()) {
return true;
}
bool left_child = (arr[i] <= arr[2 * i + 1]) && func0(arr, 2 * i + 1);
bool right_child = (2 * i + 2 == arr.size()) || (arr[i] <= arr[2 * i + 2]
&& func0(ar... | int main() {
assert(func0({1, 2, 3, 4, 5, 6}, 0) == true);
assert(func0({2, 3, 4, 5, 10, 15}, 0) == true);
assert(func0({2, 10, 4, 5, 3, 15}, 0) == false);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
mov $0x1,%eax
push %r14
push %r13
push %r12
lea 0x2(%rsi,%rsi,1),%r12d
push %rbp
movslq %r12d,%r13
push %rbx
sub $0x8,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rdx
sub %rbx,%rdx
sar $0x2,%rdx
cmp %rdx,%r13
jae ... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
mov eax, 1
push r14
push r13
push r12
lea r12d, [rsi+rsi+2]
push rbp
movsxd r13, r12d
push rbx
sub rsp, 8
mov rbp, [rdi]
mov rdx, [rdi+8]
sub rdx, rbp
sar rdx, 2
cmp r13, rdx
jnb short loc_13E8
movsxd rsi, esi
mov ... | long long func0(long long *a1, int a2)
{
long long result; // rax
int v3; // r12d
long long v4; // rbp
int v5; // r15d
int v6; // r14d
result = 1LL;
v3 = 2 * a2 + 2;
v4 = *a1;
if ( v3 < (unsigned long long)((a1[1] - *a1) >> 2) )
{
v5 = 0;
v6 = *(_DWORD *)(v4 + 4LL * a2);
if ( v6 > *(_D... | func0:
ENDBR64
PUSH R15
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
LEA R12D,[RSI + RSI*0x1 + 0x2]
PUSH RBP
MOVSXD R13,R12D
PUSH RBX
SUB RSP,0x8
MOV RBP,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
SUB RDX,RBP
SAR RDX,0x2
CMP R13,RDX
JNC 0x001013e8
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R15D,R15D
MOV R14D,dword ptr [RBP + RSI*0x4]... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
uint func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
uVar6 = 1;
iVar4 = param_2 * 2 + 2;
uVar7 = (ulong)iVar4;
lVar3 = *(long *)param_1;
if (uVar7 < (ulong)... |
3,004 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<int> dp(n + 1);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 11);
assert(func0(2) == 1);
assert(func0(4) == 5);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x35(%rbp),%rax
mov %rax,%rdi
callq 13e8 <_ZNSaIiEC1Ev>
mov -0x44(%rbp),%eax
add $0x1,%eax
movslq %eax,%rcx
lea -0x35(%rbp),%rdx
lea ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_3D]
mov [rbp+var_38], rax
nop
nop
mov eax, [rbp+var_44]
add eax, 1
movsxd rcx, eax
lea rdx, [rbp+var_3D]
lea ra... | long long func0(int a1)
{
int v1; // ebx
int v2; // ebx
unsigned int v3; // ebx
char v5; // [rsp+13h] [rbp-3Dh] BYREF
int i; // [rsp+14h] [rbp-3Ch]
char *v7; // [rsp+18h] [rbp-38h]
_BYTE v8[24]; // [rsp+20h] [rbp-30h] BYREF
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x3d]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
MOVSXD RCX,EAX
LEA RDX,[RBP + -0x3d]
LEA RAX,[RBP + ... | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
int4 *puVar4;
int *piVar5;
long in_FS_OFFSET;
allocator local_45;
int local_44;
allocator *local_40;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_... |
3,005 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<int> dp(n + 1);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 11);
assert(func0(2) == 1);
assert(func0(4) == 5);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
lea 0x1(%rdi),%ecx
movslq %ecx,%rcx
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rcx
ja 123d <_Z5func0i+0x94>
mov %edi,%ebp
test %rcx,%rcx
je 1249 <_Z5func0i+0xa0>
lea 0x0(,%rcx,4),%rbx
mov %rbx,%rdi
callq 10b0 <_Znwm@plt>
mov %rax,%... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
lea r12d, [rdi+1]
movsxd r12, r12d
mov rax, r12
shr rax, 3Dh
jnz loc_124E
mov ebx, edi
test r12, r12
jz loc_125A
lea rbp, ds:0[r12*4]
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
cm... | long long func0(int a1)
{
unsigned long long v1; // r12
unsigned long long v3; // rbp
_DWORD *v4; // rax
_DWORD *v5; // rdi
_DWORD *v6; // rax
_DWORD *i; // rdx
_DWORD *v8; // rdx
unsigned int v9; // ebx
v1 = a1 + 1;
if ( v1 >> 61 )
std::__throw_length_error("cannot create std::vector larger t... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
LEA R12D,[RDI + 0x1]
MOVSXD R12,R12D
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x0010124e
MOV EBX,EDI
TEST R12,R12
JZ 0x0010125a
LEA RBP,[R12*0x4]
MOV RDI,RBP
CALL 0x001010a0
MOV RDI,RAX
CMP R12,0x1
JZ 0x00101271
LEA RAX,[RAX + RBP*0x1]
LEA RDX,[RDI + 0x4]
CMP RDX,RAX
JZ 0x00101209
LAB_0010... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int *piVar2;
int *piVar3;
int unaff_EBX;
ulong uVar4;
ulong uVar5;
uVar5 = (ulong)(param_1 + 1);
if (uVar5 >> 0x3d == 0) {
if (uVar5 == 0) goto LAB_0010125a;
uVar4 = uVar5 * 4;
piVar2 = (int *)operator_new(uVar4);
if (uVar5 != 1) ... |
3,006 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<int> dp(n + 1);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 11);
assert(func0(2) == 1);
assert(func0(4) == 5);
return 0;
}
| O2 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rdx
lea 0x1(%rdi),%eax
push %r12
cltq
push %rbp
push %rbx
cmp %rdx,%rax
ja 1305 <_Z5func0i+0xb5>
test %rax,%rax
je 12f8 <_Z5func0i+0xa8>
lea 0x0(,%rax,4),%rbx
mov %edi,%ebp
mov %rbx,%rdi
callq 10b0 <_Znwm@plt>
mov %rax,%rdi
lea (%rax,... | _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
lea ebx, [rdi+1]
movsxd rbx, ebx
mov rax, rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_134E
test rbx, rbx
jz loc_1330
lea r13, ds:0[rbx*4]
mov r12d, edi
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
m... | long long func0(int a1)
{
unsigned long long v1; // rbx
long long v2; // r13
_DWORD *v3; // rax
_DWORD *v4; // rbp
_DWORD *v5; // rdx
int v6; // ecx
int v7; // eax
int v8; // esi
unsigned long long v9; // rsi
unsigned int v10; // ebx
v1 = a1 + 1;
if ( v1 >> 61 )
std::__throw_length_error("... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA EBX,[RDI + 0x1]
MOVSXD RBX,EBX
MOV RAX,RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x0010134e
TEST RBX,RBX
JZ 0x00101330
LEA R13,[RBX*0x4]
MOV R12D,EDI
MOV RDI,R13
CALL 0x001010c0
MOV dword ptr [RAX],0x0
MOV RBP,RAX
CMP RBX,0x1
JZ 0x00101340
LEA RDI,[RAX + 0x4]
LEA RAX,[RAX +... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
code *pcVar2;
int iVar3;
int iVar4;
int4 *puVar5;
int iVar6;
int *piVar7;
int *piVar8;
ulong uVar9;... |
3,007 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<int> dp(n + 1);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + 2 * dp[i - 2];
}
return dp[n];
}
| int main() {
assert(func0(5) == 11);
assert(func0(2) == 1);
assert(func0(4) == 5);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rdx
lea 0x1(%rdi),%eax
push %r12
cltq
push %rbp
push %rbx
cmp %rdx,%rax
ja 1344 <_Z5func0i+0xd4>
test %rax,%rax
je 1330 <_Z5func0i+0xc0>
lea 0x0(,%rax,4),%rbp
mov %edi,%ebx
mov %rbp,%rdi
callq 10d0 <_Znwm@plt>
mov %rbp,%rdx
xor %esi,%... | _Z5func0i:
endbr64
push r13
push r12
lea r12d, [rdi+1]
push rbp
movsxd r12, r12d
push rbx
mov rax, r12
sub rsp, 8
shr rax, 3Dh
jnz loc_137D
test r12, r12
jz loc_1358
lea r13, ds:0[r12*4]
mov ebp, edi
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
... | long long func0(int a1)
{
unsigned long long v1; // r12
long long v2; // r13
_DWORD *v3; // rax
_DWORD *v4; // rbx
long long v5; // rdx
int v6; // esi
int v7; // ecx
long long v8; // rax
unsigned long long v9; // rsi
unsigned int v10; // ebp
v1 = a1 + 1;
if ( v1 >> 61 )
std::__throw_length... | func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
MOVSXD R12,R12D
PUSH RBX
MOV RAX,R12
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x0010137d
TEST R12,R12
JZ 0x00101358
LEA R13,[R12*0x4]
MOV EBP,EDI
MOV RDI,R13
CALL 0x001010c0
MOV dword ptr [RAX],0x0
MOV RBX,RAX
CMP R12,0x1
JZ 0x00101368
LEA RDI,[RAX + 0x4]
LEA RAX,[RAX ... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
code *pcVar2;
int iVar3;
int4 *puVar4;
int iVar5;
long lVar6;
int iVar7;
ulong uVar8;
ulong uVar9;
... |
3,008 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(vector<pair<string, int>>& test_list, int K) {
sort(test_list.begin(), test_list.end(), [](const pair<string, int>& a, const pair<string, int>& b) {
return a.second < b.second;
});
vector<pair<string, int>> res(test_list.begin(), test_list.begin() + K);
retur... | int main() {
vector<pair<string, int>> test1 {{"Manjeet", 10}, {"Akshat", 4}, {"Akash", 2}, {"Nikhil", 8}};
vector<pair<string, int>> expected1 {{"Akash", 2}, {"Akshat", 4}};
assert(func0(test1, 2) == expected1);
vector<pair<string, int>> test2 {{"Sanjeev", 11}, {"Angat", 5}, {"Akash", 3}, {"N... | 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> > >&, int)::{lambda(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | ||||
3,009 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(vector<pair<string, int>>& test_list, int K) {
sort(test_list.begin(), test_list.end(), [](const pair<string, int>& a, const pair<string, int>& b) {
return a.second < b.second;
});
vector<pair<string, int>> res(test_list.begin(), test_list.begin() + K);
retur... | int main() {
vector<pair<string, int>> test1 {{"Manjeet", 10}, {"Akshat", 4}, {"Akash", 2}, {"Nikhil", 8}};
vector<pair<string, int>> expected1 {{"Akash", 2}, {"Akshat", 4}};
assert(func0(test1, 2) == expected1);
vector<pair<string, int>> test2 {{"Sanjeev", 11}, {"Angat", 5}, {"Akash", 3}, {"N... | O1 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, 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, st... | ||||
3,010 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(vector<pair<string, int>>& test_list, int K) {
sort(test_list.begin(), test_list.end(), [](const pair<string, int>& a, const pair<string, int>& b) {
return a.second < b.second;
});
vector<pair<string, int>> res(test_list.begin(), test_list.begin() + K);
retur... | int main() {
vector<pair<string, int>> test1 {{"Manjeet", 10}, {"Akshat", 4}, {"Akash", 2}, {"Nikhil", 8}};
vector<pair<string, int>> expected1 {{"Akash", 2}, {"Akshat", 4}};
assert(func0(test1, 2) == expected1);
vector<pair<string, int>> test2 {{"Sanjeev", 11}, {"Angat", 5}, {"Akash", 3}, {"N... | O2 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | ||||
3,011 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(vector<pair<string, int>>& test_list, int K) {
sort(test_list.begin(), test_list.end(), [](const pair<string, int>& a, const pair<string, int>& b) {
return a.second < b.second;
});
vector<pair<string, int>> res(test_list.begin(), test_list.begin() + K);
retur... | int main() {
vector<pair<string, int>> test1 {{"Manjeet", 10}, {"Akshat", 4}, {"Akash", 2}, {"Nikhil", 8}};
vector<pair<string, int>> expected1 {{"Akash", 2}, {"Akshat", 4}};
assert(func0(test1, 2) == expected1);
vector<pair<string, int>> test2 {{"Sanjeev", 11}, {"Angat", 5}, {"Akash", 3}, {"N... | O3 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | ||||
3,012 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& l1, const std::vector<int>& l2, const std::vector<int>& l3) {
std::vector<int> result;
size_t size = l1.size();
for (size_t i = 0; i < size; ++i) {
if (l1[i] == l2[i] && l2[i] == l3[i]) {
result.push_back(l1[i]);
}
}
... | int main() {
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2, 3, 4, 5, 7}) == std::vector<int>{1, 7}));
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 6, 5}, {0, 1, 2, 3, 4, 6, 7}) == std::vector<int>{1, 6}));
assert((func0({1, 1, 3, 4, 6, 5, 6}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, 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 %rcx,-0x50(%rbp)
mov %f... | _Z5func0RKSt6vectorIiSaIiEES3_S3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov ... | long long func0(long long a1, long long a2, long long a3, long long a4)
{
int v4; // ebx
int v5; // ebx
long long v7; // rax
unsigned long long i; // [rsp+20h] [rbp-20h]
unsigned long long v12; // [rsp+28h] [rbp-18h]
std::vector<int>::vector(a1);
v12 = std::vector<int>::size(a2);
for ( i = 0LL; i < v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101fec
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001020ea
MOV qword ptr ... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1,vector *param_2,vector *param_3)
{
int iVar1;
bool bVar2;
ulong uVar3;
int *piVar4;
vector<int,std::allocator<int>> *in_R... |
3,013 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& l1, const std::vector<int>& l2, const std::vector<int>& l3) {
std::vector<int> result;
size_t size = l1.size();
for (size_t i = 0; i < size; ++i) {
if (l1[i] == l2[i] && l2[i] == l3[i]) {
result.push_back(l1[i]);
}
}
... | int main() {
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2, 3, 4, 5, 7}) == std::vector<int>{1, 7}));
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 6, 5}, {0, 1, 2, 3, 4, 6, 7}) == std::vector<int>{1, 6}));
assert((func0({1, 1, 3, 4, 6, 5, 6}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(... | _Z5func0RKSt6vectorIiSaIiEES3_S3_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
mov r12, rdx
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rax, [rsi+8]
mov rdx, [rsi]
mov r13, rax
sub r13,... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3, _QWORD *a4)
{
unsigned long long v5; // r13
unsigned long long v8; // rbx
int v9; // edx
int v10; // eax
_DWORD *v11; // rsi
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v5 = (long long)(a2[1] - *a2) >> 2;
if ( *a2 != a2[1] )
{
v8 = 0LL;
do
{... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
MOV R12,RDX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV R13,RAX
SUB R13,RDX
SAR R13,0x2
CMP RDX,RAX
JZ 0x001012f6
MOV RBP,RSI
MO... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1,vector *param_2,vector *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
long lVar4;
long lVar5;
int *piVar6;
long *in_R... |
3,014 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& l1, const std::vector<int>& l2, const std::vector<int>& l3) {
std::vector<int> result;
size_t size = l1.size();
for (size_t i = 0; i < size; ++i) {
if (l1[i] == l2[i] && l2[i] == l3[i]) {
result.push_back(l1[i]);
}
}
... | int main() {
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2, 3, 4, 5, 7}) == std::vector<int>{1, 7}));
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 6, 5}, {0, 1, 2, 3, 4, 6, 7}) == std::vector<int>{1, 6}));
assert((func0({1, 1, 3, 4, 6, 5, 6}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(... | _Z5func0RKSt6vectorIiSaIiEES3_S3_:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
mov r12, rdx
push rbp
push rbx
sub rsp, 8
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi+8]
mov rax, [rsi]
mov qword ptr [rdi+10h], 0
mov r13, rdx
sub r13, rax
... | long long func0(long long a1, long long *a2, _QWORD *a3, _QWORD *a4)
{
long long v5; // rdx
long long v6; // rax
unsigned long long v7; // r13
unsigned long long v10; // rbx
int v11; // eax
_DWORD *v12; // rsi
*(_OWORD *)a1 = 0LL;
v5 = a2[1];
v6 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
v7 = (v5 - v6) ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOV R13,RDX
SUB R13,RAX
SAR R13,0x2
CMP RAX,RDX
JZ 0x00101931
MOV RBP,RSI
MOV R15,RCX... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1,vector *param_2,vector *param_3)
{
int *piVar1;
int iVar2;
int *piVar3;
long lVar4;
long *in_RCX;
long lVar5;
long lV... |
3,015 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& l1, const std::vector<int>& l2, const std::vector<int>& l3) {
std::vector<int> result;
size_t size = l1.size();
for (size_t i = 0; i < size; ++i) {
if (l1[i] == l2[i] && l2[i] == l3[i]) {
result.push_back(l1[i]);
}
}
... | int main() {
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2, 3, 4, 5, 7}) == std::vector<int>{1, 7}));
assert((func0({1, 1, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 6, 5}, {0, 1, 2, 3, 4, 6, 7}) == std::vector<int>{1, 6}));
assert((func0({1, 1, 3, 4, 6, 5, 6}, {0, 1, 2, 3, 4, 5, 7}, {0, 1, 2... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%r... | _Z5func0RKSt6vectorIiSaIiEES3_S3_:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
mov r12, rdx
push rbp
push rbx
sub rsp, 8
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi+8]
mov rax, [rsi]
mov qword ptr [rdi+10h], 0
mov r13, rdx
sub r13, rax
... | long long func0(long long a1, long long *a2, _QWORD *a3, _QWORD *a4)
{
long long v5; // rdx
long long v6; // rax
unsigned long long v7; // r13
unsigned long long v10; // rbx
int v11; // eax
_DWORD *v12; // rsi
*(_OWORD *)a1 = 0LL;
v5 = a2[1];
v6 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
v7 = (v5 - v6) ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOV R13,RDX
SUB R13,RAX
SAR R13,0x2
CMP RAX,RDX
JZ 0x001019a1
MOV RBP,RSI
MOV R15,RCX... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1,vector *param_2,vector *param_3)
{
int *piVar1;
int iVar2;
int *piVar3;
long lVar4;
long *in_RCX;
long lVar5;
long lV... |
3,016 | func0 |
#include <iostream>
#include <vector>
#include <set>
#include <cassert>
#include <algorithm>
| double func0(const std::vector<double>& numbers) {
if (numbers.size() < 2) {
return -1; // Using -1 to indicate None
}
if (numbers.size() == 2 && numbers[0] == numbers[1]) {
return -1; // Using -1 to indicate None
}
std::set<double> dup_items;
std::vector<double> uniq... | int main() {
assert(func0({1, 2, -8, -2, 0, -2}) == -2);
assert(func0({1, 1, -0.5, 0, 2, -2, -2}) == -0.5);
assert(func0({2, 2}) == -1); // Using -1 to indicate None
return 0;
}
| O0 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,-0xa8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0xa8(%rbp),%rax
mov %rax,%rdi
callq 1b76 <_ZNKSt6vectorIdSaIdEE4sizeEv>
cmp $0x1,%rax
setbe ... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_A8]
mov rdi, rax
call _ZNKSt6vectorIdSaIdEE4sizeEv; std::vector<double>::size(void)
cmp rax, 1
setbe ... | unsigned long long func0(long long a1)
{
long long v2; // rbx
long long v3; // rax
double v5; // [rsp+0h] [rbp-B0h]
long long v6; // [rsp+10h] [rbp-A0h] BYREF
long long v7; // [rsp+18h] [rbp-98h] BYREF
long long v8; // [rsp+20h] [rbp-90h] BYREF
long long v9; // [rsp+28h] [rbp-88h] BYREF
_QWORD v10[2]; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,RAX
CALL 0x00101afe
CMP RAX,0x1
SETBE AL
TEST AL,AL
JZ 0x001012de
MOVSD XMM2,qword ptr [0x001060f8]
MOVSD qword ptr [R... | /* func0(std::vector<double, std::allocator<double> > const&) */
void func0(vector *param_1)
{
double dVar1;
char cVar2;
bool bVar3;
ulong uVar4;
long lVar5;
double *pdVar6;
int8 uVar7;
int8 uVar8;
int8 *puVar9;
long in_FS_OFFSET;
int8 local_b8;
double local_a8;
int8 local_a0;
int8 local_9... |
3,017 | func0 |
#include <iostream>
#include <vector>
#include <set>
#include <cassert>
#include <algorithm>
| double func0(const std::vector<double>& numbers) {
if (numbers.size() < 2) {
return -1; // Using -1 to indicate None
}
if (numbers.size() == 2 && numbers[0] == numbers[1]) {
return -1; // Using -1 to indicate None
}
std::set<double> dup_items;
std::vector<double> uniq... | int main() {
assert(func0({1, 2, -8, -2, 0, -2}) == -2);
assert(func0({1, 1, -0.5, 0, 2, -2, -2}) == -0.5);
assert(func0({2, 2}) == -1); // Using -1 to indicate None
return 0;
}
| O1 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov 0x8(%rdi),%rbp
mov (%rdi),%rbx
mov %rbp,%rax
sub %rbx,%rax
cmp $0xf,%rax
jbe 14a3 <_Z5func0RKSt6vectorIdSaIdEE+0x1f... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 70h
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
mov rbp, [rdi+8]
mov rbx, [rdi]
mov rax, rbp
sub rax, rbx
cmp rax, 8
jbe loc_1475
cmp rax, 10h
jz short loc_12F6
loc_12A2:
mov ... | double func0(double **a1)
{
double *v1; // rbp
double *v2; // rbx
unsigned long long v3; // rax
double v4; // rbp
long long v5; // rax
double *v6; // rdx
double v7; // xmm0_8
double *v8; // rbp
double *v9; // rbx
long long v10; // r12
int v11; // eax
unsigned long long v12; // rax
double *v13... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RBP,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV RAX,RBP
SUB RAX,RBX
CMP RAX,0x8
JBE 0x00101475
CMP RAX,0x10
JZ 0x001012f6
LAB_001012a2:
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RS... | /* func0(std::vector<double, std::allocator<double> > const&) */
double 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,
int8 param_10,int1 param_11,int8 param_12,int8 param_13)
{
double dVar1;
double *pdVar2;
long lV... |
3,018 | func0 |
#include <iostream>
#include <vector>
#include <set>
#include <cassert>
#include <algorithm>
| double func0(const std::vector<double>& numbers) {
if (numbers.size() < 2) {
return -1; // Using -1 to indicate None
}
if (numbers.size() == 2 && numbers[0] == numbers[1]) {
return -1; // Using -1 to indicate None
}
std::set<double> dup_items;
std::vector<double> uniq... | int main() {
assert(func0({1, 2, -8, -2, 0, -2}) == -2);
assert(func0({1, 1, -0.5, 0, 2, -2, -2}) == -0.5);
assert(func0({2, 2}) == -1); // Using -1 to indicate None
return 0;
}
| O2 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbx
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov %r12,%rax
sub %rbx,%rax
cmp $0xf,%rax
jbe 17... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, [rdi+8]
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov rax, r12
sub rax, rbx
cmp rax, 8
jbe loc_1CC6
cmp rax, 10h
jz ... | double func0(double **a1)
{
double *v1; // r12
double *v2; // rbx
double *v3; // rsi
double *v4; // r14
double *i; // rax
double v6; // xmm0_8
double *v7; // rdx
double *v8; // r12
unsigned long long v9; // rbx
long long v10; // rdx
long long v11; // rbp
unsigned long long v12; // rax
double ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RAX,R12
SUB RAX,RBX
CMP RAX,0x8
JBE 0x00101cc6
CMP RAX,0x10
JZ 0x00101cb1
LAB_00101ac3:
LEA RBP,[RSP + 0x38]
... | /* func0(std::vector<double, std::allocator<double> > const&) */
double 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,int8 param_11,int8 param_12)
{
long *plVar1;
double dVar2;
int4 *puVar3;
ulong uV... |
3,019 | func0 |
#include <iostream>
#include <vector>
#include <set>
#include <cassert>
#include <algorithm>
| double func0(const std::vector<double>& numbers) {
if (numbers.size() < 2) {
return -1; // Using -1 to indicate None
}
if (numbers.size() == 2 && numbers[0] == numbers[1]) {
return -1; // Using -1 to indicate None
}
std::set<double> dup_items;
std::vector<double> uniq... | int main() {
assert(func0({1, 2, -8, -2, 0, -2}) == -2);
assert(func0({1, 1, -0.5, 0, 2, -2, -2}) == -0.5);
assert(func0({2, 2}) == -1); // Using -1 to indicate None
return 0;
}
| O3 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbx
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov %r12,%rax
sub %rbx,%rax
cmp $0xf,%rax
jbe 18... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov r12, [rdi+8]
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov rax, r12
sub rax, rbx
cmp rax, 8
jbe loc_1C6D
cmp rax, 10h
jz ... | double func0(double **a1)
{
double *v1; // r12
double *v2; // rbx
double *v3; // rsi
double *v4; // r14
double *i; // rax
double v6; // xmm0_8
double *v7; // rdx
double *v8; // r12
unsigned long long v9; // rbx
double *v10; // rbp
long long v11; // r13
unsigned long long v12; // rdx
double *v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV RAX,R12
SUB RAX,RBX
CMP RAX,0x8
JBE 0x00101c6d
CMP RAX,0x10
JZ 0x00101c58
LAB_001019d6:
LEA RBP,[RSP + 0x48]
... | /* func0(std::vector<double, std::allocator<double> > const&) */
double func0(vector *param_1,int param_2,int param_3,int param_4,int param_5
,int param_6,int8 param_7,int param_8,int param_9,
int param_10,int8 param_11,int8 param_12)
{
long *plVar1;
long lVar2;
int4 *puVar3;
ulong uVa... |
3,020 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text) {
std::regex pattern("ab?");
if (std::regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
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 $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%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, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aAb; "ab?"
mov ... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+1Fh] [rbp-51h] BYREF
char *v4; // [rsp+20h] [rbp-50h]
char *v5; // [rsp+28h] [rbp-48h]
_BYTE v6[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+58h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_trait... | 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
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x132051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b43:
CALL 0x001061ba
LEA RCX,[RBP + -0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
string *in_RSI;
long in_FS_OFFSET;
allocator local_59;
allocator *local_58;
allocator *local_50;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"ab?",0x... |
3,021 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text) {
std::regex pattern("ab?");
if (std::regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
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 $0x58,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZN... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_70]
lea rdi, [rbp+var_68]; this
call __Z... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x70]
LEA RDI,[RBP + -0x68]
CALL 0x001046f0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],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;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int8 local_68;
_Sp_counted_base<(_Lock_policy)2> *lo... | |
3,022 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text) {
std::regex pattern("ab?");
if (std::regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
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 $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_70]
push r12
lea r12, [rbp+var_68]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_28], rax... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
long long v4; // rsi
long long v5; // rsi
char v6; // r13
long long v7; // rdi
long long v8; // rdx
volatile signed __int32 *v9; // rcx
signed __int32 v10; // eax
long long v12; // rax
_BYTE v13[8]; // [rsp+0h] [rbp-70h] BYREF
_B... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x70]
PUSH R12
LEA R12,[RBP + -0x68]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001036d0
LEA RDX,[0x118626]
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;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int local_68 [16];
int local_58 [16];
int local_48 [16];
long local_30;
lo... |
3,023 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string& text) {
std::regex pattern("ab?");
if (std::regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
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 $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 2B8h
mov rax, fs:28h
mov [rsp+2E8h+var_40], rax
xor eax, eax
lea r14, [rsp+2E8h+var_2A0]
mov rdi, r14; this
c... | long long func0(long long a1, unsigned long long *a2)
{
__m128i v3; // xmm0
long long v4; // rdi
void *v5; // rdi
void **v6; // rbp
unsigned long long v7; // r12
void *v8; // rdi
unsigned long long v9; // r13
unsigned long long v10; // rbp
long long v11; // rax
long long v12; // rcx
unsigned long... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x2b8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2a8],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x00104730
LEA RDX,[0x11a66b]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RD... | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong uVar1;
int8 uVar2;
ulong uVar3;
int auVar4 [16];
bool bVar5;
char cVar6;
long lVar7;
int8 *puVar8;
int8 *puVar9;
ulong uVar10;
ulong *puVar11;
long lVar12;
ulong uVar13;
ulong *in_RSI;
uint *puVar14;
_Match_mode _V... |
3,024 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
| std::string func0(const std::vector<std::string>& test_list) {
int res = 0;
for (int idx = 0; idx < test_list.size(); ++idx) {
for (int idxn = idx; idxn < test_list.size(); ++idxn) {
std::string reversed_str = test_list[idx];
std::reverse(reversed_str.begin(), reversed_str.e... | int main() {
assert(func0({"julia", "best", "tseb", "for", "ailuj"}) == "2");
assert(func0({"geeks", "best", "for", "skeeg"}) == "1");
assert(func0({"makes", "best", "sekam", "for", "rof"}) == "2");
return 0;
}
| O0 | cpp | func0(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> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_4C], 0
mov [rbp+var_48], 0
jmp l... | std::__cxx11 * func0(std::__cxx11 *a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
long long v5; // rax
int v7; // [rsp+14h] [rbp-4Ch]
int i; // [rsp+18h] [rbp-48h]
int j; // [rsp+1Ch] [rbp-44h]
_BYTE v10[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v11; // [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x4c],0x0
MOV dword ptr [RBP + -0x48],0x0
JMP 0x001025fb
LAB_00102540:
MOV EAX,dword ptr [RBP + -0x48]
M... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
string *psVar3;
ulong uVar4;
vector<std::string,std::allocator<std::string>> *in_RSI;
long in_FS_OFFSET;
int local_50;
int local_4c;
string ... |
3,025 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
| std::string func0(const std::vector<std::string>& test_list) {
int res = 0;
for (int idx = 0; idx < test_list.size(); ++idx) {
for (int idxn = idx; idxn < test_list.size(); ++idxn) {
std::string reversed_str = test_list[idx];
std::reverse(reversed_str.begin(), reversed_str.e... | int main() {
assert(func0({"julia", "best", "tseb", "for", "ailuj"}) == "2");
assert(func0({"geeks", "best", "for", "skeeg"}) == "1");
assert(func0({"makes", "best", "sekam", "for", "rof"}) == "2");
return 0;
}
| O1 | cpp | func0(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> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,0x8... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov [rsp+168h+var_150], rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
mov [rsp+168h+var_1... | _QWORD * func0(_QWORD *a1, long long *a2)
{
_QWORD *v2; // rdi
char *v3; // rdx
char *v4; // rax
char v5; // cl
long long v6; // rax
size_t v7; // rdx
long long v8; // rax
unsigned long long v9; // rbp
long long v10; // rax
_BYTE *v11; // r14
size_t v12; // rbx
unsigned int v13; // ebp
unsigne... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV qword ptr [RSP + 0x18],RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV dword ptr [RSP + 0xc],0x0
LEA R13,[RSP + 0x40]
MOV RAX,qword ptr [RSI]
CMP qword ptr [R... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int uVar1;
size_t __n;
int *__src;
ulong __n_00;
int iVar2;
size_t *psVar3;
int8 *puVar4;
char *pcVar5;
uint uVar6;
size_t *psVar7;
ulong uVar8;
uint uVar9;
char cVar10;
uint uVar1... |
3,026 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
| std::string func0(const std::vector<std::string>& test_list) {
int res = 0;
for (int idx = 0; idx < test_list.size(); ++idx) {
for (int idxn = idx; idxn < test_list.size(); ++idxn) {
std::string reversed_str = test_list[idx];
std::reverse(reversed_str.begin(), reversed_str.e... | int main() {
assert(func0({"julia", "best", "tseb", "for", "ailuj"}) == "2");
assert(func0({"geeks", "best", "for", "skeeg"}) == "1");
assert(func0({"makes", "best", "sekam", "for", "rof"}) == "2");
return 0;
}
| O2 | cpp | func0(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> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov (%rsi),%... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
xor r13d, r13d
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 148h
mov rdx, [rsi+8]
mov r15, [rsi]
mov [rsp+178h+var_150], rdi
mov rax, fs:28h
mov [r... | long long * func0(long long *a1, long long *a2)
{
long long v2; // r13
unsigned int v3; // r12d
long long v4; // rdx
long long v5; // r15
int v6; // eax
unsigned long long v8; // rax
unsigned long long v9; // r14
long long v10; // r13
_BYTE **v11; // r9
size_t v12; // r15
_BYTE *v13; // r10
_QWO... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
XOR R13D,R13D
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x148
MOV RDX,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI]
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x138],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],0x0
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
uint uVar1;
int uVar2;
int *__src;
ulong *puVar3;
int iVar4;
ulong uVar5;
ulong *puVar6;
ulong *puVar7;
i... |
3,027 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
| std::string func0(const std::vector<std::string>& test_list) {
int res = 0;
for (int idx = 0; idx < test_list.size(); ++idx) {
for (int idxn = idx; idxn < test_list.size(); ++idxn) {
std::string reversed_str = test_list[idx];
std::reverse(reversed_str.begin(), reversed_str.e... | int main() {
assert(func0({"julia", "best", "tseb", "for", "ailuj"}) == "2");
assert(func0({"geeks", "best", "for", "skeeg"}) == "1");
assert(func0({"makes", "best", "sekam", "for", "rof"}) == "2");
return 0;
}
| O3 | cpp | func0(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> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rsi),%... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
mov ecx, 1
push r14
push r13
xor r13d, r13d
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 148h
mov rdx, [rsi+8]
mov r15, [rsi]
mov [rsp+178h+var_150], rdi
mov rax, fs... | long long * func0(long long *a1, long long *a2)
{
long long v2; // rcx
long long v3; // r13
unsigned int v4; // r12d
long long v5; // rdx
long long v6; // r15
unsigned long long v8; // rax
unsigned long long v9; // r14
long long v10; // r13
_BYTE **v11; // r9
size_t v12; // r15
_BYTE *v13; // r10
... | func0:
ENDBR64
PUSH R15
MOV ECX,0x1
PUSH R14
PUSH R13
XOR R13D,R13D
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x148
MOV RDX,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI]
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x138],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
uint uVar1;
int uVar2;
int *__src;
ulong *puVar3;
int iVar4;
ulong uVar5;
ulong *puVar6;
ulong *puVar7;
i... |
3,028 | func0 |
#include <vector>
#include <map>
#include <tuple>
#include <cassert>
using namespace std;
| map<vector<int>, int> func0(vector<vector<int>> list1) {
map<vector<int>, int> result;
for (auto& l : list1) {
if (result.find(l) == result.end()) {
result[l] = 0;
}
result[l]++;
}
return result;
}
| int main() {
assert((func0({{1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11}}) ==
map<vector<int>, int>{{{1, 3}, 2}, {{5, 7}, 2}, {{13, 15, 17}, 1}, {{9, 11}, 1}}));
assert((func0({{10, 20, 30, 40}, {60, 70, 50, 50}, {90, 100, 200}}) ==
map<vector<int>, int>{{{10, 20, 30, ... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
m... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt3mapISt6vectorIiSaIiEEiSt4lessIS2_ESaISt4pair... | long long func0(long long a1, long long a2)
{
_DWORD *v2; // rax
long long v4; // [rsp+18h] [rbp-48h] BYREF
long long v5; // [rsp+20h] [rbp-40h] BYREF
long long v6; // [rsp+28h] [rbp-38h] BYREF
_QWORD v7[2]; // [rsp+30h] [rbp-30h] BYREF
long long v8; // [rsp+40h] [rbp-20h]
unsigned long long v9; // [rsp+... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
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 0x001025ee
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x28],RAX
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
map<std::vector<int,std::allocator<int>>,int,std::less<std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::vector<int,std::allocator<int>>const,int>>>
* func0(vector param_1)
{... |
3,029 | func0 |
#include <vector>
#include <map>
#include <tuple>
#include <cassert>
using namespace std;
| map<vector<int>, int> func0(vector<vector<int>> list1) {
map<vector<int>, int> result;
for (auto& l : list1) {
if (result.find(l) == result.end()) {
result[l] = 0;
}
result[l]++;
}
return result;
}
| int main() {
assert((func0({{1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11}}) ==
map<vector<int>, int>{{{1, 3}, 2}, {{5, 7}, 2}, {{13, 15, 17}, 1}, {{9, 11}, 1}}));
assert((func0({{10, 20, 30, 40}, {60, 70, 50, 50}, {90, 100, 200}}) ==
map<vector<int>, int>{{{10, 20, 30, ... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r14
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movl $0x0,0x8(%rdi)
movq... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r12, rdi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea r13, [rdi+8]
mov [rdi+18h], r... | long long func0(long long a1, _QWORD *a2)
{
long long v2; // r13
_QWORD *v3; // rbp
_QWORD *v4; // r15
long long v6; // rax
long long v7; // rbx
long long v8; // rbx
long long v9; // rax
long long v10; // rax
long long v11; // rbx
char v12; // [rsp+6h] [rbp-52h] BYREF
char v13; // [rsp+7h] [rbp-5... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R13,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],R13
MOV qword ptr [RDI + 0x20],R13
MOV qword pt... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
_Rb_tree_node * func0(vector param_1)
{
_Rb_tree_node *p_Var1;
int8 *puVar2;
_Rb_tree_node_base *p_Var3;
bool bVar4;
_Rb_tree_iterator _Var5;
int4 extraout_var;
_Rb_tree_node *p_... |
3,030 | func0 |
#include <vector>
#include <map>
#include <tuple>
#include <cassert>
using namespace std;
| map<vector<int>, int> func0(vector<vector<int>> list1) {
map<vector<int>, int> result;
for (auto& l : list1) {
if (result.find(l) == result.end()) {
result[l] = 0;
}
result[l]++;
}
return result;
}
| int main() {
assert((func0({{1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11}}) ==
map<vector<int>, int>{{{1, 3}, 2}, {{5, 7}, 2}, {{13, 15, 17}, 1}, {{9, 11}, 1}}));
assert((func0({{10, 20, 30, 40}, {60, 70, 50, 50}, {90, 100, 200}}) ==
map<vector<int>, int>{{{10, 20, 30, ... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
lea 0x8(%rdi),%rbp
push %rbx
sub $0x20,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x1... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
lea rbp, [rdi+8]
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r13, [rsi+8]
mov rdx, fs:28h
mov [rsp+58h+var_40], rdx
xor edx, edx
mov dword ptr [rdi+8], 0
mov qwo... | long long func0(long long a1, long long *a2)
{
long long v3; // rbp
long long v4; // rbx
long long v5; // r13
_DWORD *v6; // r10
_DWORD *v7; // rdi
_QWORD *v8; // r9
_QWORD *v9; // r11
char *v10; // r8
char *v11; // rcx
char *v12; // rax
_DWORD *v13; // rdx
_DWORD *v14; // rdx
long long v15; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
LEA RBP,[RDI + 0x8]
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RDX
XOR EDX,EDX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI +... | /* WARNING: Removing unreachable block (ram,0x001020f8) */
/* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
long func0(vector param_1)
{
piecewise_construct_t *ppVar1;
int8 *puVar2;
int *piVar3;
_Rb_tree_iterator _Var4;
int *piVar5... |
3,031 | func0 |
#include <vector>
#include <map>
#include <tuple>
#include <cassert>
using namespace std;
| map<vector<int>, int> func0(vector<vector<int>> list1) {
map<vector<int>, int> result;
for (auto& l : list1) {
if (result.find(l) == result.end()) {
result[l] = 0;
}
result[l]++;
}
return result;
}
| int main() {
assert((func0({{1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11}}) ==
map<vector<int>, int>{{{1, 3}, 2}, {{5, 7}, 2}, {{13, 15, 17}, 1}, {{9, 11}, 1}}));
assert((func0({{10, 20, 30, 40}, {60, 70, 50, 50}, {90, 100, 200}}) ==
map<vector<int>, int>{{{10, 20, 30, ... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
lea 0x8(%rdi),%rbp
push %rbx
sub $0x28,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%r14
mov %fs:0x28,%rax
mov... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
lea rbp, [rdi+8]
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r13, [rsi+8]
mov rdx, fs:28h
mov [rsp+58h+var_40], rdx
xor edx, edx
mov dword ptr [rdi+8], 0
mov qwo... | long long func0(long long a1, long long *a2)
{
long long v3; // rbp
long long v4; // rbx
long long v5; // r13
_DWORD *v6; // r10
_DWORD *v7; // r8
_QWORD *v8; // r11
_QWORD *v9; // rdi
char *v10; // r9
char *v11; // rcx
char *v12; // rax
_DWORD *v13; // rdx
_DWORD *v14; // rdx
long long v15; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
LEA RBP,[RDI + 0x8]
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RDX
XOR EDX,EDX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI +... | /* WARNING: Removing unreachable block (ram,0x00102458) */
/* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
long func0(vector param_1)
{
piecewise_construct_t *ppVar1;
int8 *puVar2;
int *piVar3;
_Rb_tree_iterator _Var4;
int *piVar5... |
3,032 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| bool func0(const std::string& num) {
std::regex dnumre(R"(^[0-9]+(\.[0-9]{1,2})?$)");
return std::regex_search(num, dnumre);
}
| int main() {
assert(func0("123.11") == true);
assert(func0("e666.86") == false);
assert(func0("3.124587") == false);
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 %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea 0x2b3f0(%rip),%rsi
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, a090912; "^[0-9]+(\\.[0-9]{1,2})?$"
mov r... | long long func0(long long a1)
{
unsigned int v1; // ebx
_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, "^[0-9]+(\\.[0-9]{1,2})?$", 16LL);
v1 = std::regex_search<std::char_tr... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x132051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b3f:
CALL 0x00106074
LEA RCX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
bool bVar1;
int7 extraout_var;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"^[0-9]+(\\.[0-9]{1,2})?$",0x10);
/* try { // try from 0... |
3,033 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| bool func0(const std::string& num) {
std::regex dnumre(R"(^[0-9]+(\.[0-9]{1,2})?$)");
return std::regex_search(num, dnumre);
}
| int main() {
assert(func0("123.11") == true);
assert(func0("e666.86") == false);
assert(func0("3.124587") == false);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r12
mov %r12,%rdi
callq 4730 <_ZNSt6localeC1Ev@plt>
movl $0x... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea r14, [rbp+var_60]
lea rdi, [rbp+var_58]; this
call __ZNSt6localeC1Ev; std::locale::... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA R14,[RBP + -0x60]
LEA RDI,[RBP + -0x58]
CALL 0x001046f0
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV ECX,0x10
LEA RDX,[0x1185f6]
LEA RSI,[RDX ... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
int iVar4;
int7 extraout_var;
long in_FS_OFFSET;
regex local_68 [8];
int local_60 [8];
int8 local_58;
_Sp_counted_base<(_Lock_policy)2> *... | |
3,034 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| bool func0(const std::string& num) {
std::regex dnumre(R"(^[0-9]+(\.[0-9]{1,2})?$)");
return std::regex_search(num, dnumre);
}
| int main() {
assert(func0("123.11") == true);
assert(func0("e666.86") == false);
assert(func0("3.124587") == false);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r12
lea 0x8(%rsp),%rbp
mov %r12,%rdi
callq 4750... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
lea r12, [rbp+var_70]
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea rax, [rbp+var_68]
mov rdi, rax; this
mov r14... | long long func0(long long *a1)
{
long long v2; // rdi
long long v3; // rsi
long long v4; // rsi
unsigned int v5; // r12d
long long v6; // rbx
long long v7; // rdx
volatile signed __int32 *v8; // rcx
signed __int32 v9; // eax
long long v11; // rax
long long v12; // rdi
_BYTE v13[8]; // [rsp+0h] [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
LEA R12,[RBP + -0x70]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x68]
MOV RDI,RAX
MOV R14,RAX
CALL 0x001036d0
LEA RDX,[0x1185f6]
PXOR XMM0,XMM0
MOV RDI,R12
MOV ECX,0x10
LEA RSI,[RDX + -0... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
int7 extraout_var;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int local_68 [16];
int local_58 [16];
int local_48 [16];
long local_30;
... |
3,035 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| bool func0(const std::string& num) {
std::regex dnumre(R"(^[0-9]+(\.[0-9]{1,2})?$)");
return std::regex_search(num, dnumre);
}
| int main() {
assert(func0("123.11") == true);
assert(func0("e666.86") == false);
assert(func0("3.124587") == false);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r12
lea 0x8(%rsp),%rbp
mov %r12,%rdi
callq 47b0... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 2A8h
mov rax, fs:28h
mov [rsp+2D8h+var_40], rax
xor eax, eax
lea r12, [rsp+2D8h+var_2A0]
mov rdi, r12; this
call __ZNSt6loc... | long long func0(unsigned long long *a1)
{
__m128i v2; // xmm0
long long v3; // rdi
void *v4; // rdi
void **v5; // rbx
unsigned long long v6; // rbp
void *v7; // rdi
unsigned long long v8; // r13
unsigned long long v9; // rbx
long long v10; // rax
long long v11; // rcx
unsigned long long v12; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x2a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x298],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x00104730
LEA RDX,[0x11a637]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x100]
MOV R8D,0x10
MOV RCX,R12
LEA RSI,[RDX + -0x17]
M... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
ulong uVar1;
ulong uVar2;
int auVar3 [16];
bool bVar4;
char cVar5;
long lVar6;
int8 *puVar7;
int8 *puVar8;
ulong uVar9;
ulong *puVar10;
long lVar11;
ulong uVar12;
int8 uVar13;
int8 uVar14;
_Match_mode _Var15;
long in_FS_OFFS... |
3,036 | func0 |
#include <iostream>
#include <set>
#include <assert.h>
| std::string func0(int arr[], int n) {
std::set<int> s;
for (int i = 0; i < n; i++) {
s.insert(arr[i]);
}
if (s.size() == 1) {
return "YES";
} else {
return "NO";
}
}
| int main() {
int arr1[] = {1, 1, 1};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == "YES");
assert(func0(arr2, 4) == "NO");
assert(func0(arr3, 5) == "NO");
return 0;
}
| O0 | cpp | func0[abi:cxx11](int*, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %edx,-0x74(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2912 <_ZNSt3setIiSt4lessIiESaIiEEC1Ev>
mov... | _Z5func0B5cxx11Pii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov [rbp+var_84], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt3setIiSt4lessIiESaIiEEC2Ev; std::set<... | long long func0[abi:cxx11](long long a1, long long a2, int a3)
{
char v5; // [rsp+2Bh] [rbp-65h] BYREF
int i; // [rsp+2Ch] [rbp-64h]
char *v7; // [rsp+30h] [rbp-60h]
char *v8; // [rsp+38h] [rbp-58h]
_BYTE v9[56]; // [rsp+40h] [rbp-50h] BYREF
unsigned long long v10; // [rsp+78h] [rbp-18h]
v10 = __readfsq... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV dword ptr [RBP + -0x84],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001029fa
MOV dword ptr [RBP + -0x64],0x0
J... | /* func0[abi:cxx11](int*, int) */
int * func0_abi_cxx11_(int *param_1,int param_2)
{
long lVar1;
int in_EDX;
int4 in_register_00000034;
long in_FS_OFFSET;
allocator local_6d;
int local_6c;
allocator *local_68;
allocator *local_60;
set<int,std::less<int>,std::allocator<int>> local_58 [56];
long loc... |
3,037 | func0 |
#include <iostream>
#include <set>
#include <assert.h>
| std::string func0(int arr[], int n) {
std::set<int> s;
for (int i = 0; i < n; i++) {
s.insert(arr[i]);
}
if (s.size() == 1) {
return "YES";
} else {
return "NO";
}
}
| int main() {
int arr1[] = {1, 1, 1};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == "YES");
assert(func0(arr2, 4) == "NO");
assert(func0(arr3, 5) == "NO");
return 0;
}
| O1 | cpp | func0[abi:cxx11](int*, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movl $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
lea 0x8(%rsp),%rax
mov %rax,0x18(%rsp)
mov %rax,0x20(%rsp)
movq $0x0,0x28(%rsp)
tes... | _Z5func0B5cxx11Pii:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r13, rdi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
mov [rsp+68h+var_60], 0
mov [rsp+68h+var_58], 0
lea rax, [rsp+68h+var_60]
mov [rsp+68h+var_50], rax
mov [rsp+68h+var_48], r... | _QWORD * func0[abi:cxx11](_QWORD *a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rbp
long long v6; // [rsp+0h] [rbp-68h] BYREF
int v7; // [rsp+8h] [rbp-60h] BYREF
long long v8; // [rsp+10h] [rbp-58h]
int *v9; // [rsp+18h] [rbp-50h]
int *v10; // [rsp+20h] [rbp-48h]
long long v11; // [r... | func0[abi:cxx11]:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
LEA RAX,[RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP ... | /* func0[abi:cxx11](int*, int) */
int * func0_abi_cxx11_(int *param_1,int param_2)
{
int *piVar1;
int in_EDX;
int *piVar2;
int4 in_register_00000034;
long in_FS_OFFSET;
_Rb_tree<int,int,std::_Identity<int>,std::less<int>,std::allocator<int>> a_Stack_68 [8];
int4 local_60 [2];
_Rb_tree_node *local_58;
... |
3,038 | func0 |
#include <iostream>
#include <set>
#include <assert.h>
| std::string func0(int arr[], int n) {
std::set<int> s;
for (int i = 0; i < n; i++) {
s.insert(arr[i]);
}
if (s.size() == 1) {
return "YES";
} else {
return "NO";
}
}
| int main() {
int arr1[] = {1, 1, 1};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == "YES");
assert(func0(arr2, 4) == "NO");
assert(func0(arr3, 5) == "NO");
return 0;
}
| O2 | cpp | func0[abi:cxx11](int*, int):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
movl $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
mov %rbp,0x18(%rsp)
mov %rbp,0x20(%rsp)
mo... | _Z5func0B5cxx11Pii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov [rsp+88h+var_80], rdi
lea r12, [rsp+88h+var_70]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov [rsp+88h+var_70], 0
mov [rsp+88h+var_68], 0
mov [rsp+88h+var... | _QWORD * func0[abi:cxx11](_QWORD *a1, int *a2, int a3)
{
int *v3; // rbp
int v4; // r14d
int *v5; // r13
int *v6; // rbx
int v7; // edx
int *v8; // rax
bool v9; // r15
long long v10; // rax
_QWORD *v11; // rbx
void *v12; // rdi
int v15; // [rsp+18h] [rbp-70h] BYREF
void *v16; // [rsp+20h] [rbp-6... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RSP + 0x8],RDI
LEA R12,[RSP + 0x18]
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
MOV qword ptr [RSP + 0x28],R12
MOV qword pt... | /* func0[abi:cxx11](int*, int) */
int * func0_abi_cxx11_(int *param_1,int param_2)
{
int *piVar1;
_Rb_tree_node_base *p_Var2;
long lVar3;
int in_EDX;
int iVar4;
_Rb_tree_node_base *p_Var5;
int *piVar6;
int4 in_register_00000034;
int iVar7;
bool bVar8;
long in_FS_OFFSET;
int4 local_70 [2];
_R... |
3,039 | func0 |
#include <iostream>
#include <set>
#include <assert.h>
| std::string func0(int arr[], int n) {
std::set<int> s;
for (int i = 0; i < n; i++) {
s.insert(arr[i]);
}
if (s.size() == 1) {
return "YES";
} else {
return "NO";
}
}
| int main() {
int arr1[] = {1, 1, 1};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == "YES");
assert(func0(arr2, 4) == "NO");
assert(func0(arr3, 5) == "NO");
return 0;
}
| O3 | cpp | func0[abi:cxx11](int*, int):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%r13
movl $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
mov %r13,0x18(%rsp)
mov %r13,0x20(%rsp)
mo... | _Z5func0B5cxx11Pii:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea r12, [rsp+88h+var_70]
mov [rsp+88h+var_70], 0
mov [rsp+88h+var_68], 0
mov [rsp+88h+var_60], r12
mov... | long long func0[abi:cxx11](long long a1, int *a2, int a3)
{
int *v4; // rbp
long long v5; // r15
int *v6; // r14
int v7; // ecx
int *i; // rbx
int v9; // edx
int *v10; // rax
bool v11; // r15
long long v12; // rax
bool v13; // zf
void *v14; // rdi
long long v16; // rax
int v17; // [rsp+Ch] [r... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x18]
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],R12
MOV qword ptr [RSP + 0x30],R12... | /* func0[abi:cxx11](int*, int) */
int * func0_abi_cxx11_(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;
long lVar5;
int in_EDX;
int iVar6;
_Rb_tree_node_base *p_Var7;
int *piVar8;
int4 in_register_00000034;
bool bVar9;
long in_FS_OFF... |
3,040 | func0 |
#include <cassert>
| double func0(double d, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None
}
double arclength = (pi * d) * (a / 360);
return arclength;
}
| int main() {
assert(func0(9, 45) == 3.5357142857142856);
assert(func0(9, 480) == -1); // Representing None as -1
assert(func0(5, 270) == 11.785714285714285);
return 0;
}
| O0 | cpp | func0(double, double):
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd 0xf5d(%rip),%xmm0
movsd %xmm0,-0x10(%rbp)
movsd -0x20(%rbp),%xmm0
comisd 0xf53(%rip),%xmm0
jb 1181 <_Z5func0dd+0x38>
movsd 0xf51(%rip),%xmm0
jmp 11ae <_Z5func0dd+0x65>
movsd -0x10(%rbp),%xmm0
... | _Z5func0dd:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm0, cs:qword_20A0
movsd [rbp+var_10], xmm0
movsd xmm0, [rbp+var_20]
comisd xmm0, cs:qword_20A8
jb short loc_1181
movsd xmm0, cs:qword_20B0
jmp short loc_11AE
loc_1181:
movsd xmm0, [rbp+var_... | double func0(double a1, double a2)
{
if ( a2 < 360.0 )
return a2 / 360.0 * (3.142857142857143 * a1);
else
return -1.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM0,qword ptr [0x001020a0]
MOVSD qword ptr [RBP + -0x10],XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
COMISD XMM0,qword ptr [0x001020a8]
JC 0x00101181
MOVSD XMM0,qword ptr [0x001020b0]
JMP 0x001011ae
LAB_00101181... | /* func0(double, double) */
double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = DAT_001020b0;
if (param_2 < DAT_001020a8) {
dVar1 = (param_2 / DAT_001020a8) * DAT_001020a0 * param_1;
}
return dVar1;
} |
3,041 | func0 |
#include <cassert>
| double func0(double d, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None
}
double arclength = (pi * d) * (a / 360);
return arclength;
}
| int main() {
assert(func0(9, 45) == 3.5357142857142856);
assert(func0(9, 480) == -1); // Representing None as -1
assert(func0(5, 270) == 11.785714285714285);
return 0;
}
| O1 | cpp | func0(double, double):
endbr64
comisd 0xedb(%rip),%xmm1
jae 114c <_Z5func0dd+0x23>
mulsd 0xed9(%rip),%xmm0
divsd 0xec9(%rip),%xmm1
mulsd %xmm1,%xmm0
retq
movsd 0xeb4(%rip),%xmm0
retq
| _Z5func0dd:
endbr64
comisd xmm1, cs:qword_2010
jnb short loc_114C
mulsd xmm0, cs:qword_2018
divsd xmm1, cs:qword_2010
mulsd xmm0, xmm1
retn
loc_114C:
movsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2)
{
if ( a2 >= 360.0 )
return -1.0;
else
return a1 * 3.142857142857143 * (a2 / 360.0);
} | func0:
ENDBR64
COMISD XMM1,qword ptr [0x00102010]
JNC 0x0010114c
MULSD XMM0,qword ptr [0x00102018]
DIVSD XMM1,qword ptr [0x00102010]
MULSD XMM0,XMM1
RET
LAB_0010114c:
MOVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
if (param_2 < _DAT_00102010) {
return param_1 * _DAT_00102018 * (param_2 / _DAT_00102010);
}
return DAT_00102008;
} |
3,042 | func0 |
#include <cassert>
| double func0(double d, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None
}
double arclength = (pi * d) * (a / 360);
return arclength;
}
| int main() {
assert(func0(9, 45) == 3.5357142857142856);
assert(func0(9, 480) == -1); // Representing None as -1
assert(func0(5, 270) == 11.785714285714285);
return 0;
}
| O2 | cpp | func0(double, double):
endbr64
movsd 0xec4(%rip),%xmm2
comisd %xmm2,%xmm1
jae 1168 <_Z5func0dd+0x28>
divsd %xmm2,%xmm1
mulsd 0xeba(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
movsd 0xe98(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0dd:
endbr64
movsd xmm2, cs:qword_2010
comisd xmm1, xmm2
jnb short loc_1168
divsd xmm1, xmm2
mulsd xmm0, cs:qword_2018
mulsd xmm0, xmm1
retn
loc_1168:
movsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2)
{
if ( a2 >= 360.0 )
return -1.0;
else
return a1 * 3.142857142857143 * (a2 / 360.0);
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102010]
COMISD XMM1,XMM2
JNC 0x00101168
DIVSD XMM1,XMM2
MULSD XMM0,qword ptr [0x00102018]
MULSD XMM0,XMM1
RET
LAB_00101168:
MOVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
if (param_2 < DAT_00102010) {
return param_1 * _DAT_00102018 * (param_2 / DAT_00102010);
}
return DAT_00102008;
} |
3,043 | func0 |
#include <cassert>
| double func0(double d, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None
}
double arclength = (pi * d) * (a / 360);
return arclength;
}
| int main() {
assert(func0(9, 45) == 3.5357142857142856);
assert(func0(9, 480) == -1); // Representing None as -1
assert(func0(5, 270) == 11.785714285714285);
return 0;
}
| O3 | cpp | func0(double, double):
endbr64
movsd 0xec4(%rip),%xmm2
comisd %xmm2,%xmm1
jae 1168 <_Z5func0dd+0x28>
divsd %xmm2,%xmm1
mulsd 0xeba(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
movsd 0xe98(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0dd:
endbr64
movsd xmm2, cs:qword_2010
comisd xmm1, xmm2
jnb short loc_1168
divsd xmm1, xmm2
mulsd xmm0, cs:qword_2018
mulsd xmm0, xmm1
retn
loc_1168:
movsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2)
{
if ( a2 >= 360.0 )
return -1.0;
else
return a1 * 3.142857142857143 * (a2 / 360.0);
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102010]
COMISD XMM1,XMM2
JNC 0x00101168
DIVSD XMM1,XMM2
MULSD XMM0,qword ptr [0x00102018]
MULSD XMM0,XMM1
RET
LAB_00101168:
MOVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
if (param_2 < DAT_00102010) {
return param_1 * _DAT_00102018 * (param_2 / DAT_00102010);
}
return DAT_00102008;
} |
3,044 | func0 |
#include <assert.h>
| bool func0(int monthnum3) {
if (monthnum3 == 4 || monthnum3 == 6 || monthnum3 == 9 || monthnum3 == 11) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6) == true);
assert(func0(2) == false);
assert(func0(12) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x4,-0x4(%rbp)
je 116c <_Z5func0i+0x23>
cmpl $0x6,-0x4(%rbp)
je 116c <_Z5func0i+0x23>
cmpl $0x9,-0x4(%rbp)
je 116c <_Z5func0i+0x23>
cmpl $0xb,-0x4(%rbp)
jne 1173 <_Z5func0i+0x2a>
mov $0x1,%eax
jmp 1178 <_Z5func0i+... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 4
jz short loc_116C
cmp [rbp+var_4], 6
jz short loc_116C
cmp [rbp+var_4], 9
jz short loc_116C
cmp [rbp+var_4], 0Bh
jnz short loc_1173
loc_116C:
mov eax, 1
jmp short loc_1178
loc_1173:
mov... | _BOOL8 func0(int a1)
{
return a1 == 4 || a1 == 6 || a1 == 9 || a1 == 11;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x4
JZ 0x0010116c
CMP dword ptr [RBP + -0x4],0x6
JZ 0x0010116c
CMP dword ptr [RBP + -0x4],0x9
JZ 0x0010116c
CMP dword ptr [RBP + -0x4],0xb
JNZ 0x00101173
LAB_0010116c:
MOV EAX,0x1
JMP 0x00101178
LAB_00101173:
MOV EAX,0x0
LAB_0... | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
if ((((param_1 == 4) || (param_1 == 6)) || (param_1 == 9)) || (param_1 == 0xb)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
3,045 | func0 |
#include <assert.h>
| bool func0(int monthnum3) {
if (monthnum3 == 4 || monthnum3 == 6 || monthnum3 == 9 || monthnum3 == 11) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6) == true);
assert(func0(2) == false);
assert(func0(12) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
and $0xfffffffd,%edi
mov $0x1,%eax
cmp $0x4,%edi
je 1140 <_Z5func0i+0x17>
cmp $0x9,%edi
sete %al
retq
| _Z5func0i:
endbr64
mov eax, 0
cmp edi, 0Bh
ja short locret_1143
mov eax, 0A50h
bt rax, rdi
setb al
locret_1143:
retn | unsigned __int8 func0(unsigned long long a1)
{
unsigned __int8 result; // al
long long v2; // rax
result = 0;
if ( (unsigned int)a1 <= 0xB )
{
v2 = 2640LL;
return _bittest64(&v2, a1);
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0xb
JA 0x00101143
MOV EAX,0xa50
BT RAX,RDI
SETC AL
LAB_00101143:
RET | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
uVar1 = 0;
if ((uint)param_1 < 0xc) {
uVar1 = CONCAT71(10,(0xa50UL >> ((ulong)(uint)param_1 & 0x3f) & 1) != 0);
}
return uVar1;
} |
3,046 | func0 |
#include <assert.h>
| bool func0(int monthnum3) {
if (monthnum3 == 4 || monthnum3 == 6 || monthnum3 == 9 || monthnum3 == 11) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6) == true);
assert(func0(2) == false);
assert(func0(12) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
and $0xfffffffd,%edi
mov $0x1,%eax
cmp $0x4,%edi
je 1157 <_Z5func0i+0x17>
cmp $0x9,%edi
sete %al
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
xor eax, eax
cmp edi, 0Bh
ja short locret_1157
mov eax, 0A50h
bt rax, rdi
setb al
locret_1157:
retn | unsigned __int8 func0(unsigned long long a1)
{
unsigned __int8 result; // al
long long v2; // rax
result = 0;
if ( (unsigned int)a1 <= 0xB )
{
v2 = 2640LL;
return _bittest64(&v2, a1);
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0xb
JA 0x00101157
MOV EAX,0xa50
BT RAX,RDI
SETC AL
LAB_00101157:
RET | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
uVar1 = 0;
if ((uint)param_1 < 0xc) {
uVar1 = CONCAT71(10,(0xa50UL >> ((ulong)(uint)param_1 & 0x3f) & 1) != 0);
}
return uVar1;
} |
3,047 | func0 |
#include <assert.h>
| bool func0(int monthnum3) {
if (monthnum3 == 4 || monthnum3 == 6 || monthnum3 == 9 || monthnum3 == 11) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6) == true);
assert(func0(2) == false);
assert(func0(12) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
and $0xfffffffd,%edi
mov $0x1,%eax
cmp $0x4,%edi
je 1157 <_Z5func0i+0x17>
cmp $0x9,%edi
sete %al
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
xor eax, eax
cmp edi, 0Bh
ja short locret_1157
mov eax, 0A50h
bt rax, rdi
setb al
locret_1157:
retn | unsigned __int8 func0(unsigned long long a1)
{
unsigned __int8 result; // al
long long v2; // rax
result = 0;
if ( (unsigned int)a1 <= 0xB )
{
v2 = 2640LL;
return _bittest64(&v2, a1);
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0xb
JA 0x00101157
MOV EAX,0xa50
BT RAX,RDI
SETC AL
LAB_00101157:
RET | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
uVar1 = 0;
if ((uint)param_1 < 0xc) {
uVar1 = CONCAT71(10,(0xa50UL >> ((ulong)(uint)param_1 & 0x3f) & 1) != 0);
}
return uVar1;
} |
3,048 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
#include <climits>
| int func0(std::vector<int> arr, int n) {
std::sort(arr.begin(), arr.end());
int diff = INT_MAX;
for (int i = 0; i < n-1; i++) {
if (arr[i+1] - arr[i] < diff) {
diff = arr[i+1] - arr[i];
}
}
return diff;
}
| int main() {
assert(func0({1, 5, 3, 19, 18, 25}, 6) == 1);
assert(func0({4, 3, 2, 6}, 4) == 1);
assert(func0({30, 5, 20, 9}, 4) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1776 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 172a <... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call ... | long long func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
int v4; // ebx
int v5; // ebx
int v7; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = std::vector<int>::end(a1);
v3 = std::vector<int>::begin(a1);
std::sort<__gnu_cxx::__normal_iterator<int *,std::vector<int>... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001016f6
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001016aa
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101746
MOV dword ptr [RBP + -0x18... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_20;
int4 local_1c;
this = (vector<int,std::alloca... |
3,049 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
#include <climits>
| int func0(std::vector<int> arr, int n) {
std::sort(arr.begin(), arr.end());
int diff = INT_MAX;
for (int i = 0; i < n-1; i++) {
if (arr[i+1] - arr[i] < diff) {
diff = arr[i+1] - arr[i];
}
}
return diff;
}
| int main() {
assert(func0({1, 5, 3, 19, 18, 25}, 6) == 1);
assert(func0({4, 3, 2, 6}, 4) == 1);
assert(func0({30, 5, 20, 9}, 4) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%r12d
mov 0x8(%rdi),%r13
mov (%rdi),%r14
cmp %r14,%r13
je 130c <_Z5func0St6vectorIiSaIiEEi+0xa3>
mov %r13,%rbx
sub %r14,%rbx
mov %rbx,%rax
sar $0x... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
mov r12d, esi
mov rbp, [rdi+8]
mov r14, [rdi]
cmp rbp, r14
jz loc_12D2
mov rbx, rbp
sub rbx, r14
mov rdx, rbx
sar rdx, 2
mov eax, 40h ; '@'
jz short loc_1266
bsr... | long long func0(char **a1, int a2)
{
char *v3; // rbp
char *v4; // r14
int v5; // eax
unsigned long long v6; // rax
char *v7; // rbx
int v8; // ecx
char *v9; // rax
int v10; // edx
char *v11; // rsi
char *v12; // rax
int v13; // ecx
v3 = a1[1];
v4 = *a1;
if ( v3 != *a1 )
{
v5 = 64;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
MOV R12D,ESI
MOV RBP,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
CMP RBP,R14
JZ 0x001012d2
MOV RBX,RBP
SUB RBX,R14
MOV RDX,RBX
SAR RDX,0x2
MOV EAX,0x40
JZ 0x00101266
BSR RAX,RDX
XOR EAX,0x3f
LAB_00101266:
MOV EDX,0x3f
SUB EDX,EAX
MOVSXD RDX,EDX
A... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
long lVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int *piVar7;
_Iter_less_iter in_ECX;
int iVar8;
_Iter_less_iter extraout_EDX;
ulong uVar9;
int *piVar10;
__normal_iterato... |
3,050 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
#include <climits>
| int func0(std::vector<int> arr, int n) {
std::sort(arr.begin(), arr.end());
int diff = INT_MAX;
for (int i = 0; i < n-1; i++) {
if (arr[i+1] - arr[i] < diff) {
diff = arr[i+1] - arr[i];
}
}
return diff;
}
| int main() {
assert(func0({1, 5, 3, 19, 18, 25}, 6) == 1);
assert(func0({4, 3, 2, 6}, 4) == 1);
assert(func0({30, 5, 20, 9}, 4) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
mov %esi,%r13d
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov 0x8(%rdi),%r12
mov (%rdi),%r14
cmp %r14,%r12
je 1514 <_Z5func0St6vectorIiSaIiEEi+0xa4>
mov %r12,%rbx
mov $0x3f,%edx
mov %r12,%rsi
mov %r... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
mov r12, [rdi+8]
mov ebx, esi
mov r14, [rdi]
cmp r12, r14
jz loc_17E4
mov rbp, r12
mov rdx, 0FFFFFFFFFFFFFFFEh
sub rbp, r14
mov rax, rbp
sar rax, 2
jz short loc_... | long long func0(char **a1, int a2)
{
char *v3; // r12
char *v5; // r14
long long v6; // rdx
unsigned long long v7; // rax
char *v8; // rbp
int v9; // ecx
int v10; // edx
char *v11; // rax
char *v12; // rsi
int v13; // ecx
int *v14; // rax
int v15; // edx
int v16; // edi
char *v18; // rsi
... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,qword ptr [RDI + 0x8]
MOV EBX,ESI
MOV R14,qword ptr [RDI]
CMP R12,R14
JZ 0x001017e4
MOV RBP,R12
MOV RDX,-0x2
SUB RBP,R14
MOV RAX,RBP
SAR RAX,0x2
JZ 0x00101781
BSR RAX,RAX
CDQE
LEA RDX,[RAX + RAX*0x1]
LAB_00101781:
MOV RSI,R12
MOV RDI,R14
CA... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int *piVar5;
int *piVar6;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
int iVar7;
long lVar8;
int iVar9;
__normal_iterator _Var10;
int4 ... |
3,051 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
#include <climits>
| int func0(std::vector<int> arr, int n) {
std::sort(arr.begin(), arr.end());
int diff = INT_MAX;
for (int i = 0; i < n-1; i++) {
if (arr[i+1] - arr[i] < diff) {
diff = arr[i+1] - arr[i];
}
}
return diff;
}
| int main() {
assert(func0({1, 5, 3, 19, 18, 25}, 6) == 1);
assert(func0({4, 3, 2, 6}, 4) == 1);
assert(func0({30, 5, 20, 9}, 4) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
push %rbx
sub $0x18,%rsp
mov 0x8(%rdi),%r13
mov (%rdi),%r12
cmp %r12,%r13
je 155c <_Z5func0St6vectorIiSaIiEEi+0x11c>
mov %r13,%r14
mov $0x3f,%... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r13, [rdi+8]
mov rbx, [rdi]
mov [rsp+48h+var_3C], esi
cmp r13, rbx
jz loc_1774
mov r14, r13
lea r12, [rbx+4]
sub r14, rbx
mov rax, r14
sa... | long long func0(char **a1, int a2)
{
char *v3; // r13
char *v4; // rbx
char *v5; // r12
unsigned long long v6; // rdx
char *v7; // r15
int v8; // r14d
char *v9; // rsi
int v10; // edx
char *j; // rax
int v12; // ecx
int v13; // edx
char *v14; // rax
char *v15; // rsi
long long result; // ra... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R13,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV dword ptr [RSP + 0xc],ESI
CMP R13,RBX
JZ 0x00101774
MOV R14,R13
LEA R12,[RBX + 0x4]
SUB R14,RBX
MOV RAX,R14
SAR RAX,0x2
JZ 0x00101927
BSR RDX,RAX
MOV RSI,R13
MOV RDI,RB... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >, int) */
uint 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
,int4 param_11)
{
... |
3,052 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(const std::string& str) {
int number_ctr = 0;
for (size_t i = 0; i < str.length(); i++) {
if (str[i] >= '0' && str[i] <= '9') number_ctr += 1;
}
return number_ctr;
}
| int main() {
assert(func0("program2bedone") == 1);
assert(func0("3wonders") == 1);
assert(func0("123") == 3);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0xc(%rbp)
movq $0x0,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 22d0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsI... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_13B7
loc_136A:
mov rdx, [rbp+var_8]
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call __ZN... | long long func0(long long a1)
{
unsigned long long i; // rax
unsigned int v4; // [rsp+14h] [rbp-Ch]
unsigned long long v5; // [rsp+18h] [rbp-8h]
v4 = 0;
v5 = 0LL;
for ( i = std::string::length(a1); v5 < i; i = std::string::length(a1) )
{
if ( *(char *)std::string::operator[](a1, v5) > 47 && *(char *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001013b7
LAB_0010136a:
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001011e0
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x00... | /* func0(std::string const&) */
int func0(string *param_1)
{
bool bVar1;
char *pcVar2;
ulong uVar3;
int4 local_14;
int8 local_10;
local_14 = 0;
local_10 = 0;
do {
uVar3 = std::string::length();
if (uVar3 <= local_10) {
return local_14;
}
pcVar2 = (char *)std::string::operator[... |
3,053 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(const std::string& str) {
int number_ctr = 0;
for (size_t i = 0; i < str.length(); i++) {
if (str[i] >= '0' && str[i] <= '9') number_ctr += 1;
}
return number_ctr;
}
| int main() {
assert(func0("program2bedone") == 1);
assert(func0("3wonders") == 1);
assert(func0("123") == 3);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1259 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30>
mov (%rdi),%rax
add %rax,%rsi
mov $0x0,%ecx
movzbl (%rax),%edi
lea -0x30(%rdi),%edx
... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_1239
mov rax, [rdi]
add rsi, rax
mov ecx, 0
loc_1221:
movzx edi, byte ptr [rax]
lea edx, [rdi-30h]
cmp dl, 0Ah
adc ecx, 0
add rax, 1
cmp rsi, rax
jnz shor... | long long func0(_QWORD *a1)
{
long long v1; // rsi
_BYTE *v2; // rax
_BYTE *v3; // rsi
unsigned int v4; // ecx
v1 = a1[1];
if ( v1 )
{
v2 = (_BYTE *)*a1;
v3 = (_BYTE *)(*a1 + v1);
v4 = 0;
do
v4 += (unsigned __int8)(*v2++ - 48) < 0xAu;
while ( v3 != v2 );
}
else
{
retu... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00101239
MOV RAX,qword ptr [RDI]
ADD RSI,RAX
MOV ECX,0x0
LAB_00101221:
MOVZX EDI,byte ptr [RAX]
LEA EDX,[RDI + -0x30]
CMP DL,0xa
ADC ECX,0x0
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101221
LAB_00101236:
MOV EAX,ECX
RET
LAB_00101239:
MOV ECX,0x0
JMP 0x00101236 | /* func0(std::string const&) */
int func0(string *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (*(long *)(param_1 + 8) == 0) {
iVar2 = 0;
}
else {
pcVar1 = *(char **)param_1;
pcVar3 = pcVar1 + *(long *)(param_1 + 8);
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((byte)(*pcVar... |
3,054 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(const std::string& str) {
int number_ctr = 0;
for (size_t i = 0; i < str.length(); i++) {
if (str[i] >= '0' && str[i] <= '9') number_ctr += 1;
}
return number_ctr;
}
| int main() {
assert(func0("program2bedone") == 1);
assert(func0("3wonders") == 1);
assert(func0("123") == 3);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
mov 0x8(%rdi),%rcx
test %rcx,%rcx
je 1490 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x40>
mov (%rdi),%rax
xor %r8d,%r8d
add %rax,%rcx
nopw %cs:0x0(%rax,%rax,1)
movzbl (%rax),%... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_1360
mov rax, [rdi]
xor ecx, ecx
add rsi, rax
nop dword ptr [rax]
loc_1348:
movzx edi, byte ptr [rax]
lea edx, [rdi-30h]
cmp dl, 0Ah
adc ecx, 0
add rax, 1
cmp... | long long func0(_QWORD *a1)
{
long long v1; // rsi
_BYTE *v2; // rax
unsigned int v3; // ecx
_BYTE *v4; // rsi
v1 = a1[1];
if ( !v1 )
return 0LL;
v2 = (_BYTE *)*a1;
v3 = 0;
v4 = (_BYTE *)(*a1 + v1);
do
v3 += (unsigned __int8)(*v2++ - 48) < 0xAu;
while ( v4 != v2 );
return v3;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00101360
MOV RAX,qword ptr [RDI]
XOR ECX,ECX
ADD RSI,RAX
NOP dword ptr [RAX]
LAB_00101348:
MOVZX EDI,byte ptr [RAX]
LEA EDX,[RDI + -0x30]
CMP DL,0xa
ADC ECX,0x0
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101348
MOV EAX,ECX
RET
LAB_00101360:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(std::string const&) */
int func0(string *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (*(long *)(param_1 + 8) != 0) {
pcVar1 = *(char **)param_1;
iVar2 = 0;
pcVar3 = pcVar1 + *(long *)(param_1 + 8);
do {
iVar2 = iVar2 + (uint)((byte)(*pcVar1 - 0x30U) < 10);
pcVa... |
3,055 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(const std::string& str) {
int number_ctr = 0;
for (size_t i = 0; i < str.length(); i++) {
if (str[i] >= '0' && str[i] <= '9') number_ctr += 1;
}
return number_ctr;
}
| int main() {
assert(func0("program2bedone") == 1);
assert(func0("3wonders") == 1);
assert(func0("123") == 3);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
mov 0x8(%rdi),%rcx
test %rcx,%rcx
je 1dc0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x280>
lea -0x1(%rcx),%rax
mov (%rdi),%rsi
cmp $0xe,%rax
jbe 1dc3 <_Z5func0RKNSt7__cxx1112... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rcx, [rdi+8]
test rcx, rcx
jz loc_1C70
lea rax, [rcx-1]
mov rsi, [rdi]
cmp rax, 0Eh
jbe loc_1C73
mov rdx, rcx
pxor xmm1, xmm1
pxor xmm3, xmm3
mov rax, rsi
and rdx, 0FFFFFFFFFFFFFFF0h
movdqa xmm6, c... | long long func0(const __m128i **a1)
{
unsigned long long v1; // rcx
const __m128i *v2; // rsi
__m128i v3; // xmm1
const __m128i *v4; // rax
unsigned long long v5; // rdx
__m128i si128; // xmm6
__m128i v7; // xmm5
__m128i v8; // xmm2
__m128i v9; // xmm0
__m128i v10; // xmm7
__m128i v11; // xmm2
... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
TEST RCX,RCX
JZ 0x00101c70
LEA RAX,[RCX + -0x1]
MOV RSI,qword ptr [RDI]
CMP RAX,0xe
JBE 0x00101c73
MOV RDX,RCX
PXOR XMM1,XMM1
PXOR XMM3,XMM3
MOV RAX,RSI
AND RDX,-0x10
MOVDQA XMM6,xmmword ptr [0x001020d0]
MOVDQA XMM5,xmmword ptr [0x001020e0]
PXOR XMM4,XMM4
LEA RDI,[RDX + RSI*... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string const&) */
int func0(string *param_1)
{
ulong uVar1;
char *pcVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12... |
3,056 | func0 |
#include <cmath>
#include <assert.h>
| int func0(int n) {
n = n + 1;
return n + static_cast<int>(log(n + log(n) / log(2)) / log(2));
}
| int main() {
assert(func0(7) == 11);
assert(func0(4) == 7);
assert(func0(9) == 13);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
addl $0x1,-0x4(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm2
movsd %xmm2,-0x10(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm0
callq 1070 <log@plt>
movsd 0xef0(%rip),%xmm1
divsd %xmm1,%xmm0
addsd -0x10(%rbp),%xmm0
callq 1070 <log@plt>
movsd 0xeda(%r... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
add [rbp+var_4], 1
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_4]
movsd [rbp+var_10], xmm2
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_4]
movq rax, xmm3
movq xmm0, rax; x
call _log
movq rax, xmm0
movsd xmm1, cs:q... | long long func0(int a1)
{
double v1; // xmm0_8
v1 = log((double)(a1 + 1));
return (unsigned int)((int)(log(v1 / 0.6931471805599453 + (double)(a1 + 1)) / 0.6931471805599453) + a1 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
ADD dword ptr [RBP + -0x4],0x1
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x4]
MOVSD qword ptr [RBP + -0x10],XMM2
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x4]
MOVQ RAX,XMM3
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOVSD XMM1,q... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
double dVar2;
iVar1 = param_1 + 1;
dVar2 = log((double)iVar1);
dVar2 = log(dVar2 / DAT_00102068 + (double)iVar1);
return iVar1 + (int)(dVar2 / DAT_00102068);
} |
3,057 | func0 |
#include <cmath>
#include <assert.h>
| int func0(int n) {
n = n + 1;
return n + static_cast<int>(log(n + log(n) / log(2)) / log(2));
}
| int main() {
assert(func0(7) == 11);
assert(func0(4) == 7);
assert(func0(9) == 13);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %rbx
sub $0x10,%rsp
lea 0x1(%rdi),%ebx
pxor %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd %xmm1,0x8(%rsp)
movapd %xmm1,%xmm0
callq 1070 <log@plt>
divsd 0xef4(%rip),%xmm0
addsd 0x8(%rsp),%xmm0
callq 1070 <log@plt>
divsd 0xee1(%rip),%xmm0
cvttsd2si %xmm0,%eax
add %ebx,%eax
add $0x10... | _Z5func0i:
endbr64
push rbx
sub rsp, 10h
lea ebx, [rdi+1]
pxor xmm1, xmm1
cvtsi2sd xmm1, ebx
movsd [rsp+18h+var_10], xmm1
movapd xmm0, xmm1; x
call _log
divsd xmm0, cs:qword_2060
addsd xmm0, [rsp+18h+var_10]; x
call _log
divsd xmm0, cs:qword_2060
cvttsd2si eax, xmm0
add eax, ebx
add ... | long long func0(int a1)
{
double v1; // xmm0_8
v1 = log((double)(a1 + 1));
return (unsigned int)(a1 + 1 + (int)(log(v1 / 0.6931471805599453 + (double)(a1 + 1)) / 0.6931471805599453));
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x10
LEA EBX,[RDI + 0x1]
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBX
MOVSD qword ptr [RSP + 0x8],XMM1
MOVAPD XMM0,XMM1
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102060]
ADDSD XMM0,qword ptr [RSP + 0x8]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102060]
CVTTSD2SI EAX,XMM0
ADD EAX,EBX
ADD RSP,0x10
POP... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
double dVar1;
double __x;
__x = (double)(param_1 + 1);
dVar1 = log(__x);
dVar1 = log(dVar1 / _DAT_00102060 + __x);
return (int)(dVar1 / _DAT_00102060) + param_1 + 1;
} |
3,058 | func0 |
#include <cmath>
#include <assert.h>
| int func0(int n) {
n = n + 1;
return n + static_cast<int>(log(n + log(n) / log(2)) / log(2));
}
| int main() {
assert(func0(7) == 11);
assert(func0(4) == 7);
assert(func0(9) == 13);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %rbx
pxor %xmm1,%xmm1
lea 0x1(%rdi),%ebx
cvtsi2sd %ebx,%xmm1
sub $0x10,%rsp
movapd %xmm1,%xmm0
movsd %xmm1,0x8(%rsp)
callq 1070 <log@plt>
movsd 0x8(%rsp),%xmm1
divsd 0xe47(%rip),%xmm0
addsd %xmm1,%xmm0
callq 1070 <log@plt>
divsd 0xe36(%rip),%xmm0
cvttsd2si %xmm0,%eax
add $0x... | _Z5func0i:
endbr64
push rbx
pxor xmm1, xmm1
lea ebx, [rdi+1]
cvtsi2sd xmm1, ebx
sub rsp, 10h
movapd xmm0, xmm1; x
movsd [rsp+18h+var_10], xmm1
call _log
movsd xmm1, [rsp+18h+var_10]
divsd xmm0, cs:qword_2060
addsd xmm0, xmm1; x
call _log
divsd xmm0, cs:qword_2060
cvttsd2si eax, xmm0
add ... | long long func0(int a1)
{
double v1; // xmm0_8
v1 = log((double)(a1 + 1));
return (unsigned int)(a1 + 1 + (int)(log(v1 / 0.6931471805599453 + (double)(a1 + 1)) / 0.6931471805599453));
} | func0:
ENDBR64
PUSH RBX
PXOR XMM1,XMM1
LEA EBX,[RDI + 0x1]
CVTSI2SD XMM1,EBX
SUB RSP,0x10
MOVAPD XMM0,XMM1
MOVSD qword ptr [RSP + 0x8],XMM1
CALL 0x00101070
MOVSD XMM1,qword ptr [RSP + 0x8]
DIVSD XMM0,qword ptr [0x00102060]
ADDSD XMM0,XMM1
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102060]
CVTTSD2SI EAX,XMM0
ADD RSP,0x10... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
double dVar1;
double __x;
__x = (double)(param_1 + 1);
dVar1 = log(__x);
dVar1 = log(dVar1 / _DAT_00102060 + __x);
return (int)(dVar1 / _DAT_00102060) + param_1 + 1;
} |
3,059 | func0 |
#include <cmath>
#include <assert.h>
| int func0(int n) {
n = n + 1;
return n + static_cast<int>(log(n + log(n) / log(2)) / log(2));
}
| int main() {
assert(func0(7) == 11);
assert(func0(4) == 7);
assert(func0(9) == 13);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %rbx
pxor %xmm1,%xmm1
lea 0x1(%rdi),%ebx
cvtsi2sd %ebx,%xmm1
sub $0x10,%rsp
movapd %xmm1,%xmm0
movsd %xmm1,0x8(%rsp)
callq 1070 <log@plt>
movsd 0x8(%rsp),%xmm1
divsd 0xe47(%rip),%xmm0
addsd %xmm1,%xmm0
callq 1070 <log@plt>
divsd 0xe36(%rip),%xmm0
cvttsd2si %xmm0,%eax
add $0x... | _Z5func0i:
endbr64
push rbx
pxor xmm1, xmm1
lea ebx, [rdi+1]
cvtsi2sd xmm1, ebx
sub rsp, 10h
movapd xmm0, xmm1; x
movsd [rsp+18h+var_10], xmm1
call _log
movsd xmm1, [rsp+18h+var_10]
divsd xmm0, cs:qword_2068
addsd xmm0, xmm1; x
call _log
divsd xmm0, cs:qword_2068
cvttsd2si eax, xmm0
add ... | long long func0(int a1)
{
double v1; // xmm0_8
v1 = log((double)(a1 + 1));
return (unsigned int)(a1 + 1 + (int)(log(v1 / 0.6931471805599453 + (double)(a1 + 1)) / 0.6931471805599453));
} | func0:
ENDBR64
PUSH RBX
PXOR XMM1,XMM1
LEA EBX,[RDI + 0x1]
CVTSI2SD XMM1,EBX
SUB RSP,0x10
MOVAPD XMM0,XMM1
MOVSD qword ptr [RSP + 0x8],XMM1
CALL 0x00101070
MOVSD XMM1,qword ptr [RSP + 0x8]
DIVSD XMM0,qword ptr [0x00102068]
ADDSD XMM0,XMM1
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102068]
CVTTSD2SI EAX,XMM0
ADD RSP,0x10... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
double dVar1;
double __x;
__x = (double)(param_1 + 1);
dVar1 = log(__x);
dVar1 = log(dVar1 / _DAT_00102068 + __x);
return (int)(dVar1 / _DAT_00102068) + param_1 + 1;
} |
3,060 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int, int>> func0(const vector<int>& l1) {
vector<pair<int, int>> temp;
for (size_t i = 0; i < l1.size() - 1; i++) {
temp.push_back({l1[i], l1[i + 1]});
}
return temp;
}
| int main() {
{
vector<pair<int, int>> expected = {{1, 1}, {1, 2}, {2, 3}, {3, 3}, {3, 4}, {4, 4}, {4, 5}};
vector<pair<int, int>> result = func0({1, 1, 2, 3, 3, 4, 4, 5});
assert(result == expected);
}
{
vector<pair<int, int>> expected = {{1, 5}, {5, 7}, {7, 9}, {9, 10... | 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 1b6e <_ZNSt6vectorISt4pairIiiESaIS1_EEC1E... | _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 _ZNSt6vectorISt4pairIiiESaIS1_EEC2Ev; std::vector<std::pair... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
unsigned long long i; // [rsp+18h] [rbp-28h]
_BYTE v6[8]; // [rsp+20h] [rbp-20h] BYREF
unsigned long long v7; // [rsp+28h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::vector<std::pair<int,int>>::vector(a1);
for ( i =... | 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 0x00101bc8
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001012da
LAB_00101283:
MOV R... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int *piVar1;
int *piVar2;
long lVar3;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
ulong local_30;
pair<int,int> local_28 [8];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
st... |
3,061 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int, int>> func0(const vector<int>& l1) {
vector<pair<int, int>> temp;
for (size_t i = 0; i < l1.size() - 1; i++) {
temp.push_back({l1[i], l1[i + 1]});
}
return temp;
}
| int main() {
{
vector<pair<int, int>> expected = {{1, 1}, {1, 2}, {2, 3}, {3, 3}, {3, 4}, {4, 4}, {4, 5}};
vector<pair<int, int>> result = func0({1, 1, 2, 3, 3, 4, 4, 5});
assert(result == expected);
}
{
vector<pair<int, int>> expected = {{1, 5}, {5, 7}, {7, 9}, {9, 10... | 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; // rax
_QWORD *v6; // rsi
_QWORD v8[7]; // [rsp+0h] [rbp-38h] BYREF
v8[1] = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *a2;
if ( a2[1] - *a2 != 4 )
{
v4 = 0LL;
... | 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 0x001012... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int8 *puVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
long in_FS_OFFSET;
int4 local_38;
int4 uStack_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(i... |
3,062 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int, int>> func0(const vector<int>& l1) {
vector<pair<int, int>> temp;
for (size_t i = 0; i < l1.size() - 1; i++) {
temp.push_back({l1[i], l1[i + 1]});
}
return temp;
}
| int main() {
{
vector<pair<int, int>> expected = {{1, 1}, {1, 2}, {2, 3}, {3, 3}, {3, 4}, {4, 4}, {4, 5}};
vector<pair<int, int>> result = func0({1, 1, 2, 3, 3, 4, 4, 5});
assert(result == expected);
}
{
vector<pair<int, int>> expected = {{1, 5}, {5, 7}, {7, 9}, {9, 10... | 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 0x8(%rsi),%r8
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
mov %r8,%rax
movq $0x0,0x8(%rdi)
sub %rdx,%rax
m... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi+8]
mov rax,... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
long long v4; // rdi
long long v6; // rcx
long long v7; // rsi
unsigned long long v8; // rbx
long long v9; // rsi
_QWORD *v10; // rax
_QWORD v12[7]; // [rsp+0h] [rbp-38h] BYREF
v3 = *a2;
v12[1] = __readfsqword(0x28u);
*(_QWORD *... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI + 0x8]
MOV RAX,RDI
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int8 *puVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int8 *puVar5;
long lVar6;
long in_FS_OFFSET;
int8 local_38;
long local_30;
lVar3 = *in_RSI;
local_30 = *(long *)(in_FS_OFFSET + 0x28)... |
3,063 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int, int>> func0(const vector<int>& l1) {
vector<pair<int, int>> temp;
for (size_t i = 0; i < l1.size() - 1; i++) {
temp.push_back({l1[i], l1[i + 1]});
}
return temp;
}
| int main() {
{
vector<pair<int, int>> expected = {{1, 1}, {1, 2}, {2, 3}, {3, 3}, {3, 4}, {4, 4}, {4, 5}};
vector<pair<int, int>> result = func0({1, 1, 2, 3, 3, 4, 4, 5});
assert(result == expected);
}
{
vector<pair<int, int>> expected = {{1, 5}, {5, 7}, {7, 9}, {9, 10... | 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 0x8(%rsi),%r8
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
mov %r8,%rax
movups %xmm0,(%rd... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi+8]
mov rax,... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
long long v4; // rdi
long long v6; // rcx
long long v7; // rsi
unsigned long long v8; // rbx
long long v9; // rsi
_QWORD *v10; // rax
_QWORD v12[7]; // [rsp+0h] [rbp-38h] BYREF
v3 = *a2;
v12[1] = __readfsqword(0x28u);
*(_QWORD *... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI + 0x8]
MOV RAX,RDI
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int8 *puVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int8 *puVar5;
long lVar6;
long in_FS_OFFSET;
int8 local_38;
long local_30;
lVar3 = *in_RSI;
local_30 = *(long *)(in_FS_OFFSET + 0x28)... |
3,064 | func0 |
#include <iostream>
#include <cassert>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 7, -1, 5};
int arr3[] = {1, -2, 3};
assert(func0(arr1, 4, 2) == 6);
assert(func0(arr2, 5, 6) == 3);
assert(func0(arr3, 3, 1) == 1);
std::cout << "All test cases passed!" << std::endl;
return 0;
}
| O0 | cpp | func0(int*, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 1265 <_Z5func0Piii+0x7c>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
... | _Z5func0Piii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_121D
loc_11CB:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_1211
loc_11D6:
mov eax, [... | long long func0(int *a1, int a2, int a3)
{
unsigned int v4; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a3 == a1[i] + a1[j] )
++v4;
}
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010121d
LAB_001011cb:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101211
LAB_0010... | /* func0(int*, int, int) */
int func0(int *param_1,int param_2,int param_3)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (param_3 == param_1[lo... |
3,065 | func0 |
#include <iostream>
#include <cassert>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 7, -1, 5};
int arr3[] = {1, -2, 3};
assert(func0(arr1, 4, 2) == 6);
assert(func0(arr2, 5, 6) == 3);
assert(func0(arr3, 3, 1) == 1);
std::cout << "All test cases passed!" << std::endl;
return 0;
}
| O1 | cpp | func0(int*, int, int):
endbr64
test %esi,%esi
jle 1234 <_Z5func0Piii+0x4b>
lea -0x1(%rsi),%r11d
add $0x1,%r11
mov $0x1,%r10d
mov $0x0,%ecx
cmp %r11,%r10
je 1239 <_Z5func0Piii+0x50>
mov -0x4(%rdi,%r10,4),%r9d
mov %r10,%rax
mov %r9d,%r8d
add (%rdi,%rax,4),%r8d
cmp %edx,%r8d
sete %... | _Z5func0Piii:
endbr64
test esi, esi
jle short loc_1200
push rbx
mov r8, rdi
mov r11d, esi
movsxd rbx, esi
mov r10d, 1
mov ecx, 0
jmp short loc_11CB
loc_11C8:
mov r10, rax
loc_11CB:
cmp r10, r11
jz short loc_11FC
mov r9d, [r8+r10*4-4]
mov rax, r10
loc_11D8:
mov edi... | long long func0(int *a1, int a2, int a3)
{
long long v3; // r10
unsigned int v4; // ecx
long long v5; // rax
if ( a2 <= 0 )
return 0LL;
v3 = 1LL;
v4 = 0;
while ( v3 != a2 )
{
v5 = v3;
do
v4 += a1[v5++] + a1[v3 - 1] == a3;
while ( a2 > (int)v5 );
if ( v3 == a2 )
break;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101200
PUSH RBX
MOV R8,RDI
MOV R11D,ESI
MOVSXD RBX,ESI
MOV R10D,0x1
MOV ECX,0x0
JMP 0x001011cb
LAB_001011c8:
MOV R10,RAX
LAB_001011cb:
CMP R10,R11
JZ 0x001011fc
MOV R9D,dword ptr [R8 + R10*0x4 + -0x4]
MOV RAX,R10
LAB_001011d8:
MOV EDI,R9D
ADD EDI,dword ptr [R8 + RAX*0x4]
CMP EDI,EDX
... | /* func0(int*, int, int) */
int func0(int *param_1,int param_2,int param_3)
{
ulong uVar1;
int iVar2;
ulong uVar3;
bool bVar4;
if (param_2 < 1) {
return 0;
}
iVar2 = 0;
uVar3 = 1;
do {
if (uVar3 == (uint)param_2) {
return iVar2;
}
uVar1 = uVar3;
do {
iVar2 = iVar2 ... |
3,066 | func0 |
#include <iostream>
#include <cassert>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 7, -1, 5};
int arr3[] = {1, -2, 3};
assert(func0(arr1, 4, 2) == 6);
assert(func0(arr2, 5, 6) == 3);
assert(func0(arr3, 3, 1) == 1);
std::cout << "All test cases passed!" << std::endl;
return 0;
}
| O2 | cpp | func0(int*, int, int):
endbr64
test %esi,%esi
jle 1486 <_Z5func0Piii+0x56>
lea -0x1(%rsi),%r11d
mov $0x1,%r10d
xor %r8d,%r8d
add $0x1,%r11
cmp %r11,%r10
je 1482 <_Z5func0Piii+0x52>
xchg %ax,%ax
mov -0x4(%rdi,%r10,4),%r9d
mov %r10,%rax
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%ecx
add... | _Z5func0Piii:
endbr64
test esi, esi
jle short loc_1419
mov r11d, esi
mov r10d, 1
xor ecx, ecx
cmp esi, 1
jz short loc_1416
nop dword ptr [rax+rax+00000000h]
loc_13E0:
mov r9d, [rdi+r10*4-4]
mov rax, r10
nop dword ptr [rax+rax+00000000h]
loc_13F0:
mov r8d, [rdi+rax*4]
add ... | long long func0(int *a1, int a2, int a3)
{
long long v3; // r10
unsigned int v4; // ecx
long long v5; // rax
bool v6; // r8
if ( a2 <= 0 )
return 0LL;
v3 = 1LL;
v4 = 0;
if ( a2 != 1 )
{
do
{
v5 = v3;
do
{
v6 = a3 == a1[v3 - 1] + a1[v5++];
v4 += v6;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101419
MOV R11D,ESI
MOV R10D,0x1
XOR ECX,ECX
CMP ESI,0x1
JZ 0x00101416
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV R9D,dword ptr [RDI + R10*0x4 + -0x4]
MOV RAX,R10
NOP dword ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV R8D,dword ptr [RDI + RAX*0x4]
ADD R8D,R9D
CMP EDX,R8D
SETZ R8B
ADD R... | /* func0(int*, int, int) */
int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
if (param_2 < 1) {
return 0;
}
uVar4 = 1;
iVar3 = 0;
if (param_2 != 1) {
do {
uVar2 = uVar4;
do {
piVar1 = param_1 + uVar2;
uVar2 = u... |
3,067 | func0 |
#include <iostream>
#include <cassert>
| int func0(int arr[], int n, int sum) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] + arr[j] == sum) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 7, -1, 5};
int arr3[] = {1, -2, 3};
assert(func0(arr1, 4, 2) == 6);
assert(func0(arr2, 5, 6) == 3);
assert(func0(arr3, 3, 1) == 1);
std::cout << "All test cases passed!" << std::endl;
return 0;
}
| O3 | cpp | func0(int*, int, int):
endbr64
test %esi,%esi
jle 1591 <_Z5func0Piii+0x171>
cmp $0x1,%esi
je 1591 <_Z5func0Piii+0x171>
push %r14
xor %r9d,%r9d
mov $0x1,%r8d
push %r12
lea -0x1(%rsi),%r12d
push %rbp
mov $0x1,%ebp
push %rbx
mov %rdi,%rbx
mov %edx,%edi
movd %edi,%xmm5
lea 0x4(%rb... | _Z5func0Piii:
endbr64
test esi, esi
jle loc_1390
push r14
push r12
push rbp
push rbx
mov rbx, rdi
mov edi, esi
xor esi, esi
cmp edi, 1
jz loc_1383
movd xmm5, edx
mov r11d, edx
lea r10, [rbx+4]
xor esi, esi
mov ecx, 1
lea r12d, [rdi-1]
mov ebp, 1
pshufd ... | long long func0(int *a1, int a2, unsigned int a3)
{
unsigned int v5; // esi
int *v6; // r10
int v7; // ecx
__m128i v8; // xmm3
unsigned int v9; // r9d
unsigned int v10; // r8d
__m128i v11; // xmm1
const __m128i *v12; // rax
__m128i v13; // xmm2
__m128i v14; // xmm0
__m128i v15; // xmm1
int v16;... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101390
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV EDI,ESI
XOR ESI,ESI
CMP EDI,0x1
JZ 0x00101383
MOVD XMM5,EDX
MOV R11D,EDX
LEA R10,[RBX + 0x4]
XOR ESI,ESI
MOV ECX,0x1
LEA R12D,[RDI + -0x1]
MOV EBP,0x1
PSHUFD XMM3,XMM5,0x0
NOP word ptr [RAX + RAX*0x1]
LAB_00101298:
MOV R8D,ED... | /* func0(int*, int, int) */
int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
uint uVar2;
int iVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int iVar8;
int iVar9;
int *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
if (param_2 < 1) {
return 0;
}
... |
3,068 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
return (parity % 2 == 1);
}
| int main() {
assert(func0(13) == true);
assert(func0(21) == true);
assert(func0(18) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
cmpl $0x0,-0x14(%rbp)
je 1170 <_Z5func0i+0x27>
mov -0x14(%rbp),%eax
sub $0x1,%eax
and %eax,-0x14(%rbp)
addl $0x1,-0x4(%rbp)
jmp 115b <_Z5func0i+0x12>
mov -0x4(%rbp),%eax
cltd
shr $0x1f,%edx
add %... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_116A
loc_115D:
mov eax, [rbp+var_14]
sub eax, 1
and [rbp+var_14], eax
add [rbp+var_4], 1
loc_116A:
cmp [rbp+var_14], 0
jnz short loc_115D
mov edx, [rbp+var_4]
mov eax, edx
s... | bool func0(int a1)
{
int v3; // [rsp+10h] [rbp-4h]
v3 = 0;
while ( a1 )
{
a1 &= a1 - 1;
++v3;
}
return v3 % 2 == 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010116a
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
AND dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010116a:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010115d
MOV EDX,dword ptr [RBP +... | /* func0(int) */
int4 func0(int param_1)
{
int4 local_1c;
int4 local_c;
local_c = 0;
for (local_1c = param_1; local_1c != 0; local_1c = local_1c & local_1c - 1) {
local_c = local_c + 1;
}
return CONCAT31((int3)((uint)(local_c % 2) >> 8),local_c % 2 == 1);
} |
3,069 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
return (parity % 2 == 1);
}
| int main() {
assert(func0(13) == true);
assert(func0(21) == true);
assert(func0(18) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
je 1173 <_Z5func0i+0x2a>
mov $0x0,%eax
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1156 <_Z5func0i+0xd>
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
sete %al
retq
mov %edi,%eax
jmp 1160 <_Z5... | _Z5func0i:
endbr64
test edi, edi
jz short loc_1173
mov eax, 0
loc_1156:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1156
loc_1160:
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
cmp eax, 1
setz al
retn
loc_1173:
mov eax, edi
jmp s... | bool func0(int a1)
{
int v1; // eax
if ( a1 )
{
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
}
else
{
v1 = 0;
}
return v1 % 2 == 1;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101173
MOV EAX,0x0
LAB_00101156:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101156
LAB_00101160:
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
SETZ AL
RET
LAB_00101173:
MOV EAX,EDI
JMP 0x00101160 | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
param_1 = param_1 & param_1 - 1U;
} while (param_1 != 0);
}
return CONCAT31((int3)((uint)(iVar1 % 2) >> 8),iVar1 % 2 == 1);
} |
3,070 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
return (parity % 2 == 1);
}
| int main() {
assert(func0(13) == true);
assert(func0(21) == true);
assert(func0(18) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
je 1160 <_Z5func0i+0x20>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1150 <_Z5func0i+0x10>
and $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
test edi, edi
jz short loc_1160
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1150:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1150
and eax, 1
retn
loc_1160:
xor eax, eax
retn | long long func0(int a1)
{
char v1; // al
if ( !a1 )
return 0LL;
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
return v1 & 1;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101160
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101150
AND EAX,0x1
RET
LAB_00101160:
XOR EAX,EAX
RET | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
if (param_1 != 0) {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1U;
} while (param_1 != 0);
return uVar1 & 1;
}
return 0;
} |
3,071 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
return (parity % 2 == 1);
}
| int main() {
assert(func0(13) == true);
assert(func0(21) == true);
assert(func0(18) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
je 1160 <_Z5func0i+0x20>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1150 <_Z5func0i+0x10>
and $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
test edi, edi
jz short loc_1160
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1150:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1150
and eax, 1
retn
loc_1160:
xor eax, eax
retn | long long func0(int a1)
{
char v1; // al
if ( !a1 )
return 0LL;
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
return v1 & 1;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101160
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101150
AND EAX,0x1
RET
LAB_00101160:
XOR EAX,EAX
RET | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
if (param_1 != 0) {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1U;
} while (param_1 != 0);
return uVar1 & 1;
}
return 0;
} |
3,072 | func0 |
#include <iostream>
#include <vector>
#include <unordered_set>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& li1, const std::vector<int>& li2) {
std::unordered_set<int> set1(li1.begin(), li1.end());
std::unordered_set<int> set2(li2.begin(), li2.end());
std::vector<int> diff;
for(const auto& num : li1) {
if(set2.find(num) == set2.end()) {
... | int main() {
std::vector<int> list1 = {10, 15, 20, 25, 30, 35, 40};
std::vector<int> list2 = {25, 40, 35};
std::vector<int> expected1 = {10, 15, 20, 30};
assert(func0(list1, list2) == expected1);
std::vector<int> list3 = {1, 2, 3, 4, 5};
std::vector<int> list4 = {6, 7, 1};
std::... | 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 $0xe8,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov %rdx,-0xe8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp)... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0F8h
mov [rbp+var_E8], rdi
mov [rbp+var_F0], rsi
mov [rbp+var_F8], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov [rbp+var_A0], rax
nop
nop
mov rax, [rbp+va... | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
int v4; // eax
int v5; // ebx
int v6; // esi
long long v10; // [rsp+20h] [rbp-E0h] BYREF
long long v11; // [rsp+28h] [rbp-D8h] BYREF
long long v12; // [rsp+30h] [rbp-D0h] BYREF
long long v13; // [rsp+38h] [rbp-C8h] BYREF
long ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xf8
MOV qword ptr [RBP + -0xe8],RDI
MOV qword ptr [RBP + -0xf0],RSI
MOV qword ptr [RBP + -0xf8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0xa0],RAX
NOP
NOP
MOV RAX,qword ptr [RBP + -0xf0]
... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
bool bVar1;
char cVar2;
__normal_iterator _Var3;
__normal_iterator _Var4;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
int8 local_... |
3,073 | func0 |
#include <iostream>
#include <vector>
#include <unordered_set>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& li1, const std::vector<int>& li2) {
std::unordered_set<int> set1(li1.begin(), li1.end());
std::unordered_set<int> set2(li2.begin(), li2.end());
std::vector<int> diff;
for(const auto& num : li1) {
if(set2.find(num) == set2.end()) {
... | int main() {
std::vector<int> list1 = {10, 15, 20, 25, 30, 35, 40};
std::vector<int> list2 = {25, 40, 35};
std::vector<int> expected1 = {10, 15, 20, 30};
assert(func0(list1, list2) == expected1);
std::vector<int> list3 = {1, 2, 3, 4, 5};
std::vector<int> list4 = {6, 7, 1};
std::... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xb8,%rsp
mov %rdi,%rbx
mov %rsi,%r13
mov %rdx,%r15
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B0h
mov [rbp+var_C8], rdi
mov r12, rsi
mov r15, rdx
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov rdx, [rsi+8]
mov rsi, [rsi]
lea r1... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
_DWORD *v4; // rbx
_DWORD *v5; // r12
_DWORD *v6; // rsi
_DWORD *v7; // rbx
_DWORD *v8; // r12
_DWORD *v9; // rsi
char v11; // [rsp+2Dh] [rbp-B3h] BYREF
char v12; // [rsp+2Eh] [rbp-B2h] BYREF
char v13; // [rsp+2Fh] [rbp-B1h] BYREF
_BYTE v14[64]; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb0
MOV qword ptr [RBP + -0xc8],RDI
MOV R12,RSI
MOV R15,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RSI + 0x8]
MOV RSI,qword ptr [RSI]
LEA R14,[RBP + -0xb1]
LEA R13,[RBP + -0xb2]
... | /* 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;
int *piVar2;
long lVar3;
long *in_RDX;
int *piVar4;
long in_FS_OFFSET;
equal_to local_bb;
equal_to local_ba;
allocator local_b9;... |
3,074 | func0 |
#include <iostream>
#include <vector>
#include <unordered_set>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& li1, const std::vector<int>& li2) {
std::unordered_set<int> set1(li1.begin(), li1.end());
std::unordered_set<int> set2(li2.begin(), li2.end());
std::vector<int> diff;
for(const auto& num : li1) {
if(set2.find(num) == set2.end()) {
... | int main() {
std::vector<int> list1 = {10, 15, 20, 25, 30, 35, 40};
std::vector<int> list2 = {25, 40, 35};
std::vector<int> expected1 = {10, 15, 20, 30};
assert(func0(list1, list2) == expected1);
std::vector<int> list3 = {1, 2, 3, 4, 5};
std::vector<int> list4 = {6, 7, 1};
std::... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
xor %ecx,%ecx
mov %rsp,%rbp
push %r15
mov %rdx,%r15
push %r14
lea -0xb3(%rbp),%r10
lea -0xb4(%rbp),%r11
push %r13
lea -0xb0(%rbp),%r14
lea -0x70(%rbp),%r13
push %r12
lea ... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
xor ecx, ecx
mov rbp, rsp
push r15
mov r15, rdx
push r14
mov r14, rsi
lea r9, [rbp+var_B1]
push r13
lea r13, [rbp+var_B0]
push r12
lea r12, [rbp+var_70]
push rbx
lea rbx, [rbp+var_B2]
mov r8, rbx
sub rsp, 0B0h
mov... | long long func0(long long a1, unsigned int **a2, unsigned int **a3)
{
unsigned int *v5; // rdx
unsigned int *v6; // rsi
unsigned int *v7; // rsi
long long v8; // rdx
unsigned int *v9; // rbx
unsigned int *i; // r14
unsigned int v11; // r8d
unsigned int *v12; // rbx
unsigned int *v13; // r14
unsigne... | func0:
ENDBR64
PUSH RBP
XOR ECX,ECX
MOV RBP,RSP
PUSH R15
MOV R15,RDX
PUSH R14
MOV R14,RSI
LEA R9,[RBP + -0xb1]
PUSH R13
LEA R13,[RBP + -0xb0]
PUSH R12
LEA R12,[RBP + -0x70]
PUSH RBX
LEA RBX,[RBP + -0xb2]
MOV R8,RBX
SUB RSP,0xb0
MOV qword ptr [RBP + -0xc8],RDI
MOV RDX,qword ptr [RSI + 0x8]
MOV RDI,R13
MOV RSI,qword ptr ... | /* 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;
int *piVar2;
long lVar3;
int8 *in_RDX;
int *piVar4;
int iVar5;
long in_FS_OFFSET;
integral_constant iVar6;
equal_to local_bb;
... |
3,075 | func0 |
#include <iostream>
#include <vector>
#include <unordered_set>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& li1, const std::vector<int>& li2) {
std::unordered_set<int> set1(li1.begin(), li1.end());
std::unordered_set<int> set2(li2.begin(), li2.end());
std::vector<int> diff;
for(const auto& num : li1) {
if(set2.find(num) == set2.end()) {
... | int main() {
std::vector<int> list1 = {10, 15, 20, 25, 30, 35, 40};
std::vector<int> list2 = {25, 40, 35};
std::vector<int> expected1 = {10, 15, 20, 30};
assert(func0(list1, list2) == expected1);
std::vector<int> list3 = {1, 2, 3, 4, 5};
std::vector<int> list4 = {6, 7, 1};
std::... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
xor %ecx,%ecx
mov %rsp,%rbp
push %r15
mov %rdx,%r15
push %r14
lea -0xb3(%rbp),%r10
lea -0xb4(%rbp),%r11
push %r13
lea -0xb0(%rbp),%r14
lea -0x70(%rbp),%r13
push %r12
lea ... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
xor ecx, ecx
mov rbp, rsp
push r15
mov r15, rdx
push r14
lea r14, [rbp+var_B0]
lea r9, [rbp+var_B1]
push r13
lea r13, [rbp+s]
push r12
lea r12, [rbp+var_B2]
push rbx
mov rbx, rsi
mov r8, r12
sub rsp, 0B0h
mov ... | long long func0(long long a1, unsigned int **a2, unsigned int **a3)
{
unsigned int *v5; // rdx
unsigned int *v6; // rsi
_QWORD *v7; // r8
_QWORD *v8; // r9
unsigned int *v9; // r12
unsigned int *v10; // rbx
_DWORD *v11; // rax
long long v12; // rcx
unsigned int *v13; // rbx
unsigned int *v14; // r1... | func0:
ENDBR64
PUSH RBP
XOR ECX,ECX
MOV RBP,RSP
PUSH R15
MOV R15,RDX
PUSH R14
LEA R14,[RBP + -0xb0]
LEA R9,[RBP + -0xb1]
PUSH R13
LEA R13,[RBP + -0x70]
PUSH R12
LEA R12,[RBP + -0xb2]
PUSH RBX
MOV RBX,RSI
MOV R8,R12
SUB RSP,0xb0
MOV qword ptr [RBP + -0xc8],RDI
MOV RDX,qword ptr [RSI + 0x8]
MOV RDI,R14
MOV RSI,qword ptr ... | /* 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 iVar2;
int *piVar3;
int8 *puVar4;
long *plVar5;
long *plVar6;
int *piVar7;
long *plVar8;
int8 *in_RDX;
int *piVar9;
long i... |
3,076 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = 2 * i - 1;
sm += j * j * j * j;
}
return sm;
}
| int main() {
assert(func0(2) == 82);
assert(func0(3) == 707);
assert(func0(4) == 3108);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 11d3 <_Z5func0i+0x4a>
mov -0x8(%rbp),%eax
add %eax,%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
mov [rbp+var_C], 0
mov [rbp+var_8], 1
jmp short loc_118B
loc_116B:
mov eax, [rbp+var_8]
add eax, eax
sub eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+va... | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += (2 * i - 1) * (2 * i - 1) * (2 * i - 1) * (2 * i - 1);
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010118b
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 1; local_10 <= param_1; local_10 = local_10 + 1) {
iVar1 = local_10 * 2 + -1;
local_14 = local_14 + iVar1 * iVar1 * iVar1 * iVar1;
}
return local_14;
} |
3,077 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = 2 * i - 1;
sm += j * j * j * j;
}
return sm;
}
| int main() {
assert(func0(2) == 82);
assert(func0(3) == 707);
assert(func0(4) == 3108);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11b3 <_Z5func0i+0x2a>
lea 0x1(%rdi,%rdi,1),%esi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %edx,%edx
add %edx,%ecx
add $0x2,%eax
cmp %esi,%eax
jne 119f <_Z5func0i+0x16>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 11b0 <_Z5func0... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1173
lea esi, [rdi+rdi+1]
mov eax, 1
mov ecx, 0
loc_115F:
mov edx, eax
imul edx, eax
imul edx, edx
add ecx, edx
add eax, 2
cmp eax, esi
jnz short loc_115F
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short lo... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 1;
v2 = 0;
do
{
v2 += v1 * v1 * v1 * v1;
v1 += 2;
}
while ( v1 != 2 * a1 + 1 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
LEA ESI,[RDI + RDI*0x1 + 0x1]
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115f:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EDX
ADD ECX,EDX
ADD EAX,0x2
CMP EAX,ESI
JNZ 0x0010115f
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
} while (iVar1 != param_1 * 2 + 1);
}
return iVar2;
} |
3,078 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = 2 * i - 1;
sm += j * j * j * j;
}
return sm;
}
| int main() {
assert(func0(2) == 82);
assert(func0(3) == 707);
assert(func0(4) == 3108);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11f0 <_Z5func0i+0x30>
lea 0x1(%rdi,%rdi,1),%ecx
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add $0x2,%eax
imul %edx,%edx
add %edx,%r8d
cmp %ecx,%eax
jne 11d8 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor ... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1170
lea esi, [rdi+rdi+1]
mov eax, 1
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 2
imul edx, edx
add ecx, edx
cmp eax, esi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
int v3; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = v1 * v1;
v1 += 2;
v2 += v3 * v3;
}
while ( v1 != 2 * a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ESI,[RDI + RDI*0x1 + 0x1]
MOV EAX,0x1
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
IMUL EDX,EDX
ADD ECX,EDX
CMP EAX,ESI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar2 = iVar2 + iVar3 * iVar3;
} while (iVar1 != param_1 * 2 + 1);
return iVar2;
}
return 0;
} |
3,079 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = 2 * i - 1;
sm += j * j * j * j;
}
return sm;
}
| int main() {
assert(func0(2) == 82);
assert(func0(3) == 707);
assert(func0(4) == 3108);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 12e0 <_Z5func0i+0x120>
lea -0x1(%rdi),%eax
cmp $0x29,%eax
jbe 12e7 <_Z5func0i+0x127>
mov %edi,%edx
movdqa 0xe2e(%rip),%xmm5
xor %eax,%eax
pxor %xmm4,%xmm4
movdqa 0xe30(%rip),%xmm7
shr $0x2,%edx
pcmpeqd %xmm6,%xmm6
nopw 0x0(%rax,%rax,1)
movdqa %xmm5,%xmm0... | _Z5func0i:
endbr64
test edi, edi
jle loc_1250
lea eax, [rdi-1]
cmp eax, 19h
jbe loc_1255
mov edx, edi
movdqa xmm4, cs:xmmword_2010
xor eax, eax
pxor xmm3, xmm3
movdqa xmm6, cs:xmmword_2020
shr edx, 2
pcmpeqd xmm5, xmm5
nop word ptr [rax+rax+00000000h]
loc_1180:
movdqa xmm0, xmm4... | long long func0(int a1)
{
__m128i si128; // xmm4
int v2; // eax
__m128i v3; // xmm3
__m128i v4; // xmm6
__m128i v5; // xmm0
__m128i v6; // xmm0
__m128i v7; // xmm7
__m128i v8; // xmm1
__m128i v9; // xmm1
__m128i v10; // xmm3
signed int v11; // esi
unsigned int v12; // edx
int v13; // ecx
in... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101250
LEA EAX,[RDI + -0x1]
CMP EAX,0x19
JBE 0x00101255
MOV EDX,EDI
MOVDQA XMM4,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM3,XMM3
MOVDQA XMM6,xmmword ptr [0x00102020]
SHR EDX,0x2
PCMPEQD XMM5,XMM5
NOP word ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQA XMM0,XMM4
ADD EAX,0x1
PADDD XMM4,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
int auVar5 [16];
int auVar6 [16];
long lVar8;
int auVar7 [16];
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13... |
3,080 | func0 |
#include <iostream>
#include <deque>
#include <assert.h>
| bool func0(std::string exp) {
if (exp.length() % 2 != 0) {
return false;
}
std::deque<char> stack;
for (char ch : exp) {
if (ch == '(' || ch == '{' || ch == '[') {
stack.push_back(ch);
}
if (ch == ')' || ch == '}' || ch == ']') {
if (stac... | int main() {
assert(func0("{()}[{}]") == true);
assert(func0("{()}[{]") == false);
assert(func0("{()}[{}][]({})") == true);
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 $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 2390 <_ZNKSt7__cxx1112basic_str... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_98]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaI... | long long func0(long long a1)
{
unsigned int v1; // ebx
char v3; // [rsp+16h] [rbp-8Ah] BYREF
char v4; // [rsp+17h] [rbp-89h]
long long v5; // [rsp+18h] [rbp-88h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-80h] BYREF
_BYTE v7[88]; // [rsp+30h] [rbp-70h] BYREF
unsigned long long v8; // [rsp+88h] [rbp-18h]
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV RDI,RAX
CALL 0x00102340
AND EAX,0x1
TEST RAX,RAX
SETNZ AL
TEST AL,AL
JZ 0x001024d5
MOV EBX,0x0
JMP 0x0010264a
LAB_001024d5... | /* func0(std::string) */
int4 func0(int8 param_1)
{
char cVar1;
bool bVar2;
uint uVar3;
int4 uVar4;
char *pcVar5;
long in_FS_OFFSET;
char local_92;
char local_91;
int8 local_90;
int8 local_88;
int8 local_80;
deque<char,std::allocator<char>> local_78 [88];
long local_20;
local_20 = *(lon... |
3,081 | func0 |
#include <iostream>
#include <deque>
#include <assert.h>
| bool func0(std::string exp) {
if (exp.length() % 2 != 0) {
return false;
}
std::deque<char> stack;
for (char ch : exp) {
if (ch == '(' || ch == '{' || ch == '[') {
stack.push_back(ch);
}
if (ch == ')' || ch == '}' || ch == ']') {
if (stac... | int main() {
assert(func0("{()}[{}]") == true);
assert(func0("{()}[{]") == false);
assert(func0("{()}[{}][]({})") == true);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov $0x0,%ebx
testb $0x1,0x8(%rdi)
je 1373 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_t... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 70h
mov rax, fs:28h
mov [rsp+98h+var_30], rax
xor eax, eax
mov ebx, 0
test byte ptr [rdi+8], 1
jz short loc_1397
loc_1374:
mov rax, [rsp+98h+var_30]
... | long long func0(long long a1)
{
long long v1; // rbx
char *v3; // rax
unsigned __int8 *v4; // r12
unsigned __int8 *v5; // rbp
char *v6; // rax
char v7; // r13
long long v8; // r14
char v9; // r13
unsigned __int8 v10; // [rsp+Fh] [rbp-89h] BYREF
_QWORD v11[2]; // [rsp+10h] [rbp-88h] BYREF
char *v1... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV EBX,0x0
TEST byte ptr [RDI + 0x8],0x1
JZ 0x00101397
LAB_00101374:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010161d
MOV EAX,EBX
ADD RSP,0x70
POP RBX... | /* func0(std::string) */
ulong func0(int8 *param_1)
{
byte bVar1;
long lVar2;
void *pvVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
byte bVar7;
long in_FS_OFFSET;
byte local_89;
void *local_88;
int8 local_80;
byte *local_78;
byte *local_70;
byte *local_68;
long local_60;
byte *local_5... |
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.