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,782 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& list1, const std::vector<std::vector<std::string>>& list2) {
std::vector<std::vector<std::string>> result;
for (size_t i = 0; i < list1.size(); ++i) {
std::vector<std::string> combined = list1[i];
combin... | int main() {
assert(func0({{"1", "3"}, {"5", "7"}, {"9", "11"}}, {{"2", "4"}, {"6", "8"}, {"10", "12", "14"}}) == std::vector<std::vector<std::string>>({{"1", "3", "2", "4"}, {"5", "7", "6", "8"}, {"9", "11", "10", "12", "14"}}));
assert(func0({{"1", "2"}, {"3", "4"}, {"5", "6"}}, {{"7", "8"}, {"9", "10"}, {"... | O2 | cpp | func0(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0RKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EESB_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_88], rdi
mov [rsp+98h+var_70], rsi
mov [rsp+98h+var_78], rdx
mov rax, fs:28... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v3; // rbp
unsigned long long v4; // r13
long long *v5; // rbp
long long v6; // rsi
long long v7; // rdi
signed long long v8; // rax
char **v9; // rax
char **v10; // rbx
long long *v11; // r12
long long v12; // r15
long long v13... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RBP,qword ptr [RSI]
MOV q... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&,
std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&... |
2,783 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& list1, const std::vector<std::vector<std::string>>& list2) {
std::vector<std::vector<std::string>> result;
for (size_t i = 0; i < list1.size(); ++i) {
std::vector<std::string> combined = list1[i];
combin... | int main() {
assert(func0({{"1", "3"}, {"5", "7"}, {"9", "11"}}, {{"2", "4"}, {"6", "8"}, {"10", "12", "14"}}) == std::vector<std::vector<std::string>>({{"1", "3", "2", "4"}, {"5", "7", "6", "8"}, {"9", "11", "10", "12", "14"}}));
assert(func0({{"1", "2"}, {"3", "4"}, {"5", "6"}}, {{"7", "8"}, {"9", "10"}, {"... | O3 | cpp | func0(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0RKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EESB_:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
push r14
push r13
xor r13d, r13d
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_70], rsi
mov [rsp+98h+var_78], rdx
mov rax,... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
unsigned long long v4; // r13
long long v5; // rbx
long long *v6; // rbx
long long v7; // rsi
long long v8; // rdi
signed long long v9; // r14
char *v10; // rax
char *v11; // rbp
char *v12; // rbx
long long *v13; // r12
long long v14; // ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
PUSH R14
PUSH R13
XOR R13D,R13D
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV qword ... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&,
std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&... |
2,784 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 9, 10}) == 3);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 5);
assert(func0({1, 2, 4, 8, 9}) == 3);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1676 <... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_28], 0
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5... | long long func0(long long a1)
{
unsigned int v2; // [rsp+18h] [rbp-28h]
long long v3; // [rsp+20h] [rbp-20h] BYREF
_QWORD v4[3]; // [rsp+28h] [rbp-18h] BYREF
v4[2] = __readfsqword(0x28u);
v2 = 0;
v4[1] = a1;
v3 = std::vector<int>::begin(a1);
v4[0] = std::vector<int>::end(a1);
while ( (unsigned __int... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101636
MOV qword pt... | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
bool bVar1;
uint *puVar2;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0;
l... |
2,785 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 9, 10}) == 3);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 5);
assert(func0({1, 2, 4, 8, 9}) == 3);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rsi
cmp %rsi,%rax
je 1275 <_Z5func0RKSt6vectorIiSaIiEE+0x2c>
mov $0x0,%ecx
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%ecx
add $0x4,%rax
cmp %rax,%rsi
jne 125e <_Z5func0RKSt6vector... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rsi, [rdi+8]
cmp rsi, rax
jz short loc_1235
mov ecx, 0
loc_121E:
mov edx, [rax]
and edx, 1
cmp edx, 1
adc ecx, 0
add rax, 4
cmp rax, rsi
jnz short loc_121E
loc_1232:
mov eax, ecx
retn
loc_1235:
mov ecx, 0
jm... | long long func0(long long a1)
{
_DWORD *v1; // rax
_DWORD *v2; // rsi
unsigned int v3; // ecx
v1 = *(_DWORD **)a1;
v2 = *(_DWORD **)(a1 + 8);
if ( v2 == *(_DWORD **)a1 )
{
return 0;
}
else
{
v3 = 0;
do
v3 += (*v1++ & 1) == 0;
while ( v1 != v2 );
}
return v3;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
CMP RSI,RAX
JZ 0x00101235
MOV ECX,0x0
LAB_0010121e:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
ADC ECX,0x0
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010121e
LAB_00101232:
MOV EAX,ECX
RET
LAB_00101235:
MOV ECX,0x0
JMP 0x00101232 | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
int iVar2;
puVar1 = *(uint **)param_1;
if (*(uint **)(param_1 + 8) == puVar1) {
iVar2 = 0;
}
else {
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((*puVar1 & 1) == 0);
puVar1 = puVar1 +... |
2,786 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 9, 10}) == 3);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 5);
assert(func0({1, 2, 4, 8, 9}) == 3);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
xor %r8d,%r8d
cmp %rcx,%rax
je 14fd <_Z5func0RKSt6vectorIiSaIiEE+0x2d>
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x4,%rax
cmp %rax,%rcx
jne 1... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rsi, [rdi+8]
xor ecx, ecx
cmp rsi, rax
jz short loc_141C
nop word ptr [rax+rax+00h]
loc_1408:
mov edx, [rax]
and edx, 1
cmp edx, 1
adc ecx, 0
add rax, 4
cmp rsi, rax
jnz short loc_1408
loc_141C:
mov eax, ecx... | long long func0(long long a1)
{
_DWORD *v1; // rax
_DWORD *v2; // rsi
unsigned int v3; // ecx
v1 = *(_DWORD **)a1;
v2 = *(_DWORD **)(a1 + 8);
v3 = 0;
if ( v2 != *(_DWORD **)a1 )
{
do
v3 += (*v1++ & 1) == 0;
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
XOR ECX,ECX
CMP RSI,RAX
JZ 0x0010141c
NOP word ptr [RAX + RAX*0x1]
LAB_00101408:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
ADC ECX,0x0
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x00101408
LAB_0010141c:
MOV EAX,ECX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
int iVar2;
iVar2 = 0;
for (puVar1 = *(uint **)param_1; *(uint **)(param_1 + 8) != puVar1; puVar1 = puVar1 + 1) {
iVar2 = iVar2 + (uint)((*puVar1 & 1) == 0);
}
return iVar2;
} |
2,787 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 9, 10}) == 3);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 5);
assert(func0({1, 2, 4, 8, 9}) == 3);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rsi
cmp %rsi,%rdx
je 17d8 <_Z5func0RKSt6vectorIiSaIiEE+0xf8>
lea -0x4(%rsi),%rcx
mov %rdx,%rax
movabs $0x3ffffffffffffffc,%r8
sub %rdx,%rcx
shr $0x2,%rcx
lea 0x1(%rcx),%rdi
test %r8,%rcx
je 17e... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rdx, [rdi]
mov rdi, [rdi+8]
cmp rdi, rdx
jz loc_16D8
lea rcx, [rdi-4]
mov rax, rdx
sub rcx, rdx
mov rsi, rcx
shr rsi, 2
add rsi, 1
cmp rcx, 8
jbe loc_16E1
mov rcx, rsi
pxor xmm1, xmm1
movdqa xmm3, cs:xmmword_20F0
shr r... | long long func0(const __m128i **a1)
{
const __m128i *v1; // rdx
const __m128i *v2; // rdi
const __m128i *v3; // rax
unsigned long long v4; // rsi
__m128i v5; // xmm1
__m128i si128; // xmm3
__m128i v7; // xmm0
__m128i v8; // xmm1
long long result; // rax
v1 = *a1;
v2 = a1[1];
if ( v2 == v1 )
... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RDX
JZ 0x001016d8
LEA RCX,[RDI + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RSI,RCX
SHR RSI,0x2
ADD RSI,0x1
CMP RCX,0x8
JBE 0x001016e1
MOV RCX,RSI
PXOR XMM1,XMM1
MOVDQA XMM3,xmmword ptr [0x001020f0]
SHR RCX,0x2
MOVDQA XMM2,XMM1
SHL RCX,0x4
ADD RCX,RDX
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
ulong uVar7;
uint *puVar8;
ulong uVar9;
int... |
2,788 | func0 |
#include <map>
#include <utility>
#include <cassert>
using namespace std;
typedef pair<int, int> pii;
struct Compare {
bool operator() (const pii& a, const pii& b) const {
int key_a = a.first * a.second;
int key_b = b.first * b.second;
if (key_a != key_b)
return... | map<pii, int, Compare> func0(const map<pii, int, Compare>& test_dict) {
return map<pii, int, Compare>(test_dict.begin(), test_dict.end());
}
| int main() {
map<pii, int, Compare> expected1 = { {{2,3},9}, {{6,4},12}, {{5,6},3}, {{8,4},10} };
assert(func0(map<pii, int, Compare>{{{5,6},3}, {{2,3},9}, {{8,4},10}, {{6,4},12}}) == expected1);
map<pii, int, Compare> expected2 = { {{3,4},10}, {{7,5},13}, {{6,7},4}, {{9,5},11} };
assert(func0... | O0 | cpp | func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int> const, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1d04 <_ZNKSt3mapISt4pairIiiEi7Compare... | _Z5func0RKSt3mapISt4pairIiiEi7CompareSaIS0_IKS1_iEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNKSt3mapISt4pairIiiEi7CompareSaIS0_IKS1_iEEE3endEv; std::map<std::pair<int,int>,int,Compare,std... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
v2 = std::map<std::pair<int,int>,int,Compare,std::allocator<std::pair<std::pair<int,int> const,int>>>::end(a2);
v3 = std::map<std::pair<int,int>,int,Compare,std::allocator<std::pair<std::pair<int,int> const,int>>>::begin(a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101cb0
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101c92
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RBX
MOV RSI,RC... | /* func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int>
const, int> > > const&) */
map * func0(map *param_1)
{
_Rb_tree_const_iterator _Var1;
_Rb_tree_const_iterator _Var2;
map<std::pair<int,int>,int,Compare,std::allocator<std::pair<std::pair<int,int>const,int>>> *in... |
2,789 | func0 |
#include <map>
#include <utility>
#include <cassert>
using namespace std;
typedef pair<int, int> pii;
struct Compare {
bool operator() (const pii& a, const pii& b) const {
int key_a = a.first * a.second;
int key_b = b.first * b.second;
if (key_a != key_b)
return... | map<pii, int, Compare> func0(const map<pii, int, Compare>& test_dict) {
return map<pii, int, Compare>(test_dict.begin(), test_dict.end());
}
| int main() {
map<pii, int, Compare> expected1 = { {{2,3},9}, {{6,4},12}, {{5,6},3}, {{8,4},10} };
assert(func0(map<pii, int, Compare>{{{5,6},3}, {{2,3},9}, {{8,4},10}, {{6,4},12}}) == expected1);
map<pii, int, Compare> expected2 = { {{3,4},10}, {{7,5},13}, {{6,7},4}, {{9,5},11} };
assert(func0... | O1 | cpp | func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int> const, int> > > const&):
endbr64
push %r15
push %r14
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
lea 0x8(%rsi),%r13
mov... | _Z5func0RKSt3mapISt4pairIiiEi7CompareSaIS0_IKS1_iEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
lea r13, [rsi+8]
mov rbx, [rsi+18h]
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+1... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
_QWORD v4[7]; // [rsp+0h] [rbp-38h] BYREF
v4[1] = __readfsqword(0x28u);
v2 = *(_QWORD *)(a2 + 24);
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA R13,[RSI + 0x8]
MOV RBX,qword ptr [RSI + 0x18]
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R12,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],R12
MO... | /* func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int>
const, int> > > const&) */
map * func0(map *param_1)
{
pair *ppVar1;
long lVar2;
_Rb_tree_node_base *p_Var3;
long in_RSI;
long in_FS_OFFSET;
lVar2 = *(long *)(in_FS_OFFSET + 0x28);
p_Var3 = *(_Rb_tree... |
2,790 | func0 |
#include <map>
#include <utility>
#include <cassert>
using namespace std;
typedef pair<int, int> pii;
struct Compare {
bool operator() (const pii& a, const pii& b) const {
int key_a = a.first * a.second;
int key_b = b.first * b.second;
if (key_a != key_b)
return... | map<pii, int, Compare> func0(const map<pii, int, Compare>& test_dict) {
return map<pii, int, Compare>(test_dict.begin(), test_dict.end());
}
| int main() {
map<pii, int, Compare> expected1 = { {{2,3},9}, {{6,4},12}, {{5,6},3}, {{8,4},10} };
assert(func0(map<pii, int, Compare>{{{5,6},3}, {{2,3},9}, {{8,4},10}, {{6,4},12}}) == expected1);
map<pii, int, Compare> expected2 = { {{3,4},10}, {{7,5},13}, {{6,7},4}, {{9,5},11} };
assert(func0... | O2 | cpp | func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int> const, int> > > const&):
endbr64
push %r14
push %r13
lea 0x8(%rsi),%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
lea 0x8(%rdi),%rbx
sub $0x10,%rsp
mov 0x18(%rsi),%rbp
mov %fs:0x28,%rax
mov %r... | _Z5func0RKSt3mapISt4pairIiiEi7CompareSaIS0_IKS1_iEEE:
endbr64
push r14
push r13
lea r13, [rsi+8]
push r12
lea r12, [rdi+8]
push rbp
mov rbp, rdi
push rbx
mov rbx, [rsi+18h]
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rdi+18h], r12
mov [rdi+20h], r12
mov qw... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long insert_hint_unique_pos; // rax
long long v4; // rdx
v2 = *(_QWORD *)(a2 + 24);
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
for ( *(_QWORD *)(a1 + 40) = ... | func0:
ENDBR64
PUSH R14
PUSH R13
LEA R13,[RSI + 0x8]
PUSH R12
LEA R12,[RDI + 0x8]
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,qword ptr [RSI + 0x18]
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R12
MOV qword ptr [RDI + 0x20],R12
MOV qword ptr [RDI + 0x28],0x0
CMP RBX,R13
JZ 0x001019... | /* func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int>
const, int> > > const&) */
map * func0(map *param_1)
{
map *pmVar1;
_Rb_tree_node_base *p_Var2;
long in_RSI;
int auVar3 [16];
pmVar1 = param_1 + 8;
p_Var2 = *(_Rb_tree_node_base **)(in_RSI + 0x18);
*(... |
2,791 | func0 |
#include <map>
#include <utility>
#include <cassert>
using namespace std;
typedef pair<int, int> pii;
struct Compare {
bool operator() (const pii& a, const pii& b) const {
int key_a = a.first * a.second;
int key_b = b.first * b.second;
if (key_a != key_b)
return... | map<pii, int, Compare> func0(const map<pii, int, Compare>& test_dict) {
return map<pii, int, Compare>(test_dict.begin(), test_dict.end());
}
| int main() {
map<pii, int, Compare> expected1 = { {{2,3},9}, {{6,4},12}, {{5,6},3}, {{8,4},10} };
assert(func0(map<pii, int, Compare>{{{5,6},3}, {{2,3},9}, {{8,4},10}, {{6,4},12}}) == expected1);
map<pii, int, Compare> expected2 = { {{3,4},10}, {{7,5},13}, {{6,7},4}, {{9,5},11} };
assert(func0... | O3 | cpp | func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int> const, int> > > const&):
endbr64
push %r15
lea 0x8(%rsi),%r15
push %r14
lea 0x8(%rdi),%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x18(%rsi),%rbp
movl $0x0,0x8(%rd... | _Z5func0RKSt3mapISt4pairIiiEi7CompareSaIS0_IKS1_iEEE:
endbr64
push r15
lea rax, [rdi+8]
lea rcx, [rsi+8]
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov rbx, [rsi+18h]
mov dword ptr [rdi+8], 0
mov [rsp+48h+var_40], rcx
mov qword ptr [rdi+10h],... | long long func0(long long a1, long long a2)
{
_DWORD *v2; // rbx
long long v3; // r13
signed int v4; // r14d
signed int v5; // r15d
long long v6; // rbp
int v7; // edx
int v8; // eax
int v9; // r9d
int v10; // esi
bool v11; // r13
long long insert_unique_pos; // rax
long long v13; // rdx
long... | func0:
ENDBR64
PUSH R15
LEA RAX,[RDI + 0x8]
LEA RCX,[RSI + 0x8]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,qword ptr [RSI + 0x18]
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI + 0x18],RAX
MOV qword... | /* func0(std::map<std::pair<int, int>, int, Compare, std::allocator<std::pair<std::pair<int, int>
const, int> > > const&) */
map * func0(map *param_1)
{
_Rb_tree_node_base *p_Var1;
int iVar2;
int iVar3;
int iVar4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
i... |
2,792 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(std::string str1, std::string str2) {
int count = 0;
for (int i = 0; i < str1.length(); ++i) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return (count / 2);
} else {
return -1; // Using -1 to indicate "Not Possible"
... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("1111", "0100") == -1);
assert(func0("1110000", "0001101") == 3);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_13AF
loc_136E:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, ... | long long func0(long long a1, long long a2)
{
char v2; // bl
int v4; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
v2 = *(_BYTE *)std::string::operator[](a1, i);
if ( v2 != *(_BYTE *)std::string::operator[](a2, i)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013af
LAB_0010136e:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CA... | /* func0(std::string, std::string) */
int func0(ulong param_1,ulong param_2)
{
char cVar1;
int iVar2;
char *pcVar3;
ulong uVar4;
int4 local_20;
int4 local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
uVar4 = std::string::length();
if (uVar4 <= (ulong)(long)local_1c) break;
pcVar3 =... |
2,793 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(std::string str1, std::string str2) {
int count = 0;
for (int i = 0; i < str1.length(); ++i) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return (count / 2);
} else {
return -1; // Using -1 to indicate "Not Possible"
... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("1111", "0100") == -1);
assert(func0("1110000", "0001101") == 3);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r8
test %r8,%r8
je 128d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_+0x44>
mov (%rdi),%rdi
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
mov rcx, [rdi+8]
test rcx, rcx
jz short loc_1270
mov rdi, [rdi]
mov rsi, [rsi]
mov eax, 0
mov edx, 0
jmp short loc_1251
loc_1248:
add rax, 1
cmp rax, rcx
jz short loc_1261
loc_1251:
movzx r8d, byte pt... | long long func0(long long *a1, long long *a2)
{
long long v2; // rcx
long long v3; // rdi
long long v4; // rsi
long long v5; // rax
int v6; // edx
v2 = a1[1];
if ( !v2 )
{
v6 = 0;
return (unsigned int)(v6 / 2);
}
v3 = *a1;
v4 = *a2;
v5 = 0LL;
v6 = 0;
do
{
if ( *(_BYTE *)(v3 +... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
TEST RCX,RCX
JZ 0x00101270
MOV RDI,qword ptr [RDI]
MOV RSI,qword ptr [RSI]
MOV EAX,0x0
MOV EDX,0x0
JMP 0x00101251
LAB_00101248:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x00101261
LAB_00101251:
MOVZX R8D,byte ptr [RSI + RAX*0x1]
CMP byte ptr [RDI + RAX*0x1],R8B
JZ 0x00101248
ADD EDX,0x1
J... | /* func0(std::string, std::string) */
int func0(long *param_1,long *param_2)
{
long lVar1;
uint uVar2;
if (param_1[1] == 0) {
uVar2 = 0;
}
else {
lVar1 = 0;
uVar2 = 0;
do {
if (*(char *)(*param_1 + lVar1) != *(char *)(*param_2 + lVar1)) {
uVar2 = uVar2 + 1;
}
lVa... |
2,794 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(std::string str1, std::string str2) {
int count = 0;
for (int i = 0; i < str1.length(); ++i) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return (count / 2);
} else {
return -1; // Using -1 to indicate "Not Possible"
... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("1111", "0100") == -1);
assert(func0("1110000", "0001101") == 3);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r8
test %r8,%r8
je 15b0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_+0x50>
mov (%rdi),%rdi
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
mov rcx, [rdi+8]
test rcx, rcx
jz short loc_1460
mov rdi, [rdi]
mov rsi, [rsi]
xor eax, eax
xor edx, edx
nop word ptr [rax+rax+00000000h]
loc_1430:
movzx r8d, byte ptr [rsi+rax]
cmp [rdi+rax], r8b
jz shor... | long long func0(long long *a1, long long *a2)
{
long long v2; // rcx
long long v3; // rdi
long long v4; // rsi
long long v5; // rax
int v6; // edx
v2 = a1[1];
if ( !v2 )
return 0LL;
v3 = *a1;
v4 = *a2;
v5 = 0LL;
v6 = 0;
do
{
if ( *(_BYTE *)(v3 + v5) != *(_BYTE *)(v4 + v5) )
++v... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
TEST RCX,RCX
JZ 0x00101460
MOV RDI,qword ptr [RDI]
MOV RSI,qword ptr [RSI]
XOR EAX,EAX
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101430:
MOVZX R8D,byte ptr [RSI + RAX*0x1]
CMP byte ptr [RDI + RAX*0x1],R8B
JZ 0x0010143e
ADD EDX,0x1
LAB_0010143e:
ADD RAX,0x1
CMP RCX,RAX
J... | /* func0(std::string, std::string) */
int func0(long *param_1,long *param_2)
{
long lVar1;
uint uVar2;
if (param_1[1] == 0) {
return 0;
}
lVar1 = 0;
uVar2 = 0;
do {
if (*(char *)(*param_1 + lVar1) != *(char *)(*param_2 + lVar1)) {
uVar2 = uVar2 + 1;
}
lVar1 = lVar1 + 1;
} whil... |
2,795 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| int func0(std::string str1, std::string str2) {
int count = 0;
for (int i = 0; i < str1.length(); ++i) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return (count / 2);
} else {
return -1; // Using -1 to indicate "Not Possible"
... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("1111", "0100") == -1);
assert(func0("1110000", "0001101") == 3);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r8
test %r8,%r8
je 1fe0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_+0x2d0>
lea -0x1(%r8),%rax
m... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
mov r8, [rdi+8]
test r8, r8
jz loc_1DA8
lea rax, [r8-1]
mov rdi, [rdi]
mov rcx, [rsi]
cmp rax, 0Eh
jbe loc_1DAB
mov rdx, r8
pxor xmm1, xmm1
pxor xmm5, xmm5
xor eax, eax
and rdx, 0FFFFFFFFFFFFFFF0h
... | long long func0(long long *a1, long long *a2)
{
unsigned long long v2; // r8
long long v3; // rdi
long long v4; // rcx
__m128i v5; // xmm1
long long v6; // rax
unsigned long long v7; // rdx
__m128i v8; // xmm0
__m128i v9; // xmm7
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2
__... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x00101da8
LEA RAX,[R8 + -0x1]
MOV RDI,qword ptr [RDI]
MOV RCX,qword ptr [RSI]
CMP RAX,0xe
JBE 0x00101dab
MOV RDX,R8
PXOR XMM1,XMM1
PXOR XMM5,XMM5
XOR EAX,EAX
AND RDX,-0x10
PXOR XMM4,XMM4
NOP word ptr [RAX + RAX*0x1]
LAB_00101bb0:
MOVDQU XMM0,xmmword ptr [RDI + ... | /* func0(std::string, std::string) */
int func0(long *param_1,long *param_2)
{
char *pcVar1;
char *pcVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
long lVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;
bool bVar13;
bool bVar14;
int auVar15 [14];
int auVar16... |
2,796 | func0 |
#include <vector>
#include <string>
#include <assert.h>
template <typename T>
| int func0(const std::vector<T>& li, T min, T max) {
int ctr = 0;
for (T x : li) {
if (min <= x && x <= max) {
ctr += 1;
}
}
return ctr;
}
| int main() {
assert(func0(std::vector<int>{10,20,30,40,40,40,70,80,99}, 40, 100) == 6);
assert(func0(std::vector<char>{'a','b','c','d','e','f'}, 'a', 'e') == 5);
assert(func0(std::vector<int>{7,8,9,15,17,19,45}, 15, 20) == 3);
return 0;
}
| O0 | cpp | int func0<int>(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax... | _Z5func0IiEiRKSt6vectorIT_SaIS1_EES1_S1_:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_28], 0
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov ... | long long func0<int>(long long a1, int a2, int a3)
{
unsigned int v5; // [rsp+18h] [rbp-28h]
int v6; // [rsp+1Ch] [rbp-24h]
long long v7; // [rsp+20h] [rbp-20h] BYREF
_QWORD v8[3]; // [rsp+28h] [rbp-18h] BYREF
v8[2] = __readfsqword(0x28u);
v5 = 0;
v8[1] = a1;
v7 = std::vector<int>::begin(a1);
v8[0] ... | func0<int>:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV... | /* int func0<int>(std::vector<int, std::allocator<int> > const&, int, int) */
int func0<int>(vector *param_1,int param_2,int param_3)
{
bool bVar1;
int *piVar2;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(lo... |
2,797 | func0 |
#include <vector>
#include <string>
#include <assert.h>
template <typename T>
| int func0(const std::vector<T>& li, T min, T max) {
int ctr = 0;
for (T x : li) {
if (min <= x && x <= max) {
ctr += 1;
}
}
return ctr;
}
| int main() {
assert(func0(std::vector<int>{10,20,30,40,40,40,70,80,99}, 40, 100) == 6);
assert(func0(std::vector<char>{'a','b','c','d','e','f'}, 'a', 'e') == 5);
assert(func0(std::vector<int>{7,8,9,15,17,19,45}, 15, 20) == 3);
return 0;
}
| O1 | cpp | |||||
2,798 | func0 |
#include <vector>
#include <string>
#include <assert.h>
template <typename T>
| int func0(const std::vector<T>& li, T min, T max) {
int ctr = 0;
for (T x : li) {
if (min <= x && x <= max) {
ctr += 1;
}
}
return ctr;
}
| int main() {
assert(func0(std::vector<int>{10,20,30,40,40,40,70,80,99}, 40, 100) == 6);
assert(func0(std::vector<char>{'a','b','c','d','e','f'}, 'a', 'e') == 5);
assert(func0(std::vector<int>{7,8,9,15,17,19,45}, 15, 20) == 3);
return 0;
}
| O2 | cpp | |||||
2,799 | func0 |
#include <vector>
#include <string>
#include <assert.h>
template <typename T>
| int func0(const std::vector<T>& li, T min, T max) {
int ctr = 0;
for (T x : li) {
if (min <= x && x <= max) {
ctr += 1;
}
}
return ctr;
}
| int main() {
assert(func0(std::vector<int>{10,20,30,40,40,40,70,80,99}, 40, 100) == 6);
assert(func0(std::vector<char>{'a','b','c','d','e','f'}, 'a', 'e') == 5);
assert(func0(std::vector<int>{7,8,9,15,17,19,45}, 15, 20) == 3);
return 0;
}
| O3 | cpp | |||||
2,800 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& arr) {
int total_sum = std::accumulate(arr.begin(), arr.end(), 0);
int left_sum = 0;
for (size_t i = 0; i < arr.size(); ++i) {
total_sum -= arr[i];
if (left_sum == total_sum) {
return i;
}
left_sum += arr[i];
}
r... | int main() {
assert(func0({1, 2, 3, 4, 1, 2, 3}) == 3);
assert(func0({-7, 1, 5, 2, -4, 3, 0}) == 3);
assert(func0({1, 2, 3}) == -1);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 161e <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 15c6 <_ZNKSt6vectorIiSaIiEE... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5b... | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
int v4; // [rsp+10h] [rbp-20h]
int v5; // [rsp+14h] [rbp-1Ch]
unsigned long long i; // [rsp+18h] [rbp-18h]
v1 = std::vector<int>::end(a1);
v2 = std::vector<int>::begin(a1);
v4 = std::accumulate<__gnu_cxx::__normal_iterator<int c... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101676
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010162a
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RAX
CALL 0x001016c6
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr ... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int *piVar3;
ulong uVar4;
int local_28;
int local_24;
ulong local_20;
_Var1 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)para... |
2,801 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& arr) {
int total_sum = std::accumulate(arr.begin(), arr.end(), 0);
int left_sum = 0;
for (size_t i = 0; i < arr.size(); ++i) {
total_sum -= arr[i];
if (left_sum == total_sum) {
return i;
}
left_sum += arr[i];
}
r... | int main() {
assert(func0({1, 2, 3, 4, 1, 2, 3}) == 3);
assert(func0({-7, 1, 5, 2, -4, 3, 0}) == 3);
assert(func0({1, 2, 3}) == -1);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%r8
mov %r8,%rax
mov $0x0,%edx
cmp %rcx,%r8
je 125d <_Z5func0RKSt6vectorIiSaIiEE+0x54>
add (%rax),%edx
add $0x4,%rax
cmp %rax,%rcx
jne 1221 <_Z5func0RKSt6vectorIiSaIiEE+0x18>
sub %r8,%rcx
mov ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rdi+8]
mov r8, [rdi]
cmp r8, rcx
jz short loc_126D
mov rax, r8
mov esi, 0
loc_1221:
mov edx, esi
add edx, [rax]
mov esi, edx
add rax, 4
cmp rax, rcx
jnz short loc_1221
sub rcx, r8
mov rdi, rcx
sar rdi, 2
mov ... | long long func0(int **a1)
{
int *v1; // rcx
int *v2; // r8
int *v3; // rax
int v4; // esi
int v5; // edx
unsigned long long v6; // rdi
int v7; // ecx
int v8; // edx
long long result; // rax
int v10; // esi
v1 = a1[1];
v2 = *a1;
if ( *a1 == v1 )
return 0xFFFFFFFFLL;
v3 = *a1;
v4 = 0;
... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
CMP R8,RCX
JZ 0x0010126d
MOV RAX,R8
MOV ESI,0x0
LAB_00101221:
MOV EDX,ESI
ADD EDX,dword ptr [RAX]
MOV ESI,EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101221
SUB RCX,R8
MOV RDI,RCX
SAR RDI,0x2
MOV ECX,dword ptr [R8]
SUB EDX,ECX
JZ 0x00101261
MOV EAX,0x0
MOV ESI... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int iVar5;
int iVar6;
int iVar7;
piVar1 = *(int **)(param_1 + 8);
piVar2 = *(int **)param_1;
if (piVar2 == piVar1) {
return 0xffffffff;
}
iVar6 =... |
2,802 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& arr) {
int total_sum = std::accumulate(arr.begin(), arr.end(), 0);
int left_sum = 0;
for (size_t i = 0; i < arr.size(); ++i) {
total_sum -= arr[i];
if (left_sum == total_sum) {
return i;
}
left_sum += arr[i];
}
r... | int main() {
assert(func0({1, 2, 3, 4, 1, 2, 3}) == 3);
assert(func0({-7, 1, 5, 2, -4, 3, 0}) == 3);
assert(func0({1, 2, 3}) == -1);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%rdi
xor %eax,%eax
mov %rcx,%r8
mov %rdi,%rdx
sub %rdi,%r8
sar $0x2,%r8
cmp %rdi,%rcx
je 1428 <_Z5func0RKSt6vectorIiSaIiEE+0x68>
add (%rdx),%eax
add $0x4,%rdx
cmp %rdx,%rcx
jne 13e0 <_Z5fu... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rdi+8]
mov r8, [rdi]
cmp r8, rcx
jz short loc_13E5
mov rdx, r8
xor eax, eax
nop dword ptr [rax]
loc_13A8:
add eax, [rdx]
add rdx, 4
cmp rdx, rcx
jnz short loc_13A8
mov esi, [r8]
sub rdx, r8
sar rdx, 2
sub eax, es... | long long func0(int **a1)
{
int *v1; // rcx
int *v2; // r8
int *v3; // rdx
int v4; // eax
int v5; // esi
unsigned long long v6; // rdx
long long result; // rax
unsigned long long v8; // rcx
int v9; // edi
v1 = a1[1];
v2 = *a1;
if ( *a1 == v1 )
return 0xFFFFFFFFLL;
v3 = *a1;
v4 = 0;
d... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
CMP R8,RCX
JZ 0x001013e5
MOV RDX,R8
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013a8:
ADD EAX,dword ptr [RDX]
ADD RDX,0x4
CMP RDX,RCX
JNZ 0x001013a8
MOV ESI,dword ptr [R8]
SUB RDX,R8
SAR RDX,0x2
SUB EAX,ESI
JZ 0x001013ea
XOR ECX,ECX
XOR EDI,EDI
JMP 0x00101... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
int *piVar1;
int iVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
int *piVar6;
int iVar7;
uint uVar8;
piVar1 = *(int **)param_1;
if (piVar1 != *(int **)(param_1 + 8)) {
iVar2 = 0;
piVar6 = piVar1;
... |
2,803 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& arr) {
int total_sum = std::accumulate(arr.begin(), arr.end(), 0);
int left_sum = 0;
for (size_t i = 0; i < arr.size(); ++i) {
total_sum -= arr[i];
if (left_sum == total_sum) {
return i;
}
left_sum += arr[i];
}
r... | int main() {
assert(func0({1, 2, 3, 4, 1, 2, 3}) == 3);
assert(func0({-7, 1, 5, 2, -4, 3, 0}) == 3);
assert(func0({1, 2, 3}) == -1);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%rdi
mov %rcx,%r8
sub %rdi,%r8
sar $0x2,%r8
cmp %rdi,%rcx
je 14a8 <_Z5func0RKSt6vectorIiSaIiEE+0xf8>
lea -0x4(%rcx),%rdx
mov %rdi,%rax
movabs $0x3ffffffffffffffc,%r9
sub %rdi,%rdx
shr $0x2,%rdx
... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, rdi
mov rdi, [rdi+8]
mov r8, [rax]
cmp r8, rdi
jz loc_1465
lea rdx, [rdi-4]
mov rax, r8
sub rdx, r8
mov rcx, rdx
shr rcx, 2
add rcx, 1
cmp rdx, 8
jbe loc_1473
mov rdx, rcx
pxor xmm0, xmm0
shr rdx, 2
shl rdx... | long long func0(const __m128i **a1)
{
const __m128i *v2; // rdi
const __m128i *v3; // r8
const __m128i *v4; // rax
unsigned long long v5; // rcx
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm0
const __m128i *v9; // rdx
int v10; // eax
__int32 v11; // ecx
unsigned long long v12; // rdi... | func0:
ENDBR64
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RAX]
CMP R8,RDI
JZ 0x00101465
LEA RDX,[RDI + -0x4]
MOV RAX,R8
SUB RDX,R8
MOV RCX,RDX
SHR RCX,0x2
ADD RCX,0x1
CMP RDX,0x8
JBE 0x00101473
MOV RDX,RCX
PXOR XMM0,XMM0
SHR RDX,0x2
SHL RDX,0x4
ADD RDX,R8
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int *piVar8;
ulong uVar9;
ulong uVar10;
uint uVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
piVa... |
2,804 | func0 |
#include <algorithm>
#include <vector>
#include <assert.h>
int find_ind(int key, int i, int n, int k, const std::vector<int>& arr) {
int ind = -1;
int start = i + 1;
int end = n - 1;
while (start < end) {
int mid = start + (end - start) / 2;
if (arr[mid] - key <= k) {
... | int func0(const std::vector<int>& input, int n, int k) {
int ans = n - 1;
std::vector<int> arr = input;
std::sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) {
int j = find_ind(arr[i], i, n, k, arr);
if (j != -1) {
ans = std::min(ans, n - (j - i + 1));
... | int main() {
assert(func0({1, 3, 4, 9, 10, 11, 12, 17, 20}, 9, 4) == 5);
assert(func0({1, 5, 6, 2, 8}, 5, 2) == 3);
assert(func0({1, 2, 3, 4, 5, 6}, 6, 3) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %edx,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x4c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_50], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_4C]
sub eax, 1
mov [rbp+var_40], eax
mov rdx, [r... | long long func0(long long a1, unsigned int a2, unsigned int a3)
{
long long v3; // rbx
long long v4; // rax
unsigned int *v5; // rax
unsigned int v6; // ebx
unsigned int v9; // [rsp+10h] [rbp-40h] BYREF
unsigned int v10; // [rsp+14h] [rbp-3Ch] BYREF
unsigned int i; // [rsp+18h] [rbp-38h]
int ind; // [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV dword ptr [RBP + -0x50],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
MOV RDX,qword ptr ... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
long in_FS_OFFSET;
int local_48;
int local_44;
int local_40;
int local_3c;
vector<int,std::allocator<i... |
2,805 | func0 |
#include <algorithm>
#include <vector>
#include <assert.h>
int find_ind(int key, int i, int n, int k, const std::vector<int>& arr) {
int ind = -1;
int start = i + 1;
int end = n - 1;
while (start < end) {
int mid = start + (end - start) / 2;
if (arr[mid] - key <= k) {
... | int func0(const std::vector<int>& input, int n, int k) {
int ans = n - 1;
std::vector<int> arr = input;
std::sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) {
int j = find_ind(arr[i], i, n, k, arr);
if (j != -1) {
ans = std::min(ans, n - (j - i + 1));
... | int main() {
assert(func0({1, 3, 4, 9, 10, 11, 12, 17, 20}, 9, 4) == 5);
assert(func0({1, 5, 6, 2, 8}, 5, 2) == 3);
assert(func0({1, 2, 3, 4, 5, 6}, 6, 3) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r13
mov %esi,%ebp
mov %edx,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea -0x1(%rsi),%r12d
mov 0x8(%rdi),... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rbx, rdi
mov ebp, esi
mov [rsp+68h+var_64], edx
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, [rdi+8]
sub rax, [rdi]
mov [rsp+68h+var_... | long long func0(_QWORD *a1, int a2, unsigned int a3)
{
unsigned long long v4; // rax
_DWORD *v5; // r13
_DWORD *v6; // rsi
signed long long v7; // rbx
int *v8; // r12
unsigned long long v9; // rax
int *v10; // rbx
int *v11; // rsi
int *v12; // rax
int v13; // edx
int v14; // ecx
int v15; // r12... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV EBP,ESI
MOV dword ptr [RSP + 0x4],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RAX
JZ 0x0010138e
MOV RDI,RAX
MOV... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int1 param_8,int param_9,
int param_10,int8 param_11)
{
int *piVar1;
int *piVar2;
int *piVar3;
uint uVar4;
int iVar5;
u... |
2,806 | func0 |
#include <algorithm>
#include <vector>
#include <assert.h>
int find_ind(int key, int i, int n, int k, const std::vector<int>& arr) {
int ind = -1;
int start = i + 1;
int end = n - 1;
while (start < end) {
int mid = start + (end - start) / 2;
if (arr[mid] - key <= k) {
... | int func0(const std::vector<int>& input, int n, int k) {
int ans = n - 1;
std::vector<int> arr = input;
std::sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) {
int j = find_ind(arr[i], i, n, k, arr);
if (j != -1) {
ans = std::min(ans, n - (j - i + 1));
... | int main() {
assert(func0({1, 3, 4, 9, 10, 11, 12, 17, 20}, 9, 4) == 5);
assert(func0({1, 5, 6, 2, 8}, 5, 2) == 3);
assert(func0({1, 2, 3, 4, 5, 6}, 6, 3) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r15
push %r14
push %r13
mov %esi,%r13d
push %r12
lea -0x1(%rsi),%r12d
push %rbp
mov %r12d,%r14d
push %rbx
mov %edx,%ebx
sub $0x18,%rsp
mov 0x8(%rdi),%rax
mov (%rdi),%rsi
mov %rax,%r15
sub %rsi,%r15
mov ... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r15
push r14
push r13
mov r13d, esi
push r12
mov r12d, edx
push rbp
push rbx
sub rsp, 8
mov rbx, [rdi+8]
sub rbx, [rdi]
jz loc_19A8
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb loc_19E8
mov r14, rdi
mov rdi, rbx; u... | long long func0(_QWORD *a1, int a2, int a3)
{
_DWORD *v3; // rbp
signed long long v4; // r14
unsigned long long v7; // rbx
_DWORD *v8; // rax
_DWORD *v9; // rsi
_DWORD *v10; // r15
unsigned long long v11; // rax
long long v12; // rdx
_DWORD *i; // rdi
int v14; // ecx
int v15; // edx
_DWORD *v16... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12D,EDX
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,qword ptr [RDI + 0x8]
SUB RBX,qword ptr [RDI]
JZ 0x001019a8
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x001019e8
MOV R14,RDI
MOV RDI,RBX
CALL 0x00101110
MOV RSI,qword ptr [R14]
MOV R14,qword ptr [R14 + 0x8... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
_Iter_less_iter in_ECX;
int iVar5;
_Iter_less_iter extraout_EDX;
_Iter_less_iter extraout_EDX_00;
_Iter_less_iter _Var6;
ulong u... |
2,807 | func0 |
#include <algorithm>
#include <vector>
#include <assert.h>
int find_ind(int key, int i, int n, int k, const std::vector<int>& arr) {
int ind = -1;
int start = i + 1;
int end = n - 1;
while (start < end) {
int mid = start + (end - start) / 2;
if (arr[mid] - key <= k) {
... | int func0(const std::vector<int>& input, int n, int k) {
int ans = n - 1;
std::vector<int> arr = input;
std::sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) {
int j = find_ind(arr[i], i, n, k, arr);
if (j != -1) {
ans = std::min(ans, n - (j - i + 1));
... | int main() {
assert(func0({1, 3, 4, 9, 10, 11, 12, 17, 20}, 9, 4) == 5);
assert(func0({1, 5, 6, 2, 8}, 5, 2) == 3);
assert(func0({1, 2, 3, 4, 5, 6}, 6, 3) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r15
push %r14
push %r13
mov %esi,%r13d
push %r12
lea -0x1(%rsi),%r12d
push %rbp
push %rbx
mov %edx,%ebx
sub $0x18,%rsp
mov 0x8(%rdi),%rax
mov (%rdi),%rsi
mov %r12d,0x8(%rsp)
mov %rax,%r15
sub %rsi,%r15
m... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r15
push r14
lea r14d, [rsi-1]
push r13
mov r13d, edx
push r12
mov r12, rdi
push rbp
push rbx
mov ebx, esi
sub rsp, 28h
mov rdi, [rdi+8]
sub rdi, [r12]; unsigned __int64
mov [rsp+58h+var_40], rdi
jz loc_194A
mov rax, ... | long long func0(_QWORD *a1, _DWORD *a2, int a3)
{
_DWORD *v3; // rbp
long long v4; // r15
int v5; // r14d
_QWORD *v7; // r12
int v8; // ebx
unsigned long long v9; // rdi
_DWORD *v10; // rax
signed long long v11; // r10
bool v12; // zf
unsigned long long v13; // rdx
_DWORD *v14; // r8
_DWORD *v1... | func0:
ENDBR64
PUSH R15
PUSH R14
LEA R14D,[RSI + -0x1]
PUSH R13
MOV R13D,EDX
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x28
MOV RDI,qword ptr [RDI + 0x8]
SUB RDI,qword ptr [R12]
MOV qword ptr [RSP + 0x18],RDI
JZ 0x0010194a
MOV RAX,0x7ffffffffffffffc
CMP RAX,RDI
JC 0x00101a4b
CALL 0x00101110
MOV RSI,qwo... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int8 param_9)
{
vector *pvVar1;
vector *pvVar2;
int iVar3;
vector *pvVar4;
vector *pvVar5;
_Iter_less_iter _Var6;
... |
2,808 | func0 | #include <iostream>
#include <map>
#include <assert.h>
| bool func0(std::map<int, int> d, int x) {
if (d.find(x) != d.end()) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 5) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 6) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 10) == false);
return 0;
}
| O0 | cpp | func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 18d2 <_ZNSt3map... | _Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEE3endEv; std::ma... | _BOOL8 func0(long long a1, int a2)
{
int v3; // [rsp+4h] [rbp-2Ch] BYREF
long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+18h] [rbp-18h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-10h] BYREF
v4 = a1;
v3 = a2;
v6[1] = __readfsqword(0x28u);
v6[0] = std::map<int,int>::end(a1);
v5 = std::map<int,int... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010183a
MOV qword ptr [RBP + -0x10],RAX
LEA RDX,[RBP + -0x2c]
MOV RAX,qword ptr [RBP... | /* func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int) */
bool func0(map param_1,int param_2)
{
char cVar1;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_34;
map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>> *local_30;
int8 local_20;
i... |
2,809 | func0 | #include <iostream>
#include <map>
#include <assert.h>
| bool func0(std::map<int, int> d, int x) {
if (d.find(x) != d.end()) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 5) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 6) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 10) == false);
return 0;
}
| O1 | cpp | func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int):
endbr64
lea 0x8(%rdi),%rcx
mov 0x10(%rdi),%rax
test %rax,%rax
je 12a9 <_Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi+0x40>
mov %rcx,%rdx
jmp 1288 <_Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi+0x1f>
mov 0x1... | _Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi:
endbr64
lea rcx, [rdi+8]
mov rax, [rdi+10h]
test rax, rax
jz short loc_1269
mov rdx, rcx
jmp short loc_1248
loc_123F:
mov rax, [rax+18h]
loc_1243:
test rax, rax
jz short loc_1256
loc_1248:
cmp [rax+20h], esi
jl short loc_123F
mo... | bool func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
long long v4; // rdx
v2 = a1 + 8;
v3 = *(_QWORD *)(a1 + 16);
if ( v3 )
{
v4 = a1 + 8;
do
{
if ( *(_DWORD *)(v3 + 32) < a2 )
{
v3 = *(_QWORD *)(v3 + 24);
}
else
{
v4 = v3... | func0:
ENDBR64
LEA RCX,[RDI + 0x8]
MOV RAX,qword ptr [RDI + 0x10]
TEST RAX,RAX
JZ 0x00101269
MOV RDX,RCX
JMP 0x00101248
LAB_0010123f:
MOV RAX,qword ptr [RAX + 0x18]
LAB_00101243:
TEST RAX,RAX
JZ 0x00101256
LAB_00101248:
CMP dword ptr [RAX + 0x20],ESI
JL 0x0010123f
MOV RDX,RAX
MOV RAX,qword ptr [RAX + 0x10]
JMP 0x001012... | /* func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int) */
bool func0(map param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
int4 in_register_0000003c;
lVar1 = CONCAT44(in_register_0000003c,param_1) + 8;
lVar3 = *(long *)(CONCAT44(in_register... |
2,810 | func0 | #include <iostream>
#include <map>
#include <assert.h>
| bool func0(std::map<int, int> d, int x) {
if (d.find(x) != d.end()) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 5) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 6) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 10) == false);
return 0;
}
| O2 | cpp | func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int):
endbr64
mov 0x10(%rdi),%rax
lea 0x8(%rdi),%rcx
test %rax,%rax
je 15f0 <_Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi+0x50>
mov %rcx,%rdx
jmp 15cc <_Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi+0x2c>
nopw %cs... | _Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi:
endbr64
mov rax, [rdi+10h]
lea r8, [rdi+8]
test rax, rax
jz short loc_1650
mov rdi, r8
jmp short loc_1628
loc_1620:
mov rax, rcx
test rax, rax
jz short loc_1640
loc_1628:
mov rdx, [rax+10h]
mov rcx, [rax+18h]
cmp [rax+20h], e... | char func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // r8
long long v4; // rdi
long long v5; // rdx
long long v6; // rcx
v2 = *(_QWORD *)(a1 + 16);
v3 = a1 + 8;
if ( v2 )
{
v4 = a1 + 8;
do
{
while ( 1 )
{
v5 = *(_QWORD *)(v2 + 16);
v6 = *(_QW... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x10]
LEA R8,[RDI + 0x8]
TEST RAX,RAX
JZ 0x00101650
MOV RDI,R8
JMP 0x00101628
LAB_00101620:
MOV RAX,RCX
TEST RAX,RAX
JZ 0x00101640
LAB_00101628:
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
CMP dword ptr [RAX + 0x20],ESI
JL 0x00101620
MOV RDI,RAX
MOV RAX,RDX
TEST... | /* func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int) */
long func0(map param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
int4 in_register_0000003c;
long lVar5;
lVar4 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 0x10);
lVar1 = CO... |
2,811 | func0 | #include <iostream>
#include <map>
#include <assert.h>
| bool func0(std::map<int, int> d, int x) {
if (d.find(x) != d.end()) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 5) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 6) == true);
assert(func0({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}}, 10) == false);
return 0;
}
| O3 | cpp | func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int):
endbr64
mov 0x10(%rdi),%rax
lea 0x8(%rdi),%rcx
test %rax,%rax
je 1530 <_Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi+0x50>
mov %rcx,%rdx
jmp 150c <_Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi+0x2c>
nopw %cs... | _Z5func0St3mapIiiSt4lessIiESaISt4pairIKiiEEEi:
endbr64
mov rax, [rdi+10h]
lea r8, [rdi+8]
test rax, rax
jz short loc_16B0
mov rdi, r8
jmp short loc_168B
loc_1680:
mov rdi, rax
mov rax, rcx
test rax, rax
jz short loc_16A0
loc_168B:
mov rcx, [rax+10h]
mov rdx, [rax+18h]
cmp... | char func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // r8
long long v4; // rdi
long long v5; // rcx
long long v6; // rdx
v2 = *(_QWORD *)(a1 + 16);
v3 = a1 + 8;
if ( v2 )
{
v4 = a1 + 8;
do
{
while ( 1 )
{
v5 = *(_QWORD *)(v2 + 16);
v6 = *(_QW... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x10]
LEA R8,[RDI + 0x8]
TEST RAX,RAX
JZ 0x001016b0
MOV RDI,R8
JMP 0x0010168b
LAB_00101680:
MOV RDI,RAX
MOV RAX,RCX
TEST RAX,RAX
JZ 0x001016a0
LAB_0010168b:
MOV RCX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CMP dword ptr [RAX + 0x20],ESI
JGE 0x00101680
MOV RAX,RDX
TES... | /* func0(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >, int) */
long func0(map param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
int4 in_register_0000003c;
long lVar4;
long lVar5;
lVar3 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 0x10);
lVar1 = CO... |
2,812 | func0 |
#include <cassert>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(func0(10) == 2.9289682539682538);
assert(func0(4) == 2.083333333333333);
assert(func0(7) == 2.5928571428571425);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jg 1168 <_Z5func0i+0x1f>
movsd 0xf5a(%rip),%xmm0
jmp 1190 <_Z5func0i+0x47>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd 0xf4b(%rip),%xmm0
divsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
mov -0x4(%rbp),%eax
sub ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
cmp [rbp+var_4], 1
jg short loc_1168
movsd xmm0, cs:qword_20A0
jmp short locret_1194
loc_1168:
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_4]
movsd xmm0, cs:qword_20A0
divsd xmm0, xmm1
movsd [rbp+var_10], xmm0
... | double func0(int a1)
{
double result; // xmm0_8
result = 1.0;
if ( a1 > 1 )
{
func0(a1 - 1);
return 1.0 / (double)a1 + 1.0 / (double)a1;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x1
JG 0x00101168
MOVSD XMM0,qword ptr [0x001020a0]
JMP 0x00101194
LAB_00101168:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x4]
MOVSD XMM0,qword ptr [0x001020a0]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],... | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
dVar1 = DAT_001020a0;
if (1 < param_1) {
dVar1 = DAT_001020a0 / (double)param_1;
dVar2 = (double)func0(param_1 + -1);
dVar1 = dVar2 + dVar1;
}
return dVar1;
} |
2,813 | func0 |
#include <cassert>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(func0(10) == 2.9289682539682538);
assert(func0(4) == 2.083333333333333);
assert(func0(7) == 2.5928571428571425);
return 0;
}
| O1 | cpp | func0(int):
endbr64
movsd 0xf63(%rip),%xmm0
cmp $0x1,%edi
jle 1183 <_Z5func0i+0x3a>
push %rbx
mov %edi,%ebx
lea -0x1(%rdi),%edi
callq 1149 <_Z5func0i>
movapd %xmm0,%xmm2
pxor %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd 0xf3f(%rip),%xmm0
divsd %xmm1,%xmm0
addsd %xmm2,%xmm0
pop %rbx
retq
retq
| _Z5func0i:
endbr64
movsd xmm0, cs:qword_2090
cmp edi, 1
jle short locret_118B
sub rsp, 18h
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
movsd xmm1, cs:qword_2090
divsd xmm1, xmm0
movsd [rsp+18h+var_10], xmm1
sub edi, 1; int
call _Z5func0i; func0(int)
addsd xmm0, [rsp+18h+var_10]
add rsp, 18h
r... | double func0(int a1)
{
double result; // xmm0_8
result = 1.0;
if ( a1 > 1 )
{
func0(a1 - 1);
return (double)a1 + 1.0 / (double)a1;
}
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x00102090]
CMP EDI,0x1
JLE 0x0010118b
SUB RSP,0x18
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD XMM1,qword ptr [0x00102090]
DIVSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
SUB EDI,0x1
CALL 0x00101149
ADDSD XMM0,qword ptr [RSP + 0x8]
ADD RSP,0x18
RET
LAB_0010118b:
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
if (1 < param_1) {
dVar2 = DAT_00102090 / (double)param_1;
dVar1 = (double)func0(param_1 + -1);
return dVar1 + dVar2;
}
return DAT_00102090;
} |
2,814 | func0 |
#include <cassert>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(func0(10) == 2.9289682539682538);
assert(func0(4) == 2.083333333333333);
assert(func0(7) == 2.5928571428571425);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 1230 <_Z5func0i+0x10>
jmp 1240 <_Z5func0i.part.0>
nopl 0x0(%rax,%rax,1)
movsd 0xe80(%rip),%xmm0
retq
nopl 0x0(%rax)
| _Z5func0i:
endbr64
movsd xmm0, cs:qword_2090
cmp edi, 1
jle locret_1328
pxor xmm1, xmm1
movapd xmm3, xmm0
lea eax, [rdi-1]
cvtsi2sd xmm1, edi
divsd xmm3, xmm1
movapd xmm1, xmm0
cmp edi, 2
jz loc_131C
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
lea eax, [rdi-2]
divsd xmm1, xmm2
movapd xmm2... | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
__int128 result; // xmm0
__int128 v2; // xmm3
double v3; // xmm1_8
double v4; // xmm1_8
double v5; // xmm2_8
double v6; // xmm2_8
double v7; // xmm4_8
double v8; // xmm5_8
double v9; // xmm0_8
double v10; // [rsp+20h] [rbp-10h]
result = 0x3FF000000... | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x00102090]
CMP EDI,0x1
JLE 0x00101328
PXOR XMM1,XMM1
MOVAPD XMM3,XMM0
LEA EAX,[RDI + -0x1]
CVTSI2SD XMM1,EDI
DIVSD XMM3,XMM1
MOVAPD XMM1,XMM0
CMP EDI,0x2
JZ 0x0010131c
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
LEA EAX,[RDI + -0x2]
DIVSD XMM1,XMM2
MOVAPD XMM2,XMM0
CMP EDI,0x3
JZ 0x00101318
P... | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
if (param_1 < 2) {
return DAT_00102090;
}
dVar5 = DAT_00102090 / (double)param_1;
dVar3 = DAT_00102090;
if (param_1 != 2) {
dVar3 = DAT_00102090 / (double)(... |
2,815 | func0 |
#include <cassert>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(func0(10) == 2.9289682539682538);
assert(func0(4) == 2.083333333333333);
assert(func0(7) == 2.5928571428571425);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movsd 0xe8c(%rip),%xmm1
cmp $0x1,%edi
jle 1270 <_Z5func0i+0x50>
push %rbx
mov %edi,%ebx
lea -0x1(%rdi),%edi
sub $0x10,%rsp
movsd %xmm1,0x8(%rsp)
callq 1220 <_Z5func0i>
movsd 0x8(%rsp),%xmm1
add $0x10,%rsp
movapd %xmm0,%xmm2
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
d... | _Z5func0i:
endbr64
movsd xmm0, cs:qword_2098
cmp edi, 1
jle locret_1328
pxor xmm1, xmm1
movapd xmm3, xmm0
lea eax, [rdi-1]
cvtsi2sd xmm1, edi
divsd xmm3, xmm1
movapd xmm1, xmm0
cmp edi, 2
jz loc_131C
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
lea eax, [rdi-2]
divsd xmm1, xmm2
movapd xmm2... | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
__int128 result; // xmm0
__int128 v2; // xmm3
double v3; // xmm1_8
double v4; // xmm1_8
double v5; // xmm2_8
double v6; // xmm2_8
double v7; // xmm4_8
double v8; // xmm5_8
double v9; // xmm0_8
double v10; // [rsp+20h] [rbp-10h]
result = 0x3FF000000... | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x00102098]
CMP EDI,0x1
JLE 0x00101328
PXOR XMM1,XMM1
MOVAPD XMM3,XMM0
LEA EAX,[RDI + -0x1]
CVTSI2SD XMM1,EDI
DIVSD XMM3,XMM1
MOVAPD XMM1,XMM0
CMP EDI,0x2
JZ 0x0010131c
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
LEA EAX,[RDI + -0x2]
DIVSD XMM1,XMM2
MOVAPD XMM2,XMM0
CMP EDI,0x3
JZ 0x00101318
P... | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
if (param_1 < 2) {
return DAT_00102098;
}
dVar5 = DAT_00102098 / (double)param_1;
dVar3 = DAT_00102098;
if (param_1 != 2) {
dVar3 = DAT_00102098 / (double)(... |
2,816 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1) {
std::sort(list1.begin(), list1.end());
std::sort(list1.begin(), list1.end(), [](const std::vector<int>& a, const std::vector<int>& b) {
return a.size() < b.size();
});
return list1;
}
| int main() {
assert((func0({{2}, {0}, {1, 3}, {0, 7}, {9, 11}, {13, 15, 17}}) == std::vector<std::vector<int>>{{0}, {2}, {0, 7}, {1, 3}, {9, 11}, {13, 15, 17}}));
assert((func0({{1}, {2, 3}, {4, 5, 6}, {7}, {10, 11}}) == std::vector<std::vector<int>>{{1}, {7}, {2, 3}, {10, 11}, {4, 5, 6}}));
return 0;
}... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >)::{lambda(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&)#1}::operator()(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >... | _ZZ5func0St6vectorIS_IiSaIiEESaIS1_EEENKUlRKS1_S5_E_clES5_S5_:
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov rbx... | bool func0(std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}::operator()(
long long a1,
long long a2,
long long a3)
{
unsigned long long v3; // rbx
v3 = std::vector<int>::size(a2);
return v3 < std::vector<int>::size(a3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00103606
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001035ba
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00103656
MOV RAX,qword ptr [RBP + -... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocat... |
2,817 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1) {
std::sort(list1.begin(), list1.end());
std::sort(list1.begin(), list1.end(), [](const std::vector<int>& a, const std::vector<int>& b) {
return a.size() < b.size();
});
return list1;
}
| int main() {
assert((func0({{2}, {0}, {1, 3}, {0, 7}, {9, 11}, {13, 15, 17}}) == std::vector<std::vector<int>>{{0}, {2}, {0, 7}, {1, 3}, {9, 11}, {13, 15, 17}}));
assert((func0({{1}, {2, 3}, {4, 5, 6}, {7}, {10, 11}}) == std::vector<std::vector<int>>{{1}, {7}, {2, 3}, {10, 11}, {4, 5, 6}}));
return 0;
}... | O1 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int, std::allocator<int> >*, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > >, long, std::vector<int, std::allocator<int> >, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::vector<int... | _ZSt25__unguarded_linear_insertIN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES2_IS4_SaIS4_EEEENS0_5__ops14_Val_comp_iterIZ5func0S7_EUlRKS4_SC_E_EEEvT_T0_:
push r14
push r13
push r12
push rbp
push rbx
mov r13, [rdi]
mov r12, [rdi+8]
mov r14, [rdi+10h]
mov qword ptr [rdi+10h], 0
mov ... | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>,__gnu_cxx::__ops::_Val_comp_iter<func0(std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}>>(
void **a1)
{
_BYTE *v1; // r13
_BYTE *v2; // r12
void *v... | __unguarded_linear_insert<__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>,__ops::_Val_comp_iter<func0(std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>)::{... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__unguarded_linear_insert<__normal_iterator<std::vector<int, std::allocator<int> >*,
std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > >, __ops::_Val_comp_iter<func... |
2,818 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1) {
std::sort(list1.begin(), list1.end());
std::sort(list1.begin(), list1.end(), [](const std::vector<int>& a, const std::vector<int>& b) {
return a.size() < b.size();
});
return list1;
}
| int main() {
assert((func0({{2}, {0}, {1, 3}, {0, 7}, {9, 11}, {13, 15, 17}}) == std::vector<std::vector<int>>{{0}, {2}, {0, 7}, {1, 3}, {9, 11}, {13, 15, 17}}));
assert((func0({{1}, {2, 3}, {4, 5, 6}, {7}, {10, 11}}) == std::vector<std::vector<int>>{{1}, {7}, {2, 3}, {10, 11}, {4, 5, 6}}));
return 0;
}... | O2 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int, std::allocator<int> >*, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > >, long, std::vector<int, std::allocator<int> >, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::vector<int... | _ZSt25__unguarded_linear_insertIN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES2_IS4_SaIS4_EEEENS0_5__ops14_Val_comp_iterIZ5func0S7_EUlRKS4_SC_E_EEEvT_T0__isra_0:
push r12
pxor xmm0, xmm0
push rbp
push rbx
sub rsp, 10h
movdqu xmm3, xmmword ptr [rdi]
movups xmmword ptr [rdi], xmm0
mov rax, [rdi-... | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>,__gnu_cxx::__ops::_Val_comp_iter<func0(std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}>>(
__m128i *a1)
{
__m128i v1; // xmm3
unsigned long long v2; ... | __unguarded_linear_insert<__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>,__ops::_Val_comp_iter<func0(std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>)::{... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__unguarded_linear_insert<__normal_iterator<std::vector<int, std::allocator<int> >*,
std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > >, __ops::_Val_comp_iter<func... |
2,819 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1) {
std::sort(list1.begin(), list1.end());
std::sort(list1.begin(), list1.end(), [](const std::vector<int>& a, const std::vector<int>& b) {
return a.size() < b.size();
});
return list1;
}
| int main() {
assert((func0({{2}, {0}, {1, 3}, {0, 7}, {9, 11}, {13, 15, 17}}) == std::vector<std::vector<int>>{{0}, {2}, {0, 7}, {1, 3}, {9, 11}, {13, 15, 17}}));
assert((func0({{1}, {2, 3}, {4, 5, 6}, {7}, {10, 11}}) == std::vector<std::vector<int>>{{1}, {7}, {2, 3}, {10, 11}, {4, 5, 6}}));
return 0;
}... | O3 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int, std::allocator<int> >*, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > >, long, std::vector<int, std::allocator<int> >, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::vector<int... | _ZSt25__unguarded_linear_insertIN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES2_IS4_SaIS4_EEEENS0_5__ops14_Val_comp_iterIZ5func0S7_EUlRKS4_SC_E_EEEvT_T0__isra_0:
push r12
pxor xmm0, xmm0
push rbp
push rbx
sub rsp, 10h
movdqu xmm3, xmmword ptr [rdi]
movups xmmword ptr [rdi], xmm0
mov rax, [rdi-... | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>,__gnu_cxx::__ops::_Val_comp_iter<func0(std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}>>(
__m128i *a1)
{
__m128i v1; // xmm3
unsigned long long v2; ... | __unguarded_linear_insert<__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>,__ops::_Val_comp_iter<func0(std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>)::{... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__unguarded_linear_insert<__normal_iterator<std::vector<int, std::allocator<int> >*,
std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > >, __ops::_Val_comp_iter<func... |
2,820 | func0 |
#include <iostream>
#include <unordered_set>
#include <cassert>
| bool func0(int arr1[], int m, int arr2[], int n) {
std::unordered_set<int> hashset;
for (int i = 0; i < m; ++i) {
hashset.insert(arr1[i]);
}
for (int i = 0; i < n; ++i) {
if (hashset.find(arr2[i]) != hashset.end()) {
continue;
} else {
return fals... | int main() {
int arr1[] = {11, 1, 13, 21, 3, 7};
int arr2[] = {11, 3, 7, 1};
int arr3[] = {1, 2, 3, 4, 5, 6};
int arr4[] = {1, 2, 4};
int arr5[] = {10, 5, 2, 23, 19};
int arr6[] = {19, 5, 3};
assert(func0(arr1, 6, arr2, 4) == true);
assert(func0(arr3, 6, arr4, 3) == true);
... | O0 | cpp | func0(int*, int, int*, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %rdx,-0x88(%rbp)
mov %ecx,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 17ee <_ZNSt13unord... | _Z5func0PiiS_i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov [rbp+var_88], rdx
mov [rbp+var_80], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt13unordered_set... | long long func0(int *a1, int a2, int *a3, int a4)
{
unsigned int v4; // ebx
int i; // [rsp+28h] [rbp-68h]
int j; // [rsp+2Ch] [rbp-64h]
long long v10; // [rsp+30h] [rbp-60h] BYREF
long long v11; // [rsp+38h] [rbp-58h] BYREF
_BYTE v12[56]; // [rsp+40h] [rbp-50h] BYREF
unsigned long long v13; // [rsp+78h] ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV qword ptr [RBP + -0x88],RDX
MOV dword ptr [RBP + -0x80],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001017d4
MOV dword pt... | /* func0(int*, int, int*, int) */
int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
char cVar1;
int8 uVar2;
long in_FS_OFFSET;
int local_70;
int local_6c;
int8 local_68;
int8 local_60;
unordered_set<int,std::hash<int>,std::equal_to<int>,std::allocator<int>> local_58 [56];
long local_20... |
2,821 | func0 |
#include <iostream>
#include <unordered_set>
#include <cassert>
| bool func0(int arr1[], int m, int arr2[], int n) {
std::unordered_set<int> hashset;
for (int i = 0; i < m; ++i) {
hashset.insert(arr1[i]);
}
for (int i = 0; i < n; ++i) {
if (hashset.find(arr2[i]) != hashset.end()) {
continue;
} else {
return fals... | int main() {
int arr1[] = {11, 1, 13, 21, 3, 7};
int arr2[] = {11, 3, 7, 1};
int arr3[] = {1, 2, 3, 4, 5, 6};
int arr4[] = {1, 2, 4};
int arr5[] = {10, 5, 2, 23, 19};
int arr6[] = {19, 5, 3};
assert(func0(arr1, 6, arr2, 4) == true);
assert(func0(arr3, 6, arr4, 3) == true);
... | O1 | cpp | func0(int*, int, int*, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdx,0x8(%rsp)
mov %ecx,0x4(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x40(%rsp),%rax
mov %rax,0x10(%rsp)
movq $0x1,0x18(%rsp)
movq $0x0,0x20(%r... | _Z5func0PiiS_i:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 50h
mov r13, rdx
mov r12d, ecx
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
lea rax, [rsp+78h+var_38]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 1
mov [rsp+78h+var_58], 0
m... | long long func0(int *a1, int *a2, unsigned long long a3, _DWORD *a4, unsigned long long a5, long long *a6)
{
unsigned long long v6; // r13
int v7; // r12d
int *v8; // rbx
int *v9; // r14
int *v10; // rbp
int *i; // rax
long long *v12; // rax
unsigned int v13; // ebx
_QWORD **v15; // [rsp+8h] [rbp-70h... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV R13,RDX
MOV R12D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x1
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV dw... | /* func0(int*, int, int*, int) */
int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
long *plVar2;
long *plVar3;
long *plVar4;
ulong uVar5;
int8 uVar6;
long in_FS_OFFSET;
int8 *local_68;
ulong local_60;
long *local_58;
long local_50;
int4 local_48;
int8 local_40;
... |
2,822 | func0 |
#include <iostream>
#include <unordered_set>
#include <cassert>
| bool func0(int arr1[], int m, int arr2[], int n) {
std::unordered_set<int> hashset;
for (int i = 0; i < m; ++i) {
hashset.insert(arr1[i]);
}
for (int i = 0; i < n; ++i) {
if (hashset.find(arr2[i]) != hashset.end()) {
continue;
} else {
return fals... | int main() {
int arr1[] = {11, 1, 13, 21, 3, 7};
int arr2[] = {11, 3, 7, 1};
int arr3[] = {1, 2, 3, 4, 5, 6};
int arr4[] = {1, 2, 4};
int arr5[] = {10, 5, 2, 23, 19};
int arr6[] = {19, 5, 3};
assert(func0(arr1, 6, arr2, 4) == true);
assert(func0(arr3, 6, arr4, 3) == true);
... | O2 | cpp | func0(int*, int, int*, int):
endbr64
push %r15
mov %esi,%eax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdx,0x18(%rsp)
lea 0x60(%rsp),%rsi
lea 0x30(%rsp),%r15
mov %ecx,0xc(%rsp)
mov %fs:0x28,%rcx
mov %rcx,0x68(%rsp)
xor %ecx,%ecx
mov %rsi,0x30(%rsp)
m... | _Z5func0PiiS_i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_80], rdx
mov [rsp+0A8h+var_84], ecx
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_58], 3F800000h
mov [... | long long func0(unsigned int *a1, unsigned long long a2, int *a3, unsigned long long a4)
{
unsigned int *v4; // rbx
int *v5; // r15
unsigned long long v6; // r13
long long **v7; // r10
unsigned long long v8; // r14
long long *v9; // rax
int *v10; // rax
int *v11; // rax
int *v12; // r12
unsigned lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x28],RDX
MOV dword ptr [RSP + 0x24],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x60]
MOV dword ptr [RSP + 0x50],0x3f800000
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [... | /* func0(int*, int, int*, int) */
int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
uint *puVar1;
long *plVar2;
uint uVar3;
int iVar4;
char cVar5;
long *plVar6;
long *plVar7;
void *__s;
int8 *puVar8;
uint uVar9;
ulong uVar10;
long *plVar11;
ulong uVar12;
ulong extraout_RDX;
... |
2,823 | func0 |
#include <iostream>
#include <unordered_set>
#include <cassert>
| bool func0(int arr1[], int m, int arr2[], int n) {
std::unordered_set<int> hashset;
for (int i = 0; i < m; ++i) {
hashset.insert(arr1[i]);
}
for (int i = 0; i < n; ++i) {
if (hashset.find(arr2[i]) != hashset.end()) {
continue;
} else {
return fals... | int main() {
int arr1[] = {11, 1, 13, 21, 3, 7};
int arr2[] = {11, 3, 7, 1};
int arr3[] = {1, 2, 3, 4, 5, 6};
int arr4[] = {1, 2, 4};
int arr5[] = {10, 5, 2, 23, 19};
int arr6[] = {19, 5, 3};
assert(func0(arr1, 6, arr2, 4) == true);
assert(func0(arr3, 6, arr4, 3) == true);
... | O3 | cpp | func0(int*, int, int*, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdx,0x18(%rsp)
lea 0x60(%rsp),%r15
mov %ecx,0x14(%rsp)
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %r15,0x30(%rsp)
movq $0x1,0x38(%rsp)
movq $0x0,0x40(... | _Z5func0PiiS_i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_90], rdx
lea r14, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_94], ecx
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+s], r14
mov [rsp+0A8h+va... | long long func0(int *a1, int a2, int *a3, int a4)
{
int *v4; // rbx
int *v5; // r13
unsigned long long v6; // rsi
int v7; // ecx
_DWORD *v8; // rax
_QWORD *v9; // rbx
int v10; // ecx
_DWORD *v11; // rax
unsigned long long v12; // rbp
unsigned long long v13; // r12
long long v14; // rax
void **v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x18],RDX
LEA R14,[RSP + 0x60]
MOV dword ptr [RSP + 0x14],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x30],R14
MOV qword ptr [RSP + 0x38],0x1
MOV qword ptr [RSP + 0... | /* func0(int*, int, int*, int) */
int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int iVar2;
long *plVar3;
long *plVar4;
char cVar5;
int8 *puVar6;
int8 *puVar7;
ulong uVar8;
int iVar9;
ulong uVar10;
ulong extraout_RDX;
size_t __n;
ulong uVar11;
int8 uVar12;
l... |
2,824 | func0 |
#include <assert.h>
| int func0(int n) {
n += 1;
int powerOf2 = 2;
int cnt = n / 2;
while (powerOf2 <= n) {
int totalPairs = n / powerOf2;
cnt += (totalPairs / 2) * powerOf2;
if (totalPairs & 1) {
cnt += (n % powerOf2);
}
// No need for else case, it adds 0
... | int main() {
assert(func0(16) == 33);
assert(func0(2) == 2);
assert(func0(14) == 28);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
addl $0x1,-0x14(%rbp)
movl $0x2,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x8(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 11ae <_Z5func0i+0x65>
mov -0x14(... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
add [rbp+var_14], 1
mov [rbp+var_C], 2
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_8], eax
jmp short loc_11A6
loc_1170:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_C]... | long long func0(int a1)
{
int v2; // [rsp+0h] [rbp-14h]
int v3; // [rsp+8h] [rbp-Ch]
unsigned int v4; // [rsp+Ch] [rbp-8h]
v2 = a1 + 1;
v3 = 2;
v4 = (a1 + 1) / 2;
while ( v3 <= v2 )
{
v4 += v3 * (v2 / v3 / 2);
if ( ((v2 / v3) & 1) != 0 )
v4 += v2 % v3;
v3 *= 2;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
ADD dword ptr [RBP + -0x14],0x1
MOV dword ptr [RBP + -0xc],0x2
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011a6
LAB_00101170:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword p... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int4 local_14;
int4 local_10;
iVar1 = param_1 + 1;
local_10 = iVar1 / 2;
for (local_14 = 2; local_14 <= iVar1; local_14 = local_14 << 1) {
local_10 = local_10 + ((iVar1 / local_14) / 2) * local_14;
if ((iVar1 / local_14 & 1U) != 0) {
lo... |
2,825 | func0 |
#include <assert.h>
| int func0(int n) {
n += 1;
int powerOf2 = 2;
int cnt = n / 2;
while (powerOf2 <= n) {
int totalPairs = n / powerOf2;
cnt += (totalPairs / 2) * powerOf2;
if (totalPairs & 1) {
cnt += (n % powerOf2);
}
// No need for else case, it adds 0
... | int main() {
assert(func0(16) == 33);
assert(func0(2) == 2);
assert(func0(14) == 28);
return 0;
}
| O1 | cpp | func0(int):
endbr64
add $0x1,%edi
mov %edi,%esi
shr $0x1f,%esi
add %edi,%esi
sar %esi
cmp $0x1,%edi
jle 118b <_Z5func0i+0x42>
mov $0x2,%ecx
jmp 116b <_Z5func0i+0x22>
add %ecx,%ecx
cmp %ecx,%edi
jl 118b <_Z5func0i+0x42>
mov %edi,%eax
cltd
idiv %ecx
mov %eax,%edx
shr $0x1f,... | _Z5func0i:
endbr64
add edi, 1
mov esi, edi
shr esi, 1Fh
add esi, edi
sar esi, 1
cmp edi, 1
jle short loc_118B
mov ecx, 2
jmp short loc_116B
loc_1165:
add ecx, ecx
cmp edi, ecx
jl short loc_118B
loc_116B:
mov eax, edi
cdq
idiv ecx
mov edx, eax
shr edx, 1Fh
... | long long func0(int a1)
{
int v1; // edi
unsigned int v2; // esi
int i; // ecx
v1 = a1 + 1;
v2 = v1 / 2;
if ( v1 > 1 )
{
for ( i = 2; i <= v1; i *= 2 )
{
v2 += i * (v1 / i / 2);
if ( ((v1 / i) & 1) != 0 )
v2 += v1 % i;
}
}
return v2;
} | func0:
ENDBR64
ADD EDI,0x1
MOV ESI,EDI
SHR ESI,0x1f
ADD ESI,EDI
SAR ESI,0x1
CMP EDI,0x1
JLE 0x0010118b
MOV ECX,0x2
JMP 0x0010116b
LAB_00101165:
ADD ECX,ECX
CMP EDI,ECX
JL 0x0010118b
LAB_0010116b:
MOV EAX,EDI
CDQ
IDIV ECX
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
IMUL EDX,ECX
ADD ESI,EDX
TEST AL,0x1
JZ 0x00101165... | /* func0(int) */
int func0(int param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = param_1 + 1;
iVar3 = iVar4 / 2;
if (1 < iVar4) {
iVar2 = 2;
do {
uVar1 = (long)iVar4 / (long)iVar2;
iVar3 = iVar3 + ((int)(((uint)(uVar1 >> 0x1f) & 1) + (int)uVar1) >> 1) * iVar2;
... |
2,826 | func0 |
#include <assert.h>
| int func0(int n) {
n += 1;
int powerOf2 = 2;
int cnt = n / 2;
while (powerOf2 <= n) {
int totalPairs = n / powerOf2;
cnt += (totalPairs / 2) * powerOf2;
if (totalPairs & 1) {
cnt += (n % powerOf2);
}
// No need for else case, it adds 0
... | int main() {
assert(func0(16) == 33);
assert(func0(2) == 2);
assert(func0(14) == 28);
return 0;
}
| O2 | cpp | func0(int):
endbr64
add $0x1,%edi
mov %edi,%r8d
shr $0x1f,%r8d
add %edi,%r8d
sar %r8d
cmp $0x1,%edi
jle 1263 <_Z5func0i+0x43>
mov $0x2,%esi
xchg %ax,%ax
mov %edi,%eax
cltd
idiv %esi
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
imul %esi,%ecx
add %ecx,%r8d
add %r... | _Z5func0i:
endbr64
add edi, 1
mov r8d, edi
shr r8d, 1Fh
add r8d, edi
sar r8d, 1
cmp edi, 1
jle short loc_1233
mov esi, 2
xchg ax, ax
loc_1210:
mov eax, edi
cdq
idiv esi
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
imul ecx, esi
add r8d, ecx
add e... | long long func0(int a1)
{
int v1; // edi
unsigned int v2; // r8d
int i; // esi
v1 = a1 + 1;
v2 = v1 / 2;
if ( v1 > 1 )
{
for ( i = 2; i <= v1; i *= 2 )
{
v2 += i * (v1 / i / 2);
if ( ((v1 / i) & 1) != 0 )
v2 += v1 % i;
}
}
return v2;
} | func0:
ENDBR64
ADD EDI,0x1
MOV R8D,EDI
SHR R8D,0x1f
ADD R8D,EDI
SAR R8D,0x1
CMP EDI,0x1
JLE 0x00101233
MOV ESI,0x2
NOP
LAB_00101210:
MOV EAX,EDI
CDQ
IDIV ESI
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
IMUL ECX,ESI
ADD R8D,ECX
ADD EDX,R8D
TEST AL,0x1
CMOVNZ R8D,EDX
ADD ESI,ESI
CMP EDI,ESI
JGE 0x00101210
LAB_001012... | /* func0(int) */
int func0(int param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
iVar5 = param_1 + 1;
iVar6 = iVar5 / 2;
if (1 < iVar5) {
iVar4 = 2;
do {
uVar1 = (long)iVar5 / (long)iVar4;
iVar6 = iVar6 + ((int)(((uint)(uVar1 >> 0x1f) & 1) + (int)u... |
2,827 | func0 |
#include <assert.h>
| int func0(int n) {
n += 1;
int powerOf2 = 2;
int cnt = n / 2;
while (powerOf2 <= n) {
int totalPairs = n / powerOf2;
cnt += (totalPairs / 2) * powerOf2;
if (totalPairs & 1) {
cnt += (n % powerOf2);
}
// No need for else case, it adds 0
... | int main() {
assert(func0(16) == 33);
assert(func0(2) == 2);
assert(func0(14) == 28);
return 0;
}
| O3 | cpp | func0(int):
endbr64
add $0x1,%edi
mov %edi,%r8d
shr $0x1f,%r8d
add %edi,%r8d
sar %r8d
cmp $0x1,%edi
jle 1183 <_Z5func0i+0x43>
mov $0x2,%esi
xchg %ax,%ax
mov %edi,%eax
cltd
idiv %esi
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
imul %esi,%ecx
add %ecx,%r8d
add %r... | _Z5func0i:
endbr64
add edi, 1
mov r8d, edi
shr r8d, 1Fh
add r8d, edi
sar r8d, 1
cmp edi, 1
jle short loc_1183
mov esi, 2
xchg ax, ax
loc_1160:
mov eax, edi
cdq
idiv esi
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
imul ecx, esi
add r8d, ecx
add e... | long long func0(int a1)
{
int v1; // edi
unsigned int v2; // r8d
int i; // esi
v1 = a1 + 1;
v2 = v1 / 2;
if ( v1 > 1 )
{
for ( i = 2; i <= v1; i *= 2 )
{
v2 += i * (v1 / i / 2);
if ( ((v1 / i) & 1) != 0 )
v2 += v1 % i;
}
}
return v2;
} | func0:
ENDBR64
ADD EDI,0x1
MOV R8D,EDI
SHR R8D,0x1f
ADD R8D,EDI
SAR R8D,0x1
CMP EDI,0x1
JLE 0x00101183
MOV ESI,0x2
NOP
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ESI
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
IMUL ECX,ESI
ADD R8D,ECX
ADD EDX,R8D
TEST AL,0x1
CMOVNZ R8D,EDX
ADD ESI,ESI
CMP EDI,ESI
JGE 0x00101160
LAB_001011... | /* func0(int) */
int func0(int param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
iVar5 = param_1 + 1;
iVar6 = iVar5 / 2;
if (1 < iVar5) {
iVar4 = 2;
do {
uVar1 = (long)iVar5 / (long)iVar4;
iVar6 = iVar6 + ((int)(((uint)(uVar1 >> 0x1f) & 1) + (int)u... |
2,828 | func0 |
#include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
| std::vector<std::string> func0(std::string str) {
std::vector<std::string> result;
std::istringstream iss(str);
std::string word;
while (iss >> word) {
result.push_back(word);
}
return result;
}
| int main() {
std::vector<std::string> vec1 = {"python", "program"};
assert(func0("python program") == vec1);
std::vector<std::string> vec2 = {"Data", "Analysis"};
assert(func0("Data Analysis") == vec2);
std::vector<std::string> vec3 = {"Hadoop", "Training"};
assert(func0("Hadoop Traini... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x1c8,%rsp
mov %rdi,-0x1c8(%rbp)
mov %rsi,-0x1d0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x1c8(%rbp),%rax
mov %rax,%rdi
callq 30b... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 1C8h
mov [rbp+var_1C8], rdi
mov [rbp+var_1D0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_1C8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx... | long long func0(long long a1, long long a2)
{
_QWORD *v2; // rax
_BYTE v4[32]; // [rsp+10h] [rbp-1C0h] BYREF
_BYTE v5[392]; // [rsp+30h] [rbp-1A0h] BYREF
unsigned long long v6; // [rsp+1B8h] [rbp-18h]
v6 = __readfsqword(0x28u);
std::vector<std::string>::vector(a1);
std::istringstream::basic_istringstrea... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x1c8
MOV qword ptr [RBP + -0x1c8],RDI
MOV qword ptr [RBP + -0x1d0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x1c8]
MOV RDI,RAX
CALL 0x00102cfe
MOV RCX,qword ptr [RBP + -0x1d0]
LEA RAX,[RBP + -0x1a0]
MOV ED... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2)
{
bool bVar1;
istream *piVar2;
long in_FS_OFFSET;
string local_1c8 [32];
istringstream local_1a8 [392];
long local_20;
local_20 = *(long *)(in_FS_... |
2,829 | func0 |
#include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
| std::vector<std::string> func0(std::string str) {
std::vector<std::string> result;
std::istringstream iss(str);
std::string word;
while (iss >> word) {
result.push_back(word);
}
return result;
}
| int main() {
std::vector<std::string> vec1 = {"python", "program"};
assert(func0("python program") == vec1);
std::vector<std::string> vec2 = {"Data", "Analysis"};
assert(func0("Data Analysis") == vec2);
std::vector<std::string> vec3 = {"Hadoop", "Training"};
assert(func0("Hadoop Traini... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1b0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x1a8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1B0h
mov rbx, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+1D8h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // rdx
long long v4; // rsi
_QWORD *v5; // rax
_QWORD *v6; // rdi
void *v8; // [rsp+0h] [rbp-1D8h] BYREF
long long v9; // [rsp+8h] [rbp-1D0h]
_QWORD v10[2]; // [rsp+10h] [rbp-1C8h] BYREF
int *v11; // [rsp+20h] [rbp-1B8h] BYREF
long long v12; //... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b0
MOV RBX,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R14,[RSP + 0x20]
LEA RDI,[RSP + 0x98]
CALL 0x001021b0
LEA RAX... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,int8 *param_2)
{
char *pcVar1;
long *plVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
istream *piVar6;
long in_FS_OFFSET;
char *local_1d8;
int8 local_1d0;
char local... |
2,830 | func0 |
#include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
| std::vector<std::string> func0(std::string str) {
std::vector<std::string> result;
std::istringstream iss(str);
std::string word;
while (iss >> word) {
result.push_back(word);
}
return result;
}
| int main() {
std::vector<std::string> vec1 = {"python", "program"};
assert(func0("python program") == vec1);
std::vector<std::string> vec2 = {"Data", "Analysis"};
assert(func0("Data Analysis") == vec2);
std::vector<std::string> vec3 = {"Hadoop", "Training"};
assert(func0("Hadoop Traini... | O2 | cpp | func0(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
mov %rsi,%rbx
sub $0x1c8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1b8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
lea 0x30(%rsp),... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 1D8h
mov rax, fs:28h
mov [rsp+208h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
lea ... | long long func0(long long a1, long long a2)
{
_BYTE *v3; // r15
char *v4; // rbp
_QWORD *v5; // rax
_QWORD *v6; // rax
_QWORD *v7; // rdi
long long v8; // rdx
_QWORD *v9; // rax
_QWORD *v11; // rdi
char *v12; // [rsp+18h] [rbp-1F0h] BYREF
void *v13; // [rsp+20h] [rbp-1E8h] BYREF
long long v14; //... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x1d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0xb8]
LEA R12,[RSP + 0x40]
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RAX
MOV qword p... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,int8 *param_2)
{
istream iVar1;
int *__src;
ulong __n;
long *plVar2;
istream *piVar3;
int8 uVar4;
long in_FS_OFFSET;
ulong local_1f0;
char *local_1e8;
int8 loca... |
2,831 | func0 |
#include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
| std::vector<std::string> func0(std::string str) {
std::vector<std::string> result;
std::istringstream iss(str);
std::string word;
while (iss >> word) {
result.push_back(word);
}
return result;
}
| int main() {
std::vector<std::string> vec1 = {"python", "program"};
assert(func0("python program") == vec1);
std::vector<std::string> vec2 = {"Data", "Analysis"};
assert(func0("Data Analysis") == vec2);
std::vector<std::string> vec3 = {"Hadoop", "Training"};
assert(func0("Hadoop Traini... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x1f8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
sub rsp, 1F8h
mov rax, fs:28h
mov [rsp+228h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
lea ... | long long func0(long long a1, long long a2)
{
char *v3; // rbx
_BYTE *v4; // rbp
_QWORD *v5; // rax
_QWORD *v6; // rax
long long *v7; // rbx
size_t v8; // rbp
void *v9; // rdi
void *v10; // r15
_QWORD *v11; // rax
_QWORD *v13; // rdi
long long v14; // rax
char *v15; // [rsp+30h] [rbp-1F0h] BYRE... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x1f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0xd8]
LEA R14,[RSP + 0x60]
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RAX
MOV qword p... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,int8 *param_2)
{
istream iVar1;
ulong uVar2;
int *puVar3;
ulong *puVar4;
istream *piVar5;
ulong *__dest;
int8 uVar6;
long in_FS_OFFSET;
ulong local_1f0;
int *lo... |
2,832 | func0 | #include <iostream>
#include <vector>
#include <utility>
#include <unordered_map>
#include <set>
#include <string>
#include <sstream>
#include <cassert>
using namespace std;
| string func0(const vector<pair<int, int>>& test_list) {
// Use an unordered_map to record seen first elements by second element.
// Also maintain the insertion order of keys.
unordered_map<int, set<int>> mapping;
vector<int> order;
for (const auto &p : test_list) {
int first = p.... | int main(){
assert(func0({{3, 4}, {1, 2}, {2, 4}, {8, 2}, {7, 2}, {8, 1}, {9, 1}, {8, 4}, {10, 4}})
== "{4: 4, 2: 3, 1: 2}");
assert(func0({{4, 5}, {2, 3}, {3, 5}, {9, 3}, {8, 3}, {9, 2}, {10, 2}, {9, 5}, {11, 5}})
== "{5: 4, 3: 3, 2: 2}");
assert(func0({{6, 5}, {3, 4}, {2, 6}, {1... | O0 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x248,%rsp
mov %rdi,-0x248(%rbp)
mov %rsi,-0x250(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x1d0(%rbp),%rax
mov %rax,%rdi
... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 248h
mov [rbp+var_248], rdi
mov [rbp+var_250], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_1D0]
mov rdi, rax
call _ZNSt13unordered_mapIiSt3setIiSt4les... | long long func0[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // rax
char v8; // [rsp+1Fh] [rbp-231h]
int v9; // [rsp+20h] [rbp-230h] BYREF
int v10; // [rsp+24h] [rbp-22Ch] BYREF
long long v11; // [rsp+28h] [... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x248
MOV qword ptr [RBP + -0x248],RDI
MOV qword ptr [RBP + -0x250],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x1d0]
MOV RDI,RAX
CALL 0x001031d6
LEA RAX,[RBP + -0x1f0]
MOV RDI,RAX
CALL 0x0010325e
MOV RAX,qw... | /* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
char cVar1;
bool bVar2;
bool bVar3;
int4 *puVar4;
ostream *poVar5;
set<int,std::less<int>,std::allocator<int>> *psVar6;
ulong uVar7;
vector<std::pair<... |
2,833 | func0 | #include <iostream>
#include <vector>
#include <utility>
#include <unordered_map>
#include <set>
#include <string>
#include <sstream>
#include <cassert>
using namespace std;
| string func0(const vector<pair<int, int>>& test_list) {
// Use an unordered_map to record seen first elements by second element.
// Also maintain the insertion order of keys.
unordered_map<int, set<int>> mapping;
vector<int> order;
for (const auto &p : test_list) {
int first = p.... | int main(){
assert(func0({{3, 4}, {1, 2}, {2, 4}, {8, 2}, {7, 2}, {8, 1}, {9, 1}, {8, 4}, {10, 4}})
== "{4: 4, 2: 3, 1: 2}");
assert(func0({{4, 5}, {2, 3}, {3, 5}, {9, 3}, {8, 3}, {9, 2}, {10, 2}, {9, 5}, {11, 5}})
== "{5: 4, 3: 3, 2: 2}");
assert(func0({{6, 5}, {3, 4}, {2, 6}, {1... | O1 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1f8,%rsp
mov %rdi,%r14
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%rax
mov %rax,0x30(%rsp... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 208h
mov [rsp+238h+var_238], rdi
mov rax, fs:28h
mov [rsp+238h+var_40], rax
xor eax, eax
lea rax, [rsp+238h+var_1C8]
mov [rsp+238h+var_1F8], rax
mov [r... | long long func0[abi:cxx11](long long a1, int **a2)
{
int *v2; // rbp
int *v3; // r13
_QWORD *v4; // rax
long long v5; // rax
int v6; // ebx
long long *v7; // rax
char *v8; // rsi
char *v9; // r13
char *v10; // rbp
char v11; // al
long long v12; // rbx
long long v13; // rax
unsigned int v14; /... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x208
MOV qword ptr [RSP],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1f8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x70]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],0x1
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [R... | /* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
int iVar1;
int *piVar2;
bool bVar3;
int8 *puVar4;
long *plVar5;
_Rb_tree<int,int,std::_Identity<int>,std::less<int>,std::allocator<int>> *this;
ostream ... |
2,834 | func0 | #include <iostream>
#include <vector>
#include <utility>
#include <unordered_map>
#include <set>
#include <string>
#include <sstream>
#include <cassert>
using namespace std;
| string func0(const vector<pair<int, int>>& test_list) {
// Use an unordered_map to record seen first elements by second element.
// Also maintain the insertion order of keys.
unordered_map<int, set<int>> mapping;
vector<int> order;
for (const auto &p : test_list) {
int first = p.... | int main(){
assert(func0({{3, 4}, {1, 2}, {2, 4}, {8, 2}, {7, 2}, {8, 1}, {9, 1}, {8, 4}, {10, 4}})
== "{4: 4, 2: 3, 1: 2}");
assert(func0({{4, 5}, {2, 3}, {3, 5}, {9, 3}, {8, 3}, {9, 2}, {10, 2}, {9, 5}, {11, 5}})
== "{5: 4, 3: 3, 2: 2}");
assert(func0({{6, 5}, {3, 4}, {2, 6}, {1... | O2 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r15
mov %rsi,%rax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x228,%rsp
mov (%rax),%rbp
mov 0x8(%rax),%rax
mov %rdi,0x20(%rsp)
lea 0x90(%rsp),%rsi
lea 0x60(%rsp),%... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 248h
mov r13, [rsi]
mov r15, [rsi+8]
mov [rsp+278h+var_250], rdi
mov rax, fs:28h
mov [rsp+278h+var_40], rax
xor eax, eax
lea rax, [r... | long long func0[abi:cxx11](long long a1, int **a2)
{
int *v2; // r13
int *v3; // r15
long long i; // rax
unsigned int v5; // ecx
int v6; // ebp
long long *v7; // rax
long long v8; // rax
long long v9; // rbx
long long v10; // r12
long long v11; // r14
int v12; // edx
long long v13; // rax
lon... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x248
MOV R13,qword ptr [RSI]
MOV R15,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x238],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xb0]
MOVAPS xmmword ptr [RSP + 0x60],X... | /* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int *piVar2;
long *plVar3;
long *plVar4;
long *plVar5;
int8 *puVar6;
pointer_____offset_0x18___ puVar7;
pointer_____offset... |
2,835 | func0 | #include <iostream>
#include <vector>
#include <utility>
#include <unordered_map>
#include <set>
#include <string>
#include <sstream>
#include <cassert>
using namespace std;
| string func0(const vector<pair<int, int>>& test_list) {
// Use an unordered_map to record seen first elements by second element.
// Also maintain the insertion order of keys.
unordered_map<int, set<int>> mapping;
vector<int> order;
for (const auto &p : test_list) {
int first = p.... | int main(){
assert(func0({{3, 4}, {1, 2}, {2, 4}, {8, 2}, {7, 2}, {8, 1}, {9, 1}, {8, 4}, {10, 4}})
== "{4: 4, 2: 3, 1: 2}");
assert(func0({{4, 5}, {2, 3}, {3, 5}, {9, 3}, {8, 3}, {9, 2}, {10, 2}, {9, 5}, {11, 5}})
== "{5: 4, 3: 3, 2: 2}");
assert(func0({{6, 5}, {3, 4}, {2, 6}, {1... | O3 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x228,%rsp
mov (%rsi),%rbp
mov %rdi,0x18(%rsp)
lea 0x90(%rsp),%rcx
mov %fs:0x28,%rax
mov %rax,0x218(... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 248h
mov r13, [rsi]
mov r14, [rsi+8]
mov [rsp+278h+var_248], rdi
mov rax, fs:28h
mov [rsp+278h+var_40], rax
xor eax, eax
lea rax, [r... | long long func0[abi:cxx11](long long a1, int **a2)
{
int *v2; // r13
int *v3; // r14
long long v4; // rax
int v5; // ecx
int v6; // ebp
_DWORD *v7; // rax
long long v8; // rax
long long v9; // rbx
long long v10; // r12
long long v11; // r15
int v12; // edx
long long v13; // rax
long long v14;... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x248
MOV R13,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x238],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xb0]
MOVAPS xmmword ptr [RSP + 0x60],X... | /* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int *piVar2;
long *plVar3;
long *plVar4;
int8 *puVar5;
void *pvVar6;
long *plVar7;
int8 *puVar8;
void *pvVar9;
pointer... |
2,836 | func0 | #include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::tuple<int, int> func0(const std::vector<int>& test_vec) {
return std::make_tuple(test_vec.front(), test_vec.back());
}
| int main() {
std::vector<int> vec1 = {10, 4, 5, 6, 7};
assert(func0(vec1) == std::make_tuple(10, 7));
std::vector<int> vec2 = {1, 2, 3, 4, 5};
assert(func0(vec2) == std::make_tuple(1, 5));
std::vector<int> vec3 = {6, 7, 8, 9, 10};
assert(func0(vec3) == std::make_tuple(6, 10));
... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 17a8 <_ZNKSt6vectorIiSaIiEE4backEv>
mov ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4backEv; std::vector<int>::back(void)
... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
v2 = std::vector<int>::back(a2);
v3 = std::vector<int>::front(a2);
std::make_tuple<int const&,int const&>(a1, v3, v2);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x0010174c
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int *piVar2;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::back(in_RSI);
piVar2 = (int *)std::vector<int... |
2,837 | func0 | #include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::tuple<int, int> func0(const std::vector<int>& test_vec) {
return std::make_tuple(test_vec.front(), test_vec.back());
}
| int main() {
std::vector<int> vec1 = {10, 4, 5, 6, 7};
assert(func0(vec1) == std::make_tuple(10, 7));
std::vector<int> vec2 = {1, 2, 3, 4, 5};
assert(func0(vec2) == std::make_tuple(1, 5));
std::vector<int> vec3 = {6, 7, 8, 9, 10};
assert(func0(vec3) == std::make_tuple(6, 10));
... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov %rdi,%rax
mov (%rsi),%rdx
mov 0x8(%rsi),%rcx
mov -0x4(%rcx),%ecx
mov %ecx,(%rdi)
mov (%rdx),%edx
mov %edx,0x4(%rdi)
retq
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, rdi
mov rdx, [rsi]
mov rcx, [rsi+8]
mov ecx, [rcx-4]
mov [rdi], ecx
mov edx, [rdx]
mov [rdi+4], edx
retn | _DWORD * func0(_DWORD *a1, long long a2)
{
_DWORD *result; // rax
_DWORD *v3; // rdx
result = a1;
v3 = *(_DWORD **)a2;
*a1 = *(_DWORD *)(*(_QWORD *)(a2 + 8) - 4LL);
a1[1] = *v3;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV RDX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
MOV ECX,dword ptr [RCX + -0x4]
MOV dword ptr [RDI],ECX
MOV EDX,dword ptr [RDX]
MOV dword ptr [RDI + 0x4],EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 *puVar1;
int8 *in_RSI;
puVar1 = (int4 *)*in_RSI;
*(int4 *)param_1 = *(int4 *)(in_RSI[1] + -4);
*(int4 *)(param_1 + 4) = *puVar1;
return param_1;
} |
2,838 | func0 | #include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::tuple<int, int> func0(const std::vector<int>& test_vec) {
return std::make_tuple(test_vec.front(), test_vec.back());
}
| int main() {
std::vector<int> vec1 = {10, 4, 5, 6, 7};
assert(func0(vec1) == std::make_tuple(10, 7));
std::vector<int> vec2 = {1, 2, 3, 4, 5};
assert(func0(vec2) == std::make_tuple(1, 5));
std::vector<int> vec3 = {6, 7, 8, 9, 10};
assert(func0(vec3) == std::make_tuple(6, 10));
... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rsi),%rcx
mov (%rsi),%rdx
mov %rdi,%rax
mov -0x4(%rcx),%ecx
mov %ecx,(%rdi)
mov (%rdx),%edx
mov %edx,0x4(%rdi)
retq
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rsi+8]
mov rdx, [rsi]
mov rax, rdi
mov ecx, [rcx-4]
mov [rdi], ecx
mov edx, [rdx]
mov [rdi+4], edx
retn | _DWORD * func0(_DWORD *a1, long long a2)
{
_DWORD *v2; // rdx
_DWORD *result; // rax
v2 = *(_DWORD **)a2;
result = a1;
*a1 = *(_DWORD *)(*(_QWORD *)(a2 + 8) - 4LL);
a1[1] = *v2;
return result;
} | func0:
ENDBR64
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV RAX,RDI
MOV ECX,dword ptr [RCX + -0x4]
MOV dword ptr [RDI],ECX
MOV EDX,dword ptr [RDX]
MOV dword ptr [RDI + 0x4],EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 *puVar1;
int8 *in_RSI;
puVar1 = (int4 *)*in_RSI;
*(int4 *)param_1 = *(int4 *)(in_RSI[1] + -4);
*(int4 *)(param_1 + 4) = *puVar1;
return param_1;
} |
2,839 | func0 | #include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::tuple<int, int> func0(const std::vector<int>& test_vec) {
return std::make_tuple(test_vec.front(), test_vec.back());
}
| int main() {
std::vector<int> vec1 = {10, 4, 5, 6, 7};
assert(func0(vec1) == std::make_tuple(10, 7));
std::vector<int> vec2 = {1, 2, 3, 4, 5};
assert(func0(vec2) == std::make_tuple(1, 5));
std::vector<int> vec3 = {6, 7, 8, 9, 10};
assert(func0(vec3) == std::make_tuple(6, 10));
... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rsi),%rcx
mov (%rsi),%rdx
mov %rdi,%rax
mov -0x4(%rcx),%ecx
mov %ecx,(%rdi)
mov (%rdx),%edx
mov %edx,0x4(%rdi)
retq
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rsi+8]
mov rdx, [rsi]
mov rax, rdi
mov ecx, [rcx-4]
mov [rdi], ecx
mov edx, [rdx]
mov [rdi+4], edx
retn | _DWORD * func0(_DWORD *a1, long long a2)
{
_DWORD *v2; // rdx
_DWORD *result; // rax
v2 = *(_DWORD **)a2;
result = a1;
*a1 = *(_DWORD *)(*(_QWORD *)(a2 + 8) - 4LL);
a1[1] = *v2;
return result;
} | func0:
ENDBR64
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV RAX,RDI
MOV ECX,dword ptr [RCX + -0x4]
MOV dword ptr [RDI],ECX
MOV EDX,dword ptr [RDX]
MOV dword ptr [RDI + 0x4],EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 *puVar1;
int8 *in_RSI;
puVar1 = (int4 *)*in_RSI;
*(int4 *)param_1 = *(int4 *)(in_RSI[1] + -4);
*(int4 *)(param_1 + 4) = *puVar1;
return param_1;
} |
2,840 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if (n < 10) {
return false;
}
int prodOdd = 1, prodEven = 1;
while (n > 0) {
int digit = n % 10;
prodOdd *= digit;
n = n / 10;
if (n == 0) {
break;
}
digit = n % 10;
prodEven *= digit;
n... | int main() {
assert(func0(2841) == true);
assert(func0(1234) == false);
assert(func0(1212) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x9,-0x14(%rbp)
jg 11a4 <_Z5func0i+0x1b>
mov $0x0,%eax
jmpq 1286 <_Z5func0i+0xfd>
movl $0x1,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 1272 <_Z5func0i+0xe9>
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 9
jg short loc_1164
mov eax, 0
jmp loc_1244
loc_1164:
mov [rbp+var_C], 1
mov [rbp+var_8], 1
jmp loc_1223
loc_1177:
mov edx, [rbp+var_14]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
m... | _BOOL8 func0(int a1)
{
int v2; // [rsp+0h] [rbp-14h]
int v3; // [rsp+0h] [rbp-14h]
int v4; // [rsp+8h] [rbp-Ch]
int v5; // [rsp+Ch] [rbp-8h]
v2 = a1;
if ( a1 <= 9 )
return 0LL;
v4 = 1;
v5 = 1;
while ( v2 > 0 )
{
v4 *= v2 % 10;
v3 = v2 / 10;
if ( !v3 )
break;
v5 *= v3 % 10... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x9
JG 0x00101164
MOV EAX,0x0
JMP 0x00101244
LAB_00101164:
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101223
LAB_00101177:
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR... | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
int4 local_1c;
int4 local_14;
int4 local_10;
if (param_1 < 10) {
uVar1 = 0;
}
else {
local_14 = 1;
local_10 = 1;
for (local_1c = param_1; 0 < local_1c; local_1c = local_1c / 10) {
local_14 = local_14 * (local_1c % 10);
... |
2,841 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if (n < 10) {
return false;
}
int prodOdd = 1, prodEven = 1;
while (n > 0) {
int digit = n % 10;
prodOdd *= digit;
n = n / 10;
if (n == 0) {
break;
}
digit = n % 10;
prodEven *= digit;
n... | int main() {
assert(func0(2841) == true);
assert(func0(1234) == false);
assert(func0(1212) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x0,%eax
cmp $0x9,%edi
jle 120f <_Z5func0i+0x86>
movslq %edi,%rsi
imul $0x66666667,%rsi,%rsi
sar $0x22,%rsi
mov %edi,%eax
sar $0x1f,%eax
sub %eax,%esi
mov %esi,%ecx
lea (%rsi,%rsi,4),%eax
add %eax,%eax
mov %edi,%esi
sub %eax,%esi
mov $0x1,%edi
movslq %ec... | _Z5func0i:
endbr64
mov eax, 0
cmp edi, 9
jle short locret_11CF
movsxd rsi, edi
imul rsi, 66666667h
sar rsi, 22h
mov eax, edi
sar eax, 1Fh
sub esi, eax
mov ecx, esi
lea eax, [rsi+rsi*4]
add eax, eax
mov esi, edi
sub esi, eax
mov edi, 1
loc_117C:
movsxd rax, ecx
im... | bool func0(int a1)
{
bool result; // al
int v2; // ecx
int v3; // esi
int v4; // edi
int v5; // eax
result = 0;
if ( a1 > 9 )
{
v2 = a1 / 10;
v3 = a1 % 10;
v4 = 1;
do
{
v5 = v2 / 10;
v4 *= v2 % 10;
if ( v2 <= 9 )
break;
v3 *= v5 % 10;
v2 = v5 /... | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0x9
JLE 0x001011cf
MOVSXD RSI,EDI
IMUL RSI,RSI,0x66666667
SAR RSI,0x22
MOV EAX,EDI
SAR EAX,0x1f
SUB ESI,EAX
MOV ECX,ESI
LEA EAX,[RSI + RSI*0x4]
ADD EAX,EAX
MOV ESI,EDI
SUB ESI,EAX
MOV EDI,0x1
LAB_0010117c:
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,ECX
SAR EDX,0x1f
SU... | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int4 uVar2;
int iVar3;
int iVar4;
int iVar5;
uVar2 = 0;
if (9 < param_1) {
iVar3 = param_1 / 10;
iVar4 = param_1 % 10;
iVar5 = 1;
do {
iVar1 = iVar3 / 10;
iVar5 = iVar5 * (iVar3 % 10);
if (iVar3 < 10) break;
... |
2,842 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if (n < 10) {
return false;
}
int prodOdd = 1, prodEven = 1;
while (n > 0) {
int digit = n % 10;
prodOdd *= digit;
n = n / 10;
if (n == 0) {
break;
}
digit = n % 10;
prodEven *= digit;
n... | int main() {
assert(func0(2841) == true);
assert(func0(1234) == false);
assert(func0(1212) == false);
return 0;
}
| O2 | cpp | func0(int) [clone .part.0]:
test %edi,%edi
jle 12ee <_Z5func0i.part.0+0x7e>
movslq %edi,%rsi
mov %edi,%eax
mov $0xcccccccd,%r8d
imul $0x66666667,%rsi,%rsi
sar $0x1f,%eax
sar $0x22,%rsi
sub %eax,%esi
lea (%rsi,%rsi,4),%edx
mov %esi,%eax
mov %edi,%esi
mov $0x1,%edi
add %edx,%edx
sub ... | _Z5func0i_part_0:
test edi, edi
jz short loc_1266
movsxd rsi, edi
mov eax, edi
mov r8d, 0CCCCCCCDh
imul rsi, 66666667h
sar eax, 1Fh
sar rsi, 22h
sub esi, eax
lea edx, [rsi+rsi*4]
mov eax, esi
mov esi, edi
mov edi, 1
add edx, edx
sub esi, edx
test eax, eax
jnz ... | bool func0(int a1)
{
int v1; // edx
unsigned int v2; // eax
int v4; // edi
int v5; // esi
unsigned int v6; // edx
int v7; // eax
if ( a1 )
{
v1 = 5 * (a1 / 10);
v2 = a1 / 10;
v4 = 1;
v5 = a1 - 2 * v1;
if ( v2 )
{
do
{
v6 = v2 / 0xA;
v4 *= v2 % 0xA;
... | func0:
TEST EDI,EDI
JZ 0x00101266
MOVSXD RSI,EDI
MOV EAX,EDI
MOV R8D,0xcccccccd
IMUL RSI,RSI,0x66666667
SAR EAX,0x1f
SAR RSI,0x22
SUB ESI,EAX
LEA EDX,[RSI + RSI*0x4]
MOV EAX,ESI
MOV ESI,EDI
MOV EDI,0x1
ADD EDX,EDX
SUB ESI,EDX
TEST EAX,EAX
JNZ 0x00101240
JMP 0x0010126c
LAB_00101228:
MOV EAX,EDX
IMUL RAX,R8
SHR RAX,0x23
... | /* func0(int) [clone .part.0] */
ulong func0(int param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
int iVar5;
int iVar6;
if (param_1 == 0) {
return 1;
}
uVar2 = (ulong)(uint)(param_1 / 10);
iVar6 = 1;
iVar5 = param_1 % 10;
if (param_1 / 10 == 0) {
return (ulong)(iVar5 == 1)... |
2,843 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if (n < 10) {
return false;
}
int prodOdd = 1, prodEven = 1;
while (n > 0) {
int digit = n % 10;
prodOdd *= digit;
n = n / 10;
if (n == 0) {
break;
}
digit = n % 10;
prodEven *= digit;
n... | int main() {
assert(func0(2841) == true);
assert(func0(1234) == false);
assert(func0(1212) == false);
return 0;
}
| O3 | cpp | func0(int) [clone .part.0]:
test %edi,%edi
jle 12ee <_Z5func0i.part.0+0x7e>
movslq %edi,%rsi
mov %edi,%eax
mov $0xcccccccd,%r8d
imul $0x66666667,%rsi,%rsi
sar $0x1f,%eax
sar $0x22,%rsi
sub %eax,%esi
lea (%rsi,%rsi,4),%edx
mov %esi,%eax
mov %edi,%esi
mov $0x1,%edi
add %edx,%edx
sub ... | _Z5func0i_part_0:
test edi, edi
jz short loc_1266
movsxd rsi, edi
mov eax, edi
mov r8d, 0CCCCCCCDh
imul rsi, 66666667h
sar eax, 1Fh
sar rsi, 22h
sub esi, eax
lea edx, [rsi+rsi*4]
mov eax, esi
mov esi, edi
mov edi, 1
add edx, edx
sub esi, edx
test eax, eax
jnz ... | bool func0(int a1)
{
int v1; // edx
unsigned int v2; // eax
int v4; // edi
int v5; // esi
unsigned int v6; // edx
int v7; // eax
if ( a1 )
{
v1 = 5 * (a1 / 10);
v2 = a1 / 10;
v4 = 1;
v5 = a1 - 2 * v1;
if ( v2 )
{
do
{
v6 = v2 / 0xA;
v4 *= v2 % 0xA;
... | func0:
TEST EDI,EDI
JZ 0x00101266
MOVSXD RSI,EDI
MOV EAX,EDI
MOV R8D,0xcccccccd
IMUL RSI,RSI,0x66666667
SAR EAX,0x1f
SAR RSI,0x22
SUB ESI,EAX
LEA EDX,[RSI + RSI*0x4]
MOV EAX,ESI
MOV ESI,EDI
MOV EDI,0x1
ADD EDX,EDX
SUB ESI,EDX
TEST EAX,EAX
JNZ 0x00101240
JMP 0x0010126c
LAB_00101228:
MOV EAX,EDX
IMUL RAX,R8
SHR RAX,0x23
... | /* func0(int) [clone .part.0] */
ulong func0(int param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
int iVar5;
int iVar6;
if (param_1 == 0) {
return 1;
}
uVar2 = (ulong)(uint)(param_1 / 10);
iVar6 = 1;
iVar5 = param_1 % 10;
if (param_1 / 10 == 0) {
return (ulong)(iVar5 == 1)... |
2,844 | func0 | #include <vector>
#include <algorithm>
#include <iterator>
#include <assert.h>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
sort(list1.begin(), list1.end());
auto last = std::unique(list1.begin(), list1.end());
list1.erase(last, list1.end());
return list1;
}
| int main() {
assert((func0<std::vector<int>>({{10, 20}, {40}, {30, 56, 25}, {10, 20}, {33}, {40}}) == std::vector<std::vector<int>>{{10, 20}, {30, 56, 25}, {33}, {40}}));
assert((func0<std::string>({"a", "b", "a", "c", "c"}) == std::vector<std::string>{"a", "b", "c"}));
assert((func0<int>({1, 3, 5, 6, 3,... | O0 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<std::vector<int, std::allocator<int> > >(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
su... | _Z5func0ISt6vectorIiSaIiEEES0_IT_SaIS3_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE3endEv; std... | long long func0<std::vector<int>>(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v7; // [rsp+18h] [rbp-38h] BYREF
long long v8; // [rsp+20h] [rbp-30h] BYREF
long long v9; // [rsp+28h] [rbp-28h] BYREF
_QWORD v10[3]; // [rsp+30h... | func0<std::vector<int,std::allocator<int>>>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00104522
MOV RBX,RAX
MOV RAX,qword pt... | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<std::vector<int, std::allocator<int> >
>(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
vector<std::vector<int,std::allocato... |
2,845 | func0 | #include <vector>
#include <algorithm>
#include <iterator>
#include <assert.h>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
sort(list1.begin(), list1.end());
auto last = std::unique(list1.begin(), list1.end());
list1.erase(last, list1.end());
return list1;
}
| int main() {
assert((func0<std::vector<int>>({{10, 20}, {40}, {30, 56, 25}, {10, 20}, {33}, {40}}) == std::vector<std::vector<int>>{{10, 20}, {30, 56, 25}, {33}, {40}}));
assert((func0<std::string>({"a", "b", "a", "c", "c"}) == std::vector<std::string>{"a", "b", "c"}));
assert((func0<int>({1, 3, 5, 6, 3,... | O1 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%rbx
mov 0x8(%rsi),%r13
mov (%rsi),%r14
cmp %r13,%r14
je 2fcb <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xa4>
mov %r13,%rb... | _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov rbx, rsi
mov r12, [rsi+8]
mov r14, [rsi]
cmp r14, r12
jz loc_379E
mov r13, r12
sub r13, r14
mov rdx, r13
sar rdx, 2
mov eax, 40h ; '@'
jz short loc_3... | _QWORD * func0<int>(_QWORD *a1, long long a2)
{
char *v4; // r12
char *v5; // r14
int v6; // eax
unsigned long long v7; // rax
char *v8; // rdi
char *v9; // rsi
int v10; // ecx
char *v11; // rax
int v12; // edx
char *v13; // rsi
char *v14; // rax
char *v15; // rdx
char *i; // rax
_DWORD *v17... | func0<int>:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV RBX,RSI
MOV R12,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
CMP R14,R12
JZ 0x0010379e
MOV R13,R12
SUB R13,R14
MOV RDX,R13
SAR RDX,0x2
MOV EAX,0x40
JZ 0x001036f6
BSR RAX,RDX
XOR EAX,0x3f
LAB_001036f6:
MOV EDX,0x3f
SUB EDX,EAX
MOVSXD RDX,E... | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
int8 *
func0<int>(int8 *param_1,int8 *param_2,int8 param_3,_Iter_less_iter param_4)
{
int iVar1;
int iVar2;
long lVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int *piVar7;
_Iter_less_iter extraout_EDX;
ulo... |
2,846 | func0 | #include <vector>
#include <algorithm>
#include <iterator>
#include <assert.h>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
sort(list1.begin(), list1.end());
auto last = std::unique(list1.begin(), list1.end());
list1.erase(last, list1.end());
return list1;
}
| int main() {
assert((func0<std::vector<int>>({{10, 20}, {40}, {30, 56, 25}, {10, 20}, {33}, {40}}) == std::vector<std::vector<int>>{{10, 20}, {30, 56, 25}, {33}, {40}}));
assert((func0<std::string>({"a", "b", "a", "c", "c"}) == std::vector<std::string>{"a", "b", "c"}));
assert((func0<int>({1, 3, 5, 6, 3,... | O2 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<std::vector<int, std::allocator<int> > >(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r14
push %r13
push %r12
mov ... | _Z5func0ISt6vectorIiSaIiEEES0_IT_SaIS3_EES5_:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 28h
mov r15, [rsi+8]
mov rbp, [rsi]
mov [rsp+58h+var_40], rdi
cmp rbp, r15
jz loc_3E80
mov rdx, 0AAAAAAAAAAAAAAABh
mov rbx, r15
sub ... | long long * func0<std::vector<int>>(long long *a1, long long *a2, double a3, __m128 a4)
{
long long v5; // r15
long long v6; // rbp
unsigned long long v7; // rax
long long v8; // rdx
long long v9; // rcx
long long v10; // rbp
long long v11; // rbx
long long v12; // r14
long long v13; // r12
const vo... | func0<std::vector<int,std::allocator<int>>>:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R15,qword ptr [RSI + 0x8]
MOV RBP,qword ptr [RSI]
MOV qword ptr [RSP + 0x18],RDI
CMP RBP,R15
JZ 0x00103e80
MOV RDX,-0x5555555555555555
MOV RBX,R15
SUB RBX,RBP
MOV RAX,RBX
SAR RAX,0x3
I... | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<std::vector<int, std::allocator<int> >
>(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
vector func0<std::vector<int,std::al... |
2,847 | func0 | #include <vector>
#include <algorithm>
#include <iterator>
#include <assert.h>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
sort(list1.begin(), list1.end());
auto last = std::unique(list1.begin(), list1.end());
list1.erase(last, list1.end());
return list1;
}
| int main() {
assert((func0<std::vector<int>>({{10, 20}, {40}, {30, 56, 25}, {10, 20}, {33}, {40}}) == std::vector<std::vector<int>>{{10, 20}, {30, 56, 25}, {33}, {40}}));
assert((func0<std::string>({"a", "b", "a", "c", "c"}) == std::vector<std::string>{"a", "b", "c"}));
assert((func0<int>({1, 3, 5, 6, 3,... | O3 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<std::vector<int, std::allocator<int> > >(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r14
push %r13
push %r12
mov ... | _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r12, [rsi+8]
mov r13, [rsi]
cmp r13, r12
jz loc_348B
mov r14, r12
lea rbx, [r13+4]
sub r14, r13
mov rax, r14
sar ... | int ** func0<int>(int **a1, int **a2)
{
int *v4; // r12
int *k; // r13
int *v6; // rbx
unsigned long long v7; // rdx
int *v8; // r14
int v9; // ecx
int *v10; // rsi
int v11; // edx
int *j; // rax
int *v13; // rdi
int v14; // ecx
int v15; // edx
int *v16; // rax
int *v17; // rsi
int *v18; /... | func0<int>:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R12,qword ptr [RSI + 0x8]
MOV R13,qword ptr [RSI]
CMP R13,R12
JZ 0x0010348b
MOV R14,R12
LEA RBX,[R13 + 0x4]
SUB R14,R13
MOV RAX,R14
SAR RAX,0x2
JZ 0x001034bd
BSR RDX,RAX
MOV RSI,R12
MOV RDI,R13
MOVSXD RDX,... | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector func0<int>(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)
{
int8 uVar1;
long lVar2;... |
2,848 | func0 |
#include <iostream>
#include <tuple>
#include <cassert>
| bool func0(std::tuple<bool, bool, bool, bool> test_tup) {
bool res = true;
// Iterate over the tuple elements to check for truthiness
auto check_false = [&](auto ele) {
if (!ele) res = false;
};
std::apply([&](auto... args) {(check_false(args), ...);}, test_tup);
return res;
}
... | int main() {
assert(func0({true, true, true, true}) == true);
assert(func0({true, false, true, true}) == false);
assert(func0({true, true, true, true}) == true);
return 0;
}
| O0 | cpp | auto func0(std::tuple<bool, bool, bool, bool>)::{lambda(auto:1)#1}::operator()<bool>(bool) const:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,%eax
mov %al,-0xc(%rbp)
movzbl -0xc(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 11ec <_ZZ5func0St5tupleIJbbbbEEENKUlT_E_clIbEEDaS1_+0x22>
mov -0x8... | _ZZ5func0St5tupleIJbbbbEEENKUlT_E_clIbEEDaS1_:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov eax, esi
mov [rbp+var_C], al
movzx eax, [rbp+var_C]
xor eax, 1
test al, al
jz short loc_118C
mov rax, [rbp+var_8]
mov rax, [rax]
mov byte ptr [rax], 0
loc_118C:
nop
pop rbp
retn | _BYTE * ZZ5func0St5tupleIJbbbbEEENKUlT_E_clIbEEDaS1_(_QWORD *a1, unsigned __int8 a2)
{
_BYTE *result; // rax
result = (_BYTE *)(a2 ^ 1u);
if ( a2 != 1 )
{
result = (_BYTE *)*a1;
*(_BYTE *)*a1 = 0;
}
return result;
} | __apply_impl<func0(std::tuple<bool,bool,bool,bool>)::{lambda((auto:1)...)#1},std::tuple<bool,bool,bool,bool>&,0ul,1ul,2ul,3ul>:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001015f... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* decltype(auto) std::__apply_impl<func0(std::tuple<bool, bool, bool,
bool>)::{lambda((auto:1)...)#1}, std::tuple<bool, bool, bool, bool>&, 0ul, 1ul, 2ul,
3ul>(func0(std::tuple<bool, bool, bool, bool>)::{lambda((auto:1)...)#1}&&, std::t... |
2,849 | func0 |
#include <iostream>
#include <tuple>
#include <cassert>
| bool func0(std::tuple<bool, bool, bool, bool> test_tup) {
bool res = true;
// Iterate over the tuple elements to check for truthiness
auto check_false = [&](auto ele) {
if (!ele) res = false;
};
std::apply([&](auto... args) {(check_false(args), ...);}, test_tup);
return res;
}
... | int main() {
assert(func0({true, true, true, true}) == true);
assert(func0({true, false, true, true}) == false);
assert(func0({true, true, true, true}) == true);
return 0;
}
| O1 | cpp | func0(std::tuple<bool, bool, bool, bool>):
endbr64
movzbl (%rdi),%eax
movzbl 0x1(%rdi),%edx
movzbl 0x2(%rdi),%ecx
movzbl 0x3(%rdi),%esi
test %cl,%cl
cmovne %esi,%ecx
test %dl,%dl
cmovne %ecx,%edx
test %al,%al
cmovne %edx,%eax
retq
| _Z5func0St5tupleIJbbbbEE:
endbr64
movzx eax, byte ptr [rdi]
movzx edx, byte ptr [rdi+1]
movzx ecx, byte ptr [rdi+2]
test cl, cl
jz short loc_1180
movzx ecx, byte ptr [rdi+3]
loc_1180:
test dl, dl
cmovnz edx, ecx
test al, al
cmovnz eax, edx
retn | long long func0(unsigned __int8 *a1)
{
long long result; // rax
unsigned int v2; // edx
unsigned int v3; // ecx
result = *a1;
v2 = a1[1];
v3 = a1[2];
if ( (_BYTE)v3 )
v3 = a1[3];
if ( (_BYTE)v2 )
v2 = v3;
if ( (_BYTE)result )
return v2;
return result;
} | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
MOVZX EDX,byte ptr [RDI + 0x1]
MOVZX ECX,byte ptr [RDI + 0x2]
TEST CL,CL
JZ 0x00101180
MOVZX ECX,byte ptr [RDI + 0x3]
LAB_00101180:
TEST DL,DL
CMOVNZ EDX,ECX
TEST AL,AL
CMOVNZ EAX,EDX
RET | /* func0(std::tuple<bool, bool, bool, bool>) */
char func0(tuple param_1)
{
char cVar1;
char cVar2;
int4 in_register_0000003c;
cVar1 = *(char *)(CONCAT44(in_register_0000003c,param_1) + 1);
cVar2 = *(char *)(CONCAT44(in_register_0000003c,param_1) + 2);
if (cVar2 != '\0') {
cVar2 = *(char *)(CONCAT4... |
2,850 | func0 |
#include <iostream>
#include <tuple>
#include <cassert>
| bool func0(std::tuple<bool, bool, bool, bool> test_tup) {
bool res = true;
// Iterate over the tuple elements to check for truthiness
auto check_false = [&](auto ele) {
if (!ele) res = false;
};
std::apply([&](auto... args) {(check_false(args), ...);}, test_tup);
return res;
}
... | int main() {
assert(func0({true, true, true, true}) == true);
assert(func0({true, false, true, true}) == false);
assert(func0({true, true, true, true}) == true);
return 0;
}
| O2 | cpp | _ZSt12__apply_implIZ5func0St5tupleIJbbbbEEEUlDpT_E0_RS1_JLm0ELm1ELm2ELm3EEEDcOT_OT0_St16integer_sequenceImJXspT1_EEE.isra.0:
mov %rdi,%r8
cmpb $0x0,0x3(%rsi)
movzbl 0x2(%rsi),%edi
movzbl 0x1(%rsi),%ecx
movzbl (%rsi),%edx
mov (%r8),%rax
jne 135d <_ZSt12__apply_implIZ5func0St5tupleIJbbbbEEEUlDpT_E0_RS1_JLm0ELm... | _Z5func0St5tupleIJbbbbEE:
endbr64
movzx ecx, byte ptr [rdi+2]
movzx eax, byte ptr [rdi]
movzx edx, byte ptr [rdi+1]
test cl, cl
jz short loc_1257
movzx ecx, byte ptr [rdi+3]
loc_1257:
test dl, dl
cmovnz edx, ecx
test al, al
cmovnz eax, edx
retn | long long func0(unsigned __int8 *a1)
{
unsigned int v1; // ecx
long long result; // rax
unsigned int v3; // edx
v1 = a1[2];
result = *a1;
v3 = a1[1];
if ( (_BYTE)v1 )
v1 = a1[3];
if ( (_BYTE)v3 )
v3 = v1;
if ( (_BYTE)result )
return v3;
return result;
} | func0:
ENDBR64
MOVZX ECX,byte ptr [RDI + 0x2]
MOVZX EAX,byte ptr [RDI]
MOVZX EDX,byte ptr [RDI + 0x1]
TEST CL,CL
JZ 0x00101257
MOVZX ECX,byte ptr [RDI + 0x3]
LAB_00101257:
TEST DL,DL
CMOVNZ EDX,ECX
TEST AL,AL
CMOVNZ EAX,EDX
RET | /* func0(std::tuple<bool, bool, bool, bool>) */
char func0(tuple param_1)
{
char cVar1;
char cVar2;
int4 in_register_0000003c;
cVar1 = *(char *)(CONCAT44(in_register_0000003c,param_1) + 2);
cVar2 = *(char *)(CONCAT44(in_register_0000003c,param_1) + 1);
if (cVar1 != '\0') {
cVar1 = *(char *)(CONCAT4... |
2,851 | func0 |
#include <iostream>
#include <tuple>
#include <cassert>
| bool func0(std::tuple<bool, bool, bool, bool> test_tup) {
bool res = true;
// Iterate over the tuple elements to check for truthiness
auto check_false = [&](auto ele) {
if (!ele) res = false;
};
std::apply([&](auto... args) {(check_false(args), ...);}, test_tup);
return res;
}
... | int main() {
assert(func0({true, true, true, true}) == true);
assert(func0({true, false, true, true}) == false);
assert(func0({true, true, true, true}) == true);
return 0;
}
| O3 | cpp | _ZSt12__apply_implIZ5func0St5tupleIJbbbbEEEUlDpT_E0_RS1_JLm0ELm1ELm2ELm3EEEDcOT_OT0_St16integer_sequenceImJXspT1_EEE.isra.0:
mov %rdi,%r8
cmpb $0x0,0x3(%rsi)
movzbl 0x2(%rsi),%edi
movzbl 0x1(%rsi),%ecx
movzbl (%rsi),%edx
mov (%r8),%rax
jne 135d <_ZSt12__apply_implIZ5func0St5tupleIJbbbbEEEUlDpT_E0_RS1_JLm0ELm... | _ZSt12__apply_implIZ5func0St5tupleIJbbbbEEEUlDpT_E_RS1_JLm0ELm1ELm2ELm3EEEDcOT_OT0_St16integer_sequenceImJXspT1_EEE_isra_0:
cmp byte ptr [rsi+3], 0
movzx eax, byte ptr [rsi]
movzx edx, byte ptr [rsi+1]
movzx ecx, byte ptr [rsi+2]
jnz short loc_1297
mov rsi, [rdi]
mov byte ptr [rsi], 0
loc_1297:
te... | _BYTE * ZSt12__apply_implIZ5func0St5tupleIJbbbbEEEUlDpT_E_RS1_JLm0ELm1ELm2ELm3EEEDcOT_OT0_St16integer_sequenceImJXspT1_EEE_isra_0(
_BYTE **a1,
unsigned __int8 *a2)
{
_BYTE *result; // rax
unsigned __int8 v3; // dl
unsigned __int8 v4; // cl
result = (_BYTE *)*a2;
v3 = a2[1];
v4 = a2[2];
if... | __apply_impl<func0(std::tuple<bool,bool,bool,bool>)::{lambda((auto:1)...)#1},std::tuple<bool,bool,bool,bool>&,0ul,1ul,2ul,3ul>:
CMP byte ptr [RSI + 0x3],0x0
MOVZX EAX,byte ptr [RSI]
MOVZX EDX,byte ptr [RSI + 0x1]
MOVZX ECX,byte ptr [RSI + 0x2]
JNZ 0x00101297
MOV RSI,qword ptr [RDI]
MOV byte ptr [RSI],0x0
LAB_00101297:
... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* decltype(auto) std::__apply_impl<func0(std::tuple<bool, bool, bool,
bool>)::{lambda((auto:1)...)#1}, std::tuple<bool, bool, bool, bool>&, 0ul, 1ul, 2ul,
3ul>(func0(std::tuple<bool, bool, bool, bool>)::{lambda((auto:1)...)#1}&&, std::t... |
2,852 | func0 |
#include <cassert>
| int func0(int n) {
int m = n;
int count = 0;
int i = 2;
while((i * i) <= m) {
int total = 0;
while (n % i == 0) {
n /= i;
total += 1;
}
int temp = 0;
int j = 1;
while((temp + j) <= total) {
temp += j;
... | int main() {
assert(func0(24) == 3);
assert(func0(12) == 2);
assert(func0(4) == 1);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
mov %eax,-0x4(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x2,-0x14(%rbp)
mov -0x14(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x4(%rbp)
jl 11c8 <_Z5func0i+0x7f>
movl $0x0,-0x10(%rbp)
mov -0x24(%rbp),%eax
cltd
idivl ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
mov [rbp+var_18], 0
mov [rbp+var_14], 2
jmp short loc_11BD
loc_116A:
mov [rbp+var_10], 0
jmp short loc_1181
loc_1173:
mov eax, [rbp+var_24]
cdq
idiv [rbp+var_14]
mov ... | long long func0(int a1)
{
int v2; // [rsp+0h] [rbp-24h]
unsigned int v3; // [rsp+Ch] [rbp-18h]
int i; // [rsp+10h] [rbp-14h]
int v5; // [rsp+14h] [rbp-10h]
int v6; // [rsp+18h] [rbp-Ch]
int j; // [rsp+1Ch] [rbp-8h]
v2 = a1;
v3 = 0;
for ( i = 2; a1 >= i * i; ++i )
{
v5 = 0;
while ( !(v2 % i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x2
JMP 0x001011bd
LAB_0010116a:
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101181
LAB_00101173:
MOV EAX,dword ptr [RBP + -0x24]
CDQ... | /* func0(int) */
int func0(int param_1)
{
int4 local_2c;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
local_20 = 0;
local_2c = param_1;
for (local_1c = 2; local_1c * local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = 0;
for (; local_2c % local_1c == 0... |
2,853 | func0 |
#include <cassert>
| int func0(int n) {
int m = n;
int count = 0;
int i = 2;
while((i * i) <= m) {
int total = 0;
while (n % i == 0) {
n /= i;
total += 1;
}
int temp = 0;
int j = 1;
while((temp + j) <= total) {
temp += j;
... | int main() {
assert(func0(24) == 3);
assert(func0(12) == 2);
assert(func0(4) == 1);
return 0;
}
| O1 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 11b1 <_Z5func0i+0x68>
mov %edi,%ecx
mov $0x2,%esi
mov $0x0,%r10d
jmp 116d <_Z5func0i+0x24>
add $0x1,%esi
mov %esi,%eax
imul %esi,%eax
cmp %edi,%eax
jg 11b9 <_Z5func0i+0x70>
mov %ecx,%eax
cltd
idiv %esi
mov %edx,%r8d
test %edx,%edx
jne 1... | _Z5func0i:
endbr64
mov r10d, edi
mov ecx, edi
mov esi, 2
mov r8d, 0
mov r11d, 1
cmp edi, 3
jg short loc_11B9
loc_1168:
cmp ecx, 1
setnz al
movzx eax, al
add r8d, eax
mov eax, r8d
retn
loc_1178:
mov eax, ecx
cdq
idiv esi
mov ecx, eax
add edi, 1
cdq
idiv esi
... | long long func0(int a1)
{
int v2; // ecx
int v3; // esi
int v4; // r8d
int v6; // edi
int v7; // eax
int i; // edx
v2 = a1;
v3 = 2;
v4 = 0;
if ( a1 > 3 )
{
do
{
v6 = v2 % v3;
if ( !(v2 % v3) )
{
do
{
v2 /= v3;
++v6;
}
... | func0:
ENDBR64
MOV R10D,EDI
MOV ECX,EDI
MOV ESI,0x2
MOV R8D,0x0
MOV R11D,0x1
CMP EDI,0x3
JG 0x001011b9
LAB_00101168:
CMP ECX,0x1
SETNZ AL
MOVZX EAX,AL
ADD R8D,EAX
MOV EAX,R8D
RET
LAB_00101178:
MOV EAX,ECX
CDQ
IDIV ESI
MOV ECX,EAX
ADD EDI,0x1
CDQ
IDIV ESI
TEST EDX,EDX
JZ 0x00101178
TEST EDI,EDI
JLE 0x001011ac
MOV EAX,R8... | /* func0(int) */
int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
iVar6 = 2;
iVar7 = 0;
iVar2 = param_1;
iVar3 = 0;
if (3 < param_1) {
do {
iVar5 = iVar2 % iVar6;
iVar7 = iVar3;
if (iVar5 == 0) {
... |
2,854 | func0 |
#include <cassert>
| int func0(int n) {
int m = n;
int count = 0;
int i = 2;
while((i * i) <= m) {
int total = 0;
while (n % i == 0) {
n /= i;
total += 1;
}
int temp = 0;
int j = 1;
while((temp + j) <= total) {
temp += j;
... | int main() {
assert(func0(24) == 3);
assert(func0(12) == 2);
assert(func0(4) == 1);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%ecx
cmp $0x3,%edi
jle 1309 <_Z5func0i+0x79>
mov $0x2,%esi
xor %r10d,%r10d
nopl 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %esi
mov %edx,%r8d
test %edx,%edx
jne 12ee <_Z5func0i+0x5e>
nopl 0x0(%rax)
mov %ecx,%eax
add $0x1,%r8d
cltd
idiv %esi
cltd
mov ... | _Z5func0i:
endbr64
mov ecx, edi
mov r10d, edi
mov esi, 2
xor edi, edi
mov r11d, 1
cmp ecx, 3
jle short loc_125D
nop dword ptr [rax+rax+00h]
loc_1210:
mov eax, ecx
cdq
idiv esi
mov r8d, edx
test edx, edx
jnz short loc_1250
nop dword ptr [rax+00h]
loc_1220:
mov ea... | long long func0(int a1)
{
int v1; // ecx
int v3; // esi
int v4; // edi
int v5; // r8d
int v6; // edx
int v7; // eax
int v8; // edx
v1 = a1;
v3 = 2;
v4 = 0;
if ( v1 > 3 )
{
do
{
v5 = v1 % v3;
if ( !(v1 % v3) )
{
do
{
++v5;
v6 = (v1 /... | func0:
ENDBR64
MOV ECX,EDI
MOV R10D,EDI
MOV ESI,0x2
XOR EDI,EDI
MOV R11D,0x1
CMP ECX,0x3
JLE 0x0010125d
NOP dword ptr [RAX + RAX*0x1]
LAB_00101210:
MOV EAX,ECX
CDQ
IDIV ESI
MOV R8D,EDX
TEST EDX,EDX
JNZ 0x00101250
NOP dword ptr [RAX]
LAB_00101220:
MOV EAX,ECX
ADD R8D,0x1
CDQ
IDIV ESI
CDQ
MOV ECX,EAX
IDIV ESI
TEST EDX,ED... | /* func0(int) */
int func0(int param_1)
{
ulong uVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
uint uVar6;
ulong uVar7;
int iVar8;
uVar3 = (ulong)(uint)param_1;
iVar5 = 2;
iVar2 = 0;
iVar4 = param_1;
if (3 < param_1) {
do {
uVar1 = (long)(int)uVar3 % (long)iVar5;
uVa... |
2,855 | func0 |
#include <cassert>
| int func0(int n) {
int m = n;
int count = 0;
int i = 2;
while((i * i) <= m) {
int total = 0;
while (n % i == 0) {
n /= i;
total += 1;
}
int temp = 0;
int j = 1;
while((temp + j) <= total) {
temp += j;
... | int main() {
assert(func0(24) == 3);
assert(func0(12) == 2);
assert(func0(4) == 1);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%ecx
cmp $0x3,%edi
jle 1309 <_Z5func0i+0x79>
mov $0x2,%esi
xor %r10d,%r10d
nopl 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %esi
mov %edx,%r8d
test %edx,%edx
jne 12ee <_Z5func0i+0x5e>
nopl 0x0(%rax)
mov %ecx,%eax
add $0x1,%r8d
cltd
idiv %esi
cltd
mov ... | _Z5func0i:
endbr64
mov ecx, edi
mov r10d, edi
mov esi, 2
xor edi, edi
mov r11d, 1
cmp ecx, 3
jle short loc_12FD
nop dword ptr [rax+rax+00h]
loc_12B0:
mov eax, ecx
cdq
idiv esi
mov r8d, edx
test edx, edx
jnz short loc_12F0
nop dword ptr [rax+00h]
loc_12C0:
mov ea... | long long func0(int a1)
{
int v1; // ecx
int v3; // esi
int v4; // edi
int v5; // r8d
int v6; // edx
int v7; // eax
int v8; // edx
v1 = a1;
v3 = 2;
v4 = 0;
if ( v1 > 3 )
{
do
{
v5 = v1 % v3;
if ( !(v1 % v3) )
{
do
{
++v5;
v6 = (v1 /... | func0:
ENDBR64
MOV ECX,EDI
MOV R10D,EDI
MOV ESI,0x2
XOR EDI,EDI
MOV R11D,0x1
CMP ECX,0x3
JLE 0x001012fd
NOP dword ptr [RAX + RAX*0x1]
LAB_001012b0:
MOV EAX,ECX
CDQ
IDIV ESI
MOV R8D,EDX
TEST EDX,EDX
JNZ 0x001012f0
NOP dword ptr [RAX]
LAB_001012c0:
MOV EAX,ECX
ADD R8D,0x1
CDQ
IDIV ESI
CDQ
MOV ECX,EAX
IDIV ESI
TEST EDX,ED... | /* func0(int) */
int func0(int param_1)
{
ulong uVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
uint uVar6;
ulong uVar7;
int iVar8;
uVar3 = (ulong)(uint)param_1;
iVar5 = 2;
iVar2 = 0;
iVar4 = param_1;
if (3 < param_1) {
do {
uVar1 = (long)(int)uVar3 % (long)iVar5;
uVa... |
2,856 | func0 | #include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(const std::string& test_str) {
std::vector<int> res;
std::stringstream ss(test_str);
std::string item;
while(std::getline(ss, item, ',')) {
item.erase(remove_if(item.begin(), item.end(), ::isspace), item.end());
res.push_back(std::stoi(item));
}
ret... | int main() {
// Test cases
assert((func0("1, -5, 4, 6, 7") == std::vector<int>({1, -5, 4, 6, 7})));
assert((func0("1, 2, 3, 4, 5") == std::vector<int>({1, 2, 3, 4, 5})));
assert((func0("4, 6, 9, 11, 13, 14") == std::vector<int>({4, 6, 9, 11, 13, 14})));
std::cout << "All test cases passed." <... | 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 $0x1e8,%rsp
mov %rdi,-0x1e8(%rbp)
mov %rsi,-0x1f0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x1e8(%rbp),%rax
mov %rax,%rdi
cal... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 1E8h
mov [rbp+var_1E8], rdi
mov [rbp+var_1F0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_1E8]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE... | long long func0(long long a1, long long a2)
{
unsigned int v2; // eax
long long v3; // rbx
long long v4; // rax
_QWORD *v5; // rax
long long v7; // [rsp+10h] [rbp-1E0h] BYREF
long long v8; // [rsp+18h] [rbp-1D8h] BYREF
long long v9; // [rsp+20h] [rbp-1D0h] BYREF
long long v10; // [rsp+28h] [rbp-1C8h] B... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x1e8
MOV qword ptr [RBP + -0x1e8],RDI
MOV qword ptr [RBP + -0x1f0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x1e8]
MOV RDI,RAX
CALL 0x00102eb4
MOV ESI,0x8
MOV EDI,0x10
CALL 0x00102e55
MOV EDX,EAX
MOV RCX,q... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
_Ios_Openmode _Var2;
__normal_iterator _Var3;
__normal_iterator _Var4;
int4 extraout_var;
istream *piVar5;
string *in_RSI;
long in_FS_OFFSET;
int8 local_1e8;
int8 local_1e0;
__normal_iterator<char_const*,std::string> l... |
2,857 | func0 | #include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(const std::string& test_str) {
std::vector<int> res;
std::stringstream ss(test_str);
std::string item;
while(std::getline(ss, item, ',')) {
item.erase(remove_if(item.begin(), item.end(), ::isspace), item.end());
res.push_back(std::stoi(item));
}
ret... | int main() {
// Test cases
assert((func0("1, -5, 4, 6, 7") == std::vector<int>({1, -5, 4, 6, 7})));
assert((func0("1, 2, 3, 4, 5") == std::vector<int>({1, 2, 3, 4, 5})));
assert((func0("4, 6, 9, 11, 13, 14") == std::vector<int>({4, 6, 9, 11, 13, 14})));
std::cout << "All test cases passed." <... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1d8,%rsp
mov %rdi,%r13
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1D8h
mov r13, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+208h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v2; // rdx
long long v3; // rsi
_QWORD *i; // rax
char *j; // rbx
char v6; // bp
char *v7; // r15
void *v8; // rbp
int *v9; // rbx
int v10; // r12d
long long v11; // rax
_DWORD *v12; // rsi
char *v13; // r12
long long ifIN9__gnu_cxx17__norm... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1d8
MOV R13,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RBP,[RSP + 0x40]
LEA RDI,[RSP + 0xc0]
CALL 0x0010224... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char cVar1;
char *pcVar2;
int *puVar3;
int iVar4;
__normal_iterator _Var5;
int *piVar6;
long lVar7;
istream *piVar8;
int8 uVar9;
int4 extraout_var;
random_access_iterator_tag rVar10;
ulong uVar11;
int8 *in_RSI;
char *pcVar12... |
2,858 | func0 | #include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(const std::string& test_str) {
std::vector<int> res;
std::stringstream ss(test_str);
std::string item;
while(std::getline(ss, item, ',')) {
item.erase(remove_if(item.begin(), item.end(), ::isspace), item.end());
res.push_back(std::stoi(item));
}
ret... | int main() {
// Test cases
assert((func0("1, -5, 4, 6, 7") == std::vector<int>({1, -5, 4, 6, 7})));
assert((func0("1, 2, 3, 4, 5") == std::vector<int>({1, 2, 3, 4, 5})));
assert((func0("4, 6, 9, 11, 13, 14") == std::vector<int>({4, 6, 9, 11, 13, 14})));
std::cout << "All test cases passed." <... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x1f8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
lea 0x60... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 208h
movq xmm1, cs:off_5C88
mov rax, fs:28h
mov [rsp+238h+var_40], rax
xor eax, eax
mov qwo... | long long func0(long long a1, long long a2)
{
_QWORD *v3; // rdi
__m128i si128; // xmm1
char *v5; // rbx
_BYTE *v6; // r12
void *v7; // rax
_QWORD *v8; // rax
_BYTE *v9; // r13
long long v10; // r15
char *v11; // rbx
long long v12; // rcx
char *v13; // r12
char *v14; // r14
char *v15; // r12
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x208
MOVQ XMM1,qword ptr [0x00105c88]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1f8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0xf0]
LEA RBX,[RSP + 0x70]
MOVUPS xmmword ptr [... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string const&) */
string * func0(string *param_1)
{
char *pcVar1;
streambuf *psVar2;
char cVar3;
char *pcVar4;
int *__src;
int4 *puVar5;
pointer_____offset_0x40___ puVar6;
int iVar7;
istream *piVar8;
int *piVar9;
long lVar10;
... |
2,859 | func0 | #include <iostream>
#include <vector>
#include <sstream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(const std::string& test_str) {
std::vector<int> res;
std::stringstream ss(test_str);
std::string item;
while(std::getline(ss, item, ',')) {
item.erase(remove_if(item.begin(), item.end(), ::isspace), item.end());
res.push_back(std::stoi(item));
}
ret... | int main() {
// Test cases
assert((func0("1, -5, 4, 6, 7") == std::vector<int>({1, -5, 4, 6, 7})));
assert((func0("1, 2, 3, 4, 5") == std::vector<int>({1, 2, 3, 4, 5})));
assert((func0("4, 6, 9, 11, 13, 14") == std::vector<int>({4, 6, 9, 11, 13, 14})));
std::cout << "All test cases passed." <... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x1f8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
movq $0x0... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 208h
movq xmm1, cs:off_5C88
mov rax, fs:28h
mov [rsp+238h+var_40], rax
xor eax, eax
mov qwo... | long long func0(long long a1, long long a2)
{
_QWORD *v3; // rdi
__m128i si128; // xmm1
char *v5; // rbx
_BYTE *v6; // r12
void *v7; // rax
_QWORD *v8; // rax
_BYTE *v9; // r13
long long v10; // r15
char *v11; // rbx
long long v12; // rcx
char *v13; // r12
char *v14; // r14
char *v15; // r12
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x208
MOVQ XMM1,qword ptr [0x00105c88]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1f8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0xf0]
LEA RBX,[RSP + 0x70]
MOVUPS xmmword ptr [... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string const&) */
string * func0(string *param_1)
{
char *pcVar1;
streambuf *psVar2;
char cVar3;
char *pcVar4;
int *__src;
int4 *puVar5;
pointer_____offset_0x40___ puVar6;
int iVar7;
istream *piVar8;
int *piVar9;
long lVar10;
... |
2,860 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
shl $0x2,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
shl eax, 2
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
SHL EAX,0x2
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 << 2;
} |
2,861 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O1 | cpp | func0(int):
endbr64
lea 0x0(,%rdi,4),%eax
retq
| _Z5func0i:
endbr64
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI*0x4]
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * 4;
} |
2,862 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O2 | cpp | func0(int):
endbr64
lea 0x0(,%rdi,4),%eax
retq
nopl 0x0(%rax)
| _Z5func0i:
endbr64
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI*0x4]
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * 4;
} |
2,863 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O3 | cpp | func0(int):
endbr64
lea 0x0(,%rdi,4),%eax
retq
nopl 0x0(%rax)
| _Z5func0i:
endbr64
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI*0x4]
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * 4;
} |
2,864 | func0 | #include <vector>
#include <cmath>
#include <assert.h>
double avg_calc(const std::vector<int>& ls) {
int n = ls.size();
double mean = 0.0;
if (n <= 1) {
return static_cast<double>(ls[0]);
}
for (int el : ls) {
mean += static_cast<double>(el);
}
mean /= static_ca... | double func0(const std::vector<int>& data) {
int n = data.size();
if (n <= 1) {
return 0.0;
}
double mean = avg_calc(data);
double sd = 0.0;
for (int el : data) {
sd += std::pow(static_cast<double>(el) - mean, 2);
}
sd = std::sqrt(sd / static_cast<double>(n - 1)... | int main() {
assert(func0({4, 2, 5, 8, 6}) == 2.23606797749979);
assert(func0({1, 2, 3, 4, 5, 6, 7}) == 2.160246899469287);
assert(func0({5, 9, 10, 15, 6, 4}) == 4.070217029430577);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1792 <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %eax,-0x38(%rbp)
cmpl $0x1,-0x38(... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_38], eax
cmp [rbp+... | unsigned long long func0(long long a1)
{
int *v1; // rax
double v2; // xmm0_8
int v4; // [rsp+18h] [rbp-38h]
long long v5; // [rsp+20h] [rbp-30h] BYREF
long long v6; // [rsp+28h] [rbp-28h] BYREF
double v7; // [rsp+30h] [rbp-20h]
double v8; // [rsp+38h] [rbp-18h]
long long v9; // [rsp+40h] [rbp-10h]
u... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x0010184e
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x1
JG 0x001013ca
PXOR XMM0,XMM0
JMP 0x001014aa
... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
bool bVar1;
int iVar2;
int *piVar3;
long in_FS_OFFSET;
double extraout_XMM0_Qa;
double dVar4;
int8 local_38;
int8 local_30;
double local_28;
double local_20;
vector<int,std::allocator<int>> *local_18;
lo... |
2,865 | func0 | #include <vector>
#include <cmath>
#include <assert.h>
double avg_calc(const std::vector<int>& ls) {
int n = ls.size();
double mean = 0.0;
if (n <= 1) {
return static_cast<double>(ls[0]);
}
for (int el : ls) {
mean += static_cast<double>(el);
}
mean /= static_ca... | double func0(const std::vector<int>& data) {
int n = data.size();
if (n <= 1) {
return 0.0;
}
double mean = avg_calc(data);
double sd = 0.0;
for (int el : data) {
sd += std::pow(static_cast<double>(el) - mean, 2);
}
sd = std::sqrt(sd / static_cast<double>(n - 1)... | int main() {
assert(func0({4, 2, 5, 8, 6}) == 2.23606797749979);
assert(func0({1, 2, 3, 4, 5, 6, 7}) == 2.160246899469287);
assert(func0({5, 9, 10, 15, 6, 4}) == 4.070217029430577);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov 0x8(%rdi),%rbp
mov (%rdi),%rbx
mov %rbp,%r12
sub %rbx,%r12
sar $0x2,%r12
cmp $0x1,%r12d
jle 1317 <_Z5func0RKSt6vectorIiSaIiEE+0x9a>
callq 1229 <_Z8avg_calcRKSt6vectorIiSaIiEE>
mo... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
push rbp
push rbx
mov rbp, [rdi+8]
mov rbx, [rdi]
mov r12, rbp
sub r12, rbx
sar r12, 2
pxor xmm0, xmm0
cmp r12d, 1
jle short loc_12EE
call _Z8avg_calcRKSt6vectorIiSaIiEE; avg_calc(std::vector<int> const&)
movapd xmm2, xmm0
cmp ... | double func0(int **a1)
{
int *v1; // rbp
int *v2; // rbx
long long v3; // r12
double result; // xmm0_8
double v5; // xmm2_8
int *v6; // rax
double v7; // xmm0_8
double v8; // xmm0_8
v1 = a1[1];
v2 = *a1;
v3 = v1 - *a1;
result = 0.0;
if ( (int)v3 > 1 )
{
v5 = avg_calc(0.0);
if ( v1 ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV R12,RBP
SUB R12,RBX
SAR R12,0x2
PXOR XMM0,XMM0
CMP R12D,0x1
JLE 0x001012ee
CALL 0x00101229
MOVAPD XMM2,XMM0
CMP RBP,RBX
JZ 0x001012fa
MOV RAX,RBX
PXOR XMM0,XMM0
LAB_001012b2:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RAX]
... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
double dVar4;
double dVar5;
piVar1 = *(int **)(param_1 + 8);
piVar2 = *(int **)param_1;
dVar5 = 0.0;
iVar3 = (int)((long)piVar1 - (long)piVar2 >> 2);
if (1 < iVar3) {
... |
2,866 | func0 | #include <vector>
#include <cmath>
#include <assert.h>
double avg_calc(const std::vector<int>& ls) {
int n = ls.size();
double mean = 0.0;
if (n <= 1) {
return static_cast<double>(ls[0]);
}
for (int el : ls) {
mean += static_cast<double>(el);
}
mean /= static_ca... | double func0(const std::vector<int>& data) {
int n = data.size();
if (n <= 1) {
return 0.0;
}
double mean = avg_calc(data);
double sd = 0.0;
for (int el : data) {
sd += std::pow(static_cast<double>(el) - mean, 2);
}
sd = std::sqrt(sd / static_cast<double>(n - 1)... | int main() {
assert(func0({4, 2, 5, 8, 6}) == 2.23606797749979);
assert(func0({1, 2, 3, 4, 5, 6, 7}) == 2.160246899469287);
assert(func0({5, 9, 10, 15, 6, 4}) == 4.070217029430577);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%rax
mov %rcx,%rsi
sub %rax,%rsi
sar $0x2,%rsi
cmp $0x1,%esi
jle 1520 <_Z5func0RKSt6vectorIiSaIiEE+0xa0>
cmp %rcx,%rax
je 1530 <_Z5func0RKSt6vectorIiSaIiEE+0xb0>
pxor %xmm3,%xmm3
mov %rax,%rdx
mo... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov r8, [rdi+8]
mov rax, [rdi]
mov rsi, r8
sub rsi, rax
sar rsi, 2
cmp esi, 1
jle loc_14D0
cmp r8, rax
jz loc_14D8
mov rdx, rax
pxor xmm0, xmm0
xchg ax, ax
loc_1460:
pxor xmm1, xmm1
mov rcx, rdx
lea rdx, [rdx+4]
cvtsi2sd xmm1... | double func0(long long *a1)
{
long long v1; // r8
long long v2; // rax
long long v3; // rsi
long long v4; // rdx
double v5; // xmm0_8
long long v6; // rcx
double v7; // xmm2_8
double v8; // xmm0_8
double v9; // xmm2_8
long long v10; // rdx
double v11; // xmm0_8
v1 = a1[1];
v2 = *a1;
v3 = (... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOV RSI,R8
SUB RSI,RAX
SAR RSI,0x2
CMP ESI,0x1
JLE 0x001014d0
CMP R8,RAX
JZ 0x001014d8
MOV RDX,RAX
PXOR XMM0,XMM0
NOP
LAB_00101460:
PXOR XMM1,XMM1
MOV RCX,RDX
LEA RDX,[RDX + 0x4]
CVTSI2SD XMM1,dword ptr [RDX + -0x4]
ADDSD XMM0,XMM1
CMP R8,RDX
JNZ 0x001... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
bool bVar6;
double dVar7;
double dVar8;
double dVar9;
piVar1 = *(int **)(param_1 + 8);
piVar3 = *(int **)param_1;
iVar5 = (int)((long)piV... |
2,867 | func0 | #include <vector>
#include <cmath>
#include <assert.h>
double avg_calc(const std::vector<int>& ls) {
int n = ls.size();
double mean = 0.0;
if (n <= 1) {
return static_cast<double>(ls[0]);
}
for (int el : ls) {
mean += static_cast<double>(el);
}
mean /= static_ca... | double func0(const std::vector<int>& data) {
int n = data.size();
if (n <= 1) {
return 0.0;
}
double mean = avg_calc(data);
double sd = 0.0;
for (int el : data) {
sd += std::pow(static_cast<double>(el) - mean, 2);
}
sd = std::sqrt(sd / static_cast<double>(n - 1)... | int main() {
assert(func0({4, 2, 5, 8, 6}) == 2.23606797749979);
assert(func0({1, 2, 3, 4, 5, 6, 7}) == 2.160246899469287);
assert(func0({5, 9, 10, 15, 6, 4}) == 4.070217029430577);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%rax
mov %rcx,%rsi
sub %rax,%rsi
sar $0x2,%rsi
cmp $0x1,%esi
jle 14f0 <_Z5func0RKSt6vectorIiSaIiEE+0xa0>
cmp %rcx,%rax
je 1500 <_Z5func0RKSt6vectorIiSaIiEE+0xb0>
pxor %xmm3,%xmm3
mov %rax,%rdx
mo... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rsi, [rdi+8]
mov rax, [rdi]
mov rdi, rsi
sub rdi, rax
sar rdi, 2
cmp edi, 1
jle loc_14D8
cmp rsi, rax
jz loc_14E0
mov rdx, rax
pxor xmm0, xmm0
xchg ax, ax
loc_1460:
pxor xmm1, xmm1
mov rcx, rdx
lea rdx, [rdx+4]
cvtsi2sd x... | double func0(long long *a1)
{
long long v1; // rsi
long long v2; // rax
long long v3; // rdi
long long v4; // rdx
double v5; // xmm0_8
long long v6; // rcx
double v7; // xmm2_8
double v8; // xmm0_8
long long v9; // rdx
double v10; // xmm2_8
v1 = a1[1];
v2 = *a1;
v3 = (v1 - *a1) >> 2;
if ( ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOV RDI,RSI
SUB RDI,RAX
SAR RDI,0x2
CMP EDI,0x1
JLE 0x001014d8
CMP RSI,RAX
JZ 0x001014e0
MOV RDX,RAX
PXOR XMM0,XMM0
NOP
LAB_00101460:
PXOR XMM1,XMM1
MOV RCX,RDX
LEA RDX,[RDX + 0x4]
CVTSI2SD XMM1,dword ptr [RDX + -0x4]
ADDSD XMM0,XMM1
CMP RSI,RDX
JNZ 0... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
bool bVar6;
double dVar7;
double dVar8;
double dVar9;
piVar1 = *(int **)(param_1 + 8);
piVar3 = *(int **)param_1;
iVar5 = (int)((long)piV... |
2,868 | func0 |
#include <vector>
#include <assert.h>
#include <string>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
std::vector<T> result;
for (int i = 0; i < list1.size(); i += 2) {
result.push_back(list1[i]);
}
return result;
}
| int main() {
assert((func0<std::string>({"red", "black", "white", "green", "orange"}) == std::vector<std::string>{"red", "white", "orange"}));
assert((func0<int>({2, 0, 3, 4, 0, 2, 8, 3, 4, 2}) == std::vector<int>{2, 3, 0, 8, 4}));
assert((func0<int>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1... | O0 | cpp | 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> > > > func0<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::vector<std::__cxx11::basic_string<c... | _Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIT_SaIS7_EES9_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE... | long long func0<std::string>(long long a1, long long a2)
{
long long v2; // rax
int i; // [rsp+1Ch] [rbp-14h]
std::vector<std::string>::vector(a1);
for ( i = 0; i < (unsigned long long)std::vector<std::string>::size(a2); i += 2 )
{
v2 = std::vector<std::string>::operator[](a2, i);
std::vector<std::s... | func0<std::string>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010312e
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001031a2
LAB_00103177:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr... | /* std::vector<std::string, std::allocator<std::string > > func0<std::string
>(std::vector<std::string, std::allocator<std::string > >) */
vector func0<std::string>(vector param_1)
{
string *psVar1;
ulong uVar2;
vector<std::string,std::allocator<std::string>> *in_RSI;
int4 in_register_0000003c;
int4 loca... |
2,869 | func0 |
#include <vector>
#include <assert.h>
#include <string>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
std::vector<T> result;
for (int i = 0; i < list1.size(); i += 2) {
result.push_back(list1[i]);
}
return result;
}
| int main() {
assert((func0<std::string>({"red", "black", "white", "green", "orange"}) == std::vector<std::string>{"red", "white", "orange"}));
assert((func0<int>({2, 0, 3, 4, 0, 2, 8, 3, 4, 2}) == std::vector<int>{2, 3, 0, 8, 4}));
assert((func0<int>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1... | O1 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 1d2a <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x8b>
mov %r... | _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz short loc_22E9
mov r12, rsi
mov ebp, 0
jmp short loc_22B9
loc_2298:
mov ... | _QWORD * func0<int>(_QWORD *a1, long long *a2)
{
long long v2; // rdx
unsigned long long v4; // rbp
_DWORD *v5; // rdx
_DWORD *v6; // rsi
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *a2;
if ( a2[1] != *a2 )
{
v4 = 0LL;
do
{
v5 = (_DWORD *)(v2 + 4 * v4);
v6 = (_DWORD *)a1[1];
... | func0<int>:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001022e9
MOV R12,RSI
MOV EBP,0x0
JMP 0x001022b9
LAB_00102298:
MOV RDI,RBX
LAB_0010229b:
CALL 0x00102132
LAB_001022a0:... | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0<int>(vector<int,std::allocator<int>> *param_1,long *param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
ulong uVar4;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*... |
2,870 | func0 |
#include <vector>
#include <assert.h>
#include <string>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
std::vector<T> result;
for (int i = 0; i < list1.size(); i += 2) {
result.push_back(list1[i]);
}
return result;
}
| int main() {
assert((func0<std::string>({"red", "black", "white", "green", "orange"}) == std::vector<std::string>{"red", "white", "orange"}));
assert((func0<int>({2, 0, 3, 4, 0, 2, 8, 3, 4, 2}) == std::vector<int>{2, 3, 0, 8, 4}));
assert((func0<int>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1... | O2 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 1db0 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x90>
mov %r... | _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz short loc_22C8
mov r12, rsi
xor eax, eax
xor esi, esi
xor ebx, ebx
jmp sh... | long long func0<int>(long long a1, long long *a2)
{
long long v2; // rdx
long long v4; // rax
long long v5; // rsi
unsigned long long v6; // rbx
long long v7; // rsi
*(_OWORD *)a1 = 0LL;
v2 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v2 )
{
v4 = 0LL;
v5 = 0LL;
v6 = 0LL;
while ... | func0<int>:
ENDBR64
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001022c8
MOV R12,RSI
XOR EAX,EAX
XOR ESI,ESI
XOR EBX,EBX
JMP 0x001022aa
LAB_00102280:
MOV EAX,dword ptr [RCX]
ADD RSI,0x4
MOV ... | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0<int>(vector<int,std::allocator<int>> *param_1,long *param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
ulong uVar4;
int *piVar5;
*(int (*) [16])param_1 = (int [16])0x0;... |
2,871 | func0 |
#include <vector>
#include <assert.h>
#include <string>
template<typename T>
| std::vector<T> func0(std::vector<T> list1) {
std::vector<T> result;
for (int i = 0; i < list1.size(); i += 2) {
result.push_back(list1[i]);
}
return result;
}
| int main() {
assert((func0<std::string>({"red", "black", "white", "green", "orange"}) == std::vector<std::string>{"red", "white", "orange"}));
assert((func0<int>({2, 0, 3, 4, 0, 2, 8, 3, 4, 2}) == std::vector<int>{2, 3, 0, 8, 4}));
assert((func0<int>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1... | O3 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 22d0 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x80>
mov %rsi... | _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp rdx, [rsi+8]
jz loc_1FE0
mov r13, rsi
xor r8d, r... | char ** func0<int>(char **a1, long long *a2)
{
long long v3; // rdx
char *v5; // r8
long long v6; // rcx
unsigned long long v7; // rbx
_DWORD *v8; // r12
char *v9; // r15
signed long long v10; // r14
unsigned long long v11; // rax
unsigned long long v12; // rdx
char *v13; // r9
char *v15; // rax
... | func0<int>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101fe0
MOV R13,RSI
XOR R8D,R8D
XOR ECX,ECX
XOR EBX,EBX
JMP 0x00101f57
LAB_00101f30:
... | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0<int>(vector<int,std::allocator<int>> *param_1,long *param_2)
{
int4 *puVar1;
ulong uVar2;
void *__dest;
int8 uVar3;
int4 *puVar4;
int4 *puVar5;
long lVar6;
ulong uVar... |
2,872 | func0 |
#include <iostream>
#include <regex>
#include <string>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("ab*?");
if (std::regex_search(text, patterns)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "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*?",0... |
2,873 | func0 |
#include <iostream>
#include <regex>
#include <string>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("ab*?");
if (std::regex_search(text, patterns)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "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... | |
2,874 | func0 |
#include <iostream>
#include <regex>
#include <string>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("ab*?");
if (std::regex_search(text, patterns)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "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,[0x118627]
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... |
2,875 | func0 |
#include <iostream>
#include <regex>
#include <string>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("ab*?");
if (std::regex_search(text, patterns)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Found a match!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "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,[0x11a66c]
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... |
2,876 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <tuple>
#include <assert.h>
| std::tuple<std::vector<int>, std::map<std::string, int>> func0(const std::vector<int>& test_tup, std::map<std::string, int> test_dict) {
std::tuple<std::vector<int>, std::map<std::string, int>> result_tuple;
result_tuple = std::make_tuple(test_tup, test_dict);
return result_tuple;
}
| int main() {
std::vector<int> tuple1{4, 5, 6};
std::map<std::string, int> dict1{{"MSAM", 1}, {"is", 2}, {"best", 3}};
std::vector<int> tuple2{1, 2, 3};
std::map<std::string, int> dict2{{"UTS", 2}, {"is", 3}, {"Worst", 4}};
std::vector<int> tuple3{8, 9, 10};
std::map<std::string, int> d... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char... | _Z5func0RKSt6vectorIiSaIiEESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiSt4lessISA_ESaISt4pairIKSA_iEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor ea... | long long func0(long long a1, long long a2, long long a3)
{
_BYTE v5[72]; // [rsp+20h] [rbp-60h] BYREF
unsigned long long v6; // [rsp+68h] [rbp-18h]
v6 = __readfsqword(0x28u);
std::tuple<std::vector<int>,std::map<std::string,int>>::tuple<true,true>(a1);
std::make_tuple<std::vector<int> const&,std::map<std::... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x001034c4
LEA RAX,[RBP + -0x60]
MOV RDX,qwor... | /* func0(std::vector<int, std::allocator<int> > const&, std::map<std::string, int,
std::less<std::string >, std::allocator<std::pair<std::string const, int> > >) */
vector * func0(vector *param_1,map param_2)
{
int4 in_register_00000034;
long in_FS_OFFSET;
vector local_68 [72];
long local_20;
local_20... |
2,877 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <tuple>
#include <assert.h>
| std::tuple<std::vector<int>, std::map<std::string, int>> func0(const std::vector<int>& test_tup, std::map<std::string, int> test_dict) {
std::tuple<std::vector<int>, std::map<std::string, int>> result_tuple;
result_tuple = std::make_tuple(test_tup, test_dict);
return result_tuple;
}
| int main() {
std::vector<int> tuple1{4, 5, 6};
std::map<std::string, int> dict1{{"MSAM", 1}, {"is", 2}, {"best", 3}};
std::vector<int> tuple2{1, 2, 3};
std::map<std::string, int> dict2{{"UTS", 2}, {"is", 3}, {"Worst", 4}};
std::vector<int> tuple3{8, 9, 10};
std::map<std::string, int> d... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char... | _Z5func0RKSt6vectorIiSaIiEESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiSt4lessISA_ESaISt4pairIKSA_iEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 60h
mov rbx, rdi
mov r13, rsi
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
mov dword ... | long long func0(long long a1, _QWORD *a2, long long a3)
{
long long v5; // r12
long long v6; // rsi
long long v8; // rax
long long v9; // rdx
int *v10; // rcx
long long v11; // rdx
int *v12; // rcx
long long v13; // rax
unsigned long long v14; // r14
struct _Unwind_Exception *v15; // rbp
_DWORD *... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R12,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],R12
MOV qword ptr [RDI + 0x20],R12
MOV qword... | /* func0(std::vector<int, std::allocator<int> > const&, std::map<std::string, int,
std::less<std::string >, std::allocator<std::pair<std::string const, int> > >) */
vector * func0(vector *param_1,map param_2)
{
vector *pvVar1;
int4 *__src;
void *pvVar2;
long lVar3;
_Rb_tree_node_base *p_Var4;
_Rb_tree_... |
2,878 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <tuple>
#include <assert.h>
| std::tuple<std::vector<int>, std::map<std::string, int>> func0(const std::vector<int>& test_tup, std::map<std::string, int> test_dict) {
std::tuple<std::vector<int>, std::map<std::string, int>> result_tuple;
result_tuple = std::make_tuple(test_tup, test_dict);
return result_tuple;
}
| int main() {
std::vector<int> tuple1{4, 5, 6};
std::map<std::string, int> dict1{{"MSAM", 1}, {"is", 2}, {"best", 3}};
std::vector<int> tuple2{1, 2, 3};
std::map<std::string, int> dict2{{"UTS", 2}, {"is", 3}, {"Worst", 4}};
std::vector<int> tuple3{8, 9, 10};
std::map<std::string, int> d... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char... | _Z5func0RKSt6vectorIiSaIiEESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiSt4lessISA_ESaISt4pairIKSA_iEEE:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
lea r12, [rdi+8]
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 50h
mov rax, fs:28h
mov [rsp+78h+var_... | long long func0(long long a1, char *a2, long long a3)
{
long long v3; // r12
char *v4; // rbp
long long v6; // rdi
int *v8; // rax
int *v9; // rdx
int *v10; // rcx
int *v11; // rdx
int *v12; // rcx
long long v13; // rdx
long long v14; // r14
unsigned long long v15; // r14
unsigned long long v16... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
LEA R12,[RDI + 0x8]
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
LEA R13,[RSP + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R12
MOV q... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::vector<int, std::allocator<int> > const&, std::map<std::string, int,
std::less<std::string >, std::allocator<std::pair<std::string const, int> > >) */
vector * func0(vector *param_1,map param_2)
{
vector *pvVar1;
void *pvVar2;
long lVar3;
... |
2,879 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <tuple>
#include <assert.h>
| std::tuple<std::vector<int>, std::map<std::string, int>> func0(const std::vector<int>& test_tup, std::map<std::string, int> test_dict) {
std::tuple<std::vector<int>, std::map<std::string, int>> result_tuple;
result_tuple = std::make_tuple(test_tup, test_dict);
return result_tuple;
}
| int main() {
std::vector<int> tuple1{4, 5, 6};
std::map<std::string, int> dict1{{"MSAM", 1}, {"is", 2}, {"best", 3}};
std::vector<int> tuple2{1, 2, 3};
std::map<std::string, int> dict2{{"UTS", 2}, {"is", 3}, {"Worst", 4}};
std::vector<int> tuple3{8, 9, 10};
std::map<std::string, int> d... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char... | _Z5func0RKSt6vectorIiSaIiEESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiSt4lessISA_ESaISt4pairIKSA_iEEE:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
lea r12, [rdi+8]
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 50h
mov rax, fs:28h
mov [rsp+78h+var_... | long long func0(long long a1, char *a2, long long a3)
{
long long v3; // r12
char *v4; // rbp
long long v6; // rdi
int *v8; // rax
int *v9; // rdx
int *v10; // rcx
int *v11; // rdx
int *v12; // rcx
long long v13; // rdx
long long v14; // r14
unsigned long long v15; // r14
unsigned long long v16... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
LEA R12,[RDI + 0x8]
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
LEA R13,[RSP + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R12
MOV q... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::vector<int, std::allocator<int> > const&, std::map<std::string, int,
std::less<std::string >, std::allocator<std::pair<std::string const, int> > >) */
vector * func0(vector *param_1,map param_2)
{
vector *pvVar1;
void *pvVar2;
long lVar3;
... |
2,880 | func0 | #include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| double func0(vector<vector<int>> cost, int N) {
vector<vector<int>> dp(N, vector<int>(N, 0));
dp[0][0] = cost[0][0];
for (int i = 1; i < N; i++) {
dp[i][0] = dp[i - 1][0] + cost[i][0];
}
for (int j = 1; j < N; j++) {
dp[0][j] = dp[0][j - 1] + cost[0][j];
}
for ... | int main() {
assert(func0({{1, 2, 3}, {6, 5, 4}, {7, 3, 9}}, 3) == 5.2);
assert(func0({{2, 3, 4}, {7, 6, 5}, {8, 4, 10}}, 3) == 6.2);
assert(func0({{3, 4, 5}, {8, 7, 6}, {9, 5, 11}}, 3) == 7.2);
cout << "All assertions passed." << endl;
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x65(%rbp),%... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_88], rdi
mov [rbp+var_8C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_75]
mov [rbp+var_58], rax
nop
nop
lea rax, [rbp+var_76]
mov [rbp+v... | unsigned long long func0(long long a1, int a2)
{
long long v2; // rax
int v3; // ebx
long long v4; // rax
long long v5; // rax
int v6; // ebx
long long v7; // rax
int v8; // ebx
long long v9; // rax
long long v10; // rax
int v11; // ebx
long long v12; // rax
int v13; // ebx
long long v14; // ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x88],RDI
MOV dword ptr [RBP + -0x8c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x75]
MOV qword ptr [RBP + -0x58],RAX
NOP
NOP
LEA RAX,[RBP + -0x76]
MOV qword ptr [RBP + -0x60],RAX
NOP
NOP
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
double func0(vector param_1,int param_2)
{
int4 uVar1;
int iVar2;
int iVar3;
vector<int,std::allocator<int>> *pvVar4;
int4 *puVar5;
int *piVar6;
int *piVar7;
int4 in_regis... |
2,881 | func0 | #include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| double func0(vector<vector<int>> cost, int N) {
vector<vector<int>> dp(N, vector<int>(N, 0));
dp[0][0] = cost[0][0];
for (int i = 1; i < N; i++) {
dp[i][0] = dp[i - 1][0] + cost[i][0];
}
for (int j = 1; j < N; j++) {
dp[0][j] = dp[0][j - 1] + cost[0][j];
}
for ... | int main() {
assert(func0({{1, 2, 3}, {6, 5, 4}, {7, 3, 9}}, 3) == 5.2);
assert(func0({{2, 3, 4}, {7, 6, 5}, {8, 4, 10}}, 3) == 6.2);
assert(func0({{3, 4, 5}, {8, 7, 6}, {9, 5, 11}}, 3) == 7.2);
cout << "All assertions passed." << endl;
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x18(%rsp)
mov %esi,0x14(%rsp)
movslq %esi,%rbp
movabs $0x1fffffffffffffff,%rax
cmp ... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
movsxd r12, esi
mov rax, r12
shr rax, 3Dh
jnz short loc_138D
mov rbx, rdi
mov r13d, esi
test ... | double func0(_DWORD ***a1, int a2)
{
_DWORD *v4; // rax
void *v5; // r14
_DWORD *v6; // rdx
long long v7; // r12
long long v8; // r9
long long v9; // rax
long long v10; // rdi
unsigned long long v11; // rax
int v12; // edx
_QWORD *v13; // rsi
long long v14; // rax
long long v15; // rcx
_DWORD... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOVSXD R12,ESI
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x0010138d
MOV RBX,RDI
MOV R13D,ESI
TEST R12,R12
JZ 0x00101559
LEA R15,[R12*0x4]
MOV qword ptr [RSP + 0x8],R15
MOV RDI,R15
... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
double func0(vector param_1,int param_2)
{
int iVar1;
void *pvVar2;
int4 *puVar3;
int4 *puVar4;
vector *pvVar5;
long lVar6;
long lVar7;
vector *pvVar8;
int *piVar9;
ve... |
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.